@codingame/monaco-vscode-chat-service-override 33.0.9 → 34.0.1

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.workspaceFolderValue) ? 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;
+}

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(
+                14638,
+                "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 };