@codingame/monaco-vscode-katex-common 31.0.1 → 32.0.0

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

@@ -110,50 +110,112 @@ async function waitForIdleWithPromptHeuristics(onData, instance, idlePollInterva
         };
     }
 }
-async function trackIdleOnPrompt(instance, idleDurationMs, store, promptFallbackMs) {
+async function trackIdleOnPrompt(instance, idleDurationMs, store, promptFallbackMs, logService, options) {
     const idleOnPrompt = ( new DeferredPromise());
     const onData = instance.onData;
+    const log = logService ? msg => logService.info(`trackIdleOnPrompt: ${msg}`) : undefined;
+    let TerminalState;
+    (function(TerminalState) {
+        TerminalState[TerminalState["Initial"] = 0] = "Initial";
+        TerminalState[TerminalState["Prompt"] = 1] = "Prompt";
+        TerminalState[TerminalState["Executing"] = 2] = "Executing";
+        TerminalState[TerminalState["PromptAfterExecuting"] = 3] = "PromptAfterExecuting";
+    })(TerminalState || (TerminalState = {}));
+    const stateNames = {
+        [0 ]: "Initial",
+        [1 ]: "Prompt",
+        [2 ]: "Executing",
+        [3 ]: "PromptAfterExecuting"
+    };
+    let state = 0 ;
+    let dataEventCount = 0;
+    function setState(newState, reason) {
+        if (state !== newState) {
+            log?.(`State ${stateNames[state]} → ${stateNames[newState]} (${reason})`);
+            state = newState;
+        }
+    }
     const scheduler = store.add(( new RunOnceScheduler(() => {
+        log?.(`Idle scheduler fired, completing (dataEvents=${dataEventCount})`);
         idleOnPrompt.complete();
     }, idleDurationMs)));
-    let state = 0 ;
     const promptFallbackScheduler = store.add(( new RunOnceScheduler(() => {
         if (state === 2  || state === 3 ) {
             promptFallbackScheduler.cancel();
             return;
         }
-        state = 3 ;
+        log?.(`Prompt fallback fired (dataEvents=${dataEventCount})`);
+        setState(3, "promptFallback");
         scheduler.schedule();
     }, promptFallbackMs ?? 1000)));
-    let TerminalState;
-    (function(TerminalState) {
-        TerminalState[TerminalState["Initial"] = 0] = "Initial";
-        TerminalState[TerminalState["Prompt"] = 1] = "Prompt";
-        TerminalState[TerminalState["Executing"] = 2] = "Executing";
-        TerminalState[TerminalState["PromptAfterExecuting"] = 3] = "PromptAfterExecuting";
-    })(TerminalState || (TerminalState = {}));
+    const disableFallbacks = options?.disableFallbacks ?? false;
+    const initialFallbackScheduler = store.add(( new RunOnceScheduler(() => {
+        if (state === 2  || state === 3 ) {
+            log?.(`Initial fallback fired but state is ${stateNames[state]}, skipping`);
+            return;
+        }
+        log?.(`Initial fallback fired, no data events received`);
+        setState(3, "initialFallback");
+        scheduler.schedule();
+    }, 10_000)));
+    if (!disableFallbacks) {
+        initialFallbackScheduler.schedule();
+    }
+    const executingFallbackScheduler = store.add(( new RunOnceScheduler(() => {
+        if (state === 2 ) {
+            log?.(
+                `Executing fallback fired after 30s data-idle (dataEvents=${dataEventCount})`
+            );
+            setState(3, "executingFallback");
+            scheduler.schedule();
+        }
+    }, 30_000)));
+    const hardCapScheduler = store.add(( new RunOnceScheduler(() => {
+        if (state === 0  || state === 1 ) {
+            log?.(
+                `Hard cap fired after 5min in state ${stateNames[state]} (dataEvents=${dataEventCount})`
+            );
+            setState(3, "hardCap");
+            scheduler.schedule();
+        }
+    }, 60_000)));
+    if (!disableFallbacks) {
+        hardCapScheduler.schedule();
+    }
     store.add(onData(e => {
+        dataEventCount++;
+        initialFallbackScheduler.cancel();
         const matches = e.matchAll(/(?:\x1b\]|\x9d)[16]33;(?<type>[ACD])(?:;.*)?(?:\x1b\\|\x07|\x9c)/g);
         for (const match of matches) {
             if (match.groups?.type === "A") {
                 if (state === 0 ) {
-                    state = 1 ;
+                    setState(1, "sequence A");
                 } else if (state === 2 ) {
-                    state = 3 ;
+                    setState(3, "sequence A after executing");
+                    executingFallbackScheduler.cancel();
                 }
             } else if (match.groups?.type === "C" || match.groups?.type === "D") {
-                state = 2 ;
+                setState(2, `sequence ${match.groups?.type}`);
+                if (!disableFallbacks) {
+                    executingFallbackScheduler.schedule();
+                }
             }
         }
         if (state === 3 ) {
             promptFallbackScheduler.cancel();
+            executingFallbackScheduler.cancel();
             scheduler.schedule();
         } else {
             scheduler.cancel();
             if (state === 0  || state === 1 ) {
-                promptFallbackScheduler.schedule();
+                if (!disableFallbacks) {
+                    promptFallbackScheduler.schedule();
+                }
             } else {
                 promptFallbackScheduler.cancel();
+                if (!disableFallbacks) {
+                    executingFallbackScheduler.schedule();
+                }
             }
         }
     }));

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

@@ -9,6 +9,7 @@ import { waitForIdle, waitForIdleWithPromptHeuristics } from './executeStrategy.
 import { createAltBufferPromise, setupRecreatingStartMarker, stripCommandEchoAndPrompt } from './strategyHelpers.js';
 import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
 import { isMacintosh } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { isMultilineCommand } from '../runInTerminalHelpers.js';
 
 let NoneExecuteStrategy = class NoneExecuteStrategy extends Disposable {
     constructor(_instance, _hasReceivedUserInput, _configurationService, _logService) {
@@ -48,14 +49,14 @@ let NoneExecuteStrategy = class NoneExecuteStrategy extends Disposable {
                 this._log.bind(this)
             );
             if (this._hasReceivedUserInput()) {
-                this._log("Command timed out, sending SIGINT and retrying");
-                await this._instance.sendText("\u0003", false);
+                this._log("Sending Ctrl+U to clear any pending input before sending command");
+                await this._instance.sendText("\u0015", false);
                 await waitForIdle(this._instance.onData, 100);
             }
             this._log(`Executing command line \`${commandLine}\``);
             markerRecreation.dispose();
             const startLine = this._startMarker.value?.line;
-            const forceBracketedPasteMode = isMacintosh;
+            const forceBracketedPasteMode = isMacintosh || isMultilineCommand(commandLine);
             this._instance.sendText(commandLine, true, forceBracketedPasteMode);
             if (startLine !== undefined) {
                 this._log("Waiting for cursor to move past start line");

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

@@ -17,13 +17,21 @@ import type { IMarker as IXtermMarker } from "@xterm/xterm";
 export declare class RichExecuteStrategy extends Disposable implements ITerminalExecuteStrategy {
     private readonly _instance;
     private readonly _commandDetection;
+    private readonly _isSyncMode;
     private readonly _configurationService;
     private readonly _logService;
     readonly type = "rich";
     private readonly _startMarker;
     private readonly _onDidCreateStartMarker;
     onDidCreateStartMarker: Event<IXtermMarker | undefined>;
-    constructor(_instance: ITerminalInstance, _commandDetection: ICommandDetectionCapability, _configurationService: IConfigurationService, _logService: ITerminalLogService);
+    /**
+     * Tracks per-execute() DisposableStores so they can be cleaned up if the
+     * strategy is disposed mid-flight, AND removed from this collection on
+     * successful completion to avoid accumulating stale references when
+     * execute() is invoked many times on the same strategy instance.
+     */
+    private readonly _executionStores;
+    constructor(_instance: ITerminalInstance, _commandDetection: ICommandDetectionCapability, _isSyncMode: boolean, _configurationService: IConfigurationService, _logService: ITerminalLogService);
     execute(commandLine: string, token: CancellationToken, commandId?: string, commandLineForMetadata?: string): Promise<ITerminalExecuteStrategyResult>;
     private _log;
 }

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

@@ -10,51 +10,109 @@ import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/plat
 import { trackIdleOnPrompt } from './executeStrategy.js';
 import { createAltBufferPromise, setupRecreatingStartMarker, stripCommandEchoAndPrompt } from './strategyHelpers.js';
 import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
+import { isMultilineCommand } from '../runInTerminalHelpers.js';
 
+function isTerminalLaunchError(value) {
+    return typeof value === "object" && value !== null && "message" in value;
+}
+function formatExitCodeOrError(exitCodeOrError) {
+    if (isTerminalLaunchError(exitCodeOrError)) {
+        return `launch error: ${exitCodeOrError.message}${exitCodeOrError.code !== undefined ? `, code=${exitCodeOrError.code}` : ""}`;
+    }
+    return `code=${exitCodeOrError}`;
+}
+function extractExitCode(exitCodeOrError) {
+    if (isNumber(exitCodeOrError)) {
+        return exitCodeOrError;
+    }
+    if (isTerminalLaunchError(exitCodeOrError)) {
+        return exitCodeOrError.code;
+    }
+    return undefined;
+}
 let RichExecuteStrategy = class RichExecuteStrategy extends Disposable {
-    constructor(_instance, _commandDetection, _configurationService, _logService) {
+    constructor(
+        _instance,
+        _commandDetection,
+        _isSyncMode,
+        _configurationService,
+        _logService
+    ) {
         super();
         this._instance = _instance;
         this._commandDetection = _commandDetection;
+        this._isSyncMode = _isSyncMode;
         this._configurationService = _configurationService;
         this._logService = _logService;
         this.type = "rich";
         this._startMarker = this._register(( new MutableDisposable()));
         this._onDidCreateStartMarker = this._register(( new Emitter()));
         this.onDidCreateStartMarker = this._onDidCreateStartMarker.event;
+        this._executionStores = this._register(( new DisposableStore()));
     }
     async execute(commandLine, token, commandId, commandLineForMetadata) {
         const store = ( new DisposableStore());
-        this._register(store);
+        this._executionStores.add(store);
         try {
+            if (this._instance.isDisposed) {
+                this._log("Terminal already disposed at strategy entry");
+                throw ( new Error("The terminal was closed"));
+            }
+            if (this._instance.exitCode !== undefined) {
+                this._log(
+                    `Terminal pty already exited at strategy entry (code=${this._instance.exitCode})`
+                );
+                return {
+                    output: undefined,
+                    exitCode: this._instance.exitCode,
+                    additionalInformation: `Command exited with code ${this._instance.exitCode}`
+                };
+            }
+            const idlePollInterval = this._configurationService.getValue(TerminalChatAgentToolsSettingId.IdlePollInterval) ?? 1000;
+            const staleMarker = this._commandDetection.executingCommandObject?.marker;
+            const onCommandFinishedFiltered = staleMarker ? Event.filter(
+                this._commandDetection.onCommandFinished,
+                e => e.marker !== staleMarker,
+                store
+            ) : this._commandDetection.onCommandFinished;
+            const onDone = Promise.race([Event.toPromise(onCommandFinishedFiltered, store).then(e => {
+                this._log("onDone via end event");
+                return {
+                    "type": "success",
+                    command: e
+                };
+            }), Event.toPromise(token.onCancellationRequested, store).then(() => {
+                this._log("onDone via cancellation");
+            }), Event.toPromise(this._instance.onDisposed, store).then(() => {
+                this._log("onDone via terminal disposal");
+                return {
+                    type: "disposal"
+                };
+            }), Event.toPromise(this._instance.onExit, store).then(exitCodeOrError => {
+                this._log(`onDone via process exit (${formatExitCodeOrError(exitCodeOrError)})`);
+                return {
+                    type: "processExit",
+                    exitCodeOrError
+                };
+            }),
+            ...(this._isSyncMode ? [trackIdleOnPrompt(
+                this._instance,
+                idlePollInterval,
+                store,
+                idlePollInterval,
+                this._logService,
+                {
+                    disableFallbacks: true
+                }
+            ).then(() => {
+                this._log("onDone via idle prompt");
+            })] : [])]);
             this._log("Waiting for xterm");
             const xterm = await this._instance.xtermReadyPromise;
             if (!xterm) {
                 throw ( new Error("Xterm is not available"));
             }
             const alternateBufferPromise = createAltBufferPromise(xterm, store, this._log.bind(this));
-            const idlePollInterval = this._configurationService.getValue(TerminalChatAgentToolsSettingId.IdlePollInterval) ?? 1000;
-            const onDone = Promise.race([
-                Event.toPromise(this._commandDetection.onCommandFinished, store).then(e => {
-                    this._log("onDone via end event");
-                    return {
-                        "type": "success",
-                        command: e
-                    };
-                }),
-                Event.toPromise(token.onCancellationRequested, store).then(() => {
-                    this._log("onDone via cancellation");
-                }),
-                Event.toPromise(this._instance.onDisposed, store).then(() => {
-                    this._log("onDone via terminal disposal");
-                    return {
-                        type: "disposal"
-                    };
-                }),
-                trackIdleOnPrompt(this._instance, idlePollInterval, store, idlePollInterval).then(() => {
-                    this._log("onDone via idle prompt");
-                })
-            ]);
             const markerRecreation = setupRecreatingStartMarker(
                 xterm,
                 this._startMarker,
@@ -64,7 +122,7 @@ let RichExecuteStrategy = class RichExecuteStrategy extends Disposable {
             );
             this._log(`Executing command line \`${commandLine}\``);
             markerRecreation.dispose();
-            const forceBracketedPasteMode = isMacintosh;
+            const forceBracketedPasteMode = isMacintosh || isMultilineCommand(commandLine);
             this._instance.runCommand(
                 commandLine,
                 true,
@@ -117,7 +175,10 @@ let RichExecuteStrategy = class RichExecuteStrategy extends Disposable {
             if (output !== undefined && output.trim().length === 0) {
                 additionalInformationLines.push("Command produced no output");
             }
-            const exitCode = finishedCommand?.exitCode;
+            let exitCode = finishedCommand?.exitCode;
+            if (exitCode === undefined && onDoneResult && onDoneResult.type === "processExit") {
+                exitCode = extractExitCode(onDoneResult.exitCodeOrError);
+            }
             if (isNumber(exitCode) && exitCode > 0) {
                 additionalInformationLines.push(`Command exited with code ${exitCode}`);
             }
@@ -127,7 +188,7 @@ let RichExecuteStrategy = class RichExecuteStrategy extends Disposable {
                 exitCode
             };
         } finally {
-            store.dispose();
+            this._executionStores.delete(store);
         }
     }
     _log(message) {
@@ -139,6 +200,6 @@ let RichExecuteStrategy = class RichExecuteStrategy extends Disposable {
         }
     }
 };
-RichExecuteStrategy = ( __decorate([( __param(2, IConfigurationService)), ( __param(3, ITerminalLogService))], RichExecuteStrategy));
+RichExecuteStrategy = ( __decorate([( __param(3, IConfigurationService)), ( __param(4, ITerminalLogService))], RichExecuteStrategy));
 
 export { RichExecuteStrategy };

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

@@ -1,7 +1,7 @@
 
 import { truncateOutputKeepingTail } from './runInTerminalHelpers.js';
 
-const MAX_OUTPUT_LENGTH = 16000;
+const MAX_OUTPUT_LENGTH = 60000;
 function getOutput(instance, startMarker, options) {
     if (!instance.xterm || !instance.xterm.raw) {
         return '';

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

@@ -8,7 +8,6 @@ export declare function isBash(envShell: string, os: OperatingSystem): boolean;
 export declare function isFish(envShell: string, os: OperatingSystem): boolean;
 export declare const TRUNCATION_MESSAGE = "\n\n[... PREVIOUS OUTPUT TRUNCATED ...]\n\n";
 export declare function truncateOutputKeepingTail(output: string, maxLength: number): string;
-export declare function sanitizeTerminalOutput(output: string): string;
 /**
  * Normalizes command text for UI display by removing unnecessary quote and forward slash
  * escaping artifacts (for example: \" \' \/) commonly produced in streamed tool-call JSON.
@@ -24,6 +23,17 @@ export declare function buildCommandDisplayText(command: string): string;
  * This prevents multi-line input from being sent as multiple commands via sendText.
  */
 export declare function normalizeCommandForExecution(command: string): string;
+/**
+ * Whether a command spans multiple lines (heredoc, multi-statement block, etc.).
+ * Multi-line commands must be sent verbatim through bracketed paste mode so the
+ * shell treats them as a single paste instead of executing each line as it
+ * arrives.
+ *
+ * Bare line continuations (`\` immediately before a newline) are **not**
+ * considered multi-line because the shell joins them into a single logical
+ * line. Only newlines that are *not* preceded by a backslash count.
+ */
+export declare function isMultilineCommand(command: string): boolean;
 export declare function generateAutoApproveActions(commandLine: string, subCommands: string[], autoApproveResult: {
     subCommandResults: ICommandApprovalResultWithReason[];
     commandLineResult: ICommandApprovalResultWithReason;

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

@@ -57,6 +57,10 @@ function buildCommandDisplayText(command) {
 function normalizeCommandForExecution(command) {
     return command.replace(/\r\n|\r|\n/g, " ").trim();
 }
+function isMultilineCommand(command) {
+    const normalized = command.replace(/\r\n|\r/g, "\n");
+    return /(?<!\\)\n/.test(normalized);
+}
 function generateAutoApproveActions(commandLine, subCommands, autoApproveResult) {
     const actions = [];
     const canCreateAutoApproval = (autoApproveResult.subCommandResults.every(e => e.result !== "denied") && autoApproveResult.commandLineResult.result !== "denied");
@@ -162,7 +166,7 @@ function generateAutoApproveActions(commandLine, subCommands, autoApproveResult)
         const firstSubcommandFirstWord = unapprovedSubCommands.length > 0 ? unapprovedSubCommands[0].split(" ")[0] : "";
         if (firstSubcommandFirstWord !== commandLine && !( commandsWithSubcommands.has(commandLine)) && !( commandsWithSubSubCommands.has(commandLine))) {
             actions.push({
-                label: ( localize(13997, "Allow Exact Command Line in this Session")),
+                label: ( localize(14286, "Allow Exact Command Line in this Session")),
                 data: {
                     type: "newRule",
                     rule: {
@@ -176,7 +180,7 @@ function generateAutoApproveActions(commandLine, subCommands, autoApproveResult)
                 }
             });
             actions.push({
-                label: ( localize(13998, "Allow Exact Command Line in this Workspace")),
+                label: ( localize(14287, "Allow Exact Command Line in this Workspace")),
                 data: {
                     type: "newRule",
                     rule: {
@@ -190,7 +194,7 @@ function generateAutoApproveActions(commandLine, subCommands, autoApproveResult)
                 }
             });
             actions.push({
-                label: ( localize(13999, "Always Allow Exact Command Line")),
+                label: ( localize(14288, "Always Allow Exact Command Line")),
                 data: {
                     type: "newRule",
                     rule: {
@@ -209,15 +213,15 @@ function generateAutoApproveActions(commandLine, subCommands, autoApproveResult)
         actions.push(( new Separator()));
     }
     actions.push({
-        label: ( localize(14000, "Allow All Commands in this Session")),
-        tooltip: ( localize(14001, "Allow this tool to run in this session without confirmation.")),
+        label: ( localize(14289, "Allow All Commands in this Session")),
+        tooltip: ( localize(14290, "Allow this tool to run in this session without confirmation.")),
         data: {
             type: "sessionApproval"
         }
     });
     actions.push(( new Separator()));
     actions.push({
-        label: ( localize(14002, "Configure Auto Approve...")),
+        label: ( localize(14291, "Configure Auto Approve...")),
         data: {
             type: "configure"
         }
@@ -253,4 +257,4 @@ function extractCdPrefix(commandLine, shell, os) {
     return undefined;
 }
 
-export { TRUNCATION_MESSAGE, buildCommandDisplayText, dedupeRules, extractCdPrefix, generateAutoApproveActions, isBash, isFish, isPowerShell, isWindowsPowerShell, isZsh, normalizeCommandForExecution, normalizeTerminalCommandForDisplay, truncateOutputKeepingTail };
+export { TRUNCATION_MESSAGE, buildCommandDisplayText, dedupeRules, extractCdPrefix, generateAutoApproveActions, isBash, isFish, isMultilineCommand, isPowerShell, isWindowsPowerShell, isZsh, normalizeCommandForExecution, normalizeTerminalCommandForDisplay, truncateOutputKeepingTail };

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

@@ -1,9 +1,11 @@
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
 import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
 import type { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
 import { ShellIntegrationQuality } from "./toolTerminalCreator.js";
 export declare class RunInTerminalToolTelemetry {
     private readonly _telemetryService;
-    constructor(_telemetryService: ITelemetryService);
+    private readonly _configurationService;
+    constructor(_telemetryService: ITelemetryService, _configurationService: IConfigurationService);
     logPrepare(state: {
         terminalToolSessionId: string | undefined;
         subCommands: string[];

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

@@ -1,12 +1,15 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
 import { TelemetryTrustedValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetryUtils';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { ShellIntegrationQuality } from './toolTerminalCreator.js';
 
 let RunInTerminalToolTelemetry = class RunInTerminalToolTelemetry {
-    constructor(_telemetryService) {
+    constructor(_telemetryService, _configurationService) {
         this._telemetryService = _telemetryService;
+        this._configurationService = _configurationService;
     }
     logPrepare(state) {
         const subCommandsSanitized = ( state.subCommands.map(e => {
@@ -76,11 +79,12 @@ let RunInTerminalToolTelemetry = class RunInTerminalToolTelemetry {
             inputToolManualChars: state.inputToolManualChars ?? 0,
             inputToolManualShownCount: state.inputToolManualShownCount ?? 0,
             inputToolFreeFormInputShownCount: state.inputToolFreeFormInputShownCount ?? 0,
-            inputToolFreeFormInputCount: state.inputToolFreeFormInputCount ?? 0
+            inputToolFreeFormInputCount: state.inputToolFreeFormInputCount ?? 0,
+            compressOutputEnabled: this._configurationService.getValue(ChatConfiguration.CompressOutputEnabled) === true
         });
     }
 };
-RunInTerminalToolTelemetry = ( __decorate([( __param(0, ITelemetryService))], RunInTerminalToolTelemetry));
+RunInTerminalToolTelemetry = ( __decorate([( __param(0, ITelemetryService)), ( __param(1, IConfigurationService))], RunInTerminalToolTelemetry));
 const commandAllowList = ( new Set([
 "!", "@", "#", "$", "%", "^", "&", "*", "(", ")", "~", "{", "}", "<", ">",
 ".", "7z", "alias", "assoc", "attrib", "awk", "basename", "bg", "blkid", "bunzip2", "bzip2", "cat", "cd", "certutil", "chkdsk", "chmod", "chown", "cipher", "clear", "cls", "cmp", "column", "comm", "compact", "compress", "copy", "cp", "curl", "cut", "date", "dd", "del", "df", "diff", "dig", "dir", "dirname", "diskpart", "dism", "disown", "du", "echo", "env", "erase", "eval", "expand", "export", "fc", "fdisk", "fg", "file", "find", "findstr", "fmt", "fold", "forfiles", "format", "free", "fsck", "git", "gpupdate", "grep", "groupadd", "groups", "gunzip", "gzip", "hash", "head", "hexdump", "history", "host", "htop", "icacls", "id", "ifconfig", "iostat", "ip", "ipconfig", "iptables", "jobs", "jq", "kill", "killall", "less", "ln", "locate", "ls", "lsblk", "lscpu", "lsof", "man", "mkdir", "mklink", "more", "mount", "move", "mv", "nbtstat", "nc/netcat", "net", "netstat", "nice", "nl", "nohup", "nslookup", "nslookup", "od", "passwd", "paste", "pathping", "pause", "pgrep", "ping", "pkill", "powercfg", "pr", "printenv", "ps", "pwd", "query", "rar", "readlink", "realpath", "reg", "rem", "ren", "rename", "renice", "rev", "rm", "rmdir", "robocopy", "route", "rsync", "sc", "schtasks", "scp", "sed", "seq", "set", "setx", "sfc", "shred", "shuf", "shutdown", "sleep", "sort", "source", "split", "ss", "ssh", "stat", "strings", "su", "subst", "sudo", "systeminfo", "tac", "tail", "tar", "tee", "telnet", "test", "time", "top", "touch", "tr", "traceroute", "tracert", "tree", "true", "truncate", "type", "type", "umask", "umount", "unalias", "uname", "uncompress", "unexpand", "uniq", "unlink", "unrar", "unzip", "uptime", "useradd", "usermod", "vmstat", "vol", "watch", "wc", "wget", "where", "whereis", "which", "who", "whoami", "wmic", "xargs", "xcopy", "xxd", "xz", "yes", "zcat", "zip", "zless", "zmore",

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

@@ -257,7 +257,7 @@ let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
             function checkTarget(inspectValue) {
                 return (isObject(inspectValue) && Object.prototype.hasOwnProperty.call(inspectValue, key) && 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);
+            const sourceTarget = (checkTarget(configInspectValue.workspaceFolderValue) ? 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 (ignoreDefaults && isDefaultRule && sourceTarget === ConfigurationTarget.DEFAULT) {
                 continue;
             }

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/npmScriptAutoApprover.js

@@ -154,7 +154,7 @@ let NpmScriptAutoApprover = class NpmScriptAutoApprover extends Disposable {
             isAutoApproved: true,
             scriptName,
             autoApproveInfo: ( new MarkdownString(( localize(
-                14005,
+                14294,
                 "Auto approved as {0} is defined in package.json",
                 `\`${scriptName}\``
             ))))

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

@@ -31,6 +31,7 @@ export interface ICommandLineAnalyzerOptions {
     terminalToolSessionId: string;
     chatSessionResource: URI | undefined;
     requiresUnsandboxConfirmation?: boolean;
+    hasSessionAutoApproval?: boolean;
 }
 export interface ICommandLineAnalyzerResult {
     /**

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineAutoApproveAnalyzer.js

@@ -56,7 +56,7 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
                 isAutoApproved: true,
                 isAutoApproveAllowed: true,
                 disclaimers: [],
-                autoApproveInfo: ( new MarkdownString(`${( localize(14006, "Auto approved for this session"))} ([${( localize(14007, "Disable"))}](${( disableUri.toString())}))`, mdTrustSettings))
+                autoApproveInfo: ( new MarkdownString(`${( localize(14295, "Auto approved for this session"))} ([${( localize(14296, "Disable"))}](${( disableUri.toString())}))`, mdTrustSettings))
             };
         }
         const trimmedCommandLine = options.commandLine.trimStart();
@@ -158,7 +158,7 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
         const subCommandsLowerFirstWordOnly = ( subCommands.map(command => command.split(" ")[0].toLowerCase()));
         if (!isAutoApproved && (( subCommandsLowerFirstWordOnly.some(command => promptInjectionWarningCommandsLower.includes(command))) || (isPowerShell(options.shell, options.os) && ( subCommandsLowerFirstWordOnly.some(command => promptInjectionWarningCommandsLowerPwshOnly.includes(command)))))) {
             disclaimers.push(( localize(
-                14008,
+                14297,
                 "Web content may contain malicious code or attempt prompt injection attacks."
             )));
         }
@@ -199,10 +199,10 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
             return ( asArray(result).filter(e => isAutoApproveRule(e.rule)).map(e => {
                 const escapedSourceText = e.rule.sourceText.replaceAll("$", "\\$");
                 if (e.rule.sourceTarget === "session") {
-                    return localize(14009, "{0} (session)", `\`${escapedSourceText}\``);
+                    return localize(14298, "{0} (session)", `\`${escapedSourceText}\``);
                 }
                 const settingsUri = createCommandUri(TerminalChatCommandId.OpenTerminalSettingsLink, e.rule.sourceTarget);
-                const tooltip = ( localize(14010, "View rule in settings"));
+                const tooltip = ( localize(14299, "View rule in settings"));
                 let label = escapedSourceText;
                 switch (e.rule?.sourceTarget) {
                 case ConfigurationTarget.DEFAULT:
@@ -233,9 +233,9 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
         if (isGlobalAutoApproved) {
             const settingsUri = createCommandUri(TerminalChatCommandId.OpenTerminalSettingsLink, "global");
             return (new MarkdownString(`${( localize(
-                14011,
+                14300,
                 "Auto approved by setting {0}",
-                `[\`${ChatConfiguration.GlobalAutoApprove}\`](${( settingsUri.toString())} "${( localize(14012, "View settings"))}")`
+                `[\`${ChatConfiguration.GlobalAutoApprove}\`](${( settingsUri.toString())} "${( localize(14301, "View settings"))}")`
             ))}`, mdTrustSettings));
         }
         if (isAutoApproved) {
@@ -244,7 +244,7 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
                 {
                     if (isAutoApproveRule(commandLineResult.rule)) {
                         return (new MarkdownString(
-                            localize(14013, "Auto approved by rule {0}", formatRuleLinks(commandLineResult)),
+                            localize(14302, "Auto approved by rule {0}", formatRuleLinks(commandLineResult)),
                             mdTrustSettings
                         ));
                     }
@@ -259,12 +259,12 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
                     const uniqueRules = dedupeRules(subCommandResults);
                     if (uniqueRules.length === 1) {
                         return (new MarkdownString(
-                            localize(14013, "Auto approved by rule {0}", formatRuleLinks(uniqueRules)),
+                            localize(14302, "Auto approved by rule {0}", formatRuleLinks(uniqueRules)),
                             mdTrustSettings
                         ));
                     } else if (uniqueRules.length > 1) {
                         return (new MarkdownString(
-                            localize(14014, "Auto approved by rules {0}", formatRuleLinks(uniqueRules)),
+                            localize(14303, "Auto approved by rules {0}", formatRuleLinks(uniqueRules)),
                             mdTrustSettings
                         ));
                     }
@@ -277,7 +277,7 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
                 {
                     if (commandLineResult.rule) {
                         return (new MarkdownString(localize(
-                            14015,
+                            14304,
                             "Auto approval denied by rule {0}",
                             formatRuleLinks(commandLineResult)
                         ), mdTrustSettings));
@@ -289,12 +289,12 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
                     const uniqueRules = dedupeRules(subCommandResults.filter(e => e.result === "denied"));
                     if (uniqueRules.length === 1) {
                         return (new MarkdownString(
-                            localize(14015, "Auto approval denied by rule {0}", formatRuleLinks(uniqueRules)),
+                            localize(14304, "Auto approval denied by rule {0}", formatRuleLinks(uniqueRules)),
                             mdTrustSettings
                         ));
                     } else if (uniqueRules.length > 1) {
                         return (new MarkdownString(
-                            localize(14016, "Auto approval denied by rules {0}", formatRuleLinks(uniqueRules)),
+                            localize(14305, "Auto approval denied by rules {0}", formatRuleLinks(uniqueRules)),
                             mdTrustSettings
                         ));
                     }

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

@@ -16,4 +16,12 @@ export declare class CommandLineFileWriteAnalyzer extends Disposable implements
     private _stripSurroundingQuotes;
     private _mapNullDevice;
     private _getResult;
+    /**
+     * Returns true if the given URI path points inside an OS temporary directory.
+     * On posix systems this matches `/tmp/`. On Windows this matches any `temp`
+     * or `tmp` directory segment (case-insensitive), which covers the canonical
+     * user temp (`...\AppData\Local\Temp\`), system temp (`C:\Windows\Temp\`),
+     * and common dev conventions like `C:\Temp\` and `C:\tmp\`.
+     */
+    private _isInTempDirectory;
 }