@1mcp/agent 0.1.0 → 0.4.0

package/build/services/configReloadService.js

@@ -1,14 +1,14 @@
-import logger from '../logger.js';
-import configManager, { ConfigChangeEvent } from '../config/configManager.js';
-import { createTransports } from '../config/transportConfig.js';
+import logger from '../logger/logger.js';
+import { ConfigChangeEvent, ConfigManager } from '../config/configManager.js';
 import { createClients } from '../clients/clientManager.js';
-import { collectAndRegisterCapabilities } from '../capabilities/capabilityManager.js';
+import { setupCapabilities } from '../capabilities/capabilityManager.js';
+import { createTransports } from '../config/transportConfig.js';
 /**
  * Service to handle dynamic configuration reloading
  */
 export class ConfigReloadService {
     static instance;
-    server = null;
+    serverInfo = null;
     currentTransports = {};
     isReloading = false;
     /**
@@ -27,12 +27,13 @@ export class ConfigReloadService {
     }
     /**
      * Initialize the service with the server instance
-     * @param server The MCP server instance
+     * @param serverInfo The MCP server instance
      * @param initialTransports The initial transports
      */
-    initialize(server, initialTransports) {
-        this.server = server;
+    initialize(serverInfo, initialTransports) {
+        this.serverInfo = serverInfo;
         this.currentTransports = initialTransports;
+        const configManager = ConfigManager.getInstance();
         // Set up configuration change listener
         configManager.on(ConfigChangeEvent.TRANSPORT_CONFIG_CHANGED, this.handleConfigChange.bind(this));
         // Start watching for configuration changes
@@ -44,37 +45,30 @@ export class ConfigReloadService {
      * @param newConfig The new transport configuration
      */
     async handleConfigChange(newConfig) {
-        if (!this.server || this.isReloading) {
+        if (!this.serverInfo || this.isReloading) {
             return;
         }
         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.serverInfo);
             // Update current transports
             this.currentTransports = newTransports;
             logger.info('Configuration reload completed successfully');
@@ -90,6 +84,7 @@ export class ConfigReloadService {
      * Stop the service and clean up resources
      */
     stop() {
+        const configManager = ConfigManager.getInstance();
         configManager.stopWatching();
         configManager.removeAllListeners(ConfigChangeEvent.TRANSPORT_CONFIG_CHANGED);
         logger.info('Config reload service stopped');

package/build/types.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+/**
+ * Zod schema for transport configuration
+ */
+export const transportConfigSchema = z.object({
+    type: z.enum(['stdio', 'sse', 'http']).optional(),
+    disabled: z.boolean().optional(),
+    timeout: z.number().optional(),
+    tags: z.array(z.string()).optional(),
+    // HTTP/SSE Parameters
+    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(),
+});
+/**
+ * Enum representing possible client connection states
+ */
+export var ClientStatus;
+(function (ClientStatus) {
+    /** Client is successfully connected */
+    ClientStatus["Connected"] = "connected";
+    /** Client is disconnected */
+    ClientStatus["Disconnected"] = "disconnected";
+    /** Client encountered an error */
+    ClientStatus["Error"] = "error";
+})(ClientStatus || (ClientStatus = {}));

package/build/utils/clientFiltering.js

@@ -0,0 +1,29 @@
+import logger from '../logger/logger.js';
+/**
+ * Filters clients by tags
+ * @param clients Record of client instances
+ * @param tags Array of tags to filter by
+ * @returns Filtered record of client instances
+ */
+export function filterClientsByTags(clients, tags) {
+    if (!tags || tags.length === 0) {
+        return clients;
+    }
+    const filteredClients = {};
+    let matchedClients = 0;
+    for (const [name, clientInfo] of Object.entries(clients)) {
+        const clientTags = clientInfo.transport.tags || [];
+        const hasMatchingTags = tags.every((tag) => clientTags.includes(tag));
+        if (hasMatchingTags) {
+            filteredClients[name] = clientInfo;
+            matchedClients++;
+        }
+    }
+    if (matchedClients === 0) {
+        logger.warn(`No clients found matching tags: ${tags.join(', ')}`);
+    }
+    else {
+        logger.debug(`Found ${matchedClients} clients matching tags: ${tags.join(', ')}`);
+    }
+    return Object.freeze(filteredClients);
+}

package/build/utils/errorHandling.js

@@ -1,47 +1,11 @@
 import { ERROR_CODES } from '../constants.js';
-import logger from '../logger.js';
+import logger from '../logger/logger.js';
+import { MCPError, InvalidRequestError } from './errorTypes.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
+ * Wraps a function with error handling
+ * @param fn The function to wrap
+ * @param errorMessage The error message to use if the function fails
+ * @returns The wrapped function
  */
 export function withErrorHandling(fn, errorMessage) {
     return async (...args) => {
@@ -54,11 +18,70 @@ export function withErrorHandling(fn, errorMessage) {
             if (error instanceof MCPError) {
                 throw error;
             }
-            // Convert other errors to ProxyError
-            throw new ProxyError(errorMessage, error instanceof Error ? error : new Error(String(error)));
+            // Convert other errors to MCPError
+            throw new MCPError(errorMessage, ERROR_CODES.INTERNAL_SERVER_ERROR, {
+                originalError: error instanceof Error ? error : new Error(String(error)),
+            });
         }
     };
 }
+/**
+ * Normalizes an error to an MCPError type
+ * @param error The error to normalize
+ * @param errorMessage The error message to use if the error is not an MCPError
+ * @returns The normalized error
+ */
+export function normalizeError(error, errorMessage) {
+    if (error instanceof MCPError) {
+        return error;
+    }
+    if (error instanceof Error) {
+        return new MCPError(error.message || errorMessage, ERROR_CODES.INTERNAL_SERVER_ERROR);
+    }
+    return new MCPError(errorMessage, ERROR_CODES.INTERNAL_SERVER_ERROR);
+}
+/**
+ * Checks if an error is a specific MCPError type
+ * @param error The error to check
+ * @param errorType The error type to check against
+ * @returns True if the error is of the specified type
+ */
+export function isMCPError(error, errorType) {
+    return error instanceof errorType;
+}
+/**
+ * Gets the error code from an error
+ * @param error The error to get the code from
+ * @returns The error code
+ */
+export function getErrorCode(error) {
+    if (error instanceof MCPError) {
+        return error.code;
+    }
+    return ERROR_CODES.INTERNAL_SERVER_ERROR;
+}
+/**
+ * Gets the error message from an error
+ * @param error The error to get the message from
+ * @returns The error message
+ */
+export function getErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+/**
+ * Gets the error cause from an error
+ * @param error The error to get the cause from
+ * @returns The error cause
+ */
+export function getErrorCause(error) {
+    if (error instanceof Error && 'cause' in error) {
+        return error.cause;
+    }
+    return undefined;
+}
 /**
  * Formats an error for JSON-RPC response
  * @param error The error to format

package/build/utils/errorTypes.js

@@ -0,0 +1,47 @@
+import { ERROR_CODES } from '../constants.js';
+export class MCPError extends Error {
+    code;
+    data;
+    constructor(message, code, data) {
+        super(message);
+        this.name = 'MCPError';
+        this.code = code;
+        this.data = data;
+    }
+}
+export class ClientConnectionError extends MCPError {
+    constructor(clientName, cause) {
+        super(`Failed to connect to client ${clientName}: ${cause.message}`, ERROR_CODES.TRANSPORT_NOT_FOUND, { cause });
+        this.name = 'ClientConnectionError';
+    }
+}
+export class ClientNotFoundError extends MCPError {
+    constructor(clientName) {
+        super(`Client not found: ${clientName}`, ERROR_CODES.TRANSPORT_NOT_FOUND);
+        this.name = 'ClientNotFoundError';
+    }
+}
+export class ClientOperationError extends MCPError {
+    constructor(clientName, operation, cause, context) {
+        super(`Operation ${operation} failed on client ${clientName}: ${cause.message}`, ERROR_CODES.INTERNAL_SERVER_ERROR, { cause, context });
+        this.name = 'ClientOperationError';
+    }
+}
+export class ValidationError extends MCPError {
+    constructor(message, validationErrors) {
+        super(message, ERROR_CODES.INVALID_PARAMS, { validationErrors });
+        this.name = 'ValidationError';
+    }
+}
+export class TransportError extends MCPError {
+    constructor(transportName, cause) {
+        super(`Transport error for ${transportName}: ${cause.message}`, ERROR_CODES.CLIENT_CONNECTION_ERROR, { cause });
+        this.name = 'TransportError';
+    }
+}
+export class InvalidRequestError extends MCPError {
+    constructor(message, data) {
+        super(message, ERROR_CODES.INVALID_PARAMS, data);
+        this.name = 'InvalidRequestError';
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1mcp/agent",
-  "version": "0.1.0",
+  "version": "0.4.0",
   "description": "One MCP server to aggregate them all - A unified Model Context Protocol server implementation",
   "homepage": "https://1mcp.app",
   "license": "Apache-2.0",
@@ -25,31 +25,53 @@
   },
   "lint-staged": {
     "*.{js,ts}": [
+      "eslint --fix",
       "prettier --write"
     ]
   },
   "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": {
+    "@eslint/js": "^9.22.0",
+    "@testing-library/jest-dom": "^6.6.3",
     "@types/express": "^5.0.0",
+    "@types/jest": "^29.5.14",
     "@types/node": "^22.13.10",
+    "@types/uuid": "^10.0.0",
     "@types/yargs": "^17.0.33",
+    "@typescript-eslint/eslint-plugin": "^8.27.0",
+    "@typescript-eslint/parser": "^8.27.0",
+    "eslint": "^9.22.0",
+    "eslint-config-prettier": "^10.1.1",
+    "eslint-plugin-prettier": "^5.2.3",
+    "globals": "^16.0.0",
     "husky": "^9.1.7",
+    "jest": "^29.7.0",
+    "jiti": "^2.4.2",
     "lint-staged": "^15.5.0",
     "prettier": "^3.5.3",
+    "ts-jest": "^29.2.6",
+    "ts-node": "^10.9.2",
     "tsc-watch": "^6.2.1",
     "typescript": "^5.3.3"
   },
   "scripts": {
-    "dev": "tsc-watch --onSuccess \"node build/index.js\"",
+    "dev": "tsc-watch --onSuccess \"node build/index.js --config ./mcp.json\"",
     "build": "tsc && node -e \"require('fs').chmodSync('build/index.js', '755')\"",
     "watch": "tsc --watch",
-    "inspector": "npx @modelcontextprotocol/inspector build/index.js"
+    "inspector": "npx @modelcontextprotocol/inspector build/index.js",
+    "lint": "eslint . --ext .ts",
+    "lint:fix": "eslint . --ext .ts --fix",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
   }
 }