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

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

@@ -1,24 +1,29 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { structuralEquals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/equals';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { regExpLeadsToEndlessLoop, escapeRegExpCharacters } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
 import { isObject } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
-import { structuralEquals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/equals';
 import { ConfigurationTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
 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 { ITerminalChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
 import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
-import { isPowerShell } from './runInTerminalHelpers.js';
+import { isPowerShell } from '../../../runInTerminalHelpers.js';
+import { NpmScriptAutoApprover } from './npmScriptAutoApprover.js';
 
 const neverMatchRegex = /(?!.*)/;
 const transientEnvVarRegex = /^[A-Z_][A-Z0-9_]*=/i;
 let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
-    constructor(_configurationService) {
+    constructor(_configurationService, instantiationService, _terminalChatService) {
         super();
         this._configurationService = _configurationService;
+        this._terminalChatService = _terminalChatService;
         this._denyListRules = [];
         this._allowListRules = [];
         this._allowListCommandLineRules = [];
         this._denyListCommandLineRules = [];
+        this._npmScriptAutoApprover = this._register(instantiationService.createInstance(NpmScriptAutoApprover));
         this.updateConfiguration();
         this._register(this._configurationService.onDidChangeConfiguration(e => {
             if (e.affectsConfiguration(TerminalChatAgentToolsSettingId.AutoApprove) ||
@@ -44,7 +49,7 @@ let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
         this._allowListCommandLineRules = allowListCommandLineRules;
         this._denyListCommandLineRules = denyListCommandLineRules;
     }
-    isCommandAutoApproved(command, shell, os) {
+    async isCommandAutoApproved(command, shell, os, cwd, chatSessionId) {
         if (transientEnvVarRegex.test(command)) {
             return {
                 result: 'denied',
@@ -60,6 +65,15 @@ let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
                 };
             }
         }
+        for (const rule of this._getSessionRules(chatSessionId).allowListRules) {
+            if (this._commandMatchesRule(rule, command, shell, os)) {
+                return {
+                    result: 'approved',
+                    rule,
+                    reason: `Command '${command}' is approved by session allow list rule: ${rule.sourceText}`
+                };
+            }
+        }
         for (const rule of this._allowListRules) {
             if (this._commandMatchesRule(rule, command, shell, os)) {
                 return {
@@ -69,12 +83,20 @@ let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
                 };
             }
         }
+        const npmScriptResult = await this._npmScriptAutoApprover.isCommandAutoApproved(command, cwd);
+        if (npmScriptResult.isAutoApproved) {
+            return {
+                result: 'approved',
+                rule: { type: 'npmScript', npmScriptResult },
+                reason: `Command '${command}' is approved as npm script '${npmScriptResult.scriptName}' is defined in package.json`
+            };
+        }
         return {
             result: 'noMatch',
             reason: `Command '${command}' has no matching auto approve entries`
         };
     }
-    isCommandLineAutoApproved(commandLine) {
+    isCommandLineAutoApproved(commandLine, chatSessionId) {
         for (const rule of this._denyListCommandLineRules) {
             if (rule.regex.test(commandLine)) {
                 return {
@@ -84,6 +106,15 @@ let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
                 };
             }
         }
+        for (const rule of this._getSessionRules(chatSessionId).allowListCommandLineRules) {
+            if (rule.regex.test(commandLine)) {
+                return {
+                    result: 'approved',
+                    rule,
+                    reason: `Command line '${commandLine}' is approved by session allow list rule: ${rule.sourceText}`
+                };
+            }
+        }
         for (const rule of this._allowListCommandLineRules) {
             if (rule.regex.test(commandLine)) {
                 return {
@@ -98,6 +129,50 @@ let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
             reason: `Command line '${commandLine}' has no matching auto approve entries`
         };
     }
+    _getSessionRules(chatSessionId) {
+        const denyListRules = [];
+        const allowListRules = [];
+        const allowListCommandLineRules = [];
+        const denyListCommandLineRules = [];
+        if (!chatSessionId) {
+            return { denyListRules, allowListRules, allowListCommandLineRules, denyListCommandLineRules };
+        }
+        const sessionRulesConfig = this._terminalChatService.getSessionAutoApproveRules(chatSessionId);
+        for (const [key, value] of Object.entries(sessionRulesConfig)) {
+            if (typeof value === 'boolean') {
+                const { regex, regexCaseInsensitive } = this._convertAutoApproveEntryToRegex(key);
+                if (value === true) {
+                    allowListRules.push({ regex, regexCaseInsensitive, sourceText: key, sourceTarget: 'session', isDefaultRule: false });
+                }
+                else if (value === false) {
+                    denyListRules.push({ regex, regexCaseInsensitive, sourceText: key, sourceTarget: 'session', isDefaultRule: false });
+                }
+            }
+            else if (typeof value === 'object' && value !== null) {
+                const objectValue = value;
+                if (typeof objectValue.approve === 'boolean') {
+                    const { regex, regexCaseInsensitive } = this._convertAutoApproveEntryToRegex(key);
+                    if (objectValue.approve === true) {
+                        if (objectValue.matchCommandLine === true) {
+                            allowListCommandLineRules.push({ regex, regexCaseInsensitive, sourceText: key, sourceTarget: 'session', isDefaultRule: false });
+                        }
+                        else {
+                            allowListRules.push({ regex, regexCaseInsensitive, sourceText: key, sourceTarget: 'session', isDefaultRule: false });
+                        }
+                    }
+                    else if (objectValue.approve === false) {
+                        if (objectValue.matchCommandLine === true) {
+                            denyListCommandLineRules.push({ regex, regexCaseInsensitive, sourceText: key, sourceTarget: 'session', isDefaultRule: false });
+                        }
+                        else {
+                            denyListRules.push({ regex, regexCaseInsensitive, sourceText: key, sourceTarget: 'session', isDefaultRule: false });
+                        }
+                    }
+                }
+            }
+        }
+        return { denyListRules, allowListRules, allowListCommandLineRules, denyListCommandLineRules };
+    }
     _commandMatchesRule(rule, command, shell, os) {
         const isPwsh = isPowerShell(shell, os);
         if ((isPwsh ? rule.regexCaseInsensitive : rule.regex).test(command)) {
@@ -229,7 +304,9 @@ let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
     }
 };
 CommandLineAutoApprover = ( __decorate([
-    ( __param(0, IConfigurationService))
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IInstantiationService)),
+    ( __param(2, ITerminalChatService))
 ], CommandLineAutoApprover));
 
 export { CommandLineAutoApprover };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/npmScriptAutoApprover.d.ts

@@ -0,0 +1,45 @@
+import { type IMarkdownString } from "@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+export interface INpmScriptAutoApproveResult {
+    isAutoApproved: boolean;
+    scriptName?: string;
+    autoApproveInfo?: IMarkdownString;
+}
+export declare class NpmScriptAutoApprover extends Disposable {
+    private readonly _configurationService;
+    private readonly _fileService;
+    private readonly _uriIdentityService;
+    private readonly _workspaceContextService;
+    constructor(_configurationService: IConfigurationService, _fileService: IFileService, _uriIdentityService: IUriIdentityService, _workspaceContextService: IWorkspaceContextService);
+    /**
+     * Checks if a single command is an npm/yarn/pnpm script that exists in package.json.
+     * Returns auto-approve result if the command is a valid script.
+     */
+    isCommandAutoApproved(command: string, cwd: URI | undefined): Promise<INpmScriptAutoApproveResult>;
+    /**
+     * Extracts script name from an npm/yarn/pnpm run command.
+     */
+    private _extractScriptName;
+    /**
+     * Checks if a URI is within any workspace folder.
+     */
+    private _isWithinWorkspace;
+    /**
+     * Finds and parses package.json to get the scripts section.
+     * Only looks within the workspace for security.
+     */
+    private _getPackageJsonScripts;
+    /**
+     * Reads and parses the scripts section from a package.json file.
+     */
+    private _readPackageJsonScripts;
+    /**
+     * Parses the scripts section from package.json content using jsonc-parser.
+     */
+    private _parsePackageJsonScripts;
+}

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/npmScriptAutoApprover.js

@@ -0,0 +1,156 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { visit } from '@codingame/monaco-vscode-api/vscode/vs/base/common/json';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
+
+const npmRunPatterns = [
+    /^(?<command>npm)\s+(?:run(?:-script)?)\s+(?<scriptName>[^\s&|;]+)/i,
+    /^(?<command>npm)\s+(?<scriptName>test|start|stop|restart)\b/i,
+    /^(?<command>yarn)\s+(?:run\s+)?(?<scriptName>[^\s&|;]+)/i,
+    /^(?<command>pnpm)\s+(?:run\s+)?(?<scriptName>[^\s&|;]+)/i,
+];
+const yarnBuiltinCommands = ( new Set([
+    'add', 'audit', 'autoclean', 'bin', 'cache', 'check', 'config',
+    'create', 'dedupe', 'dlx', 'exec', 'explain', 'generate-lock-entry',
+    'global', 'help', 'import', 'info', 'init', 'install', 'licenses',
+    'link', 'list', 'login', 'logout', 'node', 'outdated', 'owner',
+    'pack', 'patch', 'patch-commit', 'plugin', 'policies', 'publish',
+    'rebuild', 'remove', 'run', 'search', 'set', 'stage', 'tag', 'team',
+    'unlink', 'unplug', 'up', 'upgrade', 'upgrade-interactive',
+    'version', 'versions', 'why', 'workspace', 'workspaces',
+]));
+const pnpmBuiltinCommands = ( new Set([
+    'add', 'audit', 'bin', 'config', 'dedupe', 'deploy', 'dlx', 'doctor',
+    'env', 'exec', 'fetch', 'import', 'init', 'install', 'install-test',
+    'licenses', 'link', 'list', 'ln', 'ls', 'outdated', 'pack', 'patch',
+    'patch-commit', 'patch-remove', 'prune', 'publish', 'rb', 'rebuild',
+    'remove', 'rm', 'root', 'run', 'server', 'setup', 'store',
+    'un', 'uninstall', 'unlink', 'up', 'update', 'why',
+]));
+let NpmScriptAutoApprover = class NpmScriptAutoApprover extends Disposable {
+    constructor(_configurationService, _fileService, _uriIdentityService, _workspaceContextService) {
+        super();
+        this._configurationService = _configurationService;
+        this._fileService = _fileService;
+        this._uriIdentityService = _uriIdentityService;
+        this._workspaceContextService = _workspaceContextService;
+    }
+    async isCommandAutoApproved(command, cwd) {
+        const isNpmScriptAutoApproveEnabled = this._configurationService.getValue(TerminalChatAgentToolsSettingId.AutoApproveWorkspaceNpmScripts) === true;
+        if (!isNpmScriptAutoApproveEnabled) {
+            return { isAutoApproved: false };
+        }
+        const scriptName = this._extractScriptName(command);
+        if (!scriptName) {
+            return { isAutoApproved: false };
+        }
+        const packageJsonScripts = await this._getPackageJsonScripts(cwd);
+        if (!packageJsonScripts) {
+            return { isAutoApproved: false };
+        }
+        if (!( packageJsonScripts.scripts.has(scriptName))) {
+            return { isAutoApproved: false };
+        }
+        return {
+            isAutoApproved: true,
+            scriptName,
+            autoApproveInfo: ( new MarkdownString(( localize(
+                12021,
+                'Auto approved as {0} is defined in package.json',
+                `\`${scriptName}\``
+            )))),
+        };
+    }
+    _extractScriptName(command) {
+        const trimmedCommand = command.trim();
+        for (const pattern of npmRunPatterns) {
+            const match = trimmedCommand.match(pattern);
+            if (match?.groups?.scriptName) {
+                const { command: pkgManager, scriptName } = match.groups;
+                if (pkgManager.toLowerCase() === 'yarn' && ( yarnBuiltinCommands.has(scriptName.toLowerCase()))) {
+                    continue;
+                }
+                if (pkgManager.toLowerCase() === 'pnpm' && ( pnpmBuiltinCommands.has(scriptName.toLowerCase()))) {
+                    continue;
+                }
+                return scriptName;
+            }
+        }
+        return undefined;
+    }
+    _isWithinWorkspace(uri) {
+        const workspaceFolders = this._workspaceContextService.getWorkspace().folders;
+        return ( workspaceFolders.some(
+            (folder) => this._uriIdentityService.extUri.isEqualOrParent(uri, folder.uri)
+        ));
+    }
+    async _getPackageJsonScripts(cwd) {
+        if (!cwd || !this._isWithinWorkspace(cwd)) {
+            return undefined;
+        }
+        const packageJsonUri = URI.joinPath(cwd, 'package.json');
+        const scripts = await this._readPackageJsonScripts(packageJsonUri);
+        if (scripts) {
+            return { uri: packageJsonUri, scripts };
+        }
+        return undefined;
+    }
+    async _readPackageJsonScripts(packageJsonUri) {
+        try {
+            const exists = await this._fileService.exists(packageJsonUri);
+            if (!exists) {
+                return undefined;
+            }
+            const content = await this._fileService.readFile(packageJsonUri);
+            const text = ( content.value.toString());
+            return this._parsePackageJsonScripts(text);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    _parsePackageJsonScripts(content) {
+        const scripts = ( new Set());
+        let inScripts = false;
+        let level = 0;
+        const visitor = {
+            onError() {
+            },
+            onObjectBegin() {
+                level++;
+            },
+            onObjectEnd() {
+                if (inScripts && level === 2) {
+                    inScripts = false;
+                }
+                level--;
+            },
+            onObjectProperty(property) {
+                if (level === 1 && property === 'scripts') {
+                    inScripts = true;
+                }
+                else if (inScripts && level === 2) {
+                    scripts.add(property);
+                }
+            },
+        };
+        visit(content, visitor);
+        return scripts.size > 0 ? scripts : undefined;
+    }
+};
+NpmScriptAutoApprover = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IFileService)),
+    ( __param(2, IUriIdentityService)),
+    ( __param(3, IWorkspaceContextService))
+], NpmScriptAutoApprover));
+
+export { NpmScriptAutoApprover };

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

@@ -2,8 +2,23 @@ import type { IMarkdownString } from "@codingame/monaco-vscode-api/vscode/vs/bas
 import type { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import type { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
 import type { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import type { ToolConfirmationAction } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService";
+import type { ConfigurationTarget } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration";
+import type { ToolConfirmationAction } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
+import type { INpmScriptAutoApproveResult } from "./autoApprove/npmScriptAutoApprover.js";
 import type { TreeSitterCommandParserLanguage } from "../../treeSitterCommandParser.js";
+export interface IAutoApproveRule {
+    regex: RegExp;
+    regexCaseInsensitive: RegExp;
+    sourceText: string;
+    sourceTarget: ConfigurationTarget | "session";
+    isDefaultRule: boolean;
+}
+export interface INpmScriptAutoApproveRule {
+    type: "npmScript";
+    npmScriptResult: INpmScriptAutoApproveResult;
+}
+export declare function isAutoApproveRule(rule: IAutoApproveRule | INpmScriptAutoApproveRule | undefined): rule is IAutoApproveRule;
+export declare function isNpmScriptAutoApproveRule(rule: IAutoApproveRule | INpmScriptAutoApproveRule | undefined): rule is INpmScriptAutoApproveRule;
 export interface ICommandLineAnalyzer extends IDisposable {
     analyze(options: ICommandLineAnalyzerOptions): Promise<ICommandLineAnalyzerResult>;
 }
@@ -29,7 +44,7 @@ export interface ICommandLineAnalyzerResult {
      * - `undefined`: This analyzer does not make an approval/denial decision
      */
     readonly isAutoApproved?: boolean;
-    readonly disclaimers?: readonly string[];
+    readonly disclaimers?: readonly (string | IMarkdownString)[];
     readonly autoApproveInfo?: IMarkdownString;
     readonly customActions?: ToolConfirmationAction[];
 }

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

@@ -0,0 +1,10 @@
+
+
+function isAutoApproveRule(rule) {
+    return !!rule && 'sourceText' in rule;
+}
+function isNpmScriptAutoApproveRule(rule) {
+    return !!rule && 'type' in rule && rule.type === 'npmScript';
+}
+
+export { isAutoApproveRule, isNpmScriptAutoApproveRule };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineAutoApproveAnalyzer.d.ts

@@ -5,7 +5,7 @@ import { ITerminalChatService } from "@codingame/monaco-vscode-api/vscode/vs/wor
 import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
 import type { RunInTerminalToolTelemetry } from "../../runInTerminalToolTelemetry.js";
 import { type TreeSitterCommandParser } from "../../treeSitterCommandParser.js";
-import type { ICommandLineAnalyzer, ICommandLineAnalyzerOptions, ICommandLineAnalyzerResult } from "./commandLineAnalyzer.js";
+import { type ICommandLineAnalyzer, type ICommandLineAnalyzerOptions, type ICommandLineAnalyzerResult } from "./commandLineAnalyzer.js";
 export declare class CommandLineAutoApproveAnalyzer extends Disposable implements ICommandLineAnalyzer {
     private readonly _treeSitterCommandParser;
     private readonly _telemetry;

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

@@ -4,17 +4,19 @@ import { asArray } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arra
 import { createCommandUri, MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ConfigurationTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
 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 { ITerminalChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
 import { StorageScope } 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 { TerminalToolConfirmationStorageKeys } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/chatContentParts/toolInvocationParts/chatTerminalToolConfirmationSubPart';
+import { TerminalToolConfirmationStorageKeys } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/chatContentParts/toolInvocationParts/chatTerminalToolConfirmationSubPart';
 import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
-import { CommandLineAutoApprover } from '../../commandLineAutoApprover.js';
 import { isPowerShell, generateAutoApproveActions, dedupeRules } from '../../runInTerminalHelpers.js';
+import { isAutoApproveRule, isNpmScriptAutoApproveRule } from './commandLineAnalyzer.js';
 import { TerminalChatCommandId } from '@codingame/monaco-vscode-xterm-common/vscode/vs/workbench/contrib/terminalContrib/chat/browser/terminalChat';
+import { CommandLineAutoApprover } from './autoApprove/commandLineAutoApprover.js';
 
 const promptInjectionWarningCommandsLower = [
     'curl',
@@ -50,12 +52,13 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
                 isAutoApproved: true,
                 isAutoApproveAllowed: true,
                 disclaimers: [],
-                autoApproveInfo: ( new MarkdownString(`${( localize(11997, 'Auto approved for this session'))} ([${( localize(11998, 'Disable'))}](${( disableUri.toString())}))`, mdTrustSettings)),
+                autoApproveInfo: ( new MarkdownString(`${( localize(12022, 'Auto approved for this session'))} ([${( localize(12023, 'Disable'))}](${( disableUri.toString())}))`, mdTrustSettings)),
             };
         }
+        const trimmedCommandLine = options.commandLine.trimStart();
         let subCommands;
         try {
-            subCommands = await this._treeSitterCommandParser.extractSubCommands(options.treeSitterLanguage, options.commandLine);
+            subCommands = await this._treeSitterCommandParser.extractSubCommands(options.treeSitterLanguage, trimmedCommandLine);
             this._log(`Parsed sub-commands via ${options.treeSitterLanguage} grammar`, subCommands);
         }
         catch (e) {
@@ -71,10 +74,10 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
                 disclaimers: [],
             };
         }
-        const subCommandResults = ( subCommands.map(
-            e => this._commandLineAutoApprover.isCommandAutoApproved(e, options.shell, options.os)
-        ));
-        const commandLineResult = this._commandLineAutoApprover.isCommandLineAutoApproved(options.commandLine);
+        const subCommandResults = await Promise.all(( subCommands.map(
+            e => this._commandLineAutoApprover.isCommandAutoApproved(e, options.shell, options.os, options.cwd, options.chatSessionId)
+        )));
+        const commandLineResult = this._commandLineAutoApprover.isCommandLineAutoApproved(trimmedCommandLine, options.chatSessionId);
         const autoApproveReasons = [
             ...( subCommandResults.map(e => e.reason)),
             commandLineResult.reason,
@@ -86,21 +89,21 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
         if (deniedSubCommandResult) {
             this._log('Sub-command DENIED auto approval');
             isDenied = true;
-            autoApproveDefault = deniedSubCommandResult.rule?.isDefaultRule;
+            autoApproveDefault = isAutoApproveRule(deniedSubCommandResult.rule) ? deniedSubCommandResult.rule.isDefaultRule : undefined;
             autoApproveReason = 'subCommand';
         }
         else if (commandLineResult.result === 'denied') {
             this._log('Command line DENIED auto approval');
             isDenied = true;
-            autoApproveDefault = commandLineResult.rule?.isDefaultRule;
+            autoApproveDefault = isAutoApproveRule(commandLineResult.rule) ? commandLineResult.rule.isDefaultRule : undefined;
             autoApproveReason = 'commandLine';
         }
         else {
             if (subCommandResults.every(e => e.result === 'approved')) {
                 this._log('All sub-commands auto-approved');
-                autoApproveReason = 'subCommand';
                 isAutoApproved = true;
-                autoApproveDefault = subCommandResults.every(e => e.rule?.isDefaultRule);
+                autoApproveReason = 'subCommand';
+                autoApproveDefault = subCommandResults.every(e => isAutoApproveRule(e.rule) && e.rule.isDefaultRule);
             }
             else {
                 this._log('All sub-commands NOT auto-approved');
@@ -108,7 +111,7 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
                     this._log('Command line auto-approved');
                     autoApproveReason = 'commandLine';
                     isAutoApproved = true;
-                    autoApproveDefault = commandLineResult.rule?.isDefaultRule;
+                    autoApproveDefault = isAutoApproveRule(commandLineResult.rule) ? commandLineResult.rule.isDefaultRule : undefined;
                 }
                 else {
                     this._log('Command line NOT auto-approved');
@@ -139,12 +142,18 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
         if (!isAutoApproved && (( subCommandsLowerFirstWordOnly.some(command => promptInjectionWarningCommandsLower.includes(command))) ||
             (isPowerShell(options.shell, options.os) && ( subCommandsLowerFirstWordOnly.some(command => promptInjectionWarningCommandsLowerPwshOnly.includes(command)))))) {
             disclaimers.push(( localize(
-                11999,
+                12024,
                 'Web content may contain malicious code or attempt prompt injection attacks.'
             )));
         }
+        if (isAutoApproveEnabled && isDenied) {
+            const denialInfo = this._createAutoApproveInfo(isAutoApproved, isDenied, autoApproveReason, subCommandResults, commandLineResult);
+            if (denialInfo) {
+                disclaimers.push(denialInfo);
+            }
+        }
         if (!isAutoApproved && isAutoApproveEnabled) {
-            customActions = generateAutoApproveActions(options.commandLine, subCommands, { subCommandResults, commandLineResult });
+            customActions = generateAutoApproveActions(trimmedCommandLine, subCommands, { subCommandResults, commandLineResult });
         }
         return {
             isAutoApproved,
@@ -156,9 +165,32 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
     }
     _createAutoApproveInfo(isAutoApproved, isDenied, autoApproveReason, subCommandResults, commandLineResult) {
         const formatRuleLinks = (result) => {
-            return ( asArray(result).map(e => {
+            return ( asArray(result)
+                .filter((e) => isAutoApproveRule(e.rule))
+                .map(e => {
+                if (e.rule.sourceTarget === 'session') {
+                    return localize(12025, '{0} (session)', `\`${e.rule.sourceText}\``);
+                }
                 const settingsUri = createCommandUri(TerminalChatCommandId.OpenTerminalSettingsLink, e.rule.sourceTarget);
-                return `[\`${e.rule.sourceText}\`](${( settingsUri.toString())} "${( localize(12000, 'View rule in settings'))}")`;
+                const tooltip = ( localize(12026, 'View rule in settings'));
+                let label = e.rule.sourceText;
+                switch (e.rule?.sourceTarget) {
+                    case ConfigurationTarget.DEFAULT:
+                        label = `${label} (default)`;
+                        break;
+                    case ConfigurationTarget.USER:
+                    case ConfigurationTarget.USER_LOCAL:
+                        label = `${label} (user)`;
+                        break;
+                    case ConfigurationTarget.USER_REMOTE:
+                        label = `${label} (remote)`;
+                        break;
+                    case ConfigurationTarget.WORKSPACE:
+                    case ConfigurationTarget.WORKSPACE_FOLDER:
+                        label = `${label} (workspace)`;
+                        break;
+                }
+                return `[\`${label}\`](${( settingsUri.toString())} "${tooltip}")`;
             })).join(', ');
         };
         const mdTrustSettings = {
@@ -171,33 +203,37 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
         if (isGlobalAutoApproved) {
             const settingsUri = createCommandUri(TerminalChatCommandId.OpenTerminalSettingsLink, 'global');
             return (new MarkdownString(`${( localize(
-                12001,
+                12027,
                 'Auto approved by setting {0}',
-                `[\`${ChatConfiguration.GlobalAutoApprove}\`](${( settingsUri.toString())} "${( localize(12002, 'View settings'))}")`
+                `[\`${ChatConfiguration.GlobalAutoApprove}\`](${( settingsUri.toString())} "${( localize(12028, 'View settings'))}")`
             ))}`, mdTrustSettings));
         }
         if (isAutoApproved) {
             switch (autoApproveReason) {
                 case 'commandLine': {
-                    if (commandLineResult.rule) {
+                    if (isAutoApproveRule(commandLineResult.rule)) {
                         return (new MarkdownString(
-                            localize(12003, 'Auto approved by rule {0}', formatRuleLinks(commandLineResult)),
+                            localize(12029, 'Auto approved by rule {0}', formatRuleLinks(commandLineResult)),
                             mdTrustSettings
                         ));
                     }
                     break;
                 }
                 case 'subCommand': {
+                    const npmScriptApproval = subCommandResults.find(e => isNpmScriptAutoApproveRule(e.rule));
+                    if (npmScriptApproval && isNpmScriptAutoApproveRule(npmScriptApproval.rule) && npmScriptApproval.rule.npmScriptResult.autoApproveInfo) {
+                        return npmScriptApproval.rule.npmScriptResult.autoApproveInfo;
+                    }
                     const uniqueRules = dedupeRules(subCommandResults);
                     if (uniqueRules.length === 1) {
                         return (new MarkdownString(
-                            localize(12003, 'Auto approved by rule {0}', formatRuleLinks(uniqueRules)),
+                            localize(12029, 'Auto approved by rule {0}', formatRuleLinks(uniqueRules)),
                             mdTrustSettings
                         ));
                     }
                     else if (uniqueRules.length > 1) {
                         return (new MarkdownString(
-                            localize(12004, 'Auto approved by rules {0}', formatRuleLinks(uniqueRules)),
+                            localize(12030, 'Auto approved by rules {0}', formatRuleLinks(uniqueRules)),
                             mdTrustSettings
                         ));
                     }
@@ -210,7 +246,7 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
                 case 'commandLine': {
                     if (commandLineResult.rule) {
                         return (new MarkdownString(localize(
-                            12005,
+                            12031,
                             'Auto approval denied by rule {0}',
                             formatRuleLinks(commandLineResult)
                         ), mdTrustSettings));
@@ -221,12 +257,14 @@ let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extend
                     const uniqueRules = dedupeRules(subCommandResults.filter(e => e.result === 'denied'));
                     if (uniqueRules.length === 1) {
                         return (new MarkdownString(
-                            localize(12005, 'Auto approval denied by rule {0}', formatRuleLinks(uniqueRules))
+                            localize(12031, 'Auto approval denied by rule {0}', formatRuleLinks(uniqueRules)),
+                            mdTrustSettings
                         ));
                     }
                     else if (uniqueRules.length > 1) {
                         return (new MarkdownString(
-                            localize(12006, 'Auto approval denied by rules {0}', formatRuleLinks(uniqueRules))
+                            localize(12032, 'Auto approval denied by rules {0}', formatRuleLinks(uniqueRules)),
+                            mdTrustSettings
                         ));
                     }
                     break;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineFileWriteAnalyzer.d.ts

@@ -13,6 +13,7 @@ export declare class CommandLineFileWriteAnalyzer extends Disposable implements
     constructor(_treeSitterCommandParser: TreeSitterCommandParser, _log: (message: string, ...args: unknown[]) => void, _configurationService: IConfigurationService, _labelService: ILabelService, _workspaceContextService: IWorkspaceContextService);
     analyze(options: ICommandLineAnalyzerOptions): Promise<ICommandLineAnalyzerResult>;
     private _getFileWrites;
+    private _stripSurroundingQuotes;
     private _mapNullDevice;
     private _getResult;
 }