chore(vscode): update to 1.55.2

2026-05-14 08:17:27 +02:00 · 2021-04-09 11:32:27 +05:30
parent e07ae004b7 801aed9320
commit 8fb96b9967
1102 changed files with 39988 additions and 23544 deletions
--- a/lib/vscode/src/vs/workbench/api/node/extHostCLIServer.ts
+++ b/lib/vscode/src/vs/workbench/api/node/extHostCLIServer.ts
@@ -173,7 +173,6 @@ export class CLIServerBase {
 	}

 	private async manageExtensions(data: ExtensionManagementPipeArgs, res: http.ServerResponse) {
-		console.log('server: manageExtensions');
 		try {
 			const toExtOrVSIX = (inputs: string[] | undefined) => inputs?.map(input => /\.vsix$/i.test(input) ? URI.parse(input) : input);
 			const commandArgs = {
@@ -182,12 +181,16 @@ export class CLIServerBase {
 				uninstall: toExtOrVSIX(data.uninstall),
 				force: data.force
 			};
-			const output = await this._commands.executeCommand('_remoteCLI.manageExtensions', commandArgs, { allowTunneling: true });
+			const output = await this._commands.executeCommand('_remoteCLI.manageExtensions', commandArgs);
 			res.writeHead(200);
 			res.write(output);
-		} catch (e) {
+		} catch (err) {
 			res.writeHead(500);
-			res.write(String(e));
+			res.write(String(err), err => {
+				if (err) {
+					this.logService.error(err);
+				}
+			});
 		}
 		res.end();
 	}
--- a/lib/vscode/src/vs/workbench/api/node/extHostDebugService.ts
+++ b/lib/vscode/src/vs/workbench/api/node/extHostDebugService.ts
@@ -5,7 +5,7 @@

 import * as nls from 'vs/nls';
 import type * as vscode from 'vscode';
-import * as env from 'vs/base/common/platform';
+import * as platform from 'vs/base/common/platform';
 import { DebugAdapterExecutable } from 'vs/workbench/api/common/extHostTypes';
 import { ExecutableDebugAdapter, SocketDebugAdapter, NamedPipeDebugAdapter } from 'vs/workbench/contrib/debug/node/debugAdapter';
 import { AbstractDebugAdapter } from 'vs/workbench/contrib/debug/common/abstractDebugAdapter';
@@ -110,10 +110,23 @@ export class ExtHostDebugService extends ExtHostDebugServiceBase {
 			if (giveShellTimeToInitialize) {
 				// give a new terminal some time to initialize the shell
 				await new Promise(resolve => setTimeout(resolve, 1000));
+			} else {
+				if (configProvider.getConfiguration('debug.terminal').get<boolean>('clearBeforeReusing')) {
+					// clear terminal before reusing it
+					if (shell.indexOf('powershell') >= 0 || shell.indexOf('pwsh') >= 0 || shell.indexOf('cmd.exe') >= 0) {
+						terminal.sendText('cls');
+					} else if (shell.indexOf('bash') >= 0) {
+						terminal.sendText('clear');
+					} else if (platform.isWindows) {
+						terminal.sendText('cls');
+					} else {
+						terminal.sendText('clear');
+					}
+				}
 			}

 			const command = prepareCommand(shell, args.args, cwdForPrepareCommand, args.env);
-			terminal.sendText(command, true);
+			terminal.sendText(command);

 			// Mark terminal as unused when its session ends, see #112055
 			const sessionListener = this.onDidTerminateDebugSession(s => {
@@ -133,7 +146,7 @@ export class ExtHostDebugService extends ExtHostDebugServiceBase {
 	}

 	protected createVariableResolver(folders: vscode.WorkspaceFolder[], editorService: ExtHostDocumentsAndEditors, configurationService: ExtHostConfigProvider): AbstractVariableResolverService {
-		return new ExtHostVariableResolverService(folders, editorService, configurationService, process.env as env.IProcessEnvironment, this._workspaceService);
+		return new ExtHostVariableResolverService(folders, editorService, configurationService, this._workspaceService);
 	}
 }

--- a/lib/vscode/src/vs/workbench/api/node/extHostExtensionService.ts
+++ b/lib/vscode/src/vs/workbench/api/node/extHostExtensionService.ts
@@ -16,6 +16,7 @@ import { Schemas } from 'vs/base/common/network';
 import { ExtensionIdentifier, IExtensionDescription } from 'vs/platform/extensions/common/extensions';
 import { ExtensionRuntime } from 'vs/workbench/api/common/extHostTypes';
 import { CLIServer } from 'vs/workbench/api/node/extHostCLIServer';
+import { realpathSync } from 'vs/base/node/extpath';

 class NodeModuleRequireInterceptor extends RequireInterceptor {

@@ -36,7 +37,7 @@ class NodeModuleRequireInterceptor extends RequireInterceptor {
 			}
 			return that._factories.get(request)!.load(
 				request,
-				URI.file(parent.filename),
+				URI.file(realpathSync(parent.filename)),
 				request => original.apply(this, [request, parent, isMain])
 			);
 		};
--- a/lib/vscode/src/vs/workbench/api/node/extHostSearch.ts
+++ b/lib/vscode/src/vs/workbench/api/node/extHostSearch.ts
@@ -35,13 +35,15 @@ export class NativeExtHostSearch extends ExtHostSearch {
 	) {
 		super(extHostRpc, _uriTransformer, _logService);

+		const outputChannel = new OutputChannel('RipgrepSearchUD', this._logService);
+		this.registerTextSearchProvider(Schemas.userData, new RipgrepSearchProvider(outputChannel));
 		if (initData.remote.isRemote && initData.remote.authority) {
 			this._registerEHSearchProviders();
 		}
 	}

 	private _registerEHSearchProviders(): void {
-		const outputChannel = new OutputChannel(this._logService);
+		const outputChannel = new OutputChannel('RipgrepSearchEH', this._logService);
 		this.registerTextSearchProvider(Schemas.file, new RipgrepSearchProvider(outputChannel));
 		this.registerInternalFileSearchProvider(Schemas.file, new SearchService());
 	}
@@ -101,4 +103,3 @@ export class NativeExtHostSearch extends ExtHostSearch {
 		return new NativeTextSearchManager(query, provider);
 	}
 }
-
--- a/lib/vscode/src/vs/workbench/api/node/extHostTask.ts
+++ b/lib/vscode/src/vs/workbench/api/node/extHostTask.ts
@@ -22,7 +22,6 @@ import { IExtHostInitDataService } from 'vs/workbench/api/common/extHostInitData
 import { ExtHostTaskBase, TaskHandleDTO, TaskDTO, CustomExecutionDTO, HandlerData } from 'vs/workbench/api/common/extHostTask';
 import { Schemas } from 'vs/base/common/network';
 import { ILogService } from 'vs/platform/log/common/log';
-import { IProcessEnvironment } from 'vs/base/common/platform';
 import { IExtHostApiDeprecationService } from 'vs/workbench/api/common/extHostApiDeprecationService';

 export class ExtHostTask extends ExtHostTaskBase {
@@ -122,7 +121,7 @@ export class ExtHostTask extends ExtHostTaskBase {
 	private async getVariableResolver(workspaceFolders: vscode.WorkspaceFolder[]): Promise<ExtHostVariableResolverService> {
 		if (this._variableResolver === undefined) {
 			const configProvider = await this._configurationService.getConfigProvider();
-			this._variableResolver = new ExtHostVariableResolverService(workspaceFolders, this._editorService, configProvider, process.env as IProcessEnvironment, this.workspaceService);
+			this._variableResolver = new ExtHostVariableResolverService(workspaceFolders, this._editorService, configProvider, this.workspaceService);
 		}
 		return this._variableResolver;
 	}
--- a/lib/vscode/src/vs/workbench/api/node/extHostTerminalService.ts
+++ b/lib/vscode/src/vs/workbench/api/node/extHostTerminalService.ts
@@ -3,33 +3,28 @@
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

-import type * as vscode from 'vscode';
-import * as os from 'os';
-import { URI, UriComponents } from 'vs/base/common/uri';
 import * as platform from 'vs/base/common/platform';
-import * as terminalEnvironment from 'vs/workbench/contrib/terminal/common/terminalEnvironment';
-import { IShellLaunchConfigDto, IShellDefinitionDto, IShellAndArgsDto } from 'vs/workbench/api/common/extHost.protocol';
-import { ExtHostConfiguration, ExtHostConfigProvider, IExtHostConfiguration } from 'vs/workbench/api/common/extHostConfiguration';
+import { withNullAsUndefined } from 'vs/base/common/types';
+import { generateUuid } from 'vs/base/common/uuid';
+import { getSystemShell, getSystemShellSync } from 'vs/base/node/shell';
 import { ILogService } from 'vs/platform/log/common/log';
-import { TerminalProcess } from 'vs/platform/terminal/node/terminalProcess';
-import { ExtHostWorkspace, IExtHostWorkspace } from 'vs/workbench/api/common/extHostWorkspace';
 import { IWorkspaceFolder } from 'vs/platform/workspace/common/workspace';
+import { IShellAndArgsDto } from 'vs/workbench/api/common/extHost.protocol';
+import { ExtHostConfigProvider, ExtHostConfiguration, IExtHostConfiguration } from 'vs/workbench/api/common/extHostConfiguration';
 import { ExtHostVariableResolverService } from 'vs/workbench/api/common/extHostDebugService';
 import { ExtHostDocumentsAndEditors, IExtHostDocumentsAndEditors } from 'vs/workbench/api/common/extHostDocumentsAndEditors';
-import { detectAvailableShells } from 'vs/workbench/contrib/terminal/node/terminal';
-import { getMainProcessParentEnv } from 'vs/workbench/contrib/terminal/node/terminalEnvironment';
-import { BaseExtHostTerminalService, ExtHostTerminal } from 'vs/workbench/api/common/extHostTerminalService';
 import { IExtHostRpcService } from 'vs/workbench/api/common/extHostRpcService';
-import { MergedEnvironmentVariableCollection } from 'vs/workbench/contrib/terminal/common/environmentVariableCollection';
-import { IExtHostInitDataService } from 'vs/workbench/api/common/extHostInitDataService';
-import { withNullAsUndefined } from 'vs/base/common/types';
-import { getSystemShell, getSystemShellSync } from 'vs/base/node/shell';
-import { generateUuid } from 'vs/base/common/uuid';
-import { IShellLaunchConfig, ITerminalEnvironment, ITerminalLaunchError } from 'vs/platform/terminal/common/terminal';
+import { BaseExtHostTerminalService, ExtHostTerminal } from 'vs/workbench/api/common/extHostTerminalService';
+import { ExtHostWorkspace, IExtHostWorkspace } from 'vs/workbench/api/common/extHostWorkspace';
+import { ITerminalConfiguration, ITerminalProfile } from 'vs/workbench/contrib/terminal/common/terminal';
+import * as terminalEnvironment from 'vs/workbench/contrib/terminal/common/terminalEnvironment';
+import { detectAvailableProfiles } from 'vs/workbench/contrib/terminal/node/terminalProfiles';
+import type * as vscode from 'vscode';

 export class ExtHostTerminalService extends BaseExtHostTerminalService {

 	private _variableResolver: ExtHostVariableResolverService | undefined;
+	private _variableResolverPromise: Promise<ExtHostVariableResolverService>;
 	private _lastActiveWorkspace: IWorkspaceFolder | undefined;

 	// TODO: Pull this from main side
@@ -41,18 +36,17 @@ export class ExtHostTerminalService extends BaseExtHostTerminalService {
 		@IExtHostConfiguration private _extHostConfiguration: ExtHostConfiguration,
 		@IExtHostWorkspace private _extHostWorkspace: ExtHostWorkspace,
 		@IExtHostDocumentsAndEditors private _extHostDocumentsAndEditors: ExtHostDocumentsAndEditors,
-		@ILogService private _logService: ILogService,
-		@IExtHostInitDataService private _extHostInitDataService: IExtHostInitDataService
+		@ILogService private _logService: ILogService
 	) {
 		super(true, extHostRpc);

 		// Getting the SystemShell is an async operation, however, the ExtHost terminal service is mostly synchronous
 		// and the API `vscode.env.shell` is also synchronous. The default shell _should_ be set when extensions are
 		// starting up but if not, we run getSystemShellSync below which gets a sane default.
-		getSystemShell(platform.platform).then(s => this._defaultShell = s);
+		getSystemShell(platform.platform, process.env as platform.IProcessEnvironment).then(s => this._defaultShell = s);

 		this._updateLastActiveWorkspace();
-		this._updateVariableResolver();
+		this._variableResolverPromise = this._updateVariableResolver();
 		this._registerListeners();
 	}

@@ -91,7 +85,7 @@ export class ExtHostTerminalService extends BaseExtHostTerminalService {
 		return terminalEnvironment.getDefaultShell(
 			fetchSetting,
 			this._isWorkspaceShellAllowed,
-			this._defaultShell ?? getSystemShellSync(platform.platform),
+			this._defaultShell ?? getSystemShellSync(platform.platform, process.env as platform.IProcessEnvironment),
 			process.env.hasOwnProperty('PROCESSOR_ARCHITEW6432'),
 			process.env.windir,
 			terminalEnvironment.createVariableResolver(this._lastActiveWorkspace, this._variableResolver),
@@ -121,15 +115,11 @@ export class ExtHostTerminalService extends BaseExtHostTerminalService {
 		};
 	}

-	private async _getNonInheritedEnv(): Promise<platform.IProcessEnvironment> {
-		const env = await getMainProcessParentEnv();
-		env.VSCODE_IPC_HOOK_CLI = process.env['VSCODE_IPC_HOOK_CLI']!;
-		return env;
-	}
-
 	private _registerListeners(): void {
 		this._extHostDocumentsAndEditors.onDidChangeActiveTextEditor(() => this._updateLastActiveWorkspace());
-		this._extHostWorkspace.onDidChangeWorkspace(() => this._updateVariableResolver());
+		this._extHostWorkspace.onDidChangeWorkspace(() => {
+			this._variableResolverPromise = this._updateVariableResolver();
+		});
 	}

 	private _updateLastActiveWorkspace(): void {
@@ -139,106 +129,16 @@ export class ExtHostTerminalService extends BaseExtHostTerminalService {
 		}
 	}

-	private async _updateVariableResolver(): Promise<void> {
+	private async _updateVariableResolver(): Promise<ExtHostVariableResolverService> {
 		const configProvider = await this._extHostConfiguration.getConfigProvider();
 		const workspaceFolders = await this._extHostWorkspace.getWorkspaceFolders2();
-		this._variableResolver = new ExtHostVariableResolverService(workspaceFolders || [], this._extHostDocumentsAndEditors, configProvider, process.env as platform.IProcessEnvironment);
+		this._variableResolver = new ExtHostVariableResolverService(workspaceFolders || [], this._extHostDocumentsAndEditors, configProvider);
+		return this._variableResolver;
 	}

-	public async $spawnExtHostProcess(id: number, shellLaunchConfigDto: IShellLaunchConfigDto, activeWorkspaceRootUriComponents: UriComponents | undefined, cols: number, rows: number, isWorkspaceShellAllowed: boolean): Promise<ITerminalLaunchError | undefined> {
-		const shellLaunchConfig: IShellLaunchConfig = {
-			name: shellLaunchConfigDto.name,
-			executable: shellLaunchConfigDto.executable,
-			args: shellLaunchConfigDto.args,
-			cwd: typeof shellLaunchConfigDto.cwd === 'string' ? shellLaunchConfigDto.cwd : URI.revive(shellLaunchConfigDto.cwd),
-			env: shellLaunchConfigDto.env,
-			flowControl: shellLaunchConfigDto.flowControl
-		};
-
-		// Merge in shell and args from settings
-		const platformKey = platform.isWindows ? 'windows' : (platform.isMacintosh ? 'osx' : 'linux');
-		const configProvider = await this._extHostConfiguration.getConfigProvider();
-		if (!shellLaunchConfig.executable) {
-			shellLaunchConfig.executable = this.getDefaultShell(false, configProvider);
-			shellLaunchConfig.args = this.getDefaultShellArgs(false, configProvider);
-		} else {
-			if (this._variableResolver) {
-				shellLaunchConfig.executable = this._variableResolver.resolve(this._lastActiveWorkspace, shellLaunchConfig.executable);
-				if (shellLaunchConfig.args) {
-					if (Array.isArray(shellLaunchConfig.args)) {
-						const resolvedArgs: string[] = [];
-						for (const arg of shellLaunchConfig.args) {
-							resolvedArgs.push(this._variableResolver.resolve(this._lastActiveWorkspace, arg));
-						}
-						shellLaunchConfig.args = resolvedArgs;
-					} else {
-						shellLaunchConfig.args = this._variableResolver.resolve(this._lastActiveWorkspace, shellLaunchConfig.args);
-					}
-				}
-			}
-		}
-
-		const activeWorkspaceRootUri = URI.revive(activeWorkspaceRootUriComponents);
-		let lastActiveWorkspace: IWorkspaceFolder | undefined;
-		if (activeWorkspaceRootUriComponents && activeWorkspaceRootUri) {
-			// Get the environment
-			const apiLastActiveWorkspace = await this._extHostWorkspace.getWorkspaceFolder(activeWorkspaceRootUri);
-			if (apiLastActiveWorkspace) {
-				lastActiveWorkspace = {
-					uri: apiLastActiveWorkspace.uri,
-					name: apiLastActiveWorkspace.name,
-					index: apiLastActiveWorkspace.index,
-					toResource: () => {
-						throw new Error('Not implemented');
-					}
-				};
-			}
-		}
-
-		// Get the initial cwd
-		const terminalConfig = configProvider.getConfiguration('terminal.integrated');
-
-		const initialCwd = terminalEnvironment.getCwd(shellLaunchConfig, os.homedir(), terminalEnvironment.createVariableResolver(lastActiveWorkspace, this._variableResolver), activeWorkspaceRootUri, terminalConfig.cwd, this._logService);
-		shellLaunchConfig.cwd = initialCwd;
-
-		const envFromConfig = this._apiInspectConfigToPlain(configProvider.getConfiguration('terminal.integrated').inspect<ITerminalEnvironment>(`env.${platformKey}`));
-		const baseEnv = terminalConfig.get<boolean>('inheritEnv', true) ? process.env as platform.IProcessEnvironment : await this._getNonInheritedEnv();
-		const variableResolver = terminalEnvironment.createVariableResolver(lastActiveWorkspace, this._variableResolver);
-		const env = terminalEnvironment.createTerminalEnvironment(
-			shellLaunchConfig,
-			envFromConfig,
-			variableResolver,
-			isWorkspaceShellAllowed,
-			this._extHostInitDataService.version,
-			terminalConfig.get<'auto' | 'off' | 'on'>('detectLocale', 'auto'),
-			baseEnv
-		);
-
-		// Apply extension environment variable collections to the environment
-		if (!shellLaunchConfig.strictEnv && !shellLaunchConfig.hideFromUser) {
-			const mergedCollection = new MergedEnvironmentVariableCollection(this._environmentVariableCollections);
-			mergedCollection.applyToProcessEnvironment(env, variableResolver);
-		}
-
-		this._proxy.$sendResolvedLaunchConfig(id, shellLaunchConfig);
-		// Fork the process and listen for messages
-		this._logService.debug(`Terminal process launching on ext host`, { shellLaunchConfig, initialCwd, cols, rows, env });
-		// TODO: Support conpty on remote, it doesn't seem to work for some reason?
-		// TODO: When conpty is enabled, only enable it when accessibilityMode is off
-		const enableConpty = false; //terminalConfig.get('windowsEnableConpty') as boolean;
-
-		const terminalProcess = new TerminalProcess(shellLaunchConfig, initialCwd, cols, rows, env, process.env as platform.IProcessEnvironment, enableConpty, this._logService);
-		this._setupExtHostProcessListeners(id, terminalProcess);
-		const error = await terminalProcess.start();
-		if (error) {
-			// TODO: Teardown?
-			return error;
-		}
-		return undefined;
-	}
-
-	public $getAvailableShells(): Promise<IShellDefinitionDto[]> {
-		return detectAvailableShells();
+	public async $getAvailableProfiles(quickLaunchOnly: boolean): Promise<ITerminalProfile[]> {
+		const config = await (await this._extHostConfiguration.getConfigProvider()).getConfiguration().get('terminal.integrated');
+		return detectAvailableProfiles(quickLaunchOnly, this._logService, config as ITerminalConfiguration, await this._variableResolverPromise, this._lastActiveWorkspace);
 	}

 	public async $getDefaultShellAndArgs(useAutomationShell: boolean): Promise<IShellAndArgsDto> {
--- a/lib/vscode/src/vs/workbench/api/node/extHostTunnelService.ts
+++ b/lib/vscode/src/vs/workbench/api/node/extHostTunnelService.ts
@@ -3,7 +3,7 @@
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

-import { MainThreadTunnelServiceShape, MainContext } from 'vs/workbench/api/common/extHost.protocol';
+import { MainThreadTunnelServiceShape, MainContext, PortAttributesProviderSelector } from 'vs/workbench/api/common/extHost.protocol';
 import { IExtHostRpcService } from 'vs/workbench/api/common/extHostRpcService';
 import type * as vscode from 'vscode';
 import { Disposable, IDisposable, toDisposable } from 'vs/base/common/lifecycle';
@@ -13,14 +13,16 @@ import { exec } from 'child_process';
 import * as resources from 'vs/base/common/resources';
 import * as fs from 'fs';
 import * as pfs from 'vs/base/node/pfs';
+import * as types from 'vs/workbench/api/common/extHostTypes';
 import { isLinux } from 'vs/base/common/platform';
 import { IExtHostTunnelService, TunnelDto } from 'vs/workbench/api/common/extHostTunnelService';
 import { Event, Emitter } from 'vs/base/common/event';
-import { TunnelOptions, TunnelCreationOptions } from 'vs/platform/remote/common/tunnel';
+import { TunnelOptions, TunnelCreationOptions, ProvidedPortAttributes, ProvidedOnAutoForward } from 'vs/platform/remote/common/tunnel';
 import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
 import { MovingAverage } from 'vs/base/common/numbers';
 import { CandidatePort } from 'vs/workbench/services/remote/common/remoteExplorerService';
 import { ILogService } from 'vs/platform/log/common/log';
+import { flatten } from 'vs/base/common/arrays';

 class ExtensionTunnel implements vscode.Tunnel {
 	private _onDispose: Emitter<void> = new Emitter();
@@ -37,7 +39,7 @@ class ExtensionTunnel implements vscode.Tunnel {
 	}
 }

-export function getSockets(stdout: string): { pid: number, socket: number }[] {
+export function getSockets(stdout: string): Record<string, { pid: number; socket: number; }> {
 	const lines = stdout.trim().split('\n');
 	const mapped: { pid: number, socket: number }[] = [];
 	lines.forEach(line => {
@@ -49,7 +51,11 @@ export function getSockets(stdout: string): { pid: number, socket: number }[] {
 			});
 		}
 	});
-	return mapped;
+	const socketMap = mapped.reduce((m, socket) => {
+		m[socket.socket] = socket;
+		return m;
+	}, {} as Record<string, typeof mapped[0]>);
+	return socketMap;
 }

 export function loadListeningPorts(...stdouts: string[]): { socket: number, ip: string, port: number }[] {
@@ -106,29 +112,70 @@ function knownExcludeCmdline(command: string): boolean {
 		|| (command.indexOf('_productName=VSCode') !== -1);
 }

-export async function findPorts(tcp: string, tcp6: string, procSockets: string, processes: { pid: number, cwd: string, cmd: string }[]): Promise<CandidatePort[]> {
-	const connections: { socket: number, ip: string, port: number }[] = loadListeningPorts(tcp, tcp6);
-	const sockets = getSockets(procSockets);
+export function getRootProcesses(stdout: string) {
+	const lines = stdout.trim().split('\n');
+	const mapped: { pid: number, cmd: string, ppid: number }[] = [];
+	lines.forEach(line => {
+		const match = /^\d+\s+\D+\s+root\s+(\d+)\s+(\d+).+\d+\:\d+\:\d+\s+(.+)$/.exec(line)!;
+		if (match && match.length >= 4) {
+			mapped.push({
+				pid: parseInt(match[1], 10),
+				ppid: parseInt(match[2]),
+				cmd: match[3]
+			});
+		}
+	});
+	return mapped;
+}

-	const socketMap = sockets.reduce((m, socket) => {
-		m[socket.socket] = socket;
-		return m;
-	}, {} as Record<string, typeof sockets[0]>);
+export async function findPorts(connections: { socket: number, ip: string, port: number }[], socketMap: Record<string, { pid: number, socket: number }>, processes: { pid: number, cwd: string, cmd: string }[]): Promise<CandidatePort[]> {
 	const processMap = processes.reduce((m, process) => {
 		m[process.pid] = process;
 		return m;
 	}, {} as Record<string, typeof processes[0]>);

 	const ports: CandidatePort[] = [];
-	connections.filter((connection => socketMap[connection.socket])).forEach(({ socket, ip, port }) => {
-		const command = processMap[socketMap[socket].pid].cmd;
-		if (!knownExcludeCmdline(command)) {
-			ports.push({ host: ip, port, detail: processMap[socketMap[socket].pid].cmd, pid: socketMap[socket].pid });
+	connections.forEach(({ socket, ip, port }) => {
+		const pid = socketMap[socket] ? socketMap[socket].pid : undefined;
+		const command: string | undefined = pid ? processMap[pid]?.cmd : undefined;
+		if (pid && command && !knownExcludeCmdline(command)) {
+			ports.push({ host: ip, port, detail: command, pid });
 		}
 	});
 	return ports;
 }

+export function tryFindRootPorts(connections: { socket: number, ip: string, port: number }[], rootProcessesStdout: string, previousPorts: Map<number, CandidatePort & { ppid: number }>): Map<number, CandidatePort & { ppid: number }> {
+	const ports: Map<number, CandidatePort & { ppid: number }> = new Map();
+	const rootProcesses = getRootProcesses(rootProcessesStdout);
+
+	for (const connection of connections) {
+		const previousPort = previousPorts.get(connection.port);
+		if (previousPort) {
+			ports.set(connection.port, previousPort);
+			continue;
+		}
+		const rootProcessMatch = rootProcesses.find((value) => value.cmd.includes(`${connection.port}`));
+		if (rootProcessMatch) {
+			let bestMatch = rootProcessMatch;
+			// There are often several processes that "look" like they could match the port.
+			// The one we want is usually the child of the other. Find the most child process.
+			let mostChild: { pid: number, cmd: string, ppid: number } | undefined;
+			do {
+				mostChild = rootProcesses.find(value => value.ppid === bestMatch.pid);
+				if (mostChild) {
+					bestMatch = mostChild;
+				}
+			} while (mostChild);
+			ports.set(connection.port, { host: connection.ip, port: connection.port, pid: bestMatch.pid, detail: bestMatch.cmd, ppid: bestMatch.ppid });
+		} else {
+			ports.set(connection.port, { host: connection.ip, port: connection.port, ppid: Number.MAX_VALUE });
+		}
+	}
+
+	return ports;
+}
+
 export class ExtHostTunnelService extends Disposable implements IExtHostTunnelService {
 	readonly _serviceBrand: undefined;
 	private readonly _proxy: MainThreadTunnelServiceShape;
@@ -138,6 +185,10 @@ export class ExtHostTunnelService extends Disposable implements IExtHostTunnelSe
 	private _onDidChangeTunnels: Emitter<void> = new Emitter<void>();
 	onDidChangeTunnels: vscode.Event<void> = this._onDidChangeTunnels.event;
 	private _candidateFindingEnabled: boolean = false;
+	private _foundRootPorts: Map<number, CandidatePort & { ppid: number }> = new Map();
+
+	private _providerHandleCounter: number = 0;
+	private _portAttributesProviders: Map<number, { provider: vscode.PortAttributesProvider, selector: PortAttributesProviderSelector }> = new Map();

 	constructor(
 		@IExtHostRpcService extHostRpc: IExtHostRpcService,
@@ -152,6 +203,7 @@ export class ExtHostTunnelService extends Disposable implements IExtHostTunnelSe
 	}

 	async openTunnel(extension: IExtensionDescription, forward: TunnelOptions): Promise<vscode.Tunnel | undefined> {
+		this.logService.trace(`ForwardedPorts: (ExtHostTunnelService) ${extension.identifier} called openTunnel API for ${forward.remoteAddress.port}.`);
 		const tunnel = await this._proxy.$openTunnel(forward, extension.displayName);
 		if (tunnel) {
 			const disposableTunnel: vscode.Tunnel = new ExtensionTunnel(tunnel.remoteAddress, tunnel.localAddress, () => {
@@ -172,6 +224,40 @@ export class ExtHostTunnelService extends Disposable implements IExtHostTunnelSe
 		return Math.max(movingAverage * 20, 2000);
 	}

+	private nextPortAttributesProviderHandle(): number {
+		return this._providerHandleCounter++;
+	}
+
+	registerPortsAttributesProvider(portSelector: PortAttributesProviderSelector, provider: vscode.PortAttributesProvider): vscode.Disposable {
+		const providerHandle = this.nextPortAttributesProviderHandle();
+		this._portAttributesProviders.set(providerHandle, { selector: portSelector, provider });
+
+		this._proxy.$registerPortsAttributesProvider(portSelector, providerHandle);
+		return new types.Disposable(() => {
+			this._portAttributesProviders.delete(providerHandle);
+			this._proxy.$unregisterPortsAttributesProvider(providerHandle);
+		});
+	}
+
+	async $providePortAttributes(handles: number[], ports: number[], pid: number | undefined, commandline: string | undefined, cancellationToken: vscode.CancellationToken): Promise<ProvidedPortAttributes[]> {
+		const providedAttributes = await Promise.all(handles.map(handle => {
+			const provider = this._portAttributesProviders.get(handle);
+			if (!provider) {
+				return [];
+			}
+			return provider.provider.providePortAttributes(ports, pid, commandline, cancellationToken);
+		}));
+
+		const allAttributes = <vscode.PortAttributes[][]>providedAttributes.filter(attribute => !!attribute && attribute.length > 0);
+
+		return (allAttributes.length > 0) ? flatten(allAttributes).map(attributes => {
+			return {
+				autoForwardAction: <ProvidedOnAutoForward><unknown>attributes.autoForwardAction,
+				port: attributes.port
+			};
+		}) : [];
+	}
+
 	async $registerCandidateFinder(enable: boolean): Promise<void> {
 		if (enable && this._candidateFindingEnabled) {
 			// already enabled
@@ -180,10 +266,11 @@ export class ExtHostTunnelService extends Disposable implements IExtHostTunnelSe
 		this._candidateFindingEnabled = enable;
 		// Regularly scan to see if the candidate ports have changed.
 		let movingAverage = new MovingAverage();
-		let oldPorts: { host: string, port: number, detail: string }[] | undefined = undefined;
+		let oldPorts: { host: string, port: number, detail?: string }[] | undefined = undefined;
 		while (this._candidateFindingEnabled) {
 			const startTime = new Date().getTime();
 			const newPorts = await this.findCandidatePorts();
+			this.logService.trace(`ForwardedPorts: (ExtHostTunnelService) found candidate ports ${newPorts.map(port => port.port).join(', ')}`);
 			const timeTaken = new Date().getTime() - startTime;
 			movingAverage.update(timeTaken);
 			if (!oldPorts || (JSON.stringify(oldPorts) !== JSON.stringify(newPorts))) {
@@ -238,31 +325,36 @@ export class ExtHostTunnelService extends Disposable implements IExtHostTunnelSe
 	async $forwardPort(tunnelOptions: TunnelOptions, tunnelCreationOptions: TunnelCreationOptions): Promise<TunnelDto | undefined> {
 		if (this._forwardPortProvider) {
 			try {
-				this.logService.trace('$forwardPort: Getting tunnel from provider.');
+				this.logService.trace('ForwardedPorts: (ExtHostTunnelService) Getting tunnel from provider.');
 				const providedPort = this._forwardPortProvider(tunnelOptions, tunnelCreationOptions);
-				this.logService.trace('$forwardPort: Got tunnel promise from provider.');
+				this.logService.trace('ForwardedPorts: (ExtHostTunnelService) Got tunnel promise from provider.');
 				if (providedPort !== undefined) {
 					const tunnel = await providedPort;
-					this.logService.trace('$forwardPort: Successfully awaited tunnel from provider.');
+					this.logService.trace('ForwardedPorts: (ExtHostTunnelService) Successfully awaited tunnel from provider.');
 					if (!this._extensionTunnels.has(tunnelOptions.remoteAddress.host)) {
 						this._extensionTunnels.set(tunnelOptions.remoteAddress.host, new Map());
 					}
-					const disposeListener = this._register(tunnel.onDidDispose(() => this._proxy.$closeTunnel(tunnel.remoteAddress)));
+					const disposeListener = this._register(tunnel.onDidDispose(() => {
+						this.logService.trace('ForwardedPorts: (ExtHostTunnelService) Extension fired tunnel\'s onDidDispose.');
+						return this._proxy.$closeTunnel(tunnel.remoteAddress);
+					}));
 					this._extensionTunnels.get(tunnelOptions.remoteAddress.host)!.set(tunnelOptions.remoteAddress.port, { tunnel, disposeListener });
 					return TunnelDto.fromApiTunnel(tunnel);
 				} else {
-					this.logService.trace('$forwardPort: Tunnel is undefined');
+					this.logService.trace('ForwardedPorts: (ExtHostTunnelService) Tunnel is undefined');
 				}
 			} catch (e) {
-				this.logService.trace('$forwardPort: tunnel provider error');
+				this.logService.trace('ForwardedPorts: (ExtHostTunnelService) tunnel provider error');
 			}
 		}
 		return undefined;
 	}

 	async $applyCandidateFilter(candidates: CandidatePort[]): Promise<CandidatePort[]> {
-		const filter = await Promise.all(candidates.map(candidate => this._showCandidatePort(candidate.host, candidate.port, candidate.detail)));
-		return candidates.filter((candidate, index) => filter[index]);
+		const filter = await Promise.all(candidates.map(candidate => this._showCandidatePort(candidate.host, candidate.port, candidate.detail ?? '')));
+		const result = candidates.filter((candidate, index) => filter[index]);
+		this.logService.trace(`ForwardedPorts: (ExtHostTunnelService) filtered from ${candidates.map(port => port.port).join(', ')} to ${result.map(port => port.port).join(', ')}`);
+		return result;
 	}

 	async findCandidatePorts(): Promise<CandidatePort[]> {
@@ -274,11 +366,14 @@ export class ExtHostTunnelService extends Disposable implements IExtHostTunnelSe
 		} catch (e) {
 			// File reading error. No additional handling needed.
 		}
+		const connections: { socket: number, ip: string, port: number }[] = loadListeningPorts(tcp, tcp6);
+
 		const procSockets: string = await (new Promise(resolve => {
 			exec('ls -l /proc/[0-9]*/fd/[0-9]* | grep socket:', (error, stdout, stderr) => {
 				resolve(stdout);
 			});
 		}));
+		const socketMap = getSockets(procSockets);

 		const procChildren = await pfs.readdir('/proc');
 		const processes: {
@@ -298,6 +393,36 @@ export class ExtHostTunnelService extends Disposable implements IExtHostTunnelSe
 				//
 			}
 		}
-		return findPorts(tcp, tcp6, procSockets, processes);
+
+		const unFoundConnections: { socket: number, ip: string, port: number }[] = [];
+		const filteredConnections = connections.filter((connection => {
+			const foundConnection = socketMap[connection.socket];
+			if (!foundConnection) {
+				unFoundConnections.push(connection);
+			}
+			return foundConnection;
+		}));
+
+		const foundPorts = findPorts(filteredConnections, socketMap, processes);
+		let heuristicPorts: CandidatePort[] | undefined;
+		this.logService.trace(`ForwardedPorts: (ExtHostTunnelService) number of possible root ports ${unFoundConnections.length}`);
+		if (unFoundConnections.length > 0) {
+			const rootProcesses: string = await (new Promise(resolve => {
+				exec('ps -F -A -l | grep root', (error, stdout, stderr) => {
+					resolve(stdout);
+				});
+			}));
+			this._foundRootPorts = tryFindRootPorts(unFoundConnections, rootProcesses, this._foundRootPorts);
+			heuristicPorts = Array.from(this._foundRootPorts.values());
+			this.logService.trace(`ForwardedPorts: (ExtHostTunnelService) heuristic ports ${heuristicPorts.join(', ')}`);
+
+		}
+		return foundPorts.then(foundCandidates => {
+			if (heuristicPorts) {
+				return foundCandidates.concat(heuristicPorts);
+			} else {
+				return foundCandidates;
+			}
+		});
 	}
 }