@dynamicu/chromedebug-mcp 2.6.2 → 2.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamicu/chromedebug-mcp",
-  "version": "2.6.2",
+  "version": "2.6.3",
   "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(`

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,8 @@ class ChromePilotApp {
       debug: false,
       sessionId: null,
       noCleanup: false,
-      verbose: false
+      verbose: false,
+      dbPath: null
     };
 
     const argv = process.argv.slice(2);
@@ -169,6 +177,14 @@ 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;
@@ -182,6 +198,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,6 +234,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)
   --no-cleanup        Skip cleanup of dead processes on startup
   --verbose           Enable verbose logging including session info
   --help              Show this help message
@@ -225,13 +244,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
     `);