@codingame/monaco-vscode-mcp-service-override 16.0.0

package/vscode/src/vs/workbench/contrib/mcp/common/discovery/configMcpDiscovery.js

@@ -0,0 +1,146 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { Throttler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { getMcpServerMapping } from '../mcpConfigFileUtils.js';
+import { IMcpConfigPathsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpConfigPathsService.service';
+import { mcpConfigurationSection } from '@codingame/monaco-vscode-ec21d4de-4d65-574c-8715-bb1a6bbad376-common/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration';
+import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
+import { McpServerTransportType, McpServerDefinition } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { autorunDelta } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/base';
+
+let ConfigMcpDiscovery = class ConfigMcpDiscovery extends Disposable {
+    constructor(_configurationService, _mcpRegistry, _textModelService, _mcpConfigPathsService) {
+        super();
+        this._configurationService = _configurationService;
+        this._mcpRegistry = _mcpRegistry;
+        this._textModelService = _textModelService;
+        this._mcpConfigPathsService = _mcpConfigPathsService;
+        this.configSources = [];
+    }
+    start() {
+        const throttler = this._register(( new Throttler()));
+        const addPath = (path) => {
+            this.configSources.push({
+                path,
+                serverDefinitions: observableValue(this, []),
+                disposable: this._register(( new MutableDisposable())),
+                getServerToLocationMapping: (uri) => this._getServerIdMapping(uri, path.section ? [...path.section, 'servers'] : ['servers']),
+            });
+        };
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(mcpConfigurationSection)) {
+                throttler.queue(() => this.sync());
+            }
+        }));
+        this._register(autorunDelta(this._mcpConfigPathsService.paths, ({ lastValue, newValue }) => {
+            for (const last of lastValue || []) {
+                if (!newValue.includes(last)) {
+                    const idx = this.configSources.findIndex(src => src.path.id === last.id);
+                    if (idx !== -1) {
+                        this.configSources[idx].disposable.dispose();
+                        this.configSources.splice(idx, 1);
+                    }
+                }
+            }
+            for (const next of newValue) {
+                if (!lastValue || !lastValue.includes(next)) {
+                    addPath(next);
+                }
+            }
+            this.sync();
+        }));
+    }
+    async _getServerIdMapping(resource, pathToServers) {
+        const store = ( new DisposableStore());
+        try {
+            const ref = await this._textModelService.createModelReference(resource);
+            store.add(ref);
+            const serverIdMapping = getMcpServerMapping({ model: ref.object.textEditorModel, pathToServers });
+            return serverIdMapping;
+        }
+        catch {
+            return ( new Map());
+        }
+        finally {
+            store.dispose();
+        }
+    }
+    async sync() {
+        const configurationKey = this._configurationService.inspect(mcpConfigurationSection);
+        const configMappings = await Promise.all(( this.configSources.map(src => {
+            const uri = src.path.uri;
+            return uri && src.getServerToLocationMapping(uri);
+        })));
+        for (const [index, src] of this.configSources.entries()) {
+            const collectionId = `mcp.config.${src.path.id}`;
+            let value = src.path.workspaceFolder
+                ? this._configurationService.inspect(mcpConfigurationSection, { resource: src.path.workspaceFolder.uri })[src.path.key]
+                : configurationKey[src.path.key];
+            if (value?.mcpServers) {
+                value = { ...value, servers: { ...value.servers, ...value.mcpServers }, mcpServers: undefined };
+                this._configurationService.updateValue(mcpConfigurationSection, value, {}, src.path.target, { donotNotifyError: true });
+            }
+            const configMapping = configMappings[index];
+            const nextDefinitions = ( Object.entries(value?.servers || {}).map(([name, value]) => ({
+                id: `${collectionId}.${name}`,
+                label: name,
+                launch: 'type' in value && value.type === 'sse' ? {
+                    type: McpServerTransportType.SSE,
+                    uri: ( URI.parse(value.url)),
+                    headers: Object.entries(value.headers || {}),
+                } : {
+                    type: McpServerTransportType.Stdio,
+                    args: value.args || [],
+                    command: value.command,
+                    env: value.env || {},
+                    envFile: value.envFile,
+                    cwd: undefined,
+                },
+                roots: src.path.workspaceFolder ? [src.path.workspaceFolder.uri] : [],
+                variableReplacement: {
+                    folder: src.path.workspaceFolder,
+                    section: mcpConfigurationSection,
+                    target: src.path.target,
+                },
+                presentation: {
+                    order: src.path.order,
+                    origin: configMapping?.get(name),
+                }
+            })));
+            if (equals(nextDefinitions, src.serverDefinitions.get(), McpServerDefinition.equals)) {
+                continue;
+            }
+            if (!nextDefinitions.length) {
+                src.disposable.clear();
+                src.serverDefinitions.set(nextDefinitions, undefined);
+            }
+            else {
+                src.serverDefinitions.set(nextDefinitions, undefined);
+                src.disposable.value ??= this._mcpRegistry.registerCollection({
+                    id: collectionId,
+                    label: src.path.label,
+                    presentation: { order: src.path.order, origin: src.path.uri },
+                    remoteAuthority: src.path.remoteAuthority || null,
+                    serverDefinitions: src.serverDefinitions,
+                    isTrustedByDefault: true,
+                    scope: src.path.scope,
+                });
+            }
+        }
+    }
+};
+ConfigMcpDiscovery = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IMcpRegistry)),
+    ( __param(2, ITextModelService)),
+    ( __param(3, IMcpConfigPathsService))
+], ConfigMcpDiscovery));
+
+export { ConfigMcpDiscovery };

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

@@ -0,0 +1,15 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { IMcpRegistry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service";
+import { IMcpDiscovery } from "./mcpDiscovery.js";
+export declare class ExtensionMcpDiscovery extends Disposable implements IMcpDiscovery {
+    private readonly _mcpRegistry;
+    private readonly _extensionService;
+    private readonly _extensionCollectionIdsToPersist;
+    private readonly cachedServers;
+    constructor(_mcpRegistry: IMcpRegistry, storageService: IStorageService, _extensionService: IExtensionService);
+    start(): void;
+    private _activateExtensionServers;
+    private static _validate;
+}

package/vscode/src/vs/workbench/contrib/mcp/common/discovery/extensionMcpDiscovery.js

@@ -0,0 +1,108 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isFalsyOrWhitespace } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { ExtensionsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
+import { mcpContributionPoint, mcpActivationEvent } from '@codingame/monaco-vscode-ec21d4de-4d65-574c-8715-bb1a6bbad376-common/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration';
+import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
+import { McpServerDefinition, extensionPrefixedIdentifier } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/base';
+
+var ExtensionMcpDiscovery_1;
+const cacheKey = 'mcp.extCachedServers';
+const _mcpExtensionPoint = ExtensionsRegistry.registerExtensionPoint(mcpContributionPoint);
+let ExtensionMcpDiscovery = ExtensionMcpDiscovery_1 = class ExtensionMcpDiscovery extends Disposable {
+    constructor(_mcpRegistry, storageService, _extensionService) {
+        super();
+        this._mcpRegistry = _mcpRegistry;
+        this._extensionService = _extensionService;
+        this._extensionCollectionIdsToPersist = ( new Set());
+        this.cachedServers = storageService.getObject(cacheKey, StorageScope.WORKSPACE, {});
+        this._register(storageService.onWillSaveState(() => {
+            let updated = false;
+            for (const collectionId of this._extensionCollectionIdsToPersist) {
+                const collection = this._mcpRegistry.collections.get().find(c => c.id === collectionId);
+                if (!collection || collection.lazy) {
+                    continue;
+                }
+                const defs = collection.serverDefinitions.get();
+                if (defs) {
+                    updated = true;
+                    this.cachedServers[collectionId] = { servers: ( defs.map(McpServerDefinition.toSerialized)) };
+                }
+            }
+            if (updated) {
+                storageService.store(cacheKey, this.cachedServers, StorageScope.WORKSPACE, StorageTarget.MACHINE);
+            }
+        }));
+    }
+    start() {
+        const extensionCollections = this._register(( new DisposableMap()));
+        this._register(_mcpExtensionPoint.setHandler((_extensions, delta) => {
+            const { added, removed } = delta;
+            for (const collections of removed) {
+                for (const coll of collections.value) {
+                    extensionCollections.deleteAndDispose(extensionPrefixedIdentifier(collections.description.identifier, coll.id));
+                }
+            }
+            for (const collections of added) {
+                if (!ExtensionMcpDiscovery_1._validate(collections)) {
+                    continue;
+                }
+                for (const coll of collections.value) {
+                    const id = extensionPrefixedIdentifier(collections.description.identifier, coll.id);
+                    this._extensionCollectionIdsToPersist.add(id);
+                    const serverDefs = this.cachedServers.hasOwnProperty(id) ? this.cachedServers[id].servers : undefined;
+                    const dispo = this._mcpRegistry.registerCollection({
+                        id,
+                        label: coll.label,
+                        remoteAuthority: null,
+                        isTrustedByDefault: true,
+                        scope: StorageScope.WORKSPACE,
+                        serverDefinitions: observableValue(this, serverDefs?.map(McpServerDefinition.fromSerialized) || []),
+                        lazy: {
+                            isCached: !!serverDefs,
+                            load: () => this._activateExtensionServers(coll.id),
+                            removed: () => extensionCollections.deleteAndDispose(id),
+                        }
+                    });
+                    extensionCollections.set(id, dispo);
+                }
+            }
+        }));
+    }
+    async _activateExtensionServers(collectionId) {
+        await this._extensionService.activateByEvent(mcpActivationEvent(collectionId));
+        await Promise.all(( this._mcpRegistry.delegates
+            .map(r => r.waitForInitialProviderPromises())));
+    }
+    static _validate(user) {
+        if (!Array.isArray(user.value)) {
+            user.collector.error(( localize(7631, "Expected an array of MCP collections")));
+            return false;
+        }
+        for (const contribution of user.value) {
+            if (typeof contribution.id !== 'string' || isFalsyOrWhitespace(contribution.id)) {
+                user.collector.error(( localize(7632, "Expected 'id' to be a non-empty string.")));
+                return false;
+            }
+            if (typeof contribution.label !== 'string' || isFalsyOrWhitespace(contribution.label)) {
+                user.collector.error(( localize(7633, "Expected 'label' to be a non-empty string.")));
+                return false;
+            }
+        }
+        return true;
+    }
+};
+ExtensionMcpDiscovery = ExtensionMcpDiscovery_1 = ( __decorate([
+    ( __param(0, IMcpRegistry)),
+    ( __param(1, IStorageService)),
+    ( __param(2, IExtensionService))
+], ExtensionMcpDiscovery));
+
+export { ExtensionMcpDiscovery };

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

@@ -0,0 +1,12 @@
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { SyncDescriptor0 } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors";
+export interface IMcpDiscovery extends IDisposable {
+    start(): void;
+}
+declare class McpDiscoveryRegistry {
+    private readonly _discovery;
+    register(discovery: SyncDescriptor0<IMcpDiscovery>): void;
+    getAll(): readonly SyncDescriptor0<IMcpDiscovery>[];
+}
+export declare const mcpDiscoveryRegistry: McpDiscoveryRegistry;
+export {};

package/vscode/src/vs/workbench/contrib/mcp/common/discovery/mcpDiscovery.js

@@ -0,0 +1,16 @@
+
+
+class McpDiscoveryRegistry {
+    constructor() {
+        this._discovery = [];
+    }
+    register(discovery) {
+        this._discovery.push(discovery);
+    }
+    getAll() {
+        return this._discovery;
+    }
+}
+const mcpDiscoveryRegistry = ( new McpDiscoveryRegistry());
+
+export { mcpDiscoveryRegistry };

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

@@ -0,0 +1,34 @@
+import { VSBuffer } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buffer";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable, IReader, ISettableObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
+import { INativeMcpDiscoveryData } from "../../../../../platform/mcp/common/nativeMcpDiscoveryHelper.js";
+import { Dto } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/proxyIdentifier";
+import { DiscoverySource } from "@codingame/monaco-vscode-ec21d4de-4d65-574c-8715-bb1a6bbad376-common/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration";
+import { IMcpRegistry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service";
+import { McpCollectionDefinition, McpServerDefinition } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
+import { IMcpDiscovery } from "./mcpDiscovery.js";
+export type WritableMcpCollectionDefinition = McpCollectionDefinition & {
+    serverDefinitions: ISettableObservable<readonly McpServerDefinition[]>;
+};
+export declare abstract class FilesystemMcpDiscovery extends Disposable {
+    private readonly _fileService;
+    private readonly _mcpRegistry;
+    protected readonly _fsDiscoveryEnabled: IObservable<boolean | {
+        [K in DiscoverySource]: boolean;
+    }>;
+    constructor(configurationService: IConfigurationService, _fileService: IFileService, _mcpRegistry: IMcpRegistry);
+    protected _isDiscoveryEnabled(reader: IReader, discoverySource: DiscoverySource | undefined): boolean;
+    protected watchFile(file: URI, collection: WritableMcpCollectionDefinition, discoverySource: DiscoverySource | undefined, adaptFile: (contents: VSBuffer) => McpServerDefinition[] | undefined): IDisposable;
+}
+export declare abstract class NativeFilesystemMcpDiscovery extends FilesystemMcpDiscovery implements IMcpDiscovery {
+    private readonly adapters;
+    private suffix;
+    constructor(remoteAuthority: string | null, labelService: ILabelService, fileService: IFileService, instantiationService: IInstantiationService, mcpRegistry: IMcpRegistry, configurationService: IConfigurationService);
+    abstract start(): void;
+    protected setDetails(detailsDto: Dto<INativeMcpDiscoveryData> | undefined): void;
+}

package/vscode/src/vs/workbench/contrib/mcp/common/discovery/nativeMcpDiscoveryAbstract.js

@@ -0,0 +1,134 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Disposable, DisposableStore, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
+import { StorageScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { mcpDiscoverySection, discoverySourceLabel } from '@codingame/monaco-vscode-ec21d4de-4d65-574c-8715-bb1a6bbad376-common/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration';
+import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
+import { McpCollectionSortOrder } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { ClaudeDesktopMpcDiscoveryAdapter, CursorDesktopMpcDiscoveryAdapter, WindsurfDesktopMpcDiscoveryAdapter } from './nativeMcpDiscoveryAdapters.js';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/base';
+import { autorunWithStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
+
+let FilesystemMcpDiscovery = class FilesystemMcpDiscovery extends Disposable {
+    constructor(configurationService, _fileService, _mcpRegistry) {
+        super();
+        this._fileService = _fileService;
+        this._mcpRegistry = _mcpRegistry;
+        this._fsDiscoveryEnabled = observableConfigValue(mcpDiscoverySection, true, configurationService);
+    }
+    _isDiscoveryEnabled(reader, discoverySource) {
+        const fsDiscovery = this._fsDiscoveryEnabled.read(reader);
+        if (typeof fsDiscovery === 'boolean') {
+            return fsDiscovery;
+        }
+        if (discoverySource && fsDiscovery[discoverySource] === false) {
+            return false;
+        }
+        return true;
+    }
+    watchFile(file, collection, discoverySource, adaptFile) {
+        const store = ( new DisposableStore());
+        const collectionRegistration = store.add(( new MutableDisposable()));
+        const updateFile = async () => {
+            let definitions = [];
+            try {
+                const contents = await this._fileService.readFile(file);
+                definitions = adaptFile(contents.value) || [];
+            }
+            catch {
+            }
+            if (!definitions.length) {
+                collectionRegistration.clear();
+            }
+            else {
+                collection.serverDefinitions.set(definitions, undefined);
+                if (!collectionRegistration.value) {
+                    collectionRegistration.value = this._mcpRegistry.registerCollection(collection);
+                }
+            }
+        };
+        store.add(autorunWithStore((reader, store) => {
+            if (!this._isDiscoveryEnabled(reader, discoverySource)) {
+                collectionRegistration.clear();
+                return;
+            }
+            const throttler = store.add(( new RunOnceScheduler(updateFile, 500)));
+            const watcher = store.add(this._fileService.createWatcher(file, { recursive: false, excludes: [] }));
+            store.add(watcher.onDidChange(() => throttler.schedule()));
+            updateFile();
+        }));
+        return store;
+    }
+};
+FilesystemMcpDiscovery = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IFileService)),
+    ( __param(2, IMcpRegistry))
+], FilesystemMcpDiscovery));
+let NativeFilesystemMcpDiscovery = class NativeFilesystemMcpDiscovery extends FilesystemMcpDiscovery {
+    constructor(remoteAuthority, labelService, fileService, instantiationService, mcpRegistry, configurationService) {
+        super(configurationService, fileService, mcpRegistry);
+        this.suffix = '';
+        if (remoteAuthority) {
+            this.suffix = ' ' + ( localize(
+                7634,
+                ' on {0}',
+                labelService.getHostLabel(Schemas.vscodeRemote, remoteAuthority)
+            ));
+        }
+        this.adapters = [
+            instantiationService.createInstance(ClaudeDesktopMpcDiscoveryAdapter, remoteAuthority),
+            instantiationService.createInstance(CursorDesktopMpcDiscoveryAdapter, remoteAuthority),
+            instantiationService.createInstance(WindsurfDesktopMpcDiscoveryAdapter, remoteAuthority),
+        ];
+    }
+    setDetails(detailsDto) {
+        if (!detailsDto) {
+            return;
+        }
+        const details = {
+            ...detailsDto,
+            homedir: URI.revive(detailsDto.homedir),
+            xdgHome: detailsDto.xdgHome ? URI.revive(detailsDto.xdgHome) : undefined,
+            winAppData: detailsDto.winAppData ? URI.revive(detailsDto.winAppData) : undefined,
+        };
+        for (const adapter of this.adapters) {
+            const file = adapter.getFilePath(details);
+            if (!file) {
+                continue;
+            }
+            const collection = {
+                id: adapter.id,
+                label: discoverySourceLabel[adapter.discoverySource] + this.suffix,
+                remoteAuthority: adapter.remoteAuthority,
+                scope: StorageScope.PROFILE,
+                isTrustedByDefault: false,
+                serverDefinitions: observableValue(this, []),
+                presentation: {
+                    origin: file,
+                    order: adapter.order + (adapter.remoteAuthority ? McpCollectionSortOrder.RemoteBoost : 0),
+                },
+            };
+            this._register(this.watchFile(file, collection, adapter.discoverySource, contents => adapter.adaptFile(contents, details)));
+        }
+    }
+};
+NativeFilesystemMcpDiscovery = ( __decorate([
+    ( __param(1, ILabelService)),
+    ( __param(2, IFileService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IMcpRegistry)),
+    ( __param(5, IConfigurationService))
+], NativeFilesystemMcpDiscovery));
+
+export { FilesystemMcpDiscovery, NativeFilesystemMcpDiscovery };

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

@@ -0,0 +1,34 @@
+import { VSBuffer } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buffer";
+import { Mutable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/types";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { INativeMcpDiscoveryData } from "../../../../../platform/mcp/common/nativeMcpDiscoveryHelper.js";
+import { DiscoverySource } from "@codingame/monaco-vscode-ec21d4de-4d65-574c-8715-bb1a6bbad376-common/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration";
+import { McpCollectionSortOrder, McpServerDefinition } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
+export interface NativeMpcDiscoveryAdapter {
+    readonly remoteAuthority: string | null;
+    readonly id: string;
+    readonly order: number;
+    readonly discoverySource: DiscoverySource;
+    getFilePath(details: INativeMcpDiscoveryData): URI | undefined;
+    adaptFile(contents: VSBuffer, details: INativeMcpDiscoveryData): McpServerDefinition[] | undefined;
+}
+export declare function claudeConfigToServerDefinition(idPrefix: string, contents: VSBuffer, cwd?: URI): Mutable<McpServerDefinition>[] | undefined;
+export declare class ClaudeDesktopMpcDiscoveryAdapter implements NativeMpcDiscoveryAdapter {
+    readonly remoteAuthority: string | null;
+    id: string;
+    readonly order = McpCollectionSortOrder.Filesystem;
+    readonly discoverySource: DiscoverySource;
+    constructor(remoteAuthority: string | null);
+    getFilePath({ platform, winAppData, xdgHome, homedir }: INativeMcpDiscoveryData): URI | undefined;
+    adaptFile(contents: VSBuffer, { homedir }: INativeMcpDiscoveryData): McpServerDefinition[] | undefined;
+}
+export declare class WindsurfDesktopMpcDiscoveryAdapter extends ClaudeDesktopMpcDiscoveryAdapter {
+    readonly discoverySource: DiscoverySource;
+    constructor(remoteAuthority: string | null);
+    getFilePath({ homedir }: INativeMcpDiscoveryData): URI | undefined;
+}
+export declare class CursorDesktopMpcDiscoveryAdapter extends ClaudeDesktopMpcDiscoveryAdapter {
+    readonly discoverySource: DiscoverySource;
+    constructor(remoteAuthority: string | null);
+    getFilePath({ homedir }: INativeMcpDiscoveryData): URI | undefined;
+}

package/vscode/src/vs/workbench/contrib/mcp/common/discovery/nativeMcpDiscoveryAdapters.js

@@ -0,0 +1,79 @@
+
+import { Platform } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { DiscoverySource } from '@codingame/monaco-vscode-ec21d4de-4d65-574c-8715-bb1a6bbad376-common/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration';
+import { McpServerTransportType, McpCollectionSortOrder } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+
+function claudeConfigToServerDefinition(idPrefix, contents, cwd) {
+    let parsed;
+    try {
+        parsed = JSON.parse(( contents.toString()));
+    }
+    catch {
+        return;
+    }
+    return ( Object.entries(parsed.mcpServers).map(([name, server]) => {
+        return {
+            id: `${idPrefix}.${name}`,
+            label: name,
+            launch: server.url ? {
+                type: McpServerTransportType.SSE,
+                uri: ( URI.parse(server.url)),
+                headers: [],
+            } : {
+                type: McpServerTransportType.Stdio,
+                args: server.args || [],
+                command: server.command,
+                env: server.env || {},
+                envFile: undefined,
+                cwd,
+            }
+        };
+    }));
+}
+class ClaudeDesktopMpcDiscoveryAdapter {
+    constructor(remoteAuthority) {
+        this.remoteAuthority = remoteAuthority;
+        this.order = McpCollectionSortOrder.Filesystem;
+        this.discoverySource = DiscoverySource.ClaudeDesktop;
+        this.id = `claude-desktop.${this.remoteAuthority}`;
+    }
+    getFilePath({ platform, winAppData, xdgHome, homedir }) {
+        if (platform === Platform.Windows) {
+            const appData = winAppData || URI.joinPath(homedir, 'AppData', 'Roaming');
+            return URI.joinPath(appData, 'Claude', 'claude_desktop_config.json');
+        }
+        else if (platform === Platform.Mac) {
+            return URI.joinPath(homedir, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+        }
+        else {
+            const configDir = xdgHome || URI.joinPath(homedir, '.config');
+            return URI.joinPath(configDir, 'Claude', 'claude_desktop_config.json');
+        }
+    }
+    adaptFile(contents, { homedir }) {
+        return claudeConfigToServerDefinition(this.id, contents, homedir);
+    }
+}
+class WindsurfDesktopMpcDiscoveryAdapter extends ClaudeDesktopMpcDiscoveryAdapter {
+    constructor(remoteAuthority) {
+        super(remoteAuthority);
+        this.discoverySource = DiscoverySource.Windsurf;
+        this.id = `windsurf.${this.remoteAuthority}`;
+    }
+    getFilePath({ homedir }) {
+        return URI.joinPath(homedir, '.codeium', 'windsurf', 'mcp_config.json');
+    }
+}
+class CursorDesktopMpcDiscoveryAdapter extends ClaudeDesktopMpcDiscoveryAdapter {
+    constructor(remoteAuthority) {
+        super(remoteAuthority);
+        this.discoverySource = DiscoverySource.CursorGlobal;
+        this.id = `cursor.${this.remoteAuthority}`;
+    }
+    getFilePath({ homedir }) {
+        return URI.joinPath(homedir, '.cursor', 'mcp.json');
+    }
+}
+
+export { ClaudeDesktopMpcDiscoveryAdapter, CursorDesktopMpcDiscoveryAdapter, WindsurfDesktopMpcDiscoveryAdapter, claudeConfigToServerDefinition };

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

@@ -0,0 +1,14 @@
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.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 { IMcpRegistry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service";
+import { NativeFilesystemMcpDiscovery } from "./nativeMcpDiscoveryAbstract.js";
+export declare class RemoteNativeMpcDiscovery extends NativeFilesystemMcpDiscovery {
+    private readonly remoteAgent;
+    private readonly logService;
+    constructor(remoteAgent: IRemoteAgentService, logService: ILogService, labelService: ILabelService, fileService: IFileService, instantiationService: IInstantiationService, mcpRegistry: IMcpRegistry, configurationService: IConfigurationService);
+    start(): Promise<void>;
+}

package/vscode/src/vs/workbench/contrib/mcp/common/discovery/nativeMcpRemoteDiscovery.js

@@ -0,0 +1,44 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { ProxyChannel } from '@codingame/monaco-vscode-4a3ac544-9a61-534c-88df-756262793ef7-common/vscode/vs/base/parts/ipc/common/ipc';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { NativeMcpDiscoveryHelperChannelName } from '../../../../../platform/mcp/common/nativeMcpDiscoveryHelper.js';
+import { IRemoteAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
+import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
+import { NativeFilesystemMcpDiscovery } from './nativeMcpDiscoveryAbstract.js';
+
+let RemoteNativeMpcDiscovery = class RemoteNativeMpcDiscovery extends NativeFilesystemMcpDiscovery {
+    constructor(remoteAgent, logService, labelService, fileService, instantiationService, mcpRegistry, configurationService) {
+        super(remoteAgent.getConnection()?.remoteAuthority || null, labelService, fileService, instantiationService, mcpRegistry, configurationService);
+        this.remoteAgent = remoteAgent;
+        this.logService = logService;
+    }
+    async start() {
+        const connection = this.remoteAgent.getConnection();
+        if (!connection) {
+            return this.setDetails(undefined);
+        }
+        await connection.withChannel(NativeMcpDiscoveryHelperChannelName, async (channel) => {
+            const service = ProxyChannel.toService(channel);
+            service.load().then(data => this.setDetails(data), err => {
+                this.logService.warn('Error getting remote process MCP environment', err);
+                this.setDetails(undefined);
+            });
+        });
+    }
+};
+RemoteNativeMpcDiscovery = ( __decorate([
+    ( __param(0, IRemoteAgentService)),
+    ( __param(1, ILogService)),
+    ( __param(2, ILabelService)),
+    ( __param(3, IFileService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IMcpRegistry)),
+    ( __param(6, IConfigurationService))
+], RemoteNativeMpcDiscovery));
+
+export { RemoteNativeMpcDiscovery };