@dynamicu/chromedebug-mcp 2.2.0

package/src/services/browser-daemon.js

@@ -0,0 +1,494 @@
+/**
+ * BrowserDaemon - Shared Chrome Browser Instance Manager
+ *
+ * Provides centralized Chrome browser management with enhanced security isolation.
+ * Multiple Claude instances can share a single Chrome browser while maintaining
+ * complete profile isolation and secure session management.
+ *
+ * Key Features:
+ * - Single shared Chrome browser with multiple isolated profiles
+ * - Session-based security isolation (no data leakage between sessions)
+ * - Automatic health monitoring and recovery
+ * - Graceful fallback to individual browsers on daemon issues
+ * - Resource limits to prevent DoS attacks
+ * - Persistent session registry with atomic operations
+ */
+
+import puppeteer from 'puppeteer';
+import { randomUUID } from 'crypto';
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+import { ProfileManager } from './profile-manager.js';
+import { PersistentRegistry } from './session-registry.js';
+import { FailoverManager } from './failover-manager.js';
+import { findAvailablePort } from '../utils.js';
+import { getExtensionPath } from '../utils/extension-path.js';
+
+export class BrowserDaemon {
+  constructor(options = {}) {
+    this.browser = null;
+    this.isRunning = false;
+    this.startTime = null;
+    this.daemonId = randomUUID();
+
+    // Core managers for security and isolation
+    this.profileManager = new ProfileManager();
+    this.sessionRegistry = new PersistentRegistry();
+    this.failoverManager = new FailoverManager();
+
+    // Configuration with security defaults
+    this.config = {
+      maxConcurrentSessions: options.maxConcurrentSessions || 10,
+      healthCheckInterval: options.healthCheckInterval || 10000,
+      sessionTimeoutMs: options.sessionTimeoutMs || 30 * 60 * 1000, // 30 minutes
+      daemonPort: options.daemonPort || null, // Auto-detect
+      enableHeadless: options.enableHeadless || false,
+      ...options
+    };
+
+    // Active sessions tracking
+    this.activeSessions = new Map(); // sessionId -> { contextId, profilePath, claudeInstanceId, lastActivity }
+    this.healthCheckTimer = null;
+    this.isShuttingDown = false;
+
+    // Bind methods to preserve context
+    this.performHealthCheck = this.performHealthCheck.bind(this);
+    this.gracefulShutdown = this.gracefulShutdown.bind(this);
+
+    // Setup cleanup handlers
+    this.setupProcessCleanupHandlers();
+  }
+
+  /**
+   * Setup process cleanup handlers to ensure graceful shutdown
+   */
+  setupProcessCleanupHandlers() {
+    const signals = ['SIGINT', 'SIGTERM', 'SIGQUIT'];
+    signals.forEach(signal => {
+      process.on(signal, async () => {
+        console.log(`[BrowserDaemon] Received ${signal}, initiating graceful shutdown...`);
+        await this.gracefulShutdown();
+        process.exit(0);
+      });
+    });
+
+    process.on('uncaughtException', async (error) => {
+      console.error('[BrowserDaemon] Uncaught exception:', error);
+      await this.gracefulShutdown();
+      process.exit(1);
+    });
+
+    process.on('unhandledRejection', async (reason, promise) => {
+      console.error('[BrowserDaemon] Unhandled rejection at:', promise, 'reason:', reason);
+      await this.gracefulShutdown();
+      process.exit(1);
+    });
+  }
+
+  /**
+   * Starts the shared browser daemon
+   * @returns {Promise<DaemonStartResult>}
+   */
+  async start() {
+    if (this.isRunning) {
+      throw new Error('Browser daemon is already running');
+    }
+
+    try {
+      console.log(`[BrowserDaemon] Starting daemon ${this.daemonId}...`);
+
+      // Initialize core managers
+      await this.profileManager.initialize();
+      await this.sessionRegistry.initialize();
+      await this.failoverManager.initialize();
+
+      // Find available port for debugging
+      this.config.daemonPort = this.config.daemonPort || await findAvailablePort(9222, 9300);
+
+      // Launch shared Chrome browser with security flags
+      this.browser = await this.launchSharedBrowser();
+      this.isRunning = true;
+      this.startTime = new Date();
+
+      // Note: Auto-restart functionality removed - browser disconnects will not trigger automatic restarts
+
+      // Start health monitoring
+      this.startHealthCheck();
+
+      console.log(`[BrowserDaemon] Daemon started successfully on port ${this.config.daemonPort}`);
+
+      return {
+        success: true,
+        daemonId: this.daemonId,
+        port: this.config.daemonPort,
+        startTime: this.startTime,
+        maxSessions: this.config.maxConcurrentSessions
+      };
+    } catch (error) {
+      console.error('[BrowserDaemon] Failed to start daemon:', error);
+      await this.cleanup();
+      throw new Error(`Daemon startup failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Launches the shared Chrome browser with security configurations
+   * @returns {Promise<Browser>}
+   */
+  async launchSharedBrowser() {
+    // Get Chrome extension path with fallback logic
+    const extensionPath = getExtensionPath();
+
+    // Build launch args
+    const args = [
+      `--remote-debugging-port=${this.config.daemonPort}`,
+      '--no-first-run',
+      '--no-default-browser-check',
+      '--disable-features=VizDisplayCompositor',
+      '--disable-setuid-sandbox',
+      '--no-sandbox',
+      '--disable-dev-shm-usage',
+      // Security: Disable potentially dangerous features
+      '--disable-plugins',
+      '--disable-java',
+      // Performance optimizations for shared use
+      '--max_old_space_size=4096',
+      '--no-zygote',
+      '--disable-background-timer-throttling',
+      '--disable-renderer-backgrounding'
+    ];
+
+    // Add extension flags if extension found
+    if (extensionPath) {
+      args.push(
+        '--enable-extensions',
+        '--extensions-on-chrome-urls',
+        `--disable-extensions-except=${extensionPath}`,
+        `--load-extension=${extensionPath}`
+      );
+      console.log(`[BrowserDaemon] Loading ChromeDebug extension from: ${extensionPath}`);
+    } else {
+      console.warn('[BrowserDaemon] ChromeDebug extension not found. Visual selection features will be unavailable.');
+    }
+
+    const launchOptions = {
+      headless: this.config.enableHeadless,
+      args,
+      defaultViewport: null,
+      ignoreDefaultArgs: ['--disable-extensions', '--disable-default-apps', '--disable-component-extensions-with-background-pages'],
+      timeout: 60000,
+      // Use a temporary user data dir for the shared browser
+      userDataDir: await this.createSharedUserDataDir()
+    };
+
+    console.log(`[BrowserDaemon] Launching Chrome with debugging port ${this.config.daemonPort}`);
+    return await puppeteer.launch(launchOptions);
+  }
+
+  /**
+   * Creates a temporary user data directory for the shared browser
+   * @returns {Promise<string>}
+   */
+  async createSharedUserDataDir() {
+    const tmpDir = os.tmpdir();
+    const sharedDirName = `chrome-daemon-${this.daemonId}`;
+    const sharedUserDataDir = path.join(tmpDir, sharedDirName);
+
+    await fs.mkdir(sharedUserDataDir, { recursive: true });
+    console.log(`[BrowserDaemon] Created shared user data directory: ${sharedUserDataDir}`);
+
+    return sharedUserDataDir;
+  }
+
+  /**
+   * Allocates a new isolated session for a Claude instance
+   * @param {string} claudeInstanceId - Unique identifier for the Claude instance
+   * @param {Object} options - Session allocation options
+   * @returns {Promise<SessionAllocation>}
+   */
+  async allocateSession(claudeInstanceId, options = {}) {
+    if (!this.isRunning || !this.browser) {
+      throw new Error('Browser daemon is not running');
+    }
+
+    // Check session limits
+    if (this.activeSessions.size >= this.config.maxConcurrentSessions) {
+      throw new Error(`Maximum concurrent sessions reached (${this.config.maxConcurrentSessions})`);
+    }
+
+    // Validate Claude instance ID
+    if (!claudeInstanceId || typeof claudeInstanceId !== 'string') {
+      throw new Error('Valid claudeInstanceId is required');
+    }
+
+    try {
+      const sessionId = randomUUID();
+
+      // Create isolated profile for this session
+      const profilePath = await this.profileManager.createSessionProfile(sessionId, claudeInstanceId);
+
+      // Create isolated browser context
+      const context = await this.browser.createBrowserContext({
+        // Each session gets its own isolated context
+        // Note: Puppeteer's createBrowserContext doesn't accept userDataDir
+        // Instead, we use Chrome's profile management
+      });
+
+      // Create a page in the context
+      const page = await context.newPage();
+
+      // Store session information
+      const sessionData = {
+        sessionId,
+        claudeInstanceId,
+        contextId: context._id || sessionId, // Use context ID or fallback to session ID
+        profilePath,
+        context,
+        page,
+        createdAt: new Date(),
+        lastActivity: new Date()
+      };
+
+      this.activeSessions.set(sessionId, sessionData);
+
+      // Register session persistently
+      await this.sessionRegistry.updateSession(sessionId, {
+        claudeInstanceId,
+        profilePath,
+        contextId: sessionData.contextId,
+        daemonId: this.daemonId,
+        createdAt: sessionData.createdAt,
+        lastActivity: sessionData.lastActivity
+      });
+
+      console.log(`[BrowserDaemon] Allocated session ${sessionId} for Claude instance ${claudeInstanceId}`);
+
+      return {
+        success: true,
+        sessionId,
+        contextId: sessionData.contextId,
+        profilePath,
+        browserWSEndpoint: this.browser.wsEndpoint(),
+        debugPort: this.config.daemonPort,
+        connectionInfo: {
+          type: 'shared-daemon',
+          daemonId: this.daemonId,
+          sessionId
+        }
+      };
+    } catch (error) {
+      console.error('[BrowserDaemon] Session allocation failed:', error);
+      throw new Error(`Session allocation failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Deallocates a session and cleans up resources
+   * @param {string} sessionId - Session ID to deallocate
+   * @returns {Promise<boolean>}
+   */
+  async deallocateSession(sessionId) {
+    if (!sessionId || !this.activeSessions.has(sessionId)) {
+      console.warn(`[BrowserDaemon] Attempted to deallocate non-existent session: ${sessionId}`);
+      return false;
+    }
+
+    try {
+      const sessionData = this.activeSessions.get(sessionId);
+
+      // Close browser context
+      if (sessionData.context) {
+        await sessionData.context.close();
+      }
+
+      // Cleanup profile
+      await this.profileManager.cleanupProfile(sessionId);
+
+      // Remove from active sessions
+      this.activeSessions.delete(sessionId);
+
+      // Remove from persistent registry
+      await this.sessionRegistry.removeSession(sessionId);
+
+      console.log(`[BrowserDaemon] Deallocated session ${sessionId}`);
+      return true;
+    } catch (error) {
+      console.error(`[BrowserDaemon] Error deallocating session ${sessionId}:`, error);
+      return false;
+    }
+  }
+
+  /**
+   * Updates session activity timestamp
+   * @param {string} sessionId - Session ID to update
+   */
+  async updateSessionActivity(sessionId) {
+    if (this.activeSessions.has(sessionId)) {
+      const sessionData = this.activeSessions.get(sessionId);
+      sessionData.lastActivity = new Date();
+
+      // Update persistent registry
+      await this.sessionRegistry.updateSession(sessionId, {
+        lastActivity: sessionData.lastActivity
+      });
+    }
+  }
+
+  /**
+   * Gets connection information for an existing session
+   * @param {string} sessionId - Session ID
+   * @returns {Object|null} Connection info or null if not found
+   */
+  getSessionConnection(sessionId) {
+    if (!this.activeSessions.has(sessionId)) {
+      return null;
+    }
+
+    const sessionData = this.activeSessions.get(sessionId);
+    return {
+      sessionId,
+      contextId: sessionData.contextId,
+      profilePath: sessionData.profilePath,
+      browserWSEndpoint: this.browser?.wsEndpoint(),
+      debugPort: this.config.daemonPort,
+      connectionInfo: {
+        type: 'shared-daemon',
+        daemonId: this.daemonId,
+        sessionId
+      }
+    };
+  }
+
+  /**
+   * Starts health check monitoring
+   */
+  startHealthCheck() {
+    if (this.healthCheckTimer) {
+      clearInterval(this.healthCheckTimer);
+    }
+
+    this.healthCheckTimer = setInterval(this.performHealthCheck, this.config.healthCheckInterval);
+    console.log(`[BrowserDaemon] Started health check with ${this.config.healthCheckInterval}ms interval`);
+  }
+
+  /**
+   * Performs periodic health checks and cleanup
+   */
+  async performHealthCheck() {
+    if (this.isShuttingDown) return;
+
+    try {
+      // Check browser health - log status but don't restart
+      if (!this.browser || this.browser.process()?.killed) {
+        console.warn('[BrowserDaemon] Browser process is down. Claude can launch a new browser when needed.');
+        // Don't restart - let Claude handle recovery via MCP tools
+        return;
+      }
+
+      // Clean up inactive sessions
+      const now = new Date();
+      const expiredSessions = [];
+
+      for (const [sessionId, sessionData] of this.activeSessions) {
+        const inactiveTime = now.getTime() - sessionData.lastActivity.getTime();
+        if (inactiveTime > this.config.sessionTimeoutMs) {
+          expiredSessions.push(sessionId);
+        }
+      }
+
+      // Clean up expired sessions
+      for (const sessionId of expiredSessions) {
+        console.log(`[BrowserDaemon] Cleaning up expired session: ${sessionId}`);
+        await this.deallocateSession(sessionId);
+      }
+
+      if (expiredSessions.length > 0) {
+        console.log(`[BrowserDaemon] Cleaned up ${expiredSessions.length} expired sessions`);
+      }
+
+    } catch (error) {
+      console.error('[BrowserDaemon] Health check failed:', error);
+    }
+  }
+
+
+  /**
+   * Gets daemon status and statistics
+   * @returns {Object} Daemon status information
+   */
+  getStatus() {
+    return {
+      daemonId: this.daemonId,
+      isRunning: this.isRunning,
+      startTime: this.startTime,
+      activeSessions: this.activeSessions.size,
+      maxSessions: this.config.maxConcurrentSessions,
+      debugPort: this.config.daemonPort,
+      browserConnected: this.browser && !this.browser.process()?.killed,
+      uptime: this.startTime ? Date.now() - this.startTime.getTime() : 0
+    };
+  }
+
+  /**
+   * Performs graceful shutdown of the daemon
+   */
+  async gracefulShutdown() {
+    if (this.isShuttingDown) return;
+
+    this.isShuttingDown = true;
+    console.log('[BrowserDaemon] Initiating graceful shutdown...');
+
+    try {
+      // Stop health checks
+      if (this.healthCheckTimer) {
+        clearInterval(this.healthCheckTimer);
+        this.healthCheckTimer = null;
+      }
+
+      // Clean up all active sessions
+      console.log(`[BrowserDaemon] Cleaning up ${this.activeSessions.size} active sessions...`);
+      for (const sessionId of this.activeSessions.keys()) {
+        await this.deallocateSession(sessionId);
+      }
+
+      // Close browser
+      if (this.browser) {
+        await this.browser.close();
+        this.browser = null;
+      }
+
+      // Cleanup managers
+      await this.cleanup();
+
+      this.isRunning = false;
+      console.log('[BrowserDaemon] Graceful shutdown completed');
+    } catch (error) {
+      console.error('[BrowserDaemon] Error during graceful shutdown:', error);
+    }
+  }
+
+  /**
+   * Internal cleanup method
+   */
+  async cleanup() {
+    try {
+      await this.profileManager.cleanup();
+      await this.sessionRegistry.cleanup();
+      await this.failoverManager.cleanup();
+    } catch (error) {
+      console.error('[BrowserDaemon] Error during cleanup:', error);
+    }
+  }
+
+  /**
+   * Checks if the daemon is healthy and ready to accept sessions
+   * @returns {boolean}
+   */
+  isHealthy() {
+    return this.isRunning &&
+           this.browser &&
+           !this.browser.process()?.killed &&
+           !this.isShuttingDown;
+  }
+}