Merge pull request microsoft#209946 from microsoft/tyriar/145234_confidence

Add command line confidence to shellIntegration API

Author: Tyriar

src/vs/platform/terminal/common/capabilities/capabilities.ts

@@ -240,6 +240,7 @@ export interface IPartialCommandDetectionCapability {
 interface IBaseTerminalCommand {
 	// Mandatory
 	command: string;
+	commandLineConfidence: 'low' | 'medium' | 'high';
 	isTrusted: boolean;
 	timestamp: number;
 	duration: number;
@@ -262,6 +263,7 @@ export interface ITerminalCommand extends IBaseTerminalCommand {
 	readonly aliases?: string[][];
 	readonly wasReplayed?: boolean;
 
+	extractCommandLine(): string;
 	getOutput(): string | undefined;
 	getOutputMatch(outputMatcher: ITerminalOutputMatcher): ITerminalOutputMatch | undefined;
 	hasOutput(): boolean;

src/vs/platform/terminal/common/capabilities/commandDetection/terminalCommand.ts

@@ -12,6 +12,7 @@ import type { IBuffer, IBufferLine, Terminal } from '@xterm/headless';
 
 export interface ITerminalCommandProperties {
 	command: string;
+	commandLineConfidence: 'low' | 'medium' | 'high';
 	isTrusted: boolean;
 	timestamp: number;
 	duration: number;
@@ -33,6 +34,7 @@ export interface ITerminalCommandProperties {
 export class TerminalCommand implements ITerminalCommand {
 
 	get command() { return this._properties.command; }
+	get commandLineConfidence() { return this._properties.commandLineConfidence; }
 	get isTrusted() { return this._properties.isTrusted; }
 	get timestamp() { return this._properties.timestamp; }
 	get duration() { return this._properties.duration; }
@@ -71,6 +73,7 @@ export class TerminalCommand implements ITerminalCommand {
 		const executedMarker = serialized.executedLine !== undefined ? xterm.registerMarker(serialized.executedLine - (buffer.baseY + buffer.cursorY)) : undefined;
 		const newCommand = new TerminalCommand(xterm, {
 			command: isCommandStorageDisabled ? '' : serialized.command,
+			commandLineConfidence: serialized.commandLineConfidence ?? 'low',
 			isTrusted: serialized.isTrusted,
 			promptStartMarker,
 			marker,
@@ -99,6 +102,7 @@ export class TerminalCommand implements ITerminalCommand {
 			executedLine: this.executedMarker?.line,
 			executedX: this.executedX,
 			command: isCommandStorageDisabled ? '' : this.command,
+			commandLineConfidence: isCommandStorageDisabled ? 'low' : this.commandLineConfidence,
 			isTrusted: this.isTrusted,
 			cwd: this.cwd,
 			exitCode: this.exitCode,
@@ -109,6 +113,10 @@ export class TerminalCommand implements ITerminalCommand {
 		};
 	}
 
+	extractCommandLine(): string {
+		return extractCommandLine(this._xterm.buffer.active, this._xterm.cols, this.marker, this.startX, this.executedMarker, this.executedX);
+	}
+
 	getOutput(): string | undefined {
 		if (!this.executedMarker || !this.endMarker) {
 			return undefined;
@@ -265,6 +273,7 @@ export class PartialTerminalCommand implements ICurrentPartialCommand {
 
 	cwd?: string;
 	command?: string;
+	commandLineConfidence?: 'low' | 'medium' | 'high';
 
 	isTrusted?: boolean;
 	isInvalid?: boolean;
@@ -287,6 +296,7 @@ export class PartialTerminalCommand implements ICurrentPartialCommand {
 			executedLine: undefined,
 			executedX: undefined,
 			command: '',
+			commandLineConfidence: 'low',
 			isTrusted: true,
 			cwd,
 			exitCode: undefined,
@@ -306,6 +316,7 @@ export class PartialTerminalCommand implements ICurrentPartialCommand {
 		if ((this.command !== undefined && !this.command.startsWith('\\')) || ignoreCommandLine) {
 			return new TerminalCommand(this._xterm, {
 				command: ignoreCommandLine ? '' : (this.command || ''),
+				commandLineConfidence: ignoreCommandLine ? 'low' : (this.commandLineConfidence || 'low'),
 				isTrusted: !!this.isTrusted,
 				promptStartMarker: this.promptStartMarker,
 				marker: this.commandStartMarker,
@@ -337,6 +348,10 @@ export class PartialTerminalCommand implements ICurrentPartialCommand {
 		}
 	}
 
+	extractCommandLine(): string {
+		return extractCommandLine(this._xterm.buffer.active, this._xterm.cols, this.commandStartMarker, this.commandStartX, this.commandExecutedMarker, this.commandExecutedX);
+	}
+
 	getPromptRowCount(): number {
 		return getPromptRowCount(this, this._xterm.buffer.active);
 	}
@@ -346,6 +361,27 @@ export class PartialTerminalCommand implements ICurrentPartialCommand {
 	}
 }
 
+function extractCommandLine(
+	buffer: IBuffer,
+	cols: number,
+	commandStartMarker: IXtermMarker | undefined,
+	commandStartX: number | undefined,
+	commandExecutedMarker: IXtermMarker | undefined,
+	commandExecutedX: number | undefined
+): string {
+	if (!commandStartMarker || !commandExecutedMarker || commandStartX === undefined || commandExecutedX === undefined) {
+		return '';
+	}
+	let content = '';
+	for (let i = commandStartMarker.line; i <= commandExecutedMarker.line; i++) {
+		const line = buffer.getLine(i);
+		if (line) {
+			content += line.translateToString(true, i === commandStartMarker.line ? commandStartX : 0, i === commandExecutedMarker.line ? commandExecutedX : cols);
+		}
+	}
+	return content;
+}
+
 function getXtermLineContent(buffer: IBuffer, lineStart: number, lineEnd: number, cols: number): string {
 	// Cap the maximum number of lines generated to prevent potential performance problems. This is
 	// more of a sanity check as the wrapped line should already be trimmed down at this point.

src/vs/platform/terminal/common/capabilities/commandDetectionCapability.ts

@@ -87,6 +87,43 @@ export class CommandDetectionCapability extends Disposable implements ICommandDe
 	) {
 		super();
 
+		// Pull command line from the buffer if it was not set explicitly
+		this._register(this.onCommandExecuted(command => {
+			if (command.commandLineConfidence !== 'high') {
+				// HACK: onCommandExecuted actually fired with PartialTerminalCommand
+				const typedCommand = (command as ITerminalCommand | PartialTerminalCommand);
+				command.command = typedCommand.extractCommandLine();
+				command.commandLineConfidence = 'low';
+
+				// ITerminalCommand
+				if ('getOutput' in typedCommand) {
+					if (
+						// Markers exist
+						typedCommand.promptStartMarker && typedCommand.marker && typedCommand.executedMarker &&
+						// Single line command
+						command.command.indexOf('\n') === -1 &&
+						// Start marker is not on the left-most column
+						typedCommand.startX !== undefined && typedCommand.startX > 0
+					) {
+						command.commandLineConfidence = 'medium';
+					}
+				}
+				// PartialTerminalCommand
+				else {
+					if (
+						// Markers exist
+						typedCommand.promptStartMarker && typedCommand.commandStartMarker && typedCommand.commandExecutedMarker &&
+						// Single line command
+						command.command.indexOf('\n') === -1 &&
+						// Start marker is not on the left-most column
+						typedCommand.commandStartX !== undefined && typedCommand.commandStartX > 0
+					) {
+						command.commandLineConfidence = 'medium';
+					}
+				}
+			}
+		}));
+
 		// Set up platform-specific behaviors
 		const that = this;
 		this._ptyHeuristicsHooks = new class implements ICommandDetectionHeuristicsHooks {
@@ -353,6 +390,7 @@ export class CommandDetectionCapability extends Disposable implements ICommandDe
 	setCommandLine(commandLine: string, isTrusted: boolean) {
 		this._logService.debug('CommandDetectionCapability#setCommandLine', commandLine, isTrusted);
 		this._currentCommand.command = commandLine;
+		this._currentCommand.commandLineConfidence = 'high';
 		this._currentCommand.isTrusted = isTrusted;
 	}
 

src/vs/workbench/api/browser/mainThreadTerminalShellIntegration.ts

@@ -11,6 +11,7 @@ import { ExtHostContext, MainContext, type ExtHostTerminalShellIntegrationShape,
 import { ITerminalService } from 'vs/workbench/contrib/terminal/browser/terminal';
 import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
 import { extHostNamedCustomer, type IExtHostContext } from 'vs/workbench/services/extensions/common/extHostCustomers';
+import { TerminalShellExecutionCommandLineConfidence } from 'vs/workbench/api/common/extHostTypes';
 
 @extHostNamedCustomer(MainContext.MainThreadTerminalShellIntegration)
 export class MainThreadTerminalShellIntegration extends Disposable implements MainThreadTerminalShellIntegrationShape {
@@ -46,14 +47,14 @@ export class MainThreadTerminalShellIntegration extends Disposable implements Ma
 			}
 			// String paths are not exposed in the extension API
 			currentCommand = e.data;
-			this._proxy.$shellExecutionStart(e.instance.instanceId, e.data.command, this._convertCwdToUri(e.data.cwd));
+			this._proxy.$shellExecutionStart(e.instance.instanceId, e.data.command, convertToExtHostCommandLineConfidence(e.data), e.data.isTrusted, this._convertCwdToUri(e.data.cwd));
 		}));
 
 		// onDidEndTerminalShellExecution
 		const commandDetectionEndEvent = this._store.add(this._terminalService.createOnInstanceCapabilityEvent(TerminalCapability.CommandDetection, e => e.onCommandFinished));
 		this._store.add(commandDetectionEndEvent.event(e => {
 			currentCommand = undefined;
-			this._proxy.$shellExecutionEnd(e.instance.instanceId, e.data.command, e.data.exitCode);
+			this._proxy.$shellExecutionEnd(e.instance.instanceId, e.data.command, convertToExtHostCommandLineConfidence(e.data), e.data.isTrusted, e.data.exitCode);
 		}));
 
 		// onDidChangeTerminalShellIntegration via cwd
@@ -80,3 +81,15 @@ export class MainThreadTerminalShellIntegration extends Disposable implements Ma
 		return cwd ? URI.file(cwd) : undefined;
 	}
 }
+
+function convertToExtHostCommandLineConfidence(command: ITerminalCommand): TerminalShellExecutionCommandLineConfidence {
+	switch (command.commandLineConfidence) {
+		case 'high':
+			return TerminalShellExecutionCommandLineConfidence.High;
+		case 'medium':
+			return TerminalShellExecutionCommandLineConfidence.Medium;
+		case 'low':
+		default:
+			return TerminalShellExecutionCommandLineConfidence.Low;
+	}
+}

src/vs/workbench/api/common/extHost.api.impl.ts

@@ -1601,6 +1601,7 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 			TerminalLocation: extHostTypes.TerminalLocation,
 			TerminalProfile: extHostTypes.TerminalProfile,
 			TerminalExitReason: extHostTypes.TerminalExitReason,
+			TerminalShellExecutionCommandLineConfidence: extHostTypes.TerminalShellExecutionCommandLineConfidence,
 			TextDocumentSaveReason: extHostTypes.TextDocumentSaveReason,
 			TextEdit: extHostTypes.TextEdit,
 			SnippetTextEdit: extHostTypes.SnippetTextEdit,

src/vs/workbench/api/common/extHost.protocol.ts

@@ -81,6 +81,7 @@ import { CandidatePort } from 'vs/workbench/services/remote/common/tunnelModel';
 import { IFileQueryBuilderOptions, ITextQueryBuilderOptions } from 'vs/workbench/services/search/common/queryBuilder';
 import * as search from 'vs/workbench/services/search/common/search';
 import { ISaveProfileResult } from 'vs/workbench/services/userDataProfile/common/userDataProfile';
+import type { TerminalShellExecutionCommandLineConfidence } from 'vscode';
 
 export interface IWorkspaceData extends IStaticWorkspaceData {
 	folders: { uri: UriComponents; name: string; index: number }[];
@@ -2258,8 +2259,8 @@ export interface ExtHostTerminalServiceShape {
 
 export interface ExtHostTerminalShellIntegrationShape {
 	$shellIntegrationChange(instanceId: number): void;
-	$shellExecutionStart(instanceId: number, commandLine: string | undefined, cwd: UriComponents | undefined): void;
-	$shellExecutionEnd(instanceId: number, commandLine: string | undefined, exitCode: number | undefined): void;
+	$shellExecutionStart(instanceId: number, commandLineValue: string, commandLineConfidence: TerminalShellExecutionCommandLineConfidence, isTrusted: boolean, cwd: UriComponents | undefined): void;
+	$shellExecutionEnd(instanceId: number, commandLineValue: string, commandLineConfidence: TerminalShellExecutionCommandLineConfidence, isTrusted: boolean, exitCode: number | undefined): void;
 	$shellExecutionData(instanceId: number, data: string): void;
 	$cwdChange(instanceId: number, cwd: UriComponents | undefined): void;
 	$closeTerminal(instanceId: number): void;

src/vs/workbench/api/common/extHostTerminalShellIntegration.ts

@@ -4,6 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import type * as vscode from 'vscode';
+import { TerminalShellExecutionCommandLineConfidence } from './extHostTypes';
 import { Disposable, DisposableStore, toDisposable } from 'vs/base/common/lifecycle';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
 import { MainContext, type ExtHostTerminalShellIntegrationShape, type MainThreadTerminalShellIntegrationShape } from 'vs/workbench/api/common/extHost.protocol';
@@ -17,7 +18,7 @@ export interface IExtHostTerminalShellIntegration extends ExtHostTerminalShellIn
 	readonly _serviceBrand: undefined;
 
 	readonly onDidChangeTerminalShellIntegration: Event<vscode.TerminalShellIntegrationChangeEvent>;
-	readonly onDidStartTerminalShellExecution: Event<vscode.TerminalShellExecution>;
+	readonly onDidStartTerminalShellExecution: Event<vscode.TerminalShellExecutionStartEvent>;
 	readonly onDidEndTerminalShellExecution: Event<vscode.TerminalShellExecutionEndEvent>;
 }
 export const IExtHostTerminalShellIntegration = createDecorator<IExtHostTerminalShellIntegration>('IExtHostTerminalShellIntegration');
@@ -32,7 +33,7 @@ export class ExtHostTerminalShellIntegration extends Disposable implements IExtH
 
 	protected readonly _onDidChangeTerminalShellIntegration = new Emitter<vscode.TerminalShellIntegrationChangeEvent>();
 	readonly onDidChangeTerminalShellIntegration = this._onDidChangeTerminalShellIntegration.event;
-	protected readonly _onDidStartTerminalShellExecution = new Emitter<vscode.TerminalShellExecution>();
+	protected readonly _onDidStartTerminalShellExecution = new Emitter<vscode.TerminalShellExecutionStartEvent>();
 	readonly onDidStartTerminalShellExecution = this._onDidStartTerminalShellExecution.event;
 	protected readonly _onDidEndTerminalShellExecution = new Emitter<vscode.TerminalShellExecutionEndEvent>();
 	readonly onDidEndTerminalShellExecution = this._onDidEndTerminalShellExecution.event;
@@ -103,16 +104,26 @@ export class ExtHostTerminalShellIntegration extends Disposable implements IExtH
 		});
 	}
 
-	public $shellExecutionStart(instanceId: number, commandLine: string, cwd: URI | undefined): void {
+	public $shellExecutionStart(instanceId: number, commandLineValue: string, commandLineConfidence: TerminalShellExecutionCommandLineConfidence, isTrusted: boolean, cwd: URI | undefined): void {
 		// Force shellIntegration creation if it hasn't been created yet, this could when events
 		// don't come through on startup
 		if (!this._activeShellIntegrations.has(instanceId)) {
 			this.$shellIntegrationChange(instanceId);
 		}
+		const commandLine: vscode.TerminalShellExecutionCommandLine = {
+			value: commandLineValue,
+			confidence: commandLineConfidence,
+			isTrusted
+		};
 		this._activeShellIntegrations.get(instanceId)?.startShellExecution(commandLine, cwd);
 	}
 
-	public $shellExecutionEnd(instanceId: number, commandLine: string | undefined, exitCode: number | undefined): void {
+	public $shellExecutionEnd(instanceId: number, commandLineValue: string, commandLineConfidence: TerminalShellExecutionCommandLineConfidence, isTrusted: boolean, exitCode: number | undefined): void {
+		const commandLine: vscode.TerminalShellExecutionCommandLine = {
+			value: commandLineValue,
+			confidence: commandLineConfidence,
+			isTrusted
+		};
 		this._activeShellIntegrations.get(instanceId)?.endShellExecution(commandLine, exitCode);
 	}
 
@@ -151,7 +162,7 @@ class InternalTerminalShellIntegration extends Disposable {
 
 	constructor(
 		private readonly _terminal: vscode.Terminal,
-		private readonly _onDidStartTerminalShellExecution: Emitter<vscode.TerminalShellExecution>
+		private readonly _onDidStartTerminalShellExecution: Emitter<vscode.TerminalShellExecutionStartEvent>
 	) {
 		super();
 
@@ -160,30 +171,42 @@ class InternalTerminalShellIntegration extends Disposable {
 			get cwd(): URI | undefined {
 				return that._cwd;
 			},
-			executeCommand(commandLine): vscode.TerminalShellExecution {
-				that._onDidRequestShellExecution.fire(commandLine);
+			// executeCommand(commandLine: string): vscode.TerminalShellExecution;
+			// executeCommand(executable: string, args: string[]): vscode.TerminalShellExecution;
+			executeCommand(commandLineOrExecutable: string, args?: string[]): vscode.TerminalShellExecution {
+				let commandLineValue: string = commandLineOrExecutable;
+				if (args) {
+					commandLineValue += ` "${args.map(e => `${e.replaceAll('"', '\\"')}`).join('" "')}"`;
+				}
+
+				that._onDidRequestShellExecution.fire(commandLineValue);
 				// Fire the event in a microtask to allow the extension to use the execution before
 				// the start event fires
+				const commandLine: vscode.TerminalShellExecutionCommandLine = {
+					value: commandLineValue,
+					confidence: TerminalShellExecutionCommandLineConfidence.High,
+					isTrusted: true
+				};
 				const execution = that.startShellExecution(commandLine, that._cwd, true).value;
 				that._ignoreNextExecution = true;
 				return execution;
 			}
 		};
 	}
 
-	startShellExecution(commandLine: string, cwd: URI | undefined, fireEventInMicrotask?: boolean): InternalTerminalShellExecution {
+	startShellExecution(commandLine: vscode.TerminalShellExecutionCommandLine, cwd: URI | undefined, fireEventInMicrotask?: boolean): InternalTerminalShellExecution {
 		if (this._ignoreNextExecution && this._currentExecution) {
 			this._ignoreNextExecution = false;
 		} else {
 			if (this._currentExecution) {
-				this._currentExecution.endExecution(undefined, undefined);
-				this._onDidRequestEndExecution.fire({ execution: this._currentExecution.value, exitCode: undefined });
+				this._currentExecution.endExecution(undefined);
+				this._onDidRequestEndExecution.fire({ terminal: this._terminal, shellIntegration: this.value, execution: this._currentExecution.value, exitCode: undefined });
 			}
-			const currentExecution = this._currentExecution = new InternalTerminalShellExecution(this._terminal, commandLine, cwd);
+			const currentExecution = this._currentExecution = new InternalTerminalShellExecution(commandLine, cwd);
 			if (fireEventInMicrotask) {
-				queueMicrotask(() => this._onDidStartTerminalShellExecution.fire(currentExecution.value));
+				queueMicrotask(() => this._onDidStartTerminalShellExecution.fire({ terminal: this._terminal, shellIntegration: this.value, execution: currentExecution.value }));
 			} else {
-				this._onDidStartTerminalShellExecution.fire(this._currentExecution.value);
+				this._onDidStartTerminalShellExecution.fire({ terminal: this._terminal, shellIntegration: this.value, execution: this._currentExecution.value });
 			}
 		}
 		return this._currentExecution;
@@ -193,10 +216,10 @@ class InternalTerminalShellIntegration extends Disposable {
 		this.currentExecution?.emitData(data);
 	}
 
-	endShellExecution(commandLine: string | undefined, exitCode: number | undefined): void {
+	endShellExecution(commandLine: vscode.TerminalShellExecutionCommandLine | undefined, exitCode: number | undefined): void {
 		if (this._currentExecution) {
-			this._currentExecution.endExecution(commandLine, exitCode);
-			this._onDidRequestEndExecution.fire({ execution: this._currentExecution.value, exitCode });
+			this._currentExecution.endExecution(commandLine);
+			this._onDidRequestEndExecution.fire({ terminal: this._terminal, shellIntegration: this.value, execution: this._currentExecution.value, exitCode });
 			this._currentExecution = undefined;
 		}
 	}
@@ -223,16 +246,12 @@ class InternalTerminalShellExecution {
 	readonly value: vscode.TerminalShellExecution;
 
 	constructor(
-		readonly terminal: vscode.Terminal,
-		private _commandLine: string | undefined,
+		private _commandLine: vscode.TerminalShellExecutionCommandLine,
 		readonly cwd: URI | undefined,
 	) {
 		const that = this;
 		this.value = {
-			get terminal(): vscode.Terminal {
-				return that.terminal;
-			},
-			get commandLine(): string | undefined {
+			get commandLine(): vscode.TerminalShellExecutionCommandLine {
 				return that._commandLine;
 			},
 			get cwd(): URI | undefined {
@@ -258,7 +277,7 @@ class InternalTerminalShellExecution {
 		this._dataStream?.emitData(data);
 	}
 
-	endExecution(commandLine: string | undefined, exitCode: number | undefined): void {
+	endExecution(commandLine: vscode.TerminalShellExecutionCommandLine | undefined): void {
 		if (commandLine) {
 			this._commandLine = commandLine;
 		}