@codingame/monaco-vscode-katex-common 33.0.9 → 34.0.1

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

@@ -1,177 +0,0 @@
-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>;
-    /**
-     * Fires when the terminal is detected to be waiting for sensitive input
-     * (e.g. a password, passphrase, token, secret or verification code). This
-     * is fired *instead of* {@link onDidDetectInputNeeded} so callers can show
-     * UI that focuses the terminal rather than routing the prompt through the
-     * agent.
-     */
-    readonly onDidDetectSensitiveInputNeeded: Event<void>;
-}
-export interface IOutputMonitorTelemetryCounters {
-    inputToolManualAcceptCount: number;
-    inputToolManualRejectCount: number;
-    inputToolManualChars: number;
-    inputToolAutoAcceptCount: number;
-    inputToolAutoChars: number;
-    inputToolManualShownCount: number;
-    inputToolFreeFormInputShownCount: number;
-    inputToolFreeFormInputCount: number;
-}
-/**
- * Returns the last visible line from terminal output after trimming trailing line breaks.
- */
-export declare function getLastLine(output: string | undefined): string;
-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 readonly _onDidDetectSensitiveInputNeeded;
-    readonly onDidDetectSensitiveInputNeeded: Event<void>;
-    private _asyncMode;
-    private _command;
-    private _invocationContext;
-    private _currentMonitoringCts;
-    /**
-     * Tracks whether onDidFinishCommand has fired so the event is delivered at
-     * most once. The event must fire synchronously during dispose so consumers
-     * awaiting `Event.toPromise(onDidFinishCommand)` are unblocked before the
-     * underlying emitter is torn down by super.dispose().
-     */
-    private _didFinish;
-    private _fireFinishedOnce;
-    dispose(): void;
-    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;
-}
-/**
- * Returns true when the terminal's last visible line looks like a prompt for
- * a sensitive secret (password, passphrase, token, API key, OTP, etc.). Used
- * to short-circuit the normal "input needed → return to agent" flow so that
- * the secret is never routed through the model — instead the user is asked
- * via UI to focus the terminal and type the secret directly.
- */
-export declare function detectsSensitiveInputPrompt(cursorLine: string): boolean;
-export declare function matchTerminalPromptOption(options: readonly string[], suggestedOption: string): {
-    option: string | undefined;
-    index: number;
-};
-/**
- * High-confidence patterns that reliably indicate the terminal is waiting for
- * input. These are safe to use as a fast-path in `_waitForIdle` to skip normal
- * idle detection, because they are specific enough to avoid false positives on
- * normal command output (build logs, headers, etc.).
- */
-export declare function detectsHighConfidenceInputPattern(cursorLine: string): boolean;
-/**
- * Strict input-required detection. Returns true only for patterns that are
- * specific enough to avoid false positives on normal command output (build
- * logs, status lines, error messages). Safe to call from any code path,
- * including unconditionally on the last line of a finished command.
- *
- * For the broader heuristics (bare `:` / `?` with trailing space), use
- * {@link detectsLikelyInputRequiredPattern} — but only from a call site that
- * has independent evidence the command is still running and consuming stdin
- * (e.g. `execution.isActive() === true`). Those broad patterns cannot
- * reliably distinguish a real prompt like `Enter your name: ` from log
- * output like `Last Command: ` on a single line.
- */
-export declare function detectsInputRequiredPattern(cursorLine: string): boolean;
-/**
- * Strict patterns plus broader heuristics (bare `:` and `?` with trailing
- * space). These broad patterns may produce false positives on normal command
- * output that happens to end with those characters (e.g. `Last Command: `,
- * `[INFO] Starting: `, `find: /tmp/x: No such file: `). They are
- * syntactically indistinguishable from real prompts like `Enter your name: `
- * on a single cursor line.
- *
- * Therefore this function is only safe to call when the caller has
- * independent evidence that the terminal is currently consuming stdin —
- * specifically, `execution.isActive() === true` at a moment when the output
- * stream has been quiet (idle) for several poll intervals. `_waitForIdle`
- * applies that gate; new call sites should preserve it.
- *
- * For unconditional checks (e.g. on the last line of a finished command),
- * use {@link detectsInputRequiredPattern} instead.
- */
-export declare function detectsLikelyInputRequiredPattern(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

@@ -1,512 +0,0 @@
-
-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';
-
-function getLastLine(output) {
-    if (!output) {
-        return "";
-    }
-    const trimmedOutput = output.replace(/[\r\n]+$/, "");
-    if (!trimmedOutput) {
-        return "";
-    }
-    const lastLineFeed = trimmedOutput.lastIndexOf("\n");
-    const lastLine = lastLineFeed === -1 ? trimmedOutput : trimmedOutput.slice(lastLineFeed + 1);
-    const lastCarriageReturn = lastLine.lastIndexOf("\r");
-    return lastCarriageReturn === -1 ? lastLine : lastLine.slice(lastCarriageReturn + 1);
-}
-let OutputMonitor = class OutputMonitor extends Disposable {
-    get state() {
-        return this._state;
-    }
-    _formatLastLineForLog(output) {
-        if (!output) {
-            return "<empty>";
-        }
-        const lastLine = getLastLine(output).trimEnd();
-        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;
-    }
-    _fireFinishedOnce() {
-        if (this._didFinish) {
-            return;
-        }
-        this._didFinish = true;
-        this._onDidFinishCommand.fire();
-    }
-    dispose() {
-        if (!this._didFinish) {
-            this._pollingResult ??= {
-                state: OutputMonitorState.Cancelled,
-                output: this._execution.getOutput(),
-                pollDurationMs: 0,
-                resources: undefined
-            };
-        }
-        this._fireFinishedOnce();
-        super.dispose();
-    }
-    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._onDidDetectSensitiveInputNeeded = this._register(( new Emitter()));
-        this.onDidDetectSensitiveInputNeeded = this._onDidDetectSensitiveInputNeeded.event;
-        this._asyncMode = false;
-        this._command = "";
-        this._didFinish = false;
-        this._command = command;
-        this._invocationContext = invocationContext;
-        const cts = ( new CancellationTokenSource(token));
-        this._currentMonitoringCts = cts;
-        this._register(toDisposable(() => {
-            this._currentMonitoringCts?.cancel();
-            this._currentMonitoringCts?.dispose();
-        }));
-        timeout(0).then(() => {
-            if (this._currentMonitoringCts !== cts) {
-                return;
-            }
-            this._startMonitoring(command, invocationContext, cts.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._fireFinishedOnce();
-        }
-    }
-    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);
-        const outputLastLine = getLastLine(outputTail);
-        this._logService.trace(
-            `OutputMonitor: Idle output summary: len=${output.length}, lastLine=${this._formatLastLineForLog(outputTail)}`
-        );
-        if (detectsNonInteractiveHelpPattern(outputLastLine)) {
-            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
-            };
-        }
-        let shouldFireInputNeeded = detectsInputRequiredPattern(outputLastLine);
-        if (!shouldFireInputNeeded && detectsLikelyInputRequiredPattern(outputLastLine)) {
-            const isActive = this._execution.isActive ? await this._execution.isActive() : undefined;
-            if (isActive === true) {
-                shouldFireInputNeeded = true;
-            }
-        }
-        if (shouldFireInputNeeded && this._userInputtedSinceIdleDetected) {
-            this._logService.trace(
-                "OutputMonitor: User input detected during isActive await; skipping prompt and continuing polling"
-            );
-            this._cleanupIdleInputListener();
-            return {
-                shouldContinuePolling: true
-            };
-        }
-        if (this._asyncMode) {
-            if (shouldFireInputNeeded) {
-                if (detectsSensitiveInputPrompt(outputLastLine)) {
-                    this._logService.trace(
-                        "OutputMonitor: Async mode - sensitive input prompt detected, signaling sensitive UI"
-                    );
-                    this._onDidDetectSensitiveInputNeeded.fire();
-                } else {
-                    this._logService.trace(
-                        "OutputMonitor: Async mode - input-required pattern detected, signaling agent"
-                    );
-                    this._onDidDetectInputNeeded.fire();
-                }
-            }
-            this._cleanupIdleInputListener();
-            return {
-                shouldContinuePolling: false,
-                output
-            };
-        }
-        if (shouldFireInputNeeded) {
-            if (detectsSensitiveInputPrompt(outputLastLine)) {
-                this._logService.trace("OutputMonitor: Sensitive input prompt detected, signaling sensitive UI");
-                this._onDidDetectSensitiveInputNeeded.fire();
-            } else {
-                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, signaling potential input needed"
-            );
-            this._onDidDetectInputNeeded.fire();
-            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);
-                const currentLastLine = getLastLine(currentTail);
-                if (detectsNonInteractiveHelpPattern(currentLastLine)) {
-                    this._logService.trace(
-                        `OutputMonitor: waitForIdle -> non-interactive help detected (waited=${waited}ms)`
-                    );
-                    this._state = OutputMonitorState.Idle;
-                    this._setupIdleInputListener();
-                    return this._state;
-                }
-                const promptResult = detectsHighConfidenceInputPattern(currentLastLine);
-                if (promptResult) {
-                    this._logService.trace(
-                        `OutputMonitor: waitForIdle -> high-confidence input 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;
-                }
-                if (recentlyIdle && isActive === true && detectsLikelyInputRequiredPattern(currentLastLine)) {
-                    this._logService.trace(
-                        `OutputMonitor: waitForIdle -> broad input pattern detected while active+idle (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() {
-        if (this._store.isDisposed) {
-            return;
-        }
-        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 detectsSensitiveInputPrompt(prompt);
-    }
-};
-OutputMonitor = ( __decorate([( __param(5, ITaskService)), ( __param(6, ITerminalLogService))], OutputMonitor));
-function detectsSensitiveInputPrompt(cursorLine) {
-    return /(password|passphrase|token|api\s*key|secret|verification code|otp\b|one[\s-]?time (?:code|password)|2fa|mfa|pin\s*(?:code|number)?[: ]?\s*$|authentication code)/i.test(cursorLine);
-}
-function detectsHighConfidenceInputPattern(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\) +$/i,
-        /:\s+\([^)]*\) +$/,
-        /\(END\)$/,
-        /password(?: for [^:]+)?:\s*$/i,
-        /press a(?:ny)? key/i,
-        /^(?:\s|\x1b\[[0-9;]*m)*\?.*[›❯▸▶]\s*$/
-    ].some(e => e.test(cursorLine)));
-}
-function detectsInputRequiredPattern(cursorLine) {
-    return detectsHighConfidenceInputPattern(cursorLine);
-}
-function detectsLikelyInputRequiredPattern(cursorLine) {
-    if (detectsHighConfidenceInputPattern(cursorLine)) {
-        return true;
-    }
-    return ([
-        /: +$/,
-        /\? *(?:\([a-z\s]+\))? +$/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(14475, "Terminal will be reused by tasks, press any key to close it.")), ( localize(14476, "Terminal will be reused by tasks, press any key to close it.")), (
-localize(14477, "Press any key to close the terminal.")), ( localize(14478, "Press any key to close the terminal.")), (
-localize(14479, "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, detectsHighConfidenceInputPattern, detectsInputRequiredPattern, detectsLikelyInputRequiredPattern, detectsNonInteractiveHelpPattern, detectsSensitiveInputPrompt, detectsVSCodeTaskFinishMessage, getLastLine };