feat: do installation/version checks on startup

Author: pd93

package.json

@@ -251,5 +251,10 @@
     "glob": "^8.1.0",
     "mocha": "^10.2.0",
     "typescript": "^4.9.5"
+  },
+  "dependencies": {
+    "@octokit/types": "^9.0.0",
+    "octokit": "^2.0.14",
+    "semver": "^7.3.8"
   }
 }

src/services/taskfile.ts

@@ -3,11 +3,21 @@ import * as vscode from 'vscode';
 import * as models from '../models';
 import * as path from 'path';
 import * as fs from 'fs';
+import * as semver from 'semver';
+import { Octokit } from 'octokit';
+import { Endpoints } from "@octokit/types";
+
+const octokit = new Octokit();
+type ReleaseRequest = Endpoints["GET /repos/{owner}/{repo}/releases/latest"]["parameters"];
+type ReleaseResponse = Endpoints["GET /repos/{owner}/{repo}/releases/latest"]["response"];
+
+const taskCommand = 'task';
+const minimumRequiredVersion = '3.19.1';
+const minimumRecommendedVersion = '3.23.0';
 
 class TaskfileService {
     private static _instance: TaskfileService;
     private static outputChannel: vscode.OutputChannel;
-    private static readonly taskCommand = 'task';
     private lastTaskName: string | undefined;
     private lastTaskDir: string | undefined;
 
@@ -19,9 +29,87 @@ class TaskfileService {
         return this._instance ?? (this._instance = new this());
     }
 
+    public async checkInstallation(): Promise<void> {
+        return await new Promise((resolve) => {
+            cp.exec(`${taskCommand} --version`, (_, stdout: string, stderr: string) => {
+
+                // If the version is a devel version, ignore all version checks
+                if (stdout.includes("devel")) {
+                    return resolve();
+                }
+
+                // Get the installed version of task (if any)
+                let version = this.parseVersion(stdout);
+
+                // If there is an error fetching the version, assume task is not installed
+                if (stderr !== "" || version === undefined) {
+                    vscode.window.showErrorMessage("Task command not found.", "Install").then(this.buttonCallback);
+                    return resolve();
+                }
+
+                // If the current version is older than the minimum required version, show an error
+                if (version && version.compare(minimumRequiredVersion) < 0) {
+                    vscode.window.showErrorMessage(`Task v${minimumRequiredVersion} is required to run this extension. Your current version is v${version}.`, "Update").then(this.buttonCallback);
+                    return resolve();
+                }
+
+                // If the current version is older than the minimum recommended version, show a warning
+                if (version && version.compare(minimumRecommendedVersion) < 0) {
+                    vscode.window.showWarningMessage(`Task v${minimumRecommendedVersion} is recommended to run this extension. Your current version is v${version} which doesn't support some features.`, "Update").then(this.buttonCallback);
+                    return resolve();
+                }
+
+                // If a newer version is available, show a message
+                // TODO: what happens if the user is offline?
+                this.getLatestVersion().then((latestVersion) => {
+                    if (version && latestVersion && version.compare(latestVersion) < 0) {
+                        vscode.window.showInformationMessage(`A new version of Task is available. Current version: v${version}, Latest version: v${latestVersion}`, "Update").then(this.buttonCallback);
+                    }
+                    return resolve();
+                }).catch((err) => {
+                    console.error(err);
+                    return resolve();
+                });
+            });
+        });
+    }
+
+    buttonCallback(value: string | undefined) {
+        if (value === undefined) {
+            return;
+        }
+        if (["Update", "Install"].includes(value)) {
+            vscode.env.openExternal(vscode.Uri.parse("https://taskfile.dev/installation"));
+            return;
+        }
+    }
+
+    async getLatestVersion(): Promise<semver.SemVer | null> {
+        let request: ReleaseRequest = {
+            owner: 'go-task',
+            repo: 'task'
+        };
+        let response: ReleaseResponse = await octokit.rest.repos.getLatestRelease(request);
+        return Promise.resolve(semver.parse(response.data.tag_name));
+    }
+
+    parseVersion(stdout: string): semver.SemVer | undefined {
+        // Extract the version string from the output
+        let matches = stdout.match(/v(\d+\.\d+\.\d+)/);
+        if (!matches || matches.length !== 2) {
+            return undefined;
+        }
+        // Parse the version string as a semver
+        let version = semver.parse(matches[1]);
+        if (!version) {
+            return undefined;
+        }
+        return version;
+    }
+
     public async init(dir: string): Promise<void> {
         return await new Promise((resolve) => {
-            let command = 'task --init';
+            let command = `${taskCommand} --init`;
             cp.exec(command, { cwd: dir }, (_, stdout: string, stderr: string) => {
                 if (stderr) {
                     vscode.window.showErrorMessage(stderr);
@@ -38,7 +126,6 @@ class TaskfileService {
         for (let i = 0; i < filenames.length; i++) {
             let filename = path.join(dir, filenames[i]);
             if (fs.existsSync(filename)) {
-                console.log(filename);
                 await vscode.commands.executeCommand('vscode.open', vscode.Uri.parse(filename), { preview: false });
                 return;
             }
@@ -47,7 +134,7 @@ class TaskfileService {
 
     public async read(dir: string): Promise<models.Taskfile> {
         return await new Promise((resolve) => {
-            let command = 'task --list-all --json';
+            let command = `${taskCommand} --list-all --json`;
             cp.exec(command, { cwd: dir }, (_, stdout: string) => {
                 var taskfile: models.Taskfile = JSON.parse(stdout);
                 taskfile.workspace = dir;
@@ -67,7 +154,7 @@ class TaskfileService {
     public async runTask(taskName: string, dir?: string): Promise<void> {
         return await new Promise((resolve) => {
             // Spawn a child process
-            let child = cp.spawn(TaskfileService.taskCommand, [taskName], { cwd: dir });
+            let child = cp.spawn(taskCommand, [taskName], { cwd: dir });
 
             // Clear the output channel and show it
             TaskfileService.outputChannel.clear();
@@ -97,7 +184,7 @@ class TaskfileService {
 
     public async goToDefinition(task: models.Task, preview: boolean = false): Promise<void> {
         if (task.location === undefined) {
-            vscode.window.showErrorMessage(`Go to definition requires Task v3.23.0 or higher.`);
+            vscode.window.showErrorMessage(`Go to definition requires Task v3.23.0 or higher.`, "Update").then(this.buttonCallback);
             return;
         }
 

src/task.ts

@@ -14,6 +14,7 @@ export class TaskExtension {
         this._settings = new Settings();
         this._activityBar = new elements.ActivityBar();
         this._watcher = vscode.workspace.createFileSystemWatcher("**/*.{yml,yaml}");
+        services.taskfile.checkInstallation();
         this.setTreeNesting(this._settings.treeNesting);
     }
 

tsconfig.json

@@ -4,7 +4,8 @@
 		"target": "ES2020",
 		"outDir": "out",
 		"lib": [
-			"ES2020"
+			"ES2020",
+			"dom"
 		],
 		"sourceMap": true,
 		"rootDir": "src",