@codingame/monaco-vscode-mcp-service-override 18.3.1 → 19.0.0

package/vscode/src/vs/platform/mcp/common/mcpManagementService.js

@@ -1,259 +1,308 @@
 
 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 { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
 import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { deepClone } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
-import { uppercaseFirstLetter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { ConfigurationTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
-import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 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 { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
-import { PackageType } from '@codingame/monaco-vscode-aa9ead53-dfd3-59da-b9e7-f163d201de8d-common/vscode/vs/platform/mcp/common/mcpManagement';
+import { IUserDataProfilesService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
+import { PackageType } from '@codingame/monaco-vscode-dc3fa21d-a483-5b99-a7ab-173235644a34-common/vscode/vs/platform/mcp/common/mcpManagement';
 import { IMcpGalleryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpManagement.service';
-import { McpServerVariableType } from './mcpPlatformTypes.js';
+import { McpServerType, McpServerVariableType } from './mcpPlatformTypes.js';
+import { IMcpResourceScannerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpResourceScannerService.service';
 
-let McpManagementService = class McpManagementService extends Disposable {
+let AbstractMcpResourceManagementService = class AbstractMcpResourceManagementService extends Disposable {
     get onDidInstallMcpServers() { return this._onDidInstallMcpServers.event; }
+    get onDidUpdateMcpServers() { return this._onDidUpdateMcpServers.event; }
     get onUninstallMcpServer() { return this._onUninstallMcpServer.event; }
     get onDidUninstallMcpServer() { return this._onDidUninstallMcpServer.event; }
-    constructor(configurationService, mcpGalleryService, fileService, environmentService, uriIdentityService, logService) {
+    constructor(mcpResource, target, mcpGalleryService, fileService, uriIdentityService, logService, mcpResourceScannerService) {
         super();
-        this.configurationService = configurationService;
+        this.mcpResource = mcpResource;
+        this.target = target;
         this.mcpGalleryService = mcpGalleryService;
         this.fileService = fileService;
         this.uriIdentityService = uriIdentityService;
         this.logService = logService;
+        this.mcpResourceScannerService = mcpResourceScannerService;
+        this.local = ( new Map());
         this._onInstallMcpServer = this._register(( new Emitter()));
         this.onInstallMcpServer = this._onInstallMcpServer.event;
         this._onDidInstallMcpServers = this._register(( new Emitter()));
+        this._onDidUpdateMcpServers = this._register(( new Emitter()));
         this._onUninstallMcpServer = this._register(( new Emitter()));
         this._onDidUninstallMcpServer = this._register(( new Emitter()));
-        this.mcpLocation = uriIdentityService.extUri.joinPath(environmentService.userRoamingDataHome, 'mcp');
+        this.reloadConfigurationScheduler = this._register(( new RunOnceScheduler(() => this.updateLocal(), 50)));
     }
-    async getInstalled() {
-        const { userLocal } = this.configurationService.inspect('mcp');
-        if (!userLocal?.value?.servers) {
-            return [];
+    initialize() {
+        if (!this.initializePromise) {
+            this.initializePromise = (async () => {
+                this.local = await this.populateLocalServers();
+                this.startWatching();
+            })();
         }
-        return Promise.all(( Object.entries(userLocal.value.servers).map(([name, config]) => this.scanServer(name, config))));
+        return this.initializePromise;
     }
-    async scanServer(name, config) {
-        let scanned;
-        let readmeUrl;
-        if (config.location) {
-            const manifestLocation = this.uriIdentityService.extUri.joinPath(URI.revive(config.location), 'manifest.json');
-            try {
-                const content = await this.fileService.readFile(manifestLocation);
-                scanned = JSON.parse(( content.value.toString()));
+    async populateLocalServers() {
+        this.logService.trace('AbstractMcpResourceManagementService#populateLocalServers', ( this.mcpResource.toString()));
+        const local = ( new Map());
+        try {
+            const scannedMcpServers = await this.mcpResourceScannerService.scanMcpServers(this.mcpResource, this.target);
+            if (scannedMcpServers.servers) {
+                await Promise.allSettled(( Object.entries(scannedMcpServers.servers).map(async ([name, scannedServer]) => {
+                    const server = await this.scanLocalServer(name, scannedServer);
+                    local.set(name, server);
+                })));
             }
-            catch (e) {
-                this.logService.error('MCP Management Service: failed to read manifest', ( config.location.toString()), e);
+        }
+        catch (error) {
+            this.logService.debug('Could not read user MCP servers:', error);
+            throw error;
+        }
+        return local;
+    }
+    startWatching() {
+        this._register(this.fileService.watch(this.mcpResource));
+        this._register(this.fileService.onDidFilesChange(e => {
+            if (e.affects(this.mcpResource)) {
+                this.reloadConfigurationScheduler.schedule();
             }
-            readmeUrl = this.uriIdentityService.extUri.joinPath(URI.revive(config.location), 'README.md');
-            if (!(await this.fileService.exists(readmeUrl))) {
-                readmeUrl = undefined;
+        }));
+    }
+    async updateLocal() {
+        try {
+            const current = await this.populateLocalServers();
+            const added = [];
+            const updated = [];
+            const removed = [...( this.local.keys())].filter(name => !( current.has(name)));
+            for (const server of removed) {
+                this.local.delete(server);
             }
-        }
-        if (!scanned) {
-            let publisher = '';
-            const nameParts = name.split('/');
-            if (nameParts.length > 0) {
-                const domainParts = nameParts[0].split('.');
-                if (domainParts.length > 0) {
-                    publisher = domainParts[domainParts.length - 1];
+            for (const [name, server] of current) {
+                const previous = this.local.get(name);
+                if (previous) {
+                    if (!equals(previous, server)) {
+                        updated.push(server);
+                        this.local.set(name, server);
+                    }
+                }
+                else {
+                    added.push(server);
+                    this.local.set(name, server);
                 }
             }
-            scanned = {
-                name,
-                version: '1.0.0',
-                displayName: ( nameParts[nameParts.length - 1].split('-').map(s => uppercaseFirstLetter(s))).join(' '),
-                publisher
-            };
+            for (const server of removed) {
+                this.local.delete(server);
+                this._onDidUninstallMcpServer.fire({ name: server, mcpResource: this.mcpResource });
+            }
+            if (updated.length) {
+                this._onDidUpdateMcpServers.fire(( updated.map(
+                    server => ({ name: server.name, local: server, mcpResource: this.mcpResource })
+                )));
+            }
+            if (added.length) {
+                this._onDidInstallMcpServers.fire(( added.map(
+                    server => ({ name: server.name, local: server, mcpResource: this.mcpResource })
+                )));
+            }
+        }
+        catch (error) {
+            this.logService.error('Failed to load installed MCP servers:', error);
+        }
+    }
+    async getInstalled() {
+        await this.initialize();
+        return Array.from(( this.local.values()));
+    }
+    async scanLocalServer(name, config) {
+        let mcpServerInfo = await this.getLocalServerInfo(name, config);
+        if (!mcpServerInfo) {
+            mcpServerInfo = { name, version: config.version };
         }
         return {
             name,
             config,
-            version: scanned.version,
-            location: URI.revive(config.location),
-            id: scanned.id,
-            displayName: scanned.displayName,
-            description: scanned.description,
-            publisher: scanned.publisher,
-            publisherDisplayName: scanned.publisherDisplayName,
-            repositoryUrl: scanned.repositoryUrl,
-            readmeUrl,
-            iconUrl: scanned.iconUrl,
-            manifest: scanned.manifest
+            mcpResource: this.mcpResource,
+            version: mcpServerInfo.version,
+            location: mcpServerInfo.location,
+            id: mcpServerInfo.id,
+            displayName: mcpServerInfo.displayName,
+            description: mcpServerInfo.description,
+            publisher: mcpServerInfo.publisher,
+            publisherDisplayName: mcpServerInfo.publisherDisplayName,
+            repositoryUrl: mcpServerInfo.repositoryUrl,
+            readmeUrl: mcpServerInfo.readmeUrl,
+            icon: mcpServerInfo.icon,
+            codicon: mcpServerInfo.codicon,
+            manifest: mcpServerInfo.manifest,
+            source: config.gallery ? 'gallery' : 'local'
         };
     }
-    async installFromGallery(server, packageType) {
-        this.logService.trace('MCP Management Service: installGallery', server.url);
-        this._onInstallMcpServer.fire({ name: server.name });
+    async install(server, options) {
+        this.logService.trace('MCP Management Service: install', server.name);
+        this._onInstallMcpServer.fire({ name: server.name, mcpResource: this.mcpResource });
         try {
-            const manifest = await this.mcpGalleryService.getManifest(server, CancellationToken.None);
-            const location = this.uriIdentityService.extUri.joinPath(this.mcpLocation, `${server.name.replace('/', '.')}-${server.version}`);
-            const manifestPath = this.uriIdentityService.extUri.joinPath(location, 'manifest.json');
-            await this.fileService.writeFile(manifestPath, VSBuffer.fromString(JSON.stringify({
-                id: server.id,
-                name: server.name,
-                displayName: server.displayName,
-                description: server.description,
-                version: server.version,
-                publisher: server.publisher,
-                publisherDisplayName: server.publisherDisplayName,
-                repository: server.repositoryUrl,
-                licenseUrl: server.licenseUrl,
-                ...manifest,
-            })));
-            if (server.readmeUrl) {
-                const readme = await this.mcpGalleryService.getReadme(server, CancellationToken.None);
-                await this.fileService.writeFile(this.uriIdentityService.extUri.joinPath(location, 'README.md'), VSBuffer.fromString(readme));
-            }
-            const { userLocal } = this.configurationService.inspect('mcp');
-            const value = deepClone(userLocal?.value ?? { servers: {} });
-            if (!value.servers) {
-                value.servers = {};
+            await this.mcpResourceScannerService.addMcpServers([server], this.mcpResource, this.target);
+            await this.updateLocal();
+            const local = this.local.get(server.name);
+            if (!local) {
+                throw ( new Error(`Failed to install MCP server: ${server.name}`));
             }
-            const serverConfig = this.getServerConfig(manifest, packageType);
-            value.servers[server.name] = {
-                ...serverConfig,
-                location: location.toJSON(),
-            };
-            if (serverConfig.inputs) {
-                value.inputs = value.inputs ?? [];
-                for (const input of serverConfig.inputs) {
-                    if (!( value.inputs.some(i => i.id === input.id))) {
-                        value.inputs.push({ ...input, serverName: server.name });
-                    }
-                }
-            }
-            await this.configurationService.updateValue('mcp', value, ConfigurationTarget.USER_LOCAL);
-            const local = await this.scanServer(server.name, value.servers[server.name]);
-            this._onDidInstallMcpServers.fire([{ name: server.name, source: server, local }]);
+            return local;
         }
         catch (e) {
-            this._onDidInstallMcpServers.fire([{ name: server.name, source: server, error: e }]);
+            this._onDidInstallMcpServers.fire([{ name: server.name, error: e, mcpResource: this.mcpResource }]);
             throw e;
         }
     }
-    async uninstall(server) {
+    async uninstall(server, options) {
         this.logService.trace('MCP Management Service: uninstall', server.name);
-        this._onUninstallMcpServer.fire({ name: server.name });
+        this._onUninstallMcpServer.fire({ name: server.name, mcpResource: this.mcpResource });
         try {
-            const { userLocal } = this.configurationService.inspect('mcp');
-            const value = deepClone(userLocal?.value ?? { servers: {} });
-            if (!value.servers) {
-                value.servers = {};
+            const currentServers = await this.mcpResourceScannerService.scanMcpServers(this.mcpResource, this.target);
+            if (!currentServers.servers) {
+                return;
             }
-            delete value.servers[server.name];
-            if (value.inputs) {
-                const index = value.inputs.findIndex(i => i.serverName === server.name);
-                if (index !== undefined && index >= 0) {
-                    value.inputs?.splice(index, 1);
-                }
-            }
-            await this.configurationService.updateValue('mcp', value, ConfigurationTarget.USER_LOCAL);
+            await this.mcpResourceScannerService.removeMcpServers([server.name], this.mcpResource, this.target);
             if (server.location) {
                 await this.fileService.del(URI.revive(server.location), { recursive: true });
             }
-            this._onDidUninstallMcpServer.fire({ name: server.name });
+            await this.updateLocal();
         }
         catch (e) {
-            this._onDidUninstallMcpServer.fire({ name: server.name, error: e });
+            this._onDidUninstallMcpServer.fire({ name: server.name, error: e, mcpResource: this.mcpResource });
             throw e;
         }
     }
-    getServerConfig(manifest, packageType) {
+    toScannedMcpServerAndInputs(manifest, packageType) {
         if (packageType === undefined) {
             packageType = manifest.packages?.[0]?.registry_name ?? PackageType.REMOTE;
         }
-        if (packageType === PackageType.REMOTE) {
-            const inputs = [];
+        let config;
+        const inputs = [];
+        if (packageType === PackageType.REMOTE && manifest.remotes?.length) {
             const headers = {};
             for (const input of manifest.remotes[0].headers ?? []) {
-                headers[input.name] = input.value;
-                if (input.variables) {
-                    inputs.push(...this.getVariables(input.variables));
+                const variables = input.variables ? this.getVariables(input.variables) : [];
+                let value = input.value;
+                for (const variable of variables) {
+                    value = value.replace(`{${variable.id}}`, `{input:${variable.id}}`);
+                }
+                headers[input.name] = value;
+                if (variables.length) {
+                    inputs.push(...variables);
                 }
             }
-            return {
-                type: 'http',
+            config = {
+                type: McpServerType.REMOTE,
                 url: manifest.remotes[0].url,
                 headers: ( Object.keys(headers)).length ? headers : undefined,
-                inputs: inputs.length ? inputs : undefined,
             };
         }
-        const serverPackage = manifest.packages.find(p => p.registry_name === packageType) ?? manifest.packages[0];
-        const inputs = [];
-        const args = [];
-        const env = {};
-        if (serverPackage.registry_name === PackageType.DOCKER) {
-            args.push('run');
-            args.push('-i');
-            args.push('--rm');
-        }
-        for (const arg of serverPackage.runtime_arguments ?? []) {
-            if (arg.type === 'positional') {
-                args.push(arg.value ?? arg.value_hint);
+        else {
+            const serverPackage = manifest.packages?.find(p => p.registry_name === packageType) ?? manifest.packages?.[0];
+            if (!serverPackage) {
+                throw ( new Error(`No server package found`));
             }
-            else if (arg.type === 'named') {
-                args.push(arg.name);
-                if (arg.value) {
-                    args.push(arg.value);
-                }
+            const args = [];
+            const env = {};
+            if (serverPackage.registry_name === PackageType.DOCKER) {
+                args.push('run');
+                args.push('-i');
+                args.push('--rm');
             }
-            if (arg.variables) {
-                inputs.push(...this.getVariables(arg.variables));
+            for (const arg of serverPackage.runtime_arguments ?? []) {
+                const variables = arg.variables ? this.getVariables(arg.variables) : [];
+                if (arg.type === 'positional') {
+                    let value = arg.value;
+                    if (value) {
+                        for (const variable of variables) {
+                            value = value.replace(`{${variable.id}}`, `{input:${variable.id}}`);
+                        }
+                    }
+                    args.push(value ?? arg.value_hint);
+                }
+                else if (arg.type === 'named') {
+                    args.push(arg.name);
+                    if (arg.value) {
+                        let value = arg.value;
+                        for (const variable of variables) {
+                            value = value.replace(`{${variable.id}}`, `{input:${variable.id}}`);
+                        }
+                        args.push(value);
+                    }
+                }
+                if (variables.length) {
+                    inputs.push(...variables);
+                }
             }
-        }
-        for (const input of serverPackage.environment_variables ?? []) {
-            const variables = input.variables ? this.getVariables(input.variables) : [];
-            let value = input.value;
-            for (const variable of variables) {
-                value = value.replace(`{${variable.id}}`, `\${input:${variable.id}}`);
+            for (const input of serverPackage.environment_variables ?? []) {
+                const variables = input.variables ? this.getVariables(input.variables) : [];
+                let value = input.value;
+                for (const variable of variables) {
+                    value = value.replace(`{${variable.id}}`, `{input:${variable.id}}`);
+                }
+                env[input.name] = value;
+                if (variables.length) {
+                    inputs.push(...variables);
+                }
+                if (serverPackage.registry_name === PackageType.DOCKER) {
+                    args.push('-e');
+                    args.push(input.name);
+                }
             }
-            env[input.name] = value;
-            if (variables.length) {
-                inputs.push(...variables);
+            if (serverPackage.registry_name === PackageType.NODE) {
+                args.push(serverPackage.version ? `${serverPackage.name}@${serverPackage.version}` : serverPackage.name);
             }
-            if (serverPackage.registry_name === PackageType.DOCKER) {
-                args.push('-e');
-                args.push(input.name);
+            else if (serverPackage.registry_name === PackageType.PYTHON) {
+                args.push(serverPackage.version ? `${serverPackage.name}==${serverPackage.version}` : serverPackage.name);
             }
-        }
-        if (serverPackage.registry_name === PackageType.NODE) {
-            args.push(`${serverPackage.name}@${serverPackage.version}`);
-        }
-        else if (serverPackage.registry_name === PackageType.PYTHON) {
-            args.push(`${serverPackage.name}==${serverPackage.version}`);
-        }
-        else if (serverPackage.registry_name === PackageType.DOCKER) {
-            args.push(`${serverPackage.name}:${serverPackage.version}`);
-        }
-        for (const arg of serverPackage.package_arguments ?? []) {
-            if (arg.type === 'positional') {
-                args.push(arg.value ?? arg.value_hint);
+            else if (serverPackage.registry_name === PackageType.DOCKER) {
+                args.push(serverPackage.version ? `${serverPackage.name}:${serverPackage.version}` : serverPackage.name);
             }
-            else if (arg.type === 'named') {
-                args.push(arg.name);
-                if (arg.value) {
-                    args.push(arg.value);
+            for (const arg of serverPackage.package_arguments ?? []) {
+                const variables = arg.variables ? this.getVariables(arg.variables) : [];
+                if (arg.type === 'positional') {
+                    let value = arg.value;
+                    if (value) {
+                        for (const variable of variables) {
+                            value = value.replace(`{${variable.id}}`, `{input:${variable.id}}`);
+                        }
+                    }
+                    args.push(value ?? arg.value_hint);
+                }
+                else if (arg.type === 'named') {
+                    args.push(arg.name);
+                    if (arg.value) {
+                        let value = arg.value;
+                        for (const variable of variables) {
+                            value = value.replace(`{${variable.id}}`, `{input:${variable.id}}`);
+                        }
+                        args.push(value);
+                    }
+                }
+                if (variables.length) {
+                    inputs.push(...variables);
                 }
             }
-            if (arg.variables) {
-                inputs.push(...this.getVariables(arg.variables));
-            }
+            config = {
+                type: McpServerType.LOCAL,
+                command: this.getCommandName(serverPackage.registry_name),
+                args: args.length ? args : undefined,
+                env: ( Object.keys(env)).length ? env : undefined,
+            };
         }
         return {
-            type: 'stdio',
-            command: this.getCommandName(serverPackage.registry_name),
-            args: args.length ? args : undefined,
-            env: ( Object.keys(env)).length ? env : undefined,
+            config,
             inputs: inputs.length ? inputs : undefined,
         };
     }
@@ -280,13 +329,175 @@ let McpManagementService = class McpManagementService extends Disposable {
         return variables;
     }
 };
-McpManagementService = ( __decorate([
-    ( __param(0, IConfigurationService)),
+AbstractMcpResourceManagementService = ( __decorate([
+    ( __param(2, IMcpGalleryService)),
+    ( __param(3, IFileService)),
+    ( __param(4, IUriIdentityService)),
+    ( __param(5, ILogService)),
+    ( __param(6, IMcpResourceScannerService))
+], AbstractMcpResourceManagementService));
+let McpUserResourceManagementService = class McpUserResourceManagementService extends AbstractMcpResourceManagementService {
+    constructor(mcpResource, mcpGalleryService, fileService, uriIdentityService, logService, mcpResourceScannerService, environmentService) {
+        super(mcpResource, ConfigurationTarget.USER, mcpGalleryService, fileService, uriIdentityService, logService, mcpResourceScannerService);
+        this.mcpLocation = uriIdentityService.extUri.joinPath(environmentService.userRoamingDataHome, 'mcp');
+    }
+    async installFromGallery(server, options) {
+        this.logService.trace('MCP Management Service: installGallery', server.url);
+        this._onInstallMcpServer.fire({ name: server.name, mcpResource: this.mcpResource });
+        try {
+            const manifest = await this.updateMetadataFromGallery(server);
+            const { config, inputs } = this.toScannedMcpServerAndInputs(manifest, options?.packageType);
+            const installable = {
+                name: server.name,
+                config: {
+                    ...config,
+                    gallery: true,
+                    version: server.version
+                },
+                inputs
+            };
+            await this.mcpResourceScannerService.addMcpServers([installable], this.mcpResource, this.target);
+            await this.updateLocal();
+            const local = (await this.getInstalled()).find(s => s.name === server.name);
+            if (!local) {
+                throw ( new Error(`Failed to install MCP server: ${server.name}`));
+            }
+            return local;
+        }
+        catch (e) {
+            this._onDidInstallMcpServers.fire([{ name: server.name, source: server, error: e, mcpResource: this.mcpResource }]);
+            throw e;
+        }
+    }
+    async updateMetadata(local, gallery) {
+        await this.updateMetadataFromGallery(gallery);
+        await this.updateLocal();
+        const updatedLocal = (await this.getInstalled()).find(s => s.name === local.name);
+        if (!updatedLocal) {
+            throw ( new Error(`Failed to find MCP server: ${local.name}`));
+        }
+        return updatedLocal;
+    }
+    async updateMetadataFromGallery(gallery) {
+        const manifest = await this.mcpGalleryService.getManifest(gallery, CancellationToken.None);
+        const location = this.getLocation(gallery.name, gallery.version);
+        const manifestPath = this.uriIdentityService.extUri.joinPath(location, 'manifest.json');
+        const local = {
+            id: gallery.id,
+            name: gallery.name,
+            displayName: gallery.displayName,
+            description: gallery.description,
+            version: gallery.version,
+            publisher: gallery.publisher,
+            publisherDisplayName: gallery.publisherDisplayName,
+            repositoryUrl: gallery.repositoryUrl,
+            licenseUrl: gallery.licenseUrl,
+            icon: gallery.icon,
+            codicon: gallery.codicon,
+            manifest,
+        };
+        await this.fileService.writeFile(manifestPath, VSBuffer.fromString(JSON.stringify(local)));
+        if (gallery.readmeUrl) {
+            const readme = await this.mcpGalleryService.getReadme(gallery, CancellationToken.None);
+            await this.fileService.writeFile(this.uriIdentityService.extUri.joinPath(location, 'README.md'), VSBuffer.fromString(readme));
+        }
+        return manifest;
+    }
+    async getLocalServerInfo(name, mcpServerConfig) {
+        let storedMcpServerInfo;
+        let location;
+        let readmeUrl;
+        if (mcpServerConfig.gallery) {
+            location = this.getLocation(name, mcpServerConfig.version);
+            const manifestLocation = this.uriIdentityService.extUri.joinPath(location, 'manifest.json');
+            try {
+                const content = await this.fileService.readFile(manifestLocation);
+                storedMcpServerInfo = JSON.parse(( content.value.toString()));
+                storedMcpServerInfo.location = location;
+                readmeUrl = this.uriIdentityService.extUri.joinPath(location, 'README.md');
+                if (!(await this.fileService.exists(readmeUrl))) {
+                    readmeUrl = undefined;
+                }
+                storedMcpServerInfo.readmeUrl = readmeUrl;
+            }
+            catch (e) {
+                this.logService.error('MCP Management Service: failed to read manifest', ( location.toString()), e);
+            }
+        }
+        return storedMcpServerInfo;
+    }
+    getLocation(name, version) {
+        name = name.replace('/', '.');
+        return this.uriIdentityService.extUri.joinPath(this.mcpLocation, version ? `${name}-${version}` : name);
+    }
+};
+McpUserResourceManagementService = ( __decorate([
     ( __param(1, IMcpGalleryService)),
     ( __param(2, IFileService)),
-    ( __param(3, IEnvironmentService)),
-    ( __param(4, IUriIdentityService)),
-    ( __param(5, ILogService))
+    ( __param(3, IUriIdentityService)),
+    ( __param(4, ILogService)),
+    ( __param(5, IMcpResourceScannerService)),
+    ( __param(6, IEnvironmentService))
+], McpUserResourceManagementService));
+let McpManagementService = class McpManagementService extends Disposable {
+    constructor(userDataProfilesService, instantiationService) {
+        super();
+        this.userDataProfilesService = userDataProfilesService;
+        this.instantiationService = instantiationService;
+        this._onInstallMcpServer = this._register(( new Emitter()));
+        this.onInstallMcpServer = this._onInstallMcpServer.event;
+        this._onDidInstallMcpServers = this._register(( new Emitter()));
+        this.onDidInstallMcpServers = this._onDidInstallMcpServers.event;
+        this._onDidUpdateMcpServers = this._register(( new Emitter()));
+        this.onDidUpdateMcpServers = this._onDidUpdateMcpServers.event;
+        this._onUninstallMcpServer = this._register(( new Emitter()));
+        this.onUninstallMcpServer = this._onUninstallMcpServer.event;
+        this._onDidUninstallMcpServer = this._register(( new Emitter()));
+        this.onDidUninstallMcpServer = this._onDidUninstallMcpServer.event;
+        this.mcpResourceManagementServices = ( new ResourceMap());
+    }
+    getMcpResourceManagementService(mcpResource) {
+        let mcpResourceManagementService = this.mcpResourceManagementServices.get(mcpResource);
+        if (!mcpResourceManagementService) {
+            const disposables = ( new DisposableStore());
+            const service = disposables.add(this.instantiationService.createInstance(McpUserResourceManagementService, mcpResource));
+            disposables.add(service.onInstallMcpServer(e => this._onInstallMcpServer.fire(e)));
+            disposables.add(service.onDidInstallMcpServers(e => this._onDidInstallMcpServers.fire(e)));
+            disposables.add(service.onDidUpdateMcpServers(e => this._onDidUpdateMcpServers.fire(e)));
+            disposables.add(service.onUninstallMcpServer(e => this._onUninstallMcpServer.fire(e)));
+            disposables.add(service.onDidUninstallMcpServer(e => this._onDidUninstallMcpServer.fire(e)));
+            this.mcpResourceManagementServices.set(mcpResource, mcpResourceManagementService = { service, dispose: () => disposables.dispose() });
+        }
+        return mcpResourceManagementService.service;
+    }
+    async getInstalled(mcpResource) {
+        const mcpResourceUri = mcpResource || this.userDataProfilesService.defaultProfile.mcpResource;
+        return this.getMcpResourceManagementService(mcpResourceUri).getInstalled();
+    }
+    async install(server, options) {
+        const mcpResourceUri = options?.mcpResource || this.userDataProfilesService.defaultProfile.mcpResource;
+        return this.getMcpResourceManagementService(mcpResourceUri).install(server, options);
+    }
+    async uninstall(server, options) {
+        const mcpResourceUri = options?.mcpResource || this.userDataProfilesService.defaultProfile.mcpResource;
+        return this.getMcpResourceManagementService(mcpResourceUri).uninstall(server, options);
+    }
+    async installFromGallery(server, options) {
+        const mcpResourceUri = options?.mcpResource || this.userDataProfilesService.defaultProfile.mcpResource;
+        return this.getMcpResourceManagementService(mcpResourceUri).installFromGallery(server, options);
+    }
+    async updateMetadata(local, gallery, mcpResource) {
+        return this.getMcpResourceManagementService(mcpResource || this.userDataProfilesService.defaultProfile.mcpResource).updateMetadata(local, gallery);
+    }
+    dispose() {
+        this.mcpResourceManagementServices.forEach(service => service.dispose());
+        this.mcpResourceManagementServices.clear();
+        super.dispose();
+    }
+};
+McpManagementService = ( __decorate([
+    ( __param(0, IUserDataProfilesService)),
+    ( __param(1, IInstantiationService))
 ], McpManagementService));
 
-export { McpManagementService };
+export { AbstractMcpResourceManagementService, McpManagementService, McpUserResourceManagementService };