ornold-mcp 1.0.1 → 1.0.3

package/dist/cli.js

@@ -463,6 +463,8 @@ __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"() {
@@ -484,6 +486,8 @@ var init_multi_browser = __esm({
       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)
@@ -644,6 +648,7 @@ var init_multi_browser = __esm({
         };
         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) => {
@@ -668,6 +673,7 @@ var init_multi_browser = __esm({
           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}...`);
@@ -701,6 +707,7 @@ var init_multi_browser = __esm({
         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());
@@ -940,6 +947,60 @@ var init_multi_browser = __esm({
         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
@@ -1249,11 +1310,20 @@ var init_multi_browser = __esm({
               }
               return results;
             }, !!options.compact);
-            let snapshot = this.formatSnapshot(elements, !!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: ${elements.length} elements total, showing first ${MAX_SNAPSHOT_SIZE} chars]`;
+... [TRUNCATED: ${elementsWithRefs.length} elements total, showing first ${MAX_SNAPSHOT_SIZE} chars]`;
             }
             return {
               browserId,
@@ -1285,6 +1355,7 @@ var init_multi_browser = __esm({
           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}"`);
@@ -1341,30 +1412,32 @@ var init_multi_browser = __esm({
         this.lastMousePosition.set(browserId, pos);
       }
       // ==================== REF-BASED INTERACTION (human-like) ====================
-      async parallelClick(selector, browserIds) {
+      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 } = await getClickTarget(page, locator);
+          const { target: clickTarget } = await getClickTarget(page, locator);
           const fromPos = this.getMousePos(browserId);
-          await humanClick(page, target, fromPos, profile);
-          this.setMousePos(browserId, target);
+          await humanClick(page, clickTarget, fromPos, profile);
+          this.setMousePos(browserId, clickTarget);
         });
       }
-      async parallelFill(selector, text, browserIds) {
+      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 } = await getClickTarget(page, locator);
+          const { target: clickTarget } = await getClickTarget(page, locator);
           const fromPos = this.getMousePos(browserId);
-          await humanClick(page, target, fromPos, profile);
-          this.setMousePos(browserId, target);
+          await humanClick(page, clickTarget, fromPos, profile);
+          this.setMousePos(browserId, clickTarget);
           await humanDelay(80, 200);
           await page.keyboard.press("Meta+a");
           await humanDelay(30, 80);
@@ -1374,20 +1447,21 @@ var init_multi_browser = __esm({
           return `filled "${text}"`;
         });
       }
-      async parallelFillMulti(selector, texts) {
+      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 } = await getClickTarget(page, locator);
+          const { target: clickTarget } = await getClickTarget(page, locator);
           const fromPos = this.getMousePos(browserId);
-          await humanClick(page, target, fromPos, profile);
-          this.setMousePos(browserId, target);
+          await humanClick(page, clickTarget, fromPos, profile);
+          this.setMousePos(browserId, clickTarget);
           await humanDelay(80, 200);
           await page.keyboard.press("Meta+a");
           await humanDelay(30, 80);
@@ -1396,44 +1470,47 @@ var init_multi_browser = __esm({
           await humanTypeText(page, text, profile);
         });
       }
-      async parallelType(selector, text, browserIds) {
+      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 } = await getClickTarget(page, locator);
+          const { target: clickTarget } = await getClickTarget(page, locator);
           const fromPos = this.getMousePos(browserId);
-          await humanClick(page, target, fromPos, profile);
-          this.setMousePos(browserId, target);
+          await humanClick(page, clickTarget, fromPos, profile);
+          this.setMousePos(browserId, clickTarget);
           await humanDelay(50, 150);
           await humanTypeText(page, text, profile);
         });
       }
-      async parallelHover(selector, browserIds) {
+      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 } = await getClickTarget(page, locator);
+          const { target: hoverTarget } = await getClickTarget(page, locator);
           const fromPos = this.getMousePos(browserId);
-          await humanMouseMove(page, fromPos, target, profile);
-          this.setMousePos(browserId, target);
+          await humanMouseMove(page, fromPos, hoverTarget, profile);
+          this.setMousePos(browserId, hoverTarget);
         });
       }
-      async parallelSelectOption(selector, values, browserIds) {
+      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 } = await getClickTarget(page, locator);
+          const { target: clickTarget } = await getClickTarget(page, locator);
           const fromPos = this.getMousePos(browserId);
-          await humanClick(page, target, fromPos, profile);
-          this.setMousePos(browserId, target);
+          await humanClick(page, clickTarget, fromPos, profile);
+          this.setMousePos(browserId, clickTarget);
           await humanDelay(200, 500);
           return await locator.selectOption(values);
         });
@@ -1571,8 +1648,9 @@ var init_multi_browser = __esm({
       // ==================== WAITING ====================
       async parallelWaitFor(options, browserIds) {
         const waitTimeMs = options.time ? options.time * 1e3 : 0;
-        const textTimeout = 3e4;
-        const timeout = waitTimeMs + textTimeout + 5e3;
+        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);
@@ -1583,6 +1661,9 @@ var init_multi_browser = __esm({
           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) ====================
@@ -1636,62 +1717,39 @@ var init_multi_browser = __esm({
       async listProjectFiles() {
         const dir = await this.getProjectFilesDir();
         if (!dir) return [];
-        const ids = this.getBrowserIds();
-        if (ids.length === 0) return [];
-        const browser = this.browsers.get(ids[0]);
-        if (!browser) return [];
         try {
-          const cdp = await browser.page.context().newCDPSession(browser.page);
-          try {
-            const result = await cdp.send("Runtime.evaluate", {
-              expression: `
-            (() => {
-              try {
-                const fs = require('fs');
-                const path = require('path');
-                const dir = ${JSON.stringify(dir)};
-                if (!fs.existsSync(dir)) return JSON.stringify([]);
-                const files = fs.readdirSync(dir).filter(f => !f.startsWith('.'));
-                return JSON.stringify(files.map(f => {
-                  const stat = fs.statSync(path.join(dir, f));
-                  return { name: f, size: stat.size, modified: stat.mtimeMs };
-                }));
-              } catch(e) { return JSON.stringify({ error: e.message }); }
-            })()
-          `,
-              returnByValue: true
-            });
-            const value = result.result?.value;
-            if (typeof value === "string") {
-              return JSON.parse(value);
-            }
-          } finally {
-            await cdp.detach().catch(() => {
-            });
-          }
+          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(selector, fileName, browserIds) {
+      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 } = await getClickTarget(page, locator);
+          const { target: clickTarget } = await getClickTarget(page, locator);
           const fromPos = this.getMousePos(browserId);
-          await humanClick(page, target, fromPos, profile);
-          this.setMousePos(browserId, target);
+          await humanClick(page, clickTarget, fromPos, profile);
+          this.setMousePos(browserId, clickTarget);
           const fileChooser = await fileChooserPromise;
-          const filePath = `${dir}/${fileName}`;
+          const filePath = join2(dir, fileName);
           await fileChooser.setFiles(filePath);
           return `Uploaded "${fileName}" from ${dir}`;
         }, { timeout: 15e3 });
@@ -1702,29 +1760,56 @@ var init_multi_browser = __esm({
           const profile = this.getProfile(browserId);
           const filled = [];
           for (const field of fields) {
-            const locator = page.locator(field.selector);
+            const selector = this.resolveSelector(field, browserId);
+            const locator = page.locator(selector);
             await locator.waitFor({ state: "visible", timeout: 5e3 });
             await ensureCursor(page);
             await preActionDelay(profile);
-            const { target } = await getClickTarget(page, locator);
+            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, target, fromPos, profile);
-            this.setMousePos(browserId, target);
+            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(`${field.selector}="${field.value}"`);
+            filled.push(`${selector}="${field.value}"`);
           }
           return `Filled ${filled.length} fields: ${filled.join(", ")}`;
         }, { timeout: fields.length * 5e3 + 5e3 });
       }
       // ==================== ELEMENT DRAG & DROP ====================
-      async parallelDrag(startSelector, endSelector, browserIds) {
+      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 });
@@ -1890,35 +1975,37 @@ var init_multi_browser = __esm({
         };
       }
       /** Drag and drop a file onto a dropzone (selector-based) */
-      async parallelDragDropFile(selector, fileName, browserIds) {
+      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 } = await getClickTarget(page, locator);
+          const { target: dropTarget } = await getClickTarget(page, locator);
           const fromPos = this.getMousePos(browserId);
-          await humanMouseMove(page, fromPos, target, profile);
-          this.setMousePos(browserId, target);
-          const filePath = `${dir}/${fileName}`;
-          await page.evaluate(async ({ x, y, fileName: fileName2, filePath: filePath2 }) => {
+          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();
-            try {
-              const resp = await fetch(`file://${filePath2}`);
-              const blob = await resp.blob();
-              const file = new File([blob], fileName2, { type: blob.type });
-              dataTransfer.items.add(file);
-            } catch {
-              const file = new File([""], fileName2);
-              dataTransfer.items.add(file);
-            }
+            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, {
@@ -1929,7 +2016,7 @@ var init_multi_browser = __esm({
               dropzone.dispatchEvent(event);
               await new Promise((r) => setTimeout(r, 50));
             }
-          }, { x: target.x, y: target.y, fileName, filePath });
+          }, { x: dropTarget.x, y: dropTarget.y, fileName, mimeType, fileBytes });
           return `Dropped "${fileName}" onto element`;
         }, { timeout: 15e3 });
       }
@@ -1948,10 +2035,39 @@ var getArg = (name) => {
   const i = args.indexOf(`--${name}`);
   return i >= 0 ? args[i + 1] : void 0;
 };
+var getArgAny = (...names) => names.map((name) => getArg(name)).find((value) => value !== void 0);
+var getEnvAny = (...names) => names.map((name) => process.env[name]).find((value) => value !== void 0 && value !== "");
+function getOptionalPort(argNames, envNames) {
+  const raw = getArgAny(...Array.isArray(argNames) ? argNames : [argNames]) ?? getEnvAny(...Array.isArray(envNames) ? envNames : [envNames]);
+  if (raw === void 0 || raw === "") return void 0;
+  const port = Number.parseInt(raw, 10);
+  if (!Number.isFinite(port) || port <= 0) {
+    const flagName = Array.isArray(argNames) ? argNames[0] : argNames;
+    console.error(`[ornold] Invalid --${flagName}: ${raw}`);
+    process.exit(1);
+  }
+  return port;
+}
+function getOptionalString(argNames, envNames) {
+  const raw = getArgAny(...Array.isArray(argNames) ? argNames : [argNames]) ?? getEnvAny(...Array.isArray(envNames) ? envNames : [envNames]);
+  if (raw === void 0) return void 0;
+  const value = raw.trim();
+  return value === "" ? void 0 : value;
+}
 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 = parseInt(getArg("linken-port") || process.env.LINKEN_PORT || "8080");
-var DOLPHIN_PORT = parseInt(getArg("dolphin-port") || process.env.DOLPHIN_PORT || "3001");
+var LINKEN_PORT = getOptionalPort("linken-port", "LINKEN_PORT");
+var WADEX_PORT = getOptionalPort("wadex-port", "WADEX_PORT");
+var DOLPHIN_PORT = getOptionalPort("dolphin-port", "DOLPHIN_PORT");
+var DOLPHIN_API_TOKEN = getOptionalString("dolphin-token", "DOLPHIN_API_TOKEN");
+var VISION_PORT = getOptionalPort(["vision-port", "vision-local-port"], ["VISION_PORT", "VISION_LOCAL_PORT"]);
+var VISION_TOKEN = getOptionalString(["vision-token", "vision-x-token"], ["VISION_TOKEN", "VISION_X_TOKEN"]);
+var ENABLED_VENDORS = [
+  ...LINKEN_PORT !== void 0 ? ["linken"] : [],
+  ...WADEX_PORT !== void 0 ? ["wadex"] : [],
+  ...DOLPHIN_PORT !== void 0 || DOLPHIN_API_TOKEN !== void 0 ? ["dolphin"] : [],
+  ...VISION_TOKEN !== void 0 ? ["vision"] : []
+];
 function getPackageVersion() {
   try {
     const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
@@ -2050,46 +2166,190 @@ async function getExecutor() {
   }
   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 };
+}
+function appendQueryValue(params, key, value) {
+  if (value === void 0 || value === null) return;
+  if (Array.isArray(value)) {
+    for (const item of value) appendQueryValue(params, key, item);
+    return;
+  }
+  if (typeof value === "object") {
+    params.append(key, JSON.stringify(value));
+    return;
+  }
+  params.append(key, String(value));
+}
+function withQuery(path2, query) {
+  if (!query) return path2;
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    appendQueryValue(params, key, value);
+  }
+  const search = params.toString();
+  return search ? `${path2}?${search}` : path2;
+}
+async function runVendorRequest(vendor, params) {
+  const target = params.target === "local" ? "local" : "cloud";
+  const path2 = typeof params.path === "string" ? params.path : "/";
+  const method = typeof params.method === "string" ? params.method : "GET";
+  const query = params.query && typeof params.query === "object" ? params.query : void 0;
+  let url;
+  const headers = {};
+  if (vendor === "dolphin") {
+    if (target === "cloud") {
+      if (!DOLPHIN_API_TOKEN) {
+        return { content: "DOLPHIN_API_TOKEN is not configured on this machine.", isError: true };
+      }
+      url = `https://dolphin-anty-api.com${withQuery(path2, query)}`;
+      headers.Authorization = `Bearer ${DOLPHIN_API_TOKEN}`;
+    } else {
+      if (DOLPHIN_PORT === void 0) {
+        return { content: "Dolphin local port is not configured on this machine.", isError: true };
+      }
+      url = `http://127.0.0.1:${DOLPHIN_PORT}${withQuery(path2, query)}`;
+    }
+  } else {
+    if (!VISION_TOKEN) {
+      return { content: "VISION_TOKEN is not configured on this machine.", isError: true };
+    }
+    headers["X-Token"] = VISION_TOKEN;
+    if (target === "cloud") {
+      url = `https://v1.empr.cloud/api/v1${withQuery(path2, query)}`;
+    } else {
+      if (VISION_PORT === void 0) {
+        return { content: "Vision local port is not configured on this machine.", isError: true };
+      }
+      url = `http://127.0.0.1:${VISION_PORT}${withQuery(path2, query)}`;
+    }
+  }
+  if (params.body !== void 0) {
+    headers["Content-Type"] = "application/json";
+  }
+  const resp = await fetch(url, {
+    method,
+    headers,
+    body: params.body !== void 0 ? 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 };
+  }
+}
 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(params.selector, params.browserIds);
+        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(params.selector, params.text, params.browserIds);
+        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 r = await exec.parallelFill(params.selector, params.text, params.browserIds);
+        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 });
-        return { content: formatResult(r), isError: false };
+        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);
-        return { content: formatResult(r), isError: false };
+        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);
@@ -2097,12 +2357,12 @@ async function handleExecuteCommand(msg) {
       }
       case "cdp_select_option": {
         const exec = await getExecutor();
-        const r = await exec.parallelSelectOption(params.selector, params.values, params.browserIds);
+        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(params.selector, params.browserIds);
+        const r = await exec.parallelHover(getSelectorTarget(params), params.browserIds);
         return { content: formatResult(r), isError: false };
       }
       case "cdp_go_back": {
@@ -2110,6 +2370,11 @@ async function handleExecuteCommand(msg) {
         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);
@@ -2120,11 +2385,75 @@ async function handleExecuteCommand(msg) {
         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 };
       }
@@ -2174,6 +2503,10 @@ async function handleExecuteCommand(msg) {
           return { content: data, isError: !resp.ok };
         }
       }
+      case "dolphin_request":
+        return await runVendorRequest("dolphin", params);
+      case "vision_request":
+        return await runVendorRequest("vision", params);
       default:
         return { content: `Unknown command: ${command}`, isError: true };
     }
@@ -2200,121 +2533,555 @@ async function toolHandler(tool, args2) {
   const result = await callServer(tool, args2);
   return textResult(result.content, result.isError);
 }
+var sphereStatusArg = z.enum(["stopped", "running", "imported", "warmup", "automationRunning"]).optional();
+var sphereProxyTypeArg = z.enum(["notSet", "socks5", "http", "ssh", "liveSocks5", "liveHttp", "direct", "tor", "localhost", "freeProxy"]);
+var visionFolderIconArg = z.enum([
+  "Cloud",
+  "Google",
+  "Facebook",
+  "TikTok",
+  "Amazon",
+  "Bitcoin",
+  "Meta",
+  "PayPal",
+  "Discord",
+  "Twitter",
+  "Vkontakte",
+  "Youtube",
+  "Tinder",
+  "Onlyfans",
+  "Threads"
+]);
+var visionFolderColorArg = z.enum([
+  "#FFC1073D",
+  "#C8E4FFCD",
+  "#3366FF3D",
+  "#54D62C3D",
+  "#FF48423D",
+  "#919EAB3D"
+]);
+var visionPlatformArg = z.enum(["macos", "windows", "linux"]);
+var visionProfilePlatformArg = z.enum(["Windows", "MacOS", "Linux", "windows", "macos", "linux"]);
+var visionBrowserArg = z.enum(["Chrome", "chrome"]);
+var visionProxyTypeArg = z.enum(["HTTP", "SOCKS4", "SOCKS5", "SSH", "http", "socks4", "socks5", "ssh"]);
+function registerSphereTools(server, prefix, label) {
+  server.tool(`${prefix}_get_instances`, `Get list of ${label} sessions`, {
+    status: sphereStatusArg,
+    proxy_info: z.boolean().optional()
+  }, (args2) => toolHandler(`${prefix}_get_instances`, args2));
+  server.tool(`${prefix}_create_quick_sessions`, `Create ${label} sessions`, {
+    count: z.number().optional()
+  }, (args2) => toolHandler(`${prefix}_create_quick_sessions`, args2));
+  server.tool(`${prefix}_start_instances`, `Start ${label} browser sessions`, {
+    uuids: z.array(z.string()),
+    headless: z.boolean().optional(),
+    debug_port: z.number().optional(),
+    _scope: z.string().optional()
+  }, (args2) => toolHandler(`${prefix}_start_instances`, args2));
+  server.tool(`${prefix}_stop_instances`, `Stop ${label} sessions`, {
+    uuids: z.array(z.string())
+  }, (args2) => toolHandler(`${prefix}_stop_instances`, args2));
+  server.tool(`${prefix}_session_info`, `Get ${label} session details`, {
+    uuid: z.string()
+  }, (args2) => toolHandler(`${prefix}_session_info`, args2));
+  server.tool(`${prefix}_force_stop`, `Force stop ${label} session`, {
+    uuid: z.string()
+  }, (args2) => toolHandler(`${prefix}_force_stop`, args2));
+  server.tool(`${prefix}_delete_sessions`, `Delete ${label} sessions`, {
+    uuid: z.string().optional(),
+    uuids: z.array(z.string()).optional()
+  }, (args2) => toolHandler(`${prefix}_delete_sessions`, args2));
+  server.tool(`${prefix}_unlock_stopped_sessions`, `Unlock stopped ${label} sessions`, {}, () => toolHandler(`${prefix}_unlock_stopped_sessions`, {}));
+  server.tool(`${prefix}_set_session_name`, `Rename ${label} session`, {
+    uuid: z.string(),
+    name: z.string()
+  }, (args2) => toolHandler(`${prefix}_set_session_name`, args2));
+  server.tool(`${prefix}_set_connection`, `Set proxy for ${label} session`, {
+    uuid: z.string(),
+    type: sphereProxyTypeArg,
+    ip: z.string().optional(),
+    port: z.number().optional(),
+    login: z.string().optional(),
+    password: z.string().optional()
+  }, (args2) => toolHandler(`${prefix}_set_connection`, args2));
+  server.tool(`${prefix}_check_connection`, `Check proxy for ${label} session`, {
+    uuid: z.string()
+  }, (args2) => toolHandler(`${prefix}_check_connection`, args2));
+  server.tool(`${prefix}_set_geo`, `Set ${label} geolocation`, {
+    uuid: z.string(),
+    timezone: z.string().optional(),
+    language: z.string().optional(),
+    latitude: z.number().optional(),
+    longitude: z.number().optional()
+  }, (args2) => toolHandler(`${prefix}_set_geo`, args2));
+  server.tool(`${prefix}_set_useragent`, `Set ${label} user agent`, {
+    uuid: z.string(),
+    useragent: z.string()
+  }, (args2) => toolHandler(`${prefix}_set_useragent`, args2));
+  server.tool(`${prefix}_import_cookies`, `Import cookies into ${label} session`, {
+    uuid: z.string(),
+    file_path: z.string().optional(),
+    json: z.string().optional()
+  }, (args2) => toolHandler(`${prefix}_import_cookies`, args2));
+  server.tool(`${prefix}_export_cookies`, `Export cookies from ${label} sessions`, {
+    uuids: z.array(z.string()),
+    folder_path: z.string()
+  }, (args2) => toolHandler(`${prefix}_export_cookies`, args2));
+  server.tool(`${prefix}_start_warmup`, `Start ${label} 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(`${prefix}_start_warmup`, args2));
+  server.tool(`${prefix}_get_providers`, `List ${label} providers`, {}, () => toolHandler(`${prefix}_get_providers`, {}));
+  server.tool(`${prefix}_set_active_provider`, `Set active ${label} provider`, {
+    uuid: z.string()
+  }, (args2) => toolHandler(`${prefix}_set_active_provider`, args2));
+  server.tool(`${prefix}_delete_provider`, `Delete ${label} provider`, {
+    uuid: z.string()
+  }, (args2) => toolHandler(`${prefix}_delete_provider`, args2));
+  server.tool(`${prefix}_get_desktops`, `List ${label} desktops`, {}, () => toolHandler(`${prefix}_get_desktops`, {}));
+  server.tool(`${prefix}_create_desktop`, `Create ${label} desktop`, {
+    name: z.string(),
+    team_uuid: z.string().optional()
+  }, (args2) => toolHandler(`${prefix}_create_desktop`, args2));
+  server.tool(`${prefix}_set_active_desktop`, `Set active ${label} desktop`, {
+    uuid: z.string()
+  }, (args2) => toolHandler(`${prefix}_set_active_desktop`, args2));
+  server.tool(`${prefix}_delete_desktop`, `Delete ${label} desktop`, {
+    uuid: z.string()
+  }, (args2) => toolHandler(`${prefix}_delete_desktop`, args2));
+  server.tool(`${prefix}_optimize_storage`, `Optimize ${label} storage`, {}, () => toolHandler(`${prefix}_optimize_storage`, {}));
+}
+function registerDolphinTools(server) {
+  if (DOLPHIN_API_TOKEN !== void 0) {
+    server.tool("dolphin_get_profiles", "Get list of Dolphin Anty browser profiles", {
+      limit: z.number().optional(),
+      page: z.number().optional(),
+      query: z.string().optional(),
+      tags: z.array(z.string()).optional(),
+      statuses: z.array(z.number()).optional(),
+      mainWebsites: z.array(z.string()).optional()
+    }, (args2) => toolHandler("dolphin_get_profiles", args2));
+  }
+  if (DOLPHIN_PORT !== void 0) {
+    server.tool("dolphin_start_profile", "Start a Dolphin Anty browser profile", {
+      profile_id: z.number(),
+      headless: z.boolean().optional(),
+      _scope: z.string().optional()
+    }, (args2) => toolHandler("dolphin_start_profile", args2));
+    server.tool("dolphin_stop_profile", "Stop a running Dolphin Anty browser profile", {
+      profile_id: z.number()
+    }, (args2) => toolHandler("dolphin_stop_profile", args2));
+  }
+}
+function registerVisionTools(server) {
+  if (VISION_TOKEN === void 0) {
+    return;
+  }
+  server.tool("vision_get_folders", "Get Vision Browser folders via Cloud API", {}, () => toolHandler("vision_get_folders", {}));
+  server.tool("vision_create_folder", "Create a Vision Browser folder via Cloud API", {
+    folder_name: z.string(),
+    folder_icon: visionFolderIconArg,
+    folder_color: visionFolderColorArg
+  }, (args2) => toolHandler("vision_create_folder", args2));
+  server.tool("vision_update_folder", "Update a Vision Browser folder via Cloud API", {
+    folder_id: z.string(),
+    folder_name: z.string().optional(),
+    folder_icon: visionFolderIconArg.optional(),
+    folder_color: visionFolderColorArg.optional()
+  }, (args2) => toolHandler("vision_update_folder", args2));
+  server.tool("vision_delete_folder", "Delete a Vision Browser folder via Cloud API", {
+    folder_id: z.string()
+  }, (args2) => toolHandler("vision_delete_folder", args2));
+  server.tool("vision_get_profiles", "Get Vision Browser profiles from a specific folder via Cloud API", {
+    folder_id: z.string(),
+    name: z.string().optional(),
+    pn: z.number().optional(),
+    ps: z.number().optional()
+  }, (args2) => toolHandler("vision_get_profiles", args2));
+  server.tool("vision_get_profile", "Get a specific Vision Browser profile via Cloud API", {
+    folder_id: z.string(),
+    profile_id: z.string()
+  }, (args2) => toolHandler("vision_get_profile", args2));
+  server.tool("vision_get_fingerprint", "Get a Vision Browser fingerprint via Cloud API", {
+    platform: visionPlatformArg,
+    version: z.number().optional()
+  }, (args2) => toolHandler("vision_get_fingerprint", args2));
+  server.tool("vision_import_cookies", "Import cookies into a Vision Browser profile via Cloud API", {
+    folder_id: z.string(),
+    profile_id: z.string(),
+    cookies: z.array(z.object({
+      name: z.string(),
+      value: z.string(),
+      path: z.string(),
+      domain: z.string(),
+      expires: z.number().optional()
+    }).passthrough())
+  }, (args2) => toolHandler("vision_import_cookies", args2));
+  server.tool("vision_get_cookies", "Get cookies from a Vision Browser profile via Cloud API", {
+    folder_id: z.string(),
+    profile_id: z.string()
+  }, (args2) => toolHandler("vision_get_cookies", args2));
+  server.tool("vision_create_profile", "Create a Vision Browser profile via Cloud API", {
+    folder_id: z.string(),
+    profile_name: z.string(),
+    profile_notes: z.string().nullable().optional(),
+    profile_tags: z.array(z.string()).optional(),
+    new_profile_tags: z.array(z.string()).optional(),
+    proxy_id: z.string().nullable().optional(),
+    profile_status: z.array(z.string()).nullable().optional(),
+    platform: visionProfilePlatformArg,
+    browser: visionBrowserArg,
+    fingerprint: z.object({
+      webrtc_pref: z.unknown(),
+      webgl_pref: z.unknown(),
+      canvas_pref: z.unknown(),
+      ports_protection: z.array(z.number())
+    }).passthrough()
+  }, (args2) => toolHandler("vision_create_profile", args2));
+  server.tool("vision_update_profile", "Update a Vision Browser profile via Cloud API", {
+    folder_id: z.string(),
+    profile_id: z.string(),
+    profile_name: z.string().optional(),
+    profile_notes: z.string().optional(),
+    profile_tags: z.array(z.string()).optional(),
+    new_profile_tags: z.array(z.string()).optional(),
+    profile_status: z.string().nullable().optional(),
+    pinned: z.boolean().optional(),
+    proxy_id: z.union([z.string(), z.object({ id: z.string() })]).optional()
+  }, (args2) => toolHandler("vision_update_profile", args2));
+  server.tool("vision_delete_profile", "Delete a Vision Browser profile via Cloud API", {
+    folder_id: z.string(),
+    profile_id: z.string()
+  }, (args2) => toolHandler("vision_delete_profile", args2));
+  server.tool("vision_get_proxies", "Get Vision Browser proxies from a specific folder via Cloud API", {
+    folder_id: z.string()
+  }, (args2) => toolHandler("vision_get_proxies", args2));
+  server.tool("vision_create_proxies", "Create Vision Browser proxies inside a folder via Cloud API", {
+    folder_id: z.string(),
+    proxies: z.array(z.object({
+      proxy_name: z.string(),
+      proxy_type: visionProxyTypeArg,
+      proxy_ip: z.string(),
+      proxy_port: z.number(),
+      proxy_username: z.string().optional(),
+      proxy_password: z.string().optional(),
+      update_url: z.string().optional(),
+      proxy_geo: z.record(z.unknown()).optional()
+    }).passthrough())
+  }, (args2) => toolHandler("vision_create_proxies", args2));
+  server.tool("vision_update_proxy", "Update a Vision Browser proxy via Cloud API", {
+    folder_id: z.string(),
+    proxy_id: z.string(),
+    proxy_name: z.string(),
+    proxy_type: visionProxyTypeArg,
+    proxy_ip: z.string(),
+    proxy_port: z.number(),
+    proxy_username: z.string().optional(),
+    proxy_password: z.string().optional(),
+    update_url: z.string().optional(),
+    proxy_geo: z.record(z.unknown()).optional()
+  }, (args2) => toolHandler("vision_update_proxy", args2));
+  server.tool("vision_delete_proxies", "Delete Vision Browser proxies inside a folder via Cloud API", {
+    folder_id: z.string(),
+    proxy_ids: z.array(z.string())
+  }, (args2) => toolHandler("vision_delete_proxies", args2));
+  server.tool("vision_get_statuses", "Get Vision Browser statuses from a specific folder via Cloud API", {
+    folder_id: z.string()
+  }, (args2) => toolHandler("vision_get_statuses", args2));
+  server.tool("vision_get_tags", "Get Vision Browser tags from a specific folder via Cloud API", {
+    folder_id: z.string()
+  }, (args2) => toolHandler("vision_get_tags", args2));
+  server.tool("vision_create_tags", "Create Vision Browser tags inside a folder via Cloud API", {
+    folder_id: z.string(),
+    tags: z.array(z.string())
+  }, (args2) => toolHandler("vision_create_tags", args2));
+  server.tool("vision_update_tag", "Update a Vision Browser tag via Cloud API", {
+    folder_id: z.string(),
+    tag_id: z.string(),
+    name: z.string()
+  }, (args2) => toolHandler("vision_update_tag", args2));
+  server.tool("vision_delete_tags", "Delete Vision Browser tags via Cloud API", {
+    folder_id: z.string(),
+    tag_ids: z.array(z.string())
+  }, (args2) => toolHandler("vision_delete_tags", args2));
+  server.tool("vision_create_statuses", "Create Vision Browser statuses via Cloud API", {
+    folder_id: z.string(),
+    statuses: z.array(z.tuple([z.string(), z.string()]))
+  }, (args2) => toolHandler("vision_create_statuses", args2));
+  server.tool("vision_update_status", "Update a Vision Browser status via Cloud API", {
+    folder_id: z.string(),
+    status_id: z.string(),
+    name: z.string(),
+    color: z.string()
+  }, (args2) => toolHandler("vision_update_status", args2));
+  server.tool("vision_delete_statuses", "Delete Vision Browser statuses via Cloud API", {
+    folder_id: z.string(),
+    status_ids: z.array(z.string())
+  }, (args2) => toolHandler("vision_delete_statuses", args2));
+  if (VISION_PORT !== void 0) {
+    server.tool("vision_get_languages", "Get available Vision Browser languages from the local API", {}, () => toolHandler("vision_get_languages", {}));
+    server.tool("vision_get_timezones", "Get available Vision Browser timezones from the local API", {}, () => toolHandler("vision_get_timezones", {}));
+    server.tool("vision_get_renderers", "Get available Vision Browser renderers from the local API", {
+      os: visionPlatformArg,
+      version: z.number().optional()
+    }, (args2) => toolHandler("vision_get_renderers", args2));
+  }
+}
+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: z.array(z.string()).optional()
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
   }, (args2) => toolHandler("browser_parallel_snapshot", args2));
   server.tool("browser_parallel_navigate", "Navigate to URL", {
     url: z.string(),
-    browserIds: z.array(z.string()).optional()
+    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", {
-    selector: z.string(),
-    browserIds: z.array(z.string()).optional()
+    ...browserTargetArgs
   }, (args2) => toolHandler("browser_parallel_click", args2));
   server.tool("browser_parallel_type", "Type text into element", {
-    selector: z.string(),
-    text: z.string(),
-    browserIds: z.array(z.string()).optional()
+    ...browserTargetArgs,
+    text: z.string()
   }, (args2) => toolHandler("browser_parallel_type", args2));
   server.tool("browser_parallel_fill", "Fill input (clear + type)", {
-    selector: z.string(),
-    text: z.string(),
-    browserIds: z.array(z.string()).optional()
+    ...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: z.array(z.string()).optional()
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
   }, (args2) => toolHandler("browser_parallel_press_key", args2));
   server.tool("browser_parallel_select_option", "Select dropdown option", {
-    selector: z.string(),
-    values: z.array(z.string()),
-    browserIds: z.array(z.string()).optional()
+    ...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(),
-    browserIds: z.array(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", {
-    browserIds: z.array(z.string()).optional()
+    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: z.array(z.string()).optional()
+    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", {
-    selector: z.string(),
-    browserIds: z.array(z.string()).optional()
+    ...browserTargetArgs
   }, (args2) => toolHandler("browser_parallel_hover", args2));
   server.tool("browser_parallel_go_back", "Go back", {
-    browserIds: z.array(z.string()).optional()
+    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: z.array(z.string()).optional()
+    browserIds: browserIdsArg,
+    _scope: browserScopeArg
   }, (args2) => toolHandler("browser_parallel_reload", 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()
-  }, (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_set_connection", "Set proxy for session", {
-    uuid: z.string(),
-    type: z.string(),
-    ip: z.string(),
-    port: z.number(),
-    login: z.string().optional(),
-    password: z.string().optional()
-  }, (args2) => toolHandler("linken_set_connection", args2));
-  server.tool("linken_import_cookies", "Import cookies", {
-    uuid: z.string(),
-    json: z.string()
-  }, (args2) => toolHandler("linken_import_cookies", args2));
-  server.tool("linken_export_cookies", "Export cookies", {
-    uuids: z.array(z.string())
-  }, (args2) => toolHandler("linken_export_cookies", args2));
-  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_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) registerSphereTools(server, "linken", "Linken Sphere");
+  if (WADEX_PORT !== void 0) registerSphereTools(server, "wadex", "Wade X");
+  if (DOLPHIN_PORT !== void 0 || DOLPHIN_API_TOKEN !== void 0) registerDolphinTools(server);
+  if (VISION_TOKEN !== void 0) registerVisionTools(server);
+  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: z.array(z.string()).optional()
+    browserIds: browserIdsArg
   }, (args2) => toolHandler("captcha_detect", args2));
   server.tool("captcha_solve_press_hold", "Solve press-and-hold captcha", {
-    browserIds: z.array(z.string()).optional()
+    browserIds: browserIdsArg
   }, (args2) => toolHandler("captcha_solve_press_hold", args2));
   server.tool("captcha_solve", "Solve captcha (reCAPTCHA/hCaptcha)", {
-    browserIds: z.array(z.string()).optional()
+    browserIds: browserIdsArg
   }, (args2) => toolHandler("captcha_solve", args2));
   return server;
 }
 async function main() {
   await connectServer();
-  for (const [name, port] of [["linken", LINKEN_PORT], ["dolphin", DOLPHIN_PORT]]) {
+  if (ENABLED_VENDORS.length === 0) {
+    console.error("[ornold] No antidetect vendors configured. Only browser_* and captcha_* tools will be available.");
+  }
+  for (const [name, port, path2, headers] of [
+    ["linken", LINKEN_PORT, "/sessions", void 0],
+    ["wadex", WADEX_PORT, "/sessions", void 0],
+    ["dolphin", DOLPHIN_PORT, "/v1.0/browser_profiles", void 0],
+    ["vision", VISION_PORT, "/variations/language", VISION_TOKEN ? { "X-Token": VISION_TOKEN } : void 0]
+  ]) {
+    if (port === void 0) continue;
     try {
-      const resp = await fetch(`http://127.0.0.1:${port}/sessions`, { signal: AbortSignal.timeout(2e3) });
+      const resp = await fetch(`http://127.0.0.1:${port}${path2}`, { headers, signal: AbortSignal.timeout(2e3) });
       if (resp.ok) console.error(`[ornold] ${name}: detected on port ${port}`);
     } catch {
     }
   }
+  if (DOLPHIN_API_TOKEN !== void 0) {
+    console.error("[ornold] dolphin: cloud token configured");
+  }
+  if (VISION_TOKEN !== void 0) {
+    console.error(`[ornold] vision: cloud token configured${VISION_PORT !== void 0 ? `, local port ${VISION_PORT}` : ""}`);
+  }
   ws?.send(JSON.stringify({
     type: "bridge_hello",
     hostname: (await import("os")).hostname(),
-    config: { linkenPort: LINKEN_PORT, dolphinPort: DOLPHIN_PORT }
+    config: {
+      enabledVendors: ENABLED_VENDORS,
+      ...LINKEN_PORT !== void 0 ? { linkenPort: LINKEN_PORT } : {},
+      ...WADEX_PORT !== void 0 ? { wadexPort: WADEX_PORT } : {},
+      ...DOLPHIN_PORT !== void 0 ? { dolphinPort: DOLPHIN_PORT } : {},
+      ...VISION_PORT !== void 0 ? { visionPort: VISION_PORT } : {},
+      dolphinCloud: DOLPHIN_API_TOKEN !== void 0,
+      dolphinLocal: DOLPHIN_PORT !== void 0,
+      visionCloud: VISION_TOKEN !== void 0,
+      visionLocal: VISION_TOKEN !== void 0 && VISION_PORT !== void 0
+    }
   }));
   const server = createServer();
   const transport = new StdioServerTransport();