Support debugging process from the process explorer, closes #63147 (#63953)

src/vs/code/electron-browser/issue/issueReporterMain.ts

@@ -378,15 +378,19 @@ export class IssueReporter extends Disposable {
 
 		this.previewButton.onDidClick(() => this.createIssue());
 
+		function sendWorkbenchCommand(commandId: string) {
+			ipcRenderer.send('vscode:workbenchCommand', { id: commandId, from: 'issueReporter' });
+		}
+
 		this.addEventListener('disableExtensions', 'click', () => {
-			ipcRenderer.send('vscode:workbenchCommand', 'workbench.action.reloadWindowWithExtensionsDisabled');
+			sendWorkbenchCommand('workbench.action.reloadWindowWithExtensionsDisabled');
 		});
 
 		this.addEventListener('disableExtensions', 'keydown', (e: KeyboardEvent) => {
 			e.stopPropagation();
 			if (e.keyCode === 13 || e.keyCode === 32) {
-				ipcRenderer.send('vscode:workbenchCommand', 'workbench.extensions.action.disableAll');
-				ipcRenderer.send('vscode:workbenchCommand', 'workbench.action.reloadWindow');
+				sendWorkbenchCommand('workbench.extensions.action.disableAll');
+				sendWorkbenchCommand('workbench.action.reloadWindow');
 			}
 		});
 

src/vs/code/electron-browser/processExplorer/processExplorerMain.ts

@@ -19,6 +19,9 @@ import { popup } from 'vs/base/parts/contextmenu/electron-browser/contextmenu';
 let processList: any[];
 let mapPidToWindowTitle = new Map<number, string>();
 
+const DEBUG_FLAGS_PATTERN = /\s--(inspect|debug)(-brk|port)?=(\d+)?/;
+const DEBUG_PORT_PATTERN = /\s--(inspect|debug)-port=(\d+)/;
+
 function getProcessList(rootProcess: ProcessItem) {
 	const processes: any[] = [];
 
@@ -62,6 +65,40 @@ function getProcessItem(processes: any[], item: ProcessItem, indent: number): vo
 	}
 }
 
+function isDebuggable(cmd: string): boolean {
+	const matches = DEBUG_FLAGS_PATTERN.exec(cmd);
+	return (matches && matches.length >= 2) || cmd.indexOf('node ') >= 0 || cmd.indexOf('node.exe') >= 0;
+}
+
+function attachTo(item: ProcessItem) {
+	const config: any = {
+		type: 'node',
+		request: 'attach',
+		name: `process ${item.pid}`
+	};
+
+	let matches = DEBUG_FLAGS_PATTERN.exec(item.cmd);
+	if (matches && matches.length >= 2) {
+		// attach via port
+		if (matches.length === 4 && matches[3]) {
+			config.port = parseInt(matches[3]);
+		}
+		config.protocol = matches[1] === 'debug' ? 'legacy' : 'inspector';
+	} else {
+		// no port -> try to attach via pid (send SIGUSR1)
+		config.processId = String(item.pid);
+	}
+
+	// a debug-port=n or inspect-port=n overrides the port
+	matches = DEBUG_PORT_PATTERN.exec(item.cmd);
+	if (matches && matches.length === 3) {
+		// override port
+		config.port = parseInt(matches[2]);
+	}
+
+	ipcRenderer.send('vscode:workbenchCommand', { id: 'workbench.action.debug.start', from: 'processExplorer', args: [config] });
+}
+
 function getProcessIdWithHighestProperty(processList, propertyName: string) {
 	let max = 0;
 	let maxProcessId;
@@ -190,6 +227,20 @@ function showContextMenu(e) {
 				}
 			}
 		});
+
+		const item = processList.filter(process => process.pid === pid)[0];
+		if (item && isDebuggable(item.cmd)) {
+			items.push({
+				type: 'separator'
+			});
+
+			items.push({
+				label: localize('debug', "Debug"),
+				click() {
+					attachTo(item);
+				}
+			});
+		}
 	} else {
 		items.push({
 			label: localize('copyAll', "Copy All"),

src/vs/platform/issue/electron-main/issueService.ts

@@ -21,8 +21,9 @@ const DEFAULT_BACKGROUND_COLOR = '#1E1E1E';
 export class IssueService implements IIssueService {
 	_serviceBrand: any;
 	_issueWindow: BrowserWindow | null;
-	_issueParentWindow: BrowserWindow;
+	_issueParentWindow: BrowserWindow | null;
 	_processExplorerWindow: BrowserWindow | null;
+	_processExplorerParentWindow: BrowserWindow | null;
 
 	constructor(
 		private machineId: string,
@@ -49,9 +50,23 @@ export class IssueService implements IIssueService {
 			});
 		});
 
-		ipcMain.on('vscode:workbenchCommand', (event, arg) => {
-			if (this._issueParentWindow) {
-				this._issueParentWindow.webContents.send('vscode:runAction', { id: arg, from: 'issueReporter' });
+		ipcMain.on('vscode:workbenchCommand', (_, commandInfo) => {
+			const { id, from, args } = commandInfo;
+
+			let parentWindow: BrowserWindow | null;
+			switch (from) {
+				case 'issueReporter':
+					parentWindow = this._issueParentWindow;
+					break;
+				case 'processExplorer':
+					parentWindow = this._processExplorerParentWindow;
+					break;
+				default:
+					throw new Error(`Unexpected command source: ${from}`);
+			}
+
+			if (parentWindow) {
+				parentWindow.webContents.send('vscode:runAction', { id, from, args });
 			}
 		});
 
@@ -75,10 +90,11 @@ export class IssueService implements IIssueService {
 
 	openReporter(data: IssueReporterData): Promise<void> {
 		return new Promise(_ => {
-			this._issueParentWindow = BrowserWindow.getFocusedWindow();
-			if (this._issueParentWindow) {
-				const position = this.getWindowPosition(this._issueParentWindow, 700, 800);
-				if (!this._issueWindow) {
+			if (!this._issueWindow) {
+				this._issueParentWindow = BrowserWindow.getFocusedWindow();
+				if (this._issueParentWindow) {
+					const position = this.getWindowPosition(this._issueParentWindow, 700, 800);
+
 					this._issueWindow = new BrowserWindow({
 						width: position.width,
 						height: position.height,
@@ -107,7 +123,9 @@ export class IssueService implements IIssueService {
 						}
 					});
 				}
+			}
 
+			if (this._issueWindow) {
 				this._issueWindow.focus();
 			}
 		});
@@ -117,9 +135,9 @@ export class IssueService implements IIssueService {
 		return new Promise(_ => {
 			// Create as singleton
 			if (!this._processExplorerWindow) {
-				const parentWindow = BrowserWindow.getFocusedWindow();
-				if (parentWindow) {
-					const position = this.getWindowPosition(parentWindow, 800, 300);
+				this._processExplorerParentWindow = BrowserWindow.getFocusedWindow();
+				if (this._processExplorerParentWindow) {
+					const position = this.getWindowPosition(this._processExplorerParentWindow, 800, 300);
 					this._processExplorerWindow = new BrowserWindow({
 						skipTaskbar: true,
 						resizable: true,
@@ -156,18 +174,18 @@ export class IssueService implements IIssueService {
 
 					this._processExplorerWindow.on('close', () => this._processExplorerWindow = null);
 
-					parentWindow.on('close', () => {
+					this._processExplorerParentWindow.on('close', () => {
 						if (this._processExplorerWindow) {
 							this._processExplorerWindow.close();
 							this._processExplorerWindow = null;
 						}
 					});
 				}
+			}
 
-				// Focus
-				if (this._processExplorerWindow) {
-					this._processExplorerWindow.focus();
-				}
+			// Focus
+			if (this._processExplorerWindow) {
+				this._processExplorerWindow.focus();
 			}
 		});
 	}

src/vs/platform/windows/common/windows.ts

@@ -404,6 +404,7 @@ export interface IWindowConfiguration extends ParsedArgs {
 export interface IRunActionInWindowRequest {
 	id: string;
 	from: 'menu' | 'touchbar' | 'mouse';
+	args?: any[];
 }
 
 export class ActiveWindowManager implements IDisposable {

src/vs/workbench/electron-browser/window.ts

@@ -104,7 +104,7 @@ export class ElectronWindow extends Themable {
 
 		// Support runAction event
 		ipc.on('vscode:runAction', (event: any, request: IRunActionInWindowRequest) => {
-			const args: any[] = [];
+			const args: any[] = request.args || [];
 
 			// If we run an action from the touchbar, we fill in the currently active resource
 			// as payload because the touch bar items are context aware depending on the editor

src/vs/workbench/parts/debug/browser/debugActions.ts

@@ -10,7 +10,7 @@ import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
 import { ICommandService } from 'vs/platform/commands/common/commands';
 import { IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/common/workspace';
 import { IFileService } from 'vs/platform/files/common/files';
-import { IDebugService, State, IDebugSession, IThread, IEnablement, IBreakpoint, IStackFrame, REPL_ID }
+import { IDebugService, State, IDebugSession, IThread, IEnablement, IBreakpoint, IStackFrame, REPL_ID, IConfig }
 	from 'vs/workbench/parts/debug/common/debug';
 import { Variable, Expression, Thread, Breakpoint } from 'vs/workbench/parts/debug/common/debugModel';
 import { IPartService } from 'vs/workbench/services/part/common/partService';
@@ -133,7 +133,13 @@ export class StartAction extends AbstractDebugAction {
 		this.toDispose.push(this.contextService.onDidChangeWorkbenchState(() => this.updateEnablement()));
 	}
 
-	public run(): Thenable<any> {
+	// Note: When this action is executed from the process explorer, a config is passed. For all
+	// other cases it is run with no arguments.
+	public run(config?: IConfig): Thenable<any> {
+		if (config) {
+			return this.debugService.startDebugging(undefined, config, this.isNoDebug());
+		}
+
 		const configurationManager = this.debugService.getConfigurationManager();
 		let launch = configurationManager.selectedConfiguration.launch;
 		if (!launch || launch.getConfigurationNames().length === 0) {

src/vs/workbench/parts/debug/electron-browser/debug.contribution.ts

@@ -10,7 +10,7 @@ import { KeyMod, KeyCode } from 'vs/base/common/keyCodes';
 import { SyncActionDescriptor, MenuRegistry, MenuId } from 'vs/platform/actions/common/actions';
 import { Registry } from 'vs/platform/registry/common/platform';
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
-import { KeybindingWeight, IKeybindings } from 'vs/platform/keybinding/common/keybindingsRegistry';
+import { KeybindingWeight, IKeybindings, KeybindingsRegistry } from 'vs/platform/keybinding/common/keybindingsRegistry';
 import { IConfigurationRegistry, Extensions as ConfigurationExtensions } from 'vs/platform/configuration/common/configurationRegistry';
 import { IWorkbenchActionRegistry, Extensions as WorkbenchActionRegistryExtensions } from 'vs/workbench/common/actions';
 import { ShowViewletAction, Extensions as ViewletExtensions, ViewletRegistry, ViewletDescriptor } from 'vs/workbench/browser/viewlet';
@@ -49,11 +49,13 @@ import { DebugViewlet } from 'vs/workbench/parts/debug/browser/debugViewlet';
 import { Repl, ClearReplAction } from 'vs/workbench/parts/debug/electron-browser/repl';
 import { DebugQuickOpenHandler } from 'vs/workbench/parts/debug/browser/debugQuickOpen';
 import { DebugStatus } from 'vs/workbench/parts/debug/browser/debugStatus';
-import { LifecyclePhase } from 'vs/platform/lifecycle/common/lifecycle';
+import { LifecyclePhase, ILifecycleService } from 'vs/platform/lifecycle/common/lifecycle';
 import { launchSchemaId } from 'vs/workbench/services/configuration/common/configuration';
 import { IEditorGroupsService } from 'vs/workbench/services/group/common/editorGroupsService';
 import { LoadedScriptsView } from 'vs/workbench/parts/debug/browser/loadedScriptsView';
 import { TOGGLE_LOG_POINT_ID, TOGGLE_CONDITIONAL_BREAKPOINT_ID, TOGGLE_BREAKPOINT_ID } from 'vs/workbench/parts/debug/browser/debugEditorActions';
+import { INotificationService } from 'vs/platform/notification/common/notification';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 
 class OpenDebugViewletAction extends ShowViewletAction {
 	public static readonly ID = VIEWLET_ID;
@@ -129,8 +131,59 @@ Registry.as<IWorkbenchContributionsRegistry>(WorkbenchExtensions.Workbench).regi
 Registry.as<IWorkbenchContributionsRegistry>(WorkbenchExtensions.Workbench).registerWorkbenchContribution(StatusBarColorProvider, LifecyclePhase.Eventually);
 
 const debugCategory = nls.localize('debugCategory', "Debug");
-registry.registerWorkbenchAction(new SyncActionDescriptor(
-	StartAction, StartAction.ID, StartAction.LABEL, { primary: KeyCode.F5 }, CONTEXT_IN_DEBUG_MODE.toNegated()), 'Debug: Start Debugging', debugCategory);
+
+const startDebugDescriptor = new SyncActionDescriptor(StartAction, StartAction.ID, StartAction.LABEL, { primary: KeyCode.F5 }, CONTEXT_IN_DEBUG_MODE.toNegated());
+
+function startDebugHandler(accessor, args): Promise<void> {
+	const notificationService = accessor.get(INotificationService);
+	const instantiationService = accessor.get(IInstantiationService);
+	const lifecycleService = accessor.get(ILifecycleService);
+
+	return Promise.resolve(lifecycleService.when(LifecyclePhase.Ready).then(() => {
+		const actionInstance = instantiationService.createInstance(startDebugDescriptor.syncDescriptor);
+		try {
+			// don't run the action when not enabled
+			if (!actionInstance.enabled) {
+				actionInstance.dispose();
+
+				return void 0;
+			}
+
+			const from = args && args.from || 'keybinding';
+
+			if (args) {
+				delete args.from;
+			}
+
+			return Promise.resolve(actionInstance.run(args, { from })).then(() => {
+				actionInstance.dispose();
+			}, err => {
+				actionInstance.dispose();
+
+				return Promise.reject(err);
+			});
+		} catch (err) {
+			actionInstance.dispose();
+
+			return Promise.reject(err);
+		}
+	})).then(null, err => notificationService.error(err));
+}
+
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+	id: StartAction.ID,
+	weight: KeybindingWeight.WorkbenchContrib,
+	when: CONTEXT_IN_DEBUG_MODE.toNegated(),
+	primary: KeyCode.F5,
+	handler: startDebugHandler
+});
+
+MenuRegistry.addCommand({
+	id: StartAction.ID,
+	title: StartAction.LABEL,
+	category: debugCategory
+});
+
 registry.registerWorkbenchAction(new SyncActionDescriptor(StepOverAction, StepOverAction.ID, StepOverAction.LABEL, { primary: KeyCode.F10 }, CONTEXT_IN_DEBUG_MODE), 'Debug: Step Over', debugCategory);
 registry.registerWorkbenchAction(new SyncActionDescriptor(StepIntoAction, StepIntoAction.ID, StepIntoAction.LABEL, { primary: KeyCode.F11 }, CONTEXT_IN_DEBUG_MODE, KeybindingWeight.WorkbenchContrib + 1), 'Debug: Step Into', debugCategory);
 registry.registerWorkbenchAction(new SyncActionDescriptor(StepOutAction, StepOutAction.ID, StepOutAction.LABEL, { primary: KeyMod.Shift | KeyCode.F11 }, CONTEXT_IN_DEBUG_MODE), 'Debug: Step Out', debugCategory);