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

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

@@ -0,0 +1,22 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ITerminalSandboxService } from "../../common/terminalSandboxService.js";
+import type { IOutputAnalyzer, IOutputAnalyzerOptions } from "./outputAnalyzer.js";
+export declare class SandboxOutputAnalyzer extends Disposable implements IOutputAnalyzer {
+    private readonly _sandboxService;
+    constructor(_sandboxService: ITerminalSandboxService);
+    analyze(options: IOutputAnalyzerOptions): Promise<string | undefined>;
+    /**
+     * Checks whether the command output contains strings that typically indicate
+     * the sandbox blocked the operation. Used when exit code is unavailable.
+     *
+     * The output may contain newlines inserted by terminal wrapping, so we
+     * strip them before testing.
+     */
+    private _outputLooksSandboxBlocked;
+}
+/**
+ * Checks whether the command output contains strings that typically indicate
+ * the sandbox blocked the operation. The output may contain newlines inserted
+ * by terminal wrapping, so we strip them before testing.
+ */
+export declare function outputLooksSandboxBlocked(output: string): boolean;

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

@@ -0,0 +1,43 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+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 '../../common/terminalSandboxService.js';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
+import { AgentNetworkDomainSettingId } from '../../../../../../platform/networkFilter/common/settings.js';
+import { ITerminalSandboxService } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/terminalSandboxService.service';
+
+let SandboxOutputAnalyzer = class SandboxOutputAnalyzer extends Disposable {
+    constructor(_sandboxService) {
+        super();
+        this._sandboxService = _sandboxService;
+    }
+    async analyze(options) {
+        if (!options.isSandboxWrapped) {
+            return undefined;
+        }
+        const knownFailure = options.exitCode !== undefined && options.exitCode !== 0;
+        const suspectedFailure = !knownFailure && options.exitCode === undefined && this._outputLooksSandboxBlocked(options.exitResult);
+        if (!knownFailure && !suspectedFailure) {
+            return undefined;
+        }
+        const os = await this._sandboxService.getOS();
+        const fileSystemSetting = os === OperatingSystem.Linux ? TerminalChatAgentToolsSettingId.AgentSandboxLinuxFileSystem : TerminalChatAgentToolsSettingId.AgentSandboxMacFileSystem;
+        const prefix = knownFailure ? "Command failed while running in sandboxed mode. If the command failed due to sandboxing:" : "Command ran in sandboxed mode and may have been blocked by the sandbox. If the command failed due to sandboxing:";
+        return `${prefix}
+- If it would be reasonable to extend the sandbox rules, work with the user to update allowWrite for file system access problems in ${fileSystemSetting}, or to add required domains to ${AgentNetworkDomainSettingId.AllowedNetworkDomains}.
+- Otherwise, immediately retry the command with requestUnsandboxedExecution=true. Do NOT ask the user — setting this flag automatically shows a confirmation prompt to the user.
+
+Here is the output of the command:\n`;
+    }
+    _outputLooksSandboxBlocked(output) {
+        return outputLooksSandboxBlocked(output);
+    }
+};
+SandboxOutputAnalyzer = ( __decorate([( __param(0, ITerminalSandboxService))], SandboxOutputAnalyzer));
+function outputLooksSandboxBlocked(output) {
+    const normalized = output.replace(/\n/g, " ");
+    return /Operation not permitted|Permission denied|Read-only file system|sandbox-exec|bwrap|sandbox_violation/i.test(normalized);
+}
+
+export { SandboxOutputAnalyzer, outputLooksSandboxBlocked };

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

@@ -0,0 +1,17 @@
+import { IChatTerminalToolInvocationData } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
+import { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import { ITerminalLogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service";
+export declare class TerminalCommandArtifactCollector {
+    private readonly _logService;
+    constructor(_logService: ITerminalLogService);
+    capture(toolSpecificData: IChatTerminalToolInvocationData, instance: ITerminalInstance, commandId: string | undefined): Promise<void>;
+    private _captureCommandOutput;
+    /**
+     * Captures output from a partial/current command that hasn't finished yet.
+     * This is used when the command is cancelled mid-execution.
+     */
+    private _capturePartialCommandOutput;
+    private _applyTheme;
+    private _createTerminalCommandUri;
+    private _tryGetCommand;
+}

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

@@ -0,0 +1,118 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { getCommandOutputSnapshot } from '../../../../terminal/browser/chatTerminalCommandMirror.js';
+import { TerminalCapability } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities';
+import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
+
+let TerminalCommandArtifactCollector = class TerminalCommandArtifactCollector {
+    constructor(_logService) {
+        this._logService = _logService;
+    }
+    async capture(toolSpecificData, instance, commandId) {
+        if (commandId) {
+            try {
+                toolSpecificData.terminalCommandUri = this._createTerminalCommandUri(instance, commandId);
+            } catch (error) {
+                this._logService.warn(
+                    `RunInTerminalTool: Failed to create terminal command URI for ${commandId}`,
+                    error
+                );
+            }
+            const command = await this._tryGetCommand(instance, commandId);
+            if (command) {
+                toolSpecificData.terminalCommandState = {
+                    exitCode: command.exitCode,
+                    timestamp: command.timestamp,
+                    duration: command.duration
+                };
+                const snapshot = await this._captureCommandOutput(instance, command);
+                if (snapshot) {
+                    toolSpecificData.terminalCommandOutput = snapshot;
+                }
+                this._applyTheme(toolSpecificData, instance);
+                return;
+            }
+            const partialSnapshot = await this._capturePartialCommandOutput(instance, commandId);
+            if (partialSnapshot) {
+                toolSpecificData.terminalCommandOutput = partialSnapshot;
+                this._logService.debug(`RunInTerminalTool: Captured partial command output for ${commandId}`);
+            }
+        }
+        this._applyTheme(toolSpecificData, instance);
+    }
+    async _captureCommandOutput(instance, command) {
+        try {
+            await instance.xtermReadyPromise;
+        } catch {
+            return undefined;
+        }
+        const xterm = instance.xterm;
+        if (!xterm) {
+            return undefined;
+        }
+        return getCommandOutputSnapshot(xterm, command, (reason, error) => {
+            const suffix = reason === "fallback" ? " (fallback)" : "";
+            this._logService.debug(`RunInTerminalTool: Failed to snapshot command output${suffix}`, error);
+        });
+    }
+    async _capturePartialCommandOutput(instance, commandId) {
+        try {
+            await instance.xtermReadyPromise;
+        } catch {
+            return undefined;
+        }
+        const xterm = instance.xterm;
+        if (!xterm) {
+            return undefined;
+        }
+        const commandDetection = instance.capabilities.get(TerminalCapability.CommandDetection);
+        const currentCommand = commandDetection?.currentCommand;
+        if (currentCommand && currentCommand.id === commandId) {
+            const executedMarker = currentCommand.commandExecutedMarker;
+            if (executedMarker && !executedMarker.isDisposed) {
+                try {
+                    const raw = xterm.raw;
+                    const buffer = raw.buffer.active;
+                    const endLine = buffer.baseY + buffer.cursorY;
+                    const startLine = executedMarker.line;
+                    const lineCount = Math.max(endLine - startLine, 0);
+                    if (lineCount > 0) {
+                        const text = await xterm.getRangeAsVT(executedMarker, undefined, true);
+                        if (text) {
+                            return {
+                                text,
+                                lineCount
+                            };
+                        }
+                    }
+                } catch (error) {
+                    this._logService.debug(`RunInTerminalTool: Failed to capture partial command output`, error);
+                }
+            }
+        }
+        return undefined;
+    }
+    _applyTheme(toolSpecificData, instance) {
+        const theme = instance.xterm?.getXtermTheme();
+        if (theme) {
+            toolSpecificData.terminalTheme = {
+                background: theme.background,
+                foreground: theme.foreground
+            };
+        }
+    }
+    _createTerminalCommandUri(instance, commandId) {
+        const params = ( new URLSearchParams(instance.resource.query));
+        params.set("command", commandId);
+        return instance.resource.with({
+            query: ( params.toString())
+        });
+    }
+    async _tryGetCommand(instance, commandId) {
+        const commandDetection = instance.capabilities.get(TerminalCapability.CommandDetection);
+        return commandDetection?.commands.find(c => c.id === commandId);
+    }
+};
+TerminalCommandArtifactCollector = ( __decorate([( __param(0, ITerminalLogService))], TerminalCommandArtifactCollector));
+
+export { TerminalCommandArtifactCollector };

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

@@ -0,0 +1,22 @@
+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 { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+/**
+ * Returns true if the chat session's permission level (Autopilot/Bypass Approvals)
+ * auto-approves all tool calls, unless enterprise policy restricts it.
+ * Checks both the request-stamped level and the live picker level.
+ */
+export declare function isSessionAutoApproveLevel(chatSessionResource: URI, configurationService: IConfigurationService, chatWidgetService: IChatWidgetService, chatService: IChatService): boolean;
+/**
+ * Checks whether a terminal tool is eligible for auto-approval based on user configuration.
+ * @param toolReferenceName The tool's reference name (e.g. 'runInTerminal', 'sendToTerminal').
+ * @param legacyToolReferenceFullNames Legacy names to check for backward compatibility.
+ */
+export declare function isToolEligibleForTerminalAutoApproval(toolReferenceName: string, configurationService: IConfigurationService, legacyToolReferenceFullNames?: string[]): boolean;
+/**
+ * Determines whether terminal auto-approve rules are allowed to take effect.
+ * This checks the setting enablement, the opt-in warning acceptance, and the per-tool eligibility.
+ */
+export declare function isTerminalAutoApproveAllowed(toolReferenceName: string, configurationService: IConfigurationService, storageService: IStorageService, legacyToolReferenceFullNames?: string[]): boolean;

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

@@ -0,0 +1,44 @@
+
+import { StorageScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { TerminalToolConfirmationStorageKeys } from '../../../../chat/browser/widget/chatContentParts/toolInvocationParts/chatTerminalToolConfirmationSubPart.js';
+import { ChatConfiguration, isAutoApproveLevel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
+
+function isSessionAutoApproveLevel(chatSessionResource, configurationService, chatWidgetService, chatService) {
+    const inspected = configurationService.inspect(ChatConfiguration.GlobalAutoApprove);
+    if (inspected.policyValue === false) {
+        return false;
+    }
+    const widget = chatWidgetService.getWidgetBySessionResource(chatSessionResource)
+        ?? chatWidgetService.lastFocusedWidget;
+    if (widget && isAutoApproveLevel(widget.input.currentModeInfo.permissionLevel)) {
+        return true;
+    }
+    const model = chatService.getSession(chatSessionResource);
+    const request = model?.getRequests().at(-1);
+    return isAutoApproveLevel(request?.modeInfo?.permissionLevel);
+}
+function isToolEligibleForTerminalAutoApproval(toolReferenceName, configurationService, legacyToolReferenceFullNames) {
+    const config = configurationService.getValue(ChatConfiguration.EligibleForAutoApproval);
+    if (config && typeof config === 'object') {
+        if (Object.prototype.hasOwnProperty.call(config, toolReferenceName)) {
+            return config[toolReferenceName];
+        }
+        if (legacyToolReferenceFullNames) {
+            for (const legacyName of legacyToolReferenceFullNames) {
+                if (Object.prototype.hasOwnProperty.call(config, legacyName)) {
+                    return config[legacyName];
+                }
+            }
+        }
+    }
+    return true;
+}
+function isTerminalAutoApproveAllowed(toolReferenceName, configurationService, storageService, legacyToolReferenceFullNames) {
+    const isEligible = isToolEligibleForTerminalAutoApproval(toolReferenceName, configurationService, legacyToolReferenceFullNames);
+    const isAutoApproveEnabled = configurationService.getValue(TerminalChatAgentToolsSettingId.EnableAutoApprove) === true;
+    const isAutoApproveWarningAccepted = storageService.getBoolean(TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted, StorageScope.APPLICATION, false);
+    return isEligible && isAutoApproveEnabled && isAutoApproveWarningAccepted;
+}
+
+export { isSessionAutoApproveLevel, isTerminalAutoApproveAllowed, isToolEligibleForTerminalAutoApproval };

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

@@ -0,0 +1 @@
+export { TerminalToolId } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/terminalToolIds";

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

@@ -0,0 +1,25 @@
+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";
+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[]>;
+    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;
+    private _doQuery;
+}

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

@@ -0,0 +1,141 @@
+
+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 { 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 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);
+    }
+    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/terminalSandboxService.d.ts

@@ -0,0 +1,85 @@
+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 { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IRemoteAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
+import { ILifecycleService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+import { ISandboxHelperService } from "@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/sandboxHelperService.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { TerminalSandboxPrerequisiteCheck, type ISandboxDependencyInstallOptions, type ISandboxDependencyInstallResult, 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";
+export { ITerminalSandboxService, TerminalSandboxPrerequisiteCheck };
+export type { ISandboxDependencyInstallOptions, ISandboxDependencyInstallResult, ISandboxDependencyInstallTerminal, ITerminalSandboxPrerequisiteCheckResult, ITerminalSandboxResolvedNetworkDomains, ITerminalSandboxWrapResult } from "../../../../../platform/sandbox/common/terminalSandboxService.js";
+export declare class TerminalSandboxService extends Disposable implements ITerminalSandboxService {
+    private readonly _configurationService;
+    private readonly _fileService;
+    private readonly _environmentService;
+    private readonly _logService;
+    private readonly _remoteAgentService;
+    private readonly _workspaceContextService;
+    private readonly _productService;
+    private readonly _lifecycleService;
+    private readonly _sandboxHelperService;
+    private readonly _chatService;
+    readonly _serviceBrand: undefined;
+    private _srtPath;
+    private _rgPath;
+    private _srtPathResolved;
+    private _execPath?;
+    private _sandboxConfigPath;
+    private _sandboxDependencyStatus;
+    private _needsForceUpdateConfigFile;
+    private _tempDir;
+    private _sandboxSettingsId;
+    private _remoteEnvDetailsPromise;
+    private _remoteEnvDetails;
+    private _appRoot;
+    private _os;
+    private _defaultWritePaths;
+    private static readonly _sandboxTempDirName;
+    private static readonly _urlRegex;
+    private static readonly _sshRemoteRegex;
+    private static readonly _hostRegex;
+    constructor(_configurationService: IConfigurationService, _fileService: IFileService, _environmentService: IEnvironmentService, _logService: ILogService, _remoteAgentService: IRemoteAgentService, _workspaceContextService: IWorkspaceContextService, _productService: IProductService, _lifecycleService: ILifecycleService, _sandboxHelperService: ISandboxHelperService, _chatService: IChatService);
+    isEnabled(): Promise<boolean>;
+    getOS(): Promise<OperatingSystem>;
+    wrapCommand(command: string, requestUnsandboxedExecution?: boolean, shell?: string): ITerminalSandboxWrapResult;
+    getTempDir(): URI | undefined;
+    setNeedsForceUpdateConfigFile(): void;
+    checkForSandboxingPrereqs(forceRefresh?: boolean): Promise<ITerminalSandboxPrerequisiteCheckResult>;
+    getSandboxConfigPath(forceRefresh?: boolean): Promise<string | undefined>;
+    private _checkSandboxDependencies;
+    getMissingSandboxDependencies(): Promise<string[]>;
+    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;
+    private _quoteShellArgument;
+    private _wrapUnsandboxedCommand;
+    private _getBlockedDomains;
+    private _extractDomains;
+    private _extractDomainFromUrl;
+    private _isSandboxConfiguredEnabled;
+    private _resolveSrtPath;
+    private _createSandboxConfig;
+    private _mergeAdditionalSandboxConfigProperties;
+    private _isObjectForSandboxConfigMerge;
+    private _pathJoin;
+    private _initTempDir;
+    private _cleanupSandboxTempDir;
+    private _getSandboxTempDirPath;
+    private _getSandboxWindowTempDirName;
+    getResolvedNetworkDomains(): ITerminalSandboxResolvedNetworkDomains;
+    private _updateAllowWritePathsWithWorkspaceFolders;
+    private _resolveSandboxDependencyStatus;
+    private _isSandboxEnabled;
+    private _getSettingValue;
+}