chromex-mcp 1.0.0

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

@@ -0,0 +1,54 @@
+// Screenshot (viewport + full page)
+
+import { writeFileSync } from 'fs';
+import { evalStr } from './evaluate.mjs';
+
+export async function shotStr(cdp, sid, filePath, fullPage = false, config) {
+  let dpr = 1;
+  try {
+    const metrics = await cdp.send('Page.getLayoutMetrics', {}, sid);
+    dpr = metrics.visualViewport?.clientWidth
+      ? metrics.cssVisualViewport?.clientWidth
+        ? Math.round((metrics.visualViewport.clientWidth / metrics.cssVisualViewport.clientWidth) * 100) / 100
+        : 1
+      : 1;
+    const { deviceScaleFactor } = await cdp.send('Emulation.getDeviceMetricsOverride', {}, sid).catch(() => ({}));
+    if (deviceScaleFactor) dpr = deviceScaleFactor;
+  } catch { /* fallback */ }
+  if (dpr === 1) {
+    try {
+      const raw = await evalStr(cdp, sid, 'window.devicePixelRatio');
+      const parsed = parseFloat(raw);
+      if (parsed > 0) dpr = parsed;
+    } catch { /* fallback */ }
+  }
+
+  const screenshotParams = { format: 'png' };
+
+  if (fullPage) {
+    try {
+      const metrics = await cdp.send('Page.getLayoutMetrics', {}, sid);
+      const width = metrics.contentSize?.width || metrics.cssContentSize?.width;
+      const height = metrics.contentSize?.height || metrics.cssContentSize?.height;
+      if (width && height) {
+        screenshotParams.clip = { x: 0, y: 0, width, height, scale: 1 };
+        screenshotParams.captureBeyondViewport = true;
+      }
+    } catch { /* fallback para viewport */ }
+  }
+
+  const { data } = await cdp.send('Page.captureScreenshot', screenshotParams, sid);
+  const out = filePath || config?.defaultScreenshotPath || '/tmp/screenshot.png';
+  writeFileSync(out, Buffer.from(data, 'base64'));
+
+  const lines = [out];
+  lines.push(`Screenshot saved${fullPage ? ' (full page)' : ' (viewport only)'}. DPR: ${dpr}`);
+  if (!fullPage) {
+    lines.push(`Coordinate mapping: CSS px = screenshot px / ${dpr}`);
+    lines.push(`  e.g. screenshot (${Math.round(100 * dpr)}, ${Math.round(200 * dpr)}) -> clickxy <target> 100 200`);
+    if (dpr !== 1) {
+      lines.push(`  On this ${dpr}x display: CSS px = screenshot px * ${Math.round(100 / dpr) / 100}`);
+    }
+  }
+  return lines.join('\n');
+}

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

@@ -0,0 +1,44 @@
+// Scroll controlado
+
+import { evalStr } from './evaluate.mjs';
+
+export async function scrollStr(cdp, sid, direction, amountOrSelector) {
+  if (!direction) throw new Error('Direction required: up, down, top, bottom, to');
+
+  switch (direction.toLowerCase()) {
+    case 'down': {
+      const px = parseInt(amountOrSelector) || 500;
+      await evalStr(cdp, sid, `window.scrollBy(0, ${px})`);
+      const pos = await evalStr(cdp, sid, 'Math.round(window.scrollY)');
+      return `Scrolled down ${px}px (position: ${pos}px)`;
+    }
+    case 'up': {
+      const px = parseInt(amountOrSelector) || 500;
+      await evalStr(cdp, sid, `window.scrollBy(0, -${px})`);
+      const pos = await evalStr(cdp, sid, 'Math.round(window.scrollY)');
+      return `Scrolled up ${px}px (position: ${pos}px)`;
+    }
+    case 'top':
+      await evalStr(cdp, sid, 'window.scrollTo(0, 0)');
+      return 'Scrolled to top';
+    case 'bottom':
+      await evalStr(cdp, sid, 'window.scrollTo(0, document.documentElement.scrollHeight)');
+      return 'Scrolled to bottom';
+    case 'to': {
+      if (!amountOrSelector) throw new Error('CSS selector required for "scroll to"');
+      const result = await evalStr(cdp, sid, `
+        (function() {
+          const el = document.querySelector(${JSON.stringify(amountOrSelector)});
+          if (!el) return { ok: false, error: 'Element not found: ' + ${JSON.stringify(amountOrSelector)} };
+          el.scrollIntoView({ behavior: 'smooth', block: 'center' });
+          return { ok: true, tag: el.tagName, text: el.textContent.trim().substring(0, 50) };
+        })()
+      `);
+      const r = JSON.parse(result);
+      if (!r.ok) throw new Error(r.error);
+      return `Scrolled to <${r.tag}> "${r.text}"`;
+    }
+    default:
+      throw new Error(`Unknown scroll direction: ${direction}. Use: up, down, top, bottom, to`);
+  }
+}

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

@@ -0,0 +1,100 @@
+// Accessibility tree snapshot with optional interactive refs (@e1, @e2...)
+
+const INTERACTIVE_ROLES = new Set([
+  'button', 'link', 'textbox', 'checkbox', 'radio', 'combobox',
+  'menuitem', 'tab', 'switch', 'searchbox', 'slider', 'spinbutton',
+  'option', 'menuitemcheckbox', 'menuitemradio', 'treeitem',
+]);
+
+function shouldShowAxNode(node, compact = false) {
+  const role = node.role?.value || '';
+  const name = node.name?.value ?? '';
+  const value = node.value?.value;
+  if (compact && role === 'InlineTextBox') return false;
+  return role !== 'none' && role !== 'generic' && !(name === '' && (value === '' || value == null));
+}
+
+function formatAxNode(node, depth, refIndex, refs) {
+  const role = node.role?.value || '';
+  const name = node.name?.value ?? '';
+  const value = node.value?.value;
+  const indent = '  '.repeat(Math.min(depth, 10));
+
+  let refTag = '';
+  if (refs && INTERACTIVE_ROLES.has(role.toLowerCase())) {
+    refTag = `@e${refIndex.value} `;
+    refIndex.value++;
+  }
+
+  let line = `${indent}${refTag}[${role}]`;
+  if (name !== '') line += ` ${name}`;
+  if (!(value === '' || value == null)) line += ` = ${JSON.stringify(value)}`;
+  return line;
+}
+
+function orderedAxChildren(node, nodesById, childrenByParent) {
+  const children = [];
+  const seen = new Set();
+  for (const childId of node.childIds || []) {
+    const child = nodesById.get(childId);
+    if (child && !seen.has(child.nodeId)) {
+      seen.add(child.nodeId);
+      children.push(child);
+    }
+  }
+  for (const child of childrenByParent.get(node.nodeId) || []) {
+    if (!seen.has(child.nodeId)) {
+      seen.add(child.nodeId);
+      children.push(child);
+    }
+  }
+  return children;
+}
+
+// refMap is populated when refs=true: { refNumber -> { backendNodeId, role, name } }
+// The caller (daemon) stores this map for later ref resolution.
+export async function snapshotStr(cdp, sid, compact = true, refs = false) {
+  const { nodes } = await cdp.send('Accessibility.getFullAXTree', {}, sid);
+  const nodesById = new Map(nodes.map(node => [node.nodeId, node]));
+  const childrenByParent = new Map();
+  for (const node of nodes) {
+    if (!node.parentId) continue;
+    if (!childrenByParent.has(node.parentId)) childrenByParent.set(node.parentId, []);
+    childrenByParent.get(node.parentId).push(node);
+  }
+
+  const refIndex = { value: 1 };
+  const refMap = new Map();
+  const lines = [];
+  const visited = new Set();
+
+  function visit(node, depth) {
+    if (!node || visited.has(node.nodeId)) return;
+    visited.add(node.nodeId);
+    if (shouldShowAxNode(node, compact)) {
+      const role = node.role?.value || '';
+      const currentRef = refIndex.value;
+
+      lines.push(formatAxNode(node, depth, refIndex, refs));
+
+      // If ref was assigned (refIndex advanced), record the mapping
+      if (refs && refIndex.value > currentRef) {
+        refMap.set(currentRef, {
+          backendNodeId: node.backendDOMNodeId,
+          nodeId: node.nodeId,
+          role,
+          name: node.name?.value ?? '',
+        });
+      }
+    }
+    for (const child of orderedAxChildren(node, nodesById, childrenByParent)) {
+      visit(child, depth + 1);
+    }
+  }
+
+  const roots = nodes.filter(node => !node.parentId || !nodesById.has(node.parentId));
+  for (const root of roots) visit(root, 0);
+  for (const node of nodes) visit(node, 0);
+
+  return { text: lines.join('\n'), refMap };
+}

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

@@ -0,0 +1,47 @@
+// LocalStorage / SessionStorage management
+
+import { evalStr } from './evaluate.mjs';
+
+export async function storageStr(cdp, sid, action) {
+  switch (action) {
+    case 'local': {
+      const raw = await evalStr(cdp, sid, `
+        JSON.stringify(Object.fromEntries(
+          Object.keys(localStorage).map(k => [k, localStorage.getItem(k)?.substring(0, 200)])
+        ))
+      `);
+      const data = JSON.parse(raw);
+      const keys = Object.keys(data);
+      if (keys.length === 0) return 'localStorage is empty.';
+      return keys.map(k => {
+        const v = data[k];
+        const val = v && v.length > 80 ? v.slice(0, 80) + '...' : v;
+        return `${k.padEnd(40)}  ${val}`;
+      }).join('\n');
+    }
+
+    case 'session': {
+      const raw = await evalStr(cdp, sid, `
+        JSON.stringify(Object.fromEntries(
+          Object.keys(sessionStorage).map(k => [k, sessionStorage.getItem(k)?.substring(0, 200)])
+        ))
+      `);
+      const data = JSON.parse(raw);
+      const keys = Object.keys(data);
+      if (keys.length === 0) return 'sessionStorage is empty.';
+      return keys.map(k => {
+        const v = data[k];
+        const val = v && v.length > 80 ? v.slice(0, 80) + '...' : v;
+        return `${k.padEnd(40)}  ${val}`;
+      }).join('\n');
+    }
+
+    case 'clear': {
+      await evalStr(cdp, sid, 'localStorage.clear(); sessionStorage.clear()');
+      return 'Cleared localStorage and sessionStorage.';
+    }
+
+    default:
+      throw new Error(`Unknown storage action: ${action}. Use: local, session, clear`);
+  }
+}

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

@@ -0,0 +1,31 @@
+// Multi-tab management via Target domain
+
+export async function openTabStr(cdp, url) {
+  if (!url) throw new Error('URL required');
+  const { targetId } = await cdp.send('Target.createTarget', { url });
+  return `Opened new tab (targetId: ${targetId.slice(0, 8)}). URL: ${url}`;
+}
+
+export async function closeTabStr(cdp, targetPrefix) {
+  if (!targetPrefix) throw new Error('Target ID required');
+  const targetId = await resolveTarget(cdp, targetPrefix);
+  const { success } = await cdp.send('Target.closeTarget', { targetId });
+  if (!success) throw new Error(`Failed to close target ${targetId.slice(0, 8)}`);
+  return `Closed tab ${targetId.slice(0, 8)}.`;
+}
+
+export async function focusTabStr(cdp, targetPrefix) {
+  if (!targetPrefix) throw new Error('Target ID required');
+  const targetId = await resolveTarget(cdp, targetPrefix);
+  await cdp.send('Target.activateTarget', { targetId });
+  return `Focused tab ${targetId.slice(0, 8)}.`;
+}
+
+async function resolveTarget(cdp, prefix) {
+  const { targetInfos } = await cdp.send('Target.getTargets');
+  const pages = targetInfos.filter(t => t.type === 'page');
+  const matches = pages.filter(p => p.targetId.toUpperCase().startsWith(prefix.toUpperCase()));
+  if (matches.length === 0) throw new Error(`No target matching prefix "${prefix}"`);
+  if (matches.length > 1) throw new Error(`Ambiguous prefix "${prefix}" — matches ${matches.length} targets`);
+  return matches[0].targetId;
+}

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

@@ -0,0 +1,38 @@
+// Network throttling via Network domain
+
+const PRESETS = {
+  '3g':      { offline: false, latency: 100,  downloadThroughput: 750 * 1024 / 8,  uploadThroughput: 250 * 1024 / 8 },
+  'slow-3g': { offline: false, latency: 2000, downloadThroughput: 50 * 1024 / 8,   uploadThroughput: 50 * 1024 / 8 },
+  '4g':      { offline: false, latency: 20,   downloadThroughput: 4000 * 1024 / 8,  uploadThroughput: 3000 * 1024 / 8 },
+  'offline': { offline: true,  latency: 0,    downloadThroughput: 0,                uploadThroughput: 0 },
+};
+
+export async function throttleStr(cdp, sid, preset, ...customArgs) {
+  if (!preset || preset === 'reset') {
+    await cdp.send('Network.emulateNetworkConditions', {
+      offline: false, latency: 0, downloadThroughput: -1, uploadThroughput: -1,
+    }, sid);
+    return 'Network throttling reset.';
+  }
+
+  if (preset === 'custom') {
+    const [latency, down, up] = customArgs.map(Number);
+    if (isNaN(latency) || isNaN(down) || isNaN(up)) {
+      throw new Error('Usage: throttle <target> custom <latency_ms> <down_kbps> <up_kbps>');
+    }
+    await cdp.send('Network.enable', {}, sid);
+    await cdp.send('Network.emulateNetworkConditions', {
+      offline: false, latency, downloadThroughput: down * 1024 / 8, uploadThroughput: up * 1024 / 8,
+    }, sid);
+    return `Network throttled: ${latency}ms latency, ${down}kbps down, ${up}kbps up.`;
+  }
+
+  const conditions = PRESETS[preset.toLowerCase()];
+  if (!conditions) {
+    throw new Error(`Unknown preset: ${preset}. Available: ${Object.keys(PRESETS).join(', ')}, custom, reset`);
+  }
+
+  await cdp.send('Network.enable', {}, sid);
+  await cdp.send('Network.emulateNetworkConditions', conditions, sid);
+  return `Network throttled to ${preset}${conditions.offline ? ' (offline)' : ''}.`;
+}

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

@@ -0,0 +1,62 @@
+// Touch gestures via Input domain
+
+export async function touchStr(cdp, sid, gesture, ...args) {
+  if (!gesture) throw new Error('Usage: touch <target> tap <x> <y> | swipe <x1>,<y1> <x2>,<y2> | pinch <x> <y> <scale> | longpress <x> <y> [ms]');
+
+  // Enable touch emulation
+  await cdp.send('Emulation.setTouchEmulationEnabled', { enabled: true, maxTouchPoints: 5 }, sid);
+
+  switch (gesture.toLowerCase()) {
+    case 'tap': {
+      const [x, y] = args.map(Number);
+      if (isNaN(x) || isNaN(y)) throw new Error('Usage: touch <target> tap <x> <y>');
+      await cdp.send('Input.synthesizeTapGesture', {
+        x, y, duration: 50, tapCount: 1,
+      }, sid);
+      return `Tapped at (${x}, ${y}).`;
+    }
+
+    case 'swipe': {
+      const [fromStr, toStr] = args;
+      if (!fromStr || !toStr) throw new Error('Usage: touch <target> swipe <x1>,<y1> <x2>,<y2>');
+      const [x1, y1] = fromStr.split(',').map(Number);
+      const [x2, y2] = toStr.split(',').map(Number);
+      if ([x1, y1, x2, y2].some(isNaN)) throw new Error('Invalid coordinates');
+
+      await cdp.send('Input.synthesizeScrollGesture', {
+        x: x1, y: y1,
+        xDistance: x2 - x1,
+        yDistance: y2 - y1,
+        speed: 800,
+        preventFling: true,
+        gestureSourceType: 'touch',
+      }, sid);
+      return `Swiped from (${x1},${y1}) to (${x2},${y2}).`;
+    }
+
+    case 'pinch': {
+      const [x, y, scale] = args.map(Number);
+      if (isNaN(x) || isNaN(y) || isNaN(scale)) throw new Error('Usage: touch <target> pinch <x> <y> <scale>');
+      await cdp.send('Input.synthesizePinchGesture', {
+        x, y, scaleFactor: scale, relativeSpeed: 300,
+        gestureSourceType: 'touch',
+      }, sid);
+      return `Pinch ${scale > 1 ? 'zoom in' : 'zoom out'} at (${x},${y}) scale=${scale}.`;
+    }
+
+    case 'longpress': {
+      const [x, y, durationStr] = args;
+      const cx = parseFloat(x);
+      const cy = parseFloat(y);
+      const duration = parseInt(durationStr) || 1000;
+      if (isNaN(cx) || isNaN(cy)) throw new Error('Usage: touch <target> longpress <x> <y> [ms]');
+      await cdp.send('Input.synthesizeTapGesture', {
+        x: cx, y: cy, duration, tapCount: 1,
+      }, sid);
+      return `Long press at (${cx},${cy}) for ${duration}ms.`;
+    }
+
+    default:
+      throw new Error(`Unknown gesture: ${gesture}. Available: tap, swipe, pinch, longpress`);
+  }
+}

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

@@ -0,0 +1,51 @@
+// Performance tracing via Tracing domain
+
+import { writeFileSync } from 'fs';
+
+let tracing = false;
+const chunks = [];
+
+export async function traceStr(cdp, sid, action, fileOrCategories) {
+  if (!action) throw new Error('Usage: trace <target> start [categories] | stop [file]');
+
+  switch (action) {
+    case 'start': {
+      if (tracing) return 'Tracing already active.';
+      chunks.length = 0;
+      tracing = true;
+
+      cdp.onEvent('Tracing.dataCollected', (params) => {
+        if (params.value) chunks.push(...params.value);
+      });
+
+      const categories = fileOrCategories || 'devtools.timeline,v8.execute';
+      await cdp.send('Tracing.start', {
+        traceConfig: {
+          recordMode: 'recordUntilFull',
+          includedCategories: categories.split(','),
+        },
+      }, sid);
+      return `Tracing started (categories: ${categories.substring(0, 60)}...). Use "trace <target> stop [file]" to save.`;
+    }
+
+    case 'stop': {
+      if (!tracing) return 'No trace active.';
+      tracing = false;
+
+      await cdp.send('Tracing.end', {}, sid);
+      // Aguardar Tracing.tracingComplete
+      try {
+        await cdp.waitForEvent('Tracing.tracingComplete', 30000).promise;
+      } catch { /* timeout ok, já temos os chunks */ }
+
+      const out = fileOrCategories || '/tmp/chromex-trace.json';
+      writeFileSync(out, JSON.stringify(chunks));
+      const count = chunks.length;
+      chunks.length = 0;
+      return `Trace saved to ${out} (${count} events). Open in chrome://tracing or Perfetto UI.`;
+    }
+
+    default:
+      throw new Error('Usage: trace <target> start [categories] | stop [file]');
+  }
+}

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

@@ -0,0 +1,43 @@
+// File upload via DOM domain
+
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { evalStr } from './evaluate.mjs';
+
+export async function uploadStr(cdp, sid, selector, ...filePaths) {
+  if (!selector) throw new Error('CSS selector required');
+  if (filePaths.length === 0) throw new Error('At least one file path required');
+
+  // Validar que arquivos existem
+  const resolvedPaths = filePaths.map(f => resolve(f));
+  for (const fp of resolvedPaths) {
+    if (!existsSync(fp)) throw new Error(`File not found: ${fp}`);
+  }
+
+  // Encontrar o backendNodeId do input
+  await cdp.send('DOM.enable', {}, sid);
+  const { root } = await cdp.send('DOM.getDocument', {}, sid);
+  const { nodeId } = await cdp.send('DOM.querySelector', {
+    nodeId: root.nodeId,
+    selector,
+  }, sid);
+
+  if (!nodeId) throw new Error(`Element not found: ${selector}`);
+
+  const { node } = await cdp.send('DOM.describeNode', { nodeId }, sid);
+
+  await cdp.send('DOM.setFileInputFiles', {
+    files: resolvedPaths,
+    backendNodeId: node.backendNodeId,
+  }, sid);
+
+  // Disparar change event
+  await evalStr(cdp, sid, `
+    (function() {
+      const el = document.querySelector(${JSON.stringify(selector)});
+      if (el) el.dispatchEvent(new Event('change', { bubbles: true }));
+    })()
+  `);
+
+  return `Uploaded ${resolvedPaths.length} file(s) to ${selector}: ${resolvedPaths.map(f => f.split('/').pop()).join(', ')}`;
+}

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

@@ -0,0 +1,84 @@
+// Wait for lifecycle events (networkidle, load, domready)
+
+import { sleep } from '../utils.mjs';
+import { evalStr } from './evaluate.mjs';
+
+export async function waitLifecycleStr(cdp, sid, event, timeoutMs, config) {
+  const timeout = parseInt(timeoutMs) || config?.navigationTimeout || 30000;
+  const eventMap = {
+    'networkidle': 'networkIdle',
+    'network-idle': 'networkIdle',
+    'load': 'load',
+    'domready': 'DOMContentLoaded',
+    'dom-ready': 'DOMContentLoaded',
+    'domcontentloaded': 'DOMContentLoaded',
+    'fcp': 'firstContentfulPaint',
+    'firstcontentfulpaint': 'firstContentfulPaint',
+  };
+
+  if (!event) throw new Error('Event required: networkidle, load, domready, fcp');
+
+  const cdpEvent = eventMap[event.toLowerCase()];
+  if (!cdpEvent) {
+    throw new Error(`Unknown event: ${event}. Available: ${Object.keys(eventMap).join(', ')}`);
+  }
+
+  // Checar se o estado já foi atingido (para load/domready)
+  if (cdpEvent === 'load' || cdpEvent === 'DOMContentLoaded') {
+    try {
+      const state = await evalStr(cdp, sid, 'document.readyState');
+      if (cdpEvent === 'DOMContentLoaded' && (state === 'interactive' || state === 'complete')) {
+        return `${event} already reached (readyState: ${state})`;
+      }
+      if (cdpEvent === 'load' && state === 'complete') {
+        return `${event} already reached (readyState: complete)`;
+      }
+    } catch { /* pagina pode estar navegando */ }
+  }
+
+  // Para networkIdle: poll baseado em performance API
+  if (cdpEvent === 'networkIdle') {
+    const start = Date.now();
+    const deadline = start + timeout;
+    let idleCount = 0;
+    while (Date.now() < deadline) {
+      try {
+        const pending = await evalStr(cdp, sid,
+          'performance.getEntriesByType("resource").filter(e => e.responseEnd === 0).length'
+        );
+        if (pending === '0') {
+          idleCount++;
+          if (idleCount >= 3) return `networkidle reached (waited ${Date.now() - start}ms)`;
+        } else {
+          idleCount = 0;
+        }
+      } catch { /* pagina pode estar navegando */ }
+      await sleep(500);
+    }
+    throw new Error(`Timeout (${timeout}ms) waiting for networkidle`);
+  }
+
+  // Para outros eventos: usar Page.lifecycleEvent
+  await cdp.send('Page.enable', {}, sid);
+  await cdp.send('Page.setLifecycleEventsEnabled', { enabled: true }, sid);
+
+  const start = Date.now();
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const off = cdp.onEvent('Page.lifecycleEvent', (params) => {
+      if (params.name === cdpEvent && !settled) {
+        settled = true;
+        off();
+        resolve(`${event} reached (waited ${Date.now() - start}ms)`);
+      }
+    });
+
+    setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        off();
+        reject(new Error(`Timeout (${timeout}ms) waiting for ${event}`));
+      }
+    }, timeout);
+  });
+}

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

@@ -0,0 +1,47 @@
+// WebAuthn / Passkey testing via WebAuthn domain
+
+let authenticatorId = null;
+
+export async function webauthnStr(cdp, sid, action) {
+  if (!action) throw new Error('Usage: webauthn <target> enable | creds | disable');
+
+  switch (action) {
+    case 'enable': {
+      await cdp.send('WebAuthn.enable', { enableUI: false }, sid);
+      const result = await cdp.send('WebAuthn.addVirtualAuthenticator', {
+        options: {
+          protocol: 'ctap2',
+          transport: 'internal',
+          hasResidentKey: true,
+          hasUserVerification: true,
+          isUserVerified: true,
+          automaticPresenceSimulation: true,
+        },
+      }, sid);
+      authenticatorId = result.authenticatorId;
+      return `Virtual authenticator created (id: ${authenticatorId}). Passkey flows will work automatically.`;
+    }
+
+    case 'creds': {
+      if (!authenticatorId) throw new Error('No authenticator active. Run "webauthn enable" first.');
+      const { credentials } = await cdp.send('WebAuthn.getCredentials', { authenticatorId }, sid);
+      if (credentials.length === 0) return 'No credentials stored.';
+      return credentials.map((c, i) => {
+        const id = Buffer.from(c.credentialId, 'base64').toString('hex').slice(0, 16);
+        return `${i + 1}. ${id}  rpId=${c.rpId}  userHandle=${c.userHandle || 'none'}`;
+      }).join('\n');
+    }
+
+    case 'disable': {
+      if (authenticatorId) {
+        await cdp.send('WebAuthn.removeVirtualAuthenticator', { authenticatorId }, sid);
+        authenticatorId = null;
+      }
+      await cdp.send('WebAuthn.disable', {}, sid);
+      return 'WebAuthn virtual authenticator removed.';
+    }
+
+    default:
+      throw new Error('Usage: webauthn <target> enable | creds | disable');
+  }
+}