@dynamicu/chromedebug-mcp 2.6.2 → 2.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamicu/chromedebug-mcp",
-  "version": "2.6.2",
+  "version": "2.6.4",
   "description": "ChromeDebug MCP - MCP server that provides full control over a Chrome browser instance for debugging and automation with AI assistants like Claude Code",
   "main": "src/index.js",
   "type": "module",

package/src/cli.js

@@ -38,6 +38,13 @@ async function main() {
   // Parse arguments first to get session settings
   const args = app.parseArguments();
 
+  // Set database path environment variable if provided via CLI
+  // This ensures the database singleton uses the correct path BEFORE initialization
+  if (args.dbPath) {
+    process.env.CHROMEDEBUG_DB_PATH = args.dbPath;
+    logger.debug(`[CLI] Database path set: ${args.dbPath}`);
+  }
+
   // Detect Windows and provide WSL2 guidance
   if (process.platform === 'win32' && !process.env.WSL_DISTRO_NAME && !process.env.CHROMEDEBUG_FORCE_WINDOWS) {
     console.error(`
@@ -74,6 +81,11 @@ For details: https://github.com/dynamicupgrade/ChromeDebug#windows-setup
       verbose: args.verbose
     });
 
+    // Kill other instances unless --allow-multiple is set
+    if (!args.allowMultiple) {
+      await sessionManager.killOtherInstances();
+    }
+
     // Register this process for tracking
     await registerProcess(process.pid, 'mcp-server');
 

package/src/database.js

@@ -3,6 +3,7 @@ import Database from 'better-sqlite3';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import fs from 'fs';
+import os from 'os';
 import { ProjectManager } from './services/project-manager.js';
 import logger from './utils/logger.js';
 
@@ -11,49 +12,90 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // Initialize project manager for path resolution
 const projectManager = new ProjectManager();
 
-/**
- * Gets the appropriate database path (always use global chromedebug.db)
- * @returns {string} Database file path
- */
-function getDatabasePath() {
-  // Always use global database for cross-project accessibility
-  const globalDbPath = path.join(__dirname, '../data/chromedebug.db');
-  
-  // Ensure data directory exists
-  const dbDir = path.dirname(globalDbPath);
-  if (!fs.existsSync(dbDir)) {
-    fs.mkdirSync(dbDir, { recursive: true });
-  }
-  
-  logger.debug(`[Database] Using global database: ${globalDbPath}`);
-  return globalDbPath;
-}
-
-// Get the database path (project-local or global)
-const DB_PATH = getDatabasePath();
-
 class ChromePilotDatabase {
-  constructor() {
+  constructor(options = {}) {
     this.db = null;
     this.initialized = false;
+
+    // Priority: options.dbPath > env var > centralized default
+    this.dbPath = options.dbPath ||
+                  process.env.CHROMEDEBUG_DB_PATH ||
+                  this.getCentralDbPath();
+
+    logger.debug(`[Database] Using database path: ${this.dbPath}`);
+  }
+
+  /**
+   * Gets the centralized database path in user's home directory
+   * @returns {string} Centralized database file path
+   */
+  getCentralDbPath() {
+    return path.join(os.homedir(), '.chromedebug', 'chrome-pilot.db');
+  }
+
+  /**
+   * Ensures the database directory exists with proper permissions
+   */
+  ensureDbDirectory() {
+    const dir = path.dirname(this.dbPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+      logger.debug(`[Database] Created database directory: ${dir}`);
+    }
+  }
+
+  /**
+   * Migrates from old project-local database to centralized database
+   * Only runs if:
+   * 1. We're using the central DB location (not a custom path)
+   * 2. Old project DB exists
+   * 3. Central DB doesn't exist yet
+   */
+  migrateIfNeeded() {
+    const projectDb = path.join(__dirname, '../data/chrome-pilot.db');
+    const usingCentralDb = this.dbPath === this.getCentralDbPath();
+
+    // Only migrate if using centralized path, project DB exists, and central doesn't
+    if (usingCentralDb && fs.existsSync(projectDb) && !fs.existsSync(this.dbPath)) {
+      logger.info(`[Database] Migrating database from ${projectDb} to ${this.dbPath}`);
+
+      try {
+        // Ensure central directory exists
+        this.ensureDbDirectory();
+
+        // Copy the database file
+        fs.copyFileSync(projectDb, this.dbPath);
+
+        logger.info('[Database] Migration complete. Old database preserved at original location.');
+        logger.info('[Database] All future recordings will be stored in the centralized database.');
+      } catch (error) {
+        logger.error(`[Database] Migration failed: ${error.message}`);
+        logger.error('[Database] Will create new database at centralized location.');
+      }
+    } else if (usingCentralDb && fs.existsSync(this.dbPath)) {
+      logger.debug('[Database] Using existing centralized database');
+    } else if (!usingCentralDb) {
+      logger.debug(`[Database] Using custom database path: ${this.dbPath}`);
+    }
   }
 
   init() {
     if (this.initialized) return;
-    
-    // Ensure data directory exists
-    const dataDir = path.dirname(DB_PATH);
-    if (!fs.existsSync(dataDir)) {
-      fs.mkdirSync(dataDir, { recursive: true });
-    }
-    
-    this.db = new Database(DB_PATH);
+
+    // Ensure database directory exists
+    this.ensureDbDirectory();
+
+    // Migrate from old location if needed
+    this.migrateIfNeeded();
+
+    // Open database connection
+    this.db = new Database(this.dbPath);
     this.db.pragma('journal_mode = WAL'); // Enable WAL mode for better concurrent access
-    
+
     // Create tables
     this.createTables();
     this.initialized = true;
-    logger.debug(`ChromeDebug MCP database initialized at: ${DB_PATH}`);
+    logger.debug(`ChromeDebug MCP database initialized at: ${this.dbPath}`);
   }
 
   createTables() {
@@ -1300,16 +1342,16 @@ class ChromePilotDatabase {
   // Get database stats
   getStats() {
     this.init();
-    
+
     const recordingsCount = this.db.prepare(`SELECT COUNT(*) as count FROM recordings`).get().count;
     const framesCount = this.db.prepare(`SELECT COUNT(*) as count FROM frames`).get().count;
     const logsCount = this.db.prepare(`SELECT COUNT(*) as count FROM console_logs`).get().count;
-    
+
     return {
       recordings: recordingsCount,
       frames: framesCount,
       logs: logsCount,
-      dbPath: DB_PATH
+      dbPath: this.dbPath
     };
   }
 
@@ -2175,5 +2217,8 @@ class ChromePilotDatabase {
   }
 }
 
-// Export singleton instance
-export const database = new ChromePilotDatabase();
+// Export singleton instance (uses default centralized path)
+export const database = new ChromePilotDatabase();
+
+// Export class for custom instantiation if needed
+export { ChromePilotDatabase };

package/src/index.js

@@ -46,6 +46,13 @@ class ChromePilotApp {
       const args = this.parseArguments();
       const finalOptions = { ...options, ...args };
 
+      // Set database path environment variable if provided via CLI
+      // This ensures the database singleton uses the correct path
+      if (finalOptions.dbPath) {
+        process.env.CHROMEDEBUG_DB_PATH = finalOptions.dbPath;
+        logger.debug(`[App] Database path set via CLI: ${finalOptions.dbPath}`);
+      }
+
       // Create Chrome controller instance
       this.chromeController = new ChromeController();
 
@@ -144,7 +151,9 @@ class ChromePilotApp {
       debug: false,
       sessionId: null,
       noCleanup: false,
-      verbose: false
+      verbose: false,
+      dbPath: null,
+      allowMultiple: false
     };
 
     const argv = process.argv.slice(2);
@@ -169,12 +178,23 @@ class ChromePilotApp {
             process.exit(1);
           }
           break;
+        case '--db-path':
+          if (i + 1 < argv.length) {
+            args.dbPath = argv[++i];
+          } else {
+            logger.error('--db-path requires a value');
+            process.exit(1);
+          }
+          break;
         case '--no-cleanup':
           args.noCleanup = true;
           break;
         case '--verbose':
           args.verbose = true;
           break;
+        case '--allow-multiple':
+          args.allowMultiple = true;
+          break;
         case '--help':
           this.showHelp();
           process.exit(0);
@@ -182,6 +202,8 @@ class ChromePilotApp {
         default:
           if (arg.startsWith('--session-id=')) {
             args.sessionId = arg.split('=')[1];
+          } else if (arg.startsWith('--db-path=')) {
+            args.dbPath = arg.split('=')[1];
           } else if (arg.startsWith('--')) {
             logger.error(`Unknown argument: ${arg}`);
             this.showHelp();
@@ -216,8 +238,10 @@ 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)
   --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)
   --help              Show this help message
 
 Session Isolation:
@@ -225,13 +249,20 @@ Session Isolation:
   This allows multiple Chrome Debug MCP instances to run simultaneously
   without interfering with each other.
 
+Database Location:
+  By default, ChromeDebug uses a centralized database at ~/.chromedebug/chrome-pilot.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.
+
 Examples:
   node src/index.js --session-id claude-session-1 --verbose
   node src/index.js --no-cleanup --debug
+  node src/index.js --db-path /custom/path/to/database.db
 
 Environment Variables:
-  NODE_ENV            Set to 'development' for debug mode
-  CHROME_PILOT_PORT   Configure HTTP server port
+  NODE_ENV                Set to 'development' for debug mode
+  CHROME_PILOT_PORT       Configure HTTP server port
+  CHROMEDEBUG_DB_PATH     Set custom database file path
 
 For more information, see the documentation in CLAUDE.md
     `);

package/src/services/unified-session-manager.js

@@ -446,6 +446,99 @@ export class UnifiedSessionManager {
     return sessions;
   }
 
+  /**
+   * Kill all other ChromeDebug instances
+   * Uses session files to find PIDs, then kills them gracefully
+   * @returns {Array} Array of killed PIDs
+   */
+  async killOtherInstances() {
+    const sessions = await UnifiedSessionManager.findActiveSessions();
+    const currentPid = process.pid;
+    const killedPids = [];
+
+    for (const session of sessions) {
+      if (session.pid === currentPid) continue; // Don't kill ourselves
+
+      try {
+        // Check if process exists
+        process.kill(session.pid, 0); // Signal 0 = check existence
+
+        // Verify this is actually a ChromeDebug process
+        const isChromeDebug = await this.isChromeDebugProcess(session.pid);
+        if (!isChromeDebug) {
+          console.error(`Skipping PID ${session.pid} - not a ChromeDebug process`);
+          continue;
+        }
+
+        console.error(`Killing ChromeDebug instance: PID ${session.pid} (session ${session.sessionId})`);
+
+        // Send SIGTERM for graceful shutdown
+        process.kill(session.pid, 'SIGTERM');
+        killedPids.push(session.pid);
+
+        // Wait 2 seconds, then SIGKILL if still alive
+        setTimeout(() => {
+          try {
+            process.kill(session.pid, 0); // Check if still alive
+            console.error(`  Process ${session.pid} didn't terminate, sending SIGKILL`);
+            process.kill(session.pid, 'SIGKILL');
+          } catch (err) {
+            // Process already dead, good
+          }
+        }, 2000);
+
+        // Clean up session file
+        const sessionFile = path.join(this.sessionDir, `${session.sessionId}.json`);
+        try {
+          await fs.promises.unlink(sessionFile);
+        } catch (err) {
+          // Ignore errors
+        }
+
+      } catch (error) {
+        if (error.code === 'ESRCH') {
+          // Process doesn't exist, just clean up the session file
+          const sessionFile = path.join(this.sessionDir, `${session.sessionId}.json`);
+          try {
+            await fs.promises.unlink(sessionFile);
+          } catch (err) {
+            // Ignore errors
+          }
+        }
+        // Ignore other errors (permission denied, etc.)
+      }
+    }
+
+    if (killedPids.length > 0) {
+      console.error(`Killed ${killedPids.length} other ChromeDebug instance(s)`);
+    }
+
+    return killedPids;
+  }
+
+  /**
+   * Verify if a PID belongs to a ChromeDebug process
+   * @param {number} pid - Process ID to check
+   * @returns {boolean} True if it's a ChromeDebug process
+   */
+  async isChromeDebugProcess(pid) {
+    try {
+      const { execSync } = await import('child_process');
+
+      // Get process command line
+      const cmd = execSync(`ps -p ${pid} -o command=`, { encoding: 'utf8' }).trim();
+
+      // Check if it's a ChromeDebug process (node running chromedebug or chrome-pilot)
+      return cmd.includes('chromedebug') ||
+             cmd.includes('chrome-pilot') ||
+             cmd.includes('ChromePilot') ||
+             cmd.includes('ChromeDebug');
+    } catch (error) {
+      // If we can't determine, be safe and don't kill
+      return false;
+    }
+  }
+
   /**
    * Clean up stale sessions
    */