browser-ipc-cdp 1.0.0 → 1.1.0

package/lib/browser.js

@@ -4,43 +4,144 @@ 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';
+const HOME = process.env.HOME || process.env.USERPROFILE || '';
+const LOCALAPPDATA = process.env.LOCALAPPDATA || '';
+const PROGRAMFILES = process.env.PROGRAMFILES || 'C:\\Program Files';
+const PROGRAMFILES86 = process.env['PROGRAMFILES(X86)'] || 'C:\\Program Files (x86)';
 
-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'),
+// 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'),
+    ],
+    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'),
+      mac: path.join(HOME, 'Library', 'Application Support', 'BraveSoftware', 'Brave-Browser'),
+      linux: path.join(HOME, '.config', 'BraveSoftware', 'Brave-Browser'),
+    },
+    processName: { win: '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'),
+    ],
+    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'),
+      mac: path.join(HOME, 'Library', 'Application Support', 'Google', 'Chrome'),
+      linux: path.join(HOME, '.config', 'google-chrome'),
+    },
+    processName: { win: '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'),
+    ],
+    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'),
+      mac: path.join(HOME, 'Library', 'Application Support', 'Microsoft Edge'),
+      linux: path.join(HOME, '.config', 'microsoft-edge'),
+    },
+    processName: { win: 'msedge.exe', mac: 'Microsoft Edge', linux: 'msedge' },
+  },
+  chromium: {
+    win: [
+      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'),
+      mac: path.join(HOME, 'Library', 'Application Support', 'Chromium'),
+      linux: path.join(HOME, '.config', 'chromium'),
+    },
+    processName: { win: 'chrome.exe', mac: 'Chromium', linux: 'chromium' },
+  },
 };
 
+function getPlatform() {
+  if (IS_WIN) return 'win';
+  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 +186,18 @@ 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) {
+      const result = execSync(
+        `tasklist /FI "IMAGENAME eq ${exeName}" /FO CSV /NH`,
+        { 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 +221,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) {
+      cmdOutput = execSync(
+        `wmic process where "name='${exeName}'" get commandline /format:list`,
+        { 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 +246,67 @@ 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) {
+      const taskResult = execSync(
+        `tasklist /FI "IMAGENAME eq ${exeName}" /FO CSV /NH`,
+        { 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) {
+        const netstat = execSync('netstat -ano -p tcp', { 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 +317,11 @@ 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 {
+      execSync(`pkill -f "${exeName}"`, { timeout: 10000, stdio: 'pipe' });
+    }
   } catch (e) {}
 }
 
@@ -198,10 +346,14 @@ 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' };
+      // En Mac, si el exe es un .app, necesita 'open' como wrapper
+      let cmd = browser.exe;
+      let spawnArgs = args;
+      if (IS_MAC && browser.exe.includes('.app/')) {
+        // Ejecutar directo el binario dentro del .app
+      }
+      const child = spawn(cmd, spawnArgs, spawnOpts);
       child.unref();
 
       log(`        PID: ${child.pid}`);

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,10 +1,16 @@
 const { execSync } = require('child_process');
 const { log, success, warn } = require('./logger');
 
+const IS_WIN = process.platform === 'win32';
 const FIREWALL_RULE = 'CDP All Ports (IPC)';
 
 function setupFirewall() {
-  if (process.platform !== 'win32') return false;
+  // Solo necesario en Windows (WSL requiere reglas de firewall)
+  // Mac/Linux no necesitan firewall para localhost
+  if (!IS_WIN) {
+    log('        Firewall: no necesario en esta plataforma');
+    return true;
+  }
 
   // Verificar si ya existe
   try {
@@ -30,7 +36,12 @@ function setupFirewall() {
 }
 
 function setupPortproxy(port) {
-  if (process.platform !== 'win32') return false;
+  // Solo necesario en Windows (WSL no alcanza 127.0.0.1 de Windows)
+  // Mac/Linux: localhost funciona directo
+  if (!IS_WIN) {
+    log('        Portproxy: no necesario en esta plataforma');
+    return true;
+  }
 
   // Verificar si ya existe
   try {

package/package.json

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