@codingame/monaco-vscode-api 37.6.0 → 38.0.0

package/vscode/src/vs/platform/request/common/request.js

@@ -1,8 +1,9 @@
 
-import { streamToBuffer } from '../../../base/common/buffer.js';
+import { streamToBuffer, VSBuffer } from '../../../base/common/buffer.js';
 import { isCancellationError, getErrorMessage } from '../../../base/common/errors.js';
 import { Emitter } from '../../../base/common/event.js';
 import { Disposable } from '../../../base/common/lifecycle.js';
+import { listenStream } from '../../../base/common/stream.js';
 import { localize } from '../../../nls.js';
 import { Extensions, ConfigurationScope, AgentHostConfigurationSyncScope } from '../../configuration/common/configurationRegistry.js';
 import { Registry } from '../../registry/common/platform.js';
@@ -95,6 +96,25 @@ async function asText(context) {
     const buffer = await streamToBuffer(context.stream);
     return ( buffer.toString());
 }
+function readBoundedResponse(context, maxBytes, onLimitExceeded) {
+    return ( new Promise((resolve, reject) => {
+        const chunks = [];
+        let bytes = 0;
+        listenStream(context.stream, {
+            onData: chunk => {
+                bytes += chunk.byteLength;
+                if (bytes > maxBytes) {
+                    reject(onLimitExceeded());
+                    context.stream.destroy();
+                } else {
+                    chunks.push(chunk);
+                }
+            },
+            onError: reject,
+            onEnd: () => resolve(( VSBuffer.concat(chunks).toString()))
+        });
+    }));
+}
 async function asTextOrError(context) {
     if (!isSuccess(context)) {
         throw ( new Error("Server returned " + context.res.statusCode));
@@ -145,7 +165,7 @@ function registerProxyConfigurations(useHostProxy = true, useHostProxyDefault =
     proxyConfiguration = [{
         id: "http",
         order: 15,
-        title: ( localize(2468, "HTTP")),
+        title: ( localize(2865, "HTTP")),
         type: "object",
         scope: ConfigurationScope.MACHINE,
         properties: {
@@ -153,7 +173,7 @@ function registerProxyConfigurations(useHostProxy = true, useHostProxyDefault =
                 type: "boolean",
                 default: useHostProxyDefault,
                 markdownDescription: ( localize(
-                    2469,
+                    2866,
                     "Controls whether in the remote extension host the local proxy configuration should be used. This setting only applies as a remote setting during [remote development](https://aka.ms/vscode-remote)."
                 )),
                 restricted: true
@@ -162,7 +182,7 @@ function registerProxyConfigurations(useHostProxy = true, useHostProxyDefault =
     }, {
         id: "http",
         order: 15,
-        title: ( localize(2468, "HTTP")),
+        title: ( localize(2865, "HTTP")),
         type: "object",
         scope: ConfigurationScope.APPLICATION,
         properties: {
@@ -170,7 +190,7 @@ function registerProxyConfigurations(useHostProxy = true, useHostProxyDefault =
                 type: "boolean",
                 default: false,
                 description: ( localize(
-                    2470,
+                    2867,
                     "Controls whether use of Electron's fetch implementation instead of Node.js' should be enabled. All local extensions will get Electron's fetch implementation for the global fetch API."
                 )),
                 restricted: true
@@ -179,7 +199,7 @@ function registerProxyConfigurations(useHostProxy = true, useHostProxyDefault =
     }, {
         id: "http",
         order: 15,
-        title: ( localize(2468, "HTTP")),
+        title: ( localize(2865, "HTTP")),
         type: "object",
         scope: useHostProxy ? ConfigurationScope.APPLICATION : ConfigurationScope.MACHINE,
         properties: {
@@ -187,7 +207,7 @@ function registerProxyConfigurations(useHostProxy = true, useHostProxyDefault =
                 type: "string",
                 pattern: "^(https?|socks|socks4a?|socks5h?)://([^:]*(:[^@]*)?@)?([^:]+|\\[[:0-9a-fA-F]+\\])(:\\d+)?/?$|^$",
                 markdownDescription: ( localize(
-                    2471,
+                    2868,
                     "The proxy setting to use. If not set, will be inherited from the `http_proxy` and `https_proxy` environment variables. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.",
                     "`#http.useLocalProxyConfiguration#`"
                 )),
@@ -202,7 +222,7 @@ function registerProxyConfigurations(useHostProxy = true, useHostProxyDefault =
                 type: "boolean",
                 default: true,
                 markdownDescription: ( localize(
-                    2472,
+                    2869,
                     "Controls whether the proxy server certificate should be verified against the list of supplied CAs. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.",
                     "`#http.useLocalProxyConfiguration#`"
                 )),
@@ -211,7 +231,7 @@ function registerProxyConfigurations(useHostProxy = true, useHostProxyDefault =
             "http.proxyKerberosServicePrincipal": {
                 type: "string",
                 markdownDescription: ( localize(
-                    2473,
+                    2870,
                     "Overrides the principal service name for Kerberos authentication with the HTTP proxy. A default based on the proxy hostname is used when this is not set. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.",
                     "`#http.useLocalProxyConfiguration#`"
                 )),
@@ -228,7 +248,7 @@ function registerProxyConfigurations(useHostProxy = true, useHostProxyDefault =
                     type: "string"
                 },
                 markdownDescription: ( localize(
-                    2474,
+                    2871,
                     "Specifies domain names for which proxy settings should be ignored for HTTP/HTTPS requests. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.",
                     "`#http.useLocalProxyConfiguration#`"
                 )),
@@ -243,7 +263,7 @@ function registerProxyConfigurations(useHostProxy = true, useHostProxyDefault =
                 type: ["null", "string"],
                 default: null,
                 markdownDescription: ( localize(
-                    2475,
+                    2872,
                     "The value to send as the `Proxy-Authorization` header for every network request. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.",
                     "`#http.useLocalProxyConfiguration#`"
                 )),
@@ -252,13 +272,13 @@ function registerProxyConfigurations(useHostProxy = true, useHostProxyDefault =
             "http.proxySupport": {
                 type: "string",
                 enum: ["off", "on", "fallback", "override"],
-                enumDescriptions: [( localize(2476, "Disable proxy support for extensions.")), ( localize(2477, "Enable proxy support for extensions.")), ( localize(
-                    2478,
+                enumDescriptions: [( localize(2873, "Disable proxy support for extensions.")), ( localize(2874, "Enable proxy support for extensions.")), ( localize(
+                    2875,
                     "Enable proxy support for extensions, fall back to request options, when no proxy found."
-                )), ( localize(2479, "Enable proxy support for extensions, override request options."))],
+                )), ( localize(2876, "Enable proxy support for extensions, override request options."))],
                 default: "override",
                 markdownDescription: ( localize(
-                    2480,
+                    2877,
                     "Use the proxy support for extensions. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.",
                     "`#http.useLocalProxyConfiguration#`"
                 )),
@@ -268,7 +288,7 @@ function registerProxyConfigurations(useHostProxy = true, useHostProxyDefault =
                 type: "boolean",
                 default: true,
                 markdownDescription: ( localize(
-                    2481,
+                    2878,
                     "Controls whether CA certificates should be loaded from the OS. On Windows and macOS, a reload of the window is required after turning this off. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.",
                     "`#http.useLocalProxyConfiguration#`"
                 )),
@@ -279,7 +299,7 @@ function registerProxyConfigurations(useHostProxy = true, useHostProxyDefault =
                 tags: ["experimental"],
                 default: systemCertificatesNodeDefault,
                 markdownDescription: ( localize(
-                    2482,
+                    2879,
                     "Controls whether system certificates should be loaded using Node.js built-in support. Reload the window after changing this setting. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.",
                     "`#http.useLocalProxyConfiguration#`"
                 )),
@@ -293,7 +313,7 @@ function registerProxyConfigurations(useHostProxy = true, useHostProxyDefault =
                 tags: ["experimental"],
                 default: false,
                 markdownDescription: ( localize(
-                    2483,
+                    2880,
                     "Controls whether experimental loading of CA certificates from the OS should be enabled. This uses a more general approach than the default implementation. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.",
                     "`#http.useLocalProxyConfiguration#`"
                 )),
@@ -303,7 +323,7 @@ function registerProxyConfigurations(useHostProxy = true, useHostProxyDefault =
                 type: "boolean",
                 default: true,
                 markdownDescription: ( localize(
-                    2484,
+                    2881,
                     "Controls whether Node.js' fetch implementation should be extended with additional support. Currently proxy support ({1}) and system certificates ({2}) are added when the corresponding settings are enabled. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.",
                     "`#http.useLocalProxyConfiguration#`",
                     "`#http.proxySupport#`",
@@ -315,7 +335,7 @@ function registerProxyConfigurations(useHostProxy = true, useHostProxyDefault =
                 type: "boolean",
                 default: true,
                 markdownDescription: ( localize(
-                    2485,
+                    2882,
                     "Controls whether the built-in WebSocket implementation should be extended with additional support. Currently proxy support ({1}) and system certificates ({2}) are added when the corresponding settings are enabled. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.",
                     "`#http.useLocalProxyConfiguration#`",
                     "`#http.proxySupport#`",
@@ -329,7 +349,7 @@ function registerProxyConfigurations(useHostProxy = true, useHostProxyDefault =
                 minimum: -1,
                 tags: ["experimental"],
                 markdownDescription: ( localize(
-                    2486,
+                    2883,
                     "Controls the interval in seconds for checking network interface changes to invalidate the proxy cache. Set to -1 to disable. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.",
                     "`#http.useLocalProxyConfiguration#`"
                 )),
@@ -347,4 +367,4 @@ function registerProxyConfigurations(useHostProxy = true, useHostProxyDefault =
 }
 registerProxyConfigurations();
 
-export { AbstractRequestService, NO_FETCH_TELEMETRY, USER_LOCAL_AND_REMOTE_SETTINGS, asJson, asText, asTextOrError, hasNoContent, isClientError, isServerError, isSuccess, readHeader, retryAfterFromHeaders, systemCertificatesNodeDefault };
+export { AbstractRequestService, NO_FETCH_TELEMETRY, USER_LOCAL_AND_REMOTE_SETTINGS, asJson, asText, asTextOrError, hasNoContent, isClientError, isServerError, isSuccess, readBoundedResponse, readHeader, retryAfterFromHeaders, systemCertificatesNodeDefault };

package/vscode/src/vs/platform/sandbox/common/sandboxHelperService.d.ts

@@ -6,89 +6,3 @@ export interface ISandboxDependencyStatus {
     readonly dependencyInstallCommand?: string;
     readonly apparmorRestrictsUnprivilegedUserNamespaces?: boolean;
 }
-export interface IWindowsMxcFilesystemPolicy {
-    readonly readonlyPaths: string[];
-    readonly readwritePaths: string[];
-}
-/** Sandbox policy passed to the Windows MXC helper process. */
-export interface IWindowsMxcSandboxPolicy {
-    version: string;
-    filesystem?: {
-        readwritePaths?: string[];
-        readonlyPaths?: string[];
-        deniedPaths?: string[];
-        clearPolicyOnExit?: boolean;
-    };
-    network?: {
-        allowOutbound?: boolean;
-        allowLocalNetwork?: boolean;
-        allowedHosts?: string[];
-        blockedHosts?: string[];
-        proxy?: {
-            builtinTestServer: true;
-        } | {
-            localhost: number;
-        } | {
-            url: string;
-        };
-    };
-    ui?: {
-        allowWindows?: boolean;
-        clipboard?: "none" | "read" | "write" | "all";
-        allowInputInjection?: boolean;
-    };
-    timeoutMs?: number;
-}
-/** MXC payload returned by the Windows sandbox helper. */
-export interface IWindowsMxcConfig {
-    version: string;
-    containerId?: string;
-    containment?: IWindowsMxcPolicyContainment;
-    lifecycle?: {
-        destroyOnExit?: boolean;
-        preservePolicy?: boolean;
-    };
-    process?: {
-        commandLine: string;
-        cwd?: string;
-        env?: string[];
-        timeout?: number;
-    };
-    processContainer?: {
-        leastPrivilege?: boolean;
-        capabilities?: string[];
-        ui?: {
-            isolation: "desktop" | "handles" | "atoms" | "container";
-            desktopSystemControl: boolean;
-            systemSettings: string;
-            ime: boolean;
-        };
-    };
-    filesystem?: {
-        readwritePaths?: string[];
-        readonlyPaths?: string[];
-        deniedPaths?: string[];
-        clearPolicyOnExit?: boolean;
-    };
-    network?: {
-        enforcementMode?: "capabilities" | "firewall" | "both";
-        defaultPolicy?: "allow" | "block";
-        allowLocalNetwork?: boolean;
-        allowedHosts?: string[];
-        blockedHosts?: string[];
-        proxy?: {
-            builtinTestServer: true;
-        } | {
-            localhost: number;
-        } | {
-            url: string;
-        };
-        removeRulesOnExit?: boolean;
-    };
-    ui?: {
-        disable: boolean;
-        clipboard: "none" | "read" | "write" | "all";
-        injection: boolean;
-    };
-}
-export type IWindowsMxcPolicyContainment = "process" | "vm" | "microvm" | "processcontainer" | "windows_sandbox" | "wslc" | "lxc" | "hyperlight" | "seatbelt" | "isolation_session" | "bubblewrap";

package/vscode/src/vs/platform/sandbox/common/sandboxHelperService.service.d.ts

@@ -1,9 +1,6 @@
-import { ISandboxDependencyStatus, IWindowsMxcFilesystemPolicy, IWindowsMxcSandboxPolicy, IWindowsMxcPolicyContainment, IWindowsMxcConfig } from "./sandboxHelperService.js";
+import { ISandboxDependencyStatus } from "./sandboxHelperService.js";
 export declare const ISandboxHelperService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<ISandboxHelperService>;
 export interface ISandboxHelperService {
     readonly _serviceBrand: undefined;
     checkSandboxDependencies(): Promise<ISandboxDependencyStatus | undefined>;
-    getWindowsMxcFilesystemPolicy(): Promise<IWindowsMxcFilesystemPolicy | undefined>;
-    getWindowsMxcEnvironment(): Promise<string[] | undefined>;
-    buildWindowsMxcSandboxPayload(commandLine: string, policy: IWindowsMxcSandboxPolicy, workingDirectory?: string, containerName?: string, containment?: IWindowsMxcPolicyContainment): Promise<IWindowsMxcConfig | undefined>;
 }

package/vscode/src/vs/platform/sandbox/common/sandboxSettingsResolutionHelper.d.ts

@@ -0,0 +1,34 @@
+import { AgentSandboxEnabledSettingValue, AgentSandboxEnabledValue, IAgentSandboxUserConfiguredPaths } from "./settings.js";
+type SandboxFileSystemPaths = Readonly<{
+    readwritePaths?: readonly string[];
+    readonlyPaths?: readonly string[];
+    deniedPaths?: readonly string[];
+}>;
+/** Effective network restrictions resolved by the Copilot Agent Host for an integrated-browser client tool. */
+export interface ISandboxNetworkRestrictions {
+    readonly sandboxEnabled: boolean;
+    readonly allowNetwork: boolean;
+    readonly allowedDomains: readonly string[];
+    readonly deniedDomains: readonly string[];
+}
+export declare function isSandboxNetworkRestrictions(value: unknown): value is ISandboxNetworkRestrictions;
+/** Resolves local sandbox settings against the managed floor without changing saved preferences. */
+export declare class SandboxSettingsResolutionHelper {
+    static getNetworkRestrictions(enabled: AgentSandboxEnabledSettingValue | undefined, allowNetwork: boolean | undefined): {
+        sandboxEnabled: boolean;
+        allowNetwork: boolean;
+        applyDomainRestrictions: boolean;
+    };
+    static resolveEnabled(local: AgentSandboxEnabledValue | undefined, managed: boolean | undefined): AgentSandboxEnabledValue | undefined;
+    static resolveSandboxServers(local: boolean | undefined, managed: boolean | undefined): boolean | undefined;
+    static resolveAllowBypass(local: boolean | undefined, managed: boolean | undefined, managedEnabled: boolean | undefined): boolean | undefined;
+    static resolveAllowAccess(local: boolean | undefined, managed: boolean | undefined): boolean | undefined;
+    /** Uses a managed allowlist when present and combines blocklists; runtime enforcement remains authoritative. */
+    static resolveNetworkHosts(localAllowedHosts: readonly string[] | undefined, localBlockedHosts: readonly string[] | undefined, managedAllowedHosts: readonly string[] | undefined, managedBlockedHosts: readonly string[] | undefined): {
+        allowedHosts: string[];
+        blockedHosts: string[];
+    };
+    /** Uses managed grant lists when present and combines denied paths; runtime enforcement remains authoritative. */
+    static resolveFileSystemPaths(local: SandboxFileSystemPaths | undefined, managed: SandboxFileSystemPaths | undefined): IAgentSandboxUserConfiguredPaths;
+}
+export {};

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

@@ -0,0 +1,51 @@
+
+import { isAgentSandboxEnabledValue, AgentSandboxEnabledValue } from './settings.js';
+
+function isSandboxNetworkRestrictions(value) {
+    if (!value || typeof value !== "object" || !("sandboxEnabled" in value) || !("allowNetwork" in value) || !("allowedDomains" in value) || !("deniedDomains" in value)) {
+        return false;
+    }
+    return typeof value.sandboxEnabled === "boolean" && typeof value.allowNetwork === "boolean" && Array.isArray(value.allowedDomains) && value.allowedDomains.every(domain => typeof domain === "string") && Array.isArray(value.deniedDomains) && value.deniedDomains.every(domain => typeof domain === "string");
+}
+class SandboxSettingsResolutionHelper {
+    static getNetworkRestrictions(enabled, allowNetwork) {
+        const sandboxEnabled = isAgentSandboxEnabledValue(enabled);
+        return {
+            sandboxEnabled,
+            allowNetwork: allowNetwork ?? true,
+            applyDomainRestrictions: sandboxEnabled && (allowNetwork ?? true)
+        };
+    }
+    static resolveEnabled(local, managed) {
+        return managed === true ? AgentSandboxEnabledValue.On : local;
+    }
+    static resolveSandboxServers(local, managed) {
+        return managed === true ? true : local;
+    }
+    static resolveAllowBypass(local, managed, managedEnabled) {
+        return managed === false || (managedEnabled === true && managed !== true) ? false : local;
+    }
+    static resolveAllowAccess(local, managed) {
+        return managed === false ? false : local;
+    }
+    static resolveNetworkHosts(
+        localAllowedHosts,
+        localBlockedHosts,
+        managedAllowedHosts,
+        managedBlockedHosts
+    ) {
+        return {
+            allowedHosts: [...( new Set(managedAllowedHosts ?? localAllowedHosts ?? []))],
+            blockedHosts: [...( new Set([...(localBlockedHosts ?? []), ...(managedBlockedHosts ?? [])]))]
+        };
+    }
+    static resolveFileSystemPaths(local, managed) {
+        return {
+            readwritePaths: [...( new Set(managed?.readwritePaths ?? local?.readwritePaths ?? []))],
+            readonlyPaths: [...( new Set(managed?.readonlyPaths ?? local?.readonlyPaths ?? []))],
+            deniedPaths: [...( new Set([...(local?.deniedPaths ?? []), ...(managed?.deniedPaths ?? [])]))]
+        };
+    }
+}
+
+export { SandboxSettingsResolutionHelper, isSandboxNetworkRestrictions };

package/vscode/src/vs/platform/sandbox/common/settings.d.ts

@@ -1,17 +1,37 @@
+import { OperatingSystem } from "../../../base/common/platform.js";
+export interface IAgentSandboxFileSystemSetting {
+    allowRead?: string[];
+    allowWrite?: string[];
+    denyRead?: string[];
+    denyWrite?: string[];
+}
+/** User-configured path permissions for the Copilot Agent Host sandbox. */
+export interface IAgentSandboxUserConfiguredPaths {
+    readwritePaths?: string[];
+    readonlyPaths?: string[];
+    deniedPaths?: string[];
+}
+/** Converts path separators for the sandbox's execution OS without resolving paths or patterns. */
+export declare function normalizeSandboxFileSystemPath(path: string, os: OperatingSystem): string;
+/** Whether the Local harness can sandbox terminal commands on the execution OS. */
+export declare function isTerminalSandboxSupported(os: OperatingSystem): boolean;
 /**
  * Setting IDs for agent sandboxing.
  */
 export declare enum AgentSandboxSettingId {
     AgentSandboxEnabled = "chat.agent.sandbox.enabled",
-    AgentSandboxWindowsEnabled = "chat.agent.sandbox.enabledWindows",
-    AgentSandboxAllowNetwork = "chat.agent.sandbox.allowNetwork",
+    AgentSandboxAllowNetwork = "chat.agent.sandbox.network.allowNetwork",
+    AgentSandboxAllowLocalNetwork = "chat.agent.sandbox.network.allowLocalNetwork",
     AgentSandboxAllowUnsandboxedCommands = "chat.agent.sandbox.allowUnsandboxedCommands",
+    AgentSandboxMcpServers = "chat.agent.sandbox.mcpServers",
+    AgentSandboxLspServers = "chat.agent.sandbox.lspServers",
+    AgentSandboxAuthenticateGit = "chat.agent.sandbox.credentials.authenticategit",
+    AgentSandboxAuthenticateGh = "chat.agent.sandbox.credentials.authenticategh",
+    AgentSandboxAllowDevToolAccess = "chat.agent.sandbox.fileSystem.allowDevToolAccess",
+    AgentSandboxUserConfiguredPaths = "chat.agent.sandbox.fileSystem.userConfiguredPaths",
     AgentSandboxRetryWithAllowNetworkRequests = "chat.agent.sandbox.retryWithAllowNetworkRequests",
-    AgentSandboxAllowAutoApprove = "chat.agent.sandbox.allowAutoApprove",
     AgentSandboxLinuxFileSystem = "chat.agent.sandbox.fileSystem.linux",
     AgentSandboxMacFileSystem = "chat.agent.sandbox.fileSystem.mac",
-    AgentSandboxWindowsFileSystem = "chat.agent.sandbox.fileSystem.windows",
-    AgentSandboxWindowsSchemaVersion = "chat.agent.sandbox.advanced.windows.schemaVersion",
     AgentSandboxAdvancedRuntime = "chat.agent.sandbox.advanced.runtime"
 }
 export declare enum AgentSandboxEnabledValue {

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

@@ -1,17 +1,24 @@
 
+import { OperatingSystem } from '../../../base/common/platform.js';
 
+function isTerminalSandboxSupported(os) {
+    return os !== OperatingSystem.Windows;
+}
 var AgentSandboxSettingId;
 (function (AgentSandboxSettingId) {
     AgentSandboxSettingId["AgentSandboxEnabled"] = "chat.agent.sandbox.enabled";
-    AgentSandboxSettingId["AgentSandboxWindowsEnabled"] = "chat.agent.sandbox.enabledWindows";
-    AgentSandboxSettingId["AgentSandboxAllowNetwork"] = "chat.agent.sandbox.allowNetwork";
+    AgentSandboxSettingId["AgentSandboxAllowNetwork"] = "chat.agent.sandbox.network.allowNetwork";
+    AgentSandboxSettingId["AgentSandboxAllowLocalNetwork"] = "chat.agent.sandbox.network.allowLocalNetwork";
     AgentSandboxSettingId["AgentSandboxAllowUnsandboxedCommands"] = "chat.agent.sandbox.allowUnsandboxedCommands";
+    AgentSandboxSettingId["AgentSandboxMcpServers"] = "chat.agent.sandbox.mcpServers";
+    AgentSandboxSettingId["AgentSandboxLspServers"] = "chat.agent.sandbox.lspServers";
+    AgentSandboxSettingId["AgentSandboxAuthenticateGit"] = "chat.agent.sandbox.credentials.authenticategit";
+    AgentSandboxSettingId["AgentSandboxAuthenticateGh"] = "chat.agent.sandbox.credentials.authenticategh";
+    AgentSandboxSettingId["AgentSandboxAllowDevToolAccess"] = "chat.agent.sandbox.fileSystem.allowDevToolAccess";
+    AgentSandboxSettingId["AgentSandboxUserConfiguredPaths"] = "chat.agent.sandbox.fileSystem.userConfiguredPaths";
     AgentSandboxSettingId["AgentSandboxRetryWithAllowNetworkRequests"] = "chat.agent.sandbox.retryWithAllowNetworkRequests";
-    AgentSandboxSettingId["AgentSandboxAllowAutoApprove"] = "chat.agent.sandbox.allowAutoApprove";
     AgentSandboxSettingId["AgentSandboxLinuxFileSystem"] = "chat.agent.sandbox.fileSystem.linux";
     AgentSandboxSettingId["AgentSandboxMacFileSystem"] = "chat.agent.sandbox.fileSystem.mac";
-    AgentSandboxSettingId["AgentSandboxWindowsFileSystem"] = "chat.agent.sandbox.fileSystem.windows";
-    AgentSandboxSettingId["AgentSandboxWindowsSchemaVersion"] = "chat.agent.sandbox.advanced.windows.schemaVersion";
     AgentSandboxSettingId["AgentSandboxAdvancedRuntime"] = "chat.agent.sandbox.advanced.runtime";
 })(AgentSandboxSettingId || (AgentSandboxSettingId = {}));
 var AgentSandboxEnabledValue;
@@ -32,4 +39,4 @@ function isAgentSandboxEnabledValue(value) {
     return value !== undefined && normalizeAgentSandboxEnabledValue(value) !== AgentSandboxEnabledValue.Off;
 }
 
-export { AgentSandboxEnabledValue, AgentSandboxSettingId, isAgentSandboxEnabledValue, normalizeAgentSandboxEnabledValue };
+export { AgentSandboxEnabledValue, AgentSandboxSettingId, isAgentSandboxEnabledValue, isTerminalSandboxSupported, normalizeAgentSandboxEnabledValue };

package/vscode/src/vs/platform/sandbox/common/terminalSandboxService.d.ts

@@ -0,0 +1,109 @@
+import { Event } from "../../../base/common/event.js";
+import { URI } from "../../../base/common/uri.js";
+import { OperatingSystem } from "../../../base/common/platform.js";
+import { TerminalCapability } from "../../terminal/common/capabilities/capabilities.js";
+import { ITerminalSandboxService } from "./terminalSandboxService.service.js";
+export declare function getSandboxTempDir(userHome: URI, dataFolderName: string, windowId?: number): URI;
+export interface ITerminalSandboxResolvedNetworkDomains {
+    allowedDomains: string[];
+    deniedDomains: string[];
+}
+export declare enum TerminalSandboxPrerequisiteCheck {
+    Config = "config",
+    Dependencies = "dependencies",
+    Bubblewrap = "bubblewrap"
+}
+export declare enum TerminalSandboxPreCheckRemediation {
+    DisableUnprivilagedusernamespaceRestriction = "disableUserNamespaceRestriction"
+}
+export interface ITerminalSandboxPrerequisiteCheckResult {
+    enabled: boolean;
+    sandboxConfigPath: string | undefined;
+    failedCheck: TerminalSandboxPrerequisiteCheck | undefined;
+    missingDependencies?: string[];
+    canInstallMissingDependencies?: boolean;
+    remediations?: readonly TerminalSandboxPreCheckRemediation[];
+    detail?: string;
+}
+export interface ITerminalSandboxWrapResult {
+    command: string;
+    isSandboxWrapped: boolean;
+    blockedDomains?: string[];
+    deniedDomains?: string[];
+    requiresUnsandboxConfirmation?: boolean;
+    requiresAllowNetworkConfirmation?: boolean;
+}
+export type TerminalSandboxFileAccessPermission = "read" | "write";
+export interface ITerminalSandboxFileAccessCheckResult {
+    allowed: boolean;
+    denied: string[];
+}
+export interface ITerminalSandboxPrecheckInputs {
+    /**
+     * Whether the current caller is using the default approval permission flow.
+     */
+    readonly isDefaultApprovalPermissionEnabled?: boolean;
+}
+export interface ITerminalSandboxCommand {
+    /**
+     * Normalized command name without path or executable suffix.
+     * For example, `/usr/bin/git` and `git.exe` both normalize to `git`.
+     */
+    keyword: string;
+    /**
+     * Command arguments after the executable token. These are used for
+     * argument-sensitive sandbox allow-list rules, such as matching a specific
+     * subcommand while ignoring global options.
+     */
+    args: readonly 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 NullTerminalSandboxService implements ITerminalSandboxService {
+    readonly _serviceBrand: undefined;
+    isEnabled(): Promise<boolean>;
+    isSandboxAllowNetworkEnabled(): Promise<boolean>;
+    getOS(): Promise<OperatingSystem>;
+    checkForSandboxingPrereqs(): Promise<ITerminalSandboxPrerequisiteCheckResult>;
+    wrapCommand(command: string): Promise<ITerminalSandboxWrapResult>;
+    checkFileAccess(): Promise<ITerminalSandboxFileAccessCheckResult>;
+    getSandboxConfigPath(): Promise<string | undefined>;
+    getTempDir(): URI | undefined;
+    setNeedsForceUpdateConfigFile(): void;
+    getResolvedNetworkDomains(): ITerminalSandboxResolvedNetworkDomains;
+    getMissingSandboxDependencies(): Promise<string[]>;
+    installMissingSandboxDependencies(): Promise<ISandboxDependencyInstallResult>;
+    runSandboxRemediation(): Promise<ISandboxDependencyInstallResult>;
+}

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

@@ -0,0 +1,20 @@
+
+import { URI } from '../../../base/common/uri.js';
+import '../../../base/common/platform.js';
+
+function getSandboxTempDir(userHome, dataFolderName, windowId) {
+    const sandboxRoot = URI.joinPath(userHome, dataFolderName, 'tmp');
+    return typeof windowId === 'number' ? URI.joinPath(sandboxRoot, `tmp_vscode_${windowId}`) : sandboxRoot;
+}
+var TerminalSandboxPrerequisiteCheck;
+(function (TerminalSandboxPrerequisiteCheck) {
+    TerminalSandboxPrerequisiteCheck["Config"] = "config";
+    TerminalSandboxPrerequisiteCheck["Dependencies"] = "dependencies";
+    TerminalSandboxPrerequisiteCheck["Bubblewrap"] = "bubblewrap";
+})(TerminalSandboxPrerequisiteCheck || (TerminalSandboxPrerequisiteCheck = {}));
+var TerminalSandboxPreCheckRemediation;
+(function (TerminalSandboxPreCheckRemediation) {
+    TerminalSandboxPreCheckRemediation["DisableUnprivilagedusernamespaceRestriction"] = "disableUserNamespaceRestriction";
+})(TerminalSandboxPreCheckRemediation || (TerminalSandboxPreCheckRemediation = {}));
+
+export { TerminalSandboxPreCheckRemediation, TerminalSandboxPrerequisiteCheck, getSandboxTempDir };

package/vscode/src/vs/platform/sandbox/common/terminalSandboxService.service.d.ts

@@ -1,7 +1,7 @@
 import { CancellationToken } from "../../../base/common/cancellation.js";
 import { OperatingSystem } from "../../../base/common/platform.js";
 import { URI } from "../../../sessions/sessions.web.main.internal.js";
-import { ITerminalSandboxPrecheckInputs, ITerminalSandboxPrerequisiteCheckResult, ITerminalSandboxCommand, ITerminalSandboxWrapResult, TerminalSandboxFileAccessPermission, ITerminalSandboxFileAccessCheckResult, ITerminalSandboxResolvedNetworkDomains, ISandboxDependencyInstallOptions, ISandboxDependencyInstallResult, TerminalSandboxPreCheckRemediation } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/sandbox/common/terminalSandboxService";
+import { ITerminalSandboxPrecheckInputs, ITerminalSandboxPrerequisiteCheckResult, ITerminalSandboxCommand, ITerminalSandboxWrapResult, TerminalSandboxFileAccessPermission, ITerminalSandboxFileAccessCheckResult, ITerminalSandboxResolvedNetworkDomains, ISandboxDependencyInstallOptions, ISandboxDependencyInstallResult, TerminalSandboxPreCheckRemediation } from "./terminalSandboxService.js";
 export declare const ITerminalSandboxService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<ITerminalSandboxService>;
 export interface ITerminalSandboxService {
     readonly _serviceBrand: undefined;
@@ -20,6 +20,7 @@ export interface ITerminalSandboxService {
     getSandboxConfigPath(forceRefresh?: boolean, precheckInputs?: ITerminalSandboxPrecheckInputs): Promise<string | undefined>;
     getTempDir(): URI | undefined;
     setNeedsForceUpdateConfigFile(): void;
+    /** Returns canonical allow/deny patterns, or a deny-all policy if a configured pattern cannot be normalized. */
     getResolvedNetworkDomains(): ITerminalSandboxResolvedNetworkDomains;
     getMissingSandboxDependencies(): Promise<string[]>;
     installMissingSandboxDependencies(missingDependencies: string[], sessionResource: URI | undefined, token: CancellationToken, options: ISandboxDependencyInstallOptions): Promise<ISandboxDependencyInstallResult>;

package/vscode/src/vs/platform/storage/common/storage.d.ts

@@ -122,6 +122,11 @@ export declare abstract class AbstractStorageService extends Disposable implemen
     onDidChangeValue(scope: StorageScope.PROFILE, key: string | undefined, disposable: DisposableStore): Event<IProfileStorageValueChangeEvent>;
     onDidChangeValue(scope: StorageScope.APPLICATION, key: string | undefined, disposable: DisposableStore): Event<IApplicationStorageValueChangeEvent>;
     onDidChangeValue(scope: StorageScope.APPLICATION_SHARED, key: string | undefined, disposable: DisposableStore): Event<IApplicationSharedStorageValueChangeEvent>;
+    readApplicationSharedValue(key: string): Promise<string | undefined>;
+    compareAndSwapApplicationSharedValue(key: string, expectedValue: string | undefined, newValue: string): Promise<{
+        swapped: boolean;
+        currentValue: string | undefined;
+    }>;
     private doFlushWhenIdle;
     protected shouldFlushWhenIdle(): boolean;
     protected stopFlushWhenIdle(): void;
@@ -141,7 +146,7 @@ export declare abstract class AbstractStorageService extends Disposable implemen
     remove(key: string, scope: StorageScope, external?: boolean): void;
     private withPausedEmitters;
     keys(scope: StorageScope, target: StorageTarget): string[];
-    private updateKeyTarget;
+    protected updateKeyTarget(key: string, scope: StorageScope, target: StorageTarget | undefined, external?: boolean): void;
     private _workspaceKeyTargets;
     private get workspaceKeyTargets();
     private _profileKeyTargets;