@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

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

@@ -18,18 +18,18 @@ import { isAutoApproveRule, isNpmScriptAutoApproveRule } from './commandLineAnal
 import { TerminalChatCommandId } from '@codingame/monaco-vscode-xterm-common/vscode/vs/workbench/contrib/terminalContrib/chat/browser/terminalChat';
 import { CommandLineAutoApprover } from './autoApprove/commandLineAutoApprover.js';
 
-const promptInjectionWarningCommandsLower = [
-    'curl',
-    'wget',
-];
-const promptInjectionWarningCommandsLowerPwshOnly = [
-    'invoke-restmethod',
-    'invoke-webrequest',
-    'irm',
-    'iwr',
-];
+const promptInjectionWarningCommandsLower = ["curl", "wget"];
+const promptInjectionWarningCommandsLowerPwshOnly = ["invoke-restmethod", "invoke-webrequest", "irm", "iwr"];
 let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extends Disposable {
-    constructor(_treeSitterCommandParser, _telemetry, _log, _configurationService, instantiationService, _storageService, _terminalChatService) {
+    constructor(
+        _treeSitterCommandParser,
+        _telemetry,
+        _log,
+        _configurationService,
+        instantiationService,
+        _storageService,
+        _terminalChatService
+    ) {
         super();
         this._treeSitterCommandParser = _treeSitterCommandParser;
         this._telemetry = _telemetry;
@@ -40,9 +40,12 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
         this._commandLineAutoApprover = this._register(instantiationService.createInstance(CommandLineAutoApprover));
     }
     async analyze(options) {
-        if (options.chatSessionId && this._terminalChatService.hasChatSessionAutoApproval(options.chatSessionId)) {
-            this._log('Session has auto approval enabled, auto approving command');
-            const disableUri = createCommandUri(TerminalChatCommandId.DisableSessionAutoApproval, options.chatSessionId);
+        if (options.chatSessionResource && this._terminalChatService.hasChatSessionAutoApproval(options.chatSessionResource)) {
+            this._log("Session has auto approval enabled, auto approving command");
+            const disableUri = createCommandUri(
+                TerminalChatCommandId.DisableSessionAutoApproval,
+                options.chatSessionResource
+            );
             const mdTrustSettings = {
                 isTrusted: {
                     enabledCommands: [TerminalChatCommandId.DisableSessionAutoApproval]
@@ -52,16 +55,18 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
                 isAutoApproved: true,
                 isAutoApproveAllowed: true,
                 disclaimers: [],
-                autoApproveInfo: ( new MarkdownString(`${( localize(12023, 'Auto approved for this session'))} ([${( localize(12024, 'Disable'))}](${( disableUri.toString())}))`, mdTrustSettings)),
+                autoApproveInfo: ( new MarkdownString(`${( localize(12354, "Auto approved for this session"))} ([${( localize(12355, "Disable"))}](${( disableUri.toString())}))`, mdTrustSettings))
             };
         }
         const trimmedCommandLine = options.commandLine.trimStart();
         let subCommands;
         try {
             subCommands = await this._treeSitterCommandParser.extractSubCommands(options.treeSitterLanguage, trimmedCommandLine);
-            this._log(`Parsed sub-commands via ${options.treeSitterLanguage} grammar`, subCommands);
-        }
-        catch (e) {
+            this._log(
+                `Parsed sub-commands via ${options.treeSitterLanguage} grammar`,
+                subCommands
+            );
+        } catch (e) {
             console.error(e);
             this._log(`Failed to parse sub-commands via ${options.treeSitterLanguage} grammar`);
         }
@@ -71,50 +76,43 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
         if (!subCommands) {
             return {
                 isAutoApproveAllowed: false,
-                disclaimers: [],
+                disclaimers: []
             };
         }
         const subCommandResults = await Promise.all(( subCommands.map(
-            e => this._commandLineAutoApprover.isCommandAutoApproved(e, options.shell, options.os, options.cwd, options.chatSessionId)
+            e => this._commandLineAutoApprover.isCommandAutoApproved(e, options.shell, options.os, options.cwd, options.chatSessionResource)
         )));
-        const commandLineResult = this._commandLineAutoApprover.isCommandLineAutoApproved(trimmedCommandLine, options.chatSessionId);
-        const autoApproveReasons = [
-            ...( subCommandResults.map(e => e.reason)),
-            commandLineResult.reason,
-        ];
+        const commandLineResult = this._commandLineAutoApprover.isCommandLineAutoApproved(trimmedCommandLine, options.chatSessionResource);
+        const autoApproveReasons = [...( subCommandResults.map(e => e.reason)), commandLineResult.reason];
         let isDenied = false;
         let autoApproveReason;
         let autoApproveDefault;
-        const deniedSubCommandResult = subCommandResults.find(e => e.result === 'denied');
+        const deniedSubCommandResult = subCommandResults.find(e => e.result === "denied");
         if (deniedSubCommandResult) {
-            this._log('Sub-command DENIED auto approval');
+            this._log("Sub-command DENIED auto approval");
             isDenied = true;
             autoApproveDefault = isAutoApproveRule(deniedSubCommandResult.rule) ? deniedSubCommandResult.rule.isDefaultRule : undefined;
-            autoApproveReason = 'subCommand';
-        }
-        else if (commandLineResult.result === 'denied') {
-            this._log('Command line DENIED auto approval');
+            autoApproveReason = "subCommand";
+        } else if (commandLineResult.result === "denied") {
+            this._log("Command line DENIED auto approval");
             isDenied = true;
             autoApproveDefault = isAutoApproveRule(commandLineResult.rule) ? commandLineResult.rule.isDefaultRule : undefined;
-            autoApproveReason = 'commandLine';
-        }
-        else {
-            if (subCommandResults.every(e => e.result === 'approved')) {
-                this._log('All sub-commands auto-approved');
+            autoApproveReason = "commandLine";
+        } else {
+            if (subCommandResults.every(e => e.result === "approved")) {
+                this._log("All sub-commands auto-approved");
                 isAutoApproved = true;
-                autoApproveReason = 'subCommand';
+                autoApproveReason = "subCommand";
                 autoApproveDefault = subCommandResults.every(e => isAutoApproveRule(e.rule) && e.rule.isDefaultRule);
-            }
-            else {
-                this._log('All sub-commands NOT auto-approved');
-                if (commandLineResult.result === 'approved') {
-                    this._log('Command line auto-approved');
-                    autoApproveReason = 'commandLine';
+            } else {
+                this._log("All sub-commands NOT auto-approved");
+                if (commandLineResult.result === "approved") {
+                    this._log("Command line auto-approved");
+                    autoApproveReason = "commandLine";
                     isAutoApproved = true;
                     autoApproveDefault = isAutoApproveRule(commandLineResult.rule) ? commandLineResult.rule.isDefaultRule : undefined;
-                }
-                else {
-                    this._log('Command line NOT auto-approved');
+                } else {
+                    this._log("Command line NOT auto-approved");
                 }
             }
         }
@@ -122,76 +120,98 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
             this._log(`- ${reason}`);
         }
         const isAutoApproveEnabled = this._configurationService.getValue(TerminalChatAgentToolsSettingId.EnableAutoApprove) === true;
-        const isAutoApproveWarningAccepted = this._storageService.getBoolean(TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted, StorageScope.APPLICATION, false);
+        const isAutoApproveWarningAccepted = this._storageService.getBoolean(
+            TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted,
+            StorageScope.APPLICATION,
+            false
+        );
         if (isAutoApproveEnabled && isAutoApproved) {
-            autoApproveInfo = this._createAutoApproveInfo(isAutoApproved, isDenied, autoApproveReason, subCommandResults, commandLineResult);
-        }
-        else {
+            autoApproveInfo = this._createAutoApproveInfo(
+                isAutoApproved,
+                isDenied,
+                autoApproveReason,
+                subCommandResults,
+                commandLineResult
+            );
+        } else {
             isAutoApproved = false;
         }
         this._telemetry.logPrepare({
             terminalToolSessionId: options.terminalToolSessionId,
             subCommands,
-            autoApproveAllowed: !isAutoApproveEnabled ? 'off' : isAutoApproveWarningAccepted ? 'allowed' : 'needsOptIn',
-            autoApproveResult: isAutoApproved ? 'approved' : isDenied ? 'denied' : 'manual',
+            autoApproveAllowed: !isAutoApproveEnabled ? "off" : isAutoApproveWarningAccepted ? "allowed" : "needsOptIn",
+            autoApproveResult: isAutoApproved ? "approved" : isDenied ? "denied" : "manual",
             autoApproveReason,
             autoApproveDefault
         });
         const disclaimers = [];
-        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)))))) {
+        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(
-                12025,
-                'Web content may contain malicious code or attempt prompt injection attacks.'
+                12356,
+                "Web content may contain malicious code or attempt prompt injection attacks."
             )));
         }
         if (isAutoApproveEnabled && isDenied) {
-            const denialInfo = this._createAutoApproveInfo(isAutoApproved, isDenied, autoApproveReason, subCommandResults, commandLineResult);
+            const denialInfo = this._createAutoApproveInfo(
+                isAutoApproved,
+                isDenied,
+                autoApproveReason,
+                subCommandResults,
+                commandLineResult
+            );
             if (denialInfo) {
                 disclaimers.push(denialInfo);
             }
         }
         if (!isAutoApproved && isAutoApproveEnabled) {
-            customActions = generateAutoApproveActions(trimmedCommandLine, subCommands, { subCommandResults, commandLineResult });
+            customActions = generateAutoApproveActions(trimmedCommandLine, subCommands, {
+                subCommandResults,
+                commandLineResult
+            });
         }
         return {
             isAutoApproved,
             isAutoApproveAllowed: true,
             disclaimers,
             autoApproveInfo,
-            customActions,
+            customActions
         };
     }
-    _createAutoApproveInfo(isAutoApproved, isDenied, autoApproveReason, subCommandResults, commandLineResult) {
-        const formatRuleLinks = (result) => {
-            return ( asArray(result)
-                .filter((e) => isAutoApproveRule(e.rule))
-                .map(e => {
-                if (e.rule.sourceTarget === 'session') {
-                    return localize(12026, '{0} (session)', `\`${e.rule.sourceText}\``);
+    _createAutoApproveInfo(
+        isAutoApproved,
+        isDenied,
+        autoApproveReason,
+        subCommandResults,
+        commandLineResult
+    ) {
+        const formatRuleLinks = result => {
+            return ( asArray(result).filter(e => isAutoApproveRule(e.rule)).map(e => {
+                const escapedSourceText = e.rule.sourceText.replaceAll("$", "\\$");
+                if (e.rule.sourceTarget === "session") {
+                    return localize(12357, "{0} (session)", `\`${escapedSourceText}\``);
                 }
                 const settingsUri = createCommandUri(TerminalChatCommandId.OpenTerminalSettingsLink, e.rule.sourceTarget);
-                const tooltip = ( localize(12027, 'View rule in settings'));
-                let label = e.rule.sourceText;
+                const tooltip = ( localize(12358, "View rule in settings"));
+                let label = escapedSourceText;
                 switch (e.rule?.sourceTarget) {
-                    case ConfigurationTarget.DEFAULT:
-                        label = `${label} (default)`;
-                        break;
-                    case ConfigurationTarget.USER:
-                    case ConfigurationTarget.USER_LOCAL:
-                        label = `${label} (user)`;
-                        break;
-                    case ConfigurationTarget.USER_REMOTE:
-                        label = `${label} (remote)`;
-                        break;
-                    case ConfigurationTarget.WORKSPACE:
-                    case ConfigurationTarget.WORKSPACE_FOLDER:
-                        label = `${label} (workspace)`;
-                        break;
+                case ConfigurationTarget.DEFAULT:
+                    label = `${label} (default)`;
+                    break;
+                case ConfigurationTarget.USER:
+                case ConfigurationTarget.USER_LOCAL:
+                    label = `${label} (user)`;
+                    break;
+                case ConfigurationTarget.USER_REMOTE:
+                    label = `${label} (remote)`;
+                    break;
+                case ConfigurationTarget.WORKSPACE:
+                case ConfigurationTarget.WORKSPACE_FOLDER:
+                    label = `${label} (workspace)`;
+                    break;
                 }
                 return `[\`${label}\`](${( settingsUri.toString())} "${tooltip}")`;
-            })).join(', ');
+            })).join(", ");
         };
         const mdTrustSettings = {
             isTrusted: {
@@ -201,25 +221,27 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
         const config = this._configurationService.inspect(ChatConfiguration.GlobalAutoApprove);
         const isGlobalAutoApproved = config?.value ?? config.defaultValue;
         if (isGlobalAutoApproved) {
-            const settingsUri = createCommandUri(TerminalChatCommandId.OpenTerminalSettingsLink, 'global');
+            const settingsUri = createCommandUri(TerminalChatCommandId.OpenTerminalSettingsLink, "global");
             return (new MarkdownString(`${( localize(
-                12028,
-                'Auto approved by setting {0}',
-                `[\`${ChatConfiguration.GlobalAutoApprove}\`](${( settingsUri.toString())} "${( localize(12029, 'View settings'))}")`
+                12359,
+                "Auto approved by setting {0}",
+                `[\`${ChatConfiguration.GlobalAutoApprove}\`](${( settingsUri.toString())} "${( localize(12360, "View settings"))}")`
             ))}`, mdTrustSettings));
         }
         if (isAutoApproved) {
             switch (autoApproveReason) {
-                case 'commandLine': {
+            case "commandLine":
+                {
                     if (isAutoApproveRule(commandLineResult.rule)) {
                         return (new MarkdownString(
-                            localize(12030, 'Auto approved by rule {0}', formatRuleLinks(commandLineResult)),
+                            localize(12361, "Auto approved by rule {0}", formatRuleLinks(commandLineResult)),
                             mdTrustSettings
                         ));
                     }
                     break;
                 }
-                case 'subCommand': {
+            case "subCommand":
+                {
                     const npmScriptApproval = subCommandResults.find(e => isNpmScriptAutoApproveRule(e.rule));
                     if (npmScriptApproval && isNpmScriptAutoApproveRule(npmScriptApproval.rule) && npmScriptApproval.rule.npmScriptResult.autoApproveInfo) {
                         return npmScriptApproval.rule.npmScriptResult.autoApproveInfo;
@@ -227,43 +249,42 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
                     const uniqueRules = dedupeRules(subCommandResults);
                     if (uniqueRules.length === 1) {
                         return (new MarkdownString(
-                            localize(12030, 'Auto approved by rule {0}', formatRuleLinks(uniqueRules)),
+                            localize(12361, "Auto approved by rule {0}", formatRuleLinks(uniqueRules)),
                             mdTrustSettings
                         ));
-                    }
-                    else if (uniqueRules.length > 1) {
+                    } else if (uniqueRules.length > 1) {
                         return (new MarkdownString(
-                            localize(12031, 'Auto approved by rules {0}', formatRuleLinks(uniqueRules)),
+                            localize(12362, "Auto approved by rules {0}", formatRuleLinks(uniqueRules)),
                             mdTrustSettings
                         ));
                     }
                     break;
                 }
             }
-        }
-        else if (isDenied) {
+        } else if (isDenied) {
             switch (autoApproveReason) {
-                case 'commandLine': {
+            case "commandLine":
+                {
                     if (commandLineResult.rule) {
                         return (new MarkdownString(localize(
-                            12032,
-                            'Auto approval denied by rule {0}',
+                            12363,
+                            "Auto approval denied by rule {0}",
                             formatRuleLinks(commandLineResult)
                         ), mdTrustSettings));
                     }
                     break;
                 }
-                case 'subCommand': {
-                    const uniqueRules = dedupeRules(subCommandResults.filter(e => e.result === 'denied'));
+            case "subCommand":
+                {
+                    const uniqueRules = dedupeRules(subCommandResults.filter(e => e.result === "denied"));
                     if (uniqueRules.length === 1) {
                         return (new MarkdownString(
-                            localize(12032, 'Auto approval denied by rule {0}', formatRuleLinks(uniqueRules)),
+                            localize(12363, "Auto approval denied by rule {0}", formatRuleLinks(uniqueRules)),
                             mdTrustSettings
                         ));
-                    }
-                    else if (uniqueRules.length > 1) {
+                    } else if (uniqueRules.length > 1) {
                         return (new MarkdownString(
-                            localize(12033, 'Auto approval denied by rules {0}', formatRuleLinks(uniqueRules)),
+                            localize(12364, "Auto approval denied by rules {0}", formatRuleLinks(uniqueRules)),
                             mdTrustSettings
                         ));
                     }
@@ -274,11 +295,6 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
         return undefined;
     }
 };
-CommandLineAutoApproveAnalyzer = ( __decorate([
-    ( __param(3, IConfigurationService)),
-    ( __param(4, IInstantiationService)),
-    ( __param(5, IStorageService)),
-    ( __param(6, ITerminalChatService))
-], CommandLineAutoApproveAnalyzer));
+CommandLineAutoApproveAnalyzer = ( __decorate([( __param(3, IConfigurationService)), ( __param(4, IInstantiationService)), ( __param(5, IStorageService)), ( __param(6, ITerminalChatService))], CommandLineAutoApproveAnalyzer));
 
 export { CommandLineAutoApproveAnalyzer };

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

@@ -12,9 +12,15 @@ import { OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/com
 import { isString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
 
-const nullDevice = Symbol('null device');
+const nullDevice = Symbol("null device");
 let CommandLineFileWriteAnalyzer = class CommandLineFileWriteAnalyzer extends Disposable {
-    constructor(_treeSitterCommandParser, _log, _configurationService, _labelService, _workspaceContextService) {
+    constructor(
+        _treeSitterCommandParser,
+        _log,
+        _configurationService,
+        _labelService,
+        _workspaceContextService
+    ) {
         super();
         this._treeSitterCommandParser = _treeSitterCommandParser;
         this._log = _log;
@@ -26,10 +32,9 @@ let CommandLineFileWriteAnalyzer = class CommandLineFileWriteAnalyzer extends Di
         let fileWrites;
         try {
             fileWrites = await this._getFileWrites(options);
-        }
-        catch (e) {
+        } catch (e) {
             console.error(e);
-            this._log('Failed to get file writes via grammar', options.treeSitterLanguage);
+            this._log("Failed to get file writes via grammar", options.treeSitterLanguage);
             return {
                 isAutoApproveAllowed: false
             };
@@ -38,13 +43,14 @@ let CommandLineFileWriteAnalyzer = class CommandLineFileWriteAnalyzer extends Di
     }
     async _getFileWrites(options) {
         let fileWrites = [];
-        const capturedFileWrites = ( (await this._treeSitterCommandParser.getFileWrites(options.treeSitterLanguage, options.commandLine))
-            .map(this._mapNullDevice.bind(this, options)));
-        if (capturedFileWrites.length) {
+        const capturedFileWrites = ( (await this._treeSitterCommandParser.getFileWrites(options.treeSitterLanguage, options.commandLine)).map(this._mapNullDevice.bind(this, options)));
+        const commandFileWrites = ( (await this._treeSitterCommandParser.getCommandFileWrites(options.treeSitterLanguage, options.commandLine)).map(this._mapNullDevice.bind(this, options)));
+        const allCapturedFileWrites = [...capturedFileWrites, ...commandFileWrites];
+        if (allCapturedFileWrites.length) {
             const cwd = options.cwd;
             if (cwd) {
-                this._log('Detected cwd', ( cwd.toString()));
-                fileWrites = ( capturedFileWrites.map(e => {
+                this._log("Detected cwd", ( cwd.toString()));
+                fileWrites = ( allCapturedFileWrites.map(e => {
                     if (e === nullDevice) {
                         return e;
                     }
@@ -53,82 +59,83 @@ let CommandLineFileWriteAnalyzer = class CommandLineFileWriteAnalyzer extends Di
                     }
                     const isAbsolute = options.os === OperatingSystem.Windows ? win32.isAbsolute(e) : posix.isAbsolute(e);
                     if (isAbsolute) {
-                        return cwd.with({ path: e });
+                        return cwd.with({
+                            path: e
+                        });
                     }
                     return URI.joinPath(cwd, e);
                 }));
-            }
-            else {
-                this._log('Cwd could not be detected');
-                fileWrites = capturedFileWrites;
+            } else {
+                this._log("Cwd could not be detected");
+                fileWrites = allCapturedFileWrites;
             }
         }
-        this._log('File writes detected', ( fileWrites.map(e => ( e.toString()))));
+        this._log("File writes detected", ( fileWrites.map(e => ( e.toString()))));
         return fileWrites;
     }
     _stripSurroundingQuotes(text) {
-        if ((text.startsWith('"') && text.endsWith('"')) ||
-            (text.startsWith('\'') && text.endsWith('\''))) {
+        if ((text.startsWith("\"") && text.endsWith("\"")) || (text.startsWith("'") && text.endsWith("'"))) {
             return text.slice(1, -1);
         }
         return text;
     }
     _mapNullDevice(options, rawFileWrite) {
         if (options.treeSitterLanguage === TreeSitterCommandParserLanguage.PowerShell) {
-            return rawFileWrite === '$null'
-                ? nullDevice
-                : rawFileWrite;
+            return rawFileWrite === "$null" ? nullDevice : rawFileWrite;
         }
-        return rawFileWrite === '/dev/null'
-            ? nullDevice
-            : rawFileWrite;
+        return rawFileWrite === "/dev/null" ? nullDevice : rawFileWrite;
     }
     _getResult(options, fileWrites) {
         let isAutoApproveAllowed = true;
         if (fileWrites.length > 0) {
             const blockDetectedFileWrites = this._configurationService.getValue(TerminalChatAgentToolsSettingId.BlockDetectedFileWrites);
             switch (blockDetectedFileWrites) {
-                case 'all': {
+            case "all":
+                {
                     isAutoApproveAllowed = false;
-                    this._log('File writes blocked due to "all" setting');
+                    this._log("File writes blocked due to \"all\" setting");
                     break;
                 }
-                case 'outsideWorkspace': {
+            case "outsideWorkspace":
+                {
                     const workspaceFolders = this._workspaceContextService.getWorkspace().folders;
                     if (workspaceFolders.length > 0) {
                         for (const fileWrite of fileWrites) {
                             if (fileWrite === nullDevice) {
-                                this._log('File write to null device allowed', URI.isUri(fileWrite) ? ( fileWrite.toString()) : fileWrite);
+                                this._log("File write to null device allowed", URI.isUri(fileWrite) ? ( fileWrite.toString()) : fileWrite);
                                 continue;
                             }
                             if (isString(fileWrite)) {
                                 const isAbsolute = options.os === OperatingSystem.Windows ? win32.isAbsolute(fileWrite) : posix.isAbsolute(fileWrite);
                                 if (!isAbsolute) {
                                     isAutoApproveAllowed = false;
-                                    this._log('File write blocked due to unknown terminal cwd', fileWrite);
+                                    this._log("File write blocked due to unknown terminal cwd", fileWrite);
                                     break;
                                 }
                             }
                             const fileUri = URI.isUri(fileWrite) ? fileWrite : URI.file(fileWrite);
                             if (fileUri.fsPath.match(/[$\(\){}`]/)) {
                                 isAutoApproveAllowed = false;
-                                this._log('File write blocked due to likely containing a variable or sub-command', ( fileUri.toString()));
+                                this._log(
+                                    "File write blocked due to likely containing a variable or sub-command",
+                                    ( fileUri.toString())
+                                );
                                 break;
                             }
-                            const isInsideWorkspace = ( workspaceFolders.some(folder => folder.uri.scheme === fileUri.scheme &&
-                                (fileUri.path.startsWith(folder.uri.path + '/') || fileUri.path === folder.uri.path)));
+                            const isInsideWorkspace = ( workspaceFolders.some(
+                                folder => folder.uri.scheme === fileUri.scheme && (fileUri.path.startsWith(folder.uri.path + "/") || fileUri.path === folder.uri.path)
+                            ));
                             if (!isInsideWorkspace) {
                                 isAutoApproveAllowed = false;
-                                this._log('File write blocked outside workspace', ( fileUri.toString()));
+                                this._log("File write blocked outside workspace", ( fileUri.toString()));
                                 break;
                             }
                         }
-                    }
-                    else {
+                    } else {
                         const hasOnlyNullDevices = fileWrites.every(fw => fw === nullDevice);
                         if (!hasOnlyNullDevices) {
                             isAutoApproveAllowed = false;
-                            this._log('File writes blocked - no workspace folders');
+                            this._log("File writes blocked - no workspace folders");
                         }
                     }
                     break;
@@ -138,29 +145,24 @@ let CommandLineFileWriteAnalyzer = class CommandLineFileWriteAnalyzer extends Di
         const disclaimers = [];
         if (fileWrites.length > 0) {
             const fileWritesList = ( fileWrites.map(
-                fw => `\`${URI.isUri(fw) ? this._labelService.getUriLabel(fw) : fw === nullDevice ? '/dev/null' : ( fw.toString())}\``
-            )).join(', ');
+                fw => `\`${URI.isUri(fw) ? this._labelService.getUriLabel(fw) : fw === nullDevice ? "/dev/null" : ( fw.toString())}\``
+            )).join(", ");
             if (!isAutoApproveAllowed) {
                 disclaimers.push(( localize(
-                    12034,
-                    'File write operations detected that cannot be auto approved: {0}',
+                    12365,
+                    "File write operations detected that cannot be auto approved: {0}",
                     fileWritesList
                 )));
-            }
-            else {
-                disclaimers.push(( localize(12035, 'File write operations detected: {0}', fileWritesList)));
+            } else {
+                disclaimers.push(( localize(12366, "File write operations detected: {0}", fileWritesList)));
             }
         }
         return {
             isAutoApproveAllowed,
-            disclaimers,
+            disclaimers
         };
     }
 };
-CommandLineFileWriteAnalyzer = ( __decorate([
-    ( __param(2, IConfigurationService)),
-    ( __param(3, ILabelService)),
-    ( __param(4, IWorkspaceContextService))
-], CommandLineFileWriteAnalyzer));
+CommandLineFileWriteAnalyzer = ( __decorate([( __param(2, IConfigurationService)), ( __param(3, ILabelService)), ( __param(4, IWorkspaceContextService))], CommandLineFileWriteAnalyzer));
 
 export { CommandLineFileWriteAnalyzer };

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

@@ -0,0 +1,8 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ITerminalSandboxService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxService.service";
+import type { ICommandLineAnalyzer, ICommandLineAnalyzerOptions, ICommandLineAnalyzerResult } from "./commandLineAnalyzer.js";
+export declare class CommandLineSandboxAnalyzer extends Disposable implements ICommandLineAnalyzer {
+    private readonly _sandboxService;
+    constructor(_sandboxService: ITerminalSandboxService);
+    analyze(_options: ICommandLineAnalyzerOptions): Promise<ICommandLineAnalyzerResult>;
+}

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

@@ -0,0 +1,25 @@
+
+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 { ITerminalSandboxService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxService.service';
+
+let CommandLineSandboxAnalyzer = class CommandLineSandboxAnalyzer extends Disposable {
+    constructor(_sandboxService) {
+        super();
+        this._sandboxService = _sandboxService;
+    }
+    async analyze(_options) {
+        if (!(await this._sandboxService.isEnabled())) {
+            return {
+                isAutoApproveAllowed: true
+            };
+        }
+        return {
+            isAutoApproveAllowed: true,
+            forceAutoApproval: true
+        };
+    }
+};
+CommandLineSandboxAnalyzer = ( __decorate([( __param(0, ITerminalSandboxService))], CommandLineSandboxAnalyzer));
+
+export { CommandLineSandboxAnalyzer };