@1mcp/agent 0.28.0 → 0.29.0-beta1

package/build/core/server/serverManager.js

@@ -1,31 +1,45 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { processEnvironment } from '../../config/envProcessor.js';
-import { setupCapabilities } from '../../core/capabilities/capabilityManager.js';
-import { ClientManager } from '../../core/client/clientManager.js';
-import { ServerStatus, } from '../../core/types/index.js';
-import { PresetNotificationService, } from '../../domains/preset/services/presetNotificationService.js';
+import { ConfigManager } from '../../config/configManager.js';
+import { getGlobalContextManager } from '../../core/context/globalContextManager.js';
+import { getFilterCache } from '../../core/filtering/index.js';
+import { ConnectionManager } from '../../core/server/connectionManager.js';
+import { MCPServerLifecycleManager } from '../../core/server/mcpServerLifecycleManager.js';
+import { TemplateConfigurationManager } from '../../core/server/templateConfigurationManager.js';
+import { TemplateServerManager } from '../../core/server/templateServerManager.js';
 import logger, { debugIf } from '../../logger/logger.js';
-import { enhanceServerWithLogging } from '../../logger/mcpLoggingEnhancer.js';
-import { createTransports, inferTransportType } from '../../transport/transportFactory.js';
-import { executeOperation } from '../../utils/core/operationExecution.js';
+/**
+ * Refactored ServerManager that coordinates various server management components
+ *
+ * This class acts as a facade that delegates to specialized managers:
+ * - ConnectionManager: Handles transport connection lifecycle
+ * - TemplateServerManager: Manages template-based server instances
+ * - MCPServerLifecycleManager: Manages MCP server start/stop/restart operations
+ * - ConfigurationManager: Handles configuration reprocessing with circuit breaker
+ */
 export class ServerManager {
     static instance;
-    inboundConns = new Map();
     serverConfig;
     serverCapabilities;
-    outboundConns = new Map();
-    transports = {};
-    connectionSemaphore = new Map();
-    disconnectingIds = new Set();
+    outboundConns;
+    transports;
+    serverConfigData = null; // Cache the config data
     instructionAggregator;
-    clientManager;
-    mcpServers = new Map();
+    // Component managers
+    connectionManager;
+    templateServerManager;
+    mcpServerLifecycleManager;
+    templateConfigurationManager;
+    // Filtering cache (kept separate as it's a shared resource)
+    filterCache = getFilterCache();
     constructor(config, capabilities, outboundConns, transports) {
         this.serverConfig = config;
         this.serverCapabilities = capabilities;
         this.outboundConns = outboundConns;
         this.transports = transports;
-        this.clientManager = ClientManager.getOrCreateInstance();
+        // Initialize component managers
+        this.connectionManager = new ConnectionManager(config, capabilities, outboundConns);
+        this.templateServerManager = new TemplateServerManager();
+        this.mcpServerLifecycleManager = new MCPServerLifecycleManager();
+        this.templateConfigurationManager = new TemplateConfigurationManager();
     }
     static getOrCreateInstance(config, capabilities, outboundConns, transports) {
         if (!ServerManager.instance) {
@@ -40,21 +54,14 @@ export class ServerManager {
         return ServerManager.instance;
     }
     // Test utility method to reset singleton state
-    static resetInstance() {
+    static async resetInstance() {
         if (ServerManager.instance) {
-            // Clean up existing connections with forced close
-            for (const [sessionId] of ServerManager.instance.inboundConns) {
-                ServerManager.instance.disconnectTransport(sessionId, true);
-            }
-            ServerManager.instance.inboundConns.clear();
-            ServerManager.instance.connectionSemaphore.clear();
-            ServerManager.instance.disconnectingIds.clear();
+            await ServerManager.instance.cleanup();
+            ServerManager.instance = undefined;
         }
-        ServerManager.instance = undefined;
     }
     /**
      * Set the instruction aggregator instance
-     * @param aggregator The instruction aggregator to use
      */
     setInstructionAggregator(aggregator) {
         this.instructionAggregator = aggregator;
@@ -62,179 +69,107 @@ export class ServerManager {
         aggregator.on('instructions-changed', () => {
             this.updateServerInstructions();
         });
+        // Set up context change listener for template processing
+        this.setupContextChangeListener();
         debugIf('Instruction aggregator set for ServerManager');
     }
     /**
-     * Update all server instances with new aggregated instructions
+     * Set up context change listener for dynamic template processing
      */
-    updateServerInstructions() {
-        logger.info(`Server instructions have changed. Active sessions: ${this.inboundConns.size}`);
-        for (const [sessionId, _inboundConn] of this.inboundConns) {
+    setupContextChangeListener() {
+        const globalContextManager = getGlobalContextManager();
+        globalContextManager.on('context-changed', async (data) => {
+            logger.info('Context changed, reprocessing templates', {
+                sessionId: data.newContext?.sessionId,
+                sessionChanged: data.sessionIdChanged,
+            });
             try {
-                // Note: The MCP SDK doesn't provide a direct way to update instructions
-                // on an existing server instance. Instructions are set during server construction.
-                // For now, we'll log this for future server instances.
-                debugIf(() => ({ message: `Instructions changed notification for session ${sessionId}`, meta: { sessionId } }));
+                await this.templateConfigurationManager.reprocessTemplatesWithNewContext(data.newContext, async (newConfig) => {
+                    try {
+                        await this.templateConfigurationManager.updateServersWithNewConfig(newConfig, this.getCurrentServerConfigs(), (serverName, config) => this.startServer(serverName, config), (serverName) => this.stopServer(serverName), (serverName, config) => this.restartServer(serverName, config));
+                    }
+                    catch (updateError) {
+                        logger.error('Failed to update all servers with new config, attempting individual updates:', updateError);
+                        await this.templateConfigurationManager.updateServersIndividually(newConfig, (serverName, config) => this.updateServerMetadata(serverName, config));
+                    }
+                });
             }
             catch (error) {
-                logger.warn(`Failed to process instruction change for session ${sessionId}: ${error}`);
+                logger.error('Failed to reprocess templates after context change:', error);
             }
-        }
+        });
+        debugIf('Context change listener set up for ServerManager');
     }
-    async connectTransport(transport, sessionId, opts) {
-        // Check if a connection is already in progress for this session
-        const existingConnection = this.connectionSemaphore.get(sessionId);
-        if (existingConnection) {
-            logger.warn(`Connection already in progress for session ${sessionId}, waiting...`);
-            await existingConnection;
-            return;
-        }
-        // Check if transport is already connected
-        if (this.inboundConns.has(sessionId)) {
-            logger.warn(`Transport already connected for session ${sessionId}`);
-            return;
-        }
-        // Create connection promise to prevent race conditions
-        const connectionPromise = this.performConnection(transport, sessionId, opts);
-        this.connectionSemaphore.set(sessionId, connectionPromise);
-        try {
-            await connectionPromise;
-        }
-        finally {
-            // Clean up the semaphore entry
-            this.connectionSemaphore.delete(sessionId);
+    /**
+     * Get current server configurations
+     */
+    getCurrentServerConfigs() {
+        const configs = new Map();
+        const status = this.mcpServerLifecycleManager.getMcpServerStatus();
+        for (const [serverName, serverInfo] of status) {
+            if (serverInfo.running) {
+                configs.set(serverName, serverInfo.config);
+            }
         }
+        return configs;
     }
-    async performConnection(transport, sessionId, opts) {
-        // Set connection timeout
-        const connectionTimeoutMs = 30000; // 30 seconds
-        const timeoutPromise = new Promise((_, reject) => {
-            setTimeout(() => reject(new Error(`Connection timeout for session ${sessionId}`)), connectionTimeoutMs);
-        });
-        try {
-            await Promise.race([this.doConnect(transport, sessionId, opts), timeoutPromise]);
-        }
-        catch (error) {
-            // Update status to Error if connection exists
-            const connection = this.inboundConns.get(sessionId);
-            if (connection) {
-                connection.status = ServerStatus.Error;
-                connection.lastError = error instanceof Error ? error : new Error(String(error));
+    /**
+     * Update all server instances with new aggregated instructions
+     */
+    updateServerInstructions() {
+        const inboundConns = this.connectionManager.getInboundConnections();
+        logger.info(`Server instructions have changed. Active sessions: ${inboundConns.size}`);
+        for (const [sessionId, _inboundConn] of inboundConns) {
+            try {
+                debugIf(() => ({
+                    message: `Instructions changed notification for session ${sessionId}`,
+                    meta: { sessionId },
+                }));
+            }
+            catch (error) {
+                logger.warn(`Failed to process instruction change for session ${sessionId}: ${error}`);
             }
-            logger.error(`Failed to connect transport for session ${sessionId}:`, error);
-            throw error;
         }
     }
-    async doConnect(transport, sessionId, opts) {
+    async connectTransport(transport, sessionId, opts, context) {
         // Get filtered instructions based on client's filter criteria using InstructionAggregator
         const filteredInstructions = this.instructionAggregator?.getFilteredInstructions(opts, this.outboundConns) || '';
-        // Create server capabilities with filtered instructions
-        const serverOptionsWithInstructions = {
-            ...this.serverCapabilities,
-            instructions: filteredInstructions || undefined,
-        };
-        // Create a new server instance for this transport
-        const server = new Server(this.serverConfig, serverOptionsWithInstructions);
-        // Create server info object first
-        const serverInfo = {
-            server,
-            status: ServerStatus.Connecting,
-            connectedAt: new Date(),
-            ...opts,
-        };
-        // Enhance server with logging middleware
-        enhanceServerWithLogging(server);
-        // Set up capabilities for this server instance
-        await setupCapabilities(this.outboundConns, serverInfo);
-        // Update the configuration reload service with server info
-        // Config reload service removed - handled by ConfigChangeHandler
-        // Store the server instance
-        this.inboundConns.set(sessionId, serverInfo);
-        // Connect the transport to the new server instance
-        await server.connect(transport);
-        // Update status to Connected after successful connection
-        serverInfo.status = ServerStatus.Connected;
-        serverInfo.lastConnected = new Date();
-        // Register client with preset notification service if preset is used
-        if (opts.presetName) {
-            const notificationService = PresetNotificationService.getInstance();
-            const clientConnection = {
-                id: sessionId,
-                presetName: opts.presetName,
-                sendNotification: async (method, params) => {
-                    try {
-                        if (serverInfo.status === ServerStatus.Connected && serverInfo.server.transport) {
-                            await serverInfo.server.notification({ method, params: params || {} });
-                            debugIf(() => ({ message: 'Sent notification to client', meta: { sessionId, method } }));
-                        }
-                        else {
-                            logger.warn('Cannot send notification to disconnected client', { sessionId, method });
-                        }
-                    }
-                    catch (error) {
-                        logger.error('Failed to send notification to client', {
-                            sessionId,
-                            method,
-                            error: error instanceof Error ? error.message : 'Unknown error',
-                        });
-                        throw error;
-                    }
-                },
-                isConnected: () => serverInfo.status === ServerStatus.Connected && !!serverInfo.server.transport,
+        // Load configuration data
+        // Always process templates when context is available to ensure context-specific rendering
+        const configManager = ConfigManager.getInstance();
+        if (!this.serverConfigData) {
+            // First load - static servers only (templates processed separately per context)
+            const { staticServers } = await configManager.loadConfigWithTemplates(undefined);
+            this.serverConfigData = {
+                mcpServers: staticServers,
+                mcpTemplates: {}, // Will be populated per context
             };
-            notificationService.trackClient(clientConnection, opts.presetName);
-            logger.info('Registered client for preset notifications', {
-                sessionId,
-                presetName: opts.presetName,
-            });
         }
-        logger.info(`Connected transport for session ${sessionId}`);
-    }
-    disconnectTransport(sessionId, forceClose = false) {
-        // Prevent recursive disconnection calls
-        if (this.disconnectingIds.has(sessionId)) {
-            return;
+        // Always process templates with current context when context is available
+        if (context) {
+            const { templateServers } = await configManager.loadConfigWithTemplates(context);
+            this.serverConfigData.mcpTemplates = templateServers;
+            // Note: ConfigManager.loadConfigWithTemplates already handles conflict detection
+            // by filtering out static servers that conflict with template servers
         }
-        const server = this.inboundConns.get(sessionId);
-        if (server) {
-            this.disconnectingIds.add(sessionId);
-            try {
-                // Update status to Disconnected
-                server.status = ServerStatus.Disconnected;
-                // Only close the transport if explicitly requested (e.g., during shutdown)
-                // Don't close if this is called from an onclose handler to avoid recursion
-                if (forceClose && server.server.transport) {
-                    try {
-                        server.server.transport.close();
-                    }
-                    catch (error) {
-                        logger.error(`Error closing transport for session ${sessionId}:`, error);
-                    }
-                }
-                // Untrack client from preset notification service
-                const notificationService = PresetNotificationService.getInstance();
-                notificationService.untrackClient(sessionId);
-                debugIf(() => ({ message: 'Untracked client from preset notifications', meta: { sessionId } }));
-                this.inboundConns.delete(sessionId);
-                // Config reload service removed - handled by ConfigChangeHandler
-                logger.info(`Disconnected transport for session ${sessionId}`);
-            }
-            finally {
-                this.disconnectingIds.delete(sessionId);
-            }
+        // If we have context, create template-based servers
+        if (context && this.serverConfigData.mcpTemplates) {
+            await this.templateServerManager.createTemplateBasedServers(sessionId, context, opts, this.serverConfigData, this.outboundConns, this.transports);
         }
+        // Connect the transport
+        await this.connectionManager.connectTransport(transport, sessionId, opts, context, filteredInstructions);
+    }
+    async disconnectTransport(sessionId, forceClose = false) {
+        // Clean up template-based servers for this client
+        await this.templateServerManager.cleanupTemplateServers(sessionId, this.outboundConns, this.transports);
+        // Disconnect the transport
+        await this.connectionManager.disconnectTransport(sessionId, forceClose);
     }
     getTransport(sessionId) {
-        return this.inboundConns.get(sessionId)?.server.transport;
+        return this.connectionManager.getTransport(sessionId);
     }
     getTransports() {
-        const transports = new Map();
-        for (const [id, server] of this.inboundConns.entries()) {
-            if (server.server.transport) {
-                transports.set(id, server.server.transport);
-            }
-        }
-        return transports;
+        return this.connectionManager.getTransports();
     }
     getClientTransports() {
         return this.transports;
@@ -242,290 +177,84 @@ export class ServerManager {
     getClients() {
         return this.outboundConns;
     }
-    /**
-     * Safely get a client by name. Returns undefined if not found or not an own property.
-     * Encapsulates access to prevent prototype pollution and accidental key collisions.
-     */
     getClient(serverName) {
         return this.outboundConns.get(serverName);
     }
     getActiveTransportsCount() {
-        return this.inboundConns.size;
+        return this.connectionManager.getActiveTransportsCount();
     }
     getServer(sessionId) {
-        return this.inboundConns.get(sessionId);
+        return this.connectionManager.getServer(sessionId);
     }
     getInboundConnections() {
-        return this.inboundConns;
+        return this.connectionManager.getInboundConnections();
+    }
+    getTemplateServerManager() {
+        return this.templateServerManager;
     }
     updateClientsAndTransports(newClients, newTransports) {
         this.outboundConns = newClients;
         this.transports = newTransports;
     }
-    /**
-     * Executes a server operation with error handling and retry logic
-     * @param inboundConn The inbound connection to execute the operation on
-     * @param operation The operation to execute
-     * @param options Operation options including timeout and retry settings
-     */
     async executeServerOperation(inboundConn, operation, options = {}) {
-        // Check connection status before executing operation
-        if (inboundConn.status !== ServerStatus.Connected || !inboundConn.server.transport) {
-            throw new Error(`Cannot execute operation: server status is ${inboundConn.status}`);
-        }
-        return executeOperation(() => operation(inboundConn), 'server', options);
+        return this.connectionManager.executeServerOperation(inboundConn, operation, options);
     }
-    /**
-     * Start a new MCP server instance
-     */
     async startServer(serverName, config) {
-        try {
-            logger.info(`Starting MCP server: ${serverName}`);
-            // Check if server is already running
-            if (this.mcpServers.has(serverName)) {
-                logger.warn(`Server ${serverName} is already running`);
-                return;
-            }
-            // Skip disabled servers
-            if (config.disabled) {
-                logger.info(`Server ${serverName} is disabled, skipping start`);
-                return;
-            }
-            // Process environment variables in config
-            const processedConfig = this.processServerConfig(config);
-            // Infer transport type if not specified
-            const configWithType = inferTransportType(processedConfig, serverName);
-            // Create transport for the server
-            const transport = await this.createServerTransport(serverName, configWithType);
-            // Store server info
-            this.mcpServers.set(serverName, {
-                transport,
-                config: configWithType,
-            });
-            // Create client connection to the server using ClientManager
-            await this.connectToServer(serverName, transport, configWithType);
-            logger.info(`Successfully started MCP server: ${serverName}`);
-        }
-        catch (error) {
-            logger.error(`Failed to start MCP server ${serverName}:`, error);
-            throw error;
-        }
+        await this.mcpServerLifecycleManager.startServer(serverName, config, this.outboundConns, this.transports);
     }
-    /**
-     * Stop a server instance
-     */
     async stopServer(serverName) {
-        try {
-            logger.info(`Stopping MCP server: ${serverName}`);
-            // Check if server is running
-            const serverInfo = this.mcpServers.get(serverName);
-            if (!serverInfo) {
-                logger.warn(`Server ${serverName} is not running`);
-                return;
-            }
-            // Disconnect client from the server using ClientManager
-            await this.disconnectFromServer(serverName);
-            // Clean up transport
-            const { transport } = serverInfo;
-            try {
-                if (transport.close) {
-                    await transport.close();
-                }
-            }
-            catch (error) {
-                logger.warn(`Error closing transport for server ${serverName}:`, error);
-            }
-            // Remove from tracking
-            this.mcpServers.delete(serverName);
-            logger.info(`Successfully stopped MCP server: ${serverName}`);
-        }
-        catch (error) {
-            logger.error(`Failed to stop MCP server ${serverName}:`, error);
-            throw error;
-        }
+        await this.mcpServerLifecycleManager.stopServer(serverName, this.outboundConns, this.transports);
     }
-    /**
-     * Restart a server instance
-     */
     async restartServer(serverName, config) {
-        try {
-            logger.info(`Restarting MCP server: ${serverName}`);
-            // Check if server is currently running and stop it
-            const isCurrentlyRunning = this.mcpServers.has(serverName);
-            if (isCurrentlyRunning) {
-                logger.info(`Stopping existing server ${serverName} before restart`);
-                await this.stopServer(serverName);
-            }
-            // Start the server with new configuration
-            await this.startServer(serverName, config);
-            logger.info(`Successfully restarted MCP server: ${serverName}`);
-        }
-        catch (error) {
-            logger.error(`Failed to restart MCP server ${serverName}:`, error);
-            throw error;
-        }
+        await this.mcpServerLifecycleManager.restartServer(serverName, config, this.outboundConns, this.transports);
     }
-    /**
-     * Process server configuration to handle environment variables
-     */
-    processServerConfig(config) {
-        try {
-            // Create a mutable copy for processing
-            const processedConfig = { ...config };
-            // Process environment variables if enabled - only pass env-related fields
-            const envConfig = {
-                inheritParentEnv: config.inheritParentEnv,
-                envFilter: config.envFilter,
-                env: config.env,
-            };
-            const processedEnv = processEnvironment(envConfig);
-            // Replace environment variables in the config while preserving all other fields
-            if (processedEnv.processedEnv && Object.keys(processedEnv.processedEnv).length > 0) {
-                processedConfig.env = processedEnv.processedEnv;
-            }
-            return processedConfig;
-        }
-        catch (error) {
-            logger.warn(`Failed to process environment variables for server config:`, error);
-            return config;
-        }
+    getMcpServerStatus() {
+        return this.mcpServerLifecycleManager.getMcpServerStatus();
     }
-    /**
-     * Create a transport for the given server configuration
-     */
-    async createServerTransport(serverName, config) {
-        try {
-            debugIf(() => ({
-                message: `Creating transport for server ${serverName}`,
-                meta: { serverName, type: config.type, command: config.command, url: config.url },
-            }));
-            // Create transport using the factory pattern
-            const transports = createTransports({ [serverName]: config });
-            const transport = transports[serverName];
-            if (!transport) {
-                throw new Error(`Failed to create transport for server ${serverName}`);
-            }
-            debugIf(() => ({
-                message: `Successfully created transport for server ${serverName}`,
-                meta: { serverName, transportType: config.type },
-            }));
-            return transport;
-        }
-        catch (error) {
-            logger.error(`Failed to create transport for server ${serverName}:`, error);
-            throw error;
-        }
+    isMcpServerRunning(serverName) {
+        return this.mcpServerLifecycleManager.isMcpServerRunning(serverName);
     }
-    /**
-     * Connect to a server using ClientManager
-     */
-    async connectToServer(serverName, transport, _config) {
-        try {
-            if (!this.clientManager) {
-                throw new Error('ClientManager not initialized');
-            }
-            // Create client connection using the existing ClientManager infrastructure
-            const clients = await this.clientManager.createClients({ [serverName]: transport });
-            // Update our local outbound connections
-            const newClient = clients.get(serverName);
-            if (newClient) {
-                this.outboundConns.set(serverName, newClient);
-                this.transports[serverName] = transport;
-            }
-            debugIf(() => ({
-                message: `Successfully connected to server ${serverName}`,
-                meta: { serverName, status: newClient?.status },
-            }));
-        }
-        catch (error) {
-            logger.error(`Failed to connect to server ${serverName}:`, error);
-            throw error;
-        }
+    async updateServerMetadata(serverName, newConfig) {
+        await this.mcpServerLifecycleManager.updateServerMetadata(serverName, newConfig, this.outboundConns);
     }
-    /**
-     * Disconnect from a server using ClientManager
-     */
-    async disconnectFromServer(serverName) {
-        try {
-            if (!this.clientManager) {
-                throw new Error('ClientManager not initialized');
-            }
-            // Remove from outbound connections
-            this.outboundConns.delete(serverName);
-            delete this.transports[serverName];
-            // ClientManager doesn't have explicit disconnect method, so we clean up our references
-            // The actual transport cleanup happens in stopServer
-            debugIf(() => ({
-                message: `Successfully disconnected from server ${serverName}`,
-                meta: { serverName },
-            }));
-        }
-        catch (error) {
-            logger.error(`Failed to disconnect from server ${serverName}:`, error);
-            throw error;
-        }
+    getFilteringStats() {
+        const stats = this.templateServerManager.getFilteringStats();
+        return {
+            tracker: stats.tracker,
+            cache: this.filterCache.getStats(),
+            index: stats.index,
+            enabled: stats.enabled,
+        };
     }
-    /**
-     * Get the status of all managed MCP servers
-     */
-    getMcpServerStatus() {
-        const status = new Map();
-        for (const [serverName, serverInfo] of this.mcpServers.entries()) {
-            status.set(serverName, {
-                running: true,
-                config: serverInfo.config,
-            });
-        }
-        return status;
+    getClientTemplateInfo() {
+        return this.templateServerManager.getClientTemplateInfo();
     }
-    /**
-     * Check if a specific MCP server is running
-     */
-    isMcpServerRunning(serverName) {
-        return this.mcpServers.has(serverName);
+    rebuildTemplateIndex() {
+        this.templateServerManager.rebuildTemplateIndex(this.serverConfigData || undefined);
+    }
+    clearFilterCache() {
+        this.filterCache.clear();
+        logger.info('Filter cache cleared');
+    }
+    getIdleTemplateInstances(idleTimeoutMs = 10 * 60 * 1000) {
+        return this.templateServerManager.getIdleTemplateInstances(idleTimeoutMs);
+    }
+    async cleanupIdleInstances() {
+        return this.templateServerManager.cleanupIdleInstances();
     }
     /**
-     * Update metadata for a running server without restarting it
+     * Clean up all resources (for shutdown)
      */
-    async updateServerMetadata(serverName, newConfig) {
-        try {
-            const serverInfo = this.mcpServers.get(serverName);
-            if (!serverInfo) {
-                logger.warn(`Cannot update metadata for ${serverName}: server not running`);
-                return;
-            }
-            debugIf(() => ({
-                message: `Updating metadata for server ${serverName}`,
-                meta: {
-                    oldConfig: serverInfo.config,
-                    newConfig,
-                },
-            }));
-            // Update the stored configuration with new metadata
-            serverInfo.config = { ...serverInfo.config, ...newConfig };
-            // Update transport metadata if supported
-            const { transport } = serverInfo;
-            if (transport && 'tags' in transport) {
-                // Update tags and other metadata on transport
-                if (newConfig.tags) {
-                    transport.tags = newConfig.tags;
-                }
-            }
-            // Update outbound connections metadata
-            const outboundConn = this.outboundConns.get(serverName);
-            if (outboundConn && outboundConn.transport && 'tags' in outboundConn.transport) {
-                // Update tags in the outbound connection
-                outboundConn.transport.tags = newConfig.tags;
-            }
-            debugIf(() => ({
-                message: `Successfully updated metadata for server ${serverName}`,
-                meta: { newTags: newConfig.tags },
-            }));
-        }
-        catch (error) {
-            logger.error(`Failed to update metadata for server ${serverName}:`, error);
-            throw error;
-        }
+    async cleanup() {
+        // Clean up all connections
+        await this.connectionManager.cleanup();
+        // Clean up template server manager
+        this.templateServerManager.cleanup();
+        // Clean up configuration manager
+        this.templateConfigurationManager.cleanup();
+        // Clear cache
+        this.filterCache.clear();
+        logger.info('ServerManager cleanup completed');
     }
 }
 //# sourceMappingURL=serverManager.js.map