Add custom Node option to run TS Server

extensions/typescript-language-features/package.json

@@ -21,7 +21,8 @@
       "restrictedConfigurations": [
         "typescript.tsdk",
         "typescript.tsserver.pluginPaths",
-        "typescript.npm"
+        "typescript.npm",
+        "typescript.tsserver.nodePath"
       ]
     }
   },
@@ -1250,6 +1251,11 @@
           "description": "%configuration.tsserver.web.projectWideIntellisense.suppressSemanticErrors%",
           "scope": "window"
         },
+        "typescript.tsserver.nodePath": {
+          "type": "string",
+          "description": "%configuration.tsserver.nodePath%",
+          "scope": "window"
+        },
         "typescript.preferGoToSourceDefinition": {
           "type": "boolean",
           "default": false,

extensions/typescript-language-features/package.nls.json

@@ -212,5 +212,6 @@
 	"configuration.suggest.classMemberSnippets.enabled": "Enable/disable snippet completions for class members.",
 	"configuration.suggest.objectLiteralMethodSnippets.enabled": "Enable/disable snippet completions for methods in object literals. Requires using TypeScript 4.7+ in the workspace.",
 	"configuration.tsserver.web.projectWideIntellisense.enabled": "Enable/disable project-wide IntelliSense on web. Requires that VS Code is running in a trusted context.",
-	"configuration.tsserver.web.projectWideIntellisense.suppressSemanticErrors": "Suppresses semantic errors. This is needed when using external packages as these can't be included analyzed on web."
+	"configuration.tsserver.web.projectWideIntellisense.suppressSemanticErrors": "Suppresses semantic errors. This is needed when using external packages as these can't be included analyzed on web.",
+	"configuration.tsserver.nodePath": "Run TS Server on a custom Node installation."
 }

extensions/typescript-language-features/src/configuration/configuration.browser.ts

@@ -16,4 +16,13 @@ export class BrowserServiceConfigurationProvider extends BaseServiceConfiguratio
 	protected readLocalTsdk(_configuration: vscode.WorkspaceConfiguration): string | null {
 		return null;
 	}
+
+	// On browsers, we don't run TSServer on Node
+	protected readLocalNodePath(_configuration: vscode.WorkspaceConfiguration): string | null {
+		return null;
+	}
+
+	protected override readGlobalNodePath(_configuration: vscode.WorkspaceConfiguration): string | null {
+		return null;
+	}
 }

extensions/typescript-language-features/src/configuration/configuration.electron.ts

@@ -7,6 +7,7 @@ import * as os from 'os';
 import * as path from 'path';
 import * as vscode from 'vscode';
 import { BaseServiceConfigurationProvider } from './configuration';
+import { RelativeWorkspacePathResolver } from '../utils/relativePathResolver';
 
 export class ElectronServiceConfigurationProvider extends BaseServiceConfigurationProvider {
 
@@ -35,4 +36,28 @@ export class ElectronServiceConfigurationProvider extends BaseServiceConfigurati
 		}
 		return null;
 	}
+
+	protected readLocalNodePath(configuration: vscode.WorkspaceConfiguration): string | null {
+		const inspect = configuration.inspect('typescript.tsserver.nodePath');
+		if (inspect && typeof inspect.workspaceValue === 'string') {
+			const fixedPath = this.fixPathPrefixes(inspect.workspaceValue);
+			if (!path.isAbsolute(fixedPath)) {
+				const workspacePath = RelativeWorkspacePathResolver.asAbsoluteWorkspacePath(fixedPath);
+				return workspacePath || null;
+			}
+			return fixedPath;
+		}
+		return null;
+	}
+
+	protected readGlobalNodePath(configuration: vscode.WorkspaceConfiguration): string | null {
+		const inspect = configuration.inspect('typescript.tsserver.nodePath');
+		if (inspect && typeof inspect.globalValue === 'string') {
+			const fixedPath = this.fixPathPrefixes(inspect.globalValue);
+			if (path.isAbsolute(fixedPath)) {
+				return fixedPath;
+			}
+		}
+		return null;
+	}
 }

extensions/typescript-language-features/src/configuration/configuration.ts

@@ -118,6 +118,8 @@ export interface TypeScriptServiceConfiguration {
 	readonly watchOptions: Proto.WatchOptions | undefined;
 	readonly includePackageJsonAutoImports: 'auto' | 'on' | 'off' | undefined;
 	readonly enableTsServerTracing: boolean;
+	readonly localNodePath: string | null;
+	readonly globalNodePath: string | null;
 }
 
 export function areServiceConfigurationsEqual(a: TypeScriptServiceConfiguration, b: TypeScriptServiceConfiguration): boolean {
@@ -150,11 +152,15 @@ export abstract class BaseServiceConfigurationProvider implements ServiceConfigu
 			watchOptions: this.readWatchOptions(configuration),
 			includePackageJsonAutoImports: this.readIncludePackageJsonAutoImports(configuration),
 			enableTsServerTracing: this.readEnableTsServerTracing(configuration),
+			localNodePath: this.readLocalNodePath(configuration),
+			globalNodePath: this.readGlobalNodePath(configuration),
 		};
 	}
 
 	protected abstract readGlobalTsdk(configuration: vscode.WorkspaceConfiguration): string | null;
 	protected abstract readLocalTsdk(configuration: vscode.WorkspaceConfiguration): string | null;
+	protected abstract readLocalNodePath(configuration: vscode.WorkspaceConfiguration): string | null;
+	protected abstract readGlobalNodePath(configuration: vscode.WorkspaceConfiguration): string | null;
 
 	protected readTsServerLogLevel(configuration: vscode.WorkspaceConfiguration): TsServerLogLevel {
 		const setting = configuration.get<string>('typescript.tsserver.log', 'off');

extensions/typescript-language-features/src/tsServer/nodeManager.ts

@@ -0,0 +1,130 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import { TypeScriptServiceConfiguration } from '../configuration/configuration';
+import { setImmediate } from '../utils/async';
+import { Disposable } from '../utils/dispose';
+
+
+const useWorkspaceNodeStorageKey = 'typescript.useWorkspaceNode';
+
+export class NodeVersionManager extends Disposable {
+	private _currentVersion: string | undefined;
+
+	public constructor(
+		private configuration: TypeScriptServiceConfiguration,
+		private readonly workspaceState: vscode.Memento
+	) {
+		super();
+
+		this._currentVersion = this.configuration.globalNodePath || undefined;
+		if (vscode.workspace.isTrusted) {
+			if (this.configuration.localNodePath) {
+				if (this.useWorkspaceNodeSetting === undefined) {
+					setImmediate(() => {
+						this.promptAndSetWorkspaceNode();
+					});
+				}
+				else if (this.useWorkspaceNodeSetting) {
+					this._currentVersion = this.configuration.localNodePath;
+				}
+			}
+		}
+		else {
+			this._disposables.push(vscode.workspace.onDidGrantWorkspaceTrust(() => {
+				if (this.configuration.localNodePath) {
+					if (this.useWorkspaceNodeSetting === undefined) {
+						setImmediate(() => {
+							this.promptAndSetWorkspaceNode();
+						});
+					}
+					else if (this.useWorkspaceNodeSetting) {
+						this.updateActiveVersion(this.configuration.localNodePath);
+					}
+				}
+			}));
+		}
+	}
+
+	private readonly _onDidPickNewVersion = this._register(new vscode.EventEmitter<void>());
+	public readonly onDidPickNewVersion = this._onDidPickNewVersion.event;
+
+	public get currentVersion(): string | undefined {
+		return this._currentVersion;
+	}
+
+	public reset(): void {
+		this._currentVersion = undefined;
+	}
+
+	public async updateConfiguration(nextConfiguration: TypeScriptServiceConfiguration) {
+		const oldConfiguration = this.configuration;
+		this.configuration = nextConfiguration;
+		if (oldConfiguration.globalNodePath !== nextConfiguration.globalNodePath
+			|| oldConfiguration.localNodePath !== nextConfiguration.localNodePath) {
+			await this.computeNewVersion();
+		}
+	}
+
+	private async computeNewVersion() {
+		let version = this.configuration.globalNodePath || undefined;
+		if (vscode.workspace.isTrusted && this.configuration.localNodePath) {
+			if (this.useWorkspaceNodeSetting === undefined) {
+				version = await this.promptUseWorkspaceNode();
+			}
+			else if (this.useWorkspaceNodeSetting) {
+				version = this.configuration.localNodePath;
+			}
+		}
+		this.updateActiveVersion(version);
+	}
+
+	private async promptUseWorkspaceNode(): Promise<string | undefined> {
+		const workspaceVersion = this.configuration.localNodePath;
+
+		if (workspaceVersion === null) {
+			throw new Error('Could not prompt to use workspace Node installation because no workspace Node installation is specified');
+		}
+
+		const allow = vscode.l10n.t("Allow");
+		const dismiss = vscode.l10n.t("Dismiss");
+		const neverAllow = vscode.l10n.t("Never in this workspace");
+
+		const result = await vscode.window.showInformationMessage(vscode.l10n.t("This workspace specifies a custom Node installation to run TS Server. Would you like to use this workspace's custom Node installation to run TS Server?"),
+			allow,
+			dismiss,
+			neverAllow
+		);
+
+		let version = undefined;
+		if (result === allow) {
+			await this.workspaceState.update(useWorkspaceNodeStorageKey, true);
+			version = workspaceVersion;
+		} else if (result === neverAllow) {
+			await this.workspaceState.update(useWorkspaceNodeStorageKey, false);
+		}
+		return version;
+	}
+
+	private async promptAndSetWorkspaceNode(): Promise<void> {
+		const version = await this.promptUseWorkspaceNode();
+		if (version !== undefined) {
+			this.updateActiveVersion(version);
+		}
+	}
+
+	private updateActiveVersion(pickedVersion: string | undefined): void {
+		const oldVersion = this.currentVersion;
+		this._currentVersion = pickedVersion;
+		if (oldVersion !== pickedVersion) {
+			this._onDidPickNewVersion.fire();
+		}
+	}
+
+	private get useWorkspaceNodeSetting(): boolean | undefined {
+		return this.workspaceState.get<boolean>(useWorkspaceNodeStorageKey);
+	}
+}

extensions/typescript-language-features/src/tsServer/server.ts

@@ -19,6 +19,7 @@ import type * as Proto from './protocol/protocol';
 import { EventName } from './protocol/protocol.const';
 import { TypeScriptVersionManager } from './versionManager';
 import { TypeScriptVersion } from './versionProvider';
+import { NodeVersionManager } from './nodeManager';
 
 export enum ExecutionTarget {
 	Semantic,
@@ -70,6 +71,7 @@ export interface TsServerProcessFactory {
 		kind: TsServerProcessKind,
 		configuration: TypeScriptServiceConfiguration,
 		versionManager: TypeScriptVersionManager,
+		nodeVersionManager: NodeVersionManager,
 		tsServerLog: TsServerLog | undefined,
 	): TsServerProcess;
 }

extensions/typescript-language-features/src/tsServer/serverProcess.browser.ts

@@ -13,6 +13,7 @@ import type * as Proto from './protocol/protocol';
 import { TsServerLog, TsServerProcess, TsServerProcessFactory, TsServerProcessKind } from './server';
 import { TypeScriptVersionManager } from './versionManager';
 import { TypeScriptVersion } from './versionProvider';
+import { NodeVersionManager } from './nodeManager';
 
 type BrowserWatchEvent = {
 	type: 'watchDirectory' | 'watchFile';
@@ -40,6 +41,7 @@ export class WorkerServerProcessFactory implements TsServerProcessFactory {
 		kind: TsServerProcessKind,
 		_configuration: TypeScriptServiceConfiguration,
 		_versionManager: TypeScriptVersionManager,
+		_nodeVersionManager: NodeVersionManager,
 		tsServerLog: TsServerLog | undefined,
 	) {
 		const tsServerPath = version.tsServerPath;

extensions/typescript-language-features/src/tsServer/serverProcess.electron.ts

@@ -15,6 +15,7 @@ import type * as Proto from './protocol/protocol';
 import { TsServerLog, TsServerProcess, TsServerProcessFactory, TsServerProcessKind } from './server';
 import { TypeScriptVersionManager } from './versionManager';
 import { TypeScriptVersion } from './versionProvider';
+import { NodeVersionManager } from './nodeManager';
 
 
 const defaultSize: number = 8192;
@@ -134,10 +135,12 @@ class Reader<T> extends Disposable {
 	}
 }
 
-function generatePatchedEnv(env: any, modulePath: string): any {
+function generatePatchedEnv(env: any, modulePath: string, hasExecPath: boolean): any {
 	const newEnv = Object.assign({}, env);
 
-	newEnv['ELECTRON_RUN_AS_NODE'] = '1';
+	if (!hasExecPath) {
+		newEnv['ELECTRON_RUN_AS_NODE'] = '1';
+	}
 	newEnv['NODE_PATH'] = path.join(modulePath, '..', '..', '..');
 
 	// Ensure we always have a PATH set
@@ -253,6 +256,7 @@ export class ElectronServiceProcessFactory implements TsServerProcessFactory {
 		kind: TsServerProcessKind,
 		configuration: TypeScriptServiceConfiguration,
 		versionManager: TypeScriptVersionManager,
+		nodeVersionManager: NodeVersionManager,
 		_tsserverLog: TsServerLog | undefined,
 	): TsServerProcess {
 		let tsServerPath = version.tsServerPath;
@@ -263,7 +267,13 @@ export class ElectronServiceProcessFactory implements TsServerProcessFactory {
 			tsServerPath = versionManager.currentVersion.tsServerPath;
 		}
 
-		const useIpc = version.apiVersion?.gte(API.v460);
+		let execPath = nodeVersionManager.currentVersion;
+		if (execPath && !fs.existsSync(execPath)) {
+			vscode.window.showWarningMessage(vscode.l10n.t("The path {0} doesn\'t point to a valid Node installation. Falling back to bundled Node.", execPath!));
+			nodeVersionManager.reset();
+			execPath = nodeVersionManager.currentVersion;
+		}
+		const useIpc = !execPath && version.apiVersion?.gte(API.v460);
 
 		const runtimeArgs = [...args];
 		if (useIpc) {
@@ -273,8 +283,9 @@ export class ElectronServiceProcessFactory implements TsServerProcessFactory {
 		const childProcess = child_process.fork(tsServerPath, runtimeArgs, {
 			silent: true,
 			cwd: undefined,
-			env: generatePatchedEnv(process.env, tsServerPath),
+			env: generatePatchedEnv(process.env, tsServerPath, !!execPath),
 			execArgv: getExecArgv(kind, configuration),
+			execPath,
 			stdio: useIpc ? ['pipe', 'pipe', 'pipe', 'ipc'] : undefined,
 		});
 

extensions/typescript-language-features/src/tsServer/spawner.ts

@@ -19,6 +19,7 @@ import { PluginManager } from './plugins';
 import { GetErrRoutingTsServer, ITypeScriptServer, SingleTsServer, SyntaxRoutingTsServer, TsServerDelegate, TsServerLog, TsServerProcessFactory, TsServerProcessKind } from './server';
 import { TypeScriptVersionManager } from './versionManager';
 import { ITypeScriptVersionProvider, TypeScriptVersion } from './versionProvider';
+import { NodeVersionManager } from './nodeManager';
 
 const enum CompositeServerType {
 	/** Run a single server that handles all commands  */
@@ -44,6 +45,7 @@ export class TypeScriptServerSpawner {
 	public constructor(
 		private readonly _versionProvider: ITypeScriptVersionProvider,
 		private readonly _versionManager: TypeScriptVersionManager,
+		private readonly _nodeVersionManager: NodeVersionManager,
 		private readonly _logDirectoryProvider: ILogDirectoryProvider,
 		private readonly _pluginPathsProvider: TypeScriptPluginPathsProvider,
 		private readonly _logger: Logger,
@@ -160,7 +162,7 @@ export class TypeScriptServerSpawner {
 		}
 
 		this._logger.info(`<${kind}> Forking...`);
-		const process = this._factory.fork(version, args, kind, configuration, this._versionManager, tsServerLog);
+		const process = this._factory.fork(version, args, kind, configuration, this._versionManager, this._nodeVersionManager, tsServerLog);
 		this._logger.info(`<${kind}> Starting...`);
 
 		return new SingleTsServer(