chromex-mcp 1.0.0

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

@@ -0,0 +1,343 @@
+#!/usr/bin/env node
+// chromex -- Chrome DevTools Protocol CLI for AI agents
+// Zero dependencies. Node 22+ (built-in WebSocket).
+
+import { writeFileSync, existsSync, readFileSync } from 'fs';
+import { loadConfig } from './lib/config.mjs';
+import { CDP } from './lib/client.mjs';
+import { getWsUrl, getPages, formatPageList } from './lib/browser.mjs';
+import { audit } from './lib/security.mjs';
+import { resolvePrefix, listDaemonSockets } from './lib/utils.mjs';
+import { runDaemon } from './lib/daemon.mjs';
+import { getOrStartTabDaemon, sendCommand, stopDaemons, findAnyDaemonSocket, checkTargetDomain } from './lib/ipc.mjs';
+import { launchBrowser, incognitoContext } from './lib/launcher.mjs';
+
+const config = loadConfig();
+
+// Comandos que precisam de target (tab)
+const NEEDS_TARGET = new Set([
+  'snap', 'snapshot', 'eval', 'shot', 'screenshot', 'html', 'nav', 'navigate',
+  'net', 'network', 'click', 'clickxy', 'type', 'loadall', 'evalraw', 'waitfor',
+  'fill', 'clear', 'select', 'check', 'form',
+  'scroll', 'cookies', 'pdf', 'console', 'storage', 'emulate', 'perf',
+  // Tier 1
+  'wait', 'dialog', 'upload',
+  'geo', 'timezone', 'locale', 'throttle', 'cpu', 'inject', 'download',
+  // Tier 2
+  'intercept', 'har', 'coverage',
+  // Tier 3
+  'trace', 'heap', 'webauthn', 'drag', 'touch', 'domsnapshot', 'highlight',
+  'hover',
+]);
+
+const USAGE = `chromex - Chrome DevTools Protocol CLI for AI agents
+
+Usage: chromex <command> [args]
+
+  PAGES
+    list                                List open pages (shows unique target prefixes)
+    open    <url>                       Open new tab
+    close   <target>                    Close tab
+    focus   <target>                    Activate/focus tab
+    launch  [options]                   Launch browser with remote debugging
+      --incognito                       Launch in incognito mode
+      --browser chrome|brave|edge       Choose browser
+      --profile NAME                    Use named profile
+      --url URL                         Open URL on launch
+    incognito [url]                     Create isolated browser context (no relaunch)
+
+  INSPECT
+    snap    <target>                    Accessibility tree snapshot (compact)
+    html    <target> [selector]         Get HTML (full page or CSS selector)
+    shot    <target> [file] [--full]    Screenshot (viewport or full page)
+    net     <target>                    Network performance entries
+    perf    <target>                    Core Web Vitals + performance metrics
+    console <target> [duration_ms]      Capture console output (default 5000ms)
+    domsnapshot <target> [--styles]     Structured DOM snapshot with bounding rects
+    highlight <target> <sel|clear>      Highlight element with overlay
+
+  EVALUATE
+    eval    <target> <expr>             Evaluate JS expression
+    evalraw <target> <method> [json]    Raw CDP command (some methods blocked)
+
+  NAVIGATE
+    nav     <target> <url>              Navigate to URL and wait for load
+    waitfor <target> <selector> [ms]    Wait for CSS selector to appear
+    wait    <target> <event> [ms]       Wait for: networkidle, load, domready, fcp
+    scroll  <target> <dir> [amount]     Scroll: up, down, top, bottom, to <selector>
+
+  INTERACT
+    click   <target> <selector>         Click element by CSS selector
+    clickxy <target> <x> <y>            Click at CSS pixel coordinates
+    type    <target> <text>             Type text at current focus
+    drag    <target> <from> <to>        Drag & drop (selectors or x1,y1 x2,y2)
+    touch   <target> <gesture> [args]   Touch: tap, swipe, pinch, longpress
+    dialog  <target> <action> [text]    Handle dialogs: accept, dismiss, auto
+
+  FORMS
+    fill    <target> <selector> <value> Fill input/textarea
+    clear   <target> <selector>         Clear input field
+    select  <target> <selector> <value> Select option in <select>
+    check   <target> <selector> [bool]  Toggle checkbox/radio (default: true)
+    form    <target> <json>             Batch fill: {"#email":"x","#terms":true}
+    upload  <target> <selector> <files> Upload file(s) to input[type=file]
+    loadall <target> <selector> [ms]    Click "load more" until gone
+
+  DATA
+    cookies <target> [action] [arg]     Cookies: list, set <json>, clear [domain]
+    storage <target> <type>             Storage: local, session, clear
+    pdf     <target> [file]             Save page as PDF
+
+  NETWORK
+    throttle <target> <preset|reset>    Throttle: 3g, slow-3g, 4g, offline, custom, reset
+    intercept <target> <action> [args]  Intercept: on, block, mock, off, rules
+    har     <target> start|stop [file]  Record HTTP traffic as HAR file
+
+  EMULATE
+    emulate <target> <device|reset>     Emulate device (iphone-14, pixel-7, etc.)
+    geo     <target> <lat> <lon>|reset  Set geolocation override
+    timezone <target> <tz|reset>        Set timezone (e.g. America/Sao_Paulo)
+    locale  <target> <locale|reset>     Set locale (e.g. pt-BR)
+    cpu     <target> <rate|reset>       CPU throttle (1=normal, 4=4x slower, 6=mobile)
+
+  ADVANCED
+    inject  <target> <script|flags>     Inject JS on every page load (--file, --remove, --list)
+    download <target> allow|deny|reset  Control download behavior
+    coverage <target> start|stop        CSS/JS code coverage report
+    trace   <target> start|stop [file]  Performance trace (chrome://tracing format)
+    heap    <target> snapshot [file]     Heap snapshot for memory analysis
+    webauthn <target> enable|creds|dis  Virtual authenticator for passkey testing
+
+  DAEMON
+    stop    [target]                    Stop daemon(s)
+
+<target> is a unique targetId prefix from "chromex list". Ambiguous prefixes are rejected.
+
+SECURITY
+  Config: ~/.chromex/config.json
+  - blockedDomains / allowedDomains: domain filtering
+  - blockedCdpMethods: CDP methods blocked in evalraw
+  - socketAuth / auditLog: daemon security
+
+COORDINATES
+  shot captures at native resolution: image px = CSS px * DPR.
+  clickxy takes CSS pixels. CSS px = screenshot px / DPR.
+`;
+
+async function main() {
+  const [cmd, ...args] = process.argv.slice(2);
+
+  // Daemon mode (internal)
+  if (cmd === '_daemon') {
+    await runDaemon(args[0], config);
+    return;
+  }
+
+  if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
+    console.log(USAGE);
+    process.exit(0);
+  }
+
+  // --- Comandos sem target ---
+
+  // List
+  if (cmd === 'list' || cmd === 'ls') {
+    let pages;
+    const existingSock = findAnyDaemonSocket(config);
+    if (existingSock) {
+      try {
+        const conn = await connectAndAuthFromSocket(existingSock);
+        const resp = await sendCommand(conn, { cmd: 'list_raw' });
+        if (resp.ok) pages = JSON.parse(resp.result);
+      } catch { /* fallback para conexão direta */ }
+    }
+    if (!pages) {
+      const cdp = new CDP(config.commandTimeout);
+      await cdp.connect(getWsUrl());
+      pages = await getPages(cdp);
+      cdp.close();
+    }
+    writeFileSync(config._pagesCachePath, JSON.stringify(pages));
+    audit('list', null, [], { ok: true }, config);
+    console.log(formatPageList(pages, config));
+    setTimeout(() => process.exit(0), 100);
+    return;
+  }
+
+  // Launch
+  if (cmd === 'launch') {
+    const options = parseFlags(args, ['incognito'], ['browser', 'profile', 'url']);
+    const result = await launchBrowser(options);
+    console.log(result);
+    return;
+  }
+
+  // Incognito (sem target -- cria novo context)
+  if (cmd === 'incognito') {
+    const cdp = new CDP(config.commandTimeout);
+    await cdp.connect(getWsUrl());
+    const result = await incognitoContext(cdp, args[0]);
+    console.log(result.message);
+    cdp.close();
+    return;
+  }
+
+  // Tab management (no daemon needed -- direct browser WebSocket)
+  if (cmd === 'open' || cmd === 'close' || cmd === 'focus') {
+    const { openTabStr, closeTabStr, focusTabStr } = await import('./lib/commands/tab.mjs');
+    const cdp = new CDP(config.commandTimeout);
+    await cdp.connect(getWsUrl());
+    let result;
+    if (cmd === 'open') {
+      if (!args[0]) { console.error('Error: URL required'); process.exit(1); }
+      result = await openTabStr(cdp, args[0]);
+    } else if (cmd === 'close') {
+      if (!args[0]) { console.error('Error: target prefix required'); process.exit(1); }
+      result = await closeTabStr(cdp, args[0]);
+    } else {
+      if (!args[0]) { console.error('Error: target prefix required'); process.exit(1); }
+      result = await focusTabStr(cdp, args[0]);
+    }
+    console.log(result);
+    cdp.close();
+    return;
+  }
+
+  // Stop
+  if (cmd === 'stop') {
+    await stopDaemons(args[0], config);
+    audit('stop', args[0] || 'all', [], { ok: true }, config);
+    return;
+  }
+
+  // --- Comandos com target ---
+  if (!NEEDS_TARGET.has(cmd)) {
+    console.error(`Unknown command: ${cmd}\n`);
+    console.log(USAGE);
+    process.exit(1);
+  }
+
+  const targetPrefix = args[0];
+  if (!targetPrefix) {
+    console.error('Error: target ID required. Run "chromex list" first.');
+    process.exit(1);
+  }
+
+  // Resolver prefix -> targetId
+  let targetId;
+  const daemonTargetIds = listDaemonSockets(config._socketDir).map(d => d.targetId);
+  const daemonMatches = daemonTargetIds.filter(id => id.toUpperCase().startsWith(targetPrefix.toUpperCase()));
+
+  if (daemonMatches.length > 0) {
+    targetId = resolvePrefix(targetPrefix, daemonTargetIds, 'daemon');
+  } else {
+    if (!existsSync(config._pagesCachePath)) {
+      console.error('No page list cached. Run "chromex list" first.');
+      process.exit(1);
+    }
+    const pages = JSON.parse(readFileSync(config._pagesCachePath, 'utf8'));
+    targetId = resolvePrefix(targetPrefix, pages.map(p => p.targetId), 'target', 'Run "chromex list".');
+  }
+
+  // Checar domínio da tab
+  checkTargetDomain(targetId, config);
+
+  const conn = await getOrStartTabDaemon(targetId, config);
+
+  const cmdArgs = args.slice(1);
+
+  // Juntar argumentos para comandos que aceitam texto livre
+  if (cmd === 'eval') {
+    const expr = cmdArgs.join(' ');
+    if (!expr) { console.error('Error: expression required'); process.exit(1); }
+    cmdArgs[0] = expr;
+    cmdArgs.length = 1;
+  } else if (cmd === 'type') {
+    const text = cmdArgs.join(' ');
+    if (!text) { console.error('Error: text required'); process.exit(1); }
+    cmdArgs[0] = text;
+    cmdArgs.length = 1;
+  } else if (cmd === 'fill') {
+    // fill <selector> <value...>
+    if (cmdArgs.length < 2) { console.error('Error: selector and value required'); process.exit(1); }
+    const selector = cmdArgs[0];
+    const value = cmdArgs.slice(1).join(' ');
+    cmdArgs[0] = selector;
+    cmdArgs[1] = value;
+    cmdArgs.length = 2;
+  } else if (cmd === 'evalraw') {
+    if (!cmdArgs[0]) { console.error('Error: CDP method required'); process.exit(1); }
+    if (cmdArgs.length > 2) {
+      cmdArgs[1] = cmdArgs.slice(1).join(' ');
+      cmdArgs.length = 2;
+    }
+  }
+
+  if ((cmd === 'nav' || cmd === 'navigate') && !cmdArgs[0]) {
+    console.error('Error: URL required');
+    process.exit(1);
+  }
+
+  const response = await sendCommand(conn, { cmd, args: cmdArgs });
+
+  if (response.ok) {
+    if (response.result) console.log(response.result);
+  } else {
+    console.error('Error:', response.error);
+    process.exitCode = 1;
+  }
+}
+
+// Parser de flags simples: --flag (boolean) e --key value
+function parseFlags(args, booleanFlags, valueFlags) {
+  const result = {};
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2);
+      if (booleanFlags.includes(key)) {
+        result[key] = true;
+        i++;
+      } else if (valueFlags.includes(key)) {
+        result[key] = args[i + 1];
+        i += 2;
+      } else {
+        i++;
+      }
+    } else {
+      // Argumento posicional -> assume URL
+      if (!result.url) result.url = arg;
+      i++;
+    }
+  }
+  return result;
+}
+
+// Helper para list -- conectar via socket existente
+async function connectAndAuthFromSocket(socketPath) {
+  const { getOrCreateToken } = await import('./lib/daemon.mjs');
+  const authToken = getOrCreateToken(config);
+  const net = await import('net');
+  return new Promise((resolve, reject) => {
+    const conn = net.connect(socketPath);
+    conn.on('connect', () => {
+      if (!authToken) { resolve(conn); return; }
+      let buf = '';
+      conn.on('data', (chunk) => {
+        buf += chunk.toString();
+        const idx = buf.indexOf('\n');
+        if (idx === -1) return;
+        try {
+          const resp = JSON.parse(buf.slice(0, idx));
+          if (resp.ok) resolve(conn);
+          else reject(new Error('Auth failed'));
+        } catch { reject(new Error('Invalid response')); }
+      });
+      conn.write(JSON.stringify({ auth: authToken, id: 0 }) + '\n');
+    });
+    conn.on('error', reject);
+  });
+}
+
+main().catch(e => { console.error(e.message); process.exit(1); });

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

@@ -0,0 +1,66 @@
+// Detecção de browser e listagem de páginas
+import { readFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { homedir } from 'os';
+import { checkDomain } from './security.mjs';
+import { getDisplayPrefixLength } from './utils.mjs';
+
+// Gera candidatos para cada browser: path base + Default/ subfolder
+function candidates(base) {
+  return [resolve(base, 'DevToolsActivePort'), resolve(base, 'Default/DevToolsActivePort')];
+}
+
+const home = homedir();
+const DEVTOOLS_CANDIDATES = [
+  // Brave
+  ...candidates(resolve(home, 'Library/Application Support/BraveSoftware/Brave-Browser')),
+  ...candidates(resolve(home, '.config/BraveSoftware/Brave-Browser')),
+  // Chrome
+  ...candidates(resolve(home, 'Library/Application Support/Google/Chrome')),
+  ...candidates(resolve(home, '.config/google-chrome')),
+  // Chrome Canary
+  ...candidates(resolve(home, 'Library/Application Support/Google/Chrome Canary')),
+  // Chromium
+  ...candidates(resolve(home, 'Library/Application Support/Chromium')),
+  ...candidates(resolve(home, '.config/chromium')),
+  // Edge
+  ...candidates(resolve(home, 'Library/Application Support/Microsoft Edge')),
+  ...candidates(resolve(home, '.config/microsoft-edge')),
+  // Vivaldi
+  ...candidates(resolve(home, 'Library/Application Support/Vivaldi')),
+  ...candidates(resolve(home, '.config/vivaldi')),
+];
+
+export function getWsUrl() {
+  // Override via env var para setups não-padrão
+  if (process.env.CDP_PORT_FILE && existsSync(process.env.CDP_PORT_FILE)) {
+    const lines = readFileSync(process.env.CDP_PORT_FILE, 'utf8').trim().split('\n');
+    return `ws://127.0.0.1:${lines[0]}${lines[1]}`;
+  }
+
+  const portFile = DEVTOOLS_CANDIDATES.find(path => existsSync(path));
+  if (!portFile) {
+    throw new Error(
+      'Could not find DevToolsActivePort file.\n' +
+      'Enable remote debugging: chrome://inspect/#remote-debugging\n' +
+      'Or launch with: chromex launch'
+    );
+  }
+  const lines = readFileSync(portFile, 'utf8').trim().split('\n');
+  return `ws://127.0.0.1:${lines[0]}${lines[1]}`;
+}
+
+export async function getPages(cdp) {
+  const { targetInfos } = await cdp.send('Target.getTargets');
+  return targetInfos.filter(t => t.type === 'page' && !t.url.startsWith('chrome://'));
+}
+
+export function formatPageList(pages, config) {
+  const prefixLen = getDisplayPrefixLength(pages.map(p => p.targetId));
+  return pages.map(p => {
+    const id = p.targetId.slice(0, prefixLen).padEnd(prefixLen);
+    const title = p.title.substring(0, 54).padEnd(54);
+    const blocked = checkDomain(p.url, config) ? ' [BLOCKED]' : '';
+    return `${id}  ${title}  ${p.url}${blocked}`;
+  }).join('\n');
+}

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

@@ -0,0 +1,98 @@
+// CDP WebSocket client -- protocolo raw, zero dependencies
+// Requer Node 22+ (WebSocket nativo)
+
+const DEFAULT_TIMEOUT = 15000;
+
+export class CDP {
+  #ws;
+  #id = 0;
+  #pending = new Map();
+  #eventHandlers = new Map();
+  #closeHandlers = [];
+  #timeout;
+
+  constructor(timeout = DEFAULT_TIMEOUT) {
+    this.#timeout = timeout;
+  }
+
+  async connect(wsUrl) {
+    return new Promise((res, rej) => {
+      this.#ws = new WebSocket(wsUrl);
+      this.#ws.onopen = () => res();
+      this.#ws.onerror = (e) => rej(new Error('WebSocket error: ' + (e.message || e.type)));
+      this.#ws.onclose = () => this.#closeHandlers.forEach(h => h());
+      this.#ws.onmessage = (ev) => {
+        const msg = JSON.parse(ev.data);
+        if (msg.id && this.#pending.has(msg.id)) {
+          const { resolve, reject } = this.#pending.get(msg.id);
+          this.#pending.delete(msg.id);
+          if (msg.error) reject(new Error(msg.error.message));
+          else resolve(msg.result);
+        } else if (msg.method && this.#eventHandlers.has(msg.method)) {
+          for (const handler of [...this.#eventHandlers.get(msg.method)]) {
+            handler(msg.params || {}, msg);
+          }
+        }
+      };
+    });
+  }
+
+  send(method, params = {}, sessionId) {
+    const id = ++this.#id;
+    return new Promise((resolve, reject) => {
+      this.#pending.set(id, { resolve, reject });
+      const msg = { id, method, params };
+      if (sessionId) msg.sessionId = sessionId;
+      this.#ws.send(JSON.stringify(msg));
+      setTimeout(() => {
+        if (this.#pending.has(id)) {
+          this.#pending.delete(id);
+          reject(new Error(`Timeout: ${method}`));
+        }
+      }, this.#timeout);
+    });
+  }
+
+  onEvent(method, handler) {
+    if (!this.#eventHandlers.has(method)) this.#eventHandlers.set(method, new Set());
+    const handlers = this.#eventHandlers.get(method);
+    handlers.add(handler);
+    return () => {
+      handlers.delete(handler);
+      if (handlers.size === 0) this.#eventHandlers.delete(method);
+    };
+  }
+
+  waitForEvent(method, timeout = this.#timeout) {
+    let settled = false;
+    let off;
+    let timer;
+    const promise = new Promise((resolve, reject) => {
+      off = this.onEvent(method, (params) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        off();
+        resolve(params);
+      });
+      timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        off();
+        reject(new Error(`Timeout waiting for event: ${method}`));
+      }, timeout);
+    });
+    return {
+      promise,
+      cancel() {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        off?.();
+      },
+    };
+  }
+
+  onClose(handler) { this.#closeHandlers.push(handler); }
+  close() { this.#ws.close(); }
+}

package/plugins/chromex/skills/chromex/scripts/lib/commands/console.mjs

@@ -0,0 +1,37 @@
+// Captura de console.log/error/warn
+
+import { sleep } from '../utils.mjs';
+
+export async function consoleStr(cdp, sid, durationMs = 5000) {
+  const duration = parseInt(durationMs) || 5000;
+  const entries = [];
+
+  await cdp.send('Runtime.enable', {}, sid);
+
+  const off = cdp.onEvent('Runtime.consoleAPICalled', (params) => {
+    const type = params.type; // log, error, warn, info, debug
+    const args = (params.args || []).map(a => {
+      if (a.type === 'string') return a.value;
+      if (a.type === 'number') return String(a.value);
+      if (a.type === 'boolean') return String(a.value);
+      if (a.type === 'undefined') return 'undefined';
+      if (a.subtype === 'null') return 'null';
+      return a.description || JSON.stringify(a.value) || `[${a.type}]`;
+    });
+    entries.push({
+      ts: new Date().toISOString().slice(11, 23),
+      type,
+      msg: args.join(' '),
+    });
+  });
+
+  await sleep(duration);
+  off();
+
+  if (entries.length === 0) return `No console output captured in ${duration}ms.`;
+
+  return entries.map(e => {
+    const prefix = e.type === 'error' ? 'ERR' : e.type === 'warn' ? 'WRN' : e.type.toUpperCase().slice(0, 3);
+    return `[${e.ts}] ${prefix.padEnd(3)}  ${e.msg.substring(0, 200)}`;
+  }).join('\n');
+}

package/plugins/chromex/skills/chromex/scripts/lib/commands/cookies.mjs

@@ -0,0 +1,77 @@
+// Cookie management via CDP Network domain
+
+import { evalStr } from './evaluate.mjs';
+
+export async function cookiesStr(cdp, sid, action, arg) {
+  switch (action) {
+    case undefined:
+    case 'list': {
+      // Obter URL atual para filtrar cookies
+      const url = await evalStr(cdp, sid, 'window.location.href');
+      await cdp.send('Network.enable', {}, sid);
+      const { cookies } = await cdp.send('Network.getCookies', { urls: [url] }, sid);
+      await cdp.send('Network.disable', {}, sid);
+
+      if (cookies.length === 0) return 'No cookies found for this page.';
+
+      return cookies.map(c => {
+        const flags = [
+          c.httpOnly ? 'HttpOnly' : '',
+          c.secure ? 'Secure' : '',
+          c.sameSite !== 'None' ? `SameSite=${c.sameSite}` : '',
+        ].filter(Boolean).join(' ');
+        const exp = c.expires > 0
+          ? new Date(c.expires * 1000).toISOString().slice(0, 19)
+          : 'Session';
+        const val = c.value.length > 40 ? c.value.slice(0, 40) + '...' : c.value;
+        return `${c.name.padEnd(30)}  ${val.padEnd(44)}  ${exp}  ${flags}`;
+      }).join('\n');
+    }
+
+    case 'set': {
+      if (!arg) throw new Error('Cookie JSON required: {"name":"x","value":"y","domain":".example.com"}');
+      let cookie;
+      try { cookie = JSON.parse(arg); }
+      catch { throw new Error(`Invalid JSON: ${arg}`); }
+
+      if (!cookie.name || cookie.value == null) throw new Error('Cookie must have "name" and "value"');
+
+      // Default domain da página atual
+      if (!cookie.domain) {
+        const host = await evalStr(cdp, sid, 'window.location.hostname');
+        cookie.domain = host;
+      }
+      if (!cookie.path) cookie.path = '/';
+
+      await cdp.send('Network.enable', {}, sid);
+      const result = await cdp.send('Network.setCookie', cookie, sid);
+      await cdp.send('Network.disable', {}, sid);
+
+      if (!result.success) throw new Error('Failed to set cookie');
+      return `Cookie "${cookie.name}" set on ${cookie.domain}`;
+    }
+
+    case 'clear': {
+      const url = await evalStr(cdp, sid, 'window.location.href');
+      await cdp.send('Network.enable', {}, sid);
+      const { cookies } = await cdp.send('Network.getCookies', { urls: [url] }, sid);
+
+      const domain = arg; // Filtro opcional por domínio
+      const toDelete = domain
+        ? cookies.filter(c => c.domain === domain || c.domain === '.' + domain)
+        : cookies;
+
+      for (const c of toDelete) {
+        await cdp.send('Network.deleteCookies', {
+          name: c.name, domain: c.domain, path: c.path,
+        }, sid);
+      }
+      await cdp.send('Network.disable', {}, sid);
+
+      return `Cleared ${toDelete.length} cookie(s)${domain ? ` for domain ${domain}` : ''}`;
+    }
+
+    default:
+      throw new Error(`Unknown cookies action: ${action}. Use: list, set, clear`);
+  }
+}