@codingame/monaco-vscode-chat-service-override 30.0.0 → 31.0.0

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

@@ -1,1619 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { timeout, DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
-import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
-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, 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';
-import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
-import { TerminalCapability } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities';
-import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
-import { IRemoteAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
-import { TerminalToolConfirmationStorageKeys } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/chatContentParts/toolInvocationParts/chatTerminalToolConfirmationSubPart';
-import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
-import { ToolDataSource, ToolInvocationPresentation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
-import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
-import { ITerminalChatService, ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
-import { ITerminalProfileResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal.service';
-import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
-import { getRecommendedToolsOverRunInTerminal } from '../alternativeRecommendation.js';
-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, normalizeTerminalCommandForDisplay, extractCdPrefix } from '../runInTerminalHelpers.js';
-import { NodeCommandLinePresenter } from './commandLinePresenter/nodeCommandLinePresenter.js';
-import { PythonCommandLinePresenter } from './commandLinePresenter/pythonCommandLinePresenter.js';
-import { RubyCommandLinePresenter } from './commandLinePresenter/rubyCommandLinePresenter.js';
-import { SandboxedCommandLinePresenter } from './commandLinePresenter/sandboxedCommandLinePresenter.js';
-import { RunInTerminalToolTelemetry } from '../runInTerminalToolTelemetry.js';
-import { ToolTerminalCreator, ShellIntegrationQuality } from '../toolTerminalCreator.js';
-import { TreeSitterCommandParser, TreeSitterCommandParserLanguage } from '../treeSitterCommandParser.js';
-import { CommandLineAutoApproveAnalyzer } from './commandLineAnalyzer/commandLineAutoApproveAnalyzer.js';
-import { CommandLineFileWriteAnalyzer } from './commandLineAnalyzer/commandLineFileWriteAnalyzer.js';
-import { CommandLineSandboxAnalyzer } from './commandLineAnalyzer/commandLineSandboxAnalyzer.js';
-import { OutputMonitor } from './monitoring/outputMonitor.js';
-import { OutputMonitorState } from './monitoring/types.js';
-import { LocalChatSessionUri, chatSessionResourceToId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
-import { TerminalToolId } from './toolIds.js';
-import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
-import { CommandLineCdPrefixRewriter } from './commandLineRewriter/commandLineCdPrefixRewriter.js';
-import { CommandLinePreventHistoryRewriter } from './commandLineRewriter/commandLinePreventHistoryRewriter.js';
-import { CommandLinePwshChainOperatorRewriter } from './commandLineRewriter/commandLinePwshChainOperatorRewriter.js';
-import { CommandLineSandboxRewriter } from './commandLineRewriter/commandLineSandboxRewriter.js';
-import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
-import { IHistoryService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/history/common/history.service';
-import { TerminalCommandArtifactCollector } from './terminalCommandArtifactCollector.js';
-import { isNumber, isString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
-import { ChatConfiguration, isAutoApproveLevel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
-import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
-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 { TerminalSandboxPrerequisiteCheck } from '../../common/terminalSandboxService.js';
-import { ITerminalSandboxService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxService.service';
-import { LanguageModelPartAudience } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
-
-var RunInTerminalTool_1;
-const TERMINAL_SANDBOX_DOCUMENTATION_URL = "https://aka.ms/vscode-sandboxing";
-const TOOL_REFERENCE_NAME = "runInTerminal";
-const LEGACY_TOOL_REFERENCE_FULL_NAMES = ["runCommands/runInTerminal"];
-function createPowerShellModelDescription(shell, isSandboxEnabled, networkDomains) {
-    const isWinPwsh = isWindowsPowerShell(shell);
-    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:",
-        isWinPwsh ? "- Use semicolons ; to chain commands on one line, NEVER use && even when asked explicitly" : "- Prefer ; when chaining commands on one line",
-        "- Prefer pipelines | for object-based data flow",
-        "- Never create a sub-shell (eg. powershell -c \"command\") unless explicitly asked",
-        "",
-        "Directory Management:",
-        "- Prefer relative paths when navigating directories, only use absolute when the path is far away or the current cwd is not expected",
-        "- Remember when isBackground=false is specified, that the shell and cwd are reused until it is moved to the background",
-        "- Use $PWD or Get-Location for current directory",
-        "- Use Push-Location/Pop-Location for directory stack",
-        "",
-        "Program Execution:",
-        "- Supports .NET, Python, Node.js, and other executables",
-        "- Install modules via Install-Module, Install-Package",
-        "- Use Get-Command to verify cmdlet/function availability",
-        "",
-        "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"
-    ];
-    if (isSandboxEnabled) {
-        parts.push(...createSandboxLines(networkDomains));
-    }
-    parts.push(
-        "",
-        "Output Management:",
-        "- Output is automatically truncated if longer than 60KB to prevent context overflow",
-        "- Use Select-Object, Where-Object, Format-Table to filter output",
-        "- Use -First/-Last parameters to limit results",
-        "- For pager commands, add | Out-String or | Format-List",
-        "",
-        "Best Practices:",
-        "- Use proper cmdlet names instead of aliases in scripts",
-        "- Quote paths with spaces: \"C:\\Path With Spaces\"",
-        "- Prefer PowerShell cmdlets over external commands when available",
-        "- Prefer idiomatic PowerShell like Get-ChildItem instead of dir or ls for file listings",
-        "- Use Test-Path to check file/directory existence",
-        "- Be specific with Select-Object properties to avoid excessive output",
-        "- Avoid printing credentials unless absolutely required",
-        `- NEVER run Start-Sleep or similar wait commands. If you need to wait for a background process, use ${TerminalToolId.AwaitTerminal} or ${TerminalToolId.GetTerminalOutput} instead`
-    );
-    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;
-}
-function createGenericDescription(isSandboxEnabled, networkDomains) {
-    const parts = [`
-Command Execution:
-- Use && to chain simple commands on one line
-- Prefer pipelines | over temporary files for data flow
-- Never create a sub-shell (eg. bash -c "command") unless explicitly asked
-
-Directory Management:
-- Prefer relative paths when navigating directories, only use absolute when the path is far away or the current cwd is not expected
-- Remember when isBackground=false is specified, that shell and cwd is reused until it is moved to the background
-- Use $PWD for current directory references
-- Consider using pushd/popd for directory stack management
-- Supports directory shortcuts like ~ and -
-
-Program Execution:
-- Supports Python, Node.js, and other executables
-- Install packages via package managers (brew, apt, etc.)
-- Use which or command -v to verify command availability
-
-Background Processes:
-- For long-running tasks (e.g., servers), set isBackground=true
-- 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
-- Use head, tail, grep, awk to filter and limit output size
-- For pager commands, disable paging: git --no-pager or add | cat
-- Use wc -l to count lines before displaying large outputs
-
-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
-- NEVER run sleep or similar wait commands in a terminal. If you need to wait for a background process, use ${TerminalToolId.AwaitTerminal} or ${TerminalToolId.GetTerminalOutput} instead`);
-    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.",
-        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(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.",
-        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 [ ]",
-        "- Prefer $() over backticks for command substitution",
-        "- Use setopt errexit for strict error handling",
-        "- Take advantage of zsh globbing features (**, extended globs)"
-    ].join("\n");
-}
-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.",
-        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)",
-        "- Prefer command substitution with () syntax",
-        "- Variables are arrays by default, use $var[1] for first element",
-        "- Use set -e for strict error handling",
-        "- Take advantage of fish's autosuggestions and completions"
-    ].join("\n");
-}
-async function createRunInTerminalToolData(accessor) {
-    const instantiationService = accessor.get(IInstantiationService);
-    const terminalSandboxService = accessor.get(ITerminalSandboxService);
-    const profileFetcher = instantiationService.createInstance(TerminalProfileFetcher);
-    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, isSandboxEnabled, networkDomains);
-    } else if (shell && os && isZsh(shell, os)) {
-        modelDescription = createZshModelDescription(isSandboxEnabled, networkDomains);
-    } else if (shell && os && isFish(shell, os)) {
-        modelDescription = createFishModelDescription(isSandboxEnabled, networkDomains);
-    } else {
-        modelDescription = createBashModelDescription(isSandboxEnabled, networkDomains);
-    }
-    return {
-        id: TerminalToolId.RunInTerminal,
-        toolReferenceName: TOOL_REFERENCE_NAME,
-        legacyToolReferenceFullNames: LEGACY_TOOL_REFERENCE_FULL_NAMES,
-        displayName: ( localize(13907, "Run in Terminal")),
-        modelDescription,
-        userDescription: ( localize(13908, "Run commands in the terminal")),
-        source: ToolDataSource.Internal,
-        icon: Codicon.terminal,
-        inputSchema: {
-            type: "object",
-            properties: {
-                command: {
-                    type: "string",
-                    description: "The command to run in the terminal."
-                },
-                explanation: {
-                    type: "string",
-                    description: "A one-sentence description of what the command does. This will be shown to the user before the command is run."
-                },
-                goal: {
-                    type: "string",
-                    description: "A short description of the goal or purpose of the command (e.g., \"Install dependencies\", \"Start development server\")."
-                },
-                isBackground: {
-                    type: "boolean",
-                    description: `Whether the command starts a background process.\n\n- If true, a new shell will be spawned where the cwd is the workspace directory and will run asynchronously in the background and you will not see the output.\n\n- If false, a single shell is shared between all non-background terminals where the cwd starts at the workspace directory and is remembered until that terminal is moved to the background, the tool call will block on the command finishing and only then you will get the output.\n\nExamples of background processes: building in watch mode, starting a server. You can check the output of a background process later on by using ${TerminalToolId.GetTerminalOutput}. If unsure whether a command will be long-running, prefer isBackground=true.`
-                },
-                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 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"]
-        }
-    };
-}
-var TerminalToolStorageKeysInternal;
-(function(TerminalToolStorageKeysInternal) {
-    TerminalToolStorageKeysInternal["TerminalSession"] = "chat.terminalSessions";
-})(TerminalToolStorageKeysInternal || (TerminalToolStorageKeysInternal = {}));
-const telemetryIgnoredSequences = [
-"\u001b[I",
-"\u001b[O"];
-const altBufferMessage = "\n" + ( localize(13909, "The command opened the alternate buffer."));
-let RunInTerminalTool = class RunInTerminalTool extends Disposable {
-    static {
-        RunInTerminalTool_1 = this;
-    }
-    static {
-        this._activeExecutions = ( new Map());
-    }
-    static getBackgroundOutput(id) {
-        const execution = RunInTerminalTool_1._activeExecutions.get(id);
-        if (!execution) {
-            throw ( new Error("Invalid terminal ID"));
-        }
-        return execution.getOutput();
-    }
-    static getExecution(id) {
-        return RunInTerminalTool_1._activeExecutions.get(id);
-    }
-    static removeExecution(id) {
-        const execution = RunInTerminalTool_1._activeExecutions.get(id);
-        if (!execution) {
-            return false;
-        }
-        execution.dispose();
-        RunInTerminalTool_1._activeExecutions.delete(id);
-        return true;
-    }
-    get _enableCommandLineSandboxRewriting() {
-        return true;
-    }
-    constructor(
-        _chatService,
-        _configurationService,
-        _fileService,
-        _historyService,
-        _instantiationService,
-        _labelService,
-        _languageModelToolsService,
-        _remoteAgentService,
-        _storageService,
-        _terminalChatService,
-        _logService,
-        _terminalService,
-        _terminalSandboxService,
-        _workspaceContextService,
-        _chatWidgetService,
-        _agentSessionsService
-    ) {
-        super();
-        this._chatService = _chatService;
-        this._configurationService = _configurationService;
-        this._fileService = _fileService;
-        this._historyService = _historyService;
-        this._instantiationService = _instantiationService;
-        this._labelService = _labelService;
-        this._languageModelToolsService = _languageModelToolsService;
-        this._remoteAgentService = _remoteAgentService;
-        this._storageService = _storageService;
-        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));
-        this._telemetry = this._instantiationService.createInstance(RunInTerminalToolTelemetry);
-        this._commandArtifactCollector = this._instantiationService.createInstance(TerminalCommandArtifactCollector);
-        this._profileFetcher = this._instantiationService.createInstance(TerminalProfileFetcher);
-        this._commandLineRewriters = [
-            this._register(this._instantiationService.createInstance(CommandLineCdPrefixRewriter)),
-            this._register(
-                this._instantiationService.createInstance(CommandLinePwshChainOperatorRewriter, this._treeSitterCommandParser)
-            )
-        ];
-        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,
-            (message, args) => this._logService.info(`RunInTerminalTool#CommandLineFileWriteAnalyzer: ${message}`, args)
-        )), this._register(this._instantiationService.createInstance(
-            CommandLineAutoApproveAnalyzer,
-            this._treeSitterCommandParser,
-            this._telemetry,
-            (message, args) => this._logService.info(`RunInTerminalTool#CommandLineAutoApproveAnalyzer: ${message}`, args)
-        ))];
-        if (this._enableCommandLineSandboxRewriting) {
-            this._commandLineAnalyzers.push(
-                this._register(this._instantiationService.createInstance(CommandLineSandboxAnalyzer))
-            );
-        }
-        this._commandLinePresenters = [
-            this._instantiationService.createInstance(SandboxedCommandLinePresenter),
-            ( new NodeCommandLinePresenter()),
-            ( new PythonCommandLinePresenter()),
-            ( new RubyCommandLinePresenter())
-        ];
-        this._outputAnalyzers = [
-            this._register(this._instantiationService.createInstance(SandboxOutputAnalyzer))
-        ];
-        this._register(
-            Event.runAndSubscribe(this._configurationService.onDidChangeConfiguration, e => {
-                if (!e || e.affectsConfiguration(TerminalChatAgentToolsSettingId.EnableAutoApprove)) {
-                    if (this._configurationService.getValue(TerminalChatAgentToolsSettingId.EnableAutoApprove) !== true) {
-                        this._storageService.remove(
-                            TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted,
-                            StorageScope.APPLICATION
-                        );
-                    }
-                }
-            })
-        );
-        this._restoreTerminalAssociations();
-        this._register(this._terminalService.onDidDisposeInstance(e => {
-            this._removeTerminalAssociations(e);
-        }));
-        this._register(this._chatService.onDidDisposeSession(e => {
-            for (const resource of e.sessionResources) {
-                this._cleanupSessionTerminals(resource);
-            }
-        }));
-    }
-    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(13910, "Running `{0}` in background", truncatedCommand)))) : ( new MarkdownString(( localize(13911, "Running `{0}`", truncatedCommand))));
-            return {
-                invocationMessage
-            };
-        }
-        return {
-            invocationMessage: ( localize(13912, "Running command"))
-        };
-    }
-    async prepareToolInvocation(context, token) {
-        const args = context.parameters;
-        const chatSessionResource = context.chatSessionResource;
-        let instance;
-        if (chatSessionResource) {
-            const toolTerminal = this._sessionTerminalAssociations.get(chatSessionResource);
-            if (toolTerminal && !toolTerminal.isBackground) {
-                instance = toolTerminal.instance;
-            }
-        }
-        const [os, shell, cwd, sandboxPrereqs] = await Promise.all([this._osBackend, this._profileFetcher.getCopilotShell(), (async () => {
-            let cwd = await instance?.getCwdResource();
-            if (!cwd) {
-                const activeWorkspaceRootUri = this._historyService.getLastActiveWorkspaceRoot();
-                const workspaceFolder = activeWorkspaceRootUri ? this._workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri) ?? undefined : undefined;
-                cwd = workspaceFolder?.uri;
-            }
-            return cwd;
-        })(), this._terminalSandboxService.checkForSandboxingPrereqs()]);
-        const language = os === OperatingSystem.Windows ? "pwsh" : "sh";
-        const isTerminalSandboxEnabled = sandboxPrereqs.enabled;
-        const requiresUnsandboxConfirmation = isTerminalSandboxEnabled && args.requestUnsandboxedExecution === true;
-        const missingDependencies = sandboxPrereqs.failedCheck === TerminalSandboxPrerequisiteCheck.Dependencies && sandboxPrereqs.missingDependencies?.length ? sandboxPrereqs.missingDependencies : undefined;
-        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,
-                requestUnsandboxedExecution: requiresUnsandboxConfirmation
-            });
-            if (rewriteResult) {
-                rewrittenCommand = rewriteResult.rewritten;
-                forDisplayCommand = rewriteResult.forDisplay ?? forDisplayCommand;
-                if (rewriteResult.isSandboxWrapped) {
-                    isSandboxWrapped = true;
-                }
-                this._logService.info(
-                    `RunInTerminalTool: Command rewritten by ${rewriter.constructor.name}: ${rewriteResult.reasoning}`
-                );
-            }
-        }
-        const toolSpecificData = {
-            kind: "terminal",
-            terminalToolSessionId,
-            terminalCommandId,
-            commandLine: {
-                original: args.command,
-                toolEdited: rewrittenCommand === args.command ? undefined : rewrittenCommand,
-                forDisplay: forDisplayCommand ?? normalizeTerminalCommandForDisplay(rewrittenCommand ?? args.command),
-                isSandboxWrapped
-            },
-            cwd,
-            language,
-            isBackground: args.isBackground,
-            requestUnsandboxedExecution: requiresUnsandboxConfirmation,
-            requestUnsandboxedExecutionReason: args.requestUnsandboxedExecutionReason,
-            missingSandboxDependencies: missingDependencies
-        };
-        let sandboxConfirmationMessageForMissingDeps = undefined;
-        if (missingDependencies) {
-            const depsList = missingDependencies.join(", ");
-            sandboxConfirmationMessageForMissingDeps = {
-                title: ( localize(13913, "Missing Sandbox Dependencies")),
-                message: ( new MarkdownString(( localize(
-                    13914,
-                    "The following dependencies required for sandboxed execution are not installed: {0}. Would you like to install them?",
-                    depsList
-                )))),
-                customButtons: [( localize(13915, "Install")), ( localize(13916, "Cancel"))]
-            };
-        }
-        const alternativeRecommendation = getRecommendedToolsOverRunInTerminal(args.command, this._languageModelToolsService);
-        if (alternativeRecommendation) {
-            toolSpecificData.alternativeRecommendation = alternativeRecommendation;
-            return {
-                confirmationMessages: undefined,
-                presentation: ToolInvocationPresentation.Hidden,
-                toolSpecificData
-            };
-        }
-        const commandLine = rewrittenCommand ?? args.command;
-        const isEligibleForAutoApproval = () => {
-            const config = this._configurationService.getValue(ChatConfiguration.EligibleForAutoApproval);
-            if (config && typeof config === "object") {
-                if (Object.prototype.hasOwnProperty.call(config, TOOL_REFERENCE_NAME)) {
-                    return config[TOOL_REFERENCE_NAME];
-                }
-                for (const legacyName of LEGACY_TOOL_REFERENCE_FULL_NAMES) {
-                    if (Object.prototype.hasOwnProperty.call(config, legacyName)) {
-                        return config[legacyName];
-                    }
-                }
-            }
-            return true;
-        };
-        const isAutoApproveEnabled = this._configurationService.getValue(TerminalChatAgentToolsSettingId.EnableAutoApprove) === true;
-        const isAutoApproveWarningAccepted = this._storageService.getBoolean(
-            TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted,
-            StorageScope.APPLICATION,
-            false
-        );
-        const isAutoApproveAllowed = isEligibleForAutoApproval() && isAutoApproveEnabled && isAutoApproveWarningAccepted;
-        const commandLineAnalyzerOptions = {
-            commandLine,
-            cwd,
-            os,
-            shell,
-            treeSitterLanguage: isPowerShell(shell, os) ? TreeSitterCommandParserLanguage.PowerShell : TreeSitterCommandParserLanguage.Bash,
-            terminalToolSessionId,
-            chatSessionResource,
-            requiresUnsandboxConfirmation
-        };
-        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) {
-            const disclaimerTexts = ( disclaimersRaw.map(d => typeof d === "string" ? d : d.value));
-            const hasMarkdownDisclaimer = ( disclaimersRaw.some(d => typeof d !== "string"));
-            const mdOptions = hasMarkdownDisclaimer ? {
-                supportThemeIcons: true,
-                isTrusted: {
-                    enabledCommands: [TerminalChatCommandId.OpenTerminalSettingsLink]
-                }
-            } : {
-                supportThemeIcons: true
-            };
-            disclaimer = ( new MarkdownString(`$(${Codicon.info.id}) ` + disclaimerTexts.join(" "), mdOptions));
-        }
-        const analyzersIsAutoApproveAllowed = commandLineAnalyzerResults.every(e => e.isAutoApproveAllowed);
-        const customActions = isEligibleForAutoApproval() && analyzersIsAutoApproveAllowed ? ( commandLineAnalyzerResults.map(e => e.customActions ?? [])).flat() : undefined;
-        let shellType = basename(shell, ".exe");
-        if (shellType === "powershell") {
-            shellType = "pwsh";
-        }
-        const wouldBeAutoApproved =
-        (( commandLineAnalyzerResults.some(e => e.isAutoApproved)) &&
-        commandLineAnalyzerResults.every(e => e.isAutoApproved !== false) &&
-        analyzersIsAutoApproveAllowed);
-        const isFinalAutoApproved =
-        (isAutoApproveAllowed &&
-        wouldBeAutoApproved) || ( commandLineAnalyzerResults.some(e => e.forceAutoApproval));
-        if (isFinalAutoApproved || (isAutoApproveEnabled && ( commandLineAnalyzerResults.some(e => e.autoApproveInfo)))) {
-            toolSpecificData.autoApproveInfo = commandLineAnalyzerResults.find(e => e.autoApproveInfo)?.autoApproveInfo;
-        }
-        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) {
-            const isAbsolutePath = os === OperatingSystem.Windows ? win32.isAbsolute(extractedCd.directory) : posix.isAbsolute(extractedCd.directory);
-            const directoryUri = isAbsolutePath ? ( URI.from({
-                scheme: cwd.scheme,
-                authority: cwd.authority,
-                path: extractedCd.directory
-            })) : URI.joinPath(cwd, extractedCd.directory);
-            const directoryLabel = this._labelService.getUriLabel(directoryUri);
-            const cdPrefix = commandToDisplay.substring(0, commandToDisplay.length - extractedCd.command.length);
-            toolSpecificData.confirmation = {
-                commandLine: extractedCd.command,
-                cwdLabel: directoryLabel,
-                cdPrefix
-            };
-            confirmationTitle = args.isBackground ? ( localize(
-                13917,
-                "Run `{0}` command in background within `{1}`?",
-                shellType,
-                directoryLabel
-            )) : ( localize(13918, "Run `{0}` command within `{1}`?", shellType, directoryLabel));
-        } else {
-            toolSpecificData.confirmation = {
-                commandLine: commandToDisplay
-            };
-            confirmationTitle = args.isBackground ? ( localize(13919, "Run `{0}` command in background?", shellType)) : ( localize(13920, "Run `{0}` command?", shellType));
-        }
-        const commandForPresenter = extractedCd?.command ?? commandToDisplay;
-        let presenterInput = commandForPresenter;
-        for (const presenter of this._commandLinePresenters) {
-            const presenterResult = await presenter.present({
-                commandLine: {
-                    original: args.command,
-                    forDisplay: presenterInput
-                },
-                shell,
-                os
-            });
-            if (presenterResult) {
-                toolSpecificData.presentationOverrides = {
-                    commandLine: presenterResult.commandLine,
-                    language: presenterResult.language ?? undefined
-                };
-                if (extractedCd && toolSpecificData.confirmation?.cwdLabel) {
-                    if (presenterResult.languageDisplayName) {
-                        confirmationTitle = args.isBackground ? ( localize(
-                            13921,
-                            "Run `{0}` command in `{1}` in background within `{2}`?",
-                            presenterResult.languageDisplayName,
-                            shellType,
-                            toolSpecificData.confirmation.cwdLabel
-                        )) : ( localize(
-                            13922,
-                            "Run `{0}` command in `{1}` within `{2}`?",
-                            presenterResult.languageDisplayName,
-                            shellType,
-                            toolSpecificData.confirmation.cwdLabel
-                        ));
-                    } else {
-                        confirmationTitle = args.isBackground ? ( localize(
-                            13923,
-                            "Run command in `{0}` in background within `{1}`?",
-                            shellType,
-                            toolSpecificData.confirmation.cwdLabel
-                        )) : ( localize(
-                            13924,
-                            "Run command in `{0}` within `{1}`?",
-                            shellType,
-                            toolSpecificData.confirmation.cwdLabel
-                        ));
-                    }
-                } else {
-                    if (presenterResult.languageDisplayName) {
-                        confirmationTitle = args.isBackground ? ( localize(
-                            13925,
-                            "Run `{0}` command in `{1}` in background?",
-                            presenterResult.languageDisplayName,
-                            shellType
-                        )) : ( localize(
-                            13926,
-                            "Run `{0}` command in `{1}`?",
-                            presenterResult.languageDisplayName,
-                            shellType
-                        ));
-                    } else {
-                        confirmationTitle = args.isBackground ? ( localize(13927, "Run command in `{0}` in background?", shellType)) : ( localize(13928, "Run command in `{0}`?", shellType));
-                    }
-                }
-                if (!presenterResult.processOtherPresenters) {
-                    break;
-                }
-                presenterInput = presenterResult.commandLine;
-            }
-        }
-        if (requiresUnsandboxConfirmation) {
-            confirmationTitle = args.isBackground ? ( localize(
-                13929,
-                "Run `{0}` command outside the [sandbox]({1}) in background?",
-                shellType,
-                TERMINAL_SANDBOX_DOCUMENTATION_URL
-            )) : ( localize(
-                13930,
-                "Run `{0}` command outside the [sandbox]({1})?",
-                shellType,
-                TERMINAL_SANDBOX_DOCUMENTATION_URL
-            ));
-        }
-        const shouldShowConfirmation = (!isFinalAutoApproved && !isSessionAutoApproved) || context.forceConfirmationReason !== undefined;
-        const confirmationMessage = requiresUnsandboxConfirmation ? ( new MarkdownString(( localize(
-            13931,
-            "Explanation: {0}\n\nGoal: {1}\n\nReason for leaving the sandbox: {2}",
-            args.explanation,
-            args.goal,
-            args.requestUnsandboxedExecutionReason || ( localize(13932, "The model indicated that this command needs unsandboxed access."))
-        )))) : ( new MarkdownString(( localize(13933, "Explanation: {0}\n\nGoal: {1}", args.explanation, args.goal))));
-        const confirmationMessages = shouldShowConfirmation ? {
-            title: confirmationTitle,
-            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 invocationMessage = toolSpecificData.commandLine.isSandboxWrapped ? args.isBackground ? ( new MarkdownString(( localize(13934, "Running `{0}` in sandbox in background", displayCommand)))) : ( new MarkdownString(( localize(13935, "Running `{0}` in sandbox", displayCommand)))) : args.isBackground ? ( new MarkdownString(( localize(13936, "Running `{0}` in background", displayCommand)))) : ( new MarkdownString(( localize(13937, "Running `{0}`", displayCommand))));
-        return {
-            invocationMessage,
-            icon: toolSpecificData.commandLine.isSandboxWrapped ? Codicon.terminalSecure : Codicon.terminal,
-            confirmationMessages: sandboxConfirmationMessageForMissingDeps ?? confirmationMessages,
-            toolSpecificData
-        };
-    }
-    _isSessionAutoApproveLevel(chatSessionResource) {
-        const inspected = this._configurationService.inspect(ChatConfiguration.GlobalAutoApprove);
-        if (inspected.policyValue === false) {
-            return false;
-        }
-        const widget = this._chatWidgetService.getWidgetBySessionResource(chatSessionResource) ?? this._chatWidgetService.lastFocusedWidget;
-        if (widget && isAutoApproveLevel(widget.input.currentModeInfo.permissionLevel)) {
-            return true;
-        }
-        const model = this._chatService.getSession(chatSessionResource);
-        const request = model?.getRequests().at(-1);
-        return isAutoApproveLevel(request?.modeInfo?.permissionLevel);
-    }
-    async invoke(invocation, _countTokens, _progress, token) {
-        const toolSpecificData = invocation.toolSpecificData;
-        if (!toolSpecificData) {
-            throw ( new Error("toolSpecificData must be provided for this tool"));
-        }
-        if (!invocation.context) {
-            throw ( new Error("Invocation context must be provided for this tool"));
-        }
-        const commandId = toolSpecificData.terminalCommandId;
-        if (toolSpecificData.alternativeRecommendation) {
-            return {
-                content: [{
-                    kind: "text",
-                    value: toolSpecificData.alternativeRecommendation
-                }]
-            };
-        }
-        if (toolSpecificData.missingSandboxDependencies?.length) {
-            const installButton = ( localize(13915, "Install"));
-            if (invocation.selectedCustomButton === installButton) {
-                const sessionResource = invocation.context.sessionResource;
-                const {
-                    exitCode
-                } = await this._terminalSandboxService.installMissingSandboxDependencies(toolSpecificData.missingSandboxDependencies, sessionResource, token, {
-                    createTerminal: async () => this._terminalService.createTerminal({}),
-                    focusTerminal: async terminal => {
-                        this._terminalService.setActiveInstance(terminal);
-                        await this._terminalService.revealTerminal(terminal, true);
-                        terminal.focus();
-                    }
-                });
-                if (exitCode !== undefined && exitCode !== 0) {
-                    return {
-                        content: [{
-                            kind: "text",
-                            value: ( localize(
-                                13938,
-                                "Sandbox dependency installation failed (exit code {0}). The command was not executed.",
-                                exitCode
-                            ))
-                        }]
-                    };
-                }
-                if (exitCode === undefined) {
-                    return {
-                        content: [{
-                            kind: "text",
-                            value: ( localize(
-                                13939,
-                                "Could not determine whether sandbox dependency installation succeeded. The command was not executed."
-                            ))
-                        }]
-                    };
-                }
-                this._logService.info(
-                    "RunInTerminalTool: Sandbox dependency installation succeeded, proceeding with command execution"
-                );
-            } else {
-                this._logService.info("RunInTerminalTool: User cancelled sandbox dependency installation");
-                return {
-                    content: [{
-                        kind: "text",
-                        value: ( localize(13940, "Sandbox dependency installation was cancelled by the user."))
-                    }]
-                };
-            }
-        }
-        const args = invocation.parameters;
-        this._logService.debug(`RunInTerminalTool: Invoking with options ${JSON.stringify(args)}`);
-        let toolResultMessage;
-        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 &&
-        normalizeTerminalCommandForDisplay(toolSpecificData.commandLine.toolEdited).trim() !== normalizeTerminalCommandForDisplay(toolSpecificData.commandLine.original).trim());
-        const didSandboxWrapCommand = toolSpecificData.commandLine.isSandboxWrapped === true;
-        if (token.isCancellationRequested) {
-            throw ( new CancellationError());
-        }
-        let error;
-        const isNewSession = !args.isBackground && !( this._sessionTerminalAssociations.has(chatSessionResource));
-        const timingStart = Date.now();
-        const termId = generateUuid();
-        const terminalToolSessionId = toolSpecificData.terminalToolSessionId;
-        const store = ( new DisposableStore());
-        this._logService.debug(
-            `RunInTerminalTool: Creating ${args.isBackground ? "background" : "foreground"} terminal. termId=${termId}, chatSessionResource=${chatSessionResource}`
-        );
-        const toolTerminal = await this._initTerminal(
-            chatSessionResource,
-            termId,
-            terminalToolSessionId,
-            args.isBackground,
-            token
-        );
-        this._handleTerminalVisibility(toolTerminal, chatSessionResource);
-        const timingConnectMs = Date.now() - timingStart;
-        const xterm = await toolTerminal.instance.xtermReadyPromise;
-        if (!xterm) {
-            throw ( new Error("Instance was disposed before xterm.js was ready"));
-        }
-        const commandDetection = toolTerminal.instance.capabilities.get(TerminalCapability.CommandDetection);
-        let inputUserChars = 0;
-        let inputUserSigint = false;
-        store.add(xterm.raw.onData(data => {
-            if (!telemetryIgnoredSequences.includes(data)) {
-                inputUserChars += data.length;
-            }
-            inputUserSigint ||= data === "\u0003";
-        }));
-        let terminalResult = "";
-        let outputLineCount = -1;
-        let exitCode;
-        let altBufferResult;
-        let didTimeout = false;
-        let didMoveToBackground = args.isBackground;
-        let timeoutPromise;
-        let timeoutRacePromise;
-        let outputMonitor;
-        let pollingResult;
-        const executeCancellation = store.add(( new CancellationTokenSource(token)));
-        const timeoutValue = args.timeout !== undefined ? clamp(args.timeout, 0, Number.MAX_SAFE_INTEGER) : undefined;
-        if (!args.isBackground && timeoutValue !== undefined && timeoutValue > 0) {
-            const shouldEnforceTimeout = this._configurationService.getValue(TerminalChatAgentToolsSettingId.EnforceTimeoutFromModel) === true;
-            if (shouldEnforceTimeout) {
-                timeoutPromise = timeout(timeoutValue);
-                timeoutRacePromise = timeoutPromise.then(() => ({
-                    type: "timeout"
-                })).catch(() => ({
-                    type: "timeout"
-                }));
-            }
-        }
-        let continueInBackgroundResolve;
-        const continueInBackgroundPromise = ( new Promise(resolve => {
-            continueInBackgroundResolve = resolve;
-        }));
-        if (terminalToolSessionId) {
-            store.add(this._terminalChatService.onDidContinueInBackground(sessionId => {
-                if (sessionId === terminalToolSessionId) {
-                    const execution = RunInTerminalTool_1._activeExecutions.get(termId);
-                    if (execution) {
-                        execution.setBackground();
-                    }
-                    didMoveToBackground = true;
-                    continueInBackgroundResolve?.();
-                }
-            }));
-        }
-        let executionPromise;
-        try {
-            const execution = this._instantiationService.createInstance(
-                ActiveTerminalExecution,
-                chatSessionResource,
-                termId,
-                toolTerminal,
-                commandDetection,
-                args.isBackground
-            );
-            if (toolTerminal.shellIntegrationQuality === ShellIntegrationQuality.None) {
-                toolResultMessage = "$(info) Enable [shell integration](https://code.visualstudio.com/docs/terminal/shell-integration) to improve command detection";
-            }
-            this._logService.info(
-                `RunInTerminalTool: Using \`${execution.strategy.type}\` execute strategy for command \`${command}\``
-            );
-            store.add(execution);
-            RunInTerminalTool_1._activeExecutions.set(termId, execution);
-            const startMarkerPromise = Event.toPromise(execution.strategy.onDidCreateStartMarker);
-            store.add(execution.strategy.onDidCreateStartMarker(startMarker => {
-                if (!outputMonitor) {
-                    outputMonitor = store.add(this._instantiationService.createInstance(OutputMonitor, {
-                        instance: toolTerminal.instance,
-                        sessionResource: chatSessionResource,
-                        getOutput: marker => execution.getOutput(marker ?? startMarker)
-                    }, undefined, invocation.context, token, command));
-                }
-            }));
-            executionPromise = execution.start(command, executeCancellation.token, commandId);
-            if (args.isBackground) {
-                this._logService.debug(`RunInTerminalTool: Starting background execution \`${command}\``);
-                await startMarkerPromise;
-                if (outputMonitor) {
-                    await Event.toPromise(outputMonitor.onDidFinishCommand);
-                    pollingResult = outputMonitor.pollingResult;
-                }
-                await this._commandArtifactCollector.capture(toolSpecificData, toolTerminal.instance, commandId);
-                if (token.isCancellationRequested) {
-                    throw ( new CancellationError());
-                }
-                const state = toolSpecificData.terminalCommandState ?? {};
-                state.timestamp = state.timestamp ?? timingStart;
-                toolSpecificData.terminalCommandState = state;
-                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`;
-                    if (outputAnalyzerMessage) {
-                        resultText += `${outputAnalyzerMessage}\n`;
-                    }
-                    resultText += pollingResult.modelOutputEvalResponse;
-                } else if (pollingResult) {
-                    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,
-                        id: termId,
-                        cwd: endCwd?.toString()
-                    },
-                    content: [{
-                        kind: "text",
-                        value: resultText
-                    }]
-                };
-            } else {
-                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`
-                    );
-                    error = "continueInBackground";
-                    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;
-                    if (token.isCancellationRequested) {
-                        throw ( new CancellationError());
-                    }
-                    if (executeResult.didEnterAltBuffer) {
-                        const state = toolSpecificData.terminalCommandState ?? {};
-                        state.timestamp = state.timestamp ?? timingStart;
-                        toolSpecificData.terminalCommandState = state;
-                        toolResultMessage = altBufferMessage;
-                        outputLineCount = 0;
-                        error = executeResult.error ?? "alternateBuffer";
-                        const altBufferCwd = await toolTerminal.instance.getCwdResource();
-                        altBufferResult = {
-                            toolResultMessage,
-                            toolMetadata: {
-                                exitCode: undefined,
-                                id: termId,
-                                cwd: altBufferCwd?.toString()
-                            },
-                            content: [{
-                                kind: "text",
-                                value: altBufferMessage
-                            }]
-                        };
-                    } else {
-                        await this._commandArtifactCollector.capture(toolSpecificData, toolTerminal.instance, commandId);
-                        {
-                            const state = toolSpecificData.terminalCommandState ?? {};
-                            state.timestamp = state.timestamp ?? timingStart;
-                            if (executeResult.exitCode !== undefined) {
-                                state.exitCode = executeResult.exitCode;
-                                if (state.timestamp !== undefined) {
-                                    state.duration = state.duration ?? Math.max(0, Date.now() - state.timestamp);
-                                }
-                            }
-                            toolSpecificData.terminalCommandState = state;
-                        }
-                        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;
-                        exitCode = executeResult.exitCode;
-                        error = executeResult.error;
-                        const resultArr = [];
-                        if (executeResult.output !== undefined) {
-                            resultArr.push(executeResult.output);
-                        }
-                        if (executeResult.additionalInformation) {
-                            resultArr.push(executeResult.additionalInformation);
-                        }
-                        terminalResult = resultArr.join("\n\n");
-                    }
-                }
-            }
-        } catch (e) {
-            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 ?? "";
-            } else {
-                this._logService.debug(`RunInTerminalTool: Threw exception`);
-                if (e instanceof CancellationError) {
-                    await this._commandArtifactCollector.capture(toolSpecificData, toolTerminal.instance, commandId);
-                    const state = toolSpecificData.terminalCommandState ?? {};
-                    if (state.exitCode === undefined) {
-                        state.exitCode = -1;
-                        state.timestamp = state.timestamp ?? timingStart;
-                        state.duration = state.duration ?? Math.max(0, Date.now() - state.timestamp);
-                    }
-                    toolSpecificData.terminalCommandState = state;
-                }
-                RunInTerminalTool_1._activeExecutions.get(termId)?.dispose();
-                RunInTerminalTool_1._activeExecutions.delete(termId);
-                toolTerminal.instance.dispose();
-                error = e instanceof CancellationError ? "canceled" : "unexpectedException";
-                throw e;
-            }
-        } finally {
-            timeoutPromise?.cancel();
-            if (didMoveToBackground && executionPromise) {
-                executionPromise.catch(e => {
-                    if (!(e instanceof CancellationError)) {
-                        this._logService.error(`RunInTerminalTool: Background execution error`, e);
-                    }
-                });
-            } else {
-                RunInTerminalTool_1._activeExecutions.get(termId)?.dispose();
-                RunInTerminalTool_1._activeExecutions.delete(termId);
-            }
-            store.dispose();
-            const timingExecuteMs = Date.now() - timingStart;
-            this._telemetry.logInvoke(toolTerminal.instance, {
-                terminalToolSessionId: toolSpecificData.terminalToolSessionId,
-                didUserEditCommand,
-                didToolEditCommand,
-                isBackground: args.isBackground,
-                isSandboxWrapped: toolSpecificData.commandLine.isSandboxWrapped === true,
-                shellIntegrationQuality: toolTerminal.shellIntegrationQuality,
-                error,
-                isNewSession,
-                outputLineCount,
-                exitCode,
-                timingExecuteMs,
-                timingConnectMs,
-                inputUserChars,
-                inputUserSigint,
-                terminalExecutionIdleBeforeTimeout: pollingResult?.state === OutputMonitorState.Idle,
-                pollDurationMs: pollingResult?.pollDurationMs,
-                inputToolManualAcceptCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolManualAcceptCount,
-                inputToolManualRejectCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolManualRejectCount,
-                inputToolManualChars: outputMonitor?.outputMonitorTelemetryCounters?.inputToolManualChars,
-                inputToolAutoAcceptCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolAutoAcceptCount,
-                inputToolAutoChars: outputMonitor?.outputMonitorTelemetryCounters?.inputToolAutoChars,
-                inputToolManualShownCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolManualShownCount,
-                inputToolFreeFormInputCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolFreeFormInputCount,
-                inputToolFreeFormInputShownCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolFreeFormInputShownCount
-            });
-        }
-        if (altBufferResult) {
-            return altBufferResult;
-        }
-        const resultText = [];
-        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 (didTimeout && timeoutValue !== undefined && timeoutValue > 0) {
-            resultText.push(
-                `Note: Command timed out after ${timeoutValue}ms and was moved to the background. The command may still be running in terminal ID ${termId}. Use ${TerminalToolId.AwaitTerminal} to wait for it to complete or ${TerminalToolId.GetTerminalOutput} to check its current output. Do NOT use sleep or manual polling to wait.\n\n`
-            );
-        }
-        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,
-                id: termId,
-                cwd: endCwd?.toString(),
-                timedOut: didTimeout || undefined,
-                timeoutMs: didTimeout ? timeoutValue : undefined
-            },
-            toolResultDetails: isError ? {
-                input: command,
-                output: [{
-                    type: "embed",
-                    isText: true,
-                    value: terminalResult
-                }],
-                isError: true
-            } : undefined,
-            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
-                    },
-                    audience: [LanguageModelPartAudience.User]
-                });
-            } catch {}
-        }
-        return results;
-    }
-    _handleTerminalVisibility(toolTerminal, chatSessionResource) {
-        const chatSessionOpenInWidget = !!this._chatWidgetService.getWidgetBySessionResource(chatSessionResource);
-        if (this._configurationService.getValue(TerminalChatAgentToolsSettingId.OutputLocation) === "terminal" && chatSessionOpenInWidget) {
-            this._terminalService.setActiveInstance(toolTerminal.instance);
-            this._terminalService.revealTerminal(toolTerminal.instance, true);
-        }
-    }
-    async _initTerminal(chatSessionResource, termId, terminalToolSessionId, isBackground, token) {
-        if (!isBackground) {
-            const cachedTerminal = this._sessionTerminalAssociations.get(chatSessionResource);
-            if (cachedTerminal && !cachedTerminal.isBackground) {
-                this._logService.debug(
-                    `RunInTerminalTool: Using cached terminal with session resource \`${chatSessionResource}\``
-                );
-                this._terminalToolCreator.refreshShellIntegrationQuality(cachedTerminal);
-                this._terminalChatService.registerTerminalInstanceWithToolSession(terminalToolSessionId, cachedTerminal.instance);
-                return cachedTerminal;
-            }
-        }
-        this._logService.debug(
-            `RunInTerminalTool: Creating ${isBackground ? "background" : "foreground"} terminal with ID=${termId}`
-        );
-        const profile = await this._profileFetcher.getCopilotProfile();
-        const os = await this._osBackend;
-        const toolTerminal = await this._terminalToolCreator.createTerminal(profile, os, token);
-        toolTerminal.isBackground = isBackground;
-        this._terminalChatService.registerTerminalInstanceWithToolSession(terminalToolSessionId, toolTerminal.instance);
-        this._terminalChatService.registerTerminalInstanceWithChatSession(chatSessionResource, toolTerminal.instance);
-        this._registerInputListener(toolTerminal);
-        this._addSessionTerminalAssociation(chatSessionResource, toolTerminal);
-        if (token.isCancellationRequested) {
-            toolTerminal.instance.dispose();
-            throw ( new CancellationError());
-        }
-        await this._setupProcessIdAssociation(toolTerminal, chatSessionResource, termId, isBackground);
-        return toolTerminal;
-    }
-    _registerInputListener(toolTerminal) {
-        const disposable = toolTerminal.instance.onData(data => {
-            if (!telemetryIgnoredSequences.includes(data)) {
-                toolTerminal.receivedUserInput = data.length > 0;
-            }
-        });
-        this._register(toolTerminal.instance.onDisposed(() => disposable.dispose()));
-    }
-    _restoreTerminalAssociations() {
-        const storedAssociations = this._storageService.get(
-            TerminalToolStorageKeysInternal.TerminalSession,
-            StorageScope.WORKSPACE,
-            "{}"
-        );
-        try {
-            const associations = JSON.parse(storedAssociations);
-            for (const instance of this._terminalService.instances) {
-                if (instance.processId) {
-                    const association = associations[instance.processId];
-                    if (association) {
-                        const chatSessionResource = LocalChatSessionUri.forSession(association.sessionId);
-                        this._logService.debug(
-                            `RunInTerminalTool: Restored terminal association for PID ${instance.processId}, session ${association.sessionId}`
-                        );
-                        const toolTerminal = {
-                            instance,
-                            shellIntegrationQuality: association.shellIntegrationQuality,
-                            isBackground: association.isBackground
-                        };
-                        this._addSessionTerminalAssociation(chatSessionResource, toolTerminal);
-                        this._terminalChatService.registerTerminalInstanceWithChatSession(chatSessionResource, instance);
-                        this._register(instance.onDisposed(() => {
-                            this._removeProcessIdAssociation(instance.processId);
-                        }));
-                    }
-                }
-            }
-        } catch (error) {
-            this._logService.debug(`RunInTerminalTool: Failed to restore terminal associations: ${error}`);
-        }
-    }
-    async _setupProcessIdAssociation(toolTerminal, chatSessionResource, termId, isBackground) {
-        await this._associateProcessIdWithSession(
-            toolTerminal.instance,
-            chatSessionResource,
-            termId,
-            toolTerminal.shellIntegrationQuality,
-            isBackground
-        );
-        this._register(toolTerminal.instance.onDisposed(() => {
-            if (toolTerminal.instance.processId) {
-                this._removeProcessIdAssociation(toolTerminal.instance.processId);
-            }
-        }));
-    }
-    async _associateProcessIdWithSession(terminal, chatSessionResource, id, shellIntegrationQuality, isBackground) {
-        try {
-            const pid = await Promise.race([
-                terminal.processReady.then(() => terminal.processId),
-                timeout(5000).then(() => {
-                    throw ( new Error("Timeout"));
-                })
-            ]);
-            if (isNumber(pid)) {
-                const storedAssociations = this._storageService.get(
-                    TerminalToolStorageKeysInternal.TerminalSession,
-                    StorageScope.WORKSPACE,
-                    "{}"
-                );
-                const associations = JSON.parse(storedAssociations);
-                const sessionId = chatSessionResourceToId(chatSessionResource);
-                const existingAssociation = associations[pid] || {};
-                associations[pid] = {
-                    ...existingAssociation,
-                    sessionId,
-                    shellIntegrationQuality,
-                    id,
-                    isBackground
-                };
-                this._storageService.store(
-                    TerminalToolStorageKeysInternal.TerminalSession,
-                    JSON.stringify(associations),
-                    StorageScope.WORKSPACE,
-                    StorageTarget.USER
-                );
-                this._logService.debug(
-                    `RunInTerminalTool: Associated terminal PID ${pid} with session ${sessionId}`
-                );
-            }
-        } catch (error) {
-            this._logService.debug(`RunInTerminalTool: Failed to associate terminal with session: ${error}`);
-        }
-    }
-    async _removeProcessIdAssociation(pid) {
-        try {
-            const storedAssociations = this._storageService.get(
-                TerminalToolStorageKeysInternal.TerminalSession,
-                StorageScope.WORKSPACE,
-                "{}"
-            );
-            const associations = JSON.parse(storedAssociations);
-            if (associations[pid]) {
-                delete associations[pid];
-                this._storageService.store(
-                    TerminalToolStorageKeysInternal.TerminalSession,
-                    JSON.stringify(associations),
-                    StorageScope.WORKSPACE,
-                    StorageTarget.USER
-                );
-                this._logService.debug(`RunInTerminalTool: Removed terminal association for PID ${pid}`);
-            }
-        } catch (error) {
-            this._logService.debug(`RunInTerminalTool: Failed to remove terminal association: ${error}`);
-        }
-    }
-    _cleanupSessionTerminals(chatSessionResource) {
-        const sessionTerminals = this._sessionTerminalInstances.get(chatSessionResource);
-        const toolTerminal = this._sessionTerminalAssociations.get(chatSessionResource);
-        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);
-        }
-    }
-    _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, 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;
-    }
-    get isBackground() {
-        return this._isBackground;
-    }
-    get startMarker() {
-        return this._startMarker;
-    }
-    get instance() {
-        return this._toolTerminal.instance;
-    }
-    constructor(
-        sessionResource,
-        termId,
-        toolTerminal,
-        commandDetection,
-        isBackground,
-        _instantiationService
-    ) {
-        super();
-        this.sessionResource = sessionResource;
-        this.termId = termId;
-        this._instantiationService = _instantiationService;
-        this._toolTerminal = toolTerminal;
-        this._isBackground = isBackground;
-        this._completionDeferred = ( new DeferredPromise());
-        this.strategy = this._register(this._createStrategy(commandDetection));
-        this._register(this.strategy.onDidCreateStartMarker(marker => {
-            if (marker) {
-                this._startMarker = marker;
-            }
-        }));
-    }
-    _createStrategy(commandDetection) {
-        switch (this._toolTerminal.shellIntegrationQuality) {
-        case ShellIntegrationQuality.None:
-            return this._instantiationService.createInstance(
-                NoneExecuteStrategy,
-                this._toolTerminal.instance,
-                () => this._toolTerminal.receivedUserInput ?? false
-            );
-        case ShellIntegrationQuality.Basic:
-            return this._instantiationService.createInstance(
-                BasicExecuteStrategy,
-                this._toolTerminal.instance,
-                () => this._toolTerminal.receivedUserInput ?? false,
-                commandDetection
-            );
-        case ShellIntegrationQuality.Rich:
-            return this._instantiationService.createInstance(RichExecuteStrategy, this._toolTerminal.instance, commandDetection);
-        }
-    }
-    async start(commandLine, token, commandId) {
-        try {
-            const result = await this.strategy.execute(commandLine, token, commandId);
-            this._completionDeferred.complete(result);
-            return result;
-        } catch (e) {
-            this._completionDeferred.error(e);
-            throw e;
-        }
-    }
-    setForeground() {
-        this._isBackground = false;
-    }
-    setBackground() {
-        this._isBackground = true;
-    }
-    getOutput(marker) {
-        return getOutput(this.instance, marker ?? this._startMarker);
-    }
-};
-ActiveTerminalExecution = ( __decorate([( __param(5, IInstantiationService))], ActiveTerminalExecution));
-let TerminalProfileFetcher = class TerminalProfileFetcher {
-    constructor(
-        _configurationService,
-        _terminalProfileResolverService,
-        _remoteAgentService
-    ) {
-        this._configurationService = _configurationService;
-        this._terminalProfileResolverService = _terminalProfileResolverService;
-        this._remoteAgentService = _remoteAgentService;
-        this.osBackend = this._remoteAgentService.getEnvironment().then(remoteEnv => remoteEnv?.os ?? OS);
-    }
-    async getCopilotProfile() {
-        const os = await this.osBackend;
-        const customChatAgentProfile = this._getChatTerminalProfile(os);
-        if (customChatAgentProfile) {
-            return customChatAgentProfile;
-        }
-        const defaultProfile = await this._terminalProfileResolverService.getDefaultProfile({
-            os,
-            remoteAuthority: this._remoteAgentService.getConnection()?.remoteAuthority
-        });
-        if (basename(defaultProfile.path) === "cmd.exe") {
-            return {
-                ...defaultProfile,
-                path: "C:\\WINDOWS\\System32\\WindowsPowerShell\\v1.0\\powershell.exe",
-                profileName: "PowerShell"
-            };
-        }
-        if (defaultProfile.path === "/bin/sh") {
-            return {
-                ...defaultProfile,
-                path: "/bin/bash",
-                profileName: "bash"
-            };
-        }
-        return {
-            ...defaultProfile,
-            icon: undefined
-        };
-    }
-    async getCopilotShell() {
-        return (await this.getCopilotProfile()).path;
-    }
-    _getChatTerminalProfile(os) {
-        let profileSetting;
-        switch (os) {
-        case OperatingSystem.Windows:
-            profileSetting = TerminalChatAgentToolsSettingId.TerminalProfileWindows;
-            break;
-        case OperatingSystem.Macintosh:
-            profileSetting = TerminalChatAgentToolsSettingId.TerminalProfileMacOs;
-            break;
-        case OperatingSystem.Linux:
-        default:
-            profileSetting = TerminalChatAgentToolsSettingId.TerminalProfileLinux;
-            break;
-        }
-        const profile = this._configurationService.getValue(profileSetting);
-        if (this._isValidChatAgentTerminalProfile(profile)) {
-            return profile;
-        }
-        return undefined;
-    }
-    _isValidChatAgentTerminalProfile(profile) {
-        if (profile === null || profile === undefined || typeof profile !== "object") {
-            return false;
-        }
-        if ("path" in profile && isString(profile.path)) {
-            return true;
-        }
-        return false;
-    }
-};
-TerminalProfileFetcher = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, ITerminalProfileResolverService)), ( __param(2, IRemoteAgentService))], TerminalProfileFetcher));
-
-export { RunInTerminalTool, TerminalProfileFetcher, createRunInTerminalToolData };