@mearl/native-host 2.3.0 → 2.5.0

package/dist/index.js

@@ -10,20 +10,20 @@ var __export = (target, all) => {
 };
 
 // ../setup/dist/nativeHost.js
-import fs9 from "node:fs";
+import fs11 from "node:fs";
 import os6 from "node:os";
-import path10 from "node:path";
+import path12 from "node:path";
 import { execFileSync } from "node:child_process";
 function resolveNativeHostDirectory(options = {}) {
   const env = options.env ?? process.env;
   const home = (options.homedir ?? os6.homedir)();
   switch (options.platform ?? process.platform) {
     case "darwin":
-      return path10.join(home, "Library/Application Support/Google/Chrome/NativeMessagingHosts");
+      return path12.join(home, "Library/Application Support/Google/Chrome/NativeMessagingHosts");
     case "linux":
-      return path10.join(home, ".config/google-chrome/NativeMessagingHosts");
+      return path12.join(home, ".config/google-chrome/NativeMessagingHosts");
     case "win32":
-      return path10.join(env.PROGRAMDATA || "C:\\ProgramData", "Google\\Chrome\\NativeMessagingHosts");
+      return path12.join(env.PROGRAMDATA || "C:\\ProgramData", "Google\\Chrome\\NativeMessagingHosts");
     default:
       throw new Error(`Unsupported platform: ${String(options.platform ?? process.platform)}`);
   }
@@ -46,23 +46,23 @@ function uninstallNativeHostArtifacts(options = {}, dependencies = {}) {
       writeLine(line);
   };
   try {
-    const existsSync4 = dependencies.existsSync ?? fs9.existsSync;
+    const existsSync5 = dependencies.existsSync ?? fs11.existsSync;
     const platform = dependencies.platform ?? process.platform;
     const hostDir = dependencies.hostDir ?? resolveNativeHostDirectory({
       env: dependencies.env,
       homedir: dependencies.homedir,
       platform
     });
-    const unlinkSync = dependencies.unlinkSync ?? fs9.unlinkSync;
+    const unlinkSync = dependencies.unlinkSync ?? fs11.unlinkSync;
     const unregister = dependencies.unregisterWindowsNativeHost ?? unregisterWindowsNativeHost;
     const hostName = MEARL_NATIVE_HOST_NAMES[mode];
     const launcherExtension = platform === "win32" ? "cmd" : "sh";
     const artifacts = [
-      path10.join(hostDir, `${hostName}.json`),
-      path10.join(hostDir, `${hostName}-launcher.${launcherExtension}`)
+      path12.join(hostDir, `${hostName}.json`),
+      path12.join(hostDir, `${hostName}-launcher.${launcherExtension}`)
     ];
     for (const artifact of artifacts) {
-      if (!existsSync4(artifact))
+      if (!existsSync5(artifact))
         continue;
       unlinkSync(artifact);
       log2(`✅ Removed: ${artifact}`);
@@ -94,17 +94,17 @@ __export(install_exports, {
   runCli: () => runCli,
   uninstallNativeHost: () => uninstallNativeHost
 });
-import fs10 from "node:fs";
-import path11 from "node:path";
+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 } from "node:url";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 function resolveHostDir() {
   return resolveNativeHostDirectory();
 }
 function resolveNativeHostPath() {
-  const siblingPath = path11.join(__dirname, "index.js");
-  if (fs10.existsSync(siblingPath)) {
+  const siblingPath = path13.join(__dirname, "index.js");
+  if (fs12.existsSync(siblingPath)) {
     return siblingPath;
   }
   try {
@@ -123,16 +123,16 @@ function registerWindowsNativeHost(hostName, manifestPath) {
   });
 }
 function createLauncherScript(hostDir, hostPath, hostName) {
-  const nodePath = path11.resolve(process.execPath);
+  const nodePath = path13.resolve(process.execPath);
   if (process.platform === "win32") {
-    const launcherPath2 = path11.join(hostDir, `${hostName}-launcher.cmd`);
+    const launcherPath2 = path13.join(hostDir, `${hostName}-launcher.cmd`);
     const content2 = `@echo off\r
 "${nodePath}" "${hostPath}" %*\r
 `;
-    fs10.writeFileSync(launcherPath2, content2, "utf-8");
+    fs12.writeFileSync(launcherPath2, content2, "utf-8");
     return launcherPath2;
   }
-  const launcherPath = path11.join(hostDir, `${hostName}-launcher.sh`);
+  const launcherPath = path13.join(hostDir, `${hostName}-launcher.sh`);
   const content = [
     "#!/bin/sh",
     `NODE_BIN=${JSON.stringify(nodePath)}`,
@@ -140,8 +140,8 @@ function createLauncherScript(hostDir, hostPath, hostName) {
     'exec "$NODE_BIN" "$HOST_SCRIPT" "$@"',
     ""
   ].join("\n");
-  fs10.writeFileSync(launcherPath, content, "utf-8");
-  fs10.chmodSync(launcherPath, 493);
+  fs12.writeFileSync(launcherPath, content, "utf-8");
+  fs12.chmodSync(launcherPath, 493);
   return launcherPath;
 }
 async function installNativeHost(options = {}) {
@@ -167,14 +167,14 @@ async function installNativeHost(options = {}) {
   try {
     const hostDir = resolveHostDir();
     if (skipIfExists) {
-      const manifestPath2 = path11.join(hostDir, `${hostName}.json`);
-      if (fs10.existsSync(manifestPath2)) {
+      const manifestPath2 = path13.join(hostDir, `${hostName}.json`);
+      if (fs12.existsSync(manifestPath2)) {
         log2(`✅ Already installed: ${manifestPath2}`);
         return true;
       }
     }
-    if (!fs10.existsSync(hostDir)) {
-      fs10.mkdirSync(hostDir, { recursive: true });
+    if (!fs12.existsSync(hostDir)) {
+      fs12.mkdirSync(hostDir, { recursive: true });
       log2(`✅ Created directory: ${hostDir}`);
     }
     const resolvedHostPath = resolveNativeHostPath();
@@ -188,13 +188,13 @@ async function installNativeHost(options = {}) {
       type: "stdio",
       allowed_origins: [`chrome-extension://${extensionId}/`]
     };
-    const manifestPath = path11.join(hostDir, `${hostName}.json`);
-    fs10.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+    const manifestPath = path13.join(hostDir, `${hostName}.json`);
+    fs12.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
     if (process.platform === "win32") {
       registerWindowsNativeHost(hostName, manifestPath);
       log2(`✅ Windows registry key created for: ${hostName}`);
     } else {
-      fs10.chmodSync(manifestPath, 420);
+      fs12.chmodSync(manifestPath, 420);
     }
     log2(`✅ Manifest installed: ${manifestPath}`);
     log2(`✅ Extension ID: ${extensionId}`);
@@ -306,26 +306,25 @@ var init_install = __esm({
     "use strict";
     init_nativeHost();
     DEFAULT_EXTENSION_ID = "aoehhjnofngknnjefamjbplchbolghkm";
-    __filename = fileURLToPath(import.meta.url);
-    __dirname = path11.dirname(__filename);
+    __filename = fileURLToPath3(import.meta.url);
+    __dirname = path13.dirname(__filename);
     ALL_MODES = ["skills", "mcp"];
   }
 });
 
 // src/index.ts
 import net from "node:net";
-import fs11 from "node:fs";
-import http5 from "node:http";
+import fs13 from "node:fs";
+import http4 from "node:http";
 import os7 from "node:os";
-import path12 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import path14 from "node:path";
+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);
+    }
   }
 };
 
@@ -1166,13 +1065,13 @@ function queryTrackingEvents(buffer, options = {}) {
 }
 
 // ../browser-core/dist/requestSerializer.js
-function parsePath(path13) {
-  if (path13.length > 1e3)
+function parsePath(path15) {
+  if (path15.length > 1e3)
     throw new Error("Path too long: maximum 1000 characters allowed");
   const keys = [];
   let current = "";
-  for (let i = 0; i < path13.length; i++) {
-    const char = path13[i];
+  for (let i = 0; i < path15.length; i++) {
+    const char = path15[i];
     if (char === ".") {
       if (current) {
         keys.push(current);
@@ -1184,10 +1083,10 @@ function parsePath(path13) {
         current = "";
       }
       let j = i + 1;
-      while (j < path13.length && path13[j] !== "]")
+      while (j < path15.length && path15[j] !== "]")
         j++;
-      if (j < path13.length) {
-        const index = parseInt(path13.substring(i + 1, j), 10);
+      if (j < path15.length) {
+        const index = parseInt(path15.substring(i + 1, j), 10);
         if (!isNaN(index)) {
           if (index < 0 || index > 1e5)
             throw new Error(`Array index out of safe range: ${index}`);
@@ -1205,8 +1104,8 @@ function parsePath(path13) {
     throw new Error("Path too deep: maximum 50 levels allowed");
   return keys;
 }
-function getValueByPath(obj, path13) {
-  const keys = parsePath(path13);
+function getValueByPath(obj, path15) {
+  const keys = parsePath(path15);
   let current = obj;
   for (const key of keys) {
     if (current === null || current === void 0)
@@ -1215,8 +1114,8 @@ function getValueByPath(obj, path13) {
   }
   return current;
 }
-function setValueByPath(obj, path13, value) {
-  const keys = parsePath(path13);
+function setValueByPath(obj, path15, value) {
+  const keys = parsePath(path15);
   let current = obj;
   for (let i = 0; i < keys.length - 1; i++) {
     const key = keys[i];
@@ -2752,19 +2651,19 @@ function installPageObserverInPage(maxBatches = 50) {
         }
       }
     }
-    const path13 = [];
+    const path15 = [];
     let current = input;
-    while (current && current !== document.documentElement && path13.length < 6) {
+    while (current && current !== document.documentElement && path15.length < 6) {
       const parent = current.parentElement;
       const currentTag = current.tagName.toLowerCase();
       if (!parent) {
-        path13.unshift(currentTag);
+        path15.unshift(currentTag);
         break;
       }
       const siblings = Array.from(parent.children).filter((item) => item.tagName === current.tagName);
       const position = siblings.indexOf(current) + 1;
-      path13.unshift(siblings.length > 1 ? `${currentTag}:nth-of-type(${position})` : currentTag);
-      const candidate = path13.join(" > ");
+      path15.unshift(siblings.length > 1 ? `${currentTag}:nth-of-type(${position})` : currentTag);
+      const candidate = path15.join(" > ");
       if (input.isConnected) {
         try {
           if (document.querySelectorAll(candidate).length === 1)
@@ -2774,7 +2673,7 @@ function installPageObserverInPage(maxBatches = 50) {
       }
       current = parent;
     }
-    return path13.join(" > ") || void 0;
+    return path15.join(" > ") || void 0;
   };
   const inferredRole = (element) => {
     const explicit = element.getAttribute("role");
@@ -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,
@@ -4409,12 +4308,12 @@ function resolveGetCookieTarget(currentUrl, input) {
   const url2 = parseCurrentUrl(currentUrl, action);
   const name = validateCookieName(input?.name, action);
   const domain2 = resolveExplicitDomain(url2, input?.domain, action);
-  const path13 = validateCookiePath(input?.path, action);
+  const path15 = validateCookiePath(input?.path, action);
   return {
     cookieName: name,
-    cookieUrl: `${url2.protocol}//${url2.hostname}${(path13 ?? url2.pathname) || "/"}`,
+    cookieUrl: `${url2.protocol}//${url2.hostname}${(path15 ?? url2.pathname) || "/"}`,
     ...domain2 ? { domain: domain2 } : {},
-    ...path13 ? { path: path13 } : {}
+    ...path15 ? { path: path15 } : {}
   };
 }
 function resolveSetCookieTarget(currentUrl, input) {
@@ -4422,7 +4321,7 @@ function resolveSetCookieTarget(currentUrl, input) {
   const url2 = parseCurrentUrl(currentUrl, action);
   const name = validateCookieName(input?.name, action);
   const value = validateCookieValue(input?.value);
-  const path13 = validateCookiePath(input?.path, action) ?? "/";
+  const path15 = validateCookiePath(input?.path, action) ?? "/";
   if (input.reload !== void 0 && typeof input.reload !== "boolean") {
     throw new Error('set_cookie: "reload" must be a boolean');
   }
@@ -4432,9 +4331,9 @@ function resolveSetCookieTarget(currentUrl, input) {
     cookieName: name,
     cookieValue: value,
     ...explicitDomain ? { cookieDomain: explicitDomain.includes(".") ? `.${explicitDomain}` : explicitDomain } : {},
-    cookieUrl: `${url2.protocol}//${url2.hostname.toLowerCase()}${path13}`,
+    cookieUrl: `${url2.protocol}//${url2.hostname.toLowerCase()}${path15}`,
     domain: domain2,
-    path: path13,
+    path: path15,
     reload: input.reload === true
   };
 }
@@ -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) => {
@@ -7612,8 +7534,8 @@ registerActions([
 ]);
 
 // src/cdp-backend/tdbank-handlers.ts
-async function cdpFetchTdbank(session, path13, options = {}) {
-  const url2 = new URL(`https://tdbank.alibaba-inc.com${path13}`);
+async function cdpFetchTdbank(session, path15, options = {}) {
+  const url2 = new URL(`https://tdbank.alibaba-inc.com${path15}`);
   for (const [key, value] of Object.entries(options.params ?? {})) {
     if (value !== void 0 && value !== null) {
       url2.searchParams.set(key, String(value));
@@ -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,360 @@ 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.persistent === true) {
+    throw new Error("persistent is not supported by the AgentBay CDP provider yet");
+  }
+  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 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: false,
+    agentbaySessionId: record2.sessionId,
+    ...record2.imageId ? { agentbayImageId: record2.imageId } : {},
+    ...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);
+  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 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 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 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);
+    const created = await agentBay.create({ imageId, framework: "mearl" });
+    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,
+      ...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,
+          ...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 closeAgentBayBrowser(selector) {
+  const record2 = findRecord(selector);
+  if (!record2) throw new Error(`AgentBay browser not found: ${selector}`);
+  try {
+    const session = await requireSession(record2.sessionId, resolveAgentBayApiKey());
+    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;
+  }
+  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,
+    sessionDeleted: true
+  };
+}
+
 // src/browser-registry.ts
 var BROWSERS_SUBDIR = "browsers";
 var STALE_RECORD_TTL_MS = 5 * 6e4;
@@ -9715,10 +10002,14 @@ 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 } : {},
+      ..."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 +10019,14 @@ 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 } : {},
+    ..."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 +10036,7 @@ function mergeBrowserInventory(connected, managed) {
   };
 }
 function listBrowserInventory() {
-  const managed = listManagedBrowsers();
+  const managed = [...listManagedBrowsers(), ...listAgentBayBrowsers()];
   return mergeBrowserInventory(listRegisteredBrowsers(), managed);
 }
 
@@ -9752,7 +10047,7 @@ import os2 from "node:os";
 import { randomUUID as randomUUID4 } from "node:crypto";
 
 // src/version.ts
-var NATIVE_HOST_VERSION = true ? "2.3.0" : "unknown";
+var NATIVE_HOST_VERSION = true ? "2.5.0" : "unknown";
 
 // src/analytics.ts
 var MEASUREMENT_ID = "G-W84LJDZ6PH";
@@ -9936,14 +10231,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 +10909,18 @@ 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 {
     fs5.accessSync(filePath, platform === "win32" ? fs5.constants.F_OK : fs5.constants.X_OK);
@@ -10669,12 +10965,12 @@ function resolveSpawnCommand(executable, args, platform = process.platform, comm
 function prependCommandPath(command, env = process.env) {
   if (!path6.isAbsolute(command))
     return env;
-  return prependPath(path6.dirname(command), env);
+  return prependPathDirectory(path6.dirname(command), env);
 }
 function prependNodePath(env = process.env, nodeExecutable = process.execPath) {
-  return prependPath(path6.dirname(nodeExecutable), env);
+  return prependPathDirectory(path6.dirname(nodeExecutable), env);
 }
-function prependPath(directory, env) {
+function prependPathDirectory(directory, env = process.env) {
   const pathKey = Object.keys(env).find((key) => key.toLowerCase() === "path") || "PATH";
   const inherited = env[pathKey] || "";
   const entries = inherited.split(path6.delimiter).filter(Boolean);
@@ -10682,6 +10978,59 @@ function prependPath(directory, env) {
     return env;
   return { ...env, [pathKey]: [directory, ...entries].join(path6.delimiter) };
 }
+function findExecutable(name, options = {}) {
+  const env = options.env ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const existsSync5 = options.existsSync ?? ((candidate) => isExecutable(candidate, platform));
+  const pathKey = Object.keys(env).find((key) => key.toLowerCase() === "path") || "PATH";
+  const directories = [
+    ...options.extraDirectories ?? [],
+    ...(env[pathKey] ?? "").split(path6.delimiter).filter(Boolean)
+  ];
+  for (const directory of directories) {
+    for (const executableName of executableNames(name, platform)) {
+      const candidate = path6.join(directory, executableName);
+      if (existsSync5(candidate))
+        return candidate;
+    }
+  }
+  return null;
+}
+var runCommand = (command, args, options = {}) => new Promise((resolve2, reject) => {
+  const capture = options.capture === true;
+  const launch = resolveSpawnCommand(command, args);
+  const child = spawn5(launch.command, launch.args, {
+    cwd: options.cwd,
+    env: options.env,
+    stdio: capture ? ["ignore", "pipe", "pipe"] : "inherit",
+    windowsHide: true
+  });
+  let stdout = "";
+  let stderr = "";
+  let settled = false;
+  const append = (current, chunk) => current.length >= MAX_CAPTURE_LENGTH ? current : (current + chunk.toString("utf8")).slice(0, MAX_CAPTURE_LENGTH);
+  const finish = (error48, code = 1) => {
+    if (settled)
+      return;
+    settled = true;
+    if (timer)
+      clearTimeout(timer);
+    if (error48)
+      reject(error48);
+    else
+      resolve2({ code, stdout, stderr });
+  };
+  const timer = options.timeoutMs === void 0 ? void 0 : setTimeout(() => {
+    child.kill("SIGTERM");
+    finish(new Error(`Command timed out after ${options.timeoutMs}ms`));
+  }, options.timeoutMs);
+  if (capture) {
+    child.stdout?.on("data", (chunk) => stdout = append(stdout, chunk));
+    child.stderr?.on("data", (chunk) => stderr = append(stderr, chunk));
+  }
+  child.once("error", (error48) => finish(error48));
+  child.once("close", (code) => finish(void 0, code ?? 1));
+});
 
 // src/agent/executable-resolver.ts
 function agentExecutableCandidatePaths({
@@ -10791,11 +11140,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()
@@ -10804,7 +11153,7 @@ function probeAgentExecutable(executable, options) {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve(error48);
+      resolve2(error48);
     };
     const timer = setTimeout(() => {
       child.kill("SIGTERM");
@@ -10935,13 +11284,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."));
     });
   });
@@ -11108,7 +11457,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) {
@@ -11170,7 +11519,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
@@ -11262,12 +11611,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) {
@@ -11341,7 +11690,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
@@ -11577,7 +11926,7 @@ __export(external_exports, {
   object: () => object,
   optional: () => optional,
   overwrite: () => _overwrite,
-  parse: () => parse2,
+  parse: () => parse3,
   parseAsync: () => parseAsync2,
   partialRecord: () => partialRecord,
   pipe: () => pipe,
@@ -11896,7 +12245,7 @@ __export(core_exports2, {
   isValidJWT: () => isValidJWT,
   locales: () => locales_exports,
   meta: () => meta,
-  parse: () => parse,
+  parse: () => parse2,
   parseAsync: () => parseAsync,
   prettifyError: () => prettifyError,
   process: () => process2,
@@ -12163,10 +12512,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path13) {
-  if (!path13)
+function getElementAtPath(obj, path15) {
+  if (!path15)
     return obj;
-  return path13.reduce((acc, key) => acc?.[key], obj);
+  return path15.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -12549,11 +12898,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path13, issues) {
+function prefixIssues(path15, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path13);
+    iss.path.unshift(path15);
     return iss;
   });
 }
@@ -12736,7 +13085,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path13 = []) => {
+  const processError = (error49, path15 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -12746,7 +13095,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path13, ...issue2.path];
+        const fullpath = [...path15, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -12778,8 +13127,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path13 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path13) {
+  const path15 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path15) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -12819,7 +13168,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);
@@ -15492,10 +15841,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;
     };
@@ -23544,7 +23893,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);
@@ -23587,7 +23936,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);
@@ -24756,13 +25105,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path13 = ref.slice(1).split("/").filter(Boolean);
-  if (path13.length === 0) {
+  const path15 = ref.slice(1).split("/").filter(Boolean);
+  if (path15.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path13[0] === defsKey) {
-    const key = path13[1];
+  if (path15[0] === defsKey) {
+    const key = path15[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -27146,12 +27495,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);
           }
@@ -27229,8 +27578,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();
   }
@@ -27455,13 +27804,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}`
@@ -27470,13 +27819,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}`
@@ -28018,8 +28367,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 });
     });
   }
 };
@@ -29130,7 +29479,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()
@@ -29398,10 +29747,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,
@@ -29448,7 +29797,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
@@ -29456,7 +29805,7 @@ ${message}` : message;
       promise2.then(
         (result) => {
           clearTimeout(timer);
-          resolve(result);
+          resolve2(result);
         },
         (error48) => {
           clearTimeout(timer);
@@ -29475,9 +29824,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,
@@ -29491,7 +29840,7 @@ ${message}` : message;
         settled = true;
         clearTimeout(timer);
         if (error48) reject(error48);
-        else resolve(stdout);
+        else resolve2(stdout);
       };
       const timer = setTimeout(() => {
         child.kill("SIGTERM");
@@ -29526,12 +29875,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, "");
@@ -29540,7 +29889,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);
@@ -29562,11 +29911,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"],
@@ -29584,7 +29933,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");
@@ -29769,6 +30118,409 @@ function createExtensionRequestMessage(id, action, data, trustedInternal = false
   };
 }
 
+// src/host-updater.ts
+import fs10 from "node:fs";
+import path11 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// ../setup/dist/packageManager.js
+import fs9 from "node:fs";
+import path10 from "node:path";
+function normalizePath(filePath) {
+  return filePath.replaceAll("\\", "/").replace(/\/+$/, "");
+}
+function firstExisting(candidates, existsSync5) {
+  return candidates.find((candidate) => existsSync5(candidate));
+}
+function fallbackCommand(name, platform) {
+  if (platform !== "win32")
+    return name;
+  if (name === "bun" || name === "volta")
+    return `${name}.exe`;
+  return `${name}.cmd`;
+}
+function resolvePackageManagerInstallation(packageRoot, packageName, options = {}) {
+  const env = options.env ?? process.env;
+  const platform = options.platform ?? process.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();
+  const lowerPackageName = packageName.toLowerCase();
+  const pnpmGlobalRoot = /\/global\/\d+\/(?:\.pnpm\/.*\/)?node_modules\//.exec(lowerRoot);
+  if (pnpmGlobalRoot && lowerRoot.endsWith(`/node_modules/${lowerPackageName}`)) {
+    const pnpmHome = normalizedRoot.slice(0, pnpmGlobalRoot.index);
+    const command = firstExisting([
+      ...executableNames("pnpm", platform).map((name) => path10.join(pnpmHome, name)),
+      ...executableNames("pnpm", platform).map((name) => path10.join(path10.dirname(processExecPath), name))
+    ], 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)), existsSync5) ?? fallbackCommand("bun", platform);
+    return {
+      manager: "bun",
+      command,
+      binDirectory: path10.join(bunHome, ".bun", "bin")
+    };
+  }
+  if ((lowerRoot.includes("/.config/yarn/global/node_modules/") || lowerRoot.includes("/.yarn/global/node_modules/") || lowerRoot.includes("/yarn/global/node_modules/") || lowerRoot.includes("/yarn/data/global/node_modules/")) && lowerRoot.endsWith(`/node_modules/${lowerPackageName}`)) {
+    const layout = [
+      { marker: "/.config/yarn/global/", binSegments: [".yarn", "bin"] },
+      { marker: "/.yarn/global/", binSegments: [".yarn", "bin"] },
+      { marker: "/yarn/data/global/", binSegments: ["yarn", "bin"] },
+      { marker: "/yarn/global/", binSegments: ["yarn", "bin"] }
+    ].find((candidate) => lowerRoot.includes(candidate.marker));
+    const prefix = normalizedRoot.slice(0, lowerRoot.indexOf(layout.marker));
+    const binDirectory = path10.join(prefix, ...layout.binSegments);
+    const command = firstExisting([
+      ...executableNames("yarn", platform).map((name) => path10.join(binDirectory, name)),
+      ...executableNames("yarn", platform).map((name) => path10.join(path10.dirname(processExecPath), name))
+    ], 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)), existsSync5) ?? fallbackCommand("volta", platform);
+    return {
+      manager: "volta",
+      command,
+      binDirectory: path10.join(voltaHome, ".volta", "bin")
+    };
+  }
+  const npmMarker = `/lib/node_modules/${lowerPackageName}`;
+  if (lowerRoot.endsWith(npmMarker)) {
+    const prefix = normalizedRoot.slice(0, lowerRoot.length - npmMarker.length);
+    const command = firstExisting([
+      ...executableNames("npm", platform).map((name) => path10.join(prefix, "bin", name)),
+      ...executableNames("npm", platform).map((name) => path10.join(path10.dirname(processExecPath), name))
+    ], existsSync5) ?? fallbackCommand("npm", platform);
+    return { manager: "npm", command, binDirectory: path10.join(prefix, "bin") };
+  }
+  if (platform === "win32" && env.APPDATA) {
+    const npmRoot = normalizePath(path10.join(env.APPDATA, "npm", "node_modules", packageName));
+    if (lowerRoot === npmRoot.toLowerCase()) {
+      const binDirectory = path10.join(env.APPDATA, "npm");
+      const command = firstExisting([
+        ...executableNames("npm", platform).map((name) => path10.join(binDirectory, name)),
+        ...executableNames("npm", platform).map((name) => path10.join(path10.dirname(processExecPath), name))
+      ], existsSync5) ?? fallbackCommand("npm", platform);
+      return { manager: "npm", command, binDirectory };
+    }
+  }
+  return null;
+}
+
+// ../setup/dist/version.js
+var MEARL_RELEASE_VERSION_MAX_LENGTH = 64;
+var RELEASE_VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-beta\.(0|[1-9]\d*))?$/;
+var RELEASE_LINE_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.x$/;
+var RELEASE_COMPONENT_MAXIMUM = 65535;
+function parseComponent(value) {
+  const component = Number(value);
+  return Number.isSafeInteger(component) && component <= RELEASE_COMPONENT_MAXIMUM ? component : null;
+}
+function parseMearlReleaseVersion(value) {
+  if (typeof value !== "string" || value.length > MEARL_RELEASE_VERSION_MAX_LENGTH)
+    return null;
+  const match = RELEASE_VERSION_PATTERN.exec(value);
+  if (!match)
+    return null;
+  const major = parseComponent(match[1]);
+  const minor = parseComponent(match[2]);
+  const patch = parseComponent(match[3]);
+  const beta = match[4] === void 0 ? void 0 : parseComponent(match[4]);
+  if (major === null || minor === null || patch === null || beta === null)
+    return null;
+  return {
+    raw: value,
+    major,
+    minor,
+    patch,
+    channel: beta === void 0 ? "stable" : "beta",
+    ...beta === void 0 ? {} : { beta }
+  };
+}
+function isMearlReleaseVersion(value) {
+  return parseMearlReleaseVersion(value) !== null;
+}
+function parseMearlReleaseLine(value) {
+  if (typeof value !== "string" || value.length > MEARL_RELEASE_VERSION_MAX_LENGTH)
+    return null;
+  const match = RELEASE_LINE_PATTERN.exec(value);
+  if (!match)
+    return null;
+  const major = parseComponent(match[1]);
+  const minor = parseComponent(match[2]);
+  if (major === null || minor === null)
+    return null;
+  return { raw: value, major, minor };
+}
+function mearlReleaseLineForVersion(version2) {
+  const parsed = parseMearlReleaseVersion(version2);
+  if (!parsed)
+    throw new Error("A valid Mearl release version is required");
+  return `${parsed.major}.${parsed.minor}.x`;
+}
+function isMearlReleaseVersionInLine(version2, releaseLine) {
+  const parsedVersion = parseMearlReleaseVersion(version2);
+  const parsedLine = parseMearlReleaseLine(releaseLine);
+  return parsedVersion !== null && parsedLine !== null && parsedVersion.major === parsedLine.major && parsedVersion.minor === parsedLine.minor;
+}
+function compareMearlReleaseLines(leftVersion, rightVersion) {
+  const left = parseMearlReleaseVersion(leftVersion);
+  const right = parseMearlReleaseVersion(rightVersion);
+  if (!left || !right) {
+    throw new Error("Mearl release-line comparison requires valid release versions");
+  }
+  for (const key of ["major", "minor"]) {
+    if (left[key] < right[key])
+      return -1;
+    if (left[key] > right[key])
+      return 1;
+  }
+  return 0;
+}
+
+// src/host-updater.ts
+var NATIVE_HOST_UPDATE_TIMEOUT_MS = 5 * 6e4;
+var UPDATE_LOCK_PATH = path11.join(DAEMON_HOME, "native-host-update.lock");
+var UPDATE_LOCK_POLL_MS = 500;
+var INVALID_UPDATE_LOCK_GRACE_MS = 1e4;
+var NativeHostUpdateFailure = class extends Error {
+  constructor(updateError, message) {
+    super(message);
+    this.updateError = updateError;
+    this.name = "NativeHostUpdateFailure";
+  }
+};
+function wait(delayMs) {
+  return new Promise((resolve2) => setTimeout(resolve2, delayMs));
+}
+function readLockState(lockPath) {
+  try {
+    const stat2 = fs10.lstatSync(lockPath);
+    if (!stat2.isFile() || stat2.isSymbolicLink() || stat2.size > 4096) {
+      return { modifiedAt: stat2.mtimeMs, owner: null };
+    }
+    try {
+      const value = JSON.parse(fs10.readFileSync(lockPath, "utf8"));
+      const owner = Number.isInteger(value.pid) && value.pid > 0 && typeof value.startedAt === "number" && Number.isFinite(value.startedAt) && value.startedAt > 0 ? { pid: value.pid, startedAt: value.startedAt } : null;
+      return { modifiedAt: stat2.mtimeMs, owner };
+    } catch {
+      return { modifiedAt: stat2.mtimeMs, owner: null };
+    }
+  } catch {
+    return null;
+  }
+}
+async function withNativeHostUpdateLock(lockPath, targetVersion, operation) {
+  fs10.mkdirSync(path11.dirname(lockPath), { recursive: true, mode: 448 });
+  const startedAt = Date.now();
+  const owner = `${JSON.stringify({ pid: process.pid, startedAt, targetVersion })}
+`;
+  while (true) {
+    try {
+      const handle = fs10.openSync(lockPath, "wx", 384);
+      try {
+        fs10.writeFileSync(handle, owner, "utf8");
+      } finally {
+        fs10.closeSync(handle);
+      }
+      break;
+    } catch (error48) {
+      if (!(error48 instanceof Error) || !("code" in error48) || error48.code !== "EEXIST") throw error48;
+      const existing = readLockState(lockPath);
+      const staleAfter = existing?.owner ? NATIVE_HOST_UPDATE_TIMEOUT_MS : INVALID_UPDATE_LOCK_GRACE_MS;
+      const referenceTime = existing?.owner?.startedAt ?? existing?.modifiedAt;
+      const expired = referenceTime !== void 0 && Date.now() - referenceTime > staleAfter;
+      const ownerAlive = existing?.owner ? isAlive(existing.owner.pid) : false;
+      if (expired && !ownerAlive) {
+        try {
+          fs10.unlinkSync(lockPath);
+          continue;
+        } catch {
+        }
+      }
+      if (Date.now() - startedAt > NATIVE_HOST_UPDATE_TIMEOUT_MS + 1e4) {
+        throw new NativeHostUpdateFailure(
+          "lock-timeout",
+          "Another Mearl Native Host update did not finish in time"
+        );
+      }
+      await wait(UPDATE_LOCK_POLL_MS);
+    }
+  }
+  try {
+    return await operation();
+  } finally {
+    try {
+      if (fs10.readFileSync(lockPath, "utf8") === owner) fs10.unlinkSync(lockPath);
+    } catch {
+    }
+  }
+}
+function classifyUpdateFailure(output) {
+  if (/\b(?:E404|ETARGET)\b|no matching version found|404\s+not found|package.+not found/i.test(
+    output
+  )) {
+    return "package-unavailable";
+  }
+  if (/\b(?:EAI_AGAIN|ECONNREFUSED|ECONNRESET|ENETUNREACH|ENOTFOUND|ERR_SOCKET_TIMEOUT)\b|fetch failed|network request/i.test(
+    output
+  )) {
+    return "network";
+  }
+  return "setup-failed";
+}
+function nativeHostUpdateCommand(targetVersion) {
+  if (!isMearlReleaseVersion(targetVersion)) {
+    throw new Error("The Native Host update target must be a valid Mearl release");
+  }
+  const releaseLine = mearlReleaseLineForVersion(targetVersion);
+  const packageSpec = `@mearl/setup@${releaseLine}`;
+  const args = [
+    "--yes",
+    packageSpec,
+    "update",
+    "--local",
+    "--yes",
+    "--target-line",
+    releaseLine,
+    "--skip-skill"
+  ];
+  return {
+    args
+  };
+}
+function currentNativeHostPackageRoot(entryPath) {
+  let current = path11.dirname(entryPath);
+  for (let depth = 0; depth < 12; depth += 1) {
+    try {
+      const manifest = JSON.parse(fs10.readFileSync(path11.join(current, "package.json"), "utf8"));
+      if (manifest.name === "@mearl/native-host") return current;
+    } catch {
+    }
+    const parent = path11.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+function currentPackageManagerInstallation(environment, nodePath, platform) {
+  const packageRoot = currentNativeHostPackageRoot(fileURLToPath2(import.meta.url));
+  if (!packageRoot) return null;
+  return resolvePackageManagerInstallation(packageRoot, "@mearl/native-host", {
+    env: environment,
+    platform,
+    processExecPath: nodePath
+  });
+}
+async function installedLocalPackagesMatch(targetReleaseLine, environment, runner) {
+  const installedVersions = [];
+  for (const executableName of ["mearl-native-host", "mearl"]) {
+    const executable = findExecutable(executableName, { env: environment });
+    if (!executable) return false;
+    try {
+      const result = await runner(executable, ["--version"], {
+        capture: true,
+        env: environment,
+        timeoutMs: 5e3
+      });
+      const installedVersion = result.stdout.trim();
+      if (result.code !== 0 || !isMearlReleaseVersionInLine(installedVersion, targetReleaseLine)) {
+        return false;
+      }
+      installedVersions.push(installedVersion);
+    } catch {
+      return false;
+    }
+  }
+  return new Set(installedVersions).size === 1;
+}
+async function runNativeHostUpdate(targetVersion, options = {}) {
+  const command = nativeHostUpdateCommand(targetVersion);
+  const targetReleaseLine = mearlReleaseLineForVersion(targetVersion);
+  const environment = options.environment ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const nodePath = options.nodePath ?? process.execPath;
+  const currentInstallation = currentPackageManagerInstallation(environment, nodePath, platform);
+  const managerCommand = options.packageManagerCommand === void 0 ? currentInstallation?.command ?? null : options.packageManagerCommand;
+  const packageBinDirectory = options.packageBinDirectory === void 0 ? currentInstallation?.binDirectory ?? null : options.packageBinDirectory;
+  let childEnvironment = prependNodePath(environment, nodePath);
+  if (managerCommand) childEnvironment = prependCommandPath(managerCommand, childEnvironment);
+  if (packageBinDirectory) {
+    childEnvironment = prependPathDirectory(packageBinDirectory, childEnvironment);
+  }
+  const packageRunner = options.packageRunner ?? findExecutable("npx", {
+    env: childEnvironment,
+    extraDirectories: [path11.dirname(nodePath)],
+    platform
+  });
+  if (!packageRunner) {
+    throw new NativeHostUpdateFailure("package-unavailable", "The package runner is unavailable");
+  }
+  const runner = options.runner ?? runCommand;
+  const areTargetsInstalled = options.areTargetsInstalled ?? ((version2, env) => installedLocalPackagesMatch(version2, env, runner));
+  const withUpdateLock = options.withUpdateLock ?? ((version2, operation) => withNativeHostUpdateLock(options.updateLockPath ?? UPDATE_LOCK_PATH, version2, operation));
+  await withUpdateLock(targetVersion, async () => {
+    let result;
+    try {
+      result = await runner(packageRunner, command.args, {
+        capture: true,
+        env: childEnvironment,
+        timeoutMs: options.timeoutMs ?? NATIVE_HOST_UPDATE_TIMEOUT_MS
+      });
+    } catch (error48) {
+      const message = error48 instanceof Error ? error48.message : String(error48);
+      const classified = classifyUpdateFailure(message);
+      throw new NativeHostUpdateFailure(
+        /timed out/i.test(message) ? "timeout" : classified === "setup-failed" ? "unknown" : classified,
+        "The Native Host update process did not complete"
+      );
+    }
+    if (result.code !== 0) {
+      throw new NativeHostUpdateFailure(
+        classifyUpdateFailure(`${result.stderr.slice(0, 8192)}
+${result.stdout.slice(0, 8192)}`),
+        "The Mearl setup release line did not complete successfully"
+      );
+    }
+    if (!await areTargetsInstalled(targetReleaseLine, childEnvironment)) {
+      throw new NativeHostUpdateFailure(
+        "verification-failed",
+        "The installed Native Host and client do not match the Extension release line"
+      );
+    }
+  });
+}
+var NativeHostUpdateCoordinator = class {
+  constructor(options) {
+    this.options = options;
+  }
+  #automaticAttempted = false;
+  #operation = null;
+  evaluate(extensionVersion2, checkForUpdates) {
+    if (checkForUpdates !== true || this.#automaticAttempted || this.#operation) return;
+    if (!isMearlReleaseVersion(extensionVersion2) || !isMearlReleaseVersion(this.options.hostVersion)) {
+      this.options.log("Skipped Native Host update check because a release version was invalid");
+      return;
+    }
+    const targetVersion = extensionVersion2;
+    if (compareMearlReleaseLines(this.options.hostVersion, targetVersion) >= 0) return;
+    this.#automaticAttempted = true;
+    const operation = this.options.runUpdate(targetVersion).then(() => this.options.requestRestart()).catch((error48) => {
+      const category = error48 instanceof NativeHostUpdateFailure ? error48.updateError : "unknown";
+      this.options.log(`Native Host automatic update failed (${category})`);
+    }).finally(() => {
+      if (this.#operation === operation) this.#operation = null;
+    });
+    this.#operation = operation;
+  }
+};
+
 // src/index.ts
 var cliArgs = process.argv.slice(2);
 var cliArg = cliArgs[0];
@@ -29788,6 +30540,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") {
@@ -29814,6 +30567,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
@@ -29835,11 +30589,11 @@ Examples:
   process.exit(0);
 }
 function socketPathFor(suffix) {
-  return process.platform === "win32" ? `\\\\.\\pipe\\mearl-agent${suffix}` : path12.join(os7.tmpdir(), `mearl-agent${suffix}.sock`);
+  return process.platform === "win32" ? `\\\\.\\pipe\\mearl-agent${suffix}` : path14.join(os7.tmpdir(), `mearl-agent${suffix}.sock`);
 }
 var LEGACY_SOCKET_PATH = socketPathFor("");
 var INSTANCE_SOCKET_PATH = socketPathFor(`-${process.pid}`);
-var LOG_FILE = path12.join(os7.tmpdir(), "mearl-native-host.log");
+var LOG_FILE = path14.join(os7.tmpdir(), "mearl-native-host.log");
 var DEFAULT_TIMEOUT_MS = 15e3;
 var INVENTORY_IDLE_EXIT_MS = 1e3;
 var MAX_SOCKET_BUFFER_SIZE = 64 * 1024 * 1024;
@@ -29857,28 +30611,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,
@@ -29930,7 +30709,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;
 }
@@ -29938,7 +30719,7 @@ function log(...args) {
   const msg = `[${(/* @__PURE__ */ new Date()).toISOString()}] [NativeHost] ${args.join(" ")}
 `;
   try {
-    fs11.appendFileSync(LOG_FILE, msg);
+    fs13.appendFileSync(LOG_FILE, msg);
   } catch {
   }
 }
@@ -29950,6 +30731,14 @@ function sendToExtension(message) {
   process.stdout.write(header);
   process.stdout.write(json2);
 }
+var nativeHostUpdateCoordinator = new NativeHostUpdateCoordinator({
+  hostVersion: NATIVE_HOST_VERSION,
+  log,
+  runUpdate: (targetVersion) => runNativeHostUpdate(targetVersion),
+  requestRestart: () => {
+    restartAfterUpdate();
+  }
+});
 var agentChatManager = null;
 var agentSkillManager = new AgentSkillManager();
 function getAgentChatManager() {
@@ -30060,6 +30849,7 @@ function handleExtensionMessage(message) {
       extensionVersion: extensionVersion ?? void 0
     });
     sendToExtension({ type: "pong", timestamp: Date.now(), version: NATIVE_HOST_VERSION });
+    nativeHostUpdateCoordinator.evaluate(message.version, message.checkForUpdates);
     return;
   }
   if (message && message.type === "browser_focus") {
@@ -30125,12 +30915,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)
     );
@@ -30240,7 +31030,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) : await closeManagedBrowser(selector, { deleteProfile: data?.deleteProfile });
       socket.write(JSON.stringify({ id, success: true, data: result }) + "\n");
     } catch (error48) {
       socket.write(
@@ -30332,7 +31129,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",
@@ -30342,8 +31138,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: fileURLToPath2(import.meta.url),
+        nativeHostScript: fileURLToPath4(import.meta.url),
         prepareTdbankSso,
         exportCookies,
         log
@@ -30435,8 +31257,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.`
     );
@@ -30471,16 +31306,16 @@ function onSocketConnection(socket) {
   });
 }
 function isPathAlive(socketPath) {
-  return new Promise((resolve) => {
-    if (process.platform !== "win32" && !fs11.existsSync(socketPath)) {
-      resolve(false);
+  return new Promise((resolve2) => {
+    if (process.platform !== "win32" && !fs13.existsSync(socketPath)) {
+      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", () => {
@@ -30494,10 +31329,10 @@ function isPathAlive(socketPath) {
   });
 }
 function listenOn(socketPath) {
-  return new Promise((resolve, reject) => {
-    if (process.platform !== "win32" && fs11.existsSync(socketPath)) {
+  return new Promise((resolve2, reject) => {
+    if (process.platform !== "win32" && fs13.existsSync(socketPath)) {
       try {
-        fs11.unlinkSync(socketPath);
+        fs13.unlinkSync(socketPath);
       } catch {
       }
     }
@@ -30506,11 +31341,11 @@ function listenOn(socketPath) {
     server.listen(socketPath, () => {
       if (process.platform !== "win32") {
         try {
-          fs11.chmodSync(socketPath, 384);
+          fs13.chmodSync(socketPath, 384);
         } catch (error48) {
           server.close();
           try {
-            fs11.unlinkSync(socketPath);
+            fs13.unlinkSync(socketPath);
           } catch {
           }
           reject(error48);
@@ -30520,7 +31355,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);
     });
   });
 }
@@ -30546,7 +31381,7 @@ function releaseLegacySocket() {
   }
   if (process.platform !== "win32") {
     try {
-      if (fs11.existsSync(LEGACY_SOCKET_PATH)) fs11.unlinkSync(LEGACY_SOCKET_PATH);
+      if (fs13.existsSync(LEGACY_SOCKET_PATH)) fs13.unlinkSync(LEGACY_SOCKET_PATH);
     } catch {
     }
   }
@@ -30558,8 +31393,8 @@ async function startSocketServer() {
 function cleanupInstanceSocketFile() {
   if (process.platform === "win32") return;
   try {
-    if (fs11.existsSync(INSTANCE_SOCKET_PATH)) {
-      fs11.unlinkSync(INSTANCE_SOCKET_PATH);
+    if (fs13.existsSync(INSTANCE_SOCKET_PATH)) {
+      fs13.unlinkSync(INSTANCE_SOCKET_PATH);
     }
   } catch (error48) {
     log("cleanup socket file failed:", String(error48));
@@ -30586,6 +31421,11 @@ function cleanupAndExit(code) {
   }
   finish();
 }
+function restartAfterUpdate() {
+  const forcedExit = setTimeout(() => process.exit(0), 2e3);
+  forcedExit.unref();
+  cleanupAndExit(0);
+}
 async function main() {
   initBrowserRegistry({ log });
   pruneDeadBrowsers();
@@ -30616,6 +31456,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) => {