@1mcp/agent 0.1.0

package/build/server.js

@@ -0,0 +1,61 @@
+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 { 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;
+    }
+}
+/**
+ * Main function to set up the MCP server
+ */
+async function setupServer() {
+    try {
+        // Initialize the server
+        const server = await initializeServer();
+        // Create transports from configuration
+        const transports = createTransports();
+        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');
+        logger.info('Server setup completed successfully');
+        return server;
+    }
+    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 };

package/build/services/configReloadService.js

@@ -0,0 +1,98 @@
+import logger from '../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';
+/**
+ * Service to handle dynamic configuration reloading
+ */
+export class ConfigReloadService {
+    static instance;
+    server = null;
+    currentTransports = {};
+    isReloading = false;
+    /**
+     * Private constructor to enforce singleton pattern
+     */
+    constructor() { }
+    /**
+     * Get the singleton instance of the ConfigReloadService
+     * @returns The ConfigReloadService instance
+     */
+    static getInstance() {
+        if (!ConfigReloadService.instance) {
+            ConfigReloadService.instance = new ConfigReloadService();
+        }
+        return ConfigReloadService.instance;
+    }
+    /**
+     * Initialize the service with the server instance
+     * @param server The MCP server instance
+     * @param initialTransports The initial transports
+     */
+    initialize(server, initialTransports) {
+        this.server = server;
+        this.currentTransports = initialTransports;
+        // Set up configuration change listener
+        configManager.on(ConfigChangeEvent.TRANSPORT_CONFIG_CHANGED, this.handleConfigChange.bind(this));
+        // Start watching for configuration changes
+        configManager.startWatching();
+        logger.info('Config reload service initialized');
+    }
+    /**
+     * Handle configuration changes
+     * @param newConfig The new transport configuration
+     */
+    async handleConfigChange(newConfig) {
+        if (!this.server || this.isReloading) {
+            return;
+        }
+        this.isReloading = true;
+        logger.info('Handling configuration change...');
+        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) {
+                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}`);
+                    }
+                }
+                catch (error) {
+                    logger.error(`Error closing transport ${key}: ${error}`);
+                }
+            }
+            // Create clients for the new transports
+            const newClients = await createClients(newTransports);
+            // Recollect and register capabilities with the server
+            await collectAndRegisterCapabilities(newClients, this.server);
+            // Update current transports
+            this.currentTransports = newTransports;
+            logger.info('Configuration reload completed successfully');
+        }
+        catch (error) {
+            logger.error(`Failed to reload configuration: ${error}`);
+        }
+        finally {
+            this.isReloading = false;
+        }
+    }
+    /**
+     * Stop the service and clean up resources
+     */
+    stop() {
+        configManager.stopWatching();
+        configManager.removeAllListeners(ConfigChangeEvent.TRANSPORT_CONFIG_CHANGED);
+        logger.info('Config reload service stopped');
+    }
+}
+export default ConfigReloadService.getInstance();

package/build/utils/errorHandling.js

@@ -0,0 +1,96 @@
+import { ERROR_CODES } from '../constants.js';
+import logger from '../logger.js';
+/**
+ * Custom error types for the MCP agent
+ */
+export class MCPError extends Error {
+    code;
+    data;
+    constructor(message, code, data) {
+        super(message);
+        this.name = 'MCPError';
+        this.code = code;
+        this.data = data;
+    }
+}
+export class ClientNotFoundError extends MCPError {
+    constructor(clientName) {
+        super(`Client not found: ${clientName}`, ERROR_CODES.TRANSPORT_NOT_FOUND);
+        this.name = 'ClientNotFoundError';
+    }
+}
+export class ClientConnectionError extends MCPError {
+    constructor(clientName, originalError) {
+        super(`Failed to connect to client: ${clientName}${originalError ? ` - ${originalError.message}` : ''}`, ERROR_CODES.TRANSPORT_NOT_FOUND, { originalError });
+        this.name = 'ClientConnectionError';
+    }
+}
+export class InvalidRequestError extends MCPError {
+    constructor(message, data) {
+        super(message, ERROR_CODES.INVALID_PARAMS, data);
+        this.name = 'InvalidRequestError';
+    }
+}
+export class ProxyError extends MCPError {
+    constructor(message, originalError) {
+        super(message, ERROR_CODES.INTERNAL_SERVER_ERROR, originalError ? { originalError: originalError.message } : undefined);
+        this.name = 'ProxyError';
+    }
+}
+/**
+ * Handles errors in async functions by wrapping them in a try/catch block
+ * @param fn The async function to wrap
+ * @param errorMessage The error message to log
+ * @returns A wrapped function that handles errors
+ */
+export function withErrorHandling(fn, errorMessage) {
+    return async (...args) => {
+        try {
+            return await fn(...args);
+        }
+        catch (error) {
+            logger.error(`${errorMessage}: ${error}`);
+            // Rethrow MCPErrors as is
+            if (error instanceof MCPError) {
+                throw error;
+            }
+            // Convert other errors to ProxyError
+            throw new ProxyError(errorMessage, error instanceof Error ? error : new Error(String(error)));
+        }
+    };
+}
+/**
+ * Formats an error for JSON-RPC response
+ * @param error The error to format
+ * @returns A formatted error object
+ */
+export function formatErrorResponse(error) {
+    if (error instanceof MCPError) {
+        return {
+            code: error.code,
+            message: error.message,
+            data: error.data,
+        };
+    }
+    return {
+        code: ERROR_CODES.INTERNAL_SERVER_ERROR,
+        message: error instanceof Error ? error.message : String(error),
+    };
+}
+/**
+ * Extracts client name and resource name from a URI
+ * @param uri The URI to parse
+ * @param separator The separator used in the URI
+ * @returns An object with clientName and resourceName
+ * @throws InvalidRequestError if the URI is invalid
+ */
+export function parseUri(uri, separator) {
+    const parts = uri.split(separator);
+    if (parts.length !== 2) {
+        throw new InvalidRequestError(`Invalid URI format: ${uri}`);
+    }
+    return {
+        clientName: parts[0],
+        resourceName: parts[1],
+    };
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@1mcp/agent",
+  "version": "0.1.0",
+  "description": "One MCP server to aggregate them all - A unified Model Context Protocol server implementation",
+  "homepage": "https://1mcp.app",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/1mcp-app/agent.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "bin": {
+    "1mcp": "./build/index.js"
+  },
+  "files": [
+    "build"
+  ],
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "lint-staged": {
+    "*.{js,ts}": [
+      "prettier --write"
+    ]
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.7.0",
+    "express": "^4.21.2",
+    "winston": "^3.17.0",
+    "winston-transport": "^4.9.0",
+    "yargs": "^17.7.2",
+    "yargs-parser": "^21.1.1"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.13.10",
+    "@types/yargs": "^17.0.33",
+    "husky": "^9.1.7",
+    "lint-staged": "^15.5.0",
+    "prettier": "^3.5.3",
+    "tsc-watch": "^6.2.1",
+    "typescript": "^5.3.3"
+  },
+  "scripts": {
+    "dev": "tsc-watch --onSuccess \"node build/index.js\"",
+    "build": "tsc && node -e \"require('fs').chmodSync('build/index.js', '755')\"",
+    "watch": "tsc --watch",
+    "inspector": "npx @modelcontextprotocol/inspector build/index.js"
+  }
+}