browser-ipc-cdp 1.8.3 → 2.0.0

package/brave_ipc.py

@@ -539,11 +539,18 @@ def launch_browser_ipc(
             print()
             return result
         else:
-            # Navegador corriendo pero SIN CDP → hay que reiniciar
-            print(f"        CDP no detectado. Reiniciando {browser_name} con CDP...")
+            # Navegador corriendo pero SIN CDP
             if kill_existing:
+                print(f"        CDP no detectado. Reiniciando {browser_name} con CDP...")
                 kill_browser(browser_exe)
                 time.sleep(2)
+            else:
+                # --no-kill activo. No podemos reusar user-data-dir real (lock).
+                # Forzar perfil separado para evitar conflicto.
+                print(f"        CDP no detectado. --no-kill activo: lanzando 2da")
+                print(f"        instancia en perfil separado (no toca tu sesion).")
+                clean = True
+                USER_DATA_DIR = CLEAN_USER_DATA
     elif kill_existing:
         print(f"        {browser_name} no esta corriendo.")
 

package/brave_mcp_launcher.js

@@ -1,111 +1,77 @@
 /**
- * Brave MCP Dynamic Launcher
+ * Brave MCP Launcher (refactored)
  *
- * Resuelve dinamicamente el puerto CDP (Brave/Chrome/Edge) y lanza
- * chrome-devtools-mcp apuntando al puerto correcto. Si CDP no responde,
- * lanza brave_ipc.py automaticamente para iniciar el navegador.
+ * Resuelve el puerto CDP de Brave/Chrome/Edge y arranca chrome-devtools-mcp.
  *
- * Uso en .mcp.json:
- *   {
- *     "mcpServers": {
- *       "brave": {
- *         "command": "node",
- *         "args": ["C:\\Users\\NyGsoft\\Desktop\\ipc\\brave_mcp_launcher.js"]
- *       }
- *     }
- *   }
+ * Estrategia (rápida → lenta):
+ *   1. Leer DevToolsActivePort de cada User Data dir conocido (instantáneo, autoritativo).
+ *   2. Auto-discovery via tasklist + netstat (fallback si no hay archivo o stale).
+ *   3. Auto-launch via brave_ipc.py --no-kill (último recurso).
  *
- * Flujo:
- *   1. Lee cdp_info.json -> puerto candidato
- *   2. Verifica CDP (/json/version) en hostIP:puerto
- *   3. Si responde -> lanza chrome-devtools-mcp con ese URL
- *   4. Si stale -> auto-discovery via tasklist+netstat de procesos Chromium
- *   5. Si encuentra port vivo -> reescribe cdp_info.json y conecta
- *   6. Ultimo recurso -> brave_ipc.py --no-kill (auto-launch)
+ * Usa binario global de chrome-devtools-mcp (sin npx cold cache).
  */
+
 const { execSync, spawn, spawnSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const http = require('http');
 
-const CDP_INFO = path.join(__dirname, 'cdp_info.json');
-const HOME_CDP_INFO = path.join(process.env.USERPROFILE || process.env.HOME || '.', 'cdp_info.json');
-const BRAVE_IPC_PY = path.join(__dirname, 'brave_ipc.py');
+const HERE = __dirname;
+const CDP_INFO = path.join(HERE, 'cdp_info.json');
+const BRAVE_IPC_PY = path.join(HERE, 'brave_ipc.py');
 
 const IS_WIN = process.platform === 'win32';
 let IS_WSL = false;
 try {
   const v = fs.readFileSync('/proc/version', 'utf-8').toLowerCase();
   IS_WSL = v.includes('microsoft') || v.includes('wsl');
-} catch (e) {}
-
-function logErr(msg) {
-  process.stderr.write(`[brave-mcp] ${msg}\n`);
-}
+} catch {}
 
-function readCdpInfo() {
-  for (const p of [CDP_INFO, HOME_CDP_INFO]) {
-    if (fs.existsSync(p)) {
-      try { return JSON.parse(fs.readFileSync(p, 'utf-8')); } catch (e) {}
-    }
-  }
-  return null;
-}
+const HOME = process.env.USERPROFILE || process.env.HOME || '';
+const LOCALAPPDATA = process.env.LOCALAPPDATA || path.join(HOME, 'AppData', 'Local');
 
-function getHostCandidates() {
-  if (IS_WIN) return ['127.0.0.1'];
+const USER_DATA_DIRS = [
+  { name: 'brave',    path: path.join(LOCALAPPDATA, 'BraveSoftware', 'Brave-Browser', 'User Data') },
+  { name: 'chrome',   path: path.join(LOCALAPPDATA, 'Google', 'Chrome', 'User Data') },
+  { name: 'edge',     path: path.join(LOCALAPPDATA, 'Microsoft', 'Edge', 'User Data') },
+  { name: 'chromium', path: path.join(LOCALAPPDATA, 'Chromium', 'User Data') },
+];
 
-  const seen = new Set();
-  const candidates = [];
-  const add = (ip) => { if (ip && !seen.has(ip)) { seen.add(ip); candidates.push(ip); } };
-
-  // 1. Gateway IP via /proc/net/route — IP real del host Windows en WSL2 NAT
+function resolveChromeDevtoolsMcpBin() {
   try {
-    const route = fs.readFileSync('/proc/net/route', 'utf-8');
-    for (const line of route.split('\n').slice(1)) {
-      const parts = line.split(/\s+/);
-      if (parts[1] === '00000000' && parts[2] && parts[2] !== '00000000') {
-        const hex = parts[2];
-        add([
-          parseInt(hex.slice(6, 8), 16),
-          parseInt(hex.slice(4, 6), 16),
-          parseInt(hex.slice(2, 4), 16),
-          parseInt(hex.slice(0, 2), 16),
-        ].join('.'));
-        break;
-      }
-    }
-  } catch (e) {}
-
-  // 2. Localhost (WSL2 mirrored networking mode)
-  add('127.0.0.1');
-
-  // 3. Nameservers de /etc/resolv.conf (último recurso)
-  try {
-    const resolv = fs.readFileSync('/etc/resolv.conf', 'utf-8');
-    const re = /nameserver\s+(\d+\.\d+\.\d+\.\d+)/g;
-    let m;
-    while ((m = re.exec(resolv))) add(m[1]);
-  } catch (e) {}
+    return require.resolve('chrome-devtools-mcp/build/src/bin/chrome-devtools-mcp.js');
+  } catch {}
+  const candidates = [
+    path.join('C:', 'nvm4w', 'nodejs', 'node_modules', 'chrome-devtools-mcp', 'build', 'src', 'bin', 'chrome-devtools-mcp.js'),
+    path.join(process.env.APPDATA || '', 'npm', 'node_modules', 'chrome-devtools-mcp', 'build', 'src', 'bin', 'chrome-devtools-mcp.js'),
+    path.join('/usr', 'local', 'lib', 'node_modules', 'chrome-devtools-mcp', 'build', 'src', 'bin', 'chrome-devtools-mcp.js'),
+  ];
+  for (const p of candidates) { if (p && fs.existsSync(p)) return p; }
+  return null;
+}
+const CHROME_DEVTOOLS_MCP_BIN = resolveChromeDevtoolsMcpBin();
 
-  return candidates;
+function log(msg) {
+  process.stderr.write(`[brave-mcp] ${msg}\n`);
 }
 
-async function tryCandidates(port, candidates, timeoutMs) {
-  for (const host of candidates) {
-    const url = `http://${host}:${port}`;
-    if (await testCdp(url, timeoutMs)) return url;
-  }
-  return null;
+function readJsonSafe(p) {
+  try { return JSON.parse(fs.readFileSync(p, 'utf-8')); } catch { return null; }
 }
 
-function testCdp(url, timeoutMs = 3000) {
+function testCdp(url, timeoutMs = 1500) {
   return new Promise((resolve) => {
     const req = http.get(`${url}/json/version`, { timeout: timeoutMs }, (res) => {
+      if (res.statusCode !== 200) { res.resume(); return resolve(null); }
       let data = '';
       res.on('data', c => data += c);
       res.on('end', () => {
-        try { resolve(JSON.parse(data)); } catch (e) { resolve(null); }
+        try {
+          const json = JSON.parse(data);
+          if (json && typeof json.webSocketDebuggerUrl === 'string' && json.webSocketDebuggerUrl) {
+            resolve(json);
+          } else { resolve(null); }
+        } catch { resolve(null); }
       });
     });
     req.on('error', () => resolve(null));
@@ -113,16 +79,33 @@ function testCdp(url, timeoutMs = 3000) {
   });
 }
 
-/**
- * Descubre el puerto CDP real de cualquier proceso Chromium activo.
- * Usa tasklist (PIDs por imagen) + netstat (LISTENING por PID) y
- * prueba /json/version en cada candidato.
- *
- * Retorna { port, version } si encuentra uno vivo, o null.
- */
-async function discoverBrowserCdp() {
-  if (!IS_WIN) return null;
+function readDevToolsActivePort(userDataDir) {
+  const file = path.join(userDataDir, 'DevToolsActivePort');
+  if (!fs.existsSync(file)) return null;
+  try {
+    const txt = fs.readFileSync(file, 'utf-8');
+    const lines = txt.split(/\r?\n/);
+    const port = parseInt(lines[0], 10);
+    if (Number.isFinite(port) && port > 0) return port;
+  } catch {}
+  return null;
+}
+
+async function tryDevToolsActivePort() {
+  for (const ud of USER_DATA_DIRS) {
+    const port = readDevToolsActivePort(ud.path);
+    if (!port) continue;
+    const version = await testCdp(`http://127.0.0.1:${port}`, 1500);
+    if (version) {
+      log(`DevToolsActivePort hit: ${ud.name} -> :${port}`);
+      return { port, version };
+    }
+  }
+  return null;
+}
 
+async function discoverViaNetstat() {
+  if (!IS_WIN) return null;
   const images = ['brave.exe', 'chrome.exe', 'msedge.exe', 'chromium.exe'];
   const pids = new Set();
 
@@ -139,21 +122,21 @@ async function discoverBrowserCdp() {
           if (Number.isFinite(pid) && pid > 0) pids.add(pid);
         }
       }
-    } catch (e) {}
+    } catch {}
   }
 
   if (pids.size === 0) {
-    logErr('Auto-discovery: ningun proceso Chromium corriendo');
+    log('Discovery: no Chromium processes');
     return null;
   }
 
-  let netstatOut = '';
+  let netstatOut;
   try {
     netstatOut = execSync('netstat -ano', {
       encoding: 'utf-8', timeout: 20000, maxBuffer: 64 * 1024 * 1024, stdio: ['ignore', 'pipe', 'ignore'],
     });
   } catch (e) {
-    logErr(`Auto-discovery netstat fallo: ${e.message}`);
+    log(`Discovery netstat failed: ${e.message}`);
     return null;
   }
 
@@ -169,120 +152,96 @@ async function discoverBrowserCdp() {
     if (port > 1024 && port < 65536) ports.add(port);
   }
 
-  logErr(`Auto-discovery: ${ports.size} ports candidatos de ${pids.size} procesos`);
+  log(`Discovery: ${ports.size} candidate ports across ${pids.size} processes`);
 
   for (const port of ports) {
     const version = await testCdp(`http://127.0.0.1:${port}`, 1500);
     if (version) {
-      logErr(`Auto-discovery: CDP vivo en puerto ${port}`);
+      log(`Discovery hit: :${port}`);
       return { port, version };
     }
   }
-
   return null;
 }
 
-function rewriteCdpInfo(port, version) {
-  const ws = (version && version.webSocketDebuggerUrl) || '';
-  const browser = (version && version.Browser) || 'Unknown';
+function writeCdpInfo(port, version, mode) {
   const data = {
     DEBUG_PORT: port,
-    DEBUG_WS: ws,
-    BROWSER: browser,
+    DEBUG_WS: version.webSocketDebuggerUrl || '',
+    BROWSER: version.Browser || 'Unknown',
     CDP_URL: `http://127.0.0.1:${port}`,
-    MODE: 'AUTO_DISCOVERED',
+    MODE: mode,
+    UPDATED_AT: new Date().toISOString(),
   };
-  for (const p of [HOME_CDP_INFO, CDP_INFO]) {
-    try { fs.writeFileSync(p, JSON.stringify(data, null, 2), 'utf-8'); } catch (e) {}
+  try { fs.writeFileSync(CDP_INFO, JSON.stringify(data, null, 2), 'utf-8'); } catch (e) {
+    log(`Write cdp_info failed: ${e.message}`);
   }
 }
 
-async function ensureCdpReady() {
-  const candidates = getHostCandidates();
-  logErr(`Candidatos host: ${candidates.join(', ')}`);
-  let info = readCdpInfo();
-  let port = info && info.DEBUG_PORT;
-
-  // Intento 1: probar candidatos con el puerto en cdp_info.json
-  if (port) {
-    const url = await tryCandidates(port, candidates, 3000);
-    if (url) {
-      logErr(`CDP activo en ${url}`);
-      return url;
-    }
-    logErr(`Puerto ${port} de cdp_info.json stale. Auto-discovery...`);
-  }
-
-  // Intento 2: auto-discovery via tasklist+netstat (no reinicia browser)
-  const discovered = await discoverBrowserCdp();
-  if (discovered) {
-    rewriteCdpInfo(discovered.port, discovered.version);
-    const url = await tryCandidates(discovered.port, candidates, 3000);
-    if (url) {
-      logErr(`CDP descubierto y cdp_info.json actualizado: ${url}`);
-      return url;
-    }
-  }
-
-  // Intento 3: auto-launch via brave_ipc.py
-  logErr('CDP no responde. Auto-lanzando Brave via brave_ipc.py...');
+async function autoLaunch() {
   if (!fs.existsSync(BRAVE_IPC_PY)) {
-    logErr(`brave_ipc.py no encontrado en ${BRAVE_IPC_PY}`);
+    log(`brave_ipc.py not found at ${BRAVE_IPC_PY}`);
     return null;
   }
-
-  const pythonCmd = IS_WSL ? 'python3' : 'python';
-  const launchCmd = IS_WSL
+  log('Auto-launch via brave_ipc.py --no-kill');
+  const cmd = IS_WSL
     ? `cmd.exe /c python "${BRAVE_IPC_PY.replace(/^\/mnt\/([a-z])\//, (_, d) => `${d.toUpperCase()}:\\`).replace(/\//g, '\\\\')}" --no-kill`
-    : `${pythonCmd} "${BRAVE_IPC_PY}" --no-kill`;
-
+    : `python "${BRAVE_IPC_PY}" --no-kill`;
   try {
-    spawnSync(launchCmd, { shell: true, timeout: 60000, stdio: 'pipe' });
+    spawnSync(cmd, { shell: true, timeout: 60000, stdio: 'pipe' });
   } catch (e) {
-    logErr(`Auto-launch fallo: ${e.message}`);
+    log(`Auto-launch failed: ${e.message}`);
+    return null;
   }
+  return await tryDevToolsActivePort();
+}
 
-  // Releer y reverificar contra todos los candidatos
-  info = readCdpInfo();
-  port = info && info.DEBUG_PORT;
-  if (port) {
-    const url = await tryCandidates(port, candidates, 5000);
-    if (url) {
-      logErr(`CDP activo despues de auto-launch en ${url}`);
-      return url;
-    }
-  }
+async function ensureCdp() {
+  let result = await tryDevToolsActivePort();
+  if (result) return result;
 
-  logErr('CDP sigue sin responder despues de auto-launch.');
-  return null;
-}
+  log('DevToolsActivePort miss. Falling back to netstat discovery.');
+  result = await discoverViaNetstat();
+  if (result) return result;
 
-async function main() {
-  const browserUrl = await ensureCdpReady();
+  log('No live CDP found. Auto-launching browser.');
+  result = await autoLaunch();
+  return result;
+}
 
-  if (!browserUrl) {
-    logErr('No se pudo establecer CDP. El MCP intentara conectar de todas formas.');
+function pickRunner() {
+  if (CHROME_DEVTOOLS_MCP_BIN && fs.existsSync(CHROME_DEVTOOLS_MCP_BIN)) {
+    return { cmd: process.execPath, args: [CHROME_DEVTOOLS_MCP_BIN] };
   }
+  log(`chrome-devtools-mcp bin not resolvable. Falling back to npx (slow first run).`);
+  return IS_WIN
+    ? { cmd: 'cmd.exe', args: ['/c', 'npx', '-y', 'chrome-devtools-mcp@latest'], shell: true }
+    : { cmd: 'npx', args: ['-y', 'chrome-devtools-mcp@latest'], shell: true };
+}
 
-  const finalUrl = browserUrl || `http://127.0.0.1:9222`;
-  logErr(`Lanzando chrome-devtools-mcp -> ${finalUrl}`);
+async function main() {
+  const cdp = await ensureCdp();
+
+  let browserUrl;
+  if (cdp) {
+    writeCdpInfo(cdp.port, cdp.version, 'RESOLVED');
+    browserUrl = `http://127.0.0.1:${cdp.port}`;
+    log(`CDP ready: ${browserUrl}`);
+  } else {
+    browserUrl = 'http://127.0.0.1:9222';
+    log(`CDP unresolved. MCP will retry against fallback ${browserUrl}.`);
+  }
 
-  const child = spawn(
-    IS_WIN ? 'cmd.exe' : 'npx',
-    IS_WIN
-      ? ['/c', 'npx', '-y', 'chrome-devtools-mcp@latest', '--browserUrl', finalUrl]
-      : ['-y', 'chrome-devtools-mcp@latest', '--browserUrl', finalUrl],
-    { stdio: ['inherit', 'inherit', 'inherit'], shell: !IS_WIN }
-  );
+  const runner = pickRunner();
+  const args = [...runner.args, '--browserUrl', browserUrl];
+  log(`Spawn: ${runner.cmd} ${args.join(' ')}`);
 
-  child.on('exit', (code) => process.exit(code || 0));
-  child.on('error', (e) => {
-    logErr(`spawn error: ${e.message}`);
-    process.exit(1);
+  const child = spawn(runner.cmd, args, {
+    stdio: ['inherit', 'inherit', 'inherit'],
+    shell: !!runner.shell,
   });
+  child.on('exit', (code) => process.exit(code || 0));
+  child.on('error', (e) => { log(`spawn error: ${e.message}`); process.exit(1); });
 }
 
-main().catch(e => {
-  logErr(`fatal: ${e.message}`);
-  process.exit(1);
-});
+main().catch(e => { log(`fatal: ${e.message}`); process.exit(1); });

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "browser-ipc-cdp",
-  "version": "1.8.3",
+  "version": "2.0.0",
   "description": "Control remoto de navegadores Chromium (Brave, Chrome, Edge) via IPC + CDP dinamico. Un comando para conectar Claude Code a tu navegador real.",
   "bin": {
-    "browser-ipc-cdp": "bin/cli.js"
+    "browser-ipc-cdp": "bin/cli.js",
+    "browser-ipc-cdp-mcp": "brave_mcp_launcher.js"
+  },
+  "dependencies": {
+    "chrome-devtools-mcp": "^0.25.0"
   },
   "keywords": [
     "cdp",
@@ -29,7 +33,7 @@
   },
   "homepage": "https://github.com/alexis14kl/browser-ipc-cdp#readme",
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=18.0.0"
   },
   "files": [
     "bin/",