@dynamicu/chromedebug-mcp 2.2.0

package/src/index.js

@@ -0,0 +1,305 @@
+/**
+ * Chrome Debug MCP Server - Modular Architecture
+ * Refactored from monolithic design to modular components
+ * Maintains all security fixes and functionality while improving maintainability
+ */
+
+import { ChromeController } from './chrome-controller.js';
+import { MCPServer } from './mcp/server.js';
+import { ChromeService } from './services/chrome-service.js';
+import { ProcessManager } from './services/process-manager.js';
+import {
+  initializeSessionManager,
+  getSessionInfo,
+  registerProcess,
+  findActiveSessions
+} from './services/unified-session-manager.js';
+
+/**
+ * Main application class that orchestrates all components
+ */
+class ChromePilotApp {
+  constructor() {
+    this.chromeController = null;
+    this.chromeService = null;
+    this.mcpServer = null;
+    this.processManager = null;
+    this.sessionManager = null;
+    this.initialized = false;
+  }
+
+  /**
+   * Initializes all components
+   * @param {Object} options - Initialization options
+   */
+  async initialize(options = {}) {
+    try {
+      // Parse command line arguments
+      const args = this.parseArguments();
+      const finalOptions = { ...options, ...args };
+
+      // Create Chrome controller instance
+      this.chromeController = new ChromeController();
+
+      // Create Chrome service wrapper with process management
+      this.chromeService = new ChromeService(this.chromeController);
+      this.processManager = this.chromeService.getProcessManager();
+
+      // Initialize Chrome service (starts HTTP server if needed)
+      const serviceResult = await this.chromeService.initialize({
+        ...finalOptions,
+        sessionManager: this.sessionManager
+      });
+      
+      if (serviceResult.httpServer) {
+        console.error(`Chrome service initialized with HTTP server on port ${serviceResult.httpServer.port}`);
+      }
+
+      // Create and configure MCP server
+      this.mcpServer = new MCPServer(this.chromeService);
+
+      this.initialized = true;
+      return {
+        status: 'initialized',
+        options: finalOptions,
+        serviceResult
+      };
+    } catch (error) {
+      console.error('Failed to initialize Chrome Debug:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Starts the MCP server
+   */
+  async start() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    try {
+      // Clean up any existing Chrome Debug processes
+      const cleanupResult = await this.processManager.cleanupChromePilotProcesses();
+      if (cleanupResult.total > 0) {
+        console.error(`Cleaned up ${cleanupResult.killed.length} existing processes`);
+      }
+
+      // Start the MCP server
+      await this.mcpServer.start();
+    } catch (error) {
+      console.error('Failed to start Chrome Debug MCP server:', error);
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Gets the status of all components
+   */
+  async getStatus() {
+    if (!this.initialized) {
+      return { status: 'not_initialized' };
+    }
+
+    return {
+      status: 'running',
+      components: {
+        chromeService: await this.chromeService.getStatus(),
+        processManager: this.processManager.getStatistics(),
+        mcpServer: {
+          initialized: !!this.mcpServer,
+          tools: this.mcpServer ? this.mcpServer.toolRegistry.getAllTools().length : 0
+        }
+      },
+      timestamp: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Parses command line arguments
+   * @returns {Object} Parsed arguments
+   */
+  parseArguments() {
+    const args = {
+      singleServer: false,
+      watch: false,
+      debug: false,
+      sessionId: null,
+      noCleanup: false,
+      verbose: false
+    };
+
+    const argv = process.argv.slice(2);
+    for (let i = 0; i < argv.length; i++) {
+      const arg = argv[i];
+
+      switch (arg) {
+        case '--single-server':
+          args.singleServer = true;
+          break;
+        case '--watch':
+          args.watch = true;
+          break;
+        case '--debug':
+          args.debug = true;
+          break;
+        case '--session-id':
+          if (i + 1 < argv.length) {
+            args.sessionId = argv[++i];
+          } else {
+            console.error('--session-id requires a value');
+            process.exit(1);
+          }
+          break;
+        case '--no-cleanup':
+          args.noCleanup = true;
+          break;
+        case '--verbose':
+          args.verbose = true;
+          break;
+        case '--help':
+          this.showHelp();
+          process.exit(0);
+          break;
+        default:
+          if (arg.startsWith('--session-id=')) {
+            args.sessionId = arg.split('=')[1];
+          } else if (arg.startsWith('--')) {
+            console.error(`Unknown argument: ${arg}`);
+            this.showHelp();
+            process.exit(1);
+          }
+          break;
+      }
+    }
+
+    return args;
+  }
+
+  /**
+   * Shows help information
+   */
+  showHelp() {
+    console.log(`
+Chrome Debug MCP Server - Modular Architecture with Session Isolation
+
+Usage: node src/index.js [options]
+
+Options:
+  --single-server      Run without HTTP server (MCP only)
+  --watch             Watch for file changes (development mode)
+  --debug             Enable debug logging
+  --session-id ID     Set custom session ID for resource isolation
+  --no-cleanup        Skip cleanup of dead processes on startup
+  --verbose           Enable verbose logging including session info
+  --help              Show this help message
+
+Session Isolation:
+  Each session gets isolated process tracking and port discovery.
+  This allows multiple Chrome Debug MCP instances to run simultaneously
+  without interfering with each other.
+
+Examples:
+  node src/index.js --session-id claude-session-1 --verbose
+  node src/index.js --no-cleanup --debug
+
+Environment Variables:
+  NODE_ENV            Set to 'development' for debug mode
+  CHROME_PILOT_PORT   Configure HTTP server port
+
+For more information, see the documentation in CLAUDE.md
+    `);
+  }
+
+  /**
+   * Graceful shutdown
+   */
+  async shutdown() {
+    console.error('Shutting down Chrome Debug...');
+    
+    try {
+      if (this.chromeService) {
+        await this.chromeService.cleanup();
+      }
+      
+      if (this.processManager) {
+        await this.processManager.killAllManagedProcesses();
+      }
+      
+      console.error('Chrome Debug shutdown complete');
+    } catch (error) {
+      console.error('Error during shutdown:', error);
+    }
+  }
+}
+
+/**
+ * Main entry point
+ */
+async function main() {
+  const app = new ChromePilotApp();
+
+  // Parse arguments first to get session settings
+  const args = app.parseArguments();
+
+  try {
+    // Initialize unified session manager with options
+    const sessionManager = await initializeSessionManager({
+      sessionId: args.sessionId,
+      skipCleanup: args.noCleanup,
+      verbose: args.verbose
+    });
+
+    // Register this process for tracking
+    await registerProcess(process.pid, 'mcp-server');
+
+    // Log session information if verbose
+    if (args.verbose) {
+      const sessionInfo = getSessionInfo();
+      console.log('Session Information:');
+      console.log(`  Session ID: ${sessionInfo.sessionId}`);
+      console.log(`  PID: ${sessionInfo.pid}`);
+      console.log(`  Port: ${sessionInfo.port}`);
+      console.log(`  Session File: ${sessionInfo.sessionFile}`);
+
+      // Show other active sessions
+      const activeSessions = await findActiveSessions();
+      if (activeSessions.length > 1) {
+        console.log(`  Other active sessions: ${activeSessions.length - 1}`);
+        activeSessions.filter(s => s.sessionId !== sessionInfo.sessionId).forEach(session => {
+          console.log(`    - ${session.sessionId} (PID: ${session.pid}, Port: ${session.port})`);
+        });
+      }
+    }
+
+    // Pass session manager to app
+    app.sessionManager = sessionManager;
+
+    await app.start();
+  } catch (error) {
+    console.error('Fatal error starting Chrome Debug:', error);
+    process.exit(1);
+  }
+}
+
+// Handle graceful shutdown
+process.on('SIGINT', async () => {
+  console.error('Received SIGINT, shutting down gracefully...');
+  process.exit(0);
+});
+
+process.on('SIGTERM', async () => {
+  console.error('Received SIGTERM, shutting down gracefully...');
+  process.exit(0);
+});
+
+// Export for testing
+export { ChromePilotApp };
+
+// Run if this is the main module
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((error) => {
+    console.error('Unhandled error:', error);
+    process.exit(1);
+  });
+}