@aws/lsp-codewhisperer 0.0.90 → 0.0.92

package/out/language-server/agenticChat/tools/mcp/mcpManager.js

@@ -21,6 +21,7 @@ const utils_1 = require("../../../../shared/utils");
 const profileStatusMonitor_1 = require("./profileStatusMonitor");
 const mcpOauthClient_1 = require("./mcpOauthClient");
 const agentPermissionManager_1 = require("./agentPermissionManager");
+const mcpRegistryService_1 = require("./mcpRegistryService");
 exports.MCP_SERVER_STATUS_CHANGED = 'mcpServerStatusChanged';
 exports.AGENT_TOOLS_CHANGED = 'agentToolsChanged';
 var AuthIntent;
@@ -48,6 +49,10 @@ class McpManager {
     serverNameMapping;
     agentConfig;
     permissionManager;
+    registryService;
+    currentRegistry = null;
+    registryUrlProvided = false;
+    isPeriodicSync = false;
     constructor(agentPaths, features) {
         this.agentPaths = agentPaths;
         this.features = features;
@@ -62,60 +67,31 @@ class McpManager {
         this.toolNameMapping = new Map();
         this.serverNameMapping = new Map();
     }
-    static async init(agentPaths, features) {
+    static async init(agentPaths, features, options) {
         if (!McpManager.#instance) {
             const mgr = new McpManager(agentPaths, features);
             McpManager.#instance = mgr;
-            try {
-                const shouldDiscoverServers = profileStatusMonitor_1.ProfileStatusMonitor.getMcpState();
-                if (shouldDiscoverServers) {
-                    await mgr.discoverAllServers();
-                    features.logging.info(`MCP: discovered ${mgr.mcpTools.length} tools across all servers`);
-                }
-                else {
-                    // MCP is disabled - create empty instance without connecting to any servers
-                    features.logging.info('MCP: initialized without server discovery (MCP disabled)');
-                }
-            }
-            catch (error) {
-                // Log error but keep the empty instance to prevent crashes
-                features.logging.error(`MCP: initialization failed: ${error instanceof Error ? error.message : String(error)}`);
-            }
-            // Emit MCP configuration metrics
-            const serverConfigs = mgr.getAllServerConfigs();
-            const activeServers = Array.from(serverConfigs.entries()).filter(([name, _]) => !mgr.isServerDisabled(name));
-            // Count global vs project servers
-            const globalServers = Array.from(serverConfigs.entries()).filter(([_, config]) => config?.__configPath__ === (0, mcpUtils_1.getGlobalAgentConfigPath)(features.workspace.fs.getUserHomeDir())).length;
-            const projectServers = serverConfigs.size - globalServers;
-            // Count tools by permission
-            let toolsAlwaysAllowed = 0;
-            let toolsDenied = 0;
-            for (const [serverName, _] of activeServers) {
-                const toolsWithPermissions = mgr.getAllToolsWithPermissions(serverName);
-                toolsWithPermissions.forEach(item => {
-                    if (item.permission === mcpTypes_1.McpPermissionType.alwaysAllow) {
-                        toolsAlwaysAllowed++;
+            // Initialize registry service if URL provided
+            if (options?.registryUrl) {
+                mgr.registryUrlProvided = true;
+                try {
+                    mgr.registryService = new mcpRegistryService_1.McpRegistryService(features.logging);
+                    const registry = await mgr.registryService.fetchRegistry(options.registryUrl);
+                    if (registry) {
+                        mgr.currentRegistry = registry;
+                        features.logging.info(`MCP Registry: Registry mode ACTIVE - ${registry.servers.length} servers from ${options.registryUrl}`);
                     }
-                    else if (item.permission === mcpTypes_1.McpPermissionType.deny) {
-                        toolsDenied++;
+                    else {
+                        features.logging.error('MCP Registry: Failed to fetch registry');
                     }
-                });
-            }
-            // Emit MCP configuration metrics
-            if (features.telemetry) {
-                features.telemetry.emitMetric({
-                    name: types_1.ChatTelemetryEventName.MCPConfig,
-                    data: {
-                        credentialStartUrl: features.credentialsProvider?.getConnectionMetadata()?.sso?.startUrl,
-                        languageServerVersion: features.runtime?.serverInfo.version,
-                        numActiveServers: activeServers.length,
-                        numGlobalServers: globalServers,
-                        numProjectServers: projectServers,
-                        numToolsAlwaysAllowed: toolsAlwaysAllowed,
-                        numToolsDenied: toolsDenied,
-                    },
-                });
+                }
+                catch (error) {
+                    const errorMsg = error instanceof Error ? error.message : String(error);
+                    features.logging.error(`MCP Registry: Error during initialization: ${errorMsg}`);
+                }
             }
+            // DO NOT discover servers here - wait for auth to be initialized
+            features.logging.info('MCP: Manager initialized, waiting for auth before discovering servers');
         }
         return McpManager.#instance;
     }
@@ -143,12 +119,54 @@ class McpManager {
     getAllServerStates() {
         return new Map(this.mcpServerStates);
     }
+    /**
+     * Emit MCP configuration telemetry metrics
+     * Should be called after servers are discovered and initialized
+     */
+    emitMcpConfigMetrics() {
+        const serverConfigs = this.getAllServerConfigs();
+        const activeServers = Array.from(serverConfigs.entries()).filter(([name, _]) => !this.isServerDisabled(name));
+        // Count global vs project servers
+        const globalServers = Array.from(serverConfigs.entries()).filter(([_, config]) => config?.__configPath__ === (0, mcpUtils_1.getGlobalAgentConfigPath)(this.features.workspace.fs.getUserHomeDir())).length;
+        const projectServers = serverConfigs.size - globalServers;
+        // Count tools by permission
+        let toolsAlwaysAllowed = 0;
+        let toolsDenied = 0;
+        for (const [serverName, _] of activeServers) {
+            const toolsWithPermissions = this.getAllToolsWithPermissions(serverName);
+            toolsWithPermissions.forEach(item => {
+                if (item.permission === mcpTypes_1.McpPermissionType.alwaysAllow) {
+                    toolsAlwaysAllowed++;
+                }
+                else if (item.permission === mcpTypes_1.McpPermissionType.deny) {
+                    toolsDenied++;
+                }
+            });
+        }
+        // Emit MCP configuration metrics
+        if (this.features.telemetry) {
+            this.features.telemetry.emitMetric({
+                name: types_1.ChatTelemetryEventName.MCPConfig,
+                data: {
+                    credentialStartUrl: this.features.credentialsProvider?.getConnectionMetadata()?.sso?.startUrl,
+                    languageServerVersion: this.features.runtime?.serverInfo.version,
+                    numActiveServers: activeServers.length,
+                    numGlobalServers: globalServers,
+                    numProjectServers: projectServers,
+                    numToolsAlwaysAllowed: toolsAlwaysAllowed,
+                    numToolsDenied: toolsDenied,
+                },
+            });
+        }
+        this.features.logging.info(`MCP Config Metrics: ${activeServers.length} active servers, ${this.mcpTools.length} tools`);
+    }
     /**
      * Load configurations and initialize each enabled server.
+     * Should only be called after auth is initialized and MCP is enabled.
      */
     async discoverAllServers() {
-        // Load agent config
-        const result = await (0, mcpUtils_1.loadAgentConfig)(this.features.workspace, this.features.logging, this.agentPaths);
+        // Load agent config with registry support
+        const result = await (0, mcpUtils_1.loadAgentConfig)(this.features.workspace, this.features.logging, this.agentPaths, this.currentRegistry, this.isRegistryModeActive());
         // Extract agent config and other data
         this.agentConfig = result.agentConfig;
         this.permissionManager = new agentPermissionManager_1.AgentPermissionManager(this.agentConfig, (serverName) => this.getAvailableToolsForServer(serverName), () => this.getAllAvailableServerNames(), () => this.getAllBuiltinToolNames());
@@ -177,6 +195,17 @@ class McpManager {
                 this.emitToolsChanged(name);
                 continue;
             }
+            if (!(0, mcpTypes_1.isMCPServerConfig)(cfg)) {
+                this.features.logging.warn(`MCP: server '${name}' has invalid config, skipping`);
+                continue;
+            }
+            // Check if this is a placeholder for a missing registry server
+            if (cfg.__registryError__) {
+                this.features.logging.warn(`MCP: server '${name}' not found in registry, marking as failed`);
+                this.setState(name, mcpTypes_1.McpServerStatus.FAILED, 0, cfg.__registryError__);
+                this.emitToolsChanged(name);
+                continue;
+            }
             serversToInit.push([name, cfg]);
         }
         // Process servers in batches of 5 at a time
@@ -268,12 +297,13 @@ class McpManager {
             const isStdio = !!cfg.command;
             const doConnect = async () => {
                 if (isStdio) {
-                    // stdio transport
+                    // stdio transport - merge additional env with base env
+                    const finalEnv = { ...(cfg.env || {}), ...(cfg.__additionalEnv__ || {}) };
                     const mergedEnv = {
                         ...process.env,
                         // Make sure we do not have empty key and value in mergedEnv, or adding server through UI will fail on Windows
-                        ...(cfg.env && !(0, mcpUtils_1.isEmptyEnv)(cfg.env)
-                            ? Object.fromEntries(Object.entries(cfg.env).filter(([k, v]) => k.trim() && v.trim()))
+                        ...(finalEnv && !(0, mcpUtils_1.isEmptyEnv)(finalEnv)
+                            ? Object.fromEntries(Object.entries(finalEnv).filter(([k, v]) => k.trim() && v.trim()))
                             : {}),
                     };
                     let cwd;
@@ -285,12 +315,27 @@ class McpManager {
                     catch {
                         this.features.logging.debug(`MCP: no workspace folder for [${serverName}], continuing without cwd`);
                     }
+                    const argsStr = (cfg.args ?? []).length > 0 ? ` ${(cfg.args ?? []).join(' ')}` : '';
+                    const envKeys = Object.keys(finalEnv || {});
+                    const envInfo = envKeys.length > 0 ? ` (env: ${envKeys.join(', ')})` : '';
+                    this.features.logging.info(`MCP: Executing command: ${cfg.command}${argsStr}${envInfo}`);
                     transport = new stdio_js_1.StdioClientTransport({
                         command: cfg.command,
                         args: cfg.args ?? [],
                         env: mergedEnv,
                         cwd,
+                        stderr: 'pipe',
                     });
+                    // Capture stderr from the transport
+                    const stderrStream = transport.stderr;
+                    if (stderrStream) {
+                        stderrStream.on('data', (data) => {
+                            const output = data.toString().trim();
+                            if (output) {
+                                this.features.logging.warn(`MCP [${serverName}] stderr: ${output}`);
+                            }
+                        });
+                    }
                     this.features.logging.info(`MCP: Connecting MCP server using StdioClientTransport`);
                     try {
                         await client.connect(transport);
@@ -310,11 +355,14 @@ class McpManager {
                     }
                 }
                 else {
-                    // streamable http/SSE transport
+                    // streamable http/SSE transport - merge additional headers with base headers
                     const base = new URL(cfg.url);
                     try {
                         // Use HEAD to check if it needs OAuth
-                        let headers = { ...(cfg.headers ?? {}) };
+                        let headers = {
+                            ...(cfg.headers ?? {}),
+                            ...(cfg.__additionalHeaders__ ?? {}),
+                        };
                         let needsOAuth = false;
                         try {
                             const headResp = await fetch(base, { method: 'HEAD', headers });
@@ -347,6 +395,9 @@ class McpManager {
                                 throw new errors_1.AgenticChatError(`MCP: ${short}`, 'MCPServerAuthFailed');
                             }
                         }
+                        const headerKeys = Object.keys(headers);
+                        const headerInfo = headerKeys.length > 0 ? ` (headers: ${headerKeys.join(', ')})` : '';
+                        this.features.logging.info(`MCP: Connecting to URL: ${cfg.url}${headerInfo}`);
                         try {
                             // try streamable http first
                             transport = new streamableHttp_js_1.StreamableHTTPClientTransport(base, this.buildHttpOpts(headers));
@@ -399,6 +450,15 @@ class McpManager {
                     inputSchema: t.inputSchema ?? {},
                 });
             }
+            // Cache version for registry servers
+            if (this.currentRegistry) {
+                const unsanitizedName = this.serverNameMapping.get(serverName) || serverName;
+                const registryServer = this.currentRegistry.servers.find(s => s.name === unsanitizedName);
+                if (registryServer) {
+                    cfg.__cachedVersion__ = registryServer.version;
+                    this.features.logging.debug(`MCP Registry: Cached version ${registryServer.version} for server '${unsanitizedName}'`);
+                }
+            }
             this.setState(serverName, mcpTypes_1.McpServerStatus.ENABLED, resp.tools.length);
             this.emitToolsChanged(serverName);
         }
@@ -528,11 +588,60 @@ class McpManager {
             throw err;
         }
     }
+    /**
+     * Add a registry server: persist config, register in memory, and initialize.
+     */
+    async addRegistryServer(serverName, cfg, configPath, additionalHeaders, additionalEnv) {
+        const sanitizedName = (0, mcpUtils_1.sanitizeName)(serverName);
+        if (this.mcpServers.has(sanitizedName) &&
+            this.getServerState(sanitizedName)?.status == mcpTypes_1.McpServerStatus.ENABLED) {
+            throw new Error(`MCP: server '${sanitizedName}' already exists`);
+        }
+        // Filter out empty key-value pairs
+        if (additionalHeaders) {
+            additionalHeaders = Object.fromEntries(Object.entries(additionalHeaders).filter(([k, v]) => k.trim() && v.trim()));
+        }
+        if (additionalEnv) {
+            additionalEnv = Object.fromEntries(Object.entries(additionalEnv).filter(([k, v]) => k.trim() && v.trim()));
+        }
+        // Save registry server config with type: 'registry', timeout, and additional headers/env
+        const registryServerConfig = { type: 'registry' };
+        if (cfg.timeout !== undefined) {
+            registryServerConfig.timeout = cfg.timeout;
+        }
+        if (additionalHeaders && Object.keys(additionalHeaders).length > 0) {
+            registryServerConfig.headers = additionalHeaders;
+        }
+        if (additionalEnv && Object.keys(additionalEnv).length > 0) {
+            registryServerConfig.env = additionalEnv;
+        }
+        this.agentConfig.mcpServers[serverName] = registryServerConfig;
+        const serverPrefix = `@${serverName}`;
+        if (!this.agentConfig.tools.includes(serverPrefix)) {
+            this.agentConfig.tools.push(serverPrefix);
+        }
+        await (0, mcpUtils_1.saveServerSpecificAgentConfig)(this.features.workspace, this.features.logging, serverName, registryServerConfig, [serverPrefix], [], configPath);
+        // Store additional headers/env separately and merge for runtime
+        const newCfg = { ...cfg, __configPath__: configPath };
+        if (additionalHeaders && Object.keys(additionalHeaders).length > 0) {
+            newCfg.__additionalHeaders__ = additionalHeaders;
+        }
+        if (additionalEnv && Object.keys(additionalEnv).length > 0) {
+            newCfg.__additionalEnv__ = additionalEnv;
+        }
+        this.mcpServers.set(sanitizedName, newCfg);
+        this.serverNameMapping.set(sanitizedName, serverName);
+        await this.initOneServer(sanitizedName, newCfg, AuthIntent.Interactive);
+    }
     /**
      * Add a new server: persist config, register in memory, and initialize.
      */
     async addServer(serverName, cfg, configPath, isLegacyMcpServer = false) {
         try {
+            // Reject manual server addition when registry is active
+            if (this.isRegistryModeActive()) {
+                throw new Error('MCP: Cannot add servers manually when registry mode is active. Please install servers from the registry.');
+            }
             const sanitizedName = (0, mcpUtils_1.sanitizeName)(serverName);
             if (this.mcpServers.has(sanitizedName) &&
                 this.getServerState(sanitizedName)?.status == mcpTypes_1.McpServerStatus.ENABLED) {
@@ -618,8 +727,9 @@ class McpManager {
     }
     /**
      * Remove a server: shutdown client, remove tools, and delete disk entry.
+     * @param skipAgentConfigRemoval - If true, only removes from mcpManager but keeps in agent config
      */
-    async removeServer(serverName) {
+    async removeServer(serverName, skipAgentConfigRemoval = false) {
         const cfg = this.mcpServers.get(serverName);
         const unsanitizedName = this.serverNameMapping.get(serverName);
         const permission = this.mcpServerPermissions.get(serverName);
@@ -645,8 +755,8 @@ class McpManager {
             });
             agentPath = cfg.__configPath__.replace(path.sep + 'mcp.json', path.sep + 'agents' + path.sep + 'default.json');
         }
-        // Remove from agent config
-        if (unsanitizedName && this.agentConfig) {
+        // Remove from agent config (unless skipAgentConfigRemoval is true)
+        if (!skipAgentConfigRemoval && unsanitizedName && this.agentConfig) {
             // Remove server from mcpServers
             delete this.agentConfig.mcpServers[unsanitizedName];
             // Remove server tools from tools list
@@ -693,7 +803,8 @@ class McpManager {
             const unsanitizedServerName = this.serverNameMapping.get(serverName);
             // Update agent config
             if (this.agentConfig && unsanitizedServerName) {
-                const updatedConfig = { ...(this.agentConfig.mcpServers[unsanitizedServerName] || {}) };
+                const existingConfig = this.agentConfig.mcpServers[unsanitizedServerName];
+                const updatedConfig = { ...((0, mcpTypes_1.isMCPServerConfig)(existingConfig) ? existingConfig : {}) };
                 if (configUpdates.url !== undefined)
                     updatedConfig.url = configUpdates.url;
                 if (configUpdates.headers !== undefined) {
@@ -794,10 +905,11 @@ class McpManager {
         }
     }
     /**
-     * Reinitialize all MCP servers by closing existing connections and rediscovering servers
+     * Reinitialize all MCP servers by closing existing connections
+     * @param isManualRefresh - If true, automatically discovers servers after closing connections
      */
-    async reinitializeMcpServers() {
-        this.features.logging.info('Reinitializing MCP servers');
+    async reinitializeMcpServers(isManualRefresh = false) {
+        this.features.logging.info('Reinitializing MCP servers (closing connections)');
         try {
             // Save the current tool name mapping to preserve tool names across reinitializations
             const savedToolNameMapping = this.getToolNameMapping();
@@ -805,12 +917,17 @@ class McpManager {
             await this.close(true);
             // Restore the saved tool name mapping
             this.setToolNameMapping(savedToolNameMapping);
-            const shouldDiscoverServers = profileStatusMonitor_1.ProfileStatusMonitor.getMcpState();
-            if (shouldDiscoverServers) {
-                await this.discoverAllServers();
+            if (isManualRefresh) {
+                const shouldDiscoverServers = profileStatusMonitor_1.ProfileStatusMonitor.getMcpState();
+                if (shouldDiscoverServers) {
+                    await this.discoverAllServers();
+                }
+                const reinitializedServerCount = McpManager.#instance?.mcpServers.size;
+                this.features.logging.info(`MCP servers reinitialization completed. Total servers: ${reinitializedServerCount}`);
+            }
+            else {
+                this.features.logging.info('MCP servers reinitialization completed (connections closed)');
             }
-            const reinitializedServerCount = McpManager.#instance?.mcpServers.size;
-            this.features.logging.info(`MCP servers reinitialized completed. Total servers: ${reinitializedServerCount}`);
         }
         catch (err) {
             this.features.logging.error(`Error reinitializing MCP servers: ${err.message}`);
@@ -863,8 +980,9 @@ class McpManager {
             });
             // Update server enabled/disabled state (only for non-legacy servers)
             if (!isLegacyMcpServer) {
-                if (this.agentConfig.mcpServers[unsanitizedServerName]) {
-                    this.agentConfig.mcpServers[unsanitizedServerName].disabled = !perm.enabled;
+                const serverCfg = this.agentConfig.mcpServers[unsanitizedServerName];
+                if (serverCfg && (0, mcpTypes_1.isMCPServerConfig)(serverCfg)) {
+                    serverCfg.disabled = !perm.enabled;
                 }
             }
             // Always update the mcpServers map
@@ -879,7 +997,8 @@ class McpManager {
                     const serverPrefix = `@${unsanitizedServerName}`;
                     const serverTools = this.agentConfig.tools.filter(tool => tool === serverPrefix || tool.startsWith(`${serverPrefix}/`));
                     const serverAllowedTools = this.agentConfig.allowedTools.filter(tool => tool === serverPrefix || tool.startsWith(`${serverPrefix}/`));
-                    await (0, mcpUtils_1.saveServerSpecificAgentConfig)(this.features.workspace, this.features.logging, unsanitizedServerName, this.agentConfig.mcpServers[unsanitizedServerName], serverTools, serverAllowedTools, agentPath);
+                    const serverCfg = this.agentConfig.mcpServers[unsanitizedServerName];
+                    await (0, mcpUtils_1.saveServerSpecificAgentConfig)(this.features.workspace, this.features.logging, unsanitizedServerName, (0, mcpTypes_1.isMCPServerConfig)(serverCfg) ? serverCfg : null, serverTools, serverAllowedTools, agentPath, false, (0, mcpTypes_1.isRegistryServerConfig)(serverCfg));
                 }
             }
             // enable/disable server
@@ -953,7 +1072,13 @@ class McpManager {
             return undefined;
         }
         return Array.from(this.configLoadErrors.entries())
-            .map(([server, error]) => `File: ${server}, Error: ${error}`)
+            .map(([server, error]) => {
+            // For registry errors, just return the error message without prefix
+            if (server === 'registry') {
+                return error;
+            }
+            return `File: ${server}, Error: ${error}`;
+        })
             .join('\n\n');
     }
     /**
@@ -1174,6 +1299,143 @@ class McpManager {
         }
         return { requestInit: { headers } };
     }
+    /**
+     * Get the registry service instance
+     */
+    getRegistryService() {
+        return this.registryService;
+    }
+    /**
+     * Check if registry mode is active
+     */
+    isRegistryModeActive() {
+        return this.registryUrlProvided;
+    }
+    /**
+     * Set registry mode active state
+     */
+    setRegistryActive(active) {
+        this.registryUrlProvided = active;
+    }
+    /**
+     * Update registry URL and refetch registry
+     * @throws Error if registry fetch or validation fails
+     */
+    async updateRegistryUrl(registryUrl, isPeriodicSync = false) {
+        if (!this.registryService) {
+            this.registryService = new mcpRegistryService_1.McpRegistryService(this.features.logging);
+        }
+        const wasActive = this.registryUrlProvided;
+        const registry = await this.registryService.fetchRegistry(registryUrl);
+        if (registry) {
+            this.currentRegistry = registry;
+            if (!wasActive) {
+                this.features.logging.info(`MCP Registry: Registry mode ACTIVATED - ${registry.servers.length} servers`);
+            }
+            else {
+                this.features.logging.info(`MCP Registry: Updated registry with ${registry.servers.length} servers`);
+            }
+            // Only sync during periodic updates, not at startup
+            if (isPeriodicSync) {
+                this.isPeriodicSync = true;
+                await this.syncWithRegistry();
+                this.isPeriodicSync = false;
+            }
+        }
+        else {
+            const errorMsg = 'Failed to fetch or validate registry';
+            this.features.logging.error(`MCP Registry: ${errorMsg}`);
+            this.currentRegistry = null;
+            throw new Error(errorMsg);
+        }
+    }
+    /**
+     * Synchronize client configurations with registry updates
+     * Note: Version checking only works with explicit versions, not "latest"
+     */
+    async syncWithRegistry() {
+        if (!this.currentRegistry) {
+            this.features.logging.debug('MCP Registry: No active registry for synchronization');
+            return;
+        }
+        this.features.logging.info('MCP Registry: Starting periodic registry synchronization');
+        const registryServerNames = new Set(this.currentRegistry.servers.map(s => s.name));
+        const configuredServers = Array.from(this.mcpServers.entries());
+        let serversDisabled = 0;
+        let versionsUpdated = 0;
+        for (const [sanitizedName, config] of configuredServers) {
+            const unsanitizedName = this.serverNameMapping.get(sanitizedName) || sanitizedName;
+            const agentConfig = this.agentConfig.mcpServers[unsanitizedName];
+            // Skip non-registry servers
+            if (!agentConfig || !(0, mcpTypes_1.isRegistryServerConfig)(agentConfig)) {
+                continue;
+            }
+            // Check if server still exists in registry
+            if (!registryServerNames.has(unsanitizedName)) {
+                this.features.logging.warn(`MCP Registry: Server '${unsanitizedName}' removed from registry during periodic sync`);
+                // Close client and mark as failed, but keep in agent config
+                const client = this.clients.get(sanitizedName);
+                if (client) {
+                    await client.close();
+                    this.clients.delete(sanitizedName);
+                }
+                this.mcpTools = this.mcpTools.filter(t => t.serverName !== sanitizedName);
+                this.setState(sanitizedName, mcpTypes_1.McpServerStatus.FAILED, 0, 'Server removed from registry');
+                this.emitToolsChanged(sanitizedName);
+                serversDisabled++;
+                continue;
+            }
+            // Check version mismatch for local servers during periodic sync
+            const registryServer = this.currentRegistry.servers.find(s => s.name === unsanitizedName);
+            if (registryServer && registryServer.packages) {
+                const updated = await this.checkAndUpdateVersion(sanitizedName, unsanitizedName, registryServer, config);
+                if (updated)
+                    versionsUpdated++;
+            }
+        }
+        this.features.logging.info(`MCP Registry: Periodic synchronization complete - ${serversDisabled} servers disabled, ${versionsUpdated} versions updated`);
+    }
+    /**
+     * Check version and reinstall if needed
+     * Note: Version checking doesn't work with "latest" versions - only explicit versions are supported
+     */
+    async checkAndUpdateVersion(sanitizedName, unsanitizedName, registryServer, currentConfig) {
+        if (!(0, mcpTypes_1.isMCPServerConfig)(currentConfig)) {
+            return false;
+        }
+        // Use cached version for comparison
+        const cachedVersion = currentConfig.__cachedVersion__;
+        const registryVersion = registryServer.version;
+        if (cachedVersion && cachedVersion !== registryVersion) {
+            const msg = `MCP Registry: Server '${unsanitizedName}' version changed from ${cachedVersion} to ${registryVersion} - reinstalling`;
+            this.features.logging.warn(msg);
+            if (this.isPeriodicSync) {
+                this.features.logging.warn(`WARNING: ${msg}`);
+            }
+            try {
+                await this.reinstallServer(sanitizedName, unsanitizedName, registryServer);
+                return true;
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                this.features.logging.error(`MCP Registry: Failed to reinstall server '${unsanitizedName}': ${errorMsg}`);
+                return false;
+            }
+        }
+        return false;
+    }
+    /**
+     * Reinstall server with new version
+     */
+    async reinstallServer(sanitizedName, unsanitizedName, registryServer) {
+        this.features.logging.info(`MCP Registry: Reinstalling server '${unsanitizedName}' with version ${registryServer.version}`);
+        const configPath = this.mcpServers.get(sanitizedName)?.__configPath__ ||
+            (0, mcpUtils_1.getGlobalAgentConfigPath)(this.features.workspace.fs.getUserHomeDir());
+        await this.removeServer(sanitizedName);
+        const converter = new (await Promise.resolve().then(() => require('./mcpServerConfigConverter'))).McpServerConfigConverter();
+        const newConfig = converter.convertRegistryServer(registryServer);
+        await this.addRegistryServer(unsanitizedName, newConfig, configPath);
+    }
 }
 exports.McpManager = McpManager;
 //# sourceMappingURL=mcpManager.js.map