@codingame/monaco-vscode-mcp-service-override 26.2.2 → 27.0.0

package/vscode/src/vs/workbench/contrib/mcp/common/mcpRegistry.js

@@ -24,15 +24,15 @@ import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/pla
 import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
 import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
 import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
-import { IWorkspaceTrustManagementService, IWorkspaceTrustRequestService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service';
 import { IConfigurationResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolver.service';
 import { ConfigurationResolverExpression } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolverExpression';
 import { AUX_WINDOW_GROUP } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService';
 import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
 import { IMcpDevModeDebugging } from './mcpDevMode.service.js';
 import { McpRegistryInputStorage } from './mcpRegistryInputStorage.js';
+import { IMcpSandboxService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpSandboxService.service';
 import { McpServerConnection } from './mcpServerConnection.js';
-import { LazyCollectionState, UserInteractionRequiredError, McpServerTrust, McpStartServerInteraction } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { LazyCollectionState, McpServerTrust, UserInteractionRequiredError, McpStartServerInteraction } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
 import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
 import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
@@ -53,8 +53,7 @@ let McpRegistry = class McpRegistry extends Disposable {
         _quickInputService,
         _labelService,
         _logService,
-        _workspaceTrustManagementService,
-        _workspaceTrustRequestService
+        _mcpSandboxService
     ) {
         super();
         this._instantiationService = _instantiationService;
@@ -65,8 +64,7 @@ let McpRegistry = class McpRegistry extends Disposable {
         this._quickInputService = _quickInputService;
         this._labelService = _labelService;
         this._logService = _logService;
-        this._workspaceTrustManagementService = _workspaceTrustManagementService;
-        this._workspaceTrustRequestService = _workspaceTrustRequestService;
+        this._mcpSandboxService = _mcpSandboxService;
         this._collections = observableValue("collections", []);
         this._delegates = observableValue("delegates", []);
         this.collections = derived(reader => {
@@ -220,15 +218,6 @@ let McpRegistry = class McpRegistry extends Disposable {
             errorOnUserInteraction = false
         }
     ) {
-        if (collection.scope === StorageScope.WORKSPACE && !this._workspaceTrustManagementService.isWorkspaceTrusted()) {
-            if (errorOnUserInteraction) {
-                throw ( new UserInteractionRequiredError("workspaceTrust"));
-            } else if (!(await this._workspaceTrustRequestService.requestWorkspaceTrust({
-                message: ( localize(9539, "This MCP server definition is defined in your workspace files."))
-            }))) {
-                return false;
-            }
-        }
         if (collection.trustBehavior === McpServerTrust.Kind.Trusted) {
             this._logService.trace(`MCP server ${definition.id} is trusted, no trust prompt needed`);
             return true;
@@ -302,7 +291,7 @@ let McpRegistry = class McpRegistry extends Disposable {
             const originURI = r.definition.presentation?.origin?.uri || r.collection.presentation?.origin;
             let labelWithOrigin = originURI ? `[\`${r.definition.label}\`](${originURI})` : "`" + r.definition.label + "`";
             if (r.collection.source instanceof ExtensionIdentifier) {
-                labelWithOrigin += ` (${( localize(9540, "from {0}", r.collection.source.value))})`;
+                labelWithOrigin += ` (${( localize(10243, "from {0}", r.collection.source.value))})`;
             }
             return labelWithOrigin;
         }
@@ -312,12 +301,12 @@ let McpRegistry = class McpRegistry extends Disposable {
             const {
                 result
             } = await this._dialogService.prompt({
-                message: ( localize(9541, "Trust and run MCP server {0}?", def.definition.label)),
+                message: ( localize(10244, "Trust and run MCP server {0}?", def.definition.label)),
                 custom: {
                     icon: Codicon.shield,
                     markdownDetails: [{
                         markdown: ( new MarkdownString(( localize(
-                            9542,
+                            10245,
                             "The MCP server {0} was updated. MCP servers may add context to your chat session and lead to unexpected behavior. Do you want to trust and run this server?",
                             labelFor(def)
                         )))),
@@ -330,10 +319,10 @@ let McpRegistry = class McpRegistry extends Disposable {
                     }]
                 },
                 buttons: [{
-                    label: ( localize(9543, "Trust")),
+                    label: ( localize(10246, "Trust")),
                     run: () => true
                 }, {
-                    label: ( localize(9544, "Do not trust")),
+                    label: ( localize(10247, "Do not trust")),
                     run: () => false
                 }]
             });
@@ -343,12 +332,12 @@ let McpRegistry = class McpRegistry extends Disposable {
         const {
             result
         } = await this._dialogService.prompt({
-            message: ( localize(9545, "Trust and run {0} MCP servers?", definitions.length)),
+            message: ( localize(10248, "Trust and run {0} MCP servers?", definitions.length)),
             custom: {
                 icon: Codicon.shield,
                 markdownDetails: [{
                     markdown: ( new MarkdownString(( localize(
-                        9546,
+                        10249,
                         "Several updated MCP servers were discovered:\n\n{0}\n\n MCP servers may add context to your chat session and lead to unexpected behavior. Do you want to trust and run these server?",
                         list
                     )))),
@@ -361,13 +350,13 @@ let McpRegistry = class McpRegistry extends Disposable {
                 }]
             },
             buttons: [{
-                label: ( localize(9543, "Trust")),
+                label: ( localize(10246, "Trust")),
                 run: () => "all"
             }, {
-                label: ( localize(9547, "Pick Trusted")),
+                label: ( localize(10250, "Pick Trusted")),
                 run: () => "pick"
             }, {
-                label: ( localize(9544, "Do not trust")),
+                label: ( localize(10247, "Do not trust")),
                 run: () => "none"
             }]
         });
@@ -423,13 +412,13 @@ let McpRegistry = class McpRegistry extends Disposable {
             }
         }));
         return ( new Promise(resolve => {
-            picker.onDidAccept(() => {
+            store.add(picker.onDidAccept(() => {
                 resolve(( picker.selectedItems.map(item => item.definitonId)));
                 picker.hide();
-            });
-            picker.onDidHide(() => {
+            }));
+            store.add(picker.onDidHide(() => {
                 resolve(undefined);
-            });
+            }));
             picker.show();
         })).finally(() => store.dispose());
     }
@@ -518,20 +507,26 @@ let McpRegistry = class McpRegistry extends Disposable {
                     accessor => accessor.get(IMcpDevModeDebugging).transform(definition, launch)
                 );
             }
+            launch = await this._mcpSandboxService.launchInSandboxIfEnabled(
+                definition,
+                launch,
+                collection.remoteAuthority ?? undefined,
+                collection.configTarget
+            );
         } catch (e) {
             if (e instanceof UserInteractionRequiredError) {
                 throw e;
             }
             this._notificationService.notify({
                 severity: Severity.Error,
-                message: ( localize(9548, "Error starting {0}: {1}", definition.label, String(e))),
+                message: ( localize(10251, "Error starting {0}: {1}", definition.label, String(e))),
                 actions: {
                     primary: collection.presentation?.origin && [{
                         id: "mcp.launchError.openConfig",
                         class: undefined,
                         enabled: true,
                         tooltip: "",
-                        label: ( localize(9549, "Open Configuration")),
+                        label: ( localize(10252, "Open Configuration")),
                         run: () => this._editorService.openEditor({
                             resource: collection.presentation.origin,
                             options: {
@@ -555,6 +550,6 @@ let McpRegistry = class McpRegistry extends Disposable {
         );
     }
 };
-McpRegistry = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IConfigurationResolverService)), ( __param(2, IDialogService)), ( __param(3, INotificationService)), ( __param(4, IEditorService)), ( __param(5, IConfigurationService)), ( __param(6, IQuickInputService)), ( __param(7, ILabelService)), ( __param(8, ILogService)), ( __param(9, IWorkspaceTrustManagementService)), ( __param(10, IWorkspaceTrustRequestService))], McpRegistry));
+McpRegistry = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IConfigurationResolverService)), ( __param(2, IDialogService)), ( __param(3, INotificationService)), ( __param(4, IEditorService)), ( __param(5, IConfigurationService)), ( __param(6, IQuickInputService)), ( __param(7, ILabelService)), ( __param(8, ILogService)), ( __param(9, IMcpSandboxService))], McpRegistry));
 
 export { McpRegistry };

package/vscode/src/vs/workbench/contrib/mcp/common/mcpSamplingLog.js

@@ -41,7 +41,7 @@ let McpSamplingLog = class McpSamplingLog extends Disposable {
         }
         const parts = [];
         const total = record.bins.reduce((sum, value) => sum + value, 0);
-        parts.push(( localize(9550, "{0} total requests in the last 7 days.", total)));
+        parts.push(( localize(10253, "{0} total requests in the last 7 days.", total)));
         parts.push(this._formatRecentRequests(record));
         return parts.join("\n");
     }

package/vscode/src/vs/workbench/contrib/mcp/common/mcpSamplingService.js

@@ -132,11 +132,11 @@ let McpSamplingService = class McpSamplingService extends Disposable {
                 return this._getMatchingModel(opts);
             }
             const retry = await this._showContextual(opts.isDuringToolCall, ( localize(
-                9551,
+                10254,
                 "Allow MCP tools from \"{0}\" to make LLM requests?",
                 opts.server.definition.label
             )), ( localize(
-                9552,
+                10255,
                 "The MCP server \"{0}\" has issued a request to make a language model call. Do you want to allow it to make requests during chat?",
                 opts.server.definition.label
             )), this.allowButtons(opts.server, "allowedDuringChat"));
@@ -150,11 +150,11 @@ let McpSamplingService = class McpSamplingService extends Disposable {
                 return this._getMatchingModel(opts);
             }
             const retry = await this._showContextual(opts.isDuringToolCall, ( localize(
-                9553,
+                10256,
                 "Allow MCP server \"{0}\" to make LLM requests?",
                 opts.server.definition.label
             )), ( localize(
-                9554,
+                10257,
                 "The MCP server \"{0}\" has issued a request to make a language model call. Do you want to allow it to make requests, outside of tool calls during chat?",
                 opts.server.definition.label
             )), this.allowButtons(opts.server, "allowedOutsideChat"));
@@ -166,12 +166,12 @@ let McpSamplingService = class McpSamplingService extends Disposable {
             throw McpError.notAllowed();
         } else if (model === ModelMatch.NoMatchingModel) {
             const newlyPickedModels = opts.isDuringToolCall ? await this._commandService.executeCommand(McpCommandIds.ConfigureSamplingModels, opts.server) : await this._notify(( localize(
-                9555,
+                10258,
                 "MCP server \"{0}\" triggered a language model request, but it has no allowlisted models.",
                 opts.server.definition.label
             )), {
-                [( localize(9556, "Configure"))]: () => this._commandService.executeCommand(McpCommandIds.ConfigureSamplingModels, opts.server),
-                [( localize(9557, "Cancel"))]: () => Promise.resolve(undefined)
+                [( localize(10259, "Configure"))]: () => this._commandService.executeCommand(McpCommandIds.ConfigureSamplingModels, opts.server),
+                [( localize(10260, "Cancel"))]: () => Promise.resolve(undefined)
             });
             if (newlyPickedModels) {
                 return this._getMatchingModel(opts);
@@ -182,19 +182,19 @@ let McpSamplingService = class McpSamplingService extends Disposable {
     }
     allowButtons(server, key) {
         return {
-            [( localize(9558, "Allow in this Session"))]: async () => {
+            [( localize(10261, "Allow in this Session"))]: async () => {
                 this._sessionSets[key].set(server.definition.id, true);
                 return true;
             },
-            [( localize(9559, "Always"))]: async () => {
+            [( localize(10262, "Always"))]: async () => {
                 await this.updateConfig(server, c => c[key] = true);
                 return true;
             },
-            [( localize(9560, "Not Now"))]: async () => {
+            [( localize(10263, "Not Now"))]: async () => {
                 this._sessionSets[key].set(server.definition.id, false);
                 return false;
             },
-            [( localize(9561, "Never"))]: async () => {
+            [( localize(10264, "Never"))]: async () => {
                 await this.updateConfig(server, c => c[key] = false);
                 return false;
             }

package/vscode/src/vs/workbench/contrib/mcp/common/mcpSandboxService.d.ts

@@ -0,0 +1,34 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ConfigurationTarget } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration";
+import { IEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IRemoteAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service";
+import { McpServerDefinition, McpServerLaunch } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
+import { IMcpSandboxService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpSandboxService.service";
+export declare class McpSandboxService extends Disposable implements IMcpSandboxService {
+    private readonly _fileService;
+    private readonly _environmentService;
+    private readonly _logService;
+    private readonly _remoteAgentService;
+    readonly _serviceBrand: undefined;
+    private _sandboxSettingsId;
+    private _remoteEnvDetailsPromise;
+    private readonly _defaultAllowedDomains;
+    private _sandboxConfigPerConfigurationTarget;
+    constructor(_fileService: IFileService, _environmentService: IEnvironmentService, _logService: ILogService, _remoteAgentService: IRemoteAgentService);
+    isEnabled(serverDef: McpServerDefinition, remoteAuthority?: string): Promise<boolean>;
+    launchInSandboxIfEnabled(serverDef: McpServerDefinition, launch: McpServerLaunch, remoteAuthority: string | undefined, configTarget: ConfigurationTarget): Promise<McpServerLaunch>;
+    private _resolveSandboxLaunchDetails;
+    private _getExecPath;
+    private _getSandboxEnvVariables;
+    private _getSandboxCommandArgs;
+    private _getRemoteEnv;
+    private _getOperatingSystem;
+    private _getAppRoot;
+    private _getTempDir;
+    private _updateSandboxConfig;
+    private _withDefaultSandboxConfig;
+    private _getDefaultAllowWrite;
+    private _pathJoin;
+}

package/vscode/src/vs/workbench/contrib/mcp/common/mcpSandboxService.js

@@ -0,0 +1,233 @@
+
+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 { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { FileAccess } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { win32, posix, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import { OperatingSystem, OS } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+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 { ConfigurationTargetToString } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
+import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IRemoteAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
+import { McpServerTransportType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+
+let McpSandboxService = class McpSandboxService extends Disposable {
+    constructor(_fileService, _environmentService, _logService, _remoteAgentService) {
+        super();
+        this._fileService = _fileService;
+        this._environmentService = _environmentService;
+        this._logService = _logService;
+        this._remoteAgentService = _remoteAgentService;
+        this._defaultAllowedDomains = ["*.npmjs.org"];
+        this._sandboxConfigPerConfigurationTarget = ( new Map());
+        this._pathJoin = (os, ...segments) => {
+            const path = os === OperatingSystem.Windows ? win32 : posix;
+            return path.join(...segments);
+        };
+        this._sandboxSettingsId = generateUuid();
+        this._remoteEnvDetailsPromise = this._remoteAgentService.getEnvironment();
+    }
+    async isEnabled(serverDef, remoteAuthority) {
+        const os = await this._getOperatingSystem(remoteAuthority);
+        if (os === OperatingSystem.Windows) {
+            return false;
+        }
+        return !!serverDef.sandboxEnabled;
+    }
+    async launchInSandboxIfEnabled(serverDef, launch, remoteAuthority, configTarget) {
+        if (launch.type !== McpServerTransportType.Stdio) {
+            return launch;
+        }
+        if (await this.isEnabled(serverDef, remoteAuthority)) {
+            this._logService.trace(`McpSandboxService: Launching with config target ${configTarget}`);
+            const launchDetails = await this._resolveSandboxLaunchDetails(configTarget, remoteAuthority, serverDef.sandbox);
+            const sandboxArgs = this._getSandboxCommandArgs(launch.command, launch.args, launchDetails.sandboxConfigPath);
+            const sandboxEnv = this._getSandboxEnvVariables(launchDetails.tempDir, remoteAuthority);
+            if (launchDetails.srtPath) {
+                const envWithSandbox = sandboxEnv ? {
+                    ...launch.env,
+                    ...sandboxEnv
+                } : launch.env;
+                if (launchDetails.execPath) {
+                    return {
+                        ...launch,
+                        command: launchDetails.execPath,
+                        args: [launchDetails.srtPath, ...sandboxArgs],
+                        env: envWithSandbox,
+                        type: McpServerTransportType.Stdio
+                    };
+                } else {
+                    return {
+                        ...launch,
+                        command: launchDetails.srtPath,
+                        args: sandboxArgs,
+                        env: envWithSandbox,
+                        type: McpServerTransportType.Stdio
+                    };
+                }
+            }
+            if (!launchDetails.execPath) {
+                this._logService.warn(
+                    "McpSandboxService: execPath is unavailable, launching without sandbox runtime wrapper"
+                );
+            }
+            this._logService.debug(
+                `McpSandboxService: launch details for server ${serverDef.label} - command: ${launch.command}, args: ${launch.args.join(" ")}`
+            );
+        }
+        return launch;
+    }
+    async _resolveSandboxLaunchDetails(configTarget, remoteAuthority, sandboxConfig) {
+        const os = await this._getOperatingSystem(remoteAuthority);
+        if (os === OperatingSystem.Windows) {
+            return {
+                execPath: undefined,
+                srtPath: undefined,
+                sandboxConfigPath: undefined,
+                tempDir: undefined
+            };
+        }
+        const appRoot = await this._getAppRoot(remoteAuthority);
+        const execPath = await this._getExecPath(os, appRoot, remoteAuthority);
+        const tempDir = await this._getTempDir(remoteAuthority);
+        const srtPath = this._pathJoin(
+            os,
+            appRoot,
+            "node_modules",
+            "@anthropic-ai",
+            "sandbox-runtime",
+            "dist",
+            "cli.js"
+        );
+        const sandboxConfigPath = tempDir ? await this._updateSandboxConfig(tempDir, configTarget, sandboxConfig) : undefined;
+        this._logService.debug(`McpSandboxService: Updated sandbox config path: ${sandboxConfigPath}`);
+        return {
+            execPath,
+            srtPath,
+            sandboxConfigPath,
+            tempDir
+        };
+    }
+    async _getExecPath(os, appRoot, remoteAuthority) {
+        if (remoteAuthority) {
+            return this._pathJoin(os, appRoot, "node");
+        }
+        return undefined;
+    }
+    _getSandboxEnvVariables(tempDir, remoteAuthority) {
+        let env = {};
+        if (tempDir) {
+            env = {
+                TMPDIR: tempDir.path,
+                SRT_DEBUG: "true"
+            };
+        }
+        if (!remoteAuthority) {
+            env = {
+                ...env,
+                ELECTRON_RUN_AS_NODE: "1"
+            };
+        }
+        env["VSCODE_INSPECTOR_OPTIONS"] = null;
+        return env;
+    }
+    _getSandboxCommandArgs(command, args, sandboxConfigPath) {
+        const result = [];
+        if (sandboxConfigPath) {
+            result.push("--settings", sandboxConfigPath);
+        }
+        result.push(command, ...args);
+        return result;
+    }
+    async _getRemoteEnv(remoteAuthority) {
+        if (!remoteAuthority) {
+            return null;
+        }
+        return this._remoteEnvDetailsPromise;
+    }
+    async _getOperatingSystem(remoteAuthority) {
+        const remoteEnv = await this._getRemoteEnv(remoteAuthority);
+        if (remoteEnv) {
+            return remoteEnv.os;
+        }
+        return OS;
+    }
+    async _getAppRoot(remoteAuthority) {
+        const remoteEnv = await this._getRemoteEnv(remoteAuthority);
+        if (remoteEnv) {
+            return remoteEnv.appRoot.path;
+        }
+        return dirname(( FileAccess.asFileUri("")).path);
+    }
+    async _getTempDir(remoteAuthority) {
+        const remoteEnv = await this._getRemoteEnv(remoteAuthority);
+        if (remoteEnv) {
+            return remoteEnv.tmpDir;
+        }
+        const environmentService = this._environmentService;
+        const tempDir = environmentService.tmpDir;
+        if (!tempDir) {
+            this._logService.warn(
+                "McpSandboxService: Cannot create sandbox settings file because no tmpDir is available in this environment"
+            );
+        }
+        return tempDir;
+    }
+    async _updateSandboxConfig(tempDir, configTarget, sandboxConfig) {
+        const normalizedSandboxConfig = this._withDefaultSandboxConfig(sandboxConfig);
+        let configFileUri;
+        const configTargetKey = ConfigurationTargetToString(configTarget);
+        if (( this._sandboxConfigPerConfigurationTarget.has(configTargetKey))) {
+            configFileUri = ( URI.parse(this._sandboxConfigPerConfigurationTarget.get(configTargetKey)));
+        } else {
+            configFileUri = URI.joinPath(
+                tempDir,
+                `vscode-${configTargetKey}-mcp-sandbox-settings-${this._sandboxSettingsId}.json`
+            );
+            this._sandboxConfigPerConfigurationTarget.set(configTargetKey, ( configFileUri.toString()));
+        }
+        await this._fileService.createFile(
+            configFileUri,
+            VSBuffer.fromString(JSON.stringify(normalizedSandboxConfig, null, "\t")),
+            {
+                overwrite: true
+            }
+        );
+        return configFileUri.path;
+    }
+    _withDefaultSandboxConfig(sandboxConfig) {
+        const mergedAllowWrite = ( new Set(sandboxConfig?.filesystem?.allowWrite ?? []));
+        for (const defaultAllowWrite of this._getDefaultAllowWrite()) {
+            if (defaultAllowWrite) {
+                mergedAllowWrite.add(defaultAllowWrite);
+            }
+        }
+        const mergedAllowedDomains = ( new Set(sandboxConfig?.network?.allowedDomains ?? []));
+        for (const defaultAllowedDomain of this._defaultAllowedDomains) {
+            if (defaultAllowedDomain) {
+                mergedAllowedDomains.add(defaultAllowedDomain);
+            }
+        }
+        return {
+            ...sandboxConfig,
+            network: {
+                allowedDomains: [...mergedAllowedDomains],
+                deniedDomains: sandboxConfig?.network?.deniedDomains ?? []
+            },
+            filesystem: {
+                allowWrite: [...mergedAllowWrite],
+                denyRead: sandboxConfig?.filesystem?.denyRead ?? [],
+                denyWrite: sandboxConfig?.filesystem?.denyWrite ?? []
+            }
+        };
+    }
+    _getDefaultAllowWrite() {
+        return ["~/.npm"];
+    }
+};
+McpSandboxService = ( __decorate([( __param(0, IFileService)), ( __param(1, IEnvironmentService)), ( __param(2, ILogService)), ( __param(3, IRemoteAgentService))], McpSandboxService));
+
+export { McpSandboxService };

package/vscode/src/vs/workbench/contrib/mcp/common/mcpServerConnection.js

@@ -49,7 +49,7 @@ let McpServerConnection = class McpServerConnection extends Disposable {
         this._state.set({
             state: McpConnectionState.Kind.Starting
         }, undefined);
-        this._logger.info(( localize(9571, "Starting server {0}", this.definition.label)));
+        this._logger.info(( localize(10274, "Starting server {0}", this.definition.label)));
         try {
             const launch = this._delegate.start(this._collection, this.definition, this.launchDefinition, {
                 errorOnUserInteraction: this._errorOnUserInteraction
@@ -82,7 +82,7 @@ let McpServerConnection = class McpServerConnection extends Disposable {
         store.add(autorun(reader => {
             const state = launch.state.read(reader);
             this._state.set(state, undefined);
-            this._logger.info(( localize(9572, "Connection state: {0}", (McpConnectionState.toString(state)))));
+            this._logger.info(( localize(10275, "Connection state: {0}", (McpConnectionState.toString(state)))));
             if (state.state === McpConnectionState.Kind.Running && !didStart) {
                 didStart = true;
                 McpServerRequestHandler.create(this._instantiationService, {
@@ -121,7 +121,7 @@ let McpServerConnection = class McpServerConnection extends Disposable {
         };
     }
     async stop() {
-        this._logger.info(( localize(9573, "Stopping server {0}", this.definition.label)));
+        this._logger.info(( localize(10276, "Stopping server {0}", this.definition.label)));
         this._launch.value?.object.stop();
         await this._waitForState(McpConnectionState.Kind.Stopped, McpConnectionState.Kind.Error);
     }

package/vscode/src/vs/workbench/contrib/mcp/common/mcpServerRequestHandler.d.ts

@@ -27,8 +27,7 @@ export interface IMcpServerRequestHandlerOptions extends IMcpClientMethods {
  * handling of ping requests and typed client request methods.
  */
 export declare class McpServerRequestHandler extends Disposable {
-    private _nextRequestId;
-    private readonly _pendingRequests;
+    private readonly _rpc;
     private _hasAnnouncedRoots;
     private _roots;
     set roots(roots: MCP.Root[]);
@@ -83,18 +82,6 @@ export declare class McpServerRequestHandler extends Disposable {
      */
     private sendRequestPaginated;
     private sendNotification;
-    /**
-     * Handle incoming messages from the server
-     */
-    private handleMessage;
-    /**
-     * Handle successful responses
-     */
-    private handleResult;
-    /**
-     * Handle error responses
-     */
-    private handleError;
     /**
      * Handle incoming server requests
      */
@@ -105,10 +92,6 @@ export declare class McpServerRequestHandler extends Disposable {
     private handleServerNotification;
     private handleCancelledNotification;
     private handleLoggingNotification;
-    /**
-     * Send a generic response to a request
-     */
-    private respondToRequest;
     /**
      * Send a response to a ping request
      */