@1mcp/agent 0.1.0

package/build/handlers/notificationHandlers.js

@@ -0,0 +1,60 @@
+import { CancelledNotificationSchema, ProgressNotificationSchema, LoggingMessageNotificationSchema, ResourceUpdatedNotificationSchema, ResourceListChangedNotificationSchema, ToolListChangedNotificationSchema, PromptListChangedNotificationSchema, InitializedNotificationSchema, RootsListChangedNotificationSchema, } from '@modelcontextprotocol/sdk/types.js';
+import logger from '../logger.js';
+import { withErrorHandling } from '../utils/errorHandling.js';
+/**
+ * Sets up client-to-server notification handlers
+ * @param clients Record of client instances
+ * @param server The MCP server instance
+ */
+export function setupClientToServerNotifications(clients, server) {
+    const clientNotificationSchemas = [
+        CancelledNotificationSchema,
+        ProgressNotificationSchema,
+        LoggingMessageNotificationSchema,
+        ResourceUpdatedNotificationSchema,
+        ResourceListChangedNotificationSchema,
+        ToolListChangedNotificationSchema,
+        PromptListChangedNotificationSchema,
+    ];
+    for (const [name, client] of Object.entries(clients)) {
+        clientNotificationSchemas.forEach((schema) => {
+            client.setNotificationHandler(schema, withErrorHandling(async (notification) => {
+                logger.info(`Received notification in client: ${name} ${JSON.stringify(notification)}`);
+                server.notification({
+                    ...notification,
+                    params: {
+                        ...notification.params,
+                        server: name,
+                    },
+                });
+            }, `Error handling client notification from ${name}`));
+        });
+    }
+}
+/**
+ * Sets up server-to-client notification handlers
+ * @param clients Record of client instances
+ * @param server The MCP server instance
+ */
+export function setupServerToClientNotifications(clients, server) {
+    const serverNotificationSchemas = [
+        CancelledNotificationSchema,
+        ProgressNotificationSchema,
+        InitializedNotificationSchema,
+        RootsListChangedNotificationSchema,
+    ];
+    for (const [name, client] of Object.entries(clients)) {
+        serverNotificationSchemas.forEach((schema) => {
+            server.setNotificationHandler(schema, withErrorHandling(async (notification) => {
+                logger.info(`Received notification in server: ${name} ${JSON.stringify(notification)}`);
+                client.notification({
+                    ...notification,
+                    params: {
+                        ...notification.params,
+                        client: name,
+                    },
+                });
+            }, `Error handling server notification to ${name}`));
+        });
+    }
+}

package/build/handlers/requestHandlers.js

@@ -0,0 +1,218 @@
+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 { MCP_URI_SEPARATOR, MCP_SERVER_NAME } from '../constants.js';
+import { executeClientOperation } from '../clients/clientManager.js';
+import { ProxyError, parseUri, withErrorHandling } from '../utils/errorHandling.js';
+/**
+ * Sends a partial failure notification to inform clients about backend failures
+ * @param server The MCP server instance
+ * @param operation The operation that partially failed
+ * @param failedClients Array of failed clients with error details
+ */
+function sendPartialFailureNotification(server, operation, failedClients) {
+    if (failedClients.length === 0)
+        return;
+    server.notification({
+        method: 'notifications/message',
+        params: {
+            level: 'warning',
+            message: `Partial failure during ${operation}`,
+            logger: MCP_SERVER_NAME,
+            data: {
+                operation,
+                failedClients,
+                timestamp: new Date().toISOString(),
+            },
+        },
+    });
+}
+/**
+ * Registers all request handlers based on available capabilities
+ * @param clients Record of client instances
+ * @param server The MCP server instance
+ * @param capabilities The server capabilities
+ */
+export function registerRequestHandlers(clients, server, capabilities) {
+    // Register logging level handler
+    server.setRequestHandler(SetLevelRequestSchema, async (request) => {
+        setLogLevel(request.params.level);
+        return {};
+    });
+    // Register resource-related handlers if capability is available
+    if (capabilities.resources) {
+        registerResourceHandlers(clients, server);
+    }
+    // Register tool-related handlers if capability is available
+    if (capabilities.tools) {
+        registerToolHandlers(clients, server);
+    }
+    // Register prompt-related handlers if capability is available
+    if (capabilities.prompts) {
+        registerPromptHandlers(clients, server);
+    }
+}
+/**
+ * Registers resource-related request handlers
+ * @param clients Record of client instances
+ * @param server The MCP server instance
+ */
+function registerResourceHandlers(clients, server) {
+    // List Resources handler
+    server.setRequestHandler(ListResourcesRequestSchema, withErrorHandling(async (request) => {
+        const resources = [];
+        const failedClients = [];
+        for (const [name, client] of Object.entries(clients)) {
+            logger.info(`Listing resources for ${name}`);
+            try {
+                const result = await client.listResources(request.params);
+                resources.push(...result.resources.map((resource) => ({
+                    uri: `${name}${MCP_URI_SEPARATOR}${resource.uri}`,
+                    name: resource.name,
+                    description: resource.description,
+                    mimeType: resource.mimeType,
+                })));
+            }
+            catch (error) {
+                logger.error(`Error listing resources for ${name}: ${error}`);
+                failedClients.push({ name, error: error instanceof Error ? error.message : String(error) });
+            }
+        }
+        // If all clients failed, throw an error
+        if (failedClients.length === Object.keys(clients).length && Object.keys(clients).length > 0) {
+            throw new ProxyError('Failed to list resources from all clients', new Error(JSON.stringify(failedClients)));
+        }
+        // Send notification about partial failures
+        if (failedClients.length > 0) {
+            sendPartialFailureNotification(server, 'listResources', failedClients);
+        }
+        return { resources };
+    }, 'Error listing resources'));
+    // List Resource Templates handler
+    server.setRequestHandler(ListResourceTemplatesRequestSchema, withErrorHandling(async (request) => {
+        const resourceTemplates = [];
+        const failedClients = [];
+        for (const [name, client] of Object.entries(clients)) {
+            logger.info(`Listing resource templates for ${name}`);
+            try {
+                const result = await client.listResourceTemplates(request.params);
+                resourceTemplates.push(...result.resourceTemplates.map((template) => ({
+                    uriTemplate: `${name}${MCP_URI_SEPARATOR}${template.uriTemplate}`,
+                    name: template.name,
+                    description: template.description,
+                    mimeType: template.mimeType,
+                })));
+            }
+            catch (error) {
+                logger.error(`Error listing resource templates for ${name}: ${error}`);
+                failedClients.push({ name, error: error instanceof Error ? error.message : String(error) });
+            }
+        }
+        // If all clients failed, throw an error
+        if (failedClients.length === Object.keys(clients).length && Object.keys(clients).length > 0) {
+            throw new ProxyError('Failed to list resource templates from all clients', new Error(JSON.stringify(failedClients)));
+        }
+        // Send notification about partial failures
+        if (failedClients.length > 0) {
+            sendPartialFailureNotification(server, 'listResourceTemplates', failedClients);
+        }
+        return { resourceTemplates };
+    }, 'Error listing resource templates'));
+    // Subscribe Resource handler
+    server.setRequestHandler(SubscribeRequestSchema, withErrorHandling(async (request) => {
+        const { clientName, resourceName } = parseUri(request.params.uri, MCP_URI_SEPARATOR);
+        return executeClientOperation(clients, clientName, (client) => client.subscribeResource({ ...request.params, uri: resourceName }));
+    }, 'Error subscribing to resource'));
+    // Unsubscribe Resource handler
+    server.setRequestHandler(UnsubscribeRequestSchema, withErrorHandling(async (request) => {
+        const { clientName, resourceName } = parseUri(request.params.uri, MCP_URI_SEPARATOR);
+        return executeClientOperation(clients, clientName, (client) => client.unsubscribeResource({ ...request.params, uri: resourceName }));
+    }, 'Error unsubscribing from resource'));
+    // Read Resource handler
+    server.setRequestHandler(ReadResourceRequestSchema, withErrorHandling(async (request) => {
+        const { clientName, resourceName } = parseUri(request.params.uri, MCP_URI_SEPARATOR);
+        return executeClientOperation(clients, clientName, (client) => client.readResource({ ...request.params, uri: resourceName }));
+    }, 'Error reading resource'));
+}
+/**
+ * Registers tool-related request handlers
+ * @param clients Record of client instances
+ * @param server The MCP server instance
+ */
+function registerToolHandlers(clients, server) {
+    // List Tools handler
+    server.setRequestHandler(ListToolsRequestSchema, withErrorHandling(async (request) => {
+        const tools = [];
+        const failedClients = [];
+        for (const [name, client] of Object.entries(clients)) {
+            logger.info(`Listing tools for ${name}`);
+            try {
+                const result = await client.listTools(request.params);
+                tools.push(...result.tools.map((tool) => ({
+                    name: `${name}${MCP_URI_SEPARATOR}${tool.name}`,
+                    description: tool.description,
+                    inputSchema: tool.inputSchema,
+                })));
+            }
+            catch (error) {
+                logger.error(`Error listing tools for ${name}: ${error}`);
+                failedClients.push({ name, error: error instanceof Error ? error.message : String(error) });
+            }
+        }
+        // If all clients failed, throw an error
+        if (failedClients.length === Object.keys(clients).length && Object.keys(clients).length > 0) {
+            throw new ProxyError('Failed to list tools from all clients', new Error(JSON.stringify(failedClients)));
+        }
+        // Send notification about partial failures
+        if (failedClients.length > 0) {
+            sendPartialFailureNotification(server, 'listTools', failedClients);
+        }
+        return { tools };
+    }, 'Error listing tools'));
+    // Call Tool handler
+    server.setRequestHandler(CallToolRequestSchema, withErrorHandling(async (request) => {
+        const { clientName, resourceName: toolName } = parseUri(request.params.name, MCP_URI_SEPARATOR);
+        return executeClientOperation(clients, clientName, (client) => client.callTool({ ...request.params, name: toolName }));
+    }, 'Error calling tool'));
+}
+/**
+ * Registers prompt-related request handlers
+ * @param clients Record of client instances
+ * @param server The MCP server instance
+ */
+function registerPromptHandlers(clients, server) {
+    // List Prompts handler
+    server.setRequestHandler(ListPromptsRequestSchema, withErrorHandling(async (request) => {
+        const prompts = [];
+        const failedClients = [];
+        for (const [name, client] of Object.entries(clients)) {
+            logger.info(`Listing prompts for ${name}`);
+            try {
+                const result = await client.listPrompts(request.params);
+                prompts.push(...result.prompts.map((prompt) => ({
+                    name: `${name}${MCP_URI_SEPARATOR}${prompt.name}`,
+                    description: prompt.description,
+                    arguments: prompt.arguments,
+                })));
+            }
+            catch (error) {
+                logger.error(`Error listing prompts for ${name}: ${error}`);
+                failedClients.push({ name, error: error instanceof Error ? error.message : String(error) });
+            }
+        }
+        // If all clients failed, throw an error
+        if (failedClients.length === Object.keys(clients).length && Object.keys(clients).length > 0) {
+            throw new ProxyError('Failed to list prompts from all clients', new Error(JSON.stringify(failedClients)));
+        }
+        // Send notification about partial failures
+        if (failedClients.length > 0) {
+            sendPartialFailureNotification(server, 'listPrompts', failedClients);
+        }
+        return { prompts };
+    }, 'Error listing prompts'));
+    // Get Prompt handler
+    server.setRequestHandler(GetPromptRequestSchema, withErrorHandling(async (request) => {
+        const { clientName, resourceName: promptName } = parseUri(request.params.name, MCP_URI_SEPARATOR);
+        return executeClientOperation(clients, clientName, (client) => client.getPrompt({ ...request.params, name: promptName }));
+    }, 'Error getting prompt'));
+}

package/build/index.js

@@ -0,0 +1,149 @@
+#!/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 configReloadService from './services/configReloadService.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)',
+        type: 'string',
+        choices: ['stdio', 'http'],
+        default: 'http',
+    },
+})
+    .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() {
+    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()) {
+            try {
+                transport.close();
+                logger.info(`Closed transport: ${sessionId}`);
+            }
+            catch (error) {
+                logger.error(`Error closing transport ${sessionId}: ${error}`);
+            }
+        }
+        logger.info('Server shutdown complete');
+        process.exit(0);
+    };
+    // Handle various signals for graceful shutdown
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    process.on('SIGHUP', shutdown);
+}
+/**
+ * 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');
+    }
+    else {
+        // Use HTTP/SSE transport
+        app.listen(PORT, () => {
+            logger.info(`Server is running on port ${PORT} with HTTP/SSE transport`);
+        });
+    }
+}
+main().catch((error) => {
+    logger.error('Server error:', error);
+    process.exit(1);
+});

package/build/logger.js

@@ -0,0 +1,98 @@
+import fs from 'fs';
+import path from 'path';
+import winston from 'winston';
+import { MCPTransport } from './mcpTransport.js';
+// Ensure logs directory exists
+const logsDir = path.join(process.cwd(), 'logs');
+if (!fs.existsSync(logsDir)) {
+    fs.mkdirSync(logsDir, { recursive: true });
+}
+// Map MCP log levels to Winston log levels
+const MCP_TO_WINSTON_LEVEL = {
+    debug: 'debug',
+    info: 'info',
+    notice: 'info',
+    warning: 'warn',
+    error: 'error',
+    critical: 'error',
+    alert: 'error',
+    emergency: 'error',
+};
+// Custom format for console and file output
+const customFormat = winston.format.combine(winston.format.timestamp(), winston.format.printf(({ timestamp, level, message, ...meta }) => {
+    const metaStr = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : '';
+    return `${timestamp} [${level.toUpperCase()}] ${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,
+        }),
+        //
+        // - Write all logs with importance level of `error` or higher to `error.log`
+        //   (i.e., error, fatal, but not other levels)
+        //
+        new winston.transports.File({
+            filename: path.join(logsDir, 'error.log'),
+            level: 'error',
+            format: customFormat,
+        }),
+        //
+        // - Write all logs with importance level of `info` or higher to `combined.log`
+        //   (i.e., fatal, error, warn, and info, but not trace)
+        //
+        new winston.transports.File({
+            filename: path.join(logsDir, 'combined.log'),
+            format: customFormat,
+        }),
+    ],
+    // Prevent logger from exiting on error
+    exitOnError: false,
+});
+// Store a reference to the MCP transport
+let mcpTransport = null;
+/**
+ * Adds the MCP transport to the logger
+ * @param server The MCP server instance
+ * @param loggerName Optional name for the logger in MCP notifications
+ */
+export function addMCPTransport(server, loggerName) {
+    // Add the MCP transport to the logger
+    mcpTransport = new MCPTransport({
+        server,
+        loggerName: loggerName || '1mcp-agent',
+        level: 'info',
+    });
+    logger.add(mcpTransport);
+}
+/**
+ * Set the connection status of the MCP transport
+ * @param connected Whether the server is connected
+ */
+export function setMCPTransportConnected(connected) {
+    if (mcpTransport) {
+        mcpTransport.setConnected(connected);
+    }
+}
+/**
+ * Set the log level for the logger
+ * @param mcpLevel The MCP log level to set
+ */
+export function setLogLevel(mcpLevel) {
+    // Convert MCP log level to Winston log level
+    const winstonLevel = MCP_TO_WINSTON_LEVEL[mcpLevel] || 'info';
+    // Set the log level for all transports
+    logger.level = winstonLevel;
+    logger.transports.forEach((transport) => {
+        transport.level = winstonLevel;
+    });
+    // Also set the level for the MCP transport if it exists
+    if (mcpTransport) {
+        mcpTransport.level = winstonLevel;
+    }
+}
+export default logger;

package/build/mcpTransport.js

@@ -0,0 +1,122 @@
+import Transport from 'winston-transport';
+// Map Winston log levels to MCP log levels
+const LOG_LEVEL_MAP = {
+    error: 'error',
+    warn: 'warning',
+    info: 'info',
+    verbose: 'debug',
+    debug: 'debug',
+    silly: 'debug',
+};
+/**
+ * Winston transport for sending logs to MCP clients
+ */
+export class MCPTransport extends Transport {
+    server;
+    loggerName;
+    connected = false;
+    constructor(options) {
+        super(options);
+        this.server = options.server;
+        this.loggerName = options.loggerName || '1mcp-agent';
+    }
+    /**
+     * Set the connection status of the transport
+     * @param connected Whether the server is connected
+     */
+    setConnected(connected) {
+        this.connected = connected;
+    }
+    /**
+     * Send a log notification to the MCP client
+     * @param info The log info object
+     * @returns true if the notification was sent, false otherwise
+     */
+    sendLogNotification(info) {
+        if (!this.server || !this.connected) {
+            return false;
+        }
+        // Map Winston log level to MCP log level
+        const level = LOG_LEVEL_MAP[info.level] || 'info';
+        const sanitizedData = this.sanitizeData(info);
+        // Extract message and metadata
+        const { message, level: _, ...meta } = sanitizedData;
+        // Create MCP logging notification
+        const notification = {
+            method: 'notifications/message',
+            params: {
+                level,
+                message: typeof message === 'string' ? message : JSON.stringify(message),
+                logger: this.loggerName,
+                data: Object.keys(meta).length > 0 ? meta : undefined,
+            },
+        };
+        // Send notification to MCP clients
+        try {
+            this.server.notification(notification);
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to send log notification to MCP client:', error);
+            return false;
+        }
+    }
+    /**
+     * Sanitize log data to remove sensitive information
+     * @param data The data to sanitize
+     * @returns Sanitized data
+     */
+    sanitizeData(data) {
+        if (typeof data !== 'object' || data === null) {
+            return data;
+        }
+        // List of potentially sensitive field names
+        const sensitiveFields = [
+            'password',
+            'token',
+            'secret',
+            'key',
+            'credential',
+            'auth',
+            'apiKey',
+            'api_key',
+            'accessToken',
+            'access_token',
+            'jwt',
+            'ssn',
+            'creditCard',
+            'credit_card',
+            'cvv',
+            'pin',
+        ];
+        if (Array.isArray(data)) {
+            return data.map((item) => this.sanitizeData(item));
+        }
+        const sanitized = {};
+        for (const [key, value] of Object.entries(data)) {
+            // Check if this is a sensitive field
+            const isSensitive = sensitiveFields.some((field) => key.toLowerCase().includes(field.toLowerCase()));
+            if (isSensitive) {
+                sanitized[key] = '[REDACTED]';
+            }
+            else if (typeof value === 'object' && value !== null) {
+                sanitized[key] = this.sanitizeData(value);
+            }
+            else {
+                sanitized[key] = value;
+            }
+        }
+        return sanitized;
+    }
+    log(info, callback) {
+        setImmediate(() => {
+            this.emit('logged', info);
+        });
+        if (!this.connected) {
+            callback();
+            return;
+        }
+        this.sendLogNotification(info);
+        callback();
+    }
+}