@1mcp/agent/build/serverManager.js

One MCP server to aggregate them all - A unified Model Context Protocol server implementation

import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import logger from './logger/logger.js';
import configReloadService from './services/configReloadService.js';
import { setupCapabilities } from './capabilities/capabilityManager.js';
import { enhanceServerWithLogging } from './middleware/loggingMiddleware.js';
export class ServerManager {
    static instance;
    servers = new Map();
    serverConfig;
    serverCapabilities;
    clients = {};
    transports = {};
    constructor(config, capabilities, clients, transports) {
        this.serverConfig = config;
        this.serverCapabilities = capabilities;
        this.clients = clients;
        this.transports = transports;
    }
    static getInstance(config, capabilities, clients, transports) {
        if (!ServerManager.instance) {
            ServerManager.instance = new ServerManager(config, capabilities, clients, transports);
        }
        return ServerManager.instance;
    }
    async connectTransport(transport, sessionId, tags) {
        try {
            // Create a new server instance for this transport
            const server = new Server(this.serverConfig, this.serverCapabilities);
            // Enhance server with logging middleware
            enhanceServerWithLogging(server);
            const serverInfo = {
                server,
                tags,
            };
            // Set up capabilities for this server instance
            await setupCapabilities(this.clients, serverInfo);
            // Initialize the configuration reload service
            configReloadService.initialize(serverInfo, this.transports);
            // Store the server instance
            this.servers.set(sessionId, serverInfo);
            // Connect the transport to the new server instance
            await server.connect(transport);
            logger.info(`Connected transport for session ${sessionId}`);
        }
        catch (error) {
            logger.error(`Failed to connect transport for session ${sessionId}:`, error);
            throw error;
        }
    }
    disconnectTransport(sessionId) {
        const server = this.servers.get(sessionId);
        if (server) {
            this.servers.delete(sessionId);
            logger.info(`Disconnected transport for session ${sessionId}`);
        }
    }
    getTransport(sessionId) {
        return this.servers.get(sessionId)?.server.transport;
    }
    getTransports() {
        const transports = new Map();
        for (const [id, server] of this.servers.entries()) {
            if (server.server.transport) {
                transports.set(id, server.server.transport);
            }
        }
        return transports;
    }
    getClientTransports() {
        return this.transports;
    }
    getActiveTransportsCount() {
        return this.servers.size;
    }
    getServer(sessionId) {
        return this.servers.get(sessionId);
    }
}