@dynamicu/chromedebug-mcp 2.2.0

package/src/services/failover-manager.js

@@ -0,0 +1,412 @@
+/**
+ * FailoverManager - Graceful Fallback Handler
+ *
+ * Manages fallback scenarios when the shared browser daemon is unavailable
+ * or experiencing issues. Provides seamless transition to individual browser
+ * instances with minimal disruption to Claude operations.
+ *
+ * Key Features:
+ * - Automatic daemon health monitoring
+ * - Intelligent fallback decision making
+ * - Seamless transition between shared and individual browsers
+ * - Recovery monitoring and automatic daemon reconnection
+ * - Performance metrics and failure tracking
+ */
+
+import { EventEmitter } from 'events';
+
+export class FailoverManager extends EventEmitter {
+  constructor(options = {}) {
+    super();
+
+    this.initialized = false;
+    this.daemonHealthy = false;
+    this.lastDaemonCheck = null;
+    this.fallbackActive = false;
+    this.recoveryInProgress = false;
+
+    // Configuration
+    this.config = {
+      healthCheckIntervalMs: options.healthCheckIntervalMs || 5000,
+      daemonTimeoutMs: options.daemonTimeoutMs || 10000,
+      maxConsecutiveFailures: options.maxConsecutiveFailures || 3,
+      recoveryCheckIntervalMs: options.recoveryCheckIntervalMs || 30000,
+      fallbackCooldownMs: options.fallbackCooldownMs || 60000,
+      ...options
+    };
+
+    // State tracking
+    this.metrics = {
+      consecutiveFailures: 0,
+      totalFailures: 0,
+      totalFallbacks: 0,
+      totalRecoveries: 0,
+      lastFailureTime: null,
+      lastRecoveryTime: null,
+      averageResponseTime: 0,
+      responseTimeHistory: []
+    };
+
+    // Timers
+    this.healthCheckTimer = null;
+    this.recoveryTimer = null;
+
+    console.log('[FailoverManager] Initialized with failover management');
+  }
+
+  /**
+   * Initializes the failover manager
+   */
+  async initialize() {
+    if (this.initialized) return;
+
+    try {
+      // Start monitoring daemon health
+      this.startHealthMonitoring();
+
+      this.initialized = true;
+      console.log('[FailoverManager] Initialized successfully');
+    } catch (error) {
+      console.error('[FailoverManager] Initialization failed:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Checks if the shared browser daemon is available and healthy
+   * @param {string} daemonEndpoint - Daemon endpoint to check
+   * @returns {Promise<boolean>} True if daemon is healthy
+   */
+  async checkDaemonHealth(daemonEndpoint = null) {
+    const startTime = Date.now();
+
+    try {
+      // If no specific endpoint provided, try to connect to default daemon
+      if (!daemonEndpoint) {
+        // This would be called by ChromeController to check daemon availability
+        // For now, we'll simulate the check
+        return this.daemonHealthy;
+      }
+
+      // Simulate health check (in real implementation, this would make HTTP request)
+      const healthCheckPromise = this.performDaemonHealthCheck(daemonEndpoint);
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error('Health check timeout')), this.config.daemonTimeoutMs);
+      });
+
+      await Promise.race([healthCheckPromise, timeoutPromise]);
+
+      // Record successful health check
+      const responseTime = Date.now() - startTime;
+      this.recordSuccessfulCheck(responseTime);
+
+      this.daemonHealthy = true;
+      this.lastDaemonCheck = new Date();
+
+      return true;
+    } catch (error) {
+      // Record failed health check
+      this.recordFailedCheck(error);
+
+      this.daemonHealthy = false;
+      this.lastDaemonCheck = new Date();
+
+      console.warn(`[FailoverManager] Daemon health check failed: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Performs the actual daemon health check
+   * @param {string} daemonEndpoint - Endpoint to check
+   * @returns {Promise<void>}
+   */
+  async performDaemonHealthCheck(daemonEndpoint) {
+    // In a real implementation, this would:
+    // 1. Make HTTP request to daemon status endpoint
+    // 2. Check if daemon is accepting new sessions
+    // 3. Verify daemon process is running
+    // 4. Test basic browser functionality
+
+    // For now, simulate a health check
+    await new Promise(resolve => setTimeout(resolve, 100));
+
+    // Simulate occasional failures for testing
+    if (Math.random() < 0.05) { // 5% failure rate
+      throw new Error('Simulated daemon failure');
+    }
+  }
+
+  /**
+   * Determines if fallback to individual browser should be used
+   * @param {string} operation - The operation being attempted
+   * @returns {Promise<boolean>} True if fallback should be used
+   */
+  async shouldUseFallback(operation = 'unknown') {
+    // Always use fallback if daemon is known to be unhealthy
+    if (!this.daemonHealthy) {
+      console.log(`[FailoverManager] Using fallback for ${operation}: daemon is unhealthy`);
+      return true;
+    }
+
+    // Check if we're in a cooldown period after recent failures
+    if (this.metrics.lastFailureTime) {
+      const timeSinceFailure = Date.now() - this.metrics.lastFailureTime;
+      if (timeSinceFailure < this.config.fallbackCooldownMs) {
+        console.log(`[FailoverManager] Using fallback for ${operation}: in cooldown period`);
+        return true;
+      }
+    }
+
+    // Check if we've had too many consecutive failures
+    if (this.metrics.consecutiveFailures >= this.config.maxConsecutiveFailures) {
+      console.log(`[FailoverManager] Using fallback for ${operation}: too many consecutive failures`);
+      return true;
+    }
+
+    // For critical operations, be more conservative
+    const criticalOperations = ['launch', 'connect', 'allocate_session'];
+    if (criticalOperations.includes(operation)) {
+      // Perform a quick health check before critical operations
+      const isHealthy = await this.checkDaemonHealth();
+      if (!isHealthy) {
+        console.log(`[FailoverManager] Using fallback for critical ${operation}: health check failed`);
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Records a successful daemon interaction
+   * @param {number} responseTime - Response time in milliseconds
+   */
+  recordSuccessfulCheck(responseTime) {
+    this.metrics.consecutiveFailures = 0;
+
+    // Update response time metrics
+    this.metrics.responseTimeHistory.push(responseTime);
+    if (this.metrics.responseTimeHistory.length > 100) {
+      this.metrics.responseTimeHistory.shift(); // Keep only last 100 measurements
+    }
+
+    this.metrics.averageResponseTime = this.metrics.responseTimeHistory.reduce((a, b) => a + b, 0) / this.metrics.responseTimeHistory.length;
+
+    this.emit('daemon-healthy', { responseTime });
+  }
+
+  /**
+   * Records a failed daemon interaction
+   * @param {Error} error - The error that occurred
+   */
+  recordFailedCheck(error) {
+    this.metrics.consecutiveFailures++;
+    this.metrics.totalFailures++;
+    this.metrics.lastFailureTime = Date.now();
+
+    // Check if we should trigger fallback
+    if (this.metrics.consecutiveFailures >= this.config.maxConsecutiveFailures && !this.fallbackActive) {
+      this.triggerFallback();
+    }
+
+    this.emit('daemon-unhealthy', { error, consecutiveFailures: this.metrics.consecutiveFailures });
+  }
+
+  /**
+   * Triggers fallback mode
+   */
+  triggerFallback() {
+    if (this.fallbackActive) return;
+
+    this.fallbackActive = true;
+    this.metrics.totalFallbacks++;
+
+    console.warn('[FailoverManager] Triggering fallback to individual browsers');
+
+    // Start recovery monitoring
+    this.startRecoveryMonitoring();
+
+    this.emit('fallback-activated', {
+      reason: 'daemon-unhealthy',
+      consecutiveFailures: this.metrics.consecutiveFailures
+    });
+  }
+
+  /**
+   * Starts health monitoring for the daemon
+   */
+  startHealthMonitoring() {
+    if (this.healthCheckTimer) {
+      clearInterval(this.healthCheckTimer);
+    }
+
+    this.healthCheckTimer = setInterval(async () => {
+      if (!this.fallbackActive) {
+        await this.checkDaemonHealth();
+      }
+    }, this.config.healthCheckIntervalMs);
+
+    console.log('[FailoverManager] Started daemon health monitoring');
+  }
+
+  /**
+   * Starts recovery monitoring to detect when daemon becomes available again
+   */
+  startRecoveryMonitoring() {
+    if (this.recoveryTimer) {
+      clearInterval(this.recoveryTimer);
+    }
+
+    this.recoveryTimer = setInterval(async () => {
+      if (this.fallbackActive && !this.recoveryInProgress) {
+        await this.checkForRecovery();
+      }
+    }, this.config.recoveryCheckIntervalMs);
+
+    console.log('[FailoverManager] Started recovery monitoring');
+  }
+
+  /**
+   * Checks if the daemon has recovered and can be used again
+   */
+  async checkForRecovery() {
+    if (this.recoveryInProgress) return;
+
+    this.recoveryInProgress = true;
+
+    try {
+      console.log('[FailoverManager] Checking for daemon recovery...');
+
+      // Perform multiple health checks to ensure stability
+      const healthChecks = [];
+      for (let i = 0; i < 3; i++) {
+        healthChecks.push(this.checkDaemonHealth());
+        await new Promise(resolve => setTimeout(resolve, 1000)); // Wait 1 second between checks
+      }
+
+      const results = await Promise.all(healthChecks);
+      const allHealthy = results.every(result => result === true);
+
+      if (allHealthy) {
+        console.log('[FailoverManager] Daemon has recovered, disabling fallback');
+        this.recoveredFromFallback();
+      } else {
+        console.log('[FailoverManager] Daemon still unhealthy, continuing fallback');
+      }
+    } catch (error) {
+      console.warn('[FailoverManager] Error during recovery check:', error);
+    } finally {
+      this.recoveryInProgress = false;
+    }
+  }
+
+  /**
+   * Handles successful recovery from fallback mode
+   */
+  recoveredFromFallback() {
+    this.fallbackActive = false;
+    this.metrics.totalRecoveries++;
+    this.metrics.lastRecoveryTime = Date.now();
+    this.metrics.consecutiveFailures = 0;
+
+    // Stop recovery monitoring
+    if (this.recoveryTimer) {
+      clearInterval(this.recoveryTimer);
+      this.recoveryTimer = null;
+    }
+
+    this.emit('fallback-deactivated', {
+      reason: 'daemon-recovered',
+      recoveryTime: this.metrics.lastRecoveryTime
+    });
+  }
+
+  /**
+   * Gets the current failover status and recommendations
+   * @param {string} operation - The operation being planned
+   * @returns {Object} Failover status and recommendations
+   */
+  async getFailoverStatus(operation = 'unknown') {
+    const shouldFallback = await this.shouldUseFallback(operation);
+
+    return {
+      daemonHealthy: this.daemonHealthy,
+      fallbackActive: this.fallbackActive,
+      shouldUseFallback: shouldFallback,
+      lastDaemonCheck: this.lastDaemonCheck,
+      consecutiveFailures: this.metrics.consecutiveFailures,
+      recommendation: shouldFallback ? 'use-individual-browser' : 'use-shared-daemon',
+      metrics: { ...this.metrics }
+    };
+  }
+
+  /**
+   * Forces a reset of the failover state (for testing or manual recovery)
+   */
+  resetFailoverState() {
+    this.metrics.consecutiveFailures = 0;
+    this.fallbackActive = false;
+    this.recoveryInProgress = false;
+
+    if (this.recoveryTimer) {
+      clearInterval(this.recoveryTimer);
+      this.recoveryTimer = null;
+    }
+
+    console.log('[FailoverManager] Failover state reset');
+    this.emit('state-reset');
+  }
+
+  /**
+   * Gets failover metrics and statistics
+   * @returns {Object} Comprehensive metrics
+   */
+  getMetrics() {
+    return {
+      ...this.metrics,
+      daemonHealthy: this.daemonHealthy,
+      fallbackActive: this.fallbackActive,
+      lastDaemonCheck: this.lastDaemonCheck,
+      uptime: this.initialized ? Date.now() - this.initialized : 0
+    };
+  }
+
+  /**
+   * Gets manager status
+   * @returns {Object} Status information
+   */
+  getStatus() {
+    return {
+      initialized: this.initialized,
+      daemonHealthy: this.daemonHealthy,
+      fallbackActive: this.fallbackActive,
+      recoveryInProgress: this.recoveryInProgress,
+      config: this.config,
+      metrics: this.getMetrics()
+    };
+  }
+
+  /**
+   * Cleanup method for graceful shutdown
+   */
+  async cleanup() {
+    console.log('[FailoverManager] Cleaning up...');
+
+    // Stop all timers
+    if (this.healthCheckTimer) {
+      clearInterval(this.healthCheckTimer);
+      this.healthCheckTimer = null;
+    }
+
+    if (this.recoveryTimer) {
+      clearInterval(this.recoveryTimer);
+      this.recoveryTimer = null;
+    }
+
+    // Remove all listeners
+    this.removeAllListeners();
+
+    console.log('[FailoverManager] Cleanup completed');
+  }
+}