clawbench-cli 0.1.2__py3-none-any.whl

clawbench/cli.py

@@ -0,0 +1,397 @@
+"""``claw-bench`` command-line entry point (click-based).
+
+Design notes:
+
+- Bare ``claw-bench`` launches the TUI. This preserves muscle memory from
+  the old ``./run.sh`` and keeps the zero-friction experience for users
+  who just typed ``pip install claw-bench`` and hit enter.
+- Every power-user action has an explicit subcommand so scripts don't
+  need to navigate a menu (``run``, ``batch``, ``build``, ``cases``,
+  ``models``, ``configure``, ``doctor``, ``version``).
+- Subcommands are thin wrappers that delegate to the module-level
+  ``main()`` functions in :mod:`clawbench.run` / :mod:`clawbench.batch`.
+  Those modules still accept argparse argv so they can be invoked
+  in-process *and* via ``python -m clawbench run ...`` from the batch
+  runner's subprocess fan-out — one code path, two callers.
+
+Subcommand surface intentionally kept small. Every flag the TUI exposes
+is reachable from the CLI, but we don't duplicate every internal toggle
+that ``run.py``/``batch.py`` support as argparse args — click just
+forwards through to them via ``extra_args``.
+"""
+
+from __future__ import annotations
+
+import os
+import stat
+import subprocess
+import sys
+from pathlib import Path
+
+import click
+
+from clawbench import __version__
+from clawbench import doctor as _doctor
+from clawbench import paths as _paths
+
+
+# ---------------------------------------------------------------------------
+# Small helpers
+# ---------------------------------------------------------------------------
+
+def _echo_result(r: _doctor.CheckResult) -> None:
+    """Render a single doctor CheckResult with color-coded status."""
+    symbol = {"ok": "[OK]  ", "warn": "[WARN]", "fail": "[FAIL]"}.get(r.status, "[?]")
+    color = {"ok": "green", "warn": "yellow", "fail": "red"}.get(r.status, "white")
+    click.echo(f"  {click.style(symbol, fg=color)}  {r.name}: {r.detail}")
+    if r.hint and r.status != "ok":
+        for line in r.hint.splitlines():
+            click.echo(f"        {click.style(line, dim=True)}")
+
+
+# ---------------------------------------------------------------------------
+# Root group
+# ---------------------------------------------------------------------------
+
+@click.group(
+    invoke_without_command=True,
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+@click.version_option(__version__, "-V", "--version", prog_name="claw-bench")
+@click.pass_context
+def main(ctx: click.Context) -> None:
+    """ClawBench — benchmark AI agents on 153 everyday web tasks.
+
+    Run without a subcommand to launch the interactive TUI. Use
+    ``claw-bench run``, ``batch``, ``build``, ``doctor``, etc. for
+    scripting.
+    """
+    if ctx.invoked_subcommand is None:
+        # No subcommand → TUI.
+        from clawbench import tui
+        tui.main()
+
+
+# ---------------------------------------------------------------------------
+# tui
+# ---------------------------------------------------------------------------
+
+@main.command("tui")
+def tui_cmd() -> None:
+    """Launch the interactive TUI (default action if no subcommand given)."""
+    from clawbench import tui
+    tui.main()
+
+
+# ---------------------------------------------------------------------------
+# run
+# ---------------------------------------------------------------------------
+
+@main.command(
+    "run",
+    context_settings={
+        "ignore_unknown_options": True,
+        "allow_extra_args": True,
+        "help_option_names": ["-h", "--help"],
+    },
+)
+@click.argument("test_case_dir", type=click.Path(path_type=Path))
+@click.argument("model", required=False)
+@click.option("--human", is_flag=True, help="Human mode: expose Chrome via noVNC instead of running an agent.")
+@click.option("--output-dir", type=click.Path(path_type=Path), default=None,
+              help="Directory to write output to (default: ./claw-output).")
+@click.option("--no-build", is_flag=True, help="Skip building the container image.")
+@click.option("--no-upload", is_flag=True, help="Skip HuggingFace upload even if configured.")
+@click.pass_context
+def run_cmd(
+    ctx: click.Context,
+    test_case_dir: Path,
+    model: str | None,
+    human: bool,
+    output_dir: Path | None,
+    no_build: bool,
+    no_upload: bool,
+) -> None:
+    """Run a single test case against a model (or in --human mode)."""
+    from clawbench import run as _run
+    # Accept three forms for the case argument:
+    #   (a) an absolute / already-existing path (user points at their own case),
+    #   (b) ``test-cases/<name>`` relative to the project (dev convenience),
+    #   (c) a bare case name like ``006-daily-life-food-uber-eats`` — looked up
+    #       inside the wheel's bundled test-cases. This is the common case from
+    #       the TUI, which passes only the case name.
+    resolved = test_case_dir
+    if not resolved.exists():
+        bundled = _paths.test_cases_dir() / test_case_dir.name
+        if bundled.exists():
+            resolved = bundled
+    argv: list[str] = [str(resolved)]
+    if model:
+        argv.append(model)
+    if human:
+        argv.append("--human")
+    if output_dir:
+        argv += ["--output-dir", str(output_dir)]
+    if no_build:
+        argv.append("--no-build")
+    if no_upload:
+        argv.append("--no-upload")
+    argv += list(ctx.args)
+    _run.main(argv)
+
+
+# ---------------------------------------------------------------------------
+# batch
+# ---------------------------------------------------------------------------
+
+@main.command(
+    "batch",
+    context_settings={
+        "ignore_unknown_options": True,
+        "allow_extra_args": True,
+        "help_option_names": ["-h", "--help"],
+    },
+)
+@click.option("--models", "models_", multiple=True, help="Glob(s) matching model keys in models.yaml.")
+@click.option("--all-models", is_flag=True, help="Run every model in models.yaml.")
+@click.option("--cases", "cases_", multiple=True, help="Glob(s) matching test-case dirs.")
+@click.option("--all-cases", is_flag=True, help="Run every bundled test case.")
+@click.option("--case-range", default=None, help="Numeric ID range, e.g. 1-50.")
+@click.option("--max-concurrent", type=int, default=2, help="Max parallel jobs (default: 2).")
+@click.option("--output-dir", type=click.Path(path_type=Path), default=None,
+              help="Base output directory (default: ./claw-output).")
+@click.option("--stagger-delay", type=float, default=15,
+              help="Min seconds between container starts (default: 15).")
+@click.option("--dry-run", is_flag=True, help="Print job matrix without running.")
+@click.option("--no-upload", is_flag=True, help="Skip HuggingFace upload for all runs.")
+@click.pass_context
+def batch_cmd(
+    ctx: click.Context,
+    models_: tuple[str, ...],
+    all_models: bool,
+    cases_: tuple[str, ...],
+    all_cases: bool,
+    case_range: str | None,
+    max_concurrent: int,
+    output_dir: Path | None,
+    stagger_delay: float,
+    dry_run: bool,
+    no_upload: bool,
+) -> None:
+    """Run a model x case cross-product concurrently."""
+    from clawbench import batch as _batch
+    argv: list[str] = []
+    if models_:
+        argv += ["--models", *models_]
+    if all_models:
+        argv.append("--all-models")
+    if cases_:
+        argv += ["--cases", *cases_]
+    if all_cases:
+        argv.append("--all-cases")
+    if case_range:
+        argv += ["--case-range", case_range]
+    argv += ["--max-concurrent", str(max_concurrent)]
+    if output_dir:
+        argv += ["--output-dir", str(output_dir)]
+    argv += ["--stagger-delay", str(stagger_delay)]
+    if dry_run:
+        argv.append("--dry-run")
+    if no_upload:
+        argv.append("--no-upload")
+    argv += list(ctx.args)
+    _batch.main(argv)
+
+
+# ---------------------------------------------------------------------------
+# build
+# ---------------------------------------------------------------------------
+
+@main.command("build")
+@click.option("--no-cache", is_flag=True, help="Ignore layer cache — full rebuild.")
+def build_cmd(no_cache: bool) -> None:
+    """Build the clawbench container image from the bundled Dockerfile."""
+    from clawbench import run as _run
+    # ``run.docker_build`` already retries with --no-cache on stale-cache
+    # detection; if the user explicitly asks for a cold build, we blow the
+    # cache up front by removing the existing image and then rebuilding.
+    if no_cache:
+        from clawbench.engine import detect_engine
+        eng = detect_engine()
+        if eng:
+            subprocess.run([eng, "image", "rm", "-f", "clawbench"],
+                           capture_output=True)
+    _run.docker_build()
+
+
+# ---------------------------------------------------------------------------
+# cases
+# ---------------------------------------------------------------------------
+
+@main.command("cases")
+@click.option("--category", default=None, help="Filter by category (substring match).")
+def cases_cmd(category: str | None) -> None:
+    """List bundled test cases (name, category, time-limit)."""
+    import json as _json
+    base = _paths.test_cases_dir()
+    dirs = sorted(p.parent for p in base.glob("*/task.json"))
+    if not dirs:
+        click.echo("No test cases found.")
+        sys.exit(1)
+    # One outlier case has a 180+ char name; cap padding at 60 so the
+    # common case doesn't get a wall of whitespace.
+    width = min(60, max(len(d.name) for d in dirs))
+    shown = 0
+    for d in dirs:
+        try:
+            task = _json.loads((d / "task.json").read_text())
+        except Exception as e:
+            click.echo(f"  {d.name:<{width}}  [unreadable: {e}]")
+            continue
+        cat = task.get("category", "?")
+        if category and category.lower() not in cat.lower():
+            continue
+        time_limit = task.get("time_limit", "?")
+        click.echo(f"  {d.name:<{width}}  {cat:<20}  {time_limit} min")
+        shown += 1
+    click.echo(f"\n{shown} case(s)")
+
+
+# ---------------------------------------------------------------------------
+# models
+# ---------------------------------------------------------------------------
+
+@main.command("models")
+def models_cmd() -> None:
+    """List configured models from the user's models.yaml."""
+    import yaml as _yaml
+    path = _paths.user_models_yaml()
+    try:
+        data = _yaml.safe_load(path.read_text()) or {}
+    except Exception as e:
+        click.echo(f"ERROR: cannot read {path}: {e}", err=True)
+        sys.exit(1)
+    if not data:
+        click.echo(f"No models configured. Edit {path} or run `claw-bench configure`.")
+        return
+    click.echo(f"Models configured in {path}:")
+    for name in sorted(data):
+        api = data[name].get("api_type") if isinstance(data[name], dict) else "?"
+        click.echo(f"  {name}  ({api})")
+
+
+# ---------------------------------------------------------------------------
+# configure
+# ---------------------------------------------------------------------------
+
+@main.command("configure")
+@click.option("--show", is_flag=True, help="Print the config file path and exit.")
+@click.option("--secrets", is_flag=True, help="Write a secrets.env file (chmod 600) interactively.")
+def configure_cmd(show: bool, secrets: bool) -> None:
+    """Open the user's models.yaml in $EDITOR, or manage secrets."""
+    if show and secrets:
+        click.echo("ERROR: pass --show OR --secrets, not both", err=True)
+        sys.exit(1)
+    if show:
+        click.echo(f"models.yaml: {_paths.user_models_yaml()}")
+        click.echo(f"config.json: {_paths.user_config_json()}")
+        click.echo(f"secrets.env: {_paths.user_secrets_path()}")
+        return
+    if secrets:
+        _write_secrets_interactive()
+        return
+    # Default: $EDITOR on models.yaml (seeds it first if missing).
+    path = _paths.user_models_yaml()
+    editor = os.environ.get("EDITOR") or os.environ.get("VISUAL") or "vi"
+    click.echo(f"Opening {path} with {editor}...")
+    try:
+        subprocess.run([editor, str(path)], check=False)
+    except FileNotFoundError:
+        click.echo(f"ERROR: editor '{editor}' not found. Set $EDITOR.", err=True)
+        sys.exit(1)
+
+
+def _write_secrets_interactive() -> None:
+    """Prompt for PurelyMail + optional HF keys and persist to secrets.env.
+
+    We chmod 600 and parent-dir mkdir exists_ok=True via
+    :func:`_paths.user_config_dir`. Values blanked out are omitted so we
+    never overwrite a previously-persisted key with "".
+    """
+    target = _paths.user_secrets_path()
+    existing: dict[str, str] = {}
+    if target.exists():
+        for line in target.read_text().splitlines():
+            line = line.strip()
+            if not line or line.startswith("#") or "=" not in line:
+                continue
+            k, v = line.split("=", 1)
+            existing[k.strip()] = v.strip().strip('"').strip("'")
+    click.echo(f"Writing to {target}")
+    click.echo("Leave blank to keep the current value (or skip if unset).\n")
+
+    keys = [
+        ("PURELY_MAIL_API_KEY", "PurelyMail API key"),
+        ("PURELY_MAIL_DOMAIN", "PurelyMail domain"),
+        ("HF_TOKEN", "HuggingFace token (optional)"),
+        ("HF_REPO_ID", "HuggingFace dataset repo id (optional)"),
+    ]
+    updated: dict[str, str] = dict(existing)
+    for key, label in keys:
+        cur = existing.get(key, "")
+        hint = f" [current: {_redact(cur)}]" if cur else ""
+        val = click.prompt(f"  {label}{hint}", default="", show_default=False).strip()
+        if val:
+            updated[key] = val
+
+    lines = ["# claw-bench secrets — chmod 600", ""]
+    lines += [f'{k}="{v}"' for k, v in updated.items()]
+    target.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    try:
+        target.chmod(stat.S_IRUSR | stat.S_IWUSR)
+    except OSError:
+        pass  # windows / non-posix — best effort
+    click.echo(f"\nWrote {len(updated)} key(s) to {target}")
+
+
+def _redact(v: str) -> str:
+    if len(v) <= 4:
+        return "****"
+    return v[:2] + "****" + v[-2:]
+
+
+# ---------------------------------------------------------------------------
+# doctor
+# ---------------------------------------------------------------------------
+
+@main.command("doctor")
+def doctor_cmd() -> None:
+    """Validate engine, image, test-cases, output perms, and secrets."""
+    click.echo("claw-bench diagnostics\n")
+    results = _doctor.run_all()
+    for r in results:
+        _echo_result(r)
+    click.echo()
+    fails = [r for r in results if r.status == "fail"]
+    warns = [r for r in results if r.status == "warn"]
+    if fails:
+        click.echo(click.style(f"{len(fails)} failing check(s). Fix and re-run.", fg="red"))
+        sys.exit(1)
+    if warns:
+        click.echo(click.style(f"{len(warns)} warning(s). ClawBench should still work.", fg="yellow"))
+    else:
+        click.echo(click.style("All checks passed.", fg="green"))
+
+
+# ---------------------------------------------------------------------------
+# version (explicit subcommand in addition to --version)
+# ---------------------------------------------------------------------------
+
+@main.command("version")
+def version_cmd() -> None:
+    """Print the installed version."""
+    click.echo(__version__)
+
+
+if __name__ == "__main__":
+    main()

clawbench/data/chrome-extension/README.md

@@ -0,0 +1,127 @@
+# ClawBench Chrome Extension
+
+This is the source code for the ClawBench Chrome Extension, which acts as the client for the ClawBench benchmarking framework.
+
+The extension is responsible for the following tasks:
+
+- Collecting every action performed by the user/agent on the browser and send the data to the ClawBench server.
+- Take screenshots of the browser on every action, with high-frequency events throttled.
+- Send full screen recording chunks to the server which can be later stitched together to an .mp4 file.
+
+The extension should auto start when any non-built-in page is loaded, and should stop when the browser is closed. No UI or configuration is needed for the extension, as all configuration is done on the server side.
+
+A `setup.sh` script is provided to load the extension into Chrome. Linux and MacOS are supported.
+
+## Files
+
+| File | Description |
+|------|-------------|
+| `manifest.json` | Manifest V3 extension definition. Permissions: `activeTab`, `tabs`. Content scripts injected on all URLs. |
+| `stealth.js` | Anti-bot-detection patches. Runs at `document_start` in `MAIN` world. Overrides `navigator.webdriver`, plugins, WebGL, permissions, etc. |
+| `content.js` | Injected into every non-chrome:// page. Listens for DOM events, extracts metadata, sends to background. Runs at `document_idle` in `ISOLATED` world. |
+| `background.js` | Service worker. Relays actions to server via HTTP POST. Captures screenshots with `chrome.tabs.captureVisibleTab`. |
+| `setup.sh` | Detects Chrome/Chromium binary on macOS or Linux and launches with `--load-extension` and remote debugging enabled. |
+
+## Event Capture
+
+### Captured Events
+
+`click`, `keydown`, `keyup`, `input`, `scroll`, `change`, `submit`, plus a synthetic `pageLoad` on each navigation.
+
+### Throttling
+
+High-frequency events (`scroll`, `input`) are throttled to one every 500ms. Screenshots are also throttled to one every 500ms.
+
+### Action Payload
+
+Each action sent to the server contains:
+
+```json
+{
+  "type": "click",
+  "timestamp": 1710000001234,
+  "url": "https://example.com/",
+  "target": {
+    "tagName": "BUTTON",
+    "id": "submit-btn",
+    "className": "btn primary",
+    "textContent": "Submit",
+    "xpath": "/html[1]/body[1]/form[1]/button[1]"
+  },
+  "x": 255,
+  "y": 245
+}
+```
+
+Additional fields by event type:
+- **click**: `x`, `y` (coordinates)
+- **keydown/keyup**: `key` (key name)
+- **input/change**: `value` (truncated to 200 chars)
+- **scroll**: `scrollX`, `scrollY`
+- **pageLoad**: `title`
+
+## Anti-Bot-Detection (Stealth)
+
+The extension includes `stealth.js`, a content script injected at `document_start` in the `MAIN` world — meaning it runs before any page JavaScript and patches the page's actual `window`/`navigator` objects (not the extension's isolated world). This reduces the chance of being blocked by reCAPTCHA, Cloudflare Turnstile, and similar bot-detection systems.
+
+The stealth measures are split across three layers:
+
+### Layer 1: Chrome Launch Flags (`entrypoint.sh`)
+
+| Flag | What it does |
+|------|-------------|
+| Removed `--enable-automation` | Was explicitly telling Chrome to set `navigator.webdriver = true` and show the "controlled by automated software" infobar. Removing it eliminates both signals. |
+| Removed `--disable-gpu` | Was disabling all GPU/WebGL rendering. Sites that fingerprint WebGL would see no renderer — a strong headless signal. |
+| `--disable-blink-features=AutomationControlled` | Tells Blink not to set `navigator.webdriver = true`, even if CDP is attached. Belt-and-suspenders with the flag removal. |
+| `--use-gl=angle --use-angle=swiftshader` | Enables software-rendered WebGL via SwiftShader through the ANGLE backend. This makes WebGL available with realistic renderer strings without a real GPU. Trade-off: higher CPU usage since all GL operations run in software. |
+| `--enable-webgl` | Explicitly ensures WebGL contexts can be created. |
+| `--remote-debugging-address=127.0.0.1` | CDP was previously bound to `0.0.0.0` (all interfaces). Now only accessible internally. External access still works through the `socat` forwarder on port 9223. Prevents page JavaScript from detecting CDP by probing network ports. |
+
+### Layer 2: Chrome Profile (`entrypoint.sh`)
+
+An empty Chrome profile with no bookmarks, no history, and no preferences is a strong signal of a freshly-created automated browser. The entrypoint now pre-populates:
+
+- **Preferences**: `accept_languages`, `safebrowsing`, `dns_prefetching`, `window_placement`, `skip_first_run_ui`, etc.
+- **Bookmarks**: Three common entries (Google, YouTube, Wikipedia).
+- **Local State**: Profile metadata with a named profile ("Person 1").
+
+### Layer 3: JavaScript Patches (`stealth.js`)
+
+| # | Patch | Why |
+|---|-------|-----|
+| 1 | `navigator.webdriver → false` | The #1 bot detection signal. Real Chrome returns `false`; automated Chrome returns `true`. Even with the Blink flag, CDP attachment can re-enable it. |
+| 2 | `navigator.languages → ['en-US', 'en']` | Ensures consistent locale regardless of container environment. |
+| 3 | `navigator.plugins` — fake Chrome PDF Plugin, Chrome PDF Viewer, Native Client | Headless/automated Chrome reports an empty `PluginArray` (length 0). Real Chrome always has PDF and NaCl plugins. |
+| 4 | `navigator.mimeTypes` — fake `application/pdf` entries | Must match the fake plugins. Empty mimeTypes = headless signal. |
+| 5 | WebGL `getParameter()` — return SwiftShader vendor/renderer | Even with SwiftShader actually running, this ensures consistent, known-good strings across Chromium versions. Intercepts `UNMASKED_VENDOR_WEBGL` (0x9245) and `UNMASKED_RENDERER_WEBGL` (0x9246). |
+| 6 | `Permissions.query({name:'notifications'})` → `'prompt'`, `Notification.permission` → `'default'` | Automated browsers deny all permissions by default. Real browsers return `'prompt'`/`'default'` for notifications. |
+| 7 | `window.chrome.runtime` — ensure object exists | Some bot detectors check `if (!window.chrome \|\| !window.chrome.runtime)` to distinguish headless Chrome from real Chrome. |
+| 8 | Remove `$cdc_`/`cdc_` properties on `document` | Chromedriver injects these properties. Not used by CDP directly, but removed as a precaution. |
+| 9 | `navigator.hardwareConcurrency` → 8 (if < 4) | Docker containers with limited CPUs may report 1-2, which is suspicious for a desktop browser. |
+| 10 | `navigator.deviceMemory` → 8 (if < 4) | Same — low memory is suspicious for desktop. |
+| 11 | Iframe `navigator.webdriver` patching | Advanced fingerprinters create iframes and check `navigator.webdriver` inside them to bypass page-level overrides. We hook `document.createElement('iframe')` and patch the iframe's navigator on load. |
+
+### Layer 4: Dockerfile
+
+`libegl1` and `libgbm1` are installed to provide the EGL and GBM libraries that Chrome's ANGLE/SwiftShader backend needs. Without them, `--use-gl=angle` silently falls back to no-GPU mode.
+
+### Test Results
+
+Verified against bot-detection sites (2026-03-28):
+
+| Test | Result |
+|------|--------|
+| bot.sannysoft.com | 10/11 main tests pass (only "WebDriver New" orange — CDP attachment quirk; "WebDriver Advanced" passes) |
+| intoli headless detection | "You are not Chrome headless" |
+| Cloudflare (nowsecure.nl) | Soft Turnstile challenge (not hard-blocked) |
+| CreepJS | Fingerprint generated without bot flag |
+
+## Local Development
+
+Run Chrome with the extension loaded:
+
+```bash
+./setup.sh https://example.com
+```
+
+The server must be running on `http://localhost:7878` for the extension to send data.

clawbench/data/chrome-extension/background.js

@@ -0,0 +1,50 @@
+const SERVER = "http://localhost:7878";
+const SCREENSHOT_THROTTLE_MS = 500;
+
+let lastScreenshot = 0;
+
+// Auto-focus newly created tabs so the agent's working tab is always visible
+chrome.tabs.onCreated.addListener((tab) => {
+  if (tab.id) {
+    chrome.tabs.update(tab.id, { active: true });
+  }
+});
+
+// Receive events from content script
+chrome.runtime.onMessage.addListener((msg, sender) => {
+  if (msg.type === "action") {
+    // Bring the tab where the action occurred to front so the screen recording
+    // and captureVisibleTab always show the tab the agent is working on.
+    if (sender.tab && sender.tab.id) {
+      chrome.tabs.update(sender.tab.id, { active: true });
+    }
+    postAction(msg.data);
+    captureScreenshot();
+  }
+});
+
+async function postAction(data) {
+  try {
+    await fetch(`${SERVER}/api/action`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(data),
+    });
+  } catch (e) { console.error("[clawbench] postAction failed:", e); }
+}
+
+async function captureScreenshot() {
+  const now = Date.now();
+  if (now - lastScreenshot < SCREENSHOT_THROTTLE_MS) return;
+  lastScreenshot = now;
+
+  try {
+    const dataUrl = await chrome.tabs.captureVisibleTab(null, { format: "png" });
+    const base64 = dataUrl.replace(/^data:image\/png;base64,/, "");
+    await fetch(`${SERVER}/api/screenshot`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ timestamp: now, data: base64 }),
+    });
+  } catch (e) { console.error("[clawbench] captureScreenshot failed:", e); }
+}

clawbench/data/chrome-extension/content.js

@@ -0,0 +1,70 @@
+const THROTTLE_MS = 500;
+const lastSent = {};
+
+function getXPath(el) {
+  if (!el || el.nodeType !== 1) return "";
+  const parts = [];
+  while (el && el.nodeType === 1) {
+    let idx = 1;
+    for (let sib = el.previousElementSibling; sib; sib = sib.previousElementSibling) {
+      if (sib.tagName === el.tagName) idx++;
+    }
+    parts.unshift(`${el.tagName.toLowerCase()}[${idx}]`);
+    el = el.parentElement;
+  }
+  return "/" + parts.join("/");
+}
+
+function buildPayload(type, e) {
+  const target = e.target || {};
+  const payload = {
+    type,
+    timestamp: Date.now(),
+    url: location.href,
+    target: {
+      tagName: target.tagName || "",
+      id: target.id || "",
+      className: target.className || "",
+      textContent: (target.textContent || "").slice(0, 100),
+      xpath: getXPath(target),
+    },
+  };
+  if (e.clientX !== undefined) {
+    payload.x = e.clientX;
+    payload.y = e.clientY;
+  }
+  if (e.key) payload.key = e.key;
+  if (target.value !== undefined) payload.value = String(target.value).slice(0, 200);
+  if (type === "scroll") {
+    payload.scrollX = window.scrollX;
+    payload.scrollY = window.scrollY;
+  }
+  return payload;
+}
+
+function throttled(type) {
+  return type === "scroll" || type === "input";
+}
+
+function send(type, e) {
+  if (throttled(type)) {
+    const now = Date.now();
+    if (lastSent[type] && now - lastSent[type] < THROTTLE_MS) return;
+    lastSent[type] = now;
+  }
+  chrome.runtime.sendMessage({ type: "action", data: buildPayload(type, e) });
+}
+
+["click", "keydown", "keyup", "input", "scroll", "change", "submit"].forEach((evt) => {
+  document.addEventListener(evt, (e) => send(evt, e), true);
+});
+
+chrome.runtime.sendMessage({
+  type: "action",
+  data: {
+    type: "pageLoad",
+    timestamp: Date.now(),
+    url: location.href,
+    title: document.title,
+  },
+});

clawbench/data/chrome-extension/manifest.json

@@ -0,0 +1,25 @@
+{
+  "manifest_version": 3,
+  "name": "ClawBench",
+  "version": "1.0",
+  "description": "Browser action recording for benchmarking",
+  "permissions": ["activeTab", "tabs"],
+  "host_permissions": ["<all_urls>"],
+  "background": {
+    "service_worker": "background.js"
+  },
+  "content_scripts": [
+    {
+      "matches": ["<all_urls>"],
+      "js": ["stealth.js"],
+      "run_at": "document_start",
+      "world": "MAIN"
+    },
+    {
+      "matches": ["<all_urls>"],
+      "js": ["content.js"],
+      "run_at": "document_idle",
+      "all_frames": true
+    }
+  ]
+}