browser-ipc-cdp 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alexis Malambo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,267 @@
+<<<<<<< HEAD
+# Brave IPC CDP - Documentacion
+
+## Que es esto?
+
+Sistema para controlar **tu Brave Browser real** (con todos tus datos, bookmarks, passwords, extensiones y sesiones) desde Claude Code via **IPC (Inter-Process Communication)** + **CDP (Chrome DevTools Protocol)** con puerto dinamico.
+
+**Sin puerto fijo, sin sesion separada, sin perder tus datos. Tu Brave de uso diario controlado por IA.**
+
+---
+
+## Arquitectura
+
+```
+brave_ipc.py lanza Brave
+        |
+        v
+  --remote-debugging-port=0  (OS asigna puerto aleatorio)
+        |
+        v
+  Brave escribe DevToolsActivePort (archivo IPC)
+        |
+        v
+  brave_ipc.py lee el puerto → guarda en cdp_info.json
+        |
+        v
+  MCP "brave" (brave_mcp_launcher.js) lee cdp_info.json
+        |
+        v
+  Claude Code usa mcp__brave__* para controlar el navegador
+```
+
+---
+
+## Archivos
+
+| Archivo | Funcion |
+|---------|---------|
+| `brave_ipc.py` | Launcher principal. Abre Brave con CDP dinamico via IPC |
+| `brave_cdp.bat` | Doble-click para ejecutar brave_ipc.py |
+| `brave_mcp_launcher.js` | Wrapper MCP que lee el puerto dinamico y lanza chrome-devtools-mcp |
+| `cdp_info.json` | Se genera al ejecutar. Contiene puerto, WebSocket, PID, etc. |
+| `README.md` | Este archivo |
+
+---
+
+## Como usar
+
+### 1. Abrir Brave con CDP
+
+```bat
+:: Tu Brave real (bookmarks, passwords, extensiones, todo)
+python brave_ipc.py
+
+:: Perfil limpio separado (para testing)
+python brave_ipc.py --clean
+
+:: Mas opciones
+python brave_ipc.py --port 9222       # Puerto fijo
+python brave_ipc.py --url https://..  # Abre URL al iniciar
+python brave_ipc.py --headless        # Sin ventana visible
+python brave_ipc.py --no-kill         # No mata Brave existente
+```
+
+**Modos de perfil:**
+
+| Comando | Perfil | Datos |
+|---------|--------|-------|
+| `python brave_ipc.py` | **REAL** | Todos tus bookmarks, passwords, extensiones, sesiones activas |
+| `python brave_ipc.py --clean` | Limpio | Sesion vacia, sin datos personales |
+
+### 2. Verificar CDP
+
+Despues de ejecutar, el script muestra:
+```
+  Navegador:  Chrome/146.0.7680.80
+  Puerto CDP: 58553
+  CDP URL:    http://127.0.0.1:58553
+  WebSocket:  ws://127.0.0.1:58553/devtools/browser/...
+```
+
+Tambien puedes verificar manualmente:
+```
+http://127.0.0.1:{PUERTO}/json/version   → Info del navegador
+http://127.0.0.1:{PUERTO}/json/list      → Pestanas abiertas
+```
+
+### 3. Conectar desde Claude Code
+
+El MCP "brave" esta configurado en `C:\Users\NyGsoft\.mcp.json`:
+```json
+{
+  "mcpServers": {
+    "brave": {
+      "command": "npx",
+      "args": ["-y", "chrome-devtools-mcp@latest", "--browserUrl", "http://172.20.176.1:PUERTO"]
+    }
+  }
+}
+```
+
+> **IMPORTANTE:** El puerto cambia cada vez que ejecutas `brave_ipc.py`.
+> Despues de ejecutar, actualiza el puerto en `.mcp.json` con el valor de `cdp_info.json`.
+> Luego ejecuta `/mcp` en Claude Code para reconectar.
+>
+> **Tip:** La IP de WSL puede cambiar entre reinicios.
+> Verificar con: `grep nameserver /etc/resolv.conf`
+
+### 4. Usar desde Claude Code
+
+```
+mcp__brave__list_pages          → Ver pestanas abiertas
+mcp__brave__navigate_page       → Navegar a URL
+mcp__brave__take_snapshot       → Leer contenido de la pagina
+mcp__brave__take_screenshot     → Captura de pantalla
+mcp__brave__click               → Click en elemento
+mcp__brave__fill                → Escribir en campo de texto
+mcp__brave__press_key           → Presionar tecla
+mcp__brave__evaluate_script     → Ejecutar JavaScript
+mcp__brave__list_network_requests → Ver requests de red
+```
+
+---
+
+## Que es IPC?
+
+**Inter-Process Communication** — un proceso (brave_ipc.py) se comunica con otro (Brave) sin usar la red.
+
+### Flujo tradicional (malo):
+```
+Abrir Brave con --remote-debugging-port=9222
+  → Puerto fijo → conflictos
+  → Necesita regla de firewall
+  → Necesita portproxy para WSL
+```
+
+### Flujo IPC (bueno):
+```
+Proceso padre lanza Brave con --remote-debugging-port=0
+  → OS asigna puerto aleatorio (ej: 58553)
+  → Brave escribe puerto en DevToolsActivePort (IPC via filesystem)
+  → Proceso padre lee el archivo → sabe el puerto
+  → Conexion directa, sin firewall, sin conflictos
+```
+
+### Por que puerto 0?
+
+Cuando pasas `--remote-debugging-port=0`, le dices al sistema operativo:
+"dame cualquier puerto disponible". El OS elige uno libre (ej: 58553, 62301, etc.)
+y Brave lo escribe en `DevToolsActivePort` para que otros procesos lo lean.
+
+Es el mismo patron que usa:
+- **Playwright** internamente
+- **Puppeteer** internamente
+- **El bot de publicidad** con DiCloak (inject hook → puerto dinamico)
+
+---
+
+## Que es CDP?
+
+**Chrome DevTools Protocol** — protocolo para controlar navegadores Chromium
+(Chrome, Brave, Edge, Opera, ginsbrowser) programaticamente.
+
+Permite:
+- Navegar a URLs
+- Hacer click, escribir, scroll
+- Tomar screenshots
+- Ejecutar JavaScript
+- Interceptar requests de red
+- Leer el DOM completo
+
+---
+
+## Conexion desde WSL
+
+WSL no puede acceder a `127.0.0.1` de Windows directamente.
+Para que Claude Code (WSL) llegue a Brave (Windows):
+
+1. **Portproxy** (configuracion unica como Admin):
+```powershell
+netsh interface portproxy add v4tov4 listenaddress=0.0.0.0 listenport=58553 connectaddress=127.0.0.1 connectport=58553
+```
+
+2. **Firewall** (rango dinamico, configuracion unica):
+```powershell
+netsh advfirewall firewall add rule name="CDP Dynamic Range" dir=in action=allow protocol=TCP localport=50000-65000
+```
+
+3. **IP de Windows** desde WSL:
+```bash
+grep nameserver /etc/resolv.conf
+# Resultado: 172.20.176.1 (puede cambiar entre reinicios)
+```
+
+---
+
+## Troubleshooting
+
+| Problema | Solucion |
+|----------|----------|
+| `brave_ipc.py` no encuentra Brave | Verificar ruta: `C:\Program Files\BraveSoftware\Brave-Browser\Application\brave.exe` |
+| Puerto no detectado | Brave tarda en escribir DevToolsActivePort. Esperar 10s y reintentar |
+| MCP "brave" no conecta | Verificar que el puerto en `.mcp.json` coincide con `cdp_info.json` |
+| WSL no llega al puerto | Agregar portproxy + firewall (ver seccion anterior) |
+| IP de Windows cambio | `grep nameserver /etc/resolv.conf` → actualizar `.mcp.json` |
+| Brave ya estaba abierto | Usar `--no-kill` o cerrar Brave antes de ejecutar |
+
+---
+
+## cdp_info.json (ejemplo)
+
+```json
+{
+  "DEBUG_PORT": 59152,
+  "DEBUG_WS": "ws://127.0.0.1:59152/devtools/browser/...",
+  "BROWSER": "Chrome/146.0.7680.80",
+  "PID": 25552,
+  "USER_DATA": "C:\\Users\\NyGsoft\\AppData\\Local\\BraveSoftware\\Brave-Browser\\User Data",
+  "CDP_URL": "http://127.0.0.1:59152",
+  "PAGES": 23
+}
+```
+
+Otros scripts pueden leer este archivo para saber el puerto actual.
+
+---
+
+## Ejemplo real: que puedes hacer
+
+Con tu Brave real conectado via IPC + CDP, Claude Code puede:
+
+- **Ver todas tus tabs abiertas** (Jira, WhatsApp, Facebook, n8n, ChatGPT, etc.)
+- **Navegar a cualquier pagina** en tu sesion logueada
+- **Leer contenido de paginas** donde ya estas autenticado (Jira, n8n, etc.)
+- **Hacer click, escribir, buscar** en cualquier tab
+- **Tomar screenshots** de lo que ves
+- **Ejecutar JavaScript** en cualquier pagina
+- **Interceptar network requests** para debug
+
+Todo sin necesidad de login adicional — usa tus sesiones activas.
+
+---
+
+## Flujo completo paso a paso
+
+```
+1. Cerrar Brave (si esta abierto)
+
+2. Ejecutar:
+   python C:\Users\NyGsoft\Desktop\ipc\brave_ipc.py
+
+3. Brave abre con todas tus cosas + CDP activo
+   Output: "Puerto CDP: 59152" (o el que sea)
+
+4. Agregar portproxy (solo la primera vez por puerto):
+   netsh interface portproxy add v4tov4 listenaddress=0.0.0.0 listenport=59152 connectaddress=127.0.0.1 connectport=59152
+
+5. Actualizar .mcp.json con el puerto nuevo
+
+6. En Claude Code: /mcp → Reconnected to brave
+
+7. Listo! Claude Code controla tu Brave real
+```
+=======
+# browser-ipc-cdp
+browser-ipc-cdp — Control remoto de navegadores Chromium (Brave, Chrome, Edge) via IPC con CDP dinámico. Abre tu   navegador real con todas tus sesiones, detecta o asigna puerto automáticamente, configura portproxy/firewall para WSL,    y actualiza el MCP de Claude Code. Sin puertos fijos, sin hacks de registry, sin configuración manual.
+>>>>>>> 3ba8518eefb0a7bab267193cab6800ebc9fda58b

package/bin/cli.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+/**
+ * browser-ipc-cdp CLI
+ *
+ * Un comando para conectar Claude Code a tu navegador real via IPC + CDP.
+ *
+ * Uso:
+ *   npx browser-ipc-cdp                  # Auto-detectar navegador + instalar
+ *   npx browser-ipc-cdp --browser brave  # Forzar Brave
+ *   npx browser-ipc-cdp --browser chrome # Forzar Chrome
+ *   npx browser-ipc-cdp --list           # Listar navegadores
+ *   npx browser-ipc-cdp --status         # Ver estado actual
+ *   npx browser-ipc-cdp --uninstall      # Desinstalar
+ */
+const { detectBrowsers, findBrowser, launchBrowser, detectExistingCDP } = require('../lib/browser');
+const { setupPortproxy, setupFirewall } = require('../lib/network');
+const { updateMcpJson, getWslHostIp } = require('../lib/mcp');
+const { saveCdpInfo, loadCdpInfo } = require('../lib/config');
+const { log, success, warn, error, banner, table } = require('../lib/logger');
+
+const args = process.argv.slice(2);
+const flags = {};
+for (let i = 0; i < args.length; i++) {
+  if (args[i].startsWith('--')) {
+    const key = args[i].replace('--', '');
+    flags[key] = args[i + 1] && !args[i + 1].startsWith('--') ? args[i + 1] : true;
+    if (flags[key] !== true) i++;
+  }
+}
+
+async function main() {
+  banner();
+
+  // --list: listar navegadores
+  if (flags.list) {
+    const browsers = detectBrowsers();
+    if (browsers.length === 0) {
+      error('No se encontraron navegadores Chromium instalados.');
+      process.exit(1);
+    }
+    log('Navegadores Chromium detectados:');
+    browsers.forEach(b => log(`  - ${b.name.padEnd(10)} → ${b.exe}`));
+    process.exit(0);
+  }
+
+  // --status: ver estado actual
+  if (flags.status) {
+    const info = loadCdpInfo();
+    if (info) {
+      log(`Puerto CDP: ${info.DEBUG_PORT}`);
+      log(`Navegador:  ${info.BROWSER}`);
+      log(`Modo:       ${info.MODE || 'LAUNCHED'}`);
+      log(`Paginas:    ${info.PAGES}`);
+    } else {
+      warn('No hay sesion CDP activa. Ejecuta: npx browser-ipc-cdp');
+    }
+    process.exit(0);
+  }
+
+  // --uninstall: limpiar
+  if (flags.uninstall) {
+    log('Limpiando configuracion...');
+    // TODO: remove portproxy, firewall rule, .mcp.json entry
+    success('Desinstalado.');
+    process.exit(0);
+  }
+
+  // ─── FLUJO PRINCIPAL ──────────────────────────────────────────────────
+
+  const preferredBrowser = flags.browser || '';
+  const forcePort = parseInt(flags.port) || 0;
+  const clean = !!flags.clean;
+
+  // 1. Detectar navegador
+  log('[1/6] Detectando navegador...');
+  const browser = findBrowser(preferredBrowser);
+  if (!browser) {
+    const available = detectBrowsers();
+    if (available.length > 0) {
+      error(`Navegador '${preferredBrowser}' no encontrado.`);
+      log('Disponibles:');
+      available.forEach(b => log(`  - ${b.name}`));
+    } else {
+      error('No se encontro ningun navegador Chromium.');
+      log('Instala Brave, Chrome o Edge.');
+    }
+    process.exit(1);
+  }
+  success(`${browser.name} encontrado: ${browser.exe}`);
+
+  // 2. Verificar CDP existente
+  log('[2/6] Verificando CDP existente...');
+  const existingPort = await detectExistingCDP(browser);
+
+  let port, mode, pid;
+
+  if (existingPort) {
+    success(`CDP ya activo en puerto ${existingPort}. Sin reiniciar!`);
+    port = existingPort;
+    mode = 'ATTACHED';
+    pid = 0;
+  } else {
+    // 3. Lanzar navegador con CDP
+    log('[3/6] Lanzando navegador con CDP...');
+    const result = await launchBrowser(browser, { port: forcePort, clean });
+    port = result.port;
+    mode = 'LAUNCHED';
+    pid = result.pid;
+    success(`CDP activo en puerto ${port}`);
+  }
+
+  // 4. Firewall
+  log('[4/6] Configurando firewall...');
+  setupFirewall();
+
+  // 5. Portproxy
+  log('[5/6] Configurando portproxy para WSL...');
+  setupPortproxy(port);
+
+  // 6. MCP config
+  log('[6/6] Configurando MCP para Claude Code...');
+  const wslIp = getWslHostIp();
+  updateMcpJson(port, wslIp);
+
+  // Obtener info del CDP
+  let browserVersion = 'Unknown';
+  let wsUrl = '';
+  let pages = 0;
+  try {
+    const http = require('http');
+    const versionData = await fetchJson(`http://127.0.0.1:${port}/json/version`);
+    browserVersion = versionData.Browser || 'Unknown';
+    wsUrl = versionData.webSocketDebuggerUrl || '';
+    const pageList = await fetchJson(`http://127.0.0.1:${port}/json/list`);
+    pages = Array.isArray(pageList) ? pageList.length : 0;
+  } catch (e) {}
+
+  // Guardar info
+  saveCdpInfo({
+    DEBUG_PORT: port,
+    DEBUG_WS: wsUrl,
+    BROWSER: browserVersion,
+    BROWSER_EXE: browser.exe,
+    PID: pid,
+    CDP_URL: `http://127.0.0.1:${port}`,
+    PAGES: pages,
+    MODE: mode,
+    WSL_IP: wslIp,
+  });
+
+  // Resumen
+  console.log('');
+  console.log('='.repeat(55));
+  console.log(`  MODO:        ${mode}${mode === 'ATTACHED' ? ' (sin reiniciar)' : ' (nuevo proceso)'}`);
+  console.log(`  Navegador:   ${browserVersion}`);
+  console.log(`  Puerto CDP:  ${port} (dinamico via IPC)`);
+  console.log(`  Paginas:     ${pages}`);
+  console.log(`  WSL IP:      ${wslIp}`);
+  console.log(`  Portproxy:   0.0.0.0:${port} -> 127.0.0.1:${port}`);
+  console.log(`  .mcp.json:   Actualizado`);
+  console.log('='.repeat(55));
+  console.log('');
+  console.log('  Siguiente paso en Claude Code:');
+  console.log('    /mcp   (para conectar el MCP brave)');
+  console.log('');
+  console.log('  Herramientas disponibles:');
+  console.log('    mcp__brave__list_pages');
+  console.log('    mcp__brave__navigate_page');
+  console.log('    mcp__brave__take_snapshot');
+  console.log('    mcp__brave__click / fill / press_key');
+  console.log('');
+}
+
+function fetchJson(url) {
+  return new Promise((resolve, reject) => {
+    const http = require('http');
+    http.get(url, { timeout: 5000 }, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)); }
+        catch (e) { reject(e); }
+      });
+    }).on('error', reject);
+  });
+}
+
+main().catch(e => {
+  error(e.message);
+  process.exit(1);
+});

package/lib/browser.js

@@ -0,0 +1,246 @@
+const { execSync, spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const http = require('http');
+const { log, success, warn } = require('./logger');
+
+const BROWSER_PATHS = {
+  brave: [
+    'C:\\Program Files\\BraveSoftware\\Brave-Browser\\Application\\brave.exe',
+    'C:\\Program Files (x86)\\BraveSoftware\\Brave-Browser\\Application\\brave.exe',
+    path.join(process.env.LOCALAPPDATA || '', 'BraveSoftware', 'Brave-Browser', 'Application', 'brave.exe'),
+  ],
+  chrome: [
+    'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
+    'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
+    path.join(process.env.LOCALAPPDATA || '', 'Google', 'Chrome', 'Application', 'chrome.exe'),
+  ],
+  edge: [
+    'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe',
+    'C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe',
+  ],
+};
+
+const BROWSER_USER_DATA = {
+  brave: path.join(process.env.LOCALAPPDATA || '', 'BraveSoftware', 'Brave-Browser', 'User Data'),
+  chrome: path.join(process.env.LOCALAPPDATA || '', 'Google', 'Chrome', 'User Data'),
+  edge: path.join(process.env.LOCALAPPDATA || '', 'Microsoft', 'Edge', 'User Data'),
+};
+
+function detectBrowsers() {
+  const found = [];
+  for (const [name, paths] of Object.entries(BROWSER_PATHS)) {
+    for (const p of paths) {
+      if (fs.existsSync(p)) {
+        found.push({
+          name,
+          exe: p,
+          userData: BROWSER_USER_DATA[name] || '',
+        });
+        break;
+      }
+    }
+  }
+  return found;
+}
+
+function findBrowser(preferred) {
+  const browsers = detectBrowsers();
+  if (preferred) {
+    return browsers.find(b => b.name === preferred.toLowerCase()) || null;
+  }
+  // Config guardada
+  const configPath = path.join(__dirname, '..', 'browser_config.json');
+  if (fs.existsSync(configPath)) {
+    try {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      if (config.exe && fs.existsSync(config.exe)) {
+        return config;
+      }
+    } catch (e) {}
+  }
+  // Primer navegador encontrado
+  if (browsers.length > 0) {
+    try {
+      fs.writeFileSync(configPath, JSON.stringify(browsers[0], null, 2));
+    } catch (e) {}
+    return browsers[0];
+  }
+  return null;
+}
+
+function testCdp(port, timeout = 3000) {
+  return new Promise((resolve) => {
+    const req = http.get(`http://127.0.0.1:${port}/json/version`, { timeout }, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)); }
+        catch (e) { resolve(null); }
+      });
+    });
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => { req.destroy(); resolve(null); });
+  });
+}
+
+function isBrowserRunning(exe) {
+  const exeName = path.basename(exe).toLowerCase();
+  try {
+    const result = execSync(
+      `tasklist /FI "IMAGENAME eq ${exeName}" /FO CSV /NH`,
+      { timeout: 10000, encoding: 'utf-8' }
+    );
+    return result.toLowerCase().includes(exeName);
+  } catch (e) {
+    return false;
+  }
+}
+
+async function detectExistingCDP(browser) {
+  if (!isBrowserRunning(browser.exe)) return null;
+
+  // 1. DevToolsActivePort
+  if (browser.userData) {
+    const portFile = path.join(browser.userData, 'DevToolsActivePort');
+    if (fs.existsSync(portFile)) {
+      try {
+        const lines = fs.readFileSync(portFile, 'utf-8').trim().split('\n');
+        const port = parseInt(lines[0].trim());
+        if (port > 0) {
+          const result = await testCdp(port);
+          if (result) return port;
+        }
+      } catch (e) {}
+    }
+  }
+
+  // 2. Command line
+  try {
+    const exeName = path.basename(browser.exe).toLowerCase();
+    const result = execSync(
+      `wmic process where "name='${exeName}'" get commandline /format:list`,
+      { timeout: 10000, encoding: 'utf-8' }
+    );
+    const match = result.match(/--remote-debugging-port[=\s](\d{2,5})/);
+    if (match) {
+      const port = parseInt(match[1]);
+      if (port > 0) {
+        const cdp = await testCdp(port);
+        if (cdp) return port;
+      }
+    }
+  } catch (e) {}
+
+  // 3. Scan ports via netstat
+  try {
+    const exeName = path.basename(browser.exe).toLowerCase();
+    const taskResult = execSync(
+      `tasklist /FI "IMAGENAME eq ${exeName}" /FO CSV /NH`,
+      { timeout: 10000, encoding: 'utf-8' }
+    );
+    const pids = new Set();
+    taskResult.split('\n').forEach(line => {
+      const parts = line.trim().replace(/"/g, '').split(',');
+      if (parts.length >= 2) {
+        const pid = parseInt(parts[1]);
+        if (!isNaN(pid)) pids.add(pid);
+      }
+    });
+
+    if (pids.size > 0) {
+      const netstat = execSync('netstat -ano -p tcp', { timeout: 10000, encoding: 'utf-8' });
+      for (const line of netstat.split('\n')) {
+        const tokens = line.trim().split(/\s+/);
+        if (tokens.length >= 5 && tokens[3] === 'LISTENING') {
+          const pid = parseInt(tokens[4]);
+          if (pids.has(pid)) {
+            const portStr = tokens[1].split(':').pop();
+            const port = parseInt(portStr);
+            if (port > 1024) {
+              const cdp = await testCdp(port);
+              if (cdp) return port;
+            }
+          }
+        }
+      }
+    }
+  } catch (e) {}
+
+  return null;
+}
+
+function killBrowser(exe) {
+  const exeName = path.basename(exe);
+  try {
+    execSync(`taskkill /F /IM ${exeName}`, { timeout: 10000, stdio: 'pipe' });
+  } catch (e) {}
+}
+
+function launchBrowser(browser, { port = 0, clean = false } = {}) {
+  return new Promise((resolve, reject) => {
+    killBrowser(browser.exe);
+
+    // Wait for process to die
+    setTimeout(() => {
+      const userData = clean
+        ? path.join(process.env.USERPROFILE || '', 'browser-cdp-profile')
+        : browser.userData;
+
+      // Clean DevToolsActivePort
+      const portFile = path.join(userData, 'DevToolsActivePort');
+      try { if (fs.existsSync(portFile)) fs.unlinkSync(portFile); } catch (e) {}
+
+      const args = [
+        `--remote-debugging-port=${port}`,
+        '--remote-allow-origins=*',
+        '--disable-backgrounding-occluded-windows',
+      ];
+      if (clean) args.push(`--user-data-dir=${userData}`);
+
+      const child = spawn(browser.exe, args, {
+        detached: true,
+        stdio: 'ignore',
+      });
+      child.unref();
+
+      log(`        PID: ${child.pid}`);
+      log(`        Perfil: ${clean ? 'LIMPIO' : 'REAL (tus datos)'}`);
+
+      // Wait for DevToolsActivePort
+      if (port === 0) {
+        const deadline = Date.now() + 30000;
+        const check = () => {
+          if (Date.now() > deadline) {
+            return reject(new Error('Timeout esperando DevToolsActivePort'));
+          }
+          if (fs.existsSync(portFile)) {
+            try {
+              const lines = fs.readFileSync(portFile, 'utf-8').trim().split('\n');
+              const detected = parseInt(lines[0].trim());
+              if (detected > 0) {
+                return resolve({ port: detected, pid: child.pid });
+              }
+            } catch (e) {}
+          }
+          setTimeout(check, 500);
+        };
+        check();
+      } else {
+        // Fixed port: wait for CDP
+        const deadline = Date.now() + 30000;
+        const check = async () => {
+          if (Date.now() > deadline) {
+            return reject(new Error(`Timeout esperando CDP en puerto ${port}`));
+          }
+          const result = await testCdp(port);
+          if (result) return resolve({ port, pid: child.pid });
+          setTimeout(check, 500);
+        };
+        check();
+      }
+    }, 2000);
+  });
+}
+
+module.exports = { detectBrowsers, findBrowser, detectExistingCDP, launchBrowser, testCdp };

package/lib/config.js

@@ -0,0 +1,34 @@
+const fs = require('fs');
+const path = require('path');
+
+const CDP_INFO_PATH = path.join(process.env.USERPROFILE || process.env.HOME || '.', 'cdp_info.json');
+
+function saveCdpInfo(data) {
+  // Guardar en home y en directorio actual
+  const paths = [
+    CDP_INFO_PATH,
+    path.join(process.cwd(), 'cdp_info.json'),
+  ];
+  for (const p of paths) {
+    try {
+      fs.writeFileSync(p, JSON.stringify(data, null, 2));
+    } catch (e) {}
+  }
+}
+
+function loadCdpInfo() {
+  const paths = [
+    path.join(process.cwd(), 'cdp_info.json'),
+    CDP_INFO_PATH,
+  ];
+  for (const p of paths) {
+    try {
+      if (fs.existsSync(p)) {
+        return JSON.parse(fs.readFileSync(p, 'utf-8'));
+      }
+    } catch (e) {}
+  }
+  return null;
+}
+
+module.exports = { saveCdpInfo, loadCdpInfo };

package/lib/logger.js

@@ -0,0 +1,13 @@
+const banner = () => {
+  console.log('');
+  console.log('  browser-ipc-cdp');
+  console.log('  Control remoto de navegadores Chromium via IPC + CDP');
+  console.log('');
+};
+
+const log = (msg) => console.log(`  ${msg}`);
+const success = (msg) => console.log(`  [OK] ${msg}`);
+const warn = (msg) => console.log(`  [!] ${msg}`);
+const error = (msg) => console.error(`  [ERROR] ${msg}`);
+
+module.exports = { banner, log, success, warn, error };

package/lib/mcp.js

@@ -0,0 +1,72 @@
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const { log, success, warn } = require('./logger');
+
+function getWslHostIp() {
+  // 1. Desde WSL: leer resolv.conf directamente
+  try {
+    if (fs.existsSync('/etc/resolv.conf')) {
+      const content = fs.readFileSync('/etc/resolv.conf', 'utf-8');
+      const match = content.match(/nameserver\s+(\d+\.\d+\.\d+\.\d+)/);
+      if (match) return match[1];
+    }
+  } catch (e) {}
+
+  // 2. Desde Windows: via wsl.exe
+  if (process.platform === 'win32') {
+    try {
+      const result = execSync('wsl.exe -e grep nameserver /etc/resolv.conf',
+        { timeout: 10000, encoding: 'utf-8', stdio: 'pipe' });
+      const match = result.match(/nameserver\s+(\d+\.\d+\.\d+\.\d+)/);
+      if (match) return match[1];
+    } catch (e) {}
+
+    // 3. Via \\wsl$
+    const distros = ['Ubuntu', 'Ubuntu-22.04', 'Ubuntu-24.04', 'Debian'];
+    for (const distro of distros) {
+      const resolvPath = `\\\\wsl$\\${distro}\\etc\\resolv.conf`;
+      try {
+        if (fs.existsSync(resolvPath)) {
+          const content = fs.readFileSync(resolvPath, 'utf-8');
+          const match = content.match(/nameserver\s+(\d+\.\d+\.\d+\.\d+)/);
+          if (match) return match[1];
+        }
+      } catch (e) {}
+    }
+  }
+
+  return '127.0.0.1';
+}
+
+function updateMcpJson(port, wslIp) {
+  const braveEntry = {
+    command: 'npx',
+    args: ['-y', 'chrome-devtools-mcp@latest', '--browserUrl', `http://${wslIp}:${port}`],
+  };
+
+  // Actualizar .mcp.json en home y directorio actual
+  const mcpPaths = [
+    path.join(process.env.USERPROFILE || process.env.HOME || '', '.mcp.json'),
+    path.join(process.cwd(), '.mcp.json'),
+  ];
+
+  let updated = 0;
+  for (const mcpPath of mcpPaths) {
+    try {
+      let data = { mcpServers: {} };
+      if (fs.existsSync(mcpPath)) {
+        data = JSON.parse(fs.readFileSync(mcpPath, 'utf-8'));
+      }
+      if (!data.mcpServers) data.mcpServers = {};
+      data.mcpServers.brave = braveEntry;
+      fs.writeFileSync(mcpPath, JSON.stringify(data, null, 2));
+      updated++;
+    } catch (e) {}
+  }
+
+  success(`.mcp.json actualizado (${updated} archivos): brave -> ${wslIp}:${port}`);
+  return updated > 0;
+}
+
+module.exports = { getWslHostIp, updateMcpJson };

package/lib/network.js

@@ -0,0 +1,59 @@
+const { execSync } = require('child_process');
+const { log, success, warn } = require('./logger');
+
+const FIREWALL_RULE = 'CDP All Ports (IPC)';
+
+function setupFirewall() {
+  if (process.platform !== 'win32') return false;
+
+  // Verificar si ya existe
+  try {
+    const check = execSync(
+      `netsh advfirewall firewall show rule name="${FIREWALL_RULE}"`,
+      { timeout: 10000, encoding: 'utf-8', stdio: 'pipe' }
+    );
+    if (check.includes(FIREWALL_RULE)) return true;
+  } catch (e) {}
+
+  // Crear regla universal
+  try {
+    execSync(
+      `netsh advfirewall firewall add rule name="${FIREWALL_RULE}" dir=in action=allow protocol=TCP localport=1024-65535`,
+      { timeout: 10000, stdio: 'pipe' }
+    );
+    success('Firewall: regla universal creada');
+    return true;
+  } catch (e) {
+    warn('Firewall: no se pudo crear regla (ejecuta como Admin)');
+    return false;
+  }
+}
+
+function setupPortproxy(port) {
+  if (process.platform !== 'win32') return false;
+
+  // Verificar si ya existe
+  try {
+    const check = execSync('netsh interface portproxy show all',
+      { timeout: 10000, encoding: 'utf-8', stdio: 'pipe' });
+    if (check.includes(`0.0.0.0         ${port}`)) {
+      log(`        Portproxy ya existe para puerto ${port}`);
+      return true;
+    }
+  } catch (e) {}
+
+  // Crear portproxy
+  try {
+    execSync(
+      `netsh interface portproxy add v4tov4 listenaddress=0.0.0.0 listenport=${port} connectaddress=127.0.0.1 connectport=${port}`,
+      { timeout: 10000, stdio: 'pipe' }
+    );
+    success(`Portproxy: 0.0.0.0:${port} -> 127.0.0.1:${port}`);
+    return true;
+  } catch (e) {
+    warn(`Portproxy: fallo (ejecuta como Admin)`);
+    return false;
+  }
+}
+
+module.exports = { setupFirewall, setupPortproxy };

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "browser-ipc-cdp",
+  "version": "1.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"
+  },
+  "keywords": [
+    "cdp",
+    "chrome-devtools-protocol",
+    "ipc",
+    "brave",
+    "chrome",
+    "edge",
+    "mcp",
+    "claude-code",
+    "browser-automation",
+    "devtools",
+    "remote-debugging",
+    "wsl",
+    "portproxy",
+    "chromium"
+  ],
+  "author": "Alexis Malambo <yilson.malambo@cun.edu.co>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alexis14kl/browser-ipc-cdp.git"
+  },
+  "homepage": "https://github.com/alexis14kl/browser-ipc-cdp#readme",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "templates/",
+    "README.md",
+    "LICENSE"
+  ]
+}