@codingame/monaco-vscode-chat-service-override 20.4.1 → 21.0.0

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

@@ -1,9 +1,12 @@
 
 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 { regExpLeadsToEndlessLoop } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { regExpLeadsToEndlessLoop, escapeRegExpCharacters } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { isObject } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { structuralEquals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/equals';
+import { ConfigurationTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
-import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-6883db80-c313-54eb-8fbc-5872c56b0326-common/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-a175bd1a-4858-5944-9ae5-fb73305dcb13-common/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
 import { isPowerShell } from './runInTerminalHelpers.js';
 
 const neverMatchRegex = /(?!.*)/;
@@ -25,6 +28,7 @@ let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
     }
     updateConfiguration() {
         let configValue = this._configurationService.getValue(TerminalChatAgentToolsSettingId.AutoApprove);
+        const configInspectValue = this._configurationService.inspect(TerminalChatAgentToolsSettingId.AutoApprove);
         const deprecatedValue = this._configurationService.getValue(TerminalChatAgentToolsSettingId.DeprecatedAutoApproveCompatible);
         if (deprecatedValue && typeof deprecatedValue === 'object' && configValue && typeof configValue === 'object') {
             configValue = {
@@ -32,7 +36,7 @@ let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
                 ...deprecatedValue
             };
         }
-        const { denyListRules, allowListRules, allowListCommandLineRules, denyListCommandLineRules } = this._mapAutoApproveConfigToRules(configValue);
+        const { denyListRules, allowListRules, allowListCommandLineRules, denyListCommandLineRules } = this._mapAutoApproveConfigToRules(configValue, configInspectValue);
         this._allowListRules = allowListRules;
         this._denyListRules = denyListRules;
         this._allowListCommandLineRules = allowListCommandLineRules;
@@ -40,42 +44,65 @@ let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
     }
     isCommandAutoApproved(command, shell, os) {
         for (const rule of this._denyListRules) {
-            if (this._commandMatchesRegex(rule.regex, command, shell, os)) {
-                return { result: 'denied', reason: `Command '${command}' is denied by deny list rule: ${rule.sourceText}` };
+            if (this._commandMatchesRule(rule, command, shell, os)) {
+                return {
+                    result: 'denied',
+                    rule,
+                    reason: `Command '${command}' is denied by deny list rule: ${rule.sourceText}`
+                };
             }
         }
         for (const rule of this._allowListRules) {
-            if (this._commandMatchesRegex(rule.regex, command, shell, os)) {
-                return { result: 'approved', reason: `Command '${command}' is approved by allow list rule: ${rule.sourceText}` };
+            if (this._commandMatchesRule(rule, command, shell, os)) {
+                return {
+                    result: 'approved',
+                    rule,
+                    reason: `Command '${command}' is approved by allow list rule: ${rule.sourceText}`
+                };
             }
         }
-        return { result: 'noMatch', reason: `Command '${command}' has no matching auto approve entries` };
+        return {
+            result: 'noMatch',
+            reason: `Command '${command}' has no matching auto approve entries`
+        };
     }
     isCommandLineAutoApproved(commandLine) {
         for (const rule of this._denyListCommandLineRules) {
             if (rule.regex.test(commandLine)) {
-                return { result: 'denied', reason: `Command line '${commandLine}' is denied by deny list rule: ${rule.sourceText}` };
+                return {
+                    result: 'denied',
+                    rule,
+                    reason: `Command line '${commandLine}' is denied by deny list rule: ${rule.sourceText}`
+                };
             }
         }
         for (const rule of this._allowListCommandLineRules) {
             if (rule.regex.test(commandLine)) {
-                return { result: 'approved', reason: `Command line '${commandLine}' is approved by allow list rule: ${rule.sourceText}` };
+                return {
+                    result: 'approved',
+                    rule,
+                    reason: `Command line '${commandLine}' is approved by allow list rule: ${rule.sourceText}`
+                };
             }
         }
-        return { result: 'noMatch', reason: `Command line '${commandLine}' has no matching auto approve entries` };
+        return {
+            result: 'noMatch',
+            reason: `Command line '${commandLine}' has no matching auto approve entries`
+        };
     }
-    _commandMatchesRegex(regex, command, shell, os) {
-        if (regex.test(command)) {
+    _commandMatchesRule(rule, command, shell, os) {
+        const isPwsh = isPowerShell(shell, os);
+        if ((isPwsh ? rule.regexCaseInsensitive : rule.regex).test(command)) {
             return true;
         }
-        else if (isPowerShell(shell, os) && command.startsWith('(')) {
-            if (regex.test(command.slice(1))) {
+        else if (isPwsh && command.startsWith('(')) {
+            if (rule.regexCaseInsensitive.test(command.slice(1))) {
                 return true;
             }
         }
         return false;
     }
-    _mapAutoApproveConfigToRules(config) {
+    _mapAutoApproveConfigToRules(config, configInspectValue) {
         if (!config || typeof config !== 'object') {
             return {
                 denyListRules: [],
@@ -89,33 +116,49 @@ let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
         const allowListCommandLineRules = [];
         const denyListCommandLineRules = [];
         Object.entries(config).forEach(([key, value]) => {
+            const defaultValue = configInspectValue?.default?.value;
+            const isDefaultRule = !!(isObject(defaultValue) &&
+                key in defaultValue &&
+                structuralEquals(defaultValue[key], value));
+            function checkTarget(inspectValue) {
+                return (isObject(inspectValue) &&
+                    key in inspectValue &&
+                    structuralEquals(inspectValue[key], value));
+            }
+            const sourceTarget = (checkTarget(configInspectValue.workspaceFolder) ? ConfigurationTarget.WORKSPACE_FOLDER
+                : checkTarget(configInspectValue.workspaceValue) ? ConfigurationTarget.WORKSPACE
+                    : checkTarget(configInspectValue.userRemoteValue) ? ConfigurationTarget.USER_REMOTE
+                        : checkTarget(configInspectValue.userLocalValue) ? ConfigurationTarget.USER_LOCAL
+                            : checkTarget(configInspectValue.userValue) ? ConfigurationTarget.USER
+                                : checkTarget(configInspectValue.applicationValue) ? ConfigurationTarget.APPLICATION
+                                    : ConfigurationTarget.DEFAULT);
             if (typeof value === 'boolean') {
-                const regex = this._convertAutoApproveEntryToRegex(key);
+                const { regex, regexCaseInsensitive } = this._convertAutoApproveEntryToRegex(key);
                 if (value === true) {
-                    allowListRules.push({ regex, sourceText: key });
+                    allowListRules.push({ regex, regexCaseInsensitive, sourceText: key, sourceTarget, isDefaultRule });
                 }
                 else if (value === false) {
-                    denyListRules.push({ regex, sourceText: key });
+                    denyListRules.push({ regex, regexCaseInsensitive, sourceText: key, sourceTarget, isDefaultRule });
                 }
             }
             else if (typeof value === 'object' && value !== null) {
                 const objectValue = value;
                 if (typeof objectValue.approve === 'boolean') {
-                    const regex = this._convertAutoApproveEntryToRegex(key);
+                    const { regex, regexCaseInsensitive } = this._convertAutoApproveEntryToRegex(key);
                     if (objectValue.approve === true) {
                         if (objectValue.matchCommandLine === true) {
-                            allowListCommandLineRules.push({ regex, sourceText: key });
+                            allowListCommandLineRules.push({ regex, regexCaseInsensitive, sourceText: key, sourceTarget, isDefaultRule });
                         }
                         else {
-                            allowListRules.push({ regex, sourceText: key });
+                            allowListRules.push({ regex, regexCaseInsensitive, sourceText: key, sourceTarget, isDefaultRule });
                         }
                     }
                     else if (objectValue.approve === false) {
                         if (objectValue.matchCommandLine === true) {
-                            denyListCommandLineRules.push({ regex, sourceText: key });
+                            denyListCommandLineRules.push({ regex, regexCaseInsensitive, sourceText: key, sourceTarget, isDefaultRule });
                         }
                         else {
-                            denyListRules.push({ regex, sourceText: key });
+                            denyListRules.push({ regex, regexCaseInsensitive, sourceText: key, sourceTarget, isDefaultRule });
                         }
                     }
                 }
@@ -129,6 +172,13 @@ let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
         };
     }
     _convertAutoApproveEntryToRegex(value) {
+        const regex = this._doConvertAutoApproveEntryToRegex(value);
+        if (regex.flags.includes('i')) {
+            return { regex, regexCaseInsensitive: regex };
+        }
+        return { regex, regexCaseInsensitive: ( new RegExp(regex.source, regex.flags + 'i')) };
+    }
+    _doConvertAutoApproveEntryToRegex(value) {
         const regexMatch = value.match(/^\/(?<pattern>.+)\/(?<flags>[dgimsuvy]*)$/);
         const regexPattern = regexMatch?.groups?.pattern;
         if (regexPattern) {
@@ -153,7 +203,16 @@ let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
         if (value === '') {
             return neverMatchRegex;
         }
-        const sanitizedValue = value.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&');
+        let sanitizedValue;
+        if (value.includes('/') || value.includes('\\')) {
+            let pattern = value.replace(/[/\\]/g, '%%PATH_SEP%%');
+            pattern = escapeRegExpCharacters(pattern);
+            pattern = pattern.replace(/%%PATH_SEP%%*/g, '[/\\\\]');
+            sanitizedValue = `^(?:\\.[/\\\\])?${pattern}`;
+        }
+        else {
+            sanitizedValue = escapeRegExpCharacters(value);
+        }
         return ( new RegExp(`^${sanitizedValue}\\b`));
     }
 };

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

@@ -0,0 +1,10 @@
+import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import type { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import type { IRunInTerminalInputParams } from "./tools/runInTerminalTool.js";
+export declare class CommandSimplifier {
+    private readonly _osBackend;
+    private readonly _workspaceContextService;
+    constructor(_osBackend: Promise<OperatingSystem>, _workspaceContextService: IWorkspaceContextService);
+    rewriteIfNeeded(args: IRunInTerminalInputParams, instance: Pick<ITerminalInstance, "getCwdResource"> | undefined, shell: string): Promise<string>;
+}

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

@@ -0,0 +1,55 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { isPowerShell } from './runInTerminalHelpers.js';
+
+let CommandSimplifier = class CommandSimplifier {
+    constructor(_osBackend, _workspaceContextService) {
+        this._osBackend = _osBackend;
+        this._workspaceContextService = _workspaceContextService;
+    }
+    async rewriteIfNeeded(args, instance, shell) {
+        const commandLine = args.command;
+        const os = await this._osBackend;
+        const isPwsh = isPowerShell(shell, os);
+        const cdPrefixMatch = commandLine.match(isPwsh
+            ? /^(?:cd(?: \/d)?|Set-Location(?: -Path)?) (?<dir>[^\s]+) ?(?:&&|;)\s+(?<suffix>.+)$/i
+            : /^cd (?<dir>[^\s]+) &&\s+(?<suffix>.+)$/);
+        const cdDir = cdPrefixMatch?.groups?.dir;
+        const cdSuffix = cdPrefixMatch?.groups?.suffix;
+        if (cdDir && cdSuffix) {
+            let cwd;
+            if (instance) {
+                cwd = await instance.getCwdResource();
+            }
+            if (!cwd) {
+                const workspaceFolders = this._workspaceContextService.getWorkspace().folders;
+                if (workspaceFolders.length === 1) {
+                    cwd = workspaceFolders[0].uri;
+                }
+            }
+            if (cwd) {
+                let cdDirPath = cdDir;
+                if (cdDirPath.startsWith('"') && cdDirPath.endsWith('"')) {
+                    cdDirPath = cdDirPath.slice(1, -1);
+                }
+                cdDirPath = cdDirPath.replace(/(?:[\\\/])$/, '');
+                let cwdFsPath = cwd.fsPath.replace(/(?:[\\\/])$/, '');
+                if (os === OperatingSystem.Windows) {
+                    cdDirPath = cdDirPath.toLowerCase();
+                    cwdFsPath = cwdFsPath.toLowerCase();
+                }
+                if (cdDirPath === cwdFsPath) {
+                    return cdSuffix;
+                }
+            }
+        }
+        return commandLine;
+    }
+};
+CommandSimplifier = ( __decorate([
+    ( __param(1, IWorkspaceContextService))
+], CommandSimplifier));
+
+export { CommandSimplifier };

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

@@ -1,8 +1,10 @@
 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 type { ICommandDetectionCapability } from "@codingame/monaco-vscode-a9da9abe-278d-5ce6-9418-99c7c07c5c37-common/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";
+import { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
 /**
  * This strategy is used when shell integration is enabled, but rich command detection was not
  * declared by the shell script. This is the large spectrum between rich command detection and no
@@ -27,10 +29,14 @@ import { type ITerminalExecuteStrategy, type ITerminalExecuteStrategyResult } fr
  */
 export declare class BasicExecuteStrategy implements ITerminalExecuteStrategy {
     private readonly _instance;
+    private readonly _hasReceivedUserInput;
     private readonly _commandDetection;
     private readonly _logService;
     readonly type = "basic";
-    constructor(_instance: ITerminalInstance, _commandDetection: ICommandDetectionCapability, _logService: ITerminalLogService);
+    private _startMarker;
+    private readonly _onDidCreateStartMarker;
+    onDidCreateStartMarker: Event<IXtermMarker | undefined>;
+    constructor(_instance: ITerminalInstance, _hasReceivedUserInput: () => boolean, _commandDetection: ICommandDetectionCapability, _logService: ITerminalLogService);
     execute(commandLine: string, token: CancellationToken): Promise<ITerminalExecuteStrategyResult>;
     private _log;
 }

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

@@ -1,18 +1,21 @@
 
 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 { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { isNumber } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
 import { trackIdleOnPrompt, waitForIdle } from './executeStrategy.js';
 
 let BasicExecuteStrategy = class BasicExecuteStrategy {
-    constructor(_instance, _commandDetection, _logService) {
+    constructor(_instance, _hasReceivedUserInput, _commandDetection, _logService) {
         this._instance = _instance;
+        this._hasReceivedUserInput = _hasReceivedUserInput;
         this._commandDetection = _commandDetection;
         this._logService = _logService;
         this.type = 'basic';
+        this._onDidCreateStartMarker = ( new Emitter());
+        this.onDidCreateStartMarker = this._onDidCreateStartMarker.event;
     }
     async execute(commandLine, token) {
         const store = ( new DisposableStore());
@@ -40,11 +43,16 @@ let BasicExecuteStrategy = class BasicExecuteStrategy {
             }
             this._log('Waiting for idle');
             await waitForIdle(this._instance.onData, 1000);
-            let startMarker = store.add(xterm.raw.registerMarker());
-            store.add(startMarker.onDispose(() => {
+            this._onDidCreateStartMarker.fire(this._startMarker = store.add(xterm.raw.registerMarker()));
+            store.add(this._startMarker.onDispose(() => {
                 this._log(`Start marker was disposed, recreating`);
-                startMarker = xterm.raw.registerMarker();
+                this._onDidCreateStartMarker.fire(this._startMarker = store.add(xterm.raw.registerMarker()));
             }));
+            if (this._hasReceivedUserInput()) {
+                this._log('Command timed out, sending SIGINT and retrying');
+                await this._instance.sendText('\x03', false);
+                await waitForIdle(this._instance.onData, 100);
+            }
             this._log(`Executing command line \`${commandLine}\``);
             this._instance.sendText(commandLine, true);
             const finishedCommand = await onDone;
@@ -65,7 +73,7 @@ let BasicExecuteStrategy = class BasicExecuteStrategy {
             }
             if (output === undefined) {
                 try {
-                    output = xterm.getContentsAsText(startMarker, endMarker);
+                    output = xterm.getContentsAsText(this._startMarker, endMarker);
                     this._log('Fetched output via markers');
                 }
                 catch {
@@ -95,7 +103,7 @@ let BasicExecuteStrategy = class BasicExecuteStrategy {
     }
 };
 BasicExecuteStrategy = ( __decorate([
-    ( __param(2, ITerminalLogService))
+    ( __param(3, ITerminalLogService))
 ], BasicExecuteStrategy));
 
 export { BasicExecuteStrategy };

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

@@ -2,6 +2,7 @@ import type { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/b
 import type { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 import { DisposableStore } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import type { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import type { IMarker as IXtermMarker } from "@xterm/xterm";
 export interface ITerminalExecuteStrategy {
     readonly type: "rich" | "basic" | "none";
     /**
@@ -9,6 +10,7 @@ export interface ITerminalExecuteStrategy {
      * result will include information about the exit code.
      */
     execute(commandLine: string, token: CancellationToken): Promise<ITerminalExecuteStrategyResult>;
+    onDidCreateStartMarker: Event<IXtermMarker | undefined>;
 }
 export interface ITerminalExecuteStrategyResult {
     output: string | undefined;
@@ -17,6 +19,27 @@ export interface ITerminalExecuteStrategyResult {
     error?: string;
 }
 export declare function waitForIdle(onData: Event<unknown>, idleDurationMs: number): Promise<void>;
+export interface IPromptDetectionResult {
+    /**
+     * Whether a prompt was detected.
+     */
+    detected: boolean;
+    /**
+     * The reason for logging.
+     */
+    reason?: string;
+}
+/**
+ * Detects if the given text content appears to end with a common prompt pattern.
+ */
+export declare function detectsCommonPromptPattern(cursorLine: string): IPromptDetectionResult;
+export declare function detectsInputRequiredPattern(cursorLine: string): boolean;
+/**
+ * Enhanced version of {@link waitForIdle} that uses prompt detection heuristics. After the terminal
+ * idles for the specified period, checks if the terminal's cursor line looks like a common prompt.
+ * If not, extends the timeout to give the command more time to complete.
+ */
+export declare function waitForIdleWithPromptHeuristics(onData: Event<unknown>, instance: ITerminalInstance, idlePollIntervalMs: number, extendedTimeoutMs: number): Promise<IPromptDetectionResult>;
 /**
  * Tracks the terminal for being idle on a prompt input. This must be called before `executeCommand`
  * is called.

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

@@ -10,6 +10,77 @@ async function waitForIdle(onData, idleDurationMs) {
     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}"` };
+}
+const PS_CONFIRM_RE = /\s*(?:\[[^\]]\]\s+[^\[]+\s*)+(?:\(default is\s+"[^"]+"\):)?\s+$/;
+const YN_PAIRED_RE = /(?:\(|\[)\s*(?:y(?:es)?\s*\/\s*n(?:o)?|n(?:o)?\s*\/\s*y(?:es)?)\s*(?:\]|\))\s+$/i;
+const YN_AFTER_PUNCT_RE = /[?:]\s*(?:\(|\[)?\s*y(?:es)?\s*\/\s*n(?:o)?\s*(?:\]|\))?\s+$/i;
+const LINE_ENDS_WITH_COLON_RE = /:\s*$/;
+function detectsInputRequiredPattern(cursorLine) {
+    return PS_CONFIRM_RE.test(cursorLine) || YN_PAIRED_RE.test(cursorLine) || YN_AFTER_PUNCT_RE.test(cursorLine) || LINE_ENDS_WITH_COLON_RE.test(cursorLine.trim());
+}
+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) {
     const idleOnPrompt = ( new DeferredPromise());
     const onData = instance.onData;
@@ -49,4 +120,4 @@ async function trackIdleOnPrompt(instance, idleDurationMs, store) {
     return idleOnPrompt.p;
 }
 
-export { trackIdleOnPrompt, waitForIdle };
+export { detectsCommonPromptPattern, detectsInputRequiredPattern, trackIdleOnPrompt, waitForIdle, waitForIdleWithPromptHeuristics };

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

@@ -1,7 +1,9 @@
 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 { 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";
+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
@@ -10,9 +12,13 @@ import { type ITerminalExecuteStrategy, type ITerminalExecuteStrategyResult } fr
  */
 export declare class NoneExecuteStrategy implements ITerminalExecuteStrategy {
     private readonly _instance;
+    private readonly _hasReceivedUserInput;
     private readonly _logService;
     readonly type = "none";
-    constructor(_instance: ITerminalInstance, _logService: ITerminalLogService);
+    private _startMarker;
+    private readonly _onDidCreateStartMarker;
+    onDidCreateStartMarker: Event<IXtermMarker | undefined>;
+    constructor(_instance: ITerminalInstance, _hasReceivedUserInput: () => boolean, _logService: ITerminalLogService);
     execute(commandLine: string, token: CancellationToken): Promise<ITerminalExecuteStrategyResult>;
     private _log;
 }

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

@@ -1,15 +1,19 @@
 
 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 { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
-import { waitForIdle } from './executeStrategy.js';
+import { waitForIdle, waitForIdleWithPromptHeuristics } from './executeStrategy.js';
 
 let NoneExecuteStrategy = class NoneExecuteStrategy {
-    constructor(_instance, _logService) {
+    constructor(_instance, _hasReceivedUserInput, _logService) {
         this._instance = _instance;
+        this._hasReceivedUserInput = _hasReceivedUserInput;
         this._logService = _logService;
         this.type = 'none';
+        this._onDidCreateStartMarker = ( new Emitter());
+        this.onDidCreateStartMarker = this._onDidCreateStartMarker.event;
     }
     async execute(commandLine, token) {
         const store = ( new DisposableStore());
@@ -27,15 +31,21 @@ let NoneExecuteStrategy = class NoneExecuteStrategy {
             if (token.isCancellationRequested) {
                 throw ( new CancellationError());
             }
-            let startMarker = store.add(xterm.raw.registerMarker());
-            store.add(startMarker.onDispose(() => {
+            this._onDidCreateStartMarker.fire(this._startMarker = store.add(xterm.raw.registerMarker()));
+            store.add(this._startMarker.onDispose(() => {
                 this._log(`Start marker was disposed, recreating`);
-                startMarker = xterm.raw.registerMarker();
+                this._onDidCreateStartMarker.fire(this._startMarker = store.add(xterm.raw.registerMarker()));
             }));
+            if (this._hasReceivedUserInput()) {
+                this._log('Command timed out, sending SIGINT and retrying');
+                await this._instance.sendText('\x03', false);
+                await waitForIdle(this._instance.onData, 100);
+            }
             this._log(`Executing command line \`${commandLine}\``);
             this._instance.sendText(commandLine, true);
-            this._log('Waiting for idle');
-            await waitForIdle(this._instance.onData, 1000);
+            this._log('Waiting for idle with prompt heuristics');
+            const promptResult = await waitForIdleWithPromptHeuristics(this._instance.onData, this._instance, 1000, 10000);
+            this._log(`Prompt detection result: ${promptResult.detected ? 'detected' : 'not detected'} - ${promptResult.reason}`);
             if (token.isCancellationRequested) {
                 throw ( new CancellationError());
             }
@@ -43,7 +53,7 @@ let NoneExecuteStrategy = class NoneExecuteStrategy {
             let output;
             const additionalInformationLines = [];
             try {
-                output = xterm.getContentsAsText(startMarker, endMarker);
+                output = xterm.getContentsAsText(this._startMarker, endMarker);
                 this._log('Fetched output via markers');
             }
             catch {
@@ -65,7 +75,7 @@ let NoneExecuteStrategy = class NoneExecuteStrategy {
     }
 };
 NoneExecuteStrategy = ( __decorate([
-    ( __param(1, ITerminalLogService))
+    ( __param(2, ITerminalLogService))
 ], NoneExecuteStrategy));
 
 export { NoneExecuteStrategy };

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

@@ -1,8 +1,10 @@
 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 type { ICommandDetectionCapability } from "@codingame/monaco-vscode-a9da9abe-278d-5ce6-9418-99c7c07c5c37-common/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
@@ -15,6 +17,9 @@ export declare class RichExecuteStrategy implements ITerminalExecuteStrategy {
     private readonly _commandDetection;
     private readonly _logService;
     readonly type = "rich";
+    private _startMarker;
+    private readonly _onDidCreateStartMarker;
+    onDidCreateStartMarker: Event<IXtermMarker | undefined>;
     constructor(_instance: ITerminalInstance, _commandDetection: ICommandDetectionCapability, _logService: ITerminalLogService);
     execute(commandLine: string, token: CancellationToken): Promise<ITerminalExecuteStrategyResult>;
     private _log;

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

@@ -1,7 +1,7 @@
 
 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 { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { isNumber } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
@@ -13,6 +13,8 @@ let RichExecuteStrategy = class RichExecuteStrategy {
         this._commandDetection = _commandDetection;
         this._logService = _logService;
         this.type = 'rich';
+        this._onDidCreateStartMarker = ( new Emitter());
+        this.onDidCreateStartMarker = this._onDidCreateStartMarker.event;
     }
     async execute(commandLine, token) {
         const store = ( new DisposableStore());
@@ -34,10 +36,10 @@ let RichExecuteStrategy = class RichExecuteStrategy {
                     this._log('onDone via idle prompt');
                 }),
             ]);
-            let startMarker = store.add(xterm.raw.registerMarker());
-            store.add(startMarker.onDispose(() => {
+            this._onDidCreateStartMarker.fire(this._startMarker = store.add(xterm.raw.registerMarker()));
+            store.add(this._startMarker.onDispose(() => {
                 this._log(`Start marker was disposed, recreating`);
-                startMarker = xterm.raw.registerMarker();
+                this._onDidCreateStartMarker.fire(this._startMarker = store.add(xterm.raw.registerMarker()));
             }));
             this._log(`Executing command line \`${commandLine}\``);
             this._instance.runCommand(commandLine, true);
@@ -58,7 +60,7 @@ let RichExecuteStrategy = class RichExecuteStrategy {
             }
             if (output === undefined) {
                 try {
-                    output = xterm.getContentsAsText(startMarker, endMarker);
+                    output = xterm.getContentsAsText(this._startMarker, endMarker);
                     this._log('Fetched output via markers');
                 }
                 catch {