browserforce 1.0.0 → 1.0.5

package/README.md

@@ -1,19 +1,24 @@
 # BrowserForce
 
-**Give your AI agent your real Chrome browser.** Your logins, your cookies, your extensions — already there.
+> "a lion doesn't concern itself with token counting" — [@steipete](https://x.com/steipete), creator of [OpenClaw](https://github.com/openclaw/openclaw)
 
-Other browser tools spawn a fresh Chrome — no logins, no extensions, instantly flagged by bot detectors. BrowserForce connects to **your running browser** instead. One Chrome extension, full Playwright API, everything you're already logged into.
+**You're giving an AI your real Chrome — your logins, cookies, and sessions. That takes conviction.** BrowserForce is built for people who use the best models and don't look back. Security is built in: lock URLs, block navigation, read-only mode, auto-cleanup — you stay in control.
+
+**Fully autonomous browser control.** No manual tab clicking. Your agent browses as you, even from WhatsApp. Other tools make you click each tab, spawn a fresh Chrome, or only work with one AI client. BrowserForce connects to **your running browser** and auto-attaches to all tabs. One Chrome extension, full Playwright API, completely hands-off.
 
 Works with [OpenClaw](https://github.com/openclaw/openclaw), Claude, or any MCP-compatible agent.
 
-| | OpenClaw's built-in browser | BrowserForce |
-|---|---|---|
-| Browser | Spawns dedicated Chrome | **Uses your Chrome** |
-| Login state | Fresh — must log in every time | Already logged in |
-| Extensions | None | Your existing ones |
-| 2FA / Captchas | Blocked | Already passed (you did it) |
-| Bot detection | Easily detected | Runs in your real profile |
-| Cookies & sessions | Empty | Yours |
+## Comparison
+
+| | Playwright MCP | Playwriter | Claude Extension | Antigravity | BrowserForce |
+|---|---|---|---|---|---|
+| Tab access | N/A (new browser) | Click each tab | Click each tab | Click each tab | **All tabs, automatic** |
+| Browser | Spawns new Chrome | Your Chrome | Your Chrome | Your Chrome | **Your Chrome** |
+| Autonomous | Yes | No (manual click) | No (manual click) | No (manual click) | **Yes (fully autonomous)** |
+| Tools | Many dedicated tools | 1 `execute` tool | Built-in | Many dedicated tools | **1 `execute` tool** |
+| Agent support | Any MCP client | Any MCP client | Claude only | Custom | **Any MCP client** |
+| Context method | Screenshots | A11y snapshots | Screenshots | Screenshots | **A11y snapshots** |
+| Playwright API | Partial | Full | No | No | **Full** |
 
 ## Setup
 
@@ -26,7 +31,7 @@ npm install -g browserforce
 Or from source:
 
 ```bash
-git clone https://github.com/anthropics/browserforce.git
+git clone https://github.com/ivalsaraj/browserforce.git
 cd browserforce
 pnpm install
 ```
@@ -64,7 +69,15 @@ Extension icon turns green — you're connected.
 
 ### OpenClaw
 
-Add to `~/.openclaw/openclaw.json`:
+Install the BrowserForce skill:
+
+```bash
+npx -y skills add ivalsaraj/browserforce
+```
+
+The skill teaches your agent to use BrowserForce CLI commands via Bash. Your OpenClaw agent can now browse the web as you — no login flows, no captchas.
+
+Or add BrowserForce as an MCP server in `~/.openclaw/openclaw.json`:
 
 ```json
 {
@@ -77,8 +90,8 @@ Add to `~/.openclaw/openclaw.json`:
             {
               "name": "browserforce",
               "transport": "stdio",
-              "command": "node",
-              "args": ["/absolute/path/to/browserforce/mcp/src/index.js"]
+              "command": "npx",
+              "args": ["-y", "browserforce", "mcp"]
             }
           ]
         }
@@ -88,8 +101,6 @@ Add to `~/.openclaw/openclaw.json`:
 }
 ```
 
-Then add `"mcp-adapter"` to your agent's allowed tools. Your OpenClaw agent can now browse the web as you — no login flows, no captchas.
-
 ### Claude Desktop
 
 Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
@@ -98,8 +109,8 @@ Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
 {
   "mcpServers": {
     "browserforce": {
-      "command": "node",
-      "args": ["/absolute/path/to/browserforce/mcp/src/index.js"]
+      "command": "npx",
+      "args": ["-y", "browserforce", "mcp"]
     }
   }
 }
@@ -113,8 +124,8 @@ Add to `~/.claude/mcp.json`:
 {
   "mcpServers": {
     "browserforce": {
-      "command": "node",
-      "args": ["/absolute/path/to/browserforce/mcp/src/index.js"]
+      "command": "npx",
+      "args": ["-y", "browserforce", "mcp"]
     }
   }
 }
@@ -138,16 +149,6 @@ browserforce -e "<code>"        # Run Playwright JavaScript (one-shot)
 
 Each `-e` command is one-shot — state does not persist between calls. For persistent state, use the MCP server.
 
-### OpenClaw Skill
-
-Install the skill directly:
-
-```bash
-npx -y skills add anthropics/browserforce
-```
-
-Or add to your agent config manually — the skill teaches the agent to use BrowserForce CLI commands via Bash.
-
 ### Any Playwright Script
 
 ```javascript
@@ -230,16 +231,19 @@ The **Chrome extension** lives in your browser. It attaches Chrome's built-in de
 
 When the agent connects, it immediately sees all your open tabs as controllable Playwright pages. No clicking, no manual attachment.
 
-## Extension Settings
+## You Stay in Control
 
-Click the extension icon to configure:
+Click the extension icon to configure restrictions. Your browser, your rules:
 
-- **Auto / Manual mode** — Let the agent create tabs freely, or manually select which tabs it can access
-- **Lock URL** — Prevent the agent from navigating away from the current page
-- **No new tabs** — Block tab creation
-- **Read-only** — Observe only, no interactions
-- **Auto-cleanup** — Automatically detach or close agent tabs after a timeout
-- **Custom instructions** — Pass text instructions to the agent
+| Setting | What it does |
+|---------|-------------|
+| **Auto / Manual mode** | Let the agent create tabs freely, or hand-pick which tabs it can access |
+| **Lock URL** | Prevent the agent from navigating away from the current page |
+| **No new tabs** | Block the agent from opening new tabs |
+| **Read-only** | Observe only — no clicks, no typing, no interactions |
+| **Auto-detach** | Automatically detach inactive tabs after 5-60 minutes |
+| **Auto-close** | Automatically close agent-created tabs after 5-60 minutes |
+| **Custom instructions** | Pass text instructions to the agent (e.g. "don't click any buy buttons") |
 
 ## Security
 
@@ -249,6 +253,7 @@ Click the extension icon to configure:
 | **Auth** | Random token required for every CDP connection |
 | **Origin** | Extension only accepts connections from its own Chrome origin |
 | **Visibility** | Chrome shows "controlled by automated test software" on active tabs |
+| **Restrictions** | Lock URLs, block navigation, read-only mode — enforced at the CDP level |
 
 Everything runs on your machine. The auth token is stored at `~/.browserforce/auth-token` with owner-only permissions.
 
@@ -290,4 +295,4 @@ RELAY_PORT=19333 browserforce serve
 | Extension keeps reconnecting | Normal — MV3 kills idle workers; it auto-recovers |
 | Port in use | `lsof -ti:19222 \| xargs kill -9` |
 
-> **Want the full walkthrough?** Read the [User Guide](GUIDE.md) for a plain-English explanation of what this does and how to get started.
+> **Want the full walkthrough?** Read the [User Guide](https://github.com/ivalsaraj/browserforce/blob/main/GUIDE.md) for a plain-English explanation of what this does and how to get started.

package/mcp/src/a11y-labels.js

@@ -0,0 +1,466 @@
+// BrowserForce — Accessibility Label Overlay for Screenshots
+// Uses CDP AX tree + DOM.getBoxModel for element positioning,
+// then injects browser-side label renderer for Vimium-style labels.
+
+import {
+  INTERACTIVE_ROLES, CONTEXT_ROLES, SKIP_ROLES,
+  buildLocator, escapeLocatorName,
+} from './snapshot.js';
+
+// ─── Semaphore ────────────────────────────────────────────────────────────────
+
+export class Semaphore {
+  constructor(max) {
+    this.max = max;
+    this.count = 0;
+    this.queue = [];
+  }
+
+  acquire() {
+    if (this.count < this.max) {
+      this.count++;
+      return Promise.resolve();
+    }
+    return new Promise(resolve => this.queue.push(resolve));
+  }
+
+  release() {
+    this.count--;
+    if (this.queue.length > 0) {
+      this.count++;
+      this.queue.shift()();
+    }
+  }
+}
+
+// ─── Box Model ────────────────────────────────────────────────────────────────
+
+export function buildBoxFromQuad(quad) {
+  const xs = [quad[0], quad[2], quad[4], quad[6]];
+  const ys = [quad[1], quad[3], quad[5], quad[7]];
+  return {
+    x: Math.min(...xs),
+    y: Math.min(...ys),
+    width: Math.max(...xs) - Math.min(...xs),
+    height: Math.max(...ys) - Math.min(...ys),
+  };
+}
+
+// ─── CDP AX Tree → Snapshot Text ──────────────────────────────────────────────
+
+export function buildSnapshotFromCdpNodes(nodes, scopeBackendNodeId, { refAll = false } = {}) {
+  // Build lookup maps
+  const byId = new Map();
+  for (const node of nodes) {
+    byId.set(node.nodeId, node);
+  }
+
+  // Find scope root if scoping requested
+  let scopeNodeId = null;
+  if (scopeBackendNodeId != null) {
+    const scopeNode = nodes.find(n => n.backendDOMNodeId === scopeBackendNodeId);
+    if (!scopeNode) {
+      throw new Error(
+        `Scoped element (backendNodeId=${scopeBackendNodeId}) has no matching accessibility node. ` +
+        'The element may be aria-hidden or have no accessible role.'
+      );
+    }
+    scopeNodeId = scopeNode.nodeId;
+  }
+
+  // Build tree structure from parentId references
+  const childrenMap = new Map();
+  for (const node of nodes) {
+    if (!childrenMap.has(node.nodeId)) childrenMap.set(node.nodeId, []);
+    if (node.parentId) {
+      if (!childrenMap.has(node.parentId)) childrenMap.set(node.parentId, []);
+      childrenMap.get(node.parentId).push(node);
+    }
+  }
+
+  // Check if a nodeId is inside the scope subtree
+  function isInScope(nodeId) {
+    if (!scopeNodeId) return true;
+    let current = nodeId;
+    while (current) {
+      if (current === scopeNodeId) return true;
+      const node = byId.get(current);
+      current = node?.parentId || null;
+    }
+    return false;
+  }
+
+  const lines = [];
+  const refs = [];
+  let refCounter = 0;
+
+  function walk(nodeId, depth) {
+    const node = byId.get(nodeId);
+    if (!node || node.ignored) return;
+
+    const role = node.role?.value;
+    if (!role) return;
+
+    // Skip root wrapper and generic roles — recurse into children
+    if (role === 'RootWebArea' || role === 'WebArea') {
+      for (const child of childrenMap.get(nodeId) || []) {
+        walk(child.nodeId, depth);
+      }
+      return;
+    }
+    if (SKIP_ROLES.has(role)) {
+      for (const child of childrenMap.get(nodeId) || []) {
+        walk(child.nodeId, depth);
+      }
+      return;
+    }
+
+    // Check scope
+    if (!isInScope(nodeId)) return;
+
+    const isInteractive = INTERACTIVE_ROLES.has(role);
+    const isContext = CONTEXT_ROLES.has(role);
+    const name = node.name?.value || '';
+    const children = childrenMap.get(nodeId) || [];
+
+    // Skip non-interactive, non-context nodes without interactive descendants
+    if (!isInteractive && !isContext) {
+      const hasInteractive = children.some(c => {
+        const r = c.role?.value;
+        return r && INTERACTIVE_ROLES.has(r);
+      });
+      if (!hasInteractive) {
+        // Still recurse — children may have interactive descendants
+        for (const child of children) {
+          walk(child.nodeId, depth);
+        }
+        return;
+      }
+    }
+
+    const indent = '  '.repeat(depth);
+    let lineText = `${indent}- ${role}`;
+    if (name) {
+      lineText += ` "${escapeLocatorName(name)}"`;
+    }
+
+    if (isInteractive || (refAll && isContext && node.backendDOMNodeId)) {
+      refCounter++;
+      const ref = `e${refCounter}`;
+      const locator = buildLocator(role, name, null);
+      lineText += ` [ref=${ref}]`;
+      refs.push({ ref, role, name, backendNodeId: node.backendDOMNodeId, locator });
+    }
+
+    const relevantChildren = children.filter(c => {
+      const r = c.role?.value;
+      return r && !c.ignored && (INTERACTIVE_ROLES.has(r) || CONTEXT_ROLES.has(r) || !SKIP_ROLES.has(r));
+    });
+    if (relevantChildren.length > 0) {
+      lineText += ':';
+    }
+
+    lines.push(lineText);
+
+    for (const child of children) {
+      walk(child.nodeId, depth + 1);
+    }
+  }
+
+  // Find root nodes (no parentId)
+  const roots = nodes.filter(n => !n.parentId);
+  for (const root of roots) {
+    walk(root.nodeId, 0);
+  }
+
+  return { text: lines.join('\n'), refs };
+}
+
+// ─── Browser-Side Label Renderer ──────────────────────────────────────────────
+// Injected into page context via page.evaluate().
+// Port of Playwriter's a11y-client.ts — Vimium-style color-coded labels.
+
+const LABELS_CONTAINER_ID = '__bf_labels__';
+const LABELS_TIMER_KEY = '__bf_labels_timer__';
+
+export const ROLE_COLORS = {
+  link: ['#FFF785', '#FFC542', '#E3BE23'],
+  button: ['#FFE0B2', '#FFCC80', '#FFB74D'],
+  textbox: ['#FFCDD2', '#EF9A9A', '#E57373'],
+  combobox: ['#F8BBD0', '#F48FB1', '#F06292'],
+  searchbox: ['#F8BBD0', '#F48FB1', '#F06292'],
+  checkbox: ['#C8E6C9', '#A5D6A7', '#81C784'],
+  radio: ['#C8E6C9', '#A5D6A7', '#81C784'],
+  slider: ['#BBDEFB', '#90CAF9', '#64B5F6'],
+  spinbutton: ['#BBDEFB', '#90CAF9', '#64B5F6'],
+  switch: ['#D1C4E9', '#B39DDB', '#9575CD'],
+  menuitem: ['#FFE0B2', '#FFCC80', '#FFB74D'],
+  menuitemcheckbox: ['#FFE0B2', '#FFCC80', '#FFB74D'],
+  menuitemradio: ['#FFE0B2', '#FFCC80', '#FFB74D'],
+  option: ['#FFE0B2', '#FFCC80', '#FFB74D'],
+  tab: ['#FFE0B2', '#FFCC80', '#FFB74D'],
+  treeitem: ['#FFE0B2', '#FFCC80', '#FFB74D'],
+  img: ['#B3E5FC', '#81D4FA', '#4FC3F7'],
+  video: ['#B3E5FC', '#81D4FA', '#4FC3F7'],
+  audio: ['#B3E5FC', '#81D4FA', '#4FC3F7'],
+};
+
+const DEFAULT_COLORS = ['#FFF9C4', '#FFF59D', '#FFEB3B'];
+
+// This string is injected into the page via page.evaluate().
+// It sets up globalThis.__bf_a11y with renderA11yLabels and hideA11yLabels.
+export const A11Y_CLIENT_CODE = `
+(function() {
+  const CONTAINER_ID = '${LABELS_CONTAINER_ID}';
+  const TIMER_KEY = '${LABELS_TIMER_KEY}';
+  const ROLE_COLORS = ${JSON.stringify(ROLE_COLORS)};
+  const DEFAULT_COLORS = ${JSON.stringify(DEFAULT_COLORS)};
+
+  function renderA11yLabels(labels) {
+    const doc = document;
+    const win = window;
+
+    if (win[TIMER_KEY]) {
+      win.clearTimeout(win[TIMER_KEY]);
+      win[TIMER_KEY] = null;
+    }
+
+    doc.getElementById(CONTAINER_ID)?.remove();
+
+    const container = doc.createElement('div');
+    container.id = CONTAINER_ID;
+    container.style.cssText = 'position:absolute;left:0;top:0;z-index:2147483647;pointer-events:none;';
+
+    const style = doc.createElement('style');
+    style.textContent = '.__bf_label__{position:absolute;font:bold 12px Helvetica,Arial,sans-serif;padding:1px 4px;border-radius:3px;color:black;text-shadow:0 1px 0 rgba(255,255,255,0.6);white-space:nowrap;}';
+    container.appendChild(style);
+
+    const svg = doc.createElementNS('http://www.w3.org/2000/svg', 'svg');
+    svg.style.cssText = 'position:absolute;left:0;top:0;pointer-events:none;overflow:visible;';
+    svg.setAttribute('width', '' + doc.documentElement.scrollWidth);
+    svg.setAttribute('height', '' + doc.documentElement.scrollHeight);
+
+    const defs = doc.createElementNS('http://www.w3.org/2000/svg', 'defs');
+    svg.appendChild(defs);
+    const markerCache = {};
+
+    function getArrowMarkerId(color) {
+      if (markerCache[color]) return markerCache[color];
+      const markerId = 'bf-arrow-' + color.replace('#', '');
+      const marker = doc.createElementNS('http://www.w3.org/2000/svg', 'marker');
+      marker.setAttribute('id', markerId);
+      marker.setAttribute('viewBox', '0 0 10 10');
+      marker.setAttribute('refX', '9');
+      marker.setAttribute('refY', '5');
+      marker.setAttribute('markerWidth', '6');
+      marker.setAttribute('markerHeight', '6');
+      marker.setAttribute('orient', 'auto-start-reverse');
+      const path = doc.createElementNS('http://www.w3.org/2000/svg', 'path');
+      path.setAttribute('d', 'M 0 0 L 10 5 L 0 10 z');
+      path.setAttribute('fill', color);
+      marker.appendChild(path);
+      defs.appendChild(marker);
+      markerCache[color] = markerId;
+      return markerId;
+    }
+
+    container.appendChild(svg);
+
+    const placedLabels = [];
+    const LABEL_HEIGHT = 17;
+    const LABEL_CHAR_WIDTH = 7;
+
+    const viewportLeft = win.scrollX;
+    const viewportTop = win.scrollY;
+    const viewportRight = viewportLeft + win.innerWidth;
+    const viewportBottom = viewportTop + win.innerHeight;
+
+    let count = 0;
+    for (const item of labels) {
+      const ref = item.ref;
+      const role = item.role;
+      const box = item.box;
+
+      const rectLeft = box.x;
+      const rectTop = box.y;
+      const rectRight = rectLeft + box.width;
+      const rectBottom = rectTop + box.height;
+
+      if (box.width <= 0 || box.height <= 0) continue;
+      if (rectRight < viewportLeft || rectLeft > viewportRight ||
+          rectBottom < viewportTop || rectTop > viewportBottom) continue;
+
+      const labelWidth = ref.length * LABEL_CHAR_WIDTH + 8;
+      const labelLeft = rectLeft;
+      const labelTop = Math.max(0, rectTop - LABEL_HEIGHT);
+      const labelRect = { left: labelLeft, top: labelTop, right: labelLeft + labelWidth, bottom: labelTop + LABEL_HEIGHT };
+
+      let overlaps = false;
+      for (const placed of placedLabels) {
+        if (labelRect.left < placed.right && labelRect.right > placed.left &&
+            labelRect.top < placed.bottom && labelRect.bottom > placed.top) {
+          overlaps = true;
+          break;
+        }
+      }
+      if (overlaps) continue;
+
+      const colors = ROLE_COLORS[role] || DEFAULT_COLORS;
+      const label = doc.createElement('div');
+      label.className = '__bf_label__';
+      label.textContent = ref;
+      label.style.background = 'linear-gradient(to bottom, ' + colors[0] + ' 0%, ' + colors[1] + ' 100%)';
+      label.style.border = '1px solid ' + colors[2];
+      label.style.left = labelLeft + 'px';
+      label.style.top = labelTop + 'px';
+      container.appendChild(label);
+
+      const line = doc.createElementNS('http://www.w3.org/2000/svg', 'line');
+      line.setAttribute('x1', '' + (labelLeft + labelWidth / 2));
+      line.setAttribute('y1', '' + (labelTop + LABEL_HEIGHT));
+      line.setAttribute('x2', '' + (rectLeft + box.width / 2));
+      line.setAttribute('y2', '' + (rectTop + box.height / 2));
+      line.setAttribute('stroke', colors[2]);
+      line.setAttribute('stroke-width', '1.5');
+      line.setAttribute('marker-end', 'url(#' + getArrowMarkerId(colors[2]) + ')');
+      svg.appendChild(line);
+
+      placedLabels.push(labelRect);
+      count++;
+    }
+
+    doc.documentElement.appendChild(container);
+
+    win[TIMER_KEY] = win.setTimeout(function() {
+      doc.getElementById(CONTAINER_ID)?.remove();
+      win[TIMER_KEY] = null;
+    }, 30000);
+
+    return count;
+  }
+
+  function hideA11yLabels() {
+    if (window['${LABELS_TIMER_KEY}']) {
+      window.clearTimeout(window['${LABELS_TIMER_KEY}']);
+      window['${LABELS_TIMER_KEY}'] = null;
+    }
+    document.getElementById('${LABELS_CONTAINER_ID}')?.remove();
+  }
+
+  globalThis.__bf_a11y = { renderA11yLabels: renderA11yLabels, hideA11yLabels: hideA11yLabels };
+})();
+`;
+
+// ─── CDP Helpers ──────────────────────────────────────────────────────────────
+
+const MAX_CONCURRENCY = 24;
+const BOX_MODEL_TIMEOUT_MS = 5000;
+const MAX_SCREENSHOT_DIMENSION = 1568;
+
+export async function resolveScopeBackendNodeId(cdp, selector) {
+  if (!selector) return null;
+  const { root } = await cdp.send('DOM.getDocument');
+  const { nodeId } = await cdp.send('DOM.querySelector', {
+    nodeId: root.nodeId, selector,
+  });
+  if (!nodeId) {
+    throw new Error(`Selector "${selector}" did not match any element on the page`);
+  }
+  const { node } = await cdp.send('DOM.describeNode', { nodeId });
+  return node.backendNodeId;
+}
+
+export async function getLabelBoxes(cdp, refs) {
+  const sema = new Semaphore(MAX_CONCURRENCY);
+  const results = await Promise.all(
+    refs.map(async (ref) => {
+      if (!ref.backendNodeId) return null;
+      await sema.acquire();
+      try {
+        const response = await Promise.race([
+          cdp.send('DOM.getBoxModel', { backendNodeId: ref.backendNodeId }),
+          new Promise(resolve => setTimeout(() => resolve(null), BOX_MODEL_TIMEOUT_MS)),
+        ]);
+        if (!response) return null;
+        const box = buildBoxFromQuad(response.model.border);
+        if (box.width <= 0 || box.height <= 0) return null;
+        return { ref: ref.ref, role: ref.role, box };
+      } catch {
+        return null;
+      } finally {
+        sema.release();
+      }
+    })
+  );
+  return results.filter(Boolean);
+}
+
+export async function injectA11yClient(page) {
+  const exists = await page.evaluate(() => typeof globalThis.__bf_a11y !== 'undefined');
+  if (!exists) {
+    await page.evaluate(A11Y_CLIENT_CODE);
+  }
+}
+
+export async function showLabels(page, labels) {
+  return page.evaluate((entries) => globalThis.__bf_a11y.renderA11yLabels(entries), labels);
+}
+
+export async function hideLabels(page) {
+  await page.evaluate(() => {
+    const timerKey = '__bf_labels_timer__';
+    if (window[timerKey]) {
+      window.clearTimeout(window[timerKey]);
+      window[timerKey] = null;
+    }
+    document.getElementById('__bf_labels__')?.remove();
+  });
+}
+
+// ─── Main Orchestrator ────────────────────────────────────────────────────────
+
+export async function screenshotWithLabels(page, { selector, interactiveOnly = true } = {}) {
+  let cdp;
+  let labelsInjected = false;
+
+  try {
+    cdp = await page.context().newCDPSession(page);
+
+    const scopeId = selector
+      ? await resolveScopeBackendNodeId(cdp, selector)
+      : null;
+
+    const { nodes } = await cdp.send('Accessibility.getFullAXTree');
+    const { text, refs } = buildSnapshotFromCdpNodes(nodes, scopeId, {
+      refAll: !interactiveOnly,
+    });
+
+    const labels = await getLabelBoxes(cdp, refs);
+
+    await injectA11yClient(page);
+    labelsInjected = true;
+    const labelCount = await showLabels(page, labels);
+
+    const maxDim = MAX_SCREENSHOT_DIMENSION;
+    const viewport = await page.evaluate((max) => ({
+      width: Math.min(window.innerWidth, max),
+      height: Math.min(window.innerHeight, max),
+    }), maxDim);
+
+    const screenshot = await page.screenshot({
+      type: 'jpeg',
+      quality: 80,
+      scale: 'css',
+      clip: { x: 0, y: 0, ...viewport },
+    });
+
+    return { screenshot, snapshot: text, labelCount };
+  } finally {
+    if (labelsInjected) {
+      try { await hideLabels(page); } catch { /* page may have navigated */ }
+    }
+    if (cdp) {
+      try { await cdp.detach(); } catch { /* session may already be detached */ }
+    }
+  }
+}

package/mcp/src/index.js

@@ -1,5 +1,5 @@
 // BrowserForce — MCP Server
-// 2-tool architecture: execute (run Playwright code) + reset (reconnect)
+// 3-tool architecture: execute (run Playwright code) + reset (reconnect) + screenshot_with_labels (visual a11y labels)
 // Connects to the relay via Playwright's CDP client.
 
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
@@ -9,6 +9,7 @@ import { chromium } from 'playwright-core';
 import {
   getCdpUrl, CodeExecutionTimeoutError, buildExecContext, runCode, formatResult,
 } from './exec-engine.js';
+import { screenshotWithLabels } from './a11y-labels.js';
 
 // ─── Console Log Capture ─────────────────────────────────────────────────────
 
@@ -350,6 +351,79 @@ server.tool(
   }
 );
 
+// ─── Screenshot with Labels Tool ──────────────────────────────────────────────
+
+const SCREENSHOT_LABELS_PROMPT = `Take a screenshot with Vimium-style accessibility labels on interactive elements.
+
+Returns TWO content items:
+1. JPEG screenshot with color-coded labels (e1, e2, e3...) on buttons, links, inputs, etc.
+2. Text accessibility snapshot with matching refs and role/name locators
+
+Labels are color-coded by role:
+- Yellow: links
+- Orange: buttons, menu items, tabs
+- Red/pink: text inputs, search boxes
+- Green: checkboxes, radio buttons
+- Blue: sliders, spinbuttons, media
+- Purple: switches
+
+Use this tool when:
+- You need to understand the visual layout of a page
+- Text snapshot alone can't convey spatial relationships
+- You need to verify element positions (dashboards, grids, maps)
+- You need both visual context AND element refs for interaction
+
+After getting the screenshot, use the refs to interact via the execute tool:
+  await state.page.locator('role=button[name="Submit"]').click();
+
+Parameters:
+- selector: CSS selector to scope labels to part of the page (e.g., '#main', '.sidebar'). Main frame only.
+- interactiveOnly: Only label interactive elements like buttons/links/inputs (default: true)
+
+Limitations:
+- Main frame only — does not label elements inside cross-origin iframes
+- Locators are role/name based — no data-testid matching`;
+
+server.tool(
+  'screenshot_with_labels',
+  SCREENSHOT_LABELS_PROMPT,
+  {
+    selector: z.string().optional().describe('CSS selector to scope labels to a subtree of the main frame'),
+    interactiveOnly: z.boolean().optional().describe('Only label interactive elements (default: true)'),
+  },
+  async ({ selector, interactiveOnly = true }) => {
+    await ensureBrowser();
+    const ctx = getContext();
+    const page = (userState.page && !userState.page.isClosed())
+      ? userState.page
+      : ctx.pages()[0] || null;
+    if (!page) {
+      return {
+        content: [{ type: 'text', text: 'Error: No pages available. Open a tab first.' }],
+        isError: true,
+      };
+    }
+
+    try {
+      const { screenshot, snapshot, labelCount } = await screenshotWithLabels(page, {
+        selector,
+        interactiveOnly,
+      });
+      return {
+        content: [
+          { type: 'image', data: screenshot.toString('base64'), mimeType: 'image/jpeg' },
+          { type: 'text', text: `Labels: ${labelCount} interactive elements\n\n${snapshot}` },
+        ],
+      };
+    } catch (err) {
+      return {
+        content: [{ type: 'text', text: `Error: ${err.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
 // ─── Start Server ────────────────────────────────────────────────────────────
 
 async function main() {

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "browserforce",
-  "version": "1.0.0",
+  "version": "1.0.5",
   "type": "module",
   "description": "Give AI agents your real Chrome browser — your logins, cookies, and tabs. Works with OpenClaw, Claude, and any MCP agent.",
-  "homepage": "https://github.com/anthropics/browserforce",
+  "homepage": "https://github.com/ivalsaraj/browserforce",
   "repository": {
     "type": "git",
-    "url": "https://github.com/anthropics/browserforce.git"
+    "url": "https://github.com/ivalsaraj/browserforce.git"
   },
   "license": "MIT",
   "keywords": [