@dynamicu/chromedebug-mcp 2.6.7 → 2.7.1

package/src/services/process-manager.js

@@ -62,7 +62,7 @@ async function safeKillProcess(pid, signal = 'SIGTERM') {
  * Process cleanup is skipped on Windows to allow the server to start. A proper cross-platform
  * solution will be implemented in a future update.
  */
-async function findChromePilotProcesses() {
+async function findChromeDebugProcesses() {
   // Skip process cleanup on Windows - ps command doesn't exist
   // This allows the server to start on Windows without crashing
   // TODO: Implement proper Windows process management using tasklist or Node.js process handles
@@ -107,6 +107,7 @@ async function findChromePilotProcesses() {
           if (!pid || pid === currentPid) continue;
           
           // Check if it's a ChromeDebug MCP related process
+          // Look for both new and old process names for backward compatibility
           let processType = '';
           if (line.includes('src/index.js')) {
             processType = 'MCP server';
@@ -117,7 +118,7 @@ async function findChromePilotProcesses() {
           } else if (line.includes('http-server.js')) {
             processType = 'HTTP server';
             pidsToKill.push(pid);
-          } else if (line.includes('chrome-pilot') && line.includes('node')) {
+          } else if ((line.includes('chromedebug') || line.includes('chrome-pilot') || line.includes('ChromePilot')) && line.includes('node')) {
             processType = 'ChromeDebug MCP process';
             pidsToKill.push(pid);
           }
@@ -221,8 +222,8 @@ export class ProcessManager {
    * Finds and kills ChromeDebug MCP processes
    * @returns {Promise<Object>} Cleanup results
    */
-  async cleanupChromePilotProcesses() {
-    const { pidsToKill, processDescriptions } = await findChromePilotProcesses();
+  async cleanupChromeDebugProcesses() {
+    const { pidsToKill, processDescriptions } = await findChromeDebugProcesses();
     
     const results = {
       found: processDescriptions,
@@ -326,5 +327,8 @@ export class ProcessManager {
   }
 }
 
-// Export utility functions for backward compatibility
-export { validateProcessId, safeKillProcess, findChromePilotProcesses };
+// Export utility functions
+export { validateProcessId, safeKillProcess, findChromeDebugProcesses };
+
+// Backward compatibility aliases
+export { findChromeDebugProcesses as findChromePilotProcesses };

package/src/services/process-tracker.js

@@ -306,7 +306,7 @@ export async function killAllRegisteredProcesses() {
  * Find ChromeDebug processes using pattern matching (for untracked processes)
  * This is a fallback for processes started before tracking was implemented
  */
-export async function findUntrackedChromePilotProcesses() {
+export async function findUntrackedChromeDebugProcesses() {
   const currentPid = process.pid;
   const foundProcesses = [];
 
@@ -342,6 +342,7 @@ export async function findUntrackedChromePilotProcesses() {
           if (registeredPids.has(pid)) continue;
 
           // Check if it's a ChromeDebug/ChromePilot process
+          // Look for both new and old process names for backward compatibility
           let processType = '';
           if (line.includes('src/index.js')) {
             processType = 'untracked-mcp-server';
@@ -349,7 +350,7 @@ export async function findUntrackedChromePilotProcesses() {
             processType = 'untracked-http-server';
           } else if (line.includes('standalone-server.js')) {
             processType = 'untracked-standalone-server';
-          } else if (line.includes('chromedebug-mcp') && line.includes('node')) {
+          } else if ((line.includes('chromedebug-mcp') || line.includes('chrome-pilot') || line.includes('ChromePilot')) && line.includes('node')) {
             processType = 'untracked-chromedebug-process';
           }
 
@@ -380,8 +381,8 @@ export async function findUntrackedChromePilotProcesses() {
 /**
  * Kill untracked ChromeDebug processes (emergency cleanup)
  */
-export async function killUntrackedChromePilotProcesses() {
-  const untrackedProcesses = await findUntrackedChromePilotProcesses();
+export async function killUntrackedChromeDebugProcesses() {
+  const untrackedProcesses = await findUntrackedChromeDebugProcesses();
   const results = {
     found: untrackedProcesses,
     killed: [],
@@ -571,4 +572,8 @@ export async function cleanupCurrentSession() {
   }
 
   return results;
-}
+}
+
+// Backward compatibility aliases
+export { findUntrackedChromeDebugProcesses as findUntrackedChromePilotProcesses };
+export { killUntrackedChromeDebugProcesses as killUntrackedChromePilotProcesses };

package/src/services/profile-manager.js

@@ -13,14 +13,29 @@
  * - Profile lifecycle management with proper resource tracking
  */
 
-import { promises as fs } from 'fs';
+import { promises as fs, existsSync } from 'fs';
 import path from 'path';
 import os from 'os';
 import { randomUUID } from 'crypto';
 
 export class ProfileManager {
   constructor(options = {}) {
-    this.profilesDir = options.profilesDir || path.join(os.tmpdir(), 'chrome-pilot-profiles');
+    // Use new directory name, but check old directory for migration
+    const defaultDir = path.join(os.tmpdir(), 'chromedebug-profiles');
+    const oldDir = path.join(os.tmpdir(), 'chrome-pilot-profiles');
+
+    // If old directory exists and new doesn't, use old directory for compatibility
+    let profilesDir = defaultDir;
+    try {
+      if (!options.profilesDir && existsSync(oldDir) && !existsSync(defaultDir)) {
+        profilesDir = oldDir;
+        console.error(`[ProfileManager] Using existing chrome-pilot-profiles directory for backward compatibility`);
+      }
+    } catch (error) {
+      // Ignore errors, use default
+    }
+
+    this.profilesDir = options.profilesDir || profilesDir;
     this.activeProfiles = new Map(); // sessionId -> { profilePath, claudeInstanceId, createdAt, size }
     this.initialized = false;
 

package/src/validation/schemas.js

@@ -27,21 +27,22 @@ export const workflowRecordingSchema = Joi.object({
       selector: Joi.string().optional(),
       x: Joi.number().optional(),
       y: Joi.number().optional(),
-      value: Joi.string().optional(),
-      text: Joi.string().optional(),
+      value: Joi.string().allow('').optional(),
+      text: Joi.string().allow('').optional(),
       placeholder: Joi.string().optional(),
       index: Joi.number().optional(),
-      // Enhanced click tracking fields
+      // Enhanced click tracking fields - accept both strings and objects for flexibility
+      // (matches screenInteractionsSchema pattern - extension sends objects, database handles serialization)
       element_html: Joi.string().max(10240).optional(),
       elementHTML: Joi.string().max(10240).optional(), // camelCase variant
-      component_data: Joi.string().max(3072).optional(),
-      componentData: Joi.string().max(3072).optional(), // camelCase variant
-      event_handlers: Joi.string().max(2048).optional(),
-      eventHandlers: Joi.string().max(2048).optional(), // camelCase variant
-      element_state: Joi.string().max(2048).optional(),
-      elementState: Joi.string().max(2048).optional(), // camelCase variant
-      performance_metrics: Joi.string().max(1024).optional(),
-      performanceMetrics: Joi.string().max(1024).optional(), // camelCase variant
+      component_data: Joi.alternatives().try(Joi.string().max(3072), Joi.object()).optional(),
+      componentData: Joi.alternatives().try(Joi.string().max(3072), Joi.object()).optional(), // camelCase variant
+      event_handlers: Joi.alternatives().try(Joi.string().max(2048), Joi.object()).optional(),
+      eventHandlers: Joi.alternatives().try(Joi.string().max(2048), Joi.object()).optional(), // camelCase variant
+      element_state: Joi.alternatives().try(Joi.string().max(2048), Joi.object()).optional(),
+      elementState: Joi.alternatives().try(Joi.string().max(2048), Joi.object()).optional(), // camelCase variant
+      performance_metrics: Joi.alternatives().try(Joi.string().max(1024), Joi.object()).optional(),
+      performanceMetrics: Joi.alternatives().try(Joi.string().max(1024), Joi.object()).optional(), // camelCase variant
       // Function trace fields
       component: Joi.string().optional(),
       args: Joi.alternatives().try(Joi.array(), Joi.string()).optional(),

package/src/index-direct.js

@@ -1,157 +0,0 @@
-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

@@ -1,219 +0,0 @@
-/**
- * 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.error(`
-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);
-  });
-}