claude-flow 3.25.6 → 3.26.1

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

@@ -1,238 +0,0 @@
-/**
- * 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/v3/@claude-flow/shared/dist/mcp/transport/stdio.d.ts

@@ -1,104 +0,0 @@
-/**
- * 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/v3/@claude-flow/shared/dist/mcp/transport/stdio.js

@@ -1,263 +0,0 @@
-/**
- * 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