@codingame/monaco-vscode-chat-service-override 30.0.0 → 31.0.0

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

@@ -1,22 +0,0 @@
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { ITerminalSandboxService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxService.service";
-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

@@ -1,41 +0,0 @@
-
-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 { ITerminalSandboxService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxService.service';
-import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
-
-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 ${TerminalChatAgentToolsSettingId.AgentSandboxNetworkAllowedDomains}.
-- 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

@@ -1,17 +0,0 @@
-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

@@ -1,118 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { getCommandOutputSnapshot } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/terminal/browser/chatTerminalCommandMirror';
-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/toolIds.d.ts

@@ -1,12 +0,0 @@
-export declare enum TerminalToolId {
-    RunInTerminal = "run_in_terminal",
-    AwaitTerminal = "await_terminal",
-    GetTerminalOutput = "get_terminal_output",
-    KillTerminal = "kill_terminal",
-    TerminalSelection = "terminal_selection",
-    TerminalLastCommand = "terminal_last_command",
-    ConfirmTerminalCommand = "vscode_get_terminal_confirmation",
-    CreateAndRunTask = "create_and_run_task",
-    GetTaskOutput = "get_task_output",
-    RunTask = "run_task"
-}

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

@@ -1,17 +0,0 @@
-
-
-var TerminalToolId;
-(function (TerminalToolId) {
-    TerminalToolId["RunInTerminal"] = "run_in_terminal";
-    TerminalToolId["AwaitTerminal"] = "await_terminal";
-    TerminalToolId["GetTerminalOutput"] = "get_terminal_output";
-    TerminalToolId["KillTerminal"] = "kill_terminal";
-    TerminalToolId["TerminalSelection"] = "terminal_selection";
-    TerminalToolId["TerminalLastCommand"] = "terminal_last_command";
-    TerminalToolId["ConfirmTerminalCommand"] = "vscode_get_terminal_confirmation";
-    TerminalToolId["CreateAndRunTask"] = "create_and_run_task";
-    TerminalToolId["GetTaskOutput"] = "get_task_output";
-    TerminalToolId["RunTask"] = "run_task";
-})(TerminalToolId || (TerminalToolId = {}));
-
-export { TerminalToolId };

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

@@ -1,25 +0,0 @@
-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

@@ -1,130 +0,0 @@
-
-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 = {}));
-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) {
-        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

@@ -1,122 +0,0 @@
-import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
-import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
-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 { TerminalCapability } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities";
-import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
-import { ITerminalSandboxService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxService.service";
-export interface ITerminalSandboxResolvedNetworkDomains {
-    allowedDomains: string[];
-    deniedDomains: string[];
-}
-export declare enum TerminalSandboxPrerequisiteCheck {
-    Config = "config",
-    Dependencies = "dependencies"
-}
-export interface ITerminalSandboxPrerequisiteCheckResult {
-    enabled: boolean;
-    sandboxConfigPath: string | undefined;
-    failedCheck: TerminalSandboxPrerequisiteCheck | undefined;
-    missingDependencies?: string[];
-}
-/**
- * Abstraction over terminal operations needed by the install flow.
- * Provided by the browser-layer caller so the common-layer service
- * does not import browser types directly.
- */
-export interface ISandboxDependencyInstallTerminal {
-    sendText(text: string, addNewLine?: boolean): Promise<void>;
-    focus(): void;
-    capabilities: {
-        get(id: TerminalCapability.CommandDetection): {
-            onCommandFinished: Event<{
-                exitCode: number | undefined;
-            }>;
-        } | undefined;
-        onDidAddCapability: Event<{
-            id: TerminalCapability;
-        }>;
-    };
-    onDidInputData: Event<string>;
-    onDisposed: Event<unknown>;
-}
-export interface ISandboxDependencyInstallOptions {
-    /**
-     * Creates or obtains a terminal for running the install command.
-     */
-    createTerminal(): Promise<ISandboxDependencyInstallTerminal>;
-    /**
-     * Focuses the terminal for password entry.
-     */
-    focusTerminal(terminal: ISandboxDependencyInstallTerminal): Promise<void>;
-}
-export interface ISandboxDependencyInstallResult {
-    exitCode: number | undefined;
-}
-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;
-    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): string;
-    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 _isSandboxConfiguredEnabled;
-    private _resolveSrtPath;
-    private _createSandboxConfig;
-    private _pathJoin;
-    private _initTempDir;
-    private _cleanupSandboxTempDir;
-    private _getSandboxTempDirPath;
-    private _getSandboxWindowTempDirName;
-    getResolvedNetworkDomains(): ITerminalSandboxResolvedNetworkDomains;
-    private _updateAllowWritePathsWithWorkspaceFolders;
-    private _resolveSandboxDependencyStatus;
-    private _getSettingValue;
-}