claude-flow 2.0.0-alpha.61 → 2.0.0-alpha.63

package/src/mcp/recovery/connection-health-monitor.ts

@@ -1,4 +1,3 @@
-import { getErrorMessage } from '../../utils/error-handler.js';
 /**
  * Connection Health Monitor for MCP
  * Monitors connection health and triggers recovery when needed
@@ -43,11 +42,11 @@ export class ConnectionHealthMonitor extends EventEmitter {
   constructor(
     private client: MCPClient,
     private logger: ILogger,
-    config?: Partial<HealthMonitorConfig>
+    config?: Partial<HealthMonitorConfig>,
   ) {
     super();
     this.config = { ...this.defaultConfig, ...config };
-    
+
     this.healthStatus = {
       healthy: false,
       lastHeartbeat: new Date(),
@@ -75,10 +74,10 @@ export class ConnectionHealthMonitor extends EventEmitter {
     this.isMonitoring = true;
     this.missedHeartbeats = 0;
     this.lastHeartbeat = new Date();
-    
+
     // Start heartbeat cycle
     this.scheduleHeartbeat();
-    
+
     // Update initial status
     this.updateHealthStatus('connected');
     this.emit('started');
@@ -122,17 +121,17 @@ export class ConnectionHealthMonitor extends EventEmitter {
   async checkHealth(): Promise<HealthStatus> {
     try {
       const startTime = Date.now();
-      
+
       // Send heartbeat ping
       await this.sendHeartbeat();
-      
+
       // Calculate latency
       this.currentLatency = Date.now() - startTime;
       this.lastHeartbeat = new Date();
       this.missedHeartbeats = 0;
-      
+
       this.updateHealthStatus('connected', true);
-      
+
       return this.getHealthStatus();
     } catch (error) {
       this.logger.error('Health check failed', error);
@@ -146,7 +145,7 @@ export class ConnectionHealthMonitor extends EventEmitter {
    */
   async forceCheck(): Promise<void> {
     this.logger.debug('Forcing health check');
-    
+
     // Cancel current timers
     if (this.heartbeatTimer) {
       clearTimeout(this.heartbeatTimer);
@@ -154,7 +153,7 @@ export class ConnectionHealthMonitor extends EventEmitter {
     if (this.timeoutTimer) {
       clearTimeout(this.timeoutTimer);
     }
-    
+
     // Perform immediate check
     await this.performHeartbeat();
   }
@@ -165,7 +164,7 @@ export class ConnectionHealthMonitor extends EventEmitter {
     }
 
     this.heartbeatTimer = setTimeout(() => {
-      this.performHeartbeat().catch(error => {
+      this.performHeartbeat().catch((error) => {
         this.logger.error('Heartbeat error', error);
       });
     }, this.config.heartbeatInterval);
@@ -177,28 +176,28 @@ export class ConnectionHealthMonitor extends EventEmitter {
     }
 
     this.logger.debug('Performing heartbeat');
-    
+
     try {
       // Set timeout for heartbeat response
       this.setHeartbeatTimeout();
-      
+
       const startTime = Date.now();
       await this.sendHeartbeat();
-      
+
       // Clear timeout on success
       this.clearHeartbeatTimeout();
-      
+
       // Update metrics
       this.currentLatency = Date.now() - startTime;
       this.lastHeartbeat = new Date();
       this.missedHeartbeats = 0;
-      
+
       this.logger.debug('Heartbeat successful', {
         latency: this.currentLatency,
       });
-      
+
       this.updateHealthStatus('connected', true);
-      
+
       // Schedule next heartbeat
       this.scheduleHeartbeat();
     } catch (error) {
@@ -234,18 +233,22 @@ export class ConnectionHealthMonitor extends EventEmitter {
 
   private handleHeartbeatFailure(error: Error): void {
     this.clearHeartbeatTimeout();
-    
+
     this.missedHeartbeats++;
     this.logger.warn('Heartbeat failed', {
       missedHeartbeats: this.missedHeartbeats,
       maxMissed: this.config.maxMissedHeartbeats,
-      error: (error instanceof Error ? error.message : String(error)),
+      error: error instanceof Error ? error.message : String(error),
     });
-    
+
     if (this.missedHeartbeats >= this.config.maxMissedHeartbeats) {
       this.logger.error('Max missed heartbeats exceeded, connection unhealthy');
-      this.updateHealthStatus('disconnected', false, (error instanceof Error ? error.message : String(error)));
-      
+      this.updateHealthStatus(
+        'disconnected',
+        false,
+        error instanceof Error ? error.message : String(error),
+      );
+
       if (this.config.enableAutoRecovery) {
         this.emit('connectionLost', { error });
       }
@@ -253,9 +256,9 @@ export class ConnectionHealthMonitor extends EventEmitter {
       // Schedule next heartbeat with backoff
       const backoffDelay = this.config.heartbeatInterval * (this.missedHeartbeats + 1);
       this.logger.debug('Scheduling heartbeat with backoff', { delay: backoffDelay });
-      
+
       this.heartbeatTimer = setTimeout(() => {
-        this.performHeartbeat().catch(err => {
+        this.performHeartbeat().catch((err) => {
           this.logger.error('Backoff heartbeat error', err);
         });
       }, backoffDelay);
@@ -265,28 +268,30 @@ export class ConnectionHealthMonitor extends EventEmitter {
   private updateHealthStatus(
     connectionState: 'connected' | 'disconnected' | 'reconnecting',
     healthy?: boolean,
-    error?: string
+    error?: string,
   ): void {
     const previousStatus = { ...this.healthStatus };
-    
+
     this.healthStatus = {
-      healthy: healthy ?? (connectionState === 'connected'),
+      healthy: healthy ?? connectionState === 'connected',
       lastHeartbeat: this.lastHeartbeat,
       missedHeartbeats: this.missedHeartbeats,
       latency: this.currentLatency,
       connectionState,
       error,
     };
-    
+
     // Emit event if health changed
-    if (previousStatus.healthy !== this.healthStatus.healthy ||
-        previousStatus.connectionState !== this.healthStatus.connectionState) {
+    if (
+      previousStatus.healthy !== this.healthStatus.healthy ||
+      previousStatus.connectionState !== this.healthStatus.connectionState
+    ) {
       this.logger.info('Health status changed', {
         from: previousStatus.connectionState,
         to: this.healthStatus.connectionState,
         healthy: this.healthStatus.healthy,
       });
-      
+
       this.emit('healthChange', this.healthStatus, previousStatus);
     }
   }
@@ -302,11 +307,11 @@ export class ConnectionHealthMonitor extends EventEmitter {
     this.missedHeartbeats = 0;
     this.currentLatency = 0;
     this.lastHeartbeat = new Date();
-    
+
     if (this.isMonitoring) {
       this.logger.debug('Resetting health monitor');
       this.clearHeartbeatTimeout();
       this.scheduleHeartbeat();
     }
   }
-}
+}

package/src/mcp/recovery/connection-state-manager.ts

@@ -1,4 +1,3 @@
-import { getErrorMessage } from '../../utils/error-handler.js';
 /**
  * Connection State Manager for MCP
  * Persists connection state across disconnections
@@ -54,7 +53,7 @@ export class ConnectionStateManager {
     averageReconnectionTime: 0,
     connectionHistory: [],
   };
-  
+
   private persistenceTimer?: NodeJS.Timeout;
   private statePath: string;
   private metricsPath: string;
@@ -68,14 +67,14 @@ export class ConnectionStateManager {
 
   constructor(
     private logger: ILogger,
-    config?: Partial<StateManagerConfig>
+    config?: Partial<StateManagerConfig>,
   ) {
     this.config = { ...this.defaultConfig, ...config };
-    
+
     this.statePath = join(this.config.stateDirectory, 'connection-state.json');
     this.metricsPath = join(this.config.stateDirectory, 'connection-metrics.json');
-    
-    this.initialize().catch(error => {
+
+    this.initialize().catch((error) => {
       this.logger.error('Failed to initialize state manager', error);
     });
   }
@@ -93,14 +92,14 @@ export class ConnectionStateManager {
     try {
       // Ensure state directory exists
       await fs.mkdir(this.config.stateDirectory, { recursive: true });
-      
+
       // Load existing state
       await this.loadState();
       await this.loadMetrics();
-      
+
       // Start persistence timer
       this.startPersistenceTimer();
-      
+
       this.logger.info('Connection state manager initialized', {
         stateDirectory: this.config.stateDirectory,
       });
@@ -128,7 +127,7 @@ export class ConnectionStateManager {
 
     // Persist immediately if critical
     if (state.pendingRequests.length > 0) {
-      this.persistState().catch(error => {
+      this.persistState().catch((error) => {
         this.logger.error('Failed to persist critical state', error);
       });
     }
@@ -161,7 +160,7 @@ export class ConnectionStateManager {
     };
 
     this.connectionHistory.push(fullEvent);
-    
+
     // Trim history if needed
     if (this.connectionHistory.length > this.config.maxHistorySize) {
       this.connectionHistory = this.connectionHistory.slice(-this.config.maxHistorySize);
@@ -192,10 +191,10 @@ export class ConnectionStateManager {
   clearSession(sessionId: string): void {
     if (this.currentState?.sessionId === sessionId) {
       this.currentState = undefined;
-      
+
       this.logger.info('Session state cleared', { sessionId });
-      
-      this.persistState().catch(error => {
+
+      this.persistState().catch((error) => {
         this.logger.error('Failed to persist cleared state', error);
       });
     }
@@ -211,7 +210,7 @@ export class ConnectionStateManager {
     }
 
     this.currentState.pendingRequests.push(request);
-    
+
     this.logger.debug('Pending request added', {
       requestId: request.id,
       method: request.method,
@@ -228,7 +227,7 @@ export class ConnectionStateManager {
     }
 
     this.currentState.pendingRequests = this.currentState.pendingRequests.filter(
-      req => req.id !== requestId
+      (req) => req.id !== requestId,
     );
   }
 
@@ -258,11 +257,11 @@ export class ConnectionStateManager {
    */
   getSessionDuration(sessionId: string): number | null {
     const connectEvent = this.connectionHistory.find(
-      e => e.sessionId === sessionId && e.type === 'connect'
+      (e) => e.sessionId === sessionId && e.type === 'connect',
     );
-    
+
     const disconnectEvent = this.connectionHistory.find(
-      e => e.sessionId === sessionId && e.type === 'disconnect'
+      (e) => e.sessionId === sessionId && e.type === 'disconnect',
     );
 
     if (!connectEvent) {
@@ -278,12 +277,14 @@ export class ConnectionStateManager {
    */
   getReconnectionTime(sessionId: string): number | null {
     const disconnectEvent = this.connectionHistory.find(
-      e => e.sessionId === sessionId && e.type === 'disconnect'
+      (e) => e.sessionId === sessionId && e.type === 'disconnect',
     );
-    
+
     const reconnectEvent = this.connectionHistory.find(
-      e => e.sessionId === sessionId && e.type === 'reconnect' &&
-      e.timestamp > (disconnectEvent?.timestamp || new Date(0))
+      (e) =>
+        e.sessionId === sessionId &&
+        e.type === 'reconnect' &&
+        e.timestamp > (disconnectEvent?.timestamp || new Date(0)),
     );
 
     if (!disconnectEvent || !reconnectEvent) {
@@ -298,31 +299,32 @@ export class ConnectionStateManager {
       case 'connect':
         this.metrics.totalConnections++;
         break;
-      
+
       case 'disconnect':
         this.metrics.totalDisconnections++;
-        
+
         // Calculate session duration
         const duration = this.getSessionDuration(event.sessionId);
         if (duration !== null) {
           this.metrics.lastConnectionDuration = duration;
-          
+
           // Update average
-          const totalDuration = this.metrics.averageSessionDuration * 
-            (this.metrics.totalDisconnections - 1) + duration;
+          const totalDuration =
+            this.metrics.averageSessionDuration * (this.metrics.totalDisconnections - 1) + duration;
           this.metrics.averageSessionDuration = totalDuration / this.metrics.totalDisconnections;
         }
         break;
-      
+
       case 'reconnect':
         this.metrics.totalReconnections++;
-        
+
         // Calculate reconnection time
         const reconnectTime = this.getReconnectionTime(event.sessionId);
         if (reconnectTime !== null) {
           // Update average
-          const totalTime = this.metrics.averageReconnectionTime * 
-            (this.metrics.totalReconnections - 1) + reconnectTime;
+          const totalTime =
+            this.metrics.averageReconnectionTime * (this.metrics.totalReconnections - 1) +
+            reconnectTime;
           this.metrics.averageReconnectionTime = totalTime / this.metrics.totalReconnections;
         }
         break;
@@ -333,15 +335,15 @@ export class ConnectionStateManager {
     try {
       const data = await fs.readFile(this.statePath, 'utf-8');
       const state = JSON.parse(data);
-      
+
       // Convert date strings back to Date objects
       state.lastConnected = new Date(state.lastConnected);
       if (state.lastDisconnected) {
         state.lastDisconnected = new Date(state.lastDisconnected);
       }
-      
+
       this.currentState = state;
-      
+
       this.logger.info('Connection state loaded', {
         sessionId: state.sessionId,
         pendingRequests: state.pendingRequests.length,
@@ -357,16 +359,16 @@ export class ConnectionStateManager {
     try {
       const data = await fs.readFile(this.metricsPath, 'utf-8');
       const loaded = JSON.parse(data);
-      
+
       // Convert date strings back to Date objects
       loaded.connectionHistory = loaded.connectionHistory.map((event: any) => ({
         ...event,
         timestamp: new Date(event.timestamp),
       }));
-      
+
       this.metrics = loaded;
       this.connectionHistory = loaded.connectionHistory;
-      
+
       this.logger.info('Connection metrics loaded', {
         totalConnections: this.metrics.totalConnections,
         historySize: this.connectionHistory.length,
@@ -385,21 +387,21 @@ export class ConnectionStateManager {
 
     try {
       if (this.currentState) {
-        await fs.writeFile(
-          this.statePath,
-          JSON.stringify(this.currentState, null, 2),
-          'utf-8'
-        );
+        await fs.writeFile(this.statePath, JSON.stringify(this.currentState, null, 2), 'utf-8');
       }
 
       // Also persist metrics
       await fs.writeFile(
         this.metricsPath,
-        JSON.stringify({
-          ...this.metrics,
-          connectionHistory: this.connectionHistory,
-        }, null, 2),
-        'utf-8'
+        JSON.stringify(
+          {
+            ...this.metrics,
+            connectionHistory: this.connectionHistory,
+          },
+          null,
+          2,
+        ),
+        'utf-8',
       );
 
       this.logger.debug('State and metrics persisted');
@@ -414,7 +416,7 @@ export class ConnectionStateManager {
     }
 
     this.persistenceTimer = setInterval(() => {
-      this.persistState().catch(error => {
+      this.persistState().catch((error) => {
         this.logger.error('Periodic persistence failed', error);
       });
     }, this.config.persistenceInterval);
@@ -432,4 +434,4 @@ export class ConnectionStateManager {
     // Final persistence
     await this.persistState();
   }
-}
+}

package/src/mcp/recovery/fallback-coordinator.ts

@@ -1,4 +1,3 @@
-import { getErrorMessage } from '../../utils/error-handler.js';
 /**
  * Fallback Coordinator for MCP
  * Manages graceful degradation to CLI when MCP connection fails
@@ -54,11 +53,11 @@ export class FallbackCoordinator extends EventEmitter {
 
   constructor(
     private logger: ILogger,
-    config?: Partial<FallbackConfig>
+    config?: Partial<FallbackConfig>,
   ) {
     super();
     this.config = { ...this.defaultConfig, ...config };
-    
+
     this.state = {
       isFallbackActive: false,
       queuedOperations: 0,
@@ -94,13 +93,13 @@ export class FallbackCoordinator extends EventEmitter {
     }
 
     this.logger.warn('Enabling CLI fallback mode');
-    
+
     this.state.isFallbackActive = true;
     this.state.lastFallbackActivation = new Date();
-    
+
     // Start notification timer
     this.startNotificationTimer();
-    
+
     this.emit('fallbackEnabled', this.state);
   }
 
@@ -113,17 +112,17 @@ export class FallbackCoordinator extends EventEmitter {
     }
 
     this.logger.info('Disabling CLI fallback mode');
-    
+
     this.state.isFallbackActive = false;
-    
+
     // Stop notification timer
     this.stopNotificationTimer();
-    
+
     this.emit('fallbackDisabled', this.state);
-    
+
     // Process any queued operations
     if (this.operationQueue.length > 0) {
-      this.processQueue().catch(error => {
+      this.processQueue().catch((error) => {
         this.logger.error('Error processing queue after fallback disabled', error);
       });
     }
@@ -164,7 +163,7 @@ export class FallbackCoordinator extends EventEmitter {
 
     // If in fallback mode, try to execute via CLI
     if (this.state.isFallbackActive && !this.processingQueue) {
-      this.executeViaCliFallback(queuedOp).catch(error => {
+      this.executeViaCliFallback(queuedOp).catch((error) => {
         this.logger.error('CLI fallback execution failed', { operation: queuedOp, error });
       });
     }
@@ -193,7 +192,7 @@ export class FallbackCoordinator extends EventEmitter {
     // Process operations in order
     while (this.operationQueue.length > 0) {
       const operation = this.operationQueue.shift()!;
-      
+
       // Check if operation has expired
       if (this.isOperationExpired(operation)) {
         this.logger.warn('Operation expired', { id: operation.id });
@@ -248,7 +247,7 @@ export class FallbackCoordinator extends EventEmitter {
     const clearedCount = this.operationQueue.length;
     this.operationQueue = [];
     this.state.queuedOperations = 0;
-    
+
     this.logger.info('Operation queue cleared', { clearedCount });
     this.emit('queueCleared', clearedCount);
   }
@@ -262,13 +261,13 @@ export class FallbackCoordinator extends EventEmitter {
     try {
       // Map MCP operations to CLI commands
       const cliCommand = this.mapOperationToCli(operation);
-      
+
       if (!cliCommand) {
         throw new Error(`No CLI mapping for operation: ${operation.method}`);
       }
 
       const { stdout, stderr } = await execAsync(cliCommand);
-      
+
       if (stderr) {
         this.logger.warn('CLI command stderr', { stderr });
       }
@@ -313,18 +312,19 @@ export class FallbackCoordinator extends EventEmitter {
     const mappings: Record<string, (params: any) => string> = {
       // Tool operations
       'tools/list': () => `${this.config.cliPath} tools list`,
-      'tools/call': (params) => `${this.config.cliPath} tools call ${params.name} '${JSON.stringify(params.arguments)}'`,
-      
+      'tools/call': (params) =>
+        `${this.config.cliPath} tools call ${params.name} '${JSON.stringify(params.arguments)}'`,
+
       // Resource operations
       'resources/list': () => `${this.config.cliPath} resources list`,
       'resources/read': (params) => `${this.config.cliPath} resources read ${params.uri}`,
-      
+
       // Session operations
-      'initialize': () => `${this.config.cliPath} session init`,
-      'shutdown': () => `${this.config.cliPath} session shutdown`,
-      
+      initialize: () => `${this.config.cliPath} session init`,
+      shutdown: () => `${this.config.cliPath} session shutdown`,
+
       // Custom operations
-      'heartbeat': () => `${this.config.cliPath} health check`,
+      heartbeat: () => `${this.config.cliPath} health check`,
     };
 
     const mapper = mappings[operation.method];
@@ -363,4 +363,4 @@ export class FallbackCoordinator extends EventEmitter {
       this.notificationTimer = undefined;
     }
   }
-}
+}

package/src/mcp/recovery/index.ts

@@ -4,7 +4,26 @@
  */
 
 export { RecoveryManager, RecoveryConfig, RecoveryStatus } from './recovery-manager.js';
-export { ConnectionHealthMonitor, HealthStatus, HealthMonitorConfig } from './connection-health-monitor.js';
-export { ReconnectionManager, ReconnectionConfig, ReconnectionState } from './reconnection-manager.js';
-export { FallbackCoordinator, FallbackOperation, FallbackConfig, FallbackState } from './fallback-coordinator.js';
-export { ConnectionStateManager, ConnectionState, ConnectionEvent, ConnectionMetrics, StateManagerConfig } from './connection-state-manager.js';
+export {
+  ConnectionHealthMonitor,
+  HealthStatus,
+  HealthMonitorConfig,
+} from './connection-health-monitor.js';
+export {
+  ReconnectionManager,
+  ReconnectionConfig,
+  ReconnectionState,
+} from './reconnection-manager.js';
+export {
+  FallbackCoordinator,
+  FallbackOperation,
+  FallbackConfig,
+  FallbackState,
+} from './fallback-coordinator.js';
+export {
+  ConnectionStateManager,
+  ConnectionState,
+  ConnectionEvent,
+  ConnectionMetrics,
+  StateManagerConfig,
+} from './connection-state-manager.js';