Can specify the node path

package.json

@@ -271,7 +271,7 @@
                         "type": "boolean",
                         "default": false,
                         "scope": "application",
-                        "description": "Use Node.js inside the Windows Subsystem for Linux."
+                        "description": "Use the Windows Subsystem for Linux."
                     },
                     "leetcode.endpoint": {
                         "type": "string",
@@ -286,13 +286,19 @@
                     "leetcode.outputFolder": {
                         "type": "string",
                         "scope": "application",
-                        "description": "Specify the relative path to save the problem files."
+                        "description": "The relative path to save the problem files."
                     },
                     "leetcode.enableStatusBar": {
                         "type": "boolean",
                         "default": true,
                         "scope": "application",
-                        "description": "Specify whether the LeetCode status bar will be shown or not."
+                        "description": "Show the LeetCode status bar or not."
+                    },
+                    "leetcode.nodePath": {
+                        "type": "string",
+                        "default": "node",
+                        "scope": "application",
+                        "description": "The Node.js executable path."
                     }
                 }
             }

src/extension.ts

@@ -41,6 +41,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
         leetCodePreviewProvider,
         leetCodeResultProvider,
         leetCodeSolutionProvider,
+        leetCodeExecutor,
         vscode.window.createTreeView("leetCodeExplorer", { treeDataProvider: leetCodeTreeDataProvider, showCollapseAll: true }),
         vscode.languages.registerCodeLensProvider({ scheme: "file" }, codeLensProvider),
         vscode.commands.registerCommand("leetcode.deleteCache", () => cache.deleteCache()),

src/leetCodeExecutor.ts

@@ -5,20 +5,29 @@ import * as cp from "child_process";
 import * as fse from "fs-extra";
 import * as path from "path";
 import * as requireFromString from "require-from-string";
-import * as vscode from "vscode";
+import { ConfigurationChangeEvent, Disposable, MessageItem, window, workspace, WorkspaceConfiguration } from "vscode";
 import { Endpoint, IProblem, supportedPlugins } from "./shared";
 import { executeCommand, executeCommandWithProgress } from "./utils/cpUtils";
 import { genFileName } from "./utils/problemUtils";
 import { DialogOptions, openUrl } from "./utils/uiUtils";
 import * as wsl from "./utils/wslUtils";
+import { toWslPath, useWsl } from "./utils/wslUtils";
 
-class LeetCodeExecutor {
+class LeetCodeExecutor implements Disposable {
     private leetCodeRootPath: string;
     private leetCodeRootPathInWsl: string;
+    private nodeExecutable: string;
+    private configurationChangeListener: Disposable;
 
     constructor() {
         this.leetCodeRootPath = path.join(__dirname, "..", "..", "node_modules", "vsc-leetcode-cli");
         this.leetCodeRootPathInWsl = "";
+        this.nodeExecutable = this.getNodePath();
+        this.configurationChangeListener = workspace.onDidChangeConfiguration((event: ConfigurationChangeEvent) => {
+            if (event.affectsConfiguration("leetcode.nodePath")) {
+                this.nodeExecutable = this.getNodePath();
+            }
+        }, this);
     }
 
     public async getLeetCodeRootPath(): Promise<string> { // not wrapped by ""
@@ -36,10 +45,18 @@ class LeetCodeExecutor {
     }
 
     public async meetRequirements(): Promise<boolean> {
+        if (this.nodeExecutable !== "node") {
+            if (!await fse.pathExists(this.nodeExecutable)) {
+                throw new Error(`The Node.js executable does not exist on path ${this.nodeExecutable}`);
+            }
+            if (useWsl()) {
+                this.nodeExecutable = await toWslPath(this.nodeExecutable);
+            }
+        }
         try {
-            await this.executeCommandEx("node", ["-v"]);
+            await this.executeCommandEx(this.nodeExecutable, ["-v"]);
         } catch (error) {
-            const choice: vscode.MessageItem | undefined = await vscode.window.showErrorMessage(
+            const choice: MessageItem | undefined = await window.showErrorMessage(
                 "LeetCode extension needs Node.js installed in environment path",
                 DialogOptions.open,
             );
@@ -50,28 +67,28 @@ class LeetCodeExecutor {
         }
         for (const plugin of supportedPlugins) {
             try { // Check plugin
-                await this.executeCommandEx("node", [await this.getLeetCodeBinaryPath(), "plugin", "-e", plugin]);
+                await this.executeCommandEx(this.nodeExecutable, [await this.getLeetCodeBinaryPath(), "plugin", "-e", plugin]);
             } catch (error) { // Download plugin and activate
-                await this.executeCommandEx("node", [await this.getLeetCodeBinaryPath(), "plugin", "-i", plugin]);
+                await this.executeCommandEx(this.nodeExecutable, [await this.getLeetCodeBinaryPath(), "plugin", "-i", plugin]);
             }
         }
         return true;
     }
 
     public async deleteCache(): Promise<string> {
-        return await this.executeCommandEx("node", [await this.getLeetCodeBinaryPath(), "cache", "-d"]);
+        return await this.executeCommandEx(this.nodeExecutable, [await this.getLeetCodeBinaryPath(), "cache", "-d"]);
     }
 
     public async getUserInfo(): Promise<string> {
-        return await this.executeCommandEx("node", [await this.getLeetCodeBinaryPath(), "user"]);
+        return await this.executeCommandEx(this.nodeExecutable, [await this.getLeetCodeBinaryPath(), "user"]);
     }
 
     public async signOut(): Promise<string> {
-        return await await this.executeCommandEx("node", [await this.getLeetCodeBinaryPath(), "user", "-L"]);
+        return await await this.executeCommandEx(this.nodeExecutable, [await this.getLeetCodeBinaryPath(), "user", "-L"]);
     }
 
     public async listProblems(showLocked: boolean): Promise<string> {
-        return await this.executeCommandEx("node", showLocked ?
+        return await this.executeCommandEx(this.nodeExecutable, showLocked ?
             [await this.getLeetCodeBinaryPath(), "list"] :
             [await this.getLeetCodeBinaryPath(), "list", "-q", "L"],
         );
@@ -82,37 +99,37 @@ class LeetCodeExecutor {
         const filePath: string = path.join(outDir, fileName);
 
         if (!await fse.pathExists(filePath)) {
-            const codeTemplate: string = await this.executeCommandWithProgressEx("Fetching problem data...", "node", [await this.getLeetCodeBinaryPath(), "show", problemNode.id, "-cx", "-l", language]);
+            const codeTemplate: string = await this.executeCommandWithProgressEx("Fetching problem data...", this.nodeExecutable, [await this.getLeetCodeBinaryPath(), "show", problemNode.id, "-cx", "-l", language]);
             await fse.writeFile(filePath, codeTemplate);
         }
 
         return filePath;
     }
 
     public async showSolution(problemNode: IProblem, language: string): Promise<string> {
-        const solution: string = await this.executeCommandWithProgressEx("Fetching top voted solution from discussions...", "node", [await this.getLeetCodeBinaryPath(), "show", problemNode.id, "--solution", "-l", language]);
+        const solution: string = await this.executeCommandWithProgressEx("Fetching top voted solution from discussions...", this.nodeExecutable, [await this.getLeetCodeBinaryPath(), "show", problemNode.id, "--solution", "-l", language]);
         return solution;
     }
 
     public async getDescription(problemNode: IProblem): Promise<string> {
-        return await this.executeCommandWithProgressEx("Fetching problem description...", "node", [await this.getLeetCodeBinaryPath(), "show", problemNode.id, "-x"]);
+        return await this.executeCommandWithProgressEx("Fetching problem description...", this.nodeExecutable, [await this.getLeetCodeBinaryPath(), "show", problemNode.id, "-x"]);
     }
 
     public async listSessions(): Promise<string> {
-        return await this.executeCommandEx("node", [await this.getLeetCodeBinaryPath(), "session"]);
+        return await this.executeCommandEx(this.nodeExecutable, [await this.getLeetCodeBinaryPath(), "session"]);
     }
 
     public async enableSession(name: string): Promise<string> {
-        return await this.executeCommandEx("node", [await this.getLeetCodeBinaryPath(), "session", "-e", name]);
+        return await this.executeCommandEx(this.nodeExecutable, [await this.getLeetCodeBinaryPath(), "session", "-e", name]);
     }
 
     public async createSession(name: string): Promise<string> {
-        return await this.executeCommandEx("node", [await this.getLeetCodeBinaryPath(), "session", "-c", name]);
+        return await this.executeCommandEx(this.nodeExecutable, [await this.getLeetCodeBinaryPath(), "session", "-c", name]);
     }
 
     public async submitSolution(filePath: string): Promise<string> {
         try {
-            return await this.executeCommandWithProgressEx("Submitting to LeetCode...", "node", [await this.getLeetCodeBinaryPath(), "submit", `"${filePath}"`]);
+            return await this.executeCommandWithProgressEx("Submitting to LeetCode...", this.nodeExecutable, [await this.getLeetCodeBinaryPath(), "submit", `"${filePath}"`]);
         } catch (error) {
             if (error.result) {
                 return error.result;
@@ -123,18 +140,18 @@ class LeetCodeExecutor {
 
     public async testSolution(filePath: string, testString?: string): Promise<string> {
         if (testString) {
-            return await this.executeCommandWithProgressEx("Submitting to LeetCode...", "node", [await this.getLeetCodeBinaryPath(), "test", `"${filePath}"`, "-t", `${testString}`]);
+            return await this.executeCommandWithProgressEx("Submitting to LeetCode...", this.nodeExecutable, [await this.getLeetCodeBinaryPath(), "test", `"${filePath}"`, "-t", `${testString}`]);
         }
-        return await this.executeCommandWithProgressEx("Submitting to LeetCode...", "node", [await this.getLeetCodeBinaryPath(), "test", `"${filePath}"`]);
+        return await this.executeCommandWithProgressEx("Submitting to LeetCode...", this.nodeExecutable, [await this.getLeetCodeBinaryPath(), "test", `"${filePath}"`]);
     }
 
     public async switchEndpoint(endpoint: string): Promise<string> {
         switch (endpoint) {
             case Endpoint.LeetCodeCN:
-                return await this.executeCommandEx("node", [await this.getLeetCodeBinaryPath(), "plugin", "-e", "leetcode.cn"]);
+                return await this.executeCommandEx(this.nodeExecutable, [await this.getLeetCodeBinaryPath(), "plugin", "-e", "leetcode.cn"]);
             case Endpoint.LeetCode:
             default:
-                return await this.executeCommandEx("node", [await this.getLeetCodeBinaryPath(), "plugin", "-d", "leetcode.cn"]);
+                return await this.executeCommandEx(this.nodeExecutable, [await this.getLeetCodeBinaryPath(), "plugin", "-d", "leetcode.cn"]);
         }
     }
 
@@ -149,6 +166,19 @@ class LeetCodeExecutor {
         return { companies: COMPONIES, tags: TAGS };
     }
 
+    public get node(): string {
+        return this.nodeExecutable;
+    }
+
+    public dispose(): void {
+        this.configurationChangeListener.dispose();
+    }
+
+    private getNodePath(): string {
+        const extensionConfig: WorkspaceConfiguration = workspace.getConfiguration("leetcode", null);
+        return extensionConfig.get<string>("nodePath", "node" /* default value */);
+    }
+
     private async executeCommandEx(command: string, args: string[], options: cp.SpawnOptions = { shell: true }): Promise<string> {
         if (wsl.useWsl()) {
             return await executeCommand("wsl", [command].concat(args), options);

src/leetCodeManager.ts

@@ -42,8 +42,8 @@ class LeetCodeManager extends EventEmitter {
                 const leetCodeBinaryPath: string = await leetCodeExecutor.getLeetCodeBinaryPath();
 
                 const childProc: cp.ChildProcess = wsl.useWsl()
-                    ? cp.spawn("wsl", ["node", leetCodeBinaryPath, "user", "-l"], { shell: true })
-                    : cp.spawn("node", [leetCodeBinaryPath, "user", "-l"], {
+                    ? cp.spawn("wsl", [leetCodeExecutor.node, leetCodeBinaryPath, "user", "-l"], { shell: true })
+                    : cp.spawn(leetCodeExecutor.node, [leetCodeBinaryPath, "user", "-l"], {
                         shell: true,
                         env: createEnvOption(),
                     });

src/utils/wslUtils.ts

@@ -3,10 +3,11 @@
 
 import * as vscode from "vscode";
 import { executeCommand } from "./cpUtils";
+import { isWindows } from "./osUtils";
 
 export function useWsl(): boolean {
     const leetCodeConfig: vscode.WorkspaceConfiguration = vscode.workspace.getConfiguration("leetcode");
-    return process.platform === "win32" && leetCodeConfig.get<boolean>("useWsl") === true;
+    return isWindows() && leetCodeConfig.get<boolean>("useWsl") === true;
 }
 
 export async function toWslPath(path: string): Promise<string> {