@1mcp/agent 0.1.0 → 0.2.0

package/README.md

@@ -4,47 +4,37 @@ A unified Model Context Protocol server implementation that aggregates multiple
 
 ## Overview
 
-1MCP (One MCP) is designed to simplify the way you work with AI coding assistants. Instead of configuring multiple MCP servers for different clients (Cursor, Roo Code, Claude, etc.), 1MCP provides a single, unified server that:
+1MCP (One MCP) is designed to simplify the way you work with AI assistants. Instead of configuring multiple MCP servers for different clients (Claude Desktop, Cherry Studio, Cursor, Roo Code, Claude, etc.), 1MCP provides a single, unified server that:
 
 - Aggregates multiple MCP servers into one unified interface
 - Reduces system resource usage by eliminating redundant server instances
-- Simplifies configuration management across different AI coding assistants
+- Simplifies configuration management across different AI assistants
 - Provides a standardized way for AI models to interact with external tools and resources
+- Supports dynamic configuration reloading without server restart
+- Handles graceful shutdown and resource cleanup
 
-The implementation includes:
+## Quick Start
 
-- Express-based HTTP server with SSE (Server-Sent Events) support
-- Winston-based logging system with MCP protocol integration
-- Support for MCP capabilities and notifications
-- Smart request routing and capability aggregation
+To enable Cursor to use existing MCP servers already configured in Claude Desktop, follow these steps:
 
-## Server Implementation
-
-The server is implemented using:
-
-- Express.js for HTTP handling
-- Server-Sent Events (SSE) for real-time communication
-- MCP SDK for protocol implementation
-
-### Server Configuration
-
-The server runs on port 3050 by default and exposes the following endpoints:
-
-- `/sse` - SSE endpoint for establishing connections
-- `/messages` - Endpoint for receiving messages from clients
-
-## MCP Logging Implementation
-
-This project includes a Winston transport for the Model Context Protocol (MCP) logging protocol. The implementation allows logs from the agent to be sent to MCP clients using the standard MCP logging notification format.
+1. Run the 1MCP server with the Claude Desktop config file:
+```bash
+npx -y @1mcp/agent --config ~/Library/Application\ Support/Claude/claude_desktop_config.json
+```
 
-### Features
+2. Add the 1MCP server to your Cursor config file (`~/.cursor/mcp.json`):
+```json
+{
+    "mcpServers": {
+        "1mcp": {
+            "type": "http",
+            "url": "http://localhost:3050"
+        }
+    }
+}
+```
 
-- Seamless integration with Winston logger
-- Automatic mapping of Winston log levels to MCP log levels
-- Support for structured logging data
-- Configurable logger name
-- Connection-aware logging (only sends logs when clients are connected)
-- Sensitive data sanitization
+3. Enjoy it!
 
 ## Usage
 
@@ -57,14 +47,107 @@ npx -y @1mcp/agent
 # Run with stdio transport
 npx -y @1mcp/agent --transport stdio
 
+# Run with AI assistant config file
+npx -y @1mcp/agent --config /path/to/ai/assistant/config.json
+
 # Show help
 npx -y @1mcp/agent --help
 ```
 
 Available options:
-- `--transport, -t`: Transport type to use (choices: "stdio", "http", default: "http")
+- `--transport, -t`: Transport type to use (choices: "stdio", "sse", default: "sse")
+- `--config, -c`: Path to the configuration file
 - `--help, -h`: Show help
 
+## Configuration
+
+### Global Configuration
+
+The server automatically manages configuration in a global location:
+
+- macOS/Linux: `~/.config/1mcp/mcp.json`
+- Windows: `%APPDATA%/1mcp/mcp.json`
+
+### Configuration File Format
+
+```json
+{
+  "mcpServers": {
+    "mcp-server-fetch": {
+      "command": "uvx",
+      "args": [
+        "mcp-server-fetch"
+      ],
+      "disabled": false
+    },
+    "server-memory": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@modelcontextprotocol/server-memory"
+      ],
+      "disabled": false
+    }
+  }
+}
+```
+
+## How It Works
+
+### System Architecture
+
+```mermaid
+graph TB
+    subgraph "AI Assistants"
+        A1[Claude Desktop]
+        A2[Cursor]
+        A3[Cherry Studio]
+        A4[Roo Code]
+    end
+
+    subgraph "1MCP Server"
+        MCP[1MCP Agent]
+    end
+
+    subgraph "MCP Servers"
+        S1[Server 1]
+        S2[Server 2]
+        S3[Server 3]
+    end
+
+    A1 -->|sse| MCP
+    A2 -->|sse| MCP
+    A3 -->|sse| MCP
+    A4 -->|sse| MCP
+
+    MCP --> |sse| S1
+    MCP --> |stdio| S2
+    MCP --> |stdio| S3
+```
+
+### Request Flow
+
+```mermaid
+sequenceDiagram
+    participant Client as AI Assistant
+    participant 1MCP as 1MCP Server
+    participant MCP as MCP Servers
+
+    Client->>1MCP: Send MCP Request
+    activate 1MCP
+
+    1MCP->>1MCP: Validate Request
+    1MCP->>1MCP: Load Config
+    1MCP->>MCP: Forward Request
+    activate MCP
+
+    MCP-->>1MCP: Response
+    deactivate MCP
+
+    1MCP-->>Client: Forward Response
+    deactivate 1MCP
+```
+
 ## Development
 
 Install dependencies:
@@ -87,23 +170,6 @@ Run the server:
 pnpm dev
 ```
 
-## Installation
-
-To use with Claude Desktop, add the server config:
-
-On MacOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
-On Windows: `%APPDATA%/Claude/claude_desktop_config.json`
-
-```json
-{
-  "mcpServers": {
-    "agent": {
-      "command": "/path/to/agent/build/index.js"
-    }
-  }
-}
-```
-
 ### Debugging
 
 Since MCP servers communicate over stdio, debugging can be challenging. We recommend using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector), which is available as a package script:

package/build/capabilities/capabilityManager.js

@@ -1,4 +1,4 @@
-import logger from '../logger.js';
+import logger from '../logger/logger.js';
 import { setupClientToServerNotifications, setupServerToClientNotifications, } from '../handlers/notificationHandlers.js';
 import { registerRequestHandlers } from '../handlers/requestHandlers.js';
 /**
@@ -7,15 +7,12 @@ import { registerRequestHandlers } from '../handlers/requestHandlers.js';
  * @param server The MCP server instance
  * @returns The combined server capabilities
  */
-export async function collectAndRegisterCapabilities(clients, server) {
+export async function setupCapabilities(clients, server) {
     // Collect capabilities from all clients
     const capabilities = collectCapabilities(clients);
     // Set up notification handlers
     setupClientToServerNotifications(clients, server);
     setupServerToClientNotifications(clients, server);
-    // Register capabilities with the server
-    logger.info(`Registering capabilities: ${JSON.stringify(capabilities)}`);
-    server.registerCapabilities(capabilities);
     // Register request handlers based on capabilities
     registerRequestHandlers(clients, server, capabilities);
     return capabilities;

package/build/client.js

@@ -1,8 +1,9 @@
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-export default async function createClient(transport) {
+import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from './constants.js';
+export default async function createClient() {
     const client = new Client({
-        name: '1mcp',
-        version: '1.0.0',
+        name: MCP_SERVER_NAME,
+        version: MCP_SERVER_VERSION,
     }, {
         capabilities: {
             experimental: {},

package/build/clients/clientManager.js

@@ -1,6 +1,6 @@
 import createClient from '../client.js';
-import logger from '../logger.js';
-import { CONNECTION_RETRY } from '../constants.js';
+import logger from '../logger/logger.js';
+import { CONNECTION_RETRY, MCP_SERVER_NAME } from '../constants.js';
 import { ClientConnectionError, ClientNotFoundError, withErrorHandling } from '../utils/errorHandling.js';
 /**
  * Creates client instances for all transports with retry logic
@@ -12,7 +12,7 @@ export async function createClients(transports) {
     for (const [name, transport] of Object.entries(transports)) {
         logger.info(`Creating client for ${name}`);
         try {
-            const client = await createClient(transport);
+            const client = await createClient();
             // Connect with retry logic
             await connectWithRetry(client, transport, name);
             clients[name] = client;
@@ -36,7 +36,11 @@ async function connectWithRetry(client, transport, name) {
     for (let i = 0; i < CONNECTION_RETRY.MAX_ATTEMPTS; i++) {
         try {
             await client.connect(transport);
-            logger.info(`Successfully connected to ${name}`);
+            const sv = await client.getServerVersion();
+            if (sv?.name === MCP_SERVER_NAME) {
+                throw new ClientConnectionError(name, new Error('Aborted to prevent circular dependency'));
+            }
+            logger.info(`Successfully connected to ${name} with server ${sv?.name} version ${sv?.version}`);
             return;
         }
         catch (error) {

package/build/config/configManager.js

@@ -1,8 +1,8 @@
 import fs from 'fs';
 import path from 'path';
 import { EventEmitter } from 'events';
-import { MCP_CONFIG_FILE } from '../constants.js';
-import logger from '../logger.js';
+import { getGlobalConfigPath, getGlobalConfigDir, DEFAULT_CONFIG } from '../constants.js';
+import logger from '../logger/logger.js';
 /**
  * Configuration change event types
  */
@@ -20,22 +20,44 @@ export class ConfigManager extends EventEmitter {
     configFilePath;
     /**
      * Private constructor to enforce singleton pattern
+     * @param configFilePath - Optional path to the config file. If not provided, uses global config path
      */
-    constructor() {
+    constructor(configFilePath) {
         super();
-        this.configFilePath = path.resolve(process.cwd(), MCP_CONFIG_FILE);
+        this.configFilePath = configFilePath || getGlobalConfigPath();
+        this.ensureConfigExists();
         this.loadConfig();
     }
     /**
-     * Get the singleton instance of the ConfigManager
-     * @returns The ConfigManager instance
+     * Get the singleton instance of ConfigManager
+     * @param configFilePath - Optional path to the config file
      */
-    static getInstance() {
+    static getInstance(configFilePath) {
         if (!ConfigManager.instance) {
-            ConfigManager.instance = new ConfigManager();
+            ConfigManager.instance = new ConfigManager(configFilePath);
         }
         return ConfigManager.instance;
     }
+    /**
+     * Ensure the config directory and file exist
+     */
+    ensureConfigExists() {
+        try {
+            const configDir = getGlobalConfigDir();
+            if (!fs.existsSync(configDir)) {
+                fs.mkdirSync(configDir, { recursive: true });
+                logger.info(`Created config directory: ${configDir}`);
+            }
+            if (!fs.existsSync(this.configFilePath)) {
+                fs.writeFileSync(this.configFilePath, JSON.stringify(DEFAULT_CONFIG, null, 2));
+                logger.info(`Created default config file: ${this.configFilePath}`);
+            }
+        }
+        catch (error) {
+            logger.error(`Failed to ensure config exists: ${error}`);
+            throw error;
+        }
+    }
     /**
      * Load the configuration from the config file
      */

package/build/config/transportConfig.js

@@ -1,38 +1,74 @@
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
-import logger from '../logger.js';
-import configManager from './configManager.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { z, ZodError } from 'zod';
+import logger from '../logger/logger.js';
 /**
- * Loads transport configurations from the MCP config file
- * @returns Record of transport configurations
+ * Zod schema for transport configuration
  */
-export function loadTransportConfig() {
-    return configManager.getTransportConfig();
-}
+export const transportConfigSchema = z.object({
+    type: z.enum(['stdio', 'sse', 'http']).optional(),
+    disabled: z.boolean().optional(),
+    // SSEServerParameters fields
+    url: z.string().url().optional(),
+    headers: z.record(z.string()).optional(),
+    // StdioServerParameters fields
+    command: z.string().optional(),
+    args: z.array(z.string()).optional(),
+    stderr: z.union([z.string(), z.number()]).optional(),
+    cwd: z.string().optional(),
+    env: z.record(z.string()).optional(),
+});
 /**
  * Creates transport instances from configuration
  * @returns Record of transport instances
  */
-export function createTransports() {
+export function createTransports(mcpConfig) {
     const transports = {};
-    const mcpConfig = loadTransportConfig();
     for (const [name, transport] of Object.entries(mcpConfig)) {
         if (transport.disabled) {
             logger.debug(`Skipping disabled transport: ${name}`);
             continue;
         }
         try {
+            // Validate transport configuration
+            const validatedTransport = transportConfigSchema.parse(transport);
             // Merge environment variables
-            transport.env = {
+            validatedTransport.env = {
                 ...Object.fromEntries(Object.entries(process.env)
                     .filter(([_, v]) => v !== undefined)
                     .map(([k, v]) => [k, String(v)])),
-                ...transport.env,
+                ...validatedTransport.env,
             };
-            transports[name] = new StdioClientTransport(transport);
-            logger.debug(`Created transport for ${name}`);
+            // Create transport based on type
+            if (validatedTransport.type === 'sse' || validatedTransport.type === 'http') {
+                if (!validatedTransport.url) {
+                    throw new Error(`URL is required for SSE transport: ${name}`);
+                }
+                transports[name] = new SSEClientTransport(new URL(validatedTransport.url), {
+                    requestInit: {
+                        headers: validatedTransport.headers,
+                    },
+                });
+            }
+            else {
+                // For stdio transport, ensure required fields are present
+                if (!validatedTransport.command) {
+                    throw new Error(`Command is required for stdio transport: ${name}`);
+                }
+                transports[name] = new StdioClientTransport(validatedTransport);
+            }
+            logger.debug(`Created ${validatedTransport.type} transport for ${name}`);
         }
         catch (error) {
-            logger.error(`Failed to create transport for ${name}: ${error}`);
+            if (error instanceof ZodError) {
+                logger.error(`Invalid transport configuration for ${name}:`, error.errors);
+            }
+            else if (error instanceof Error) {
+                logger.error(`Failed to create transport for ${name}: ${error.message}`);
+            }
+            else {
+                logger.error(`Failed to create transport for ${name}: ${String(error)}`);
+            }
         }
     }
     return transports;

package/build/constants.js

@@ -22,10 +22,40 @@ export const ERROR_CODES = {
 // MCP constants
 export const MCP_CONFIG_FILE = 'mcp.json';
 export const MCP_SERVER_NAME = '1mcp';
-export const MCP_SERVER_VERSION = '0.1.0';
+export const MCP_SERVER_VERSION = '0.2.0';
 export const MCP_URI_SEPARATOR = '_1mcp_';
+// Global config paths
+export const CONFIG_DIR_NAME = '1mcp';
+export const DEFAULT_CONFIG = {
+    mcpServers: {},
+};
+/**
+ * Get the global config directory path based on OS
+ */
+export function getGlobalConfigDir() {
+    const homeDir = process.env.HOME || process.env.USERPROFILE;
+    if (!homeDir) {
+        throw new Error('Could not determine home directory');
+    }
+    const configDir = process.platform === 'darwin' || process.platform === 'linux'
+        ? `${homeDir}/.config/${CONFIG_DIR_NAME}`
+        : `${homeDir}/AppData/Roaming/${CONFIG_DIR_NAME}`;
+    return configDir;
+}
+/**
+ * Get the global config file path
+ */
+export function getGlobalConfigPath() {
+    return `${getGlobalConfigDir()}/${MCP_CONFIG_FILE}`;
+}
 // Connection retry settings
 export const CONNECTION_RETRY = {
     MAX_ATTEMPTS: 3,
     INITIAL_DELAY_MS: 1000,
 };
+export const MCP_SERVER_CAPABILITIES = {
+    logging: {},
+    resources: {},
+    tools: {},
+    prompts: {},
+};

package/build/handlers/notificationHandlers.js

@@ -1,5 +1,5 @@
 import { CancelledNotificationSchema, ProgressNotificationSchema, LoggingMessageNotificationSchema, ResourceUpdatedNotificationSchema, ResourceListChangedNotificationSchema, ToolListChangedNotificationSchema, PromptListChangedNotificationSchema, InitializedNotificationSchema, RootsListChangedNotificationSchema, } from '@modelcontextprotocol/sdk/types.js';
-import logger from '../logger.js';
+import logger from '../logger/logger.js';
 import { withErrorHandling } from '../utils/errorHandling.js';
 /**
  * Sets up client-to-server notification handlers

package/build/handlers/requestHandlers.js

@@ -1,6 +1,6 @@
 import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, ListResourceTemplatesRequestSchema, SubscribeRequestSchema, UnsubscribeRequestSchema, SetLevelRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import logger from '../logger.js';
-import { setLogLevel } from '../logger.js';
+import logger from '../logger/logger.js';
+import { setLogLevel } from '../logger/logger.js';
 import { MCP_URI_SEPARATOR, MCP_SERVER_NAME } from '../constants.js';
 import { executeClientOperation } from '../clients/clientManager.js';
 import { ProxyError, parseUri, withErrorHandling } from '../utils/errorHandling.js';

package/build/index.js

@@ -1,115 +1,45 @@
 #!/usr/bin/env node
-import express from 'express';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
-import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { server } from './server.js';
-import logger, { setMCPTransportConnected } from './logger.js';
-import { PORT, SSE_ENDPOINT, MESSAGES_ENDPOINT, ERROR_CODES } from './constants.js';
+import { setupServer } from './server.js';
+import logger from './logger/logger.js';
 import configReloadService from './services/configReloadService.js';
+import { ConfigManager } from './config/configManager.js';
+import { ExpressServer } from './server/expressServer.js';
 // Parse command line arguments
 const argv = yargs(hideBin(process.argv))
     .usage('Usage: $0 [options]')
     .options({
     transport: {
         alias: 't',
-        describe: 'Transport type to use (stdio or http)',
+        describe: 'Transport type to use (stdio or sse)',
         type: 'string',
-        choices: ['stdio', 'http'],
-        default: 'http',
+        choices: ['stdio', 'sse'],
+        default: 'sse',
+    },
+    config: {
+        alias: 'c',
+        describe: 'Path to the config file',
+        type: 'string',
+        default: undefined,
     },
 })
     .help()
     .alias('help', 'h')
     .parseSync();
-const app = express();
-// app.use(express.json());
-// app.use(express.urlencoded({ extended: true }));
-const transportMap = new Map();
-// Add error handling middleware
-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',
-        },
-    });
-});
-app.get(SSE_ENDPOINT, async (req, res) => {
-    try {
-        logger.info('sse', { query: req.query, headers: req.headers });
-        const transport = new SSEServerTransport(MESSAGES_ENDPOINT, res);
-        await server.connect(transport);
-        transportMap.set(transport.sessionId, transport);
-        // Update MCP transport connection status when a client connects
-        if (transportMap.size === 1) {
-            setMCPTransportConnected(true);
-            logger.info('First client connected, enabling MCP logging transport');
-        }
-        transport.onclose = () => {
-            transportMap.delete(transport.sessionId);
-            logger.info('transport closed', transport.sessionId);
-            // Update MCP transport connection status when all clients disconnect
-            if (transportMap.size === 0) {
-                setMCPTransportConnected(false);
-                logger.info('All clients disconnected, disabling MCP logging transport');
-            }
-        };
-    }
-    catch (error) {
-        logger.error('SSE connection error:', error);
-        res.status(500).end();
-    }
-});
-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 = transportMap.get(sessionId);
-        if (transport) {
-            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',
-            },
-        });
-    }
-});
 /**
  * Set up graceful shutdown handling
  */
-function setupGracefulShutdown() {
+function setupGracefulShutdown(serverManager) {
     const shutdown = async () => {
         logger.info('Shutting down server...');
         // Stop the configuration reload service
         configReloadService.stop();
         // Close all transports
-        for (const [sessionId, transport] of transportMap.entries()) {
+        for (const [sessionId, transport] of serverManager.getTransports().entries()) {
             try {
-                transport.close();
+                transport?.close();
                 logger.info(`Closed transport: ${sessionId}`);
             }
             catch (error) {
@@ -128,19 +58,27 @@ function setupGracefulShutdown() {
  * Start the server using the specified transport.
  */
 async function main() {
-    // Set up graceful shutdown handling
-    setupGracefulShutdown();
-    if (argv.transport === 'stdio') {
-        // Use stdio transport
-        const transport = new StdioServerTransport();
-        await server.connect(transport);
-        logger.info('Server started with stdio transport');
+    try {
+        ConfigManager.getInstance(argv.config);
+        // Initialize server and get server manager with custom config path if provided
+        const serverManager = await setupServer();
+        // Set up graceful shutdown handling
+        setupGracefulShutdown(serverManager);
+        if (argv.transport === 'stdio') {
+            // Use stdio transport
+            const transport = new StdioServerTransport();
+            await serverManager.connectTransport(transport, 'stdio');
+            logger.info('Server started with stdio transport');
+        }
+        else {
+            // Use HTTP/SSE transport
+            const expressServer = new ExpressServer(serverManager);
+            expressServer.start();
+        }
     }
-    else {
-        // Use HTTP/SSE transport
-        app.listen(PORT, () => {
-            logger.info(`Server is running on port ${PORT} with HTTP/SSE transport`);
-        });
+    catch (error) {
+        logger.error('Server error:', error);
+        process.exit(1);
     }
 }
 main().catch((error) => {

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

@@ -23,14 +23,18 @@ const customFormat = winston.format.combine(winston.format.timestamp(), winston.
     const metaStr = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : '';
     return `${timestamp} [${level.toUpperCase()}] ${message}${metaStr}`;
 }));
+const consoleFormat = winston.format.combine(winston.format.timestamp(), winston.format.printf(({ timestamp, level, message, ...meta }) => {
+    const keys = Object.keys(meta);
+    const metaStr = keys.length > 0 ? ` ${keys.map((key) => `${key}=${JSON.stringify(meta[key])}`).join(' ')}` : '';
+    return `${timestamp} [${level.toUpperCase()}] message=${JSON.stringify(message)}${metaStr}`;
+}));
 // Create the logger without the MCP transport initially
 const logger = winston.createLogger({
     level: 'info',
     format: customFormat,
-    defaultMeta: { service: '1mcp' },
     transports: [
         new winston.transports.Console({
-            format: customFormat,
+            format: consoleFormat,
         }),
         //
         // - Write all logs with importance level of `error` or higher to `error.log`
@@ -64,7 +68,7 @@ export function addMCPTransport(server, loggerName) {
     // Add the MCP transport to the logger
     mcpTransport = new MCPTransport({
         server,
-        loggerName: loggerName || '1mcp-agent',
+        loggerName: loggerName || '1mcp',
         level: 'info',
     });
     logger.add(mcpTransport);

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 (error) {
+                // 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,94 @@
+import express from 'express';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import logger, { setMCPTransportConnected } from '../logger/logger.js';
+import { PORT, 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);
+                // Connect the transport using the server manager
+                await this.serverManager.connectTransport(transport, transport.sessionId);
+                // 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() {
+        this.app.listen(PORT, () => {
+            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,71 @@
+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 = {};
+    clientTransports = {};
+    constructor(config, capabilities, clients, clientTransports) {
+        this.serverConfig = config;
+        this.serverCapabilities = capabilities;
+        this.clients = clients;
+        this.clientTransports = clientTransports;
+    }
+    static getInstance(config, capabilities, clients, clientTransports) {
+        if (!ServerManager.instance) {
+            ServerManager.instance = new ServerManager(config, capabilities, clients, clientTransports);
+        }
+        return ServerManager.instance;
+    }
+    async connectTransport(transport, sessionId) {
+        try {
+            // Create a new server instance for this transport
+            const server = new Server(this.serverConfig, this.serverCapabilities);
+            // Enhance server with logging middleware
+            enhanceServerWithLogging(server);
+            // Collect capabilities and register handlers
+            await setupCapabilities(this.clients, server);
+            // Initialize the configuration reload service
+            configReloadService.initialize(server, this.clientTransports);
+            // Connect the transport to the new server instance
+            await server.connect(transport);
+            // Store the server instance
+            this.servers.set(sessionId, server);
+            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)?.transport;
+    }
+    getTransports() {
+        const transports = new Map();
+        for (const [id, server] of this.servers.entries()) {
+            if (server.transport) {
+                transports.set(id, server.transport);
+            }
+        }
+        return transports;
+    }
+    getActiveTransportsCount() {
+        return this.servers.size;
+    }
+    getServer(sessionId) {
+        return this.servers.get(sessionId);
+    }
+}

package/build/services/configReloadService.js

@@ -1,8 +1,8 @@
-import logger from '../logger.js';
+import logger from '../logger/logger.js';
 import configManager, { ConfigChangeEvent } from '../config/configManager.js';
 import { createTransports } from '../config/transportConfig.js';
 import { createClients } from '../clients/clientManager.js';
-import { collectAndRegisterCapabilities } from '../capabilities/capabilityManager.js';
+import { setupCapabilities } from '../capabilities/capabilityManager.js';
 /**
  * Service to handle dynamic configuration reloading
  */
@@ -49,32 +49,25 @@ export class ConfigReloadService {
         }
         this.isReloading = true;
         logger.info('Handling configuration change...');
+        // Store current transports for reconnection
+        const currentTransportEntries = Object.entries(this.currentTransports);
         try {
-            // Create new transports from updated configuration
-            const newTransports = createTransports();
-            // Disconnect and clean up old transports that are no longer in the config
-            // or have changed configuration
-            const transportKeysToRemove = Object.keys(this.currentTransports).filter((key) => !newTransports[key] ||
-                JSON.stringify(newConfig[key]) !== JSON.stringify(configManager.getTransportConfig()[key]));
-            for (const key of transportKeysToRemove) {
+            // Close all current transports
+            for (const [key, transport] of currentTransportEntries) {
                 try {
-                    const transport = this.currentTransports[key];
-                    // Attempt to close the transport if possible
-                    // Note: Transport interface might not have a standard disconnect method,
-                    // but we can safely try to close it if it's a closeable transport
-                    if (transport && 'close' in transport && typeof transport.close === 'function') {
-                        await transport.close();
-                        logger.info(`Closed transport: ${key}`);
-                    }
+                    await transport.close();
+                    logger.info(`Closed transport: ${key}`);
                 }
                 catch (error) {
                     logger.error(`Error closing transport ${key}: ${error}`);
                 }
             }
+            // Create new transports from updated configuration
+            const newTransports = createTransports(newConfig);
             // Create clients for the new transports
             const newClients = await createClients(newTransports);
-            // Recollect and register capabilities with the server
-            await collectAndRegisterCapabilities(newClients, this.server);
+            // Register new capabilities with the server
+            await setupCapabilities(newClients, this.server);
             // Update current transports
             this.currentTransports = newTransports;
             logger.info('Configuration reload completed successfully');

package/build/utils/errorHandling.js

@@ -1,5 +1,5 @@
 import { ERROR_CODES } from '../constants.js';
-import logger from '../logger.js';
+import logger from '../logger/logger.js';
 /**
  * Custom error types for the MCP agent
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1mcp/agent",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "One MCP server to aggregate them all - A unified Model Context Protocol server implementation",
   "homepage": "https://1mcp.app",
   "license": "Apache-2.0",
@@ -31,14 +31,17 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.7.0",
     "express": "^4.21.2",
+    "uuid": "^11.1.0",
     "winston": "^3.17.0",
     "winston-transport": "^4.9.0",
     "yargs": "^17.7.2",
-    "yargs-parser": "^21.1.1"
+    "yargs-parser": "^21.1.1",
+    "zod": "^3.24.2"
   },
   "devDependencies": {
     "@types/express": "^5.0.0",
     "@types/node": "^22.13.10",
+    "@types/uuid": "^10.0.0",
     "@types/yargs": "^17.0.33",
     "husky": "^9.1.7",
     "lint-staged": "^15.5.0",