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

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

@@ -0,0 +1,58 @@
+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"
+}
+export declare class TreeSitterCommandParser extends Disposable {
+    private readonly _treeSitterLibraryService;
+    private readonly _parser;
+    private readonly _treeCache;
+    private readonly _commandFileWriteParsers;
+    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.
+     * Uses registered command parsers (e.g., for `sed -i`) to detect command-specific file writes.
+     * Returns an array of file paths that would be modified.
+     */
+    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

@@ -0,0 +1,223 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+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';
+
+var TreeSitterCommandParserLanguage;
+(function(TreeSitterCommandParserLanguage) {
+    TreeSitterCommandParserLanguage["Bash"] = "bash";
+    TreeSitterCommandParserLanguage["PowerShell"] = "powershell";
+})(TreeSitterCommandParserLanguage || (TreeSitterCommandParserLanguage = {}));
+const pwshFlagEqualsRegex = /(^|\s)(-{1,2}[\w-]+)=/g;
+function maskPwshFlagEquals(commandLine) {
+    return commandLine.replace(pwshFlagEqualsRegex, (_, pre, flag) => `${pre}${flag} `);
+}
+let TreeSitterCommandParser = class TreeSitterCommandParser extends Disposable {
+    constructor(_treeSitterLibraryService) {
+        super();
+        this._treeSitterLibraryService = _treeSitterLibraryService;
+        this._treeCache = this._register(( new TreeCache()));
+        this._commandFileWriteParsers = [( new SedFileWriteParser())];
+        this._parser = ( new Lazy(
+            () => this._treeSitterLibraryService.getParserClass().then(ParserCtor => ( new ParserCtor()))
+        ));
+    }
+    async extractSubCommands(languageId, commandLine) {
+        if (languageId === TreeSitterCommandParserLanguage.PowerShell) {
+            const masked = maskPwshFlagEquals(commandLine);
+            if (masked !== commandLine) {
+                const captures = await this._queryTree(languageId, masked, "(command) @command");
+                return ( captures.map(e => commandLine.substring(e.node.startIndex, e.node.endIndex)));
+            }
+        }
+        const captures = await this._queryTree(languageId, commandLine, "(command) @command");
+        return ( captures.map(e => e.node.text));
+    }
+    async extractPwshDoubleAmpersandChainOperators(commandLine) {
+        const captures = await this._queryTree(
+            TreeSitterCommandParserLanguage.PowerShell,
+            commandLine,
+            ["(", "  (pipeline", "    (pipeline_chain_tail) @double.ampersand)", ")"].join("\n")
+        );
+        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) {
+        case TreeSitterCommandParserLanguage.Bash:
+            query = [
+                "(file_redirect",
+                "  destination: [(word) (string (string_content)) (raw_string) (concatenation)] @file)"
+            ].join("\n");
+            break;
+        case TreeSitterCommandParserLanguage.PowerShell:
+            query = ["(redirection", "  (redirected_file_name) @file)"].join("\n");
+            break;
+        }
+        const captures = await this._queryTree(languageId, commandLine, query);
+        return ( captures.map(e => e.node.text.trim()));
+    }
+    async getCommandFileWrites(languageId, commandLine) {
+        if (languageId !== TreeSitterCommandParserLanguage.Bash) {
+            return [];
+        }
+        const query = "(command) @command";
+        const captures = await this._queryTree(languageId, commandLine, query);
+        const result = [];
+        for (const capture of captures) {
+            const commandText = capture.node.text;
+            for (const parser of this._commandFileWriteParsers) {
+                if (parser.canHandle(commandText)) {
+                    result.push(...parser.extractFileWrites(commandText));
+                }
+            }
+        }
+        return result;
+    }
+    async _queryTree(languageId, commandLine, querySource) {
+        const {
+            tree,
+            query
+        } = 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) {
+            throw ( new BugIndicatingError("Failed to fetch language grammar"));
+        }
+        let tree = this._treeCache.get(languageId, commandLine);
+        if (!tree) {
+            const parser = await this._parser.value;
+            parser.setLanguage(language);
+            const parsedTree = parser.parse(commandLine);
+            if (!parsedTree) {
+                throw ( new ErrorNoTelemetry("Failed to parse tree"));
+            }
+            tree = parsedTree;
+            this._treeCache.set(languageId, commandLine, tree);
+        }
+        const query = await this._treeSitterLibraryService.createQuery(language, querySource);
+        if (!query) {
+            throw ( new BugIndicatingError("Failed to create tree sitter query"));
+        }
+        return {
+            tree,
+            query
+        };
+    }
+};
+TreeSitterCommandParser = ( __decorate([( __param(0, ITreeSitterLibraryService))], TreeSitterCommandParser));
+class TreeCache extends Disposable {
+    constructor() {
+        super();
+        this._cache = ( new Map());
+        this._clearScheduler = this._register(( new MutableDisposable()));
+        this._register(toDisposable(() => this._cache.clear()));
+    }
+    get(languageId, commandLine) {
+        this._resetClearTimer();
+        return this._cache.get(this._getCacheKey(languageId, commandLine));
+    }
+    set(languageId, commandLine, tree) {
+        this._resetClearTimer();
+        this._cache.set(this._getCacheKey(languageId, commandLine), tree);
+    }
+    _getCacheKey(languageId, commandLine) {
+        return `${languageId}:${commandLine}`;
+    }
+    _resetClearTimer() {
+        this._clearScheduler.value = ( new RunOnceScheduler(() => {
+            this._cache.clear();
+        }, 10000));
+        this._clearScheduler.value.schedule();
+    }
+}
+
+export { TreeSitterCommandParser, TreeSitterCommandParserLanguage };

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

@@ -0,0 +1,20 @@
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+/** Setting IDs that affect the engine's sandbox configuration (modern + deprecated). */
+export declare const SANDBOX_SETTING_KEYS: readonly string[];
+/**
+ * Reads a single sandbox-related setting from `IConfigurationService`,
+ * preferring the modern key and falling back to its deprecated peers in
+ * order. Boolean values for `chat.agent.sandbox.enabled` (legacy) are
+ * normalized to the modern `'on' | 'off'` enum. Returns `undefined` when
+ * no user value is configured.
+ */
+export declare function readSandboxSetting<T>(configurationService: IConfigurationService, logService: ILogService, settingId: string): T | undefined;
+/**
+ * Reads the currently-configured sandbox values for forwarding to an agent
+ * host. The returned record is keyed by the prefix-free agent-host sandbox
+ * sub-keys ({@link AgentHostSandboxKey}); keys without a user value are
+ * omitted entirely. Callers should nest this under the agent host's
+ * top-level `sandbox` config key when dispatching a `RootConfigChanged`.
+ */
+export declare function readAgentHostSandboxValues(configurationService: IConfigurationService, logService: ILogService): Record<string, unknown>;

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

@@ -0,0 +1,81 @@
+
+import { AgentNetworkDomainSettingId } from '../../../../../platform/networkFilter/common/settings.js';
+import { AgentSandboxSettingId, AgentSandboxEnabledValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/settings';
+import { sandboxSettingIdToAgentHostKey } from '../../../../../platform/agentHost/common/sandboxConfigSchema.js';
+
+const SANDBOX_SETTING_KEYS = [
+    AgentSandboxSettingId.AgentSandboxEnabled,
+    AgentSandboxSettingId.AgentSandboxWindowsEnabled,
+    AgentSandboxSettingId.AgentSandboxAllowUnsandboxedCommands,
+    AgentSandboxSettingId.AgentSandboxAutoApproveUnsandboxedCommands,
+    AgentSandboxSettingId.AgentSandboxLinuxFileSystem,
+    AgentSandboxSettingId.AgentSandboxMacFileSystem,
+    AgentSandboxSettingId.AgentSandboxWindowsFileSystem,
+    AgentSandboxSettingId.AgentSandboxWindowsSchemaVersion,
+    AgentSandboxSettingId.AgentSandboxAdvancedRuntime,
+    AgentSandboxSettingId.DeprecatedAgentSandboxEnabled,
+    AgentSandboxSettingId.DeprecatedAgentSandboxLinuxFileSystem,
+    AgentSandboxSettingId.DeprecatedAgentSandboxMacFileSystem,
+    AgentNetworkDomainSettingId.AllowedNetworkDomains,
+    AgentNetworkDomainSettingId.DeniedNetworkDomains,
+    AgentNetworkDomainSettingId.DeprecatedSandboxAllowedNetworkDomains,
+    AgentNetworkDomainSettingId.DeprecatedSandboxDeniedNetworkDomains,
+    AgentNetworkDomainSettingId.DeprecatedOldAllowedNetworkDomains,
+    AgentNetworkDomainSettingId.DeprecatedOldDeniedNetworkDomains
+];
+const DEPRECATED_SANDBOX_FALLBACKS = {
+    [AgentSandboxSettingId.AgentSandboxEnabled]: [AgentSandboxSettingId.DeprecatedAgentSandboxEnabled],
+    [AgentSandboxSettingId.AgentSandboxLinuxFileSystem]: [AgentSandboxSettingId.DeprecatedAgentSandboxLinuxFileSystem],
+    [AgentSandboxSettingId.AgentSandboxMacFileSystem]: [AgentSandboxSettingId.DeprecatedAgentSandboxMacFileSystem],
+    [AgentNetworkDomainSettingId.AllowedNetworkDomains]: [
+        AgentNetworkDomainSettingId.DeprecatedSandboxAllowedNetworkDomains,
+        AgentNetworkDomainSettingId.DeprecatedOldAllowedNetworkDomains
+    ],
+    [AgentNetworkDomainSettingId.DeniedNetworkDomains]: [
+        AgentNetworkDomainSettingId.DeprecatedSandboxDeniedNetworkDomains,
+        AgentNetworkDomainSettingId.DeprecatedOldDeniedNetworkDomains
+    ]
+};
+function readSandboxSetting(configurationService, logService, settingId) {
+    const modern = configurationService.inspect(settingId);
+    if (modern.userValue !== undefined) {
+        return normalizeSandboxSettingValue(settingId, modern.value);
+    }
+    const deprecatedFallbacks = DEPRECATED_SANDBOX_FALLBACKS[settingId];
+    if (deprecatedFallbacks?.length) {
+        const userConfiguredKeys = ( configurationService.keys()).user;
+        for (const deprecatedId of deprecatedFallbacks) {
+            const deprecated = configurationService.inspect(deprecatedId);
+            if (deprecated.userValue !== undefined && userConfiguredKeys.includes(deprecatedId)) {
+                logService.warn(
+                    `SandboxSettingsReader: Using deprecated setting ${deprecatedId} because ${settingId} is not set. Please update your settings to use ${settingId} instead.`
+                );
+                return normalizeSandboxSettingValue(settingId, deprecated.value);
+            }
+        }
+    }
+    return normalizeSandboxSettingValue(settingId, modern.value);
+}
+function readAgentHostSandboxValues(configurationService, logService) {
+    const values = {};
+    for (const [settingId, sandboxKey] of Object.entries(sandboxSettingIdToAgentHostKey)) {
+        const value = readSandboxSetting(configurationService, logService, settingId);
+        if (value !== undefined) {
+            values[sandboxKey] = value;
+        }
+    }
+    return values;
+}
+function normalizeSandboxSettingValue(settingId, value) {
+    if (settingId === AgentSandboxSettingId.AgentSandboxEnabled || settingId === AgentSandboxSettingId.DeprecatedAgentSandboxEnabled) {
+        if (value === true) {
+            return AgentSandboxEnabledValue.On;
+        }
+        if (value === false) {
+            return AgentSandboxEnabledValue.Off;
+        }
+    }
+    return value;
+}
+
+export { SANDBOX_SETTING_KEYS, readAgentHostSandboxValues, readSandboxSetting };

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

@@ -0,0 +1,63 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import { 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 { IEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
+import { ISandboxHelperService } from "@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/sandboxHelperService.service";
+import { ISandboxDependencyInstallTerminal, TerminalSandboxPrerequisiteCheck, type ISandboxDependencyInstallOptions, type ISandboxDependencyInstallResult, type ITerminalSandboxCommand, type ITerminalSandboxPrecheckInputs, type ITerminalSandboxPrerequisiteCheckResult, type ITerminalSandboxResolvedNetworkDomains, type ITerminalSandboxWrapResult } from "../../../../../platform/sandbox/common/terminalSandboxService.js";
+import { ITerminalSandboxService } from "@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/terminalSandboxService.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { IRemoteAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service";
+import { ILifecycleService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+export { ITerminalSandboxService, TerminalSandboxPrerequisiteCheck, ISandboxDependencyInstallOptions, ISandboxDependencyInstallResult, ISandboxDependencyInstallTerminal, ITerminalSandboxCommand, ITerminalSandboxPrecheckInputs, ITerminalSandboxPrerequisiteCheckResult, ITerminalSandboxResolvedNetworkDomains, ITerminalSandboxWrapResult };
+export declare class TerminalSandboxService extends Disposable implements ITerminalSandboxService {
+    private readonly _configurationService;
+    private readonly _environmentService;
+    private readonly _logService;
+    private readonly _remoteAgentService;
+    private readonly _workspaceContextService;
+    private readonly _productService;
+    private readonly _sandboxHelperService;
+    private readonly _chatService;
+    readonly _serviceBrand: undefined;
+    private readonly _engine;
+    private readonly _remoteEnvDetailsPromise;
+    private _remoteEnvDetails;
+    private readonly _onDidChangeRoots;
+    constructor(_configurationService: IConfigurationService, fileService: IFileService, _environmentService: IEnvironmentService, _logService: ILogService, _remoteAgentService: IRemoteAgentService, _workspaceContextService: IWorkspaceContextService, _productService: IProductService, lifecycleService: ILifecycleService, _sandboxHelperService: ISandboxHelperService, _chatService: IChatService, instantiationService: IInstantiationService);
+    isEnabled(precheckInputs?: ITerminalSandboxPrecheckInputs): Promise<boolean>;
+    isSandboxAllowNetworkEnabled(precheckInputs?: ITerminalSandboxPrecheckInputs): Promise<boolean>;
+    getOS(): Promise<OperatingSystem>;
+    wrapCommand(command: string, requestUnsandboxedExecution?: boolean, shell?: string, cwd?: URI, commandDetails?: readonly ITerminalSandboxCommand[], requestAllowNetwork?: boolean): Promise<ITerminalSandboxWrapResult>;
+    checkForSandboxingPrereqs(forceRefresh?: boolean, precheckInputs?: ITerminalSandboxPrecheckInputs): Promise<ITerminalSandboxPrerequisiteCheckResult>;
+    getSandboxConfigPath(forceRefresh?: boolean, precheckInputs?: ITerminalSandboxPrecheckInputs): Promise<string | undefined>;
+    getTempDir(): URI | undefined;
+    setNeedsForceUpdateConfigFile(): void;
+    getResolvedNetworkDomains(): ITerminalSandboxResolvedNetworkDomains;
+    getMissingSandboxDependencies(): Promise<string[]>;
+    private _resolveRemoteEnv;
+    private _resolveOS;
+    private _readSandboxSetting;
+    private _resolveRuntimeInfo;
+    private _toWindowsPath;
+    private _resolveUserHome;
+    private _resolveSandboxTempDir;
+    private _resolveWorkspaceStorageReadRoot;
+    private _getSandboxWindowTempDirName;
+    private _resolveSandboxDependencyStatus;
+    private _resolveWindowsMxcFilesystemPolicy;
+    private _resolveWindowsMxcEnvironment;
+    private _resolveWindowsMxcSandboxPayload;
+    installMissingSandboxDependencies(missingDependencies: string[], sessionResource: URI | undefined, token: CancellationToken, options: ISandboxDependencyInstallOptions): Promise<ISandboxDependencyInstallResult>;
+    /**
+     * Shows a chat elicitation that keeps the "Install" flow grounded in chat while
+     * the user focuses the terminal and types a sudo password.
+     */
+    private _createMissingDependencyPasswordPrompt;
+}