agent-browser-bridge 2.0.0 → 2.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-browser-bridge",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "Live multi-tab, multi-profile Chrome DevTools MCP bridge for AI agents (Antigravity, Claude, Cursor, Windsurf)",
   "author": "thisisdarkstar",
   "type": "module",
@@ -11,6 +11,8 @@
   "files": [
     "bin",
     "index.js",
+    "core",
+    "tools",
     "README.md"
   ],
   "scripts": {

package/tools/browser-data-tools.js

@@ -0,0 +1,141 @@
+// Agent Bridge MCP - Bookmarks, History, Notifications, Clipboard & Downloads Tools (ES Module)
+import { z } from "zod";
+import { jsonResult } from "../core/state.js";
+import { callProfileExtension } from "../core/bridge.js";
+
+export function registerBrowserDataTools(server) {
+  server.registerTool(
+    "browser_search_bookmarks",
+    {
+      description: "Search the user's personal browser bookmarks by query keyword or folder name.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        query: z.string().optional().describe("Search keyword to match in title or URL. Empty string returns all recent bookmarks."),
+        limit: z.number().optional().describe("Max bookmarks to return (default 50)"),
+      },
+    },
+    async ({ profile, query, limit }) => {
+      const res = await callProfileExtension(profile, "search_bookmarks", { query, limit });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_add_bookmark",
+    {
+      description: "Create a new bookmark in the user's browser with title and URL.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        title: z.string().describe("Title for the bookmark"),
+        url: z.string().describe("Target webpage URL to bookmark"),
+        parentId: z.string().optional().describe("Optional parent bookmark folder ID (defaults to 'Other bookmarks')"),
+      },
+    },
+    async ({ profile, title, url, parentId }) => {
+      const res = await callProfileExtension(profile, "add_bookmark", { title, url, parentId });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_search_history",
+    {
+      description: "Search the user's browsing history by query keyword, date range, and visit counts.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        query: z.string().optional().describe("Search keyword in history titles or URLs"),
+        limit: z.number().optional().describe("Max history items to return (default 50)"),
+        startTime: z.number().optional().describe("Milliseconds timestamp to search after (defaults to 7 days ago)"),
+      },
+    },
+    async ({ profile, query, limit, startTime }) => {
+      const res = await callProfileExtension(profile, "search_history", { query, limit, startTime });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_show_notification",
+    {
+      description: "Display a native OS desktop notification from the browser (ideal for alerting user when a long-running agent task finishes).",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        title: z.string().optional().describe("Notification title"),
+        message: z.string().describe("Notification body message text"),
+      },
+    },
+    async ({ profile, title, message }) => {
+      const res = await callProfileExtension(profile, "show_notification", { title, message });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_download_file",
+    {
+      description: "Trigger a file download from a direct URL in the browser with customizable filename and conflict action.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().optional().describe("Optional tabId associated with the download"),
+        url: z.string().describe("Direct URL of the file to download"),
+        filename: z.string().optional().describe("Custom local filename or subpath"),
+        saveAs: z.boolean().optional().describe("Whether to prompt user with save file dialog (default false)"),
+        conflictAction: z.enum(["uniquify", "overwrite", "prompt"]).optional().describe("Action on duplicate filename (default 'uniquify')"),
+      },
+    },
+    async ({ profile, tabId, url, filename, saveAs, conflictAction }) => {
+      const res = await callProfileExtension(profile, "download_file", { tabId, url, filename, saveAs, conflictAction });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_wait_for_download",
+    {
+      description: "Wait for a file download to complete, returning its final filename and file size.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        downloadId: z.number().optional().describe("Specific download ID to wait for"),
+        timeoutMs: z.number().optional().describe("Timeout in milliseconds (default 30000)"),
+      },
+    },
+    async ({ profile, downloadId, timeoutMs }) => {
+      const res = await callProfileExtension(profile, "wait_for_download", { downloadId, timeoutMs });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_list_downloads",
+    {
+      description: "List recent downloads in the browser profile (status, file path, bytes received).",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        limit: z.number().optional().describe("Max downloads to return (default 20)"),
+        state: z.enum(["in_progress", "interrupted", "complete"]).optional().describe("Filter by state"),
+      },
+    },
+    async ({ profile, limit, state }) => {
+      const res = await callProfileExtension(profile, "list_downloads", { limit, state });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_clipboard",
+    {
+      description: "Read or copy text directly to/from the system clipboard in the active tab context.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+        operation: z.enum(["get", "set"]).optional().describe("'get' to read clipboard, 'set' to copy text (default 'get')"),
+        text: z.string().optional().describe("Text string to write when operation is 'set'"),
+      },
+    },
+    async ({ profile, tabId, operation, text }) => {
+      const res = await callProfileExtension(profile, "clipboard", { tabId, operation, text });
+      return jsonResult(res);
+    }
+  );
+}
+

package/tools/diagnostic-tools.js

@@ -0,0 +1,170 @@
+// Agent Bridge MCP - Diagnostics, Performance, Console & Raw CDP Tools (ES Module)
+import { z } from "zod";
+import { jsonResult } from "../core/state.js";
+import { callProfileExtension } from "../core/bridge.js";
+
+export function registerDiagnosticTools(server) {
+  server.registerTool(
+    "browser_wait_for",
+    {
+      description: "Wait until a selector appears in DOM or text appears in document body (replaces arbitrary sleep timers).",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+        selector: z.string().optional().describe("CSS selector or ref to wait for"),
+        text: z.string().optional().describe("Text string to wait for on page"),
+        visible: z.boolean().optional().describe("Require element to be visible (default true)"),
+        timeout: z.number().optional().describe("Timeout in milliseconds (default 10000)"),
+      },
+    },
+    async ({ profile, tabId, selector, text, visible, timeout }) => {
+      const res = await callProfileExtension(profile, "wait_for", { tabId, selector, text, visible, timeout });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_list_console_messages",
+    {
+      description: "List captured console messages (log, info, warn, error, uncaught exceptions) with arguments and stack traces.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+        types: z.array(z.string()).optional().describe("Filter by type (e.g. ['error', 'warn'])"),
+        limit: z.number().optional().describe("Max messages to return (default 100)"),
+      },
+    },
+    async ({ profile, tabId, types, limit }) => {
+      const res = await callProfileExtension(profile, "list_console_messages", { tabId, types, limit });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_get_telemetry",
+    {
+      description: "Combined telemetry snapshot: console logs, recent network requests, and dialog events for a tab in one call.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+      },
+    },
+    async ({ profile, tabId }) => {
+      const res = await callProfileExtension(profile, "get_telemetry", { tabId });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_take_heapsnapshot",
+    {
+      description: "Capture V8 heap snapshot via DevTools HeapProfiler.takeHeapSnapshot for JavaScript memory leak diagnosis.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+      },
+    },
+    async ({ profile, tabId }) => {
+      const res = await callProfileExtension(profile, "take_heapsnapshot", { tabId });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_performance_trace",
+    {
+      description: "Start or stop Chrome DevTools Tracing performance profile.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+        action: z.enum(["start", "stop"]).describe("Action to perform"),
+        categories: z.string().optional().describe("Trace categories string"),
+      },
+    },
+    async ({ profile, tabId, action, categories }) => {
+      const res = await callProfileExtension(profile, "performance_trace", { tabId, action, categories });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_performance_analyze_insight",
+    {
+      description: "Extract Core Web Vitals (TTFB, FCP, First Paint, DOMContentLoaded, Load Time, Transfer Size) for a tab.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+      },
+    },
+    async ({ profile, tabId }) => {
+      const res = await callProfileExtension(profile, "performance_analyze_insight", { tabId });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_eval_js",
+    {
+      description: "Evaluate arbitrary JavaScript in the tab context with async/await support and return serialized result.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+        code: z.string().describe("JavaScript code string to evaluate"),
+        useDebugger: z.boolean().optional().describe("Use Runtime.evaluate over CDP (default false)"),
+      },
+    },
+    async ({ profile, tabId, code, useDebugger }) => {
+      const res = await callProfileExtension(profile, "eval_js", { tabId, code, useDebugger });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_raw_cdp",
+    {
+      description: "Ultimate escape hatch: execute ANY raw Chrome DevTools Protocol command with arbitrary parameters on a tab.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+        method: z.string().describe("CDP method name (e.g. 'Page.captureScreenshot', 'DOM.getDocument', 'Network.clearBrowserCache')"),
+        commandParams: z.record(z.any()).optional().describe("Parameters for the CDP command"),
+      },
+    },
+    async ({ profile, tabId, method, commandParams }) => {
+      const res = await callProfileExtension(profile, "raw_cdp", { tabId, method, commandParams });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_request_human_takeover",
+    {
+      description: "Pause agent execution and display a prominent interactive takeover banner in the browser for manual 2FA, CAPTCHA, or payment confirmation. Resumes automatically when user clicks 'Resume Agent' or timeout expires.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+        reason: z.string().optional().describe("Brief message shown to the user explaining what they need to complete (e.g. 'Please complete 2FA on screen')"),
+        timeoutSeconds: z.number().optional().describe("Maximum seconds to pause before timing out (default 300)"),
+      },
+    },
+    async ({ profile, tabId, reason, timeoutSeconds }) => {
+      const res = await callProfileExtension(profile, "request_human_takeover", { tabId, reason, timeoutSeconds });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_reload_extension",
+    {
+      description: "Hot reload the Agent Bridge Chrome extension service worker in the browser profile.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+      },
+    },
+    async ({ profile }) => {
+      const res = await callProfileExtension(profile, "reload_extension");
+      return jsonResult(res);
+    }
+  );
+}
+

package/tools/dom-tools.js

@@ -0,0 +1,295 @@
+// Agent Bridge MCP - DOM Snapshots & Element Interaction Tools (ES Module)
+import { z } from "zod";
+import { jsonResult } from "../core/state.js";
+import { callProfileExtension } from "../core/bridge.js";
+
+export function registerDomTools(server) {
+  server.registerTool(
+    "browser_get_interactive_snapshot",
+    {
+      description: "Maps all interactive elements on the page (buttons, links, inputs, selects, tabs, clickable elements, shadow roots), assigning deterministic 'ref_1', 'ref_2' IDs with coordinates and bounding boxes. Supports viewportOnly filtering for token efficiency.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+        viewportOnly: z.boolean().optional().describe("If true, only returns elements visible within the current viewport (default false)"),
+      },
+    },
+    async ({ profile, tabId, viewportOnly }) => {
+      const res = await callProfileExtension(profile, "get_interactive_snapshot", { tabId, viewportOnly });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_take_snapshot",
+    {
+      description: "Accessibility (a11y) tree text snapshot of the page matching standard Chrome DevTools MCP.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+        verbose: z.boolean().optional().describe("Include deeper accessibility details"),
+      },
+    },
+    async ({ profile, tabId, verbose }) => {
+      const res = await callProfileExtension(profile, "take_snapshot", { tabId, verbose });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_get_css_styles",
+    {
+      description: "Inspect computed CSS styling for any element ref or CSS selector (display, visibility, opacity, colors, fonts, geometry, z-index).",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+        target: z.string().describe("Target element data-agent-ref (e.g. 'ref_1') or CSS selector"),
+        properties: z.array(z.string()).optional().describe("Array of specific CSS property names (e.g. ['color', 'font-size']). Omit for essential styling."),
+      },
+    },
+    async ({ profile, tabId, target, properties }) => {
+      const res = await callProfileExtension(profile, "get_css_styles", { tabId, target, properties });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_act_on_ref",
+    {
+      description: "Perform precision interaction on a data-agent-ref target or coordinates with visible virtual cursor and action HUD animations.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+        ref: z.string().optional().describe("The data-agent-ref ID (e.g. 'ref_1')"),
+        actionType: z.enum(["click", "type"]).optional().describe("Action to perform (default 'click')"),
+        text: z.string().optional().describe("Text to insert if actionType is 'type'"),
+        button: z.enum(["left", "right", "middle"]).optional().describe("Mouse button (default 'left')"),
+        clickCount: z.number().optional().describe("Number of clicks (default 1, 2 for double click)"),
+        clearFirst: z.boolean().optional().describe("Clear input field before typing (default false)"),
+        pressEnter: z.boolean().optional().describe("Press Enter after typing text (default false)"),
+        x: z.number().optional().describe("Direct X coordinate"),
+        y: z.number().optional().describe("Direct Y coordinate"),
+      },
+    },
+    async ({ profile, tabId, ref, actionType, text, button, clickCount, clearFirst, pressEnter, x, y }) => {
+      const res = await callProfileExtension(profile, "act_on_ref", {
+        tabId,
+        ref,
+        actionType,
+        text,
+        button,
+        clickCount,
+        clearFirst,
+        pressEnter,
+        x,
+        y,
+      });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_click",
+    {
+      description: "Click an element by ref or CSS selector, or click exact screen coordinates (matching chrome-devtools click).",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+        target: z.string().optional().describe("Target ref (e.g. 'ref_1') or CSS selector"),
+        x: z.number().optional().describe("Direct X coordinate"),
+        y: z.number().optional().describe("Direct Y coordinate"),
+        button: z.enum(["left", "right", "middle"]).optional().describe("Mouse button (default 'left')"),
+        clickCount: z.number().optional().describe("1 for single click, 2 for double click"),
+      },
+    },
+    async ({ profile, tabId, target, x, y, button, clickCount }) => {
+      const res = await callProfileExtension(profile, "act_on_ref", {
+        tabId,
+        ref: target,
+        actionType: "click",
+        x,
+        y,
+        button,
+        clickCount,
+      });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_hover",
+    {
+      description: "Hover over an element by ref or CSS selector, or move mouse to coordinates.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+        target: z.string().optional().describe("Target ref (e.g. 'ref_1') or CSS selector"),
+        x: z.number().optional().describe("Direct X coordinate"),
+        y: z.number().optional().describe("Direct Y coordinate"),
+      },
+    },
+    async ({ profile, tabId, target, x, y }) => {
+      const res = await callProfileExtension(profile, "hover", { tabId, target, x, y });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_drag",
+    {
+      description: "Drag and drop from one element/coordinate to another with visual laser trajectory.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+        fromTarget: z.string().optional().describe("Source element ref or selector"),
+        toTarget: z.string().optional().describe("Destination element ref or selector"),
+        fromX: z.number().optional().describe("Source X coordinate"),
+        fromY: z.number().optional().describe("Source Y coordinate"),
+        toX: z.number().optional().describe("Destination X coordinate"),
+        toY: z.number().optional().describe("Destination Y coordinate"),
+      },
+    },
+    async ({ profile, tabId, fromTarget, toTarget, fromX, fromY, toX, toY }) => {
+      const res = await callProfileExtension(profile, "drag", { tabId, fromTarget, toTarget, fromX, fromY, toX, toY });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_fill",
+    {
+      description: "Focus an input/textarea and fill its value (matching chrome-devtools fill).",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+        target: z.string().describe("Target ref (e.g. 'ref_1') or CSS selector"),
+        value: z.string().describe("Value to fill"),
+      },
+    },
+    async ({ profile, tabId, target, value }) => {
+      const res = await callProfileExtension(profile, "fill", { tabId, target, value });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_fill_form",
+    {
+      description: "Fill multiple form fields in one batch call (e.g. { '#username': 'alice', '#password': 'secret' }).",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+        fields: z.record(z.string()).describe("Key-value mapping of selector/ref to input string values"),
+      },
+    },
+    async ({ profile, tabId, fields }) => {
+      const res = await callProfileExtension(profile, "fill_form", { tabId, fields });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_press_key",
+    {
+      description: "Dispatch a physical keyboard key press (e.g. 'Enter', 'Tab', 'Escape', 'ArrowDown', 'Backspace', 'a', '1') with 3D mechanical keycap HUD animation.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+        key: z.string().describe("Key identifier (e.g. 'Enter', 'Tab', 'Escape', 'ArrowDown', 'Space')"),
+        code: z.string().optional().describe("Optional DOM code (e.g. 'KeyA', 'Enter')"),
+      },
+    },
+    async ({ profile, tabId, key, code }) => {
+      const res = await callProfileExtension(profile, "press_key", { tabId, key, code });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_type_text",
+    {
+      description: "Type raw text into the currently focused element or specified target.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+        text: z.string().describe("Text string to type"),
+        target: z.string().optional().describe("Optional ref or selector to click/focus before typing"),
+      },
+    },
+    async ({ profile, tabId, text, target }) => {
+      const res = await callProfileExtension(profile, "type_text", { tabId, text, target });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_upload_file",
+    {
+      description: "Set files on an HTML file input element (<input type='file'>) via DevTools DOM.setFileInputFiles.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+        target: z.string().describe("Target input[type='file'] ref or selector"),
+        filePaths: z.union([z.string(), z.array(z.string())]).describe("Absolute local file path(s) to attach"),
+      },
+    },
+    async ({ profile, tabId, target, filePaths }) => {
+      const res = await callProfileExtension(profile, "upload_file", { tabId, target, filePaths });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_handle_dialog",
+    {
+      description: "Accept or dismiss active JavaScript dialogs (alert, confirm, prompt, beforeunload).",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+        action: z.enum(["accept", "dismiss"]).describe("Whether to accept or dismiss the dialog"),
+        promptText: z.string().optional().describe("Text response if the dialog is a prompt"),
+      },
+    },
+    async ({ profile, tabId, action, promptText }) => {
+      const res = await callProfileExtension(profile, "handle_dialog", { tabId, action, promptText });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_select_option",
+    {
+      description: "Select an option from a dropdown (<select>) element by value, visible label text, or index. Handles shadow DOM & iframes.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+        target: z.string().describe("Target <select> ref (e.g. 'ref_1') or CSS selector"),
+        value: z.string().optional().describe("The option value attribute to select"),
+        label: z.string().optional().describe("The visible option text to select"),
+        index: z.number().optional().describe("The zero-based option index to select"),
+      },
+    },
+    async ({ profile, tabId, target, value, label, index }) => {
+      const res = await callProfileExtension(profile, "select_option", { tabId, target, value, label, index });
+      return jsonResult(res);
+    }
+  );
+
+  server.registerTool(
+    "browser_set_checked",
+    {
+      description: "Set the checked state of a checkbox or radio button element (true or false) with spring bloom visual animation.",
+      inputSchema: {
+        profile: z.string().optional().describe("Target browser profile"),
+        tabId: z.number().describe("Target tabId"),
+        target: z.string().describe("Target checkbox or radio ref (e.g. 'ref_1') or CSS selector"),
+        checked: z.boolean().describe("Whether the checkbox/radio should be checked (true) or unchecked (false)"),
+      },
+    },
+    async ({ profile, tabId, target, checked }) => {
+      const res = await callProfileExtension(profile, "set_checked", { tabId, target, checked });
+      return jsonResult(res);
+    }
+  );
+}
+