ornold-mcp 1.0.0 → 1.0.2

package/dist/cli.js

@@ -0,0 +1,2788 @@
+#!/usr/bin/env node
+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/executor/concurrency.ts
+import * as os from "os";
+function detectOptimalConcurrency(browserCount = 0) {
+  const cpuCores = os.cpus().length;
+  const totalMemGB = os.totalmem() / 1024 ** 3;
+  const freeMemGB = os.freemem() / 1024 ** 3;
+  const memPerHeavyOp = 0.5;
+  const memPerLightOp = 0.2;
+  const ramBasedHeavy = Math.floor(freeMemGB / memPerHeavyOp);
+  const ramBasedLight = Math.floor(freeMemGB / memPerLightOp);
+  const cpuBasedDefault = Math.max(2, Math.floor(cpuCores / 2));
+  const cpuBasedLight = Math.max(3, cpuCores);
+  const heavyConcurrency = Math.max(2, Math.min(ramBasedHeavy, cpuBasedDefault));
+  const lightConcurrency = Math.max(3, Math.min(ramBasedLight, cpuBasedLight));
+  const defaultConcurrency = Math.max(2, Math.floor((heavyConcurrency + lightConcurrency) / 2));
+  const effectiveHeavy = browserCount > 0 ? Math.min(heavyConcurrency, browserCount) : heavyConcurrency;
+  const effectiveLight = browserCount > 0 ? Math.min(lightConcurrency, browserCount) : lightConcurrency;
+  const effectiveDefault = browserCount > 0 ? Math.min(defaultConcurrency, browserCount) : defaultConcurrency;
+  console.error(`[Concurrency] System: ${cpuCores} cores, ${totalMemGB.toFixed(1)}GB total RAM, ${freeMemGB.toFixed(1)}GB free`);
+  console.error(`[Concurrency] Detected limits: default=${effectiveDefault}, heavy=${effectiveHeavy}, light=${effectiveLight}`);
+  return {
+    default: effectiveDefault,
+    heavy: effectiveHeavy,
+    light: effectiveLight
+  };
+}
+var ConcurrencyLimiter;
+var init_concurrency = __esm({
+  "src/executor/concurrency.ts"() {
+    "use strict";
+    ConcurrencyLimiter = class {
+      constructor(maxConcurrent) {
+        this.maxConcurrent = maxConcurrent;
+        if (maxConcurrent < 1) {
+          throw new Error("maxConcurrent must be at least 1");
+        }
+      }
+      maxConcurrent;
+      running = 0;
+      queue = [];
+      get limit() {
+        return this.maxConcurrent;
+      }
+      get active() {
+        return this.running;
+      }
+      get pending() {
+        return this.queue.length;
+      }
+      async acquire() {
+        if (this.running < this.maxConcurrent) {
+          this.running++;
+          return;
+        }
+        return new Promise((resolve) => {
+          this.queue.push(() => {
+            this.running++;
+            resolve();
+          });
+        });
+      }
+      release() {
+        if (this.running <= 0) {
+          console.error("[ConcurrencyLimiter] Warning: release() called when running <= 0");
+          return;
+        }
+        this.running--;
+        const next = this.queue.shift();
+        if (next) next();
+      }
+      async run(fn) {
+        await this.acquire();
+        try {
+          return await fn();
+        } finally {
+          this.release();
+        }
+      }
+    };
+  }
+});
+
+// src/executor/human-like.ts
+import * as fs from "fs";
+import * as path from "path";
+function debugLog(category, message, data) {
+  try {
+    const dir = path.dirname(LOG_FILE);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    let line = `[${ts}] [${category}] ${message}`;
+    if (data !== void 0) {
+      line += ` | ${JSON.stringify(data)}`;
+    }
+    fs.appendFileSync(LOG_FILE, line + "\n");
+  } catch {
+  }
+}
+function gaussianRandom(mean, stddev) {
+  const u1 = Math.random();
+  const u2 = Math.random();
+  const z2 = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+  return mean + z2 * stddev;
+}
+function clampedRandom(min, max) {
+  return Math.min(max, Math.max(min, min + Math.random() * (max - min)));
+}
+function clampedGaussian(mean, stddev, min, max) {
+  return Math.min(max, Math.max(min, gaussianRandom(mean, stddev)));
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function generateProfile(browserId) {
+  let hash = 0;
+  for (let i = 0; i < browserId.length; i++) {
+    hash = (hash << 5) - hash + browserId.charCodeAt(i) | 0;
+  }
+  const seed = Math.abs(hash);
+  return {
+    typingSpeed: 0.8 + seed % 100 / 100 * 0.4,
+    // 0.8 - 1.2
+    mouseSpeed: 0.85 + (seed >> 8) % 100 / 100 * 0.3,
+    // 0.85 - 1.15
+    actionDelay: 0.7 + (seed >> 16) % 100 / 100 * 0.6
+    // 0.7 - 1.3
+  };
+}
+async function preActionDelay(profile) {
+  const base = clampedGaussian(250, 80, 100, 400);
+  const ms = profile ? base * profile.actionDelay : base;
+  await sleep(ms);
+}
+function typingDelay(profile) {
+  if (Math.random() < 0.05) {
+    const pause = clampedGaussian(350, 100, 200, 600);
+    return profile ? pause * profile.typingSpeed : pause;
+  }
+  const base = clampedGaussian(80, 30, 40, 180);
+  return profile ? base * profile.typingSpeed : base;
+}
+async function humanDelay(min, max) {
+  await sleep(clampedRandom(min, max));
+}
+function cubicBezier(t, p0, p1, p2, p3) {
+  const t2 = t * t;
+  const t3 = t2 * t;
+  const mt = 1 - t;
+  const mt2 = mt * mt;
+  const mt3 = mt2 * mt;
+  return mt3 * p0 + 3 * mt2 * t * p1 + 3 * mt * t2 * p2 + t3 * p3;
+}
+function generateBezierPath(from, to, steps = 20) {
+  const dx = to.x - from.x;
+  const dy = to.y - from.y;
+  const distance = Math.sqrt(dx * dx + dy * dy);
+  const spreadX = distance * 0.15;
+  const spreadY = distance * 0.15;
+  const cp1 = {
+    x: from.x + dx * 0.25 + (Math.random() - 0.5) * spreadX,
+    y: from.y + dy * 0.25 + (Math.random() - 0.5) * spreadY
+  };
+  const cp2 = {
+    x: from.x + dx * 0.75 + (Math.random() - 0.5) * spreadX,
+    y: from.y + dy * 0.75 + (Math.random() - 0.5) * spreadY
+  };
+  const actualSteps = Math.max(10, Math.min(40, Math.round(steps * (distance / 500))));
+  const points = [];
+  for (let i = 0; i <= actualSteps; i++) {
+    const t = i / actualSteps;
+    const eased = t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
+    points.push({
+      x: Math.round(cubicBezier(eased, from.x, cp1.x, cp2.x, to.x)),
+      y: Math.round(cubicBezier(eased, from.y, cp1.y, cp2.y, to.y))
+    });
+  }
+  return points;
+}
+async function humanMouseMove(page, from, to, profile) {
+  debugLog("MOUSE_MOVE", `from=(${from.x},${from.y}) to=(${to.x},${to.y})`);
+  const path2 = generateBezierPath(from, to);
+  const speedMult = profile?.mouseSpeed ?? 1;
+  debugLog("MOUSE_MOVE", `bezier path generated: ${path2.length} steps, speedMult=${speedMult.toFixed(2)}`);
+  let cdpSession = null;
+  try {
+    cdpSession = await page.context().newCDPSession(page);
+  } catch (err) {
+    debugLog("MOUSE_MOVE", `CDP session creation failed, cursor won't be visible in screencast`, String(err));
+  }
+  for (let i = 0; i < path2.length; i++) {
+    const point = path2[i];
+    const delay = clampedRandom(5, 15) * speedMult;
+    try {
+      await page.mouse.move(point.x, point.y);
+    } catch (err) {
+      debugLog("MOUSE_MOVE", `ERROR at step ${i}/${path2.length}: page.mouse.move(${point.x},${point.y}) failed`, String(err));
+      throw err;
+    }
+    if (cdpSession) {
+      try {
+        await cdpSession.send("Runtime.evaluate", {
+          expression: `window.__cpSrv = {x:${Math.round(point.x)},y:${Math.round(point.y)}}`,
+          returnByValue: false
+          // no need to read back on every step
+        });
+      } catch (err) {
+      }
+    }
+    await sleep(delay);
+  }
+  if (cdpSession) {
+    try {
+      await cdpSession.detach();
+    } catch (err) {
+    }
+  }
+  debugLog("MOUSE_MOVE", `movement complete at (${to.x},${to.y})`);
+  console.log(`[HumanLike] Mouse moved smoothly to (${to.x},${to.y}), ${path2.length} steps`);
+  await showCursorOverlay(page, to.x, to.y);
+}
+function clickOffset(width, height) {
+  const maxOffX = Math.min(8, width * 0.15);
+  const maxOffY = Math.min(5, height * 0.15);
+  return {
+    x: clampedGaussian(0, maxOffX * 0.5, -maxOffX, maxOffX),
+    y: clampedGaussian(0, maxOffY * 0.5, -maxOffY, maxOffY)
+  };
+}
+async function humanClick(page, target, fromPos, profile) {
+  debugLog("CLICK", `target=(${target.x},${target.y}) from=(${fromPos.x},${fromPos.y})`);
+  await humanMouseMove(page, fromPos, target, profile);
+  debugLog("CLICK", `mouse.down()`);
+  await page.mouse.down();
+  const holdDelay = clampedRandom(50, 120);
+  debugLog("CLICK", `holding for ${holdDelay.toFixed(0)}ms`);
+  await sleep(holdDelay);
+  debugLog("CLICK", `mouse.up()`);
+  await page.mouse.up();
+  debugLog("CLICK", `click complete`);
+}
+async function getClickTarget(page, locator) {
+  debugLog("GET_TARGET", `getting bounding box for locator`);
+  const box = await locator.boundingBox();
+  if (!box) {
+    debugLog("GET_TARGET", `ERROR: no bounding box returned (element not visible)`);
+    throw new Error("Element is not visible \u2014 no bounding box");
+  }
+  debugLog("GET_TARGET", `boundingBox: x=${box.x} y=${box.y} w=${box.width} h=${box.height}`);
+  const offset = clickOffset(box.width, box.height);
+  const target = {
+    x: Math.round(box.x + box.width / 2 + offset.x),
+    y: Math.round(box.y + box.height / 2 + offset.y)
+  };
+  debugLog("GET_TARGET", `center=(${Math.round(box.x + box.width / 2)},${Math.round(box.y + box.height / 2)}) offset=(${offset.x.toFixed(1)},${offset.y.toFixed(1)}) final=(${target.x},${target.y})`);
+  return {
+    target,
+    box: { width: box.width, height: box.height }
+  };
+}
+async function cdpTypeChar(cdp, char) {
+  const info = KEY_CODES[char];
+  const code = info?.code ?? "";
+  const keyCode = info?.keyCode ?? char.charCodeAt(0);
+  debugLog("TYPE_CHAR", `char="${char}" code=${code} keyCode=${keyCode} (has mapping: ${!!info})`);
+  try {
+    await cdp.send("Input.dispatchKeyEvent", {
+      type: "keyDown",
+      key: char,
+      code,
+      windowsVirtualKeyCode: keyCode,
+      nativeVirtualKeyCode: keyCode
+    });
+    debugLog("TYPE_CHAR", `keyDown sent OK`);
+  } catch (err) {
+    debugLog("TYPE_CHAR", `keyDown FAILED`, String(err));
+    throw err;
+  }
+  try {
+    await cdp.send("Input.dispatchKeyEvent", {
+      type: "char",
+      text: char,
+      unmodifiedText: char
+    });
+    debugLog("TYPE_CHAR", `char event sent OK`);
+  } catch (err) {
+    debugLog("TYPE_CHAR", `char event FAILED`, String(err));
+    throw err;
+  }
+  const pressDelay = clampedRandom(20, 60);
+  await sleep(pressDelay);
+  try {
+    await cdp.send("Input.dispatchKeyEvent", {
+      type: "keyUp",
+      key: char,
+      code,
+      windowsVirtualKeyCode: keyCode,
+      nativeVirtualKeyCode: keyCode
+    });
+    debugLog("TYPE_CHAR", `keyUp sent OK (pressDelay=${pressDelay.toFixed(0)}ms)`);
+  } catch (err) {
+    debugLog("TYPE_CHAR", `keyUp FAILED`, String(err));
+    throw err;
+  }
+}
+async function humanTypeText(page, text, profile) {
+  debugLog("TYPE_TEXT", `typing "${text}" (${text.length} chars)`);
+  let cdp;
+  try {
+    cdp = await page.context().newCDPSession(page);
+    debugLog("TYPE_TEXT", `CDP session created for typing`);
+  } catch (err) {
+    debugLog("TYPE_TEXT", `FAILED to create CDP session`, String(err));
+    throw err;
+  }
+  try {
+    for (let i = 0; i < text.length; i++) {
+      const char = text[i];
+      await cdpTypeChar(cdp, char);
+      const delay = typingDelay(profile);
+      debugLog("TYPE_TEXT", `char ${i + 1}/${text.length} "${char}" typed, next delay=${delay.toFixed(0)}ms`);
+      await sleep(delay);
+    }
+    debugLog("TYPE_TEXT", `typing complete`);
+  } finally {
+    await cdp.detach().catch(() => {
+    });
+    debugLog("TYPE_TEXT", `CDP session detached`);
+  }
+}
+async function getOverlaySession(page) {
+  let cdp = overlaySessions.get(page);
+  if (cdp) {
+    debugLog("OVERLAY", `reusing existing overlay session`);
+    return cdp;
+  }
+  debugLog("OVERLAY", `creating new overlay CDP session`);
+  cdp = await page.context().newCDPSession(page);
+  try {
+    await cdp.send("DOM.enable");
+    debugLog("OVERLAY", `DOM.enable SUCCESS`);
+    await cdp.send("Overlay.enable");
+    debugLog("OVERLAY", `Overlay.enable SUCCESS`);
+  } catch (err) {
+    debugLog("OVERLAY", `Overlay.enable FAILED`, String(err));
+  }
+  overlaySessions.set(page, cdp);
+  cdp.on("detached", () => {
+    debugLog("OVERLAY", `overlay session detached (cleanup)`);
+    overlaySessions.delete(page);
+  });
+  return cdp;
+}
+async function showCursorOverlay(page, x, y) {
+  debugLog("CURSOR", `showCursorOverlay called at (${x},${y})`);
+  try {
+    const cdp = await getOverlaySession(page);
+    const params = {
+      x: Math.round(x) - 4,
+      y: Math.round(y) - 4,
+      width: 8,
+      height: 8,
+      color: { r: 255, g: 69, b: 58, a: 0.7 },
+      outlineColor: { r: 255, g: 255, b: 255, a: 0.9 }
+    };
+    debugLog("CURSOR", `sending Overlay.highlightRect`, params);
+    await cdp.send("Overlay.highlightRect", params);
+    debugLog("CURSOR", `highlightRect SUCCESS`);
+  } catch (err) {
+    debugLog("CURSOR", `highlightRect FAILED (attempt 1), retrying...`, String(err));
+    overlaySessions.delete(page);
+    try {
+      const cdp = await getOverlaySession(page);
+      await cdp.send("Overlay.highlightRect", {
+        x: Math.round(x) - 4,
+        y: Math.round(y) - 4,
+        width: 8,
+        height: 8,
+        color: { r: 255, g: 69, b: 58, a: 0.7 },
+        outlineColor: { r: 255, g: 255, b: 255, a: 0.9 }
+      });
+      debugLog("CURSOR", `highlightRect SUCCESS (retry)`);
+    } catch (err2) {
+      debugLog("CURSOR", `highlightRect FAILED (retry), giving up`, String(err2));
+    }
+  }
+}
+async function ensureCursor(page) {
+}
+var LOG_FILE, KEY_CODES, SYMBOLS, overlaySessions;
+var init_human_like = __esm({
+  "src/executor/human-like.ts"() {
+    "use strict";
+    LOG_FILE = path.join(process.cwd(), "logs", "human-like-debug.log");
+    KEY_CODES = {};
+    for (let i = 0; i < 26; i++) {
+      const lower = String.fromCharCode(97 + i);
+      const upper = String.fromCharCode(65 + i);
+      KEY_CODES[lower] = { keyCode: 65 + i, code: `Key${upper}`, key: lower };
+      KEY_CODES[upper] = { keyCode: 65 + i, code: `Key${upper}`, key: upper };
+    }
+    for (let i = 0; i < 10; i++) {
+      const ch = String(i);
+      KEY_CODES[ch] = { keyCode: 48 + i, code: `Digit${i}`, key: ch };
+    }
+    SYMBOLS = {
+      " ": { keyCode: 32, code: "Space" },
+      ".": { keyCode: 190, code: "Period" },
+      ",": { keyCode: 188, code: "Comma" },
+      "/": { keyCode: 191, code: "Slash" },
+      "\\": { keyCode: 220, code: "Backslash" },
+      "-": { keyCode: 189, code: "Minus" },
+      "=": { keyCode: 187, code: "Equal" },
+      "[": { keyCode: 219, code: "BracketLeft" },
+      "]": { keyCode: 221, code: "BracketRight" },
+      ";": { keyCode: 186, code: "Semicolon" },
+      "'": { keyCode: 222, code: "Quote" },
+      "`": { keyCode: 192, code: "Backquote" },
+      "@": { keyCode: 50, code: "Digit2" },
+      "!": { keyCode: 49, code: "Digit1" },
+      "#": { keyCode: 51, code: "Digit3" },
+      "$": { keyCode: 52, code: "Digit4" },
+      "%": { keyCode: 53, code: "Digit5" },
+      "^": { keyCode: 54, code: "Digit6" },
+      "&": { keyCode: 55, code: "Digit7" },
+      "*": { keyCode: 56, code: "Digit8" },
+      "(": { keyCode: 57, code: "Digit9" },
+      ")": { keyCode: 48, code: "Digit0" },
+      "_": { keyCode: 189, code: "Minus" },
+      "+": { keyCode: 187, code: "Equal" },
+      "{": { keyCode: 219, code: "BracketLeft" },
+      "}": { keyCode: 221, code: "BracketRight" },
+      ":": { keyCode: 186, code: "Semicolon" },
+      '"': { keyCode: 222, code: "Quote" },
+      "~": { keyCode: 192, code: "Backquote" },
+      "<": { keyCode: 188, code: "Comma" },
+      ">": { keyCode: 190, code: "Period" },
+      "?": { keyCode: 191, code: "Slash" },
+      "|": { keyCode: 220, code: "Backslash" },
+      "\n": { keyCode: 13, code: "Enter" },
+      "	": { keyCode: 9, code: "Tab" }
+    };
+    for (const [ch, info] of Object.entries(SYMBOLS)) {
+      KEY_CODES[ch] = { ...info, key: ch };
+    }
+    overlaySessions = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// src/executor/multi-browser.ts
+var multi_browser_exports = {};
+__export(multi_browser_exports, {
+  MultiBrowserExecutor: () => MultiBrowserExecutor
+});
+import * as playwright from "patchright";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { join as join2, extname } from "node:path";
+var MultiBrowserExecutor;
+var init_multi_browser = __esm({
+  "src/executor/multi-browser.ts"() {
+    "use strict";
+    init_concurrency();
+    init_human_like();
+    MultiBrowserExecutor = class _MultiBrowserExecutor {
+      browsers = /* @__PURE__ */ new Map();
+      defaultTimeout;
+      limiter;
+      heavyLimiter;
+      lightLimiter;
+      // Cache for browser sync - prevents excessive API calls
+      lastSyncTime = 0;
+      syncInProgress = null;
+      static SYNC_TTL_MS = 5e3;
+      // 5 seconds cache TTL
+      // Track last mouse position per browser for human-like movement
+      lastMousePosition = /* @__PURE__ */ new Map();
+      // Per-browser human profiles for varied timing
+      profiles = /* @__PURE__ */ new Map();
+      // Snapshot refs map back to selectors for flow-agent style browser tools
+      snapshotRefs = /* @__PURE__ */ new Map();
+      // Console messages collected per browser (since connect time)
+      consoleMessages = /* @__PURE__ */ new Map();
+      // Network requests collected per browser (since connect time)
+      networkRequests = /* @__PURE__ */ new Map();
+      constructor(options = {}) {
+        this.defaultTimeout = options.timeout ?? 5e3;
+        const detected = detectOptimalConcurrency();
+        const defaultConcurrency = options.maxConcurrency ?? detected.default;
+        const heavyConcurrency = options.maxConcurrency ? Math.max(2, Math.floor(options.maxConcurrency * 0.75)) : detected.heavy;
+        const lightConcurrency = options.maxConcurrency ? Math.min(options.maxConcurrency * 1.5, 10) : detected.light;
+        this.limiter = new ConcurrencyLimiter(defaultConcurrency);
+        this.heavyLimiter = new ConcurrencyLimiter(heavyConcurrency);
+        this.lightLimiter = new ConcurrencyLimiter(lightConcurrency);
+        console.error(`[Executor] Concurrency limiters initialized: default=${defaultConcurrency}, heavy=${heavyConcurrency}, light=${lightConcurrency}`);
+      }
+      // ==================== CONNECTION MANAGEMENT ====================
+      /**
+       * Connect to multiple browsers with controlled concurrency.
+       * OPTIMIZATION: Limits simultaneous connections to prevent overwhelming CDP endpoints.
+       */
+      async connectAll(endpoints) {
+        const start = Date.now();
+        console.error(`[Executor] connectAll: starting connection to ${endpoints.length} browsers with concurrency limit`);
+        const connectionLimiter = new ConcurrencyLimiter(
+          this.heavyLimiter.limit
+        );
+        const tasks = endpoints.map(async (endpoint) => {
+          return connectionLimiter.run(async () => {
+            const taskStart = Date.now();
+            try {
+              console.error(`[Executor] Connecting to ${endpoint.id} at ${endpoint.cdpEndpoint}...`);
+              const result = await this.connect(endpoint);
+              console.error(`[Executor] \u2705 Connected to ${endpoint.id}: ${result.url}`);
+              return {
+                browserId: endpoint.id,
+                success: true,
+                result,
+                duration: Date.now() - taskStart
+              };
+            } catch (error) {
+              console.error(`[Executor] \u274C Failed to connect to ${endpoint.id}: ${error}`);
+              return {
+                browserId: endpoint.id,
+                success: false,
+                error: String(error),
+                duration: Date.now() - taskStart
+              };
+            }
+          });
+        });
+        const results = await Promise.all(tasks);
+        console.error(`[Executor] connectAll complete: ${results.filter((r) => r.success).length}/${results.length} connected in ${Date.now() - start}ms`);
+        return {
+          results,
+          totalDuration: Date.now() - start,
+          successCount: results.filter((r) => r.success).length,
+          failureCount: results.filter((r) => !r.success).length
+        };
+      }
+      async connect(endpoint, retries = 3) {
+        if (this.browsers.has(endpoint.id)) {
+          throw new Error(`Browser ${endpoint.id} is already connected`);
+        }
+        let lastError = null;
+        for (let attempt = 1; attempt <= retries; attempt++) {
+          try {
+            console.error(`[Executor] Attempt ${attempt}/${retries} to connect to ${endpoint.id} at ${endpoint.cdpEndpoint}`);
+            const browser = await playwright.chromium.connectOverCDP(endpoint.cdpEndpoint, {
+              headers: endpoint.cdpHeaders
+            });
+            return await this._finishConnect(endpoint, browser);
+          } catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            console.error(`[Executor] Attempt ${attempt}/${retries} failed for ${endpoint.id}: ${lastError.message}`);
+            if (attempt < retries) {
+              const delay = Math.pow(2, attempt - 1) * 300;
+              console.error(`[Executor] Retrying in ${delay}ms...`);
+              await new Promise((r) => setTimeout(r, delay));
+            }
+          }
+        }
+        throw lastError || new Error(`Failed to connect to ${endpoint.id} after ${retries} attempts`);
+      }
+      async _finishConnect(endpoint, browser) {
+        let context;
+        let page;
+        const contexts = browser.contexts();
+        console.error(`[Executor] Browser ${endpoint.id} has ${contexts.length} contexts`);
+        if (contexts.length > 0) {
+          context = contexts[0];
+          const pages = context.pages();
+          console.error(`[Executor] Context has ${pages.length} pages`);
+          if (pages.length > 0) {
+            page = pages.find((p) => !p.url().startsWith("about:")) || pages[0];
+            console.error(`[Executor] Using existing page: ${page.url()}`);
+          } else {
+            console.error(`[Executor] No pages in context, waiting for existing page...`);
+            const waitStart = Date.now();
+            while (Date.now() - waitStart < 2e3) {
+              const currentPages = context.pages();
+              if (currentPages.length > 0) {
+                page = currentPages.find((p) => !p.url().startsWith("about:")) || currentPages[0];
+                console.error(`[Executor] Found page after waiting: ${page.url()}`);
+                break;
+              }
+              await new Promise((r) => setTimeout(r, 100));
+            }
+            if (!page) {
+              console.error(`[Executor] No pages appeared after 2s, creating new page (fallback)`);
+              page = await context.newPage();
+            }
+          }
+        } else {
+          console.error(`[Executor] No contexts, waiting for context to appear...`);
+          const waitStart = Date.now();
+          while (Date.now() - waitStart < 2e3) {
+            const currentContexts = browser.contexts();
+            if (currentContexts.length > 0) {
+              context = currentContexts[0];
+              const pages = context.pages();
+              if (pages.length > 0) {
+                page = pages.find((p) => !p.url().startsWith("about:")) || pages[0];
+                console.error(`[Executor] Found context and page after waiting: ${page.url()}`);
+                break;
+              }
+            }
+            await new Promise((r) => setTimeout(r, 100));
+          }
+          if (!context) {
+            console.error(`[Executor] Creating new context and page for ${endpoint.id} (fallback)`);
+            context = await browser.newContext();
+            page = await context.newPage();
+          } else if (!page) {
+            console.error(`[Executor] Context found but no pages, creating page (fallback)`);
+            page = await context.newPage();
+          }
+        }
+        try {
+          const allPages = context.pages();
+          for (const p of allPages) {
+            if (p !== page && p.url() === "about:blank") {
+              await p.close().catch(() => {
+              });
+              console.error(`[Executor] Closed extra about:blank page for ${endpoint.id}`);
+            }
+          }
+        } catch {
+        }
+        page.setDefaultTimeout(this.defaultTimeout);
+        page.setDefaultNavigationTimeout(6e4);
+        const connected = {
+          id: endpoint.id,
+          browser,
+          context,
+          page,
+          endpoint,
+          connectedAt: /* @__PURE__ */ new Date()
+        };
+        this.browsers.set(endpoint.id, connected);
+        console.error(`[Executor] Successfully stored ${endpoint.id} in browsers map. Total browsers: ${this.browsers.size}`);
+        this.snapshotRefs.set(endpoint.id, /* @__PURE__ */ new Map());
+        const consoleLog = [];
+        this.consoleMessages.set(endpoint.id, consoleLog);
+        page.on("console", (msg) => {
+          consoleLog.push({ type: msg.type(), text: msg.text(), timestamp: Date.now() });
+          if (consoleLog.length > 1e3) consoleLog.shift();
+        });
+        const networkLog = [];
+        this.networkRequests.set(endpoint.id, networkLog);
+        page.on("response", (response) => {
+          const req = response.request();
+          networkLog.push({
+            url: req.url(),
+            method: req.method(),
+            status: response.status(),
+            resourceType: req.resourceType(),
+            timestamp: Date.now()
+          });
+          if (networkLog.length > 1e3) networkLog.shift();
+        });
+        browser.on("disconnected", () => {
+          console.error(`[Executor] Browser ${endpoint.id} disconnected`);
+          this.browsers.delete(endpoint.id);
+          this.consoleMessages.delete(endpoint.id);
+          this.networkRequests.delete(endpoint.id);
+          this.snapshotRefs.delete(endpoint.id);
+          setTimeout(async () => {
+            if (!this.browsers.has(endpoint.id)) {
+              console.error(`[Executor] Attempting auto-reconnect for ${endpoint.id}...`);
+              try {
+                await this.connect(endpoint, 2);
+                console.error(`[Executor] \u2705 Auto-reconnected ${endpoint.id}`);
+              } catch (e) {
+                console.error(`[Executor] \u274C Auto-reconnect failed for ${endpoint.id}: ${e instanceof Error ? e.message : String(e)}`);
+              }
+            }
+          }, 500);
+        });
+        const url = page.url();
+        const title = await page.title().catch(() => "");
+        console.error(`[Executor] Browser ${endpoint.id} connected. URL: ${url}, Title: ${title}`);
+        return {
+          id: endpoint.id,
+          connected: true,
+          url,
+          title,
+          endpoint: endpoint.cdpEndpoint,
+          tags: endpoint.tags,
+          connectedAt: connected.connectedAt
+        };
+      }
+      async disconnect(browserId) {
+        const browser = this.browsers.get(browserId);
+        if (!browser) throw new Error(`Browser ${browserId} not found`);
+        await browser.browser.close().catch(() => {
+        });
+        this.browsers.delete(browserId);
+        this.consoleMessages.delete(browserId);
+        this.networkRequests.delete(browserId);
+        this.snapshotRefs.delete(browserId);
+      }
+      async disconnectAll() {
+        const ids = Array.from(this.browsers.keys());
+        await Promise.all(
+          ids.map((id) => this.disconnect(id).catch(() => {
+          }))
+        );
+        this.browsers.clear();
+      }
+      async listBrowsers() {
+        const statuses = [];
+        for (const [id, browser] of this.browsers) {
+          try {
+            statuses.push({
+              id,
+              connected: browser.browser.isConnected(),
+              url: browser.page.url(),
+              title: await browser.page.title().catch(() => ""),
+              endpoint: browser.endpoint.cdpEndpoint,
+              tags: browser.endpoint.tags,
+              connectedAt: browser.connectedAt
+            });
+          } catch {
+            statuses.push({
+              id,
+              connected: false,
+              endpoint: browser.endpoint.cdpEndpoint,
+              tags: browser.endpoint.tags
+            });
+          }
+        }
+        return statuses;
+      }
+      /**
+       * Detailed status check for all browsers
+       */
+      async getDetailedStatus(options = {}) {
+        const results = [];
+        const urlCounts = /* @__PURE__ */ new Map();
+        for (const [id, browser] of this.browsers) {
+          try {
+            if (!browser.browser.isConnected()) {
+              results.push({
+                id,
+                status: "disconnected",
+                url: "",
+                title: "",
+                error: "Browser disconnected",
+                responsive: false
+              });
+              continue;
+            }
+            const url = browser.page.url();
+            const title = await browser.page.title().catch(() => "");
+            let responsive = true;
+            try {
+              let timeoutId;
+              const timeoutPromise = new Promise((_, reject) => {
+                timeoutId = setTimeout(() => reject(new Error("timeout")), 1e3);
+              });
+              try {
+                await Promise.race([
+                  browser.page.evaluate(() => true),
+                  timeoutPromise
+                ]);
+                clearTimeout(timeoutId);
+              } catch {
+                clearTimeout(timeoutId);
+                responsive = false;
+              }
+            } catch {
+              responsive = false;
+            }
+            const baseUrl = url.split("?")[0];
+            urlCounts.set(baseUrl, (urlCounts.get(baseUrl) || 0) + 1);
+            results.push({
+              id,
+              status: responsive ? "ok" : "error",
+              url,
+              title,
+              error: responsive ? void 0 : "Page not responding",
+              responsive
+            });
+          } catch (error) {
+            results.push({
+              id,
+              status: "error",
+              url: "",
+              title: "",
+              error: String(error),
+              responsive: false
+            });
+          }
+        }
+        let majorityUrl;
+        let maxCount = 0;
+        for (const [url, count] of urlCounts) {
+          if (count > maxCount) {
+            maxCount = count;
+            majorityUrl = url;
+          }
+        }
+        if (majorityUrl && maxCount > 1) {
+          for (const result of results) {
+            if (result.status === "ok" && result.url.split("?")[0] !== majorityUrl) {
+              result.status = "behind";
+            }
+          }
+        }
+        const okCount = results.filter((r) => r.status === "ok").length;
+        return {
+          browsers: results,
+          summary: {
+            total: results.length,
+            ok: okCount,
+            problems: results.length - okCount
+          },
+          majorityUrl
+        };
+      }
+      /**
+       * Sync browsers from API (on-demand) with retry logic.
+       * Called automatically when getBrowserIds finds no connected browsers.
+       */
+      async syncFromAPI(retries = 2) {
+        const apiServerUrl = process.env.API_SERVER_URL;
+        const userId = process.env.USER_ID;
+        if (!apiServerUrl || !userId) {
+          console.error(`[Executor] syncFromAPI: missing API_SERVER_URL or USER_ID`);
+          return;
+        }
+        let lastError = null;
+        for (let attempt = 1; attempt <= retries; attempt++) {
+          try {
+            const url = `${apiServerUrl}/api/browsers?userId=${userId}`;
+            console.error(`[Executor] syncFromAPI: fetching ${url} (attempt ${attempt}/${retries})`);
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 5e3);
+            try {
+              const response = await fetch(url, { signal: controller.signal });
+              clearTimeout(timeoutId);
+              if (!response.ok) {
+                throw new Error(`API returned ${response.status}`);
+              }
+              const data = await response.json();
+              const apiBrowsers = data.browsers || [];
+              console.error(`[Executor] syncFromAPI: API returned ${apiBrowsers.length} browsers`);
+              const connectedIds = new Set(this.browsers.keys());
+              for (const browser of apiBrowsers) {
+                if (!connectedIds.has(browser.id)) {
+                  console.error(`[Executor] syncFromAPI: connecting ${browser.id}`);
+                  try {
+                    await this.connect({
+                      id: browser.id,
+                      cdpEndpoint: browser.cdpEndpoint,
+                      tags: browser.tags || []
+                    });
+                    console.error(`[Executor] syncFromAPI: \u2713 connected ${browser.id}`);
+                  } catch (e) {
+                    console.error(`[Executor] syncFromAPI: \u2717 failed ${browser.id}: ${e instanceof Error ? e.message : String(e)}`);
+                  }
+                }
+              }
+              const apiIds = new Set(apiBrowsers.map((b) => b.id));
+              for (const id of connectedIds) {
+                if (!apiIds.has(id)) {
+                  console.error(`[Executor] syncFromAPI: disconnecting stale ${id}`);
+                  try {
+                    await this.disconnect(id);
+                  } catch {
+                  }
+                }
+              }
+              console.error(`[Executor] syncFromAPI: done, now have ${this.browsers.size} browsers`);
+              this.lastSyncTime = Date.now();
+              return;
+            } catch (e) {
+              clearTimeout(timeoutId);
+              throw e;
+            }
+          } catch (e) {
+            lastError = e instanceof Error ? e : new Error(String(e));
+            console.error(`[Executor] syncFromAPI: attempt ${attempt}/${retries} failed: ${lastError.message}`);
+            if (attempt < retries) {
+              const delay = Math.pow(2, attempt - 1) * 300;
+              console.error(`[Executor] syncFromAPI: retrying in ${delay}ms...`);
+              await new Promise((r) => setTimeout(r, delay));
+            }
+          }
+        }
+        console.error(`[Executor] syncFromAPI: all ${retries} attempts failed`);
+      }
+      getBrowserIds(filter) {
+        let ids = Array.from(this.browsers.keys());
+        if (filter?.browserIds?.length) {
+          ids = ids.filter((id) => filter.browserIds.includes(id));
+        }
+        if (filter?.tags?.length) {
+          ids = ids.filter((id) => {
+            const browser = this.browsers.get(id);
+            return browser?.endpoint.tags?.some((t) => filter.tags.includes(t));
+          });
+        }
+        return ids;
+      }
+      /**
+       * Ensure browsers are loaded before operations.
+       * Uses caching to prevent excessive API calls.
+       * Only syncs if: no browsers connected AND cache expired.
+       */
+      async ensureBrowsersLoaded() {
+        if (this.browsers.size > 0) {
+          return;
+        }
+        const now = Date.now();
+        if (now - this.lastSyncTime < _MultiBrowserExecutor.SYNC_TTL_MS) {
+          console.error(`[Executor] ensureBrowsersLoaded: skipping sync, cache valid (${now - this.lastSyncTime}ms old)`);
+          return;
+        }
+        if (this.syncInProgress) {
+          console.error(`[Executor] ensureBrowsersLoaded: sync already in progress, waiting...`);
+          await this.syncInProgress;
+          return;
+        }
+        console.error(`[Executor] ensureBrowsersLoaded: no browsers, syncing from API...`);
+        this.syncInProgress = this.syncFromAPI().finally(() => {
+          this.syncInProgress = null;
+        });
+        await this.syncInProgress;
+      }
+      getBrowserEndpoint(browserId) {
+        const browser = this.browsers.get(browserId);
+        return browser?.endpoint;
+      }
+      getPage(browserId) {
+        const browser = this.browsers.get(browserId);
+        if (!browser) throw new Error(`Browser ${browserId} not found`);
+        return browser.page;
+      }
+      resolveSelector(target, browserId) {
+        if (typeof target === "string") return target;
+        if (target.selector) return target.selector;
+        if (target.ref) {
+          const selector = this.snapshotRefs.get(browserId)?.get(String(target.ref));
+          if (selector) return selector;
+          throw new Error(`Unknown ref "${target.ref}" for browser ${browserId}. Call browser_parallel_snapshot first.`);
+        }
+        throw new Error("Either selector or ref is required");
+      }
+      isTruthyFieldValue(value) {
+        return ["true", "1", "yes", "on", "checked"].includes(value.trim().toLowerCase());
+      }
+      async waitForDomStable(page, stableMs, timeoutMs) {
+        const startedAt = Date.now();
+        let lastSignature = "";
+        let stableSince = 0;
+        const pollInterval = Math.min(250, Math.max(75, Math.floor(stableMs / 3) || 100));
+        while (Date.now() - startedAt <= timeoutMs) {
+          const signature = await page.evaluate(() => JSON.stringify({
+            readyState: document.readyState,
+            nodeCount: document.querySelectorAll("*").length,
+            textLength: document.body?.innerText.length ?? 0,
+            scrollHeight: document.documentElement?.scrollHeight ?? 0,
+            scrollWidth: document.documentElement?.scrollWidth ?? 0
+          }));
+          if (signature === lastSignature) {
+            if (!stableSince) stableSince = Date.now();
+            if (Date.now() - stableSince >= stableMs) return;
+          } else {
+            lastSignature = signature;
+            stableSince = 0;
+          }
+          await page.waitForTimeout(pollInterval);
+        }
+        throw new Error(`DOM did not become stable within ${timeoutMs}ms`);
+      }
+      getMimeType(fileName) {
+        const ext = extname(fileName).toLowerCase();
+        const types = {
+          ".txt": "text/plain",
+          ".json": "application/json",
+          ".csv": "text/csv",
+          ".pdf": "application/pdf",
+          ".png": "image/png",
+          ".jpg": "image/jpeg",
+          ".jpeg": "image/jpeg",
+          ".gif": "image/gif",
+          ".webp": "image/webp",
+          ".svg": "image/svg+xml",
+          ".zip": "application/zip"
+        };
+        return types[ext] || "application/octet-stream";
+      }
+      // ==================== PARALLEL EXECUTION ====================
+      /**
+       * Get the appropriate limiter based on operation type
+       */
+      getLimiter(type) {
+        if (typeof type === "number") {
+          return new ConcurrencyLimiter(type);
+        }
+        switch (type) {
+          case "heavy":
+            return this.heavyLimiter;
+          case "light":
+            return this.lightLimiter;
+          default:
+            return this.limiter;
+        }
+      }
+      /**
+       * Execute action on multiple browsers with controlled concurrency.
+       * This prevents system overload when operating on 9+ browsers.
+       * Concurrency is auto-detected based on system resources (RAM, CPU cores).
+       * 
+       * @param browserIds - specific browsers to target, or undefined for all
+       * @param action - async function to execute on each browser
+       * @param options.timeout - per-browser timeout
+       * @param options.concurrency - 'heavy' | 'light' | number - type of operation or explicit limit
+       */
+      async executeParallel(browserIds, action, options = {}) {
+        const start = Date.now();
+        await this.ensureBrowsersLoaded();
+        const ids = browserIds ?? this.getBrowserIds();
+        const timeout = options.timeout ?? this.defaultTimeout;
+        const limiter = this.getLimiter(options.concurrency);
+        console.error(`[Executor] executeParallel: running on ${ids.length} browsers with concurrency limit: [${ids.join(", ")}]`);
+        const tasks = ids.map(async (id) => {
+          return limiter.run(async () => {
+            const taskStart = Date.now();
+            const browser = this.browsers.get(id);
+            if (!browser) {
+              console.error(`[Executor] \u274C Browser ${id} not found in map`);
+              return {
+                browserId: id,
+                success: false,
+                error: `Browser ${id} not found`,
+                duration: Date.now() - taskStart
+              };
+            }
+            if (!browser.browser.isConnected()) {
+              console.error(`[Executor] \u274C Browser ${id} is disconnected`);
+              this.browsers.delete(id);
+              return {
+                browserId: id,
+                success: false,
+                error: `Browser ${id} is disconnected`,
+                duration: Date.now() - taskStart
+              };
+            }
+            try {
+              console.error(`[Executor] \u{1F504} Executing action on ${id}...`);
+              let timeoutId;
+              const timeoutPromise = new Promise((_, reject) => {
+                timeoutId = setTimeout(() => reject(new Error("Timeout")), timeout);
+              });
+              try {
+                const result = await Promise.race([
+                  action(browser.page, id),
+                  timeoutPromise
+                ]);
+                clearTimeout(timeoutId);
+                console.error(`[Executor] \u2705 Action completed on ${id}`);
+                return {
+                  browserId: id,
+                  success: true,
+                  result,
+                  duration: Date.now() - taskStart
+                };
+              } catch (error) {
+                clearTimeout(timeoutId);
+                throw error;
+              }
+            } catch (error) {
+              console.error(`[Executor] \u274C Action failed on ${id}: ${error}`);
+              return {
+                browserId: id,
+                success: false,
+                error: String(error),
+                duration: Date.now() - taskStart
+              };
+            }
+          });
+        });
+        const results = await Promise.all(tasks);
+        console.error(`[Executor] executeParallel complete: ${results.filter((r) => r.success).length}/${results.length} succeeded in ${Date.now() - start}ms`);
+        return {
+          results,
+          totalDuration: Date.now() - start,
+          successCount: results.filter((r) => r.success).length,
+          failureCount: results.filter((r) => !r.success).length
+        };
+      }
+      // ==================== NAVIGATION ====================
+      /**
+       * Navigate multiple browsers to the same URL.
+       * OPTIMIZATION: Uses higher concurrency for navigation (it's mostly network-bound)
+       */
+      async parallelNavigate(url, browserIds) {
+        return this.executeParallel(
+          browserIds,
+          async (page) => {
+            await page.goto(url, { waitUntil: "domcontentloaded" });
+            await page.waitForLoadState("load", { timeout: 5e3 }).catch(() => {
+            });
+            return { url: page.url(), title: await page.title() };
+          },
+          {
+            timeout: 6e4,
+            concurrency: "light"
+          }
+        );
+      }
+      async parallelNavigateMulti(targets) {
+        const start = Date.now();
+        const tasks = targets.map(async (target) => {
+          const taskStart = Date.now();
+          const browser = this.browsers.get(target.browserId);
+          if (!browser) {
+            return {
+              browserId: target.browserId,
+              success: false,
+              error: `Browser ${target.browserId} not found`,
+              duration: Date.now() - taskStart
+            };
+          }
+          try {
+            await browser.page.goto(target.url, { waitUntil: "domcontentloaded" });
+            await browser.page.waitForLoadState("load", { timeout: 5e3 }).catch(() => {
+            });
+            return {
+              browserId: target.browserId,
+              success: true,
+              result: { url: browser.page.url(), title: await browser.page.title() },
+              duration: Date.now() - taskStart
+            };
+          } catch (error) {
+            return {
+              browserId: target.browserId,
+              success: false,
+              error: String(error),
+              duration: Date.now() - taskStart
+            };
+          }
+        });
+        const results = await Promise.all(tasks);
+        return {
+          results,
+          totalDuration: Date.now() - start,
+          successCount: results.filter((r) => r.success).length,
+          failureCount: results.filter((r) => !r.success).length
+        };
+      }
+      async parallelGoBack(browserIds) {
+        return this.executeParallel(browserIds, async (page) => {
+          await page.goBack();
+        });
+      }
+      async parallelGoForward(browserIds) {
+        return this.executeParallel(browserIds, async (page) => {
+          await page.goForward();
+        });
+      }
+      async parallelReload(browserIds) {
+        return this.executeParallel(browserIds, async (page) => {
+          await page.reload();
+        });
+      }
+      // ==================== SNAPSHOT ====================
+      async parallelSnapshot(browserIds, options = {}) {
+        const MAX_SNAPSHOT_SIZE = 3e4;
+        return this.executeParallel(
+          browserIds,
+          async (page, browserId) => {
+            const elements = await page.evaluate((compactMode) => {
+              const interactiveTags = /* @__PURE__ */ new Set(["a", "button", "input", "select", "textarea", "summary"]);
+              const interactiveRoles = /* @__PURE__ */ new Set([
+                "button",
+                "link",
+                "textbox",
+                "combobox",
+                "searchbox",
+                "checkbox",
+                "radio",
+                "switch",
+                "slider",
+                "spinbutton",
+                "menuitem",
+                "menuitemcheckbox",
+                "menuitemradio",
+                "option",
+                "tab",
+                "treeitem",
+                "listbox"
+              ]);
+              function buildSelector(el) {
+                const tag = el.tagName.toLowerCase();
+                if (el.id) return `#${CSS.escape(el.id)}`;
+                const testId = el.getAttribute("data-testid");
+                if (testId) return `[data-testid="${testId}"]`;
+                const name = el.getAttribute("name");
+                if (name) return `${tag}[name="${name}"]`;
+                const placeholder = el.getAttribute("placeholder");
+                if (placeholder) return `${tag}[placeholder="${placeholder}"]`;
+                const ariaLabel = el.getAttribute("aria-label");
+                if (ariaLabel) return `[aria-label="${ariaLabel}"]`;
+                const role = el.getAttribute("role");
+                if (role) {
+                  const text = el.textContent?.trim().slice(0, 40);
+                  if (text) return `role=${role}[name="${text}"]`;
+                  return `[role="${role}"]`;
+                }
+                if (tag === "button" || tag === "a") {
+                  const text = el.textContent?.trim().slice(0, 40);
+                  if (text) return `${tag}:has-text("${text}")`;
+                }
+                const type = el.getAttribute("type");
+                if (tag === "input" && type) return `input[type="${type}"]`;
+                if (el.className && typeof el.className === "string") {
+                  const cls = el.className.trim().split(/\s+/)[0];
+                  if (cls) return `${tag}.${CSS.escape(cls)}`;
+                }
+                return tag;
+              }
+              function findSection(el) {
+                let node = el;
+                while (node) {
+                  let sibling = node.previousElementSibling;
+                  while (sibling) {
+                    if (/^H[1-6]$/.test(sibling.tagName)) {
+                      return sibling.textContent?.trim().slice(0, 50) || "";
+                    }
+                    sibling = sibling.previousElementSibling;
+                  }
+                  const role = node.getAttribute("role");
+                  const ariaLabel = node.getAttribute("aria-label");
+                  if (role === "navigation" || role === "main" || role === "banner" || role === "dialog" || role === "form") {
+                    return `[${role}${ariaLabel ? ": " + ariaLabel : ""}]`;
+                  }
+                  if (node.tagName === "NAV" || node.tagName === "MAIN" || node.tagName === "HEADER" || node.tagName === "FOOTER" || node.tagName === "FORM") {
+                    const label = ariaLabel || node.getAttribute("name") || "";
+                    return `[${node.tagName.toLowerCase()}${label ? ": " + label : ""}]`;
+                  }
+                  node = node.parentElement;
+                }
+                return "";
+              }
+              const results = [];
+              const seen = /* @__PURE__ */ new Set();
+              if (!compactMode) {
+                const headings = Array.from(document.querySelectorAll("h1, h2, h3"));
+                for (const h of headings) {
+                  const text = h.textContent?.trim().slice(0, 80);
+                  if (text) {
+                    results.push({
+                      tag: h.tagName.toLowerCase(),
+                      selector: "",
+                      text
+                    });
+                  }
+                }
+              }
+              const allElements = Array.from(document.querySelectorAll("*"));
+              for (const el of allElements) {
+                const tag = el.tagName.toLowerCase();
+                const role = el.getAttribute("role");
+                const isInteractive = interactiveTags.has(tag) || role !== null && interactiveRoles.has(role) || el.getAttribute("contenteditable") === "true" || el.getAttribute("tabindex") !== null && el.getAttribute("tabindex") !== "-1";
+                if (!isInteractive) continue;
+                const rect = el.getBoundingClientRect();
+                if (rect.width === 0 && rect.height === 0) continue;
+                const style = window.getComputedStyle(el);
+                if (style.display === "none" || style.visibility === "hidden") continue;
+                const selector = buildSelector(el);
+                if (seen.has(selector)) continue;
+                seen.add(selector);
+                const text = el.textContent?.trim().slice(0, 60) || "";
+                const info = { tag, selector, text };
+                const type = el.getAttribute("type");
+                if (type) info.type = type;
+                if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) {
+                  if (el.value) info.value = el.value.slice(0, 60);
+                }
+                if (el instanceof HTMLInputElement && (el.type === "checkbox" || el.type === "radio")) {
+                  info.checked = el.checked;
+                }
+                if (el.getAttribute("disabled") !== null) {
+                  info.disabled = true;
+                }
+                const href = el.getAttribute("href");
+                if (href && href !== "#" && !href.startsWith("javascript:")) {
+                  info.href = href.slice(0, 100);
+                }
+                const placeholder = el.getAttribute("placeholder");
+                if (placeholder) info.placeholder = placeholder;
+                if (!compactMode) {
+                  const section = findSection(el);
+                  if (section) info.section = section;
+                }
+                results.push(info);
+              }
+              return results;
+            }, !!options.compact);
+            const refMap = /* @__PURE__ */ new Map();
+            let nextRef = 1;
+            const elementsWithRefs = elements.map((element) => {
+              if (!element.selector) return element;
+              const ref = String(nextRef++);
+              refMap.set(ref, element.selector);
+              return { ...element, ref };
+            });
+            this.snapshotRefs.set(browserId, refMap);
+            let snapshot = this.formatSnapshot(elementsWithRefs, !!options.compact);
+            if (snapshot.length > MAX_SNAPSHOT_SIZE) {
+              snapshot = snapshot.substring(0, MAX_SNAPSHOT_SIZE) + `
+
+... [TRUNCATED: ${elementsWithRefs.length} elements total, showing first ${MAX_SNAPSHOT_SIZE} chars]`;
+            }
+            return {
+              browserId,
+              snapshot,
+              url: page.url(),
+              title: await page.title()
+            };
+          },
+          { concurrency: "heavy" }
+        );
+      }
+      /**
+       * Format extracted elements into readable snapshot text
+       */
+      formatSnapshot(elements, compact) {
+        const lines = [];
+        let lastSection = "";
+        for (const el of elements) {
+          if (!el.selector && (el.tag === "h1" || el.tag === "h2" || el.tag === "h3")) {
+            lines.push(`
+## ${el.text}`);
+            continue;
+          }
+          if (!compact && el.section && el.section !== lastSection) {
+            lastSection = el.section;
+            lines.push(`
+--- ${el.section} ---`);
+          }
+          let line = `- ${el.tag}`;
+          if (el.type) line += `[type=${el.type}]`;
+          if (el.disabled) line += " (disabled)";
+          if (el.ref) line += ` [ref=${el.ref}]`;
+          line += `  \u2192  ${el.selector}`;
+          const details = [];
+          if (el.placeholder) details.push(`placeholder="${el.placeholder}"`);
+          if (el.value) details.push(`value="${el.value}"`);
+          if (el.checked !== void 0) details.push(el.checked ? "checked" : "unchecked");
+          if (el.text && el.text.length > 0) details.push(`"${el.text}"`);
+          if (el.href) details.push(`\u2192 ${el.href}`);
+          if (details.length > 0) {
+            line += `  ${details.join(" | ")}`;
+          }
+          lines.push(line);
+        }
+        return lines.join("\n");
+      }
+      /**
+       * Take screenshots from multiple browsers.
+       * OPTIMIZATION: Uses JPEG format with quality 70% for ~5x smaller files.
+       * For 9 browsers: ~4.5MB PNG → ~900KB JPEG
+       */
+      async parallelScreenshot(browserIds, options = {}) {
+        const format = options.format ?? "jpeg";
+        const quality = format === "jpeg" ? options.quality ?? 70 : void 0;
+        return this.executeParallel(
+          browserIds,
+          async (page) => {
+            return await page.screenshot({
+              fullPage: options.fullPage,
+              type: format,
+              quality
+            });
+          },
+          { concurrency: "heavy" }
+        );
+      }
+      // ==================== HUMAN-LIKE HELPERS ====================
+      /** Get or create a human profile for a browser */
+      getProfile(browserId) {
+        let profile = this.profiles.get(browserId);
+        if (!profile) {
+          profile = generateProfile(browserId);
+          this.profiles.set(browserId, profile);
+        }
+        return profile;
+      }
+      /** Get last known mouse position, or a random starting position */
+      getMousePos(browserId) {
+        return this.lastMousePosition.get(browserId) ?? {
+          x: 200 + Math.random() * 400,
+          y: 150 + Math.random() * 300
+        };
+      }
+      /** Update tracked mouse position */
+      setMousePos(browserId, pos) {
+        this.lastMousePosition.set(browserId, pos);
+      }
+      // ==================== REF-BASED INTERACTION (human-like) ====================
+      async parallelClick(target, browserIds) {
+        return this.executeParallel(browserIds, async (page, browserId) => {
+          const profile = this.getProfile(browserId);
+          const selector = this.resolveSelector(target, browserId);
+          const locator = page.locator(selector);
+          await locator.waitFor({ state: "visible", timeout: 5e3 });
+          await ensureCursor(page);
+          await preActionDelay(profile);
+          const { target: clickTarget } = await getClickTarget(page, locator);
+          const fromPos = this.getMousePos(browserId);
+          await humanClick(page, clickTarget, fromPos, profile);
+          this.setMousePos(browserId, clickTarget);
+        });
+      }
+      async parallelFill(target, text, browserIds) {
+        return this.executeParallel(browserIds, async (page, browserId) => {
+          const profile = this.getProfile(browserId);
+          const selector = this.resolveSelector(target, browserId);
+          const locator = page.locator(selector);
+          await locator.waitFor({ state: "visible", timeout: 5e3 });
+          await ensureCursor(page);
+          await preActionDelay(profile);
+          const { target: clickTarget } = await getClickTarget(page, locator);
+          const fromPos = this.getMousePos(browserId);
+          await humanClick(page, clickTarget, fromPos, profile);
+          this.setMousePos(browserId, clickTarget);
+          await humanDelay(80, 200);
+          await page.keyboard.press("Meta+a");
+          await humanDelay(30, 80);
+          await page.keyboard.press("Backspace");
+          await humanDelay(50, 150);
+          await humanTypeText(page, text, profile);
+          return `filled "${text}"`;
+        });
+      }
+      async parallelFillMulti(target, texts) {
+        const browserIds = Object.keys(texts);
+        return this.executeParallel(browserIds, async (page, browserId) => {
+          const text = texts[browserId];
+          if (!text) throw new Error(`No text provided for browser ${browserId}`);
+          const profile = this.getProfile(browserId);
+          const selector = this.resolveSelector(target, browserId);
+          const locator = page.locator(selector);
+          await locator.waitFor({ state: "visible", timeout: 5e3 });
+          await ensureCursor(page);
+          await preActionDelay(profile);
+          const { target: clickTarget } = await getClickTarget(page, locator);
+          const fromPos = this.getMousePos(browserId);
+          await humanClick(page, clickTarget, fromPos, profile);
+          this.setMousePos(browserId, clickTarget);
+          await humanDelay(80, 200);
+          await page.keyboard.press("Meta+a");
+          await humanDelay(30, 80);
+          await page.keyboard.press("Backspace");
+          await humanDelay(50, 150);
+          await humanTypeText(page, text, profile);
+        });
+      }
+      async parallelType(target, text, browserIds) {
+        return this.executeParallel(browserIds, async (page, browserId) => {
+          const profile = this.getProfile(browserId);
+          const selector = this.resolveSelector(target, browserId);
+          const locator = page.locator(selector);
+          await locator.waitFor({ state: "visible", timeout: 5e3 });
+          await ensureCursor(page);
+          const { target: clickTarget } = await getClickTarget(page, locator);
+          const fromPos = this.getMousePos(browserId);
+          await humanClick(page, clickTarget, fromPos, profile);
+          this.setMousePos(browserId, clickTarget);
+          await humanDelay(50, 150);
+          await humanTypeText(page, text, profile);
+        });
+      }
+      async parallelHover(target, browserIds) {
+        return this.executeParallel(browserIds, async (page, browserId) => {
+          const profile = this.getProfile(browserId);
+          const selector = this.resolveSelector(target, browserId);
+          const locator = page.locator(selector);
+          await locator.waitFor({ state: "visible", timeout: 5e3 });
+          await ensureCursor(page);
+          await preActionDelay(profile);
+          const { target: hoverTarget } = await getClickTarget(page, locator);
+          const fromPos = this.getMousePos(browserId);
+          await humanMouseMove(page, fromPos, hoverTarget, profile);
+          this.setMousePos(browserId, hoverTarget);
+        });
+      }
+      async parallelSelectOption(target, values, browserIds) {
+        return this.executeParallel(browserIds, async (page, browserId) => {
+          const profile = this.getProfile(browserId);
+          const selector = this.resolveSelector(target, browserId);
+          const locator = page.locator(selector);
+          await locator.waitFor({ state: "visible", timeout: 5e3 });
+          await ensureCursor(page);
+          await preActionDelay(profile);
+          const { target: clickTarget } = await getClickTarget(page, locator);
+          const fromPos = this.getMousePos(browserId);
+          await humanClick(page, clickTarget, fromPos, profile);
+          this.setMousePos(browserId, clickTarget);
+          await humanDelay(200, 500);
+          return await locator.selectOption(values);
+        });
+      }
+      async parallelPressKey(key, browserIds) {
+        return this.executeParallel(browserIds, async (page, browserId) => {
+          await preActionDelay(this.getProfile(browserId));
+          await page.keyboard.press(key);
+        });
+      }
+      async parallelClickCoordinates(coordinates, options = {}) {
+        const browserIds = Object.keys(coordinates);
+        return this.executeParallel(
+          browserIds,
+          async (page, browserId) => {
+            const profile = this.getProfile(browserId);
+            const target = coordinates[browserId];
+            if (!target) {
+              throw new Error(`No coordinates provided for browser ${browserId}`);
+            }
+            const viewport = page.viewportSize();
+            if (!viewport) {
+              throw new Error("Viewport size is not available for the page");
+            }
+            await ensureCursor(page);
+            await preActionDelay(profile);
+            if (options.fromViewport !== false) {
+              const clickX = Math.max(0, Math.min(Math.round(target.x), viewport.width - 1));
+              const clickY = Math.max(0, Math.min(Math.round(target.y), viewport.height - 1));
+              const fromPos = this.getMousePos(browserId);
+              await humanClick(page, { x: clickX, y: clickY }, fromPos, profile);
+              this.setMousePos(browserId, { x: clickX, y: clickY });
+              const scrollY = await page.evaluate(() => globalThis.scrollY ?? 0);
+              return {
+                clickedAt: { x: clickX, y: clickY },
+                documentY: scrollY + clickY,
+                scrollY
+              };
+            } else {
+              const desiredCenter = options.center ?? viewport.height / 2;
+              const desiredScroll = Math.max(0, Math.floor(target.y - desiredCenter));
+              await page.evaluate((scrollY) => {
+                globalThis.scrollTo?.(0, scrollY);
+              }, desiredScroll);
+              const actualScroll = await page.evaluate(() => globalThis.scrollY ?? 0);
+              const clickX = Math.max(0, Math.min(Math.round(target.x), viewport.width - 1));
+              const clickY = Math.round(target.y - actualScroll);
+              if (clickY < 0 || clickY > viewport.height) {
+                throw new Error(
+                  `Target Y=${target.y} is outside viewport after scrolling (scrollY=${actualScroll}, viewportHeight=${viewport.height})`
+                );
+              }
+              const fromPos = this.getMousePos(browserId);
+              await humanClick(page, { x: clickX, y: clickY }, fromPos, profile);
+              this.setMousePos(browserId, { x: clickX, y: clickY });
+              return {
+                clickedAt: { x: clickX, y: clickY },
+                documentY: target.y,
+                scrollY: actualScroll
+              };
+            }
+          },
+          { timeout: options.timeout ?? this.defaultTimeout }
+        );
+      }
+      /**
+       * Click at center of normalized bounding box (from OmniParser output)
+       */
+      async parallelClickNormalizedBox(box, browserIds, options = {}) {
+        const [x1, y1, x2, y2] = box;
+        if (x1 < 0 || x1 > 1 || x2 < 0 || x2 > 1 || y1 < 0 || y1 > 1 || y2 < 0 || y2 > 1) {
+          throw new Error("Coordinates must be normalized (0-1 range)");
+        }
+        const normalizedX = (x1 + x2) / 2;
+        const normalizedY = (y1 + y2) / 2;
+        return this.executeParallel(
+          browserIds,
+          async (page, browserId) => {
+            const profile = this.getProfile(browserId);
+            const viewport = page.viewportSize();
+            if (!viewport) {
+              throw new Error("Viewport size is not available");
+            }
+            const absoluteX = Math.round(normalizedX * viewport.width);
+            const absoluteY = Math.round(normalizedY * viewport.height);
+            await ensureCursor(page);
+            await preActionDelay(profile);
+            const fromPos = this.getMousePos(browserId);
+            await humanMouseMove(page, fromPos, { x: absoluteX, y: absoluteY }, profile);
+            await page.mouse.down({ button: options.button || "left" });
+            await humanDelay(50, 120);
+            await page.mouse.up({ button: options.button || "left" });
+            if (options.clickCount && options.clickCount > 1) {
+              for (let i = 1; i < options.clickCount; i++) {
+                await humanDelay(80, 150);
+                await page.mouse.down({ button: options.button || "left" });
+                await humanDelay(30, 80);
+                await page.mouse.up({ button: options.button || "left" });
+              }
+            }
+            this.setMousePos(browserId, { x: absoluteX, y: absoluteY });
+            return { absoluteX, absoluteY, viewport };
+          },
+          { timeout: options.timeout ?? this.defaultTimeout }
+        );
+      }
+      // ==================== CODE EXECUTION ====================
+      async parallelRunCode(code, browserIds) {
+        return this.executeParallel(browserIds, async (page) => {
+          const AsyncFunction = Object.getPrototypeOf(async function() {
+          }).constructor;
+          const fn = new AsyncFunction("page", code);
+          return await fn(page);
+        });
+      }
+      async parallelRunCodeWithVariables(codeTemplate, variables) {
+        const browserIds = Object.keys(variables);
+        return this.executeParallel(browserIds, async (page, browserId) => {
+          const vars = variables[browserId] || {};
+          let code = codeTemplate;
+          for (const [key, value] of Object.entries(vars)) {
+            code = code.replace(new RegExp(`{{${key}}}`, "g"), value);
+          }
+          const AsyncFunction = Object.getPrototypeOf(async function() {
+          }).constructor;
+          const fn = new AsyncFunction("page", code);
+          return await fn(page);
+        });
+      }
+      async parallelEvaluate(script, browserIds) {
+        return this.executeParallel(browserIds, async (page) => {
+          return await page.evaluate(script);
+        });
+      }
+      // ==================== WAITING ====================
+      async parallelWaitFor(options, browserIds) {
+        const waitTimeMs = options.time ? options.time * 1e3 : 0;
+        const textTimeout = options.timeoutMs ?? 3e4;
+        const domStableTimeout = options.timeoutMs ?? Math.max(options.domStableMs ?? 0, 5e3);
+        const timeout = waitTimeMs + Math.max(textTimeout, domStableTimeout) + 5e3;
+        return this.executeParallel(browserIds, async (page) => {
+          if (options.time) {
+            await page.waitForTimeout(options.time * 1e3);
+          }
+          if (options.text) {
+            await page.getByText(options.text).waitFor({ timeout: textTimeout });
+          }
+          if (options.textGone) {
+            await page.getByText(options.textGone).waitFor({ state: "hidden", timeout: textTimeout });
+          }
+          if (options.domStableMs) {
+            await this.waitForDomStable(page, options.domStableMs, domStableTimeout);
+          }
+        }, { timeout });
+      }
+      // ==================== FILE OPERATIONS (downloads, uploads, drag&drop) ====================
+      /** Cached project files directory path */
+      projectFilesDir = void 0;
+      /** Fetch project files directory from API (cached) */
+      async getProjectFilesDir() {
+        if (this.projectFilesDir !== void 0) return this.projectFilesDir;
+        const apiUrl = process.env.API_SERVER_URL;
+        const userId = process.env.USER_ID;
+        const deviceId = process.env.DEVICE_ID;
+        if (!apiUrl || !userId) {
+          this.projectFilesDir = null;
+          return null;
+        }
+        try {
+          const params = new URLSearchParams({ userId });
+          if (deviceId) params.set("deviceId", deviceId);
+          const resp = await fetch(`${apiUrl}/api/project-path?${params}`);
+          const data = await resp.json();
+          this.projectFilesDir = data.localPath;
+          console.error(`[Executor] Project files dir: ${this.projectFilesDir}`);
+          return this.projectFilesDir;
+        } catch (e) {
+          console.error(`[Executor] Failed to fetch project path:`, e);
+          this.projectFilesDir = null;
+          return null;
+        }
+      }
+      /** Configure browser to download files to project directory */
+      async setupDownloads(browserIds) {
+        const dir = await this.getProjectFilesDir();
+        if (!dir) {
+          throw new Error("Project files directory not available \u2014 file relay may not be connected");
+        }
+        return this.executeParallel(browserIds, async (page) => {
+          const cdp = await page.context().newCDPSession(page);
+          try {
+            await cdp.send("Page.setDownloadBehavior", {
+              behavior: "allow",
+              downloadPath: dir
+            });
+          } finally {
+            await cdp.detach().catch(() => {
+            });
+          }
+          return `Downloads \u2192 ${dir}`;
+        });
+      }
+      /** List files in the project directory */
+      async listProjectFiles() {
+        const dir = await this.getProjectFilesDir();
+        if (!dir) return [];
+        try {
+          const files = await readdir(dir);
+          const items = await Promise.all(
+            files.filter((file) => !file.startsWith(".")).map(async (file) => {
+              const fileStat = await stat(join2(dir, file));
+              return { name: file, size: fileStat.size, modified: fileStat.mtimeMs };
+            })
+          );
+          return items;
+        } catch {
+        }
+        return [];
+      }
+      /** Upload a file from project directory via filechooser (selector-based) */
+      async parallelUploadFile(target, fileName, browserIds) {
+        const dir = await this.getProjectFilesDir();
+        if (!dir) {
+          throw new Error("Project files directory not available");
+        }
+        return this.executeParallel(browserIds, async (page, browserId) => {
+          const profile = this.getProfile(browserId);
+          const selector = this.resolveSelector(target, browserId);
+          const locator = page.locator(selector);
+          await locator.waitFor({ state: "visible", timeout: 5e3 });
+          await ensureCursor(page);
+          await preActionDelay(profile);
+          const fileChooserPromise = page.waitForEvent("filechooser", { timeout: 1e4 });
+          const { target: clickTarget } = await getClickTarget(page, locator);
+          const fromPos = this.getMousePos(browserId);
+          await humanClick(page, clickTarget, fromPos, profile);
+          this.setMousePos(browserId, clickTarget);
+          const fileChooser = await fileChooserPromise;
+          const filePath = join2(dir, fileName);
+          await fileChooser.setFiles(filePath);
+          return `Uploaded "${fileName}" from ${dir}`;
+        }, { timeout: 15e3 });
+      }
+      // ==================== BATCH FORM FILL ====================
+      async parallelFillForm(fields, browserIds) {
+        return this.executeParallel(browserIds, async (page, browserId) => {
+          const profile = this.getProfile(browserId);
+          const filled = [];
+          for (const field of fields) {
+            const selector = this.resolveSelector(field, browserId);
+            const locator = page.locator(selector);
+            await locator.waitFor({ state: "visible", timeout: 5e3 });
+            await ensureCursor(page);
+            await preActionDelay(profile);
+            if (field.type === "checkbox") {
+              if (this.isTruthyFieldValue(field.value)) {
+                await locator.check();
+              } else {
+                await locator.uncheck();
+              }
+              filled.push(`${selector}=${field.value}`);
+              continue;
+            }
+            if (field.type === "radio") {
+              await locator.check();
+              filled.push(`${selector}=${field.value}`);
+              continue;
+            }
+            if (field.type === "combobox") {
+              const { target: clickTarget2 } = await getClickTarget(page, locator);
+              const fromPos2 = this.getMousePos(browserId);
+              await humanClick(page, clickTarget2, fromPos2, profile);
+              this.setMousePos(browserId, clickTarget2);
+              await humanDelay(120, 240);
+              await locator.selectOption(field.value);
+              filled.push(`${selector}="${field.value}"`);
+              continue;
+            }
+            const { target: clickTarget } = await getClickTarget(page, locator);
+            const fromPos = this.getMousePos(browserId);
+            await humanClick(page, clickTarget, fromPos, profile);
+            this.setMousePos(browserId, clickTarget);
+            await humanDelay(80, 200);
+            await page.keyboard.press("Meta+a");
+            await humanDelay(30, 80);
+            await page.keyboard.press("Backspace");
+            await humanDelay(50, 150);
+            await humanTypeText(page, field.value, profile);
+            filled.push(`${selector}="${field.value}"`);
+          }
+          return `Filled ${filled.length} fields: ${filled.join(", ")}`;
+        }, { timeout: fields.length * 5e3 + 5e3 });
+      }
+      // ==================== ELEMENT DRAG & DROP ====================
+      async parallelDrag(startTarget, endTarget, browserIds) {
+        return this.executeParallel(browserIds, async (page, browserId) => {
+          const profile = this.getProfile(browserId);
+          const startSelector = this.resolveSelector(startTarget, browserId);
+          const endSelector = this.resolveSelector(endTarget, browserId);
+          const startLocator = page.locator(startSelector);
+          const endLocator = page.locator(endSelector);
+          await startLocator.waitFor({ state: "visible", timeout: 5e3 });
+          await endLocator.waitFor({ state: "visible", timeout: 5e3 });
+          await ensureCursor(page);
+          await preActionDelay(profile);
+          const { target: startPos } = await getClickTarget(page, startLocator);
+          const { target: endPos } = await getClickTarget(page, endLocator);
+          const fromPos = this.getMousePos(browserId);
+          await humanMouseMove(page, fromPos, startPos, profile);
+          await humanDelay(50, 150);
+          await page.mouse.down();
+          await humanDelay(100, 250);
+          await humanMouseMove(page, startPos, endPos, profile);
+          await humanDelay(50, 150);
+          await page.mouse.up();
+          this.setMousePos(browserId, endPos);
+          return `Dragged "${startSelector}" \u2192 "${endSelector}"`;
+        }, { timeout: 15e3 });
+      }
+      // ==================== TAB MANAGEMENT ====================
+      async parallelTabs(action, options = {}, browserIds) {
+        return this.executeParallel(browserIds, async (page, browserId) => {
+          const browser = this.browsers.get(browserId);
+          if (!browser) throw new Error(`Browser ${browserId} not found`);
+          const context = browser.context;
+          const pages = context.pages();
+          switch (action) {
+            case "list": {
+              return pages.map((p, i) => ({
+                index: i,
+                url: p.url(),
+                active: p === browser.page
+              }));
+            }
+            case "new": {
+              const newPage = await context.newPage();
+              if (options.url) {
+                await newPage.goto(options.url, { waitUntil: "domcontentloaded" });
+              }
+              browser.page = newPage;
+              newPage.setDefaultTimeout(this.defaultTimeout);
+              newPage.setDefaultNavigationTimeout(6e4);
+              this._setupPageTracking(browserId, newPage);
+              return { index: context.pages().length - 1, url: newPage.url() };
+            }
+            case "close": {
+              const idx = options.index ?? pages.indexOf(browser.page);
+              if (idx < 0 || idx >= pages.length) throw new Error(`Tab index ${idx} out of range (0-${pages.length - 1})`);
+              const targetPage = pages[idx];
+              await targetPage.close();
+              if (targetPage === browser.page) {
+                const remaining = context.pages();
+                if (remaining.length > 0) {
+                  browser.page = remaining[Math.min(idx, remaining.length - 1)];
+                }
+              }
+              return { closed: idx, remaining: context.pages().length };
+            }
+            case "select": {
+              if (options.index === void 0) throw new Error("index required for select action");
+              const currentPages = context.pages();
+              if (options.index < 0 || options.index >= currentPages.length) {
+                throw new Error(`Tab index ${options.index} out of range (0-${currentPages.length - 1})`);
+              }
+              browser.page = currentPages[options.index];
+              await browser.page.bringToFront();
+              return { selected: options.index, url: browser.page.url() };
+            }
+          }
+        }, { timeout: 3e4 });
+      }
+      /** Set up console/network tracking on a new page */
+      _setupPageTracking(browserId, page) {
+        const consoleLog = this.consoleMessages.get(browserId);
+        if (consoleLog) {
+          page.on("console", (msg) => {
+            consoleLog.push({ type: msg.type(), text: msg.text(), timestamp: Date.now() });
+            if (consoleLog.length > 1e3) consoleLog.shift();
+          });
+        }
+        const networkLog = this.networkRequests.get(browserId);
+        if (networkLog) {
+          page.on("response", (response) => {
+            const req = response.request();
+            networkLog.push({
+              url: req.url(),
+              method: req.method(),
+              status: response.status(),
+              resourceType: req.resourceType(),
+              timestamp: Date.now()
+            });
+            if (networkLog.length > 1e3) networkLog.shift();
+          });
+        }
+      }
+      // ==================== DIALOG HANDLING ====================
+      async parallelHandleDialog(accept, promptText, browserIds) {
+        return this.executeParallel(browserIds, async (page) => {
+          return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+              reject(new Error("No dialog appeared within 10 seconds"));
+            }, 1e4);
+            page.once("dialog", async (dialog) => {
+              clearTimeout(timeout);
+              const type = dialog.type();
+              const message = dialog.message();
+              try {
+                if (accept) {
+                  await dialog.accept(promptText);
+                } else {
+                  await dialog.dismiss();
+                }
+                resolve(`${accept ? "Accepted" : "Dismissed"} ${type} dialog: "${message}"`);
+              } catch (e) {
+                reject(e);
+              }
+            });
+          });
+        }, { timeout: 15e3 });
+      }
+      // ==================== CONSOLE MESSAGES ====================
+      async parallelConsoleMessages(onlyErrors, browserIds) {
+        await this.ensureBrowsersLoaded();
+        const ids = browserIds ?? this.getBrowserIds();
+        const results = ids.map((id) => {
+          let messages = this.consoleMessages.get(id) || [];
+          if (onlyErrors) {
+            messages = messages.filter((m) => m.type === "error");
+          }
+          return {
+            browserId: id,
+            success: true,
+            result: [...messages],
+            duration: 0
+          };
+        });
+        return {
+          results,
+          totalDuration: 0,
+          successCount: results.length,
+          failureCount: 0
+        };
+      }
+      // ==================== NETWORK REQUESTS ====================
+      async parallelNetworkRequests(browserIds) {
+        await this.ensureBrowsersLoaded();
+        const ids = browserIds ?? this.getBrowserIds();
+        const results = ids.map((id) => {
+          const requests = this.networkRequests.get(id) || [];
+          return {
+            browserId: id,
+            success: true,
+            result: [...requests],
+            duration: 0
+          };
+        });
+        return {
+          results,
+          totalDuration: 0,
+          successCount: results.length,
+          failureCount: 0
+        };
+      }
+      /** Drag and drop a file onto a dropzone (selector-based) */
+      async parallelDragDropFile(target, fileName, browserIds) {
+        const dir = await this.getProjectFilesDir();
+        if (!dir) {
+          throw new Error("Project files directory not available");
+        }
+        return this.executeParallel(browserIds, async (page, browserId) => {
+          const profile = this.getProfile(browserId);
+          const selector = this.resolveSelector(target, browserId);
+          const locator = page.locator(selector);
+          await locator.waitFor({ state: "visible", timeout: 5e3 });
+          await ensureCursor(page);
+          await preActionDelay(profile);
+          const { target: dropTarget } = await getClickTarget(page, locator);
+          const fromPos = this.getMousePos(browserId);
+          await humanMouseMove(page, fromPos, dropTarget, profile);
+          this.setMousePos(browserId, dropTarget);
+          const filePath = join2(dir, fileName);
+          const fileBytes = Array.from(await readFile(filePath));
+          const mimeType = this.getMimeType(fileName);
+          await page.evaluate(async ({
+            x,
+            y,
+            fileName: fileName2,
+            mimeType: mimeType2,
+            fileBytes: fileBytes2
+          }) => {
+            const dropzone = document.elementFromPoint(x, y);
+            if (!dropzone) throw new Error("No element at drop coordinates");
+            const dataTransfer = new DataTransfer();
+            const file = new File([new Uint8Array(fileBytes2)], fileName2, { type: mimeType2 });
+            dataTransfer.items.add(file);
+            const events = ["dragenter", "dragover", "drop"];
+            for (const eventType of events) {
+              const event = new DragEvent(eventType, {
+                bubbles: true,
+                cancelable: true,
+                dataTransfer
+              });
+              dropzone.dispatchEvent(event);
+              await new Promise((r) => setTimeout(r, 50));
+            }
+          }, { x: dropTarget.x, y: dropTarget.y, fileName, mimeType, fileBytes });
+          return `Dropped "${fileName}" onto element`;
+        }, { timeout: 15e3 });
+      }
+    };
+  }
+});
+
+// client/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { readFileSync } from "node:fs";
+import { z } from "zod";
+import WebSocket from "ws";
+var args = process.argv.slice(2);
+var getArg = (name) => {
+  const i = args.indexOf(`--${name}`);
+  return i >= 0 ? args[i + 1] : void 0;
+};
+function getOptionalPort(argName, envName) {
+  const raw = getArg(argName) ?? process.env[envName];
+  if (raw === void 0 || raw === "") return void 0;
+  const port = Number.parseInt(raw, 10);
+  if (!Number.isFinite(port) || port <= 0) {
+    console.error(`[ornold] Invalid --${argName}: ${raw}`);
+    process.exit(1);
+  }
+  return port;
+}
+var TOKEN = getArg("token") || process.env.ORNOLD_TOKEN || "";
+var SERVER_URL = getArg("server") || process.env.ORNOLD_SERVER || "wss://ornold-mcp.fly.dev/bridge";
+var LINKEN_PORT = getOptionalPort("linken-port", "LINKEN_PORT");
+var DOLPHIN_PORT = getOptionalPort("dolphin-port", "DOLPHIN_PORT");
+var ENABLED_VENDORS = [
+  ...LINKEN_PORT !== void 0 ? ["linken"] : [],
+  ...DOLPHIN_PORT !== void 0 ? ["dolphin"] : []
+];
+function getPackageVersion() {
+  try {
+    const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    return packageJson.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var CLIENT_VERSION = getPackageVersion();
+if (!TOKEN) {
+  console.error("Usage: npx ornold-mcp --token <your_token>");
+  console.error("Get your token at https://ornold-mcp.fly.dev");
+  process.exit(1);
+}
+var ws = null;
+var serverReady = false;
+var pendingCalls = /* @__PURE__ */ new Map();
+var callCounter = 0;
+function connectServer() {
+  return new Promise((resolve, reject) => {
+    console.error(`[ornold] Connecting to ${SERVER_URL}...`);
+    ws = new WebSocket(`${SERVER_URL}?token=${TOKEN}`);
+    ws.on("open", () => {
+      console.error("[ornold] Connected to server");
+    });
+    ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        if (msg.type === "connected") {
+          serverReady = true;
+          console.error(`[ornold] Authenticated. Plan: ${msg.plan}, Profiles: ${msg.limits?.profiles}, Captchas: ${msg.limits?.captchas}`);
+          resolve();
+        }
+        if (msg.type === "error") {
+          console.error(`[ornold] Server error: ${msg.message}`);
+          if (!serverReady) reject(new Error(msg.message));
+        }
+        if (msg.type === "tool_result" && msg.requestId) {
+          const p = pendingCalls.get(msg.requestId);
+          if (p) {
+            clearTimeout(p.timer);
+            pendingCalls.delete(msg.requestId);
+            p.resolve(msg.result);
+          }
+        }
+        if (msg.type === "execute") {
+          handleExecuteCommand(msg).then((result) => {
+            ws?.send(JSON.stringify({
+              type: "execute_result",
+              requestId: msg.requestId,
+              result
+            }));
+          });
+        }
+      } catch {
+      }
+    });
+    ws.on("close", (code) => {
+      serverReady = false;
+      if (code === 4001) {
+        console.error("[ornold] Invalid token. Get your token at https://ornold-mcp.fly.dev");
+        process.exit(1);
+      }
+      console.error(`[ornold] Disconnected (${code}). Reconnecting in 3s...`);
+      setTimeout(connectServer, 3e3);
+    });
+    ws.on("error", (err) => {
+      console.error(`[ornold] WS error: ${err.message}`);
+    });
+  });
+}
+function callServer(tool, toolArgs) {
+  if (!ws || ws.readyState !== WebSocket.OPEN || !serverReady) {
+    return Promise.resolve({ content: "Not connected to Ornold server. Check your token and internet connection.", isError: true });
+  }
+  const requestId = `r_${++callCounter}`;
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      pendingCalls.delete(requestId);
+      resolve({ content: "Server timeout", isError: true });
+    }, 12e4);
+    pendingCalls.set(requestId, { resolve, timer });
+    ws.send(JSON.stringify({
+      type: "tool_call",
+      requestId,
+      tool,
+      args: toolArgs
+    }));
+  });
+}
+var executor = null;
+async function getExecutor() {
+  if (!executor) {
+    const { MultiBrowserExecutor: MultiBrowserExecutor2 } = await Promise.resolve().then(() => (init_multi_browser(), multi_browser_exports));
+    executor = new MultiBrowserExecutor2();
+  }
+  return executor;
+}
+function getSelectorTarget(params) {
+  const selector = typeof params.selector === "string" ? params.selector : void 0;
+  const ref = typeof params.ref === "string" || typeof params.ref === "number" ? String(params.ref) : void 0;
+  if (!selector && !ref) {
+    throw new Error("Either selector or ref is required");
+  }
+  return selector ? { selector } : { ref };
+}
+async function handleExecuteCommand(msg) {
+  const { command, params } = msg;
+  try {
+    switch (command) {
+      // CDP commands — executed via local Patchright
+      case "cdp_status": {
+        const exec = await getExecutor();
+        await exec.ensureBrowsersLoaded();
+        const status = await exec.getDetailedStatus({ checkContent: !!params.checkContent });
+        return { content: JSON.stringify(status), isError: false };
+      }
+      case "cdp_tabs": {
+        const exec = await getExecutor();
+        const r = await exec.parallelTabs(params.action, { index: params.index, url: params.url }, params.browserIds);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_navigate": {
+        const exec = await getExecutor();
+        const r = await exec.parallelNavigate(params.url, params.browserIds);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_navigate_multi": {
+        const exec = await getExecutor();
+        const r = await exec.parallelNavigateMulti(params.targets);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_click": {
+        const exec = await getExecutor();
+        const r = await exec.parallelClick(getSelectorTarget(params), params.browserIds);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_type": {
+        const exec = await getExecutor();
+        const r = await exec.parallelType(getSelectorTarget(params), params.text, params.browserIds);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_fill": {
+        const exec = await getExecutor();
+        const target = getSelectorTarget(params);
+        const r = params.texts ? await exec.parallelFillMulti(target, params.texts) : await exec.parallelFill(target, params.text, params.browserIds);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_fill_multi": {
+        const exec = await getExecutor();
+        const r = await exec.parallelFillMulti(getSelectorTarget(params), params.texts);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_fill_form": {
+        const exec = await getExecutor();
+        const r = await exec.parallelFillForm(params.fields, params.browserIds);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_drag": {
+        const exec = await getExecutor();
+        const r = await exec.parallelDrag(
+          {
+            selector: typeof params.startSelector === "string" ? params.startSelector : void 0,
+            ref: typeof params.startRef === "string" || typeof params.startRef === "number" ? String(params.startRef) : void 0
+          },
+          {
+            selector: typeof params.endSelector === "string" ? params.endSelector : void 0,
+            ref: typeof params.endRef === "string" || typeof params.endRef === "number" ? String(params.endRef) : void 0
+          },
+          params.browserIds
+        );
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_snapshot": {
+        const exec = await getExecutor();
+        const r = await exec.parallelSnapshot(params.browserIds, { compact: params.compact });
+        const parts = (r.results || []).map((item) => {
+          if (!item.success) return `[${item.browserId}] ERROR: ${item.error || "unknown"}`;
+          const result = item.result || {};
+          return `### ${item.browserId}
+URL: ${result.url || ""}
+Title: ${result.title || ""}
+${result.snapshot || ""}`;
+        });
+        return { content: parts.join("\n\n") || "OK", isError: false };
+      }
+      case "cdp_screenshot": {
+        const exec = await getExecutor();
+        const r = await exec.parallelScreenshot(params.browserIds, { fullPage: params.fullPage });
+        const lines = (r.results || []).map((item) => {
+          if (!item.success) return `[${item.browserId}] ERROR: ${item.error || "unknown"}`;
+          const image = Buffer.isBuffer(item.result) ? item.result.toString("base64") : Buffer.from(item.result || []).toString("base64");
+          return `[${item.browserId}] ${image}`;
+        });
+        return { content: lines.join("\n") || "OK", isError: false };
+      }
+      case "cdp_evaluate": {
+        const exec = await getExecutor();
+        const r = await exec.parallelEvaluate(params.script, params.browserIds);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_run_code": {
+        const exec = await getExecutor();
+        const r = await exec.parallelRunCode(params.code, params.browserIds);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_run_code_with_vars": {
+        const exec = await getExecutor();
+        const r = await exec.parallelRunCodeWithVariables(params.codeTemplate, params.variables);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_press_key": {
+        const exec = await getExecutor();
+        const r = await exec.parallelPressKey(params.key, params.browserIds);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_select_option": {
+        const exec = await getExecutor();
+        const r = await exec.parallelSelectOption(getSelectorTarget(params), params.values, params.browserIds);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_hover": {
+        const exec = await getExecutor();
+        const r = await exec.parallelHover(getSelectorTarget(params), params.browserIds);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_go_back": {
+        const exec = await getExecutor();
+        const r = await exec.parallelGoBack(params.browserIds);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_go_forward": {
+        const exec = await getExecutor();
+        const r = await exec.parallelGoForward(params.browserIds);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_reload": {
+        const exec = await getExecutor();
+        const r = await exec.parallelReload(params.browserIds);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_wait_for": {
+        const exec = await getExecutor();
+        const opts = {};
+        if (params.time) opts.time = params.time;
+        if (params.text) opts.text = params.text;
+        if (params.textGone) opts.textGone = params.textGone;
+        if (params.domStableMs) opts.domStableMs = params.domStableMs;
+        if (params.timeoutMs) opts.timeoutMs = params.timeoutMs;
+        const r = await exec.parallelWaitFor(opts, params.browserIds);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_handle_dialog": {
+        const exec = await getExecutor();
+        const r = await exec.parallelHandleDialog(!!params.accept, params.promptText, params.browserIds);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_console_messages": {
+        const exec = await getExecutor();
+        const r = await exec.parallelConsoleMessages(!!params.onlyErrors, params.browserIds);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_network_requests": {
+        const exec = await getExecutor();
+        const r = await exec.parallelNetworkRequests(params.browserIds);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_click_normalized_box": {
+        const exec = await getExecutor();
+        const r = await exec.parallelClickNormalizedBox(params.box, params.browserIds);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_setup_downloads": {
+        const exec = await getExecutor();
+        const r = await exec.setupDownloads(params.browserIds);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_list_downloads": {
+        const exec = await getExecutor();
+        const files = await exec.listProjectFiles();
+        return { content: JSON.stringify(files), isError: false };
+      }
+      case "cdp_upload_file": {
+        const exec = await getExecutor();
+        const r = await exec.parallelUploadFile(getSelectorTarget(params), params.fileName, params.browserIds);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_drag_drop_file": {
+        const exec = await getExecutor();
+        const r = await exec.parallelDragDropFile(getSelectorTarget(params), params.fileName, params.browserIds);
+        return { content: formatResult(r), isError: false };
+      }
+      case "cdp_vision_capture": {
+        const exec = await getExecutor();
+        await exec.ensureBrowsersLoaded();
+        const statuses = await exec.listBrowsers();
+        const statusMap = new Map(statuses.map((browser) => [browser.id, browser]));
+        const screenshotResult = await exec.parallelScreenshot(params.browserIds, {
+          format: "jpeg",
+          quality: 70
+        });
+        const captures = (screenshotResult.results || []).filter((item) => item.success && item.result !== void 0).map((item) => ({
+          browserId: item.browserId,
+          url: statusMap.get(item.browserId)?.url || "",
+          screenshot: Buffer.isBuffer(item.result) ? item.result.toString("base64") : Buffer.from(item.result || []).toString("base64")
+        }));
+        const errors = (screenshotResult.results || []).filter((item) => !item.success).map((item) => ({
+          browserId: item.browserId,
+          error: item.error || "unknown"
+        }));
+        return { content: JSON.stringify({ captures, errors }), isError: captures.length === 0 };
+      }
+      case "cdp_list_browsers": {
+        const exec = await getExecutor();
+        await exec.ensureBrowsersLoaded();
+        const browsers = await exec.listBrowsers();
+        return { content: browsers.length === 0 ? "No browsers connected" : browsers.map((b) => `${b.id} ${b.connected ? "OK" : "DISCONNECTED"} ${b.url || ""}`).join("\n"), isError: false };
+      }
+      case "cdp_connect": {
+        const exec = await getExecutor();
+        await exec.connect({ id: params.id, cdpEndpoint: params.cdpEndpoint });
+        return { content: `Connected: ${params.id}`, isError: false };
+      }
+      case "cdp_disconnect": {
+        const exec = await getExecutor();
+        await exec.disconnect(params.id);
+        return { content: `Disconnected: ${params.id}`, isError: false };
+      }
+      // Press and hold (for captcha solving)
+      case "cdp_press_hold": {
+        const exec = await getExecutor();
+        const browsers = params.browserIds ? void 0 : await exec.listBrowsers();
+        const targetId = params.browserIds?.[0] || browsers?.[0]?.id;
+        if (!targetId) return { content: "No browser connected", isError: true };
+        const page = exec.getPage(targetId);
+        if (!page) return { content: "Browser page not found", isError: true };
+        const x = params.x;
+        const y = params.y;
+        const duration = params.duration;
+        await page.mouse.move(x, y);
+        await page.mouse.down();
+        const start = Date.now();
+        while (Date.now() - start < duration) {
+          await page.waitForTimeout(80 + Math.random() * 170);
+          await page.mouse.move(x + (Math.random() - 0.5) * 6, y + (Math.random() - 0.5) * 6);
+        }
+        await page.mouse.up();
+        return { content: JSON.stringify({ held: true, duration }), isError: false };
+      }
+      // Antidetect HTTP proxy — executed locally
+      case "http_request": {
+        const resp = await fetch(params.url, {
+          method: params.method || "GET",
+          headers: params.headers || { "Content-Type": "application/json" },
+          body: params.body ? JSON.stringify(params.body) : void 0,
+          signal: AbortSignal.timeout(3e4)
+        });
+        const data = await resp.text();
+        try {
+          return { content: JSON.stringify(JSON.parse(data)), isError: !resp.ok };
+        } catch {
+          return { content: data, isError: !resp.ok };
+        }
+      }
+      default:
+        return { content: `Unknown command: ${command}`, isError: true };
+    }
+  } catch (e) {
+    return { content: `Execution error: ${e.message}`, isError: true };
+  }
+}
+function formatResult(r) {
+  const lines = [];
+  for (const item of r.results || []) {
+    if (item.success && item.result !== void 0) {
+      const val = typeof item.result === "string" ? item.result : JSON.stringify(item.result);
+      lines.push(`[${item.browserId}] ${val.slice(0, 4e3)}`);
+    } else if (!item.success) {
+      lines.push(`[${item.browserId}] ERROR: ${item.error || "unknown"}`);
+    }
+  }
+  return lines.join("\n") || "OK";
+}
+function textResult(text, isError = false) {
+  return { content: [{ type: "text", text }], isError };
+}
+async function toolHandler(tool, args2) {
+  const result = await callServer(tool, args2);
+  return textResult(result.content, result.isError);
+}
+function registerLinkenTools(server) {
+  server.tool("linken_get_instances", "Get list of Linken Sphere sessions", {
+    status: z.enum(["stopped", "running", "imported", "warmup", "automationRunning"]).optional(),
+    proxy_info: z.boolean().optional()
+  }, (args2) => toolHandler("linken_get_instances", args2));
+  server.tool("linken_create_quick_sessions", "Create Linken Sphere sessions", {
+    count: z.number().optional()
+  }, (args2) => toolHandler("linken_create_quick_sessions", args2));
+  server.tool("linken_start_instances", "Start Linken browser sessions", {
+    uuids: z.array(z.string()),
+    headless: z.boolean().optional(),
+    debug_port: z.number().optional(),
+    _scope: z.string().optional()
+  }, (args2) => toolHandler("linken_start_instances", args2));
+  server.tool("linken_stop_instances", "Stop Linken sessions", {
+    uuids: z.array(z.string())
+  }, (args2) => toolHandler("linken_stop_instances", args2));
+  server.tool("linken_session_info", "Get session details", {
+    uuid: z.string()
+  }, (args2) => toolHandler("linken_session_info", args2));
+  server.tool("linken_force_stop", "Force stop Linken session", {
+    uuid: z.string()
+  }, (args2) => toolHandler("linken_force_stop", args2));
+  server.tool("linken_delete_sessions", "Delete Linken sessions", {
+    uuid: z.string().optional(),
+    uuids: z.array(z.string()).optional()
+  }, (args2) => toolHandler("linken_delete_sessions", args2));
+  server.tool("linken_unlock_stopped_sessions", "Unlock stopped Linken sessions", {}, () => toolHandler("linken_unlock_stopped_sessions", {}));
+  server.tool("linken_set_session_name", "Rename Linken session", {
+    uuid: z.string(),
+    name: z.string()
+  }, (args2) => toolHandler("linken_set_session_name", args2));
+  server.tool("linken_set_connection", "Set proxy for Linken session", {
+    uuid: z.string(),
+    type: z.string(),
+    ip: z.string().optional(),
+    port: z.number().optional(),
+    login: z.string().optional(),
+    password: z.string().optional()
+  }, (args2) => toolHandler("linken_set_connection", args2));
+  server.tool("linken_check_connection", "Check proxy for Linken session", {
+    uuid: z.string()
+  }, (args2) => toolHandler("linken_check_connection", args2));
+  server.tool("linken_set_geo", "Set Linken geolocation", {
+    uuid: z.string(),
+    timezone: z.string().optional(),
+    language: z.string().optional(),
+    latitude: z.number().optional(),
+    longitude: z.number().optional()
+  }, (args2) => toolHandler("linken_set_geo", args2));
+  server.tool("linken_set_useragent", "Set Linken user agent", {
+    uuid: z.string(),
+    useragent: z.string()
+  }, (args2) => toolHandler("linken_set_useragent", args2));
+  server.tool("linken_import_cookies", "Import cookies into Linken session", {
+    uuid: z.string(),
+    file_path: z.string().optional(),
+    json: z.string().optional()
+  }, (args2) => toolHandler("linken_import_cookies", args2));
+  server.tool("linken_export_cookies", "Export cookies from Linken sessions", {
+    uuids: z.array(z.string()),
+    folder_path: z.string()
+  }, (args2) => toolHandler("linken_export_cookies", args2));
+  server.tool("linken_start_warmup", "Start Linken session warmup", {
+    uuid: z.string(),
+    url_count: z.number().optional(),
+    time_per_url: z.number().optional(),
+    view_depth: z.number().optional(),
+    urls: z.array(z.string()).optional()
+  }, (args2) => toolHandler("linken_start_warmup", args2));
+  server.tool("linken_get_providers", "List Linken providers", {}, () => toolHandler("linken_get_providers", {}));
+  server.tool("linken_set_active_provider", "Set active Linken provider", {
+    uuid: z.string()
+  }, (args2) => toolHandler("linken_set_active_provider", args2));
+  server.tool("linken_delete_provider", "Delete Linken provider", {
+    uuid: z.string()
+  }, (args2) => toolHandler("linken_delete_provider", args2));
+  server.tool("linken_get_desktops", "List Linken desktops", {}, () => toolHandler("linken_get_desktops", {}));
+  server.tool("linken_create_desktop", "Create Linken desktop", {
+    name: z.string(),
+    team_uuid: z.string().optional()
+  }, (args2) => toolHandler("linken_create_desktop", args2));
+  server.tool("linken_set_active_desktop", "Set active Linken desktop", {
+    uuid: z.string()
+  }, (args2) => toolHandler("linken_set_active_desktop", args2));
+  server.tool("linken_delete_desktop", "Delete Linken desktop", {
+    uuid: z.string()
+  }, (args2) => toolHandler("linken_delete_desktop", args2));
+  server.tool("linken_optimize_storage", "Optimize Linken storage", {}, () => toolHandler("linken_optimize_storage", {}));
+}
+var browserIdsArg = z.array(z.string()).optional();
+var browserScopeArg = z.string().optional();
+var browserRefArg = z.union([z.string(), z.number()]).optional();
+var browserTargetArgs = {
+  element: z.string().optional(),
+  ref: browserRefArg,
+  selector: z.string().optional(),
+  browserIds: browserIdsArg,
+  _scope: browserScopeArg
+};
+function createServer() {
+  const server = new McpServer({ name: "ornold-browser", version: CLIENT_VERSION });
+  server.tool("browser_list", "List connected browsers", {}, () => toolHandler("browser_list", {}));
+  server.tool("browser_status", "Check browser sync and responsiveness", {
+    checkContent: z.boolean().optional(),
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_status", args2));
+  server.tool("browser_parallel_tabs", "Manage browser tabs in parallel", {
+    action: z.enum(["list", "new", "close", "select"]),
+    index: z.number().optional(),
+    url: z.string().optional(),
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_parallel_tabs", args2));
+  server.tool("browser_parallel_snapshot", "Get page snapshot with [ref=N] markers", {
+    compact: z.boolean().optional(),
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_parallel_snapshot", args2));
+  server.tool("browser_parallel_navigate", "Navigate to URL", {
+    url: z.string(),
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_parallel_navigate", args2));
+  server.tool("browser_parallel_navigate_multi", "Navigate each browser to a different URL", {
+    targets: z.array(z.object({
+      browserId: z.string(),
+      url: z.string()
+    })),
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_parallel_navigate_multi", args2));
+  server.tool("browser_parallel_click", "Click element", {
+    ...browserTargetArgs
+  }, (args2) => toolHandler("browser_parallel_click", args2));
+  server.tool("browser_parallel_type", "Type text into element", {
+    ...browserTargetArgs,
+    text: z.string()
+  }, (args2) => toolHandler("browser_parallel_type", args2));
+  server.tool("browser_parallel_fill", "Fill input (clear + type)", {
+    ...browserTargetArgs,
+    text: z.string().optional(),
+    texts: z.record(z.string()).optional()
+  }, (args2) => toolHandler("browser_parallel_fill", args2));
+  server.tool("browser_parallel_fill_multi", "Fill input with per-browser values", {
+    ...browserTargetArgs,
+    texts: z.record(z.string())
+  }, (args2) => toolHandler("browser_parallel_fill_multi", args2));
+  server.tool("browser_parallel_fill_form", "Fill multiple form fields sequentially", {
+    fields: z.array(z.object({
+      element: z.string().optional(),
+      ref: browserRefArg,
+      selector: z.string().optional(),
+      value: z.string(),
+      type: z.enum(["textbox", "checkbox", "radio", "combobox"]).optional()
+    })),
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_parallel_fill_form", args2));
+  server.tool("browser_parallel_drag", "Drag from one element to another", {
+    startElement: z.string().optional(),
+    startRef: browserRefArg,
+    startSelector: z.string().optional(),
+    endElement: z.string().optional(),
+    endRef: browserRefArg,
+    endSelector: z.string().optional(),
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_parallel_drag", args2));
+  server.tool("browser_parallel_press_key", "Press keyboard key", {
+    key: z.string(),
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_parallel_press_key", args2));
+  server.tool("browser_parallel_select_option", "Select dropdown option", {
+    ...browserTargetArgs,
+    values: z.array(z.string())
+  }, (args2) => toolHandler("browser_parallel_select_option", args2));
+  server.tool("browser_parallel_wait_for", "Wait for condition", {
+    time: z.number().optional(),
+    text: z.string().optional(),
+    textGone: z.string().optional(),
+    domStableMs: z.number().optional(),
+    timeoutMs: z.number().optional(),
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_parallel_wait_for", args2));
+  server.tool("browser_parallel_screenshot", "Take screenshot", {
+    fullPage: z.boolean().optional(),
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_parallel_screenshot", args2));
+  server.tool("browser_parallel_evaluate", "Run JavaScript in page", {
+    script: z.string(),
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_parallel_evaluate", args2));
+  server.tool("browser_parallel_run_code", "Run JavaScript code in page context", {
+    code: z.string(),
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_parallel_run_code", args2));
+  server.tool("browser_parallel_run_code_with_vars", "Run templated JavaScript code with per-browser variables", {
+    codeTemplate: z.string(),
+    variables: z.record(z.record(z.string())),
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_parallel_run_code_with_vars", args2));
+  server.tool("browser_parallel_hover", "Hover over element", {
+    ...browserTargetArgs
+  }, (args2) => toolHandler("browser_parallel_hover", args2));
+  server.tool("browser_parallel_go_back", "Go back", {
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_parallel_go_back", args2));
+  server.tool("browser_parallel_go_forward", "Go forward", {
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_parallel_go_forward", args2));
+  server.tool("browser_parallel_reload", "Reload page", {
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_parallel_reload", args2));
+  server.tool("browser_parallel_handle_dialog", "Handle JavaScript dialogs", {
+    accept: z.boolean(),
+    promptText: z.string().optional(),
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_parallel_handle_dialog", args2));
+  server.tool("browser_parallel_console_messages", "Get console messages", {
+    onlyErrors: z.boolean().optional(),
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_parallel_console_messages", args2));
+  server.tool("browser_parallel_network_requests", "Get network requests", {
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_parallel_network_requests", args2));
+  server.tool("browser_parallel_vision_analyze_grouped", "Analyze grouped browser screenshots with OmniParser via Ornold server", {
+    similarityThreshold: z.number().optional(),
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_parallel_vision_analyze_grouped", args2));
+  server.tool("browser_parallel_click_normalized_box", "Click normalized viewport box center", {
+    box: z.tuple([z.number(), z.number(), z.number(), z.number()]),
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_parallel_click_normalized_box", args2));
+  server.tool("browser_setup_downloads", "Enable browser downloads to project files directory", {
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_setup_downloads", args2));
+  server.tool("browser_list_downloads", "List files in project files directory", {}, () => toolHandler("browser_list_downloads", {}));
+  server.tool("browser_parallel_upload_file", "Upload a file to an input element", {
+    ...browserTargetArgs,
+    fileName: z.string()
+  }, (args2) => toolHandler("browser_parallel_upload_file", args2));
+  server.tool("browser_parallel_drag_drop_file", "Drag and drop a file onto an element", {
+    ...browserTargetArgs,
+    fileName: z.string()
+  }, (args2) => toolHandler("browser_parallel_drag_drop_file", args2));
+  server.tool("browser_search_macros", "Search saved browser macros", {
+    name: z.string(),
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_search_macros", args2));
+  server.tool("browser_run_recorded_flow", "Run saved browser macro by ID", {
+    macroId: z.string(),
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_run_recorded_flow", args2));
+  if (LINKEN_PORT !== void 0) {
+    registerLinkenTools(server);
+  }
+  if (DOLPHIN_PORT !== void 0) {
+    server.tool("dolphin_get_profiles", "List Dolphin profiles", {}, () => toolHandler("dolphin_get_profiles", {}));
+    server.tool("dolphin_start_profile", "Start Dolphin profile", {
+      profileId: z.string()
+    }, (args2) => toolHandler("dolphin_start_profile", args2));
+    server.tool("dolphin_stop_profile", "Stop Dolphin profile", {
+      profileId: z.string()
+    }, (args2) => toolHandler("dolphin_stop_profile", args2));
+  }
+  server.tool("browser_detect_captcha", "Detect captcha on page", {
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_detect_captcha", args2));
+  server.tool("browser_solve_press_hold", "Solve press-and-hold captcha", {
+    browserIds: browserIdsArg,
+    maxAttempts: z.number().optional(),
+    holdMs: z.number().optional(),
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_solve_press_hold", args2));
+  server.tool("browser_detect_press_hold", "Detect press-and-hold captcha", {
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_detect_press_hold", args2));
+  server.tool("browser_solve_captcha", "Solve captcha (reCAPTCHA/hCaptcha)", {
+    browserIds: browserIdsArg,
+    timeout: z.number().optional(),
+    autoSubmit: z.boolean().optional(),
+    _scope: browserScopeArg
+  }, (args2) => toolHandler("browser_solve_captcha", args2));
+  server.tool("browser_captcha_balance", "Check 2captcha balance", {}, () => toolHandler("browser_captcha_balance", {}));
+  server.tool("captcha_detect", "Detect captcha on page", {
+    browserIds: browserIdsArg
+  }, (args2) => toolHandler("captcha_detect", args2));
+  server.tool("captcha_solve_press_hold", "Solve press-and-hold captcha", {
+    browserIds: browserIdsArg
+  }, (args2) => toolHandler("captcha_solve_press_hold", args2));
+  server.tool("captcha_solve", "Solve captcha (reCAPTCHA/hCaptcha)", {
+    browserIds: browserIdsArg
+  }, (args2) => toolHandler("captcha_solve", args2));
+  return server;
+}
+async function main() {
+  await connectServer();
+  if (ENABLED_VENDORS.length === 0) {
+    console.error("[ornold] No antidetect vendor ports configured. Only browser_* and captcha_* tools will be available.");
+  }
+  for (const [name, port] of [["linken", LINKEN_PORT], ["dolphin", DOLPHIN_PORT]]) {
+    if (port === void 0) continue;
+    try {
+      const resp = await fetch(`http://127.0.0.1:${port}/sessions`, { signal: AbortSignal.timeout(2e3) });
+      if (resp.ok) console.error(`[ornold] ${name}: detected on port ${port}`);
+    } catch {
+    }
+  }
+  ws?.send(JSON.stringify({
+    type: "bridge_hello",
+    hostname: (await import("os")).hostname(),
+    config: {
+      enabledVendors: ENABLED_VENDORS,
+      ...LINKEN_PORT !== void 0 ? { linkenPort: LINKEN_PORT } : {},
+      ...DOLPHIN_PORT !== void 0 ? { dolphinPort: DOLPHIN_PORT } : {}
+    }
+  }));
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("[ornold] MCP server ready (stdio)");
+}
+main().catch((e) => {
+  console.error(`[ornold] Fatal: ${e.message}`);
+  process.exit(1);
+});