@rabbitai-lab/agent-browser-mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,1901 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import { createServer } from "http";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { randomUUID } from "crypto";
+
+// src/executor.ts
+import { spawn } from "child_process";
+
+// src/utils.ts
+function shellEscape(str) {
+  if (!str) return "''";
+  if (/^[a-zA-Z0-9./:@_\-+%*=~]+$/.test(str)) return str;
+  return "'" + str.replace(/'/g, "'\\''") + "'";
+}
+function getRequestBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      const raw = Buffer.concat(chunks).toString("utf-8");
+      if (!raw) {
+        resolve(void 0);
+        return;
+      }
+      try {
+        resolve(JSON.parse(raw));
+      } catch (e) {
+        reject(new Error(`Invalid JSON body: ${e.message}`));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function buildGlobalArgs(options) {
+  if (!options) return "";
+  const args = [];
+  if (options.session) args.push(`--session ${shellEscape(options.session)}`);
+  if (options.headed) args.push("--headed");
+  if (options.cdp) args.push(`--cdp ${shellEscape(options.cdp)}`);
+  if (options.profile) args.push(`--profile ${shellEscape(options.profile)}`);
+  if (options.proxy) args.push(`--proxy ${shellEscape(options.proxy)}`);
+  if (options.json) args.push("--json");
+  if (options.debug) args.push("--debug");
+  return args.join(" ");
+}
+function extractGlobalOptions(args) {
+  const globalKeys = /* @__PURE__ */ new Set(["session", "headed", "cdp", "profile", "proxy", "json", "debug"]);
+  const global = {};
+  const rest = {};
+  for (const [key, value] of Object.entries(args)) {
+    if (globalKeys.has(key)) {
+      global[key] = value;
+    } else {
+      rest[key] = value;
+    }
+  }
+  return { global, rest };
+}
+
+// src/executor.ts
+var DEFAULT_OPTIONS = {
+  cliPath: "agent-browser",
+  timeout: 12e4
+};
+var CliExecutor = class {
+  options;
+  activeProcesses = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+  async execute(command, globalOptions) {
+    const cliPath = this.options.cliPath;
+    const timeout = this.options.timeout;
+    const globalArgs = buildGlobalArgs(globalOptions);
+    const fullCommand = globalArgs ? `${command} ${globalArgs}` : command;
+    return new Promise((resolve) => {
+      const proc = spawn(cliPath, [fullCommand], {
+        shell: true,
+        env: { ...process.env }
+      });
+      this.activeProcesses.add(proc);
+      let stdout = "";
+      let stderr = "";
+      let settled = false;
+      const finish = (error) => {
+        if (settled) return;
+        settled = true;
+        this.activeProcesses.delete(proc);
+        resolve({ stdout, stderr, exitCode: proc.exitCode ?? -1, error });
+      };
+      proc.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      proc.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      proc.on("close", (code) => {
+        if (code === 0) {
+          finish();
+        } else {
+          finish(stderr || `Process exited with code ${code}`);
+        }
+      });
+      proc.on("error", (err) => {
+        finish(err.message);
+      });
+      setTimeout(() => {
+        if (!settled) {
+          proc.kill("SIGTERM");
+          finish(`Command timed out after ${timeout}ms`);
+        }
+      }, timeout);
+    });
+  }
+  async close() {
+    for (const proc of this.activeProcesses) {
+      proc.kill("SIGTERM");
+    }
+    this.activeProcesses.clear();
+  }
+};
+
+// src/tools/navigation.ts
+import { z as z2 } from "zod";
+
+// src/tools/schemas.ts
+import { z } from "zod";
+var GlobalOptionsSchema = {
+  session: z.string().optional().describe("Isolated browser session name (--session)"),
+  headed: z.boolean().optional().describe("Show browser window, not headless (--headed)"),
+  cdp: z.string().optional().describe("Connect via Chrome DevTools Protocol port or URL (--cdp)"),
+  profile: z.string().optional().describe("Chrome profile name or directory path (--profile)"),
+  proxy: z.string().optional().describe("Proxy server URL (--proxy)"),
+  json: z.boolean().optional().describe("JSON output (--json)"),
+  debug: z.boolean().optional().describe("Debug output (--debug)")
+};
+var SelectorSchema = z.string().describe("CSS selector, XPath, or @ref from snapshot (e.g., @e1)");
+var DirectionSchema = z.enum(["up", "down", "left", "right"]);
+
+// src/tools/navigation.ts
+function buildOpenCommand(params) {
+  const parts = [`open ${shellEscape(params.url)}`];
+  if (params.headers) parts.push(`--headers ${shellEscape(params.headers)}`);
+  return parts.join(" ");
+}
+function buildConnectCommand(params) {
+  return `connect ${shellEscape(params.target)}`;
+}
+function buildCloseCommand(params) {
+  const parts = ["close"];
+  if (params.all) parts.push("--all");
+  return parts.join(" ");
+}
+function buildBackCommand() {
+  return "back";
+}
+function buildForwardCommand() {
+  return "forward";
+}
+function buildReloadCommand() {
+  return "reload";
+}
+function registerNavigationTools(server, executor) {
+  server.tool(
+    "open",
+    "Navigate to a URL",
+    {
+      url: z2.string().describe("URL to navigate to"),
+      headers: z2.string().optional().describe("HTTP headers as JSON string"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const cmd = buildOpenCommand(rest);
+      const result = await executor.execute(cmd, global);
+      return {
+        content: [{ type: "text", text: result.stdout || "OK" }],
+        ...result.error ? { isError: true } : {}
+      };
+    }
+  );
+  server.tool(
+    "back",
+    "Go back to the previous page",
+    { ...GlobalOptionsSchema },
+    async (args) => {
+      const { global } = extractGlobalOptions(args);
+      const result = await executor.execute(buildBackCommand(), global);
+      return {
+        content: [{ type: "text", text: result.stdout || "OK" }],
+        ...result.error ? { isError: true } : {}
+      };
+    }
+  );
+  server.tool(
+    "forward",
+    "Go forward to the next page",
+    { ...GlobalOptionsSchema },
+    async (args) => {
+      const { global } = extractGlobalOptions(args);
+      const result = await executor.execute(buildForwardCommand(), global);
+      return {
+        content: [{ type: "text", text: result.stdout || "OK" }],
+        ...result.error ? { isError: true } : {}
+      };
+    }
+  );
+  server.tool(
+    "reload",
+    "Reload the current page",
+    { ...GlobalOptionsSchema },
+    async (args) => {
+      const { global } = extractGlobalOptions(args);
+      const result = await executor.execute(buildReloadCommand(), global);
+      return {
+        content: [{ type: "text", text: result.stdout || "OK" }],
+        ...result.error ? { isError: true } : {}
+      };
+    }
+  );
+  server.tool(
+    "close",
+    "Close the browser session",
+    {
+      all: z2.boolean().optional().describe("Close every browser session"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const cmd = buildCloseCommand(rest);
+      const result = await executor.execute(cmd, global);
+      return {
+        content: [{ type: "text", text: result.stdout || "OK" }],
+        ...result.error ? { isError: true } : {}
+      };
+    }
+  );
+  server.tool(
+    "connect",
+    "Connect to a browser via CDP (Chrome DevTools Protocol)",
+    {
+      target: z2.string().describe("CDP port number or URL to connect to"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const cmd = buildConnectCommand(rest);
+      const result = await executor.execute(cmd, global);
+      return {
+        content: [{ type: "text", text: result.stdout || "OK" }],
+        ...result.error ? { isError: true } : {}
+      };
+    }
+  );
+}
+
+// src/tools/interaction.ts
+import { z as z3 } from "zod";
+function buildClickCommand(params) {
+  const parts = [`click ${shellEscape(params.selector)}`];
+  if (params.newTab) parts.push("--new-tab");
+  return parts.join(" ");
+}
+function buildDblclickCommand(params) {
+  return `dblclick ${shellEscape(params.selector)}`;
+}
+function buildTypeCommand(params) {
+  return `type ${shellEscape(params.selector)} ${shellEscape(params.text)}`;
+}
+function buildFillCommand(params) {
+  return `fill ${shellEscape(params.selector)} ${shellEscape(params.text)}`;
+}
+function buildPressCommand(params) {
+  return `press ${shellEscape(params.key)}`;
+}
+function buildHoverCommand(params) {
+  return `hover ${shellEscape(params.selector)}`;
+}
+function buildFocusCommand(params) {
+  return `focus ${shellEscape(params.selector)}`;
+}
+function buildCheckCommand(params) {
+  return `check ${shellEscape(params.selector)}`;
+}
+function buildUncheckCommand(params) {
+  return `uncheck ${shellEscape(params.selector)}`;
+}
+function buildSelectCommand(params) {
+  const values = params.values.map((v) => shellEscape(v)).join(" ");
+  return `select ${shellEscape(params.selector)} ${values}`;
+}
+function buildDragCommand(params) {
+  return `drag ${shellEscape(params.source)} ${shellEscape(params.target)}`;
+}
+function buildUploadCommand(params) {
+  const files = params.files.map((f) => shellEscape(f)).join(" ");
+  return `upload ${shellEscape(params.selector)} ${files}`;
+}
+function buildDownloadCommand(params) {
+  return `download ${shellEscape(params.selector)} ${shellEscape(params.path)}`;
+}
+function buildScrollCommand(params) {
+  const dir = params.direction || "down";
+  const amount = params.amount || 300;
+  let cmd = `scroll ${dir} ${amount}`;
+  if (params.selector) cmd += ` -s ${shellEscape(params.selector)}`;
+  return cmd;
+}
+function buildScrollIntoViewCommand(params) {
+  return `scrollintoview ${shellEscape(params.selector)}`;
+}
+function buildWaitCommand(params) {
+  const target = params.target;
+  if (/^\d+$/.test(target)) return `wait ${target}`;
+  return `wait ${shellEscape(target)}`;
+}
+function registerInteractionTools(server, executor) {
+  server.tool(
+    "click",
+    "Click an element by selector or @ref",
+    {
+      selector: SelectorSchema,
+      newTab: z3.boolean().optional().describe("Open link in new tab"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildClickCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "dblclick",
+    "Double-click an element",
+    {
+      selector: SelectorSchema,
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildDblclickCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "type",
+    "Type text into an element (appends to existing content)",
+    {
+      selector: SelectorSchema,
+      text: z3.string().describe("Text to type"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildTypeCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "fill",
+    "Clear and fill an element with text",
+    {
+      selector: SelectorSchema,
+      text: z3.string().describe("Text to fill"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildFillCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "press",
+    "Press a keyboard key (e.g., Enter, Tab, Control+a)",
+    {
+      key: z3.string().describe("Key to press (e.g., Enter, Tab, Control+a)"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildPressCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "hover",
+    "Hover over an element",
+    {
+      selector: SelectorSchema,
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildHoverCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "focus",
+    "Focus an element",
+    {
+      selector: SelectorSchema,
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildFocusCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "check",
+    "Check a checkbox",
+    {
+      selector: SelectorSchema,
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildCheckCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "uncheck",
+    "Uncheck a checkbox",
+    {
+      selector: SelectorSchema,
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildUncheckCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "select",
+    "Select dropdown option(s)",
+    {
+      selector: SelectorSchema,
+      values: z3.array(z3.string()).describe("Option value(s) to select"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildSelectCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "drag",
+    "Drag and drop from source to target element",
+    {
+      source: z3.string().describe("Source element selector or @ref"),
+      target: z3.string().describe("Target element selector or @ref"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildDragCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "upload",
+    "Upload file(s) to an element",
+    {
+      selector: SelectorSchema,
+      files: z3.array(z3.string()).describe("File path(s) to upload"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildUploadCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "download",
+    "Download a file by clicking an element",
+    {
+      selector: SelectorSchema,
+      path: z3.string().describe("Download destination path"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildDownloadCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "scroll",
+    "Scroll the page or a scrollable container",
+    {
+      direction: z3.enum(["up", "down", "left", "right"]).optional().describe("Scroll direction (default: down)"),
+      amount: z3.number().optional().describe("Pixels to scroll (default: 300)"),
+      selector: z3.string().optional().describe("Scrollable container selector"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildScrollCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "scroll_into_view",
+    "Scroll an element into view",
+    {
+      selector: SelectorSchema,
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildScrollIntoViewCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "wait",
+    "Wait for an element, timeout, or condition",
+    {
+      target: z3.string().describe("CSS selector, @ref, or milliseconds to wait"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildWaitCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+}
+
+// src/tools/query.ts
+import { z as z4 } from "zod";
+function buildSnapshotCommand(params) {
+  const parts = ["snapshot"];
+  if (params.interactive) parts.push("-i");
+  if (params.compact) parts.push("-c");
+  if (params.depth) parts.push(`-d ${params.depth}`);
+  if (params.selector) parts.push(`-s ${shellEscape(params.selector)}`);
+  return parts.join(" ");
+}
+function buildGetCommand(params) {
+  const what = params.what;
+  const parts = [`get ${what}`];
+  if (params.selector) parts.push(shellEscape(params.selector));
+  if (what === "attr" && params.attribute) parts.push(shellEscape(params.attribute));
+  return parts.join(" ");
+}
+function buildIsCommand(params) {
+  return `is ${params.what} ${shellEscape(params.selector)}`;
+}
+function buildFindCommand(params) {
+  const parts = [`find ${params.locator} ${shellEscape(params.value)}`];
+  if (params.action) parts.push(params.action);
+  if (params.actionText) parts.push(shellEscape(params.actionText));
+  if (params.name) parts.push(`--name ${shellEscape(params.name)}`);
+  if (params.exact) parts.push("--exact");
+  return parts.join(" ");
+}
+function buildEvalCommand(params) {
+  return `eval ${shellEscape(params.script)}`;
+}
+function registerQueryTools(server, executor) {
+  server.tool(
+    "snapshot",
+    "Capture accessibility tree with element refs (for AI agents)",
+    {
+      interactive: z4.boolean().optional().describe("Only interactive elements (-i)"),
+      compact: z4.boolean().optional().describe("Remove empty structural elements (-c)"),
+      depth: z4.number().optional().describe("Limit tree depth (-d)"),
+      selector: z4.string().optional().describe("Scope to CSS selector (-s)"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildSnapshotCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "get",
+    "Get element information (text, html, value, attribute, title, URL, etc.)",
+    {
+      what: z4.enum(["text", "html", "value", "attr", "title", "url", "count", "box", "styles", "cdp-url"]).describe("What to get"),
+      selector: z4.string().optional().describe("Element selector or @ref (required for most properties)"),
+      attribute: z4.string().optional().describe("Attribute name (required when what=attr)"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildGetCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "is",
+    "Check element state (visible, enabled, checked)",
+    {
+      what: z4.enum(["visible", "enabled", "checked"]).describe("State to check"),
+      selector: SelectorSchema,
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildIsCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "find",
+    "Find elements by locator and perform an action",
+    {
+      locator: z4.enum(["role", "text", "label", "placeholder", "alt", "title", "testid", "first", "last", "nth"]).describe("Locator strategy"),
+      value: z4.string().describe("Locator value to search for"),
+      action: z4.enum(["click", "fill", "type", "hover", "focus", "check", "uncheck"]).optional().describe("Action to perform on found element"),
+      actionText: z4.string().optional().describe("Text for fill/type actions"),
+      name: z4.string().optional().describe("Name filter (for role locator)"),
+      exact: z4.boolean().optional().describe("Exact match"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildFindCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "eval",
+    "Run JavaScript in the browser page",
+    {
+      script: z4.string().describe("JavaScript expression to evaluate"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildEvalCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+}
+
+// src/tools/visual.ts
+import { z as z5 } from "zod";
+function buildScreenshotCommand(params) {
+  const parts = ["screenshot"];
+  if (params.full) parts.push("--full");
+  if (params.annotate) parts.push("--annotate");
+  if (params.selector) parts.push(shellEscape(params.selector));
+  if (params.path) parts.push(shellEscape(params.path));
+  if (params.format) parts.push(`--screenshot-format ${params.format}`);
+  if (params.quality !== void 0) parts.push(`--screenshot-quality ${params.quality}`);
+  return parts.join(" ");
+}
+function buildPdfCommand(params) {
+  return `pdf ${shellEscape(params.path)}`;
+}
+function buildDiffSnapshotCommand(params) {
+  return "diff snapshot";
+}
+function buildDiffScreenshotCommand(params) {
+  const parts = ["diff screenshot"];
+  if (params.baseline) parts.push(`--baseline ${shellEscape(params.baseline)}`);
+  return parts.join(" ");
+}
+function buildDiffUrlCommand(params) {
+  return `diff url ${shellEscape(params.url1)} ${shellEscape(params.url2)}`;
+}
+function buildHighlightCommand(params) {
+  return `highlight ${shellEscape(params.selector)}`;
+}
+function registerVisualTools(server, executor) {
+  server.tool(
+    "screenshot",
+    "Take a screenshot of the current page",
+    {
+      selector: z5.string().optional().describe("Element selector to screenshot"),
+      path: z5.string().optional().describe("Output file path"),
+      full: z5.boolean().optional().describe("Full page screenshot (--full)"),
+      annotate: z5.boolean().optional().describe("Annotated screenshot with numbered labels (--annotate)"),
+      format: z5.enum(["png", "jpeg"]).optional().describe("Screenshot format"),
+      quality: z5.number().optional().describe("JPEG quality 0-100"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildScreenshotCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "pdf",
+    "Save the current page as PDF",
+    {
+      path: z5.string().describe("Output PDF file path"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildPdfCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "diff_snapshot",
+    "Compare current accessibility snapshot vs last snapshot",
+    { ...GlobalOptionsSchema },
+    async (args) => {
+      const { global } = extractGlobalOptions(args);
+      const result = await executor.execute(buildDiffSnapshotCommand({}), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "diff_screenshot",
+    "Compare current screenshot vs baseline image",
+    {
+      baseline: z5.string().describe("Path to baseline image"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildDiffScreenshotCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "diff_url",
+    "Compare two URLs side by side",
+    {
+      url1: z5.string().describe("First URL"),
+      url2: z5.string().describe("Second URL"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildDiffUrlCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "highlight",
+    "Highlight an element on the page (for debugging)",
+    {
+      selector: SelectorSchema,
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildHighlightCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+}
+
+// src/tools/mouse.ts
+import { z as z6 } from "zod";
+function buildMouseMoveCommand(params) {
+  return `mouse move ${params.x} ${params.y}`;
+}
+function buildMouseDownCommand(params) {
+  const btn = params.button ? ` ${params.button}` : "";
+  return `mouse down${btn}`;
+}
+function buildMouseUpCommand(params) {
+  const btn = params.button ? ` ${params.button}` : "";
+  return `mouse up${btn}`;
+}
+function buildMouseWheelCommand(params) {
+  const dx = params.deltaX ? ` ${params.deltaX}` : "";
+  return `mouse wheel ${params.deltaY}${dx}`;
+}
+function registerMouseTools(server, executor) {
+  server.tool(
+    "mouse_move",
+    "Move mouse to coordinates",
+    {
+      x: z6.number().describe("X coordinate"),
+      y: z6.number().describe("Y coordinate"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildMouseMoveCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "mouse_down",
+    "Press a mouse button",
+    {
+      button: z6.enum(["left", "right", "middle"]).optional().describe("Mouse button (default: left)"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildMouseDownCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "mouse_up",
+    "Release a mouse button",
+    {
+      button: z6.enum(["left", "right", "middle"]).optional().describe("Mouse button (default: left)"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildMouseUpCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "mouse_wheel",
+    "Scroll the mouse wheel",
+    {
+      deltaY: z6.number().describe("Vertical scroll amount"),
+      deltaX: z6.number().optional().describe("Horizontal scroll amount"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildMouseWheelCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+}
+
+// src/tools/keyboard.ts
+import { z as z7 } from "zod";
+function buildKeyboardTypeCommand(params) {
+  return `keyboard type ${shellEscape(params.text)}`;
+}
+function buildKeyboardInsertCommand(params) {
+  return `keyboard inserttext ${shellEscape(params.text)}`;
+}
+function buildKeydownCommand(params) {
+  return `keydown ${shellEscape(params.key)}`;
+}
+function buildKeyupCommand(params) {
+  return `keyup ${shellEscape(params.key)}`;
+}
+function registerKeyboardTools(server, executor) {
+  server.tool(
+    "keyboard_type",
+    "Type text with real keystrokes (no selector needed)",
+    {
+      text: z7.string().describe("Text to type"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildKeyboardTypeCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "keyboard_insert",
+    "Insert text without key events (no selector needed)",
+    {
+      text: z7.string().describe("Text to insert"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildKeyboardInsertCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "keydown",
+    "Press and hold a key (without releasing)",
+    {
+      key: z7.string().describe("Key to hold down (e.g., Shift, Control, Alt)"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildKeydownCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+  server.tool(
+    "keyup",
+    "Release a previously held key",
+    {
+      key: z7.string().describe("Key to release (e.g., Shift, Control, Alt)"),
+      ...GlobalOptionsSchema
+    },
+    async (args) => {
+      const { global, rest } = extractGlobalOptions(args);
+      const result = await executor.execute(buildKeyupCommand(rest), global);
+      return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+    }
+  );
+}
+
+// src/tools/browser-settings.ts
+import { z as z8 } from "zod";
+function buildSetViewportCommand(params) {
+  return `set viewport ${params.width} ${params.height}`;
+}
+function buildSetDeviceCommand(params) {
+  return `set device ${shellEscape(params.device)}`;
+}
+function buildSetGeolocationCommand(params) {
+  return `set geo ${params.latitude} ${params.longitude}`;
+}
+function buildSetOfflineCommand(params) {
+  const enabled = params.enabled !== false;
+  return `set offline ${enabled ? "on" : "off"}`;
+}
+function buildSetHeadersCommand(params) {
+  return `set headers ${shellEscape(params.headers)}`;
+}
+function buildSetCredentialsCommand(params) {
+  return `set credentials ${shellEscape(params.username)} ${shellEscape(params.password)}`;
+}
+function buildSetColorSchemeCommand(params) {
+  const parts = ["set media"];
+  if (params.scheme) parts.push(params.scheme);
+  return parts.join(" ");
+}
+function registerBrowserSettingsTools(server, executor) {
+  server.tool("set_viewport", "Set browser viewport size", {
+    width: z8.number().describe("Viewport width"),
+    height: z8.number().describe("Viewport height"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildSetViewportCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("set_device", "Emulate a device", {
+    device: z8.string().describe('Device name (e.g., "iPhone 15 Pro")'),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildSetDeviceCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("set_geolocation", "Set geolocation", {
+    latitude: z8.number().describe("Latitude"),
+    longitude: z8.number().describe("Longitude"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildSetGeolocationCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("set_offline", "Toggle offline mode", {
+    enabled: z8.boolean().optional().describe("Enable offline mode (default: true)"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildSetOfflineCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("set_headers", "Set HTTP headers", {
+    headers: z8.string().describe("Headers as JSON string"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildSetHeadersCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("set_credentials", "Set HTTP authentication credentials", {
+    username: z8.string().describe("Username"),
+    password: z8.string().describe("Password"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildSetCredentialsCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("set_color_scheme", "Set color scheme preference", {
+    scheme: z8.enum(["dark", "light"]).optional().describe("Color scheme"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildSetColorSchemeCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+}
+
+// src/tools/network.ts
+import { z as z9 } from "zod";
+function buildNetworkRouteCommand(params) {
+  const parts = [`network route ${shellEscape(params.url)}`];
+  if (params.abort) parts.push("--abort");
+  if (params.body) parts.push(`--body ${shellEscape(params.body)}`);
+  return parts.join(" ");
+}
+function buildNetworkUnrouteCommand(params) {
+  if (params.url) return `network unroute ${shellEscape(params.url)}`;
+  return "network unroute";
+}
+function buildNetworkRequestsCommand(params) {
+  const parts = ["network requests"];
+  if (params.clear) parts.push("--clear");
+  if (params.filter) parts.push(`--filter ${shellEscape(params.filter)}`);
+  return parts.join(" ");
+}
+function buildNetworkRequestDetailCommand(params) {
+  return `network request ${shellEscape(params.requestId)}`;
+}
+function buildNetworkHarCommand(params) {
+  const parts = [`network har ${params.action}`];
+  if (params.path) parts.push(shellEscape(params.path));
+  return parts.join(" ");
+}
+function registerNetworkTools(server, executor) {
+  server.tool("network_route", "Intercept network requests by URL pattern", {
+    url: z9.string().describe("URL pattern to intercept"),
+    abort: z9.boolean().optional().describe("Abort the request"),
+    body: z9.string().optional().describe("Response body as JSON (--body)"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildNetworkRouteCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("network_unroute", "Remove a network route", {
+    url: z9.string().optional().describe("URL pattern to remove (omit to remove all)"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildNetworkUnrouteCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("network_requests", "List network requests", {
+    clear: z9.boolean().optional().describe("Clear request log (--clear)"),
+    filter: z9.string().optional().describe("Filter pattern (--filter)"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildNetworkRequestsCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("network_request_detail", "Get full details of a network request", {
+    requestId: z9.string().describe("Request ID from network requests list"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildNetworkRequestDetailCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("network_har", "Start or stop HAR recording", {
+    action: z9.enum(["start", "stop"]).describe("Start or stop recording"),
+    path: z9.string().optional().describe("HAR file output path"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildNetworkHarCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+}
+
+// src/tools/storage.ts
+import { z as z10 } from "zod";
+function buildCookiesGetCommand() {
+  return "cookies get";
+}
+function buildCookiesSetCommand(params) {
+  const parts = [`cookies set ${shellEscape(params.name)} ${shellEscape(params.value)}`];
+  if (params.url) parts.push(`--url ${shellEscape(params.url)}`);
+  if (params.domain) parts.push(`--domain ${shellEscape(params.domain)}`);
+  if (params.path) parts.push(`--path ${shellEscape(params.path)}`);
+  if (params.httpOnly) parts.push("--httpOnly");
+  if (params.secure) parts.push("--secure");
+  if (params.sameSite) parts.push(`--sameSite ${params.sameSite}`);
+  if (params.expires !== void 0) parts.push(`--expires ${params.expires}`);
+  return parts.join(" ");
+}
+function buildCookiesClearCommand() {
+  return "cookies clear";
+}
+function buildStorageGetCommand(params) {
+  const parts = [`storage ${params.type} get`];
+  if (params.key) parts.push(shellEscape(params.key));
+  return parts.join(" ");
+}
+function buildStorageSetCommand(params) {
+  return `storage ${params.type} set ${shellEscape(params.key)} ${shellEscape(params.value)}`;
+}
+function buildStorageClearCommand(params) {
+  return `storage ${params.type} clear`;
+}
+function registerStorageTools(server, executor) {
+  server.tool("cookies_get", "Get all cookies", { ...GlobalOptionsSchema }, async (args) => {
+    const { global } = extractGlobalOptions(args);
+    const result = await executor.execute(buildCookiesGetCommand(), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("cookies_set", "Set a cookie", {
+    name: z10.string().describe("Cookie name"),
+    value: z10.string().describe("Cookie value"),
+    url: z10.string().optional().describe("Cookie URL"),
+    domain: z10.string().optional().describe("Cookie domain"),
+    path: z10.string().optional().describe("Cookie path"),
+    httpOnly: z10.boolean().optional().describe("HTTP only"),
+    secure: z10.boolean().optional().describe("Secure only"),
+    sameSite: z10.enum(["Strict", "Lax", "None"]).optional().describe("SameSite policy"),
+    expires: z10.number().optional().describe("Expiration timestamp"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildCookiesSetCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("cookies_clear", "Clear all cookies", { ...GlobalOptionsSchema }, async (args) => {
+    const { global } = extractGlobalOptions(args);
+    const result = await executor.execute(buildCookiesClearCommand(), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("storage_get", "Get web storage value(s)", {
+    type: z10.enum(["local", "session"]).describe("Storage type"),
+    key: z10.string().optional().describe("Key to get (omit to get all)"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildStorageGetCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("storage_set", "Set a web storage value", {
+    type: z10.enum(["local", "session"]).describe("Storage type"),
+    key: z10.string().describe("Storage key"),
+    value: z10.string().describe("Storage value"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildStorageSetCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("storage_clear", "Clear web storage", {
+    type: z10.enum(["local", "session"]).describe("Storage type"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildStorageClearCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+}
+
+// src/tools/tabs.ts
+import { z as z11 } from "zod";
+function buildTabListCommand() {
+  return "tab list";
+}
+function buildTabNewCommand(params) {
+  const parts = ["tab new"];
+  if (params.url) parts.push(shellEscape(params.url));
+  if (params.label) parts.push(`--label ${shellEscape(params.label)}`);
+  return parts.join(" ");
+}
+function buildTabCloseCommand(params) {
+  if (params.ref) return `tab close ${shellEscape(params.ref)}`;
+  return "tab close";
+}
+function buildTabSwitchCommand(params) {
+  return `tab ${shellEscape(params.ref)}`;
+}
+function buildFrameCommand(params) {
+  return `frame ${shellEscape(params.target)}`;
+}
+function buildWindowNewCommand() {
+  return "window new";
+}
+function registerTabTools(server, executor) {
+  server.tool("tab_list", "List all browser tabs", { ...GlobalOptionsSchema }, async (args) => {
+    const { global } = extractGlobalOptions(args);
+    const result = await executor.execute(buildTabListCommand(), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("tab_new", "Open a new tab", {
+    url: z11.string().optional().describe("URL to open in new tab"),
+    label: z11.string().optional().describe("Tab label (--label)"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildTabNewCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("tab_close", "Close a tab", {
+    ref: z11.string().optional().describe("Tab reference or label (omit to close current)"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildTabCloseCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("tab_switch", "Switch to a tab by reference or label", {
+    ref: z11.string().describe("Tab reference (e.g., t1) or label"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildTabSwitchCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("frame", "Switch frame context (iframe or main)", {
+    target: z11.string().describe('CSS selector, @ref for iframe, or "main" to return to top-level frame'),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildFrameCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("window_new", "Open a new browser window", { ...GlobalOptionsSchema }, async (args) => {
+    const { global } = extractGlobalOptions(args);
+    const result = await executor.execute(buildWindowNewCommand(), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+}
+
+// src/tools/debug.ts
+import { z as z12 } from "zod";
+function buildConsoleCommand(params) {
+  const parts = ["console"];
+  if (params.clear) parts.push("--clear");
+  return parts.join(" ");
+}
+function buildErrorsCommand(params) {
+  const parts = ["errors"];
+  if (params.clear) parts.push("--clear");
+  return parts.join(" ");
+}
+function buildTraceCommand(params) {
+  const parts = [`trace ${params.action}`];
+  if (params.path) parts.push(shellEscape(params.path));
+  return parts.join(" ");
+}
+function buildProfilerCommand(params) {
+  const parts = [`profiler ${params.action}`];
+  if (params.path) parts.push(shellEscape(params.path));
+  return parts.join(" ");
+}
+function buildRecordCommand(params) {
+  if (params.action === "stop") return "record stop";
+  if (params.action === "restart") return `record restart ${shellEscape(params.path)}`;
+  const parts = [`record start ${shellEscape(params.path)}`];
+  if (params.url) parts.push(shellEscape(params.url));
+  return parts.join(" ");
+}
+function buildClipboardCommand(params) {
+  const parts = [`clipboard ${params.operation}`];
+  if (params.text) parts.push(shellEscape(params.text));
+  return parts.join(" ");
+}
+function buildInspectCommand() {
+  return "inspect";
+}
+function registerDebugTools(server, executor) {
+  server.tool("console", "View console logs", {
+    clear: z12.boolean().optional().describe("Clear console log"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildConsoleCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("errors", "View page errors", {
+    clear: z12.boolean().optional().describe("Clear errors"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildErrorsCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("trace", "Record Chrome DevTools trace", {
+    action: z12.enum(["start", "stop"]).describe("Start or stop tracing"),
+    path: z12.string().optional().describe("Output trace file path"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildTraceCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("profiler", "Record Chrome DevTools profile", {
+    action: z12.enum(["start", "stop"]).describe("Start or stop profiling"),
+    path: z12.string().optional().describe("Output profile file path"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildProfilerCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("record", "Record browser session as video (WebM)", {
+    action: z12.enum(["start", "stop", "restart"]).describe("Start, stop, or restart recording"),
+    path: z12.string().optional().describe("Output video file path (required for start)"),
+    url: z12.string().optional().describe("URL to open when recording starts"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildRecordCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("clipboard", "Read or write the clipboard", {
+    operation: z12.enum(["read", "write", "copy", "paste"]).describe("Clipboard operation"),
+    text: z12.string().optional().describe("Text for write operation"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildClipboardCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("inspect", "Open Chrome DevTools for the active page", { ...GlobalOptionsSchema }, async (args) => {
+    const { global } = extractGlobalOptions(args);
+    const result = await executor.execute(buildInspectCommand(), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+}
+
+// src/tools/auth.ts
+import { z as z13 } from "zod";
+function buildAuthSaveCommand(params) {
+  const parts = [`auth save ${shellEscape(params.name)}`];
+  if (params.url) parts.push(`--url ${shellEscape(params.url)}`);
+  if (params.username) parts.push(`--username ${shellEscape(params.username)}`);
+  if (params.password) parts.push(`--password ${shellEscape(params.password)}`);
+  return parts.join(" ");
+}
+function buildAuthLoginCommand(params) {
+  return `auth login ${shellEscape(params.name)}`;
+}
+function buildAuthListCommand() {
+  return "auth list";
+}
+function buildAuthShowCommand(params) {
+  return `auth show ${shellEscape(params.name)}`;
+}
+function buildAuthDeleteCommand(params) {
+  return `auth delete ${shellEscape(params.name)}`;
+}
+function registerAuthTools(server, executor) {
+  server.tool("auth_save", "Save an authentication profile", {
+    name: z13.string().describe("Profile name"),
+    url: z13.string().optional().describe("Login page URL (--url)"),
+    username: z13.string().optional().describe("Username (--username)"),
+    password: z13.string().optional().describe("Password (--password)"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildAuthSaveCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("auth_login", "Login using a saved auth profile", {
+    name: z13.string().describe("Profile name"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildAuthLoginCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("auth_list", "List saved auth profiles", { ...GlobalOptionsSchema }, async (args) => {
+    const { global } = extractGlobalOptions(args);
+    const result = await executor.execute(buildAuthListCommand(), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("auth_show", "Show auth profile metadata", {
+    name: z13.string().describe("Profile name"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildAuthShowCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("auth_delete", "Delete a saved auth profile", {
+    name: z13.string().describe("Profile name"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildAuthDeleteCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+}
+
+// src/tools/batch.ts
+import { z as z14 } from "zod";
+function buildBatchCommand(params) {
+  const commands = params.commands.map((c) => `"${c}"`).join(" ");
+  const parts = [`batch ${commands}`];
+  if (params.bail) parts.push("--bail");
+  return parts.join(" ");
+}
+function registerBatchTools(server, executor) {
+  server.tool("batch", "Execute multiple browser commands sequentially", {
+    commands: z14.array(z14.string()).describe("Array of agent-browser commands to execute"),
+    bail: z14.boolean().optional().describe("Stop on first error (--bail)"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildBatchCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+}
+
+// src/tools/sessions.ts
+import { z as z15 } from "zod";
+function buildSessionListCommand() {
+  return "session list";
+}
+function buildStreamEnableCommand(params) {
+  const parts = ["stream enable"];
+  if (params.port) parts.push(`--port ${params.port}`);
+  return parts.join(" ");
+}
+function buildStreamDisableCommand() {
+  return "stream disable";
+}
+function buildStreamStatusCommand() {
+  return "stream status";
+}
+function registerSessionTools(server, executor) {
+  server.tool("session_list", "List active browser sessions", { ...GlobalOptionsSchema }, async (args) => {
+    const { global } = extractGlobalOptions(args);
+    const result = await executor.execute(buildSessionListCommand(), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("stream_enable", "Start runtime WebSocket streaming", {
+    port: z15.number().optional().describe("WebSocket streaming port (--port)"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildStreamEnableCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("stream_disable", "Stop runtime WebSocket streaming", { ...GlobalOptionsSchema }, async (args) => {
+    const { global } = extractGlobalOptions(args);
+    const result = await executor.execute(buildStreamDisableCommand(), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("stream_status", "Show streaming status and active port", { ...GlobalOptionsSchema }, async (args) => {
+    const { global } = extractGlobalOptions(args);
+    const result = await executor.execute(buildStreamStatusCommand(), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+}
+
+// src/tools/dialog.ts
+import { z as z16 } from "zod";
+function buildDialogAcceptCommand(params) {
+  if (params.text) return `dialog accept ${shellEscape(params.text)}`;
+  return "dialog accept";
+}
+function buildDialogDismissCommand() {
+  return "dialog dismiss";
+}
+function buildDialogStatusCommand() {
+  return "dialog status";
+}
+function registerDialogTools(server, executor) {
+  server.tool("dialog_accept", "Accept a dialog (alert/confirm/prompt)", {
+    text: z16.string().optional().describe("Response text for prompt dialogs"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildDialogAcceptCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("dialog_dismiss", "Dismiss a dialog", { ...GlobalOptionsSchema }, async (args) => {
+    const { global } = extractGlobalOptions(args);
+    const result = await executor.execute(buildDialogDismissCommand(), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("dialog_status", "Check if a dialog is currently open", { ...GlobalOptionsSchema }, async (args) => {
+    const { global } = extractGlobalOptions(args);
+    const result = await executor.execute(buildDialogStatusCommand(), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+}
+
+// src/tools/confirmation.ts
+import { z as z17 } from "zod";
+function buildConfirmCommand(params) {
+  return `confirm ${shellEscape(params.id)}`;
+}
+function buildDenyCommand(params) {
+  return `deny ${shellEscape(params.id)}`;
+}
+function registerConfirmationTools(server, executor) {
+  server.tool("confirm", "Approve a pending confirmation action", {
+    id: z17.string().describe("Confirmation ID to approve"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildConfirmCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("deny", "Deny a pending confirmation action", {
+    id: z17.string().describe("Confirmation ID to deny"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildDenyCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+}
+
+// src/tools/state.ts
+import { z as z18 } from "zod";
+function buildStateSaveCommand(params) {
+  return `state save ${shellEscape(params.path)}`;
+}
+function buildStateLoadCommand(params) {
+  return `state load ${shellEscape(params.path)}`;
+}
+function buildStateListCommand() {
+  return "state list";
+}
+function buildStateShowCommand(params) {
+  return `state show ${shellEscape(params.file)}`;
+}
+function buildStateRenameCommand(params) {
+  return `state rename ${shellEscape(params.oldName)} ${shellEscape(params.newName)}`;
+}
+function buildStateClearCommand(params) {
+  if (params.all) return "state clear --all";
+  if (params.name) return `state clear ${shellEscape(params.name)}`;
+  return "state clear";
+}
+function buildStateCleanCommand(params) {
+  const parts = ["state clean"];
+  if (params.olderThan) parts.push(`--older-than ${params.olderThan}`);
+  return parts.join(" ");
+}
+function registerStateTools(server, executor) {
+  server.tool("state_save", "Save browser auth state (cookies + storage) to a file", {
+    path: z18.string().describe("Output file path for saved state"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildStateSaveCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("state_load", "Load browser auth state from a file", {
+    path: z18.string().describe("State file path to load"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildStateLoadCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("state_list", "List saved state files", { ...GlobalOptionsSchema }, async (args) => {
+    const { global } = extractGlobalOptions(args);
+    const result = await executor.execute(buildStateListCommand(), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("state_show", "Show state file summary", {
+    file: z18.string().describe("State file to inspect"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildStateShowCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("state_rename", "Rename a state file", {
+    oldName: z18.string().describe("Current state file name"),
+    newName: z18.string().describe("New state file name"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildStateRenameCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("state_clear", "Clear saved states", {
+    name: z18.string().optional().describe("Session name to clear (omit for current session)"),
+    all: z18.boolean().optional().describe("Clear all saved states (--all)"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildStateClearCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("state_clean", "Delete old state files", {
+    olderThan: z18.number().optional().describe("Delete states older than N days (--older-than)"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildStateCleanCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+}
+
+// src/tools/dashboard.ts
+import { z as z19 } from "zod";
+function buildDashboardStartCommand(params) {
+  const parts = ["dashboard start"];
+  if (params.port) parts.push(`--port ${params.port}`);
+  return parts.join(" ");
+}
+function buildDashboardStopCommand() {
+  return "dashboard stop";
+}
+function registerDashboardTools(server, executor) {
+  server.tool("dashboard_start", "Start the observability dashboard server", {
+    port: z19.number().optional().describe("Dashboard port (default: 4848) (--port)"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildDashboardStartCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("dashboard_stop", "Stop the dashboard server", { ...GlobalOptionsSchema }, async (args) => {
+    const { global } = extractGlobalOptions(args);
+    const result = await executor.execute(buildDashboardStopCommand(), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+}
+
+// src/tools/react.ts
+import { z as z20 } from "zod";
+function buildReactTreeCommand() {
+  return "react tree";
+}
+function buildReactInspectCommand(params) {
+  return `react inspect ${shellEscape(params.fiberId)}`;
+}
+function buildReactRendersCommand(params) {
+  return `react renders ${params.action}`;
+}
+function buildReactSuspenseCommand(params) {
+  const parts = ["react suspense"];
+  if (params.onlyDynamic) parts.push("--only-dynamic");
+  return parts.join(" ");
+}
+function registerReactTools(server, executor) {
+  server.tool("react_tree", "Show full React component tree (requires --enable react-devtools)", { ...GlobalOptionsSchema }, async (args) => {
+    const { global } = extractGlobalOptions(args);
+    const result = await executor.execute(buildReactTreeCommand(), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("react_inspect", "Inspect a single React component by fiber ID", {
+    fiberId: z20.string().describe("React fiber ID to inspect"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildReactInspectCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("react_renders", "Start or stop React fiber render recording", {
+    action: z20.enum(["start", "stop"]).describe("Start or stop render recording"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildReactRendersCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("react_suspense", "List React Suspense boundaries", {
+    onlyDynamic: z20.boolean().optional().describe("Hide static boundaries (--only-dynamic)"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildReactSuspenseCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+}
+
+// src/tools/misc.ts
+import { z as z21 } from "zod";
+function buildDoctorCommand(params) {
+  const parts = ["doctor"];
+  if (params.fix) parts.push("--fix");
+  return parts.join(" ");
+}
+function buildChatCommand(params) {
+  const parts = ["chat"];
+  if (params.message) parts.push(shellEscape(params.message));
+  if (params.model) parts.push(`--model ${shellEscape(params.model)}`);
+  return parts.join(" ");
+}
+function buildPushstateCommand(params) {
+  return `pushstate ${shellEscape(params.url)}`;
+}
+function buildProfilesCommand() {
+  return "profiles";
+}
+function buildSessionCommand() {
+  return "session";
+}
+function buildVitalsCommand(params) {
+  const parts = ["vitals"];
+  if (params.url) parts.push(shellEscape(params.url));
+  return parts.join(" ");
+}
+function buildAddinitscriptCommand(params) {
+  return `addinitscript ${shellEscape(params.script)}`;
+}
+function buildRemoveinitscriptCommand(params) {
+  return `removeinitscript ${shellEscape(params.identifier)}`;
+}
+function registerMiscTools(server, executor) {
+  server.tool("doctor", "Diagnose agent-browser installation and configuration", {
+    fix: z21.boolean().optional().describe("Auto-fix issues (--fix)"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildDoctorCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("chat", "Send a natural language instruction to the AI agent", {
+    message: z21.string().describe("Natural language instruction"),
+    model: z21.string().optional().describe("AI model name (--model)"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildChatCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("pushstate", "SPA client-side navigation via history.pushState", {
+    url: z21.string().describe("URL to push to browser history"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildPushstateCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("profiles", "List available Chrome profiles", { ...GlobalOptionsSchema }, async (args) => {
+    const { global } = extractGlobalOptions(args);
+    const result = await executor.execute(buildProfilesCommand(), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("session", "Show current session name", { ...GlobalOptionsSchema }, async (args) => {
+    const { global } = extractGlobalOptions(args);
+    const result = await executor.execute(buildSessionCommand(), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("vitals", "Measure Web Vitals (LCP/CLS/TTFB/FCP/INP)", {
+    url: z21.string().optional().describe("URL to measure (optional, uses current page)"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildVitalsCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("addinitscript", "Register an init script at runtime", {
+    script: z21.string().describe("JavaScript code for the init script"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildAddinitscriptCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+  server.tool("removeinitscript", "Remove a previously registered init script", {
+    identifier: z21.string().describe("Init script identifier to remove"),
+    ...GlobalOptionsSchema
+  }, async (args) => {
+    const { global, rest } = extractGlobalOptions(args);
+    const result = await executor.execute(buildRemoveinitscriptCommand(rest), global);
+    return { content: [{ type: "text", text: result.stdout || "OK" }], ...result.error ? { isError: true } : {} };
+  });
+}
+
+// src/tools/index.ts
+function registerAllTools(server, executor) {
+  registerNavigationTools(server, executor);
+  registerInteractionTools(server, executor);
+  registerQueryTools(server, executor);
+  registerVisualTools(server, executor);
+  registerMouseTools(server, executor);
+  registerKeyboardTools(server, executor);
+  registerBrowserSettingsTools(server, executor);
+  registerNetworkTools(server, executor);
+  registerStorageTools(server, executor);
+  registerTabTools(server, executor);
+  registerDebugTools(server, executor);
+  registerAuthTools(server, executor);
+  registerBatchTools(server, executor);
+  registerSessionTools(server, executor);
+  registerDialogTools(server, executor);
+  registerConfirmationTools(server, executor);
+  registerStateTools(server, executor);
+  registerDashboardTools(server, executor);
+  registerReactTools(server, executor);
+  registerMiscTools(server, executor);
+}
+
+// src/server.ts
+function createMcpServerWithTools(executor) {
+  const server = new McpServer(
+    { name: "agent-browser", version: "0.1.0" },
+    { capabilities: { tools: {} } }
+  );
+  registerAllTools(server, executor);
+  return server;
+}
+async function startServer(port, executor) {
+  const cliExecutor = executor ?? new CliExecutor();
+  const sessions = /* @__PURE__ */ new Map();
+  const httpServer = createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", `http://localhost:${port}`);
+    if (url.pathname !== "/mcp") {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Not found. Use POST /mcp for MCP requests." }));
+      return;
+    }
+    try {
+      const sessionId = req.headers["mcp-session-id"];
+      if (sessionId && sessions.has(sessionId)) {
+        const session = sessions.get(sessionId);
+        if (req.method === "POST") {
+          const body = await getRequestBody(req);
+          await session.transport.handleRequest(req, res, body);
+        } else {
+          await session.transport.handleRequest(req, res);
+        }
+      } else if (req.method === "POST") {
+        let newSessionId;
+        const transport = new StreamableHTTPServerTransport({
+          sessionIdGenerator: () => {
+            const id = randomUUID();
+            newSessionId = id;
+            return id;
+          }
+        });
+        const server = createMcpServerWithTools(cliExecutor);
+        await server.connect(transport);
+        const body = await getRequestBody(req);
+        await transport.handleRequest(req, res, body);
+        if (newSessionId) {
+          sessions.set(newSessionId, { transport, server });
+        }
+        transport.onclose = () => {
+          if (newSessionId) {
+            sessions.delete(newSessionId);
+          }
+        };
+      } else if (req.method === "GET") {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Valid session ID required for GET requests" }));
+      } else if (req.method === "DELETE") {
+        res.writeHead(200);
+        res.end();
+      }
+    } catch (error) {
+      const errMsg = error instanceof Error ? `${error.message}
+${error.stack}` : String(error);
+      console.error("[MCP] Request handling error:", errMsg);
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "text/plain" });
+        res.end(errMsg);
+      }
+    }
+  });
+  const close = async () => {
+    await cliExecutor.close();
+    for (const [, session] of sessions) {
+      await session.transport.close();
+    }
+    sessions.clear();
+    httpServer.close();
+  };
+  return new Promise((resolve) => {
+    httpServer.listen(port, () => {
+      resolve({ httpServer, executor: cliExecutor, close });
+    });
+  });
+}
+
+// src/index.ts
+var DEFAULT_PORT = 12347;
+function parsePort() {
+  const args = process.argv.slice(2);
+  const portIndex = args.indexOf("--port");
+  if (portIndex !== -1 && args[portIndex + 1]) {
+    const port = parseInt(args[portIndex + 1], 10);
+    if (!isNaN(port) && port > 0 && port < 65536) return port;
+    console.error(`Invalid port: ${args[portIndex + 1]}`);
+    process.exit(1);
+  }
+  const envPort = process.env.PORT;
+  if (envPort) {
+    const port = parseInt(envPort, 10);
+    if (!isNaN(port) && port > 0 && port < 65536) return port;
+  }
+  return DEFAULT_PORT;
+}
+async function main() {
+  const port = parsePort();
+  const instance = await startServer(port);
+  console.log(`Agent Browser MCP server running on http://localhost:${port}/mcp`);
+  const shutdown = async () => {
+    console.log("\nShutting down...");
+    await instance.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+main().catch((err) => {
+  console.error("Failed to start server:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map