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

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

@@ -0,0 +1,31 @@
+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 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";
+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 | 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;
+    private readonly _npmScriptAutoApprover;
+    constructor(_configurationService: IConfigurationService, instantiationService: IInstantiationService, _terminalChatService: ITerminalChatService);
+    updateConfiguration(): void;
+    isCommandAutoApproved(command: string, shell: string, os: OperatingSystem, cwd: URI | undefined, chatSessionResource?: URI): Promise<ICommandApprovalResultWithReason>;
+    isCommandLineAutoApproved(commandLine: string, chatSessionResource?: URI): ICommandApprovalResultWithReason;
+    private _getSessionRules;
+    private _commandMatchesRule;
+    private _mapAutoApproveConfigToRules;
+    private _convertAutoApproveEntryToRegex;
+    private _doConvertAutoApproveEntryToRegex;
+}

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

@@ -0,0 +1,392 @@
+
+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 { 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 { NpmScriptAutoApprover } from './npmScriptAutoApprover.js';
+
+const neverMatchRegex = /(?!.*)/;
+const transientEnvVarRegex = /^[A-Z_][A-Z0-9_]*=/i;
+let CommandLineAutoApprover = class CommandLineAutoApprover extends Disposable {
+    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) || e.affectsConfiguration(TerminalChatAgentToolsSettingId.IgnoreDefaultAutoApproveRules) || e.affectsConfiguration(TerminalChatAgentToolsSettingId.DeprecatedAutoApproveCompatible)) {
+                this.updateConfiguration();
+            }
+        }));
+    }
+    updateConfiguration() {
+        let configValue = this._configurationService.getValue(TerminalChatAgentToolsSettingId.AutoApprove);
+        const configInspectValue = this._configurationService.inspect(TerminalChatAgentToolsSettingId.AutoApprove);
+        const deprecatedValue = this._configurationService.getValue(TerminalChatAgentToolsSettingId.DeprecatedAutoApproveCompatible);
+        if (deprecatedValue && typeof deprecatedValue === "object" && configValue && typeof configValue === "object") {
+            configValue = {
+                ...configValue,
+                ...deprecatedValue
+            };
+        }
+        const {
+            denyListRules,
+            allowListRules,
+            allowListCommandLineRules,
+            denyListCommandLineRules
+        } = this._mapAutoApproveConfigToRules(configValue, configInspectValue);
+        this._allowListRules = allowListRules;
+        this._denyListRules = denyListRules;
+        this._allowListCommandLineRules = allowListCommandLineRules;
+        this._denyListCommandLineRules = denyListCommandLineRules;
+    }
+    async isCommandAutoApproved(command, shell, os, cwd, chatSessionResource) {
+        if (transientEnvVarRegex.test(command)) {
+            return {
+                result: "denied",
+                reason: `Command '${command}' is denied because it contains transient environment variables`
+            };
+        }
+        for (const rule of this._denyListRules) {
+            if (this._commandMatchesRule(rule, command, shell, os)) {
+                return {
+                    result: "denied",
+                    rule,
+                    reason: `Command '${command}' is denied by deny list rule: ${rule.sourceText}`
+                };
+            }
+        }
+        for (const rule of this._getSessionRules(chatSessionResource).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 {
+                    result: "approved",
+                    rule,
+                    reason: `Command '${command}' is approved by allow list rule: ${rule.sourceText}`
+                };
+            }
+        }
+        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, chatSessionResource) {
+        for (const rule of this._denyListCommandLineRules) {
+            if (rule.regex.test(commandLine)) {
+                return {
+                    result: "denied",
+                    rule,
+                    reason: `Command line '${commandLine}' is denied by deny list rule: ${rule.sourceText}`
+                };
+            }
+        }
+        for (const rule of this._getSessionRules(chatSessionResource).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 {
+                    result: "approved",
+                    rule,
+                    reason: `Command line '${commandLine}' is approved by allow list rule: ${rule.sourceText}`
+                };
+            }
+        }
+        return {
+            result: "noMatch",
+            reason: `Command line '${commandLine}' has no matching auto approve entries`
+        };
+    }
+    _getSessionRules(chatSessionResource) {
+        const denyListRules = [];
+        const allowListRules = [];
+        const allowListCommandLineRules = [];
+        const denyListCommandLineRules = [];
+        if (!chatSessionResource) {
+            return {
+                denyListRules,
+                allowListRules,
+                allowListCommandLineRules,
+                denyListCommandLineRules
+            };
+        }
+        const sessionRulesConfig = this._terminalChatService.getSessionAutoApproveRules(chatSessionResource);
+        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)) {
+            return true;
+        } else if (isPwsh && command.startsWith("(")) {
+            if (rule.regexCaseInsensitive.test(command.slice(1))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    _mapAutoApproveConfigToRules(config, configInspectValue) {
+        if (!config || typeof config !== "object") {
+            return {
+                denyListRules: [],
+                allowListRules: [],
+                allowListCommandLineRules: [],
+                denyListCommandLineRules: []
+            };
+        }
+        const denyListRules = [];
+        const allowListRules = [];
+        const allowListCommandLineRules = [];
+        const denyListCommandLineRules = [];
+        const ignoreDefaults = this._configurationService.getValue(TerminalChatAgentToolsSettingId.IgnoreDefaultAutoApproveRules) === true;
+        for (const [key, value] of Object.entries(config)) {
+            const defaultValue = configInspectValue?.default?.value;
+            const isDefaultRule = !!(isObject(defaultValue) && Object.prototype.hasOwnProperty.call(defaultValue, key) && structuralEquals(defaultValue[key], value));
+            function checkTarget(inspectValue) {
+                return (isObject(inspectValue) && Object.prototype.hasOwnProperty.call(inspectValue, key) && structuralEquals(inspectValue[key], value));
+            }
+            const sourceTarget = (checkTarget(configInspectValue.workspaceFolder) ? ConfigurationTarget.WORKSPACE_FOLDER : checkTarget(configInspectValue.workspaceValue) ? ConfigurationTarget.WORKSPACE : checkTarget(configInspectValue.userRemoteValue) ? ConfigurationTarget.USER_REMOTE : checkTarget(configInspectValue.userLocalValue) ? ConfigurationTarget.USER_LOCAL : checkTarget(configInspectValue.userValue) ? ConfigurationTarget.USER : checkTarget(configInspectValue.applicationValue) ? ConfigurationTarget.APPLICATION : ConfigurationTarget.DEFAULT);
+            if (ignoreDefaults && isDefaultRule && sourceTarget === ConfigurationTarget.DEFAULT) {
+                continue;
+            }
+            if (typeof value === "boolean") {
+                const {
+                    regex,
+                    regexCaseInsensitive
+                } = this._convertAutoApproveEntryToRegex(key);
+                if (value === true) {
+                    allowListRules.push({
+                        regex,
+                        regexCaseInsensitive,
+                        sourceText: key,
+                        sourceTarget,
+                        isDefaultRule
+                    });
+                } else if (value === false) {
+                    denyListRules.push({
+                        regex,
+                        regexCaseInsensitive,
+                        sourceText: key,
+                        sourceTarget,
+                        isDefaultRule
+                    });
+                }
+            } 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,
+                                isDefaultRule
+                            });
+                        } else {
+                            allowListRules.push({
+                                regex,
+                                regexCaseInsensitive,
+                                sourceText: key,
+                                sourceTarget,
+                                isDefaultRule
+                            });
+                        }
+                    } else if (objectValue.approve === false) {
+                        if (objectValue.matchCommandLine === true) {
+                            denyListCommandLineRules.push({
+                                regex,
+                                regexCaseInsensitive,
+                                sourceText: key,
+                                sourceTarget,
+                                isDefaultRule
+                            });
+                        } else {
+                            denyListRules.push({
+                                regex,
+                                regexCaseInsensitive,
+                                sourceText: key,
+                                sourceTarget,
+                                isDefaultRule
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            denyListRules,
+            allowListRules,
+            allowListCommandLineRules,
+            denyListCommandLineRules
+        };
+    }
+    _convertAutoApproveEntryToRegex(value) {
+        const regex = this._doConvertAutoApproveEntryToRegex(value);
+        if (regex.flags.includes("i")) {
+            return {
+                regex,
+                regexCaseInsensitive: regex
+            };
+        }
+        return {
+            regex,
+            regexCaseInsensitive: ( new RegExp(regex.source, regex.flags + "i"))
+        };
+    }
+    _doConvertAutoApproveEntryToRegex(value) {
+        const regexMatch = value.match(/^\/(?<pattern>.+)\/(?<flags>[dgimsuvy]*)$/);
+        const regexPattern = regexMatch?.groups?.pattern;
+        if (regexPattern) {
+            let flags = regexMatch.groups?.flags;
+            if (flags) {
+                flags = flags.replaceAll("g", "");
+            }
+            if (regexPattern === ".*") {
+                return ( new RegExp(regexPattern));
+            }
+            try {
+                const regex = ( new RegExp(regexPattern, flags || undefined));
+                if (regExpLeadsToEndlessLoop(regex)) {
+                    return neverMatchRegex;
+                }
+                return regex;
+            } catch (error) {
+                return neverMatchRegex;
+            }
+        }
+        if (value === "") {
+            return neverMatchRegex;
+        }
+        let sanitizedValue;
+        if (value.includes("/") || value.includes("\\")) {
+            let pattern = value.replace(/[/\\]/g, "%%PATH_SEP%%");
+            pattern = escapeRegExpCharacters(pattern);
+            pattern = pattern.replace(/%%PATH_SEP%%*/g, "[/\\\\]");
+            sanitizedValue = `^(?:\\.[/\\\\])?${pattern}`;
+        }
+        else {
+            sanitizedValue = escapeRegExpCharacters(value);
+        }
+        return ( new RegExp(`^${sanitizedValue}\\b`));
+    }
+};
+CommandLineAutoApprover = ( __decorate([( __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;
+}