@mearl/native-host 2.4.0 → 2.5.1

package/dist/index.js

@@ -46,7 +46,7 @@ function uninstallNativeHostArtifacts(options = {}, dependencies = {}) {
       writeLine(line);
   };
   try {
-    const existsSync4 = dependencies.existsSync ?? fs11.existsSync;
+    const existsSync5 = dependencies.existsSync ?? fs11.existsSync;
     const platform = dependencies.platform ?? process.platform;
     const hostDir = dependencies.hostDir ?? resolveNativeHostDirectory({
       env: dependencies.env,
@@ -62,7 +62,7 @@ function uninstallNativeHostArtifacts(options = {}, dependencies = {}) {
       path12.join(hostDir, `${hostName}-launcher.${launcherExtension}`)
     ];
     for (const artifact of artifacts) {
-      if (!existsSync4(artifact))
+      if (!existsSync5(artifact))
         continue;
       unlinkSync(artifact);
       log2(`✅ Removed: ${artifact}`);
@@ -98,7 +98,7 @@ import fs12 from "node:fs";
 import path13 from "node:path";
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { createRequire } from "node:module";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 function resolveHostDir() {
   return resolveNativeHostDirectory();
 }
@@ -306,7 +306,7 @@ var init_install = __esm({
     "use strict";
     init_nativeHost();
     DEFAULT_EXTENSION_ID = "aoehhjnofngknnjefamjbplchbolghkm";
-    __filename = fileURLToPath2(import.meta.url);
+    __filename = fileURLToPath3(import.meta.url);
     __dirname = path13.dirname(__filename);
     ALL_MODES = ["skills", "mcp"];
   }
@@ -315,17 +315,16 @@ var init_install = __esm({
 // src/index.ts
 import net from "node:net";
 import fs13 from "node:fs";
-import http5 from "node:http";
+import http4 from "node:http";
 import os7 from "node:os";
 import path14 from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // src/cdp-backend/cdp-session.ts
-import http3 from "node:http";
+import http2 from "node:http";
 
 // src/cdp-backend/client.ts
-import http from "node:http";
-import crypto2 from "node:crypto";
+import WebSocket from "ws";
 var CdpChildSession = class {
   constructor(parent, sessionId) {
     this.parent = parent;
@@ -344,199 +343,89 @@ var CdpChildSession = class {
   }
 };
 var CdpClient = class _CdpClient {
-  socket;
-  buffer = Buffer.alloc(0);
+  constructor(socket) {
+    this.socket = socket;
+    socket.on("message", (data) => this.consumeMessage(data));
+    socket.on("close", () => this.handleClosed());
+    socket.on("error", () => this.handleClosed());
+  }
   nextId = 1;
   pending = /* @__PURE__ */ new Map();
   eventHandlers = /* @__PURE__ */ new Map();
-  /** sessionId → method → callbacks (for multiplexed page sessions) */
   sessionEventHandlers = /* @__PURE__ */ new Map();
   _closed = false;
-  constructor(socket) {
-    this.socket = socket;
-    socket.on("data", (chunk) => {
-      this.buffer = Buffer.concat([this.buffer, chunk]);
-      this.consumeFrames();
-    });
-    socket.on("close", () => {
-      this._closed = true;
-      for (const [id, pending] of this.pending) {
-        clearTimeout(pending.timer);
-        pending.reject(new Error("CDP connection closed"));
-        this.pending.delete(id);
+  static connect(wsUrl) {
+    return new Promise((resolve2, reject) => {
+      let url2;
+      try {
+        url2 = new URL(wsUrl);
+      } catch {
+        reject(new Error("Invalid CDP WebSocket URL"));
+        return;
       }
-    });
-    socket.on("error", () => {
-      this._closed = true;
+      if (url2.protocol !== "ws:" && url2.protocol !== "wss:") {
+        reject(new Error(`Unsupported CDP WebSocket protocol: ${url2.protocol}`));
+        return;
+      }
+      const socket = new WebSocket(url2, {
+        handshakeTimeout: 5e3,
+        maxPayload: 64 * 1024 * 1024,
+        perMessageDeflate: false
+      });
+      let settled = false;
+      const fail = (error48) => {
+        if (settled) return;
+        settled = true;
+        socket.terminate();
+        reject(error48);
+      };
+      socket.once("open", () => {
+        if (settled) return;
+        settled = true;
+        resolve2(new _CdpClient(socket));
+      });
+      socket.once("error", fail);
+      socket.once("unexpected-response", (_request, response) => {
+        response.resume();
+        fail(new Error(`CDP WebSocket upgrade failed with status ${response.statusCode ?? 0}`));
+      });
     });
   }
-  /** Create a child session client that routes through this connection via sessionId. */
   createChildSession(sessionId) {
     return new CdpChildSession(this, sessionId);
   }
-  /** Send a command within a specific CDP session (multiplexed on this connection). */
   sendCommandInSession(sessionId, method, params, timeoutMs = 3e4) {
-    return new Promise((resolve, reject) => {
-      if (this._closed) {
-        reject(new Error("CDP client is closed"));
-        return;
-      }
-      const id = this.nextId++;
-      const timer = setTimeout(() => {
-        this.pending.delete(id);
-        reject(new Error(`CDP command timeout: ${method}`));
-      }, timeoutMs);
-      this.pending.set(id, { resolve, reject, timer, sessionId });
-      this.sendText(JSON.stringify({ id, method, params: params ?? {}, sessionId }));
-    });
+    return this.sendRequest(method, params, timeoutMs, sessionId);
   }
-  /** Subscribe to events from a specific CDP session. */
   onSession(sessionId, method, callback) {
     if (!this.sessionEventHandlers.has(sessionId)) {
       this.sessionEventHandlers.set(sessionId, /* @__PURE__ */ new Map());
     }
     const sessionMap = this.sessionEventHandlers.get(sessionId);
-    if (!sessionMap.has(method)) {
-      sessionMap.set(method, /* @__PURE__ */ new Set());
-    }
+    if (!sessionMap.has(method)) sessionMap.set(method, /* @__PURE__ */ new Set());
     sessionMap.get(method).add(callback);
     return () => sessionMap.get(method)?.delete(callback);
   }
-  static connect(wsUrl) {
-    return new Promise((resolve, reject) => {
-      const url2 = new URL(wsUrl);
-      const port = parseInt(url2.port || "9222", 10);
-      const key = crypto2.randomBytes(16).toString("base64");
-      const expectedAccept = crypto2.createHash("sha1").update(key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").digest("base64");
-      const req = http.request({
-        host: url2.hostname,
-        port,
-        path: url2.pathname,
-        headers: {
-          Connection: "Upgrade",
-          Upgrade: "websocket",
-          "Sec-WebSocket-Key": key,
-          "Sec-WebSocket-Version": "13",
-          Host: url2.host
-          // No Origin header — Chrome allows connections without Origin,
-          // but rejects any Origin not in --remote-allow-origins allowlist.
-        }
-      });
-      let settled = false;
-      const fail = (err) => {
-        if (settled) return;
-        settled = true;
-        reject(err);
-      };
-      req.on("upgrade", (res, socket, head) => {
-        if (settled) return;
-        if (res.statusCode !== 101) {
-          settled = true;
-          socket.destroy();
-          reject(new Error(`WebSocket upgrade failed with status ${res.statusCode}`));
-          return;
-        }
-        const acceptHeader = res.headers["sec-websocket-accept"];
-        if (acceptHeader !== expectedAccept) {
-          settled = true;
-          socket.destroy();
-          reject(new Error("WebSocket handshake key mismatch"));
-          return;
-        }
-        settled = true;
-        const client2 = new _CdpClient(socket);
-        if (head && head.length > 0) {
-          client2.buffer = Buffer.concat([client2.buffer, head]);
-          client2.consumeFrames();
-        }
-        resolve(client2);
-      });
-      req.on("error", fail);
-      req.setTimeout(5e3, () => {
-        req.destroy();
-        fail(new Error("CDP WebSocket connect timeout"));
-      });
-      req.end();
-    });
+  sendCommand(method, params, timeoutMs = 3e4) {
+    return this.sendRequest(method, params, timeoutMs);
   }
-  consumeFrames() {
-    while (true) {
-      if (this.buffer.length < 2) return;
-      const byte1 = this.buffer[1];
-      const masked = (byte1 & 128) !== 0;
-      let payloadLen = byte1 & 127;
-      let headerLen = 2;
-      if (payloadLen === 126) {
-        if (this.buffer.length < 4) return;
-        payloadLen = this.buffer.readUInt16BE(2);
-        headerLen = 4;
-      } else if (payloadLen === 127) {
-        if (this.buffer.length < 10) return;
-        payloadLen = Number(this.buffer.readBigUInt64BE(2));
-        headerLen = 10;
-      }
-      if (masked) headerLen += 4;
-      if (this.buffer.length < headerLen + payloadLen) return;
-      const opcode = this.buffer[0] & 15;
-      let payload;
-      if (masked) {
-        const maskKey = this.buffer.subarray(headerLen - 4, headerLen);
-        payload = Buffer.from(
-          this.buffer.subarray(headerLen, headerLen + payloadLen).map((b, i) => b ^ maskKey[i % 4])
-        );
-      } else {
-        payload = this.buffer.subarray(headerLen, headerLen + payloadLen);
-      }
-      this.buffer = this.buffer.subarray(headerLen + payloadLen);
-      if (opcode === 1 || opcode === 2) {
-        try {
-          const msg = JSON.parse(payload.toString("utf-8"));
-          this.handleMessage(msg);
-        } catch {
-        }
-      }
-    }
+  on(method, callback) {
+    if (!this.eventHandlers.has(method)) this.eventHandlers.set(method, /* @__PURE__ */ new Set());
+    this.eventHandlers.get(method).add(callback);
+    return () => this.eventHandlers.get(method)?.delete(callback);
   }
-  handleMessage(msg) {
-    if (msg.id !== void 0) {
-      const pending = this.pending.get(msg.id);
-      if (pending) {
-        clearTimeout(pending.timer);
-        this.pending.delete(msg.id);
-        if (msg.error) {
-          pending.reject(new Error(msg.error.message ?? JSON.stringify(msg.error)));
-        } else {
-          pending.resolve(msg.result ?? {});
-        }
-      }
-    } else if (msg.method) {
-      if (msg.sessionId) {
-        const sessionMap = this.sessionEventHandlers.get(msg.sessionId);
-        const handlers = sessionMap?.get(msg.method);
-        if (handlers) {
-          for (const cb of handlers) {
-            try {
-              cb(msg.params);
-            } catch {
-            }
-          }
-        }
-      } else {
-        const handlers = this.eventHandlers.get(msg.method);
-        if (handlers) {
-          for (const cb of handlers) {
-            try {
-              cb(msg.params);
-            } catch {
-            }
-          }
-        }
-      }
-    }
+  close() {
+    if (this._closed) return;
+    this._closed = true;
+    this.socket.terminate();
+    this.rejectPending("CDP connection closed");
   }
-  sendCommand(method, params, timeoutMs = 3e4) {
-    return new Promise((resolve, reject) => {
-      if (this._closed) {
+  get closed() {
+    return this._closed;
+  }
+  sendRequest(method, params, timeoutMs, sessionId) {
+    return new Promise((resolve2, reject) => {
+      if (this._closed || this.socket.readyState !== WebSocket.OPEN) {
         reject(new Error("CDP client is closed"));
         return;
       }
@@ -545,51 +434,61 @@ var CdpClient = class _CdpClient {
         this.pending.delete(id);
         reject(new Error(`CDP command timeout: ${method}`));
       }, timeoutMs);
-      this.pending.set(id, { resolve, reject, timer });
-      this.sendText(JSON.stringify({ id, method, params: params ?? {} }));
+      this.pending.set(id, { resolve: resolve2, reject, timer, sessionId });
+      this.socket.send(
+        JSON.stringify({ id, method, params: params ?? {}, ...sessionId ? { sessionId } : {} }),
+        (error48) => {
+          if (!error48) return;
+          const pending = this.pending.get(id);
+          if (!pending) return;
+          clearTimeout(pending.timer);
+          this.pending.delete(id);
+          pending.reject(error48);
+        }
+      );
     });
   }
-  on(method, callback) {
-    if (!this.eventHandlers.has(method)) {
-      this.eventHandlers.set(method, /* @__PURE__ */ new Set());
+  consumeMessage(data) {
+    try {
+      const text = Array.isArray(data) ? Buffer.concat(data).toString("utf8") : Buffer.isBuffer(data) ? data.toString("utf8") : Buffer.from(data).toString("utf8");
+      this.handleMessage(JSON.parse(text));
+    } catch {
     }
-    this.eventHandlers.get(method).add(callback);
-    return () => this.eventHandlers.get(method)?.delete(callback);
   }
-  sendText(text) {
-    if (this._closed) return;
-    const payload = Buffer.from(text, "utf-8");
-    const maskKey = crypto2.randomBytes(4);
-    const masked = Buffer.from(payload.map((b, i) => b ^ maskKey[i % 4]));
-    let header;
-    if (payload.length < 126) {
-      header = Buffer.alloc(6);
-      header[0] = 129;
-      header[1] = 128 | payload.length;
-      maskKey.copy(header, 2);
-    } else if (payload.length < 65536) {
-      header = Buffer.alloc(8);
-      header[0] = 129;
-      header[1] = 128 | 126;
-      header.writeUInt16BE(payload.length, 2);
-      maskKey.copy(header, 4);
-    } else {
-      header = Buffer.alloc(14);
-      header[0] = 129;
-      header[1] = 128 | 127;
-      header.writeBigUInt64BE(BigInt(payload.length), 2);
-      maskKey.copy(header, 10);
+  handleMessage(msg) {
+    if (msg.id !== void 0) {
+      const pending = this.pending.get(msg.id);
+      if (!pending) return;
+      clearTimeout(pending.timer);
+      this.pending.delete(msg.id);
+      if (msg.error) {
+        pending.reject(new Error(msg.error.message ?? JSON.stringify(msg.error)));
+      } else {
+        pending.resolve(msg.result ?? {});
+      }
+      return;
     }
-    this.socket.write(Buffer.concat([header, masked]));
-  }
-  close() {
-    if (!this._closed) {
-      this._closed = true;
-      this.socket.destroy();
+    if (!msg.method) return;
+    const handlers = msg.sessionId ? this.sessionEventHandlers.get(msg.sessionId)?.get(msg.method) : this.eventHandlers.get(msg.method);
+    if (!handlers) return;
+    for (const callback of handlers) {
+      try {
+        callback(msg.params);
+      } catch {
+      }
     }
   }
-  get closed() {
-    return this._closed;
+  handleClosed() {
+    if (this._closed) return;
+    this._closed = true;
+    this.rejectPending("CDP connection closed");
+  }
+  rejectPending(message) {
+    for (const [id, pending] of this.pending) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error(message));
+      this.pending.delete(id);
+    }
   }
 };
 
@@ -3056,7 +2955,7 @@ function installPageObserverInPage(maxBatches = 50) {
   });
   state.waitSince = (checkpoint, checkpointFocus, quietMs, firstChangeTimeoutMs, timeoutMs) => {
     const startedAt = performance.now();
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       let completed = false;
       let quietTimer;
       let firstChangeTimer;
@@ -3121,7 +3020,7 @@ function installPageObserverInPage(maxBatches = 50) {
         if (structuralMutationCount > 0 && unclassifiedStructuralMutationCount > 0) {
           snapshotReasons.push("unclassified-structure");
         }
-        resolve({
+        resolve2({
           mode: "delta",
           scope: "main-document",
           checkpoint,
@@ -3360,14 +3259,14 @@ function createNavigationSettlementTracker(options) {
       return Promise.resolve(true);
     if (timeoutMs <= 0 || disposed)
       return Promise.resolve(false);
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const initialDeadline = performance.now() + timeoutMs;
       const hardDeadline = initialDeadline + 4e3;
       let timer;
       const waiter = (didStart) => {
         clearTimeout(timer);
         startWaiters.delete(waiter);
-        resolve(didStart);
+        resolve2(didStart);
       };
       const check2 = () => {
         if (started) {
@@ -3389,26 +3288,26 @@ function createNavigationSettlementTracker(options) {
   const waitForResult = (timeoutMs) => {
     if (completed)
       return Promise.resolve(completed);
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const waiter = (result) => {
         clearTimeout(timer);
         resultWaiters.delete(waiter);
-        resolve(result);
+        resolve2(result);
       };
       const timer = setTimeout(() => {
         resultWaiters.delete(waiter);
         finish(documentComplete, false, "timeout");
         if (completed)
-          resolve(completed);
+          resolve2(completed);
       }, timeoutMs);
       resultWaiters.add(waiter);
     });
   };
   const waitForNetworkIdle = (timeoutMs) => {
     const waitStartedAt = performance.now();
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const finishWait = (ready, settledBy) => {
-        resolve({
+        resolve2({
           ready,
           settledBy,
           pendingRequests: pendingRequests2.size,
@@ -4848,7 +4747,7 @@ async function setupBufferListeners(client2, buffers) {
 
 // src/cdp-backend/discover.ts
 import fs from "node:fs";
-import http2 from "node:http";
+import http from "node:http";
 import os from "node:os";
 import path from "node:path";
 function chromeUserDataDir() {
@@ -4876,13 +4775,13 @@ function readDevToolsActivePort(userDataDir = chromeUserDataDir()) {
   }
 }
 async function discoverTargets(port = 9222) {
-  return new Promise((resolve, reject) => {
-    const req = http2.get(`http://localhost:${port}/json`, (res) => {
+  return new Promise((resolve2, reject) => {
+    const req = http.get(`http://localhost:${port}/json`, (res) => {
       let data = "";
       res.on("data", (chunk) => data += chunk);
       res.on("end", () => {
         try {
-          resolve(JSON.parse(data));
+          resolve2(JSON.parse(data));
         } catch (e) {
           reject(new Error(`Failed to parse CDP targets: ${e}`));
         }
@@ -4909,6 +4808,8 @@ async function isCdpAvailable(port = 9222, userDataDir) {
 var CdpSession = class {
   port;
   userDataDir;
+  endpointUrl;
+  endpointResolver;
   browserClient = null;
   pageSessions = /* @__PURE__ */ new Map();
   // targetId → PageSession
@@ -4922,6 +4823,8 @@ var CdpSession = class {
     }
     this.port = options.port ?? 9222;
     this.userDataDir = options.userDataDir;
+    this.endpointUrl = options.endpointUrl;
+    this.endpointResolver = options.endpointResolver;
   }
   // ── Browser-level ──────────────────────────────────────────────────────────
   async getBrowserClient() {
@@ -4999,7 +4902,13 @@ var CdpSession = class {
         5e3
       );
       client2 = browser.createChildSession(sessionId);
-    } catch {
+    } catch (error48) {
+      if (this.isRemote()) {
+        throw new Error(
+          `Failed to attach to remote CDP target ${target.id}: ${error48 instanceof Error ? error48.message : String(error48)}`,
+          { cause: error48 }
+        );
+      }
       client2 = await CdpClient.connect(target.webSocketDebuggerUrl);
     }
     let tabId;
@@ -5029,6 +4938,7 @@ var CdpSession = class {
     return session;
   }
   async findTargetById(targetId) {
+    if (this.isRemote()) return this.findTargetByIdViaCdp(targetId);
     try {
       const targets = await discoverTargets(this.effectivePort());
       return targets.find((t) => t.id === targetId && t.webSocketDebuggerUrl) ?? null;
@@ -5037,6 +4947,7 @@ var CdpSession = class {
     }
   }
   async findDefaultPageTarget() {
+    if (this.isRemote()) return this.findDefaultPageTargetViaCdp();
     try {
       const targets = await discoverTargets(this.effectivePort());
       return targets.find(
@@ -5056,6 +4967,14 @@ var CdpSession = class {
    * Priority: DevToolsActivePort file → HTTP /json/version
    */
   async resolveBrowserWsUrl() {
+    const configuredEndpoint = this.endpointResolver ? await this.endpointResolver() : this.endpointUrl;
+    if (configuredEndpoint) {
+      const url2 = new URL(configuredEndpoint);
+      if (url2.protocol !== "ws:" && url2.protocol !== "wss:") {
+        throw new Error(`Unsupported CDP endpoint protocol: ${url2.protocol}`);
+      }
+      return url2.toString();
+    }
     const fileInfo = readDevToolsActivePort(this.userDataDir);
     if (fileInfo) {
       return `ws://localhost:${fileInfo.port}${fileInfo.browserWsPath}`;
@@ -5075,6 +4994,9 @@ var CdpSession = class {
     const port = this.effectivePort();
     return `ws://localhost:${port}/devtools/page/${targetId}`;
   }
+  isRemote() {
+    return Boolean(this.endpointUrl || this.endpointResolver);
+  }
   async findTargetByIdViaCdp(targetId) {
     try {
       const browser = await this.getBrowserClient();
@@ -5114,13 +5036,13 @@ var CdpSession = class {
     }
   }
   fetchVersionInfo() {
-    return new Promise((resolve, reject) => {
-      const req = http3.get(`http://localhost:${this.port}/json/version`, (res) => {
+    return new Promise((resolve2, reject) => {
+      const req = http2.get(`http://localhost:${this.port}/json/version`, (res) => {
         let data = "";
         res.on("data", (chunk) => data += chunk);
         res.on("end", () => {
           try {
-            resolve(JSON.parse(data));
+            resolve2(JSON.parse(data));
           } catch (e) {
             reject(new Error(`Failed to parse CDP version info: ${e}`));
           }
@@ -5829,15 +5751,15 @@ async function releaseCdpControl(session) {
 
 // src/cdp-backend/cdp-utils.ts
 import https from "node:https";
-import http4 from "node:http";
+import http3 from "node:http";
 var TYPE_INTO_ELEMENT_SRC = typeIntoElement.toString();
 var CLICK_ELEMENT_VIA_JS_SRC = clickElementViaJS.toString();
 var GET_CLICK_COORDS_FROM_NODE_SRC = getClickCoordsFromNode.toString();
 function nodeFetch(urlStr, options = {}) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const url2 = new URL(urlStr);
     const isHttps = url2.protocol === "https:";
-    const lib = isHttps ? https : http4;
+    const lib = isHttps ? https : http3;
     const { method = "GET", headers = {}, body, timeoutMs = 3e4 } = options;
     const req = lib.request(
       {
@@ -5857,7 +5779,7 @@ function nodeFetch(urlStr, options = {}) {
         res.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
         res.on("end", () => {
           const bodyBuffer = Buffer.concat(chunks);
-          resolve({
+          resolve2({
             status: res.statusCode ?? 0,
             statusText: res.statusMessage ?? "",
             headers: responseHeaders,
@@ -5914,7 +5836,7 @@ ${value}\r
   return { contentType: `multipart/form-data; boundary=${boundary}`, body };
 }
 async function waitForPageLoad(session, timeoutMs) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     let settled = false;
     let removeLoadListener = () => {
     };
@@ -5924,7 +5846,7 @@ async function waitForPageLoad(session, timeoutMs) {
       clearTimeout(timer);
       removeLoadListener();
       if (error48) reject(error48);
-      else resolve();
+      else resolve2();
     };
     const timer = setTimeout(() => {
       finish(new Error(`Page load timeout after ${timeoutMs}ms`));
@@ -7017,12 +6939,12 @@ function resolveCloudConnectorCommand() {
   };
 }
 function startCloudConnector(serverUrl) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const existingPid = findLiveConnector(serverUrl);
     if (existingPid) {
       logFn(`Reusing existing cloud connector for ${serverUrl} (pid=${existingPid})`);
       const entry = registerConnector(serverUrl, existingPid);
-      resolve({
+      resolve2({
         success: true,
         pid: existingPid,
         ...entry.connectorId ? { connectorId: entry.connectorId } : {},
@@ -7055,14 +6977,14 @@ function startCloudConnector(serverUrl) {
       clearTimeout(startupTimer);
       if (ok && child.pid) {
         const entry = registerConnector(serverUrl, child.pid, child);
-        resolve({
+        resolve2({
           success: true,
           pid: child.pid,
           ...entry.connectorId ? { connectorId: entry.connectorId } : {},
           ...entry.name ? { name: entry.name } : {}
         });
       } else {
-        resolve({ success: false, error: result.error || "Failed to spawn cloud connector" });
+        resolve2({ success: false, error: result.error || "Failed to spawn cloud connector" });
       }
     };
     child.once("error", (error48) => {
@@ -7674,7 +7596,7 @@ async function cdpWaitForTracknick(session, options = {}) {
     latest = await cdpGetTracknick(session);
     if (expected && latest === expected) return latest;
     if (!expected && latest && latest !== previous) return latest;
-    await new Promise((resolve) => setTimeout(resolve, 500));
+    await new Promise((resolve2) => setTimeout(resolve2, 500));
   }
   return latest || await cdpGetTracknick(session);
 }
@@ -7684,7 +7606,7 @@ async function cdpOpenAndCloseTarget(cdpSession2, url2) {
     url: url2,
     background: true
   });
-  await new Promise((resolve) => setTimeout(resolve, 3500));
+  await new Promise((resolve2) => setTimeout(resolve2, 3500));
   await browser.sendCommand("Target.closeTarget", { targetId }).catch(() => {
   });
 }
@@ -8434,7 +8356,7 @@ async function cdpPageWait(session, data) {
   const options = resolvePageWaitInput(data);
   const startedAt = Date.now();
   if (options.mode === "time") {
-    await new Promise((resolve) => setTimeout(resolve, options.time));
+    await new Promise((resolve2) => setTimeout(resolve2, options.time));
     return { success: true, waited: true, elapsed: options.time, mode: options.mode };
   }
   const expression = options.mode === "selector" ? `!!document.querySelector(${JSON.stringify(options.selector)})` : options.condition;
@@ -8459,7 +8381,7 @@ async function cdpPageWait(session, data) {
         value
       };
     }
-    await new Promise((resolve) => setTimeout(resolve, options.interval));
+    await new Promise((resolve2) => setTimeout(resolve2, options.interval));
   }
   if (options.mode === "selector") {
     throw new Error(
@@ -8530,7 +8452,7 @@ async function waitForHistoryIndex(session, targetIndex, timeoutMs) {
       }
     } catch {
     }
-    await new Promise((resolve) => setTimeout(resolve, 50));
+    await new Promise((resolve2) => setTimeout(resolve2, 50));
   }
   throw new Error(`Page history navigation timeout after ${timeoutMs}ms`);
 }
@@ -8678,7 +8600,7 @@ async function readCurrentUrl(session, action) {
   return url2;
 }
 function reloadPageAndWait(session, timeoutMs) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     let settled = false;
     let removeListener = () => {
     };
@@ -8688,7 +8610,7 @@ function reloadPageAndWait(session, timeoutMs) {
       clearTimeout(timer);
       removeListener();
       if (error48) reject(error48);
-      else resolve();
+      else resolve2();
     };
     const timer = setTimeout(() => {
       finish(new Error(`Page load timeout after ${timeoutMs}ms`));
@@ -9137,6 +9059,10 @@ async function cdpExportCookies(session, domains) {
 async function cdpImportCookies(session, cookies) {
   if (cookies.length === 0) return 0;
   const browser = await session.getBrowserClient();
+  return cdpImportCookiesWithClient(browser, cookies);
+}
+async function cdpImportCookiesWithClient(browser, cookies) {
+  if (cookies.length === 0) return 0;
   await browser.sendCommand("Storage.setCookies", { cookies });
   return cookies.length;
 }
@@ -9263,6 +9189,7 @@ function browserSummary(record2, running) {
   return {
     browserId: record2.browserId,
     name: record2.name,
+    provider: "local",
     headless: record2.headless,
     persistent: record2.persistent,
     cdpPort: record2.cdpPort,
@@ -9329,12 +9256,15 @@ function findManagedRecord(selector) {
     ({ record: record2 }) => record2.browserId.toLowerCase() === normalized || record2.name.toLowerCase() === normalized
   )?.record ?? null;
 }
+function hasManagedBrowser(selector) {
+  return findManagedRecord(selector) !== null;
+}
 async function waitForActivePort(userDataDir) {
   const deadline = Date.now() + LAUNCH_TIMEOUT_MS;
   while (Date.now() < deadline) {
     const info = readDevToolsActivePort(userDataDir);
     if (info) return info.port;
-    await new Promise((resolve) => setTimeout(resolve, 100));
+    await new Promise((resolve2) => setTimeout(resolve2, 100));
   }
   throw new Error(`Chrome did not expose a CDP port within ${LAUNCH_TIMEOUT_MS}ms`);
 }
@@ -9344,7 +9274,7 @@ async function waitForBrowserRegistration(browserId, expectedPid) {
   while (Date.now() < deadline) {
     const record2 = readRecord(file2);
     if (record2?.pid === expectedPid && isAlive(expectedPid)) return;
-    await new Promise((resolve) => setTimeout(resolve, 100));
+    await new Promise((resolve2) => setTimeout(resolve2, 100));
   }
   throw new Error(`Managed browser ${browserId} did not register within ${LAUNCH_TIMEOUT_MS}ms`);
 }
@@ -9366,7 +9296,7 @@ async function stopProcess(pid, commandMarker) {
   signalProcess(pid, "SIGTERM", commandMarker);
   const deadline = Date.now() + 3e3;
   while (Date.now() < deadline && isManagedProcess(pid, commandMarker)) {
-    await new Promise((resolve) => setTimeout(resolve, 50));
+    await new Promise((resolve2) => setTimeout(resolve2, 50));
   }
   if (isManagedProcess(pid, commandMarker)) signalProcess(pid, "SIGKILL", commandMarker);
 }
@@ -9435,6 +9365,9 @@ function acquireLaunchLock(browserId) {
   };
 }
 async function launchManagedBrowser(input, deps) {
+  if (input.imageId !== void 0) {
+    throw new Error("imageId is only supported by the AgentBay browser provider");
+  }
   const name = validateName(input.name);
   const browserId = managedBrowserId(name);
   validateTdbankSelector(input);
@@ -9470,9 +9403,9 @@ async function launchManagedBrowser(input, deps) {
       stdio: ["ignore", "ignore", logFd],
       windowsHide: headless
     });
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       chrome.once("error", reject);
-      chrome.once("spawn", resolve);
+      chrome.once("spawn", resolve2);
     });
     chromePid = chrome.pid ?? 0;
     if (!chromePid) throw new Error("Chrome launched without a process id");
@@ -9511,9 +9444,9 @@ async function launchManagedBrowser(input, deps) {
       ],
       { detached: true, stdio: "ignore", windowsHide: true }
     );
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       host.once("error", reject);
-      host.once("spawn", resolve);
+      host.once("spawn", resolve2);
     });
     hostPid = host.pid ?? 0;
     if (!hostPid) throw new Error("Native host launched without a process id");
@@ -9566,6 +9499,450 @@ async function closeManagedBrowser(selector, options = {}) {
   return { browserId: record2.browserId, closed: true, profileDeleted: deleteProfile };
 }
 
+// src/agentbay-browser.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
+import { spawn as spawn4 } from "node:child_process";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname3, join as join4, parse, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var AGENTBAY_BROWSERS_SUBDIR = "agentbay-browsers";
+var DEFAULT_AGENTBAY_IMAGE_ID = "imgc-0aae4rgl8kvagdv1j";
+var sdkPromise = null;
+async function loadSdk() {
+  sdkPromise ??= import("wuying-agentbay-sdk").then((sdk) => {
+    sdk.setupLogger({ level: "ERROR", enableConsole: false });
+    return sdk;
+  });
+  return sdkPromise;
+}
+async function createClient(apiKey) {
+  const { AgentBay } = await loadSdk();
+  return new AgentBay({ apiKey });
+}
+function agentBayBrowserId(name) {
+  return `managed:agentbay:${name.toLocaleLowerCase("en-US")}`;
+}
+function envValue(text, key) {
+  for (const line of text.split(/\r?\n/)) {
+    const match = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)\s*$/.exec(line);
+    if (!match || match[1] !== key) continue;
+    let value = (match[2] ?? "").trim();
+    if (value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    } else {
+      value = value.replace(/\s+#.*$/, "").trim();
+    }
+    return value || void 0;
+  }
+  return void 0;
+}
+function envFilesUpward(start) {
+  const files = [];
+  let current = resolve(start);
+  while (true) {
+    files.push(join4(current, ".env"));
+    const parent = dirname3(current);
+    if (parent === current || current === parse(current).root) break;
+    current = parent;
+  }
+  return files;
+}
+function resolveAgentBayApiKey() {
+  const inherited = process.env.AGENTBAY_KEY?.trim() || process.env.AGENTBAY_API_KEY?.trim();
+  if (inherited) return inherited;
+  const moduleDir = dirname3(fileURLToPath(import.meta.url));
+  const candidates = [
+    ...process.env.MEARL_ENV_FILE ? [resolve(process.env.MEARL_ENV_FILE)] : [],
+    ...envFilesUpward(process.cwd()),
+    ...envFilesUpward(moduleDir),
+    join4(homedir2(), ".mearl", ".env")
+  ];
+  for (const file2 of new Set(candidates)) {
+    if (!existsSync4(file2)) continue;
+    try {
+      const text = readFileSync4(file2, "utf8");
+      const value = envValue(text, "AGENTBAY_KEY") ?? envValue(text, "AGENTBAY_API_KEY");
+      if (value) return value;
+    } catch {
+    }
+  }
+  throw new Error(
+    "AgentBay API key not found. Set AGENTBAY_KEY in the environment, project .env, or ~/.mearl/.env."
+  );
+}
+function validateAgentBayInput(input) {
+  if (input.headless === true) {
+    throw new Error("headless=true is not supported by the AgentBay browser provider");
+  }
+  if (input.executablePath) {
+    throw new Error("executablePath is only supported by the local browser provider");
+  }
+  if (input.accountId !== void 0 || input.havanaId !== void 0 || input.site !== void 0 || typeof input.query === "string" && input.query.trim()) {
+    throw new Error("TDBank login parameters are only supported by the local browser provider");
+  }
+}
+function resolveAgentBayImageId(value) {
+  if (value === void 0) return DEFAULT_AGENTBAY_IMAGE_ID;
+  const imageId = typeof value === "string" ? value.trim() : "";
+  if (!imageId || imageId.length > 128 || !/^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(imageId)) {
+    throw new Error("imageId must be a valid AgentBay image alias or image ID");
+  }
+  return imageId;
+}
+function agentBayContextName(browserId) {
+  return `mearl-browser-${hashKey(browserId)}`;
+}
+function normalizeDesktopUserAgent(value) {
+  const userAgent = typeof value === "string" ? value.trim() : "";
+  if (!userAgent) throw new Error("Could not determine the control browser user agent");
+  return userAgent.replace(/\bHeadlessChrome\//g, "Chrome/");
+}
+function normalizeAgentBayAccessUrl(value) {
+  const candidate = typeof value === "string" ? value.trim() : "";
+  if (!candidate) return void 0;
+  try {
+    const url2 = new URL(candidate);
+    return url2.protocol === "https:" || url2.protocol === "http:" ? url2.toString() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function browserSummary2(record2, running) {
+  const accessUrl = normalizeAgentBayAccessUrl(record2.accessUrl);
+  return {
+    browserId: record2.browserId,
+    name: record2.name,
+    provider: "agentbay",
+    headless: false,
+    persistent: record2.persistent === true,
+    agentbaySessionId: record2.sessionId,
+    ...record2.imageId ? { agentbayImageId: record2.imageId } : {},
+    ...record2.contextId ? { agentbayContextId: record2.contextId } : {},
+    ...record2.contextName ? { agentbayContextName: record2.contextName } : {},
+    ...accessUrl ? { agentbayAccessUrl: accessUrl } : {},
+    createdAt: record2.createdAt,
+    ...record2.copiedCookies ? { copiedCookies: record2.copiedCookies } : {},
+    running
+  };
+}
+function listRecords2() {
+  const records = [];
+  for (const file2 of listRecordFiles(keyedDir(AGENTBAY_BROWSERS_SUBDIR))) {
+    const record2 = readRecord(file2);
+    if (!record2) {
+      removeRecord(file2);
+      continue;
+    }
+    const running = isManagedProcess(record2.pid, `--browser-id ${record2.browserId}`);
+    if (!running) removeRecord(keyedConfigFile("browsers", record2.browserId));
+    records.push({ record: record2, running });
+  }
+  return records;
+}
+function findRecord(selector) {
+  const normalized = selector.trim().toLowerCase();
+  return listRecords2().find(
+    ({ record: record2 }) => record2.browserId.toLowerCase() === normalized || record2.name.toLowerCase() === normalized
+  )?.record ?? null;
+}
+function hasAgentBayBrowser(selector) {
+  return findRecord(selector) !== null;
+}
+function listAgentBayBrowsers() {
+  return listRecords2().map(({ record: record2, running }) => browserSummary2(record2, running));
+}
+async function requireSession(sessionId, apiKey) {
+  const agentBay = await createClient(apiKey);
+  return requireSessionFromClient(agentBay, sessionId);
+}
+async function requireSessionFromClient(agentBay, sessionId) {
+  const result = await agentBay.get(sessionId);
+  if (!result.success || !result.session) {
+    throw new Error(result.errorMessage || `AgentBay session not found: ${sessionId}`);
+  }
+  return result.session;
+}
+async function resolvePersistentContext(agentBay, browserId) {
+  if (!agentBay.context) {
+    throw new Error("The installed AgentBay SDK does not support persistent browser contexts");
+  }
+  const name = agentBayContextName(browserId);
+  const result = await agentBay.context.get(name, true);
+  if (!result.success || !result.context?.id) {
+    throw new Error(result.errorMessage || `Failed to create AgentBay browser context: ${name}`);
+  }
+  return { id: result.context.id, name: result.context.name || name };
+}
+async function resolveAgentBayEndpoint(sessionId) {
+  const apiKey = resolveAgentBayApiKey();
+  const { AgentBay, GetCdpLinkRequest } = await loadSdk();
+  const agentBay = new AgentBay({ apiKey });
+  const response = await agentBay.client.getCdpLink(
+    new GetCdpLinkRequest({ authorization: `Bearer ${apiKey}`, sessionId })
+  );
+  const endpoint = response.body?.success ? response.body.data?.url : void 0;
+  if (!endpoint) {
+    throw new Error(response.body?.message || `Failed to get AgentBay CDP link: ${sessionId}`);
+  }
+  const url2 = new URL(endpoint);
+  if (url2.protocol !== "ws:" && url2.protocol !== "wss:") {
+    throw new Error(`AgentBay returned an unsupported CDP endpoint: ${url2.protocol}`);
+  }
+  return url2.toString();
+}
+async function keepAgentBaySessionAlive(sessionId) {
+  const session = await requireSession(sessionId, resolveAgentBayApiKey());
+  const result = await session.keepAlive();
+  if (result.success === false) throw new Error(result.errorMessage || "AgentBay keepalive failed");
+}
+async function initializeAgentBayBrowserSession(session, input, cookies, options = {}) {
+  const initialized = await session.browser.initializeAsync(
+    options.userAgent ? { userAgent: options.userAgent } : {}
+  );
+  if (!initialized) throw new Error("AgentBay browser initialization failed");
+  const endpoint = await session.browser.getEndpointUrl();
+  const cdp = await (options.connectCdp ?? ((url2) => CdpClient.connect(url2)))(endpoint);
+  try {
+    await cdp.sendCommand("Browser.getVersion", {}, 1e4);
+    const copiedCookieCount = await cdpImportCookiesWithClient(cdp, cookies);
+    if (input.url) {
+      await cdp.sendCommand("Target.createTarget", { url: input.url, background: false });
+    }
+    return copiedCookieCount;
+  } finally {
+    cdp.close();
+  }
+}
+async function launchAgentBayBrowser(input, deps) {
+  const name = validateName(input.name);
+  const browserId = agentBayBrowserId(name);
+  validateAgentBayInput(input);
+  const imageId = resolveAgentBayImageId(input.imageId);
+  const persistent = input.persistent === true;
+  const userAgentMode = resolveUserAgentMode(input.userAgentMode);
+  const copyCookieDomains = input.copyCookieDomains === void 0 ? [] : normalizeCookieDomains(input.copyCookieDomains);
+  const apiKey = (deps.resolveApiKey ?? resolveAgentBayApiKey)();
+  const releaseLock = acquireLaunchLock(browserId);
+  const persistBrowserRecord = deps.persistBrowserRecord ?? ((record2) => writeRecord(keyedConfigFile(AGENTBAY_BROWSERS_SUBDIR, record2.browserId), record2));
+  let session = null;
+  let context;
+  let hostPid = 0;
+  let recordWritten = false;
+  try {
+    if (findRecord(browserId)) throw new Error(`AgentBay browser already exists: ${browserId}`);
+    const [cookies, userAgent] = await Promise.all([
+      copyCookieDomains.length > 0 ? deps.exportCookies(copyCookieDomains) : Promise.resolve([]),
+      userAgentMode === "desktop" ? deps.getBrowserUserAgent().then(normalizeDesktopUserAgent) : Promise.resolve(void 0)
+    ]);
+    const agentBay = await (deps.createAgentBayClient ?? createClient)(apiKey);
+    context = persistent ? await resolvePersistentContext(agentBay, browserId) : void 0;
+    const created = await agentBay.create({
+      imageId,
+      framework: "mearl",
+      ...context ? {
+        browserContext: {
+          contextId: context.id,
+          autoUpload: true,
+          syncMode: "standard"
+        }
+      } : {}
+    });
+    if (!created.success || !created.session) {
+      throw new Error(created.errorMessage || "AgentBay session creation failed");
+    }
+    session = created.session;
+    const copiedCookieCount = await initializeAgentBayBrowserSession(session, input, cookies, {
+      userAgent
+    });
+    const host = spawn4(
+      process.execPath,
+      [
+        deps.nativeHostScript,
+        "--daemon",
+        "--agentbay-session-id",
+        session.sessionId,
+        "--browser-id",
+        browserId,
+        "--browser-name",
+        name
+      ],
+      {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true
+      }
+    );
+    await new Promise((resolveSpawn, rejectSpawn) => {
+      host.once("error", rejectSpawn);
+      host.once("spawn", resolveSpawn);
+    });
+    hostPid = host.pid ?? 0;
+    if (!hostPid) throw new Error("AgentBay native host launched without a process id");
+    host.unref();
+    const accessUrl = normalizeAgentBayAccessUrl(session.resourceUrl);
+    const record2 = {
+      pid: hostPid,
+      browserId,
+      name,
+      sessionId: session.sessionId,
+      imageId,
+      persistent,
+      ...context ? { contextId: context.id, contextName: context.name } : {},
+      ...accessUrl ? { accessUrl } : {},
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...copyCookieDomains.length > 0 ? { copiedCookies: { domains: copyCookieDomains, count: copiedCookieCount } } : {}
+    };
+    persistBrowserRecord(record2);
+    recordWritten = true;
+    await waitForBrowserRegistration(browserId, hostPid);
+    deps.log(`AgentBay browser launched: ${browserId}, host=${hostPid}`);
+    return browserSummary2(record2, true);
+  } catch (error48) {
+    if (hostPid) await stopProcess(hostPid, `--browser-id ${browserId}`);
+    if (recordWritten) {
+      removeRecord(keyedConfigFile(AGENTBAY_BROWSERS_SUBDIR, browserId));
+      removeRecord(keyedConfigFile("browsers", browserId));
+    }
+    if (session) {
+      let cleanupError;
+      try {
+        const deleted = await session.delete(false);
+        if (!deleted.success) {
+          cleanupError = new Error(deleted.errorMessage || "AgentBay session deletion failed");
+        }
+      } catch (deleteError) {
+        cleanupError = deleteError;
+      }
+      if (cleanupError) {
+        const accessUrl = normalizeAgentBayAccessUrl(session.resourceUrl);
+        const recoveryRecord = {
+          pid: hostPid,
+          browserId,
+          name,
+          sessionId: session.sessionId,
+          imageId,
+          persistent,
+          ...context ? { contextId: context.id, contextName: context.name } : {},
+          ...accessUrl ? { accessUrl } : {},
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        let recoverySaved = false;
+        let recoveryError;
+        try {
+          persistBrowserRecord(recoveryRecord);
+          recoverySaved = true;
+        } catch (writeError) {
+          recoveryError = writeError;
+        }
+        deps.log(
+          `AgentBay launch cleanup failed for ${session.sessionId}:`,
+          cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
+        );
+        if (recoveryError) {
+          deps.log(
+            `AgentBay recovery metadata could not be saved for ${session.sessionId}:`,
+            recoveryError instanceof Error ? recoveryError.message : String(recoveryError)
+          );
+        }
+        throw new AggregateError(
+          recoveryError ? [error48, cleanupError, recoveryError] : [error48, cleanupError],
+          `${error48 instanceof Error ? error48.message : String(error48)}; ` + (recoverySaved ? "AgentBay session cleanup failed and recovery metadata was retained for browser_close" : `AgentBay session cleanup failed; session ${session.sessionId} may require manual deletion`),
+          { cause: error48 }
+        );
+      }
+    }
+    throw error48;
+  } finally {
+    releaseLock();
+  }
+}
+function isMissingSessionError(error48) {
+  const message = error48 instanceof Error ? error48.message : String(error48);
+  return /not[ -]?found|does not exist|already deleted|invalid session/i.test(message);
+}
+async function releaseAgentBayBrowserResources(record2, agentBay, options = {}) {
+  const deleteContext = record2.persistent === true && options.deleteProfile === true;
+  const syncContext = record2.persistent === true && !deleteContext;
+  let contextSynced = Boolean(record2.contextSyncedAt);
+  let session;
+  try {
+    session = await requireSessionFromClient(agentBay, record2.sessionId);
+  } catch (error48) {
+    if (!isMissingSessionError(error48)) throw error48;
+  }
+  if (session) {
+    if (syncContext && !contextSynced) {
+      if (!session.callMcpTool) {
+        throw new Error("The installed AgentBay SDK cannot stop the browser before context sync");
+      }
+      const stopped = await session.callMcpTool("stopChrome", {}, false);
+      if (stopped.success === false) {
+        throw new Error(stopped.errorMessage || "AgentBay browser shutdown failed");
+      }
+      if (!session.context) {
+        throw new Error("The installed AgentBay SDK cannot synchronize browser context state");
+      }
+      const synced = await session.context.sync();
+      if (!synced.success) {
+        throw new Error(synced.errorMessage || "AgentBay browser context sync failed");
+      }
+      contextSynced = true;
+      record2.contextSyncedAt = (/* @__PURE__ */ new Date()).toISOString();
+      options.persistRecord?.(record2);
+    }
+    try {
+      const result = await session.delete(false);
+      if (!result.success) {
+        throw new Error(result.errorMessage || "AgentBay session deletion failed");
+      }
+    } catch (error48) {
+      if (!isMissingSessionError(error48)) throw error48;
+    }
+  }
+  if (deleteContext) {
+    if (!record2.contextId || !record2.contextName || !agentBay.context) {
+      throw new Error("AgentBay browser context metadata is unavailable for profile deletion");
+    }
+    const result = await agentBay.context.delete({
+      id: record2.contextId,
+      name: record2.contextName
+    });
+    if (!result.success) throw new Error(result.errorMessage || "AgentBay context deletion failed");
+  }
+  return {
+    sessionDeleted: true,
+    ...syncContext ? { contextSynced } : {},
+    ...deleteContext ? { contextDeleted: true } : {}
+  };
+}
+async function closeAgentBayBrowser(selector, options = {}) {
+  const record2 = findRecord(selector);
+  if (!record2) throw new Error(`AgentBay browser not found: ${selector}`);
+  const agentBay = await createClient(resolveAgentBayApiKey());
+  const released = await releaseAgentBayBrowserResources(record2, agentBay, {
+    ...options,
+    persistRecord: (updatedRecord) => writeRecord(
+      keyedConfigFile(AGENTBAY_BROWSERS_SUBDIR, updatedRecord.browserId),
+      updatedRecord
+    )
+  });
+  const closingOwnHost = record2.pid === process.pid;
+  if (!closingOwnHost) await stopProcess(record2.pid, `--browser-id ${record2.browserId}`);
+  removeRecord(keyedConfigFile(AGENTBAY_BROWSERS_SUBDIR, record2.browserId));
+  removeRecord(keyedConfigFile("browsers", record2.browserId));
+  if (closingOwnHost) {
+    const timer = setTimeout(() => process.kill(process.pid, "SIGTERM"), 250);
+    timer.unref();
+  }
+  return {
+    browserId: record2.browserId,
+    provider: "agentbay",
+    closed: true,
+    ...released,
+    ...record2.persistent === true ? { profileDeleted: options.deleteProfile === true } : { profileDeleted: true }
+  };
+}
+
 // src/browser-registry.ts
 var BROWSERS_SUBDIR = "browsers";
 var STALE_RECORD_TTL_MS = 5 * 6e4;
@@ -9715,10 +10092,16 @@ function mergeBrowserInventory(connected, managed) {
       ...connectionFields(record2),
       headless: managedBrowser.headless,
       persistent: managedBrowser.persistent,
-      cdpPort: managedBrowser.cdpPort,
+      provider: managedBrowser.provider,
+      ..."cdpPort" in managedBrowser ? { cdpPort: managedBrowser.cdpPort } : {},
+      ..."agentbaySessionId" in managedBrowser ? { agentbaySessionId: managedBrowser.agentbaySessionId } : {},
+      ..."agentbayImageId" in managedBrowser && managedBrowser.agentbayImageId ? { agentbayImageId: managedBrowser.agentbayImageId } : {},
+      ..."agentbayContextId" in managedBrowser && managedBrowser.agentbayContextId ? { agentbayContextId: managedBrowser.agentbayContextId } : {},
+      ..."agentbayContextName" in managedBrowser && managedBrowser.agentbayContextName ? { agentbayContextName: managedBrowser.agentbayContextName } : {},
+      ..."agentbayAccessUrl" in managedBrowser && managedBrowser.agentbayAccessUrl ? { agentbayAccessUrl: managedBrowser.agentbayAccessUrl } : {},
       createdAt: managedBrowser.createdAt,
-      account: managedBrowser.account,
-      copiedCookies: managedBrowser.copiedCookies
+      ..."account" in managedBrowser ? { account: managedBrowser.account } : {},
+      ..."copiedCookies" in managedBrowser ? { copiedCookies: managedBrowser.copiedCookies } : {}
     };
   });
   const disconnected = [...managedById.values()].sort((a, b) => b.createdAt.localeCompare(a.createdAt)).map((browser) => ({
@@ -9728,10 +10111,16 @@ function mergeBrowserInventory(connected, managed) {
     status: browser.running ? "running_disconnected" : "stopped",
     headless: browser.headless,
     persistent: browser.persistent,
-    cdpPort: browser.cdpPort,
+    provider: browser.provider,
+    ..."cdpPort" in browser ? { cdpPort: browser.cdpPort } : {},
+    ..."agentbaySessionId" in browser ? { agentbaySessionId: browser.agentbaySessionId } : {},
+    ..."agentbayImageId" in browser && browser.agentbayImageId ? { agentbayImageId: browser.agentbayImageId } : {},
+    ..."agentbayContextId" in browser && browser.agentbayContextId ? { agentbayContextId: browser.agentbayContextId } : {},
+    ..."agentbayContextName" in browser && browser.agentbayContextName ? { agentbayContextName: browser.agentbayContextName } : {},
+    ..."agentbayAccessUrl" in browser && browser.agentbayAccessUrl ? { agentbayAccessUrl: browser.agentbayAccessUrl } : {},
     createdAt: browser.createdAt,
-    account: browser.account,
-    copiedCookies: browser.copiedCookies
+    ..."account" in browser ? { account: browser.account } : {},
+    ..."copiedCookies" in browser ? { copiedCookies: browser.copiedCookies } : {}
   }));
   browsers.push(...disconnected);
   return {
@@ -9741,7 +10130,7 @@ function mergeBrowserInventory(connected, managed) {
   };
 }
 function listBrowserInventory() {
-  const managed = listManagedBrowsers();
+  const managed = [...listManagedBrowsers(), ...listAgentBayBrowsers()];
   return mergeBrowserInventory(listRegisteredBrowsers(), managed);
 }
 
@@ -9752,7 +10141,7 @@ import os2 from "node:os";
 import { randomUUID as randomUUID4 } from "node:crypto";
 
 // src/version.ts
-var NATIVE_HOST_VERSION = true ? "2.4.0" : "unknown";
+var NATIVE_HOST_VERSION = true ? "2.5.1" : "unknown";
 
 // src/analytics.ts
 var MEASUREMENT_ID = "G-W84LJDZ6PH";
@@ -9936,14 +10325,14 @@ function selectedPath(stdout) {
   const value = stdout.replace(/[\r\n]+$/, "");
   return value || null;
 }
-var runDirectoryPickerCommand = (command, args) => new Promise((resolve, reject) => {
+var runDirectoryPickerCommand = (command, args) => new Promise((resolve2, reject) => {
   execFile(command, args, { encoding: "utf8", windowsHide: true }, (error48, stdout) => {
     if (!error48) {
-      resolve(selectedPath(stdout));
+      resolve2(selectedPath(stdout));
       return;
     }
     if (error48.code === 1) {
-      resolve(null);
+      resolve2(null);
       return;
     }
     reject(error48);
@@ -10614,17 +11003,17 @@ var AgentChatManager = class {
 // src/agent/codex-provider.ts
 import os3 from "node:os";
 import readline from "node:readline";
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 
 // src/agent/executable-resolver.ts
 import fs6 from "node:fs";
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 import path7 from "node:path";
 
 // ../setup/dist/process.js
 import fs5 from "node:fs";
 import path6 from "node:path";
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 var MAX_CAPTURE_LENGTH = 1e6;
 function isExecutable(filePath, platform = process.platform) {
   try {
@@ -10686,7 +11075,7 @@ function prependPathDirectory(directory, env = process.env) {
 function findExecutable(name, options = {}) {
   const env = options.env ?? process.env;
   const platform = options.platform ?? process.platform;
-  const existsSync4 = options.existsSync ?? ((candidate) => isExecutable(candidate, platform));
+  const existsSync5 = options.existsSync ?? ((candidate) => isExecutable(candidate, platform));
   const pathKey = Object.keys(env).find((key) => key.toLowerCase() === "path") || "PATH";
   const directories = [
     ...options.extraDirectories ?? [],
@@ -10695,16 +11084,16 @@ function findExecutable(name, options = {}) {
   for (const directory of directories) {
     for (const executableName of executableNames(name, platform)) {
       const candidate = path6.join(directory, executableName);
-      if (existsSync4(candidate))
+      if (existsSync5(candidate))
         return candidate;
     }
   }
   return null;
 }
-var runCommand = (command, args, options = {}) => new Promise((resolve, reject) => {
+var runCommand = (command, args, options = {}) => new Promise((resolve2, reject) => {
   const capture = options.capture === true;
   const launch = resolveSpawnCommand(command, args);
-  const child = spawn4(launch.command, launch.args, {
+  const child = spawn5(launch.command, launch.args, {
     cwd: options.cwd,
     env: options.env,
     stdio: capture ? ["ignore", "pipe", "pipe"] : "inherit",
@@ -10723,7 +11112,7 @@ var runCommand = (command, args, options = {}) => new Promise((resolve, reject)
     if (error48)
       reject(error48);
     else
-      resolve({ code, stdout, stderr });
+      resolve2({ code, stdout, stderr });
   };
   const timer = options.timeoutMs === void 0 ? void 0 : setTimeout(() => {
     child.kill("SIGTERM");
@@ -10845,11 +11234,11 @@ function executableFileCandidates(candidates) {
   return executableCandidates;
 }
 function probeAgentExecutable(executable, options) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     let settled = false;
     let stderr = "";
     const launch = resolveSpawnCommand(executable, options.args);
-    const child = spawn5(launch.command, launch.args, {
+    const child = spawn6(launch.command, launch.args, {
       stdio: ["ignore", "ignore", "pipe"],
       windowsHide: true,
       env: prependNodePath()
@@ -10858,7 +11247,7 @@ function probeAgentExecutable(executable, options) {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve(error48);
+      resolve2(error48);
     };
     const timer = setTimeout(() => {
       child.kill("SIGTERM");
@@ -10989,13 +11378,13 @@ function externalOpenCommand(url2, platform = process.platform) {
 }
 function openExternalUrl(url2) {
   const { command, args } = externalOpenCommand(url2);
-  return new Promise((resolve, reject) => {
-    const child = spawn6(command, args, { stdio: "ignore", windowsHide: true });
+  return new Promise((resolve2, reject) => {
+    const child = spawn7(command, args, { stdio: "ignore", windowsHide: true });
     child.once("error", (error48) => {
       reject(new Error(`Unable to open Codex App: ${error48.message}`));
     });
     child.once("close", (code) => {
-      if (code === 0) resolve();
+      if (code === 0) resolve2();
       else reject(new Error("Unable to open Codex App. Make sure it is installed."));
     });
   });
@@ -11162,7 +11551,7 @@ var CodexAgentProvider = class {
           url: `data:${image.mimeType};base64,${image.data}`
         }))
       ],
-      summary: "concise"
+      summary: "detailed"
     });
     const turnId = result?.turn?.id;
     if (typeof turnId !== "string" || !turnId) {
@@ -11224,7 +11613,7 @@ var CodexAgentProvider = class {
     const launch = resolveSpawnCommand(executable, ["app-server", "--listen", "stdio://"]);
     const childEnv = prependNodePath();
     if (this.mearlSocketPath) childEnv.MEARL_SOCKET_PATH = this.mearlSocketPath;
-    const child = spawn6(launch.command, launch.args, {
+    const child = spawn7(launch.command, launch.args, {
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true,
       env: childEnv
@@ -11316,12 +11705,12 @@ var CodexAgentProvider = class {
   }
   request(method, params) {
     const id = this.nextRequestId++;
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const timer = setTimeout(() => {
         this.pendingRequests.delete(id);
         reject(new Error(`Codex request timed out: ${method}`));
       }, REQUEST_TIMEOUT_MS);
-      this.pendingRequests.set(id, { resolve, reject, timer });
+      this.pendingRequests.set(id, { resolve: resolve2, reject, timer });
       try {
         this.write({ id, method, params });
       } catch (error48) {
@@ -11395,7 +11784,7 @@ var CodexAgentProvider = class {
 import fs7 from "node:fs";
 import os4 from "node:os";
 import path8 from "node:path";
-import { spawn as spawn7 } from "node:child_process";
+import { spawn as spawn8 } from "node:child_process";
 import { Readable, Writable } from "node:stream";
 
 // ../../node_modules/.pnpm/@agentclientprotocol+sdk@1.2.1_zod@4.3.6/node_modules/@agentclientprotocol/sdk/dist/schema/index.js
@@ -11631,7 +12020,7 @@ __export(external_exports, {
   object: () => object,
   optional: () => optional,
   overwrite: () => _overwrite,
-  parse: () => parse2,
+  parse: () => parse3,
   parseAsync: () => parseAsync2,
   partialRecord: () => partialRecord,
   pipe: () => pipe,
@@ -11950,7 +12339,7 @@ __export(core_exports2, {
   isValidJWT: () => isValidJWT,
   locales: () => locales_exports,
   meta: () => meta,
-  parse: () => parse,
+  parse: () => parse2,
   parseAsync: () => parseAsync,
   prettifyError: () => prettifyError,
   process: () => process2,
@@ -12873,7 +13262,7 @@ var _parse = (_Err) => (schema, value, _ctx, _params) => {
   }
   return result.value;
 };
-var parse = /* @__PURE__ */ _parse($ZodRealError);
+var parse2 = /* @__PURE__ */ _parse($ZodRealError);
 var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
   const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
   let result = schema._zod.run({ value, issues: [] }, ctx);
@@ -15546,10 +15935,10 @@ var $ZodFunction = /* @__PURE__ */ $constructor("$ZodFunction", (inst, def) => {
       throw new Error("implement() must be called with a function");
     }
     return function(...args) {
-      const parsedArgs = inst._def.input ? parse(inst._def.input, args) : args;
+      const parsedArgs = inst._def.input ? parse2(inst._def.input, args) : args;
       const result = Reflect.apply(func, this, parsedArgs);
       if (inst._def.output) {
-        return parse(inst._def.output, result);
+        return parse2(inst._def.output, result);
       }
       return result;
     };
@@ -23598,7 +23987,7 @@ var ZodRealError = $constructor("ZodError", initializer2, {
 });
 
 // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/parse.js
-var parse2 = /* @__PURE__ */ _parse(ZodRealError);
+var parse3 = /* @__PURE__ */ _parse(ZodRealError);
 var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
 var safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
 var safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
@@ -23641,7 +24030,7 @@ var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
     reg.add(inst, meta3);
     return inst;
   });
-  inst.parse = (data, params) => parse2(inst, data, params, { callee: inst.parse });
+  inst.parse = (data, params) => parse3(inst, data, params, { callee: inst.parse });
   inst.safeParse = (data, params) => safeParse2(inst, data, params);
   inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
   inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params);
@@ -27200,12 +27589,12 @@ var Connection = class {
     const id = this.nextRequestId++;
     let cancel = () => {
     };
-    const responsePromise = new Promise((resolve, reject) => {
+    const responsePromise = new Promise((resolve2, reject) => {
       const pendingResponse = {
         resolve: (response) => {
           try {
             const value = mapResponse ? mapResponse(response) : response;
-            resolve(value);
+            resolve2(value);
           } catch (error48) {
             reject(error48);
           }
@@ -27283,8 +27672,8 @@ var Connection = class {
   initialize(stream, handlers) {
     this.stream = stream;
     this.staticHandlers = handlers;
-    this.closedPromise = new Promise((resolve) => {
-      this.abortController.signal.addEventListener("abort", () => resolve());
+    this.closedPromise = new Promise((resolve2) => {
+      this.abortController.signal.addEventListener("abort", () => resolve2());
     });
     void this.receive();
   }
@@ -27509,13 +27898,13 @@ var ConnectionBuilder = class {
   /**
    * Adds a typed request handler for one method.
    */
-  onReceiveRequest(method, parse3, handler) {
+  onReceiveRequest(method, parse4, handler) {
     return this.withHandler({
       handleMessage: async (message, cx) => {
         if (message.kind !== "request" || message.method !== method) {
           return Handled.no(message);
         }
-        const request = parse3(message.params);
+        const request = parse4(message.params);
         return await handler(request, message.responder, cx) ?? Handled.yes();
       },
       describe: () => `${this.connectionName ?? "request"}:${method}`
@@ -27524,13 +27913,13 @@ var ConnectionBuilder = class {
   /**
    * Adds a typed notification handler for one method.
    */
-  onReceiveNotification(method, parse3, handler) {
+  onReceiveNotification(method, parse4, handler) {
     return this.withHandler({
       handleMessage: async (message, cx) => {
         if (message.kind !== "notification" || message.method !== method) {
           return Handled.no(message);
         }
-        const notification = parse3(message.params);
+        const notification = parse4(message.params);
         return await handler(notification, cx) ?? Handled.yes();
       },
       describe: () => `${this.connectionName ?? "notification"}:${method}`
@@ -28072,8 +28461,8 @@ var AsyncQueue = class {
     if (this.failed) {
       return Promise.reject(this.failure);
     }
-    return new Promise((resolve, reject) => {
-      this.waiters.push({ resolve, reject });
+    return new Promise((resolve2, reject) => {
+      this.waiters.push({ resolve: resolve2, reject });
     });
   }
 };
@@ -29184,7 +29573,7 @@ ${message}` : message;
     }
     const { executable } = resolution;
     const launch = resolveSpawnCommand(executable, ["--acp"]);
-    const child = spawn7(launch.command, launch.args, {
+    const child = spawn8(launch.command, launch.args, {
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true,
       env: prependNodePath()
@@ -29452,10 +29841,10 @@ ${message}` : message;
     if (requestId === null) {
       return Promise.resolve({ outcome: { outcome: "cancelled" } });
     }
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       this.pendingPermissions.set(requestId, {
         providerSessionId: request.sessionId,
-        resolve
+        resolve: resolve2
       });
       this.emit({
         providerSessionId: request.sessionId,
@@ -29502,7 +29891,7 @@ ${message}` : message;
     }
   }
   withTimeout(promise2, operation) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const timer = setTimeout(
         () => reject(new Error(`${operation} timed out`)),
         REQUEST_TIMEOUT_MS2
@@ -29510,7 +29899,7 @@ ${message}` : message;
       promise2.then(
         (result) => {
           clearTimeout(timer);
-          resolve(result);
+          resolve2(result);
         },
         (error48) => {
           clearTimeout(timer);
@@ -29529,9 +29918,9 @@ ${message}` : message;
     });
   }
   runSkillsList(executable, cwd) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const launch = resolveSpawnCommand(executable, ["skill", "list", "--all"]);
-      const child = spawn7(launch.command, launch.args, {
+      const child = spawn8(launch.command, launch.args, {
         cwd,
         stdio: ["ignore", "pipe", "pipe"],
         windowsHide: true,
@@ -29545,7 +29934,7 @@ ${message}` : message;
         settled = true;
         clearTimeout(timer);
         if (error48) reject(error48);
-        else resolve(stdout);
+        else resolve2(stdout);
       };
       const timer = setTimeout(() => {
         child.kill("SIGTERM");
@@ -29580,12 +29969,12 @@ ${message}` : message;
 import fs8 from "node:fs";
 import os5 from "node:os";
 import path9 from "node:path";
-import { spawn as spawn8 } from "node:child_process";
+import { spawn as spawn9 } from "node:child_process";
 var COMMAND_TIMEOUT_MS = 12e4;
 var MAX_OUTPUT_LENGTH = 1e6;
 var ANSI_ESCAPE_PATTERN = new RegExp(String.raw`\u001B\[[0-?]*[ -/]*[@-~]`, "g");
-function existingExecutable(candidates, existsSync4) {
-  return candidates.find((candidate) => candidate && existsSync4(candidate)) ?? null;
+function existingExecutable(candidates, existsSync5) {
+  return candidates.find((candidate) => candidate && existsSync5(candidate)) ?? null;
 }
 function stripAnsi(value) {
   return value.replace(ANSI_ESCAPE_PATTERN, "");
@@ -29594,7 +29983,7 @@ function resolveAliSkillsExecutable(options = {}) {
   const env = options.env ?? process.env;
   const home = (options.homedir ?? os5.homedir)();
   const platform = options.platform ?? process.platform;
-  const existsSync4 = options.existsSync ?? ((candidate) => isExecutable(candidate, platform));
+  const existsSync5 = options.existsSync ?? ((candidate) => isExecutable(candidate, platform));
   const processExecPath = options.processExecPath ?? process.execPath;
   const readdirSync2 = options.readdirSync ?? fs8.readdirSync;
   const names = executableNames("ali-skills", platform);
@@ -29616,11 +30005,11 @@ function resolveAliSkillsExecutable(options = {}) {
     ...platform === "win32" ? [] : ["/opt/homebrew/bin/ali-skills", "/usr/local/bin/ali-skills", "/usr/bin/ali-skills"],
     ...pathCandidates
   ];
-  return existingExecutable(candidates, existsSync4);
+  return existingExecutable(candidates, existsSync5);
 }
-var runAliSkillsCli = (executable, args, cwd) => new Promise((resolve, reject) => {
+var runAliSkillsCli = (executable, args, cwd) => new Promise((resolve2, reject) => {
   const launch = resolveSpawnCommand(executable, args);
-  const child = spawn8(launch.command, launch.args, {
+  const child = spawn9(launch.command, launch.args, {
     cwd,
     env: prependNodePath(prependCommandPath(executable)),
     stdio: ["ignore", "pipe", "pipe"],
@@ -29638,7 +30027,7 @@ var runAliSkillsCli = (executable, args, cwd) => new Promise((resolve, reject) =
     if (error48)
       reject(error48);
     else
-      resolve({ stdout, stderr });
+      resolve2({ stdout, stderr });
   };
   const timer = setTimeout(() => {
     child.kill("SIGTERM");
@@ -29826,7 +30215,7 @@ function createExtensionRequestMessage(id, action, data, trustedInternal = false
 // src/host-updater.ts
 import fs10 from "node:fs";
 import path11 from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // ../setup/dist/packageManager.js
 import fs9 from "node:fs";
@@ -29834,8 +30223,8 @@ import path10 from "node:path";
 function normalizePath(filePath) {
   return filePath.replaceAll("\\", "/").replace(/\/+$/, "");
 }
-function firstExisting(candidates, existsSync4) {
-  return candidates.find((candidate) => existsSync4(candidate));
+function firstExisting(candidates, existsSync5) {
+  return candidates.find((candidate) => existsSync5(candidate));
 }
 function fallbackCommand(name, platform) {
   if (platform !== "win32")
@@ -29847,7 +30236,7 @@ function fallbackCommand(name, platform) {
 function resolvePackageManagerInstallation(packageRoot, packageName, options = {}) {
   const env = options.env ?? process.env;
   const platform = options.platform ?? process.platform;
-  const existsSync4 = options.existsSync ?? ((candidate) => isExecutable(candidate, platform));
+  const existsSync5 = options.existsSync ?? ((candidate) => isExecutable(candidate, platform));
   const processExecPath = options.processExecPath ?? process.execPath;
   const normalizedRoot = normalizePath(path10.resolve(packageRoot));
   const lowerRoot = normalizedRoot.toLowerCase();
@@ -29858,13 +30247,13 @@ function resolvePackageManagerInstallation(packageRoot, packageName, options = {
     const command = firstExisting([
       ...executableNames("pnpm", platform).map((name) => path10.join(pnpmHome, name)),
       ...executableNames("pnpm", platform).map((name) => path10.join(path10.dirname(processExecPath), name))
-    ], existsSync4) ?? fallbackCommand("pnpm", platform);
+    ], existsSync5) ?? fallbackCommand("pnpm", platform);
     return { manager: "pnpm", command, binDirectory: pnpmHome };
   }
   const bunMarker = `/.bun/install/global/node_modules/${lowerPackageName}`;
   if (lowerRoot.endsWith(bunMarker)) {
     const bunHome = normalizedRoot.slice(0, lowerRoot.indexOf("/.bun/"));
-    const command = firstExisting(executableNames("bun", platform).map((name) => path10.join(bunHome, ".bun", "bin", name)), existsSync4) ?? fallbackCommand("bun", platform);
+    const command = firstExisting(executableNames("bun", platform).map((name) => path10.join(bunHome, ".bun", "bin", name)), existsSync5) ?? fallbackCommand("bun", platform);
     return {
       manager: "bun",
       command,
@@ -29883,12 +30272,12 @@ function resolvePackageManagerInstallation(packageRoot, packageName, options = {
     const command = firstExisting([
       ...executableNames("yarn", platform).map((name) => path10.join(binDirectory, name)),
       ...executableNames("yarn", platform).map((name) => path10.join(path10.dirname(processExecPath), name))
-    ], existsSync4) ?? findExecutable("yarn", { env, existsSync: existsSync4, platform }) ?? fallbackCommand("yarn", platform);
+    ], existsSync5) ?? findExecutable("yarn", { env, existsSync: existsSync5, platform }) ?? fallbackCommand("yarn", platform);
     return { manager: "yarn", command, binDirectory };
   }
   if (lowerRoot.includes("/.volta/tools/image/packages/") && lowerRoot.endsWith(`/lib/node_modules/${lowerPackageName}`)) {
     const voltaHome = normalizedRoot.slice(0, lowerRoot.indexOf("/.volta/"));
-    const command = firstExisting(executableNames("volta", platform).map((name) => path10.join(voltaHome, ".volta", "bin", name)), existsSync4) ?? fallbackCommand("volta", platform);
+    const command = firstExisting(executableNames("volta", platform).map((name) => path10.join(voltaHome, ".volta", "bin", name)), existsSync5) ?? fallbackCommand("volta", platform);
     return {
       manager: "volta",
       command,
@@ -29901,7 +30290,7 @@ function resolvePackageManagerInstallation(packageRoot, packageName, options = {
     const command = firstExisting([
       ...executableNames("npm", platform).map((name) => path10.join(prefix, "bin", name)),
       ...executableNames("npm", platform).map((name) => path10.join(path10.dirname(processExecPath), name))
-    ], existsSync4) ?? fallbackCommand("npm", platform);
+    ], existsSync5) ?? fallbackCommand("npm", platform);
     return { manager: "npm", command, binDirectory: path10.join(prefix, "bin") };
   }
   if (platform === "win32" && env.APPDATA) {
@@ -29911,7 +30300,7 @@ function resolvePackageManagerInstallation(packageRoot, packageName, options = {
       const command = firstExisting([
         ...executableNames("npm", platform).map((name) => path10.join(binDirectory, name)),
         ...executableNames("npm", platform).map((name) => path10.join(path10.dirname(processExecPath), name))
-      ], existsSync4) ?? fallbackCommand("npm", platform);
+      ], existsSync5) ?? fallbackCommand("npm", platform);
       return { manager: "npm", command, binDirectory };
     }
   }
@@ -30002,7 +30391,7 @@ var NativeHostUpdateFailure = class extends Error {
   }
 };
 function wait(delayMs) {
-  return new Promise((resolve) => setTimeout(resolve, delayMs));
+  return new Promise((resolve2) => setTimeout(resolve2, delayMs));
 }
 function readLockState(lockPath) {
   try {
@@ -30115,7 +30504,7 @@ function currentNativeHostPackageRoot(entryPath) {
   return null;
 }
 function currentPackageManagerInstallation(environment, nodePath, platform) {
-  const packageRoot = currentNativeHostPackageRoot(fileURLToPath(import.meta.url));
+  const packageRoot = currentNativeHostPackageRoot(fileURLToPath2(import.meta.url));
   if (!packageRoot) return null;
   return resolvePackageManagerInstallation(packageRoot, "@mearl/native-host", {
     env: environment,
@@ -30245,6 +30634,7 @@ function positivePort(value, fallback) {
 }
 var CDP_PORT = positivePort(cliOption("--cdp-port"), 9222);
 var CDP_USER_DATA_DIR = cliOption("--cdp-user-data-dir");
+var AGENTBAY_SESSION_ID = cliOption("--agentbay-session-id");
 var CDP_BROWSER_ID = cliOption("--browser-id") ?? "cdp";
 var CDP_BROWSER_NAME = cliOption("--browser-name") ?? "CDP";
 if (cliArg === "--init" || cliArg === "--uninstall") {
@@ -30271,6 +30661,7 @@ Options:
   --daemon                   Start as standalone CDP daemon (no extension needed)
   --cdp-port <port>          CDP port for daemon mode (default 9222)
   --cdp-user-data-dir <dir>  Read DevToolsActivePort from this Chrome profile
+  --agentbay-session-id <id> Connect to an AgentBay browser session over CDP
   --browser-id <id>          Registry id for this CDP browser
   --browser-name <name>      Human-readable registry name
   --version, -v              Show version
@@ -30314,28 +30705,53 @@ function extractChromeVersion(input) {
   const parts = match[1].split(".");
   return parts.slice(0, 3).join(".");
 }
-function fetchCdpBrowserVersion() {
+async function fetchCdpBrowserVersion() {
+  if (AGENTBAY_SESSION_ID) {
+    try {
+      const browser = await getCdpSession().getBrowserClient();
+      const result = await browser.sendCommand("Browser.getVersion", {}, 5e3);
+      return result.product ?? null;
+    } catch {
+      return null;
+    }
+  }
   const port = readDevToolsActivePort(CDP_USER_DATA_DIR)?.port ?? CDP_PORT;
-  return new Promise((resolve) => {
-    const req = http5.get(`http://localhost:${port}/json/version`, (res) => {
+  return new Promise((resolve2) => {
+    const req = http4.get(`http://localhost:${port}/json/version`, (res) => {
       let data = "";
       res.on("data", (chunk) => data += chunk);
       res.on("end", () => {
         try {
           const info = JSON.parse(data);
-          resolve(info.Browser ?? null);
+          resolve2(info.Browser ?? null);
         } catch {
-          resolve(null);
+          resolve2(null);
         }
       });
     });
-    req.on("error", () => resolve(null));
+    req.on("error", () => resolve2(null));
     req.setTimeout(2e3, () => {
       req.destroy();
-      resolve(null);
+      resolve2(null);
     });
   });
 }
+async function getCurrentBrowserUserAgent() {
+  if (extensionVersion !== null) {
+    try {
+      const result = await sendRequestToExtension("get_browser_info", {}, 3e3);
+      if (result.userAgent?.trim()) return result.userAgent;
+    } catch {
+    }
+  }
+  try {
+    const browser = await getCdpSession().getBrowserClient();
+    const result = await browser.sendCommand("Browser.getVersion", {}, 5e3);
+    if (result.userAgent?.trim()) return result.userAgent;
+  } catch {
+  }
+  throw new Error("Could not determine the control browser user agent for userAgentMode=desktop");
+}
 async function collectVersions() {
   const info = {
     nativeHost: NATIVE_HOST_VERSION,
@@ -30387,7 +30803,9 @@ function scheduleInventoryExit() {
 var cdpSession = null;
 function getCdpSession() {
   if (!cdpSession) {
-    cdpSession = new CdpSession({ port: CDP_PORT, userDataDir: CDP_USER_DATA_DIR });
+    cdpSession = AGENTBAY_SESSION_ID ? new CdpSession({
+      endpointResolver: () => resolveAgentBayEndpoint(AGENTBAY_SESSION_ID)
+    }) : new CdpSession({ port: CDP_PORT, userDataDir: CDP_USER_DATA_DIR });
   }
   return cdpSession;
 }
@@ -30591,12 +31009,12 @@ function setupNativeMessageInput() {
 }
 function sendRequestToExtension(action, data, timeoutMs, trustedInternal = false, controlSource = "local") {
   const id = `${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const timer = setTimeout(() => {
       pendingRequests.delete(id);
       reject(new Error(`Request timeout after ${timeoutMs}ms`));
     }, timeoutMs);
-    pendingRequests.set(id, { resolve, reject, timer });
+    pendingRequests.set(id, { resolve: resolve2, reject, timer });
     sendToExtension(
       createExtensionRequestMessage(id, action, data, trustedInternal, controlSource)
     );
@@ -30706,7 +31124,14 @@ async function handleSocketLine(socket, line) {
     try {
       const selector = String(data?.browser ?? data?.browserId ?? data?.name ?? "").trim();
       if (!selector) throw new Error("browser is required");
-      const result = await closeManagedBrowser(selector, { deleteProfile: data?.deleteProfile });
+      const localExists = hasManagedBrowser(selector);
+      const agentBayExists = hasAgentBayBrowser(selector);
+      if (localExists && agentBayExists) {
+        throw new Error(
+          `Managed browser name is ambiguous: ${selector}. Use the full browserId from browser_list.`
+        );
+      }
+      const result = agentBayExists ? await closeAgentBayBrowser(selector, { deleteProfile: data?.deleteProfile }) : await closeManagedBrowser(selector, { deleteProfile: data?.deleteProfile });
       socket.write(JSON.stringify({ id, success: true, data: result }) + "\n");
     } catch (error48) {
       socket.write(
@@ -30798,7 +31223,6 @@ async function handleSocketLine(socket, line) {
   }
   if (action === "browser_launch") {
     try {
-      const prepareTdbankSso = extensionVersion !== null ? (payload) => sendRequestToExtension("__tdbank_prepare_sso", payload, 2e4, true) : (payload) => cdpPrepareTdbankSso(getCdpSession(), payload);
       const exportCookies = extensionVersion !== null ? async (domains) => {
         const result2 = await sendRequestToExtension(
           "__export_cookies",
@@ -30808,8 +31232,34 @@ async function handleSocketLine(socket, line) {
         );
         return result2.cookies ?? [];
       } : (domains) => cdpExportCookies(getCdpSession(), domains);
+      if (data?.provider === "agentbay") {
+        const name2 = typeof data?.name === "string" ? data.name.trim() : "";
+        if (name2 && hasManagedBrowser(name2)) {
+          throw new Error(
+            `Managed browser name is already used by the local provider: ${name2}. Choose a unique name.`
+          );
+        }
+        const result2 = await launchAgentBayBrowser(data, {
+          nativeHostScript: fileURLToPath4(import.meta.url),
+          exportCookies,
+          getBrowserUserAgent: getCurrentBrowserUserAgent,
+          log
+        });
+        socket.write(JSON.stringify({ id, success: true, data: result2 }) + "\n");
+        return;
+      }
+      if (data?.provider !== void 0 && data.provider !== "local") {
+        throw new Error('provider must be "local" or "agentbay"');
+      }
+      const name = typeof data?.name === "string" ? data.name.trim() : "";
+      if (name && hasAgentBayBrowser(name)) {
+        throw new Error(
+          `Managed browser name is already used by the AgentBay provider: ${name}. Choose a unique name.`
+        );
+      }
+      const prepareTdbankSso = extensionVersion !== null ? (payload) => sendRequestToExtension("__tdbank_prepare_sso", payload, 2e4, true) : (payload) => cdpPrepareTdbankSso(getCdpSession(), payload);
       const result = await launchManagedBrowser(data, {
-        nativeHostScript: fileURLToPath3(import.meta.url),
+        nativeHostScript: fileURLToPath4(import.meta.url),
         prepareTdbankSso,
         exportCookies,
         log
@@ -30901,8 +31351,21 @@ async function handleViaCdp(action, data, _timeoutMs, controlSource) {
       `${action} requires the Mearl browser extension. Install it from https://chromewebstore.google.com/detail/mearl/aoehhjnofngknnjefamjbplchbolghkm`
     );
   }
-  const available = await isCdpAvailable(CDP_PORT, CDP_USER_DATA_DIR);
+  if (AGENTBAY_SESSION_ID && action === "page_upload") {
+    throw new Error(
+      "page_upload is not available for AgentBay CDP sessions because file paths resolve on the remote browser host."
+    );
+  }
+  const available = AGENTBAY_SESSION_ID ? await getCdpSession().getBrowserClient().then(
+    () => true,
+    () => false
+  ) : await isCdpAvailable(CDP_PORT, CDP_USER_DATA_DIR);
   if (!available) {
+    if (AGENTBAY_SESSION_ID) {
+      throw new Error(
+        `AgentBay CDP endpoint is not available for session ${AGENTBAY_SESSION_ID}. Check the session status and AgentBay plan permissions.`
+      );
+    }
     throw new Error(
       `Chrome DevTools remote debugging is not available on port ${CDP_PORT}. Enable it via chrome://inspect/#remote-debugging (Chrome 145+) or install the Mearl extension.`
     );
@@ -30937,16 +31400,16 @@ function onSocketConnection(socket) {
   });
 }
 function isPathAlive(socketPath) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     if (process.platform !== "win32" && !fs13.existsSync(socketPath)) {
-      resolve(false);
+      resolve2(false);
       return;
     }
     const client2 = net.createConnection(socketPath);
     const done = (alive) => {
       client2.removeAllListeners();
       client2.destroy();
-      resolve(alive);
+      resolve2(alive);
     };
     const timer = setTimeout(() => done(false), 500);
     client2.on("connect", () => {
@@ -30960,7 +31423,7 @@ function isPathAlive(socketPath) {
   });
 }
 function listenOn(socketPath) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     if (process.platform !== "win32" && fs13.existsSync(socketPath)) {
       try {
         fs13.unlinkSync(socketPath);
@@ -30986,7 +31449,7 @@ function listenOn(socketPath) {
       server.removeListener("error", reject);
       server.on("error", (error48) => log("socket server error:", String(error48)));
       log(`listening on ${socketPath}`);
-      resolve(server);
+      resolve2(server);
     });
   });
 }
@@ -31087,6 +31550,17 @@ async function main() {
       lastFocusedAt: CDP_BROWSER_ID.startsWith("managed:") ? 0 : void 0
     });
   }
+  if (AGENTBAY_SESSION_ID) {
+    const keepAliveTimer = setInterval(() => {
+      keepAgentBaySessionAlive(AGENTBAY_SESSION_ID).catch((error48) => {
+        log(
+          `AgentBay keepalive failed for ${AGENTBAY_SESSION_ID}:`,
+          error48 instanceof Error ? error48.message : String(error48)
+        );
+      });
+    }, 6e4);
+    keepAliveTimer.unref();
+  }
   process.on("SIGINT", () => cleanupAndExit(0));
   process.on("SIGTERM", () => cleanupAndExit(0));
   process.on("uncaughtException", (error48) => {