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

package/vscode/src/vs/platform/sandbox/common/terminalSandboxEngine.js

@@ -0,0 +1,784 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+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 { win32, posix } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import { OS, OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { arch } from '@codingame/monaco-vscode-api/vscode/vs/base/common/process';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+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 { matchesDomainPattern, normalizeDomain } from '../../networkFilter/common/domainMatcher.js';
+import { AgentNetworkDomainSettingId } from '../../networkFilter/common/settings.js';
+import { AgentSandboxSettingId, AgentSandboxEnabledValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/settings';
+import { IWindowsMxcTerminalSandboxRuntime } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/terminalSandboxMxcRuntime.service';
+import { getTerminalSandboxReadAllowListForCommands } from './terminalSandboxReadAllowList.js';
+import { getTerminalSandboxRuntimeConfigurationForCommands } from './terminalSandboxRuntimeConfigurationPerOperation.js';
+import { TerminalSandboxPrerequisiteCheck } from './terminalSandboxService.js';
+
+var TerminalSandboxEngine_1;
+let TerminalSandboxEngine = class TerminalSandboxEngine extends Disposable {
+    static {
+        TerminalSandboxEngine_1 = this;
+    }
+    static {
+        this._urlRegex = /(?:https?|wss?):\/\/[^\s'"`|&;<>]+/gi;
+    }
+    static {
+        this._sshRemoteRegex = /(?:^|[\s'"`])(?:[^\s@:'"`]+@)?([a-zA-Z0-9.-]+\.[a-zA-Z]{2,})(?::[^\s'"`|&;<>]+)(?=$|[\s'"`|&;<>])/gi;
+    }
+    static {
+        this._hostRegex = /(?:^|[\s'"`(=])([a-zA-Z0-9.-]+\.[a-zA-Z]{2,})(?::\d+)?(?=(?:\/[^\s'"`|&;<>]*)?(?:$|[\s'"`)\]|,;|&<>]))/gi;
+    }
+    constructor(_host, _fileService, _logService, _windowsMxcRuntime) {
+        super();
+        this._host = _host;
+        this._fileService = _fileService;
+        this._logService = _logService;
+        this._windowsMxcRuntime = _windowsMxcRuntime;
+        this._sandboxSettingsId = generateUuid();
+        this._runtimeResolved = false;
+        this._runAsNode = false;
+        this._needsForceUpdateConfigFile = true;
+        this._commandAllowListKeywords = [];
+        this._commandAllowListCommandDetails = [];
+        this._commandAllowNetwork = false;
+        this._os = OS;
+        this._defaultWritePaths = [];
+        this._buildSandboxPayload = (commandLine, policy, workingDirectory, containerName, containment) => {
+            return this._host.buildWindowsMxcSandboxPayload(commandLine, policy, workingDirectory, containerName, containment);
+        };
+        this._pathJoin = (...segments) => {
+            const path = this._os === OperatingSystem.Windows ? win32 : posix;
+            return path.join(...segments);
+        };
+        this._register(Event.runAndSubscribe(this._host.onDidChangeSandboxSettings, () => {
+            this.setNeedsForceUpdateConfigFile();
+        }));
+        this._register(this._host.onDidChangeRoots(() => this.setNeedsForceUpdateConfigFile()));
+    }
+    async isEnabled(precheckInputs) {
+        return this._isSandboxConfiguredEnabled(precheckInputs);
+    }
+    async isSandboxAllowNetworkEnabled(precheckInputs) {
+        if (!(await this._isSandboxConfiguredEnabled(precheckInputs))) {
+            return false;
+        }
+        return this._isSandboxAllowNetworkConfigured();
+    }
+    areUnsandboxedCommandsAllowed() {
+        return this._areUnsandboxedCommandsAllowed();
+    }
+    areRetryWithAllowNetworkRequestsAllowed() {
+        return this._areRetryWithAllowNetworkRequestsAllowed();
+    }
+    isAutoApproveUnsandboxedCommands() {
+        return this._areUnsandboxedCommandsAllowed() && this._getSettingValue(AgentSandboxSettingId.AgentSandboxAutoApproveUnsandboxedCommands) === true;
+    }
+    async getOS() {
+        this._os = await this._host.getOS();
+        return this._os;
+    }
+    getTempDir() {
+        return this._tempDir;
+    }
+    setNeedsForceUpdateConfigFile() {
+        this._needsForceUpdateConfigFile = true;
+    }
+    getResolvedNetworkDomains() {
+        const allowedDomains = this._getSettingValue(AgentNetworkDomainSettingId.AllowedNetworkDomains) ?? [];
+        const deniedDomains = this._getSettingValue(AgentNetworkDomainSettingId.DeniedNetworkDomains) ?? [];
+        return {
+            allowedDomains,
+            deniedDomains
+        };
+    }
+    async wrapCommand(
+        command,
+        requestUnsandboxedExecution,
+        shell,
+        cwd,
+        commandDetails,
+        requestAllowNetwork
+    ) {
+        const allowUnsandboxedCommands = this._areUnsandboxedCommandsAllowed();
+        const retryWithAllowNetworkRequests = this._areRetryWithAllowNetworkRequestsAllowed();
+        const shouldInspectBlockedDomains = requestUnsandboxedExecution !== true && requestAllowNetwork !== true && (retryWithAllowNetworkRequests || allowUnsandboxedCommands);
+        const blockedDomainResult = shouldInspectBlockedDomains ? this._getBlockedDomains(command) : {
+            blockedDomains: [],
+            deniedDomains: []
+        };
+        const requiresPreflightAllowNetwork = retryWithAllowNetworkRequests && blockedDomainResult.blockedDomains.length > 0;
+        const allowNetworkForCommand = requestUnsandboxedExecution !== true && ((requestAllowNetwork === true && retryWithAllowNetworkRequests) || requiresPreflightAllowNetwork);
+        const normalizedCommandDetails = this._normalizeCommandDetails(commandDetails ?? []);
+        const normalizedCommandKeywords = this._normalizeCommandKeywords(( normalizedCommandDetails.map(c => c.keyword)));
+        const currentReadAllowListPaths = getTerminalSandboxReadAllowListForCommands(
+            this._os,
+            this._commandAllowListKeywords,
+            this._commandAllowListCommandDetails
+        );
+        const nextReadAllowListPaths = getTerminalSandboxReadAllowListForCommands(this._os, normalizedCommandKeywords, normalizedCommandDetails);
+        const currentRuntimeConfiguration = getTerminalSandboxRuntimeConfigurationForCommands(this._os, this._commandAllowListCommandDetails);
+        const nextRuntimeConfiguration = getTerminalSandboxRuntimeConfigurationForCommands(this._os, normalizedCommandDetails);
+        const shouldRefreshConfig = this._commandAllowListKeywords.length === 0 || this._needsForceUpdateConfigFile || !this._areStringArraysEqual(this._commandAllowListKeywords, normalizedCommandKeywords) || !this._areStringArraysEqual(currentReadAllowListPaths, nextReadAllowListPaths) || !this._areObjectsEqual(currentRuntimeConfiguration, nextRuntimeConfiguration) || this._commandCwd?.toString() !== cwd?.toString() || this._commandAllowNetwork !== allowNetworkForCommand || (this._os === OperatingSystem.Windows && (this._commandLine !== command || this._commandShell !== shell));
+        if (shouldRefreshConfig) {
+            this._commandAllowListKeywords = normalizedCommandKeywords;
+            this._commandAllowListCommandDetails = normalizedCommandDetails;
+            this._commandCwd = cwd;
+            this._commandLine = command;
+            this._commandShell = shell;
+            this._commandAllowNetwork = allowNetworkForCommand;
+            await this.getSandboxConfigPath(true);
+        }
+        if (!this._sandboxConfigPath || !this._tempDir) {
+            throw ( new Error("Sandbox config path or temp dir not initialized"));
+        }
+        if (!requestUnsandboxedExecution && !retryWithAllowNetworkRequests && allowUnsandboxedCommands && blockedDomainResult.blockedDomains.length > 0) {
+            return {
+                command: this._wrapUnsandboxedCommand(command, shell),
+                isSandboxWrapped: false,
+                blockedDomains: blockedDomainResult.blockedDomains,
+                deniedDomains: blockedDomainResult.deniedDomains,
+                requiresUnsandboxConfirmation: true
+            };
+        }
+        if (requestUnsandboxedExecution && allowUnsandboxedCommands) {
+            return {
+                command: this._wrapUnsandboxedCommand(command, shell),
+                isSandboxWrapped: false
+            };
+        }
+        const allowNetworkConfirmationMetadata = requiresPreflightAllowNetwork ? {
+            blockedDomains: blockedDomainResult.blockedDomains,
+            deniedDomains: blockedDomainResult.deniedDomains
+        } : undefined;
+        if (this._os === OperatingSystem.Windows) {
+            if (!this._mxcPath) {
+                throw ( new Error("MXC executable path not resolved"));
+            }
+            return {
+                command: this._windowsMxcRuntime.wrapCommand(this._mxcPath, this._sandboxConfigPath),
+                isSandboxWrapped: true,
+                requiresAllowNetworkConfirmation: allowNetworkForCommand && !this._isSandboxAllowNetworkConfigured() ? true : undefined,
+                ...allowNetworkConfirmationMetadata
+            };
+        }
+        if (!this._execPath) {
+            throw ( new Error("Executable path not set to run sandbox commands"));
+        }
+        if (!this._srtPath) {
+            throw ( new Error("Sandbox runtime path not resolved"));
+        }
+        if (!this._rgPath) {
+            throw ( new Error("Ripgrep path not resolved"));
+        }
+        const commandToRunInSandbox = this._getSandboxCommandWithPreservedCwd(command, cwd);
+        const sandboxRuntimeCommand = `PATH="$PATH:${this._pathDirname(this._rgPath)}" TMPDIR="${this._tempDir.path}" CLAUDE_TMPDIR="${this._tempDir.path}" "${this._execPath}" "${this._srtPath}" --settings "${this._sandboxConfigPath}" -c ${this._quoteShellArgument(commandToRunInSandbox)}`;
+        if (this._runAsNode) {
+            const nodeSandboxRuntimeCommand = `ELECTRON_RUN_AS_NODE=1 ${sandboxRuntimeCommand}`;
+            return {
+                command: this._wrapSandboxRuntimeCommandForLaunch(nodeSandboxRuntimeCommand, cwd),
+                isSandboxWrapped: true,
+                requiresAllowNetworkConfirmation: allowNetworkForCommand && !this._isSandboxAllowNetworkConfigured() ? true : undefined,
+                ...allowNetworkConfirmationMetadata
+            };
+        }
+        return {
+            command: this._wrapSandboxRuntimeCommandForLaunch(sandboxRuntimeCommand, cwd),
+            isSandboxWrapped: true,
+            requiresAllowNetworkConfirmation: allowNetworkForCommand && !this._isSandboxAllowNetworkConfigured() ? true : undefined,
+            ...allowNetworkConfirmationMetadata
+        };
+    }
+    async checkForSandboxingPrereqs(forceRefresh = false, precheckInputs) {
+        if (!(await this._isSandboxConfiguredEnabled(precheckInputs))) {
+            return {
+                enabled: false,
+                sandboxConfigPath: undefined,
+                failedCheck: undefined
+            };
+        }
+        const sandboxConfigPath = await this.getSandboxConfigPath(forceRefresh, precheckInputs);
+        if (!sandboxConfigPath) {
+            return {
+                enabled: true,
+                sandboxConfigPath,
+                failedCheck: TerminalSandboxPrerequisiteCheck.Config
+            };
+        }
+        if (!(await this._checkSandboxDependencies(forceRefresh))) {
+            return {
+                enabled: true,
+                sandboxConfigPath,
+                failedCheck: TerminalSandboxPrerequisiteCheck.Dependencies,
+                missingDependencies: await this.getMissingSandboxDependencies()
+            };
+        }
+        return {
+            enabled: true,
+            sandboxConfigPath,
+            failedCheck: undefined
+        };
+    }
+    async getSandboxConfigPath(forceRefresh = false, precheckInputs) {
+        if (!(await this._isSandboxConfiguredEnabled(precheckInputs))) {
+            return undefined;
+        }
+        await this._resolveRuntimeInfo();
+        if (!this._sandboxConfigPath || forceRefresh || this._needsForceUpdateConfigFile) {
+            this._sandboxConfigPath = await this._createSandboxConfig();
+            this._needsForceUpdateConfigFile = false;
+        }
+        return this._sandboxConfigPath;
+    }
+    async getMissingSandboxDependencies() {
+        const os = await this.getOS();
+        if (os === OperatingSystem.Windows) {
+            return [];
+        }
+        if (!this._sandboxDependencyStatus || !this._sandboxDependencyStatus.bubblewrapInstalled || !this._sandboxDependencyStatus.socatInstalled) {
+            this._sandboxDependencyStatus = await this._host.checkSandboxDependencies();
+        }
+        const missing = [];
+        if (this._sandboxDependencyStatus && !this._sandboxDependencyStatus.bubblewrapInstalled) {
+            missing.push("bubblewrap");
+        }
+        if (this._sandboxDependencyStatus && !this._sandboxDependencyStatus.socatInstalled) {
+            missing.push("socat");
+        }
+        return missing;
+    }
+    async cleanupTempDir() {
+        if (!this._tempDir) {
+            return;
+        }
+        try {
+            await this._fileService.del(this._tempDir, {
+                recursive: true,
+                useTrash: false
+            });
+        } catch (error) {
+            this._logService.warn("TerminalSandboxEngine: Failed to delete sandbox temp dir", error);
+        }
+    }
+    async _checkSandboxDependencies(forceRefresh = false) {
+        const os = await this.getOS();
+        if (os === OperatingSystem.Windows) {
+            return true;
+        }
+        if (!forceRefresh && this._sandboxDependencyStatus) {
+            return this._sandboxDependencyStatus.bubblewrapInstalled && this._sandboxDependencyStatus.socatInstalled;
+        }
+        const status = await this._host.checkSandboxDependencies();
+        this._sandboxDependencyStatus = status;
+        if (status && !status.bubblewrapInstalled) {
+            this._logService.warn("TerminalSandboxEngine: bubblewrap (bwrap) is not installed");
+        }
+        if (status && !status.socatInstalled) {
+            this._logService.warn("TerminalSandboxEngine: socat is not installed");
+        }
+        return status ? status.bubblewrapInstalled && status.socatInstalled : true;
+    }
+    _quoteShellArgument(value) {
+        return `'${value.replace(/'/g, `'\\''`)}'`;
+    }
+    _getSandboxCommandWithPreservedCwd(command, cwd) {
+        if (this._os !== OperatingSystem.Linux || !cwd?.path || cwd.path === this._tempDir?.path) {
+            return command;
+        }
+        return `cd ${this._quoteShellArgument(cwd.path)} && ${command}`;
+    }
+    _wrapSandboxRuntimeCommandForLaunch(sandboxRuntimeCommand, cwd) {
+        const tempDirPath = this._tempDir?.path;
+        return this._os === OperatingSystem.Linux && cwd?.path && tempDirPath && cwd.path !== tempDirPath ? `cd ${this._quoteShellArgument(tempDirPath)}; ${sandboxRuntimeCommand}` : sandboxRuntimeCommand;
+    }
+    _wrapUnsandboxedCommand(command, shell) {
+        if (this._os === OperatingSystem.Windows) {
+            return this._windowsMxcRuntime.wrapUnsandboxedCommand(command);
+        }
+        if (!this._tempDir?.path) {
+            return command;
+        }
+        if (!shell) {
+            return `(TMPDIR="${this._tempDir.path}"; export TMPDIR; ${command})`;
+        }
+        return `env TMPDIR="${this._tempDir.path}" ${this._quoteShellArgument(shell)} -c ${this._quoteShellArgument(command)}`;
+    }
+    _getBlockedDomains(command) {
+        if (this._isSandboxAllowNetworkConfigured()) {
+            return {
+                blockedDomains: [],
+                deniedDomains: []
+            };
+        }
+        const domains = this._extractDomains(command);
+        if (domains.length === 0) {
+            return {
+                blockedDomains: [],
+                deniedDomains: []
+            };
+        }
+        const {
+            allowedDomains,
+            deniedDomains
+        } = this.getResolvedNetworkDomains();
+        const blockedDomains = ( new Set());
+        const explicitlyDeniedDomains = ( new Set());
+        for (const domain of domains) {
+            if (( deniedDomains.some(pattern => matchesDomainPattern(domain, pattern)))) {
+                blockedDomains.add(domain);
+                explicitlyDeniedDomains.add(domain);
+                continue;
+            }
+            if (!( allowedDomains.some(pattern => matchesDomainPattern(domain, pattern)))) {
+                blockedDomains.add(domain);
+            }
+        }
+        return {
+            blockedDomains: [...blockedDomains],
+            deniedDomains: [...explicitlyDeniedDomains]
+        };
+    }
+    _extractDomains(command) {
+        const domains = ( new Set());
+        let match;
+        TerminalSandboxEngine_1._urlRegex.lastIndex = 0;
+        while ((match = TerminalSandboxEngine_1._urlRegex.exec(command)) !== null) {
+            const domain = this._extractDomainFromUrl(match[0]);
+            if (domain) {
+                domains.add(domain);
+            }
+        }
+        TerminalSandboxEngine_1._sshRemoteRegex.lastIndex = 0;
+        while ((match = TerminalSandboxEngine_1._sshRemoteRegex.exec(command)) !== null) {
+            const domain = normalizeDomain(match[1], true);
+            if (domain) {
+                domains.add(domain);
+            }
+        }
+        TerminalSandboxEngine_1._hostRegex.lastIndex = 0;
+        while ((match = TerminalSandboxEngine_1._hostRegex.exec(command)) !== null) {
+            const domain = normalizeDomain(match[1]);
+            if (domain) {
+                domains.add(domain);
+            }
+        }
+        return [...domains];
+    }
+    _extractDomainFromUrl(value) {
+        try {
+            const authority = ( URI.parse(value)).authority;
+            return normalizeDomain(authority, true);
+        } catch {
+            return undefined;
+        }
+    }
+    _normalizeCommandKeywords(commandKeywords) {
+        return [...( new Set(( commandKeywords.map(keyword => keyword.toLowerCase()))))].sort();
+    }
+    _normalizeCommandDetails(commandDetails) {
+        const seen = ( new Set());
+        const result = [];
+        for (const command of commandDetails) {
+            const normalizedCommand = {
+                keyword: command.keyword.toLowerCase(),
+                args: [...command.args]
+            };
+            const key = JSON.stringify(normalizedCommand);
+            if (!( seen.has(key))) {
+                seen.add(key);
+                result.push(normalizedCommand);
+            }
+        }
+        return result.sort(
+            (a, b) => a.keyword.localeCompare(b.keyword) || a.args.join("\u0000").localeCompare(b.args.join("\u0000"))
+        );
+    }
+    _areStringArraysEqual(a, b) {
+        return a.length === b.length && a.every((keyword, index) => keyword === b[index]);
+    }
+    _areObjectsEqual(a, b) {
+        return JSON.stringify(a) === JSON.stringify(b);
+    }
+    _isSandboxAllowedByPrecheckInputs(precheckInputs) {
+        return precheckInputs?.isDefaultApprovalPermissionEnabled !== false;
+    }
+    async _isSandboxConfiguredEnabled(precheckInputs) {
+        if (!this._isSandboxAllowedByPrecheckInputs(precheckInputs)) {
+            return false;
+        }
+        await this.getOS();
+        if (this._os === OperatingSystem.Windows) {
+            return this._getSandboxConfiguredWindowsEnabledValue() === AgentSandboxEnabledValue.AllowNetwork;
+        }
+        const value = this._getSandboxConfiguredEnabledValue();
+        return value === AgentSandboxEnabledValue.On || value === AgentSandboxEnabledValue.AllowNetwork;
+    }
+    async _resolveRuntimeInfo() {
+        if (this._runtimeResolved) {
+            return;
+        }
+        this._runtimeResolved = true;
+        const runtimeInfo = await this._host.getRuntimeInfo();
+        this._appRoot = runtimeInfo.appRoot;
+        this._execPath = runtimeInfo.execPath;
+        this._runAsNode = runtimeInfo.runAsNode ?? false;
+        this._userHome = await this._host.getUserHome();
+        this._srtPath = this._pathJoin(
+            this._appRoot,
+            "node_modules",
+            "@vscode",
+            "sandbox-runtime",
+            "dist",
+            "cli.js"
+        );
+        const rgPlatform = this._os === OperatingSystem.Windows ? "win32" : this._os === OperatingSystem.Macintosh ? "darwin" : "linux";
+        const rgBinary = this._os === OperatingSystem.Windows ? "rg.exe" : "rg";
+        this._rgPath = this._pathJoin(
+            this._appRoot,
+            "node_modules",
+            "@vscode",
+            "ripgrep-universal",
+            "bin",
+            `${rgPlatform}-${arch}`,
+            rgBinary
+        );
+        this._mxcPath = this._windowsMxcRuntime.getExecutablePath(this._appRoot, runtimeInfo.arch);
+    }
+    async _createSandboxConfig() {
+        if ((await this.isEnabled()) && !this._tempDir) {
+            await this._initTempDir();
+        }
+        if (!this._tempDir) {
+            return undefined;
+        }
+        const allowNetwork = this._commandAllowNetwork || (await this.isSandboxAllowNetworkEnabled());
+        const linuxFileSystemSetting = this._os === OperatingSystem.Linux ? this._getSettingValue(AgentSandboxSettingId.AgentSandboxLinuxFileSystem) ?? {} : {};
+        const macFileSystemSetting = this._os === OperatingSystem.Macintosh ? this._getSettingValue(AgentSandboxSettingId.AgentSandboxMacFileSystem) ?? {} : {};
+        const windowsFileSystemSetting = this._os === OperatingSystem.Windows ? this._getSettingValue(AgentSandboxSettingId.AgentSandboxWindowsFileSystem) ?? {} : {};
+        const windowsSchemaVersion = this._os === OperatingSystem.Windows ? this._getSettingValue(AgentSandboxSettingId.AgentSandboxWindowsSchemaVersion) : undefined;
+        const runtimeSetting = this._getSettingValue(AgentSandboxSettingId.AgentSandboxAdvancedRuntime) ?? {};
+        const commandRuntimeSetting = getTerminalSandboxRuntimeConfigurationForCommands(this._os, this._commandAllowListCommandDetails);
+        const commandRuntimeAllowReadPaths = this._getCommandRuntimeFileSystemPaths(commandRuntimeSetting, "allowRead");
+        const commandRuntimeAllowWritePaths = this._getCommandRuntimeFileSystemPaths(commandRuntimeSetting, "allowWrite");
+        const configFileUri = URI.joinPath(this._tempDir, `vscode-sandbox-settings-${this._sandboxSettingsId}.json`);
+        let allowWritePaths = [];
+        let allowReadPaths = [];
+        let denyReadPaths = [];
+        let denyWritePaths;
+        if (this._os === OperatingSystem.Windows) {
+            const filesystemPolicy = await this._getWindowsMxcFilesystemPolicy();
+            const env = await this._getWindowsMxcEnvironment();
+            allowWritePaths = await this._resolveFileSystemPaths([
+                ...(await this._updateAllowWritePathsWithWorkspaceFolders(windowsFileSystemSetting.allowWrite)),
+                ...filesystemPolicy.readwritePaths
+            ]);
+            allowReadPaths = await this._resolveFileSystemPaths([
+                ...(windowsFileSystemSetting.allowRead ?? []),
+                ...filesystemPolicy.readonlyPaths
+            ]);
+            denyReadPaths = await this._resolveFileSystemPaths(windowsFileSystemSetting.denyRead ?? []);
+            this._windowsMxcEnvironment = env;
+        } else if (this._os === OperatingSystem.Macintosh) {
+            allowWritePaths = await this._resolveFileSystemPaths(
+                await this._updateAllowWritePathsWithWorkspaceFolders(macFileSystemSetting.allowWrite, commandRuntimeAllowWritePaths)
+            );
+            allowReadPaths = await this._resolveFileSystemPaths(await this._updateAllowReadPathsWithAllowWrite(
+                macFileSystemSetting.allowRead,
+                allowWritePaths,
+                commandRuntimeAllowReadPaths
+            ));
+            denyReadPaths = await this._resolveFileSystemPaths(this._updateDenyReadPathsWithHome(macFileSystemSetting.denyRead));
+            denyWritePaths = macFileSystemSetting.denyWrite ? await this._resolveFileSystemPaths(macFileSystemSetting.denyWrite) : undefined;
+        } else if (this._os === OperatingSystem.Linux) {
+            allowWritePaths = await this._resolveFileSystemPaths(
+                await this._updateAllowWritePathsWithWorkspaceFolders(linuxFileSystemSetting.allowWrite, commandRuntimeAllowWritePaths)
+            );
+            allowReadPaths = await this._resolveFileSystemPaths(await this._updateAllowReadPathsWithAllowWrite(
+                linuxFileSystemSetting.allowRead,
+                allowWritePaths,
+                commandRuntimeAllowReadPaths
+            ));
+            denyReadPaths = await this._resolveFileSystemPaths(this._updateDenyReadPathsWithHome(linuxFileSystemSetting.denyRead));
+            denyWritePaths = await this._resolveFileSystemPaths(linuxFileSystemSetting.denyWrite);
+        }
+        const sandboxSettings = this._os === OperatingSystem.Windows ? await this._windowsMxcRuntime.createConfig({
+            command: this._commandLine ?? "",
+            shell: this._commandShell,
+            cwd: this._commandCwd ?? this._getDefaultWindowsMxcCwd(),
+            tempDir: this._tempDir,
+            schemaVersion: windowsSchemaVersion,
+            allowNetwork,
+            networkDomains: this.getResolvedNetworkDomains(),
+            allowReadPaths,
+            allowWritePaths,
+            denyReadPaths,
+            env: this._windowsMxcEnvironment ?? []
+        }, this._buildSandboxPayload) : {
+            network: allowNetwork ? {
+                allowedDomains: [],
+                deniedDomains: [],
+                enabled: false
+            } : this.getResolvedNetworkDomains(),
+            filesystem: {
+                denyRead: denyReadPaths,
+                allowRead: allowReadPaths,
+                allowWrite: allowWritePaths,
+                denyWrite: denyWritePaths
+            }
+        };
+        if (this._os !== OperatingSystem.Windows) {
+            this._mergeAdditionalSandboxConfigProperties(
+                sandboxSettings,
+                allowNetwork ? this._withoutNetworkRuntimeSetting(runtimeSetting) : runtimeSetting
+            );
+            this._mergeAdditionalSandboxConfigProperties(sandboxSettings, commandRuntimeSetting);
+        }
+        this._sandboxConfigPath = this._getUriPath(configFileUri);
+        await this._fileService.createFile(
+            configFileUri,
+            VSBuffer.fromString(JSON.stringify(sandboxSettings, null, "\t")),
+            {
+                overwrite: true
+            }
+        );
+        return this._sandboxConfigPath;
+    }
+    _getCommandRuntimeFileSystemPaths(runtimeSetting, key) {
+        const filesystem = runtimeSetting.filesystem;
+        if (!this._isObjectForSandboxConfigMerge(filesystem)) {
+            return [];
+        }
+        const paths = filesystem[key];
+        if (!Array.isArray(paths)) {
+            return [];
+        }
+        return paths.filter(path => typeof path === "string");
+    }
+    _withoutNetworkRuntimeSetting(runtimeSetting) {
+        const sanitizedRuntimeSetting = {
+            ...runtimeSetting
+        };
+        delete sanitizedRuntimeSetting.network;
+        return sanitizedRuntimeSetting;
+    }
+    _mergeAdditionalSandboxConfigProperties(target, additional) {
+        for (const [key, value] of Object.entries(additional)) {
+            if (!Object.prototype.hasOwnProperty.call(target, key)) {
+                target[key] = value;
+                continue;
+            }
+            const existingValue = target[key];
+            if (this._isObjectForSandboxConfigMerge(existingValue) && this._isObjectForSandboxConfigMerge(value)) {
+                this._mergeAdditionalSandboxConfigProperties(existingValue, value);
+            }
+        }
+    }
+    _isObjectForSandboxConfigMerge(value) {
+        return typeof value === "object" && value !== null && !Array.isArray(value);
+    }
+    async _getWindowsMxcFilesystemPolicy() {
+        if (!this._windowsMxcFilesystemPolicy) {
+            this._windowsMxcFilesystemPolicy = (await this._host.getWindowsMxcFilesystemPolicy()) ?? {
+                readonlyPaths: [],
+                readwritePaths: []
+            };
+        }
+        return this._windowsMxcFilesystemPolicy;
+    }
+    async _getWindowsMxcEnvironment() {
+        if (!this._windowsMxcEnvironment) {
+            this._windowsMxcEnvironment = (await this._host.getWindowsMxcEnvironment()) ?? [];
+        }
+        return this._windowsMxcEnvironment;
+    }
+    _pathDirname(path) {
+        return (this._os === OperatingSystem.Windows ? win32 : posix).dirname(path);
+    }
+    _getUriPath(uri) {
+        return this._os === OperatingSystem.Windows ? this._windowsMxcRuntime.toWindowsPath(uri) : uri.path;
+    }
+    async _initTempDir() {
+        if (!(await this.isEnabled())) {
+            return;
+        }
+        this._needsForceUpdateConfigFile = true;
+        this._tempDir = await this._host.getSandboxTempDir();
+        if (this._tempDir) {
+            await this._fileService.createFolder(this._tempDir);
+            this._defaultWritePaths.push(this._getUriPath(this._tempDir));
+        } else {
+            this._logService.warn(
+                "TerminalSandboxEngine: Cannot create sandbox settings file because no tmpDir is available in this environment"
+            );
+        }
+    }
+    async _updateAllowWritePathsWithWorkspaceFolders(configuredAllowWrite, commandRuntimeAllowWrite = []) {
+        const writeRootPaths = ( this._host.getWriteRoots().map(folder => this._getUriPath(folder)));
+        return [...( new Set([
+            ...writeRootPaths,
+            ...this._defaultWritePaths,
+            ...(await this._getWorkspaceStorageReadPaths()),
+            ...(configuredAllowWrite ?? []),
+            ...commandRuntimeAllowWrite
+        ]))];
+    }
+    _updateDenyReadPathsWithHome(configuredDenyRead) {
+        if (this._os === OperatingSystem.Windows) {
+            return [...( new Set(configuredDenyRead ?? []))];
+        }
+        const userHome = this._userHome ? this._getUriPath(this._userHome) : undefined;
+        return [...( new Set([...(configuredDenyRead ?? []), ...(userHome ? [userHome] : [])]))];
+    }
+    async _updateAllowReadPathsWithAllowWrite(configuredAllowRead, allowWrite, commandRuntimeAllowRead = []) {
+        return [...( new Set([
+            ...(configuredAllowRead ?? []),
+            ...getTerminalSandboxReadAllowListForCommands(
+                this._os,
+                this._commandAllowListKeywords,
+                this._commandAllowListCommandDetails
+            ),
+            ...commandRuntimeAllowRead,
+            ...this._getSandboxRuntimeReadPaths(),
+            ...(await this._getWorkspaceStorageReadPaths()),
+            ...allowWrite
+        ]))];
+    }
+    async _resolveFileSystemPaths(paths) {
+        const resolvedPaths = await Promise.all(( (paths ?? []).map(path => this._resolveFileSystemPath(path))));
+        return [...( new Set(resolvedPaths.flat()))];
+    }
+    async _resolveFileSystemPath(path) {
+        const expandedPath = this._os === OperatingSystem.Linux ? this._expandHomePath(path) : path;
+        if (!this._isAbsoluteFileSystemPath(expandedPath)) {
+            return [expandedPath];
+        }
+        try {
+            const realpath = await this._fileService.realpath(this._toFileSystemResource(expandedPath));
+            const resolvedPath = realpath ? this._getUriPath(realpath) : undefined;
+            return resolvedPath && resolvedPath !== expandedPath ? [expandedPath, resolvedPath] : [expandedPath];
+        } catch {
+            return [expandedPath];
+        }
+    }
+    _isAbsoluteFileSystemPath(path) {
+        return (this._os === OperatingSystem.Windows ? win32 : posix).isAbsolute(path);
+    }
+    _toFileSystemResource(path) {
+        if (this._os === OperatingSystem.Windows) {
+            return this._toWindowsFileSystemResource(path);
+        }
+        return this._userHome?.with({
+            path
+        }) ?? this._tempDir?.with({
+            path
+        }) ?? this._host.getWriteRoots()[0]?.with({
+            path
+        }) ?? URI.file(path);
+    }
+    _toWindowsFileSystemResource(path) {
+        const normalizedPath = path.replace(/\\/g, "/");
+        if (/^\/\/[^/]/.test(normalizedPath)) {
+            const firstPathSeparator = normalizedPath.indexOf("/", 2);
+            if (firstPathSeparator === -1) {
+                return ( URI.from({
+                    scheme: "file",
+                    authority: normalizedPath.slice(2),
+                    path: "/"
+                }));
+            }
+            return ( URI.from({
+                scheme: "file",
+                authority: normalizedPath.slice(2, firstPathSeparator),
+                path: normalizedPath.slice(firstPathSeparator) || "/"
+            }));
+        }
+        if (/^[a-zA-Z]:($|\/)/.test(normalizedPath)) {
+            return ( URI.from({
+                scheme: "file",
+                path: `/${normalizedPath[0].toLowerCase()}${normalizedPath.slice(1)}`
+            }));
+        }
+        if (/^\/[a-zA-Z]:($|\/)/.test(normalizedPath)) {
+            return ( URI.from({
+                scheme: "file",
+                path: `/${normalizedPath[1].toLowerCase()}${normalizedPath.slice(2)}`
+            }));
+        }
+        return ( URI.from({
+            scheme: "file",
+            path: normalizedPath
+        }));
+    }
+    _expandHomePath(path) {
+        const userHome = this._userHome?.path;
+        if (!userHome) {
+            return path;
+        }
+        if (path === "~") {
+            return userHome;
+        }
+        if (path.startsWith("~/")) {
+            return this._pathJoin(userHome, path.slice(2));
+        }
+        return path;
+    }
+    _getSandboxRuntimeReadPaths() {
+        if (!this._appRoot) {
+            return [];
+        }
+        if (this._os === OperatingSystem.Windows) {
+            return this._windowsMxcRuntime.getRuntimeReadPaths(this._appRoot, this._mxcPath);
+        }
+        const paths = [this._appRoot];
+        if (this._execPath) {
+            for (const path of [this._execPath, this._pathDirname(this._execPath)]) {
+                if (!this._isPathUnderAppRoot(path)) {
+                    paths.push(path);
+                }
+            }
+        }
+        return paths;
+    }
+    _isPathUnderAppRoot(path) {
+        if (!this._appRoot) {
+            return false;
+        }
+        return path === this._appRoot || path.startsWith(
+            `${this._appRoot}${this._os === OperatingSystem.Windows ? win32.sep : posix.sep}`
+        );
+    }
+    async _getWorkspaceStorageReadPaths() {
+        const root = await this._host.getWorkspaceStorageReadRoot();
+        return root ? [this._getUriPath(root)] : [];
+    }
+    _getDefaultWindowsMxcCwd() {
+        return this._host.getWriteRoots()[0];
+    }
+    _getSandboxConfiguredEnabledValue() {
+        return this._getSettingValue(AgentSandboxSettingId.AgentSandboxEnabled) ?? AgentSandboxEnabledValue.Off;
+    }
+    _getSandboxConfiguredWindowsEnabledValue() {
+        return this._getSettingValue(AgentSandboxSettingId.AgentSandboxWindowsEnabled) ?? AgentSandboxEnabledValue.Off;
+    }
+    _isSandboxAllowNetworkConfigured() {
+        if (this._os === OperatingSystem.Windows) {
+            return this._getSandboxConfiguredWindowsEnabledValue() === AgentSandboxEnabledValue.AllowNetwork;
+        }
+        return this._getSandboxConfiguredEnabledValue() === AgentSandboxEnabledValue.AllowNetwork;
+    }
+    _areUnsandboxedCommandsAllowed() {
+        return this._getSettingValue(AgentSandboxSettingId.AgentSandboxAllowUnsandboxedCommands) === true;
+    }
+    _areRetryWithAllowNetworkRequestsAllowed() {
+        return this._getSettingValue(AgentSandboxSettingId.AgentSandboxRetryWithAllowNetworkRequests) === true;
+    }
+    _getSettingValue(settingId) {
+        return this._host.getSandboxSetting(settingId);
+    }
+};
+TerminalSandboxEngine = TerminalSandboxEngine_1 = ( __decorate([( __param(1, IFileService)), ( __param(2, ILogService)), ( __param(3, IWindowsMxcTerminalSandboxRuntime))], TerminalSandboxEngine));
+
+export { TerminalSandboxEngine };