chromex-mcp 1.0.0

package/plugins/chromex/skills/chromex/scripts/lib/launcher.mjs

@@ -0,0 +1,111 @@
+// Browser launcher -- abre Chrome/Brave/Edge com remote debugging habilitado
+import { existsSync } from 'fs';
+import { spawn } from 'child_process';
+import { resolve } from 'path';
+import { homedir } from 'os';
+import { sleep } from './utils.mjs';
+import { getWsUrl } from './browser.mjs';
+
+const BROWSER_PATHS = {
+  darwin: {
+    chrome: '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+    brave: '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser',
+    edge: '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+    chromium: '/Applications/Chromium.app/Contents/MacOS/Chromium',
+    'chrome-canary': '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary',
+    vivaldi: '/Applications/Vivaldi.app/Contents/MacOS/Vivaldi',
+  },
+  linux: {
+    chrome: 'google-chrome',
+    brave: 'brave-browser',
+    edge: 'microsoft-edge',
+    chromium: 'chromium-browser',
+    vivaldi: 'vivaldi',
+  },
+};
+
+const PROFILES_DIR = resolve(homedir(), '.chromex/profiles');
+
+export async function launchBrowser(options = {}) {
+  const platform = process.platform === 'darwin' ? 'darwin' : 'linux';
+  const paths = BROWSER_PATHS[platform];
+  if (!paths) throw new Error(`Unsupported platform: ${process.platform}`);
+
+  // Encontrar browser
+  let browserPath;
+  if (options.browser) {
+    browserPath = paths[options.browser.toLowerCase()];
+    if (!browserPath) {
+      throw new Error(`Unknown browser: ${options.browser}. Available: ${Object.keys(paths).join(', ')}`);
+    }
+    if (platform === 'darwin' && !existsSync(browserPath)) {
+      throw new Error(`Browser not found: ${browserPath}`);
+    }
+  } else {
+    // Auto-detect: tentar na ordem
+    for (const path of Object.values(paths)) {
+      if (platform === 'darwin' ? existsSync(path) : true) {
+        browserPath = path;
+        break;
+      }
+    }
+    if (!browserPath) throw new Error('No supported browser found.');
+  }
+
+  const flags = [
+    '--remote-debugging-port=0', // Porta aleatória, Chrome escreve no DevToolsActivePort
+    '--no-first-run',
+    '--no-default-browser-check',
+  ];
+
+  if (options.incognito) flags.push('--incognito');
+
+  if (options.profile) {
+    const profilePath = resolve(PROFILES_DIR, options.profile);
+    flags.push(`--user-data-dir=${profilePath}`);
+  }
+
+  if (options.url) flags.push(options.url);
+
+  const child = spawn(browserPath, flags, {
+    detached: true,
+    stdio: 'ignore',
+  });
+  child.unref();
+
+  // Aguardar DevToolsActivePort aparecer
+  const maxWait = 10000;
+  const start = Date.now();
+  while (Date.now() - start < maxWait) {
+    try {
+      const wsUrl = getWsUrl();
+      if (wsUrl) {
+        const lines = [`Browser launched (PID: ${child.pid})`];
+        if (options.incognito) lines.push('Mode: incognito');
+        if (options.profile) lines.push(`Profile: ${options.profile}`);
+        lines.push(`Remote debugging active`);
+        return lines.join('\n');
+      }
+    } catch { /* aguardando */ }
+    await sleep(500);
+  }
+
+  return `Browser launched (PID: ${child.pid}) but DevToolsActivePort not found yet. Wait a moment and try "chromex list".`;
+}
+
+export async function incognitoContext(cdp, url) {
+  const { browserContextId } = await cdp.send('Target.createBrowserContext', {
+    disposeOnDetach: true,
+  });
+
+  const { targetId } = await cdp.send('Target.createTarget', {
+    url: url || 'about:blank',
+    browserContextId,
+  });
+
+  return {
+    targetId,
+    browserContextId,
+    message: `Incognito context created (targetId: ${targetId.slice(0, 8)}). Isolated cookies/storage.${url ? ` Navigated to ${url}.` : ''}`,
+  };
+}

package/plugins/chromex/skills/chromex/scripts/lib/security.mjs

@@ -0,0 +1,48 @@
+// Segurança: domain filtering, CDP method blocklist, audit log
+import { appendFileSync } from 'fs';
+
+export function checkDomain(url, config) {
+  if (!url) return null;
+  try {
+    const { hostname } = new URL(url);
+
+    if (config.allowedDomains?.length > 0) {
+      const allowed = config.allowedDomains.some(d =>
+        hostname === d || hostname.endsWith('.' + d)
+      );
+      if (!allowed) return `Domain "${hostname}" not in allowedDomains. Configure ~/.chromex/config.json`;
+    }
+
+    if (config.blockedDomains?.length > 0) {
+      const blocked = config.blockedDomains.find(d =>
+        hostname === d || hostname.endsWith('.' + d)
+      );
+      if (blocked) return `Domain "${hostname}" is blocked. Configure ~/.chromex/config.json`;
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export function isCdpMethodBlocked(method, config) {
+  if (!method) return false;
+  return config.blockedCdpMethods.some(m =>
+    m.toLowerCase() === method.toLowerCase()
+  );
+}
+
+export function audit(cmd, target, args, result, config) {
+  if (!config.auditLog) return;
+  const entry = {
+    ts: new Date().toISOString(),
+    cmd,
+    target: target?.slice(0, 12) || null,
+    args: (args || []).map(a => typeof a === 'string' && a.length > 120 ? a.slice(0, 120) + '...' : a).slice(0, 3),
+    ok: result?.ok ?? true,
+  };
+  try {
+    appendFileSync(config._auditLogPath, JSON.stringify(entry) + '\n');
+  } catch { /* falha no audit não deve quebrar o comando */ }
+}

package/plugins/chromex/skills/chromex/scripts/lib/utils.mjs

@@ -0,0 +1,47 @@
+// Utilitários compartilhados
+import { readdirSync } from 'fs';
+import { resolve } from 'path';
+
+const MIN_TARGET_PREFIX_LEN = 8;
+
+export const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+
+export function resolvePrefix(prefix, candidates, noun = 'target', missingHint = '') {
+  const upper = prefix.toUpperCase();
+  const matches = candidates.filter(c => c.toUpperCase().startsWith(upper));
+  if (matches.length === 0) {
+    const hint = missingHint ? ` ${missingHint}` : '';
+    throw new Error(`No ${noun} matching prefix "${prefix}".${hint}`);
+  }
+  if (matches.length > 1) {
+    throw new Error(`Ambiguous prefix "${prefix}" — matches ${matches.length} ${noun}s. Use more characters.`);
+  }
+  return matches[0];
+}
+
+export function getDisplayPrefixLength(targetIds) {
+  if (targetIds.length === 0) return MIN_TARGET_PREFIX_LEN;
+  const maxLen = Math.max(...targetIds.map(id => id.length));
+  for (let len = MIN_TARGET_PREFIX_LEN; len <= maxLen; len++) {
+    const prefixes = new Set(targetIds.map(id => id.slice(0, len).toUpperCase()));
+    if (prefixes.size === targetIds.length) return len;
+  }
+  return maxLen;
+}
+
+export function listDaemonSockets(socketDir) {
+  try {
+    return readdirSync(socketDir)
+      .filter(f => f.endsWith('.sock') && f !== '.token')
+      .map(f => ({
+        targetId: f.slice(0, -5),
+        socketPath: resolve(socketDir, f),
+      }));
+  } catch {
+    return [];
+  }
+}
+
+export function sockPath(socketDir, targetId) {
+  return resolve(socketDir, `${targetId}.sock`);
+}