browsirai 0.1.0

package/dist/server.js

@@ -0,0 +1,4172 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/version.ts
+import { createRequire } from "module";
+var require2, pkg, VERSION;
+var init_version = __esm({
+  "src/version.ts"() {
+    "use strict";
+    require2 = createRequire(import.meta.url);
+    pkg = require2("../package.json");
+    VERSION = pkg.version;
+  }
+});
+
+// src/upgrade.ts
+var upgrade_exports = {};
+__export(upgrade_exports, {
+  checkForUpgrade: () => checkForUpgrade,
+  getInstallMethod: () => getInstallMethod,
+  getInstallPath: () => getInstallPath,
+  getUpgradeStatus: () => getUpgradeStatus
+});
+import { spawn as spawn2, execSync as execSync2 } from "child_process";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3, dirname } from "path";
+import { fileURLToPath } from "url";
+function getInstallMethod() {
+  try {
+    const scriptPath = fileURLToPath(import.meta.url);
+    const parentDir = dirname(dirname(scriptPath));
+    if (existsSync3(join3(parentDir, ".git")) || existsSync3(join3(parentDir, "tsconfig.json"))) {
+      return "dev";
+    }
+    if (scriptPath.includes("_npx") || scriptPath.includes(".npm")) {
+      return "npx";
+    }
+    try {
+      const globalPrefix = execSync2("npm prefix -g", { stdio: "pipe" }).toString().trim();
+      if (scriptPath.startsWith(globalPrefix)) {
+        return "global";
+      }
+    } catch {
+    }
+    return "npx";
+  } catch {
+    return "npx";
+  }
+}
+function getInstallPath() {
+  try {
+    return dirname(dirname(fileURLToPath(import.meta.url)));
+  } catch {
+    return "unknown";
+  }
+}
+function isNewer(current, latest) {
+  const a = current.split(".").map(Number);
+  const b = latest.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((b[i] ?? 0) > (a[i] ?? 0)) return true;
+    if ((b[i] ?? 0) < (a[i] ?? 0)) return false;
+  }
+  return false;
+}
+function getUpgradeStatus() {
+  try {
+    if (!existsSync3(UPGRADE_FILE)) return null;
+    return JSON.parse(readFileSync3(UPGRADE_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeUpgradeStatus(status) {
+  try {
+    mkdirSync3(BROWSIR_DIR, { recursive: true });
+    writeFileSync2(UPGRADE_FILE, JSON.stringify(status, null, 2));
+  } catch {
+  }
+}
+async function checkForUpgrade() {
+  try {
+    const method = getInstallMethod();
+    if (method === "dev") return null;
+    const cached = getUpgradeStatus();
+    if (cached) {
+      const elapsed = Date.now() - new Date(cached.checkedAt).getTime();
+      if (elapsed < CHECK_INTERVAL_MS) return cached;
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5e3);
+    const res = await fetch("https://registry.npmjs.org/browsirai/latest", {
+      signal: controller.signal,
+      headers: { Accept: "application/json" }
+    });
+    clearTimeout(timeout);
+    if (!res.ok) return null;
+    const data = await res.json();
+    const latest = data.version;
+    if (!latest) return null;
+    const status = {
+      current: VERSION,
+      latest,
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      installMethod: method
+    };
+    writeUpgradeStatus(status);
+    if (isNewer(VERSION, latest)) {
+      process.stderr.write(
+        `browsirai: v${latest} available (current: v${VERSION}). Upgrading in background...
+`
+      );
+      if (method === "npx") {
+        spawn2("npm", ["cache", "clean", "--force"], {
+          stdio: "ignore",
+          detached: true
+        }).unref();
+      } else if (method === "global") {
+        spawn2("npm", ["install", "-g", `browsirai@${latest}`], {
+          stdio: "ignore",
+          detached: true
+        }).unref();
+      }
+    }
+    return status;
+  } catch {
+    return null;
+  }
+}
+var BROWSIR_DIR, UPGRADE_FILE, CHECK_INTERVAL_MS;
+var init_upgrade = __esm({
+  "src/upgrade.ts"() {
+    "use strict";
+    init_version();
+    BROWSIR_DIR = join3(homedir3(), ".browsirai");
+    UPGRADE_FILE = join3(BROWSIR_DIR, "upgrade.json");
+    CHECK_INTERVAL_MS = 60 * 60 * 1e3;
+  }
+});
+
+// src/server.ts
+init_version();
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/tools/index.ts
+import { z } from "zod";
+
+// src/cdp/connection.ts
+var TIMEOUT = 15e3;
+var DAEMON_CONNECT_RETRIES = 20;
+var DAEMON_CONNECT_DELAY = 300;
+var CDPConnection = class {
+  wsUrl;
+  ws = null;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  eventHandlers = /* @__PURE__ */ new Map();
+  closed = false;
+  reconnecting = false;
+  _connected = false;
+  // Bound listener references for cleanup
+  boundOnMessage = null;
+  boundOnClose = null;
+  boundOnError = null;
+  constructor(wsUrl) {
+    this.wsUrl = wsUrl;
+  }
+  // -----------------------------------------------------------------------
+  // Public API
+  // -----------------------------------------------------------------------
+  /** Whether the underlying WebSocket is currently open. */
+  get isConnected() {
+    return this._connected;
+  }
+  /**
+   * Open the WebSocket connection.
+   * Resolves on the `open` event; rejects on `error`.
+   */
+  async connect() {
+    let WS = globalThis.WebSocket;
+    if (!WS) {
+      try {
+        const wsModule = await import("ws");
+        WS = wsModule.default ?? wsModule.WebSocket ?? wsModule;
+      } catch {
+        throw new Error(
+          "No WebSocket implementation found. Install the `ws` package or use Node 22+."
+        );
+      }
+    }
+    const ws = new WS(this.wsUrl);
+    this.ws = ws;
+    await new Promise((resolve, reject) => {
+      const onOpen = () => {
+        ws.removeEventListener("open", onOpen);
+        ws.removeEventListener("error", onError);
+        resolve();
+      };
+      const onError = (ev) => {
+        ws.removeEventListener("open", onOpen);
+        ws.removeEventListener("error", onError);
+        const msg = ev?.message ?? "WebSocket error";
+        reject(new Error(msg));
+      };
+      ws.addEventListener("open", onOpen);
+      ws.addEventListener("error", onError);
+    });
+    this._connected = true;
+    this.attachListeners(ws);
+  }
+  /**
+   * Send a CDP command and await its result.
+   *
+   * @param method  CDP method (e.g. `"Runtime.evaluate"`)
+   * @param params  Optional method parameters
+   * @param options Optional timeout / sessionId overrides
+   */
+  send(method, params, options) {
+    if (this.closed || !this._connected || !this.ws) {
+      return Promise.reject(
+        new Error(`Connection closed \u2014 cannot send ${method}`)
+      );
+    }
+    const id = this.nextId++;
+    const timeout = options?.timeout ?? TIMEOUT;
+    const message = { id, method };
+    if (params !== void 0) {
+      message.params = params;
+    }
+    if (options?.sessionId !== void 0) {
+      message.sessionId = options.sessionId;
+    }
+    this.ws.send(JSON.stringify(message));
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`CDP command timeout: ${method} (${timeout}ms)`));
+      }, timeout);
+      this.pending.set(id, { resolve, reject, method, timer });
+    });
+  }
+  /**
+   * Register an event handler for a CDP event or lifecycle event.
+   *
+   * CDP events are dispatched as `handler(params, { method })`.
+   * Lifecycle events: `disconnected`, `browserCrashed`, `reconnected`,
+   * `reconnectionFailed`.
+   */
+  on(event, handler) {
+    let handlers = this.eventHandlers.get(event);
+    if (!handlers) {
+      handlers = /* @__PURE__ */ new Set();
+      this.eventHandlers.set(event, handlers);
+    }
+    handlers.add(handler);
+  }
+  /** Remove a previously registered event handler. */
+  off(event, handler) {
+    this.eventHandlers.get(event)?.delete(handler);
+  }
+  /**
+   * Close the connection. Suppresses reconnection.
+   * Safe to call multiple times.
+   */
+  close() {
+    this.closed = true;
+    this._connected = false;
+    this.rejectAllPending(new Error("Connection closed"));
+    if (this.ws) {
+      this.detachListeners(this.ws);
+      try {
+        this.ws.close();
+      } catch {
+      }
+      this.ws = null;
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Private
+  // -----------------------------------------------------------------------
+  /** Attach message / close / error listeners to the WebSocket. */
+  attachListeners(ws) {
+    this.boundOnMessage = (event) => {
+      const data = event?.data;
+      if (typeof data !== "string") return;
+      let msg;
+      try {
+        msg = JSON.parse(data);
+      } catch {
+        return;
+      }
+      if (msg.id !== void 0) {
+        const entry = this.pending.get(msg.id);
+        if (entry) {
+          this.pending.delete(msg.id);
+          clearTimeout(entry.timer);
+          if (msg.error) {
+            entry.reject(new Error(msg.error.message));
+          } else {
+            entry.resolve(msg.result);
+          }
+        }
+        return;
+      }
+      if (msg.method) {
+        this.emit(msg.method, msg.params ?? {}, { method: msg.method });
+      }
+    };
+    this.boundOnClose = (event) => {
+      const code = event?.code ?? 1006;
+      this._connected = false;
+      this.rejectAllPending(new Error("WebSocket disconnected \u2014 connection closed"));
+      if (code !== 1e3) {
+        this.emit("browserCrashed");
+      }
+      this.emit("disconnected");
+      if (!this.closed && code !== 1e3) {
+        this.attemptReconnection().catch(() => {
+        });
+      }
+    };
+    this.boundOnError = () => {
+    };
+    ws.addEventListener("message", this.boundOnMessage);
+    ws.addEventListener("close", this.boundOnClose);
+    ws.addEventListener("error", this.boundOnError);
+  }
+  /** Detach WebSocket listeners. */
+  detachListeners(ws) {
+    if (this.boundOnMessage) ws.removeEventListener("message", this.boundOnMessage);
+    if (this.boundOnClose) ws.removeEventListener("close", this.boundOnClose);
+    if (this.boundOnError) ws.removeEventListener("error", this.boundOnError);
+  }
+  /** Reject every pending command. */
+  rejectAllPending(error) {
+    for (const [id, entry] of this.pending) {
+      clearTimeout(entry.timer);
+      entry.reject(error);
+      this.pending.delete(id);
+    }
+  }
+  /** Dispatch an event to all registered handlers. */
+  emit(event, ...args) {
+    const handlers = this.eventHandlers.get(event);
+    if (!handlers) return;
+    for (const handler of handlers) {
+      try {
+        handler(...args);
+      } catch {
+      }
+    }
+  }
+  /** Attempt reconnection with retries after abnormal close. */
+  async attemptReconnection() {
+    if (this.reconnecting || this.closed) return;
+    this.reconnecting = true;
+    for (let attempt = 0; attempt < DAEMON_CONNECT_RETRIES; attempt++) {
+      if (this.closed) {
+        this.reconnecting = false;
+        return;
+      }
+      await this.delay(DAEMON_CONNECT_DELAY);
+      if (this.closed) {
+        this.reconnecting = false;
+        return;
+      }
+      try {
+        await this.connect();
+        this.reconnecting = false;
+        this.emit("reconnected");
+        return;
+      } catch {
+      }
+    }
+    this.reconnecting = false;
+    this.emit("reconnectionFailed");
+  }
+  /** Promise-based delay. */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/chrome-launcher.ts
+import { execSync, spawn } from "child_process";
+import { existsSync, readFileSync, mkdirSync, copyFileSync, readdirSync, statSync } from "fs";
+import http from "http";
+import { join } from "path";
+import { homedir, tmpdir } from "os";
+import { createConnection } from "net";
+var CHROME_PATHS = {
+  darwin: [
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+    "/Applications/Chromium.app/Contents/MacOS/Chromium",
+    "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+    "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"
+  ],
+  linux: [
+    "google-chrome",
+    "google-chrome-stable",
+    "chromium",
+    "chromium-browser",
+    "microsoft-edge",
+    "brave-browser"
+  ],
+  win32: [
+    "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+    "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+    "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe",
+    "C:\\Program Files\\BraveSoftware\\Brave-Browser\\Application\\brave.exe"
+  ]
+};
+function getDefaultChromeDataDir() {
+  const home = homedir();
+  switch (process.platform) {
+    case "darwin":
+      return join(home, "Library", "Application Support", "Google", "Chrome");
+    case "win32":
+      return join(home, "AppData", "Local", "Google", "Chrome", "User Data");
+    default:
+      return join(home, ".config", "google-chrome");
+  }
+}
+function findChrome() {
+  const platform = process.platform;
+  const candidates = CHROME_PATHS[platform] ?? [];
+  for (const candidate of candidates) {
+    if (platform === "darwin" || platform === "win32") {
+      if (existsSync(candidate)) return candidate;
+    } else {
+      try {
+        const result = execSync(`which ${candidate}`, { stdio: "pipe" });
+        const path = result.toString().trim();
+        if (path) return path;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function isCDPHealthy(port, host = "127.0.0.1") {
+  return new Promise((resolve) => {
+    const req = http.get(`http://${host}:${port}/json/version`, (res) => {
+      resolve(res.statusCode === 200);
+      res.resume();
+    });
+    req.setTimeout(3e3, () => {
+      req.destroy();
+      resolve(false);
+    });
+    req.on("error", () => resolve(false));
+  });
+}
+function readDevToolsActivePort(chromeDataDir) {
+  const dataDir = chromeDataDir ?? getDefaultChromeDataDir();
+  const portFile = join(dataDir, "DevToolsActivePort");
+  if (!existsSync(portFile)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(portFile, "utf-8");
+    const lines = content.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+    if (lines.length < 2) return null;
+    const port = parseInt(lines[0], 10);
+    const wsPath = lines[1];
+    if (isNaN(port) || !wsPath.startsWith("/")) return null;
+    return {
+      port,
+      wsPath,
+      wsEndpoint: `ws://127.0.0.1:${port}${wsPath}`
+    };
+  } catch {
+    return null;
+  }
+}
+function isChromeRunning() {
+  try {
+    if (process.platform === "win32") {
+      const r2 = execSync('tasklist /FI "IMAGENAME eq chrome.exe" /NH', { stdio: "pipe" }).toString();
+      return r2.includes("chrome.exe");
+    }
+    const r = execSync("pgrep -x 'Google Chrome' || pgrep -x chrome || pgrep -x chromium", { stdio: "pipe" }).toString().trim();
+    return r.length > 0;
+  } catch {
+    return false;
+  }
+}
+var SEPARATE_PORT = 9444;
+async function launchChromeWithDebugging(port = 9222, headless = false) {
+  const healthy = await isCDPHealthy(port);
+  if (healthy) {
+    const ws = await getWsEndpoint(port);
+    return { success: true, port, wsEndpoint: ws };
+  }
+  const sepHealthy = await isCDPHealthy(SEPARATE_PORT);
+  if (sepHealthy) {
+    const ws = await getWsEndpoint(SEPARATE_PORT);
+    return { success: true, port: SEPARATE_PORT, wsEndpoint: ws };
+  }
+  const chromePath = findChrome();
+  if (!chromePath) {
+    return { success: false, port, error: "Chrome not found. Install Chrome and try again." };
+  }
+  const usesSeparateInstance = isChromeRunning();
+  const targetPort = usesSeparateInstance ? SEPARATE_PORT : port;
+  const dataDir = usesSeparateInstance ? join(tmpdir(), "browsirai-normal") : void 0;
+  if (dataDir) {
+    mkdirSync(dataDir, { recursive: true });
+    syncCookiesToHeadless(dataDir);
+  }
+  const args = [
+    `--remote-debugging-port=${targetPort}`,
+    "--remote-allow-origins=*"
+  ];
+  if (dataDir) {
+    args.push(`--user-data-dir=${dataDir}`, "--no-first-run", "--no-default-browser-check", "--disable-extensions");
+  }
+  if (headless) {
+    args.push("--headless=new");
+  }
+  const child = spawn(chromePath, args, {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  for (let i = 0; i < 75; i++) {
+    await new Promise((r) => setTimeout(r, 200));
+    const ok = await isCDPHealthy(targetPort);
+    if (ok) {
+      const ws = await getWsEndpoint(targetPort);
+      return { success: true, port: targetPort, wsEndpoint: ws };
+    }
+  }
+  return {
+    success: false,
+    port: targetPort,
+    error: "Chrome launched but CDP port not reachable after 15s. Check if another Chrome instance is blocking the profile."
+  };
+}
+var HEADLESS_PORT = 9333;
+async function getWsEndpoint(port) {
+  return new Promise((resolve) => {
+    const req = http.get(`http://127.0.0.1:${port}/json/version`, (res) => {
+      let body = "";
+      res.on("data", (c) => {
+        body += c.toString();
+      });
+      res.on("end", () => {
+        try {
+          const data = JSON.parse(body);
+          resolve(data.webSocketDebuggerUrl);
+        } catch {
+          resolve(void 0);
+        }
+      });
+    });
+    req.setTimeout(3e3, () => {
+      req.destroy();
+      resolve(void 0);
+    });
+    req.on("error", () => resolve(void 0));
+  });
+}
+var cookieSyncState = null;
+function needsCookieResync(chromeDataDir) {
+  if (!cookieSyncState) return false;
+  const dataDir = chromeDataDir ?? getDefaultChromeDataDir();
+  const localStatePath = join(dataDir, "Local State");
+  if (!existsSync(localStatePath)) return false;
+  try {
+    const localState = JSON.parse(readFileSync(localStatePath, "utf-8"));
+    const profileName = localState.profile?.last_used ?? "Default";
+    if (profileName !== cookieSyncState.profileName) return true;
+    const cookiePath = join(dataDir, profileName, "Cookies");
+    if (!existsSync(cookiePath)) return false;
+    const mtime = statSync(cookiePath).mtimeMs;
+    return mtime !== cookieSyncState.cookieMtime;
+  } catch {
+    return false;
+  }
+}
+function syncCookiesAndTrack(destDataDir, chromeDataDir) {
+  const dataDir = chromeDataDir ?? getDefaultChromeDataDir();
+  try {
+    const localStatePath = join(dataDir, "Local State");
+    if (!existsSync(localStatePath)) return;
+    const localState = JSON.parse(readFileSync(localStatePath, "utf-8"));
+    const profileName = localState.profile?.last_used ?? "Default";
+    const srcProfileDir = join(dataDir, profileName);
+    if (!existsSync(join(srcProfileDir, "Cookies"))) return;
+    const destProfileDir = join(destDataDir, "Default");
+    mkdirSync(destProfileDir, { recursive: true });
+    const files = readdirSync(srcProfileDir).filter((f) => f.startsWith("Cookies"));
+    for (const file of files) {
+      copyFileSync(join(srcProfileDir, file), join(destProfileDir, file));
+    }
+    const mtime = statSync(join(srcProfileDir, "Cookies")).mtimeMs;
+    cookieSyncState = { profileName, cookieMtime: mtime };
+  } catch {
+  }
+}
+function syncCookiesToHeadless(headlessDataDir) {
+  syncCookiesAndTrack(headlessDataDir);
+}
+async function launchHeadlessChrome() {
+  const healthy = await isCDPHealthy(HEADLESS_PORT);
+  if (healthy) {
+    const ws = await getWsEndpoint(HEADLESS_PORT);
+    return { success: true, port: HEADLESS_PORT, wsEndpoint: ws };
+  }
+  const chromePath = findChrome();
+  if (!chromePath) {
+    return { success: false, port: HEADLESS_PORT, error: "Chrome not found." };
+  }
+  const dataDir = join(tmpdir(), "browsirai-headless");
+  mkdirSync(dataDir, { recursive: true });
+  syncCookiesToHeadless(dataDir);
+  const child = spawn(chromePath, [
+    "--headless=new",
+    `--remote-debugging-port=${HEADLESS_PORT}`,
+    "--remote-allow-origins=*",
+    `--user-data-dir=${dataDir}`,
+    "--no-first-run",
+    "--no-default-browser-check",
+    "--disable-extensions",
+    "--disable-gpu"
+  ], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  for (let i = 0; i < 75; i++) {
+    await new Promise((r) => setTimeout(r, 200));
+    if (await isCDPHealthy(HEADLESS_PORT)) {
+      const ws = await getWsEndpoint(HEADLESS_PORT);
+      return { success: true, port: HEADLESS_PORT, wsEndpoint: ws };
+    }
+  }
+  return { success: false, port: HEADLESS_PORT, error: "Headless Chrome did not start in 15s." };
+}
+async function connectChrome(options = {}) {
+  const targetPort = options.port ?? 9222;
+  const activePort = readDevToolsActivePort();
+  if (activePort) {
+    const healthy2 = await isCDPHealthy(activePort.port);
+    if (healthy2) {
+      return {
+        success: true,
+        port: activePort.port,
+        wsEndpoint: activePort.wsEndpoint,
+        activePortFound: true
+      };
+    }
+  }
+  const healthy = await isCDPHealthy(targetPort);
+  if (healthy) {
+    return {
+      success: true,
+      port: targetPort,
+      activePortFound: false
+    };
+  }
+  if (options.autoLaunch) {
+    const launch = await launchChromeWithDebugging(targetPort, options.headless);
+    if (launch.success) {
+      return {
+        success: true,
+        port: launch.port,
+        wsEndpoint: launch.wsEndpoint,
+        activePortFound: false
+      };
+    }
+    return {
+      success: false,
+      port: targetPort,
+      activePortFound: false,
+      error: launch.error
+    };
+  }
+  return {
+    success: false,
+    port: targetPort,
+    activePortFound: activePort !== null,
+    error: "Chrome remote debugging is not enabled. Enable it at chrome://inspect/#remote-debugging"
+  };
+}
+
+// src/tools/browser-navigate.ts
+var POLL_INTERVAL_MS = 100;
+async function browserNavigate(cdp, params) {
+  const { url, timeout = 8 } = params;
+  const timeoutMs = timeout * 1e3;
+  await cdp.send("Page.enable");
+  const result = await Promise.race([
+    performNavigation(cdp, url, params.waitUntil),
+    createTimeout(timeoutMs)
+  ]);
+  return result;
+}
+async function performNavigation(cdp, url, waitUntil) {
+  const navResponse = await cdp.send("Page.navigate", { url });
+  if (navResponse.errorText) {
+    throw new Error(`Navigation failed: ${navResponse.errorText}`);
+  }
+  const hasCrossDocNavigation = Boolean(navResponse.loaderId);
+  if (hasCrossDocNavigation) {
+    await waitForLoadCompletion(cdp, waitUntil);
+  }
+  return getPageInfo(cdp);
+}
+function waitForLoadCompletion(cdp, waitUntil) {
+  const eventName = waitUntil === "domcontentloaded" ? "Page.domContentEventFired" : "Page.loadEventFired";
+  return new Promise((resolve) => {
+    let settled = false;
+    const handler = () => {
+      if (settled) return;
+      settled = true;
+      cdp.off(eventName, handler);
+      resolve();
+    };
+    cdp.on(eventName, handler);
+    const poll = async () => {
+      while (!settled) {
+        try {
+          const response = await cdp.send("Runtime.evaluate", {
+            expression: "document.readyState",
+            returnByValue: true
+          });
+          const readyState = response.result.value;
+          const isLoadingState = readyState === "loading" || readyState === "interactive";
+          if (readyState === "complete" || !isLoadingState) {
+            if (!settled) {
+              settled = true;
+              cdp.off(eventName, handler);
+              resolve();
+            }
+            return;
+          }
+        } catch {
+        }
+        if (!settled) {
+          await delay(POLL_INTERVAL_MS);
+        }
+      }
+    };
+    poll();
+  });
+}
+async function getPageInfo(cdp) {
+  const [titleResponse, urlResponse] = await Promise.all([
+    cdp.send("Runtime.evaluate", {
+      expression: "document.title"
+    }),
+    cdp.send("Runtime.evaluate", {
+      expression: "location.href"
+    })
+  ]);
+  return {
+    title: titleResponse.result.value ?? "",
+    url: urlResponse.result.value ?? ""
+  };
+}
+function createTimeout(ms) {
+  return new Promise((_resolve, reject) => {
+    setTimeout(() => {
+      reject(new Error(`Navigation timeout after ${ms}ms`));
+    }, ms);
+  });
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/tools/browser-screenshot.ts
+async function detectDPR(cdp) {
+  try {
+    const metrics = await cdp.send("Page.getLayoutMetrics", {});
+    if (metrics.visualViewport && metrics.cssVisualViewport) {
+      const physicalWidth = metrics.visualViewport.clientWidth;
+      const cssWidth = metrics.cssVisualViewport.clientWidth;
+      if (cssWidth > 0 && physicalWidth > 0) {
+        const dpr = physicalWidth / cssWidth;
+        if (dpr >= 1) {
+          return dpr;
+        }
+      }
+    }
+  } catch {
+  }
+  try {
+    const evalResult = await cdp.send("Runtime.evaluate", {
+      expression: "window.devicePixelRatio",
+      returnByValue: true
+    });
+    if (evalResult.result.type === "number" && typeof evalResult.result.value === "number") {
+      return evalResult.result.value;
+    }
+  } catch {
+  }
+  return 1;
+}
+async function getElementBoxBySelector(cdp, selector) {
+  const doc = await cdp.send("DOM.getDocument", {});
+  const queryResult = await cdp.send("DOM.querySelector", {
+    nodeId: doc.root.nodeId,
+    selector
+  });
+  if (!queryResult.nodeId) {
+    throw new Error(`Element not found: ${selector}`);
+  }
+  const boxModel = await cdp.send("DOM.getBoxModel", {
+    nodeId: queryResult.nodeId
+  });
+  const content = boxModel.model.content;
+  const x = content[0];
+  const y = content[1];
+  const width = content[2] - content[0];
+  const height = content[5] - content[1];
+  return { x, y, width, height };
+}
+async function getElementBoxByRef(cdp, ref) {
+  const match = /^@e(\d+)$/.exec(ref);
+  if (!match) {
+    throw new Error(`Invalid ref format: ${ref}`);
+  }
+  const backendNodeId = parseInt(match[1], 10);
+  const resolved = await cdp.send("DOM.resolveNode", {
+    backendNodeId
+  });
+  const boxModel = await cdp.send("DOM.getBoxModel", {
+    backendNodeId
+  });
+  const content = boxModel.model.content;
+  const x = content[0];
+  const y = content[1];
+  const width = content[2] - content[0];
+  const height = content[5] - content[1];
+  return { x, y, width, height };
+}
+async function buildAnnotations(cdp) {
+  const axTree = await cdp.send("Accessibility.getFullAXTree", {}, { timeout: 1e4 });
+  const annotations = [];
+  let counter = 0;
+  for (const node of axTree.nodes) {
+    const role = node.role?.value;
+    if (role === "WebArea") {
+      continue;
+    }
+    counter++;
+    const ref = node.backendDOMNodeId ? `@e${node.backendDOMNodeId}` : `@e${counter}`;
+    const label = `[${counter}]`;
+    annotations.push({
+      ref,
+      label,
+      role: role ?? "unknown",
+      name: node.name?.value ?? ""
+    });
+  }
+  return annotations;
+}
+async function browserScreenshot(cdp, params) {
+  const format = params.format ?? "png";
+  const captureParams = {
+    format
+  };
+  if (format === "jpeg" && params.quality !== void 0) {
+    captureParams.quality = params.quality;
+  }
+  const _dpr = await detectDPR(cdp);
+  if (params.selector) {
+    const box = await getElementBoxBySelector(cdp, params.selector);
+    captureParams.clip = {
+      x: box.x,
+      y: box.y,
+      width: box.width,
+      height: box.height,
+      scale: 1
+    };
+  }
+  if (params.ref) {
+    const box = await getElementBoxByRef(cdp, params.ref);
+    captureParams.clip = {
+      x: box.x,
+      y: box.y,
+      width: box.width,
+      height: box.height,
+      scale: 1
+    };
+  }
+  if (params.fullPage) {
+    const metrics = await cdp.send("Page.getLayoutMetrics", {});
+    const contentWidth = metrics.cssContentSize?.width ?? metrics.contentSize.width;
+    const contentHeight = metrics.cssContentSize?.height ?? metrics.contentSize.height;
+    captureParams.clip = {
+      x: 0,
+      y: 0,
+      width: contentWidth,
+      height: contentHeight,
+      scale: 1
+    };
+  }
+  const screenshot = await cdp.send("Page.captureScreenshot", captureParams);
+  const result = {
+    base64: screenshot.data
+  };
+  if (params.annotate) {
+    result.annotations = await buildAnnotations(cdp);
+  }
+  return result;
+}
+
+// src/tools/browser-tabs.ts
+function globToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  const regexStr = escaped.replace(/\*/g, ".*");
+  return new RegExp(`^${regexStr}$`, "i");
+}
+async function browserTabs(cdp, params = {}) {
+  const response = await cdp.send("Target.getTargets");
+  let tabs = response.targetInfos.filter(
+    (target) => target.type === "page"
+  );
+  if (params.filter) {
+    const regex = globToRegExp(params.filter);
+    tabs = tabs.filter((target) => regex.test(target.url));
+  }
+  return {
+    tabs: tabs.map((target) => ({
+      id: target.targetId,
+      title: target.title,
+      url: target.url
+    }))
+  };
+}
+
+// src/tools/browser-eval.ts
+function parseRemoteObject(obj) {
+  if (obj.type === "undefined") {
+    return void 0;
+  }
+  if (obj.type === "object" && obj.subtype === "null") {
+    return null;
+  }
+  if (obj.type === "object" && obj.subtype === "node") {
+    return obj.description ?? `[${obj.className ?? "Node"}]`;
+  }
+  if (obj.value !== void 0) {
+    return obj.value;
+  }
+  if (obj.description) {
+    return obj.description;
+  }
+  return void 0;
+}
+function formatException(details) {
+  if (details.exception?.description) {
+    return details.exception.description;
+  }
+  if (details.exception?.className) {
+    return `${details.exception.className}: ${details.text}`;
+  }
+  return details.text;
+}
+async function browserEval(cdp, params) {
+  let expression = params.expression;
+  if (params.base64) {
+    expression = atob(expression);
+  }
+  if (params.ref) {
+    return evalWithRef(cdp, expression, params.ref);
+  }
+  return evalGlobal(cdp, expression);
+}
+async function evalGlobal(cdp, expression) {
+  const response = await cdp.send("Runtime.evaluate", {
+    expression,
+    returnByValue: true,
+    awaitPromise: true
+  });
+  if (response.exceptionDetails) {
+    return {
+      error: formatException(response.exceptionDetails)
+    };
+  }
+  const value = parseRemoteObject(response.result);
+  return { result: value };
+}
+async function evalWithRef(cdp, functionDeclaration, ref) {
+  const match = /^@e(\d+)$/.exec(ref);
+  if (!match) {
+    return { error: `Invalid ref format: ${ref}` };
+  }
+  const backendNodeId = parseInt(match[1], 10);
+  const resolved = await cdp.send("DOM.resolveNode", {
+    backendNodeId
+  });
+  const objectId = resolved.object.objectId;
+  const response = await cdp.send("Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration,
+    returnByValue: true,
+    awaitPromise: true
+  });
+  if (response.exceptionDetails) {
+    return {
+      error: formatException(response.exceptionDetails)
+    };
+  }
+  const value = parseRemoteObject(response.result);
+  return { result: value };
+}
+
+// src/tools/browser-snapshot.ts
+var INTERACTIVE_ROLES = /* @__PURE__ */ new Set([
+  "button",
+  "link",
+  "textbox",
+  "checkbox",
+  "radio",
+  "combobox",
+  "listbox",
+  "menuitem",
+  "menuitemcheckbox",
+  "menuitemradio",
+  "option",
+  "searchbox",
+  "slider",
+  "spinbutton",
+  "switch",
+  "tab",
+  "treeitem"
+]);
+function shouldShowAxNode(node, options) {
+  const role = node.role?.value ?? "";
+  if (role === "none") {
+    return false;
+  }
+  if (role === "generic") {
+    const name2 = node.name?.value ?? "";
+    if (!name2) {
+      return false;
+    }
+  }
+  if (options?.compact && role === "InlineTextBox") {
+    return false;
+  }
+  const name = node.name?.value ?? "";
+  const value = node.value?.value ?? null;
+  if (!name && (value === null || value === void 0 || value === "")) {
+    return false;
+  }
+  return true;
+}
+function getChildNodeIds(node) {
+  if (node.childIds && node.childIds.length > 0) {
+    return node.childIds;
+  }
+  if (node.children && node.children.length > 0) {
+    return node.children.map((c) => c.nodeId);
+  }
+  return [];
+}
+function formatNodeAttributes(node) {
+  const parts = [];
+  if (node.value?.value !== void 0 && node.value.value !== "") {
+    parts.push(`value="${node.value.value}"`);
+  }
+  if (node.description?.value) {
+    parts.push(`description="${node.description.value}"`);
+  }
+  if (node.properties) {
+    for (const prop of node.properties) {
+      switch (prop.name) {
+        case "level":
+          parts.push(`level=${prop.value.value}`);
+          break;
+        case "checked": {
+          const val = prop.value.value;
+          if (val === true || val === "true" || val === "mixed") {
+            parts.push("checked");
+          }
+          break;
+        }
+        case "selected":
+          if (prop.value.value === true) {
+            parts.push("selected");
+          }
+          break;
+        case "expanded":
+          if (prop.value.value === true || prop.value.value === "true") {
+            parts.push("expanded");
+          } else {
+            parts.push("collapsed");
+          }
+          break;
+        default:
+          break;
+      }
+    }
+  }
+  return parts.join(" ");
+}
+async function browserSnapshot(cdp, params) {
+  const options = {
+    interactive: params?.interactive,
+    cursor: params?.cursor,
+    compact: params?.compact,
+    depth: params?.depth,
+    selector: params?.selector
+  };
+  await cdp.send("Accessibility.enable");
+  let axNodes;
+  if (options.selector) {
+    const docResult = await cdp.send("DOM.getDocument");
+    const queryResult = await cdp.send("DOM.querySelector", {
+      nodeId: docResult.root.nodeId,
+      selector: options.selector
+    });
+    if (queryResult.nodeId === 0) {
+      return { snapshot: `No element found for selector: ${options.selector}` };
+    }
+    const partialResult = await cdp.send("Accessibility.getPartialAXTree", {
+      nodeId: queryResult.nodeId,
+      fetchRelatives: true
+    });
+    axNodes = partialResult.nodes;
+  } else {
+    const fullResult = await cdp.send("Accessibility.getFullAXTree");
+    axNodes = fullResult.nodes;
+  }
+  const totalElements = axNodes.filter(
+    (n) => n.role?.value !== "WebArea"
+  ).length;
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const node of axNodes) {
+    nodeMap.set(node.nodeId, node);
+  }
+  let root;
+  for (const node of axNodes) {
+    if (!node.parentId) {
+      root = node;
+      break;
+    }
+  }
+  if (!root) {
+    root = axNodes[0];
+  }
+  if (!root) {
+    return { snapshot: "" };
+  }
+  const lines = [];
+  let refCounter = 0;
+  const visited = /* @__PURE__ */ new Set();
+  const maxDepth = options.depth ?? 100;
+  function traverse(node, depth) {
+    if (visited.has(node.nodeId)) {
+      return;
+    }
+    visited.add(node.nodeId);
+    if (depth > maxDepth) {
+      return;
+    }
+    const role = node.role?.value ?? "";
+    const isRoot = role === "WebArea";
+    const showNode = isRoot || shouldShow(node, options);
+    if (showNode && !isRoot) {
+      refCounter++;
+      const ref = node.backendDOMNodeId ? `@e${node.backendDOMNodeId}` : `@e${refCounter}`;
+      const indent = "  ".repeat(depth);
+      const name = node.name?.value ?? "";
+      const attrs = formatNodeAttributes(node);
+      let line = `${indent}${ref} ${role}`;
+      if (name) {
+        line += ` "${name}"`;
+      }
+      if (attrs) {
+        line += ` ${attrs}`;
+      }
+      lines.push(line);
+    }
+    const childNodeIds = getChildNodeIds(node);
+    const nextDepth = isRoot ? depth : depth + 1;
+    for (const childId of childNodeIds) {
+      const childNode = nodeMap.get(childId);
+      if (childNode) {
+        traverse(childNode, nextDepth);
+      }
+    }
+  }
+  traverse(root, 0);
+  const snapshot = lines.join("\n");
+  const result = { snapshot };
+  if (totalElements > 1e3) {
+    result.truncated = true;
+    result.totalElements = totalElements;
+  }
+  return result;
+}
+function shouldShow(node, options) {
+  if (!shouldShowAxNode(node, { compact: options.compact })) {
+    return false;
+  }
+  const role = node.role?.value ?? "";
+  if (options.interactive) {
+    if (INTERACTIVE_ROLES.has(role)) {
+      return true;
+    }
+    if (options.cursor) {
+      return hasCursorPointer(node);
+    }
+    return false;
+  }
+  if (options.cursor) {
+    if (hasCursorPointer(node)) {
+      return true;
+    }
+  }
+  return true;
+}
+function hasCursorPointer(node) {
+  if (!node.properties) return false;
+  return node.properties.some(
+    (p) => p.name === "cursor" && p.value.value === "pointer"
+  );
+}
+
+// src/tools/browser-click.ts
+var MODIFIER_BITS = {
+  Alt: 1,
+  Control: 2,
+  Meta: 4,
+  Shift: 8
+};
+var REF_PATTERN = /^@e(\d+)$/;
+function calculateCenter(content) {
+  const x = (content[0] + content[2] + content[4] + content[6]) / 4;
+  const y = (content[1] + content[3] + content[5] + content[7]) / 4;
+  return { x: Math.round(x), y: Math.round(y) };
+}
+async function resolveElementCoordinates(cdp, params) {
+  let backendNodeId;
+  let nodeId;
+  if (params.ref) {
+    const match = REF_PATTERN.exec(params.ref);
+    if (!match) {
+      throw new Error(`Invalid ref format: ${params.ref}`);
+    }
+    backendNodeId = parseInt(match[1], 10);
+    await cdp.send("DOM.resolveNode", {
+      backendNodeId
+    });
+  } else if (params.selector) {
+    const docResponse = await cdp.send("DOM.getDocument");
+    const queryResponse = await cdp.send("DOM.querySelector", {
+      nodeId: docResponse.root.nodeId,
+      selector: params.selector
+    });
+    if (!queryResponse.nodeId || queryResponse.nodeId === 0) {
+      throw new Error(
+        `Element not found: no element matches selector "${params.selector}"`
+      );
+    }
+    nodeId = queryResponse.nodeId;
+  } else {
+    throw new Error("Either ref, selector, or coordinates (x, y) must be provided");
+  }
+  const scrollParams = {};
+  if (backendNodeId !== void 0) {
+    scrollParams.backendNodeId = backendNodeId;
+  } else if (nodeId !== void 0) {
+    scrollParams.nodeId = nodeId;
+  }
+  await cdp.send(
+    "DOM.scrollIntoViewIfNeeded",
+    scrollParams
+  );
+  const boxParams = {};
+  if (backendNodeId !== void 0) {
+    boxParams.backendNodeId = backendNodeId;
+  } else if (nodeId !== void 0) {
+    boxParams.nodeId = nodeId;
+  }
+  const boxResponse = await cdp.send("DOM.getBoxModel", boxParams);
+  const { content, width, height } = boxResponse.model;
+  if (width === 0 && height === 0) {
+    throw new Error(
+      "Element is not visible: zero-size box model. The element may be hidden or not rendered."
+    );
+  }
+  return calculateCenter(content);
+}
+function computeModifiers(modifiers) {
+  if (!modifiers || modifiers.length === 0) return 0;
+  let bits = 0;
+  for (const mod of modifiers) {
+    const bit = MODIFIER_BITS[mod];
+    if (bit !== void 0) {
+      bits |= bit;
+    }
+  }
+  return bits;
+}
+function delay2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function browserClick(cdp, params) {
+  let x;
+  let y;
+  if (params.x !== void 0 && params.y !== void 0) {
+    x = params.x;
+    y = params.y;
+  } else {
+    const coords = await resolveElementCoordinates(cdp, params);
+    x = coords.x;
+    y = coords.y;
+  }
+  const button = params.button ?? "left";
+  let effectiveModifiers = params.modifiers ? [...params.modifiers] : [];
+  if (params.newTab) {
+    const isMac = typeof process !== "undefined" && process.platform === "darwin";
+    const newTabModifier = isMac ? "Meta" : "Control";
+    if (!effectiveModifiers.includes(newTabModifier)) {
+      effectiveModifiers.push(newTabModifier);
+    }
+  }
+  const modifiers = computeModifiers(effectiveModifiers);
+  if (params.doubleClick) {
+    await performDoubleClick(cdp, x, y, button, modifiers);
+  } else {
+    await performClick(cdp, x, y, button, modifiers);
+  }
+  return { success: true };
+}
+async function performClick(cdp, x, y, button, modifiers, clickCount = 1) {
+  await cdp.send("Input.dispatchMouseEvent", {
+    type: "mouseMoved",
+    x,
+    y,
+    modifiers
+  });
+  await cdp.send("Input.dispatchMouseEvent", {
+    type: "mousePressed",
+    x,
+    y,
+    button,
+    clickCount,
+    modifiers
+  });
+  await delay2(50);
+  await cdp.send("Input.dispatchMouseEvent", {
+    type: "mouseReleased",
+    x,
+    y,
+    button,
+    clickCount,
+    modifiers
+  });
+}
+async function performDoubleClick(cdp, x, y, button, modifiers) {
+  await performClick(cdp, x, y, button, modifiers, 1);
+  await performClick(cdp, x, y, button, modifiers, 2);
+}
+
+// src/tools/browser-scroll.ts
+var DEFAULT_SCROLL_AMOUNT = 300;
+async function resolveSelector(cdp, selector) {
+  const evalResult = await cdp.send("Runtime.evaluate", {
+    expression: `document.querySelector(${JSON.stringify(selector)})`,
+    returnByValue: false
+  });
+  if (evalResult.result.objectId && evalResult.result.subtype !== "null") {
+    return { objectId: evalResult.result.objectId };
+  }
+  if (evalResult.result.subtype === "null" || evalResult.result.value === null) {
+    throw new Error(`Element not found: ${selector}`);
+  }
+  try {
+    const resolveResponse = await cdp.send("DOM.resolveNode", {
+      backendNodeId: void 0
+    });
+    if (resolveResponse.object?.objectId) {
+      return { objectId: resolveResponse.object.objectId };
+    }
+  } catch {
+  }
+  throw new Error(`Could not find element: ${selector}`);
+}
+async function browserScroll(cdp, params) {
+  const { direction, selector } = params;
+  const amount = params.amount ?? DEFAULT_SCROLL_AMOUNT;
+  if (selector && !direction) {
+    const { objectId } = await resolveSelector(cdp, selector);
+    await cdp.send("Runtime.callFunctionOn", {
+      objectId,
+      functionDeclaration: `function() { this.scrollIntoView({ behavior: "smooth", block: "center" }); }`,
+      returnByValue: true
+    });
+    return { success: true };
+  }
+  if (selector && direction) {
+    const { objectId } = await resolveSelector(cdp, selector);
+    const scrollX2 = direction === "left" ? -amount : direction === "right" ? amount : 0;
+    const scrollY2 = direction === "up" ? -amount : direction === "down" ? amount : 0;
+    await cdp.send("Runtime.callFunctionOn", {
+      objectId,
+      functionDeclaration: `function() { this.scrollBy(${scrollX2}, ${scrollY2}); }`,
+      returnByValue: true
+    });
+    return { success: true };
+  }
+  const scrollX = direction === "left" ? -amount : direction === "right" ? amount : 0;
+  const scrollY = direction === "up" ? -amount : direction === "down" ? amount : 0;
+  await cdp.send("Runtime.evaluate", {
+    expression: `window.scrollBy(${scrollX}, ${scrollY})`,
+    returnByValue: true
+  });
+  return { success: true };
+}
+
+// src/tools/browser-html.ts
+async function browserHtml(cdp, params) {
+  if (!params.selector) {
+    const evalResult = await cdp.send("Runtime.evaluate", {
+      expression: "document.documentElement.outerHTML",
+      returnByValue: true
+    });
+    return { html: evalResult.result.value };
+  }
+  const doc = await cdp.send("DOM.getDocument", {});
+  const queryResult = await cdp.send("DOM.querySelector", {
+    nodeId: doc.root.nodeId,
+    selector: params.selector
+  });
+  if (!queryResult.nodeId) {
+    return {
+      html: "",
+      error: `Element not found: ${params.selector}`
+    };
+  }
+  const outerResult = await cdp.send("DOM.getOuterHTML", {
+    nodeId: queryResult.nodeId
+  });
+  return { html: outerResult.outerHTML };
+}
+
+// src/tools/browser-navigate-back.ts
+async function browserNavigateBack(cdp, params) {
+  const direction = params.direction ?? "back";
+  const history = await cdp.send("Page.getNavigationHistory");
+  const targetIndex = direction === "back" ? history.currentIndex - 1 : history.currentIndex + 1;
+  if (targetIndex < 0 || targetIndex >= history.entries.length) {
+    return { success: false, url: history.entries[history.currentIndex]?.url };
+  }
+  const entry = history.entries[targetIndex];
+  await cdp.send("Page.navigateToHistoryEntry", { entryId: entry.id });
+  return { success: true, url: entry.url };
+}
+
+// src/tools/browser-press-key.ts
+var KEY_CODE_MAP = {
+  Enter: 13,
+  Tab: 9,
+  Escape: 27,
+  Backspace: 8,
+  Delete: 46,
+  ArrowLeft: 37,
+  ArrowUp: 38,
+  ArrowRight: 39,
+  ArrowDown: 40,
+  Home: 36,
+  End: 35,
+  PageUp: 33,
+  PageDown: 34,
+  Insert: 45,
+  Space: 32,
+  " ": 32,
+  F1: 112,
+  F2: 113,
+  F3: 114,
+  F4: 115,
+  F5: 116,
+  F6: 117,
+  F7: 118,
+  F8: 119,
+  F9: 120,
+  F10: 121,
+  F11: 122,
+  F12: 123,
+  Control: 17,
+  Shift: 16,
+  Alt: 18,
+  Meta: 91
+};
+var KEY_TO_CODE = {
+  Enter: "Enter",
+  Tab: "Tab",
+  Escape: "Escape",
+  Backspace: "Backspace",
+  Delete: "Delete",
+  ArrowLeft: "ArrowLeft",
+  ArrowUp: "ArrowUp",
+  ArrowRight: "ArrowRight",
+  ArrowDown: "ArrowDown",
+  Home: "Home",
+  End: "End",
+  PageUp: "PageUp",
+  PageDown: "PageDown",
+  Insert: "Insert",
+  Space: "Space",
+  " ": "Space",
+  Control: "ControlLeft",
+  Shift: "ShiftLeft",
+  Alt: "AltLeft",
+  Meta: "MetaLeft"
+};
+var KEY_TEXT_MAP = {
+  Enter: "\r",
+  Tab: "	",
+  Escape: "",
+  Space: " ",
+  Backspace: "\b"
+};
+var MODIFIER_BITS2 = {
+  Alt: 1,
+  Control: 2,
+  Meta: 4,
+  Shift: 8
+};
+function getKeyCode(key) {
+  if (KEY_CODE_MAP[key] !== void 0) {
+    return KEY_CODE_MAP[key];
+  }
+  if (key.length === 1) {
+    return key.toUpperCase().charCodeAt(0);
+  }
+  return 0;
+}
+function getCode(key) {
+  if (KEY_TO_CODE[key] !== void 0) {
+    return KEY_TO_CODE[key];
+  }
+  if (key.length === 1) {
+    const upper = key.toUpperCase();
+    if (upper >= "A" && upper <= "Z") {
+      return `Key${upper}`;
+    }
+    if (upper >= "0" && upper <= "9") {
+      return `Digit${upper}`;
+    }
+  }
+  return key;
+}
+function getKeyText(key) {
+  if (KEY_TEXT_MAP[key] !== void 0) {
+    return KEY_TEXT_MAP[key] || void 0;
+  }
+  if (key.length === 1) {
+    return key;
+  }
+  return void 0;
+}
+async function browserPressKey(cdp, params) {
+  const parts = params.key.split("+");
+  const mainKey = parts[parts.length - 1];
+  const modifierKeys = parts.slice(0, -1);
+  let modifiers = 0;
+  for (const mod of modifierKeys) {
+    if (MODIFIER_BITS2[mod] !== void 0) {
+      modifiers |= MODIFIER_BITS2[mod];
+    }
+  }
+  for (const mod of modifierKeys) {
+    await cdp.send("Input.dispatchKeyEvent", {
+      type: "keyDown",
+      key: mod,
+      code: getCode(mod),
+      windowsVirtualKeyCode: getKeyCode(mod),
+      modifiers
+    });
+  }
+  const text = getKeyText(mainKey);
+  const keyDownParams = {
+    type: "keyDown",
+    key: mainKey,
+    code: getCode(mainKey),
+    windowsVirtualKeyCode: getKeyCode(mainKey),
+    modifiers
+  };
+  if (text !== void 0) {
+    keyDownParams.text = text;
+  }
+  await cdp.send("Input.dispatchKeyEvent", keyDownParams);
+  if (text && modifierKeys.length === 0) {
+    await cdp.send("Input.dispatchKeyEvent", {
+      type: "char",
+      key: mainKey,
+      code: getCode(mainKey),
+      windowsVirtualKeyCode: getKeyCode(mainKey),
+      modifiers,
+      text
+    });
+  }
+  await cdp.send("Input.dispatchKeyEvent", {
+    type: "keyUp",
+    key: mainKey,
+    code: getCode(mainKey),
+    windowsVirtualKeyCode: getKeyCode(mainKey),
+    modifiers
+  });
+  for (let i = modifierKeys.length - 1; i >= 0; i--) {
+    const mod = modifierKeys[i];
+    await cdp.send("Input.dispatchKeyEvent", {
+      type: "keyUp",
+      key: mod,
+      code: getCode(mod),
+      windowsVirtualKeyCode: getKeyCode(mod),
+      modifiers: 0
+    });
+  }
+  return { success: true };
+}
+
+// src/tools/browser-hover.ts
+var REF_PATTERN2 = /^@?e(\d+)$/;
+function calculateCenter2(content) {
+  const x = (content[0] + content[2] + content[4] + content[6]) / 4;
+  const y = (content[1] + content[3] + content[5] + content[7]) / 4;
+  return { x: Math.round(x), y: Math.round(y) };
+}
+async function resolveElementCoordinates2(cdp, params) {
+  let backendNodeId;
+  let nodeId;
+  if (params.ref) {
+    const match = REF_PATTERN2.exec(params.ref);
+    if (!match) {
+      throw new Error(`Invalid ref format: ${params.ref}`);
+    }
+    backendNodeId = parseInt(match[1], 10);
+    await cdp.send("DOM.resolveNode", {
+      backendNodeId
+    });
+  } else if (params.selector) {
+    const docResponse = await cdp.send("DOM.getDocument");
+    const queryResponse = await cdp.send("DOM.querySelector", {
+      nodeId: docResponse.root.nodeId,
+      selector: params.selector
+    });
+    if (!queryResponse.nodeId || queryResponse.nodeId === 0) {
+      throw new Error(
+        `Element not found: no element matches selector "${params.selector}"`
+      );
+    }
+    nodeId = queryResponse.nodeId;
+  } else {
+    throw new Error("Either ref or selector must be provided");
+  }
+  const scrollParams = {};
+  if (backendNodeId !== void 0) {
+    scrollParams.backendNodeId = backendNodeId;
+  } else if (nodeId !== void 0) {
+    scrollParams.nodeId = nodeId;
+  }
+  await cdp.send("DOM.scrollIntoViewIfNeeded", scrollParams);
+  const boxParams = {};
+  if (backendNodeId !== void 0) {
+    boxParams.backendNodeId = backendNodeId;
+  } else if (nodeId !== void 0) {
+    boxParams.nodeId = nodeId;
+  }
+  const boxResponse = await cdp.send("DOM.getBoxModel", boxParams);
+  return calculateCenter2(boxResponse.model.content);
+}
+async function browserHover(cdp, params) {
+  const { x, y } = await resolveElementCoordinates2(cdp, params);
+  await cdp.send("Input.dispatchMouseEvent", {
+    type: "mouseMoved",
+    x,
+    y
+  });
+  return { success: true };
+}
+
+// src/tools/browser-resize.ts
+var PRESETS = {
+  mobile: { width: 375, height: 667 },
+  tablet: { width: 768, height: 1024 },
+  desktop: { width: 1280, height: 720 },
+  fullhd: { width: 1920, height: 1080 }
+};
+async function browserResize(cdp, params) {
+  let width;
+  let height;
+  if (params.preset?.toLowerCase() === "reset") {
+    await cdp.send("Emulation.clearDeviceMetricsOverride");
+    return { success: true, width: 0, height: 0 };
+  }
+  if (params.preset) {
+    const preset = PRESETS[params.preset.toLowerCase()];
+    if (!preset) {
+      throw new Error(
+        `Unknown preset "${params.preset}". Available: ${Object.keys(PRESETS).join(", ")}, reset`
+      );
+    }
+    width = preset.width;
+    height = preset.height;
+  } else {
+    width = params.width ?? 1280;
+    height = params.height ?? 720;
+  }
+  if (params.width !== void 0) width = params.width;
+  if (params.height !== void 0) height = params.height;
+  const deviceScaleFactor = params.deviceScaleFactor ?? 0;
+  const mobile = width < 768;
+  await cdp.send("Emulation.setDeviceMetricsOverride", {
+    width,
+    height,
+    deviceScaleFactor,
+    mobile
+  });
+  return {
+    success: true,
+    width,
+    height
+  };
+}
+
+// src/tools/browser-close.ts
+async function browserClose(cdp, params) {
+  let closedCount = 0;
+  if (params.closeAll) {
+    const targetsResponse = await cdp.send("Target.getTargets");
+    const pageTargets = targetsResponse.targetInfos.filter(
+      (t) => t.type === "page"
+    );
+    for (const target of pageTargets) {
+      try {
+        await cdp.send("Target.closeTarget", {
+          targetId: target.targetId
+        });
+        closedCount++;
+      } catch {
+      }
+    }
+  } else if (params.targetId) {
+    await cdp.send("Target.closeTarget", {
+      targetId: params.targetId
+    });
+    closedCount = 1;
+  } else {
+    const targetsResponse = await cdp.send("Target.getTargets");
+    const pageTargets = targetsResponse.targetInfos.filter(
+      (t) => t.type === "page"
+    );
+    if (pageTargets.length === 0) {
+      throw new Error("No page targets found to close");
+    }
+    const activeTarget = pageTargets.find((t) => t.attached) ?? pageTargets[0];
+    await cdp.send("Target.closeTarget", {
+      targetId: activeTarget.targetId
+    });
+    closedCount = 1;
+  }
+  return {
+    success: true,
+    closedTargets: closedCount
+  };
+}
+
+// src/tools/browser-fill-form.ts
+function parseRef(ref) {
+  const match = ref.match(/@?e(\d+)/);
+  if (!match) {
+    throw new Error(`Invalid ref format: ${ref}`);
+  }
+  return parseInt(match[1], 10);
+}
+async function resolveObjectId(cdp, field) {
+  if (field.ref) {
+    const backendNodeId = parseRef(field.ref);
+    const result = await cdp.send("DOM.resolveNode", {
+      backendNodeId
+    });
+    return result.object.objectId;
+  }
+  if (field.selector) {
+    const evalResult = await cdp.send("Runtime.evaluate", {
+      expression: `document.querySelector(${JSON.stringify(field.selector)})`,
+      returnByValue: false
+    });
+    if (evalResult.result.objectId) {
+      return evalResult.result.objectId;
+    }
+    const docResult = await cdp.send(
+      "DOM.getDocument",
+      {}
+    );
+    const queryResult = await cdp.send("DOM.querySelector", {
+      nodeId: docResult.root.nodeId,
+      selector: field.selector
+    });
+    const resolveResult = await cdp.send("DOM.resolveNode", {
+      nodeId: queryResult.nodeId
+    });
+    return resolveResult.object.objectId;
+  }
+  throw new Error(`Field "${field.name}" has neither ref nor selector`);
+}
+async function isReadonlyOrDisabled(cdp, objectId) {
+  const result = await cdp.send("Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration: `function() { return this.readOnly || this.disabled; }`,
+    returnByValue: true
+  });
+  return result.result.value === true;
+}
+async function clickElement(cdp, field) {
+  let backendNodeId;
+  if (field.ref) {
+    backendNodeId = parseRef(field.ref);
+  }
+  if (backendNodeId !== void 0) {
+    await cdp.send("DOM.scrollIntoViewIfNeeded", {
+      backendNodeId
+    });
+  }
+  const boxResult = await cdp.send("DOM.getBoxModel", {
+    backendNodeId
+  });
+  const quad = boxResult.model.content;
+  const centerX = (quad[0] + quad[2] + quad[4] + quad[6]) / 4;
+  const centerY = (quad[1] + quad[3] + quad[5] + quad[7]) / 4;
+  await cdp.send("Input.dispatchMouseEvent", {
+    type: "mousePressed",
+    x: centerX,
+    y: centerY,
+    button: "left",
+    clickCount: 1
+  });
+  await cdp.send("Input.dispatchMouseEvent", {
+    type: "mouseReleased",
+    x: centerX,
+    y: centerY,
+    button: "left",
+    clickCount: 1
+  });
+}
+async function fillTextbox(cdp, field, objectId) {
+  if (field.ref) {
+    const backendNodeId = parseRef(field.ref);
+    await cdp.send("DOM.focus", {
+      backendNodeId
+    });
+  } else {
+    await cdp.send("Runtime.callFunctionOn", {
+      objectId,
+      functionDeclaration: `function() { this.focus(); }`,
+      returnByValue: true
+    });
+  }
+  await cdp.send("Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration: `function() { this.value = ''; this.dispatchEvent(new Event('input', { bubbles: true })); }`,
+    returnByValue: true
+  });
+  await cdp.send("Input.insertText", {
+    text: field.value
+  });
+  await cdp.send("Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration: `function() {
+      this.dispatchEvent(new Event('input', { bubbles: true }));
+      this.dispatchEvent(new Event('change', { bubbles: true }));
+    }`,
+    returnByValue: true
+  });
+}
+async function fillCombobox(cdp, _field, objectId, value) {
+  await cdp.send("Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration: `function(val) {
+      this.value = val;
+      this.dispatchEvent(new Event('input', { bubbles: true }));
+      this.dispatchEvent(new Event('change', { bubbles: true }));
+      return [val];
+    }`,
+    arguments: [{ value }],
+    returnByValue: true
+  });
+}
+async function fillSlider(cdp, _field, objectId, value) {
+  await cdp.send("Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration: `function(val) {
+      this.value = val;
+      this.dispatchEvent(new Event('input', { bubbles: true }));
+      this.dispatchEvent(new Event('change', { bubbles: true }));
+    }`,
+    arguments: [{ value }],
+    returnByValue: true
+  });
+}
+async function browserFillForm(cdp, params) {
+  let filledCount = 0;
+  const errors = [];
+  for (const field of params.fields) {
+    try {
+      const objectId = await resolveObjectId(cdp, field);
+      switch (field.type) {
+        case "textbox": {
+          const isBlocked = await isReadonlyOrDisabled(cdp, objectId);
+          if (isBlocked) {
+            errors.push({
+              field: field.name,
+              error: `Cannot fill readonly or disabled field "${field.name}"`
+            });
+            continue;
+          }
+          await fillTextbox(cdp, field, objectId);
+          filledCount++;
+          break;
+        }
+        case "checkbox": {
+          await clickElement(cdp, field);
+          filledCount++;
+          break;
+        }
+        case "radio": {
+          await clickElement(cdp, field);
+          filledCount++;
+          break;
+        }
+        case "combobox": {
+          await fillCombobox(cdp, field, objectId, field.value);
+          filledCount++;
+          break;
+        }
+        case "slider": {
+          await fillSlider(cdp, field, objectId, field.value);
+          filledCount++;
+          break;
+        }
+        default: {
+          await fillTextbox(cdp, field, objectId);
+          filledCount++;
+          break;
+        }
+      }
+    } catch (err) {
+      errors.push({
+        field: field.name,
+        error: err instanceof Error ? err.message : `Unknown error filling ${field.name}`
+      });
+    }
+  }
+  return {
+    success: errors.length === 0,
+    filledCount,
+    errors: errors.length > 0 ? errors : void 0
+  };
+}
+
+// src/tools/browser-type.ts
+function parseRef2(ref) {
+  const match = ref.match(/@e(\d+)/);
+  if (!match) {
+    throw new Error(`Invalid ref format: ${ref}`);
+  }
+  return parseInt(match[1], 10);
+}
+function getKeyCode2(key) {
+  if (key.length === 1) {
+    return key.toUpperCase().charCodeAt(0);
+  }
+  const codes = {
+    Enter: 13,
+    Tab: 9,
+    Backspace: 8
+  };
+  return codes[key] ?? 0;
+}
+function getCode2(key) {
+  if (key.length === 1) {
+    const upper = key.toUpperCase();
+    if (upper >= "A" && upper <= "Z") return `Key${upper}`;
+    if (upper >= "0" && upper <= "9") return `Digit${upper}`;
+  }
+  return key;
+}
+function delay3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function dispatchCharEvents(cdp, char) {
+  const keyCode = getKeyCode2(char);
+  const code = getCode2(char);
+  await cdp.send("Input.dispatchKeyEvent", {
+    type: "keyDown",
+    key: char,
+    code,
+    windowsVirtualKeyCode: keyCode,
+    text: char
+  });
+  await cdp.send("Input.dispatchKeyEvent", {
+    type: "char",
+    key: char,
+    code,
+    windowsVirtualKeyCode: keyCode,
+    text: char
+  });
+  await cdp.send("Input.dispatchKeyEvent", {
+    type: "keyUp",
+    key: char,
+    code,
+    windowsVirtualKeyCode: keyCode
+  });
+}
+async function browserType(cdp, params) {
+  if (params.ref) {
+    const backendNodeId = parseRef2(params.ref);
+    await cdp.send("DOM.focus", {
+      backendNodeId
+    });
+  }
+  if (!params.ref && params.selector) {
+    const evalResult = await cdp.send("Runtime.evaluate", {
+      expression: `document.querySelector(${JSON.stringify(params.selector)})`,
+      returnByValue: false
+    });
+    if (evalResult.result.objectId) {
+      await cdp.send("Runtime.callFunctionOn", {
+        objectId: evalResult.result.objectId,
+        functionDeclaration: `function() { this.focus(); }`,
+        returnByValue: true
+      });
+    }
+  }
+  if (params.slowly) {
+    for (let i = 0; i < params.text.length; i++) {
+      await dispatchCharEvents(cdp, params.text[i]);
+      if (i < params.text.length - 1) {
+        await delay3(50);
+      }
+    }
+  } else {
+    await cdp.send("Input.insertText", {
+      text: params.text
+    });
+  }
+  if (params.submit) {
+    await cdp.send("Input.dispatchKeyEvent", {
+      type: "keyDown",
+      key: "Enter",
+      code: "Enter",
+      windowsVirtualKeyCode: 13
+    });
+    await cdp.send("Input.dispatchKeyEvent", {
+      type: "keyUp",
+      key: "Enter",
+      code: "Enter",
+      windowsVirtualKeyCode: 13
+    });
+  }
+  return { success: true };
+}
+
+// src/tools/browser-select-option.ts
+function refToBackendNodeId(ref) {
+  const match = /^@?e(\d+)$/.exec(ref);
+  if (!match) {
+    throw new Error(`Invalid ref format: ${ref}`);
+  }
+  return parseInt(match[1], 10);
+}
+async function browserSelectOption(cdp, params) {
+  const backendNodeId = refToBackendNodeId(params.ref);
+  const resolveResponse = await cdp.send("DOM.resolveNode", {
+    backendNodeId
+  });
+  const objectId = resolveResponse.object.objectId;
+  const valuesJson = JSON.stringify(params.values);
+  const result = await cdp.send("Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration: `function() {
+      var select = this;
+      if (select.tagName !== 'SELECT') {
+        throw new Error('Element is not a SELECT');
+      }
+      var values = ${valuesJson};
+      var matched = [];
+
+      for (var i = 0; i < select.options.length; i++) {
+        var option = select.options[i];
+        var isMatch = values.indexOf(option.value) !== -1 ||
+                      values.indexOf(option.textContent.trim()) !== -1;
+        option.selected = isMatch;
+        if (isMatch) {
+          matched.push(option.value);
+        }
+      }
+
+      select.dispatchEvent(new Event('input', { bubbles: true }));
+      select.dispatchEvent(new Event('change', { bubbles: true }));
+
+      return matched;
+    }`,
+    returnByValue: true
+  });
+  const selected = result.result.value ?? [];
+  return {
+    success: true,
+    selected
+  };
+}
+
+// src/tools/browser-wait-for.ts
+var DEFAULT_TIMEOUT_S = 30;
+var POLL_INTERVAL_MS2 = 100;
+function normalizeTimeoutMs(timeout) {
+  if (timeout > 60) {
+    return timeout;
+  }
+  return timeout * 1e3;
+}
+async function browserWaitFor(cdp, params) {
+  const timeoutMs = normalizeTimeoutMs(params.timeout ?? DEFAULT_TIMEOUT_S);
+  const start = Date.now();
+  if (params.time !== void 0) {
+    const delayMs = params.time * 1e3;
+    await delay4(delayMs);
+    return { success: true, elapsed: Date.now() - start };
+  }
+  const condition = buildCondition(params);
+  while (true) {
+    const elapsed = Date.now() - start;
+    if (elapsed >= timeoutMs) {
+      throw new Error(
+        `Timeout after ${timeoutMs}ms waiting for condition: ${describeCondition(params)}`
+      );
+    }
+    let met = false;
+    try {
+      met = await evaluateCondition(cdp, condition);
+    } catch {
+    }
+    if (met) {
+      return { success: true, elapsed: Date.now() - start };
+    }
+    await delay4(POLL_INTERVAL_MS2);
+  }
+}
+function buildCondition(params) {
+  if (params.url !== void 0) {
+    return { kind: "url", expression: params.url };
+  }
+  if (params.fn !== void 0) {
+    return {
+      kind: "fn",
+      expression: `Boolean(${params.fn})`
+    };
+  }
+  if (params.selector !== void 0 && params.state === "hidden") {
+    return {
+      kind: "selectorHidden",
+      expression: buildVisibilityCheck(params.selector)
+    };
+  }
+  if (params.selector !== void 0 && params.visible) {
+    return {
+      kind: "selectorVisible",
+      expression: buildVisibilityCheck(params.selector)
+    };
+  }
+  if (params.selector !== void 0) {
+    return {
+      kind: "selector",
+      expression: `document.querySelector(${JSON.stringify(params.selector)})`
+    };
+  }
+  if (params.text !== void 0) {
+    return {
+      kind: "text",
+      expression: `document.body && document.body.innerText.includes(${JSON.stringify(params.text)})`
+    };
+  }
+  if (params.textGone !== void 0) {
+    return {
+      kind: "textGone",
+      expression: `document.body && !document.body.innerText.includes(${JSON.stringify(params.textGone)})`
+    };
+  }
+  if (params.networkIdle) {
+    return {
+      kind: "networkIdle",
+      expression: "true"
+      // Simplified: check via Runtime.evaluate
+    };
+  }
+  if (params.loadState !== void 0) {
+    return {
+      kind: "loadState",
+      expression: params.loadState
+    };
+  }
+  if (params.load) {
+    return {
+      kind: "load",
+      expression: "document.readyState"
+    };
+  }
+  throw new Error("browserWaitFor: no wait condition specified");
+}
+function buildVisibilityCheck(selector) {
+  const sel = JSON.stringify(selector);
+  return `(function() {
+    var el = document.querySelector(${sel});
+    if (!el) return false;
+    var style = window.getComputedStyle(el);
+    return style.display !== 'none' && style.visibility !== 'hidden' && el.offsetParent !== null;
+  })()`;
+}
+async function evaluateCondition(cdp, condition) {
+  if (condition.kind === "url") {
+    return evaluateUrlCondition(cdp, condition.expression);
+  }
+  if (condition.kind === "load") {
+    return evaluateLoadCondition(cdp, condition.expression);
+  }
+  if (condition.kind === "loadState") {
+    return evaluateLoadStateCondition(cdp, condition.expression);
+  }
+  if (condition.kind === "selectorHidden") {
+    const response2 = await cdp.send("Runtime.evaluate", {
+      expression: condition.expression,
+      returnByValue: true
+    });
+    return response2.result.value === false;
+  }
+  if (condition.kind === "selector") {
+    const response2 = await cdp.send("Runtime.evaluate", {
+      expression: condition.expression,
+      returnByValue: true
+    });
+    return response2.result.value !== null && response2.result.subtype !== "null";
+  }
+  const response = await cdp.send("Runtime.evaluate", {
+    expression: condition.expression,
+    returnByValue: true
+  });
+  return response.result.value === true;
+}
+async function evaluateLoadCondition(cdp, expression) {
+  const response = await cdp.send("Runtime.evaluate", {
+    expression,
+    returnByValue: true
+  });
+  if (response.result.type === "string") {
+    return response.result.value === "complete";
+  }
+  return response.result.value === true;
+}
+async function evaluateLoadStateCondition(cdp, targetState) {
+  const response = await cdp.send("Runtime.evaluate", {
+    expression: "document.readyState",
+    returnByValue: true
+  });
+  const current = response.result.value;
+  if (targetState === "complete") {
+    return current === "complete";
+  }
+  if (targetState === "interactive") {
+    return current === "interactive" || current === "complete";
+  }
+  return current === targetState;
+}
+async function evaluateUrlCondition(cdp, pattern) {
+  const response = await cdp.send("Runtime.evaluate", {
+    expression: "location.href",
+    returnByValue: true
+  });
+  const currentUrl = response.result.value;
+  return globMatch(pattern, currentUrl);
+}
+function globMatch(pattern, value) {
+  const regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\0").replace(/\*/g, "[^/]*").replace(/\u0000/g, ".*").replace(/\?/g, ".");
+  const regex = new RegExp(regexStr);
+  return regex.test(value);
+}
+function describeCondition(params) {
+  if (params.text) return `text "${params.text}" to appear`;
+  if (params.textGone) return `text "${params.textGone}" to disappear`;
+  if (params.selector && params.state === "hidden")
+    return `selector "${params.selector}" to become hidden`;
+  if (params.selector && params.visible)
+    return `selector "${params.selector}" to become visible`;
+  if (params.selector) return `selector "${params.selector}" to appear`;
+  if (params.url) return `URL matching "${params.url}"`;
+  if (params.fn) return `JS condition: ${params.fn}`;
+  if (params.loadState) return `document.readyState === "${params.loadState}"`;
+  if (params.networkIdle) return "network idle";
+  if (params.load) return "page load complete";
+  return "unknown condition";
+}
+function delay4(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/tools/browser-drag.ts
+var REF_PATTERN3 = /^@?e(\d+)$/;
+function calculateCenter3(content) {
+  const x = (content[0] + content[2] + content[4] + content[6]) / 4;
+  const y = (content[1] + content[3] + content[5] + content[7]) / 4;
+  return { x: Math.round(x), y: Math.round(y) };
+}
+async function resolveRefCoordinates(cdp, ref) {
+  const match = REF_PATTERN3.exec(ref);
+  if (!match) {
+    throw new Error(`Invalid ref format: ${ref}`);
+  }
+  const backendNodeId = parseInt(match[1], 10);
+  const opts = { timeout: 5e3 };
+  await cdp.send("DOM.resolveNode", {
+    backendNodeId
+  }, opts);
+  try {
+    await cdp.send("DOM.scrollIntoViewIfNeeded", {
+      backendNodeId
+    }, opts);
+  } catch {
+  }
+  const boxResponse = await cdp.send("DOM.getBoxModel", {
+    backendNodeId
+  }, opts);
+  return calculateCenter3(boxResponse.model.content);
+}
+function delay5(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function interpolatePoints(startX, startY, endX, endY, steps = 8) {
+  const points = [];
+  for (let i = 1; i < steps; i++) {
+    const t = i / steps;
+    points.push({
+      x: Math.round(startX + (endX - startX) * t),
+      y: Math.round(startY + (endY - startY) * t)
+    });
+  }
+  return points;
+}
+async function browserDrag(cdp, params) {
+  let startX;
+  let startY;
+  if (params.startX !== void 0 && params.startY !== void 0) {
+    startX = params.startX;
+    startY = params.startY;
+  } else if (params.startRef) {
+    const coords = await resolveRefCoordinates(cdp, params.startRef);
+    startX = coords.x;
+    startY = coords.y;
+  } else {
+    throw new Error("Either startRef or startX/startY must be provided");
+  }
+  let endX;
+  let endY;
+  if (params.endX !== void 0 && params.endY !== void 0) {
+    endX = params.endX;
+    endY = params.endY;
+  } else if (params.endRef) {
+    const coords = await resolveRefCoordinates(cdp, params.endRef);
+    endX = coords.x;
+    endY = coords.y;
+  } else {
+    throw new Error("Either endRef or endX/endY must be provided");
+  }
+  const mouseOpts = { timeout: 3e3 };
+  await cdp.send("Input.dispatchMouseEvent", {
+    type: "mouseMoved",
+    x: startX,
+    y: startY
+  }, mouseOpts);
+  await cdp.send("Input.dispatchMouseEvent", {
+    type: "mousePressed",
+    x: startX,
+    y: startY,
+    button: "left",
+    clickCount: 1
+  }, mouseOpts);
+  const intermediatePoints = interpolatePoints(startX, startY, endX, endY, 4);
+  for (const point of intermediatePoints) {
+    await cdp.send("Input.dispatchMouseEvent", {
+      type: "mouseMoved",
+      x: point.x,
+      y: point.y
+    }, mouseOpts);
+    await delay5(10);
+  }
+  await cdp.send("Input.dispatchMouseEvent", {
+    type: "mouseMoved",
+    x: endX,
+    y: endY
+  }, mouseOpts);
+  await cdp.send("Input.dispatchMouseEvent", {
+    type: "mouseReleased",
+    x: endX,
+    y: endY,
+    button: "left",
+    clickCount: 1
+  }, mouseOpts);
+  return { success: true };
+}
+
+// src/tools/browser-handle-dialog.ts
+async function browserHandleDialog(cdp, params) {
+  const dialogParams = {
+    accept: params.accept
+  };
+  if (params.promptText !== void 0) {
+    dialogParams.promptText = params.promptText;
+  }
+  try {
+    await cdp.send("Page.handleJavaScriptDialog", dialogParams);
+    return { success: true };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.includes("No dialog is showing") || message.includes("no dialog")) {
+      return {
+        success: false,
+        error: "No JavaScript dialog is currently pending. A dialog must be open before it can be handled."
+      };
+    }
+    return {
+      success: false,
+      error: `Failed to handle dialog: ${message}`
+    };
+  }
+}
+
+// src/tools/browser-file-upload.ts
+var REF_PATTERN4 = /^@e(\d+)$/;
+async function browserFileUpload(cdp, params) {
+  const match = REF_PATTERN4.exec(params.ref);
+  if (!match) {
+    return {
+      success: false,
+      filesCount: 0,
+      error: `Invalid ref format: ${params.ref}. Expected @eN pattern (e.g. @e5).`
+    };
+  }
+  const backendNodeId = parseInt(match[1], 10);
+  const resolved = await cdp.send("DOM.resolveNode", {
+    backendNodeId
+  });
+  const objectId = resolved.object.objectId;
+  await cdp.send("DOM.setFileInputFiles", {
+    files: params.paths,
+    objectId
+  });
+  return {
+    success: true,
+    filesCount: params.paths.length
+  };
+}
+
+// src/event-buffer.ts
+var EventBuffer = class {
+  _buffer;
+  _capacity;
+  _head;
+  // next write index
+  _size;
+  _totalPushed;
+  constructor(capacity = 500) {
+    this._capacity = capacity;
+    this._buffer = new Array(capacity);
+    this._head = 0;
+    this._size = 0;
+    this._totalPushed = 0;
+  }
+  /** Append an event, evicting the oldest if at capacity. */
+  push(event) {
+    this._buffer[this._head] = event;
+    this._head = (this._head + 1) % this._capacity;
+    if (this._size < this._capacity) {
+      this._size++;
+    }
+    this._totalPushed++;
+  }
+  /**
+   * Return the last `n` events in chronological (oldest-first) order.
+   * Defaults to all events when `n` is omitted.
+   */
+  last(n) {
+    const count = n === void 0 ? this._size : Math.min(n, this._size);
+    if (count === 0) return [];
+    const result = new Array(count);
+    let start = (this._head - count + this._capacity) % this._capacity;
+    for (let i = 0; i < count; i++) {
+      result[i] = this._buffer[(start + i) % this._capacity];
+    }
+    return result;
+  }
+  /** Remove all events from the buffer. */
+  clear() {
+    this._buffer = new Array(this._capacity);
+    this._head = 0;
+    this._size = 0;
+  }
+  /**
+   * Return the last `n` events AND remove them from the buffer.
+   * Defaults to all events when `n` is omitted.
+   */
+  drain(n) {
+    const events = this.last(n);
+    this.clear();
+    return events;
+  }
+  /** Current number of events stored. */
+  get size() {
+    return this._size;
+  }
+  /** Maximum number of events this buffer can hold. */
+  get capacity() {
+    return this._capacity;
+  }
+  /** Total number of events ever pushed (including evicted ones). */
+  get totalPushed() {
+    return this._totalPushed;
+  }
+  /** Return events matching `predicate` without modifying the buffer. */
+  filter(predicate) {
+    return this.last().filter(predicate);
+  }
+  /** Snapshot of buffer statistics. */
+  get stats() {
+    return {
+      size: this._size,
+      capacity: this._capacity,
+      totalPushed: this._totalPushed,
+      evicted: this._totalPushed - this._size
+    };
+  }
+};
+
+// src/redactor.ts
+var JWT_PATTERN = /eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+/g;
+var BEARER_PATTERN = /Bearer\s+\S+/gi;
+var REDACTED = "[REDACTED]";
+var REDACTED_JWT = "[REDACTED_JWT]";
+function redactInlineSecrets(text, opts) {
+  if (opts?.enabled === false) {
+    return text;
+  }
+  let result = text.replace(JWT_PATTERN, REDACTED_JWT);
+  result = result.replace(BEARER_PATTERN, (match) => {
+    const bearerWord = match.split(/\s+/)[0];
+    return `${bearerWord} ${REDACTED}`;
+  });
+  return result;
+}
+
+// src/tools/browser-network-requests.ts
+var STATIC_TYPES = /* @__PURE__ */ new Set([
+  "Image",
+  "Stylesheet",
+  "Font",
+  "Script",
+  "Media"
+]);
+var networkBuffer = new EventBuffer(500);
+var pendingRequests = /* @__PURE__ */ new Map();
+function setupNetworkCapture(cdp) {
+  cdp.on("Network.requestWillBeSent", (params) => {
+    const p = params;
+    const entry = {
+      requestId: p.requestId,
+      url: p.request.url,
+      method: p.request.method,
+      type: p.type ?? "Other",
+      timestamp: p.timestamp ? Math.floor(p.timestamp * 1e3) : Date.now()
+    };
+    pendingRequests.set(p.requestId, entry);
+    networkBuffer.push(entry);
+  });
+  cdp.on("Network.responseReceived", (params) => {
+    const p = params;
+    const entry = pendingRequests.get(p.requestId);
+    if (entry) {
+      entry.status = p.response.status;
+      pendingRequests.delete(p.requestId);
+    }
+  });
+}
+function resetNetworkBuffer() {
+  networkBuffer.clear();
+  pendingRequests.clear();
+}
+async function browserNetworkRequests(_cdp, params) {
+  let entries = networkBuffer.last();
+  if (!params.includeStatic) {
+    entries = entries.filter((e) => !STATIC_TYPES.has(e.type));
+  }
+  if (params.filter) {
+    const filterLower = params.filter.toLowerCase();
+    entries = entries.filter((e) => e.url.toLowerCase().includes(filterLower));
+  }
+  const limit = params.limit ?? 100;
+  entries = entries.slice(0, limit);
+  const requests = entries.map((e) => ({
+    url: redactInlineSecrets(e.url),
+    method: e.method,
+    status: e.status,
+    type: e.type
+  }));
+  return { requests };
+}
+
+// src/tools/browser-console-messages.ts
+var SUPPORTED_LEVELS = /* @__PURE__ */ new Set(["log", "warn", "warning", "error", "info"]);
+var consoleBuffer = new EventBuffer(500);
+function setupConsoleCapture(cdp) {
+  cdp.on("Runtime.consoleAPICalled", (params) => {
+    const p = params;
+    if (!SUPPORTED_LEVELS.has(p.type)) return;
+    const text = (p.args ?? []).map((arg) => {
+      if (arg.type === "string") return String(arg.value);
+      if (arg.type === "undefined") return "undefined";
+      if (arg.value !== void 0) return String(arg.value);
+      if (arg.description) return arg.description;
+      return "";
+    }).join(" ");
+    consoleBuffer.push({
+      level: p.type === "warning" ? "warn" : p.type,
+      text,
+      timestamp: p.timestamp ? Math.floor(p.timestamp) : Date.now()
+    });
+  });
+}
+function resetConsoleBuffer() {
+  consoleBuffer.clear();
+}
+async function browserConsoleMessages(_cdp, params) {
+  let messages = consoleBuffer.last();
+  messages = messages.map((m) => ({ ...m, text: redactInlineSecrets(m.text) }));
+  if (params.level) {
+    messages = messages.filter((m) => m.level === params.level);
+  }
+  const limit = params.limit ?? 100;
+  if (messages.length > limit) {
+    messages = messages.slice(-limit);
+  }
+  return { messages };
+}
+
+// src/tools/browser-annotated-screenshot.ts
+async function browserAnnotatedScreenshot(cdp, params) {
+  const result = await browserScreenshot(cdp, {
+    annotate: true,
+    selector: params.selector
+  });
+  return {
+    base64: result.base64,
+    annotations: result.annotations ?? []
+  };
+}
+
+// src/tools/browser-inspect-source.ts
+var REF_PATTERN5 = /^@?e(\d+)$/;
+async function browserInspectSource(cdp, params) {
+  let objectId;
+  if (params.ref) {
+    const match = REF_PATTERN5.exec(params.ref);
+    if (!match) throw new Error(`Invalid ref format: ${params.ref}`);
+    const backendNodeId = parseInt(match[1], 10);
+    const resolved = await cdp.send("DOM.resolveNode", { backendNodeId });
+    objectId = resolved.object.objectId;
+  } else if (params.selector) {
+    const evalResult = await cdp.send("Runtime.evaluate", {
+      expression: `document.querySelector(${JSON.stringify(params.selector)})`,
+      returnByValue: false
+    });
+    if (!evalResult.result.objectId || evalResult.result.subtype === "null") {
+      throw new Error(`Element not found: ${params.selector}`);
+    }
+    objectId = evalResult.result.objectId;
+  } else {
+    throw new Error("Either ref or selector must be provided");
+  }
+  const cdpResult = await cdp.send("Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration: `function() {
+      var el = this;
+      var tagName = (el.tagName || '').toLowerCase();
+
+      // Find React Fiber
+      var fiberKey = Object.keys(el).find(function(k) { return k.startsWith('__reactFiber'); });
+
+      // Also check Vue, Svelte
+      var vueComp = el.__vueParentComponent;
+      var svelteMeta = el.__svelte_meta;
+
+      if (!fiberKey && !vueComp && !svelteMeta) {
+        return JSON.stringify({ tagName: tagName, componentName: null, source: null, stack: [], framework: null });
+      }
+
+      // --- React path ---
+      if (fiberKey) {
+        var fiber = el[fiberKey];
+        var stack = [];
+        var current = fiber;
+        var firstSource = null;
+        var firstName = null;
+
+        while (current && stack.length < 15) {
+          if (typeof current.type === 'function' && current.type.name) {
+            var fn = current.type;
+            var fnStr = fn.toString();
+            var fileName = null;
+            var lineNumber = null;
+            var columnNumber = null;
+
+            // Parse jsxDEV calls for embedded fileName/lineNumber
+            var fileMatch = fnStr.match(/fileName:\\s*"([^"]+)"/);
+            if (fileMatch) {
+              fileName = fileMatch[1];
+              var lineMatch = fnStr.match(/lineNumber:\\s*(\\d+)/);
+              if (lineMatch) lineNumber = parseInt(lineMatch[1]);
+              var colMatch = fnStr.match(/columnNumber:\\s*(\\d+)/);
+              if (colMatch) columnNumber = parseInt(colMatch[1]);
+            }
+
+            var entry = {
+              filePath: fileName,
+              lineNumber: lineNumber,
+              columnNumber: columnNumber,
+              componentName: fn.name
+            };
+
+            stack.push(entry);
+
+            if (fileName && !firstSource) {
+              firstSource = entry;
+            }
+            if (!firstName && fn.name.length > 1) {
+              firstName = fn.name;
+            }
+          }
+          current = current.return;
+        }
+
+        return JSON.stringify({
+          tagName: tagName,
+          componentName: firstName || null,
+          source: firstSource || (stack.length > 0 ? { filePath: null, lineNumber: null, columnNumber: null, componentName: stack[0].componentName } : null),
+          stack: stack.filter(function(s) { return s.filePath; }),
+          framework: 'react'
+        });
+      }
+
+      // --- Svelte path ---
+      if (svelteMeta) {
+        var loc = svelteMeta.loc || {};
+        return JSON.stringify({
+          tagName: tagName,
+          componentName: loc.char ? null : (svelteMeta.component || null),
+          source: loc.file ? { filePath: loc.file, lineNumber: loc.line || null, columnNumber: (loc.column || 0) + 1, componentName: null } : null,
+          stack: [],
+          framework: 'svelte'
+        });
+      }
+
+      // --- Vue path ---
+      if (vueComp) {
+        var comp = vueComp;
+        var vueName = comp.type?.__name || comp.type?.name || null;
+        var vueFile = comp.type?.__file || null;
+        return JSON.stringify({
+          tagName: tagName,
+          componentName: vueName,
+          source: vueFile ? { filePath: vueFile, lineNumber: null, columnNumber: null, componentName: vueName } : null,
+          stack: [],
+          framework: 'vue'
+        });
+      }
+
+      return JSON.stringify({ tagName: tagName, componentName: null, source: null, stack: [], framework: null });
+    }`,
+    returnByValue: true
+  });
+  return JSON.parse(cdpResult.result.value);
+}
+
+// src/tools/browser-intercept.ts
+var activeRoutes = /* @__PURE__ */ new Map();
+var activeAborts = /* @__PURE__ */ new Map();
+var fetchEnabled = false;
+var handlerAttached = false;
+function matchGlob(pattern, url) {
+  const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "___DOUBLESTAR___").replace(/\*/g, "[^/]*").replace(/___DOUBLESTAR___/g, ".*");
+  return new RegExp(`^${regex}$`).test(url);
+}
+async function syncFetchPatterns(cdp) {
+  const patterns = [
+    ...Array.from(activeRoutes.keys()),
+    ...Array.from(activeAborts.keys())
+  ].map((p) => ({ urlPattern: p }));
+  if (patterns.length === 0) {
+    if (fetchEnabled) {
+      await cdp.send("Fetch.disable");
+      fetchEnabled = false;
+    }
+    return;
+  }
+  await cdp.send("Fetch.enable", { patterns });
+  fetchEnabled = true;
+  if (!handlerAttached) {
+    cdp.on("Fetch.requestPaused", async (params) => {
+      const url = params.request.url;
+      const requestId = params.requestId;
+      try {
+        for (const [pattern] of activeAborts) {
+          if (matchGlob(pattern, url)) {
+            await cdp.send("Fetch.failRequest", {
+              requestId,
+              reason: "BlockedByClient"
+            });
+            return;
+          }
+        }
+        for (const [pattern, rule] of activeRoutes) {
+          if (matchGlob(pattern, url)) {
+            const responseHeaders = Object.entries(rule.headers).map(
+              ([name, value]) => ({ name, value })
+            );
+            await cdp.send("Fetch.fulfillRequest", {
+              requestId,
+              responseCode: rule.status,
+              body: btoa(rule.body),
+              responseHeaders
+            });
+            return;
+          }
+        }
+        await cdp.send("Fetch.continueRequest", { requestId });
+      } catch {
+      }
+    });
+    handlerAttached = true;
+  }
+}
+async function browserRoute(cdp, params) {
+  const body = typeof params.body === "object" && params.body !== null ? JSON.stringify(params.body) : String(params.body);
+  const status = params.status ?? 200;
+  const headers = params.headers ?? { "Content-Type": "application/json" };
+  const rule = {
+    urlPattern: params.url,
+    body,
+    status,
+    headers
+  };
+  activeRoutes.set(params.url, rule);
+  await syncFetchPatterns(cdp);
+  return {
+    url: params.url,
+    status,
+    activeRoutes: activeRoutes.size
+  };
+}
+async function browserAbort(cdp, params) {
+  const rule = {
+    urlPattern: params.url
+  };
+  activeAborts.set(params.url, rule);
+  await syncFetchPatterns(cdp);
+  return {
+    url: params.url,
+    activeAborts: activeAborts.size
+  };
+}
+async function browserUnroute(cdp, params) {
+  let removed = 0;
+  if (params.all) {
+    removed = activeRoutes.size + activeAborts.size;
+    activeRoutes.clear();
+    activeAborts.clear();
+  } else if (params.url) {
+    if (activeRoutes.delete(params.url)) removed++;
+    if (activeAborts.delete(params.url)) removed++;
+  }
+  await syncFetchPatterns(cdp);
+  return {
+    removed,
+    remaining: activeRoutes.size + activeAborts.size
+  };
+}
+
+// src/tools/browser-find.ts
+async function browserFind(cdp, params) {
+  const nth = params.nth ?? 0;
+  const response = await cdp.send("Accessibility.getFullAXTree", void 0, {
+    timeout: 1e4
+  });
+  const matches = response.nodes.filter((node) => {
+    if (params.role) {
+      const nodeRole = node.role?.value ?? "";
+      if (nodeRole.toLowerCase() !== params.role.toLowerCase()) {
+        return false;
+      }
+    }
+    if (params.name) {
+      const nodeName = node.name?.value ?? "";
+      if (!nodeName.includes(params.name)) {
+        return false;
+      }
+    }
+    if (params.text) {
+      const nodeName = node.name?.value ?? "";
+      if (!nodeName.includes(params.text)) {
+        return false;
+      }
+    }
+    return true;
+  });
+  const count = matches.length;
+  if (nth >= count || count === 0) {
+    return {
+      found: false,
+      ref: null,
+      role: null,
+      name: null,
+      count
+    };
+  }
+  const match = matches[nth];
+  const ref = match.backendDOMNodeId ? `@e${match.backendDOMNodeId}` : null;
+  return {
+    found: true,
+    ref,
+    role: match.role?.value ?? null,
+    name: match.name?.value ?? null,
+    count
+  };
+}
+
+// src/tools/browser-diff.ts
+async function captureScreenshot(cdp, selector) {
+  const captureParams = { format: "png" };
+  if (selector) {
+    const doc = await cdp.send("DOM.getDocument", {});
+    const queryResult = await cdp.send("DOM.querySelector", {
+      nodeId: doc.root.nodeId,
+      selector
+    });
+    if (!queryResult.nodeId) {
+      throw new Error(`Element not found: ${selector}`);
+    }
+    const boxModel = await cdp.send("DOM.getBoxModel", {
+      nodeId: queryResult.nodeId
+    });
+    const content = boxModel.model.content;
+    captureParams.clip = {
+      x: content[0],
+      y: content[1],
+      width: content[2] - content[0],
+      height: content[5] - content[1],
+      scale: 1
+    };
+  }
+  const screenshot = await cdp.send(
+    "Page.captureScreenshot",
+    captureParams
+  );
+  return screenshot.data;
+}
+function buildComparisonExpression(threshold) {
+  return [
+    "(async () => {",
+    "  const beforeSrc = window._diffBefore;",
+    "  const afterSrc = window._diffAfter;",
+    "",
+    "  const loadImg = (src) => new Promise((res, rej) => {",
+    "    const img = new Image();",
+    "    img.onload = () => res(img);",
+    "    img.onerror = (e) => rej(new Error('Failed to load image'));",
+    "    img.src = src;",
+    "  });",
+    "",
+    "  const img1 = await loadImg('data:image/png;base64,' + beforeSrc);",
+    "  const img2 = await loadImg('data:image/png;base64,' + afterSrc);",
+    "",
+    "  const w = Math.max(img1.width, img2.width);",
+    "  const h = Math.max(img1.height, img2.height);",
+    "",
+    "  const c1 = document.createElement('canvas');",
+    "  c1.width = w; c1.height = h;",
+    "  const ctx1 = c1.getContext('2d');",
+    "  ctx1.drawImage(img1, 0, 0);",
+    "",
+    "  const c2 = document.createElement('canvas');",
+    "  c2.width = w; c2.height = h;",
+    "  const ctx2 = c2.getContext('2d');",
+    "  ctx2.drawImage(img2, 0, 0);",
+    "",
+    "  const d1 = ctx1.getImageData(0, 0, w, h).data;",
+    "  const d2 = ctx2.getImageData(0, 0, w, h).data;",
+    "",
+    "  const diff = document.createElement('canvas');",
+    "  diff.width = w; diff.height = h;",
+    "  const dCtx = diff.getContext('2d');",
+    "  dCtx.drawImage(img2, 0, 0);",
+    "  const dData = dCtx.getImageData(0, 0, w, h);",
+    "",
+    "  let diffCount = 0;",
+    "  const threshold = " + threshold + ";",
+    "  for (let i = 0; i < d1.length; i += 4) {",
+    "    const dr = Math.abs(d1[i] - d2[i]);",
+    "    const dg = Math.abs(d1[i+1] - d2[i+1]);",
+    "    const db = Math.abs(d1[i+2] - d2[i+2]);",
+    "    if (dr > threshold || dg > threshold || db > threshold) {",
+    "      diffCount++;",
+    "      dData.data[i] = 255;",
+    "      dData.data[i+1] = 0;",
+    "      dData.data[i+2] = 0;",
+    "      dData.data[i+3] = 200;",
+    "    }",
+    "  }",
+    "",
+    "  dCtx.putImageData(dData, 0, 0);",
+    "  const diffBase64 = diff.toDataURL('image/png').split(',')[1];",
+    "",
+    "  const total = w * h;",
+    "  return JSON.stringify({",
+    "    diffPercentage: parseFloat((diffCount / total * 100).toFixed(4)),",
+    "    totalPixels: total,",
+    "    diffPixels: diffCount,",
+    "    identical: (diffCount / total) < 0.001,",
+    "    diffImage: diffBase64,",
+    "    width: w,",
+    "    height: h",
+    "  });",
+    "})()"
+  ].join("\n");
+}
+async function browserDiff(cdp, params) {
+  const threshold = params.threshold ?? 30;
+  let beforeBase64;
+  if (params.before === "current") {
+    beforeBase64 = await captureScreenshot(cdp, params.selector);
+  } else {
+    beforeBase64 = params.before;
+  }
+  let afterBase64;
+  if (!params.after || params.after === "current") {
+    afterBase64 = await captureScreenshot(cdp, params.selector);
+  } else {
+    afterBase64 = params.after;
+  }
+  await cdp.send("Runtime.evaluate", {
+    expression: "window._diffBefore = " + JSON.stringify(beforeBase64) + ";",
+    returnByValue: true
+  });
+  await cdp.send("Runtime.evaluate", {
+    expression: "window._diffAfter = " + JSON.stringify(afterBase64) + ";",
+    returnByValue: true
+  });
+  const result = await cdp.send("Runtime.evaluate", {
+    expression: buildComparisonExpression(threshold),
+    awaitPromise: true,
+    returnByValue: true
+  });
+  if (result.exceptionDetails) {
+    throw new Error(
+      "Diff comparison failed: " + result.exceptionDetails.text
+    );
+  }
+  await cdp.send("Runtime.evaluate", {
+    expression: "delete window._diffBefore; delete window._diffAfter;",
+    returnByValue: true
+  });
+  return JSON.parse(result.result.value);
+}
+
+// src/tools/browser-session-state.ts
+import { writeFileSync, readFileSync as readFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+function getStatesDir() {
+  return join2(homedir2(), ".browsirai", "states");
+}
+function ensureStatesDir() {
+  const dir = getStatesDir();
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  return dir;
+}
+function getStatePath(name) {
+  return join2(getStatesDir(), `${name}.json`);
+}
+async function browserSaveState(cdp, params) {
+  const { name } = params;
+  const cookieResponse = await cdp.send("Network.getAllCookies");
+  const cookies = cookieResponse.cookies ?? [];
+  const urlResponse = await cdp.send("Runtime.evaluate", {
+    expression: "window.location.href",
+    returnByValue: true
+  });
+  const url = urlResponse.result.value ?? "";
+  const localStorageResponse = await cdp.send("Runtime.evaluate", {
+    expression: "JSON.stringify(Object.entries(localStorage))",
+    returnByValue: true
+  });
+  const localStorageEntries = JSON.parse(
+    localStorageResponse.result.value ?? "[]"
+  );
+  const localStorage = Object.fromEntries(localStorageEntries);
+  const sessionStorageResponse = await cdp.send("Runtime.evaluate", {
+    expression: "JSON.stringify(Object.entries(sessionStorage))",
+    returnByValue: true
+  });
+  const sessionStorageEntries = JSON.parse(
+    sessionStorageResponse.result.value ?? "[]"
+  );
+  const sessionStorage = Object.fromEntries(sessionStorageEntries);
+  const dir = ensureStatesDir();
+  const filePath = join2(dir, `${name}.json`);
+  const stateFile = {
+    version: 1,
+    savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    url,
+    cookies,
+    localStorage,
+    sessionStorage
+  };
+  writeFileSync(filePath, JSON.stringify(stateFile, null, 2), "utf-8");
+  return {
+    name,
+    path: filePath,
+    cookies: cookies.length,
+    localStorage: localStorageEntries.length,
+    sessionStorage: sessionStorageEntries.length
+  };
+}
+async function browserLoadState(cdp, params) {
+  const { name, url: customUrl } = params;
+  const filePath = getStatePath(name);
+  if (!existsSync2(filePath)) {
+    throw new Error(`State file not found: ${filePath}`);
+  }
+  const stateFile = JSON.parse(readFileSync2(filePath, "utf-8"));
+  const targetUrl = customUrl ?? stateFile.url;
+  if (targetUrl) {
+    await cdp.send("Page.enable");
+    await cdp.send("Page.navigate", { url: targetUrl });
+  }
+  if (stateFile.cookies.length > 0) {
+    await cdp.send("Network.setCookies", { cookies: stateFile.cookies });
+  }
+  const localEntries = Object.entries(stateFile.localStorage);
+  if (localEntries.length > 0) {
+    const localScript = localEntries.map(([k, v]) => `localStorage.setItem(${JSON.stringify(k)}, ${JSON.stringify(v)})`).join(";");
+    await cdp.send("Runtime.evaluate", {
+      expression: localScript,
+      returnByValue: true
+    });
+  }
+  const sessionEntries = Object.entries(stateFile.sessionStorage);
+  if (sessionEntries.length > 0) {
+    const sessionScript = sessionEntries.map(([k, v]) => `sessionStorage.setItem(${JSON.stringify(k)}, ${JSON.stringify(v)})`).join(";");
+    await cdp.send("Runtime.evaluate", {
+      expression: sessionScript,
+      returnByValue: true
+    });
+  }
+  await cdp.send("Page.reload");
+  return {
+    name,
+    cookies: stateFile.cookies.length,
+    localStorage: localEntries.length,
+    sessionStorage: sessionEntries.length
+  };
+}
+
+// src/tools/index.ts
+var browserCdp = null;
+var activeSessionId = null;
+var SessionCDP = class {
+  constructor(conn, sessionId) {
+    this.conn = conn;
+    this.sessionId = sessionId;
+  }
+  get isConnected() {
+    return this.conn.isConnected;
+  }
+  send(method, params, options) {
+    return this.conn.send(method, params, {
+      ...options,
+      sessionId: options?.sessionId ?? this.sessionId
+    });
+  }
+  on(event, handler) {
+    this.conn.on(event, handler);
+  }
+  off(event, handler) {
+    this.conn.off(event, handler);
+  }
+  close() {
+  }
+};
+var headlessMode = process.env.BROWSIR_HEADLESS === "1" || process.env.BROWSIR_HEADLESS === "true";
+function attachLifecycleListeners(conn) {
+  const resetState = () => {
+    browserCdp = null;
+    activeSessionId = null;
+    resetConsoleBuffer();
+    resetNetworkBuffer();
+  };
+  conn.on("reconnectionFailed", resetState);
+  conn.on("browserCrashed", resetState);
+}
+async function getCDP() {
+  if (browserCdp?.isConnected && activeSessionId) {
+    return new SessionCDP(browserCdp, activeSessionId);
+  }
+  if (headlessMode) {
+    const launch = await launchHeadlessChrome();
+    if (!launch.success) {
+      throw new Error(launch.error ?? "Failed to launch headless Chrome.");
+    }
+    const wsUrl2 = launch.wsEndpoint ?? `ws://127.0.0.1:${launch.port}/devtools/browser`;
+    browserCdp = new CDPConnection(wsUrl2);
+    await browserCdp.connect();
+    attachLifecycleListeners(browserCdp);
+    const targets2 = await browserCdp.send("Target.getTargets");
+    let page2 = targets2.targetInfos.find((t) => t.type === "page");
+    if (!page2) {
+      const created = await browserCdp.send("Target.createTarget", { url: "about:blank" });
+      page2 = { targetId: created.targetId, type: "page", url: "about:blank", title: "" };
+    }
+    const attached2 = await browserCdp.send("Target.attachToTarget", {
+      targetId: page2.targetId,
+      flatten: true
+    });
+    activeSessionId = attached2.sessionId;
+    const session2 = new SessionCDP(browserCdp, activeSessionId);
+    await Promise.all([
+      session2.send("Network.enable"),
+      session2.send("Runtime.enable"),
+      session2.send("Page.enable")
+    ]).catch(() => {
+    });
+    setupConsoleCapture(session2);
+    setupNetworkCapture(session2);
+    return session2;
+  }
+  const connection = await connectChrome({ autoLaunch: true });
+  if (!connection.success) {
+    throw new Error(
+      connection.error ?? "Cannot connect to Chrome. Run `browsirai doctor` to set up."
+    );
+  }
+  const wsUrl = connection.wsEndpoint ?? `ws://127.0.0.1:${connection.port}/devtools/browser`;
+  browserCdp = new CDPConnection(wsUrl);
+  await browserCdp.connect();
+  attachLifecycleListeners(browserCdp);
+  const targets = await browserCdp.send("Target.getTargets");
+  let page = targets.targetInfos.find(
+    (t) => t.type === "page" && !t.url.startsWith("chrome://")
+  ) ?? targets.targetInfos.find(
+    (t) => t.type === "page"
+  );
+  if (!page) {
+    const created = await browserCdp.send("Target.createTarget", { url: "about:blank" });
+    page = { targetId: created.targetId, type: "page", url: "about:blank", title: "" };
+  }
+  const attached = await browserCdp.send("Target.attachToTarget", {
+    targetId: page.targetId,
+    flatten: true
+  });
+  activeSessionId = attached.sessionId;
+  const session = new SessionCDP(browserCdp, activeSessionId);
+  await Promise.all([
+    session.send("Network.enable"),
+    session.send("Runtime.enable"),
+    session.send("Page.enable")
+  ]).catch(() => {
+  });
+  setupConsoleCapture(session);
+  setupNetworkCapture(session);
+  return session;
+}
+function textResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+function errorResult(msg) {
+  return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
+}
+var SKILL_SUMMARY = `Connected to Chrome via CDP.
+
+## browsirai \u2014 Quick Reference
+
+**Cost hierarchy (cheapest first):**
+1. \`browser_evaluate\` \u2014 JS expression for single values (~10 tokens). Use when you need one data point (count, text, attribute).
+2. \`browser_snapshot\` \u2014 accessibility tree with @eN refs (~500 tokens). Use for page understanding and interaction.
+3. \`browser_screenshot { visual: true }\` \u2014 full image (~10K tokens). ONLY for layout/colors/visual bugs.
+
+**Core workflow: snapshot \u2192 ref \u2192 interact \u2192 snapshot**
+
+1. \`browser_snapshot\` \u2014 get accessibility tree with @eN refs
+2. Use @eN refs with: \`browser_click\`, \`browser_fill_form\`, \`browser_hover\`, \`browser_type\`, \`browser_select_option\`, \`browser_drag\`, \`browser_inspect_source\`
+3. \`browser_snapshot\` \u2014 verify result (ALWAYS use this)
+
+**Cost optimization (enforced server-side):**
+- \`browser_screenshot\` without \`visual: true\` auto-returns snapshot text
+- For single data extraction: \`browser_evaluate\` > \`browser_snapshot\` (50x cheaper)
+- Reserve \`browser_screenshot { visual: true }\` for CSS/layout debugging only
+
+**Identity resolution (cookie-based, always-first):**
+- NEVER guess usernames. The browser has an active session \u2014 use it.
+- To find the logged-in user: \`browser_evaluate\` on the site (e.g. GitHub avatar menu, X profile link).
+- When asked "go to my profile/repo/account" \u2192 navigate to the site root first, extract identity from session, then proceed.
+- Cookie sync means the browser IS the user. Trust the session, not assumptions.
+
+**Key patterns:**
+- \`browser_fill_form\` clears existing value. Use \`browser_type\` to append.
+- \`browser_type\` with \`submit: true\` presses Enter after typing.
+- \`browser_wait_for\` \u2014 wait for text, selector, URL, or JS condition before proceeding.
+- \`browser_inspect_source\` \u2014 find source file, line, component name (React/Vue/Svelte, dev mode only).
+- \`browser_resize\` with \`preset: "reset"\` \u2014 restore native viewport.
+- Refs become stale after navigation or major DOM changes \u2014 take a new snapshot.
+- \`browser_evaluate\` cannot access cross-origin iframes \u2014 use \`browser_type\` instead.
+- \`browser_console_messages\` / \`browser_network_requests\` \u2014 check for errors after interactions.`;
+var toolHints = {
+  browser_navigate: "\n\n\u2192 Next: browser_evaluate for quick data extraction (~10 tokens), or browser_snapshot for page structure and @eN refs (~500 tokens).",
+  browser_navigate_back: "\n\n\u2192 Next: browser_snapshot to see updated page.",
+  browser_snapshot: "\n\n\u2192 Next: Use @eN refs with browser_click, browser_fill_form, browser_hover, browser_type, browser_select_option, browser_drag, or browser_inspect_source.",
+  browser_screenshot: "\n\n\u2192 Cost: This call was auto-optimized to snapshot text. For full image, pass { visual: true }. Prefer browser_snapshot (~500 tokens) over browser_screenshot (~10K tokens).",
+  browser_annotated_screenshot: "\n\n\u2192 Cost: ~12K tokens. Consider browser_snapshot { interactive: true } (~500 tokens) for same info as text.",
+  browser_click: "\n\n\u2192 Next: browser_snapshot to verify result. Refs may be stale after DOM changes.",
+  browser_fill_form: "\n\n\u2192 Next: browser_snapshot to verify. Note: fill_form clears existing value first.",
+  browser_type: "\n\n\u2192 Tip: Use submit: true to press Enter. Does NOT clear existing value (unlike fill_form).",
+  browser_press_key: "\n\n\u2192 Next: browser_snapshot to verify effect.",
+  browser_hover: "\n\n\u2192 Next: browser_snapshot to verify hover state. Use browser_screenshot { visual: true } only for visual hover effects.",
+  browser_drag: "\n\n\u2192 Next: browser_snapshot to verify drag result.",
+  browser_scroll: "\n\n\u2192 Next: browser_snapshot to see new viewport content.",
+  browser_select_option: "\n\n\u2192 Next: browser_snapshot to verify selection.",
+  browser_handle_dialog: "\n\n\u2192 Next: browser_snapshot to see page state after dialog.",
+  browser_file_upload: "\n\n\u2192 Next: browser_snapshot to verify upload.",
+  browser_wait_for: "\n\n\u2192 Next: browser_snapshot to see current page state.",
+  browser_resize: '\n\n\u2192 Next: browser_snapshot to verify viewport. Use browser_screenshot { visual: true } only to check visual layout. Use preset: "reset" to restore.',
+  browser_close: "\n\n\u2192 Next: browser_tabs to see remaining tabs.",
+  browser_evaluate: "\n\n\u2192 Tip: Cheapest tool (~10 tokens). Use for single data extraction (counts, text, attributes). Prefer browser_snapshot + @eN refs for DOM interaction. Cannot access cross-origin iframes.",
+  browser_html: "\n\n\u2192 Tip: Prefer browser_snapshot for structured page understanding with @eN refs.",
+  browser_tabs: "\n\n\u2192 Tip: Use browser_navigate to open a URL in current tab.",
+  browser_console_messages: '\n\n\u2192 Tip: Use level: "error" to filter for errors only.',
+  browser_network_requests: '\n\n\u2192 Tip: Use filter: "*api*" and includeStatic: false for API calls only.',
+  browser_inspect_source: "\n\n\u2192 Tip: Dev mode only. Use browser_snapshot first to get @eN refs for specific elements.",
+  browser_route: "\n\n\u2192 Tip: Use browser_network_requests to verify intercepted responses. Use browser_unroute to remove.",
+  browser_abort: "\n\n\u2192 Tip: Use browser_network_requests to verify blocked requests. Use browser_unroute to remove.",
+  browser_unroute: "\n\n\u2192 Tip: Use {all: true} to clear all intercepts at once.",
+  browser_find: "\n\n\u2192 Next: Use the @eN ref with browser_click, browser_fill_form, browser_hover, or browser_inspect_source.",
+  browser_diff: "\n\n\u2192 Tip: Use 'current' as before value to capture the page now. Make changes, then call again with the first result as before.",
+  browser_save_state: "\n\n\u2192 Tip: State saved to ~/.browsirai/states/. Use browser_load_state to restore later.",
+  browser_load_state: "\n\n\u2192 Next: browser_snapshot to see the restored page state.",
+  browser_connect: "",
+  // SKILL_SUMMARY is returned directly
+  browser_list: "\n\n\u2192 Tip: Use browser_connect to connect to a specific instance."
+};
+function appendHint(result, toolName) {
+  const hint = toolHints[toolName];
+  if (!hint) return result;
+  const lastTextIdx = result.content.findLastIndex((c) => c.type === "text");
+  if (lastTextIdx >= 0) {
+    result.content[lastTextIdx] = {
+      ...result.content[lastTextIdx],
+      text: (result.content[lastTextIdx].text ?? "") + hint
+    };
+  } else {
+    result.content.push({ type: "text", text: hint.trimStart() });
+  }
+  return result;
+}
+function coerceArgs(args) {
+  const out = {};
+  for (const [k, v] of Object.entries(args)) {
+    if (typeof v === "string") {
+      if (v === "true") {
+        out[k] = true;
+        continue;
+      }
+      if (v === "false") {
+        out[k] = false;
+        continue;
+      }
+      const n = Number(v);
+      if (v !== "" && !isNaN(n)) {
+        out[k] = n;
+        continue;
+      }
+    }
+    out[k] = v;
+  }
+  return out;
+}
+var browser_connect = z.object({
+  port: z.number().optional(),
+  host: z.string().optional(),
+  headless: z.boolean().optional()
+});
+var browser_tabs = z.object({
+  filter: z.string().optional()
+});
+var browser_snapshot = z.object({
+  selector: z.string().optional(),
+  compact: z.boolean().optional(),
+  interactive: z.boolean().optional(),
+  cursor: z.boolean().optional(),
+  depth: z.number().optional()
+});
+var browser_screenshot = z.object({
+  selector: z.string().optional(),
+  fullPage: z.boolean().optional(),
+  format: z.enum(["png", "jpeg"]).optional(),
+  quality: z.number().optional(),
+  annotate: z.boolean().optional(),
+  visual: z.boolean().optional()
+});
+var browser_click = z.object({
+  selector: z.string().optional(),
+  ref: z.string().optional(),
+  x: z.number().optional(),
+  y: z.number().optional(),
+  newTab: z.boolean().optional()
+}).refine(
+  (data) => {
+    if (data.selector) return true;
+    if (data.ref) return true;
+    if (data.x !== void 0 && data.y !== void 0) return true;
+    return false;
+  },
+  { message: "Must provide selector, ref, or both x and y coordinates" }
+);
+var browser_fill_form = z.object({
+  ref: z.string().optional(),
+  selector: z.string().optional(),
+  value: z.string()
+}).refine(
+  (data) => data.ref !== void 0 || data.selector !== void 0,
+  { message: "Must provide ref or selector" }
+);
+var browser_type = z.object({
+  text: z.string(),
+  ref: z.string().optional(),
+  slowly: z.boolean().optional(),
+  submit: z.boolean().optional()
+});
+var browser_press_key = z.object({
+  key: z.string()
+});
+var browser_navigate = z.object({
+  url: z.string(),
+  waitUntil: z.enum(["load", "domcontentloaded", "networkidle"]).optional()
+});
+var browser_navigate_back = z.object({
+  direction: z.enum(["back", "forward"]).optional()
+});
+var browser_evaluate = z.object({
+  expression: z.string(),
+  frameId: z.string().optional()
+});
+var browser_scroll = z.object({
+  direction: z.enum(["up", "down", "left", "right"]).optional(),
+  pixels: z.number().optional(),
+  selector: z.string().optional()
+});
+var browser_network_requests = z.object({
+  filter: z.string().optional(),
+  limit: z.number().optional(),
+  includeHeaders: z.boolean().optional(),
+  includeStatic: z.boolean().optional()
+});
+var browser_console_messages = z.object({
+  limit: z.number().optional(),
+  level: z.enum(["log", "warn", "error", "info"]).optional()
+});
+var browser_html = z.object({
+  selector: z.string().optional()
+});
+var browser_close = z.object({
+  targetId: z.string().optional(),
+  force: z.boolean().optional(),
+  closeAll: z.boolean().optional()
+});
+var browser_wait_for = z.object({
+  text: z.string().optional(),
+  textGone: z.string().optional(),
+  time: z.number().optional(),
+  timeout: z.number().optional(),
+  url: z.string().optional(),
+  fn: z.string().optional(),
+  selector: z.string().optional(),
+  state: z.string().optional(),
+  loadState: z.string().optional()
+});
+var browser_hover = z.object({
+  ref: z.string()
+});
+var browser_drag = z.object({
+  startRef: z.string(),
+  endRef: z.string()
+});
+var browser_select_option = z.object({
+  ref: z.string(),
+  values: z.array(z.string())
+});
+var browser_handle_dialog = z.object({
+  accept: z.boolean(),
+  promptText: z.string().optional()
+});
+var browser_file_upload = z.object({
+  ref: z.string(),
+  paths: z.array(z.string())
+});
+var browser_resize = z.object({
+  width: z.number().optional(),
+  height: z.number().optional(),
+  deviceScaleFactor: z.number().optional(),
+  preset: z.string().optional()
+}).refine(
+  (data) => {
+    if (data.preset) return true;
+    if (data.width !== void 0 && data.height !== void 0) return true;
+    return false;
+  },
+  { message: "Must provide both width and height together, or a preset" }
+);
+var browser_annotated_screenshot = z.object({
+  selector: z.string().optional()
+});
+var browser_inspect_source = z.object({
+  ref: z.string().optional(),
+  selector: z.string().optional()
+}).refine(
+  (data) => data.ref !== void 0 || data.selector !== void 0,
+  { message: "Must provide ref or selector" }
+);
+var browser_route = z.object({
+  url: z.string(),
+  body: z.string(),
+  status: z.number().optional(),
+  headers: z.record(z.string()).optional()
+});
+var browser_abort = z.object({
+  url: z.string()
+});
+var browser_unroute = z.object({
+  url: z.string().optional(),
+  all: z.boolean().optional()
+}).refine(
+  (data) => data.url || data.all,
+  { message: "Must provide url or all" }
+);
+var browser_find = z.object({
+  role: z.string().optional(),
+  name: z.string().optional(),
+  text: z.string().optional(),
+  nth: z.number().optional()
+}).refine(
+  (data) => data.role !== void 0 || data.name !== void 0 || data.text !== void 0,
+  { message: "Must provide at least one of role, name, or text" }
+);
+var browser_diff = z.object({
+  before: z.string(),
+  after: z.string().optional(),
+  selector: z.string().optional(),
+  threshold: z.number().optional()
+});
+var browser_save_state = z.object({
+  name: z.string()
+});
+var browser_load_state = z.object({
+  name: z.string(),
+  url: z.string().optional()
+});
+var browser_list = z.object({}).passthrough().optional().transform((val) => val ?? {});
+var schemas = {
+  browser_connect,
+  browser_tabs,
+  browser_snapshot,
+  browser_screenshot,
+  browser_click,
+  browser_fill_form,
+  browser_type,
+  browser_press_key,
+  browser_navigate,
+  browser_navigate_back,
+  browser_evaluate,
+  browser_scroll,
+  browser_network_requests,
+  browser_console_messages,
+  browser_html,
+  browser_close,
+  browser_wait_for,
+  browser_hover,
+  browser_drag,
+  browser_select_option,
+  browser_handle_dialog,
+  browser_file_upload,
+  browser_resize,
+  browser_annotated_screenshot,
+  browser_inspect_source,
+  browser_route,
+  browser_abort,
+  browser_unroute,
+  browser_find,
+  browser_diff,
+  browser_save_state,
+  browser_load_state,
+  browser_list
+};
+var descriptions = {
+  browser_connect: "Connect to a running browser instance via Chrome DevTools Protocol. Use headless: true to run in background without visible window. Use resync: true to force cookie re-sync (e.g. after switching Chrome profile).",
+  browser_tabs: "List open browser tabs, optionally filtered by title or URL",
+  browser_snapshot: "Capture an accessibility snapshot of the current page or a specific element. [~500 tokens, PREFERRED for page understanding]",
+  browser_screenshot: "Take a screenshot. Auto-returns snapshot text unless visual: true, fullPage: true, or selector is specified. [~10K tokens when image returned]",
+  browser_click: "Click an element identified by selector, ref, or coordinates",
+  browser_fill_form: "Fill a form field identified by ref or selector with a value",
+  browser_type: "Type text into the focused element or a specific ref",
+  browser_press_key: "Press a keyboard key or key combination",
+  browser_navigate: "Navigate to a URL",
+  browser_navigate_back: "Navigate back or forward in browser history",
+  browser_evaluate: "Evaluate a JavaScript expression in the page context",
+  browser_scroll: "Scroll the page or a specific element in a given direction",
+  browser_network_requests: "List captured network requests, optionally filtered",
+  browser_console_messages: "Retrieve console messages from the page, optionally filtered by level",
+  browser_html: "Get the HTML content of the page or a specific element",
+  browser_close: "Close a browser tab or the entire browser",
+  browser_wait_for: "Wait for a condition: text appearance/disappearance, time, URL, selector, or JS function",
+  browser_hover: "Hover over an element identified by ref",
+  browser_drag: "Drag from one element to another by ref",
+  browser_select_option: "Select option(s) in a select element identified by ref",
+  browser_handle_dialog: "Accept or dismiss a browser dialog (alert, confirm, prompt)",
+  browser_file_upload: "Upload file(s) to a file input element identified by ref",
+  browser_resize: "Resize the browser viewport to specific dimensions or a preset",
+  browser_annotated_screenshot: "Take a screenshot with element annotations overlaid. [~12K tokens, prefer browser_snapshot { interactive: true } for text alternative]",
+  browser_inspect_source: "Inspect a DOM element and return its source code location (file, line, component name). Works with React, Vue, Svelte, Solid.",
+  browser_route: "Intercept requests matching a URL pattern and respond with a custom body, status, and headers",
+  browser_abort: "Block requests matching a URL pattern",
+  browser_unroute: "Remove request intercept rules \u2014 a specific pattern or all at once",
+  browser_find: "Find elements by ARIA role, accessible name, or text content. Returns @eN ref for use with other tools.",
+  browser_diff: "Compare two screenshots pixel-by-pixel. Returns diff percentage and visual diff image highlighting changes. [~11K tokens]",
+  browser_save_state: "Save browser state (cookies, localStorage, sessionStorage) to a named file for later restoration",
+  browser_load_state: "Load a previously saved browser state (cookies, storage) and optionally navigate to a URL",
+  browser_list: "List available browser instances"
+};
+var cNum = z.coerce.number();
+var cBool = z.preprocess(
+  (v) => v === "true" ? true : v === "false" ? false : v,
+  z.boolean()
+);
+var toolShapes = {
+  browser_connect: { port: cNum.optional(), host: z.string().optional(), headless: cBool.optional(), resync: cBool.optional() },
+  browser_tabs: { filter: z.string().optional() },
+  browser_snapshot: {
+    selector: z.string().optional(),
+    compact: cBool.optional(),
+    interactive: cBool.optional(),
+    cursor: cBool.optional(),
+    depth: cNum.optional()
+  },
+  browser_screenshot: {
+    selector: z.string().optional(),
+    fullPage: cBool.optional(),
+    format: z.enum(["png", "jpeg"]).optional(),
+    quality: cNum.optional(),
+    annotate: cBool.optional(),
+    visual: cBool.optional()
+  },
+  browser_click: {
+    selector: z.string().optional(),
+    ref: z.string().optional(),
+    x: cNum.optional(),
+    y: cNum.optional(),
+    newTab: cBool.optional()
+  },
+  browser_fill_form: { ref: z.string().optional(), selector: z.string().optional(), value: z.string() },
+  browser_type: { text: z.string(), ref: z.string().optional(), slowly: cBool.optional(), submit: cBool.optional() },
+  browser_press_key: { key: z.string() },
+  browser_navigate: { url: z.string(), waitUntil: z.enum(["load", "domcontentloaded", "networkidle"]).optional() },
+  browser_navigate_back: { direction: z.enum(["back", "forward"]).optional() },
+  browser_evaluate: { expression: z.string(), frameId: z.string().optional() },
+  browser_scroll: { direction: z.enum(["up", "down", "left", "right"]).optional(), pixels: cNum.optional(), selector: z.string().optional() },
+  browser_network_requests: { filter: z.string().optional(), limit: cNum.optional(), includeHeaders: cBool.optional(), includeStatic: cBool.optional() },
+  browser_console_messages: { limit: cNum.optional(), level: z.enum(["log", "warn", "error", "info"]).optional() },
+  browser_html: { selector: z.string().optional() },
+  browser_close: { targetId: z.string().optional(), force: cBool.optional(), closeAll: cBool.optional() },
+  browser_wait_for: { text: z.string().optional(), textGone: z.string().optional(), time: cNum.optional(), timeout: cNum.optional(), url: z.string().optional(), fn: z.string().optional(), selector: z.string().optional(), state: z.string().optional(), loadState: z.string().optional() },
+  browser_hover: { ref: z.string() },
+  browser_drag: { startRef: z.string(), endRef: z.string() },
+  browser_select_option: { ref: z.string(), values: z.array(z.string()) },
+  browser_handle_dialog: { accept: cBool, promptText: z.string().optional() },
+  browser_file_upload: { ref: z.string(), paths: z.array(z.string()) },
+  browser_resize: { width: cNum.optional(), height: cNum.optional(), deviceScaleFactor: cNum.optional(), preset: z.string().optional() },
+  browser_annotated_screenshot: { selector: z.string().optional() },
+  browser_inspect_source: { ref: z.string().optional(), selector: z.string().optional() },
+  browser_route: { url: z.string(), body: z.string(), status: cNum.optional(), headers: z.record(z.string()).optional() },
+  browser_abort: { url: z.string() },
+  browser_unroute: { url: z.string().optional(), all: cBool.optional() },
+  browser_find: { role: z.string().optional(), name: z.string().optional(), text: z.string().optional(), nth: cNum.optional() },
+  browser_diff: { before: z.string(), after: z.string().optional(), selector: z.string().optional(), threshold: cNum.optional() },
+  browser_save_state: { name: z.string() },
+  browser_load_state: { name: z.string(), url: z.string().optional() },
+  browser_list: {}
+};
+function createHandlers() {
+  return {
+    // --- Core tools with real implementations ---
+    browser_navigate: async (args) => {
+      try {
+        if (needsCookieResync() && browserCdp?.isConnected) {
+          browserCdp.close();
+          browserCdp = void 0;
+          activeSessionId = void 0;
+        }
+        const conn = await getCDP();
+        const result = await browserNavigate(conn, args);
+        return textResult(`Navigated to ${result.url}
+Title: ${result.title}`);
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_screenshot: async (args) => {
+      try {
+        const conn = await getCDP();
+        const needsImage = args.visual === true || args.fullPage === true || args.selector || args.annotate === true;
+        if (!needsImage) {
+          const snap = await browserSnapshot(conn, {});
+          const text = typeof snap === "string" ? snap : snap.snapshot ?? JSON.stringify(snap, null, 2);
+          return textResult(`[auto-optimized: snapshot returned \u2014 pass visual: true for image]
+
+${text}`);
+        }
+        const result = await browserScreenshot(conn, args);
+        const mimeType = args.format === "jpeg" ? "image/jpeg" : "image/png";
+        const content = [{
+          type: "image",
+          data: result.base64,
+          mimeType
+        }];
+        if (result.annotations?.length) {
+          content.push({
+            type: "text",
+            text: result.annotations.map((a) => `${a.label} ${a.role}: ${a.name} (${a.ref})`).join("\n")
+          });
+        }
+        return { content };
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_tabs: async (args) => {
+      try {
+        const conn = await getCDP();
+        const result = await browserTabs(conn, args);
+        const lines = result.tabs.map((t) => `[${t.id}] ${t.title}
+  ${t.url}`);
+        return textResult(lines.length ? lines.join("\n\n") : "No tabs found");
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_evaluate: async (args) => {
+      try {
+        const conn = await getCDP();
+        const result = await browserEval(conn, args);
+        if (result.error) return errorResult(result.error);
+        return textResult(JSON.stringify(result.result, null, 2));
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_snapshot: async (args) => {
+      try {
+        const conn = await getCDP();
+        const result = await browserSnapshot(conn, args);
+        return textResult(typeof result === "string" ? result : JSON.stringify(result, null, 2));
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_click: async (args) => {
+      try {
+        const conn = await getCDP();
+        const result = await browserClick(conn, args);
+        return textResult(typeof result === "string" ? result : JSON.stringify(result));
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_scroll: async (args) => {
+      try {
+        const conn = await getCDP();
+        const result = await browserScroll(conn, args);
+        return textResult(typeof result === "string" ? result : JSON.stringify(result));
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_html: async (args) => {
+      try {
+        const conn = await getCDP();
+        const result = await browserHtml(conn, args);
+        return textResult(typeof result === "string" ? result : JSON.stringify(result));
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_connect: async (args) => {
+      try {
+        const typed = args;
+        const wasHeadless = headlessMode;
+        headlessMode = typed.headless === true;
+        if ((wasHeadless !== headlessMode || typed.resync === true) && browserCdp?.isConnected) {
+          browserCdp.close();
+          browserCdp = void 0;
+          activeSessionId = void 0;
+        }
+        const conn = await getCDP();
+        const mode = headlessMode ? " (headless)" : "";
+        let summary = SKILL_SUMMARY.replace("Connected to Chrome via CDP.", `Connected to Chrome via CDP${mode}.`);
+        try {
+          const { getUpgradeStatus: getUpgradeStatus2 } = await Promise.resolve().then(() => (init_upgrade(), upgrade_exports));
+          const status = getUpgradeStatus2();
+          if (status && status.latest !== status.current) {
+            summary += `
+
+\u26A0\uFE0F browsirai v${status.latest} available (current: v${status.current}). Restart to apply.`;
+          }
+        } catch {
+        }
+        return textResult(summary);
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_list: async () => {
+      try {
+        if (!browserCdp?.isConnected) {
+          await getCDP();
+        }
+        const targets = await browserCdp.send("Target.getTargets");
+        const pages = targets.targetInfos.filter((t) => t.type === "page");
+        const lines = pages.map((t) => `[${t.targetId}] ${t.title}
+  ${t.url}`);
+        return textResult(lines.length ? lines.join("\n\n") : "No pages found");
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    // --- Newly wired tools ---
+    browser_navigate_back: async (args) => {
+      try {
+        const conn = await getCDP();
+        const result = await browserNavigateBack(conn, args);
+        return textResult(result.url ? `Navigated ${args.direction || "back"} to ${result.url}` : `Navigated ${args.direction || "back"}`);
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_press_key: async (args) => {
+      try {
+        const conn = await getCDP();
+        await browserPressKey(conn, args);
+        return textResult(`Pressed key: ${args.key}`);
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_type: async (args) => {
+      try {
+        const conn = await getCDP();
+        await browserType(conn, args);
+        return textResult(`Typed ${args.text.length} characters`);
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_fill_form: async (args) => {
+      try {
+        const conn = await getCDP();
+        const fields = [{
+          name: args.selector ?? args.ref ?? "field",
+          type: "textbox",
+          ref: args.ref,
+          selector: args.selector,
+          value: args.value
+        }];
+        await browserFillForm(conn, { fields });
+        return textResult(`Filled form field with value`);
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_hover: async (args) => {
+      try {
+        const conn = await getCDP();
+        await browserHover(conn, args);
+        return textResult(`Hovered over element`);
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_drag: async (args) => {
+      try {
+        const conn = await getCDP();
+        await browserDrag(conn, args);
+        return textResult(`Dragged from ${args.startRef} to ${args.endRef}`);
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_select_option: async (args) => {
+      try {
+        const conn = await getCDP();
+        const result = await browserSelectOption(conn, args);
+        return textResult(`Selected: ${result.selected.join(", ")}`);
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_handle_dialog: async (args) => {
+      try {
+        const conn = await getCDP();
+        await browserHandleDialog(conn, args);
+        return textResult(`Dialog ${args.accept ? "accepted" : "dismissed"}`);
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_file_upload: async (args) => {
+      try {
+        const conn = await getCDP();
+        const result = await browserFileUpload(conn, args);
+        return textResult(`Uploaded ${result.filesCount} file(s)`);
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_wait_for: async (args) => {
+      try {
+        const conn = await getCDP();
+        const result = await browserWaitFor(conn, args);
+        return textResult(`Wait completed in ${result.elapsed}ms`);
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_resize: async (args) => {
+      try {
+        const conn = await getCDP();
+        const result = await browserResize(conn, args);
+        return textResult(`Resized to ${result.width}x${result.height}`);
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_close: async (args) => {
+      try {
+        const conn = await getCDP();
+        const result = await browserClose(conn, args);
+        return textResult(`Closed ${result.closedTargets} tab(s)`);
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_network_requests: async (args) => {
+      try {
+        const conn = await getCDP();
+        const result = await browserNetworkRequests(conn, args);
+        const lines = result.requests.map((r) => `${r.method} ${r.status ?? "?"} ${r.url}`);
+        return textResult(lines.length ? lines.join("\n") : "No network requests captured");
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_console_messages: async (args) => {
+      try {
+        const conn = await getCDP();
+        const result = await browserConsoleMessages(conn, args);
+        const lines = result.messages.map((m) => `[${m.level}] ${m.text}`);
+        return textResult(lines.length ? lines.join("\n") : "No console messages");
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_inspect_source: async (args) => {
+      try {
+        const conn = await getCDP();
+        const result = await browserInspectSource(conn, args);
+        const lines = [];
+        lines.push(`Element: <${result.tagName}>`);
+        if (result.componentName) {
+          lines.push(`Component: ${result.componentName}`);
+        }
+        if (result.source) {
+          lines.push(`Source: ${result.source.filePath}:${result.source.lineNumber ?? "?"}:${result.source.columnNumber ?? "?"}`);
+        } else {
+          lines.push("Source: not found (no framework metadata detected)");
+        }
+        if (result.stack.length > 0) {
+          lines.push("\nComponent Stack:");
+          for (const frame of result.stack) {
+            const loc = `${frame.filePath}:${frame.lineNumber ?? "?"}`;
+            lines.push(`  ${frame.componentName ?? "anonymous"} (${loc})`);
+          }
+        }
+        return textResult(lines.join("\n"));
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_route: async (args) => {
+      try {
+        const conn = await getCDP();
+        const result = await browserRoute(conn, args);
+        return textResult(`Route registered: ${result.url} \u2192 ${result.status}
+Active routes: ${result.activeRoutes}`);
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_abort: async (args) => {
+      try {
+        const conn = await getCDP();
+        const result = await browserAbort(conn, args);
+        return textResult(`Abort registered: ${result.url}
+Active aborts: ${result.activeAborts}`);
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_unroute: async (args) => {
+      try {
+        const conn = await getCDP();
+        const result = await browserUnroute(conn, args);
+        return textResult(`Removed ${result.removed} rule(s)
+Remaining: ${result.remaining}`);
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_annotated_screenshot: async (args) => {
+      try {
+        const conn = await getCDP();
+        const result = await browserAnnotatedScreenshot(conn, args);
+        const content = [{
+          type: "image",
+          data: result.base64,
+          mimeType: "image/png"
+        }];
+        if (result.annotations?.length) {
+          content.push({
+            type: "text",
+            text: result.annotations.map((a) => `${a.label} ${a.role}: ${a.name} (${a.ref})`).join("\n")
+          });
+        }
+        return { content };
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_diff: async (args) => {
+      try {
+        const conn = await getCDP();
+        const result = await browserDiff(conn, args);
+        const content = [{
+          type: "image",
+          data: result.diffImage,
+          mimeType: "image/png"
+        }, {
+          type: "text",
+          text: [
+            `Diff: ${result.diffPercentage}% changed`,
+            `Pixels: ${result.diffPixels} / ${result.totalPixels} differ`,
+            `Dimensions: ${result.width}x${result.height}`,
+            `Identical: ${result.identical}`
+          ].join("\n")
+        }];
+        return { content };
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_find: async (args) => {
+      try {
+        const conn = await getCDP();
+        const result = await browserFind(conn, args);
+        if (!result.found) {
+          return textResult(`No match found (${result.count} candidates)`);
+        }
+        const lines = [];
+        lines.push(`Found: ${result.ref ?? "no ref"}`);
+        lines.push(`Role: ${result.role ?? "unknown"}`);
+        lines.push(`Name: ${result.name ?? ""}`);
+        lines.push(`Matches: ${result.count}`);
+        return textResult(lines.join("\n"));
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_save_state: async (args) => {
+      try {
+        const conn = await getCDP();
+        const result = await browserSaveState(conn, args);
+        return textResult(
+          `State "${result.name}" saved to ${result.path}
+Cookies: ${result.cookies}, localStorage: ${result.localStorage}, sessionStorage: ${result.sessionStorage}`
+        );
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    },
+    browser_load_state: async (args) => {
+      try {
+        const conn = await getCDP();
+        const result = await browserLoadState(conn, args);
+        return textResult(
+          `State "${result.name}" restored
+Cookies: ${result.cookies}, localStorage: ${result.localStorage}, sessionStorage: ${result.sessionStorage}`
+        );
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    }
+  };
+}
+function registerTools(server, _manager) {
+  const handlers = createHandlers();
+  const toolNames = Object.keys(schemas);
+  for (const name of toolNames) {
+    const description = descriptions[name] ?? name;
+    const shape = toolShapes[name] ?? {};
+    const rawHandler = handlers[name] ?? (async () => textResult(`${name}: not yet implemented`));
+    const handler = async (args) => {
+      const coerced = coerceArgs(args);
+      const result = await rawHandler(coerced);
+      return appendHint(result, name);
+    };
+    server.tool(name, description, shape, handler);
+  }
+}
+
+// src/server.ts
+async function createServer() {
+  const server = new McpServer({
+    name: "browsirai",
+    version: VERSION
+  });
+  registerTools(server);
+  return server;
+}
+export {
+  createServer
+};
+//# sourceMappingURL=server.js.map