@codingame/monaco-vscode-chat-service-override 24.2.0 → 25.0.0

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/executeStrategy/noneExecuteStrategy.js

@@ -5,7 +5,7 @@ import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/even
 import { MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
 import { waitForIdle, waitForIdleWithPromptHeuristics } from './executeStrategy.js';
-import { setupRecreatingStartMarker } from './strategyHelpers.js';
+import { createAltBufferPromise, setupRecreatingStartMarker } from './strategyHelpers.js';
 
 let NoneExecuteStrategy = class NoneExecuteStrategy {
     constructor(_instance, _hasReceivedUserInput, _logService) {
@@ -28,6 +28,7 @@ let NoneExecuteStrategy = class NoneExecuteStrategy {
             if (!xterm) {
                 throw ( new Error('Xterm is not available'));
             }
+            const alternateBufferPromise = createAltBufferPromise(xterm, store, this._log.bind(this));
             this._log('Waiting for idle');
             await waitForIdle(this._instance.onData, 1000);
             if (token.isCancellationRequested) {
@@ -42,7 +43,21 @@ let NoneExecuteStrategy = class NoneExecuteStrategy {
             this._log(`Executing command line \`${commandLine}\``);
             this._instance.sendText(commandLine, true);
             this._log('Waiting for idle with prompt heuristics');
-            const promptResult = await waitForIdleWithPromptHeuristics(this._instance.onData, this._instance, 1000, 10000);
+            const promptResultOrAltBuffer = await Promise.race([
+                waitForIdleWithPromptHeuristics(this._instance.onData, this._instance, 1000, 10000),
+                alternateBufferPromise.then(() => 'alternateBuffer')
+            ]);
+            if (promptResultOrAltBuffer === 'alternateBuffer') {
+                this._log('Detected alternate buffer entry, skipping output capture');
+                return {
+                    output: undefined,
+                    additionalInformation: undefined,
+                    exitCode: undefined,
+                    error: 'alternateBuffer',
+                    didEnterAltBuffer: true,
+                };
+            }
+            const promptResult = promptResultOrAltBuffer;
             this._log(`Prompt detection result: ${promptResult.detected ? 'detected' : 'not detected'} - ${promptResult.reason}`);
             if (token.isCancellationRequested) {
                 throw ( new CancellationError());

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/executeStrategy/richExecuteStrategy.js

@@ -6,7 +6,7 @@ import { MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api
 import { isNumber } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
 import { trackIdleOnPrompt } from './executeStrategy.js';
-import { setupRecreatingStartMarker } from './strategyHelpers.js';
+import { createAltBufferPromise, setupRecreatingStartMarker } from './strategyHelpers.js';
 
 let RichExecuteStrategy = class RichExecuteStrategy {
     constructor(_instance, _commandDetection, _logService) {
@@ -26,6 +26,7 @@ let RichExecuteStrategy = class RichExecuteStrategy {
             if (!xterm) {
                 throw ( new Error('Xterm is not available'));
             }
+            const alternateBufferPromise = createAltBufferPromise(xterm, store, this._log.bind(this));
             const onDone = Promise.race([
                 Event.toPromise(this._commandDetection.onCommandFinished, store).then(e => {
                     this._log('onDone via end event');
@@ -49,10 +50,19 @@ let RichExecuteStrategy = class RichExecuteStrategy {
             this._log(`Executing command line \`${commandLine}\``);
             this._instance.runCommand(commandLine, true, commandId);
             this._log('Waiting for done event');
-            const onDoneResult = await onDone;
+            const onDoneResult = await Promise.race([onDone, alternateBufferPromise.then(() => ({ type: 'alternateBuffer' }))]);
             if (onDoneResult && onDoneResult.type === 'disposal') {
                 throw ( new Error('The terminal was closed'));
             }
+            if (onDoneResult && onDoneResult.type === 'alternateBuffer') {
+                this._log('Detected alternate buffer entry, skipping output capture');
+                return {
+                    output: undefined,
+                    exitCode: undefined,
+                    error: 'alternateBuffer',
+                    didEnterAltBuffer: true
+                };
+            }
             const finishedCommand = onDoneResult && onDoneResult.type === 'success' ? onDoneResult.command : undefined;
             if (token.isCancellationRequested) {
                 throw ( new CancellationError());

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/executeStrategy/strategyHelpers.d.ts

@@ -1,4 +1,4 @@
-import { DisposableStore, MutableDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { DisposableStore, MutableDisposable, type IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import type { IMarker as IXtermMarker } from "@xterm/xterm";
 /**
  * Sets up a recreating start marker which is resilient to prompts that clear/re-render (eg. transient
@@ -10,3 +10,12 @@ export declare function setupRecreatingStartMarker(xterm: {
         registerMarker(): IXtermMarker | undefined;
     };
 }, startMarker: MutableDisposable<IXtermMarker>, fire: (marker: IXtermMarker | undefined) => void, store: DisposableStore, log?: (message: string) => void): void;
+export declare function createAltBufferPromise(xterm: {
+    raw: {
+        buffer: {
+            active: unknown;
+            alternate: unknown;
+            onBufferChange: (callback: () => void) => IDisposable;
+        };
+    };
+}, store: DisposableStore, log?: (message: string) => void): Promise<void>;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/executeStrategy/strategyHelpers.js

@@ -1,4 +1,5 @@
 
+import { DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { MutableDisposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 
 function setupRecreatingStartMarker(xterm, startMarker, fire, store, log) {
@@ -27,5 +28,25 @@ function setupRecreatingStartMarker(xterm, startMarker, fire, store, log) {
     }));
     store.add(startMarker);
 }
+function createAltBufferPromise(xterm, store, log) {
+    const deferred = ( new DeferredPromise());
+    const complete = () => {
+        if (!deferred.isSettled) {
+            log?.('Detected alternate buffer entry');
+            deferred.complete();
+        }
+    };
+    if (xterm.raw.buffer.active === xterm.raw.buffer.alternate) {
+        complete();
+    }
+    else {
+        store.add(xterm.raw.buffer.onBufferChange(() => {
+            if (xterm.raw.buffer.active === xterm.raw.buffer.alternate) {
+                complete();
+            }
+        }));
+    }
+    return deferred.p;
+}
 
-export { setupRecreatingStartMarker };
+export { createAltBufferPromise, setupRecreatingStartMarker };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/runInTerminalHelpers.d.ts

@@ -1,9 +1,10 @@
 import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
-import type { ToolConfirmationAction } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService";
-import type { ICommandApprovalResultWithReason } from "./commandLineAutoApprover.js";
+import type { ToolConfirmationAction } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
+import type { ICommandApprovalResultWithReason } from "./tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.js";
 export declare function isPowerShell(envShell: string, os: OperatingSystem): boolean;
 export declare function isWindowsPowerShell(envShell: string): boolean;
 export declare function isZsh(envShell: string, os: OperatingSystem): boolean;
+export declare function isBash(envShell: string, os: OperatingSystem): boolean;
 export declare function isFish(envShell: string, os: OperatingSystem): boolean;
 export declare const TRUNCATION_MESSAGE = "\n\n[... PREVIOUS OUTPUT TRUNCATED ...]\n\n";
 export declare function truncateOutputKeepingTail(output: string, maxLength: number): string;

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

@@ -5,6 +5,7 @@ import { win32, posix } from '@codingame/monaco-vscode-api/vscode/vs/base/common
 import { OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
 import { escapeRegExpCharacters } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { isAutoApproveRule } from './tools/commandLineAnalyzer/commandLineAnalyzer.js';
 
 function isPowerShell(envShell, os) {
     if (os === OperatingSystem.Windows) {
@@ -21,6 +22,12 @@ function isZsh(envShell, os) {
     }
     return /^zsh$/.test(posix.basename(envShell));
 }
+function isBash(envShell, os) {
+    if (os === OperatingSystem.Windows) {
+        return /^bash(?:\.exe)?$/i.test(win32.basename(envShell));
+    }
+    return /^bash$/.test(posix.basename(envShell));
+}
 function isFish(envShell, os) {
     if (os === OperatingSystem.Windows) {
         return /^fish(?:\.exe)?$/i.test(win32.basename(envShell));
@@ -56,25 +63,37 @@ function generateAutoApproveActions(commandLine, subCommands, autoApproveResult)
             'curl', 'wget', 'invoke-restmethod', 'invoke-webrequest', 'irm', 'iwr',
         ]));
         const commandsWithSubcommands = ( new Set(
-            ['git', 'npm', 'yarn', 'docker', 'kubectl', 'cargo', 'dotnet', 'mvn', 'gradle']
+            ['git', 'npm', 'npx', 'yarn', 'docker', 'kubectl', 'cargo', 'dotnet', 'mvn', 'gradle']
         ));
         const commandsWithSubSubCommands = ( new Set(['npm run', 'yarn run']));
+        const findNextNonFlagArg = (parts, startIndex) => {
+            for (let i = startIndex; i < parts.length; i++) {
+                if (!parts[i].startsWith('-')) {
+                    return i;
+                }
+            }
+            return undefined;
+        };
         const subCommandsToSuggest = Array.from(( new Set(coalesce(( unapprovedSubCommands.map(command => {
             const parts = command.trim().split(/\s+/);
             const baseCommand = parts[0].toLowerCase();
-            const baseSubCommand = parts.length > 1 ? `${parts[0]} ${parts[1]}`.toLowerCase() : '';
             if (( neverAutoApproveCommands.has(baseCommand))) {
                 return undefined;
             }
-            if (( commandsWithSubSubCommands.has(baseSubCommand))) {
-                if (parts.length >= 3 && !parts[2].startsWith('-')) {
-                    return `${parts[0]} ${parts[1]} ${parts[2]}`;
-                }
-                return undefined;
-            }
-            else if (( commandsWithSubcommands.has(baseCommand))) {
-                if (parts.length >= 2 && !parts[1].startsWith('-')) {
-                    return `${parts[0]} ${parts[1]}`;
+            if (( commandsWithSubcommands.has(baseCommand))) {
+                const subCommandIndex = findNextNonFlagArg(parts, 1);
+                if (subCommandIndex !== undefined) {
+                    const baseSubCommand = `${parts[0]} ${parts[subCommandIndex]}`.toLowerCase();
+                    if (( commandsWithSubSubCommands.has(baseSubCommand))) {
+                        const subSubCommandIndex = findNextNonFlagArg(parts, subCommandIndex + 1);
+                        if (subSubCommandIndex !== undefined) {
+                            return parts.slice(0, subSubCommandIndex + 1).join(' ');
+                        }
+                        return undefined;
+                    }
+                    else {
+                        return parts.slice(0, subCommandIndex + 1).join(' ');
+                    }
                 }
                 return undefined;
             }
@@ -85,29 +104,54 @@ function generateAutoApproveActions(commandLine, subCommands, autoApproveResult)
         if (subCommandsToSuggest.length > 0) {
             let subCommandLabel;
             if (subCommandsToSuggest.length === 1) {
-                subCommandLabel = ( localize(11989, 'Always Allow Command: {0}', subCommandsToSuggest[0]));
+                subCommandLabel = `\`${subCommandsToSuggest[0]} \u2026\``;
             }
             else {
-                const commandSeparated = subCommandsToSuggest.join(', ');
-                subCommandLabel = ( localize(11990, 'Always Allow Commands: {0}', commandSeparated));
+                subCommandLabel = `Commands ${( subCommandsToSuggest.map(e => `\`${e} \u2026\``)).join(', ')}`;
             }
             actions.push({
-                label: subCommandLabel,
+                label: `Allow ${subCommandLabel} in this Session`,
+                data: {
+                    type: 'newRule',
+                    rule: ( subCommandsToSuggest.map(key => ({
+                        key,
+                        value: true,
+                        scope: 'session'
+                    })))
+                }
+            });
+            actions.push({
+                label: `Allow ${subCommandLabel} in this Workspace`,
+                data: {
+                    type: 'newRule',
+                    rule: ( subCommandsToSuggest.map(key => ({
+                        key,
+                        value: true,
+                        scope: 'workspace'
+                    })))
+                }
+            });
+            actions.push({
+                label: `Always Allow ${subCommandLabel}`,
                 data: {
                     type: 'newRule',
                     rule: ( subCommandsToSuggest.map(key => ({
                         key,
-                        value: true
+                        value: true,
+                        scope: 'user'
                     })))
                 }
             });
         }
+        if (actions.length > 0) {
+            actions.push(( new Separator()));
+        }
         const firstSubcommandFirstWord = unapprovedSubCommands.length > 0 ? unapprovedSubCommands[0].split(' ')[0] : '';
         if (firstSubcommandFirstWord !== commandLine &&
             !( commandsWithSubcommands.has(commandLine)) &&
             !( commandsWithSubSubCommands.has(commandLine))) {
             actions.push({
-                label: ( localize(11991, 'Always Allow Exact Command Line')),
+                label: ( localize(12013, 'Allow Exact Command Line in this Session')),
                 data: {
                     type: 'newRule',
                     rule: {
@@ -115,7 +159,36 @@ function generateAutoApproveActions(commandLine, subCommands, autoApproveResult)
                         value: {
                             approve: true,
                             matchCommandLine: true
-                        }
+                        },
+                        scope: 'session'
+                    }
+                }
+            });
+            actions.push({
+                label: ( localize(12014, 'Allow Exact Command Line in this Workspace')),
+                data: {
+                    type: 'newRule',
+                    rule: {
+                        key: `/^${escapeRegExpCharacters(commandLine)}$/`,
+                        value: {
+                            approve: true,
+                            matchCommandLine: true
+                        },
+                        scope: 'workspace'
+                    }
+                }
+            });
+            actions.push({
+                label: ( localize(12015, 'Always Allow Exact Command Line')),
+                data: {
+                    type: 'newRule',
+                    rule: {
+                        key: `/^${escapeRegExpCharacters(commandLine)}$/`,
+                        value: {
+                            approve: true,
+                            matchCommandLine: true
+                        },
+                        scope: 'user'
                     }
                 }
             });
@@ -125,15 +198,15 @@ function generateAutoApproveActions(commandLine, subCommands, autoApproveResult)
         actions.push(( new Separator()));
     }
     actions.push({
-        label: ( localize(11992, 'Allow All Commands in this Session')),
-        tooltip: ( localize(11993, 'Allow this tool to run in this session without confirmation.')),
+        label: ( localize(12016, 'Allow All Commands in this Session')),
+        tooltip: ( localize(12017, 'Allow this tool to run in this session without confirmation.')),
         data: {
             type: 'sessionApproval'
         }
     });
     actions.push(( new Separator()));
     actions.push({
-        label: ( localize(11994, 'Configure Auto Approve...')),
+        label: ( localize(12018, 'Configure Auto Approve...')),
         data: {
             type: 'configure'
         }
@@ -142,8 +215,12 @@ function generateAutoApproveActions(commandLine, subCommands, autoApproveResult)
 }
 function dedupeRules(rules) {
     return rules.filter((result, index, array) => {
-        return result.rule && array.findIndex(r => r.rule && r.rule.sourceText === result.rule.sourceText) === index;
+        if (!isAutoApproveRule(result.rule)) {
+            return false;
+        }
+        const sourceText = result.rule.sourceText;
+        return array.findIndex(r => isAutoApproveRule(r.rule) && r.rule.sourceText === sourceText) === index;
     });
 }
 
-export { TRUNCATION_MESSAGE, dedupeRules, generateAutoApproveActions, isFish, isPowerShell, isWindowsPowerShell, isZsh, truncateOutputKeepingTail };
+export { TRUNCATION_MESSAGE, dedupeRules, generateAutoApproveActions, isBash, isFish, isPowerShell, isWindowsPowerShell, isZsh, truncateOutputKeepingTail };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/taskHelpers.d.ts

@@ -4,7 +4,7 @@ import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
 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 { IToolInvocationContext, ToolProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService";
+import { IToolInvocationContext, ToolProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
 import { Task } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/tasks";
 import { ITaskService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/taskService.service";
 import { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/terminal.chatAgentTools.contribution.js

@@ -11,8 +11,8 @@ import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/pl
 import { TerminalSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal';
 import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
-import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
-import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
 import { registerActiveInstanceAction, sharedWhenClause } from '@codingame/monaco-vscode-xterm-common/vscode/vs/workbench/contrib/terminal/browser/terminalActions';
 import { TerminalContextMenuGroup } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminalMenus';
 import { TerminalContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminalContextKey';
@@ -72,8 +72,8 @@ let ChatAgentToolsContribution = class ChatAgentToolsContribution extends Dispos
         const createAndRunTaskTool = instantiationService.createInstance(CreateAndRunTaskTool);
         this._register(toolsService.registerTool(CreateAndRunTaskToolData, createAndRunTaskTool));
         this._register(toolsService.executeToolSet.addTool(RunTaskToolData));
-        this._register(toolsService.executeToolSet.addTool(GetTaskOutputToolData));
         this._register(toolsService.executeToolSet.addTool(CreateAndRunTaskToolData));
+        this._register(toolsService.readToolSet.addTool(GetTaskOutputToolData));
     }
 };
 ChatAgentToolsContribution = ( __decorate([
@@ -83,7 +83,7 @@ ChatAgentToolsContribution = ( __decorate([
 registerWorkbenchContribution2(ChatAgentToolsContribution.ID, ChatAgentToolsContribution, WorkbenchPhase.AfterRestored);
 registerActiveInstanceAction({
     id: TerminalChatAgentToolsCommandId.ChatAddTerminalSelection,
-    title: ( localize(11995, 'Add Terminal Selection to Chat')),
+    title: ( localize(12019, 'Add Terminal Selection to Chat')),
     precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, sharedWhenClause.terminalAvailable)),
     menu: [
         {
@@ -106,8 +106,8 @@ registerActiveInstanceAction({
         chatView.attachmentModel.addContext({
             id: `terminal-selection-${Date.now()}`,
             kind: 'generic',
-            name: ( localize(11996, 'Terminal Selection')),
-            fullName: ( localize(11996, 'Terminal Selection')),
+            name: ( localize(12020, 'Terminal Selection')),
+            fullName: ( localize(12020, 'Terminal Selection')),
             value: selection,
             icon: Codicon.terminal
         });

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/toolTerminalCreator.d.ts

@@ -1,4 +1,5 @@
 import type { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
 import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
 import { ITerminalProfile } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal";
 import { ITerminalLogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service";
@@ -24,7 +25,7 @@ export declare class ToolTerminalCreator {
      */
     private static _lastSuccessfulShell;
     constructor(_configurationService: IConfigurationService, _logService: ITerminalLogService, _terminalService: ITerminalService);
-    createTerminal(shellOrProfile: string | ITerminalProfile, token: CancellationToken): Promise<IToolTerminal>;
+    createTerminal(shellOrProfile: string | ITerminalProfile, os: OperatingSystem, token: CancellationToken): Promise<IToolTerminal>;
     /**
      * Synchronously update shell integration quality based on the terminal instance's current
      * capabilities. This is a defensive change to avoid no shell integration being sticky

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

@@ -14,6 +14,8 @@ import { TerminalSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platfo
 import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
 import { ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
 import { getShellIntegrationTimeout } from '@codingame/monaco-vscode-xterm-common/vscode/vs/workbench/contrib/terminal/common/terminalEnvironment';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
+import { isBash, isZsh, isFish, isPowerShell } from './runInTerminalHelpers.js';
 
 var ToolTerminalCreator_1;
 var ShellLaunchType;
@@ -36,8 +38,8 @@ let ToolTerminalCreator = class ToolTerminalCreator {
         this._logService = _logService;
         this._terminalService = _terminalService;
     }
-    async createTerminal(shellOrProfile, token) {
-        const instance = await this._createCopilotTerminal(shellOrProfile);
+    async createTerminal(shellOrProfile, os, token) {
+        const instance = await this._createCopilotTerminal(shellOrProfile, os);
         const toolTerminal = {
             instance,
             shellIntegrationQuality: ShellIntegrationQuality.None,
@@ -91,14 +93,25 @@ let ToolTerminalCreator = class ToolTerminalCreator {
             }
         }
     }
-    _createCopilotTerminal(shellOrProfile) {
+    _createCopilotTerminal(shellOrProfile, os) {
+        const shellPath = isString(shellOrProfile) ? shellOrProfile : shellOrProfile.path;
+        const env = {
+            GIT_PAGER: 'cat',
+        };
+        const preventShellHistory = this._configurationService.getValue(TerminalChatAgentToolsSettingId.PreventShellHistory) === true;
+        if (preventShellHistory) {
+            if (isBash(shellPath, os) ||
+                isZsh(shellPath, os) ||
+                isFish(shellPath, os) ||
+                isPowerShell(shellPath, os)) {
+                env['VSCODE_PREVENT_SHELL_HISTORY'] = '1';
+            }
+        }
         const config = {
             icon: ThemeIcon.fromId(Codicon.chatSparkle.id),
             hideFromUser: true,
             forcePersist: true,
-            env: {
-                GIT_PAGER: 'cat',
-            }
+            env,
         };
         if (isString(shellOrProfile)) {
             config.executable = shellOrProfile;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/{commandLineAutoApprover.d.ts → tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.d.ts}

@@ -1,30 +1,29 @@
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import type { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
-import { ConfigurationTarget } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration";
+import type { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
-export interface IAutoApproveRule {
-    regex: RegExp;
-    regexCaseInsensitive: RegExp;
-    sourceText: string;
-    sourceTarget: ConfigurationTarget;
-    isDefaultRule: boolean;
-}
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ITerminalChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+import type { IAutoApproveRule, INpmScriptAutoApproveRule } from "../commandLineAnalyzer.js";
 export interface ICommandApprovalResultWithReason {
     result: ICommandApprovalResult;
     reason: string;
-    rule?: IAutoApproveRule;
+    rule?: IAutoApproveRule | INpmScriptAutoApproveRule;
 }
 export type ICommandApprovalResult = "approved" | "denied" | "noMatch";
 export declare class CommandLineAutoApprover extends Disposable {
     private readonly _configurationService;
+    private readonly _terminalChatService;
     private _denyListRules;
     private _allowListRules;
     private _allowListCommandLineRules;
     private _denyListCommandLineRules;
-    constructor(_configurationService: IConfigurationService);
+    private readonly _npmScriptAutoApprover;
+    constructor(_configurationService: IConfigurationService, instantiationService: IInstantiationService, _terminalChatService: ITerminalChatService);
     updateConfiguration(): void;
-    isCommandAutoApproved(command: string, shell: string, os: OperatingSystem): ICommandApprovalResultWithReason;
-    isCommandLineAutoApproved(commandLine: string): ICommandApprovalResultWithReason;
+    isCommandAutoApproved(command: string, shell: string, os: OperatingSystem, cwd: URI | undefined, chatSessionId?: string): Promise<ICommandApprovalResultWithReason>;
+    isCommandLineAutoApproved(commandLine: string, chatSessionId?: string): ICommandApprovalResultWithReason;
+    private _getSessionRules;
     private _commandMatchesRule;
     private _mapAutoApproveConfigToRules;
     private _convertAutoApproveEntryToRegex;