browser-ipc-cdp 1.0.0 → 1.2.0

package/bin/cli.js

@@ -12,7 +12,7 @@
  *   npx browser-ipc-cdp --status         # Ver estado actual
  *   npx browser-ipc-cdp --uninstall      # Desinstalar
  */
-const { detectBrowsers, findBrowser, launchBrowser, detectExistingCDP } = require('../lib/browser');
+const { detectBrowsers, findBrowser, launchBrowser, detectExistingCDP, IS_WSL, IS_WIN, IS_MAC } = require('../lib/browser');
 const { setupPortproxy, setupFirewall } = require('../lib/network');
 const { updateMcpJson, getWslHostIp } = require('../lib/mcp');
 const { saveCdpInfo, loadCdpInfo } = require('../lib/config');
@@ -30,6 +30,8 @@ for (let i = 0; i < args.length; i++) {
 
 async function main() {
   banner();
+  const platform = IS_WIN ? 'Windows' : IS_WSL ? 'WSL (Windows host)' : IS_MAC ? 'macOS' : 'Linux';
+  log(`Plataforma: ${platform}`);
 
   // --list: listar navegadores
   if (flags.list) {

package/lib/browser.js

@@ -4,43 +4,203 @@ 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 IS_WIN = process.platform === 'win32';
+const IS_MAC = process.platform === 'darwin';
+
+// Detectar WSL: Linux pero con acceso a Windows
+function isWSL() {
+  if (IS_WIN || IS_MAC) return false;
+  try {
+    const version = fs.readFileSync('/proc/version', 'utf-8').toLowerCase();
+    if (version.includes('microsoft') || version.includes('wsl')) return true;
+  } catch (e) {}
+  try {
+    return fs.existsSync('/proc/sys/fs/binfmt_misc/WSLInterop');
+  } catch (e) {}
+  return false;
+}
+
+const IS_WSL = isWSL();
+const HOME = process.env.HOME || process.env.USERPROFILE || '';
+
+// En WSL: obtener paths de Windows via /mnt/c/
+function getWindowsEnv(varName) {
+  if (IS_WIN) return process.env[varName] || '';
+  if (IS_WSL) {
+    try {
+      const result = execSync(`cmd.exe /c echo %${varName}%`, { encoding: 'utf-8', timeout: 5000, stdio: 'pipe' });
+      const winPath = result.trim();
+      if (winPath && !winPath.includes('%')) {
+        // Convertir C:\Users\... a /mnt/c/Users/...
+        return winPath.replace(/\\/g, '/').replace(/^([A-Za-z]):/, (_, d) => `/mnt/${d.toLowerCase()}`);
+      }
+    } catch (e) {}
+  }
+  return '';
+}
+
+const LOCALAPPDATA = IS_WIN ? (process.env.LOCALAPPDATA || '') : getWindowsEnv('LOCALAPPDATA');
+const USERPROFILE = IS_WIN ? (process.env.USERPROFILE || '') : getWindowsEnv('USERPROFILE');
 
-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'),
+// Program Files: en WSL usar /mnt/c/
+const PROGRAMFILES = IS_WIN ? (process.env.PROGRAMFILES || 'C:\\Program Files')
+  : IS_WSL ? '/mnt/c/Program Files' : '';
+const PROGRAMFILES86 = IS_WIN ? (process.env['PROGRAMFILES(X86)'] || 'C:\\Program Files (x86)')
+  : IS_WSL ? '/mnt/c/Program Files (x86)' : '';
+
+// Rutas dinámicas por plataforma
+const BROWSER_REGISTRY = {
+  brave: {
+    win: [
+      path.join(PROGRAMFILES, 'BraveSoftware', 'Brave-Browser', 'Application', 'brave.exe'),
+      path.join(PROGRAMFILES86, 'BraveSoftware', 'Brave-Browser', 'Application', 'brave.exe'),
+      path.join(LOCALAPPDATA, 'BraveSoftware', 'Brave-Browser', 'Application', 'brave.exe'),
+    ],
+    wsl: [
+      path.join(PROGRAMFILES, 'BraveSoftware', 'Brave-Browser', 'Application', 'brave.exe'),
+      path.join(PROGRAMFILES86, 'BraveSoftware', 'Brave-Browser', 'Application', 'brave.exe'),
+      ...(LOCALAPPDATA ? [path.join(LOCALAPPDATA, 'BraveSoftware', 'Brave-Browser', 'Application', 'brave.exe')] : []),
+    ],
+    mac: [
+      '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser',
+      path.join(HOME, 'Applications', 'Brave Browser.app', 'Contents', 'MacOS', 'Brave Browser'),
+    ],
+    linux: [
+      '/usr/bin/brave-browser',
+      '/usr/bin/brave',
+      '/snap/bin/brave',
+      '/opt/brave.com/brave/brave-browser',
+    ],
+    userData: {
+      win: path.join(LOCALAPPDATA, 'BraveSoftware', 'Brave-Browser', 'User Data'),
+      wsl: LOCALAPPDATA ? path.join(LOCALAPPDATA, 'BraveSoftware', 'Brave-Browser', 'User Data') : '',
+      mac: path.join(HOME, 'Library', 'Application Support', 'BraveSoftware', 'Brave-Browser'),
+      linux: path.join(HOME, '.config', 'BraveSoftware', 'Brave-Browser'),
+    },
+    processName: { win: 'brave.exe', wsl: 'brave.exe', mac: 'Brave Browser', linux: 'brave' },
+  },
+  chrome: {
+    win: [
+      path.join(PROGRAMFILES, 'Google', 'Chrome', 'Application', 'chrome.exe'),
+      path.join(PROGRAMFILES86, 'Google', 'Chrome', 'Application', 'chrome.exe'),
+      path.join(LOCALAPPDATA, 'Google', 'Chrome', 'Application', 'chrome.exe'),
+    ],
+    wsl: [
+      path.join(PROGRAMFILES, 'Google', 'Chrome', 'Application', 'chrome.exe'),
+      path.join(PROGRAMFILES86, 'Google', 'Chrome', 'Application', 'chrome.exe'),
+      ...(LOCALAPPDATA ? [path.join(LOCALAPPDATA, 'Google', 'Chrome', 'Application', 'chrome.exe')] : []),
+    ],
+    mac: [
+      '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+      path.join(HOME, 'Applications', 'Google Chrome.app', 'Contents', 'MacOS', 'Google Chrome'),
+    ],
+    linux: [
+      '/usr/bin/google-chrome',
+      '/usr/bin/google-chrome-stable',
+      '/snap/bin/chromium',
+      '/usr/bin/chromium-browser',
+      '/usr/bin/chromium',
+    ],
+    userData: {
+      win: path.join(LOCALAPPDATA, 'Google', 'Chrome', 'User Data'),
+      wsl: LOCALAPPDATA ? path.join(LOCALAPPDATA, 'Google', 'Chrome', 'User Data') : '',
+      mac: path.join(HOME, 'Library', 'Application Support', 'Google', 'Chrome'),
+      linux: path.join(HOME, '.config', 'google-chrome'),
+    },
+    processName: { win: 'chrome.exe', wsl: 'chrome.exe', mac: 'Google Chrome', linux: 'chrome' },
+  },
+  edge: {
+    win: [
+      path.join(PROGRAMFILES86, 'Microsoft', 'Edge', 'Application', 'msedge.exe'),
+      path.join(PROGRAMFILES, 'Microsoft', 'Edge', 'Application', 'msedge.exe'),
+    ],
+    wsl: [
+      path.join(PROGRAMFILES86, 'Microsoft', 'Edge', 'Application', 'msedge.exe'),
+      path.join(PROGRAMFILES, 'Microsoft', 'Edge', 'Application', 'msedge.exe'),
+    ],
+    mac: [
+      '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+    ],
+    linux: [
+      '/usr/bin/microsoft-edge',
+      '/usr/bin/microsoft-edge-stable',
+    ],
+    userData: {
+      win: path.join(LOCALAPPDATA, 'Microsoft', 'Edge', 'User Data'),
+      wsl: LOCALAPPDATA ? path.join(LOCALAPPDATA, 'Microsoft', 'Edge', 'User Data') : '',
+      mac: path.join(HOME, 'Library', 'Application Support', 'Microsoft Edge'),
+      linux: path.join(HOME, '.config', 'microsoft-edge'),
+    },
+    processName: { win: 'msedge.exe', wsl: 'msedge.exe', mac: 'Microsoft Edge', linux: 'msedge' },
+  },
+  chromium: {
+    win: [
+      path.join(LOCALAPPDATA, 'Chromium', 'Application', 'chrome.exe'),
+    ],
+    wsl: [
+      ...(LOCALAPPDATA ? [path.join(LOCALAPPDATA, 'Chromium', 'Application', 'chrome.exe')] : []),
+    ],
+    mac: [
+      '/Applications/Chromium.app/Contents/MacOS/Chromium',
+    ],
+    linux: [
+      '/usr/bin/chromium',
+      '/usr/bin/chromium-browser',
+      '/snap/bin/chromium',
+    ],
+    userData: {
+      win: path.join(LOCALAPPDATA, 'Chromium', 'User Data'),
+      wsl: LOCALAPPDATA ? path.join(LOCALAPPDATA, 'Chromium', 'User Data') : '',
+      mac: path.join(HOME, 'Library', 'Application Support', 'Chromium'),
+      linux: path.join(HOME, '.config', 'chromium'),
+    },
+    processName: { win: 'chrome.exe', wsl: 'chrome.exe', mac: 'Chromium', linux: 'chromium' },
+  },
 };
 
+function getPlatform() {
+  if (IS_WIN) return 'win';
+  if (IS_WSL) return 'wsl';
+  if (IS_MAC) return 'mac';
+  return 'linux';
+}
+
+function getBrowserPaths(name) {
+  const entry = BROWSER_REGISTRY[name];
+  if (!entry) return { paths: [], userData: '', processName: '' };
+  const plat = getPlatform();
+  return {
+    paths: entry[plat] || [],
+    userData: (entry.userData && entry.userData[plat]) || '',
+    processName: (entry.processName && entry.processName[plat]) || name,
+  };
+}
+
 function detectBrowsers() {
   const found = [];
-  for (const [name, paths] of Object.entries(BROWSER_PATHS)) {
+  for (const name of Object.keys(BROWSER_REGISTRY)) {
+    const { paths, userData } = getBrowserPaths(name);
     for (const p of paths) {
       if (fs.existsSync(p)) {
-        found.push({
-          name,
-          exe: p,
-          userData: BROWSER_USER_DATA[name] || '',
-        });
+        found.push({ name, exe: p, userData });
         break;
       }
     }
   }
+  // Fallback: buscar en PATH
+  const cmds = IS_WIN
+    ? ['brave', 'chrome', 'msedge']
+    : ['brave-browser', 'brave', 'google-chrome', 'google-chrome-stable', 'chromium', 'chromium-browser', 'microsoft-edge'];
+  for (const cmd of cmds) {
+    try {
+      const which = IS_WIN
+        ? execSync(`where ${cmd} 2>nul`, { encoding: 'utf-8', timeout: 5000 }).trim().split('\n')[0]
+        : execSync(`which ${cmd} 2>/dev/null`, { encoding: 'utf-8', timeout: 5000 }).trim();
+      if (which && fs.existsSync(which) && !found.some(b => b.exe === which)) {
+        found.push({ name: cmd, exe: which, userData: '' });
+      }
+    } catch (e) {}
+  }
   return found;
 }
 
@@ -85,13 +245,19 @@ function testCdp(port, timeout = 3000) {
 }
 
 function isBrowserRunning(exe) {
-  const exeName = path.basename(exe).toLowerCase();
+  const exeName = path.basename(exe);
   try {
-    const result = execSync(
-      `tasklist /FI "IMAGENAME eq ${exeName}" /FO CSV /NH`,
-      { timeout: 10000, encoding: 'utf-8' }
-    );
-    return result.toLowerCase().includes(exeName);
+    if (IS_WIN || IS_WSL) {
+      // Windows y WSL: usar tasklist de Windows
+      const cmd = IS_WSL
+        ? `cmd.exe /c tasklist /FI "IMAGENAME eq ${exeName}" /FO CSV /NH`
+        : `tasklist /FI "IMAGENAME eq ${exeName}" /FO CSV /NH`;
+      const result = execSync(cmd, { timeout: 10000, encoding: 'utf-8', stdio: 'pipe' });
+      return result.toLowerCase().includes(exeName.toLowerCase());
+    } else {
+      const result = execSync(`pgrep -f "${exeName}"`, { timeout: 5000, stdio: 'pipe' });
+      return result.length > 0;
+    }
   } catch (e) {
     return false;
   }
@@ -115,14 +281,22 @@ async function detectExistingCDP(browser) {
     }
   }
 
-  // 2. Command line
+  // 2. Command line scan
   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})/);
+    const exeName = path.basename(browser.exe);
+    let cmdOutput = '';
+    if (IS_WIN || IS_WSL) {
+      const wmicCmd = `wmic process where "name='${exeName}'" get commandline /format:list`;
+      cmdOutput = IS_WSL
+        ? execSync(`cmd.exe /c ${wmicCmd}`, { timeout: 10000, encoding: 'utf-8', stdio: 'pipe' })
+        : execSync(wmicCmd, { timeout: 10000, encoding: 'utf-8', stdio: 'pipe' });
+    } else {
+      cmdOutput = execSync(
+        `ps aux | grep "${exeName}" | grep -v grep`,
+        { timeout: 10000, encoding: 'utf-8', stdio: 'pipe' }
+      );
+    }
+    const match = cmdOutput.match(/--remote-debugging-port[=\s](\d{2,5})/);
     if (match) {
       const port = parseInt(match[1]);
       if (port > 0) {
@@ -132,37 +306,70 @@ async function detectExistingCDP(browser) {
     }
   } catch (e) {}
 
-  // 3. Scan ports via netstat
+  // 3. Scan ports
   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 exeName = path.basename(browser.exe);
     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 (IS_WIN || IS_WSL) {
+      const taskCmd = `tasklist /FI "IMAGENAME eq ${exeName}" /FO CSV /NH`;
+      const taskResult = IS_WSL
+        ? execSync(`cmd.exe /c ${taskCmd}`, { timeout: 10000, encoding: 'utf-8', stdio: 'pipe' })
+        : execSync(taskCmd, { timeout: 10000, encoding: 'utf-8', stdio: 'pipe' });
+      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);
+        }
+      });
+    } else {
+      const pgrepResult = execSync(`pgrep -f "${exeName}"`,
+        { timeout: 5000, encoding: 'utf-8', stdio: 'pipe' });
+      pgrepResult.trim().split('\n').forEach(p => {
+        const pid = parseInt(p.trim());
         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;
+      if (IS_WIN || IS_WSL) {
+        const netstatCmd = 'netstat -ano -p tcp';
+        const netstat = IS_WSL
+          ? execSync(`cmd.exe /c ${netstatCmd}`, { timeout: 10000, encoding: 'utf-8', stdio: 'pipe' })
+          : execSync(netstatCmd, { timeout: 10000, encoding: 'utf-8', stdio: 'pipe' });
+        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;
+              }
             }
           }
         }
+      } else {
+        // Mac/Linux: use lsof or ss
+        for (const pid of pids) {
+          try {
+            const lsof = execSync(`lsof -i -P -n -p ${pid} 2>/dev/null | grep LISTEN`,
+              { timeout: 10000, encoding: 'utf-8', stdio: 'pipe' });
+            for (const line of lsof.split('\n')) {
+              const match = line.match(/:(\d+)\s/);
+              if (match) {
+                const port = parseInt(match[1]);
+                if (port > 1024) {
+                  const cdp = await testCdp(port);
+                  if (cdp) return port;
+                }
+              }
+            }
+          } catch (e) {}
+        }
       }
     }
   } catch (e) {}
@@ -173,7 +380,13 @@ async function detectExistingCDP(browser) {
 function killBrowser(exe) {
   const exeName = path.basename(exe);
   try {
-    execSync(`taskkill /F /IM ${exeName}`, { timeout: 10000, stdio: 'pipe' });
+    if (IS_WIN) {
+      execSync(`taskkill /F /IM ${exeName}`, { timeout: 10000, stdio: 'pipe' });
+    } else if (IS_WSL) {
+      execSync(`cmd.exe /c taskkill /F /IM ${exeName}`, { timeout: 10000, stdio: 'pipe' });
+    } else {
+      execSync(`pkill -f "${exeName}"`, { timeout: 10000, stdio: 'pipe' });
+    }
   } catch (e) {}
 }
 
@@ -198,10 +411,22 @@ function launchBrowser(browser, { port = 0, clean = false } = {}) {
       ];
       if (clean) args.push(`--user-data-dir=${userData}`);
 
-      const child = spawn(browser.exe, args, {
-        detached: true,
-        stdio: 'ignore',
-      });
+      const spawnOpts = { detached: true, stdio: 'ignore' };
+      let child;
+
+      if (IS_WSL) {
+        // WSL: convertir ruta /mnt/c/... a C:\... y lanzar via cmd.exe
+        const winExe = browser.exe.replace(/^\/mnt\/([a-z])\//, (_, d) => `${d.toUpperCase()}:\\`).replace(/\//g, '\\');
+        const winArgs = args.map(a => {
+          if (a.startsWith('--user-data-dir=/mnt/')) {
+            return a.replace(/^--user-data-dir=\/mnt\/([a-z])\//, (_, d) => `--user-data-dir=${d.toUpperCase()}:\\`).replace(/\//g, '\\');
+          }
+          return a;
+        });
+        child = spawn('cmd.exe', ['/c', 'start', '', winExe, ...winArgs], spawnOpts);
+      } else {
+        child = spawn(browser.exe, args, spawnOpts);
+      }
       child.unref();
 
       log(`        PID: ${child.pid}`);
@@ -243,4 +468,4 @@ function launchBrowser(browser, { port = 0, clean = false } = {}) {
   });
 }
 
-module.exports = { detectBrowsers, findBrowser, detectExistingCDP, launchBrowser, testCdp };
+module.exports = { detectBrowsers, findBrowser, detectExistingCDP, launchBrowser, testCdp, IS_WSL, IS_WIN, IS_MAC };

package/lib/mcp.js

@@ -4,6 +4,13 @@ const path = require('path');
 const { log, success, warn } = require('./logger');
 
 function getWslHostIp() {
+  const IS_WIN = process.platform === 'win32';
+
+  // Mac/Linux: localhost funciona directo, no necesita IP especial
+  if (!IS_WIN) return '127.0.0.1';
+
+  // Windows: detectar IP para WSL
+
   // 1. Desde WSL: leer resolv.conf directamente
   try {
     if (fs.existsSync('/etc/resolv.conf')) {
@@ -14,26 +21,24 @@ function getWslHostIp() {
   } 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 {
-      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];
+      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) {}
-
-    // 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';

package/lib/network.js

@@ -1,12 +1,50 @@
 const { execSync } = require('child_process');
 const { log, success, warn } = require('./logger');
 
+const IS_WIN = process.platform === 'win32';
+let IS_WSL = false;
+try { const { IS_WSL: w } = require('./browser'); IS_WSL = w; } catch (e) {
+  try {
+    const fs = require('fs');
+    const v = fs.readFileSync('/proc/version', 'utf-8').toLowerCase();
+    IS_WSL = v.includes('microsoft') || v.includes('wsl');
+  } catch (e2) {}
+}
+
+const NEEDS_NETSH = IS_WIN; // WSL no necesita netsh, usa host IP directo
 const FIREWALL_RULE = 'CDP All Ports (IPC)';
 
 function setupFirewall() {
-  if (process.platform !== 'win32') return false;
+  // Solo Windows nativo necesita firewall
+  // WSL: el navegador corre en Windows pero WSL accede via host IP, firewall ya debe estar abierto
+  // Mac/Linux: localhost directo
+  if (!NEEDS_NETSH) {
+    if (IS_WSL) {
+      // En WSL: ejecutar netsh via cmd.exe para crear la regla en Windows
+      try {
+        const check = execSync(
+          `cmd.exe /c netsh advfirewall firewall show rule name="${FIREWALL_RULE}"`,
+          { timeout: 10000, encoding: 'utf-8', stdio: 'pipe' }
+        );
+        if (check.includes(FIREWALL_RULE)) return true;
+      } catch (e) {}
+
+      try {
+        execSync(
+          `cmd.exe /c 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 (via WSL)');
+        return true;
+      } catch (e) {
+        warn('Firewall: no se pudo crear regla desde WSL (ejecuta como Admin en Windows)');
+        return false;
+      }
+    }
+    return true;
+  }
 
-  // Verificar si ya existe
+  // Windows nativo
   try {
     const check = execSync(
       `netsh advfirewall firewall show rule name="${FIREWALL_RULE}"`,
@@ -15,7 +53,6 @@ function setupFirewall() {
     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`,
@@ -30,9 +67,36 @@ function setupFirewall() {
 }
 
 function setupPortproxy(port) {
-  if (process.platform !== 'win32') return false;
+  // Mac/Linux nativo: no necesita portproxy
+  if (!IS_WIN && !IS_WSL) {
+    return true;
+  }
+
+  // WSL: ejecutar netsh via cmd.exe
+  if (IS_WSL) {
+    try {
+      const check = execSync('cmd.exe /c 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) {}
+
+    try {
+      execSync(
+        `cmd.exe /c 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} (via WSL)`);
+      return true;
+    } catch (e) {
+      warn(`Portproxy: fallo desde WSL (ejecuta como Admin en Windows)`);
+      return false;
+    }
+  }
 
-  // Verificar si ya existe
+  // Windows nativo
   try {
     const check = execSync('netsh interface portproxy show all',
       { timeout: 10000, encoding: 'utf-8', stdio: 'pipe' });
@@ -42,7 +106,6 @@ function setupPortproxy(port) {
     }
   } 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}`,

package/package.json

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