@codingame/monaco-vscode-chat-service-override 28.4.1 → 29.1.0

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

@@ -5,15 +5,17 @@ import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 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 { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
-import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { MarkdownString, escapeMarkdownSyntaxTokens } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { getMediaMime } from '@codingame/monaco-vscode-api/vscode/vs/base/common/mime';
 import { basename, win32, posix } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
 import { OS, OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
 import { count } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
 import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
 import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
@@ -33,7 +35,7 @@ import { BasicExecuteStrategy } from '../executeStrategy/basicExecuteStrategy.js
 import { NoneExecuteStrategy } from '../executeStrategy/noneExecuteStrategy.js';
 import { RichExecuteStrategy } from '../executeStrategy/richExecuteStrategy.js';
 import { getOutput } from '../outputHelpers.js';
-import { isWindowsPowerShell, isPowerShell, isZsh, isFish, extractCdPrefix } from '../runInTerminalHelpers.js';
+import { isWindowsPowerShell, isPowerShell, isZsh, isFish, normalizeTerminalCommandForDisplay, extractCdPrefix } from '../runInTerminalHelpers.js';
 import { NodeCommandLinePresenter } from './commandLinePresenter/nodeCommandLinePresenter.js';
 import { PythonCommandLinePresenter } from './commandLinePresenter/pythonCommandLinePresenter.js';
 import { RubyCommandLinePresenter } from './commandLinePresenter/rubyCommandLinePresenter.js';
@@ -62,13 +64,15 @@ import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workb
 import { TerminalChatCommandId } from '@codingame/monaco-vscode-xterm-common/vscode/vs/workbench/contrib/terminalContrib/chat/browser/terminalChat';
 import { clamp } from '@codingame/monaco-vscode-api/vscode/vs/base/common/numbers';
 import { SandboxOutputAnalyzer } from './sandboxOutputAnalyzer.js';
+import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
+import { ITerminalSandboxService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxService.service';
 
 var RunInTerminalTool_1;
 const TOOL_REFERENCE_NAME = "runInTerminal";
 const LEGACY_TOOL_REFERENCE_FULL_NAMES = ["runCommands/runInTerminal"];
-function createPowerShellModelDescription(shell) {
+function createPowerShellModelDescription(shell, isSandboxEnabled, networkDomains) {
     const isWinPwsh = isWindowsPowerShell(shell);
-    return [
+    const parts = [
         `This tool allows you to execute ${isWinPwsh ? "Windows PowerShell 5.1" : "PowerShell"} commands in a persistent terminal session, preserving environment variables, working directory, and other context across multiple commands.`,
         "",
         "Command Execution:",
@@ -90,7 +94,12 @@ function createPowerShellModelDescription(shell) {
         "Background Processes:",
         "- For long-running tasks (e.g., servers), set isBackground=true",
         "- Returns a terminal ID for checking status and runtime later",
-        "- Use Start-Job for background PowerShell jobs",
+        "- Use Start-Job for background PowerShell jobs"
+    ];
+    if (isSandboxEnabled) {
+        parts.push(...createSandboxLines(networkDomains));
+    }
+    parts.push(
         "",
         "Output Management:",
         "- Output is automatically truncated if longer than 60KB to prevent context overflow",
@@ -106,9 +115,40 @@ function createPowerShellModelDescription(shell) {
         "- Use Test-Path to check file/directory existence",
         "- Be specific with Select-Object properties to avoid excessive output",
         "- Avoid printing credentials unless absolutely required"
-    ].join("\n");
+    );
+    return parts.join("\n");
+}
+function createSandboxLines(networkDomains) {
+    const lines = [
+        "",
+        "Sandboxing:",
+        "- ATTENTION: Terminal sandboxing is enabled, commands run in a sandbox by default",
+        "- When executing commands within the sandboxed environment, all operations requiring a temporary directory must utilize the $TMPDIR environment variable. The /tmp directory is not guaranteed to be accessible or writable and must be avoided",
+        "- Tools and scripts should respect the TMPDIR environment variable, which is automatically set to an appropriate path within the sandbox",
+        "- When a command fails due to sandbox restrictions, immediately re-run it with requestUnsandboxedExecution=true. Do NOT ask the user for permission — setting this flag automatically shows a confirmation prompt to the user",
+        "- Only set requestUnsandboxedExecution=true when there is evidence of failures caused by the sandbox, e.g. 'Operation not permitted' errors, network failures, or file access errors, etc",
+        "- When setting requestUnsandboxedExecution=true, also provide requestUnsandboxedExecutionReason explaining why the command needs unsandboxed access"
+    ];
+    if (networkDomains) {
+        const deniedSet = ( new Set(networkDomains.deniedDomains));
+        const effectiveAllowed = networkDomains.allowedDomains.filter(d => !( deniedSet.has(d)));
+        if (effectiveAllowed.length === 0) {
+            lines.push("- All network access is blocked in the sandbox");
+        } else {
+            lines.push(
+                `- Only the following domains are accessible in the sandbox (all other network access is blocked): ${effectiveAllowed.join(", ")}`
+            );
+        }
+        if (networkDomains.deniedDomains.length > 0) {
+            lines.push(
+                `- The following domains are explicitly blocked in the sandbox: ${networkDomains.deniedDomains.join(", ")}`
+            );
+        }
+    }
+    return lines;
 }
-const genericDescription = `
+function createGenericDescription(isSandboxEnabled, networkDomains) {
+    const parts = [`
 Command Execution:
 - Use && to chain simple commands on one line
 - Prefer pipelines | over temporary files for data flow
@@ -128,7 +168,11 @@ Program Execution:
 
 Background Processes:
 - For long-running tasks (e.g., servers), set isBackground=true
-- Returns a terminal ID for checking status and runtime later
+- Returns a terminal ID for checking status and runtime later`];
+    if (isSandboxEnabled) {
+        parts.push(createSandboxLines(networkDomains).join("\n"));
+    }
+    parts.push(`
 
 Output Management:
 - Output is automatically truncated if longer than 60KB to prevent context overflow
@@ -140,20 +184,22 @@ Best Practices:
 - Quote variables: "$var" instead of $var to handle spaces
 - Use find with -exec or xargs for file operations
 - Be specific with commands to avoid excessive output
-- Avoid printing credentials unless absolutely required`;
-function createBashModelDescription() {
+- Avoid printing credentials unless absolutely required`);
+    return parts.join("");
+}
+function createBashModelDescription(isSandboxEnabled, networkDomains) {
     return [
         "This tool allows you to execute shell commands in a persistent bash terminal session, preserving environment variables, working directory, and other context across multiple commands.",
-        genericDescription,
+        createGenericDescription(isSandboxEnabled, networkDomains),
         "- Use [[ ]] for conditional tests instead of [ ]",
         "- Prefer $() over backticks for command substitution",
         "- Use set -e at start of complex commands to exit on errors"
     ].join("\n");
 }
-function createZshModelDescription() {
+function createZshModelDescription(isSandboxEnabled, networkDomains) {
     return [
         "This tool allows you to execute shell commands in a persistent zsh terminal session, preserving environment variables, working directory, and other context across multiple commands.",
-        genericDescription,
+        createGenericDescription(isSandboxEnabled, networkDomains),
         "- Use type to check command type (builtin, function, alias)",
         "- Use jobs, fg, bg for job control",
         "- Use [[ ]] for conditional tests instead of [ ]",
@@ -162,10 +208,10 @@ function createZshModelDescription() {
         "- Take advantage of zsh globbing features (**, extended globs)"
     ].join("\n");
 }
-function createFishModelDescription() {
+function createFishModelDescription(isSandboxEnabled, networkDomains) {
     return [
         "This tool allows you to execute shell commands in a persistent fish terminal session, preserving environment variables, working directory, and other context across multiple commands.",
-        genericDescription,
+        createGenericDescription(isSandboxEnabled, networkDomains),
         "- Use type to check command type (builtin, function, alias)",
         "- Use jobs, fg, bg for job control",
         "- Use test expressions for conditionals (no [[ ]] syntax)",
@@ -177,26 +223,31 @@ function createFishModelDescription() {
 }
 async function createRunInTerminalToolData(accessor) {
     const instantiationService = accessor.get(IInstantiationService);
+    const terminalSandboxService = accessor.get(ITerminalSandboxService);
     const profileFetcher = instantiationService.createInstance(TerminalProfileFetcher);
-    const shell = await profileFetcher.getCopilotShell();
-    const os = await profileFetcher.osBackend;
+    const [shell, os, isSandboxEnabled] = await Promise.all([
+        profileFetcher.getCopilotShell(),
+        profileFetcher.osBackend,
+        terminalSandboxService.isEnabled()
+    ]);
+    const networkDomains = isSandboxEnabled ? terminalSandboxService.getResolvedNetworkDomains() : undefined;
     let modelDescription;
     if (shell && os && isPowerShell(shell, os)) {
-        modelDescription = createPowerShellModelDescription(shell);
+        modelDescription = createPowerShellModelDescription(shell, isSandboxEnabled, networkDomains);
     } else if (shell && os && isZsh(shell, os)) {
-        modelDescription = createZshModelDescription();
+        modelDescription = createZshModelDescription(isSandboxEnabled, networkDomains);
     } else if (shell && os && isFish(shell, os)) {
-        modelDescription = createFishModelDescription();
+        modelDescription = createFishModelDescription(isSandboxEnabled, networkDomains);
     } else {
-        modelDescription = createBashModelDescription();
+        modelDescription = createBashModelDescription(isSandboxEnabled, networkDomains);
     }
     return {
         id: TerminalToolId.RunInTerminal,
         toolReferenceName: TOOL_REFERENCE_NAME,
         legacyToolReferenceFullNames: LEGACY_TOOL_REFERENCE_FULL_NAMES,
-        displayName: ( localize(13593, "Run in Terminal")),
+        displayName: ( localize(13843, "Run in Terminal")),
         modelDescription,
-        userDescription: ( localize(13594, "Run commands in the terminal")),
+        userDescription: ( localize(13844, "Run commands in the terminal")),
         source: ToolDataSource.Internal,
         icon: Codicon.terminal,
         inputSchema: {
@@ -220,8 +271,18 @@ async function createRunInTerminalToolData(accessor) {
                 },
                 timeout: {
                     type: "number",
-                    description: "An optional timeout in milliseconds. When provided, the tool will stop tracking the command after this duration and return the output collected so far. Be conservative with the timeout duration, give enough time that the command would complete on a low-end machine. Use 0 for no timeout. If it's not clear how long the command will take then use 0 to avoid prematurely terminating it, never guess too low."
-                }
+                    description: "An optional timeout in milliseconds. When provided, the tool will stop tracking the command after this duration and return the output collected so far with a timeout indicator. Be conservative with the timeout duration, give enough time that the command would complete on a low-end machine. Use 0 for no timeout. If it's not clear how long the command will take then use 0 to avoid prematurely terminating it, never guess too low."
+                },
+                ...(isSandboxEnabled ? {
+                    requestUnsandboxedExecution: {
+                        type: "boolean",
+                        description: "Request that this command run outside the terminal sandbox. Only set this when the command clearly needs unsandboxed access. The user will be prompted before the command runs unsandboxed."
+                    },
+                    requestUnsandboxedExecutionReason: {
+                        type: "string",
+                        description: "A short explanation of why this command must run outside the terminal sandbox. Only provide this when requestUnsandboxedExecution is true."
+                    }
+                } : {})
             },
             required: ["command", "explanation", "goal", "isBackground", "timeout"]
         }
@@ -234,7 +295,7 @@ var TerminalToolStorageKeysInternal;
 const telemetryIgnoredSequences = [
 "\u001b[I",
 "\u001b[O"];
-const altBufferMessage = "\n" + ( localize(13595, "The command opened the alternate buffer."));
+const altBufferMessage = "\n" + ( localize(13845, "The command opened the alternate buffer."));
 let RunInTerminalTool = class RunInTerminalTool extends Disposable {
     static {
         RunInTerminalTool_1 = this;
@@ -261,9 +322,13 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         RunInTerminalTool_1._activeExecutions.delete(id);
         return true;
     }
+    get _enableCommandLineSandboxRewriting() {
+        return true;
+    }
     constructor(
         _chatService,
         _configurationService,
+        _fileService,
         _historyService,
         _instantiationService,
         _labelService,
@@ -273,12 +338,15 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         _terminalChatService,
         _logService,
         _terminalService,
+        _terminalSandboxService,
         _workspaceContextService,
-        _chatWidgetService
+        _chatWidgetService,
+        _agentSessionsService
     ) {
         super();
         this._chatService = _chatService;
         this._configurationService = _configurationService;
+        this._fileService = _fileService;
         this._historyService = _historyService;
         this._instantiationService = _instantiationService;
         this._labelService = _labelService;
@@ -288,9 +356,14 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         this._terminalChatService = _terminalChatService;
         this._logService = _logService;
         this._terminalService = _terminalService;
+        this._terminalSandboxService = _terminalSandboxService;
         this._workspaceContextService = _workspaceContextService;
         this._chatWidgetService = _chatWidgetService;
+        this._agentSessionsService = _agentSessionsService;
+        this._archivedSessionListener = this._register(( new MutableDisposable()));
         this._sessionTerminalAssociations = ( new ResourceMap());
+        this._sessionTerminalInstances = ( new ResourceMap());
+        this._terminalsBeingDisposedBySessionCleanup = ( new Set());
         this._osBackend = this._remoteAgentService.getEnvironment().then(remoteEnv => remoteEnv?.os ?? OS);
         this._terminalToolCreator = this._instantiationService.createInstance(ToolTerminalCreator);
         this._treeSitterCommandParser = this._register(this._instantiationService.createInstance(TreeSitterCommandParser));
@@ -301,12 +374,16 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             this._register(this._instantiationService.createInstance(CommandLineCdPrefixRewriter)),
             this._register(
                 this._instantiationService.createInstance(CommandLinePwshChainOperatorRewriter, this._treeSitterCommandParser)
-            ),
-            this._register(
-                this._instantiationService.createInstance(CommandLinePreventHistoryRewriter)
-            ),
-            this._register(this._instantiationService.createInstance(CommandLineSandboxRewriter))
+            )
         ];
+        if (this._enableCommandLineSandboxRewriting) {
+            this._commandLineRewriters.push(
+                this._register(this._instantiationService.createInstance(CommandLineSandboxRewriter))
+            );
+        }
+        this._commandLineRewriters.push(this._register(
+            this._instantiationService.createInstance(CommandLinePreventHistoryRewriter)
+        ));
         this._commandLineAnalyzers = [this._register(this._instantiationService.createInstance(
             CommandLineFileWriteAnalyzer,
             this._treeSitterCommandParser,
@@ -316,7 +393,12 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             this._treeSitterCommandParser,
             this._telemetry,
             (message, args) => this._logService.info(`RunInTerminalTool#CommandLineAutoApproveAnalyzer: ${message}`, args)
-        )), this._register(this._instantiationService.createInstance(CommandLineSandboxAnalyzer))];
+        ))];
+        if (this._enableCommandLineSandboxRewriting) {
+            this._commandLineAnalyzers.push(
+                this._register(this._instantiationService.createInstance(CommandLineSandboxAnalyzer))
+            );
+        }
         this._commandLinePresenters = [
             this._instantiationService.createInstance(SandboxedCommandLinePresenter),
             ( new NodeCommandLinePresenter()),
@@ -340,11 +422,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         );
         this._restoreTerminalAssociations();
         this._register(this._terminalService.onDidDisposeInstance(e => {
-            for (const [sessionResource, toolTerminal] of this._sessionTerminalAssociations.entries()) {
-                if (e === toolTerminal.instance) {
-                    this._sessionTerminalAssociations.delete(sessionResource);
-                }
-            }
+            this._removeTerminalAssociations(e);
         }));
         this._register(this._chatService.onDidDisposeSession(e => {
             for (const resource of e.sessionResource) {
@@ -352,6 +430,20 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             }
         }));
     }
+    async handleToolStream(context, _token) {
+        const partialInput = context.rawInput;
+        if (partialInput && typeof partialInput === "object" && partialInput.command) {
+            const normalizedCommand = normalizeTerminalCommandForDisplay(partialInput.command).replace(/\r\n|\r|\n/g, " ");
+            const truncatedCommand = normalizedCommand.length > 80 ? normalizedCommand.substring(0, 77) + "..." : normalizedCommand;
+            const invocationMessage = partialInput.isBackground ? ( new MarkdownString(( localize(13846, "Running `{0}` in background", truncatedCommand)))) : ( new MarkdownString(( localize(13847, "Running `{0}`", truncatedCommand))));
+            return {
+                invocationMessage
+            };
+        }
+        return {
+            invocationMessage: ( localize(13848, "Running command"))
+        };
+    }
     async prepareToolInvocation(context, token) {
         const args = context.parameters;
         const chatSessionResource = context.chatSessionResource;
@@ -362,7 +454,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 instance = toolTerminal.instance;
             }
         }
-        const [os, shell, cwd] = await Promise.all([this._osBackend, this._profileFetcher.getCopilotShell(), (async () => {
+        const [os, shell, cwd, isTerminalSandboxEnabled] = await Promise.all([this._osBackend, this._profileFetcher.getCopilotShell(), (async () => {
             let cwd = await instance?.getCwdResource();
             if (!cwd) {
                 const activeWorkspaceRootUri = this._historyService.getLastActiveWorkspaceRoot();
@@ -370,22 +462,28 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 cwd = workspaceFolder?.uri;
             }
             return cwd;
-        })()]);
+        })(), this._terminalSandboxService.isEnabled()]);
         const language = os === OperatingSystem.Windows ? "pwsh" : "sh";
+        const requiresUnsandboxConfirmation = isTerminalSandboxEnabled && args.requestUnsandboxedExecution === true;
         const terminalToolSessionId = generateUuid();
         const terminalCommandId = `tool-${generateUuid()}`;
         let rewrittenCommand = args.command;
         let forDisplayCommand = undefined;
+        let isSandboxWrapped = false;
         for (const rewriter of this._commandLineRewriters) {
             const rewriteResult = await rewriter.rewrite({
                 commandLine: rewrittenCommand,
                 cwd,
                 shell,
-                os
+                os,
+                requestUnsandboxedExecution: requiresUnsandboxConfirmation
             });
             if (rewriteResult) {
                 rewrittenCommand = rewriteResult.rewritten;
-                forDisplayCommand = rewriteResult.forDisplay;
+                forDisplayCommand = rewriteResult.forDisplay ?? forDisplayCommand;
+                if (rewriteResult.isSandboxWrapped) {
+                    isSandboxWrapped = true;
+                }
                 this._logService.info(
                     `RunInTerminalTool: Command rewritten by ${rewriter.constructor.name}: ${rewriteResult.reasoning}`
                 );
@@ -398,11 +496,14 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             commandLine: {
                 original: args.command,
                 toolEdited: rewrittenCommand === args.command ? undefined : rewrittenCommand,
-                forDisplay: forDisplayCommand
+                forDisplay: forDisplayCommand ?? normalizeTerminalCommandForDisplay(rewrittenCommand ?? args.command),
+                isSandboxWrapped
             },
             cwd,
             language,
-            isBackground: args.isBackground
+            isBackground: args.isBackground,
+            requestUnsandboxedExecution: requiresUnsandboxConfirmation,
+            requestUnsandboxedExecutionReason: args.requestUnsandboxedExecutionReason
         };
         const alternativeRecommendation = getRecommendedToolsOverRunInTerminal(args.command, this._languageModelToolsService);
         if (alternativeRecommendation) {
@@ -442,9 +543,12 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             shell,
             treeSitterLanguage: isPowerShell(shell, os) ? TreeSitterCommandParserLanguage.PowerShell : TreeSitterCommandParserLanguage.Bash,
             terminalToolSessionId,
-            chatSessionResource
+            chatSessionResource,
+            requiresUnsandboxConfirmation
         };
-        const commandLineAnalyzerResults = await Promise.all(( this._commandLineAnalyzers.map(e => e.analyze(commandLineAnalyzerOptions))));
+        const isSessionAutoApproved = chatSessionResource && this._isSessionAutoApproveLevel(chatSessionResource);
+        const commandLineAnalyzers = isSessionAutoApproved ? this._commandLineAnalyzers.filter(e => !(e instanceof CommandLineAutoApproveAnalyzer)) : this._commandLineAnalyzers;
+        const commandLineAnalyzerResults = await Promise.all(( commandLineAnalyzers.map(e => e.analyze(commandLineAnalyzerOptions))));
         const disclaimersRaw = ( commandLineAnalyzerResults.map(e => e.disclaimers)).filter(e => !!e).flatMap(e => e);
         let disclaimer;
         if (disclaimersRaw.length > 0) {
@@ -476,7 +580,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         if (isFinalAutoApproved || (isAutoApproveEnabled && ( commandLineAnalyzerResults.some(e => e.autoApproveInfo)))) {
             toolSpecificData.autoApproveInfo = commandLineAnalyzerResults.find(e => e.autoApproveInfo)?.autoApproveInfo;
         }
-        const commandToDisplay = (toolSpecificData.commandLine.userEdited ?? toolSpecificData.commandLine.toolEdited ?? toolSpecificData.commandLine.original).trimStart();
+        const commandToDisplay = (toolSpecificData.commandLine.forDisplay ?? toolSpecificData.commandLine.userEdited ?? toolSpecificData.commandLine.toolEdited ?? toolSpecificData.commandLine.original).trimStart();
         const extractedCd = extractCdPrefix(commandToDisplay, shell, os);
         let confirmationTitle;
         if (extractedCd && cwd) {
@@ -494,16 +598,16 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 cdPrefix
             };
             confirmationTitle = args.isBackground ? ( localize(
-                13596,
+                13849,
                 "Run `{0}` command in background within `{1}`?",
                 shellType,
                 directoryLabel
-            )) : ( localize(13597, "Run `{0}` command within `{1}`?", shellType, directoryLabel));
+            )) : ( localize(13850, "Run `{0}` command within `{1}`?", shellType, directoryLabel));
         } else {
             toolSpecificData.confirmation = {
                 commandLine: commandToDisplay
             };
-            confirmationTitle = args.isBackground ? ( localize(13598, "Run `{0}` command in background?", shellType)) : ( localize(13599, "Run `{0}` command?", shellType));
+            confirmationTitle = args.isBackground ? ( localize(13851, "Run `{0}` command in background?", shellType)) : ( localize(13852, "Run `{0}` command?", shellType));
         }
         const commandForPresenter = extractedCd?.command ?? commandToDisplay;
         let presenterInput = commandForPresenter;
@@ -523,13 +627,13 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 };
                 if (extractedCd && toolSpecificData.confirmation?.cwdLabel) {
                     confirmationTitle = args.isBackground ? ( localize(
-                        13600,
+                        13853,
                         "Run `{0}` command in `{1}` in background within `{2}`?",
                         presenterResult.languageDisplayName,
                         shellType,
                         toolSpecificData.confirmation.cwdLabel
                     )) : ( localize(
-                        13601,
+                        13854,
                         "Run `{0}` command in `{1}` within `{2}`?",
                         presenterResult.languageDisplayName,
                         shellType,
@@ -537,12 +641,12 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                     ));
                 } else {
                     confirmationTitle = args.isBackground ? ( localize(
-                        13602,
+                        13855,
                         "Run `{0}` command in `{1}` in background?",
                         presenterResult.languageDisplayName,
                         shellType
                     )) : ( localize(
-                        13603,
+                        13856,
                         "Run `{0}` command in `{1}`?",
                         presenterResult.languageDisplayName,
                         shellType
@@ -554,15 +658,31 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 presenterInput = presenterResult.commandLine;
             }
         }
-        const isSessionAutoApproved = chatSessionResource && this._isSessionAutoApproveLevel(chatSessionResource);
+        if (requiresUnsandboxConfirmation) {
+            confirmationTitle = args.isBackground ? ( localize(13857, "Run `{0}` command outside the sandbox in background?", shellType)) : ( localize(13858, "Run `{0}` command outside the sandbox?", shellType));
+        }
         const shouldShowConfirmation = (!isFinalAutoApproved && !isSessionAutoApproved) || context.forceConfirmationReason !== undefined;
+        const confirmationMessage = requiresUnsandboxConfirmation ? ( new MarkdownString(( localize(
+            13859,
+            "Explanation: {0}\n\nGoal: {1}\n\nReason for leaving the sandbox: {2}",
+            args.explanation,
+            args.goal,
+            args.requestUnsandboxedExecutionReason || ( localize(13860, "The model indicated that this command needs unsandboxed access."))
+        )))) : ( new MarkdownString(( localize(13861, "Explanation: {0}\n\nGoal: {1}", args.explanation, args.goal))));
         const confirmationMessages = shouldShowConfirmation ? {
             title: confirmationTitle,
-            message: ( new MarkdownString(( localize(13604, "Explanation: {0}\n\nGoal: {1}", args.explanation, args.goal)))),
+            message: confirmationMessage,
             disclaimer,
+            allowAutoConfirm: undefined,
             terminalCustomActions: customActions
         } : undefined;
+        const rawDisplayCommand = toolSpecificData.commandLine.forDisplay ?? toolSpecificData.commandLine.toolEdited ?? toolSpecificData.commandLine.original;
+        const displayCommand = rawDisplayCommand.length > 80 ? rawDisplayCommand.substring(0, 77) + "..." : rawDisplayCommand;
+        const escapedDisplayCommand = escapeMarkdownSyntaxTokens(displayCommand);
+        const invocationMessage = toolSpecificData.commandLine.isSandboxWrapped ? args.isBackground ? ( new MarkdownString(( localize(13862, "Running `{0}` in sandbox in background", escapedDisplayCommand)))) : ( new MarkdownString(( localize(13863, "Running `{0}` in sandbox", escapedDisplayCommand)))) : args.isBackground ? ( new MarkdownString(( localize(13864, "Running `{0}` in background", escapedDisplayCommand)))) : ( new MarkdownString(( localize(13865, "Running `{0}`", escapedDisplayCommand))));
         return {
+            invocationMessage,
+            icon: toolSpecificData.commandLine.isSandboxWrapped ? Codicon.terminalSecure : Codicon.terminal,
             confirmationMessages,
             toolSpecificData
         };
@@ -603,7 +723,9 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         const chatSessionResource = invocation.context.sessionResource;
         const command = toolSpecificData.commandLine.userEdited ?? toolSpecificData.commandLine.toolEdited ?? toolSpecificData.commandLine.original;
         const didUserEditCommand = (toolSpecificData.commandLine.userEdited !== undefined && toolSpecificData.commandLine.userEdited !== toolSpecificData.commandLine.original);
-        const didToolEditCommand = (!didUserEditCommand && toolSpecificData.commandLine.toolEdited !== undefined && toolSpecificData.commandLine.toolEdited !== toolSpecificData.commandLine.original);
+        const didToolEditCommand = (!didUserEditCommand && toolSpecificData.commandLine.toolEdited !== undefined && toolSpecificData.commandLine.toolEdited !== toolSpecificData.commandLine.original &&
+        normalizeTerminalCommandForDisplay(toolSpecificData.commandLine.toolEdited).trim() !== normalizeTerminalCommandForDisplay(toolSpecificData.commandLine.original).trim());
+        const didSandboxWrapCommand = toolSpecificData.commandLine.isSandboxWrapped === true;
         if (token.isCancellationRequested) {
             throw ( new CancellationError());
         }
@@ -645,6 +767,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         let didTimeout = false;
         let didMoveToBackground = args.isBackground;
         let timeoutPromise;
+        let timeoutRacePromise;
         let outputMonitor;
         let pollingResult;
         const executeCancellation = store.add(( new CancellationTokenSource(token)));
@@ -653,12 +776,11 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             const shouldEnforceTimeout = this._configurationService.getValue(TerminalChatAgentToolsSettingId.EnforceTimeoutFromModel) === true;
             if (shouldEnforceTimeout) {
                 timeoutPromise = timeout(timeoutValue);
-                timeoutPromise.then(() => {
-                    if (!executeCancellation.token.isCancellationRequested) {
-                        didTimeout = true;
-                        executeCancellation.cancel();
-                    }
-                });
+                timeoutRacePromise = timeoutPromise.then(() => ({
+                    type: "timeout"
+                })).catch(() => ({
+                    type: "timeout"
+                }));
             }
         }
         let continueInBackgroundResolve;
@@ -690,7 +812,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             if (toolTerminal.shellIntegrationQuality === ShellIntegrationQuality.None) {
                 toolResultMessage = "$(info) Enable [shell integration](https://code.visualstudio.com/docs/terminal/shell-integration) to improve command detection";
             }
-            this._logService.debug(
+            this._logService.info(
                 `RunInTerminalTool: Using \`${execution.strategy.type}\` execute strategy for command \`${command}\``
             );
             store.add(execution);
@@ -720,15 +842,28 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 const state = toolSpecificData.terminalCommandState ?? {};
                 state.timestamp = state.timestamp ?? timingStart;
                 toolSpecificData.terminalCommandState = state;
-                let resultText = (didUserEditCommand ? `Note: The user manually edited the command to \`${command}\`, and that command is now running in terminal with ID=${termId}` : didToolEditCommand ? `Note: The tool simplified the command to \`${command}\`, and that command is now running in terminal with ID=${termId}` : `Command is running in terminal with ID=${termId}`);
+                let resultText = (didSandboxWrapCommand ? `Command is now running in terminal with ID=${termId}` : didUserEditCommand ? `Note: The user manually edited the command to \`${command}\`, and that command is now running in terminal with ID=${termId}` : didToolEditCommand ? `Note: The tool simplified the command to \`${command}\`, and that command is now running in terminal with ID=${termId}` : `Command is running in terminal with ID=${termId}`);
+                const backgroundOutput = pollingResult?.modelOutputEvalResponse ?? pollingResult?.output;
+                const outputAnalyzerMessage = backgroundOutput ? await this._getOutputAnalyzerMessage(undefined, backgroundOutput, command, didSandboxWrapCommand) : undefined;
                 if (pollingResult && pollingResult.modelOutputEvalResponse) {
-                    resultText += `\n\ The command became idle with output:\n${pollingResult.modelOutputEvalResponse}`;
+                    resultText += `\n\ The command became idle with output:\n`;
+                    if (outputAnalyzerMessage) {
+                        resultText += `${outputAnalyzerMessage}\n`;
+                    }
+                    resultText += pollingResult.modelOutputEvalResponse;
                 } else if (pollingResult) {
-                    resultText += `\n\ The command is still running, with output:\n${pollingResult.output}`;
+                    resultText += `\n\ The command is still running, with output:\n`;
+                    if (outputAnalyzerMessage) {
+                        resultText += `${outputAnalyzerMessage}\n`;
+                    }
+                    resultText += pollingResult.output;
                 }
+                const endCwd = await toolTerminal.instance.getCwdResource();
                 return {
                     toolMetadata: {
-                        exitCode: undefined
+                        exitCode: undefined,
+                        id: termId,
+                        cwd: endCwd?.toString()
                     },
                     content: [{
                         kind: "text",
@@ -736,12 +871,16 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                     }]
                 };
             } else {
-                const raceResult = await Promise.race([executionPromise.then(result => ({
+                const raceCandidates = [executionPromise.then(result => ({
                     type: "completed",
                     result
                 })), continueInBackgroundPromise.then(() => ({
                     type: "background"
-                }))]);
+                }))];
+                if (timeoutRacePromise) {
+                    raceCandidates.push(timeoutRacePromise);
+                }
+                const raceResult = await Promise.race(raceCandidates);
                 if (raceResult.type === "background") {
                     this._logService.debug(
                         `RunInTerminalTool: Continue in background triggered, returning output collected so far`
@@ -750,6 +889,23 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                     const backgroundOutput = execution.getOutput();
                     outputLineCount = backgroundOutput ? count(backgroundOutput.trim(), "\n") + 1 : 0;
                     terminalResult = backgroundOutput;
+                } else if (raceResult.type === "timeout") {
+                    this._logService.debug(`RunInTerminalTool: Timeout reached, returning output collected so far`);
+                    error = "timeout";
+                    didTimeout = true;
+                    didMoveToBackground = true;
+                    toolTerminal.isBackground = true;
+                    this._sessionTerminalAssociations.delete(chatSessionResource);
+                    await this._associateProcessIdWithSession(
+                        toolTerminal.instance,
+                        chatSessionResource,
+                        termId,
+                        toolTerminal.shellIntegrationQuality,
+                        true
+                    );
+                    const timeoutOutput = execution.getOutput();
+                    outputLineCount = timeoutOutput ? count(timeoutOutput.trim(), "\n") + 1 : 0;
+                    terminalResult = timeoutOutput ?? "";
                 } else {
                     const executeResult = raceResult.result;
                     toolTerminal.receivedUserInput = false;
@@ -763,10 +919,13 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                         toolResultMessage = altBufferMessage;
                         outputLineCount = 0;
                         error = executeResult.error ?? "alternateBuffer";
+                        const altBufferCwd = await toolTerminal.instance.getCwdResource();
                         altBufferResult = {
                             toolResultMessage,
                             toolMetadata: {
-                                exitCode: undefined
+                                exitCode: undefined,
+                                id: termId,
+                                cwd: altBufferCwd?.toString()
                             },
                             content: [{
                                 kind: "text",
@@ -786,7 +945,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                             }
                             toolSpecificData.terminalCommandState = state;
                         }
-                        this._logService.debug(
+                        this._logService.info(
                             `RunInTerminalTool: Finished \`${execution.strategy.type}\` execute strategy with exitCode \`${executeResult.exitCode}\`, result.length \`${executeResult.output?.length}\`, error \`${executeResult.error}\``
                         );
                         outputLineCount = executeResult.output === undefined ? 0 : count(executeResult.output.trim(), "\n") + 1;
@@ -807,6 +966,9 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             if (didTimeout && e instanceof CancellationError) {
                 this._logService.debug(`RunInTerminalTool: Timeout reached, returning output collected so far`);
                 error = "timeout";
+                didMoveToBackground = true;
+                toolTerminal.isBackground = true;
+                this._sessionTerminalAssociations.delete(chatSessionResource);
                 const timeoutOutput = getOutput(toolTerminal.instance, undefined);
                 outputLineCount = timeoutOutput ? count(timeoutOutput.trim(), "\n") + 1 : 0;
                 terminalResult = timeoutOutput ?? "";
@@ -872,41 +1034,43 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             return altBufferResult;
         }
         const resultText = [];
-        if (didUserEditCommand) {
-            resultText.push(
-                `Note: The user manually edited the command to \`${command}\`, and this is the output of running that command instead:\n`
-            );
-        } else if (didToolEditCommand) {
-            resultText.push(
-                `Note: The tool simplified the command to \`${command}\`, and this is the output of running that command instead:\n`
-            );
+        if (!didSandboxWrapCommand) {
+            if (didUserEditCommand) {
+                resultText.push(
+                    `Note: The user manually edited the command to \`${command}\`, and this is the output of running that command instead:\n`
+                );
+            } else if (didToolEditCommand) {
+                resultText.push(
+                    `Note: The tool simplified the command to \`${command}\`, and this is the output of running that command instead:\n`
+                );
+            }
+            if (didMoveToBackground && !args.isBackground) {
+                resultText.push(
+                    `Note: This terminal execution was moved to the background using the ID ${termId}\n`
+                );
+            }
         }
-        if (didMoveToBackground && !args.isBackground) {
+        if (didTimeout && timeoutValue !== undefined && timeoutValue > 0) {
             resultText.push(
-                `Note: This terminal execution was moved to the background using the ID ${termId}\n`
+                `Note: Command timed out after ${timeoutValue}ms. Output collected so far is shown below and the command may still be running in terminal ID ${termId}.\n\n`
             );
         }
-        let outputAnalyzerMessage;
-        for (const analyzer of this._outputAnalyzers) {
-            const message = await analyzer.analyze({
-                exitCode,
-                exitResult: terminalResult,
-                commandLine: command
-            });
-            if (message) {
-                outputAnalyzerMessage = message;
-                break;
-            }
-        }
+        const outputAnalyzerMessage = await this._getOutputAnalyzerMessage(exitCode, terminalResult, command, didSandboxWrapCommand);
         if (outputAnalyzerMessage) {
             resultText.push(`${outputAnalyzerMessage}\n`);
         }
         resultText.push(terminalResult);
         const isError = exitCode !== undefined && exitCode !== 0;
+        const endCwd = await toolTerminal.instance.getCwdResource();
+        const imageContent = await this._extractImagesFromOutput(terminalResult, endCwd);
         return {
             toolResultMessage,
             toolMetadata: {
-                exitCode: exitCode
+                exitCode: exitCode,
+                id: termId,
+                cwd: endCwd?.toString(),
+                timedOut: didTimeout || undefined,
+                timeoutMs: didTimeout ? timeoutValue : undefined
             },
             toolResultDetails: isError ? {
                 input: command,
@@ -920,9 +1084,67 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             content: [{
                 kind: "text",
                 value: resultText.join("")
-            }]
+            }, ...imageContent]
         };
     }
+    async _getOutputAnalyzerMessage(exitCode, exitResult, commandLine, isSandboxWrapped) {
+        for (const analyzer of this._outputAnalyzers) {
+            const message = await analyzer.analyze({
+                exitCode,
+                exitResult,
+                commandLine,
+                isSandboxWrapped
+            });
+            if (message) {
+                return message;
+            }
+        }
+        return undefined;
+    }
+    static {
+        this._maxImageFileSize = 5 * 1024 * 1024;
+    }
+    async _extractImagesFromOutput(output, cwd) {
+        const normalizedOutput = output.replace(/\r?\n/g, "");
+        const pathPattern = /(?:[^\s]*[\/\\][^\s]*\.(?:png|jpe?g|gif|webp|bmp))/gi;
+        const matches = ( new Set());
+        for (const match of normalizedOutput.matchAll(pathPattern)) {
+            matches.add(match[0]);
+        }
+        if (matches.size === 0) {
+            return [];
+        }
+        const results = [];
+        for (const filePath of matches) {
+            try {
+                const mimeType = getMediaMime(filePath);
+                if (!mimeType || !mimeType.startsWith("image/")) {
+                    continue;
+                }
+                let fileUri;
+                if (/^\/|^[A-Za-z]:[\\\/]/.test(filePath)) {
+                    fileUri = URI.file(filePath);
+                } else if (cwd) {
+                    fileUri = URI.joinPath(cwd, filePath);
+                } else {
+                    continue;
+                }
+                const stat = await this._fileService.stat(fileUri).catch(() => undefined);
+                if (!stat || stat.isDirectory || stat.size > RunInTerminalTool_1._maxImageFileSize) {
+                    continue;
+                }
+                const fileContent = await this._fileService.readFile(fileUri);
+                results.push({
+                    kind: "data",
+                    value: {
+                        mimeType,
+                        data: fileContent.value
+                    }
+                });
+            } catch {}
+        }
+        return results;
+    }
     _handleTerminalVisibility(toolTerminal, chatSessionResource) {
         const chatSessionOpenInWidget = !!this._chatWidgetService.getWidgetBySessionResource(chatSessionResource);
         if (this._configurationService.getValue(TerminalChatAgentToolsSettingId.OutputLocation) === "terminal" && chatSessionOpenInWidget) {
@@ -952,7 +1174,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         this._terminalChatService.registerTerminalInstanceWithToolSession(terminalToolSessionId, toolTerminal.instance);
         this._terminalChatService.registerTerminalInstanceWithChatSession(chatSessionResource, toolTerminal.instance);
         this._registerInputListener(toolTerminal);
-        this._sessionTerminalAssociations.set(chatSessionResource, toolTerminal);
+        this._addSessionTerminalAssociation(chatSessionResource, toolTerminal);
         if (token.isCancellationRequested) {
             toolTerminal.instance.dispose();
             throw ( new CancellationError());
@@ -989,7 +1211,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                             shellIntegrationQuality: association.shellIntegrationQuality,
                             isBackground: association.isBackground
                         };
-                        this._sessionTerminalAssociations.set(chatSessionResource, toolTerminal);
+                        this._addSessionTerminalAssociation(chatSessionResource, toolTerminal);
                         this._terminalChatService.registerTerminalInstanceWithChatSession(chatSessionResource, instance);
                         this._register(instance.onDisposed(() => {
                             this._removeProcessIdAssociation(instance.processId);
@@ -1076,27 +1298,74 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         }
     }
     _cleanupSessionTerminals(chatSessionResource) {
+        const sessionTerminals = this._sessionTerminalInstances.get(chatSessionResource);
         const toolTerminal = this._sessionTerminalAssociations.get(chatSessionResource);
-        if (toolTerminal) {
-            this._logService.debug(
-                `RunInTerminalTool: Cleaning up terminal for disposed chat session ${chatSessionResource}`
-            );
-            this._sessionTerminalAssociations.delete(chatSessionResource);
-            toolTerminal.instance.dispose();
-            const terminalToRemove = [];
-            for (const [termId, execution] of RunInTerminalTool_1._activeExecutions.entries()) {
-                if (execution.instance === toolTerminal.instance) {
-                    execution.dispose();
-                    terminalToRemove.push(termId);
-                }
+        const terminalsToDispose = sessionTerminals ?? (toolTerminal ? ( new Set([toolTerminal.instance])) : undefined);
+        if (!terminalsToDispose || terminalsToDispose.size === 0) {
+            return;
+        }
+        this._logService.debug(
+            `RunInTerminalTool: Cleaning up ${terminalsToDispose.size} terminal(s) for ended chat session ${chatSessionResource}`
+        );
+        this._sessionTerminalAssociations.delete(chatSessionResource);
+        this._sessionTerminalInstances.delete(chatSessionResource);
+        for (const terminal of terminalsToDispose) {
+            this._terminalsBeingDisposedBySessionCleanup.add(terminal);
+            terminal.dispose();
+        }
+        const terminalToRemove = [];
+        for (const [termId, execution] of RunInTerminalTool_1._activeExecutions.entries()) {
+            if (( terminalsToDispose.has(execution.instance))) {
+                execution.dispose();
+                terminalToRemove.push(termId);
             }
-            for (const termId of terminalToRemove) {
-                RunInTerminalTool_1._activeExecutions.delete(termId);
+        }
+        for (const termId of terminalToRemove) {
+            RunInTerminalTool_1._activeExecutions.delete(termId);
+        }
+    }
+    _addSessionTerminalAssociation(chatSessionResource, toolTerminal) {
+        this._ensureArchivedSessionListener();
+        let sessionTerminals = this._sessionTerminalInstances.get(chatSessionResource);
+        if (!sessionTerminals) {
+            sessionTerminals = ( new Set());
+            this._sessionTerminalInstances.set(chatSessionResource, sessionTerminals);
+        }
+        sessionTerminals.add(toolTerminal.instance);
+        if (!toolTerminal.isBackground) {
+            this._sessionTerminalAssociations.set(chatSessionResource, toolTerminal);
+        }
+    }
+    _ensureArchivedSessionListener() {
+        if (this._archivedSessionListener.value) {
+            return;
+        }
+        this._archivedSessionListener.value = this._agentSessionsService.onDidChangeSessionArchivedState(session => {
+            if (session.isArchived()) {
+                this._cleanupSessionTerminals(session.resource);
+            }
+        });
+    }
+    _removeTerminalAssociations(terminal) {
+        if (this._terminalsBeingDisposedBySessionCleanup.delete(terminal)) {
+            return;
+        }
+        for (const [sessionResource, toolTerminal] of this._sessionTerminalAssociations.entries()) {
+            if (terminal === toolTerminal.instance) {
+                this._sessionTerminalAssociations.delete(sessionResource);
+            }
+        }
+        for (const [sessionResource, sessionTerminals] of this._sessionTerminalInstances.entries()) {
+            if (!sessionTerminals.delete(terminal)) {
+                continue;
+            }
+            if (sessionTerminals.size === 0) {
+                this._sessionTerminalInstances.delete(sessionResource);
             }
         }
     }
 };
-RunInTerminalTool = RunInTerminalTool_1 = ( __decorate([( __param(0, IChatService)), ( __param(1, IConfigurationService)), ( __param(2, IHistoryService)), ( __param(3, IInstantiationService)), ( __param(4, ILabelService)), ( __param(5, ILanguageModelToolsService)), ( __param(6, IRemoteAgentService)), ( __param(7, IStorageService)), ( __param(8, ITerminalChatService)), ( __param(9, ITerminalLogService)), ( __param(10, ITerminalService)), ( __param(11, IWorkspaceContextService)), ( __param(12, IChatWidgetService))], RunInTerminalTool));
+RunInTerminalTool = RunInTerminalTool_1 = ( __decorate([( __param(0, IChatService)), ( __param(1, IConfigurationService)), ( __param(2, IFileService)), ( __param(3, IHistoryService)), ( __param(4, IInstantiationService)), ( __param(5, ILabelService)), ( __param(6, ILanguageModelToolsService)), ( __param(7, IRemoteAgentService)), ( __param(8, IStorageService)), ( __param(9, ITerminalChatService)), ( __param(10, ITerminalLogService)), ( __param(11, ITerminalService)), ( __param(12, ITerminalSandboxService)), ( __param(13, IWorkspaceContextService)), ( __param(14, IChatWidgetService)), ( __param(15, IAgentSessionsService))], RunInTerminalTool));
 let ActiveTerminalExecution = class ActiveTerminalExecution extends Disposable {
     get completionPromise() {
         return this._completionDeferred.p;
@@ -1200,6 +1469,13 @@ let TerminalProfileFetcher = class TerminalProfileFetcher {
                 profileName: "PowerShell"
             };
         }
+        if (defaultProfile.path === "/bin/sh") {
+            return {
+                ...defaultProfile,
+                path: "/bin/bash",
+                profileName: "bash"
+            };
+        }
         return {
             ...defaultProfile,
             icon: undefined