@codingame/monaco-vscode-mcp-service-override 17.2.0 → 18.0.0

package/index.js

@@ -2,18 +2,36 @@
 import '@codingame/monaco-vscode-api/vscode/vs/editor/standalone/browser/standaloneServices';
 import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
 import { IMcpConfigPathsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpConfigPathsService.service';
-import { IMcpService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
+import { IMcpSamplingService, IMcpWorkbenchService, IMcpService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
 import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
 import { McpConfigPathsService } from './vscode/src/vs/workbench/contrib/mcp/common/mcpConfigPathsService.js';
 import { McpService } from './vscode/src/vs/workbench/contrib/mcp/common/mcpService.js';
 import { McpRegistry } from './vscode/src/vs/workbench/contrib/mcp/common/mcpRegistry.js';
 import './vscode/src/vs/workbench/contrib/mcp/browser/mcp.contribution.js';
+import { IAuthenticationMcpService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/browser/authenticationMcpService.service';
+import { AuthenticationMcpService } from './vscode/src/vs/workbench/services/authentication/browser/authenticationMcpService.js';
+import { IAuthenticationMcpAccessService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/browser/authenticationMcpAccessService.service';
+import { AuthenticationMcpAccessService } from './vscode/src/vs/workbench/services/authentication/browser/authenticationMcpAccessService.js';
+import { IAuthenticationMcpUsageService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/browser/authenticationMcpUsageService.service';
+import { AuthenticationMcpUsageService } from './vscode/src/vs/workbench/services/authentication/browser/authenticationMcpUsageService.js';
+import { McpWorkbenchService } from './vscode/src/vs/workbench/contrib/mcp/browser/mcpWorkbenchService.js';
+import { IMcpManagementService, IMcpGalleryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpManagement.service';
+import { McpGalleryService } from './vscode/src/vs/platform/mcp/common/mcpGalleryService.js';
+import { McpManagementService } from './vscode/src/vs/platform/mcp/common/mcpManagementService.js';
+import { McpSamplingService } from './vscode/src/vs/workbench/contrib/mcp/common/mcpSamplingService.js';
 
 function getServiceOverride() {
     return {
         [IMcpConfigPathsService.toString()]: new SyncDescriptor(McpConfigPathsService, [], true),
         [IMcpService.toString()]: new SyncDescriptor(McpService, [], true),
-        [IMcpRegistry.toString()]: new SyncDescriptor(McpRegistry, [], true)
+        [IMcpRegistry.toString()]: new SyncDescriptor(McpRegistry, [], true),
+        [IAuthenticationMcpService.toString()]: new SyncDescriptor(AuthenticationMcpService, [], true),
+        [IAuthenticationMcpAccessService.toString()]: new SyncDescriptor(AuthenticationMcpAccessService, [], true),
+        [IAuthenticationMcpUsageService.toString()]: new SyncDescriptor(AuthenticationMcpUsageService, [], true),
+        [IMcpWorkbenchService.toString()]: new SyncDescriptor(McpWorkbenchService, [], true),
+        [IMcpGalleryService.toString()]: new SyncDescriptor(McpGalleryService, [], true),
+        [IMcpManagementService.toString()]: new SyncDescriptor(McpManagementService, [], true),
+        [IMcpSamplingService.toString()]: new SyncDescriptor(McpSamplingService, [], true)
     };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-mcp-service-override",
-  "version": "17.2.0",
+  "version": "18.0.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - mcp service-override",
   "keywords": [],
@@ -15,10 +15,19 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-1cb11a73-359e-5a2f-9e95-6989cc9858ee-common": "17.2.0",
-    "@codingame/monaco-vscode-4a0e04a7-c3bd-5fb7-9d3b-4fd047cc9e59-common": "17.2.0",
-    "@codingame/monaco-vscode-4a3ac544-9a61-534c-88df-756262793ef7-common": "17.2.0",
-    "@codingame/monaco-vscode-api": "17.2.0"
+    "@codingame/monaco-vscode-1cb11a73-359e-5a2f-9e95-6989cc9858ee-common": "18.0.0",
+    "@codingame/monaco-vscode-2673c6e2-17c1-5710-b169-46f3d4a28696-common": "18.0.0",
+    "@codingame/monaco-vscode-4a3ac544-9a61-534c-88df-756262793ef7-common": "18.0.0",
+    "@codingame/monaco-vscode-501b06ab-3f58-516b-8a1a-c29d375d3da4-common": "18.0.0",
+    "@codingame/monaco-vscode-93784a59-b4cf-520c-8339-f8104d3a4f3e-common": "18.0.0",
+    "@codingame/monaco-vscode-937ecbdf-94c7-5b16-aefa-ad78ae557a93-common": "18.0.0",
+    "@codingame/monaco-vscode-9ed6fe06-a052-57c2-a234-5d9b94d2e7e0-common": "18.0.0",
+    "@codingame/monaco-vscode-aa9ead53-dfd3-59da-b9e7-f163d201de8d-common": "18.0.0",
+    "@codingame/monaco-vscode-api": "18.0.0",
+    "@codingame/monaco-vscode-c87fff3a-2aa9-52ab-ba4d-17e8d1e5e185-common": "18.0.0",
+    "@codingame/monaco-vscode-ce7c734f-7712-563c-9335-d7acb43306af-common": "18.0.0",
+    "@codingame/monaco-vscode-cf77987b-b1b7-5359-aaf8-a259c63d9f03-common": "18.0.0",
+    "@codingame/monaco-vscode-dcfc2191-2da1-54c7-8fb7-e92c5d11ecef-common": "18.0.0"
   },
   "main": "index.js",
   "module": "index.js",

package/vscode/src/vs/platform/mcp/common/mcpGalleryService.d.ts

@@ -0,0 +1,26 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+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 { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
+import { IRequestService } from "@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request.service";
+import { IGalleryMcpServer, IMcpServerManifest, IQueryOptions } from "@codingame/monaco-vscode-aa9ead53-dfd3-59da-b9e7-f163d201de8d-common/vscode/vs/platform/mcp/common/mcpManagement";
+import { IMcpGalleryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpManagement.service";
+export declare class McpGalleryService extends Disposable implements IMcpGalleryService {
+    private readonly configurationService;
+    private readonly requestService;
+    private readonly fileService;
+    private readonly productService;
+    private readonly logService;
+    _serviceBrand: undefined;
+    constructor(configurationService: IConfigurationService, requestService: IRequestService, fileService: IFileService, productService: IProductService, logService: ILogService);
+    isEnabled(): boolean;
+    query(options?: IQueryOptions, token?: CancellationToken): Promise<IGalleryMcpServer[]>;
+    getManifest(gallery: IGalleryMcpServer, token: CancellationToken): Promise<IMcpServerManifest>;
+    getReadme(gallery: IGalleryMcpServer, token: CancellationToken): Promise<string>;
+    private toGalleryMcpServer;
+    private fetchGallery;
+    private getManifestUrl;
+    private getMcpGalleryUrl;
+}

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

@@ -0,0 +1,170 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { joinPath, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { uppercaseFirstLetter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+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 { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { asJson, asText } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request';
+import { IRequestService } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request.service';
+import { mcpGalleryServiceUrlConfig } from '@codingame/monaco-vscode-aa9ead53-dfd3-59da-b9e7-f163d201de8d-common/vscode/vs/platform/mcp/common/mcpManagement';
+
+let McpGalleryService = class McpGalleryService extends Disposable {
+    constructor(configurationService, requestService, fileService, productService, logService) {
+        super();
+        this.configurationService = configurationService;
+        this.requestService = requestService;
+        this.fileService = fileService;
+        this.productService = productService;
+        this.logService = logService;
+    }
+    isEnabled() {
+        return this.getMcpGalleryUrl() !== undefined;
+    }
+    async query(options, token = CancellationToken.None) {
+        let { servers } = await this.fetchGallery(token);
+        if (options?.text) {
+            const searchText = options.text.toLowerCase();
+            servers = servers.filter(item => item.name.toLowerCase().includes(searchText) || item.description.toLowerCase().includes(searchText));
+        }
+        const galleryServers = [];
+        for (const item of servers) {
+            galleryServers.push(this.toGalleryMcpServer(item));
+        }
+        return galleryServers;
+    }
+    async getManifest(gallery, token) {
+        const uri = ( URI.parse(gallery.manifestUrl));
+        if (uri.scheme === Schemas.file) {
+            try {
+                const content = await this.fileService.readFile(uri);
+                const data = ( content.value.toString());
+                return JSON.parse(data);
+            }
+            catch (error) {
+                this.logService.error(`Failed to read file from ${uri}: ${error}`);
+            }
+        }
+        const context = await this.requestService.request({
+            type: 'GET',
+            url: gallery.manifestUrl,
+        }, token);
+        const result = await asJson(context);
+        if (!result) {
+            throw ( new Error(`Failed to fetch manifest from ${gallery.manifestUrl}`));
+        }
+        return {
+            packages: result.packages,
+            remotes: result.remotes,
+        };
+    }
+    async getReadme(gallery, token) {
+        const readmeUrl = gallery.readmeUrl;
+        if (!readmeUrl) {
+            return Promise.resolve(( localize(1942, 'No README available')));
+        }
+        const uri = ( URI.parse(readmeUrl));
+        if (uri.scheme === Schemas.file) {
+            try {
+                const content = await this.fileService.readFile(uri);
+                return ( content.value.toString());
+            }
+            catch (error) {
+                this.logService.error(`Failed to read file from ${uri}: ${error}`);
+            }
+        }
+        const context = await this.requestService.request({
+            type: 'GET',
+            url: readmeUrl,
+        }, token);
+        const result = await asText(context);
+        if (!result) {
+            throw ( new Error(`Failed to fetch README from ${readmeUrl}`));
+        }
+        return result;
+    }
+    toGalleryMcpServer(item) {
+        let publisher = '';
+        const nameParts = item.name.split('/');
+        if (nameParts.length > 0) {
+            const domainParts = nameParts[0].split('.');
+            if (domainParts.length > 0) {
+                publisher = domainParts[domainParts.length - 1];
+            }
+        }
+        return {
+            id: item.id,
+            name: item.name,
+            displayName: item.displayName ?? ( nameParts[nameParts.length - 1].split('-').map(s => uppercaseFirstLetter(s))).join(' '),
+            url: item.repository.url,
+            description: item.description,
+            version: item.version_detail.version,
+            lastUpdated: Date.parse(item.version_detail.release_date),
+            repositoryUrl: item.repository.url,
+            readmeUrl: item.readmeUrl,
+            manifestUrl: this.getManifestUrl(item),
+            packageTypes: item.package_types ?? [],
+            publisher,
+            publisherDisplayName: item.publisher?.displayName,
+            publisherDomain: item.publisher ? {
+                link: item.publisher.url,
+                verified: item.publisher.is_verified,
+            } : undefined,
+        };
+    }
+    async fetchGallery(token) {
+        const mcpGalleryUrl = this.getMcpGalleryUrl();
+        if (!mcpGalleryUrl) {
+            return Promise.resolve({ servers: [] });
+        }
+        const uri = ( URI.parse(mcpGalleryUrl));
+        if (uri.scheme === Schemas.file) {
+            try {
+                const content = await this.fileService.readFile(uri);
+                const data = ( content.value.toString());
+                return JSON.parse(data);
+            }
+            catch (error) {
+                this.logService.error(`Failed to read file from ${uri}: ${error}`);
+            }
+        }
+        const context = await this.requestService.request({
+            type: 'GET',
+            url: mcpGalleryUrl,
+        }, token);
+        const result = await asJson(context);
+        return result || { servers: [] };
+    }
+    getManifestUrl(item) {
+        const mcpGalleryUrl = this.getMcpGalleryUrl();
+        if (!mcpGalleryUrl) {
+            return item.repository.url;
+        }
+        const uri = ( URI.parse(mcpGalleryUrl));
+        if (uri.scheme === Schemas.file) {
+            return joinPath(dirname(uri), item.id).fsPath;
+        }
+        return `${mcpGalleryUrl}/${item.id}`;
+    }
+    getMcpGalleryUrl() {
+        if (this.productService.quality === 'stable') {
+            return undefined;
+        }
+        return this.configurationService.getValue(mcpGalleryServiceUrlConfig);
+    }
+};
+McpGalleryService = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IRequestService)),
+    ( __param(2, IFileService)),
+    ( __param(3, IProductService)),
+    ( __param(4, ILogService))
+], McpGalleryService));
+
+export { McpGalleryService };

package/vscode/src/vs/platform/mcp/common/mcpManagementService.d.ts

@@ -0,0 +1,35 @@
+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 { 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 { 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 { DidUninstallMcpServerEvent, IGalleryMcpServer, ILocalMcpServer, InstallMcpServerEvent, InstallMcpServerResult, PackageType, UninstallMcpServerEvent } from "@codingame/monaco-vscode-aa9ead53-dfd3-59da-b9e7-f163d201de8d-common/vscode/vs/platform/mcp/common/mcpManagement";
+import { IMcpManagementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpManagement.service";
+import { IMcpGalleryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpManagement.service";
+export declare class McpManagementService extends Disposable implements IMcpManagementService {
+    private readonly configurationService;
+    private readonly mcpGalleryService;
+    private readonly fileService;
+    private readonly uriIdentityService;
+    private readonly logService;
+    _serviceBrand: undefined;
+    private readonly mcpLocation;
+    private readonly _onInstallMcpServer;
+    readonly onInstallMcpServer: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<InstallMcpServerEvent>;
+    protected readonly _onDidInstallMcpServers: Emitter<InstallMcpServerResult[]>;
+    get onDidInstallMcpServers(): import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<InstallMcpServerResult[]>;
+    protected readonly _onUninstallMcpServer: Emitter<UninstallMcpServerEvent>;
+    get onUninstallMcpServer(): import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<UninstallMcpServerEvent>;
+    protected _onDidUninstallMcpServer: Emitter<DidUninstallMcpServerEvent>;
+    get onDidUninstallMcpServer(): import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<DidUninstallMcpServerEvent>;
+    constructor(configurationService: IConfigurationService, mcpGalleryService: IMcpGalleryService, fileService: IFileService, environmentService: IEnvironmentService, uriIdentityService: IUriIdentityService, logService: ILogService);
+    getInstalled(): Promise<ILocalMcpServer[]>;
+    private scanServer;
+    installFromGallery(server: IGalleryMcpServer, packageType?: PackageType): Promise<void>;
+    uninstall(server: ILocalMcpServer): Promise<void>;
+    private getServerConfig;
+    private getCommandName;
+    private getVariables;
+}

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

@@ -0,0 +1,292 @@
+
+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 { 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 { 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 { 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 { IMcpGalleryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpManagement.service';
+import { McpServerVariableType } from './mcpPlatformTypes.js';
+
+let McpManagementService = class McpManagementService extends Disposable {
+    get onDidInstallMcpServers() { return this._onDidInstallMcpServers.event; }
+    get onUninstallMcpServer() { return this._onUninstallMcpServer.event; }
+    get onDidUninstallMcpServer() { return this._onDidUninstallMcpServer.event; }
+    constructor(configurationService, mcpGalleryService, fileService, environmentService, uriIdentityService, logService) {
+        super();
+        this.configurationService = configurationService;
+        this.mcpGalleryService = mcpGalleryService;
+        this.fileService = fileService;
+        this.uriIdentityService = uriIdentityService;
+        this.logService = logService;
+        this._onInstallMcpServer = this._register(( new Emitter()));
+        this.onInstallMcpServer = this._onInstallMcpServer.event;
+        this._onDidInstallMcpServers = this._register(( new Emitter()));
+        this._onUninstallMcpServer = this._register(( new Emitter()));
+        this._onDidUninstallMcpServer = this._register(( new Emitter()));
+        this.mcpLocation = uriIdentityService.extUri.joinPath(environmentService.userRoamingDataHome, 'mcp');
+    }
+    async getInstalled() {
+        const { userLocal } = this.configurationService.inspect('mcp');
+        if (!userLocal?.value?.servers) {
+            return [];
+        }
+        return Promise.all(( Object.entries(userLocal.value.servers).map(([name, config]) => this.scanServer(name, config))));
+    }
+    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()));
+            }
+            catch (e) {
+                this.logService.error('MCP Management Service: failed to read manifest', ( config.location.toString()), e);
+            }
+            readmeUrl = this.uriIdentityService.extUri.joinPath(URI.revive(config.location), 'README.md');
+            if (!(await this.fileService.exists(readmeUrl))) {
+                readmeUrl = undefined;
+            }
+        }
+        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];
+                }
+            }
+            scanned = {
+                name,
+                version: '1.0.0',
+                displayName: ( nameParts[nameParts.length - 1].split('-').map(s => uppercaseFirstLetter(s))).join(' '),
+                publisher
+            };
+        }
+        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
+        };
+    }
+    async installFromGallery(server, packageType) {
+        this.logService.trace('MCP Management Service: installGallery', server.url);
+        this._onInstallMcpServer.fire({ name: server.name });
+        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 = {};
+            }
+            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 }]);
+        }
+        catch (e) {
+            this._onDidInstallMcpServers.fire([{ name: server.name, source: server, error: e }]);
+            throw e;
+        }
+    }
+    async uninstall(server) {
+        this.logService.trace('MCP Management Service: uninstall', server.name);
+        this._onUninstallMcpServer.fire({ name: server.name });
+        try {
+            const { userLocal } = this.configurationService.inspect('mcp');
+            const value = deepClone(userLocal?.value ?? { servers: {} });
+            if (!value.servers) {
+                value.servers = {};
+            }
+            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);
+            if (server.location) {
+                await this.fileService.del(URI.revive(server.location), { recursive: true });
+            }
+            this._onDidUninstallMcpServer.fire({ name: server.name });
+        }
+        catch (e) {
+            this._onDidUninstallMcpServer.fire({ name: server.name, error: e });
+            throw e;
+        }
+    }
+    getServerConfig(manifest, packageType) {
+        if (packageType === undefined) {
+            packageType = manifest.packages?.[0]?.registry_name ?? PackageType.REMOTE;
+        }
+        if (packageType === PackageType.REMOTE) {
+            const inputs = [];
+            const headers = {};
+            for (const input of manifest.remotes[0].headers ?? []) {
+                headers[input.name] = input.value;
+                if (input.variables) {
+                    inputs.push(...this.getVariables(input.variables));
+                }
+            }
+            return {
+                type: 'http',
+                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 if (arg.type === 'named') {
+                args.push(arg.name);
+                if (arg.value) {
+                    args.push(arg.value);
+                }
+            }
+            if (arg.variables) {
+                inputs.push(...this.getVariables(arg.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}}`);
+            }
+            env[input.name] = value;
+            if (variables.length) {
+                inputs.push(...variables);
+            }
+            if (serverPackage.registry_name === PackageType.DOCKER) {
+                args.push('-e');
+                args.push(input.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 (arg.type === 'named') {
+                args.push(arg.name);
+                if (arg.value) {
+                    args.push(arg.value);
+                }
+            }
+            if (arg.variables) {
+                inputs.push(...this.getVariables(arg.variables));
+            }
+        }
+        return {
+            type: 'stdio',
+            command: this.getCommandName(serverPackage.registry_name),
+            args: args.length ? args : undefined,
+            env: ( Object.keys(env)).length ? env : undefined,
+            inputs: inputs.length ? inputs : undefined,
+        };
+    }
+    getCommandName(packageType) {
+        switch (packageType) {
+            case PackageType.NODE: return 'npx';
+            case PackageType.DOCKER: return 'docker';
+            case PackageType.PYTHON: return 'uvx';
+        }
+        return packageType;
+    }
+    getVariables(variableInputs) {
+        const variables = [];
+        for (const [key, value] of Object.entries(variableInputs)) {
+            variables.push({
+                id: key,
+                type: value.choices ? McpServerVariableType.PICK : McpServerVariableType.PROMPT,
+                description: value.description ?? '',
+                password: !!value.is_secret,
+                default: value.default,
+                options: value.choices,
+            });
+        }
+        return variables;
+    }
+};
+McpManagementService = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IMcpGalleryService)),
+    ( __param(2, IFileService)),
+    ( __param(3, IEnvironmentService)),
+    ( __param(4, IUriIdentityService)),
+    ( __param(5, ILogService))
+], McpManagementService));
+
+export { McpManagementService };

package/vscode/src/vs/platform/mcp/common/mcpPlatformTypes.d.ts

@@ -0,0 +1,65 @@
+import { IStringDictionary } from "@codingame/monaco-vscode-api/vscode/vs/base/common/collections";
+import { UriComponents } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+export interface IMcpConfiguration {
+    inputs?: unknown[];
+    mcpServers?: Record<string, IMcpConfigurationStdio>;
+    servers?: Record<string, IMcpConfigurationStdio | IMcpConfigurationHTTP>;
+}
+export type McpConfigurationServer = IMcpConfigurationStdio | IMcpConfigurationHTTP;
+export interface IMcpDevModeConfig {
+    watch?: string | string[];
+    debug?: {
+        type: "node";
+    } | {
+        type: "debugpy";
+        debugpyPath?: string;
+    };
+}
+export interface IMcpConfigurationCommon {
+    dev?: IMcpDevModeConfig;
+}
+export interface IMcpConfigurationStdio extends IMcpConfigurationCommon {
+    type?: "stdio";
+    command: string;
+    args?: readonly string[];
+    env?: Record<string, string | number | null>;
+    envFile?: string;
+    cwd?: string;
+}
+export interface IMcpConfigurationHTTP extends IMcpConfigurationCommon {
+    type?: "http";
+    url: string;
+    headers?: Record<string, string>;
+}
+export declare enum McpServerVariableType {
+    PROMPT = "promptString",
+    PICK = "pickString"
+}
+export interface IMcpServerVariable {
+    readonly id: string;
+    readonly type: McpServerVariableType;
+    readonly description: string;
+    readonly password: boolean;
+    readonly default?: string;
+    readonly options?: readonly string[];
+    readonly serverName?: string;
+}
+export interface IMcpServerConfiguration {
+    readonly location?: UriComponents;
+}
+export interface IMcpStdioServerConfiguration extends IMcpServerConfiguration {
+    readonly type: "stdio";
+    readonly command: string;
+    readonly args?: readonly string[];
+    readonly env?: Record<string, string | number | null>;
+    readonly envFile?: string;
+}
+export interface IMcpRemtoeServerConfiguration extends IMcpServerConfiguration {
+    readonly type: "http";
+    readonly url: string;
+    readonly headers?: Record<string, string>;
+}
+export interface IMcpServersConfiguration {
+    servers?: IStringDictionary<IMcpServerConfiguration>;
+    inputs?: IMcpServerVariable[];
+}