@claude-flow/mcp 3.0.0-alpha.1

package/src/transport/index.ts

@@ -0,0 +1,233 @@
+/**
+ * @claude-flow/mcp - Transport Factory
+ *
+ * Central factory for creating transport instances
+ */
+
+import type {
+  ITransport,
+  TransportType,
+  TransportHealthStatus,
+  ILogger,
+} from '../types.js';
+import { StdioTransport, StdioTransportConfig, createStdioTransport } from './stdio.js';
+import { HttpTransport, HttpTransportConfig, createHttpTransport } from './http.js';
+import { WebSocketTransport, WebSocketTransportConfig, createWebSocketTransport } from './websocket.js';
+
+export { StdioTransport } from './stdio.js';
+export { HttpTransport } from './http.js';
+export { WebSocketTransport } from './websocket.js';
+
+export type { StdioTransportConfig } from './stdio.js';
+export type { HttpTransportConfig } from './http.js';
+export type { WebSocketTransportConfig } from './websocket.js';
+
+export type TransportConfig =
+  | { type: 'stdio' } & StdioTransportConfig
+  | { type: 'http' } & HttpTransportConfig
+  | { type: 'websocket' } & WebSocketTransportConfig
+  | { type: 'in-process' };
+
+export function createTransport(
+  type: TransportType,
+  logger: ILogger,
+  config?: Partial<TransportConfig>
+): ITransport {
+  switch (type) {
+    case 'stdio':
+      return createStdioTransport(logger, config as StdioTransportConfig);
+
+    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 as string,
+        port: config.port as number,
+        ...config,
+      } as HttpTransportConfig);
+
+    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 as string,
+        port: config.port as number,
+        ...config,
+      } as WebSocketTransportConfig);
+
+    case 'in-process':
+      return createInProcessTransport(logger);
+
+    default:
+      throw new Error(`Unknown transport type: ${type}`);
+  }
+}
+
+class InProcessTransport implements ITransport {
+  public readonly type: TransportType = 'in-process';
+
+  constructor(private readonly logger: ILogger) {}
+
+  async start(): Promise<void> {
+    this.logger.debug('In-process transport started');
+  }
+
+  async stop(): Promise<void> {
+    this.logger.debug('In-process transport stopped');
+  }
+
+  onRequest(): void {
+    // No-op - requests are handled directly
+  }
+
+  onNotification(): void {
+    // No-op - notifications are handled directly
+  }
+
+  async getHealthStatus(): Promise<TransportHealthStatus> {
+    return {
+      healthy: true,
+      metrics: {
+        latency: 0,
+        connections: 1,
+      },
+    };
+  }
+}
+
+export function createInProcessTransport(logger: ILogger): ITransport {
+  return new InProcessTransport(logger);
+}
+
+export class TransportManager {
+  private transports: Map<string, ITransport> = new Map();
+  private running = false;
+
+  constructor(private readonly logger: ILogger) {}
+
+  addTransport(name: string, transport: ITransport): void {
+    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 });
+  }
+
+  async removeTransport(name: string): Promise<boolean> {
+    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;
+  }
+
+  getTransport(name: string): ITransport | undefined {
+    return this.transports.get(name);
+  }
+
+  getTransportNames(): string[] {
+    return Array.from(this.transports.keys());
+  }
+
+  async startAll(): Promise<void> {
+    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');
+  }
+
+  async stopAll(): Promise<void> {
+    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');
+  }
+
+  async getHealthStatus(): Promise<Record<string, { healthy: boolean; error?: string }>> {
+    const results: Record<string, { healthy: boolean; error?: string }> = {};
+
+    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;
+  }
+
+  isRunning(): boolean {
+    return this.running;
+  }
+}
+
+export function createTransportManager(logger: ILogger): TransportManager {
+  return new TransportManager(logger);
+}
+
+export const DEFAULT_TRANSPORT_CONFIGS = {
+  stdio: {} as StdioTransportConfig,
+
+  http: {
+    host: 'localhost',
+    port: 3000,
+    corsEnabled: true,
+    corsOrigins: ['*'],
+    maxRequestSize: '10mb',
+    requestTimeout: 30000,
+  } as HttpTransportConfig,
+
+  websocket: {
+    host: 'localhost',
+    port: 3001,
+    path: '/ws',
+    maxConnections: 100,
+    heartbeatInterval: 30000,
+    heartbeatTimeout: 10000,
+    maxMessageSize: 10 * 1024 * 1024,
+  } as WebSocketTransportConfig,
+} as const;

package/src/transport/stdio.ts

@@ -0,0 +1,252 @@
+/**
+ * @claude-flow/mcp - Stdio Transport
+ *
+ * Standard I/O transport for MCP communication
+ */
+
+import { EventEmitter } from 'events';
+import * as readline from 'readline';
+import type {
+  ITransport,
+  TransportType,
+  MCPRequest,
+  MCPResponse,
+  MCPNotification,
+  RequestHandler,
+  NotificationHandler,
+  TransportHealthStatus,
+  ILogger,
+} from '../types.js';
+
+export interface StdioTransportConfig {
+  inputStream?: NodeJS.ReadableStream;
+  outputStream?: NodeJS.WritableStream;
+  maxMessageSize?: number;
+}
+
+export class StdioTransport extends EventEmitter implements ITransport {
+  public readonly type: TransportType = 'stdio';
+
+  private requestHandler?: RequestHandler;
+  private notificationHandler?: NotificationHandler;
+  private rl?: readline.Interface;
+  private running = false;
+
+  private messagesReceived = 0;
+  private messagesSent = 0;
+  private errors = 0;
+
+  private readonly inputStream: NodeJS.ReadableStream;
+  private readonly outputStream: NodeJS.WritableStream;
+  private readonly maxMessageSize: number;
+
+  constructor(
+    private readonly logger: ILogger,
+    config: StdioTransportConfig = {}
+  ) {
+    super();
+    this.inputStream = config.inputStream || process.stdin;
+    this.outputStream = config.outputStream || process.stdout;
+    this.maxMessageSize = config.maxMessageSize || 10 * 1024 * 1024;
+  }
+
+  async start(): Promise<void> {
+    if (this.running) {
+      throw new Error('Stdio transport already running');
+    }
+
+    this.logger.info('Starting stdio transport');
+
+    this.rl = readline.createInterface({
+      input: this.inputStream,
+      crlfDelay: Infinity,
+    });
+
+    this.rl.on('line', (line) => {
+      this.handleLine(line);
+    });
+
+    this.rl.on('close', () => {
+      this.handleClose();
+    });
+
+    this.inputStream.on('error', (error) => {
+      this.handleError(error);
+    });
+
+    this.running = true;
+    this.logger.info('Stdio transport started');
+  }
+
+  async stop(): Promise<void> {
+    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');
+  }
+
+  onRequest(handler: RequestHandler): void {
+    this.requestHandler = handler;
+  }
+
+  onNotification(handler: NotificationHandler): void {
+    this.notificationHandler = handler;
+  }
+
+  async getHealthStatus(): Promise<TransportHealthStatus> {
+    return {
+      healthy: this.running,
+      metrics: {
+        messagesReceived: this.messagesReceived,
+        messagesSent: this.messagesSent,
+        errors: this.errors,
+      },
+    };
+  }
+
+  private async handleLine(line: string): Promise<void> {
+    if (!line.trim()) {
+      return;
+    }
+
+    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++;
+
+      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;
+      }
+
+      if (message.id !== undefined) {
+        await this.handleRequest(message as MCPRequest);
+      } else {
+        await this.handleNotification(message as MCPNotification);
+      }
+    } catch (error) {
+      this.errors++;
+      this.logger.error('Failed to parse message', { error, line: line.substring(0, 100) });
+      await this.sendError(null, -32700, 'Parse error');
+    }
+  }
+
+  private async handleRequest(request: MCPRequest): Promise<void> {
+    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'
+      );
+    }
+  }
+
+  private async handleNotification(notification: MCPNotification): Promise<void> {
+    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 });
+    }
+  }
+
+  private async sendResponse(response: MCPResponse): Promise<void> {
+    const json = JSON.stringify(response);
+    await this.write(json);
+    this.messagesSent++;
+  }
+
+  private async sendError(id: string | number | null, code: number, message: string): Promise<void> {
+    const response: MCPResponse = {
+      jsonrpc: '2.0',
+      id,
+      error: { code, message },
+    };
+    await this.sendResponse(response);
+    this.errors++;
+  }
+
+  async sendNotification(notification: MCPNotification): Promise<void> {
+    const json = JSON.stringify(notification);
+    await this.write(json);
+    this.messagesSent++;
+  }
+
+  private write(data: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.outputStream.write(data + '\n', (error) => {
+        if (error) {
+          this.errors++;
+          reject(error);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  private handleClose(): void {
+    this.logger.info('Stdio stream closed');
+    this.running = false;
+    this.emit('close');
+  }
+
+  private handleError(error: Error): void {
+    this.logger.error('Stdio stream error', error);
+    this.errors++;
+    this.emit('error', error);
+  }
+}
+
+export function createStdioTransport(
+  logger: ILogger,
+  config: StdioTransportConfig = {}
+): StdioTransport {
+  return new StdioTransport(logger, config);
+}