browser-ipc-cdp 1.8.1 → 1.8.3

package/brave_mcp_launcher.js

@@ -17,10 +17,11 @@
  *
  * Flujo:
  *   1. Lee cdp_info.json -> puerto candidato
- *   2. Verifica CDP (curl /json/version) en hostIP:puerto
+ *   2. Verifica CDP (/json/version) en hostIP:puerto
  *   3. Si responde -> lanza chrome-devtools-mcp con ese URL
- *   4. Si NO responde -> ejecuta brave_ipc.py --no-kill (auto-launch)
- *   5. Releer cdp_info.json + reverificar -> conectar
+ *   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)
  */
 const { execSync, spawn, spawnSync } = require('child_process');
 const fs = require('fs');
@@ -112,6 +113,90 @@ 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;
+
+  const images = ['brave.exe', 'chrome.exe', 'msedge.exe', 'chromium.exe'];
+  const pids = new Set();
+
+  for (const img of images) {
+    try {
+      const out = execSync(
+        `tasklist /FI "IMAGENAME eq ${img}" /FO CSV /NH`,
+        { encoding: 'utf-8', timeout: 8000, maxBuffer: 16 * 1024 * 1024, stdio: ['ignore', 'pipe', 'ignore'] }
+      );
+      for (const line of out.split('\n')) {
+        const parts = line.trim().split('","');
+        if (parts.length >= 2) {
+          const pid = parseInt(parts[1].replace(/"/g, ''), 10);
+          if (Number.isFinite(pid) && pid > 0) pids.add(pid);
+        }
+      }
+    } catch (e) {}
+  }
+
+  if (pids.size === 0) {
+    logErr('Auto-discovery: ningun proceso Chromium corriendo');
+    return null;
+  }
+
+  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}`);
+    return null;
+  }
+
+  const ports = new Set();
+  for (const line of netstatOut.split('\n')) {
+    const tokens = line.trim().split(/\s+/);
+    if (tokens.length < 5 || tokens[0] !== 'TCP' || !tokens[3].includes('LISTENING')) continue;
+    const pid = parseInt(tokens[4], 10);
+    if (!pids.has(pid)) continue;
+    const m = tokens[1].match(/:(\d+)$/);
+    if (!m) continue;
+    const port = parseInt(m[1], 10);
+    if (port > 1024 && port < 65536) ports.add(port);
+  }
+
+  logErr(`Auto-discovery: ${ports.size} ports candidatos de ${pids.size} procesos`);
+
+  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}`);
+      return { port, version };
+    }
+  }
+
+  return null;
+}
+
+function rewriteCdpInfo(port, version) {
+  const ws = (version && version.webSocketDebuggerUrl) || '';
+  const browser = (version && version.Browser) || 'Unknown';
+  const data = {
+    DEBUG_PORT: port,
+    DEBUG_WS: ws,
+    BROWSER: browser,
+    CDP_URL: `http://127.0.0.1:${port}`,
+    MODE: 'AUTO_DISCOVERED',
+  };
+  for (const p of [HOME_CDP_INFO, CDP_INFO]) {
+    try { fs.writeFileSync(p, JSON.stringify(data, null, 2), 'utf-8'); } catch (e) {}
+  }
+}
+
 async function ensureCdpReady() {
   const candidates = getHostCandidates();
   logErr(`Candidatos host: ${candidates.join(', ')}`);
@@ -125,9 +210,21 @@ async function ensureCdpReady() {
       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 2: auto-launch via brave_ipc.py
+  // Intento 3: auto-launch via brave_ipc.py
   logErr('CDP no responde. Auto-lanzando Brave via brave_ipc.py...');
   if (!fs.existsSync(BRAVE_IPC_PY)) {
     logErr(`brave_ipc.py no encontrado en ${BRAVE_IPC_PY}`);

package/lib/mcp.js

@@ -46,6 +46,53 @@ function getWslHostIp() {
   return '127.0.0.1';
 }
 
+function updateClaudeUserConfig(wrapperPath) {
+  // Registra el MCP "brave" en scope user (~/.claude.json top-level mcpServers)
+  // para que aparezca en /mcp desde cualquier directorio, sin depender del cwd.
+  const braveEntry = {
+    type: 'stdio',
+    command: 'node',
+    args: [wrapperPath],
+    env: {},
+  };
+
+  const candidates = new Set();
+  if (process.env.HOME) candidates.add(path.join(process.env.HOME, '.claude.json'));
+  if (process.env.USERPROFILE) candidates.add(path.join(process.env.USERPROFILE, '.claude.json'));
+
+  // Desde WSL: buscar tambien en /mnt/c/Users/*/.claude.json
+  try {
+    if (fs.existsSync('/mnt/c/Users')) {
+      for (const user of fs.readdirSync('/mnt/c/Users')) {
+        const candidate = `/mnt/c/Users/${user}/.claude.json`;
+        if (fs.existsSync(candidate)) candidates.add(candidate);
+      }
+    }
+  } catch (e) {}
+
+  let updated = 0;
+  for (const p of candidates) {
+    try {
+      // Solo modificar si Claude Code ya creo el archivo.
+      // No bootstrap-eamos .claude.json para no chocar con first-run setup.
+      if (!fs.existsSync(p)) continue;
+      const data = JSON.parse(fs.readFileSync(p, 'utf-8'));
+      if (!data.mcpServers) data.mcpServers = {};
+      data.mcpServers.brave = braveEntry;
+
+      // Write atomico: tmp + rename (evita corromper si Claude Code lee a medias)
+      const tmp = p + '.tmp';
+      fs.writeFileSync(tmp, JSON.stringify(data, null, 2));
+      fs.renameSync(tmp, p);
+      updated++;
+      log(`        -> ${p} (user scope)`);
+    } catch (e) {
+      warn(`No se pudo actualizar ${p}: ${e.message}`);
+    }
+  }
+  return updated;
+}
+
 function updateMcpJson(port, wslIp) {
   // Estrategia: apuntar al wrapper Node dinamico.
   // El wrapper lee cdp_info.json en cada invocacion -> puerto siempre fresco.
@@ -115,7 +162,16 @@ function updateMcpJson(port, wslIp) {
   }
 
   success(`.mcp.json actualizado (${updated} archivos): brave -> ${wslIp}:${port}`);
-  return updated > 0;
+
+  // Tambien registrar en scope user (~/.claude.json) para que /mcp lo vea desde cualquier cwd
+  const userUpdated = updateClaudeUserConfig(wrapperPath);
+  if (userUpdated > 0) {
+    success(`.claude.json actualizado (${userUpdated} archivos, scope user): brave registrado`);
+  } else {
+    warn('No se encontro .claude.json para registrar en scope user. Reinicia Claude Code una vez para que se cree, luego re-ejecuta este comando.');
+  }
+
+  return (updated + userUpdated) > 0;
 }
 
-module.exports = { getWslHostIp, updateMcpJson };
+module.exports = { getWslHostIp, updateMcpJson, updateClaudeUserConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "browser-ipc-cdp",
-  "version": "1.8.1",
+  "version": "1.8.3",
   "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"