moflo 4.8.16 → 4.8.19

package/src/@claude-flow/shared/dist/mcp/server.js

@@ -1,593 +0,0 @@
-/**
- * V3 MCP Server Implementation
- *
- * Optimized MCP server with:
- * - Connection pooling for efficient resource usage
- * - Fast tool registration (<10ms)
- * - Optimized request routing (<50ms overhead)
- * - Multiple transport support (stdio, http, websocket, in-process)
- * - Session management with timeout handling
- * - Comprehensive metrics and monitoring
- *
- * Performance Targets:
- * - Server startup: <400ms
- * - Tool registration: <10ms
- * - Tool execution: <50ms overhead
- */
-import { EventEmitter } from 'events';
-import { platform, arch } from 'os';
-import { MCPServerError, ErrorCodes, } from './types.js';
-import { createToolRegistry } from './tool-registry.js';
-import { createSessionManager } from './session-manager.js';
-import { createConnectionPool } from './connection-pool.js';
-import { createTransport, createTransportManager } from './transport/index.js';
-/**
- * Default server configuration
- */
-const DEFAULT_CONFIG = {
-    name: 'Claude-Flow MCP Server V3',
-    version: '3.0.0',
-    transport: 'stdio',
-    host: 'localhost',
-    port: 3000,
-    enableMetrics: true,
-    enableCaching: true,
-    cacheTTL: 10000,
-    logLevel: 'info',
-    requestTimeout: 30000,
-    maxRequestSize: 10 * 1024 * 1024,
-};
-/**
- * V3 MCP Server
- */
-export class MCPServer extends EventEmitter {
-    logger;
-    orchestrator;
-    swarmCoordinator;
-    config;
-    toolRegistry;
-    sessionManager;
-    connectionPool;
-    transportManager;
-    transport;
-    running = false;
-    startTime;
-    startupDuration;
-    currentSession;
-    // Server information
-    serverInfo = {
-        name: 'Claude-Flow MCP Server V3',
-        version: '3.0.0',
-    };
-    // Protocol version
-    protocolVersion = {
-        major: 2024,
-        minor: 11,
-        patch: 5,
-    };
-    // Server capabilities
-    capabilities = {
-        logging: { level: 'info' },
-        tools: { listChanged: true },
-        resources: { listChanged: false, subscribe: false },
-        prompts: { listChanged: false },
-    };
-    // Request statistics
-    requestStats = {
-        total: 0,
-        successful: 0,
-        failed: 0,
-        totalResponseTime: 0,
-    };
-    constructor(config, logger, orchestrator, swarmCoordinator) {
-        super();
-        this.logger = logger;
-        this.orchestrator = orchestrator;
-        this.swarmCoordinator = swarmCoordinator;
-        this.config = { ...DEFAULT_CONFIG, ...config };
-        // Initialize components
-        this.toolRegistry = createToolRegistry(logger);
-        this.sessionManager = createSessionManager(logger, {
-            maxSessions: 100,
-            sessionTimeout: 30 * 60 * 1000,
-        });
-        this.transportManager = createTransportManager(logger);
-        // Initialize connection pool if enabled
-        if (this.config.connectionPool) {
-            this.connectionPool = createConnectionPool(this.config.connectionPool, logger, this.config.transport);
-        }
-        // Setup event handlers
-        this.setupEventHandlers();
-    }
-    /**
-     * Start the MCP server
-     */
-    async start() {
-        if (this.running) {
-            throw new MCPServerError('Server already running');
-        }
-        const startTime = performance.now();
-        this.startTime = new Date();
-        this.logger.info('Starting MCP server', {
-            name: this.config.name,
-            version: this.config.version,
-            transport: this.config.transport,
-        });
-        try {
-            // Create and start transport
-            this.transport = createTransport(this.config.transport, this.logger, {
-                type: this.config.transport,
-                host: this.config.host,
-                port: this.config.port,
-                corsEnabled: this.config.corsEnabled,
-                corsOrigins: this.config.corsOrigins,
-                auth: this.config.auth,
-                maxRequestSize: String(this.config.maxRequestSize),
-                requestTimeout: this.config.requestTimeout,
-            });
-            // Setup request handler
-            this.transport.onRequest(async (request) => {
-                return await this.handleRequest(request);
-            });
-            // Setup notification handler
-            this.transport.onNotification(async (notification) => {
-                await this.handleNotification(notification);
-            });
-            // Start transport
-            await this.transport.start();
-            // Register built-in tools
-            await this.registerBuiltInTools();
-            this.running = true;
-            this.startupDuration = performance.now() - startTime;
-            this.logger.info('MCP server started', {
-                startupTime: `${this.startupDuration.toFixed(2)}ms`,
-                tools: this.toolRegistry.getToolCount(),
-            });
-            this.emit('server:started', {
-                startupTime: this.startupDuration,
-                tools: this.toolRegistry.getToolCount(),
-            });
-        }
-        catch (error) {
-            this.logger.error('Failed to start MCP server', { error });
-            throw new MCPServerError('Failed to start server', ErrorCodes.INTERNAL_ERROR, { error });
-        }
-    }
-    /**
-     * Stop the MCP server
-     */
-    async stop() {
-        if (!this.running) {
-            return;
-        }
-        this.logger.info('Stopping MCP server');
-        try {
-            // Stop transport
-            if (this.transport) {
-                await this.transport.stop();
-                this.transport = undefined;
-            }
-            // Clear sessions
-            this.sessionManager.clearAll();
-            // Clear connection pool
-            if (this.connectionPool) {
-                await this.connectionPool.clear();
-            }
-            this.running = false;
-            this.currentSession = undefined;
-            this.logger.info('MCP server stopped');
-            this.emit('server:stopped');
-        }
-        catch (error) {
-            this.logger.error('Error stopping MCP server', { error });
-            throw error;
-        }
-    }
-    /**
-     * Register a tool
-     */
-    registerTool(tool) {
-        return this.toolRegistry.register(tool);
-    }
-    /**
-     * Register multiple tools
-     */
-    registerTools(tools) {
-        return this.toolRegistry.registerBatch(tools);
-    }
-    /**
-     * Unregister a tool
-     */
-    unregisterTool(name) {
-        return this.toolRegistry.unregister(name);
-    }
-    /**
-     * Get health status
-     */
-    async getHealthStatus() {
-        try {
-            const transportHealth = this.transport
-                ? await this.transport.getHealthStatus()
-                : { healthy: false, error: 'Transport not initialized' };
-            const sessionMetrics = this.sessionManager.getSessionMetrics();
-            const poolStats = this.connectionPool?.getStats();
-            const metrics = {
-                registeredTools: this.toolRegistry.getToolCount(),
-                totalRequests: this.requestStats.total,
-                successfulRequests: this.requestStats.successful,
-                failedRequests: this.requestStats.failed,
-                totalSessions: sessionMetrics.total,
-                activeSessions: sessionMetrics.active,
-                ...(transportHealth.metrics || {}),
-            };
-            if (poolStats) {
-                metrics.poolConnections = poolStats.totalConnections;
-                metrics.poolIdleConnections = poolStats.idleConnections;
-                metrics.poolBusyConnections = poolStats.busyConnections;
-            }
-            return {
-                healthy: this.running && transportHealth.healthy,
-                error: transportHealth.error,
-                metrics,
-            };
-        }
-        catch (error) {
-            return {
-                healthy: false,
-                error: error instanceof Error ? error.message : 'Unknown error',
-            };
-        }
-    }
-    /**
-     * Get server metrics
-     */
-    getMetrics() {
-        const sessionMetrics = this.sessionManager.getSessionMetrics();
-        const registryStats = this.toolRegistry.getStats();
-        return {
-            totalRequests: this.requestStats.total,
-            successfulRequests: this.requestStats.successful,
-            failedRequests: this.requestStats.failed,
-            averageResponseTime: this.requestStats.total > 0
-                ? this.requestStats.totalResponseTime / this.requestStats.total
-                : 0,
-            activeSessions: sessionMetrics.active,
-            toolInvocations: Object.fromEntries(registryStats.topTools.map((t) => [t.name, t.calls])),
-            errors: {},
-            lastReset: this.startTime || new Date(),
-            startupTime: this.startupDuration,
-            uptime: this.startTime ? Date.now() - this.startTime.getTime() : 0,
-        };
-    }
-    /**
-     * Get all sessions
-     */
-    getSessions() {
-        return this.sessionManager.getActiveSessions();
-    }
-    /**
-     * Get session by ID
-     */
-    getSession(sessionId) {
-        return this.sessionManager.getSession(sessionId);
-    }
-    /**
-     * Terminate a session
-     */
-    terminateSession(sessionId) {
-        const result = this.sessionManager.closeSession(sessionId, 'Terminated by server');
-        if (this.currentSession?.id === sessionId) {
-            this.currentSession = undefined;
-        }
-        return result;
-    }
-    /**
-     * Handle incoming request
-     */
-    async handleRequest(request) {
-        const startTime = performance.now();
-        this.requestStats.total++;
-        this.logger.debug('Handling request', {
-            id: request.id,
-            method: request.method,
-        });
-        try {
-            // Handle initialization
-            if (request.method === 'initialize') {
-                return await this.handleInitialize(request);
-            }
-            // Get or create session
-            const session = this.getOrCreateSession();
-            // Check initialization
-            if (!session.isInitialized && request.method !== 'initialized') {
-                return this.createErrorResponse(request.id, ErrorCodes.SERVER_NOT_INITIALIZED, 'Server not initialized');
-            }
-            // Update session activity
-            this.sessionManager.updateActivity(session.id);
-            // Route request
-            const response = await this.routeRequest(request);
-            const duration = performance.now() - startTime;
-            this.requestStats.successful++;
-            this.requestStats.totalResponseTime += duration;
-            this.logger.debug('Request completed', {
-                id: request.id,
-                method: request.method,
-                duration: `${duration.toFixed(2)}ms`,
-            });
-            return response;
-        }
-        catch (error) {
-            const duration = performance.now() - startTime;
-            this.requestStats.failed++;
-            this.requestStats.totalResponseTime += duration;
-            this.logger.error('Request failed', {
-                id: request.id,
-                method: request.method,
-                error,
-            });
-            return this.createErrorResponse(request.id, ErrorCodes.INTERNAL_ERROR, error instanceof Error ? error.message : 'Internal error');
-        }
-    }
-    /**
-     * Handle notification
-     */
-    async handleNotification(notification) {
-        this.logger.debug('Handling notification', { method: notification.method });
-        switch (notification.method) {
-            case 'initialized':
-                this.logger.info('Client initialized notification received');
-                break;
-            case 'notifications/cancelled':
-                this.logger.debug('Request cancelled', notification.params);
-                break;
-            default:
-                this.logger.debug('Unknown notification', { method: notification.method });
-        }
-    }
-    /**
-     * Handle initialize request
-     */
-    async handleInitialize(request) {
-        const params = request.params;
-        if (!params) {
-            return this.createErrorResponse(request.id, ErrorCodes.INVALID_PARAMS, 'Invalid params');
-        }
-        // Create and initialize session
-        const session = this.sessionManager.createSession(this.config.transport);
-        this.sessionManager.initializeSession(session.id, params);
-        this.currentSession = session;
-        const result = {
-            protocolVersion: this.protocolVersion,
-            capabilities: this.capabilities,
-            serverInfo: this.serverInfo,
-            instructions: 'Claude-Flow MCP Server V3 ready for tool execution',
-        };
-        this.logger.info('Session initialized', {
-            sessionId: session.id,
-            clientInfo: params.clientInfo,
-        });
-        return {
-            jsonrpc: '2.0',
-            id: request.id,
-            result,
-        };
-    }
-    /**
-     * Route request to appropriate handler
-     */
-    async routeRequest(request) {
-        switch (request.method) {
-            case 'tools/list':
-                return this.handleToolsList(request);
-            case 'tools/call':
-                return this.handleToolsCall(request);
-            case 'resources/list':
-                return this.handleResourcesList(request);
-            case 'prompts/list':
-                return this.handlePromptsList(request);
-            case 'ping':
-                return {
-                    jsonrpc: '2.0',
-                    id: request.id,
-                    result: { pong: true, timestamp: Date.now() },
-                };
-            default:
-                // Try to execute as tool call (backwards compatibility)
-                if (this.toolRegistry.hasTool(request.method)) {
-                    return this.handleToolExecution(request);
-                }
-                return this.createErrorResponse(request.id, ErrorCodes.METHOD_NOT_FOUND, `Method not found: ${request.method}`);
-        }
-    }
-    /**
-     * Handle tools/list request
-     */
-    handleToolsList(request) {
-        const tools = this.toolRegistry.listTools().map((t) => ({
-            name: t.name,
-            description: t.description,
-            inputSchema: this.toolRegistry.getTool(t.name)?.inputSchema,
-        }));
-        return {
-            jsonrpc: '2.0',
-            id: request.id,
-            result: { tools },
-        };
-    }
-    /**
-     * Handle tools/call request
-     */
-    async handleToolsCall(request) {
-        const params = request.params;
-        if (!params?.name) {
-            return this.createErrorResponse(request.id, ErrorCodes.INVALID_PARAMS, 'Tool name is required');
-        }
-        const context = {
-            sessionId: this.currentSession?.id || 'unknown',
-            requestId: request.id,
-            orchestrator: this.orchestrator,
-            swarmCoordinator: this.swarmCoordinator,
-        };
-        const result = await this.toolRegistry.execute(params.name, params.arguments || {}, context);
-        return {
-            jsonrpc: '2.0',
-            id: request.id,
-            result,
-        };
-    }
-    /**
-     * Handle direct tool execution (backwards compatibility)
-     */
-    async handleToolExecution(request) {
-        const context = {
-            sessionId: this.currentSession?.id || 'unknown',
-            requestId: request.id,
-            orchestrator: this.orchestrator,
-            swarmCoordinator: this.swarmCoordinator,
-        };
-        const result = await this.toolRegistry.execute(request.method, request.params || {}, context);
-        return {
-            jsonrpc: '2.0',
-            id: request.id,
-            result,
-        };
-    }
-    /**
-     * Handle resources/list request
-     */
-    handleResourcesList(request) {
-        return {
-            jsonrpc: '2.0',
-            id: request.id,
-            result: { resources: [] },
-        };
-    }
-    /**
-     * Handle prompts/list request
-     */
-    handlePromptsList(request) {
-        return {
-            jsonrpc: '2.0',
-            id: request.id,
-            result: { prompts: [] },
-        };
-    }
-    /**
-     * Get or create current session
-     */
-    getOrCreateSession() {
-        if (this.currentSession) {
-            return this.currentSession;
-        }
-        const session = this.sessionManager.createSession(this.config.transport);
-        this.currentSession = session;
-        return session;
-    }
-    /**
-     * Create error response
-     */
-    createErrorResponse(id, code, message) {
-        return {
-            jsonrpc: '2.0',
-            id,
-            error: { code, message },
-        };
-    }
-    /**
-     * Register built-in tools
-     */
-    async registerBuiltInTools() {
-        // System info tool
-        this.registerTool({
-            name: 'system/info',
-            description: 'Get system information',
-            inputSchema: { type: 'object', properties: {} },
-            handler: async () => ({
-                name: this.serverInfo.name,
-                version: this.serverInfo.version,
-                platform: platform(),
-                arch: arch(),
-                runtime: 'Node.js',
-                uptime: this.startTime ? Date.now() - this.startTime.getTime() : 0,
-            }),
-            category: 'system',
-        });
-        // Health check tool
-        this.registerTool({
-            name: 'system/health',
-            description: 'Get system health status',
-            inputSchema: { type: 'object', properties: {} },
-            handler: async () => await this.getHealthStatus(),
-            category: 'system',
-            cacheable: true,
-            cacheTTL: 2000,
-        });
-        // Metrics tool
-        this.registerTool({
-            name: 'system/metrics',
-            description: 'Get server metrics',
-            inputSchema: { type: 'object', properties: {} },
-            handler: async () => this.getMetrics(),
-            category: 'system',
-            cacheable: true,
-            cacheTTL: 1000,
-        });
-        // Tools list tool
-        this.registerTool({
-            name: 'tools/list-detailed',
-            description: 'List all registered tools with details',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    category: { type: 'string', description: 'Filter by category' },
-                },
-            },
-            handler: async (input) => {
-                const params = input;
-                if (params.category) {
-                    return this.toolRegistry.getByCategory(params.category);
-                }
-                return this.toolRegistry.listTools();
-            },
-            category: 'system',
-        });
-        this.logger.info('Built-in tools registered', {
-            count: 4,
-        });
-    }
-    /**
-     * Setup event handlers
-     */
-    setupEventHandlers() {
-        // Tool events
-        this.toolRegistry.on('tool:registered', (name) => {
-            this.emit('tool:registered', name);
-        });
-        this.toolRegistry.on('tool:called', (data) => {
-            this.emit('tool:called', data);
-        });
-        this.toolRegistry.on('tool:completed', (data) => {
-            this.emit('tool:completed', data);
-        });
-        this.toolRegistry.on('tool:error', (data) => {
-            this.emit('tool:error', data);
-        });
-        // Session events
-        this.sessionManager.on('session:created', (session) => {
-            this.emit('session:created', session);
-        });
-        this.sessionManager.on('session:closed', (data) => {
-            this.emit('session:closed', data);
-        });
-        this.sessionManager.on('session:expired', (session) => {
-            this.emit('session:expired', session);
-        });
-    }
-}
-/**
- * Create an MCP server instance
- */
-export function createMCPServer(config, logger, orchestrator, swarmCoordinator) {
-    return new MCPServer(config, logger, orchestrator, swarmCoordinator);
-}
-//# sourceMappingURL=server.js.map