@dynamicu/chromedebug-mcp 2.6.3 → 2.6.6

package/CLAUDE.md

@@ -23,6 +23,9 @@ npm run server      # Run standalone server
 npm run single-server # Run with --single-server flag
 npm run cleanup     # Clean up stale Chrome processes
 npm run cleanup-force # Force cleanup of all Chrome processes
+
+# Persistent server (won't be killed by other instances)
+chromedebug-mcp --persistent  # Start a persistent server for manual debugging
 ```
 
 ### Testing
@@ -235,8 +238,30 @@ Chrome Debug provides a CLI tool that can be used directly:
 ```bash
 chromedebug-mcp  # Runs the MCP server (equivalent to npm start)
 npx chromedebug-mcp  # Run without global installation
+
+# Persistent server mode
+chromedebug-mcp --persistent  # Won't be killed by other instances
+```
+
+### Persistent Server Mode
+
+The `--persistent` flag marks a server as persistent, preventing it from being killed when other ChromeDebug instances start. This is useful for:
+
+- **Manual debugging servers**: Keep a debug server running while using Claude Code
+- **Multiple projects**: Run persistent servers for different projects simultaneously
+- **Development workflows**: Maintain a stable server instance across multiple Claude Code sessions
+
+Example:
+```bash
+# Terminal 1: Start persistent debug server
+chromedebug-mcp --persistent --verbose
+
+# Terminal 2: Use Claude Code normally
+# Claude's MCP server will NOT kill the persistent server
 ```
 
+See `PERSISTENT-FLAG-README.md` for detailed documentation and examples.
+
 The package name is `chromedebug-mcp` but the project is commonly referred to as Chrome Debug.
 
 ## Additional Architecture Notes

package/chrome-extension/manifest.free.json

@@ -1,15 +1,14 @@
 {
   "manifest_version": 3,
-  "name": "ChromeDebug MCP Assistant FREE v2.6.0",
-  "version": "2.6.0",
-  "description": "ChromeDebug MCP visual element selector [FREE Edition] [Build: 2025-10-24-v2.6.0]",
+  "name": "ChromeDebug MCP Assistant FREE v2.6.1",
+  "version": "2.6.1",
+  "description": "ChromeDebug MCP visual element selector [FREE Edition] [Build: 2025-10-28-v2.6.1]",
   "permissions": [
     "activeTab",
     "scripting",
     "tabs",
     "storage",
     "tabCapture",
-    "desktopCapture",
     "notifications",
     "offscreen"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamicu/chromedebug-mcp",
-  "version": "2.6.3",
+  "version": "2.6.6",
   "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/scripts/webpack.config.free.cjs

@@ -11,7 +11,7 @@ module.exports = {
     options: './chrome-extension/options.js'
   },
   output: {
-    path: path.resolve(__dirname, 'dist/free'),
+    path: path.resolve(__dirname, '../dist/free'),
     filename: '[name].js',
     clean: true
   },

package/scripts/webpack.config.pro.cjs

@@ -12,7 +12,7 @@ module.exports = {
     'pro/frame-editor': './chrome-extension/pro/frame-editor.js'
   },
   output: {
-    path: path.resolve(__dirname, 'dist/pro'),
+    path: path.resolve(__dirname, '../dist/pro'),
     filename: '[name].js',
     clean: true
   },

package/src/cli.js

@@ -81,6 +81,17 @@ For details: https://github.com/dynamicupgrade/ChromeDebug#windows-setup
       verbose: args.verbose
     });
 
+    // Mark as persistent if requested
+    if (args.persistent) {
+      await sessionManager.markAsPersistent();
+      console.error('Session marked as persistent - will not be killed by other instances');
+    }
+
+    // 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/index.js

@@ -152,7 +152,9 @@ class ChromePilotApp {
       sessionId: null,
       noCleanup: false,
       verbose: false,
-      dbPath: null
+      dbPath: null,
+      allowMultiple: false,
+      persistent: false
     };
 
     const argv = process.argv.slice(2);
@@ -191,6 +193,12 @@ class ChromePilotApp {
         case '--verbose':
           args.verbose = true;
           break;
+        case '--allow-multiple':
+          args.allowMultiple = true;
+          break;
+        case '--persistent':
+          args.persistent = true;
+          break;
         case '--help':
           this.showHelp();
           process.exit(0);
@@ -237,6 +245,8 @@ Options:
   --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)
+  --persistent        Mark as persistent server (won't be killed by other instances)
   --help              Show this help message
 
 Session Isolation:

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

@@ -31,7 +31,8 @@ export class UnifiedSessionManager {
       port: null,
       processes: [],
       locks: [],
-      heartbeat: Date.now()
+      heartbeat: Date.now(),
+      persistent: false  // If true, won't be killed by other instances
     };
 
     this.heartbeatInterval = null;
@@ -354,6 +355,18 @@ export class UnifiedSessionManager {
     }
   }
 
+  /**
+   * Mark this session as persistent (won't be killed by other instances)
+   */
+  async markAsPersistent() {
+    this.state.persistent = true;
+    await this.updateSessionFile();
+
+    if (this.verbose) {
+      console.error(`Session ${this.sessionId} marked as persistent`);
+    }
+  }
+
   /**
    * Start heartbeat to keep session alive
    */
@@ -446,6 +459,106 @@ export class UnifiedSessionManager {
     return sessions;
   }
 
+  /**
+   * Kill all other ChromeDebug instances
+   * Uses session files to find PIDs, then kills them gracefully
+   * Skips sessions marked as persistent
+   * @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
+
+      // Skip persistent sessions
+      if (session.persistent) {
+        console.error(`Skipping persistent session: PID ${session.pid} (session ${session.sessionId})`);
+        continue;
+      }
+
+      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 } = require('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
    */