@codingame/monaco-vscode-katex-common 30.0.1 → 31.0.1

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

@@ -0,0 +1,243 @@
+
+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(
+                14005,
+                "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

@@ -0,0 +1,52 @@
+import type { IMarkdownString } from "@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent";
+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 { 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>;
+}
+export interface ICommandLineAnalyzerOptions {
+    commandLine: string;
+    cwd: URI | undefined;
+    shell: string;
+    os: OperatingSystem;
+    treeSitterLanguage: TreeSitterCommandParserLanguage;
+    terminalToolSessionId: string;
+    chatSessionResource: URI | undefined;
+    requiresUnsandboxConfirmation?: boolean;
+}
+export interface ICommandLineAnalyzerResult {
+    /**
+     * Whether auto approval is allowed based on the analysis, when false this
+     * will block auto approval.
+    */
+    readonly isAutoApproveAllowed: boolean;
+    /**
+     * Whether the command line was explicitly auto approved by this analyzer.
+     * - `true`: This analyzer explicitly approves auto-execution
+     * - `false`: This analyzer explicitly denies auto-execution
+     * - `undefined`: This analyzer does not make an approval/denial decision
+     */
+    readonly isAutoApproved?: boolean;
+    readonly disclaimers?: readonly (string | IMarkdownString)[];
+    readonly autoApproveInfo?: IMarkdownString;
+    readonly customActions?: ToolConfirmationAction[];
+    readonly forceAutoApproval?: boolean;
+}

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

@@ -0,0 +1,20 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+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 { 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, type ICommandLineAnalyzerOptions, type ICommandLineAnalyzerResult } from "./commandLineAnalyzer.js";
+export declare class CommandLineAutoApproveAnalyzer extends Disposable implements ICommandLineAnalyzer {
+    private readonly _treeSitterCommandParser;
+    private readonly _telemetry;
+    private readonly _log;
+    private readonly _configurationService;
+    private readonly _storageService;
+    private readonly _terminalChatService;
+    private readonly _commandLineAutoApprover;
+    constructor(_treeSitterCommandParser: TreeSitterCommandParser, _telemetry: RunInTerminalToolTelemetry, _log: (message: string, ...args: unknown[]) => void, _configurationService: IConfigurationService, instantiationService: IInstantiationService, _storageService: IStorageService, _terminalChatService: ITerminalChatService);
+    analyze(options: ICommandLineAnalyzerOptions): Promise<ICommandLineAnalyzerResult>;
+    private _createAutoApproveInfo;
+}

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

@@ -0,0 +1,310 @@
+
+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 { 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 '../../../../../chat/browser/widget/chatContentParts/toolInvocationParts/chatTerminalToolConfirmationSubPart.js';
+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 { isPowerShell, generateAutoApproveActions, dedupeRules } from '../../runInTerminalHelpers.js';
+import { isAutoApproveRule, isNpmScriptAutoApproveRule } from './commandLineAnalyzer.js';
+import { TerminalChatCommandId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chat/browser/terminalChat';
+import { CommandLineAutoApprover } from './autoApprove/commandLineAutoApprover.js';
+
+const promptInjectionWarningCommandsLower = ["curl", "wget"];
+const promptInjectionWarningCommandsLowerPwshOnly = ["invoke-restmethod", "invoke-webrequest", "irm", "iwr"];
+let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extends Disposable {
+    constructor(
+        _treeSitterCommandParser,
+        _telemetry,
+        _log,
+        _configurationService,
+        instantiationService,
+        _storageService,
+        _terminalChatService
+    ) {
+        super();
+        this._treeSitterCommandParser = _treeSitterCommandParser;
+        this._telemetry = _telemetry;
+        this._log = _log;
+        this._configurationService = _configurationService;
+        this._storageService = _storageService;
+        this._terminalChatService = _terminalChatService;
+        this._commandLineAutoApprover = this._register(instantiationService.createInstance(CommandLineAutoApprover));
+    }
+    async analyze(options) {
+        const isAutoApproveEnabledInSettings = this._configurationService.getValue(TerminalChatAgentToolsSettingId.EnableAutoApprove) === true;
+        if (isAutoApproveEnabledInSettings && options.chatSessionResource && this._terminalChatService.hasChatSessionAutoApproval(options.chatSessionResource)) {
+            this._log("Session has auto approval enabled, auto approving command");
+            const disableUri = createCommandUri(
+                TerminalChatCommandId.DisableSessionAutoApproval,
+                options.chatSessionResource
+            );
+            const mdTrustSettings = {
+                isTrusted: {
+                    enabledCommands: [TerminalChatCommandId.DisableSessionAutoApproval]
+                }
+            };
+            return {
+                isAutoApproved: true,
+                isAutoApproveAllowed: true,
+                disclaimers: [],
+                autoApproveInfo: ( new MarkdownString(`${( localize(14006, "Auto approved for this session"))} ([${( localize(14007, "Disable"))}](${( disableUri.toString())}))`, mdTrustSettings))
+            };
+        }
+        const trimmedCommandLine = options.commandLine.trimStart();
+        let subCommands;
+        try {
+            subCommands = await this._treeSitterCommandParser.extractSubCommands(options.treeSitterLanguage, trimmedCommandLine);
+            this._log(
+                `Parsed sub-commands via ${options.treeSitterLanguage} grammar`,
+                subCommands
+            );
+        } catch (e) {
+            console.error(e);
+            this._log(`Failed to parse sub-commands via ${options.treeSitterLanguage} grammar`);
+        }
+        let isAutoApproved = false;
+        let autoApproveInfo;
+        let customActions;
+        if (!subCommands?.length) {
+            if (trimmedCommandLine.length === 0) {
+                this._log("Command line is empty, auto approving");
+                return {
+                    isAutoApproved: true,
+                    isAutoApproveAllowed: true,
+                    disclaimers: []
+                };
+            }
+            this._log("No sub-commands were parsed, auto approval is not allowed");
+            return {
+                isAutoApproveAllowed: false,
+                disclaimers: []
+            };
+        }
+        const subCommandResults = await Promise.all(( subCommands.map(
+            e => this._commandLineAutoApprover.isCommandAutoApproved(e, options.shell, options.os, options.cwd, options.chatSessionResource)
+        )));
+        const commandLineResult = this._commandLineAutoApprover.isCommandLineAutoApproved(trimmedCommandLine, options.chatSessionResource);
+        const autoApproveReasons = [...( subCommandResults.map(e => e.reason)), commandLineResult.reason];
+        let isDenied = false;
+        let autoApproveReason;
+        let autoApproveDefault;
+        const deniedSubCommandResult = subCommandResults.find(e => e.result === "denied");
+        if (deniedSubCommandResult) {
+            this._log("Sub-command DENIED auto approval");
+            isDenied = true;
+            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 = isAutoApproveRule(commandLineResult.rule) ? commandLineResult.rule.isDefaultRule : undefined;
+            autoApproveReason = "commandLine";
+        } else {
+            if (subCommandResults.every(e => e.result === "approved")) {
+                this._log("All sub-commands auto-approved");
+                isAutoApproved = true;
+                autoApproveReason = "subCommand";
+                autoApproveDefault = subCommandResults.every(e => isAutoApproveRule(e.rule) && e.rule.isDefaultRule);
+            } else {
+                this._log("All sub-commands NOT auto-approved");
+                if (commandLineResult.result === "approved") {
+                    this._log("Command line auto-approved");
+                    autoApproveReason = "commandLine";
+                    isAutoApproved = true;
+                    autoApproveDefault = isAutoApproveRule(commandLineResult.rule) ? commandLineResult.rule.isDefaultRule : undefined;
+                } else {
+                    this._log("Command line NOT auto-approved");
+                }
+            }
+        }
+        for (const reason of autoApproveReasons) {
+            this._log(`- ${reason}`);
+        }
+        const isAutoApproveEnabled = this._configurationService.getValue(TerminalChatAgentToolsSettingId.EnableAutoApprove) === true;
+        const isAutoApproveWarningAccepted = this._storageService.getBoolean(
+            TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted,
+            StorageScope.APPLICATION,
+            false
+        );
+        if (isAutoApproveEnabled && isAutoApproved) {
+            autoApproveInfo = this._createAutoApproveInfo(
+                isAutoApproved,
+                isDenied,
+                autoApproveReason,
+                subCommandResults,
+                commandLineResult
+            );
+        } else {
+            isAutoApproved = false;
+        }
+        this._telemetry.logPrepare({
+            terminalToolSessionId: options.terminalToolSessionId,
+            subCommands,
+            autoApproveAllowed: !isAutoApproveEnabled ? "off" : isAutoApproveWarningAccepted ? "allowed" : "needsOptIn",
+            autoApproveResult: isAutoApproved ? "approved" : isDenied ? "denied" : "manual",
+            autoApproveReason,
+            autoApproveDefault
+        });
+        const disclaimers = [];
+        const subCommandsLowerFirstWordOnly = ( subCommands.map(command => command.split(" ")[0].toLowerCase()));
+        if (!isAutoApproved && (( subCommandsLowerFirstWordOnly.some(command => promptInjectionWarningCommandsLower.includes(command))) || (isPowerShell(options.shell, options.os) && ( subCommandsLowerFirstWordOnly.some(command => promptInjectionWarningCommandsLowerPwshOnly.includes(command)))))) {
+            disclaimers.push(( localize(
+                14008,
+                "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(trimmedCommandLine, subCommands, {
+                subCommandResults,
+                commandLineResult
+            });
+        }
+        return {
+            isAutoApproved,
+            isAutoApproveAllowed: true,
+            disclaimers,
+            autoApproveInfo,
+            customActions
+        };
+    }
+    _createAutoApproveInfo(
+        isAutoApproved,
+        isDenied,
+        autoApproveReason,
+        subCommandResults,
+        commandLineResult
+    ) {
+        const formatRuleLinks = result => {
+            return ( asArray(result).filter(e => isAutoApproveRule(e.rule)).map(e => {
+                const escapedSourceText = e.rule.sourceText.replaceAll("$", "\\$");
+                if (e.rule.sourceTarget === "session") {
+                    return localize(14009, "{0} (session)", `\`${escapedSourceText}\``);
+                }
+                const settingsUri = createCommandUri(TerminalChatCommandId.OpenTerminalSettingsLink, e.rule.sourceTarget);
+                const tooltip = ( localize(14010, "View rule in settings"));
+                let label = escapedSourceText;
+                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 = {
+            isTrusted: {
+                enabledCommands: [TerminalChatCommandId.OpenTerminalSettingsLink]
+            }
+        };
+        const config = this._configurationService.inspect(ChatConfiguration.GlobalAutoApprove);
+        const isGlobalAutoApproved = config?.value ?? config.defaultValue;
+        if (isGlobalAutoApproved) {
+            const settingsUri = createCommandUri(TerminalChatCommandId.OpenTerminalSettingsLink, "global");
+            return (new MarkdownString(`${( localize(
+                14011,
+                "Auto approved by setting {0}",
+                `[\`${ChatConfiguration.GlobalAutoApprove}\`](${( settingsUri.toString())} "${( localize(14012, "View settings"))}")`
+            ))}`, mdTrustSettings));
+        }
+        if (isAutoApproved) {
+            switch (autoApproveReason) {
+            case "commandLine":
+                {
+                    if (isAutoApproveRule(commandLineResult.rule)) {
+                        return (new MarkdownString(
+                            localize(14013, "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(14013, "Auto approved by rule {0}", formatRuleLinks(uniqueRules)),
+                            mdTrustSettings
+                        ));
+                    } else if (uniqueRules.length > 1) {
+                        return (new MarkdownString(
+                            localize(14014, "Auto approved by rules {0}", formatRuleLinks(uniqueRules)),
+                            mdTrustSettings
+                        ));
+                    }
+                    break;
+                }
+            }
+        } else if (isDenied) {
+            switch (autoApproveReason) {
+            case "commandLine":
+                {
+                    if (commandLineResult.rule) {
+                        return (new MarkdownString(localize(
+                            14015,
+                            "Auto approval denied by rule {0}",
+                            formatRuleLinks(commandLineResult)
+                        ), mdTrustSettings));
+                    }
+                    break;
+                }
+            case "subCommand":
+                {
+                    const uniqueRules = dedupeRules(subCommandResults.filter(e => e.result === "denied"));
+                    if (uniqueRules.length === 1) {
+                        return (new MarkdownString(
+                            localize(14015, "Auto approval denied by rule {0}", formatRuleLinks(uniqueRules)),
+                            mdTrustSettings
+                        ));
+                    } else if (uniqueRules.length > 1) {
+                        return (new MarkdownString(
+                            localize(14016, "Auto approval denied by rules {0}", formatRuleLinks(uniqueRules)),
+                            mdTrustSettings
+                        ));
+                    }
+                    break;
+                }
+            }
+        }
+        return undefined;
+    }
+};
+CommandLineAutoApproveAnalyzer = ( __decorate([( __param(3, IConfigurationService)), ( __param(4, IInstantiationService)), ( __param(5, IStorageService)), ( __param(6, ITerminalChatService))], CommandLineAutoApproveAnalyzer));
+
+export { CommandLineAutoApproveAnalyzer };

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

@@ -0,0 +1,19 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { type TreeSitterCommandParser } from "../../treeSitterCommandParser.js";
+import type { ICommandLineAnalyzer, ICommandLineAnalyzerOptions, ICommandLineAnalyzerResult } from "./commandLineAnalyzer.js";
+import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
+export declare class CommandLineFileWriteAnalyzer extends Disposable implements ICommandLineAnalyzer {
+    private readonly _treeSitterCommandParser;
+    private readonly _log;
+    private readonly _configurationService;
+    private readonly _labelService;
+    private readonly _workspaceContextService;
+    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;
+}