@dynamicu/chromedebug-mcp 2.6.6 → 2.7.0

package/src/database.js

@@ -12,7 +12,7 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // Initialize project manager for path resolution
 const projectManager = new ProjectManager();
 
-class ChromePilotDatabase {
+class ChromeDebugDatabase {
   constructor(options = {}) {
     this.db = null;
     this.initialized = false;
@@ -27,10 +27,54 @@ class ChromePilotDatabase {
 
   /**
    * Gets the centralized database path in user's home directory
+   * Performs atomic migration from old chrome-pilot.db to new chromedebug.db
    * @returns {string} Centralized database file path
    */
   getCentralDbPath() {
-    return path.join(os.homedir(), '.chromedebug', 'chrome-pilot.db');
+    const dbDir = path.join(os.homedir(), '.chromedebug');
+    const newPath = path.join(dbDir, 'chromedebug.db');
+    const oldPath = path.join(dbDir, 'chrome-pilot.db');
+    const lockFile = path.join(dbDir, '.migration.lock');
+
+    // Ensure directory exists
+    if (!fs.existsSync(dbDir)) {
+      fs.mkdirSync(dbDir, { recursive: true });
+    }
+
+    // Check if migration is needed
+    if (fs.existsSync(oldPath) && !fs.existsSync(newPath)) {
+      // Try to acquire lock (simple file-based lock)
+      try {
+        if (!fs.existsSync(lockFile)) {
+          fs.writeFileSync(lockFile, process.pid.toString());
+          logger.info('[Database] Migrating chrome-pilot.db to chromedebug.db');
+          fs.renameSync(oldPath, newPath);
+          fs.unlinkSync(lockFile);
+          logger.info('[Database] Migration complete');
+        } else {
+          // Wait for other process to finish migration
+          let attempts = 0;
+          while (fs.existsSync(lockFile) && attempts < 10) {
+            // Sleep for 100ms (blocking - acceptable for startup migration)
+            const start = Date.now();
+            while (Date.now() - start < 100) { /* busy wait */ }
+            attempts++;
+          }
+          // Clean up stale lock if needed
+          if (fs.existsSync(lockFile) && !fs.existsSync(newPath)) {
+            try { fs.unlinkSync(lockFile); } catch {}
+          }
+        }
+      } catch (error) {
+        logger.error('[Database] Migration failed:', error);
+        // Clean up lock file if we created it
+        if (fs.existsSync(lockFile)) {
+          try { fs.unlinkSync(lockFile); } catch {}
+        }
+      }
+    }
+
+    return newPath;
   }
 
   /**
@@ -1366,11 +1410,12 @@ class ChromePilotDatabase {
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
     `);
     
-    const recordingId = `workflow_${sessionId}`;
+    // sessionId already contains workflow_ prefix from extension, use it directly
+    const recordingId = sessionId;
     const timestamp = Date.now();
-    
+
     stmt.run(
-      recordingId, 
+      recordingId,
       sessionId, 
       name,
       url, 
@@ -1414,6 +1459,8 @@ class ChromePilotDatabase {
           return action[camelCaseName] || action[snakeCaseName] || null;
         };
 
+        const screenshotDataToStore = action.screenshot_data || null;
+
         stmt.run(
           workflowId,
           action.index,
@@ -1425,7 +1472,7 @@ class ChromePilotDatabase {
           action.text || null,
           action.placeholder || null,
           action.timestamp,
-          action.screenshot_data || null,
+          screenshotDataToStore,
           action.component || null,  // For function traces
           action.args ? JSON.stringify(action.args) : null,  // Store args as JSON string
           action.stack || null,  // For function traces
@@ -1436,6 +1483,7 @@ class ChromePilotDatabase {
           safeJsonStringify(getEnhancedFieldData(action, 'elementState', 'element_state'), 2048),   // 2KB limit
           safeJsonStringify(getEnhancedFieldData(action, 'performanceMetrics', 'performance_metrics'), 1024)  // 1KB limit
         );
+
         storedCount++;
       }
 
@@ -1452,6 +1500,7 @@ class ChromePilotDatabase {
     `);
     updateStmt.run(storedCount, workflowId);
 
+    logger.debug('[SCREENSHOT-DEBUG] database.storeWorkflowActions - EXIT');
     return { success: true, storedCount };
   }
 
@@ -1560,7 +1609,7 @@ class ChromePilotDatabase {
         text: action.text,
         placeholder: action.placeholder,
         timestamp: action.timestamp,
-        screenshot_data: action.screenshot_data
+        screenshot: action.screenshot_data  // Map screenshot_data to screenshot for consistency
       };
 
       // Add function trace fields if they exist
@@ -2218,7 +2267,10 @@ class ChromePilotDatabase {
 }
 
 // Export singleton instance (uses default centralized path)
-export const database = new ChromePilotDatabase();
+export const database = new ChromeDebugDatabase();
 
 // Export class for custom instantiation if needed
-export { ChromePilotDatabase };
+export { ChromeDebugDatabase };
+
+// Backward compatibility alias
+export { ChromeDebugDatabase as ChromePilotDatabase };

package/src/http-server.js

@@ -286,18 +286,19 @@ async function startHttpServer(chromeController = null, targetPort = null) {
   });
 
   // Protected workflow recording endpoints
-  app.post('/chromedebug/workflow-recording', 
+  app.post('/chromedebug/workflow-recording',
     authenticate,
     authorize(PERMISSIONS.WORKFLOW_WRITE),
     createValidator(workflowRecordingSchema),
     async (req, res) => {
     const { sessionId, url, title, includeLogs, actions, logs, functionTraces, name, screenshotSettings } = req.body;
+
     logger.info('[HTTP Server] Received workflow recording with name:', name);
     logger.info('[HTTP Server] Function traces count:', functionTraces ? functionTraces.length : 0);
     if (!sessionId || !actions) {
       return res.status(400).json({ error: 'sessionId and actions are required' });
     }
-    
+
     try {
       const result = await activeController.storeWorkflowRecording(sessionId, url, title, includeLogs, actions, logs, name, screenshotSettings, functionTraces);
       res.json(result);

package/src/index.js

@@ -26,7 +26,7 @@ interceptStdout();
 /**
  * Main application class that orchestrates all components
  */
-class ChromePilotApp {
+class ChromeDebugApp {
   constructor() {
     this.chromeController = null;
     this.chromeService = null;
@@ -105,7 +105,7 @@ class ChromePilotApp {
 
     try {
       // Clean up any existing Chrome Debug processes
-      const cleanupResult = await this.processManager.cleanupChromePilotProcesses();
+      const cleanupResult = await this.processManager.cleanupChromeDebugProcesses();
       if (cleanupResult.total > 0) {
         logger.debug(`Cleaned up ${cleanupResult.killed.length} existing processes`);
       }
@@ -242,7 +242,7 @@ Options:
   --watch             Watch for file changes (development mode)
   --debug             Enable debug logging
   --session-id ID     Set custom session ID for resource isolation
-  --db-path PATH      Set custom database file path (default: ~/.chromedebug/chrome-pilot.db)
+  --db-path PATH      Set custom database file path (default: ~/.chromedebug/chromedebug.db)
   --no-cleanup        Skip cleanup of dead processes on startup
   --verbose           Enable verbose logging including session info
   --allow-multiple    Allow multiple ChromeDebug instances (default: kill others on startup)
@@ -255,7 +255,7 @@ Session Isolation:
   without interfering with each other.
 
 Database Location:
-  By default, ChromeDebug uses a centralized database at ~/.chromedebug/chrome-pilot.db
+  By default, ChromeDebug uses a centralized database at ~/.chromedebug/chromedebug.db
   This allows recordings from all projects to be accessible in one place.
   Use --db-path to override, or set CHROMEDEBUG_DB_PATH environment variable.
 
@@ -296,11 +296,14 @@ For more information, see the documentation in CLAUDE.md
 }
 
 // Export for library usage and testing
-export { ChromePilotApp };
+export { ChromeDebugApp };
+
+// Backward compatibility alias
+export { ChromeDebugApp as ChromePilotApp };
 
 // Auto-start when run directly (not imported as a module)
 if (import.meta.url === `file://${process.argv[1]}`) {
-  const app = new ChromePilotApp();
+  const app = new ChromeDebugApp();
 
   // Handle graceful shutdown
   process.on('SIGINT', async () => {

package/src/mcp/server.js

@@ -20,8 +20,8 @@ export class MCPServer {
     
     this.server = new Server(
       {
-        name: 'chrome-pilot',
-        version: '1.0.0',
+        name: 'chromedebug',
+        version: '2.6.7',
       },
       {
         capabilities: {

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

@@ -20,8 +20,35 @@ export const workflowRecordingSchema = Joi.object({
     Joi.object({
       type: Joi.string().required(),
       timestamp: Joi.number().required(),
-      data: Joi.object().optional()
-    })
+      data: Joi.object().optional(),
+      // Screenshot field - base64 encoded image data
+      screenshot_data: Joi.string().max(10485760).optional(), // 10MB max for base64 string
+      // Click/interaction fields
+      selector: Joi.string().optional(),
+      x: Joi.number().optional(),
+      y: Joi.number().optional(),
+      value: Joi.string().allow('').optional(),
+      text: Joi.string().allow('').optional(),
+      placeholder: Joi.string().optional(),
+      index: Joi.number().optional(),
+      // Enhanced click tracking fields
+      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
+      // Function trace fields
+      component: Joi.string().optional(),
+      args: Joi.alternatives().try(Joi.array(), Joi.string()).optional(),
+      stack: Joi.string().optional(),
+      // Attached logs
+      logs: Joi.array().optional()
+    }).unknown(true) // Allow additional fields for future extensibility
   ).required(),
   logs: Joi.array().items(
     Joi.object({
@@ -42,10 +69,13 @@ export const workflowRecordingSchema = Joi.object({
   ).optional(),
   name: Joi.any().optional(),
   screenshotSettings: Joi.object({
-    width: Joi.number().integer().min(100).max(4000).optional(),
-    height: Joi.number().integer().min(100).max(4000).optional(),
-    quality: Joi.number().min(10).max(100).optional()
-  }).optional()
+    width: Joi.number().integer().min(100).max(4000).optional().allow(null),
+    height: Joi.number().integer().min(100).max(4000).optional().allow(null),
+    quality: Joi.number().min(10).max(100).optional().allow(null),
+    format: Joi.string().valid('png', 'jpeg').optional().allow(null),
+    enabled: Joi.boolean().optional().allow(null),
+    maxWidth: Joi.number().integer().optional().allow(null)
+  }).optional().allow(null)
 });
 
 // Frame batch schema

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);
-});