@codingame/monaco-vscode-katex-common 30.0.1 → 31.0.0

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineRewriter/commandLinePwshChainOperatorRewriter.js

@@ -0,0 +1,33 @@
+
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isPowerShell } from '../../runInTerminalHelpers.js';
+
+class CommandLinePwshChainOperatorRewriter extends Disposable {
+    constructor(_treeSitterCommandParser) {
+        super();
+        this._treeSitterCommandParser = _treeSitterCommandParser;
+    }
+    async rewrite(options) {
+        if (isPowerShell(options.shell, options.os)) {
+            let doubleAmpersandCaptures;
+            try {
+                doubleAmpersandCaptures = await this._treeSitterCommandParser.extractPwshDoubleAmpersandChainOperators(options.commandLine);
+            }
+            catch {
+            }
+            if (doubleAmpersandCaptures && doubleAmpersandCaptures.length > 0) {
+                let rewritten = options.commandLine;
+                for (const capture of doubleAmpersandCaptures.reverse()) {
+                    rewritten = `${rewritten.substring(0, capture.node.startIndex)};${rewritten.substring(capture.node.endIndex)}`;
+                }
+                return {
+                    rewritten,
+                    reasoning: '&& re-written to ;'
+                };
+            }
+        }
+        return undefined;
+    }
+}
+
+export { CommandLinePwshChainOperatorRewriter };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineRewriter/commandLineRewriter.d.ts

@@ -0,0 +1,24 @@
+import type { MaybePromise } from "@codingame/monaco-vscode-api/vscode/vs/base/common/async";
+import type { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import type { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import type { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+export interface ICommandLineRewriter extends IDisposable {
+    rewrite(options: ICommandLineRewriterOptions): MaybePromise<ICommandLineRewriterResult | undefined>;
+}
+export interface ICommandLineRewriterOptions {
+    commandLine: string;
+    cwd: URI | undefined;
+    shell: string;
+    os: OperatingSystem;
+    isBackground?: boolean;
+    requestUnsandboxedExecution?: boolean;
+}
+export interface ICommandLineRewriterResult {
+    rewritten: string;
+    reasoning: string;
+    forDisplay?: string;
+    isSandboxWrapped?: boolean;
+    requiresUnsandboxConfirmation?: boolean;
+    blockedDomains?: string[];
+    deniedDomains?: string[];
+}

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineRewriter/commandLineSandboxRewriter.d.ts

@@ -0,0 +1,8 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ITerminalSandboxService } from "../../../common/terminalSandboxService.js";
+import type { ICommandLineRewriter, ICommandLineRewriterOptions, ICommandLineRewriterResult } from "./commandLineRewriter.js";
+export declare class CommandLineSandboxRewriter extends Disposable implements ICommandLineRewriter {
+    private readonly _sandboxService;
+    constructor(_sandboxService: ITerminalSandboxService);
+    rewrite(options: ICommandLineRewriterOptions): Promise<ICommandLineRewriterResult | undefined>;
+}

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineRewriter/commandLineSandboxRewriter.js

@@ -0,0 +1,32 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '../../../common/terminalSandboxService.js';
+import { TerminalSandboxPrerequisiteCheck } from '../../../../../../../platform/sandbox/common/terminalSandboxService.js';
+import { ITerminalSandboxService } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/terminalSandboxService.service';
+
+let CommandLineSandboxRewriter = class CommandLineSandboxRewriter extends Disposable {
+    constructor(_sandboxService) {
+        super();
+        this._sandboxService = _sandboxService;
+    }
+    async rewrite(options) {
+        const sandboxPrereqs = await this._sandboxService.checkForSandboxingPrereqs();
+        if (!sandboxPrereqs.enabled || sandboxPrereqs.failedCheck === TerminalSandboxPrerequisiteCheck.Config) {
+            return undefined;
+        }
+        const wrappedCommand = this._sandboxService.wrapCommand(options.commandLine, options.requestUnsandboxedExecution, options.shell);
+        return {
+            rewritten: wrappedCommand.command,
+            reasoning: wrappedCommand.requiresUnsandboxConfirmation ? "Switched command to unsandboxed execution because the command includes a domain that is not in the sandbox allowlist" : "Wrapped command for sandbox execution",
+            forDisplay: options.commandLine,
+            isSandboxWrapped: wrappedCommand.isSandboxWrapped,
+            requiresUnsandboxConfirmation: wrappedCommand.requiresUnsandboxConfirmation,
+            blockedDomains: wrappedCommand.blockedDomains,
+            deniedDomains: wrappedCommand.deniedDomains
+        };
+    }
+};
+CommandLineSandboxRewriter = ( __decorate([( __param(0, ITerminalSandboxService))], CommandLineSandboxRewriter));
+
+export { CommandLineSandboxRewriter };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/monitoring/outputMonitor.d.ts

@@ -0,0 +1,108 @@
+import { 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 { IToolInvocationContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
+import { ITaskService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/taskService.service";
+import { IExecution, IPollingResult, OutputMonitorState } from "./types.js";
+import { ITerminalLogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service";
+export interface IOutputMonitor extends Disposable {
+    readonly pollingResult: IPollingResult & {
+        pollDurationMs: number;
+    } | undefined;
+    readonly outputMonitorTelemetryCounters: IOutputMonitorTelemetryCounters;
+    readonly onDidFinishCommand: Event<void>;
+    readonly onDidDetectInputNeeded: Event<void>;
+}
+export interface IOutputMonitorTelemetryCounters {
+    inputToolManualAcceptCount: number;
+    inputToolManualRejectCount: number;
+    inputToolManualChars: number;
+    inputToolAutoAcceptCount: number;
+    inputToolAutoChars: number;
+    inputToolManualShownCount: number;
+    inputToolFreeFormInputShownCount: number;
+    inputToolFreeFormInputCount: number;
+}
+export declare class OutputMonitor extends Disposable implements IOutputMonitor {
+    private readonly _execution;
+    private readonly _pollFn;
+    private readonly _taskService;
+    private readonly _logService;
+    private _state;
+    get state(): OutputMonitorState;
+    private _formatLastLineForLog;
+    private _pollingResult;
+    get pollingResult(): IPollingResult & {
+        pollDurationMs: number;
+    } | undefined;
+    /**
+     * Flag to track if user has inputted since idle was detected.
+     * This is used to skip showing prompts if the user already provided input.
+     */
+    private _userInputtedSinceIdleDetected;
+    private readonly _userInputListener;
+    private readonly _outputMonitorTelemetryCounters;
+    get outputMonitorTelemetryCounters(): Readonly<IOutputMonitorTelemetryCounters>;
+    private readonly _onDidFinishCommand;
+    readonly onDidFinishCommand: Event<void>;
+    private readonly _onDidDetectInputNeeded;
+    readonly onDidDetectInputNeeded: Event<void>;
+    private _asyncMode;
+    private _command;
+    private _invocationContext;
+    private _currentMonitoringCts;
+    constructor(_execution: IExecution, _pollFn: ((execution: IExecution, token: CancellationToken, taskService: ITaskService) => Promise<IPollingResult | undefined>) | undefined, invocationContext: IToolInvocationContext | undefined, token: CancellationToken, command: string, _taskService: ITaskService, _logService: ITerminalLogService);
+    private _startMonitoring;
+    /**
+     * Continues monitoring in background mode with a new cancellation token.
+     * In background mode, the monitor re-polls for idle and handles prompts
+     * whenever new terminal data arrives, rather than stopping after the first
+     * idle detection. Resource cost is bounded because the monitor only wakes
+     * on new terminal data (via {@link _waitForNewData}) and each idle cycle
+     * is capped by the standard polling timeouts.
+     */
+    continueMonitoringAsync(token: CancellationToken): void;
+    /**
+     * Waits for new terminal data or cancellation. Used in background mode
+     * to avoid polling and LLM calls while the terminal is quiet.
+     */
+    private _waitForNewData;
+    private _handleIdleState;
+    private _handleTimeoutState;
+    /**
+     * Single bounded polling pass that returns when:
+     *  - terminal becomes inactive/idle, or
+     *  - timeout window elapses.
+     */
+    private _waitForIdle;
+    /**
+     * Sets up a listener for user input that triggers immediately when idle is detected.
+     * This ensures we catch any input that happens between idle detection and prompt creation.
+     */
+    private _setupIdleInputListener;
+    /**
+     * Cleans up the idle input listener and resets the flag.
+     */
+    private _cleanupIdleInputListener;
+    private _isSensitivePrompt;
+}
+export declare function matchTerminalPromptOption(options: readonly string[], suggestedOption: string): {
+    option: string | undefined;
+    index: number;
+};
+export declare function detectsInputRequiredPattern(cursorLine: string): boolean;
+export declare function detectsNonInteractiveHelpPattern(cursorLine: string): boolean;
+/**
+ * Detects VS Code's specific task completion messages like:
+ * - "Press any key to close the terminal."
+ * - "Terminal will be reused by tasks, press any key to close it."
+ * These appear when a task finishes and should be ignored if the task is done.
+ * Note: These messages may be prefixed with " * " by VS Code and may have line wrapping
+ * that can split words across lines (e.g., "t\no" instead of "to").
+ */
+export declare function detectsVSCodeTaskFinishMessage(cursorLine: string): boolean;
+/**
+ * Detects generic "press any key" prompts from scripts (not VS Code task messages).
+ * These should prompt the user to interact with the terminal.
+ */
+export declare function detectsGenericPressAnyKeyPattern(cursorLine: string): boolean;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/monitoring/outputMonitor.js

@@ -0,0 +1,412 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, MutableDisposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ITaskService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/taskService.service';
+import { OutputMonitorState, PollingConsts } from './types.js';
+import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
+
+let OutputMonitor = class OutputMonitor extends Disposable {
+    get state() {
+        return this._state;
+    }
+    _formatLastLineForLog(output) {
+        if (!output) {
+            return "<empty>";
+        }
+        const lastLine = output.trimEnd().split(/\r?\n/).pop() ?? "";
+        if (!lastLine) {
+            return "<empty>";
+        }
+        if (this._isSensitivePrompt(lastLine)) {
+            return "<redacted>";
+        }
+        return lastLine.length > 200 ? lastLine.slice(0, 200) + "…" : lastLine;
+    }
+    get pollingResult() {
+        return this._pollingResult;
+    }
+    get outputMonitorTelemetryCounters() {
+        return this._outputMonitorTelemetryCounters;
+    }
+    constructor(
+        _execution,
+        _pollFn,
+        invocationContext,
+        token,
+        command,
+        _taskService,
+        _logService
+    ) {
+        super();
+        this._execution = _execution;
+        this._pollFn = _pollFn;
+        this._taskService = _taskService;
+        this._logService = _logService;
+        this._state = OutputMonitorState.PollingForIdle;
+        this._userInputtedSinceIdleDetected = false;
+        this._userInputListener = this._register(( new MutableDisposable()));
+        this._outputMonitorTelemetryCounters = {
+            inputToolManualAcceptCount: 0,
+            inputToolManualRejectCount: 0,
+            inputToolManualChars: 0,
+            inputToolAutoAcceptCount: 0,
+            inputToolAutoChars: 0,
+            inputToolManualShownCount: 0,
+            inputToolFreeFormInputShownCount: 0,
+            inputToolFreeFormInputCount: 0
+        };
+        this._onDidFinishCommand = this._register(( new Emitter()));
+        this.onDidFinishCommand = this._onDidFinishCommand.event;
+        this._onDidDetectInputNeeded = this._register(( new Emitter()));
+        this.onDidDetectInputNeeded = this._onDidDetectInputNeeded.event;
+        this._asyncMode = false;
+        this._command = "";
+        this._command = command;
+        this._invocationContext = invocationContext;
+        this._register(toDisposable(() => this._currentMonitoringCts?.dispose()));
+        timeout(0).then(() => {
+            this._currentMonitoringCts = ( new CancellationTokenSource(token));
+            this._startMonitoring(command, invocationContext, this._currentMonitoringCts.token);
+        });
+    }
+    async _startMonitoring(command, invocationContext, token) {
+        const pollStartTime = Date.now();
+        let resources;
+        let output;
+        let extended = false;
+        try {
+            while (!token.isCancellationRequested) {
+                switch (this._state) {
+                case OutputMonitorState.PollingForIdle:
+                    {
+                        this._logService.trace(`OutputMonitor: Entering PollingForIdle (extended=${extended})`);
+                        this._state = await this._waitForIdle(this._execution, extended, token);
+                        this._logService.trace(
+                            `OutputMonitor: PollingForIdle completed -> state=${OutputMonitorState[this._state]}`
+                        );
+                        continue;
+                    }
+                case OutputMonitorState.Timeout:
+                    {
+                        this._logService.trace(`OutputMonitor: Entering Timeout state (extended=${extended})`);
+                        const shouldContinuePolling = await this._handleTimeoutState(command, invocationContext, extended, token);
+                        if (shouldContinuePolling) {
+                            extended = true;
+                            this._state = OutputMonitorState.PollingForIdle;
+                            continue;
+                        } else if (this._asyncMode) {
+                            this._logService.trace(
+                                "OutputMonitor: Async mode - timeout reached, waiting for new terminal data"
+                            );
+                            extended = false;
+                            await this._waitForNewData(token);
+                            if (token.isCancellationRequested) {
+                                break;
+                            }
+                            this._state = OutputMonitorState.PollingForIdle;
+                            continue;
+                        } else {
+                            break;
+                        }
+                    }
+                case OutputMonitorState.Cancelled:
+                    break;
+                case OutputMonitorState.Idle:
+                    {
+                        this._logService.trace("OutputMonitor: Entering Idle handler");
+                        const idleResult = await this._handleIdleState(token);
+                        if (idleResult.shouldContinuePolling) {
+                            this._logService.trace("OutputMonitor: Idle handler -> continue polling");
+                            this._state = OutputMonitorState.PollingForIdle;
+                            continue;
+                        } else if (this._asyncMode) {
+                            this._logService.trace(
+                                "OutputMonitor: Async mode - waiting for new terminal data before next monitoring cycle"
+                            );
+                            await this._waitForNewData(token);
+                            if (token.isCancellationRequested) {
+                                break;
+                            }
+                            this._state = OutputMonitorState.PollingForIdle;
+                            continue;
+                        } else {
+                            this._logService.trace(
+                                `OutputMonitor: Idle handler -> stop polling (hasResources=${!!idleResult.resources}, outputLen=${idleResult.output?.length ?? 0})`
+                            );
+                            resources = idleResult.resources;
+                            output = idleResult.output;
+                        }
+                        break;
+                    }
+                }
+                if (this._state === OutputMonitorState.Idle || this._state === OutputMonitorState.Cancelled || this._state === OutputMonitorState.Timeout) {
+                    break;
+                }
+            }
+            if (token.isCancellationRequested) {
+                this._state = OutputMonitorState.Cancelled;
+            }
+        } finally {
+            this._logService.trace(
+                `OutputMonitor: Monitoring finished (state=${OutputMonitorState[this._state]}, duration=${Date.now() - pollStartTime}ms)`
+            );
+            this._pollingResult = {
+                state: this._state,
+                output: output ?? this._execution.getOutput(),
+                pollDurationMs: Date.now() - pollStartTime,
+                resources
+            };
+            this._userInputListener.clear();
+            this._onDidFinishCommand.fire();
+        }
+    }
+    continueMonitoringAsync(token) {
+        this._asyncMode = true;
+        const currentMonitoringCts = this._currentMonitoringCts;
+        currentMonitoringCts?.cancel();
+        currentMonitoringCts?.dispose();
+        this._currentMonitoringCts = ( new CancellationTokenSource(token));
+        this._state = OutputMonitorState.PollingForIdle;
+        this._startMonitoring(this._command, this._invocationContext, this._currentMonitoringCts.token);
+    }
+    _waitForNewData(token) {
+        return ( new Promise(resolve => {
+            if (token.isCancellationRequested) {
+                resolve();
+                return;
+            }
+            const cleanup = () => {
+                dataListener.dispose();
+                tokenListener.dispose();
+                disposedListener.dispose();
+            };
+            const dataListener = this._execution.instance.onData(() => {
+                cleanup();
+                resolve();
+            });
+            const tokenListener = token.onCancellationRequested(() => {
+                cleanup();
+                resolve();
+            });
+            const disposedListener = this._execution.instance.onDisposed(() => {
+                cleanup();
+                resolve();
+            });
+        }));
+    }
+    async _handleIdleState(token) {
+        const output = this._execution.getOutput();
+        const outputTail = output.slice(-1e3);
+        this._logService.trace(
+            `OutputMonitor: Idle output summary: len=${output.length}, lastLine=${this._formatLastLineForLog(outputTail)}`
+        );
+        if (detectsNonInteractiveHelpPattern(outputTail)) {
+            this._logService.trace("OutputMonitor: Idle -> non-interactive help pattern detected, stopping");
+            return {
+                shouldContinuePolling: false,
+                output
+            };
+        }
+        const isTask = this._execution.task !== undefined;
+        if (isTask && detectsVSCodeTaskFinishMessage(outputTail)) {
+            this._logService.trace("OutputMonitor: Idle -> VS Code task finish message detected, stopping");
+            return {
+                shouldContinuePolling: false,
+                output
+            };
+        }
+        if (!isTask && detectsGenericPressAnyKeyPattern(outputTail)) {
+            this._logService.trace(
+                "OutputMonitor: Idle -> generic \"press any key\" detected, signaling agent"
+            );
+            this._onDidDetectInputNeeded.fire();
+            this._cleanupIdleInputListener();
+            return {
+                shouldContinuePolling: false,
+                output
+            };
+        }
+        if (this._userInputtedSinceIdleDetected) {
+            this._logService.trace(
+                "OutputMonitor: User input detected since idle; skipping prompt and continuing polling"
+            );
+            this._cleanupIdleInputListener();
+            return {
+                shouldContinuePolling: true
+            };
+        }
+        if (this._asyncMode) {
+            if (detectsInputRequiredPattern(outputTail)) {
+                this._logService.trace(
+                    "OutputMonitor: Async mode - input-required pattern detected, signaling agent"
+                );
+                this._onDidDetectInputNeeded.fire();
+            }
+            this._cleanupIdleInputListener();
+            return {
+                shouldContinuePolling: false,
+                output
+            };
+        }
+        if (detectsInputRequiredPattern(outputTail)) {
+            this._logService.trace("OutputMonitor: Input-required pattern detected, signaling agent");
+            this._onDidDetectInputNeeded.fire();
+            this._cleanupIdleInputListener();
+            return {
+                shouldContinuePolling: false,
+                output
+            };
+        }
+        this._cleanupIdleInputListener();
+        const custom = await this._pollFn?.(this._execution, token, this._taskService);
+        this._logService.trace(`OutputMonitor: Custom poller result: ${custom ? "provided" : "none"}`);
+        const resources = custom?.resources;
+        return {
+            resources,
+            shouldContinuePolling: false,
+            output: custom?.output ?? output
+        };
+    }
+    async _handleTimeoutState(_command, _invocationContext, _extended, _token) {
+        if (_extended) {
+            this._logService.info("OutputMonitor: Extended polling timeout reached after 2 minutes");
+            this._state = OutputMonitorState.Cancelled;
+            return false;
+        }
+        return true;
+    }
+    async _waitForIdle(execution, extendedPolling, token) {
+        const maxWaitMs = extendedPolling ? PollingConsts.ExtendedPollingMaxDuration : PollingConsts.FirstPollingMaxDuration;
+        const maxInterval = PollingConsts.MaxPollingIntervalDuration;
+        let currentInterval = PollingConsts.MinPollingDuration;
+        let waited = 0;
+        let consecutiveIdleEvents = 0;
+        let hasReceivedData = false;
+        const onDataDisposable = execution.instance.onData(_data => {
+            hasReceivedData = true;
+        });
+        try {
+            while (!token.isCancellationRequested && waited < maxWaitMs) {
+                const waitTime = Math.min(currentInterval, maxWaitMs - waited);
+                try {
+                    await timeout(waitTime, token);
+                } catch (err) {
+                    if (token.isCancellationRequested) {
+                        return OutputMonitorState.Cancelled;
+                    }
+                    throw err;
+                }
+                waited += waitTime;
+                currentInterval = Math.min(currentInterval * 2, maxInterval);
+                const currentOutput = execution.getOutput();
+                const currentTail = currentOutput.slice(-1000);
+                if (detectsNonInteractiveHelpPattern(currentTail)) {
+                    this._logService.trace(
+                        `OutputMonitor: waitForIdle -> non-interactive help detected (waited=${waited}ms)`
+                    );
+                    this._state = OutputMonitorState.Idle;
+                    this._setupIdleInputListener();
+                    return this._state;
+                }
+                const promptResult = detectsInputRequiredPattern(currentTail);
+                if (promptResult) {
+                    this._logService.trace(
+                        `OutputMonitor: waitForIdle -> input-required pattern detected (waited=${waited}ms, lastLine=${this._formatLastLineForLog(currentTail)})`
+                    );
+                    this._state = OutputMonitorState.Idle;
+                    this._setupIdleInputListener();
+                    return this._state;
+                }
+                if (hasReceivedData) {
+                    consecutiveIdleEvents = 0;
+                    hasReceivedData = false;
+                } else {
+                    consecutiveIdleEvents++;
+                }
+                const recentlyIdle = consecutiveIdleEvents >= PollingConsts.MinIdleEvents;
+                const isActive = execution.isActive ? await execution.isActive() : undefined;
+                this._logService.trace(
+                    `OutputMonitor: waitForIdle check: waited=${waited}ms, recentlyIdle=${recentlyIdle}, isActive=${isActive}`
+                );
+                if (recentlyIdle && isActive !== true) {
+                    this._logService.trace(
+                        `OutputMonitor: waitForIdle -> recentlyIdle && !active (waited=${waited}ms, lastLine=${this._formatLastLineForLog(currentTail)})`
+                    );
+                    this._state = OutputMonitorState.Idle;
+                    this._setupIdleInputListener();
+                    return this._state;
+                }
+            }
+        } finally {
+            onDataDisposable.dispose();
+        }
+        if (token.isCancellationRequested) {
+            return OutputMonitorState.Cancelled;
+        }
+        return OutputMonitorState.Timeout;
+    }
+    _setupIdleInputListener() {
+        this._userInputtedSinceIdleDetected = false;
+        this._logService.trace("OutputMonitor: Setting up idle input listener");
+        this._userInputListener.value = this._execution.instance.onDidInputData(() => {
+            this._userInputtedSinceIdleDetected = true;
+            this._logService.trace("OutputMonitor: Detected user terminal input while idle");
+        });
+    }
+    _cleanupIdleInputListener() {
+        this._userInputtedSinceIdleDetected = false;
+        this._userInputListener.clear();
+    }
+    _isSensitivePrompt(prompt) {
+        return /(password|passphrase|token|api\s*key|secret)/i.test(prompt);
+    }
+};
+OutputMonitor = ( __decorate([( __param(5, ITaskService)), ( __param(6, ITerminalLogService))], OutputMonitor));
+function detectsInputRequiredPattern(cursorLine) {
+    return ([
+        /\s*(?:\[[^\]]\][^\[]*)+(?:\(default is\s+"[^"]+"\):)?\s+$/,
+        /(?:\(|\[)\s*(?:y(?:es)?\s*\/\s*n(?:o)?|n(?:o)?\s*\/\s*y(?:es)?)\s*(?:\]|\))\s+$/i,
+        /[?:]\s*(?:\(|\[)?\s*y(?:es)?\s*\/\s*n(?:o)?\s*(?:\]|\))?\s+$/i,
+        /\(y\)\s*$/i,
+        /:\s*$/,
+        /:\s*\([^)]*\)\s*$/,
+        /\(END\)$/,
+        /password[:]?$/i,
+        /\?\s*(?:\([a-z\s]+\))?$/i,
+        /press a(?:ny)? key/i
+    ].some(e => e.test(cursorLine)));
+}
+function detectsNonInteractiveHelpPattern(cursorLine) {
+    return ([
+        /press [h?]\s*(?:\+\s*enter)?\s*to (?:show|open|display|get|see)\s*(?:available )?(?:help|commands|options)/i,
+        /press h\s*(?:or\s*\?)?\s*(?:\+\s*enter)?\s*for (?:help|commands|options)/i,
+        /press \?\s*(?:\+\s*enter)?\s*(?:to|for)?\s*(?:help|commands|options|list)/i,
+        /type\s*[h?]\s*(?:\+\s*enter)?\s*(?:for|to see|to show)\s*(?:help|commands|options)/i,
+        /hit\s*[h?]\s*(?:\+\s*enter)?\s*(?:for|to see|to show)\s*(?:help|commands|options)/i,
+        /press o\s*(?:\+\s*enter)?\s*(?:to|for)?\s*(?:open|launch)(?:\s*(?:the )?(?:app|application|browser)|\s+in\s+(?:the\s+)?browser)?/i,
+        /press r\s*(?:\+\s*enter)?\s*(?:to|for)?\s*(?:restart|reload|refresh)(?:\s*(?:the )?(?:server|dev server|service))?/i,
+        /press q\s*(?:\+\s*enter)?\s*(?:to|for)?\s*(?:quit|exit|stop)(?:\s*(?:the )?(?:server|app|process))?/i,
+        /press u\s*(?:\+\s*enter)?\s*(?:to|for)?\s*(?:show|print|display)\s*(?:the )?(?:server )?urls?/i
+    ].some(e => e.test(cursorLine)));
+}
+const taskFinishMessages = [(
+localize(14031, "Terminal will be reused by tasks, press any key to close it.")), ( localize(14032, "Terminal will be reused by tasks, press any key to close it.")), (
+localize(14033, "Press any key to close the terminal.")), ( localize(14034, "Press any key to close the terminal.")), (
+localize(14035, "The terminal will be reused by tasks. Press any key to close."))];
+const normalizedTaskFinishMessages = ( taskFinishMessages.map(msg => msg.replace(/[\s.,:;!?"'`()[\]{}<>\-_/\\]+/g, "").toLowerCase()));
+function detectsVSCodeTaskFinishMessage(cursorLine) {
+    const compact = cursorLine.replace(/[\s.,:;!?"'`()[\]{}<>\-_/\\]+/g, "").toLowerCase();
+    return ( normalizedTaskFinishMessages.some(msg => compact.includes(msg)));
+}
+function detectsGenericPressAnyKeyPattern(cursorLine) {
+    if (detectsVSCodeTaskFinishMessage(cursorLine)) {
+        return false;
+    }
+    return /press a(?:ny)? key/i.test(cursorLine);
+}
+
+export { OutputMonitor, detectsGenericPressAnyKeyPattern, detectsInputRequiredPattern, detectsNonInteractiveHelpPattern, detectsVSCodeTaskFinishMessage };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/monitoring/types.d.ts

@@ -0,0 +1,42 @@
+import type { Task } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/taskService";
+import type { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import type { ILinkLocation } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/taskHelpers";
+import type { IMarker as XtermMarker } from "@xterm/xterm";
+import type { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+export interface IConfirmationPrompt {
+    prompt: string;
+    options: string[];
+    descriptions?: string[];
+    detectedRequestForFreeFormInput: boolean;
+    suggestedInput?: string;
+}
+export interface IExecution {
+    getOutput: (marker?: XtermMarker) => string;
+    isActive?: () => Promise<boolean>;
+    task?: Task | Pick<Task, "configurationProperties">;
+    dependencyTasks?: Task[];
+    instance: Pick<ITerminalInstance, "sendText" | "instanceId" | "onDidInputData" | "onDisposed" | "onData" | "focus" | "registerMarker">;
+    sessionResource: URI | undefined;
+}
+export interface IPollingResult {
+    output: string;
+    resources?: ILinkLocation[];
+    state: OutputMonitorState;
+}
+export declare enum OutputMonitorState {
+    Initial = "Initial",
+    Idle = "Idle",
+    PollingForIdle = "PollingForIdle",
+    Prompting = "Prompting",
+    Timeout = "Timeout",
+    Active = "Active",
+    Cancelled = "Cancelled"
+}
+export declare enum PollingConsts {
+    MinIdleEvents = 2,// Minimum number of idle checks before considering the terminal idle
+    MinPollingDuration = 500,
+    FirstPollingMaxDuration = 20000,// 20 seconds
+    ExtendedPollingMaxDuration = 120000,// 2 minutes
+    MaxPollingIntervalDuration = 10000,// 10 seconds - grows via exponential backoff
+    MaxRecursionCount = 5
+}