Shell integration foundation

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

@@ -370,6 +370,13 @@ export interface IHeartbeatService {
 	readonly onBeat: Event<void>;
 }
 
+export interface TerminalCommand {
+	command: string;
+	timestamp: number;
+	cwd?: string;
+	exitCode?: number;
+}
+
 export interface IShellLaunchConfig {
 	/**
 	 * The name of the terminal, if this is not set the name of the process will be used.
@@ -548,7 +555,8 @@ export interface IProcessReadyEvent {
 }
 
 export const enum ProcessCapability {
-	CwdDetection = 'cwdDetection'
+	CwdDetection = 'cwdDetection',
+	CommandCognisant = 'commandCognisant'
 }
 
 /**

src/vs/platform/terminal/node/ptyService.ts

@@ -724,6 +724,7 @@ export class PersistentTerminalProcess extends Disposable {
 class XtermSerializer implements ITerminalSerializer {
 	private _xterm: XtermTerminal;
 	private _unicodeAddon?: XtermUnicode11Addon;
+	private _isShellIntegrationEnabled: boolean = false;
 
 	constructor(
 		cols: number,
@@ -735,10 +736,23 @@ class XtermSerializer implements ITerminalSerializer {
 		this._xterm = new XtermTerminal({ cols, rows, scrollback });
 		if (reviveBuffer) {
 			this._xterm.writeln(reviveBuffer);
+			if (this._isShellIntegrationEnabled) {
+				this._xterm.write('\x1b033]133;E\x1b007');
+			}
 		}
+		this._xterm.parser.registerOscHandler(133, (data => this._handleShellIntegration(data)));
 		this.setUnicodeVersion(unicodeVersion);
 	}
 
+	private _handleShellIntegration(data: string): boolean {
+		const [command,] = data.split(';');
+		if (command === 'E') {
+			this._isShellIntegrationEnabled = true;
+			return true;
+		}
+		return false;
+	}
+
 	handleData(data: string): void {
 		this._xterm.write(data);
 	}

src/vs/workbench/contrib/terminal/browser/terminal.ts

@@ -793,6 +793,12 @@ export interface ITerminalInstance {
 	 * clipboard.
 	 */
 	showLinkQuickpick(): Promise<void>;
+
+	/**
+	 * Triggers a quick pick that displays recent commands or cwds. Selecting one will
+	 * re-run it in the active terminal.
+	 */
+	runRecent(type: 'command' | 'cwd'): Promise<void>;
 }
 
 export interface IXtermTerminal {
@@ -839,6 +845,11 @@ export interface IXtermTerminal {
 	 * viewport.
 	 */
 	clearBuffer(): void;
+
+	/*
+	 * When process capabilites are updated, update the command tracker
+	 */
+	upgradeCommandTracker(): void;
 }
 
 export interface IRequestAddInstanceToGroupEvent {

src/vs/workbench/contrib/terminal/browser/terminalActions.ts

@@ -300,6 +300,34 @@ export function registerTerminalActions() {
 			await terminalGroupService.showPanel(true);
 		}
 	});
+	registerAction2(class extends Action2 {
+		constructor() {
+			super({
+				id: TerminalCommandId.RunRecentCommand,
+				title: { value: localize('workbench.action.terminal.runRecentCommand', "Run Recent Command"), original: 'Run Recent Command' },
+				f1: true,
+				category,
+				precondition: ContextKeyExpr.or(TerminalContextKeys.processSupported, TerminalContextKeys.terminalHasBeenCreated)
+			});
+		}
+		async run(accessor: ServicesAccessor): Promise<void> {
+			await accessor.get(ITerminalService).activeInstance?.runRecent('command');
+		}
+	});
+	registerAction2(class extends Action2 {
+		constructor() {
+			super({
+				id: TerminalCommandId.GoToRecentDirectory,
+				title: { value: localize('workbench.action.terminal.goToRecentDirectory', "Go to Recent Directory"), original: 'Go to Recent Directory' },
+				f1: true,
+				category,
+				precondition: ContextKeyExpr.or(TerminalContextKeys.processSupported, TerminalContextKeys.terminalHasBeenCreated)
+			});
+		}
+		async run(accessor: ServicesAccessor): Promise<void> {
+			await accessor.get(ITerminalService).activeInstance?.runRecent('cwd');
+		}
+	});
 	registerAction2(class extends Action2 {
 		constructor() {
 			super({

src/vs/workbench/contrib/terminal/browser/terminalInstance.ts

@@ -68,6 +68,7 @@ import { escapeNonWindowsPath } from 'vs/platform/terminal/common/terminalEnviro
 import { IWorkspaceTrustRequestService } from 'vs/platform/workspace/common/workspaceTrust';
 import { isFirefox } from 'vs/base/browser/browser';
 import { TerminalLinkQuickpick } from 'vs/workbench/contrib/terminal/browser/links/terminalLinkQuickpick';
+import { fromNow } from 'vs/base/common/date';
 
 const enum Constants {
 	/**
@@ -697,6 +698,52 @@ export class TerminalInstance extends Disposable implements ITerminalInstance {
 		return { wordLinks: wordResults, webLinks: webResults, fileLinks: fileResults };
 	}
 
+	async runRecent(type: 'command' | 'cwd'): Promise<void> {
+		const commands = this.xterm?.commandTracker.commands;
+		if (!commands || !this.xterm) {
+			return;
+		}
+		type Item = IQuickPickItem;
+		const items: Item[] = [];
+		if (type === 'command') {
+			for (const { command, timestamp, cwd, exitCode } of commands) {
+				// trim off any whitespace and/or line endings
+				const label = command.trim();
+				if (label.length === 0) {
+					continue;
+				}
+				let description = '';
+				if (cwd) {
+					description += `cwd: ${cwd} `;
+				}
+				if (exitCode) {
+					// Since you cannot get the last command's exit code on pwsh, just whether it failed
+					// or not, -1 is treated specially as simply failed
+					if (exitCode === -1) {
+						description += 'failed';
+					} else {
+						description += `exitCode: ${exitCode}`;
+					}
+				}
+				items.push({
+					label,
+					description: description.trim(),
+					detail: fromNow(timestamp, true),
+					id: timestamp.toString()
+				});
+			}
+		} else {
+			const cwds = this.xterm.commandTracker.cwds;
+			for (const label of cwds) {
+				items.push({ label });
+			}
+		}
+		const result = await this._quickInputService.pick(items.reverse(), {});
+		if (result) {
+			this.sendText(type === 'cwd' ? `cd ${result.label}` : result.label, true);
+		}
+	}
+
 	detachFromElement(): void {
 		this._wrapperElement?.remove();
 		this._container = undefined;

src/vs/workbench/contrib/terminal/browser/xterm/cognisantCommandTrackerAddon.ts

@@ -0,0 +1,139 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import type { Terminal, IMarker } from 'xterm';
+import { TerminalCommand } from 'vs/platform/terminal/common/terminal';
+import { Emitter } from 'vs/base/common/event';
+import { CommandTrackerAddon } from 'vs/workbench/contrib/terminal/browser/xterm/commandTrackerAddon';
+import { ILogService } from 'vs/platform/log/common/log';
+import { ShellIntegrationInfo, ShellIntegrationInteraction } from 'vs/workbench/contrib/terminal/browser/xterm/shellIntegrationAddon';
+
+interface ICurrentPartialCommand {
+	marker?: IMarker;
+	previousCommandMarker?: IMarker;
+	promptStartY?: number;
+	commandStartY?: number;
+	commandStartX?: number;
+	commandExecutedY?: number;
+	commandFinishedY?: number;
+	command?: string;
+}
+
+export class CognisantCommandTrackerAddon extends CommandTrackerAddon {
+	private _commands: TerminalCommand[] = [];
+	private _cwds = new Map<string, number>();
+	private _exitCode: number | undefined;
+	private _cwd: string | undefined;
+	private _currentCommand: ICurrentPartialCommand = {};
+
+	protected _terminal: Terminal | undefined;
+
+	private readonly _onCwdChanged = new Emitter<string>();
+	readonly onCwdChanged = this._onCwdChanged.event;
+
+	constructor(
+		@ILogService private readonly _logService: ILogService
+	) {
+		super();
+	}
+
+	activate(terminal: Terminal): void {
+		this._terminal = terminal;
+	}
+
+	handleIntegratedShellChange(event: { type: string, value: string }): void {
+		if (!this._terminal) {
+			return;
+		}
+		switch (event.type) {
+			case ShellIntegrationInfo.CurrentDir: {
+				this._cwd = event.value;
+				const freq = this._cwds.get(this._cwd) || 0;
+				this._cwds.set(this._cwd, freq + 1);
+				this._onCwdChanged.fire(this._cwd);
+				break;
+			}
+			case ShellIntegrationInteraction.PromptStart:
+				this._currentCommand.promptStartY = this._terminal.buffer.active.baseY + this._terminal.buffer.active.cursorY;
+				break;
+			case ShellIntegrationInteraction.CommandStart:
+				this._currentCommand.commandStartX = this._terminal.buffer.active.cursorX;
+				this._currentCommand.commandStartY = this._terminal.buffer.active.baseY + this._terminal.buffer.active.cursorY;
+				this._currentCommand.marker = this._terminal.registerMarker(0);
+				break;
+			case ShellIntegrationInteraction.CommandExecuted:
+				this._currentCommand.commandExecutedY = this._terminal.buffer.active.baseY + this._terminal.buffer.active.cursorY;
+
+				// TODO: Leverage key events on Windows between CommandStart and Executed to ensure we have the correct line
+
+				// TODO: Only do this on Windows backends
+				// Check if the command line is the same as the previous command line or if the
+				// start Y differs from the executed Y. This is to catch the conpty case where the
+				// "rendering" of the shell integration sequences doesn't occur on the correct cell
+				// due to https://github.com/microsoft/terminal/issues/11220
+				if (this._currentCommand.previousCommandMarker?.line === this._currentCommand.marker?.line ||
+					this._currentCommand.commandStartY === this._currentCommand.commandExecutedY) {
+					this._currentCommand.marker = this._terminal?.registerMarker(0);
+					this._currentCommand.commandStartX = 0;
+				}
+
+				// TODO: This does not yet work when the prompt line is wrapped
+				this._currentCommand.command = this._terminal!.buffer.active.getLine(this._currentCommand.commandExecutedY)?.translateToString(true, this._currentCommand.commandStartX || 0);
+
+				// TODO: Only do this on Windows backends
+				// Something went wrong, try predict the prompt based on the shell.
+				if (this._currentCommand.commandStartX === 0) {
+					// TODO: Only do this on pwsh
+					const promptPredictions = [
+						`PS ${this._cwd}> `,
+						`PS>`,
+					];
+					for (const promptPrediction of promptPredictions) {
+						if (this._currentCommand.command?.startsWith(promptPrediction)) {
+							// TODO: Consider cell vs string positioning; test CJK
+							this._currentCommand.commandStartX = promptPrediction.length;
+							this._currentCommand.command = this._currentCommand.command.substring(this._currentCommand.commandStartX);
+							break;
+						}
+					}
+				}
+				break;
+			case ShellIntegrationInteraction.CommandFinished:
+				this._logService.trace('Terminal Command Finished', this._currentCommand.command);
+				this._exitCode = Number.parseInt(event.value);
+				if (!this._currentCommand.marker?.line || !this._terminal.buffer.active) {
+					break;
+				}
+				if (this._currentCommand.command && !this._currentCommand.command.startsWith('\\') && this._currentCommand.command !== '') {
+					this._commands.push({
+						command: this._currentCommand.command,
+						timestamp: Date.now(),
+						cwd: this._cwd,
+						exitCode: this._exitCode
+					});
+				}
+
+				this._currentCommand.previousCommandMarker?.dispose();
+				this._currentCommand.previousCommandMarker = this._currentCommand.marker;
+				this._currentCommand.marker = undefined;
+				break;
+			default:
+				return;
+		}
+	}
+
+	get commands(): TerminalCommand[] {
+		return this._commands;
+	}
+
+	get cwds(): string[] {
+		const cwds = [];
+		const sorted = new Map([...this._cwds.entries()].sort((a, b) => b[1] - a[1]));
+		for (const [key,] of sorted.entries()) {
+			cwds.push(key);
+		}
+		return cwds;
+	}
+}