@codingame/monaco-vscode-chat-service-override 22.1.9 → 23.0.0

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

@@ -1,11 +1,10 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { asArray } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
 import { timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 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, createCommandUri } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+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 { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
 import { OS, OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
@@ -16,108 +15,199 @@ import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/pl
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 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-a9da9abe-278d-5ce6-9418-99c7c07c5c37-common/vscode/vs/platform/terminal/common/capabilities/capabilities';
+import { TerminalCapability } from '@codingame/monaco-vscode-10af0e5d-64cb-56de-b584-29ab4a355d15-common/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-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/browser/chatContentParts/toolInvocationParts/chatTerminalToolConfirmationSubPart';
-import { openTerminalSettingsLinkCommandId } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/browser/chatContentParts/toolInvocationParts/chatTerminalToolProgressPart';
+import { TerminalToolConfirmationStorageKeys } from '@codingame/monaco-vscode-a793b3ee-7ba9-5176-a019-30ec806fdd95-common/vscode/vs/workbench/contrib/chat/browser/chatContentParts/toolInvocationParts/chatTerminalToolConfirmationSubPart';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
-import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { ToolDataSource, ToolInvocationPresentation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService';
 import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
-import { ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.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-a175bd1a-4858-5944-9ae5-fb73305dcb13-common/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-de235d7f-e72a-5adb-9256-acf6c64eb6f2-common/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
 import { getRecommendedToolsOverRunInTerminal } from '../alternativeRecommendation.js';
-import { CommandLineAutoApprover } from '../commandLineAutoApprover.js';
-import { CommandSimplifier } from '../commandSimplifier.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 { isPowerShell, generateAutoApproveActions, dedupeRules } from '../runInTerminalHelpers.js';
+import { isWindowsPowerShell, isPowerShell, isZsh, isFish } from '../runInTerminalHelpers.js';
 import { RunInTerminalToolTelemetry } from '../runInTerminalToolTelemetry.js';
-import { splitCommandLineIntoSubCommands } from '../subCommands.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 { OutputMonitor } from './monitoring/outputMonitor.js';
 import { OutputMonitorState } from './monitoring/types.js';
+import { LocalChatSessionUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatUri';
+import { CommandLineCdPrefixRewriter } from './commandLineRewriter/commandLineCdPrefixRewriter.js';
+import { CommandLinePwshChainOperatorRewriter } from './commandLineRewriter/commandLinePwshChainOperatorRewriter.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';
 
 var RunInTerminalTool_1;
-var TerminalToolStorageKeysInternal;
-(function (TerminalToolStorageKeysInternal) {
-    TerminalToolStorageKeysInternal["TerminalSession"] = "chat.terminalSessions";
-})(TerminalToolStorageKeysInternal || (TerminalToolStorageKeysInternal = {}));
-const RunInTerminalToolData = {
-    id: 'run_in_terminal',
-    toolReferenceName: 'runInTerminal',
-    displayName: ( localize(11585, 'Run in Terminal')),
-    modelDescription: [
-        'This tool allows you to execute shell commands in a persistent terminal session, preserving environment variables, working directory, and other context across multiple commands.',
+function createPowerShellModelDescription(shell) {
+    const isWinPwsh = isWindowsPowerShell(shell);
+    return [
+        `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:',
-        '- Does NOT support multi-line commands',
+        '- Use semicolons ; to chain commands on one line, NEVER use && even when asked explicitly',
+        '- Prefer pipelines | for object-based data flow',
+        '- Never create a sub-shell (eg. powershell -c "command") unless explicitly asked',
         '',
         'Directory Management:',
-        '- Must use absolute paths to avoid navigation issues.',
+        '- Must use absolute paths to avoid navigation issues',
+        '- Use $PWD or Get-Location for current directory',
+        '- Use Push-Location/Pop-Location for directory stack',
         '',
         'Program Execution:',
-        '- Supports Python, Node.js, and other executables.',
-        '- Install dependencies via pip, npm, etc.',
+        '- 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.',
+        '- 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',
         '',
         'Output Management:',
         '- Output is automatically truncated if longer than 60KB to prevent context overflow',
-        '- Use filters like \'head\', \'tail\', \'grep\' to limit output size',
-        '- For pager commands, disable paging: use \'git --no-pager\' or add \'| cat\'',
+        '- 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:',
-        '- Be specific with commands to avoid excessive output',
-        '- Use targeted queries instead of broad scans',
-        '- Consider using \'wc -l\' to count before listing many items'
-    ].join('\n'),
-    userDescription: ( localize(11586, 'Tool for running 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.'
-            },
-            isBackground: {
-                type: 'boolean',
-                description: 'Whether the command starts a background process. If true, the command will run in the background and you will not see the output. If false, the tool call will block on the command finishing, and then you will get the output. Examples of background processes: building in watch mode, starting a server. You can check the output of a background process later on by using get_terminal_output.'
-            },
-        },
-        required: [
-            'command',
-            'explanation',
-            'isBackground',
-        ]
+        '- 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'
+    ].join('\n');
+}
+const genericDescription = `
+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:
+- Must use absolute paths to avoid navigation issues
+- 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
+
+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`;
+function createBashModelDescription() {
+    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,
+        '- 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() {
+    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,
+        '- 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() {
+    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,
+        '- 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 profileFetcher = instantiationService.createInstance(TerminalProfileFetcher);
+    const shell = await profileFetcher.getCopilotShell();
+    const os = await profileFetcher.osBackend;
+    let modelDescription;
+    if (shell && os && isPowerShell(shell, os)) {
+        modelDescription = createPowerShellModelDescription(shell);
     }
-};
+    else if (shell && os && isZsh(shell, os)) {
+        modelDescription = createZshModelDescription();
+    }
+    else if (shell && os && isFish(shell, os)) {
+        modelDescription = createFishModelDescription();
+    }
+    else {
+        modelDescription = createBashModelDescription();
+    }
+    return {
+        id: 'run_in_terminal',
+        toolReferenceName: 'runInTerminal',
+        displayName: ( localize(11867, 'Run in Terminal')),
+        modelDescription,
+        userDescription: ( localize(11868, 'Tool for running 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.'
+                },
+                isBackground: {
+                    type: 'boolean',
+                    description: 'Whether the command starts a background process. If true, the command will run in the background and you will not see the output. If false, the tool call will block on the command finishing, and then you will get the output. Examples of background processes: building in watch mode, starting a server. You can check the output of a background process later on by using get_terminal_output.'
+                },
+            },
+            required: [
+                'command',
+                'explanation',
+                'isBackground',
+            ]
+        }
+    };
+}
+var TerminalToolStorageKeysInternal;
+(function (TerminalToolStorageKeysInternal) {
+    TerminalToolStorageKeysInternal["TerminalSession"] = "chat.terminalSessions";
+})(TerminalToolStorageKeysInternal || (TerminalToolStorageKeysInternal = {}));
 const telemetryIgnoredSequences = [
     '\x1b[I',
     '\x1b[O',
 ];
-const promptInjectionWarningCommandsLower = [
-    'curl',
-    'wget',
-];
-const promptInjectionWarningCommandsLowerPwshOnly = [
-    'invoke-restmethod',
-    'invoke-webrequest',
-    'irm',
-    'iwr',
-];
 let RunInTerminalTool = class RunInTerminalTool extends Disposable {
     static { RunInTerminalTool_1 = this; }
     static { this._backgroundExecutions = ( new Map()); }
@@ -128,23 +218,33 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         }
         return backgroundExecution.getOutput();
     }
-    constructor(_instantiationService, _configurationService, _languageModelToolsService, _storageService, _logService, _terminalProfileResolverService, _terminalService, _remoteAgentService, _chatService) {
+    constructor(_chatService, _configurationService, _historyService, _instantiationService, _languageModelToolsService, _remoteAgentService, _storageService, _terminalChatService, _logService, _terminalService, _workspaceContextService) {
         super();
-        this._instantiationService = _instantiationService;
+        this._chatService = _chatService;
         this._configurationService = _configurationService;
+        this._historyService = _historyService;
+        this._instantiationService = _instantiationService;
         this._languageModelToolsService = _languageModelToolsService;
+        this._remoteAgentService = _remoteAgentService;
         this._storageService = _storageService;
+        this._terminalChatService = _terminalChatService;
         this._logService = _logService;
-        this._terminalProfileResolverService = _terminalProfileResolverService;
         this._terminalService = _terminalService;
-        this._remoteAgentService = _remoteAgentService;
-        this._chatService = _chatService;
+        this._workspaceContextService = _workspaceContextService;
         this._sessionTerminalAssociations = ( new Map());
         this._osBackend = this._remoteAgentService.getEnvironment().then(remoteEnv => remoteEnv?.os ?? OS);
-        this._terminalToolCreator = _instantiationService.createInstance(ToolTerminalCreator);
-        this._commandSimplifier = _instantiationService.createInstance(CommandSimplifier, this._osBackend);
-        this._telemetry = _instantiationService.createInstance(RunInTerminalToolTelemetry);
-        this._commandLineAutoApprover = this._register(_instantiationService.createInstance(CommandLineAutoApprover));
+        this._terminalToolCreator = this._instantiationService.createInstance(ToolTerminalCreator);
+        this._treeSitterCommandParser = this._register(this._instantiationService.createInstance(TreeSitterCommandParser));
+        this._telemetry = this._instantiationService.createInstance(RunInTerminalToolTelemetry);
+        this._profileFetcher = this._instantiationService.createInstance(TerminalProfileFetcher);
+        this._commandLineRewriters = [
+            this._register(this._instantiationService.createInstance(CommandLineCdPrefixRewriter)),
+            this._register(this._instantiationService.createInstance(CommandLinePwshChainOperatorRewriter, this._treeSitterCommandParser)),
+        ];
+        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))),
+        ];
         this._register(Event.runAndSubscribe(this._configurationService.onDidChangeConfiguration, e => {
             if (!e || e.affectsConfiguration(TerminalChatAgentToolsSettingId.EnableAutoApprove)) {
                 if (this._configurationService.getValue(TerminalChatAgentToolsSettingId.EnableAutoApprove) !== true) {
@@ -161,133 +261,102 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             }
         }));
         this._register(this._chatService.onDidDisposeSession(e => {
-            this._cleanupSessionTerminals(e.sessionId);
+            const localSessionId = LocalChatSessionUri.parseLocalSessionId(e.sessionResource);
+            if (localSessionId) {
+                this._cleanupSessionTerminals(localSessionId);
+            }
         }));
     }
     async prepareToolInvocation(context, token) {
         const args = context.parameters;
-        const alternativeRecommendation = getRecommendedToolsOverRunInTerminal(args.command, this._languageModelToolsService);
-        const presentation = alternativeRecommendation ? ToolInvocationPresentation.Hidden : undefined;
-        const os = await this._osBackend;
-        const shell = await this._getCopilotShell();
-        const language = os === OperatingSystem.Windows ? 'pwsh' : 'sh';
         const instance = context.chatSessionId ? this._sessionTerminalAssociations.get(context.chatSessionId)?.instance : undefined;
-        const terminalToolSessionId = generateUuid();
-        let toolEditedCommand = await this._commandSimplifier.rewriteIfNeeded(args, instance, shell);
-        if (toolEditedCommand === args.command) {
-            toolEditedCommand = undefined;
-        }
-        let autoApproveInfo;
-        let confirmationMessages;
-        if (alternativeRecommendation) {
-            confirmationMessages = undefined;
-        }
-        else {
-            const actualCommand = toolEditedCommand ?? args.command;
-            const subCommands = splitCommandLineIntoSubCommands(actualCommand, shell, os);
-            const subCommandResults = ( subCommands.map(e => this._commandLineAutoApprover.isCommandAutoApproved(e, shell, os)));
-            const commandLineResult = this._commandLineAutoApprover.isCommandLineAutoApproved(actualCommand);
-            const autoApproveReasons = [
-                ...( subCommandResults.map(e => e.reason)),
-                commandLineResult.reason,
-            ];
-            let isAutoApproved = false;
-            let isDenied = false;
-            let autoApproveReason;
-            let autoApproveDefault;
-            const deniedSubCommandResult = subCommandResults.find(e => e.result === 'denied');
-            if (deniedSubCommandResult) {
-                this._logService.info('autoApprove: Sub-command DENIED auto approval');
-                isDenied = true;
-                autoApproveDefault = deniedSubCommandResult.rule?.isDefaultRule;
-                autoApproveReason = 'subCommand';
-            }
-            else if (commandLineResult.result === 'denied') {
-                this._logService.info('autoApprove: Command line DENIED auto approval');
-                isDenied = true;
-                autoApproveDefault = commandLineResult.rule?.isDefaultRule;
-                autoApproveReason = 'commandLine';
-            }
-            else {
-                if (subCommandResults.every(e => e.result === 'approved')) {
-                    this._logService.info('autoApprove: All sub-commands auto-approved');
-                    autoApproveReason = 'subCommand';
-                    isAutoApproved = true;
-                    autoApproveDefault = subCommandResults.every(e => e.rule?.isDefaultRule);
-                }
-                else {
-                    this._logService.info('autoApprove: All sub-commands NOT auto-approved');
-                    if (commandLineResult.result === 'approved') {
-                        this._logService.info('autoApprove: Command line auto-approved');
-                        autoApproveReason = 'commandLine';
-                        isAutoApproved = true;
-                        autoApproveDefault = commandLineResult.rule?.isDefaultRule;
-                    }
-                    else {
-                        this._logService.info('autoApprove: Command line NOT auto-approved');
-                    }
+        const [os, shell, cwd] = 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;
                 }
-            }
-            for (const reason of autoApproveReasons) {
-                this._logService.info(`- ${reason}`);
-            }
-            const isAutoApproveEnabled = this._configurationService.getValue(TerminalChatAgentToolsSettingId.EnableAutoApprove) === true;
-            const isAutoApproveWarningAccepted = this._storageService.getBoolean(TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted, StorageScope.APPLICATION, false);
-            const isAutoApproveAllowed = isAutoApproveEnabled && isAutoApproveWarningAccepted;
-            if (isAutoApproveEnabled) {
-                autoApproveInfo = this._createAutoApproveInfo(isAutoApproved, isDenied, autoApproveReason, subCommandResults, commandLineResult);
-            }
-            else {
-                isAutoApproved = false;
-            }
-            this._telemetry.logPrepare({
-                terminalToolSessionId,
-                subCommands,
-                autoApproveAllowed: !isAutoApproveEnabled ? 'off' : isAutoApproveWarningAccepted ? 'allowed' : 'needsOptIn',
-                autoApproveResult: isAutoApproved ? 'approved' : isDenied ? 'denied' : 'manual',
-                autoApproveReason,
-                autoApproveDefault
+                return cwd;
+            })()
+        ]);
+        const language = os === OperatingSystem.Windows ? 'pwsh' : 'sh';
+        const terminalToolSessionId = generateUuid();
+        const terminalCommandId = `tool-${generateUuid()}`;
+        let rewrittenCommand = args.command;
+        for (const rewriter of this._commandLineRewriters) {
+            const rewriteResult = await rewriter.rewrite({
+                commandLine: rewrittenCommand,
+                cwd,
+                shell,
+                os
             });
-            let disclaimer;
-            const subCommandsLowerFirstWordOnly = ( subCommands.map(command => command.split(' ')[0].toLowerCase()));
-            if (!isAutoApproved && (( subCommandsLowerFirstWordOnly.some(command => promptInjectionWarningCommandsLower.includes(command))) ||
-                (isPowerShell(shell, os) && ( subCommandsLowerFirstWordOnly.some(command => promptInjectionWarningCommandsLowerPwshOnly.includes(command)))))) {
-                disclaimer = ( new MarkdownString(`$(${Codicon.info.id}) ` + ( localize(
-                    11587,
-                    'Web content may contain malicious code or attempt prompt injection attacks.'
-                )), { supportThemeIcons: true }));
-            }
-            let customActions;
-            if (!isAutoApproved && isAutoApproveEnabled) {
-                customActions = generateAutoApproveActions(actualCommand, subCommands, { subCommandResults, commandLineResult });
-            }
-            let shellType = basename(shell, '.exe');
-            if (shellType === 'powershell') {
-                shellType = 'pwsh';
+            if (rewriteResult) {
+                rewrittenCommand = rewriteResult.rewritten;
+                this._logService.info(`RunInTerminalTool: Command rewritten by ${rewriter.constructor.name}: ${rewriteResult.reasoning}`);
             }
-            confirmationMessages = (isAutoApproved && isAutoApproveAllowed) ? undefined : {
-                title: args.isBackground
-                    ? ( localize(11588, "Run `{0}` command? (background terminal)", shellType))
-                    : ( localize(11589, "Run `{0}` command?", shellType)),
-                message: ( new MarkdownString(args.explanation)),
-                disclaimer,
-                terminalCustomActions: customActions,
+        }
+        const toolSpecificData = {
+            kind: 'terminal',
+            terminalToolSessionId,
+            terminalCommandId,
+            commandLine: {
+                original: args.command,
+                toolEdited: rewrittenCommand === args.command ? undefined : rewrittenCommand
+            },
+            language,
+        };
+        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 isAutoApproveEnabled = this._configurationService.getValue(TerminalChatAgentToolsSettingId.EnableAutoApprove) === true;
+        const isAutoApproveWarningAccepted = this._storageService.getBoolean(TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted, StorageScope.APPLICATION, false);
+        const isAutoApproveAllowed = isAutoApproveEnabled && isAutoApproveWarningAccepted;
+        const commandLineAnalyzerOptions = {
+            commandLine,
+            cwd,
+            os,
+            shell,
+            treeSitterLanguage: isPowerShell(shell, os) ? TreeSitterCommandParserLanguage.PowerShell : TreeSitterCommandParserLanguage.Bash,
+            terminalToolSessionId,
+        };
+        const commandLineAnalyzerResults = await Promise.all(( this._commandLineAnalyzers.map(e => e.analyze(commandLineAnalyzerOptions))));
+        const disclaimersRaw = commandLineAnalyzerResults.filter(e => e.disclaimers).flatMap(e => e.disclaimers);
+        let disclaimer;
+        if (disclaimersRaw.length > 0) {
+            disclaimer = ( new MarkdownString(
+                `$(${Codicon.info.id}) ` + disclaimersRaw.join(' '),
+                { supportThemeIcons: true }
+            ));
+        }
+        const customActions = ( commandLineAnalyzerResults.map(e => e.customActions ?? [])).flat();
+        toolSpecificData.autoApproveInfo = commandLineAnalyzerResults.find(e => e.autoApproveInfo)?.autoApproveInfo;
+        let shellType = basename(shell, '.exe');
+        if (shellType === 'powershell') {
+            shellType = 'pwsh';
+        }
+        const isFinalAutoApproved = isAutoApproveAllowed && commandLineAnalyzerResults.every(e => e.isAutoApproveAllowed);
+        const confirmationMessages = isFinalAutoApproved ? undefined : {
+            title: args.isBackground
+                ? ( localize(11869, "Run `{0}` command? (background terminal)", shellType))
+                : ( localize(11870, "Run `{0}` command?", shellType)),
+            message: ( new MarkdownString(args.explanation)),
+            disclaimer,
+            terminalCustomActions: customActions,
+        };
         return {
             confirmationMessages,
-            presentation,
-            toolSpecificData: {
-                kind: 'terminal',
-                terminalToolSessionId,
-                commandLine: {
-                    original: args.command,
-                    toolEdited: toolEditedCommand
-                },
-                language,
-                alternativeRecommendation,
-                autoApproveInfo,
-            }
+            toolSpecificData,
         };
     }
     async invoke(invocation, _countTokens, _progress, token) {
@@ -320,18 +389,19 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         const isNewSession = !args.isBackground && !( this._sessionTerminalAssociations.has(chatSessionId));
         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}, chatSessionId=${chatSessionId}`);
         const toolTerminal = await (args.isBackground
-            ? this._initBackgroundTerminal(chatSessionId, termId, token)
-            : this._initForegroundTerminal(chatSessionId, termId, token));
-        this._terminalService.setActiveInstance(toolTerminal.instance);
-        this._terminalService.revealTerminal(toolTerminal.instance, true);
+            ? this._initBackgroundTerminal(chatSessionId, termId, terminalToolSessionId, token)
+            : this._initForegroundTerminal(chatSessionId, termId, terminalToolSessionId, token));
+        this._handleTerminalVisibility(toolTerminal);
         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 => {
@@ -345,7 +415,8 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             let pollingResult;
             try {
                 this._logService.debug(`RunInTerminalTool: Starting background execution \`${command}\``);
-                const execution = ( new BackgroundTerminalExecution(toolTerminal.instance, xterm, command, chatSessionId));
+                const commandId = toolSpecificData.terminalCommandId;
+                const execution = ( new BackgroundTerminalExecution(toolTerminal.instance, xterm, command, chatSessionId, commandId));
                 RunInTerminalTool_1._backgroundExecutions.set(termId, execution);
                 outputMonitor = store.add(this._instantiationService.createInstance(OutputMonitor, execution, undefined, invocation.context, token, command));
                 await Event.toPromise(outputMonitor.onDidFinishCommand);
@@ -364,16 +435,14 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 else if (pollingResult) {
                     resultText += `\n\ The command is still running, with output:\n${pollingResult.output}`;
                 }
-                const toolResultMessage = toolSpecificData.autoApproveInfo;
                 return {
-                    toolResultMessage: toolResultMessage,
                     toolMetadata: {
                         exitCode: undefined
                     },
                     content: [{
                             kind: 'text',
                             value: resultText,
-                        }]
+                        }],
                 };
             }
             catch (e) {
@@ -421,7 +490,6 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             let exitCode;
             try {
                 let strategy;
-                const commandDetection = toolTerminal.instance.capabilities.get(TerminalCapability.CommandDetection);
                 switch (toolTerminal.shellIntegrationQuality) {
                     case ShellIntegrationQuality.None: {
                         strategy = this._instantiationService.createInstance(NoneExecuteStrategy, toolTerminal.instance, () => toolTerminal.receivedUserInput ?? false);
@@ -443,7 +511,8 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                         outputMonitor = store.add(this._instantiationService.createInstance(OutputMonitor, { instance: toolTerminal.instance, sessionId: invocation.context?.sessionId, getOutput: (marker) => getOutput(toolTerminal.instance, marker ?? startMarker) }, undefined, invocation.context, token, command));
                     }
                 }));
-                const executeResult = await strategy.execute(command, token);
+                const commandId = toolSpecificData.terminalCommandId;
+                const executeResult = await strategy.execute(command, token, commandId);
                 toolTerminal.receivedUserInput = false;
                 if (token.isCancellationRequested) {
                     throw ( new CancellationError());
@@ -504,20 +573,8 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 resultText.push(`Note: The tool simplified the command to \`${command}\`, and this is the output of running that command instead:\n`);
             }
             resultText.push(terminalResult);
-            let resolvedToolResultMessage;
-            if (toolSpecificData.autoApproveInfo) {
-                if (toolResultMessage) {
-                    resolvedToolResultMessage = ( new MarkdownString(
-                        `${toolSpecificData.autoApproveInfo.value}\n\n${toolResultMessage}`,
-                        toolSpecificData.autoApproveInfo
-                    ));
-                }
-                else {
-                    resolvedToolResultMessage = toolSpecificData.autoApproveInfo;
-                }
-            }
             return {
-                toolResultMessage: resolvedToolResultMessage,
+                toolResultMessage,
                 toolMetadata: {
                     exitCode: exitCode
                 },
@@ -528,61 +585,18 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             };
         }
     }
-    async _getCopilotShellOrProfile() {
-        const os = await this._osBackend;
-        const customChatAgentProfile = this._getChatTerminalProfile(os);
-        if (customChatAgentProfile) {
-            return customChatAgentProfile;
-        }
-        const defaultShell = await this._terminalProfileResolverService.getDefaultShell({
-            os,
-            remoteAuthority: this._remoteAgentService.getConnection()?.remoteAuthority
-        });
-        if (basename(defaultShell) === 'cmd.exe') {
-            return 'C:\\WINDOWS\\System32\\WindowsPowerShell\\v1.0\\powershell.exe';
-        }
-        return defaultShell;
-    }
-    async _getCopilotShell() {
-        const shellOrProfile = await this._getCopilotShellOrProfile();
-        if (typeof shellOrProfile === 'string') {
-            return shellOrProfile;
-        }
-        return shellOrProfile.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 && typeof profile.path === 'string') {
-            return true;
+    _handleTerminalVisibility(toolTerminal) {
+        if (this._configurationService.getValue(TerminalChatAgentToolsSettingId.OutputLocation) === 'terminal') {
+            this._terminalService.setActiveInstance(toolTerminal.instance);
+            this._terminalService.revealTerminal(toolTerminal.instance, true);
         }
-        return false;
     }
-    async _initBackgroundTerminal(chatSessionId, termId, token) {
+    async _initBackgroundTerminal(chatSessionId, termId, terminalToolSessionId, token) {
         this._logService.debug(`RunInTerminalTool: Creating background terminal with ID=${termId}`);
-        const shellOrProfile = await this._getCopilotShellOrProfile();
-        const toolTerminal = await this._terminalToolCreator.createTerminal(shellOrProfile, token);
+        const profile = await this._profileFetcher.getCopilotProfile();
+        const toolTerminal = await this._terminalToolCreator.createTerminal(profile, token);
+        this._terminalChatService.registerTerminalInstanceWithToolSession(terminalToolSessionId, toolTerminal.instance);
+        this._terminalChatService.registerTerminalInstanceWithChatSession(chatSessionId, toolTerminal.instance);
         this._registerInputListener(toolTerminal);
         this._sessionTerminalAssociations.set(chatSessionId, toolTerminal);
         if (token.isCancellationRequested) {
@@ -592,15 +606,18 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         await this._setupProcessIdAssociation(toolTerminal, chatSessionId, termId, true);
         return toolTerminal;
     }
-    async _initForegroundTerminal(chatSessionId, termId, token) {
+    async _initForegroundTerminal(chatSessionId, termId, terminalToolSessionId, token) {
         const cachedTerminal = this._sessionTerminalAssociations.get(chatSessionId);
         if (cachedTerminal) {
             this._logService.debug(`RunInTerminalTool: Using cached foreground terminal with session ID \`${chatSessionId}\``);
             this._terminalToolCreator.refreshShellIntegrationQuality(cachedTerminal);
+            this._terminalChatService.registerTerminalInstanceWithToolSession(terminalToolSessionId, cachedTerminal.instance);
             return cachedTerminal;
         }
-        const shellOrProfile = await this._getCopilotShellOrProfile();
-        const toolTerminal = await this._terminalToolCreator.createTerminal(shellOrProfile, token);
+        const profile = await this._profileFetcher.getCopilotProfile();
+        const toolTerminal = await this._terminalToolCreator.createTerminal(profile, token);
+        this._terminalChatService.registerTerminalInstanceWithToolSession(terminalToolSessionId, toolTerminal.instance);
+        this._terminalChatService.registerTerminalInstanceWithChatSession(chatSessionId, toolTerminal.instance);
         this._registerInputListener(toolTerminal);
         this._sessionTerminalAssociations.set(chatSessionId, toolTerminal);
         if (token.isCancellationRequested) {
@@ -632,6 +649,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                             shellIntegrationQuality: association.shellIntegrationQuality
                         };
                         this._sessionTerminalAssociations.set(association.sessionId, toolTerminal);
+                        this._terminalChatService.registerTerminalInstanceWithChatSession(association.sessionId, instance);
                         this._register(instance.onDisposed(() => {
                             this._removeProcessIdAssociation(instance.processId);
                         }));
@@ -708,112 +726,97 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             }
         }
     }
-    _createAutoApproveInfo(isAutoApproved, isDenied, autoApproveReason, subCommandResults, commandLineResult) {
-        const formatRuleLinks = (result) => {
-            return ( asArray(result).map(e => {
-                const settingsUri = createCommandUri(openTerminalSettingsLinkCommandId, e.rule.sourceTarget);
-                return `[\`${e.rule.sourceText}\`](${( settingsUri.toString())} "${( localize(11590, 'View rule in settings'))}")`;
-            })).join(', ');
-        };
-        const mdTrustSettings = {
-            isTrusted: {
-                enabledCommands: [openTerminalSettingsLinkCommandId]
-            }
-        };
-        const config = this._configurationService.inspect(ChatConfiguration.GlobalAutoApprove);
-        const isGlobalAutoApproved = config?.value ?? config.defaultValue;
-        if (isGlobalAutoApproved) {
-            const settingsUri = createCommandUri(openTerminalSettingsLinkCommandId, 'global');
-            return (new MarkdownString(`_${( localize(
-                11591,
-                'Auto approved by setting {0}',
-                `[\`${ChatConfiguration.GlobalAutoApprove}\`](${( settingsUri.toString())} "${( localize(11592, 'View settings'))}")`
-            ))}_`, mdTrustSettings));
-        }
-        if (isAutoApproved) {
-            switch (autoApproveReason) {
-                case 'commandLine': {
-                    if (commandLineResult.rule) {
-                        return (new MarkdownString(
-                            `_${( localize(11593, 'Auto approved by rule {0}', formatRuleLinks(commandLineResult)))}_`,
-                            mdTrustSettings
-                        ));
-                    }
-                    break;
-                }
-                case 'subCommand': {
-                    const uniqueRules = dedupeRules(subCommandResults);
-                    if (uniqueRules.length === 1) {
-                        return (new MarkdownString(
-                            `_${( localize(11593, 'Auto approved by rule {0}', formatRuleLinks(uniqueRules)))}_`,
-                            mdTrustSettings
-                        ));
-                    }
-                    else if (uniqueRules.length > 1) {
-                        return (new MarkdownString(
-                            `_${( localize(11594, 'Auto approved by rules {0}', formatRuleLinks(uniqueRules)))}_`,
-                            mdTrustSettings
-                        ));
-                    }
-                    break;
-                }
-            }
-        }
-        else if (isDenied) {
-            switch (autoApproveReason) {
-                case 'commandLine': {
-                    if (commandLineResult.rule) {
-                        return (new MarkdownString(`_${( localize(
-                            11595,
-                            'Auto approval denied by rule {0}',
-                            formatRuleLinks(commandLineResult)
-                        ))}_`, mdTrustSettings));
-                    }
-                    break;
-                }
-                case 'subCommand': {
-                    const uniqueRules = dedupeRules(subCommandResults.filter(e => e.result === 'denied'));
-                    if (uniqueRules.length === 1) {
-                        return (new MarkdownString(
-                            `_${( localize(11595, 'Auto approval denied by rule {0}', formatRuleLinks(uniqueRules)))}_`
-                        ));
-                    }
-                    else if (uniqueRules.length > 1) {
-                        return (new MarkdownString(
-                            `_${( localize(11596, 'Auto approval denied by rules {0}', formatRuleLinks(uniqueRules)))}_`
-                        ));
-                    }
-                    break;
-                }
-            }
-        }
-        return undefined;
-    }
 };
 RunInTerminalTool = RunInTerminalTool_1 = ( __decorate([
-    ( __param(0, IInstantiationService)),
+    ( __param(0, IChatService)),
     ( __param(1, IConfigurationService)),
-    ( __param(2, ILanguageModelToolsService)),
-    ( __param(3, IStorageService)),
-    ( __param(4, ITerminalLogService)),
-    ( __param(5, ITerminalProfileResolverService)),
-    ( __param(6, ITerminalService)),
-    ( __param(7, IRemoteAgentService)),
-    ( __param(8, IChatService))
+    ( __param(2, IHistoryService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, ILanguageModelToolsService)),
+    ( __param(5, IRemoteAgentService)),
+    ( __param(6, IStorageService)),
+    ( __param(7, ITerminalChatService)),
+    ( __param(8, ITerminalLogService)),
+    ( __param(9, ITerminalService)),
+    ( __param(10, IWorkspaceContextService))
 ], RunInTerminalTool));
 class BackgroundTerminalExecution extends Disposable {
-    constructor(instance, _xterm, _commandLine, sessionId) {
+    constructor(instance, _xterm, _commandLine, sessionId, commandId) {
         super();
         this.instance = instance;
         this._xterm = _xterm;
         this._commandLine = _commandLine;
         this.sessionId = sessionId;
         this._startMarker = this._register(this._xterm.raw.registerMarker());
-        this.instance.runCommand(this._commandLine, true);
+        this.instance.runCommand(this._commandLine, true, commandId);
     }
     getOutput(marker) {
         return getOutput(this.instance, marker ?? this._startMarker);
     }
 }
+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'
+            };
+        }
+        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 && typeof profile.path === 'string') {
+            return true;
+        }
+        return false;
+    }
+};
+TerminalProfileFetcher = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, ITerminalProfileResolverService)),
+    ( __param(2, IRemoteAgentService))
+], TerminalProfileFetcher));
 
-export { RunInTerminalTool, RunInTerminalToolData };
+export { RunInTerminalTool, TerminalProfileFetcher, createRunInTerminalToolData };