moflo 4.8.19 → 4.8.20

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

@@ -0,0 +1,238 @@
+/**
+ * V3 MCP Transport Factory
+ *
+ * Central factory for creating transport instances:
+ * - Unified transport creation API
+ * - Transport type validation
+ * - Configuration defaults
+ * - Multi-transport support
+ *
+ * Supported transports:
+ * - stdio: Standard I/O (default for CLI)
+ * - http: HTTP/REST with WebSocket upgrade
+ * - websocket: Standalone WebSocket
+ * - in-process: Direct function calls (fastest)
+ */
+import { createStdioTransport } from './stdio.js';
+import { createHttpTransport } from './http.js';
+import { createWebSocketTransport } from './websocket.js';
+// Re-export transport classes (values)
+export { StdioTransport } from './stdio.js';
+export { HttpTransport } from './http.js';
+export { WebSocketTransport } from './websocket.js';
+/**
+ * Create a transport instance based on type
+ */
+export function createTransport(type, logger, config) {
+    switch (type) {
+        case 'stdio':
+            return createStdioTransport(logger, config);
+        case 'http':
+            if (!config || !('host' in config) || !('port' in config)) {
+                throw new Error('HTTP transport requires host and port configuration');
+            }
+            return createHttpTransport(logger, {
+                host: config.host,
+                port: config.port,
+                ...config,
+            });
+        case 'websocket':
+            if (!config || !('host' in config) || !('port' in config)) {
+                throw new Error('WebSocket transport requires host and port configuration');
+            }
+            return createWebSocketTransport(logger, {
+                host: config.host,
+                port: config.port,
+                ...config,
+            });
+        case 'in-process':
+            // In-process transport is handled directly by the server
+            // Return a no-op transport wrapper
+            return createInProcessTransport(logger);
+        default:
+            throw new Error(`Unknown transport type: ${type}`);
+    }
+}
+/**
+ * In-process transport (no-op wrapper)
+ *
+ * Used when tools are executed directly without network transport
+ */
+class InProcessTransport {
+    logger;
+    type = 'in-process';
+    constructor(logger) {
+        this.logger = logger;
+    }
+    async start() {
+        this.logger.debug('In-process transport started');
+    }
+    async stop() {
+        this.logger.debug('In-process transport stopped');
+    }
+    onRequest() {
+        // No-op - requests are handled directly
+    }
+    onNotification() {
+        // No-op - notifications are handled directly
+    }
+    async getHealthStatus() {
+        return {
+            healthy: true,
+            metrics: {
+                latency: 0,
+                connections: 1,
+            },
+        };
+    }
+}
+/**
+ * Create in-process transport
+ */
+export function createInProcessTransport(logger) {
+    return new InProcessTransport(logger);
+}
+/**
+ * Transport manager for multi-transport scenarios
+ */
+export class TransportManager {
+    logger;
+    transports = new Map();
+    running = false;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    /**
+     * Add a transport
+     */
+    addTransport(name, transport) {
+        if (this.transports.has(name)) {
+            throw new Error(`Transport "${name}" already exists`);
+        }
+        this.transports.set(name, transport);
+        this.logger.debug('Transport added', { name, type: transport.type });
+    }
+    /**
+     * Remove a transport
+     */
+    async removeTransport(name) {
+        const transport = this.transports.get(name);
+        if (!transport) {
+            return false;
+        }
+        await transport.stop();
+        this.transports.delete(name);
+        this.logger.debug('Transport removed', { name });
+        return true;
+    }
+    /**
+     * Get a transport by name
+     */
+    getTransport(name) {
+        return this.transports.get(name);
+    }
+    /**
+     * Get all transport names
+     */
+    getTransportNames() {
+        return Array.from(this.transports.keys());
+    }
+    /**
+     * Start all transports
+     */
+    async startAll() {
+        if (this.running) {
+            throw new Error('TransportManager already running');
+        }
+        this.logger.info('Starting all transports', { count: this.transports.size });
+        const startPromises = Array.from(this.transports.entries()).map(async ([name, transport]) => {
+            try {
+                await transport.start();
+                this.logger.info('Transport started', { name, type: transport.type });
+            }
+            catch (error) {
+                this.logger.error('Failed to start transport', { name, error });
+                throw error;
+            }
+        });
+        await Promise.all(startPromises);
+        this.running = true;
+        this.logger.info('All transports started');
+    }
+    /**
+     * Stop all transports
+     */
+    async stopAll() {
+        if (!this.running) {
+            return;
+        }
+        this.logger.info('Stopping all transports');
+        const stopPromises = Array.from(this.transports.entries()).map(async ([name, transport]) => {
+            try {
+                await transport.stop();
+                this.logger.info('Transport stopped', { name });
+            }
+            catch (error) {
+                this.logger.error('Error stopping transport', { name, error });
+            }
+        });
+        await Promise.all(stopPromises);
+        this.running = false;
+        this.logger.info('All transports stopped');
+    }
+    /**
+     * Get health status of all transports
+     */
+    async getHealthStatus() {
+        const results = {};
+        for (const [name, transport] of this.transports) {
+            try {
+                const status = await transport.getHealthStatus();
+                results[name] = { healthy: status.healthy, error: status.error };
+            }
+            catch (error) {
+                results[name] = {
+                    healthy: false,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                };
+            }
+        }
+        return results;
+    }
+    /**
+     * Check if any transport is running
+     */
+    isRunning() {
+        return this.running;
+    }
+}
+/**
+ * Create a transport manager
+ */
+export function createTransportManager(logger) {
+    return new TransportManager(logger);
+}
+/**
+ * Default transport configurations
+ */
+export const DEFAULT_TRANSPORT_CONFIGS = {
+    stdio: {},
+    http: {
+        host: 'localhost',
+        port: 3000,
+        corsEnabled: true,
+        corsOrigins: ['*'],
+        maxRequestSize: '10mb',
+        requestTimeout: 30000,
+    },
+    websocket: {
+        host: 'localhost',
+        port: 3001,
+        path: '/ws',
+        maxConnections: 100,
+        heartbeatInterval: 30000,
+        heartbeatTimeout: 10000,
+        maxMessageSize: 10 * 1024 * 1024,
+    },
+};
+//# sourceMappingURL=index.js.map

package/src/@claude-flow/shared/dist/mcp/transport/stdio.d.ts

@@ -0,0 +1,104 @@
+/**
+ * V3 MCP Stdio Transport
+ *
+ * Standard I/O transport for MCP communication:
+ * - Optimized JSON parsing with streaming
+ * - Buffer management for large messages
+ * - Graceful shutdown handling
+ *
+ * Performance Targets:
+ * - Message parsing: <5ms
+ * - Response sending: <2ms
+ */
+import { EventEmitter } from 'events';
+import { ITransport, TransportType, MCPNotification, RequestHandler, NotificationHandler, TransportHealthStatus, ILogger } from '../types.js';
+/**
+ * Stdio Transport Configuration
+ */
+export interface StdioTransportConfig {
+    inputStream?: NodeJS.ReadableStream;
+    outputStream?: NodeJS.WritableStream;
+    maxMessageSize?: number;
+}
+/**
+ * Stdio Transport Implementation
+ *
+ * Uses readline for efficient line-by-line processing of JSON-RPC messages
+ */
+export declare class StdioTransport extends EventEmitter implements ITransport {
+    private readonly logger;
+    readonly type: TransportType;
+    private requestHandler?;
+    private notificationHandler?;
+    private rl?;
+    private running;
+    private messageBuffer;
+    private messagesReceived;
+    private messagesSent;
+    private errors;
+    private readonly inputStream;
+    private readonly outputStream;
+    private readonly maxMessageSize;
+    constructor(logger: ILogger, config?: StdioTransportConfig);
+    /**
+     * Start the transport
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the transport
+     */
+    stop(): Promise<void>;
+    /**
+     * Register request handler
+     */
+    onRequest(handler: RequestHandler): void;
+    /**
+     * Register notification handler
+     */
+    onNotification(handler: NotificationHandler): void;
+    /**
+     * Get health status
+     */
+    getHealthStatus(): Promise<TransportHealthStatus>;
+    /**
+     * Handle incoming line
+     */
+    private handleLine;
+    /**
+     * Handle MCP request
+     */
+    private handleRequest;
+    /**
+     * Handle MCP notification
+     */
+    private handleNotification;
+    /**
+     * Send response to stdout
+     */
+    private sendResponse;
+    /**
+     * Send error response
+     */
+    private sendError;
+    /**
+     * Send notification to stdout
+     */
+    sendNotification(notification: MCPNotification): Promise<void>;
+    /**
+     * Write to output stream
+     */
+    private write;
+    /**
+     * Handle stream close
+     */
+    private handleClose;
+    /**
+     * Handle stream error
+     */
+    private handleError;
+}
+/**
+ * Create stdio transport
+ */
+export declare function createStdioTransport(logger: ILogger, config?: StdioTransportConfig): StdioTransport;
+//# sourceMappingURL=stdio.d.ts.map

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

@@ -0,0 +1,263 @@
+/**
+ * V3 MCP Stdio Transport
+ *
+ * Standard I/O transport for MCP communication:
+ * - Optimized JSON parsing with streaming
+ * - Buffer management for large messages
+ * - Graceful shutdown handling
+ *
+ * Performance Targets:
+ * - Message parsing: <5ms
+ * - Response sending: <2ms
+ */
+import { EventEmitter } from 'events';
+import * as readline from 'readline';
+/**
+ * Stdio Transport Implementation
+ *
+ * Uses readline for efficient line-by-line processing of JSON-RPC messages
+ */
+export class StdioTransport extends EventEmitter {
+    logger;
+    type = 'stdio';
+    requestHandler;
+    notificationHandler;
+    rl;
+    running = false;
+    messageBuffer = '';
+    // Statistics
+    messagesReceived = 0;
+    messagesSent = 0;
+    errors = 0;
+    inputStream;
+    outputStream;
+    maxMessageSize;
+    constructor(logger, config = {}) {
+        super();
+        this.logger = logger;
+        this.inputStream = config.inputStream || process.stdin;
+        this.outputStream = config.outputStream || process.stdout;
+        this.maxMessageSize = config.maxMessageSize || 10 * 1024 * 1024; // 10MB default
+    }
+    /**
+     * Start the transport
+     */
+    async start() {
+        if (this.running) {
+            throw new Error('Stdio transport already running');
+        }
+        this.logger.info('Starting stdio transport');
+        // Create readline interface for efficient line processing
+        this.rl = readline.createInterface({
+            input: this.inputStream,
+            crlfDelay: Infinity,
+        });
+        // Handle incoming lines
+        this.rl.on('line', (line) => {
+            this.handleLine(line);
+        });
+        // Handle close
+        this.rl.on('close', () => {
+            this.handleClose();
+        });
+        // Handle errors on input stream
+        this.inputStream.on('error', (error) => {
+            this.handleError(error);
+        });
+        this.running = true;
+        this.logger.info('Stdio transport started');
+    }
+    /**
+     * Stop the transport
+     */
+    async stop() {
+        if (!this.running) {
+            return;
+        }
+        this.logger.info('Stopping stdio transport');
+        this.running = false;
+        if (this.rl) {
+            this.rl.close();
+            this.rl = undefined;
+        }
+        this.logger.info('Stdio transport stopped');
+    }
+    /**
+     * Register request handler
+     */
+    onRequest(handler) {
+        this.requestHandler = handler;
+    }
+    /**
+     * Register notification handler
+     */
+    onNotification(handler) {
+        this.notificationHandler = handler;
+    }
+    /**
+     * Get health status
+     */
+    async getHealthStatus() {
+        return {
+            healthy: this.running,
+            metrics: {
+                messagesReceived: this.messagesReceived,
+                messagesSent: this.messagesSent,
+                errors: this.errors,
+            },
+        };
+    }
+    /**
+     * Handle incoming line
+     */
+    async handleLine(line) {
+        if (!line.trim()) {
+            return;
+        }
+        // Check message size
+        if (line.length > this.maxMessageSize) {
+            this.logger.error('Message exceeds maximum size', {
+                size: line.length,
+                max: this.maxMessageSize,
+            });
+            this.errors++;
+            return;
+        }
+        try {
+            const message = JSON.parse(line);
+            this.messagesReceived++;
+            // Validate JSON-RPC format
+            if (message.jsonrpc !== '2.0') {
+                this.logger.warn('Invalid JSON-RPC version', { received: message.jsonrpc });
+                await this.sendError(message.id, -32600, 'Invalid JSON-RPC version');
+                return;
+            }
+            if (!message.method) {
+                this.logger.warn('Missing method in request');
+                await this.sendError(message.id, -32600, 'Missing method');
+                return;
+            }
+            // Determine if this is a request or notification
+            if (message.id !== undefined) {
+                // Request - needs response
+                await this.handleRequest(message);
+            }
+            else {
+                // Notification - no response needed
+                await this.handleNotification(message);
+            }
+        }
+        catch (error) {
+            this.errors++;
+            this.logger.error('Failed to parse message', { error, line: line.substring(0, 100) });
+            await this.sendError(null, -32700, 'Parse error');
+        }
+    }
+    /**
+     * Handle MCP request
+     */
+    async handleRequest(request) {
+        if (!this.requestHandler) {
+            this.logger.warn('No request handler registered');
+            await this.sendError(request.id, -32603, 'No request handler');
+            return;
+        }
+        try {
+            const startTime = performance.now();
+            const response = await this.requestHandler(request);
+            const duration = performance.now() - startTime;
+            this.logger.debug('Request processed', {
+                method: request.method,
+                duration: `${duration.toFixed(2)}ms`,
+            });
+            await this.sendResponse(response);
+        }
+        catch (error) {
+            this.logger.error('Request handler error', { method: request.method, error });
+            await this.sendError(request.id, -32603, error instanceof Error ? error.message : 'Internal error');
+        }
+    }
+    /**
+     * Handle MCP notification
+     */
+    async handleNotification(notification) {
+        if (!this.notificationHandler) {
+            this.logger.debug('Notification received but no handler', { method: notification.method });
+            return;
+        }
+        try {
+            await this.notificationHandler(notification);
+        }
+        catch (error) {
+            this.logger.error('Notification handler error', { method: notification.method, error });
+            // Notifications don't send error responses
+        }
+    }
+    /**
+     * Send response to stdout
+     */
+    async sendResponse(response) {
+        const json = JSON.stringify(response);
+        await this.write(json);
+        this.messagesSent++;
+    }
+    /**
+     * Send error response
+     */
+    async sendError(id, code, message) {
+        const response = {
+            jsonrpc: '2.0',
+            id,
+            error: { code, message },
+        };
+        await this.sendResponse(response);
+        this.errors++;
+    }
+    /**
+     * Send notification to stdout
+     */
+    async sendNotification(notification) {
+        const json = JSON.stringify(notification);
+        await this.write(json);
+        this.messagesSent++;
+    }
+    /**
+     * Write to output stream
+     */
+    write(data) {
+        return new Promise((resolve, reject) => {
+            this.outputStream.write(data + '\n', (error) => {
+                if (error) {
+                    this.errors++;
+                    reject(error);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    /**
+     * Handle stream close
+     */
+    handleClose() {
+        this.logger.info('Stdio stream closed');
+        this.running = false;
+        this.emit('close');
+    }
+    /**
+     * Handle stream error
+     */
+    handleError(error) {
+        this.logger.error('Stdio stream error', error);
+        this.errors++;
+        this.emit('error', error);
+    }
+}
+/**
+ * Create stdio transport
+ */
+export function createStdioTransport(logger, config = {}) {
+    return new StdioTransport(logger, config);
+}
+//# sourceMappingURL=stdio.js.map