@dynamicu/chromedebug-mcp 2.2.0

package/src/index-direct.js

@@ -0,0 +1,157 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { 
+  ListToolsRequestSchema,
+  CallToolRequestSchema
+} from '@modelcontextprotocol/sdk/types.js';
+import { ChromeController } from './chrome-controller.js';
+
+// Create a single Chrome controller instance for this MCP server
+const chromeController = new ChromeController();
+
+const server = new Server(
+  {
+    name: 'chrome-pilot',
+    version: '1.0.0',
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+const tools = [
+  {
+    name: 'launch_chrome',
+    description: 'Launch a Chrome browser instance for this MCP server',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+    },
+  },
+  {
+    name: 'get_chrome_info',
+    description: 'Get Chrome debugging port and connection info for extensions',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+    },
+  },
+  {
+    name: 'connect_to_existing_chrome',
+    description: 'Connect to an existing Chrome instance with debugging enabled',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        port: {
+          type: 'number',
+          description: 'Debugging port Chrome is running on (default: 9222)',
+          default: 9222,
+        },
+      },
+    },
+  },
+  // ... other tools remain the same
+];
+
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return { tools };
+});
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    switch (name) {
+      case 'launch_chrome': {
+        const result = await chromeController.launch();
+        
+        // Write Chrome info to a known location for the extension
+        const chromeInfo = {
+          debugPort: result.debugPort,
+          wsEndpoint: result.browserWSEndpoint,
+          timestamp: new Date().toISOString()
+        };
+        
+        // The extension can read this file or connect directly to debugPort
+        await fs.writeFile(
+          '/tmp/chrome-pilot-current.json',
+          JSON.stringify(chromeInfo, null, 2)
+        );
+        
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Chrome launched on debugging port ${result.debugPort}\n\n` +
+                   `The Chrome extension can now connect directly to:\n` +
+                   `http://localhost:${result.debugPort}\n\n` +
+                   JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      }
+      
+      case 'get_chrome_info': {
+        const status = await chromeController.getConnectionStatus();
+        if (!status.connected) {
+          return {
+            content: [
+              {
+                type: 'text',
+                text: 'Chrome is not connected. Launch Chrome first using launch_chrome.',
+              },
+            ],
+          };
+        }
+        
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Chrome debugging info:\n` +
+                   `Port: ${status.debugPort}\n` +
+                   `WebSocket: ${status.browserWSEndpoint}\n\n` +
+                   `Extensions can connect to: http://localhost:${status.debugPort}`,
+            },
+          ],
+        };
+      }
+      
+      // ... rest of the cases
+    }
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Error: ${error.message}`,
+        },
+      ],
+      isError: true,
+    };
+  }
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('Chrome Debug MCP server running (direct mode - no Express)');
+}
+
+// Clean shutdown
+process.on('SIGINT', async () => {
+  await chromeController.close();
+  process.exit(0);
+});
+
+process.on('SIGTERM', async () => {
+  await chromeController.close();
+  process.exit(0);
+});
+
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/src/index-modular.js

@@ -0,0 +1,219 @@
+/**
+ * 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';
+
+/**
+ * Main application class that orchestrates all components
+ */
+class ChromePilotApp {
+  constructor() {
+    this.chromeController = null;
+    this.chromeService = null;
+    this.mcpServer = null;
+    this.processManager = 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);
+      
+      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
+    };
+
+    for (const arg of process.argv.slice(2)) {
+      switch (arg) {
+        case '--single-server':
+          args.singleServer = true;
+          break;
+        case '--watch':
+          args.watch = true;
+          break;
+        case '--debug':
+          args.debug = true;
+          break;
+        case '--help':
+          this.showHelp();
+          process.exit(0);
+          break;
+      }
+    }
+
+    return args;
+  }
+
+  /**
+   * Shows help information
+   */
+  showHelp() {
+    console.log(`
+Chrome Debug MCP Server - Modular Architecture
+
+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
+  --help           Show this help message
+
+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();
+  
+  try {
+    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);
+  });
+}