@codingame/monaco-vscode-chat-service-override 20.5.0 → 21.0.1

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

@@ -1,48 +1,60 @@
 
 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 { 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';
 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 { 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 { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
 import { TerminalCapability } from '@codingame/monaco-vscode-a9da9abe-278d-5ce6-9418-99c7c07c5c37-common/vscode/vs/platform/terminal/common/capabilities/capabilities';
 import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
-import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
 import { IRemoteAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
-import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
-import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService';
+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 { ITerminalProfileResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal.service';
-import { getRecommendedToolsOverRunInTerminal } from './alternativeRecommendation.js';
-import { pollForOutputAndIdle, racePollingOrPrompt, promptForMorePolling, getOutput } from './bufferOutputPolling.js';
-import { CommandLineAutoApprover } from './commandLineAutoApprover.js';
-import { BasicExecuteStrategy } from './executeStrategy/basicExecuteStrategy.js';
-import { NoneExecuteStrategy } from './executeStrategy/noneExecuteStrategy.js';
-import { RichExecuteStrategy } from './executeStrategy/richExecuteStrategy.js';
-import { isPowerShell } from './runInTerminalHelpers.js';
-import { splitCommandLineIntoSubCommands, extractInlineSubCommands } from './subCommands.js';
-import { ShellIntegrationQuality, ToolTerminalCreator } from './toolTerminalCreator.js';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-a175bd1a-4858-5944-9ae5-fb73305dcb13-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 { OutputMonitor } from './monitoring/outputMonitor.js';
+import { isPowerShell, generateAutoApproveActions } from '../runInTerminalHelpers.js';
+import { RunInTerminalToolTelemetry } from '../runInTerminalToolTelemetry.js';
+import { splitCommandLineIntoSubCommands } from '../subCommands.js';
+import { ToolTerminalCreator, ShellIntegrationQuality } from '../toolTerminalCreator.js';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { TerminalToolConfirmationStorageKeys } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/browser/chatContentParts/toolInvocationParts/chatTerminalToolConfirmationSubPart';
+import { OutputMonitorState } from './monitoring/types.js';
+import { getOutput } from '../outputHelpers.js';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 
 var RunInTerminalTool_1;
-const TERMINAL_SESSION_STORAGE_KEY = 'chat.terminalSessions';
+var TerminalToolStorageKeysInternal;
+(function (TerminalToolStorageKeysInternal) {
+    TerminalToolStorageKeysInternal["TerminalSession"] = "chat.terminalSessions";
+})(TerminalToolStorageKeysInternal || (TerminalToolStorageKeysInternal = {}));
 const RunInTerminalToolData = {
     id: 'run_in_terminal',
     toolReferenceName: 'runInTerminal',
-    displayName: ( localize(11264, 'Run in Terminal')),
+    displayName: ( localize(11451, '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.',
         '',
         'Command Execution:',
-        '- Supports multi-line commands',
+        '- Does NOT support multi-line commands',
         '',
         'Directory Management:',
         '- Must use absolute paths to avoid navigation issues.',
@@ -65,8 +77,9 @@ const RunInTerminalToolData = {
         '- Use targeted queries instead of broad scans',
         '- Consider using \'wc -l\' to count before listing many items'
     ].join('\n'),
-    userDescription: ( localize(11265, 'Tool for running commands in the terminal')),
+    userDescription: ( localize(11452, 'Tool for running commands in the terminal')),
     source: ToolDataSource.Internal,
+    icon: Codicon.terminal,
     inputSchema: {
         type: 'object',
         properties: {
@@ -94,6 +107,16 @@ 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()); }
@@ -104,22 +127,30 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         }
         return backgroundExecution.getOutput();
     }
-    constructor(_instantiationService, _languageModelToolsService, _storageService, _telemetryService, _logService, _terminalProfileResolverService, _terminalService, _remoteAgentService, _chatService, _workspaceContextService, _languageModelsService) {
+    constructor(_instantiationService, _configurationService, _languageModelToolsService, _storageService, _logService, _terminalProfileResolverService, _terminalService, _remoteAgentService, _chatService) {
         super();
         this._instantiationService = _instantiationService;
+        this._configurationService = _configurationService;
         this._languageModelToolsService = _languageModelToolsService;
         this._storageService = _storageService;
-        this._telemetryService = _telemetryService;
         this._logService = _logService;
         this._terminalProfileResolverService = _terminalProfileResolverService;
         this._terminalService = _terminalService;
         this._remoteAgentService = _remoteAgentService;
         this._chatService = _chatService;
-        this._workspaceContextService = _workspaceContextService;
-        this._languageModelsService = _languageModelsService;
         this._sessionTerminalAssociations = ( new Map());
-        this._commandLineAutoApprover = this._register(_instantiationService.createInstance(CommandLineAutoApprover));
         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._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 => {
             for (const [sessionId, toolTerminal] of this._sessionTerminalAssociations.entries()) {
@@ -134,51 +165,62 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
     }
     async prepareToolInvocation(context, token) {
         const args = context.parameters;
-        this._alternativeRecommendation = getRecommendedToolsOverRunInTerminal(args.command, this._languageModelToolsService);
-        const presentation = this._alternativeRecommendation ? 'hidden' : undefined;
+        const alternativeRecommendation = getRecommendedToolsOverRunInTerminal(args.command, this._languageModelToolsService);
+        const presentation = alternativeRecommendation ? ToolInvocationPresentation.Hidden : undefined;
         const os = await this._osBackend;
-        const shell = await this._terminalProfileResolverService.getDefaultShell({
-            os,
-            remoteAuthority: this._remoteAgentService.getConnection()?.remoteAuthority
-        });
+        const shell = await this._getCopilotShell();
         const language = os === OperatingSystem.Windows ? 'pwsh' : 'sh';
         const instance = context.chatSessionId ? this._sessionTerminalAssociations.get(context.chatSessionId)?.instance : undefined;
-        let toolEditedCommand = await this._rewriteCommandIfNeeded(args, instance, shell);
+        const terminalToolSessionId = generateUuid();
+        let toolEditedCommand = await this._commandSimplifier.rewriteIfNeeded(args, instance, shell);
         if (toolEditedCommand === args.command) {
             toolEditedCommand = undefined;
         }
+        let autoApproveInfo;
         let confirmationMessages;
-        if (this._alternativeRecommendation) {
+        if (alternativeRecommendation) {
             confirmationMessages = undefined;
         }
         else {
             const actualCommand = toolEditedCommand ?? args.command;
             const subCommands = splitCommandLineIntoSubCommands(actualCommand, shell, os);
-            const inlineSubCommands = ( subCommands.map(e => Array.from(extractInlineSubCommands(e, shell, os)))).flat();
-            const allSubCommands = [...subCommands, ...inlineSubCommands];
-            const subCommandResults = ( allSubCommands.map(e => this._commandLineAutoApprover.isCommandAutoApproved(e, 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;
-            if (( subCommandResults.some(e => e.result === 'denied'))) {
+            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');
@@ -188,11 +230,47 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             for (const reason of autoApproveReasons) {
                 this._logService.info(`- ${reason}`);
             }
-            confirmationMessages = isAutoApproved ? undefined : {
+            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
+            });
+            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(
+                    11453,
+                    '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';
+            }
+            confirmationMessages = (isAutoApproved && isAutoApproveAllowed) ? undefined : {
                 title: args.isBackground
-                    ? ( localize(11266, "Run command in background terminal"))
-                    : ( localize(11267, "Run command in terminal")),
+                    ? ( localize(11454, "Run `{0}` command? (background terminal)", shellType))
+                    : ( localize(11455, "Run `{0}` command?", shellType)),
                 message: ( new MarkdownString(args.explanation)),
+                disclaimer,
+                terminalCustomActions: customActions,
             };
         }
         return {
@@ -200,24 +278,32 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             presentation,
             toolSpecificData: {
                 kind: 'terminal',
+                terminalToolSessionId,
                 commandLine: {
                     original: args.command,
                     toolEdited: toolEditedCommand
                 },
                 language,
+                alternativeRecommendation,
+                autoApproveInfo,
             }
         };
     }
     async invoke(invocation, _countTokens, _progress, token) {
-        if (this._alternativeRecommendation) {
-            return this._alternativeRecommendation;
-        }
-        const args = invocation.parameters;
-        this._logService.debug(`RunInTerminalTool: Invoking with options ${JSON.stringify(args)}`);
         const toolSpecificData = invocation.toolSpecificData;
         if (!toolSpecificData) {
             throw ( new Error('toolSpecificData must be provided for this tool'));
         }
+        if (toolSpecificData.alternativeRecommendation) {
+            return {
+                content: [{
+                        kind: 'text',
+                        value: toolSpecificData.alternativeRecommendation
+                    }]
+            };
+        }
+        const args = invocation.parameters;
+        this._logService.debug(`RunInTerminalTool: Invoking with options ${JSON.stringify(args)}`);
         let toolResultMessage;
         const chatSessionId = invocation.context?.sessionId ?? 'no-chat-session';
         const command = toolSpecificData.commandLine.userEdited ?? toolSpecificData.commandLine.toolEdited ?? toolSpecificData.commandLine.original;
@@ -253,34 +339,36 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             }
             inputUserSigint ||= data === '\x03';
         }));
+        let outputMonitor;
         if (args.isBackground) {
-            let outputAndIdle = undefined;
+            let pollingResult;
             try {
                 this._logService.debug(`RunInTerminalTool: Starting background execution \`${command}\``);
-                const execution = ( new BackgroundTerminalExecution(toolTerminal.instance, xterm, command));
+                const execution = ( new BackgroundTerminalExecution(toolTerminal.instance, xterm, command, chatSessionId));
                 RunInTerminalTool_1._backgroundExecutions.set(termId, execution);
-                outputAndIdle = await pollForOutputAndIdle(execution, false, token, this._languageModelsService);
+                outputMonitor = store.add(this._instantiationService.createInstance(OutputMonitor, execution, undefined, invocation.context, token, command));
+                await Event.toPromise(outputMonitor.onDidFinishCommand);
+                const pollingResult = outputMonitor.pollingResult;
                 if (token.isCancellationRequested) {
                     throw ( new CancellationError());
                 }
-                if (!outputAndIdle.terminalExecutionIdleBeforeTimeout) {
-                    outputAndIdle = await racePollingOrPrompt(() => pollForOutputAndIdle(execution, true, token, this._languageModelsService), () => promptForMorePolling(command, token, invocation.context, this._chatService), outputAndIdle, token, this._languageModelsService, execution);
-                    if (token.isCancellationRequested) {
-                        throw ( new CancellationError());
-                    }
-                }
                 let resultText = (didUserEditCommand
                     ? `Note: The user manually edited the command to \`${command}\`, and that command is now running in terminal with ID=${termId}`
                     : didToolEditCommand
                         ? `Note: The tool simplified the command to \`${command}\`, and that command is now running in terminal with ID=${termId}`
                         : `Command is running in terminal with ID=${termId}`);
-                if (outputAndIdle && outputAndIdle.modelOutputEvalResponse) {
-                    resultText += `\n\ The command became idle with output:\n${outputAndIdle.modelOutputEvalResponse}`;
+                if (pollingResult && pollingResult.modelOutputEvalResponse) {
+                    resultText += `\n\ The command became idle with output:\n${pollingResult.modelOutputEvalResponse}`;
                 }
-                else if (outputAndIdle) {
-                    resultText += `\n\ The command is still running, with output:\n${outputAndIdle.output}`;
+                else if (pollingResult) {
+                    resultText += `\n\ The command is still running, with output:\n${pollingResult.output}`;
+                }
+                let toolResultMessage;
+                if (toolSpecificData.autoApproveInfo) {
+                    toolResultMessage = toolSpecificData.autoApproveInfo.value;
                 }
                 return {
+                    toolResultMessage: toolResultMessage ? ( new MarkdownString(toolResultMessage)) : undefined,
                     content: [{
                             kind: 'text',
                             value: resultText,
@@ -297,9 +385,10 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             }
             finally {
                 store.dispose();
-                this._logService.debug(`RunInTerminalTool: Finished polling \`${outputAndIdle?.output.length}\` lines of output in \`${outputAndIdle?.pollDurationMs}\``);
+                this._logService.debug(`RunInTerminalTool: Finished polling \`${pollingResult?.output.length}\` lines of output in \`${pollingResult?.pollDurationMs}\``);
                 const timingExecuteMs = Date.now() - timingStart;
-                this._sendTelemetry(toolTerminal.instance, {
+                this._telemetry.logInvoke(toolTerminal.instance, {
+                    terminalToolSessionId: toolSpecificData.terminalToolSessionId,
                     didUserEditCommand,
                     didToolEditCommand,
                     shellIntegrationQuality: toolTerminal.shellIntegrationQuality,
@@ -309,11 +398,14 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                     isNewSession: true,
                     timingExecuteMs,
                     timingConnectMs,
-                    terminalExecutionIdleBeforeTimeout: outputAndIdle?.terminalExecutionIdleBeforeTimeout,
-                    outputLineCount: outputAndIdle?.output ? count(outputAndIdle.output, '\n') : 0,
-                    pollDurationMs: outputAndIdle?.pollDurationMs,
+                    terminalExecutionIdleBeforeTimeout: pollingResult?.state === OutputMonitorState.Idle,
+                    outputLineCount: 0,
+                    pollDurationMs: pollingResult?.pollDurationMs,
                     inputUserChars,
                     inputUserSigint,
+                    inputToolManualAcceptCount: outputMonitor?.outputMonitorTelemetryCounters.inputToolManualAcceptCount,
+                    inputToolManualRejectCount: outputMonitor?.outputMonitorTelemetryCounters.inputToolManualRejectCount,
+                    inputToolManualChars: outputMonitor?.outputMonitorTelemetryCounters.inputToolManualChars,
                 });
             }
         }
@@ -326,11 +418,12 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 const commandDetection = toolTerminal.instance.capabilities.get(TerminalCapability.CommandDetection);
                 switch (toolTerminal.shellIntegrationQuality) {
                     case ShellIntegrationQuality.None: {
-                        strategy = this._instantiationService.createInstance(NoneExecuteStrategy, toolTerminal.instance);
+                        strategy = this._instantiationService.createInstance(NoneExecuteStrategy, toolTerminal.instance, () => toolTerminal.receivedUserInput ?? false);
+                        toolResultMessage = '$(info) Enable [shell integration](https://code.visualstudio.com/docs/terminal/shell-integration) to improve command detection';
                         break;
                     }
                     case ShellIntegrationQuality.Basic: {
-                        strategy = this._instantiationService.createInstance(BasicExecuteStrategy, toolTerminal.instance, commandDetection);
+                        strategy = this._instantiationService.createInstance(BasicExecuteStrategy, toolTerminal.instance, () => toolTerminal.receivedUserInput ?? false, commandDetection);
                         break;
                     }
                     case ShellIntegrationQuality.Rich: {
@@ -339,7 +432,11 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                     }
                 }
                 this._logService.debug(`RunInTerminalTool: Using \`${strategy.type}\` execute strategy for command \`${command}\``);
+                store.add(strategy.onDidCreateStartMarker(startMarker => {
+                    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);
+                toolTerminal.receivedUserInput = false;
                 if (token.isCancellationRequested) {
                     throw ( new CancellationError());
                 }
@@ -365,7 +462,8 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             finally {
                 store.dispose();
                 const timingExecuteMs = Date.now() - timingStart;
-                this._sendTelemetry(toolTerminal.instance, {
+                this._telemetry.logInvoke(toolTerminal.instance, {
+                    terminalToolSessionId: toolSpecificData.terminalToolSessionId,
                     didUserEditCommand,
                     didToolEditCommand,
                     isBackground: false,
@@ -378,6 +476,11 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                     timingConnectMs,
                     inputUserChars,
                     inputUserSigint,
+                    terminalExecutionIdleBeforeTimeout: undefined,
+                    pollDurationMs: undefined,
+                    inputToolManualAcceptCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolManualAcceptCount,
+                    inputToolManualRejectCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolManualRejectCount,
+                    inputToolManualChars: outputMonitor?.outputMonitorTelemetryCounters?.inputToolManualChars,
                 });
             }
             const resultText = [];
@@ -388,8 +491,16 @@ 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);
+            if (toolSpecificData.autoApproveInfo) {
+                if (toolResultMessage) {
+                    toolResultMessage = `${toolSpecificData.autoApproveInfo.value}\n\n${toolResultMessage}`;
+                }
+                else {
+                    toolResultMessage = toolSpecificData.autoApproveInfo.value;
+                }
+            }
             return {
-                toolResultMessage,
+                toolResultMessage: toolResultMessage ? ( new MarkdownString(toolResultMessage)) : undefined,
                 content: [{
                         kind: 'text',
                         value: resultText.join(''),
@@ -397,9 +508,21 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             };
         }
     }
+    async _getCopilotShell() {
+        const defaultShell = await this._terminalProfileResolverService.getDefaultShell({
+            os: await this._osBackend,
+            remoteAuthority: this._remoteAgentService.getConnection()?.remoteAuthority
+        });
+        if (basename(defaultShell) === 'cmd.exe') {
+            return 'C:\\WINDOWS\\System32\\WindowsPowerShell\\v1.0\\powershell.exe';
+        }
+        return defaultShell;
+    }
     async _initBackgroundTerminal(chatSessionId, termId, token) {
         this._logService.debug(`RunInTerminalTool: Creating background terminal with ID=${termId}`);
-        const toolTerminal = await this._instantiationService.createInstance(ToolTerminalCreator).createTerminal(token);
+        const shell = await this._getCopilotShell();
+        const toolTerminal = await this._terminalToolCreator.createTerminal(shell, token);
+        this._registerInputListener(toolTerminal);
         this._sessionTerminalAssociations.set(chatSessionId, toolTerminal);
         if (token.isCancellationRequested) {
             toolTerminal.instance.dispose();
@@ -412,9 +535,12 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         const cachedTerminal = this._sessionTerminalAssociations.get(chatSessionId);
         if (cachedTerminal) {
             this._logService.debug(`RunInTerminalTool: Using cached foreground terminal with session ID \`${chatSessionId}\``);
+            this._terminalToolCreator.refreshShellIntegrationQuality(cachedTerminal);
             return cachedTerminal;
         }
-        const toolTerminal = await this._instantiationService.createInstance(ToolTerminalCreator).createTerminal(token);
+        const shell = await this._getCopilotShell();
+        const toolTerminal = await this._terminalToolCreator.createTerminal(shell, token);
+        this._registerInputListener(toolTerminal);
         this._sessionTerminalAssociations.set(chatSessionId, toolTerminal);
         if (token.isCancellationRequested) {
             toolTerminal.instance.dispose();
@@ -423,46 +549,16 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         await this._setupProcessIdAssociation(toolTerminal, chatSessionId, termId, false);
         return toolTerminal;
     }
-    async _rewriteCommandIfNeeded(args, instance, shell) {
-        const commandLine = args.command;
-        const os = await this._osBackend;
-        const isPwsh = isPowerShell(shell, os);
-        const cdPrefixMatch = commandLine.match(isPwsh
-            ? /^(?:cd(?: \/d)?|Set-Location(?: -Path)?) (?<dir>[^\s]+) ?(?:&&|;)\s+(?<suffix>.+)$/i
-            : /^cd (?<dir>[^\s]+) &&\s+(?<suffix>.+)$/);
-        const cdDir = cdPrefixMatch?.groups?.dir;
-        const cdSuffix = cdPrefixMatch?.groups?.suffix;
-        if (cdDir && cdSuffix) {
-            let cwd;
-            if (instance) {
-                cwd = await instance.getCwdResource();
-            }
-            if (!cwd) {
-                const workspaceFolders = this._workspaceContextService.getWorkspace().folders;
-                if (workspaceFolders.length === 1) {
-                    cwd = workspaceFolders[0].uri;
-                }
-            }
-            if (cwd) {
-                let cdDirPath = cdDir;
-                if (cdDirPath.startsWith('"') && cdDirPath.endsWith('"')) {
-                    cdDirPath = cdDirPath.slice(1, -1);
-                }
-                cdDirPath = cdDirPath.replace(/(?:[\\\/])$/, '');
-                let cwdFsPath = cwd.fsPath.replace(/(?:[\\\/])$/, '');
-                if (os === OperatingSystem.Windows) {
-                    cdDirPath = cdDirPath.toLowerCase();
-                    cwdFsPath = cwdFsPath.toLowerCase();
-                }
-                if (cdDirPath === cwdFsPath) {
-                    return cdSuffix;
-                }
+    _registerInputListener(toolTerminal) {
+        const disposable = toolTerminal.instance.onData(data => {
+            if (!telemetryIgnoredSequences.includes(data)) {
+                toolTerminal.receivedUserInput = data.length > 0;
             }
-        }
-        return commandLine;
+        });
+        this._register(toolTerminal.instance.onDisposed(() => disposable.dispose()));
     }
     _restoreTerminalAssociations() {
-        const storedAssociations = this._storageService.get(TERMINAL_SESSION_STORAGE_KEY, StorageScope.WORKSPACE, '{}');
+        const storedAssociations = this._storageService.get(TerminalToolStorageKeysInternal.TerminalSession, StorageScope.WORKSPACE, '{}');
         try {
             const associations = JSON.parse(storedAssociations);
             for (const instance of this._terminalService.instances) {
@@ -501,7 +597,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 timeout(5000).then(() => { throw ( new Error('Timeout')); })
             ]);
             if (typeof pid === 'number') {
-                const storedAssociations = this._storageService.get(TERMINAL_SESSION_STORAGE_KEY, StorageScope.WORKSPACE, '{}');
+                const storedAssociations = this._storageService.get(TerminalToolStorageKeysInternal.TerminalSession, StorageScope.WORKSPACE, '{}');
                 const associations = JSON.parse(storedAssociations);
                 const existingAssociation = associations[pid] || {};
                 associations[pid] = {
@@ -511,7 +607,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                     id,
                     isBackground
                 };
-                this._storageService.store(TERMINAL_SESSION_STORAGE_KEY, JSON.stringify(associations), StorageScope.WORKSPACE, StorageTarget.USER);
+                this._storageService.store(TerminalToolStorageKeysInternal.TerminalSession, JSON.stringify(associations), StorageScope.WORKSPACE, StorageTarget.USER);
                 this._logService.debug(`RunInTerminalTool: Associated terminal PID ${pid} with session ${sessionId}`);
             }
         }
@@ -521,11 +617,11 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
     }
     async _removeProcessIdAssociation(pid) {
         try {
-            const storedAssociations = this._storageService.get(TERMINAL_SESSION_STORAGE_KEY, StorageScope.WORKSPACE, '{}');
+            const storedAssociations = this._storageService.get(TerminalToolStorageKeysInternal.TerminalSession, StorageScope.WORKSPACE, '{}');
             const associations = JSON.parse(storedAssociations);
             if (associations[pid]) {
                 delete associations[pid];
-                this._storageService.store(TERMINAL_SESSION_STORAGE_KEY, JSON.stringify(associations), StorageScope.WORKSPACE, StorageTarget.USER);
+                this._storageService.store(TerminalToolStorageKeysInternal.TerminalSession, JSON.stringify(associations), StorageScope.WORKSPACE, StorageTarget.USER);
                 this._logService.debug(`RunInTerminalTool: Removed terminal association for PID ${pid}`);
             }
         }
@@ -551,49 +647,102 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             }
         }
     }
-    _sendTelemetry(instance, state) {
-        this._telemetryService.publicLog2('toolUse.runInTerminal', {
-            terminalSessionId: instance.sessionId,
-            result: state.error ?? 'success',
-            strategy: state.shellIntegrationQuality === ShellIntegrationQuality.Rich ? 2 : state.shellIntegrationQuality === ShellIntegrationQuality.Basic ? 1 : 0,
-            userEditedCommand: state.didUserEditCommand ? 1 : 0,
-            toolEditedCommand: state.didToolEditCommand ? 1 : 0,
-            isBackground: state.isBackground ? 1 : 0,
-            isNewSession: state.isNewSession ? 1 : 0,
-            outputLineCount: state.outputLineCount,
-            nonZeroExitCode: state.exitCode === undefined ? -1 : state.exitCode === 0 ? 0 : 1,
-            timingConnectMs: state.timingConnectMs,
-            pollDurationMs: state.pollDurationMs ?? 0,
-            terminalExecutionIdleBeforeTimeout: state.terminalExecutionIdleBeforeTimeout ?? false,
-            inputUserChars: state.inputUserChars,
-            inputUserSigint: state.inputUserSigint,
-        });
+    _createAutoApproveInfo(isAutoApproved, isDenied, autoApproveReason, subCommandResults, commandLineResult) {
+        function formatRuleLinks(result) {
+            return ( asArray(result).map(e => {
+                return `[\`${e.rule.sourceText}\`](settings_${e.rule.sourceTarget} "${( localize(11456, 'View rule in settings'))}")`;
+            })).join(', ');
+        }
+        const config = this._configurationService.inspect(ChatConfiguration.GlobalAutoApprove);
+        const isGlobalAutoApproved = config?.value ?? config.defaultValue;
+        if (isGlobalAutoApproved) {
+            return (new MarkdownString(`_${( localize(
+                11457,
+                'Auto approved by setting {0}',
+                `[\`${ChatConfiguration.GlobalAutoApprove}\`](settings_global "${( localize(11458, 'View settings'))}")`
+            ))}_`));
+        }
+        if (isAutoApproved) {
+            switch (autoApproveReason) {
+                case 'commandLine': {
+                    if (commandLineResult.rule) {
+                        return (new MarkdownString(
+                            `_${( localize(11459, 'Auto approved by rule {0}', formatRuleLinks(commandLineResult)))}_`
+                        ));
+                    }
+                    break;
+                }
+                case 'subCommand': {
+                    const uniqueRules = Array.from(( new Set(subCommandResults)));
+                    if (uniqueRules.length === 1) {
+                        return (new MarkdownString(
+                            `_${( localize(11459, 'Auto approved by rule {0}', formatRuleLinks(uniqueRules)))}_`
+                        ));
+                    }
+                    else if (uniqueRules.length > 1) {
+                        return (new MarkdownString(
+                            `_${( localize(11460, 'Auto approved by rules {0}', formatRuleLinks(uniqueRules)))}_`
+                        ));
+                    }
+                    break;
+                }
+            }
+        }
+        else if (isDenied) {
+            switch (autoApproveReason) {
+                case 'commandLine': {
+                    if (commandLineResult.rule) {
+                        return (new MarkdownString(`_${( localize(
+                            11461,
+                            'Auto approval denied by rule {0}',
+                            formatRuleLinks(commandLineResult)
+                        ))}_`));
+                    }
+                    break;
+                }
+                case 'subCommand': {
+                    const deniedRules = subCommandResults.filter(e => e.result === 'denied');
+                    const uniqueRules = Array.from(( new Set(deniedRules)));
+                    if (uniqueRules.length === 1) {
+                        return (new MarkdownString(
+                            `_${( localize(11461, 'Auto approval denied by rule {0}', formatRuleLinks(uniqueRules)))}_`
+                        ));
+                    }
+                    else if (uniqueRules.length > 1) {
+                        return (new MarkdownString(
+                            `_${( localize(11462, 'Auto approval denied by rules {0}', formatRuleLinks(uniqueRules)))}_`
+                        ));
+                    }
+                    break;
+                }
+            }
+        }
+        return undefined;
     }
 };
 RunInTerminalTool = RunInTerminalTool_1 = ( __decorate([
     ( __param(0, IInstantiationService)),
-    ( __param(1, ILanguageModelToolsService)),
-    ( __param(2, IStorageService)),
-    ( __param(3, ITelemetryService)),
+    ( __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(9, IWorkspaceContextService)),
-    ( __param(10, ILanguageModelsService))
+    ( __param(8, IChatService))
 ], RunInTerminalTool));
 class BackgroundTerminalExecution extends Disposable {
-    constructor(instance, _xterm, _commandLine) {
+    constructor(instance, _xterm, _commandLine, sessionId) {
         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);
     }
-    getOutput() {
-        return getOutput(this.instance, this._startMarker);
+    getOutput(marker) {
+        return getOutput(this.instance, marker ?? this._startMarker);
     }
 }