chromex-mcp 1.0.0

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

@@ -0,0 +1,100 @@
+// Configuração centralizada -- paths, defaults, load/save
+import { readFileSync, writeFileSync, existsSync, mkdirSync, copyFileSync } from 'fs';
+import { resolve } from 'path';
+import { homedir } from 'os';
+
+const CONFIG_DIR_NEW = resolve(homedir(), '.chromex');
+const CONFIG_DIR_LEGACY = resolve(homedir(), '.config/cdp-skill');
+
+export function getConfigDir() {
+  // Preferir novo path; fallback para legado se existir
+  if (existsSync(resolve(CONFIG_DIR_NEW, 'config.json'))) return CONFIG_DIR_NEW;
+  if (existsSync(resolve(CONFIG_DIR_LEGACY, 'config.json'))) return CONFIG_DIR_LEGACY;
+  return CONFIG_DIR_NEW;
+}
+
+export function getAuditLogPath(configDir) {
+  return resolve(configDir, 'audit.log');
+}
+
+export function getSocketDir(configDir) {
+  const dir = process.env.XDG_RUNTIME_DIR
+    ? resolve(process.env.XDG_RUNTIME_DIR, 'chromex')
+    : resolve(configDir, 'run');
+  ensureDir(dir);
+  return dir;
+}
+
+export function getTokenPath(socketDir) {
+  return resolve(socketDir, '.token');
+}
+
+export function getPagesCachePath(socketDir) {
+  return resolve(socketDir, 'pages.json');
+}
+
+export function ensureDir(dir) {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 0o700 });
+}
+
+const DEFAULTS = {
+  commandTimeout: 15000,
+  navigationTimeout: 30000,
+  idleTimeout: 20 * 60 * 1000,
+  allowedDomains: [],
+  blockedDomains: [],
+  blockedCdpMethods: [
+    'Network.enable',
+    'Network.setRequestInterception',
+    'Network.setCacheDisabled',
+    'Page.setDocumentContent',
+    'Security.disable',
+    'Security.setIgnoreCertificateErrors',
+    'Fetch.enable',
+    'Fetch.fulfillRequest',
+    'Fetch.continueRequest',
+    'Browser.close',
+    'Browser.crashGpuProcess',
+    'Target.disposeBrowserContext',
+    'SystemInfo.getProcessInfo',
+    'Storage.clearDataForOrigin',
+    'Storage.getCookies',
+    'IndexedDB.requestData',
+  ],
+  auditLog: true,
+  socketAuth: true,
+  defaultScreenshotPath: '/tmp/screenshot.png',
+};
+
+export function loadConfig() {
+  const configDir = getConfigDir();
+  ensureDir(configDir);
+  const configPath = resolve(configDir, 'config.json');
+
+  let userConfig = {};
+  if (existsSync(configPath)) {
+    try {
+      userConfig = JSON.parse(readFileSync(configPath, 'utf8'));
+    } catch { /* config corrompida, usar defaults */ }
+  } else {
+    // Migrar config legada se existir
+    const legacyPath = resolve(CONFIG_DIR_LEGACY, 'config.json');
+    if (configDir === CONFIG_DIR_NEW && existsSync(legacyPath)) {
+      try {
+        copyFileSync(legacyPath, configPath);
+        userConfig = JSON.parse(readFileSync(configPath, 'utf8'));
+      } catch { /* falha na migração, usar defaults */ }
+    } else {
+      // Primeira execução: gerar config default
+      writeFileSync(configPath, JSON.stringify(DEFAULTS, null, 2));
+    }
+  }
+
+  const config = { ...DEFAULTS, ...userConfig };
+  config._configDir = configDir;
+  config._socketDir = getSocketDir(configDir);
+  config._tokenPath = getTokenPath(config._socketDir);
+  config._pagesCachePath = getPagesCachePath(config._socketDir);
+  config._auditLogPath = getAuditLogPath(configDir);
+  return config;
+}

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

@@ -0,0 +1,368 @@
+// Per-tab daemon: mantém sessão CDP aberta, recebe comandos via Unix socket
+import { readFileSync, writeFileSync, unlinkSync, existsSync } from 'fs';
+import { randomBytes } from 'crypto';
+import net from 'net';
+import { CDP } from './client.mjs';
+import { getWsUrl, getPages, formatPageList } from './browser.mjs';
+import { audit } from './security.mjs';
+import { sockPath } from './utils.mjs';
+
+// Importar todos os comandos
+import { snapshotStr } from './commands/snapshot.mjs';
+import { evalStr, evalRawStr } from './commands/evaluate.mjs';
+import { shotStr } from './commands/screenshot.mjs';
+import { navStr } from './commands/navigate.mjs';
+import { htmlStr } from './commands/html.mjs';
+import { netStr } from './commands/network.mjs';
+import { clickStr, clickXyStr, typeStr, loadAllStr, waitForStr } from './commands/interact.mjs';
+import { fillStr, clearStr, selectStr, checkStr, formStr } from './commands/form.mjs';
+import { scrollStr } from './commands/scroll.mjs';
+import { cookiesStr } from './commands/cookies.mjs';
+import { pdfStr } from './commands/pdf.mjs';
+import { consoleStr } from './commands/console.mjs';
+import { storageStr } from './commands/storage.mjs';
+import { emulateStr } from './commands/emulate.mjs';
+import { perfStr } from './commands/perf.mjs';
+// Tier 1
+import { waitLifecycleStr } from './commands/wait.mjs';
+import { openTabStr, closeTabStr, focusTabStr } from './commands/tab.mjs';
+import { dialogStr, setupAutoDialog } from './commands/dialog.mjs';
+import { uploadStr } from './commands/upload.mjs';
+import { geoStr, timezoneStr, localeStr } from './commands/geo.mjs';
+import { throttleStr } from './commands/throttle.mjs';
+import { cpuStr } from './commands/cpu.mjs';
+import { injectStr } from './commands/inject.mjs';
+import { downloadStr } from './commands/download.mjs';
+// Tier 2
+import { interceptStr } from './commands/intercept.mjs';
+import { harStr } from './commands/har.mjs';
+import { coverageStr } from './commands/coverage.mjs';
+// Tier 3
+import { traceStr } from './commands/trace.mjs';
+import { heapStr } from './commands/heap.mjs';
+import { webauthnStr } from './commands/webauthn.mjs';
+import { dragStr } from './commands/drag.mjs';
+import { touchStr } from './commands/touch.mjs';
+import { domsnapshotStr } from './commands/domsnapshot.mjs';
+import { parseRef, clickRefStr, hoverRefStr, fillRefStr } from './commands/refs.mjs';
+import { highlightStr } from './commands/highlight.mjs';
+
+export function getOrCreateToken(config) {
+  if (!config.socketAuth) return null;
+  const tokenPath = config._tokenPath;
+  if (existsSync(tokenPath)) {
+    return readFileSync(tokenPath, 'utf8').trim();
+  }
+  const token = randomBytes(32).toString('hex');
+  writeFileSync(tokenPath, token, { mode: 0o600 });
+  return token;
+}
+
+export async function runDaemon(targetId, config) {
+  const sp = sockPath(config._socketDir, targetId);
+  const authToken = getOrCreateToken(config);
+
+  const cdp = new CDP(config.commandTimeout);
+  try {
+    await cdp.connect(getWsUrl());
+  } catch (e) {
+    process.stderr.write(`Daemon: cannot connect to Chrome: ${e.message}\n`);
+    process.exit(1);
+  }
+
+  let sessionId;
+  try {
+    const res = await cdp.send('Target.attachToTarget', { targetId, flatten: true });
+    sessionId = res.sessionId;
+  } catch (e) {
+    process.stderr.write(`Daemon: attach failed: ${e.message}\n`);
+    cdp.close();
+    process.exit(1);
+  }
+
+  let alive = true;
+  function shutdown() {
+    if (!alive) return;
+    alive = false;
+    server.close();
+    try { unlinkSync(sp); } catch { /* socket já removido */ }
+    cdp.close();
+    process.exit(0);
+  }
+
+  cdp.onEvent('Target.targetDestroyed', (params) => {
+    if (params.targetId === targetId) shutdown();
+  });
+  cdp.onEvent('Target.detachedFromTarget', (params) => {
+    if (params.sessionId === sessionId) shutdown();
+  });
+  cdp.onClose(() => shutdown());
+  process.on('SIGTERM', shutdown);
+  process.on('SIGINT', shutdown);
+
+  let idleTimer = setTimeout(shutdown, config.idleTimeout);
+  function resetIdle() {
+    clearTimeout(idleTimer);
+    idleTimer = setTimeout(shutdown, config.idleTimeout);
+  }
+
+  // Ref-based selection state: stores mapping from @eN -> {backendNodeId, role, name}
+  let currentRefMap = new Map();
+
+  async function handleCommand({ cmd, args }) {
+    resetIdle();
+    const auditResult = { ok: true };
+    try {
+      // Ref-based dispatch: click @e5, fill @e3 "value", hover @e12
+      if (args[0] && parseRef(args[0]) !== null) {
+        const refNum = parseRef(args[0]);
+        let result;
+        if (cmd === 'click') {
+          result = await clickRefStr(cdp, sessionId, currentRefMap, refNum);
+        } else if (cmd === 'fill') {
+          result = await fillRefStr(cdp, sessionId, currentRefMap, refNum, args.slice(1).join(' '));
+        } else if (cmd === 'hover') {
+          result = await hoverRefStr(cdp, sessionId, currentRefMap, refNum);
+        } else {
+          throw new Error(`Ref @e${refNum} not supported for command "${cmd}". Use with: click, fill, hover.`);
+        }
+        audit(cmd, targetId, args, auditResult, config);
+        return { ok: true, result };
+      }
+
+      let result;
+      switch (cmd) {
+        // --- Comandos originais ---
+        case 'list': {
+          const pages = await getPages(cdp);
+          result = formatPageList(pages, config);
+          break;
+        }
+        case 'list_raw': {
+          const pages = await getPages(cdp);
+          result = JSON.stringify(pages);
+          break;
+        }
+        case 'snap': case 'snapshot': {
+          const useRefs = args.includes('--refs') || args.includes('-i');
+          const snapResult = await snapshotStr(cdp, sessionId, true, useRefs);
+          result = snapResult.text;
+          if (useRefs && snapResult.refMap.size > 0) {
+            currentRefMap = snapResult.refMap;
+          }
+          break;
+        }
+        case 'eval':
+          result = await evalStr(cdp, sessionId, args[0]);
+          break;
+        case 'shot': case 'screenshot': {
+          const full = args.includes('--full');
+          const file = args.find(a => a && a !== '--full');
+          result = await shotStr(cdp, sessionId, file, full, config);
+          break;
+        }
+        case 'html':
+          result = await htmlStr(cdp, sessionId, args[0]);
+          break;
+        case 'nav': case 'navigate':
+          result = await navStr(cdp, sessionId, args[0], config);
+          break;
+        case 'net': case 'network':
+          result = await netStr(cdp, sessionId);
+          break;
+        case 'click':
+          result = await clickStr(cdp, sessionId, args[0]);
+          break;
+        case 'clickxy':
+          result = await clickXyStr(cdp, sessionId, args[0], args[1]);
+          break;
+        case 'type':
+          result = await typeStr(cdp, sessionId, args[0]);
+          break;
+        case 'loadall':
+          result = await loadAllStr(cdp, sessionId, args[0], args[1] ? parseInt(args[1]) : 1500);
+          break;
+        case 'evalraw':
+          result = await evalRawStr(cdp, sessionId, args[0], args[1], config);
+          break;
+        case 'waitfor':
+          result = await waitForStr(cdp, sessionId, args[0], args[1] ? parseInt(args[1]) : undefined, config);
+          break;
+        // --- Novos comandos ---
+        case 'fill':
+          result = await fillStr(cdp, sessionId, args[0], args.slice(1).join(' '));
+          break;
+        case 'clear':
+          result = await clearStr(cdp, sessionId, args[0]);
+          break;
+        case 'select':
+          result = await selectStr(cdp, sessionId, args[0], args.slice(1).join(' '));
+          break;
+        case 'check':
+          result = await checkStr(cdp, sessionId, args[0], args[1] !== 'false');
+          break;
+        case 'form':
+          result = await formStr(cdp, sessionId, args[0]);
+          break;
+        case 'scroll':
+          result = await scrollStr(cdp, sessionId, args[0], args[1]);
+          break;
+        case 'cookies':
+          result = await cookiesStr(cdp, sessionId, args[0], args.slice(1).join(' ') || undefined);
+          break;
+        case 'pdf':
+          result = await pdfStr(cdp, sessionId, args[0]);
+          break;
+        case 'console':
+          result = await consoleStr(cdp, sessionId, args[0]);
+          break;
+        case 'storage':
+          result = await storageStr(cdp, sessionId, args[0]);
+          break;
+        case 'emulate':
+          result = await emulateStr(cdp, sessionId, args[0]);
+          break;
+        case 'perf':
+          result = await perfStr(cdp, sessionId);
+          break;
+        // --- Tier 1: Quick Wins ---
+        case 'wait':
+          result = await waitLifecycleStr(cdp, sessionId, args[0], args[1], config);
+          break;
+        case 'open':
+          result = await openTabStr(cdp, args[0]);
+          break;
+        case 'close':
+          result = await closeTabStr(cdp, args[0]);
+          break;
+        case 'focus':
+          result = await focusTabStr(cdp, args[0]);
+          break;
+        case 'dialog': {
+          const dialogResult = await dialogStr(cdp, sessionId, args[0], args.slice(1).join(' ') || undefined);
+          if (dialogResult === '__AUTO_DIALOG__') {
+            result = setupAutoDialog(cdp, sessionId);
+          } else {
+            result = dialogResult;
+          }
+          break;
+        }
+        case 'upload':
+          result = await uploadStr(cdp, sessionId, args[0], ...args.slice(1));
+          break;
+        case 'geo':
+          result = await geoStr(cdp, sessionId, args[0], args[1], args[2]);
+          break;
+        case 'timezone':
+          result = await timezoneStr(cdp, sessionId, args[0]);
+          break;
+        case 'locale':
+          result = await localeStr(cdp, sessionId, args[0]);
+          break;
+        case 'throttle':
+          result = await throttleStr(cdp, sessionId, args[0], ...args.slice(1));
+          break;
+        case 'cpu':
+          result = await cpuStr(cdp, sessionId, args[0]);
+          break;
+        case 'inject':
+          result = await injectStr(cdp, sessionId, args[0], args.slice(1).join(' ') || undefined);
+          break;
+        case 'download':
+          result = await downloadStr(cdp, sessionId, args[0], args[1]);
+          break;
+        // --- Tier 2: Game Changers ---
+        case 'intercept':
+          result = await interceptStr(cdp, sessionId, args[0], args[1], args.slice(2).join(' ') || undefined);
+          break;
+        case 'har':
+          result = await harStr(cdp, sessionId, args[0], args[1]);
+          break;
+        case 'coverage':
+          result = await coverageStr(cdp, sessionId, args[0]);
+          break;
+        // --- Tier 3: Pro Features ---
+        case 'trace':
+          result = await traceStr(cdp, sessionId, args[0], args[1]);
+          break;
+        case 'heap':
+          result = await heapStr(cdp, sessionId, args[0], args[1]);
+          break;
+        case 'webauthn':
+          result = await webauthnStr(cdp, sessionId, args[0]);
+          break;
+        case 'drag':
+          result = await dragStr(cdp, sessionId, args[0], args[1]);
+          break;
+        case 'touch':
+          result = await touchStr(cdp, sessionId, args[0], ...args.slice(1));
+          break;
+        case 'domsnapshot':
+          result = await domsnapshotStr(cdp, sessionId, args.includes('--styles'));
+          break;
+        case 'highlight':
+          result = await highlightStr(cdp, sessionId, args[0]);
+          break;
+        case 'hover':
+          throw new Error('hover requires a ref (@eN). Run "snap --refs" first, then "hover @e5".');
+        case 'stop': {
+          audit(cmd, targetId, args, auditResult, config);
+          return { ok: true, result: '', stopAfter: true };
+        }
+        default: {
+          auditResult.ok = false;
+          audit(cmd, targetId, args, auditResult, config);
+          return { ok: false, error: `Unknown command: ${cmd}` };
+        }
+      }
+      audit(cmd, targetId, args, auditResult, config);
+      return { ok: true, result: result ?? '' };
+    } catch (e) {
+      auditResult.ok = false;
+      audit(cmd, targetId, args, auditResult, config);
+      return { ok: false, error: e.message };
+    }
+  }
+
+  // Unix socket server com autenticação
+  const server = net.createServer((conn) => {
+    let buf = '';
+    let authenticated = !config.socketAuth;
+
+    conn.on('data', (chunk) => {
+      buf += chunk.toString();
+      const lines = buf.split('\n');
+      buf = lines.pop();
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        let req;
+        try {
+          req = JSON.parse(line);
+        } catch {
+          conn.write(JSON.stringify({ ok: false, error: 'Invalid JSON request', id: null }) + '\n');
+          continue;
+        }
+
+        if (!authenticated) {
+          if (req.auth === authToken) {
+            authenticated = true;
+            conn.write(JSON.stringify({ ok: true, id: req.id || 0 }) + '\n');
+          } else {
+            conn.write(JSON.stringify({ ok: false, error: 'Authentication failed', id: req.id || 0 }) + '\n');
+            conn.end();
+          }
+          continue;
+        }
+
+        handleCommand(req).then((res) => {
+          const payload = JSON.stringify({ ...res, id: req.id }) + '\n';
+          if (res.stopAfter) conn.end(payload, shutdown);
+          else conn.write(payload);
+        });
+      }
+    });
+  });
+
+  try { unlinkSync(sp); } catch { /* socket não existe */ }
+  server.listen(sp);
+}

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

@@ -0,0 +1,178 @@
+// Comunicação CLI <-> daemon via Unix sockets
+import { unlinkSync, readFileSync, existsSync } from 'fs';
+import { checkDomain } from './security.mjs';
+import { spawn } from 'child_process';
+import net from 'net';
+import { sleep, resolvePrefix, listDaemonSockets, sockPath } from './utils.mjs';
+import { getOrCreateToken } from './daemon.mjs';
+
+const DAEMON_CONNECT_RETRIES = 20;
+const DAEMON_CONNECT_DELAY = 300;
+
+function connectToSocket(sp) {
+  return new Promise((resolve, reject) => {
+    const conn = net.connect(sp);
+    conn.on('connect', () => resolve(conn));
+    conn.on('error', reject);
+  });
+}
+
+async function authenticateConnection(conn, authToken) {
+  if (!authToken) return true;
+
+  return new Promise((resolve, reject) => {
+    let buf = '';
+    const onData = (chunk) => {
+      buf += chunk.toString();
+      const idx = buf.indexOf('\n');
+      if (idx === -1) return;
+      conn.off('data', onData);
+      conn.off('error', onError);
+      try {
+        const resp = JSON.parse(buf.slice(0, idx));
+        resolve(resp.ok === true);
+      } catch {
+        resolve(false);
+      }
+    };
+    const onError = (e) => {
+      conn.off('data', onData);
+      reject(e);
+    };
+    conn.on('data', onData);
+    conn.on('error', onError);
+    conn.write(JSON.stringify({ auth: authToken, id: 0 }) + '\n');
+  });
+}
+
+async function connectAndAuth(sp, authToken) {
+  const conn = await connectToSocket(sp);
+  const ok = await authenticateConnection(conn, authToken);
+  if (!ok) {
+    conn.end();
+    throw new Error('Socket authentication failed');
+  }
+  return conn;
+}
+
+export async function getOrStartTabDaemon(targetId, config) {
+  const sp = sockPath(config._socketDir, targetId);
+  const authToken = getOrCreateToken(config);
+
+  // Tentar daemon existente
+  try { return await connectAndAuth(sp, authToken); } catch { /* daemon não existe */ }
+
+  // Limpar socket stale
+  try { unlinkSync(sp); } catch { /* não existe */ }
+
+  // Spawnar daemon -- usa o mesmo script com _daemon como primeiro arg
+  const scriptPath = new URL('../chromex.mjs', import.meta.url).pathname;
+  const child = spawn(process.execPath, [scriptPath, '_daemon', targetId], {
+    detached: true,
+    stdio: 'ignore',
+  });
+  child.unref();
+
+  // Aguardar socket (inclui tempo do usuário clicar Allow)
+  for (let i = 0; i < DAEMON_CONNECT_RETRIES; i++) {
+    await sleep(DAEMON_CONNECT_DELAY);
+    try { return await connectAndAuth(sp, authToken); } catch { /* aguardando */ }
+  }
+  throw new Error('Daemon failed to start — did you click Allow in Chrome?');
+}
+
+export function sendCommand(conn, req) {
+  return new Promise((resolve, reject) => {
+    let buf = '';
+    let settled = false;
+
+    const cleanup = () => {
+      conn.off('data', onData);
+      conn.off('error', onError);
+      conn.off('end', onEnd);
+      conn.off('close', onClose);
+    };
+
+    const onData = (chunk) => {
+      buf += chunk.toString();
+      const idx = buf.indexOf('\n');
+      if (idx === -1) return;
+      settled = true;
+      cleanup();
+      resolve(JSON.parse(buf.slice(0, idx)));
+      conn.end();
+    };
+
+    const onError = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(error);
+    };
+
+    const onEnd = () => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(new Error('Connection closed before response'));
+    };
+
+    const onClose = () => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(new Error('Connection closed before response'));
+    };
+
+    conn.on('data', onData);
+    conn.on('error', onError);
+    conn.on('end', onEnd);
+    conn.on('close', onClose);
+    req.id = 1;
+    conn.write(JSON.stringify(req) + '\n');
+  });
+}
+
+export async function stopDaemons(targetPrefix, config) {
+  const authToken = getOrCreateToken(config);
+  const daemons = listDaemonSockets(config._socketDir);
+
+  if (targetPrefix) {
+    const targetId = resolvePrefix(targetPrefix, daemons.map(d => d.targetId), 'daemon');
+    const daemon = daemons.find(d => d.targetId === targetId);
+    try {
+      const conn = await connectAndAuth(daemon.socketPath, authToken);
+      await sendCommand(conn, { cmd: 'stop' });
+    } catch {
+      try { unlinkSync(daemon.socketPath); } catch { /* já removido */ }
+    }
+    return;
+  }
+
+  for (const daemon of daemons) {
+    try {
+      const conn = await connectAndAuth(daemon.socketPath, authToken);
+      await sendCommand(conn, { cmd: 'stop' });
+    } catch {
+      try { unlinkSync(daemon.socketPath); } catch { /* já removido */ }
+    }
+  }
+}
+
+export function findAnyDaemonSocket(config) {
+  return listDaemonSockets(config._socketDir)[0]?.socketPath || null;
+}
+
+export function checkTargetDomain(targetId, config) {
+  if (!existsSync(config._pagesCachePath)) return;
+  try {
+    const pages = JSON.parse(readFileSync(config._pagesCachePath, 'utf8'));
+    const page = pages.find(p => p.targetId === targetId);
+    if (page) {
+      const error = checkDomain(page.url, config);
+      if (error) throw new Error(`${error}\nTab: ${page.title} (${page.url})`);
+    }
+  } catch (e) {
+    if (e.message.includes('blocked') || e.message.includes('allowedDomains')) throw e;
+  }
+}