@1mcp/agent 0.1.0 → 0.4.0

package/build/{mcpTransport.js → logger/mcpTransport.js}

@@ -18,14 +18,30 @@ export class MCPTransport extends Transport {
     constructor(options) {
         super(options);
         this.server = options.server;
-        this.loggerName = options.loggerName || '1mcp-agent';
+        this.loggerName = options.loggerName || '1mcp';
+        // Set up connection status handlers
+        this.setupConnectionHandlers();
+    }
+    /**
+     * Set up handlers for connection status changes
+     */
+    setupConnectionHandlers() {
+        // Handle connection close
+        this.server.onclose = () => {
+            this.setConnected(false);
+        };
     }
     /**
      * Set the connection status of the transport
      * @param connected Whether the server is connected
      */
     setConnected(connected) {
+        const previousState = this.connected;
         this.connected = connected;
+        // Log connection state changes
+        if (previousState !== connected) {
+            console.debug(`MCP Transport connection state changed to: ${connected ? 'connected' : 'disconnected'}`);
+        }
     }
     /**
      * Send a log notification to the MCP client
@@ -112,11 +128,23 @@ export class MCPTransport extends Transport {
         setImmediate(() => {
             this.emit('logged', info);
         });
-        if (!this.connected) {
-            callback();
-            return;
+        // Only try to send if connected
+        if (this.connected) {
+            try {
+                this.sendLogNotification(info);
+            }
+            catch (_) {
+                // Ignore any errors during log sending
+            }
         }
-        this.sendLogNotification(info);
+        // Always call the callback to prevent blocking
         callback();
     }
+    /**
+     * Clean up resources when the transport is closed
+     */
+    close() {
+        this.setConnected(false);
+        this.server.onclose = undefined;
+    }
 }

package/build/middleware/loggingMiddleware.js

@@ -0,0 +1,114 @@
+import { v4 as uuidv4 } from 'uuid';
+import logger from '../logger/logger.js';
+const activeRequests = new Map();
+/**
+ * Logs MCP request details
+ */
+function logRequest(requestId, method, params) {
+    logger.info('MCP Request', {
+        requestId,
+        method,
+        params: JSON.stringify(params),
+        timestamp: new Date().toISOString(),
+    });
+}
+/**
+ * Logs MCP response details
+ */
+function logResponse(requestId, result, duration) {
+    logger.info('MCP Response', {
+        requestId,
+        duration,
+        timestamp: new Date().toISOString(),
+    });
+}
+/**
+ * Logs MCP error details
+ */
+function logError(requestId, error, duration) {
+    logger.error('MCP Error', {
+        requestId,
+        error: error instanceof Error ? error.message : JSON.stringify(error),
+        stack: error instanceof Error ? error.stack : undefined,
+        duration,
+        timestamp: new Date().toISOString(),
+    });
+}
+/**
+ * Logs MCP notification details
+ */
+function logNotification(method, params) {
+    logger.info('MCP Notification', {
+        method,
+        params: JSON.stringify(params),
+        timestamp: new Date().toISOString(),
+    });
+}
+/**
+ * Wraps the original request handler with logging
+ */
+function wrapRequestHandler(originalHandler, method) {
+    return async (request, extra) => {
+        const requestId = uuidv4();
+        const startTime = Date.now();
+        // Store request context
+        activeRequests.set(requestId, {
+            requestId,
+            method,
+            startTime,
+        });
+        // Log request
+        logRequest(requestId, method, request.params);
+        try {
+            // Execute original handler
+            const result = await originalHandler(request, extra);
+            // Log response
+            const duration = Date.now() - startTime;
+            logResponse(requestId, result, duration);
+            return result;
+        }
+        catch (error) {
+            // Log error
+            const duration = Date.now() - startTime;
+            logError(requestId, error, duration);
+            throw error;
+        }
+        finally {
+            // Clean up request context
+            activeRequests.delete(requestId);
+        }
+    };
+}
+/**
+ * Wraps the original notification handler with logging
+ */
+function wrapNotificationHandler(originalHandler, method) {
+    return async (notification) => {
+        // Log notification
+        logNotification(method, notification.params);
+        // Execute original handler
+        await originalHandler(notification);
+    };
+}
+/**
+ * Enhances an MCP server with request/response logging
+ */
+export function enhanceServerWithLogging(server) {
+    // Store original methods
+    const originalSetRequestHandler = server.setRequestHandler.bind(server);
+    const originalSetNotificationHandler = server.setNotificationHandler.bind(server);
+    const originalNotification = server.notification.bind(server);
+    // Override request handler registration
+    server.setRequestHandler = (schema, handler) => {
+        return originalSetRequestHandler(schema, wrapRequestHandler(handler, schema._def.shape().method._def.value));
+    };
+    // Override notification handler registration
+    server.setNotificationHandler = (schema, handler) => {
+        return originalSetNotificationHandler(schema, wrapNotificationHandler(handler, schema._def.shape().method._def.value));
+    };
+    // Override notification sending
+    server.notification = (notification) => {
+        logNotification(notification.method, notification.params);
+        return originalNotification(notification);
+    };
+}

package/build/server/expressServer.js

@@ -0,0 +1,109 @@
+import express from 'express';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import logger, { setMCPTransportConnected } from '../logger/logger.js';
+import { SSE_ENDPOINT, MESSAGES_ENDPOINT, ERROR_CODES } from '../constants.js';
+export class ExpressServer {
+    app;
+    serverManager;
+    constructor(serverManager) {
+        this.app = express();
+        this.serverManager = serverManager;
+        this.setupMiddleware();
+        this.setupRoutes();
+    }
+    setupMiddleware() {
+        // Add error handling middleware
+        this.app.use((err, req, res, _next) => {
+            logger.error('Express error:', err);
+            res.status(500).json({
+                error: {
+                    code: ERROR_CODES.INTERNAL_SERVER_ERROR,
+                    message: 'Internal server error',
+                },
+            });
+        });
+    }
+    setupRoutes() {
+        this.app.get(SSE_ENDPOINT, async (req, res) => {
+            try {
+                logger.info('sse', { query: req.query, headers: req.headers });
+                const transport = new SSEServerTransport(MESSAGES_ENDPOINT, res);
+                // Extract and validate tags from query parameters
+                let tags;
+                if (req.query.tags) {
+                    const tagsStr = req.query.tags;
+                    if (typeof tagsStr !== 'string') {
+                        res.status(400).json({
+                            error: {
+                                code: ERROR_CODES.INVALID_PARAMS,
+                                message: 'Invalid params: tags must be a string',
+                            },
+                        });
+                        return;
+                    }
+                    tags = tagsStr.split(',').filter((tag) => tag.trim().length > 0);
+                }
+                // Connect the transport using the server manager
+                await this.serverManager.connectTransport(transport, transport.sessionId, tags);
+                // Update MCP transport connection status when a client connects
+                if (this.serverManager.getActiveTransportsCount() === 1) {
+                    setMCPTransportConnected(true);
+                    logger.info('First client connected, enabling MCP logging transport');
+                }
+                transport.onclose = () => {
+                    this.serverManager.disconnectTransport(transport.sessionId);
+                    logger.info('transport closed', transport.sessionId);
+                    // Update MCP transport connection status when all clients disconnect
+                    if (this.serverManager.getActiveTransportsCount() === 0) {
+                        setMCPTransportConnected(false);
+                        logger.info('All clients disconnected, disabling MCP logging transport');
+                    }
+                };
+            }
+            catch (error) {
+                logger.error('SSE connection error:', error);
+                res.status(500).end();
+            }
+        });
+        this.app.post(MESSAGES_ENDPOINT, async (req, res) => {
+            try {
+                const sessionId = req.query.sessionId;
+                if (!sessionId) {
+                    res.status(400).json({
+                        error: {
+                            code: ERROR_CODES.INVALID_PARAMS,
+                            message: 'Invalid params: sessionId is required',
+                        },
+                    });
+                    return;
+                }
+                logger.info('message', { body: req.body, sessionId });
+                const transport = this.serverManager.getTransport(sessionId);
+                if (transport instanceof SSEServerTransport) {
+                    await transport.handlePostMessage(req, res);
+                    return;
+                }
+                res.status(404).json({
+                    error: {
+                        code: ERROR_CODES.TRANSPORT_NOT_FOUND,
+                        message: 'Transport not found',
+                    },
+                });
+            }
+            catch (error) {
+                logger.error('Message handling error:', error);
+                res.status(500).json({
+                    error: {
+                        code: ERROR_CODES.INTERNAL_SERVER_ERROR,
+                        message: 'Internal server error',
+                    },
+                });
+            }
+        });
+    }
+    start(port, host) {
+        this.app.listen(port, host, () => {
+            logger.info(`Server is running on port ${port} with HTTP/SSE transport`);
+        });
+    }
+}

package/build/server.js

@@ -1,61 +1,28 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from './constants.js';
-import logger, { addMCPTransport } from './logger.js';
+import { MCP_SERVER_CAPABILITIES, MCP_SERVER_NAME, MCP_SERVER_VERSION } from './constants.js';
+import logger from './logger/logger.js';
 import { createTransports } from './config/transportConfig.js';
 import { createClients } from './clients/clientManager.js';
-import { collectAndRegisterCapabilities } from './capabilities/capabilityManager.js';
-import configReloadService from './services/configReloadService.js';
-/**
- * Initialize and configure the MCP server
- * @returns The configured MCP server instance
- */
-async function initializeServer() {
-    try {
-        // Create the server instance
-        const server = new Server({
-            name: MCP_SERVER_NAME,
-            version: MCP_SERVER_VERSION,
-        }, {
-            capabilities: {
-                logging: {},
-            },
-        });
-        // Initialize the MCP transport for logging
-        addMCPTransport(server, MCP_SERVER_NAME);
-        logger.info('Server created and MCP transport initialized for logging');
-        return server;
-    }
-    catch (error) {
-        logger.error(`Failed to initialize server: ${error}`);
-        throw error;
-    }
-}
+import { ServerManager } from './serverManager.js';
+import { ConfigManager } from './config/configManager.js';
 /**
  * Main function to set up the MCP server
  */
 async function setupServer() {
     try {
-        // Initialize the server
-        const server = await initializeServer();
+        const mcpConfig = ConfigManager.getInstance().getTransportConfig();
         // Create transports from configuration
-        const transports = createTransports();
+        const transports = createTransports(mcpConfig);
         logger.info(`Created ${Object.keys(transports).length} transports`);
         // Create clients for each transport
         const clients = await createClients(transports);
         logger.info(`Created ${Object.keys(clients).length} clients`);
-        // Collect capabilities and register handlers
-        await collectAndRegisterCapabilities(clients, server);
-        // Initialize the configuration reload service
-        configReloadService.initialize(server, transports);
-        logger.info('Configuration reload service initialized');
+        const serverManager = ServerManager.getInstance({ name: MCP_SERVER_NAME, version: MCP_SERVER_VERSION }, { capabilities: MCP_SERVER_CAPABILITIES }, clients, transports);
         logger.info('Server setup completed successfully');
-        return server;
+        return serverManager;
     }
     catch (error) {
         logger.error(`Failed to set up server: ${error}`);
         throw error;
     }
 }
-// Set up the server and export it
-const server = await setupServer();
-export { server };
+export { setupServer };

package/build/serverManager.js

@@ -0,0 +1,78 @@
+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);
+    }
+}

package/build/serverManager.test.js

@@ -0,0 +1,158 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { ServerManager } from './serverManager.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';
+// Mock dependencies
+jest.mock('@modelcontextprotocol/sdk/server/index.js', () => ({
+    Server: jest.fn(),
+}));
+jest.mock('@modelcontextprotocol/sdk/shared/transport.js', () => ({
+    Transport: jest.fn(),
+}));
+jest.mock('./logger/logger.js', () => {
+    const mockLogger = {
+        info: jest.fn(),
+        error: jest.fn(),
+    };
+    return {
+        __esModule: true,
+        default: mockLogger,
+    };
+});
+jest.mock('./services/configReloadService.js', () => ({
+    __esModule: true,
+    default: {
+        initialize: jest.fn(),
+    },
+}));
+jest.mock('./capabilities/capabilityManager.js', () => ({
+    setupCapabilities: jest.fn(),
+}));
+jest.mock('./middleware/loggingMiddleware.js', () => ({
+    enhanceServerWithLogging: jest.fn(),
+}));
+describe('ServerManager', () => {
+    let mockConfig;
+    let mockCapabilities;
+    let mockClients;
+    let mockTransports;
+    let mockTransport;
+    let mockServer;
+    beforeEach(() => {
+        // Reset all mocks
+        jest.clearAllMocks();
+        // Setup test data
+        mockConfig = { name: 'test-server', version: '1.0.0' };
+        mockCapabilities = { capabilities: { test: true } };
+        mockClients = {};
+        mockTransports = {};
+        mockTransport = {
+        // Add any required Transport properties here
+        };
+        mockServer = {
+            connect: jest.fn().mockResolvedValue(undefined),
+            transport: mockTransport,
+        };
+        // Setup mocks
+        Server.mockImplementation(() => mockServer);
+        setupCapabilities.mockResolvedValue(undefined);
+        enhanceServerWithLogging.mockReturnValue(undefined);
+        configReloadService.initialize.mockImplementation(() => undefined);
+    });
+    describe('getInstance', () => {
+        it('should create a singleton instance', () => {
+            const instance1 = ServerManager.getInstance(mockConfig, mockCapabilities, mockClients, mockTransports);
+            const instance2 = ServerManager.getInstance(mockConfig, mockCapabilities, mockClients, mockTransports);
+            expect(instance1).toBe(instance2);
+        });
+    });
+    describe('connectTransport', () => {
+        let serverManager;
+        const sessionId = 'test-session';
+        const tags = ['tag1', 'tag2'];
+        beforeEach(() => {
+            serverManager = ServerManager.getInstance(mockConfig, mockCapabilities, mockClients, mockTransports);
+        });
+        it('should successfully connect a transport', async () => {
+            await serverManager.connectTransport(mockTransport, sessionId, tags);
+            expect(Server).toHaveBeenCalledWith(mockConfig, mockCapabilities);
+            expect(enhanceServerWithLogging).toHaveBeenCalledWith(mockServer);
+            expect(setupCapabilities).toHaveBeenCalled();
+            expect(configReloadService.initialize).toHaveBeenCalled();
+            expect(mockServer.connect).toHaveBeenCalledWith(mockTransport);
+            expect(logger.info).toHaveBeenCalledWith(`Connected transport for session ${sessionId}`);
+        });
+        it('should handle connection errors', async () => {
+            const error = new Error('Connection failed');
+            mockServer.connect.mockRejectedValueOnce(error);
+            await expect(serverManager.connectTransport(mockTransport, sessionId, tags)).rejects.toThrow('Connection failed');
+            expect(logger.error).toHaveBeenCalled();
+        });
+    });
+    describe('disconnectTransport', () => {
+        let serverManager;
+        const sessionId = 'test-session';
+        beforeEach(() => {
+            serverManager = ServerManager.getInstance(mockConfig, mockCapabilities, mockClients, mockTransports);
+        });
+        it('should successfully disconnect a transport', async () => {
+            await serverManager.connectTransport(mockTransport, sessionId);
+            jest.clearAllMocks(); // Clear the logs from connectTransport
+            serverManager.disconnectTransport(sessionId);
+            expect(logger.info).toHaveBeenCalledWith(`Disconnected transport for session ${sessionId}`);
+        });
+        it('should handle non-existent session gracefully', () => {
+            serverManager.disconnectTransport('non-existent');
+            expect(logger.info).not.toHaveBeenCalled();
+        });
+    });
+    describe('transport management methods', () => {
+        let serverManager;
+        const sessionId = 'test-session';
+        beforeEach(async () => {
+            serverManager = ServerManager.getInstance(mockConfig, mockCapabilities, mockClients, mockTransports);
+            await serverManager.connectTransport(mockTransport, sessionId);
+        });
+        it('should get transport by session id', () => {
+            const transport = serverManager.getTransport(sessionId);
+            expect(transport).toBe(mockTransport);
+        });
+        it('should return undefined for non-existent session', () => {
+            const transport = serverManager.getTransport('non-existent');
+            expect(transport).toBeUndefined();
+        });
+        it('should get all transports', () => {
+            const transports = serverManager.getTransports();
+            expect(transports.size).toBe(1);
+            expect(transports.get(sessionId)).toBe(mockTransport);
+        });
+        it('should get client transports', () => {
+            const clientTransports = serverManager.getClientTransports();
+            expect(clientTransports).toEqual(mockTransports);
+        });
+        it('should get active transports count', () => {
+            expect(serverManager.getActiveTransportsCount()).toBe(1);
+        });
+    });
+    describe('getServer', () => {
+        let serverManager;
+        const sessionId = 'test-session';
+        const tags = ['tag1', 'tag2'];
+        beforeEach(async () => {
+            serverManager = ServerManager.getInstance(mockConfig, mockCapabilities, mockClients, mockTransports);
+            await serverManager.connectTransport(mockTransport, sessionId, tags);
+        });
+        it('should return server info for existing session', () => {
+            const serverInfo = serverManager.getServer(sessionId);
+            expect(serverInfo).toBeDefined();
+            expect(serverInfo?.server).toBe(mockServer);
+            expect(serverInfo?.tags).toEqual(tags);
+        });
+        it('should return undefined for non-existent session', () => {
+            const serverInfo = serverManager.getServer('non-existent');
+            expect(serverInfo).toBeUndefined();
+        });
+    });
+});