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

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

@@ -0,0 +1,118 @@
+
+import { OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { gitGlobalOptionsWithValue, matchesTerminalSandboxCommandRule } from './terminalSandboxCommandRules.js';
+
+var TerminalSandboxRuntimeConfigurationOperation;
+(function(TerminalSandboxRuntimeConfigurationOperation) {
+    TerminalSandboxRuntimeConfigurationOperation["GnuPG"] = "gnupg";
+    TerminalSandboxRuntimeConfigurationOperation["Node"] = "node";
+})(
+    TerminalSandboxRuntimeConfigurationOperation || (TerminalSandboxRuntimeConfigurationOperation = {})
+);
+const terminalSandboxRuntimeConfigurationCommandRules = [{
+    keywords: [
+        "node",
+        "npm",
+        "npx",
+        "pnpm",
+        "yarn",
+        "corepack",
+        "bun",
+        "deno",
+        "nvm",
+        "volta",
+        "fnm",
+        "asdf",
+        "mise"
+    ],
+    value: TerminalSandboxRuntimeConfigurationOperation.Node
+}, {
+    keywords: ["git"],
+    value: TerminalSandboxRuntimeConfigurationOperation.GnuPG,
+    subcommands: ["commit"],
+    optionsWithValue: gitGlobalOptionsWithValue,
+    condition: (
+        {
+            os
+        }
+    ) => os !== OperatingSystem.Windows,
+    when: isGpgSignedGitCommit
+}];
+function getTerminalSandboxRuntimeConfigurationForOperation(operation, os) {
+    switch (operation) {
+    case TerminalSandboxRuntimeConfigurationOperation.GnuPG:
+        switch (os) {
+        case OperatingSystem.Windows:
+            return {};
+        case OperatingSystem.Macintosh:
+        case OperatingSystem.Linux:
+        default:
+            return {
+                network: {
+                    allowAllUnixSockets: true
+                },
+                filesystem: {
+                    allowRead: ["~/.gnupg"],
+                    allowWrite: ["~/.gnupg"]
+                }
+            };
+        }
+    case TerminalSandboxRuntimeConfigurationOperation.Node:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+        case OperatingSystem.Linux:
+        default:
+            return {
+                filesystem: {
+                    allowWrite: ["~/.volta/"]
+                }
+            };
+        }
+    }
+}
+function getTerminalSandboxRuntimeConfigurationForCommands(os, commandDetails) {
+    const operations = ( new Set());
+    for (const command of commandDetails) {
+        for (const rule of terminalSandboxRuntimeConfigurationCommandRules) {
+            if (matchesTerminalSandboxCommandRule(command, rule, {
+                os
+            })) {
+                operations.add(rule.value);
+            }
+        }
+    }
+    const configuration = {};
+    for (const operation of operations) {
+        mergeAdditionalSandboxConfigProperties(
+            configuration,
+            getTerminalSandboxRuntimeConfigurationForOperation(operation, os)
+        );
+    }
+    return configuration;
+}
+function isGpgSignedGitCommit(command) {
+    return ( command.args.some(
+        arg => arg === "-S" || arg.startsWith("-S") || arg === "--gpg-sign" || arg.startsWith("--gpg-sign=")
+    ));
+}
+function 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 (Array.isArray(existingValue) && Array.isArray(value)) {
+            target[key] = [...( new Set([...existingValue, ...value]))];
+            continue;
+        }
+        if (isObjectForSandboxConfigMerge(existingValue) && isObjectForSandboxConfigMerge(value)) {
+            mergeAdditionalSandboxConfigProperties(existingValue, value);
+        }
+    }
+}
+function isObjectForSandboxConfigMerge(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export { TerminalSandboxRuntimeConfigurationOperation, getTerminalSandboxRuntimeConfigurationForCommands };

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

@@ -12,10 +12,10 @@ import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform
 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 { TerminalSandboxPrerequisiteCheck, type ISandboxDependencyInstallOptions, type ISandboxDependencyInstallResult, type ITerminalSandboxCommand, 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 type { ISandboxDependencyInstallOptions, ISandboxDependencyInstallResult, ISandboxDependencyInstallTerminal, ITerminalSandboxCommand, ITerminalSandboxPrerequisiteCheckResult, ITerminalSandboxResolvedNetworkDomains, ITerminalSandboxWrapResult } from "../../../../../platform/sandbox/common/terminalSandboxService.js";
 export declare class TerminalSandboxService extends Disposable implements ITerminalSandboxService {
     private readonly _configurationService;
     private readonly _fileService;
@@ -40,6 +40,9 @@ export declare class TerminalSandboxService extends Disposable implements ITermi
     private _remoteEnvDetailsPromise;
     private _remoteEnvDetails;
     private _appRoot;
+    private _commandAllowListKeywords;
+    private _commandAllowListCommandDetails;
+    private _commandCwd;
     private _os;
     private _defaultWritePaths;
     private static readonly _sandboxTempDirName;
@@ -48,8 +51,9 @@ export declare class TerminalSandboxService extends Disposable implements ITermi
     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>;
+    isSandboxAllowNetworkEnabled(): Promise<boolean>;
     getOS(): Promise<OperatingSystem>;
-    wrapCommand(command: string, requestUnsandboxedExecution?: boolean, shell?: string): ITerminalSandboxWrapResult;
+    wrapCommand(command: string, requestUnsandboxedExecution?: boolean, shell?: string, cwd?: URI, commandDetails?: readonly ITerminalSandboxCommand[]): Promise<ITerminalSandboxWrapResult>;
     getTempDir(): URI | undefined;
     setNeedsForceUpdateConfigFile(): void;
     checkForSandboxingPrereqs(forceRefresh?: boolean): Promise<ITerminalSandboxPrerequisiteCheckResult>;
@@ -63,13 +67,29 @@ export declare class TerminalSandboxService extends Disposable implements ITermi
      */
     private _createMissingDependencyPasswordPrompt;
     private _quoteShellArgument;
+    private _getSandboxCommandWithPreservedCwd;
+    private _wrapSandboxRuntimeCommandForLaunch;
     private _wrapUnsandboxedCommand;
     private _getBlockedDomains;
     private _extractDomains;
     private _extractDomainFromUrl;
+    /**
+     * Creates a stable, case-insensitive keyword set for config refresh checks and
+     * coarse command allow-list rules.
+     */
+    private _normalizeCommandKeywords;
+    /**
+     * Normalizes command details for deterministic comparisons while preserving
+     * argument order within each command for argument-sensitive allow-list rules.
+     */
+    private _normalizeCommandDetails;
+    private _areStringArraysEqual;
+    private _areObjectsEqual;
     private _isSandboxConfiguredEnabled;
     private _resolveSrtPath;
     private _createSandboxConfig;
+    private _getCommandRuntimeFileSystemPaths;
+    private _withoutNetworkRuntimeSetting;
     private _mergeAdditionalSandboxConfigProperties;
     private _isObjectForSandboxConfigMerge;
     private _pathJoin;
@@ -79,7 +99,17 @@ export declare class TerminalSandboxService extends Disposable implements ITermi
     private _getSandboxWindowTempDirName;
     getResolvedNetworkDomains(): ITerminalSandboxResolvedNetworkDomains;
     private _updateAllowWritePathsWithWorkspaceFolders;
+    private _updateDenyReadPathsWithHome;
+    private _updateAllowReadPathsWithAllowWrite;
+    private _resolveLinuxFileSystemPaths;
+    private _expandHomePath;
+    private _getSandboxRuntimeReadPaths;
+    private _isPathUnderAppRoot;
+    private _getWorkspaceStorageReadPaths;
+    private _getUserHomePath;
     private _resolveSandboxDependencyStatus;
-    private _isSandboxEnabled;
+    private _getSandboxConfiguredEnabledValue;
+    private _isSandboxAllowNetworkConfigured;
+    private _areUnsandboxedCommandsAllowed;
     private _getSettingValue;
 }

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

@@ -33,6 +33,8 @@ import { SANDBOX_HELPER_CHANNEL_NAME, SandboxHelperChannelClient } from '../../.
 import { AgentSandboxSettingId, AgentSandboxEnabledValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/settings';
 import { TerminalSandboxPrerequisiteCheck } from '../../../../../platform/sandbox/common/terminalSandboxService.js';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { getTerminalSandboxReadAllowListForCommands } from './terminalSandboxReadAllowList.js';
+import { getTerminalSandboxRuntimeConfigurationForCommands } from './terminalSandboxRuntimeConfigurationPerOperation.js';
 
 var TerminalSandboxService_1;
 let TerminalSandboxService = class TerminalSandboxService extends Disposable {
@@ -77,8 +79,10 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
         this._srtPathResolved = false;
         this._needsForceUpdateConfigFile = true;
         this._remoteEnvDetails = null;
+        this._commandAllowListKeywords = [];
+        this._commandAllowListCommandDetails = [];
         this._os = OS;
-        this._defaultWritePaths = ["~/.npm"];
+        this._defaultWritePaths = [];
         this._pathJoin = (...segments) => {
             const path = this._os === OperatingSystem.Windows ? win32 : posix;
             return path.join(...segments);
@@ -104,7 +108,7 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
             }
             e.join(this._cleanupSandboxTempDir(), {
                 id: "join.deleteFilesInSandboxTempDir",
-                label: ( localize(14190, "Delete Files in Sandbox Temp Dir")),
+                label: ( localize(14495, "Delete Files in Sandbox Temp Dir")),
                 order: WillShutdownJoinerOrder.Default
             });
         }));
@@ -112,20 +116,44 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
     async isEnabled() {
         return await this._isSandboxConfiguredEnabled();
     }
+    async isSandboxAllowNetworkEnabled() {
+        if (!(await this._isSandboxConfiguredEnabled())) {
+            return false;
+        }
+        return this._isSandboxAllowNetworkConfigured();
+    }
     async getOS() {
         this._remoteEnvDetails = await this._remoteEnvDetailsPromise;
         this._os = this._remoteEnvDetails ? this._remoteEnvDetails.os : OS;
         return this._os;
     }
-    wrapCommand(command, requestUnsandboxedExecution, shell) {
+    async wrapCommand(command, requestUnsandboxedExecution, shell, cwd, commandDetails) {
+        const normalizedCommandDetails = this._normalizeCommandDetails(commandDetails ?? []);
+        const normalizedCommandKeywords = this._normalizeCommandKeywords(( normalizedCommandDetails.map(command => command.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();
+        if (shouldRefreshConfig) {
+            this._commandAllowListKeywords = normalizedCommandKeywords;
+            this._commandAllowListCommandDetails = normalizedCommandDetails;
+            this._commandCwd = cwd;
+            await this.getSandboxConfigPath(true);
+        }
         if (!this._sandboxConfigPath || !this._tempDir) {
             throw ( new Error("Sandbox config path or temp dir not initialized"));
         }
-        const blockedDomainResult = requestUnsandboxedExecution ? {
+        const allowUnsandboxedCommands = this._areUnsandboxedCommandsAllowed();
+        const blockedDomainResult = requestUnsandboxedExecution || !allowUnsandboxedCommands ? {
             blockedDomains: [],
             deniedDomains: []
         } : this._getBlockedDomains(command);
-        if (!requestUnsandboxedExecution && blockedDomainResult.blockedDomains.length > 0) {
+        if (!requestUnsandboxedExecution && allowUnsandboxedCommands && blockedDomainResult.blockedDomains.length > 0) {
             return {
                 command: this._wrapUnsandboxedCommand(command, shell),
                 isSandboxWrapped: false,
@@ -134,7 +162,7 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
                 requiresUnsandboxConfirmation: true
             };
         }
-        if (requestUnsandboxedExecution) {
+        if (requestUnsandboxedExecution && allowUnsandboxedCommands) {
             return {
                 command: this._wrapUnsandboxedCommand(command, shell),
                 isSandboxWrapped: false
@@ -149,15 +177,18 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
         if (!this._rgPath) {
             throw ( new Error("Ripgrep path not resolved"));
         }
-        const wrappedCommand = `PATH="$PATH:${dirname(this._rgPath)}" TMPDIR="${this._tempDir.path}" CLAUDE_TMPDIR="${this._tempDir.path}" "${this._execPath}" "${this._srtPath}" --settings "${this._sandboxConfigPath}" -c ${this._quoteShellArgument(command)}`;
+        const commandToRunInSandbox = this._getSandboxCommandWithPreservedCwd(command, cwd);
+        const sandboxRuntimeCommand = `PATH="$PATH:${dirname(this._rgPath)}" TMPDIR="${this._tempDir.path}" CLAUDE_TMPDIR="${this._tempDir.path}" "${this._execPath}" "${this._srtPath}" --settings "${this._sandboxConfigPath}" -c ${this._quoteShellArgument(commandToRunInSandbox)}`;
+        const nodeSandboxRuntimeCommand = `ELECTRON_RUN_AS_NODE=1 ${sandboxRuntimeCommand}`;
+        const wrappedCommand = this._wrapSandboxRuntimeCommandForLaunch(nodeSandboxRuntimeCommand, cwd);
         if (this._remoteEnvDetails) {
             return {
-                command: wrappedCommand,
+                command: this._wrapSandboxRuntimeCommandForLaunch(sandboxRuntimeCommand, cwd),
                 isSandboxWrapped: true
             };
         }
         return {
-            command: `ELECTRON_RUN_AS_NODE=1 ${wrappedCommand}`,
+            command: wrappedCommand,
             isSandboxWrapped: true
         };
     }
@@ -298,10 +329,10 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
         if (!request) {
             return ( new DisposableStore());
         }
-        const part = ( new ChatElicitationRequestPart(( localize(14191, "The terminal is awaiting input.")), ( new MarkdownString(( localize(
-            14192,
+        const part = ( new ChatElicitationRequestPart(( localize(14496, "The terminal is awaiting input.")), ( new MarkdownString(( localize(
+            14497,
             "Installing missing sandbox dependencies may prompt for your sudo password. Select Focus Terminal to type it in the terminal."
-        )))), "", ( localize(14193, "Focus Terminal")), undefined, async () => {
+        )))), "", ( localize(14498, "Focus Terminal")), undefined, async () => {
             await promptContext.focusTerminal();
             return ElicitationState.Pending;
         }));
@@ -323,6 +354,16 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
     _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._tempDir?.path) {
             return command;
@@ -333,6 +374,12 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
         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 {
@@ -395,15 +442,40 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
             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);
+    }
     async _isSandboxConfiguredEnabled() {
         const os = await this.getOS();
         if (os === OperatingSystem.Windows) {
             return false;
         }
-        return this._isSandboxEnabled(this._getSettingValue(
-            AgentSandboxSettingId.AgentSandboxEnabled,
-            AgentSandboxSettingId.DeprecatedAgentSandboxEnabled
-        ) ?? AgentSandboxEnabledValue.Off);
+        const value = this._getSandboxConfiguredEnabledValue();
+        return value === true || value === AgentSandboxEnabledValue.On || value === AgentSandboxEnabledValue.AllowNetwork;
     }
     async _resolveSrtPath() {
         if (this._srtPathResolved) {
@@ -418,7 +490,7 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
         this._srtPath = this._pathJoin(
             this._appRoot,
             "node_modules",
-            "@anthropic-ai",
+            "@vscode",
             "sandbox-runtime",
             "dist",
             "cli.js"
@@ -430,16 +502,7 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
             await this._initTempDir();
         }
         if (this._tempDir) {
-            const allowedDomainsSetting = this._getSettingValue(
-                AgentNetworkDomainSettingId.AllowedNetworkDomains,
-                AgentNetworkDomainSettingId.DeprecatedSandboxAllowedNetworkDomains,
-                AgentNetworkDomainSettingId.DeprecatedOldAllowedNetworkDomains
-            ) ?? [];
-            const deniedDomainsSetting = this._getSettingValue(
-                AgentNetworkDomainSettingId.DeniedNetworkDomains,
-                AgentNetworkDomainSettingId.DeprecatedSandboxDeniedNetworkDomains,
-                AgentNetworkDomainSettingId.DeprecatedOldDeniedNetworkDomains
-            ) ?? [];
+            const allowNetwork = await this.isSandboxAllowNetworkEnabled();
             const linuxFileSystemSetting = this._os === OperatingSystem.Linux ? this._getSettingValue(
                 TerminalChatAgentToolsSettingId.AgentSandboxLinuxFileSystem,
                 TerminalChatAgentToolsSettingId.DeprecatedAgentSandboxLinuxFileSystem
@@ -449,21 +512,53 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
                 TerminalChatAgentToolsSettingId.DeprecatedAgentSandboxMacFileSystem
             ) ?? {} : {};
             const runtimeSetting = this._getSettingValue(TerminalChatAgentToolsSettingId.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`);
-            const linuxAllowWrite = this._updateAllowWritePathsWithWorkspaceFolders(linuxFileSystemSetting.allowWrite);
-            const macAllowWrite = this._updateAllowWritePathsWithWorkspaceFolders(macFileSystemSetting.allowWrite);
+            let allowWritePaths = [];
+            let allowReadPaths = [];
+            let denyReadPaths = [];
+            let denyWritePaths;
+            if (this._os === OperatingSystem.Macintosh) {
+                allowWritePaths = this._updateAllowWritePathsWithWorkspaceFolders(macFileSystemSetting.allowWrite, commandRuntimeAllowWritePaths);
+                allowReadPaths = this._updateAllowReadPathsWithAllowWrite(
+                    macFileSystemSetting.allowRead,
+                    allowWritePaths,
+                    commandRuntimeAllowReadPaths
+                );
+                denyReadPaths = this._updateDenyReadPathsWithHome(macFileSystemSetting.denyRead);
+                denyWritePaths = macFileSystemSetting.denyWrite;
+            } else if (this._os === OperatingSystem.Linux) {
+                allowWritePaths = this._resolveLinuxFileSystemPaths(
+                    this._updateAllowWritePathsWithWorkspaceFolders(linuxFileSystemSetting.allowWrite, commandRuntimeAllowWritePaths)
+                );
+                allowReadPaths = this._resolveLinuxFileSystemPaths(this._updateAllowReadPathsWithAllowWrite(
+                    linuxFileSystemSetting.allowRead,
+                    allowWritePaths,
+                    commandRuntimeAllowReadPaths
+                ));
+                denyReadPaths = this._resolveLinuxFileSystemPaths(this._updateDenyReadPathsWithHome(linuxFileSystemSetting.denyRead));
+                denyWritePaths = this._resolveLinuxFileSystemPaths(linuxFileSystemSetting.denyWrite);
+            }
             const sandboxSettings = {
-                network: {
-                    allowedDomains: allowedDomainsSetting,
-                    deniedDomains: deniedDomainsSetting
-                },
+                network: allowNetwork ? {
+                    allowedDomains: [],
+                    deniedDomains: [],
+                    enabled: false
+                } : this.getResolvedNetworkDomains(),
                 filesystem: {
-                    denyRead: this._os === OperatingSystem.Macintosh ? macFileSystemSetting.denyRead : linuxFileSystemSetting.denyRead,
-                    allowWrite: this._os === OperatingSystem.Macintosh ? macAllowWrite : linuxAllowWrite,
-                    denyWrite: this._os === OperatingSystem.Macintosh ? macFileSystemSetting.denyWrite : linuxFileSystemSetting.denyWrite
+                    denyRead: denyReadPaths,
+                    allowRead: allowReadPaths,
+                    allowWrite: allowWritePaths,
+                    denyWrite: denyWritePaths
                 }
             };
-            this._mergeAdditionalSandboxConfigProperties(sandboxSettings, runtimeSetting);
+            this._mergeAdditionalSandboxConfigProperties(
+                sandboxSettings,
+                allowNetwork ? this._withoutNetworkRuntimeSetting(runtimeSetting) : runtimeSetting
+            );
+            this._mergeAdditionalSandboxConfigProperties(sandboxSettings, commandRuntimeSetting);
             this._sandboxConfigPath = configFileUri.path;
             await this._fileService.createFile(
                 configFileUri,
@@ -476,6 +571,24 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
         }
         return undefined;
     }
+    _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)) {
@@ -562,14 +675,74 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
             deniedDomains
         };
     }
-    _updateAllowWritePathsWithWorkspaceFolders(configuredAllowWrite) {
+    _updateAllowWritePathsWithWorkspaceFolders(configuredAllowWrite, commandRuntimeAllowWrite = []) {
         const workspaceFolderPaths = ( this._workspaceContextService.getWorkspace().folders.map(folder => folder.uri.path));
         return [...( new Set([
             ...workspaceFolderPaths,
             ...this._defaultWritePaths,
-            ...(configuredAllowWrite ?? [])
+            ...(configuredAllowWrite ?? []),
+            ...commandRuntimeAllowWrite
         ]))];
     }
+    _updateDenyReadPathsWithHome(configuredDenyRead) {
+        const userHome = this._getUserHomePath();
+        return [...( new Set([...(configuredDenyRead ?? []), ...(userHome ? [userHome] : [])]))];
+    }
+    _updateAllowReadPathsWithAllowWrite(configuredAllowRead, allowWrite, commandRuntimeAllowRead = []) {
+        return [...( new Set([
+            ...(configuredAllowRead ?? []),
+            ...getTerminalSandboxReadAllowListForCommands(
+                this._os,
+                this._commandAllowListKeywords,
+                this._commandAllowListCommandDetails
+            ),
+            ...commandRuntimeAllowRead,
+            ...this._getSandboxRuntimeReadPaths(),
+            ...this._getWorkspaceStorageReadPaths(),
+            ...allowWrite
+        ]))];
+    }
+    _resolveLinuxFileSystemPaths(paths) {
+        return ( (paths ?? []).map(path => this._expandHomePath(path)));
+    }
+    _expandHomePath(path) {
+        const userHome = this._getUserHomePath();
+        if (!userHome) {
+            return path;
+        }
+        if (path === "~") {
+            return userHome;
+        }
+        if (path.startsWith("~/")) {
+            return this._pathJoin(userHome, path.slice(2));
+        }
+        return path;
+    }
+    _getSandboxRuntimeReadPaths() {
+        const paths = [this._appRoot];
+        if (this._execPath) {
+            for (const path of [this._execPath, dirname(this._execPath)]) {
+                if (!this._isPathUnderAppRoot(path)) {
+                    paths.push(path);
+                }
+            }
+        }
+        return paths;
+    }
+    _isPathUnderAppRoot(path) {
+        return path === this._appRoot || path.startsWith(
+            `${this._appRoot}${this._os === OperatingSystem.Windows ? win32.sep : posix.sep}`
+        );
+    }
+    _getWorkspaceStorageReadPaths() {
+        const workspaceStorageHome = this._remoteEnvDetails?.workspaceStorageHome ?? this._environmentService.workspaceStorageHome;
+        const workspaceId = this._workspaceContextService.getWorkspace().id;
+        return [URI.joinPath(workspaceStorageHome, workspaceId).path];
+    }
+    _getUserHomePath() {
+        const nativeEnv = this._environmentService;
+        return this._remoteEnvDetails?.userHome?.path ?? nativeEnv.userHome?.path;
+    }
     async _resolveSandboxDependencyStatus(forceRefresh = false) {
         if (!forceRefresh && this._sandboxDependencyStatus) {
             return this._sandboxDependencyStatus;
@@ -583,21 +756,33 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
         }
         return this._sandboxHelperService.checkSandboxDependencies();
     }
-    _isSandboxEnabled(value) {
-        return value === true || value === AgentSandboxEnabledValue.On;
+    _getSandboxConfiguredEnabledValue() {
+        return this._getSettingValue(
+            AgentSandboxSettingId.AgentSandboxEnabled,
+            AgentSandboxSettingId.DeprecatedAgentSandboxEnabled
+        ) ?? AgentSandboxEnabledValue.Off;
+    }
+    _isSandboxAllowNetworkConfigured() {
+        return this._getSandboxConfiguredEnabledValue() === AgentSandboxEnabledValue.AllowNetwork;
+    }
+    _areUnsandboxedCommandsAllowed() {
+        return this._getSettingValue(AgentSandboxSettingId.AgentSandboxAllowUnsandboxedCommands) === true;
     }
     _getSettingValue(settingId, ...deprecatedSettingIds) {
         const setting = this._configurationService.inspect(settingId);
         if (setting.userValue !== undefined) {
             return setting.value;
         }
-        for (const deprecatedId of deprecatedSettingIds) {
-            const deprecated = this._configurationService.inspect(deprecatedId);
-            if (deprecated.userValue !== undefined) {
-                this._logService.warn(
-                    `TerminalSandboxService: Using deprecated setting ${deprecatedId} because ${settingId} is not set. Please update your settings to use ${settingId} instead.`
-                );
-                return deprecated.value;
+        if (deprecatedSettingIds.length > 0) {
+            const userConfiguredKeys = ( this._configurationService.keys()).user;
+            for (const deprecatedId of deprecatedSettingIds) {
+                const deprecated = this._configurationService.inspect(deprecatedId);
+                if (deprecated.userValue !== undefined && userConfiguredKeys.includes(deprecatedId)) {
+                    this._logService.warn(
+                        `TerminalSandboxService: Using deprecated setting ${deprecatedId} because ${settingId} is not set. Please update your settings to use ${settingId} instead.`
+                    );
+                    return deprecated.value;
+                }
             }
         }
         return setting.value;

package/vscode/src/vs/platform/actions/browser/actionbar.d.ts

@@ -1,16 +0,0 @@
-import { ActionBar, IActionBarOptions } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionbar";
-import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
-export interface IWorkbenchActionBarOptions extends IActionBarOptions {
-    /**
-     * When set the `workbenchActionExecuted` is automatically sent for each invoked action. The `from` property
-     * of the event will be the passed `telemetrySource`-value.
-     */
-    telemetrySource?: string;
-}
-/**
- * A {@link ActionBar action bar} that automatically sends `workbenchActionExecuted` telemetry
- * events for each invoked action, like {@link import('./toolbar.js').WorkbenchToolBar WorkbenchToolBar} does.
- */
-export declare class WorkbenchActionBar extends ActionBar {
-    constructor(container: HTMLElement, options: IWorkbenchActionBarOptions, telemetryService: ITelemetryService);
-}