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

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

@@ -1,6 +1,7 @@
 import type { QueryCapture } from "@codingame/monaco-vscode-api/external/@vscode/tree-sitter-wasm/wasm/tree-sitter";
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { ITreeSitterLibraryService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/treeSitter/treeSitterLibraryService.service";
+import type { ITerminalSandboxCommand } from "../../../../../platform/sandbox/common/terminalSandboxService.js";
 export declare enum TreeSitterCommandParserLanguage {
     Bash = "bash",
     PowerShell = "powershell"
@@ -13,6 +14,18 @@ export declare class TreeSitterCommandParser extends Disposable {
     constructor(_treeSitterLibraryService: ITreeSitterLibraryService);
     extractSubCommands(languageId: TreeSitterCommandParserLanguage, commandLine: string): Promise<string[]>;
     extractPwshDoubleAmpersandChainOperators(commandLine: string): Promise<QueryCapture[]>;
+    /**
+     * Extracts executable command invocations from the command line and returns
+     * normalized command details for sandbox allow-listing.
+     *
+     * Example: `PATH=/bin /usr/bin/git commit -S -m "test" && npm install`
+     * returns:
+     * `[
+     * 	{ keyword: 'git', args: ['commit', '-S', '-m', 'test'] },
+     * 	{ keyword: 'npm', args: ['install'] }
+     * ]`.
+     */
+    extractCommands(languageId: TreeSitterCommandParserLanguage, commandLine: string): Promise<ITerminalSandboxCommand[]>;
     getFileWrites(languageId: TreeSitterCommandParserLanguage, commandLine: string): Promise<string[]>;
     /**
      * Extracts file targets from commands that perform file writes beyond shell redirections.
@@ -21,5 +34,25 @@ export declare class TreeSitterCommandParser extends Disposable {
      */
     getCommandFileWrites(languageId: TreeSitterCommandParserLanguage, commandLine: string): Promise<string[]>;
     private _queryTree;
+    /**
+     * Converts a command token to the stable keyword used by sandbox allow-list
+     * rules by stripping quotes, path segments, and common executable suffixes.
+     */
+    private _normalizeCommandKeyword;
+    /**
+     * Parses a single tree-sitter command node into command details, ignoring
+     * leading environment variable assignments such as `NODE_ENV=test npm run build`.
+     */
+    private _parseCommand;
+    /**
+     * Splits enough shell syntax for sandbox allow-listing: whitespace separates
+     * tokens, quotes are removed, and backslash escapes preserve the escaped char.
+     */
+    private _splitCommandTokens;
+    /**
+     * Returns true for simple shell-style environment variable assignments that
+     * can prefix a command invocation.
+     */
+    private _isVariableAssignment;
     private _doQuery;
 }

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

@@ -4,6 +4,7 @@ import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/co
 import { BugIndicatingError, ErrorNoTelemetry } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
 import { Disposable, MutableDisposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { win32, posix } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
 import { ITreeSitterLibraryService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/treeSitter/treeSitterLibraryService.service';
 import { SedFileWriteParser } from './commandParsers/sedFileWriteParser.js';
 
@@ -45,6 +46,16 @@ let TreeSitterCommandParser = class TreeSitterCommandParser extends Disposable {
         );
         return captures;
     }
+    async extractCommands(languageId, commandLine) {
+        const commands = [];
+        for (const commandText of await this.extractSubCommands(languageId, commandLine)) {
+            const command = this._parseCommand(commandText);
+            if (command) {
+                commands.push(command);
+            }
+        }
+        return commands;
+    }
     async getFileWrites(languageId, commandLine) {
         let query;
         switch (languageId) {
@@ -85,6 +96,77 @@ let TreeSitterCommandParser = class TreeSitterCommandParser extends Disposable {
         } = await this._doQuery(languageId, commandLine, querySource);
         return query.captures(tree.rootNode);
     }
+    _normalizeCommandKeyword(token) {
+        const unquoted = token.replace(/^['"]|['"]$/g, "");
+        if (!unquoted) {
+            return undefined;
+        }
+        const pathBase = unquoted.includes("\\") ? win32.basename(unquoted) : posix.basename(unquoted);
+        const normalized = pathBase.toLowerCase().replace(/\.(?:exe|cmd|bat|ps1)$/i, "");
+        return normalized || undefined;
+    }
+    _parseCommand(commandText) {
+        const tokens = this._splitCommandTokens(commandText);
+        let commandIndex = 0;
+        while (commandIndex < tokens.length && this._isVariableAssignment(tokens[commandIndex])) {
+            commandIndex++;
+        }
+        const keyword = this._normalizeCommandKeyword(tokens[commandIndex] ?? "");
+        if (!keyword) {
+            return undefined;
+        }
+        return {
+            keyword,
+            args: tokens.slice(commandIndex + 1)
+        };
+    }
+    _splitCommandTokens(commandText) {
+        const tokens = [];
+        let current = "";
+        let quote;
+        let escaping = false;
+        for (const char of commandText.trim()) {
+            if (escaping) {
+                current += char;
+                escaping = false;
+                continue;
+            }
+            if (char === "\\" && quote !== "'") {
+                escaping = true;
+                continue;
+            }
+            if (quote) {
+                if (char === quote) {
+                    quote = undefined;
+                } else {
+                    current += char;
+                }
+                continue;
+            }
+            if (char === "'" || char === "\"") {
+                quote = char;
+                continue;
+            }
+            if (/\s/.test(char)) {
+                if (current) {
+                    tokens.push(current);
+                    current = "";
+                }
+                continue;
+            }
+            current += char;
+        }
+        if (escaping) {
+            current += "\\";
+        }
+        if (current) {
+            tokens.push(current);
+        }
+        return tokens;
+    }
+    _isVariableAssignment(token) {
+        return /^[A-Za-z_][A-Za-z0-9_]*=.*/.test(token);
+    }
     async _doQuery(languageId, commandLine, querySource) {
         const language = await this._treeSitterLibraryService.getLanguagePromise(languageId);
         if (!language) {

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxCommandRules.d.ts

@@ -0,0 +1,31 @@
+import type { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import type { ITerminalSandboxCommand } from "../../../../../platform/sandbox/common/terminalSandboxService.js";
+export interface ITerminalSandboxCommandRuleContext {
+    readonly os: OperatingSystem;
+}
+export interface ITerminalSandboxCommandRule<T> {
+    readonly keywords: readonly string[];
+    readonly value: T;
+    readonly subcommands?: readonly string[];
+    readonly optionsWithValue?: ReadonlySet<string>;
+    /** Context-wide guard for rules, such as OS-specific sandbox capabilities. */
+    readonly condition?: (context: ITerminalSandboxCommandRuleContext) => boolean;
+    /** Command-specific guard for argument-sensitive rules. */
+    readonly when?: (command: ITerminalSandboxCommand) => boolean;
+}
+/**
+ * Git global options that consume the following argument. These need to be
+ * skipped when finding the subcommand so `git -C repo commit` matches `commit`
+ * instead of treating `repo` as the subcommand.
+ */
+export declare const gitGlobalOptionsWithValue: Set<string>;
+export declare function matchesTerminalSandboxCommandRule<T>(command: ITerminalSandboxCommand, rule: ITerminalSandboxCommandRule<T>, context?: ITerminalSandboxCommandRuleContext): boolean;
+/**
+ * Returns the first non-option argument, treating it as the command's subcommand.
+ * Options are skipped, and options listed in `optionsWithValue` also skip the
+ * following argument so global option values are not mistaken for subcommands.
+ *
+ * For example, with `-C` in `optionsWithValue`, `git -C repo commit` returns
+ * `commit` instead of `repo`.
+ */
+export declare function getCommandSubcommand(args: readonly string[], optionsWithValue?: ReadonlySet<string>): string | undefined;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxCommandRules.js

@@ -0,0 +1,49 @@
+
+
+const gitGlobalOptionsWithValue = ( new Set([
+    "-C",
+    "-c",
+    "--config-env",
+    "--exec-path",
+    "--git-dir",
+    "--html-path",
+    "--info-path",
+    "--man-path",
+    "--namespace",
+    "--super-prefix",
+    "--work-tree"
+]));
+function matchesTerminalSandboxCommandRule(command, rule, context) {
+    if (!rule.keywords.includes(command.keyword.toLowerCase())) {
+        return false;
+    }
+    if (rule.condition && (!context || !rule.condition(context))) {
+        return false;
+    }
+    if (rule.subcommands) {
+        const subcommand = getCommandSubcommand(command.args, rule.optionsWithValue);
+        if (subcommand === undefined || !rule.subcommands.includes(subcommand)) {
+            return false;
+        }
+    }
+    return rule.when?.(command) ?? true;
+}
+function getCommandSubcommand(args, optionsWithValue) {
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--") {
+            return undefined;
+        }
+        if (arg.startsWith("-")) {
+            const option = arg.includes("=") ? arg.substring(0, arg.indexOf("=")) : arg;
+            if (!arg.includes("=") && optionsWithValue?.has(option)) {
+                i++;
+            }
+            continue;
+        }
+        return arg.toLowerCase();
+    }
+    return undefined;
+}
+
+export { getCommandSubcommand, gitGlobalOptionsWithValue, matchesTerminalSandboxCommandRule };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxReadAllowList.d.ts

@@ -0,0 +1,18 @@
+import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import type { ITerminalSandboxCommand } from "../../../../../platform/sandbox/common/terminalSandboxService.js";
+export declare enum TerminalSandboxReadAllowListOperation {
+    Git = "git",
+    Node = "node",
+    Rust = "rust",
+    Go = "go",
+    Python = "python",
+    Java = "java",
+    Dotnet = "dotnet",
+    Nuget = "nuget",
+    Msbuild = "msbuild",
+    Ruby = "ruby",
+    NativeBuild = "nativeBuild",
+    Conan = "conan",
+    GnuPG = "gnupg"
+}
+export declare function getTerminalSandboxReadAllowListForCommands(os: OperatingSystem, commandKeywords: readonly string[], commandDetails?: readonly ITerminalSandboxCommand[]): readonly string[];

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxReadAllowList.js

@@ -0,0 +1,302 @@
+
+import { OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { gitGlobalOptionsWithValue, matchesTerminalSandboxCommandRule } from './terminalSandboxCommandRules.js';
+
+var TerminalSandboxReadAllowListOperation;
+(function(TerminalSandboxReadAllowListOperation) {
+    TerminalSandboxReadAllowListOperation["Git"] = "git";
+    TerminalSandboxReadAllowListOperation["Node"] = "node";
+    TerminalSandboxReadAllowListOperation["Rust"] = "rust";
+    TerminalSandboxReadAllowListOperation["Go"] = "go";
+    TerminalSandboxReadAllowListOperation["Python"] = "python";
+    TerminalSandboxReadAllowListOperation["Java"] = "java";
+    TerminalSandboxReadAllowListOperation["Dotnet"] = "dotnet";
+    TerminalSandboxReadAllowListOperation["Nuget"] = "nuget";
+    TerminalSandboxReadAllowListOperation["Msbuild"] = "msbuild";
+    TerminalSandboxReadAllowListOperation["Ruby"] = "ruby";
+    TerminalSandboxReadAllowListOperation["NativeBuild"] = "nativeBuild";
+    TerminalSandboxReadAllowListOperation["Conan"] = "conan";
+    TerminalSandboxReadAllowListOperation["GnuPG"] = "gnupg";
+})(
+    TerminalSandboxReadAllowListOperation || (TerminalSandboxReadAllowListOperation = {})
+);
+const terminalSandboxReadAllowListKeywordMap = ( new Map([
+    ["git", TerminalSandboxReadAllowListOperation.Git],
+    ["gh", TerminalSandboxReadAllowListOperation.Git],
+    ["node", TerminalSandboxReadAllowListOperation.Node],
+    ["npm", TerminalSandboxReadAllowListOperation.Node],
+    ["npx", TerminalSandboxReadAllowListOperation.Node],
+    ["pnpm", TerminalSandboxReadAllowListOperation.Node],
+    ["yarn", TerminalSandboxReadAllowListOperation.Node],
+    ["corepack", TerminalSandboxReadAllowListOperation.Node],
+    ["bun", TerminalSandboxReadAllowListOperation.Node],
+    ["deno", TerminalSandboxReadAllowListOperation.Node],
+    ["nvm", TerminalSandboxReadAllowListOperation.Node],
+    ["volta", TerminalSandboxReadAllowListOperation.Node],
+    ["fnm", TerminalSandboxReadAllowListOperation.Node],
+    ["asdf", TerminalSandboxReadAllowListOperation.Node],
+    ["mise", TerminalSandboxReadAllowListOperation.Node],
+    ["cargo", TerminalSandboxReadAllowListOperation.Rust],
+    ["rustc", TerminalSandboxReadAllowListOperation.Rust],
+    ["rustup", TerminalSandboxReadAllowListOperation.Rust],
+    ["go", TerminalSandboxReadAllowListOperation.Go],
+    ["gofmt", TerminalSandboxReadAllowListOperation.Go],
+    ["python", TerminalSandboxReadAllowListOperation.Python],
+    ["python3", TerminalSandboxReadAllowListOperation.Python],
+    ["pip", TerminalSandboxReadAllowListOperation.Python],
+    ["pip3", TerminalSandboxReadAllowListOperation.Python],
+    ["poetry", TerminalSandboxReadAllowListOperation.Python],
+    ["uv", TerminalSandboxReadAllowListOperation.Python],
+    ["pipx", TerminalSandboxReadAllowListOperation.Python],
+    ["pyenv", TerminalSandboxReadAllowListOperation.Python],
+    ["java", TerminalSandboxReadAllowListOperation.Java],
+    ["javac", TerminalSandboxReadAllowListOperation.Java],
+    ["jar", TerminalSandboxReadAllowListOperation.Java],
+    ["mvn", TerminalSandboxReadAllowListOperation.Java],
+    ["mvnw", TerminalSandboxReadAllowListOperation.Java],
+    ["gradle", TerminalSandboxReadAllowListOperation.Java],
+    ["gradlew", TerminalSandboxReadAllowListOperation.Java],
+    ["sdk", TerminalSandboxReadAllowListOperation.Java],
+    ["dotnet", TerminalSandboxReadAllowListOperation.Dotnet],
+    ["nuget", TerminalSandboxReadAllowListOperation.Nuget],
+    ["msbuild", TerminalSandboxReadAllowListOperation.Msbuild],
+    ["ruby", TerminalSandboxReadAllowListOperation.Ruby],
+    ["gem", TerminalSandboxReadAllowListOperation.Ruby],
+    ["bundle", TerminalSandboxReadAllowListOperation.Ruby],
+    ["bundler", TerminalSandboxReadAllowListOperation.Ruby],
+    ["rake", TerminalSandboxReadAllowListOperation.Ruby],
+    ["rbenv", TerminalSandboxReadAllowListOperation.Ruby],
+    ["rvm", TerminalSandboxReadAllowListOperation.Ruby],
+    ["ccache", TerminalSandboxReadAllowListOperation.NativeBuild],
+    ["sccache", TerminalSandboxReadAllowListOperation.NativeBuild],
+    ["cmake", TerminalSandboxReadAllowListOperation.NativeBuild],
+    ["conan", TerminalSandboxReadAllowListOperation.Conan]
+]));
+function getTerminalSandboxReadAllowListForOperation(operation, os) {
+    switch (operation) {
+    case TerminalSandboxReadAllowListOperation.Git:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+        case OperatingSystem.Linux:
+        default:
+            return [
+                "~/.gitconfig",
+                "~/.config/git/config",
+                "~/.gitignore",
+                "~/.gitignore_global",
+                "~/.config/git/ignore",
+                "~/.config/git/attributes"
+            ];
+        }
+    case TerminalSandboxReadAllowListOperation.Node:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+            return [
+                "~/.npm",
+                "~/Library/Caches/node",
+                "~/Library/Caches/electron",
+                "~/Library/Caches/ms-playwright",
+                "~/Library/Caches/Yarn",
+                "~/Library/Caches/deno",
+                "~/Library/pnpm",
+                "~/.electron-gyp",
+                "~/.node-gyp",
+                "~/.yarn/berry",
+                "~/.local/share/pnpm",
+                "~/.pnpm-store",
+                "~/.bun/install/cache",
+                "~/.bun/bin",
+                "~/.deno",
+                "~/.nvm/versions",
+                "~/.nvm/alias",
+                "~/.volta/bin",
+                "~/.volta/tools",
+                "~/.fnm",
+                "~/.asdf/installs/nodejs",
+                "~/.asdf/shims",
+                "~/.local/share/mise/installs/node",
+                "~/.local/share/mise/shims"
+            ];
+        case OperatingSystem.Linux:
+        default:
+            return [
+                "~/.npm",
+                "~/.cache/node",
+                "~/.cache/node/corepack",
+                "~/.cache/electron",
+                "~/.cache/ms-playwright",
+                "~/.cache/yarn",
+                "~/.electron-gyp",
+                "~/.node-gyp",
+                "~/.yarn/berry",
+                "~/.local/share/pnpm",
+                "~/.pnpm-store",
+                "~/.bun/install/cache",
+                "~/.bun/bin",
+                "~/.deno",
+                "~/.cache/deno",
+                "~/.nvm/versions",
+                "~/.nvm/alias",
+                "~/.volta/bin",
+                "~/.volta/tools",
+                "~/.fnm",
+                "~/.asdf/installs/nodejs",
+                "~/.asdf/shims",
+                "~/.local/share/mise/installs/node",
+                "~/.local/share/mise/shims"
+            ];
+        }
+    case TerminalSandboxReadAllowListOperation.Rust:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+        case OperatingSystem.Linux:
+        default:
+            return [
+                "~/.cargo/bin",
+                "~/.cargo/registry",
+                "~/.cargo/git",
+                "~/.rustup/toolchains"
+            ];
+        }
+    case TerminalSandboxReadAllowListOperation.Go:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+            return ["~/go/pkg/mod", "~/go/bin", "~/Library/Caches/go-build"];
+        case OperatingSystem.Linux:
+        default:
+            return ["~/go/pkg/mod", "~/go/bin", "~/.cache/go-build"];
+        }
+    case TerminalSandboxReadAllowListOperation.Python:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+            return [
+                "~/Library/Caches/pip",
+                "~/Library/Caches/pypoetry",
+                "~/Library/Caches/uv",
+                "~/.local/bin",
+                "~/.local/share/virtualenv",
+                "~/.local/share/pipx",
+                "~/.pyenv/versions",
+                "~/.pyenv/shims"
+            ];
+        case OperatingSystem.Linux:
+        default:
+            return [
+                "~/.cache/pip",
+                "~/.cache/pypoetry",
+                "~/.cache/uv",
+                "~/.local/bin",
+                "~/.local/share/virtualenv",
+                "~/.local/share/pipx",
+                "~/.pyenv/versions",
+                "~/.pyenv/shims"
+            ];
+        }
+    case TerminalSandboxReadAllowListOperation.Java:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+        case OperatingSystem.Linux:
+        default:
+            return [
+                "~/.m2/repository",
+                "~/.gradle/caches",
+                "~/.gradle/wrapper/dists",
+                "~/.sdkman/candidates"
+            ];
+        }
+    case TerminalSandboxReadAllowListOperation.Dotnet:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+        case OperatingSystem.Linux:
+        default:
+            return ["~/.dotnet"];
+        }
+    case TerminalSandboxReadAllowListOperation.Nuget:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+            return ["~/.nuget/packages", "~/Library/Caches/NuGet/v3-cache"];
+        case OperatingSystem.Linux:
+        default:
+            return ["~/.nuget/packages", "~/.local/share/NuGet/v3-cache"];
+        }
+    case TerminalSandboxReadAllowListOperation.Msbuild:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+        case OperatingSystem.Linux:
+        default:
+            return [];
+        }
+    case TerminalSandboxReadAllowListOperation.Ruby:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+            return ["~/.gem", "~/.rbenv/versions", "~/.rbenv/shims", "~/.rvm/rubies"];
+        case OperatingSystem.Linux:
+        default:
+            return ["~/.gem", "~/.rbenv/versions", "~/.rbenv/shims", "~/.rvm/rubies"];
+        }
+    case TerminalSandboxReadAllowListOperation.NativeBuild:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+            return ["~/Library/Caches/ccache", "~/Library/Caches/sccache"];
+        case OperatingSystem.Linux:
+        default:
+            return ["~/.cache/ccache", "~/.cache/sccache"];
+        }
+    case TerminalSandboxReadAllowListOperation.Conan:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+        case OperatingSystem.Linux:
+        default:
+            return ["~/.conan2/p", "~/.conan2/b"];
+        }
+    case TerminalSandboxReadAllowListOperation.GnuPG:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+        case OperatingSystem.Linux:
+        default:
+            return ["~/.gnupg"];
+        }
+    }
+}
+function getTerminalSandboxReadAllowListForCommandDetails(os, commandDetails) {
+    const operations = ( new Set());
+    for (const command of commandDetails) {
+        for (const rule of terminalSandboxReadAllowListCommandDetailRules) {
+            if (matchesTerminalSandboxCommandRule(command, rule, {
+                os
+            })) {
+                operations.add(rule.value);
+            }
+        }
+    }
+    const paths = [...operations].flatMap(operation => getTerminalSandboxReadAllowListForOperation(operation, os));
+    return [...( new Set(paths))];
+}
+const terminalSandboxReadAllowListCommandDetailRules = [{
+    keywords: ["gpg", "gpg2"],
+    value: TerminalSandboxReadAllowListOperation.GnuPG
+}, {
+    keywords: ["git"],
+    value: TerminalSandboxReadAllowListOperation.GnuPG,
+    subcommands: ["commit"],
+    optionsWithValue: gitGlobalOptionsWithValue
+}];
+function getTerminalSandboxReadAllowListForCommands(os, commandKeywords, commandDetails = []) {
+    if (commandKeywords.length === 0) {
+        return getTerminalSandboxReadAllowListForCommandDetails(os, commandDetails);
+    }
+    const operations = ( new Set());
+    for (const keyword of commandKeywords) {
+        const operation = terminalSandboxReadAllowListKeywordMap.get(keyword.toLowerCase());
+        if (operation) {
+            operations.add(operation);
+        }
+    }
+    const paths = [...operations].flatMap(operation => getTerminalSandboxReadAllowListForOperation(operation, os));
+    return [...( new Set([
+        ...paths,
+        ...getTerminalSandboxReadAllowListForCommandDetails(os, commandDetails)
+    ]))];
+}
+
+export { TerminalSandboxReadAllowListOperation, getTerminalSandboxReadAllowListForCommands };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxRuntimeConfigurationPerOperation.d.ts

@@ -0,0 +1,7 @@
+import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import type { ITerminalSandboxCommand } from "../../../../../platform/sandbox/common/terminalSandboxService.js";
+export declare enum TerminalSandboxRuntimeConfigurationOperation {
+    GnuPG = "gnupg",
+    Node = "node"
+}
+export declare function getTerminalSandboxRuntimeConfigurationForCommands(os: OperatingSystem, commandDetails: readonly ITerminalSandboxCommand[]): Record<string, unknown>;