chromex-mcp 1.0.0

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

@@ -0,0 +1,95 @@
+// CSS/JS coverage reporting via Profiler and CSS domains
+
+let active = false;
+
+export async function coverageStr(cdp, sid, action) {
+  if (!action) throw new Error('Usage: coverage <target> start | stop');
+
+  switch (action) {
+    case 'start': {
+      if (active) return 'Coverage collection already active.';
+      await cdp.send('DOM.enable', {}, sid);
+      await cdp.send('Profiler.enable', {}, sid);
+      await cdp.send('Debugger.enable', {}, sid);
+      await cdp.send('Profiler.startPreciseCoverage', { callCount: true, detailed: true }, sid);
+      await cdp.send('CSS.enable', {}, sid);
+      await cdp.send('CSS.startRuleUsageTracking', {}, sid);
+      active = true;
+      return 'Coverage collection started. Navigate/interact, then "coverage <target> stop" for report.';
+    }
+
+    case 'stop': {
+      if (!active) return 'No coverage collection active.';
+      active = false;
+
+      // JS Coverage
+      const { result: jsCoverage } = await cdp.send('Profiler.takePreciseCoverage', {}, sid);
+      await cdp.send('Profiler.stopPreciseCoverage', {}, sid);
+      await cdp.send('Profiler.disable', {}, sid);
+      await cdp.send('Debugger.disable', {}, sid);
+
+      // CSS Coverage
+      const { ruleUsage } = await cdp.send('CSS.stopRuleUsageTracking', {}, sid);
+      await cdp.send('CSS.disable', {}, sid);
+
+      // JS report
+      const jsFiles = [];
+      let jsTotalBytes = 0;
+      let jsUsedBytes = 0;
+      for (const script of jsCoverage) {
+        if (!script.url || script.url.startsWith('extensions://')) continue;
+        let scriptTotal = 0;
+        let scriptUsed = 0;
+        for (const fn of script.functions) {
+          for (const range of fn.ranges) {
+            const size = range.endOffset - range.startOffset;
+            scriptTotal += size;
+            if (range.count > 0) scriptUsed += size;
+          }
+        }
+        jsTotalBytes += scriptTotal;
+        jsUsedBytes += scriptUsed;
+        if (scriptTotal > 0) {
+          jsFiles.push({
+            url: script.url.substring(0, 80),
+            total: scriptTotal,
+            used: scriptUsed,
+            pct: Math.round((scriptUsed / scriptTotal) * 100),
+          });
+        }
+      }
+
+      // CSS report
+      const cssUsed = ruleUsage ? ruleUsage.filter(r => r.used).length : 0;
+      const cssTotal = ruleUsage ? ruleUsage.length : 0;
+
+      const lines = ['## JavaScript Coverage'];
+      lines.push(`Total: ${formatBytes(jsTotalBytes)}, Used: ${formatBytes(jsUsedBytes)} (${jsTotalBytes > 0 ? Math.round((jsUsedBytes / jsTotalBytes) * 100) : 0}%)`);
+      lines.push('');
+
+      // Top unused files
+      const unused = jsFiles.filter(f => f.pct < 50).sort((a, b) => (a.pct - b.pct));
+      if (unused.length > 0) {
+        lines.push('Files with <50% usage:');
+        for (const f of unused.slice(0, 10)) {
+          lines.push(`  ${String(f.pct).padStart(3)}%  ${formatBytes(f.total).padStart(8)}  ${f.url}`);
+        }
+        lines.push('');
+      }
+
+      lines.push('## CSS Coverage');
+      lines.push(`Rules: ${cssTotal} total, ${cssUsed} used (${cssTotal > 0 ? Math.round((cssUsed / cssTotal) * 100) : 0}%)`);
+
+      return lines.join('\n');
+    }
+
+    default:
+      throw new Error('Usage: coverage <target> start | stop');
+  }
+}
+
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}

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

@@ -0,0 +1,14 @@
+// CPU throttling via Emulation domain
+
+export async function cpuStr(cdp, sid, rate) {
+  if (!rate || rate === 'reset') {
+    await cdp.send('Emulation.setCPUThrottlingRate', { rate: 1 }, sid);
+    return 'CPU throttling reset to normal.';
+  }
+
+  const r = parseFloat(rate);
+  if (isNaN(r) || r < 1) throw new Error('Rate must be >= 1 (1=normal, 4=4x slower, 6=mobile sim)');
+
+  await cdp.send('Emulation.setCPUThrottlingRate', { rate: r }, sid);
+  return `CPU throttled to ${r}x slower.`;
+}

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

@@ -0,0 +1,38 @@
+// Dialog handling (alert/confirm/prompt) via Page domain
+
+export async function dialogStr(cdp, sid, action, text) {
+  await cdp.send('Page.enable', {}, sid);
+
+  switch (action) {
+    case 'accept':
+      await cdp.send('Page.handleJavaScriptDialog', {
+        accept: true,
+        promptText: text || '',
+      }, sid);
+      return `Dialog accepted${text ? ` with text "${text}"` : ''}.`;
+
+    case 'dismiss':
+      await cdp.send('Page.handleJavaScriptDialog', { accept: false }, sid);
+      return 'Dialog dismissed.';
+
+    case 'auto':
+      // Retorna flag para o daemon registrar auto-handler
+      return '__AUTO_DIALOG__';
+
+    default:
+      throw new Error('Usage: dialog <target> accept [text] | dismiss | auto');
+  }
+}
+
+// Registra handler permanente que auto-aceita dialogs
+export function setupAutoDialog(cdp, sid) {
+  cdp.onEvent('Page.javascriptDialogOpening', async (params) => {
+    try {
+      await cdp.send('Page.handleJavaScriptDialog', {
+        accept: true,
+        promptText: '',
+      }, sid);
+    } catch { /* dialog ja foi tratado */ }
+  });
+  return 'Auto-dialog enabled: all dialogs (alert/confirm/prompt) will be auto-accepted.';
+}

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

@@ -0,0 +1,84 @@
+// Structured DOM snapshot via DOMSnapshot domain
+
+export async function domsnapshotStr(cdp, sid, includeStyles) {
+  const computedStyles = includeStyles
+    ? ['display', 'visibility', 'opacity', 'overflow', 'position', 'z-index', 'font-size', 'color', 'background-color']
+    : ['display', 'visibility'];
+
+  const snapshot = await cdp.send('DOMSnapshot.captureSnapshot', {
+    computedStyles,
+    includeDOMRects: true,
+    includePaintOrder: true,
+  }, sid);
+
+  const { documents, strings } = snapshot;
+  if (!documents || documents.length === 0) return 'No DOM snapshot available.';
+
+  const doc = documents[0];
+  const nodes = doc.nodes;
+  const layout = doc.layout;
+  const lines = [];
+
+  // Build layout index by nodeIndex
+  const layoutMap = new Map();
+  if (layout && layout.nodeIndex && layout.bounds) {
+    for (let i = 0; i < layout.nodeIndex.length; i++) {
+      const ni = layout.nodeIndex[i];
+      const b = layout.bounds[i]; // Each bounds is [x, y, w, h]
+      if (Array.isArray(b) && b.length >= 4) {
+        layoutMap.set(ni, { bounds: b });
+      }
+    }
+  }
+
+  // Build indented tree
+  const parentIndex = nodes.parentIndex || [];
+  const nodeNames = nodes.nodeName || [];
+  const nodeValues = nodes.nodeValue || [];
+  const attrs = nodes.attributes || [];
+
+  // Calcular profundidade
+  const depth = new Array(nodeNames.length).fill(0);
+  for (let i = 1; i < nodeNames.length; i++) {
+    if (parentIndex[i] >= 0) depth[i] = depth[parentIndex[i]] + 1;
+  }
+
+  for (let i = 0; i < nodeNames.length; i++) {
+    const name = strings[nodeNames[i]] || '';
+    if (!name || name === '#document' || name === '#comment') continue;
+
+    const indent = '  '.repeat(Math.min(depth[i], 8));
+    const lay = layoutMap.get(i);
+
+    if (name === '#text') {
+      const text = strings[nodeValues[i]] || '';
+      if (text.trim()) {
+        lines.push(`${indent}"${text.trim().substring(0, 80)}"`);
+      }
+      continue;
+    }
+
+    // Atributos do nó
+    const nodeAttrs = attrs[i] || [];
+    let attrStr = '';
+    for (let a = 0; a < nodeAttrs.length; a += 2) {
+      const attrName = strings[nodeAttrs[a]] || '';
+      const attrVal = strings[nodeAttrs[a + 1]] || '';
+      if (['id', 'class', 'name', 'type', 'href', 'src', 'role'].includes(attrName) && attrVal) {
+        attrStr += ` ${attrName}="${attrVal.substring(0, 40)}"`;
+      }
+    }
+
+    let line = `${indent}<${name.toLowerCase()}${attrStr}>`;
+
+    // Adicionar bounding rect se disponível
+    if (lay?.bounds) {
+      const [x, y, w, h] = lay.bounds;
+      line += `  [${Math.round(x)},${Math.round(y)} ${Math.round(w)}x${Math.round(h)}]`;
+    }
+
+    lines.push(line);
+  }
+
+  return lines.join('\n');
+}

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

@@ -0,0 +1,25 @@
+// Download control via Browser domain
+
+import { existsSync, mkdirSync } from 'fs';
+
+export async function downloadStr(cdp, sid, action, path) {
+  switch (action) {
+    case 'allow': {
+      const downloadPath = path || '/tmp/chromex-downloads';
+      if (!existsSync(downloadPath)) mkdirSync(downloadPath, { recursive: true });
+      await cdp.send('Browser.setDownloadBehavior', {
+        behavior: 'allowAndName',
+        downloadPath,
+      }, sid);
+      return `Downloads allowed. Path: ${downloadPath}`;
+    }
+    case 'deny':
+      await cdp.send('Browser.setDownloadBehavior', { behavior: 'deny' }, sid);
+      return 'Downloads blocked.';
+    case 'reset':
+      await cdp.send('Browser.setDownloadBehavior', { behavior: 'default' }, sid);
+      return 'Download behavior reset to default.';
+    default:
+      throw new Error('Usage: download <target> allow [path] | deny | reset');
+  }
+}

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

@@ -0,0 +1,71 @@
+// Drag & Drop via Input domain
+
+import { sleep } from '../utils.mjs';
+import { evalStr } from './evaluate.mjs';
+
+export async function dragStr(cdp, sid, from, to) {
+  if (!from || !to) throw new Error('Usage: drag <target> <from_selector> <to_selector> or drag <target> x1,y1 x2,y2');
+
+  let fromX, fromY, toX, toY;
+
+  // Coordenadas diretas: "100,200"
+  if (from.includes(',') && to.includes(',')) {
+    [fromX, fromY] = from.split(',').map(Number);
+    [toX, toY] = to.split(',').map(Number);
+    if (isNaN(fromX) || isNaN(fromY) || isNaN(toX) || isNaN(toY)) {
+      throw new Error('Invalid coordinates. Use: x1,y1 x2,y2');
+    }
+  } else {
+    // CSS selectors: resolver para coordenadas centrais
+    fromX = await getCenterX(cdp, sid, from);
+    fromY = await getCenterY(cdp, sid, from);
+    toX = await getCenterX(cdp, sid, to);
+    toY = await getCenterY(cdp, sid, to);
+  }
+
+  const base = { button: 'left', clickCount: 1, modifiers: 0 };
+
+  // Mouse down no ponto de origem
+  await cdp.send('Input.dispatchMouseEvent', { ...base, type: 'mousePressed', x: fromX, y: fromY }, sid);
+  await sleep(100);
+
+  // Mover em passos intermediários para simular arraste real
+  const steps = 5;
+  for (let i = 1; i <= steps; i++) {
+    const x = fromX + (toX - fromX) * (i / steps);
+    const y = fromY + (toY - fromY) * (i / steps);
+    await cdp.send('Input.dispatchMouseEvent', { ...base, type: 'mouseMoved', x, y }, sid);
+    await sleep(50);
+  }
+
+  // Mouse up no destino
+  await cdp.send('Input.dispatchMouseEvent', { ...base, type: 'mouseReleased', x: toX, y: toY }, sid);
+
+  return `Dragged from (${Math.round(fromX)},${Math.round(fromY)}) to (${Math.round(toX)},${Math.round(toY)}).`;
+}
+
+async function getCenterX(cdp, sid, selector) {
+  const raw = await evalStr(cdp, sid, `
+    (function() {
+      const el = document.querySelector(${JSON.stringify(selector)});
+      if (!el) return null;
+      const r = el.getBoundingClientRect();
+      return Math.round(r.left + r.width / 2);
+    })()
+  `);
+  if (raw === 'null') throw new Error(`Element not found: ${selector}`);
+  return parseFloat(raw);
+}
+
+async function getCenterY(cdp, sid, selector) {
+  const raw = await evalStr(cdp, sid, `
+    (function() {
+      const el = document.querySelector(${JSON.stringify(selector)});
+      if (!el) return null;
+      const r = el.getBoundingClientRect();
+      return Math.round(r.top + r.height / 2);
+    })()
+  `);
+  if (raw === 'null') throw new Error(`Element not found: ${selector}`);
+  return parseFloat(raw);
+}

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

@@ -0,0 +1,44 @@
+// Device emulation via CDP
+
+const DEVICES = {
+  'iphone-14': { width: 390, height: 844, deviceScaleFactor: 3, mobile: true, ua: 'Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1' },
+  'iphone-15-pro': { width: 393, height: 852, deviceScaleFactor: 3, mobile: true, ua: 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1' },
+  'ipad-pro': { width: 1024, height: 1366, deviceScaleFactor: 2, mobile: true, ua: 'Mozilla/5.0 (iPad; CPU OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1' },
+  'pixel-7': { width: 412, height: 915, deviceScaleFactor: 2.625, mobile: true, ua: 'Mozilla/5.0 (Linux; Android 13; Pixel 7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36' },
+  'galaxy-s23': { width: 360, height: 780, deviceScaleFactor: 3, mobile: true, ua: 'Mozilla/5.0 (Linux; Android 13; SM-S911B) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36' },
+  'macbook-air': { width: 1440, height: 900, deviceScaleFactor: 2, mobile: false, ua: '' },
+  'desktop-1080p': { width: 1920, height: 1080, deviceScaleFactor: 1, mobile: false, ua: '' },
+  'desktop-4k': { width: 3840, height: 2160, deviceScaleFactor: 1, mobile: false, ua: '' },
+};
+
+export async function emulateStr(cdp, sid, device) {
+  if (!device) {
+    const list = Object.keys(DEVICES).join(', ');
+    throw new Error(`Device name required. Available: ${list}, reset`);
+  }
+
+  if (device === 'reset') {
+    await cdp.send('Emulation.clearDeviceMetricsOverride', {}, sid);
+    await cdp.send('Emulation.setUserAgentOverride', { userAgent: '' }, sid);
+    return 'Device emulation reset to default.';
+  }
+
+  const preset = DEVICES[device.toLowerCase()];
+  if (!preset) {
+    const list = Object.keys(DEVICES).join(', ');
+    throw new Error(`Unknown device: ${device}. Available: ${list}, reset`);
+  }
+
+  await cdp.send('Emulation.setDeviceMetricsOverride', {
+    width: preset.width,
+    height: preset.height,
+    deviceScaleFactor: preset.deviceScaleFactor,
+    mobile: preset.mobile,
+  }, sid);
+
+  if (preset.ua) {
+    await cdp.send('Emulation.setUserAgentOverride', { userAgent: preset.ua }, sid);
+  }
+
+  return `Emulating ${device}: ${preset.width}x${preset.height} @${preset.deviceScaleFactor}x${preset.mobile ? ' (mobile)' : ''}`;
+}

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

@@ -0,0 +1,31 @@
+// Eval JS + evalraw CDP
+
+import { isCdpMethodBlocked } from '../security.mjs';
+
+export async function evalStr(cdp, sid, expression) {
+  await cdp.send('Runtime.enable', {}, sid);
+  const result = await cdp.send('Runtime.evaluate', {
+    expression, returnByValue: true, awaitPromise: true,
+  }, sid);
+  if (result.exceptionDetails) {
+    throw new Error(result.exceptionDetails.text || result.exceptionDetails.exception?.description);
+  }
+  const val = result.result.value;
+  return typeof val === 'object' ? JSON.stringify(val, null, 2) : String(val ?? '');
+}
+
+export async function evalRawStr(cdp, sid, method, paramsJson, config) {
+  if (!method) throw new Error('CDP method required (e.g. "DOM.getDocument")');
+
+  if (isCdpMethodBlocked(method, config)) {
+    throw new Error(`CDP method "${method}" is blocked by security config. Edit ~/.chromex/config.json to change.`);
+  }
+
+  let params = {};
+  if (paramsJson) {
+    try { params = JSON.parse(paramsJson); }
+    catch { throw new Error(`Invalid JSON params: ${paramsJson}`); }
+  }
+  const result = await cdp.send(method, params, sid);
+  return JSON.stringify(result, null, 2);
+}

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

@@ -0,0 +1,163 @@
+// Form filling: fill, clear, select, check, form (batch)
+
+import { sleep } from '../utils.mjs';
+import { evalStr } from './evaluate.mjs';
+
+export async function fillStr(cdp, sid, selector, value) {
+  if (!selector) throw new Error('CSS selector required');
+  if (value == null) throw new Error('Value required');
+
+  // Focar e limpar o campo
+  const info = await evalStr(cdp, sid, `
+    (function() {
+      const el = document.querySelector(${JSON.stringify(selector)});
+      if (!el) return { ok: false, error: 'Element not found: ' + ${JSON.stringify(selector)} };
+      el.scrollIntoView({ block: 'center' });
+      el.focus();
+      if (el.select) el.select();
+      return { ok: true, tag: el.tagName, type: el.type || '', name: el.name || '' };
+    })()
+  `);
+  const r = JSON.parse(info);
+  if (!r.ok) throw new Error(r.error);
+
+  // Selecionar tudo e deletar (funciona em campos React controlled)
+  await cdp.send('Input.dispatchKeyEvent', {
+    type: 'keyDown', key: 'a', code: 'KeyA', modifiers: getModifierKey(),
+  }, sid);
+  await cdp.send('Input.dispatchKeyEvent', {
+    type: 'keyUp', key: 'a', code: 'KeyA', modifiers: 0,
+  }, sid);
+  await sleep(50);
+
+  // Inserir texto
+  await cdp.send('Input.insertText', { text: String(value) }, sid);
+
+  // Disparar eventos de mudança para frameworks reativos
+  await evalStr(cdp, sid, `
+    (function() {
+      const el = document.querySelector(${JSON.stringify(selector)});
+      if (!el) return;
+      el.dispatchEvent(new Event('input', { bubbles: true }));
+      el.dispatchEvent(new Event('change', { bubbles: true }));
+    })()
+  `);
+
+  return `Filled <${r.tag}${r.name ? ` name="${r.name}"` : ''}> with "${String(value).substring(0, 50)}"`;
+}
+
+export async function clearStr(cdp, sid, selector) {
+  if (!selector) throw new Error('CSS selector required');
+
+  const info = await evalStr(cdp, sid, `
+    (function() {
+      const el = document.querySelector(${JSON.stringify(selector)});
+      if (!el) return { ok: false, error: 'Element not found: ' + ${JSON.stringify(selector)} };
+      el.scrollIntoView({ block: 'center' });
+      el.focus();
+      if (el.select) el.select();
+      return { ok: true, tag: el.tagName, name: el.name || '' };
+    })()
+  `);
+  const r = JSON.parse(info);
+  if (!r.ok) throw new Error(r.error);
+
+  // Selecionar tudo + Delete
+  await cdp.send('Input.dispatchKeyEvent', {
+    type: 'keyDown', key: 'a', code: 'KeyA', modifiers: getModifierKey(),
+  }, sid);
+  await cdp.send('Input.dispatchKeyEvent', {
+    type: 'keyUp', key: 'a', code: 'KeyA', modifiers: 0,
+  }, sid);
+  await cdp.send('Input.dispatchKeyEvent', {
+    type: 'keyDown', key: 'Delete', code: 'Delete',
+  }, sid);
+  await cdp.send('Input.dispatchKeyEvent', {
+    type: 'keyUp', key: 'Delete', code: 'Delete',
+  }, sid);
+
+  await evalStr(cdp, sid, `
+    (function() {
+      const el = document.querySelector(${JSON.stringify(selector)});
+      if (!el) return;
+      el.dispatchEvent(new Event('input', { bubbles: true }));
+      el.dispatchEvent(new Event('change', { bubbles: true }));
+    })()
+  `);
+
+  return `Cleared <${r.tag}${r.name ? ` name="${r.name}"` : ''}>`;
+}
+
+export async function selectStr(cdp, sid, selector, value) {
+  if (!selector) throw new Error('CSS selector required');
+  if (value == null) throw new Error('Value required');
+
+  const result = await evalStr(cdp, sid, `
+    (function() {
+      const el = document.querySelector(${JSON.stringify(selector)});
+      if (!el) return { ok: false, error: 'Element not found: ' + ${JSON.stringify(selector)} };
+      if (el.tagName !== 'SELECT') return { ok: false, error: 'Element is not a <select>' };
+      const val = ${JSON.stringify(String(value))};
+      const option = Array.from(el.options).find(o => o.value === val || o.textContent.trim() === val);
+      if (!option) {
+        const opts = Array.from(el.options).map(o => o.value || o.textContent.trim()).slice(0, 10);
+        return { ok: false, error: 'Option not found: ' + val + '. Available: ' + opts.join(', ') };
+      }
+      el.value = option.value;
+      el.dispatchEvent(new Event('change', { bubbles: true }));
+      el.dispatchEvent(new Event('input', { bubbles: true }));
+      return { ok: true, selected: option.textContent.trim(), value: option.value };
+    })()
+  `);
+  const r = JSON.parse(result);
+  if (!r.ok) throw new Error(r.error);
+  return `Selected "${r.selected}" (value="${r.value}")`;
+}
+
+export async function checkStr(cdp, sid, selector, checked = true) {
+  if (!selector) throw new Error('CSS selector required');
+
+  const result = await evalStr(cdp, sid, `
+    (function() {
+      const el = document.querySelector(${JSON.stringify(selector)});
+      if (!el) return { ok: false, error: 'Element not found: ' + ${JSON.stringify(selector)} };
+      const want = ${JSON.stringify(checked)};
+      if (el.type !== 'checkbox' && el.type !== 'radio') {
+        return { ok: false, error: 'Element is not a checkbox/radio (type: ' + el.type + ')' };
+      }
+      if (el.checked !== want) {
+        el.click();
+        el.dispatchEvent(new Event('change', { bubbles: true }));
+      }
+      return { ok: true, type: el.type, checked: el.checked, name: el.name || '' };
+    })()
+  `);
+  const r = JSON.parse(result);
+  if (!r.ok) throw new Error(r.error);
+  return `${r.type} ${r.name ? `"${r.name}" ` : ''}is now ${r.checked ? 'checked' : 'unchecked'}`;
+}
+
+export async function formStr(cdp, sid, fieldsJson) {
+  let fields;
+  try {
+    fields = JSON.parse(fieldsJson);
+  } catch {
+    throw new Error(`Invalid JSON: ${fieldsJson}`);
+  }
+
+  const results = [];
+  for (const [selector, value] of Object.entries(fields)) {
+    if (typeof value === 'boolean') {
+      results.push(await checkStr(cdp, sid, selector, value));
+    } else {
+      results.push(await fillStr(cdp, sid, selector, String(value)));
+    }
+    await sleep(100); // Pausa entre campos para frameworks reativos
+  }
+  return results.join('\n');
+}
+
+// macOS usa Meta (Cmd), Linux usa Control
+function getModifierKey() {
+  return process.platform === 'darwin' ? 4 : 2; // 4 = Meta, 2 = Control
+}

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

@@ -0,0 +1,37 @@
+// Geolocation, timezone, and locale override via Emulation domain
+
+export async function geoStr(cdp, sid, lat, lon, accuracy) {
+  if (lat === 'reset') {
+    await cdp.send('Emulation.clearGeolocationOverride', {}, sid);
+    return 'Geolocation override cleared.';
+  }
+
+  const latitude = parseFloat(lat);
+  const longitude = parseFloat(lon);
+  if (isNaN(latitude) || isNaN(longitude)) {
+    throw new Error('Usage: geo <target> <latitude> <longitude> [accuracy] | reset');
+  }
+
+  await cdp.send('Emulation.setGeolocationOverride', {
+    latitude, longitude, accuracy: parseFloat(accuracy) || 100,
+  }, sid);
+  return `Geolocation set to (${latitude}, ${longitude}).`;
+}
+
+export async function timezoneStr(cdp, sid, tz) {
+  if (!tz || tz === 'reset') {
+    await cdp.send('Emulation.setTimezoneOverride', { timezoneId: '' }, sid);
+    return 'Timezone override cleared.';
+  }
+  await cdp.send('Emulation.setTimezoneOverride', { timezoneId: tz }, sid);
+  return `Timezone set to ${tz}.`;
+}
+
+export async function localeStr(cdp, sid, locale) {
+  if (!locale || locale === 'reset') {
+    await cdp.send('Emulation.setLocaleOverride', { locale: '' }, sid);
+    return 'Locale override cleared.';
+  }
+  await cdp.send('Emulation.setLocaleOverride', { locale }, sid);
+  return `Locale set to ${locale}.`;
+}