@codingame/monaco-vscode-chat-service-override 33.0.9 → 34.0.1

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/executeStrategy/executeStrategy.js

@@ -0,0 +1,225 @@
+
+import { DeferredPromise, RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+
+async function waitForIdle(onData, idleDurationMs) {
+    const store = ( new DisposableStore());
+    const deferred = ( new DeferredPromise());
+    const scheduler = store.add(( new RunOnceScheduler(() => deferred.complete(), idleDurationMs)));
+    store.add(onData(() => scheduler.schedule()));
+    scheduler.schedule();
+    return deferred.p.finally(() => store.dispose());
+}
+function detectsCommonPromptPattern(cursorLine) {
+    if (cursorLine.trim().length === 0) {
+        return {
+            detected: false,
+            reason: "Content is empty or contains only whitespace"
+        };
+    }
+    if (/PS\s+[A-Z]:\\.*>\s*$/.test(cursorLine)) {
+        return {
+            detected: true,
+            reason: `PowerShell prompt pattern detected: "${cursorLine}"`
+        };
+    }
+    if (/^[A-Z]:\\.*>\s*$/.test(cursorLine)) {
+        return {
+            detected: true,
+            reason: `Command Prompt pattern detected: "${cursorLine}"`
+        };
+    }
+    if (/\$\s*$/.test(cursorLine)) {
+        return {
+            detected: true,
+            reason: `Bash-style prompt pattern detected: "${cursorLine}"`
+        };
+    }
+    if (/#\s*$/.test(cursorLine)) {
+        return {
+            detected: true,
+            reason: `Root prompt pattern detected: "${cursorLine}"`
+        };
+    }
+    if (/^>>>\s*$/.test(cursorLine)) {
+        return {
+            detected: true,
+            reason: `Python REPL prompt pattern detected: "${cursorLine}"`
+        };
+    }
+    if (/\u276f\s*$/.test(cursorLine)) {
+        return {
+            detected: true,
+            reason: `Starship prompt pattern detected: "${cursorLine}"`
+        };
+    }
+    if (/[>%]\s*$/.test(cursorLine)) {
+        return {
+            detected: true,
+            reason: `Generic prompt pattern detected: "${cursorLine}"`
+        };
+    }
+    return {
+        detected: false,
+        reason: `No common prompt pattern found in last line: "${cursorLine}"`
+    };
+}
+async function waitForIdleWithPromptHeuristics(onData, instance, idlePollIntervalMs, extendedTimeoutMs) {
+    await waitForIdle(onData, idlePollIntervalMs);
+    const xterm = await instance.xtermReadyPromise;
+    if (!xterm) {
+        return {
+            detected: false,
+            reason: `Xterm not available, using ${idlePollIntervalMs}ms timeout`
+        };
+    }
+    const startTime = Date.now();
+    while (Date.now() - startTime < extendedTimeoutMs) {
+        try {
+            let content = "";
+            const buffer = xterm.raw.buffer.active;
+            const line = buffer.getLine(buffer.baseY + buffer.cursorY);
+            if (line) {
+                content = line.translateToString(true);
+            }
+            const promptResult = detectsCommonPromptPattern(content);
+            if (promptResult.detected) {
+                return promptResult;
+            }
+        } catch (error) {}
+        await waitForIdle(
+            onData,
+            Math.min(idlePollIntervalMs, extendedTimeoutMs - (Date.now() - startTime))
+        );
+    }
+    try {
+        let content = "";
+        const buffer = xterm.raw.buffer.active;
+        const line = buffer.getLine(buffer.baseY + buffer.cursorY);
+        if (line) {
+            content = line.translateToString(true) + "\n";
+        }
+        return {
+            detected: false,
+            reason: `Extended timeout reached without prompt detection. Last line: "${content.trim()}"`
+        };
+    } catch (error) {
+        return {
+            detected: false,
+            reason: `Extended timeout reached. Error reading terminal content: ${error}`
+        };
+    }
+}
+async function trackIdleOnPrompt(instance, idleDurationMs, store, promptFallbackMs, logService, options) {
+    const idleOnPrompt = ( new DeferredPromise());
+    const onData = instance.onData;
+    const log = logService ? msg => logService.info(`trackIdleOnPrompt: ${msg}`) : undefined;
+    let TerminalState;
+    (function(TerminalState) {
+        TerminalState[TerminalState["Initial"] = 0] = "Initial";
+        TerminalState[TerminalState["Prompt"] = 1] = "Prompt";
+        TerminalState[TerminalState["Executing"] = 2] = "Executing";
+        TerminalState[TerminalState["PromptAfterExecuting"] = 3] = "PromptAfterExecuting";
+    })(TerminalState || (TerminalState = {}));
+    const stateNames = {
+        [0 ]: "Initial",
+        [1 ]: "Prompt",
+        [2 ]: "Executing",
+        [3 ]: "PromptAfterExecuting"
+    };
+    let state = 0 ;
+    let dataEventCount = 0;
+    function setState(newState, reason) {
+        if (state !== newState) {
+            log?.(`State ${stateNames[state]} → ${stateNames[newState]} (${reason})`);
+            state = newState;
+        }
+    }
+    const scheduler = store.add(( new RunOnceScheduler(() => {
+        log?.(`Idle scheduler fired, completing (dataEvents=${dataEventCount})`);
+        idleOnPrompt.complete();
+    }, idleDurationMs)));
+    const promptFallbackScheduler = store.add(( new RunOnceScheduler(() => {
+        if (state === 2  || state === 3 ) {
+            promptFallbackScheduler.cancel();
+            return;
+        }
+        log?.(`Prompt fallback fired (dataEvents=${dataEventCount})`);
+        setState(3, "promptFallback");
+        scheduler.schedule();
+    }, promptFallbackMs ?? 1000)));
+    const disableFallbacks = options?.disableFallbacks ?? false;
+    const initialFallbackScheduler = store.add(( new RunOnceScheduler(() => {
+        if (state === 2  || state === 3 ) {
+            log?.(`Initial fallback fired but state is ${stateNames[state]}, skipping`);
+            return;
+        }
+        log?.(`Initial fallback fired, no data events received`);
+        setState(3, "initialFallback");
+        scheduler.schedule();
+    }, 10_000)));
+    if (!disableFallbacks) {
+        initialFallbackScheduler.schedule();
+    }
+    const executingFallbackScheduler = store.add(( new RunOnceScheduler(() => {
+        if (state === 2 ) {
+            log?.(
+                `Executing fallback fired after 30s data-idle (dataEvents=${dataEventCount})`
+            );
+            setState(3, "executingFallback");
+            scheduler.schedule();
+        }
+    }, 30_000)));
+    const hardCapScheduler = store.add(( new RunOnceScheduler(() => {
+        if (state === 0  || state === 1 ) {
+            log?.(
+                `Hard cap fired after 5min in state ${stateNames[state]} (dataEvents=${dataEventCount})`
+            );
+            setState(3, "hardCap");
+            scheduler.schedule();
+        }
+    }, 60_000)));
+    if (!disableFallbacks) {
+        hardCapScheduler.schedule();
+    }
+    store.add(onData(e => {
+        dataEventCount++;
+        initialFallbackScheduler.cancel();
+        const matches = e.matchAll(/(?:\x1b\]|\x9d)[16]33;(?<type>[ACD])(?:;.*)?(?:\x1b\\|\x07|\x9c)/g);
+        for (const match of matches) {
+            if (match.groups?.type === "A") {
+                if (state === 0 ) {
+                    setState(1, "sequence A");
+                } else if (state === 2 ) {
+                    setState(3, "sequence A after executing");
+                    executingFallbackScheduler.cancel();
+                }
+            } else if (match.groups?.type === "C" || match.groups?.type === "D") {
+                setState(2, `sequence ${match.groups?.type}`);
+                if (!disableFallbacks) {
+                    executingFallbackScheduler.schedule();
+                }
+            }
+        }
+        if (state === 3 ) {
+            promptFallbackScheduler.cancel();
+            executingFallbackScheduler.cancel();
+            scheduler.schedule();
+        } else {
+            scheduler.cancel();
+            if (state === 0  || state === 1 ) {
+                if (!disableFallbacks) {
+                    promptFallbackScheduler.schedule();
+                }
+            } else {
+                promptFallbackScheduler.cancel();
+                if (!disableFallbacks) {
+                    executingFallbackScheduler.schedule();
+                }
+            }
+        }
+    }));
+    return idleOnPrompt.p;
+}
+
+export { detectsCommonPromptPattern, trackIdleOnPrompt, waitForIdle, waitForIdleWithPromptHeuristics };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/executeStrategy/noneExecuteStrategy.d.ts

@@ -0,0 +1,27 @@
+import type { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { ITerminalLogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service";
+import { type ITerminalExecuteStrategy, type ITerminalExecuteStrategyResult } from "./executeStrategy.js";
+import type { IMarker as IXtermMarker } from "@xterm/xterm";
+import { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+/**
+ * This strategy is used when no shell integration is available. There are very few extension APIs
+ * available in this case. This uses similar strategies to the basic integration strategy, but
+ * with `sendText` instead of `shellIntegration.executeCommand` and relying on idle events instead
+ * of execution events.
+ */
+export declare class NoneExecuteStrategy extends Disposable implements ITerminalExecuteStrategy {
+    private readonly _instance;
+    private readonly _hasReceivedUserInput;
+    private readonly _configurationService;
+    private readonly _logService;
+    readonly type = "none";
+    private readonly _startMarker;
+    private readonly _onDidCreateStartMarker;
+    onDidCreateStartMarker: Event<IXtermMarker | undefined>;
+    constructor(_instance: ITerminalInstance, _hasReceivedUserInput: () => boolean, _configurationService: IConfigurationService, _logService: ITerminalLogService);
+    execute(commandLine: string, token: CancellationToken, _commandId?: string, _commandLineForMetadata?: string): Promise<ITerminalExecuteStrategyResult>;
+    private _log;
+}

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/executeStrategy/noneExecuteStrategy.js

@@ -0,0 +1,143 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
+import { waitForIdle, waitForIdleWithPromptHeuristics } from './executeStrategy.js';
+import { createAltBufferPromise, setupRecreatingStartMarker, stripCommandEchoAndPrompt } from './strategyHelpers.js';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
+import { isMacintosh } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { isMultilineCommand } from '../runInTerminalHelpers.js';
+
+let NoneExecuteStrategy = class NoneExecuteStrategy extends Disposable {
+    constructor(_instance, _hasReceivedUserInput, _configurationService, _logService) {
+        super();
+        this._instance = _instance;
+        this._hasReceivedUserInput = _hasReceivedUserInput;
+        this._configurationService = _configurationService;
+        this._logService = _logService;
+        this.type = "none";
+        this._startMarker = this._register(( new MutableDisposable()));
+        this._onDidCreateStartMarker = this._register(( new Emitter()));
+        this.onDidCreateStartMarker = this._onDidCreateStartMarker.event;
+    }
+    async execute(commandLine, token, _commandId, _commandLineForMetadata) {
+        const store = ( new DisposableStore());
+        try {
+            if (token.isCancellationRequested) {
+                throw ( new CancellationError());
+            }
+            this._log("Waiting for xterm");
+            const xterm = await this._instance.xtermReadyPromise;
+            if (!xterm) {
+                throw ( new Error("Xterm is not available"));
+            }
+            const alternateBufferPromise = createAltBufferPromise(xterm, store, this._log.bind(this));
+            const idlePollInterval = this._configurationService.getValue(TerminalChatAgentToolsSettingId.IdlePollInterval) ?? 1000;
+            this._log("Waiting for idle");
+            await waitForIdle(this._instance.onData, idlePollInterval);
+            if (token.isCancellationRequested) {
+                throw ( new CancellationError());
+            }
+            const markerRecreation = setupRecreatingStartMarker(
+                xterm,
+                this._startMarker,
+                m => this._onDidCreateStartMarker.fire(m),
+                store,
+                this._log.bind(this)
+            );
+            if (this._hasReceivedUserInput()) {
+                this._log("Sending Ctrl+U to clear any pending input before sending command");
+                await this._instance.sendText("\u0015", false);
+                await waitForIdle(this._instance.onData, 100);
+            }
+            this._log(`Executing command line \`${commandLine}\``);
+            markerRecreation.dispose();
+            const startLine = this._startMarker.value?.line;
+            const forceBracketedPasteMode = isMacintosh || isMultilineCommand(commandLine);
+            this._instance.sendText(commandLine, true, forceBracketedPasteMode);
+            if (startLine !== undefined) {
+                this._log("Waiting for cursor to move past start line");
+                const cursorMovedPromise = ( new Promise(resolve => {
+                    const check = () => {
+                        const buffer = xterm.raw.buffer.active;
+                        const cursorLine = buffer.baseY + buffer.cursorY;
+                        if (cursorLine > startLine) {
+                            resolve();
+                        }
+                    };
+                    const listener = this._instance.onData(() => check());
+                    store.add(listener);
+                    check();
+                }));
+                const cursorMoveTimeout = ( new Promise(resolve => {
+                    const handle = setTimeout(() => resolve("timeout"), 1000);
+                    store.add({
+                        dispose: () => clearTimeout(handle)
+                    });
+                }));
+                const raceResult = await Promise.race([cursorMovedPromise, cursorMoveTimeout]);
+                if (raceResult === "timeout") {
+                    this._log(
+                        "Cursor did not move past start line before timeout, proceeding with idle detection"
+                    );
+                }
+            }
+            this._log("Waiting for idle with prompt heuristics");
+            const promptResultOrAltBuffer = await Promise.race([waitForIdleWithPromptHeuristics(
+                this._instance.onData,
+                this._instance,
+                idlePollInterval,
+                idlePollInterval * 10
+            ), alternateBufferPromise.then(() => "alternateBuffer")]);
+            if (promptResultOrAltBuffer === "alternateBuffer") {
+                this._log("Detected alternate buffer entry, skipping output capture");
+                return {
+                    output: undefined,
+                    additionalInformation: undefined,
+                    exitCode: undefined,
+                    error: "alternateBuffer",
+                    didEnterAltBuffer: true
+                };
+            }
+            const promptResult = promptResultOrAltBuffer;
+            this._log(
+                `Prompt detection result: ${promptResult.detected ? "detected" : "not detected"} - ${promptResult.reason}`
+            );
+            if (token.isCancellationRequested) {
+                throw ( new CancellationError());
+            }
+            const endMarker = store.add(xterm.raw.registerMarker());
+            let output;
+            const additionalInformationLines = [];
+            try {
+                output = xterm.getContentsAsText(this._startMarker.value, endMarker);
+                this._log("Fetched output via markers");
+                if (output !== undefined) {
+                    output = stripCommandEchoAndPrompt(output, commandLine, this._log.bind(this));
+                }
+            } catch {
+                this._log("Failed to fetch output via markers");
+                additionalInformationLines.push("Failed to retrieve command output");
+            }
+            if (output !== undefined && output.trim().length === 0) {
+                additionalInformationLines.push("Command produced no output");
+            }
+            return {
+                output,
+                additionalInformation: additionalInformationLines.length > 0 ? additionalInformationLines.join("\n") : undefined,
+                exitCode: undefined
+            };
+        } finally {
+            store.dispose();
+        }
+    }
+    _log(message) {
+        this._logService.debug(`RunInTerminalTool#None: ${message}`);
+    }
+};
+NoneExecuteStrategy = ( __decorate([( __param(2, IConfigurationService)), ( __param(3, ITerminalLogService))], NoneExecuteStrategy));
+
+export { NoneExecuteStrategy };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/executeStrategy/richExecuteStrategy.d.ts

@@ -0,0 +1,37 @@
+import type { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import type { ICommandDetectionCapability } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities";
+import { ITerminalLogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service";
+import type { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import { type ITerminalExecuteStrategy, type ITerminalExecuteStrategyResult } from "./executeStrategy.js";
+import type { IMarker as IXtermMarker } from "@xterm/xterm";
+/**
+ * This strategy is used when the terminal has rich shell integration/command detection is
+ * available, meaning every sequence we rely upon should be exactly where we expect it to be. In
+ * particular (`633;`) `A, B, E, C, D` all happen in exactly that order. While things still could go
+ * wrong in this state, minimal verification is done in this mode since rich command detection is a
+ * strong signal that it's behaving correctly.
+ */
+export declare class RichExecuteStrategy extends Disposable implements ITerminalExecuteStrategy {
+    private readonly _instance;
+    private readonly _commandDetection;
+    private readonly _isSyncMode;
+    private readonly _configurationService;
+    private readonly _logService;
+    readonly type = "rich";
+    private readonly _startMarker;
+    private readonly _onDidCreateStartMarker;
+    onDidCreateStartMarker: Event<IXtermMarker | undefined>;
+    /**
+     * Tracks per-execute() DisposableStores so they can be cleaned up if the
+     * strategy is disposed mid-flight, AND removed from this collection on
+     * successful completion to avoid accumulating stale references when
+     * execute() is invoked many times on the same strategy instance.
+     */
+    private readonly _executionStores;
+    constructor(_instance: ITerminalInstance, _commandDetection: ICommandDetectionCapability, _isSyncMode: boolean, _configurationService: IConfigurationService, _logService: ITerminalLogService);
+    execute(commandLine: string, token: CancellationToken, commandId?: string, commandLineForMetadata?: string): Promise<ITerminalExecuteStrategyResult>;
+    private _log;
+}

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/executeStrategy/richExecuteStrategy.js

@@ -0,0 +1,205 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isNumber } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { isMacintosh, isCI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
+import { trackIdleOnPrompt } from './executeStrategy.js';
+import { createAltBufferPromise, setupRecreatingStartMarker, stripCommandEchoAndPrompt } from './strategyHelpers.js';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
+import { isMultilineCommand } from '../runInTerminalHelpers.js';
+
+function isTerminalLaunchError(value) {
+    return typeof value === "object" && value !== null && "message" in value;
+}
+function formatExitCodeOrError(exitCodeOrError) {
+    if (isTerminalLaunchError(exitCodeOrError)) {
+        return `launch error: ${exitCodeOrError.message}${exitCodeOrError.code !== undefined ? `, code=${exitCodeOrError.code}` : ""}`;
+    }
+    return `code=${exitCodeOrError}`;
+}
+function extractExitCode(exitCodeOrError) {
+    if (isNumber(exitCodeOrError)) {
+        return exitCodeOrError;
+    }
+    if (isTerminalLaunchError(exitCodeOrError)) {
+        return exitCodeOrError.code;
+    }
+    return undefined;
+}
+let RichExecuteStrategy = class RichExecuteStrategy extends Disposable {
+    constructor(
+        _instance,
+        _commandDetection,
+        _isSyncMode,
+        _configurationService,
+        _logService
+    ) {
+        super();
+        this._instance = _instance;
+        this._commandDetection = _commandDetection;
+        this._isSyncMode = _isSyncMode;
+        this._configurationService = _configurationService;
+        this._logService = _logService;
+        this.type = "rich";
+        this._startMarker = this._register(( new MutableDisposable()));
+        this._onDidCreateStartMarker = this._register(( new Emitter()));
+        this.onDidCreateStartMarker = this._onDidCreateStartMarker.event;
+        this._executionStores = this._register(( new DisposableStore()));
+    }
+    async execute(commandLine, token, commandId, commandLineForMetadata) {
+        const store = ( new DisposableStore());
+        this._executionStores.add(store);
+        try {
+            if (this._instance.isDisposed) {
+                this._log("Terminal already disposed at strategy entry");
+                throw ( new Error("The terminal was closed"));
+            }
+            if (this._instance.exitCode !== undefined) {
+                this._log(
+                    `Terminal pty already exited at strategy entry (code=${this._instance.exitCode})`
+                );
+                return {
+                    output: undefined,
+                    exitCode: this._instance.exitCode,
+                    additionalInformation: `Command exited with code ${this._instance.exitCode}`
+                };
+            }
+            const idlePollInterval = this._configurationService.getValue(TerminalChatAgentToolsSettingId.IdlePollInterval) ?? 1000;
+            const staleMarker = this._commandDetection.executingCommandObject?.marker;
+            const onCommandFinishedFiltered = staleMarker ? Event.filter(
+                this._commandDetection.onCommandFinished,
+                e => e.marker !== staleMarker,
+                store
+            ) : this._commandDetection.onCommandFinished;
+            const onDone = Promise.race([Event.toPromise(onCommandFinishedFiltered, store).then(e => {
+                this._log("onDone via end event");
+                return {
+                    "type": "success",
+                    command: e
+                };
+            }), Event.toPromise(token.onCancellationRequested, store).then(() => {
+                this._log("onDone via cancellation");
+            }), Event.toPromise(this._instance.onDisposed, store).then(() => {
+                this._log("onDone via terminal disposal");
+                return {
+                    type: "disposal"
+                };
+            }), Event.toPromise(this._instance.onExit, store).then(exitCodeOrError => {
+                this._log(`onDone via process exit (${formatExitCodeOrError(exitCodeOrError)})`);
+                return {
+                    type: "processExit",
+                    exitCodeOrError
+                };
+            }),
+            ...(this._isSyncMode ? [trackIdleOnPrompt(
+                this._instance,
+                idlePollInterval,
+                store,
+                idlePollInterval,
+                this._logService,
+                {
+                    disableFallbacks: true
+                }
+            ).then(() => {
+                this._log("onDone via idle prompt");
+            })] : [])]);
+            this._log("Waiting for xterm");
+            const xterm = await this._instance.xtermReadyPromise;
+            if (!xterm) {
+                throw ( new Error("Xterm is not available"));
+            }
+            const alternateBufferPromise = createAltBufferPromise(xterm, store, this._log.bind(this));
+            const markerRecreation = setupRecreatingStartMarker(
+                xterm,
+                this._startMarker,
+                m => this._onDidCreateStartMarker.fire(m),
+                store,
+                this._log.bind(this)
+            );
+            this._log(`Executing command line \`${commandLine}\``);
+            markerRecreation.dispose();
+            const forceBracketedPasteMode = isMacintosh || isMultilineCommand(commandLine);
+            this._instance.runCommand(
+                commandLine,
+                true,
+                commandId,
+                forceBracketedPasteMode,
+                commandLineForMetadata
+            );
+            this._log("Waiting for done event");
+            const onDoneResult = await Promise.race([onDone, alternateBufferPromise.then(() => ({
+                type: "alternateBuffer"
+            }))]);
+            if (onDoneResult && onDoneResult.type === "disposal") {
+                throw ( new Error("The terminal was closed"));
+            }
+            if (onDoneResult && onDoneResult.type === "alternateBuffer") {
+                this._log("Detected alternate buffer entry, skipping output capture");
+                return {
+                    output: undefined,
+                    exitCode: undefined,
+                    error: "alternateBuffer",
+                    didEnterAltBuffer: true
+                };
+            }
+            const finishedCommand = onDoneResult && onDoneResult.type === "success" ? onDoneResult.command : undefined;
+            if (token.isCancellationRequested) {
+                throw ( new CancellationError());
+            }
+            const endMarker = store.add(xterm.raw.registerMarker());
+            let output;
+            const additionalInformationLines = [];
+            if (finishedCommand) {
+                const commandOutput = finishedCommand?.getOutput();
+                if (commandOutput !== undefined) {
+                    this._log("Fetched output via finished command");
+                    output = stripCommandEchoAndPrompt(commandOutput, commandLine, this._log.bind(this));
+                }
+            }
+            if (output === undefined) {
+                try {
+                    output = xterm.getContentsAsText(this._startMarker.value, endMarker);
+                    this._log("Fetched output via markers");
+                    if (output !== undefined) {
+                        output = stripCommandEchoAndPrompt(output, commandLine, this._log.bind(this));
+                    }
+                } catch {
+                    this._log("Failed to fetch output via markers");
+                    additionalInformationLines.push("Failed to retrieve command output");
+                }
+            }
+            if (output !== undefined && output.trim().length === 0) {
+                additionalInformationLines.push("Command produced no output");
+            }
+            let exitCode = finishedCommand?.exitCode;
+            if (exitCode === undefined && onDoneResult && onDoneResult.type === "processExit") {
+                exitCode = extractExitCode(onDoneResult.exitCodeOrError);
+            }
+            if (isNumber(exitCode) && exitCode > 0) {
+                additionalInformationLines.push(`Command exited with code ${exitCode}`);
+            }
+            return {
+                output,
+                additionalInformation: additionalInformationLines.length > 0 ? additionalInformationLines.join("\n") : undefined,
+                exitCode
+            };
+        } finally {
+            this._executionStores.delete(store);
+        }
+    }
+    _log(message) {
+        const msg = `RunInTerminalTool#Rich: ${message}`;
+        if (isCI) {
+            this._logService.info(msg);
+        } else {
+            this._logService.debug(msg);
+        }
+    }
+};
+RichExecuteStrategy = ( __decorate([( __param(3, IConfigurationService)), ( __param(4, ITerminalLogService))], RichExecuteStrategy));
+
+export { RichExecuteStrategy };