@mearl/native-host 2.2.1 → 2.3.0

package/dist/index.js

@@ -9,40 +9,102 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// ../setup/dist/nativeHost.js
+import fs9 from "node:fs";
+import os6 from "node:os";
+import path10 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");
+    case "linux":
+      return path10.join(home, ".config/google-chrome/NativeMessagingHosts");
+    case "win32":
+      return path10.join(env.PROGRAMDATA || "C:\\ProgramData", "Google\\Chrome\\NativeMessagingHosts");
+    default:
+      throw new Error(`Unsupported platform: ${String(options.platform ?? process.platform)}`);
+  }
+}
+function unregisterWindowsNativeHost(hostName) {
+  const registryKey = `HKCU\\SOFTWARE\\Google\\Chrome\\NativeMessagingHosts\\${hostName}`;
+  try {
+    execFileSync("reg", ["delete", registryKey, "/f"], { stdio: "pipe" });
+  } catch {
+  }
+}
+function uninstallNativeHostArtifacts(options = {}, dependencies = {}) {
+  const { mode = "both", silent = false } = options;
+  if (mode === "both") {
+    return ["skills", "mcp"].map((integrationMode) => uninstallNativeHostArtifacts({ ...options, mode: integrationMode }, dependencies)).every(Boolean);
+  }
+  const writeLine = dependencies.writeLine ?? ((line) => console.error(line));
+  const log2 = (line) => {
+    if (!silent)
+      writeLine(line);
+  };
+  try {
+    const existsSync4 = dependencies.existsSync ?? fs9.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 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}`)
+    ];
+    for (const artifact of artifacts) {
+      if (!existsSync4(artifact))
+        continue;
+      unlinkSync(artifact);
+      log2(`✅ Removed: ${artifact}`);
+    }
+    if (platform === "win32")
+      unregister(hostName);
+    return true;
+  } catch (error48) {
+    log2(`❌ Uninstall failed: ${error48 instanceof Error ? error48.message : String(error48)}`);
+    return false;
+  }
+}
+var MEARL_NATIVE_HOST_NAMES;
+var init_nativeHost = __esm({
+  "../setup/dist/nativeHost.js"() {
+    "use strict";
+    MEARL_NATIVE_HOST_NAMES = {
+      skills: "com.alibaba.mearl.skills",
+      mcp: "com.alibaba.mearl.mcp"
+    };
+  }
+});
+
 // src/install.ts
 var install_exports = {};
 __export(install_exports, {
   installNativeHost: () => installNativeHost,
   resolveHostDir: () => resolveHostDir,
-  runCli: () => runCli
+  runCli: () => runCli,
+  uninstallNativeHost: () => uninstallNativeHost
 });
-import fs8 from "node:fs";
-import path10 from "node:path";
-import os6 from "node:os";
-import { execFileSync } from "node:child_process";
+import fs10 from "node:fs";
+import path11 from "node:path";
+import { execFileSync as execFileSync2 } from "node:child_process";
 import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 function resolveHostDir() {
-  switch (process.platform) {
-    case "darwin":
-      return path10.join(
-        os6.homedir(),
-        "Library/Application Support/Google/Chrome/NativeMessagingHosts"
-      );
-    case "linux":
-      return path10.join(os6.homedir(), ".config/google-chrome/NativeMessagingHosts");
-    case "win32":
-      return path10.join(
-        process.env.PROGRAMDATA || "C:\\ProgramData",
-        "Google\\Chrome\\NativeMessagingHosts"
-      );
-    default:
-      throw new Error(`Unsupported platform: ${process.platform}`);
-  }
+  return resolveNativeHostDirectory();
 }
 function resolveNativeHostPath() {
-  const siblingPath = path10.join(__dirname, "index.js");
-  if (fs8.existsSync(siblingPath)) {
+  const siblingPath = path11.join(__dirname, "index.js");
+  if (fs10.existsSync(siblingPath)) {
     return siblingPath;
   }
   try {
@@ -56,21 +118,21 @@ function resolveNativeHostPath() {
 }
 function registerWindowsNativeHost(hostName, manifestPath) {
   const regKey = `HKCU\\SOFTWARE\\Google\\Chrome\\NativeMessagingHosts\\${hostName}`;
-  execFileSync("reg", ["add", regKey, "/ve", "/t", "REG_SZ", "/d", manifestPath, "/f"], {
+  execFileSync2("reg", ["add", regKey, "/ve", "/t", "REG_SZ", "/d", manifestPath, "/f"], {
     stdio: "pipe"
   });
 }
 function createLauncherScript(hostDir, hostPath, hostName) {
-  const nodePath = path10.resolve(process.execPath);
+  const nodePath = path11.resolve(process.execPath);
   if (process.platform === "win32") {
-    const launcherPath2 = path10.join(hostDir, `${hostName}-launcher.cmd`);
+    const launcherPath2 = path11.join(hostDir, `${hostName}-launcher.cmd`);
     const content2 = `@echo off\r
 "${nodePath}" "${hostPath}" %*\r
 `;
-    fs8.writeFileSync(launcherPath2, content2, "utf-8");
+    fs10.writeFileSync(launcherPath2, content2, "utf-8");
     return launcherPath2;
   }
-  const launcherPath = path10.join(hostDir, `${hostName}-launcher.sh`);
+  const launcherPath = path11.join(hostDir, `${hostName}-launcher.sh`);
   const content = [
     "#!/bin/sh",
     `NODE_BIN=${JSON.stringify(nodePath)}`,
@@ -78,8 +140,8 @@ function createLauncherScript(hostDir, hostPath, hostName) {
     'exec "$NODE_BIN" "$HOST_SCRIPT" "$@"',
     ""
   ].join("\n");
-  fs8.writeFileSync(launcherPath, content, "utf-8");
-  fs8.chmodSync(launcherPath, 493);
+  fs10.writeFileSync(launcherPath, content, "utf-8");
+  fs10.chmodSync(launcherPath, 493);
   return launcherPath;
 }
 async function installNativeHost(options = {}) {
@@ -95,7 +157,7 @@ async function installNativeHost(options = {}) {
     );
     return results.every(Boolean);
   }
-  const hostName = HOST_NAME_BY_MODE[mode];
+  const hostName = MEARL_NATIVE_HOST_NAMES[mode];
   if (!hostName) {
     throw new Error(`Unknown mode: ${mode}. Expected 'skills' or 'mcp'.`);
   }
@@ -105,14 +167,14 @@ async function installNativeHost(options = {}) {
   try {
     const hostDir = resolveHostDir();
     if (skipIfExists) {
-      const manifestPath2 = path10.join(hostDir, `${hostName}.json`);
-      if (fs8.existsSync(manifestPath2)) {
+      const manifestPath2 = path11.join(hostDir, `${hostName}.json`);
+      if (fs10.existsSync(manifestPath2)) {
         log2(`✅ Already installed: ${manifestPath2}`);
         return true;
       }
     }
-    if (!fs8.existsSync(hostDir)) {
-      fs8.mkdirSync(hostDir, { recursive: true });
+    if (!fs10.existsSync(hostDir)) {
+      fs10.mkdirSync(hostDir, { recursive: true });
       log2(`✅ Created directory: ${hostDir}`);
     }
     const resolvedHostPath = resolveNativeHostPath();
@@ -126,13 +188,13 @@ async function installNativeHost(options = {}) {
       type: "stdio",
       allowed_origins: [`chrome-extension://${extensionId}/`]
     };
-    const manifestPath = path10.join(hostDir, `${hostName}.json`);
-    fs8.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+    const manifestPath = path11.join(hostDir, `${hostName}.json`);
+    fs10.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
     if (process.platform === "win32") {
       registerWindowsNativeHost(hostName, manifestPath);
       log2(`✅ Windows registry key created for: ${hostName}`);
     } else {
-      fs8.chmodSync(manifestPath, 420);
+      fs10.chmodSync(manifestPath, 420);
     }
     log2(`✅ Manifest installed: ${manifestPath}`);
     log2(`✅ Extension ID: ${extensionId}`);
@@ -146,14 +208,18 @@ async function installNativeHost(options = {}) {
     return false;
   }
 }
+async function uninstallNativeHost(options = {}, dependencies = {}) {
+  return uninstallNativeHostArtifacts(options, dependencies);
+}
 function parseCliArgs(argv) {
   let mode = "both";
   let extensionId;
   let skipIfExists = false;
+  let uninstall = false;
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
     if (arg === "--help" || arg === "-h") {
-      return { showHelp: true, mode, skipIfExists };
+      return { showHelp: true, uninstall, mode, skipIfExists };
     }
     if (arg === "--mode" || arg.startsWith("--mode=")) {
       const value = arg.includes("=") ? arg.slice("--mode=".length) : argv[++i];
@@ -172,24 +238,31 @@ function parseCliArgs(argv) {
       skipIfExists = true;
       continue;
     }
+    if (arg === "--uninstall") {
+      uninstall = true;
+      continue;
+    }
     if (arg === "--init") {
       continue;
     }
   }
-  return { showHelp: false, mode, extensionId, skipIfExists };
+  return { showHelp: false, uninstall, mode, extensionId, skipIfExists };
 }
 function printHelp() {
   console.error(`Usage:
   mearl-native-host --init [options]
+  mearl-native-host --uninstall [options]
 
 Options:
   --mode <skills|mcp|both> Integration mode (default: both — installs both hosts)
   --extension-id <id>      Chrome extension ID (default: ${DEFAULT_EXTENSION_ID})
+  --uninstall              Remove the selected Native Messaging manifests
   -h, --help               Show this help message
 
 Examples:
   mearl-native-host --init
   mearl-native-host --init --mode mcp
+  mearl-native-host --uninstall --mode skills
   mearl-native-host --init --extension-id abcdefghijklmnopqrstuvwxyzabcdef`);
 }
 async function runCli(argv) {
@@ -203,6 +276,11 @@ async function runCli(argv) {
     console.error("   Must be a 32-character lowercase string (see chrome://extensions/)");
     process.exit(1);
   }
+  if (parsed.uninstall) {
+    const success3 = await uninstallNativeHost({ mode: parsed.mode });
+    if (success3) console.error("\n✅ Uninstall complete!\n");
+    process.exit(success3 ? 0 : 1);
+  }
   const success2 = await installNativeHost({
     mode: parsed.mode,
     extensionId: parsed.extensionId,
@@ -222,27 +300,24 @@ Verify:
   }
   process.exit(success2 ? 0 : 1);
 }
-var DEFAULT_EXTENSION_ID, HOST_NAME_BY_MODE, __filename, __dirname, ALL_MODES;
+var DEFAULT_EXTENSION_ID, __filename, __dirname, ALL_MODES;
 var init_install = __esm({
   "src/install.ts"() {
     "use strict";
+    init_nativeHost();
     DEFAULT_EXTENSION_ID = "aoehhjnofngknnjefamjbplchbolghkm";
-    HOST_NAME_BY_MODE = {
-      skills: "com.alibaba.mearl.skills",
-      mcp: "com.alibaba.mearl.mcp"
-    };
     __filename = fileURLToPath(import.meta.url);
-    __dirname = path10.dirname(__filename);
+    __dirname = path11.dirname(__filename);
     ALL_MODES = ["skills", "mcp"];
   }
 });
 
 // src/index.ts
 import net from "node:net";
-import fs9 from "node:fs";
+import fs11 from "node:fs";
 import http5 from "node:http";
 import os7 from "node:os";
-import path11 from "node:path";
+import path12 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/cdp-backend/cdp-session.ts
@@ -250,7 +325,7 @@ import http3 from "node:http";
 
 // src/cdp-backend/client.ts
 import http from "node:http";
-import crypto from "node:crypto";
+import crypto2 from "node:crypto";
 var CdpChildSession = class {
   constructor(parent, sessionId) {
     this.parent = parent;
@@ -331,8 +406,8 @@ var CdpClient = class _CdpClient {
     return new Promise((resolve, reject) => {
       const url2 = new URL(wsUrl);
       const port = parseInt(url2.port || "9222", 10);
-      const key = crypto.randomBytes(16).toString("base64");
-      const expectedAccept = crypto.createHash("sha1").update(key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").digest("base64");
+      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,
@@ -484,7 +559,7 @@ var CdpClient = class _CdpClient {
   sendText(text) {
     if (this._closed) return;
     const payload = Buffer.from(text, "utf-8");
-    const maskKey = crypto.randomBytes(4);
+    const maskKey = crypto2.randomBytes(4);
     const masked = Buffer.from(payload.map((b, i) => b ^ maskKey[i % 4]));
     let header;
     if (payload.length < 126) {
@@ -679,6 +754,9 @@ function buildCookieHeaderValue(cookieMap) {
 var APLUS_URL_PATTERN = /\.mmstat\.com\//;
 var RUM_URL_PATTERN = /\.rum\.aliyuncs\.com\//;
 var ARMS_URL_PATTERN = /arms-retcode\.aliyuncs\.com\//;
+function isTrackingUrl(url2) {
+  return APLUS_URL_PATTERN.test(url2) || RUM_URL_PATTERN.test(url2) || ARMS_URL_PATTERN.test(url2) || /retcode\.alicdn\.com|beacon\.taobao\.com|tbsec\./i.test(url2);
+}
 var aplusCounter = 0;
 var armsCounter = 0;
 var rumCounter = 0;
@@ -1088,13 +1166,13 @@ function queryTrackingEvents(buffer, options = {}) {
 }
 
 // ../browser-core/dist/requestSerializer.js
-function parsePath(path12) {
-  if (path12.length > 1e3)
+function parsePath(path13) {
+  if (path13.length > 1e3)
     throw new Error("Path too long: maximum 1000 characters allowed");
   const keys = [];
   let current = "";
-  for (let i = 0; i < path12.length; i++) {
-    const char = path12[i];
+  for (let i = 0; i < path13.length; i++) {
+    const char = path13[i];
     if (char === ".") {
       if (current) {
         keys.push(current);
@@ -1106,10 +1184,10 @@ function parsePath(path12) {
         current = "";
       }
       let j = i + 1;
-      while (j < path12.length && path12[j] !== "]")
+      while (j < path13.length && path13[j] !== "]")
         j++;
-      if (j < path12.length) {
-        const index = parseInt(path12.substring(i + 1, j), 10);
+      if (j < path13.length) {
+        const index = parseInt(path13.substring(i + 1, j), 10);
         if (!isNaN(index)) {
           if (index < 0 || index > 1e5)
             throw new Error(`Array index out of safe range: ${index}`);
@@ -1127,8 +1205,8 @@ function parsePath(path12) {
     throw new Error("Path too deep: maximum 50 levels allowed");
   return keys;
 }
-function getValueByPath(obj, path12) {
-  const keys = parsePath(path12);
+function getValueByPath(obj, path13) {
+  const keys = parsePath(path13);
   let current = obj;
   for (const key of keys) {
     if (current === null || current === void 0)
@@ -1137,8 +1215,8 @@ function getValueByPath(obj, path12) {
   }
   return current;
 }
-function setValueByPath(obj, path12, value) {
-  const keys = parsePath(path12);
+function setValueByPath(obj, path13, value) {
+  const keys = parsePath(path13);
   let current = obj;
   for (let i = 0; i < keys.length - 1; i++) {
     const key = keys[i];
@@ -1212,7 +1290,11 @@ function serializeRequest(request, options = {}) {
     status: request.status,
     statusText: request.statusText,
     queryString: request.queryString,
-    duration: request.duration
+    duration: request.duration,
+    captureSequence: request.captureSequence,
+    isPending: request.isPending,
+    source: request.source,
+    resourceType: request.resourceType
   };
   if (includeHeaders) {
     result.headers = request.headers;
@@ -1336,10 +1418,14 @@ function applyFieldLimits(request, maxFieldBytes) {
   request.responseBody = limitBufferedField(request.responseBody, maxFieldBytes);
 }
 function trimRequestBuffer(requests, accounting, maxEntries, maxBytes) {
+  const removed = [];
   while (requests.length > 1 && (requests.length > maxEntries || accounting.totalBytes > maxBytes)) {
-    requests.shift();
+    const request = requests.shift();
+    if (request)
+      removed.push(request);
     accounting.totalBytes -= accounting.sizes.shift() ?? 0;
   }
+  return removed;
 }
 function appendRequestToBuffer(requests, accounting, request, limits = {}) {
   const { maxEntries = REQUEST_BUFFER_MAX_ENTRIES, maxBytes = REQUEST_BUFFER_MAX_BYTES, maxFieldBytes = REQUEST_BUFFER_MAX_FIELD_BYTES } = limits;
@@ -1349,20 +1435,20 @@ function appendRequestToBuffer(requests, accounting, request, limits = {}) {
   requests.push(request);
   accounting.sizes.push(size);
   accounting.totalBytes += size;
-  trimRequestBuffer(requests, accounting, maxEntries, maxBytes);
+  return trimRequestBuffer(requests, accounting, maxEntries, maxBytes);
 }
 function refreshRequestInBuffer(requests, accounting, request, limits = {}) {
   const { maxEntries = REQUEST_BUFFER_MAX_ENTRIES, maxBytes = REQUEST_BUFFER_MAX_BYTES, maxFieldBytes = REQUEST_BUFFER_MAX_FIELD_BYTES } = limits;
   const index = requests.indexOf(request);
   if (index === -1)
-    return;
+    return [];
   synchronizeAccounting(requests, accounting);
   applyFieldLimits(request, maxFieldBytes);
   const previousSize = accounting.sizes[index] ?? 0;
   const nextSize = estimateRequestBufferBytes(request);
   accounting.sizes[index] = nextSize;
   accounting.totalBytes += nextSize - previousSize;
-  trimRequestBuffer(requests, accounting, maxEntries, maxBytes);
+  return trimRequestBuffer(requests, accounting, maxEntries, maxBytes);
 }
 
 // ../browser-core/dist/proxyPermissions.js
@@ -2141,6 +2227,24 @@ var CHECKABLE_AX_ROLES = /* @__PURE__ */ new Set([
   "radio",
   "switch"
 ]);
+function resolveDOMSnapshotViewportBounds(metrics) {
+  const viewport = metrics.visualViewport ?? metrics.cssVisualViewport;
+  return normalizePageViewportBounds({
+    left: viewport?.pageX ?? 0,
+    top: viewport?.pageY ?? 0,
+    width: viewport?.clientWidth,
+    height: viewport?.clientHeight
+  });
+}
+function normalizePageViewportBounds(value) {
+  if (!value || typeof value !== "object")
+    return null;
+  const { left, top, width, height } = value;
+  if (typeof left !== "number" || typeof top !== "number" || typeof width !== "number" || typeof height !== "number" || !Number.isFinite(left) || !Number.isFinite(top) || !Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+    return null;
+  }
+  return { left, top, width, height };
+}
 function readDOMCheckedState() {
   const tag = String(this && this.tagName || "").toLowerCase();
   const type = String(this && this.type || "").toLowerCase();
@@ -2648,19 +2752,19 @@ function installPageObserverInPage(maxBatches = 50) {
         }
       }
     }
-    const path12 = [];
+    const path13 = [];
     let current = input;
-    while (current && current !== document.documentElement && path12.length < 6) {
+    while (current && current !== document.documentElement && path13.length < 6) {
       const parent = current.parentElement;
       const currentTag = current.tagName.toLowerCase();
       if (!parent) {
-        path12.unshift(currentTag);
+        path13.unshift(currentTag);
         break;
       }
       const siblings = Array.from(parent.children).filter((item) => item.tagName === current.tagName);
       const position = siblings.indexOf(current) + 1;
-      path12.unshift(siblings.length > 1 ? `${currentTag}:nth-of-type(${position})` : currentTag);
-      const candidate = path12.join(" > ");
+      path13.unshift(siblings.length > 1 ? `${currentTag}:nth-of-type(${position})` : currentTag);
+      const candidate = path13.join(" > ");
       if (input.isConnected) {
         try {
           if (document.querySelectorAll(candidate).length === 1)
@@ -2670,7 +2774,7 @@ function installPageObserverInPage(maxBatches = 50) {
       }
       current = parent;
     }
-    return path12.join(" > ") || void 0;
+    return path13.join(" > ") || void 0;
   };
   const inferredRole = (element) => {
     const explicit = element.getAttribute("role");
@@ -3377,6 +3481,7 @@ var PAGE_ACT_ACTIONS = [
   "page_eval"
 ];
 var BROWSER_COMMAND_ACTIONS = {
+  capture_checkpoint: true,
   get_requests: true,
   get_logs: true,
   get_events: true,
@@ -3419,6 +3524,7 @@ var BROWSER_COMMAND_ACTIONS = {
   run_actions: true
 };
 var EXTENSION_BROWSER_ACTIONS = {
+  capture_checkpoint: true,
   get_requests: true,
   get_logs: true,
   get_events: true,
@@ -3465,24 +3571,35 @@ function isExtensionBrowserAction(value) {
 }
 
 // ../browser-core/dist/pageAct.js
+var DEFAULT_PAGE_DIAGNOSTICS = {
+  logs: true,
+  requests: true
+};
 function isPageActAction(action) {
   return PAGE_ACT_ACTIONS.includes(action);
 }
 function shouldObservePageAction(action, data) {
   if (!isPageActAction(action))
     return false;
+  const diagnosticsEnabled = data?.diagnostics !== void 0 && data.diagnostics !== false;
   if (action === "page_eval") {
-    return Boolean(data?.observe && typeof data.observe === "object" && !Array.isArray(data.observe));
+    return Boolean(diagnosticsEnabled || data?.observe && typeof data.observe === "object" && !Array.isArray(data.observe));
   }
-  return data?.observe !== false;
+  return data?.observe !== false || data?.diagnostics !== false;
 }
-function splitObservedActionPayload(data) {
-  const { observe, ...actionData } = data ?? {};
+function splitObservedActionPayload(action, data) {
+  const { observe, diagnostics, ...actionData } = data ?? {};
+  const setting = diagnostics;
+  const resolvedDiagnostics = setting === false ? void 0 : setting === true ? DEFAULT_PAGE_DIAGNOSTICS : setting && typeof setting === "object" && !Array.isArray(setting) ? setting : action === "page_eval" ? void 0 : DEFAULT_PAGE_DIAGNOSTICS;
   if (observe === false)
-    return { actionData, observe: false };
+    return { actionData, observe: false, diagnostics: resolvedDiagnostics };
+  if (action === "page_eval" && (!observe || typeof observe !== "object")) {
+    return { actionData, observe: false, diagnostics: resolvedDiagnostics };
+  }
   return {
     actionData,
-    observe: observe && typeof observe === "object" && !Array.isArray(observe) ? observe : {}
+    observe: observe && typeof observe === "object" && !Array.isArray(observe) ? observe : {},
+    diagnostics: resolvedDiagnostics
   };
 }
 function unavailableObservation(checkpoint, error48) {
@@ -4176,6 +4293,20 @@ function assertSendRequestBase64FileLimits(byteLengths) {
   }
 }
 
+// ../browser-core/dist/sendRequestHeaders.js
+function resolveHeader(headers, name, fallback) {
+  const key = findSendRequestHeaderName(headers, name);
+  if (!key)
+    return fallback;
+  return headers[key] === "" ? void 0 : headers[key];
+}
+function getSendRequestSourceHeaders(targetUrl, headers = {}) {
+  return {
+    referer: resolveHeader(headers, "Referer", `${targetUrl.origin}/mearl`),
+    origin: resolveHeader(headers, "Origin", targetUrl.origin)
+  };
+}
+
 // ../browser-core/dist/cookie.js
 function normalizeCookieDomain(input, action) {
   const value = input.trim();
@@ -4278,12 +4409,12 @@ function resolveGetCookieTarget(currentUrl, input) {
   const url2 = parseCurrentUrl(currentUrl, action);
   const name = validateCookieName(input?.name, action);
   const domain2 = resolveExplicitDomain(url2, input?.domain, action);
-  const path12 = validateCookiePath(input?.path, action);
+  const path13 = validateCookiePath(input?.path, action);
   return {
     cookieName: name,
-    cookieUrl: `${url2.protocol}//${url2.hostname}${(path12 ?? url2.pathname) || "/"}`,
+    cookieUrl: `${url2.protocol}//${url2.hostname}${(path13 ?? url2.pathname) || "/"}`,
     ...domain2 ? { domain: domain2 } : {},
-    ...path12 ? { path: path12 } : {}
+    ...path13 ? { path: path13 } : {}
   };
 }
 function resolveSetCookieTarget(currentUrl, input) {
@@ -4291,7 +4422,7 @@ function resolveSetCookieTarget(currentUrl, input) {
   const url2 = parseCurrentUrl(currentUrl, action);
   const name = validateCookieName(input?.name, action);
   const value = validateCookieValue(input?.value);
-  const path12 = validateCookiePath(input?.path, action) ?? "/";
+  const path13 = validateCookiePath(input?.path, action) ?? "/";
   if (input.reload !== void 0 && typeof input.reload !== "boolean") {
     throw new Error('set_cookie: "reload" must be a boolean');
   }
@@ -4301,9 +4432,9 @@ function resolveSetCookieTarget(currentUrl, input) {
     cookieName: name,
     cookieValue: value,
     ...explicitDomain ? { cookieDomain: explicitDomain.includes(".") ? `.${explicitDomain}` : explicitDomain } : {},
-    cookieUrl: `${url2.protocol}//${url2.hostname.toLowerCase()}${path12}`,
+    cookieUrl: `${url2.protocol}//${url2.hostname.toLowerCase()}${path13}`,
     domain: domain2,
-    path: path12,
+    path: path13,
     reload: input.reload === true
   };
 }
@@ -4319,10 +4450,7 @@ var SOURCE_BADGES = {
     <circle cx="104" cy="104" r="21" fill="#16A34A" stroke="#FFFFFF" stroke-width="6"/>
   `,
   cloud: `
-    <path d="M91 116H116C123 116 128 111 128 104C128 97 123 92 116 92H114
-      C111 85 106 82 100 82C91 82 85 89 84 97C78 99 75 104 75 109
-      C75 116 81 121 89 121H91Z" fill="#7C3AED" stroke="#FFFFFF" stroke-width="6"
-      stroke-linejoin="round"/>
+    <circle cx="104" cy="104" r="21" fill="#FF7A00" stroke="#FFFFFF" stroke-width="6"/>
   `
 };
 function createControlledFaviconDataUrl(source) {
@@ -4333,6 +4461,83 @@ ${SOURCE_BADGES[source]}
   return `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
 }
 
+// ../browser-core/dist/capture.js
+var CURSOR_PREFIX = "mearl-capture-v1";
+function createCaptureGeneration() {
+  return crypto.randomUUID();
+}
+function encodeCaptureCursor(cursor) {
+  return `${CURSOR_PREFIX}:${cursor.tabId}:${cursor.generation}:${cursor.scope}:${cursor.sequence}`;
+}
+function decodeCaptureCursor(value) {
+  const match = value.match(/^mearl-capture-v1:(\d+):([^:]+):(all|logs|requests):(\d+)$/);
+  if (!match)
+    throw new Error("Invalid capture cursor");
+  const tabId = Number(match[1]);
+  const sequence = Number(match[4]);
+  if (!Number.isSafeInteger(tabId) || !Number.isSafeInteger(sequence)) {
+    throw new Error("Invalid capture cursor");
+  }
+  return {
+    tabId,
+    generation: match[2],
+    scope: match[3],
+    sequence
+  };
+}
+function captureCheckpoint(state) {
+  return encodeCaptureCursor({
+    tabId: state.tabId,
+    generation: state.generation,
+    sequence: state.currentSequence,
+    scope: "all"
+  });
+}
+function nextCaptureSequence(state) {
+  state.currentSequence += 1;
+  return state.currentSequence;
+}
+function resolveAfterSequence(after, state, scope) {
+  if (!after)
+    return 0;
+  const cursor = decodeCaptureCursor(after);
+  if (cursor.tabId !== state.tabId) {
+    throw new Error(`Capture cursor belongs to tab ${cursor.tabId}, not tab ${state.tabId}`);
+  }
+  if (cursor.generation !== state.generation) {
+    throw new Error("Capture cursor expired because the tab collector was restarted");
+  }
+  if (cursor.scope !== "all" && cursor.scope !== scope) {
+    throw new Error(`Capture cursor is scoped to ${cursor.scope}, not ${scope}`);
+  }
+  if (cursor.sequence > state.currentSequence) {
+    throw new Error("Capture cursor is ahead of the current collector state");
+  }
+  return cursor.sequence;
+}
+function queryCapturedEntries(buffer, state, options, matches, droppedThroughSequence = 0, scope = "all") {
+  const { after, since, now = Date.now() } = options;
+  const limit = Math.max(1, Math.floor(options.limit ?? 100));
+  const afterSequence = resolveAfterSequence(after, state, scope);
+  const sinceTimestampMs = since === void 0 ? void 0 : now - since * 1e3;
+  const matched = buffer.filter((entry) => entry.captureSequence > afterSequence && (sinceTimestampMs === void 0 || entry.timestampMs >= sinceTimestampMs) && matches(entry));
+  const hasMore = matched.length > limit;
+  const entries = after ? matched.slice(0, limit) : matched.slice(-limit);
+  const nextSequence = after && hasMore && entries.length > 0 ? entries[entries.length - 1].captureSequence : state.currentSequence;
+  return {
+    entries,
+    totalMatched: matched.length,
+    nextCursor: encodeCaptureCursor({
+      tabId: state.tabId,
+      generation: state.generation,
+      sequence: nextSequence,
+      scope
+    }),
+    hasMore,
+    gap: after !== void 0 && afterSequence < droppedThroughSequence
+  };
+}
+
 // src/cdp-backend/domain-manager.ts
 var enabledDomains = /* @__PURE__ */ new WeakMap();
 function ensureCdpDomain(client2, domain2, params = {}) {
@@ -4354,14 +4559,22 @@ function ensureCdpDomain(client2, domain2, params = {}) {
 // src/cdp-backend/buffers.ts
 var MAX_LOGS = 500;
 var MAX_EVENTS = 500;
-function createBuffers() {
+var COLLECTED_RESOURCE_TYPES = /* @__PURE__ */ new Set(["xhr", "fetch", "document"]);
+function createBuffers(tabId = 0) {
   return {
     requests: [],
     logs: [],
     events: [],
     pending: /* @__PURE__ */ new Map(),
     requestCounter: 0,
-    requestBufferAccounting: createRequestBufferAccounting()
+    requestBufferAccounting: createRequestBufferAccounting(),
+    capture: {
+      tabId,
+      generation: createCaptureGeneration(),
+      currentSequence: 0,
+      droppedRequestsThroughSequence: 0,
+      droppedLogsThroughSequence: 0
+    }
   };
 }
 function parseQueryString(url2) {
@@ -4377,12 +4590,34 @@ function parseQueryString(url2) {
 function headersObjToArray(obj) {
   return Object.entries(obj).map(([name, value]) => ({ name, value }));
 }
-function extractApiName(url2) {
+function extractMtopApiName(url2, postData) {
   try {
     const u = new URL(url2);
-    const match = u.pathname.match(/\/h5\/([^/]+\/[^/]+)/);
-    if (match) return match[1];
-    return u.pathname;
+    const pathMatch = u.pathname.match(/\/h5\/([\w.]+)\//);
+    if (pathMatch) return pathMatch[1];
+    const requestUrl = u.searchParams.get("requestUrl");
+    const proxyMatch = requestUrl?.match(/\b(?:mtop|mopen)\.[\w.]+/);
+    if (proxyMatch) return proxyMatch[0];
+  } catch {
+  }
+  const urlMatch = url2.match(/\b(?:mtop|mopen)\.[\w.]+/);
+  if (urlMatch) return urlMatch[0];
+  if (!postData) return null;
+  try {
+    const parsed = JSON.parse(postData);
+    const requestUrl = typeof parsed?.requestUrl === "string" ? parsed.requestUrl : void 0;
+    const proxyMatch = requestUrl?.match(/\b(?:mtop|mopen)\.[\w.]+/);
+    if (proxyMatch) return proxyMatch[0];
+  } catch {
+    const requestUrl = new URLSearchParams(postData).get("requestUrl");
+    const proxyMatch = requestUrl?.match(/\b(?:mtop|mopen)\.[\w.]+/);
+    if (proxyMatch) return proxyMatch[0];
+  }
+  return null;
+}
+function requestDisplayName(url2) {
+  try {
+    return new URL(url2).pathname;
   } catch {
     return url2;
   }
@@ -4413,28 +4648,73 @@ function appendTrackingEvents(buffers, url2, postData, sequence) {
   }
   return true;
 }
-function setupBufferListeners(client2, buffers) {
-  ensureCdpDomain(client2, "Network", {
-    maxTotalBufferSize: 10 * 1024 * 1024,
-    maxPostDataSize: 5 * 1024 * 1024
-  }).catch(() => {
-  });
-  ensureCdpDomain(client2, "Runtime").catch(() => {
-  });
-  ensureCdpDomain(client2, "Log").catch(() => {
-  });
+function recordDroppedRequests(buffers, removed) {
+  for (const request of removed) {
+    if (request.captureSequence !== void 0) {
+      buffers.capture.droppedRequestsThroughSequence = Math.max(
+        buffers.capture.droppedRequestsThroughSequence,
+        request.captureSequence
+      );
+    }
+  }
+}
+function appendCapturedRequest(buffers, request) {
+  recordDroppedRequests(
+    buffers,
+    appendRequestToBuffer(buffers.requests, buffers.requestBufferAccounting, request)
+  );
+}
+function refreshCapturedRequest(buffers, request) {
+  recordDroppedRequests(
+    buffers,
+    refreshRequestInBuffer(buffers.requests, buffers.requestBufferAccounting, request)
+  );
+}
+function appendCapturedLog(buffers, log2) {
+  buffers.logs.push({ ...log2, captureSequence: nextCaptureSequence(buffers.capture) });
+  if (buffers.logs.length > MAX_LOGS) {
+    const removed = buffers.logs.shift();
+    if (removed) buffers.capture.droppedLogsThroughSequence = removed.captureSequence;
+  }
+}
+async function setupBufferListeners(client2, buffers) {
   client2.on("Network.requestWillBeSent", (params) => {
     const url2 = params.request?.url ?? "";
-    const ts = params.timestamp ?? Date.now() / 1e3;
+    if (!url2.startsWith("http")) return;
+    if (isTrackingUrl(url2)) {
+      const sequence = ++buffers.requestCounter;
+      const captured = appendTrackingEvents(buffers, url2, params.request?.postData, sequence);
+      if (!captured && params.request?.hasPostData && !params.request?.postData) {
+        client2.sendCommand("Network.getRequestPostData", { requestId: params.requestId }, 1e4).then((result) => appendTrackingEvents(buffers, url2, result?.postData, sequence)).catch(() => {
+        });
+      }
+      return;
+    }
+    const resourceType = String(params.type ?? "").toLowerCase();
+    const mtopApiName = extractMtopApiName(url2, params.request?.postData);
+    const isMtop = mtopApiName !== null;
+    if (!isMtop && !COLLECTED_RESOURCE_TYPES.has(resourceType)) return;
+    const ts = params.timestamp;
+    const timestampMs2 = params.wallTime !== void 0 ? Math.floor(params.wallTime * 1e3) : Date.now();
+    const redirected = buffers.pending.get(params.requestId);
+    if (redirected && params.redirectResponse) {
+      redirected.status = params.redirectResponse.status ?? 0;
+      redirected.statusText = params.redirectResponse.statusText ?? "";
+      redirected.duration = ts !== void 0 && redirected.startTs !== void 0 ? Math.round((ts - redirected.startTs) * 1e3) : void 0;
+      redirected.isPending = false;
+      refreshCapturedRequest(buffers, redirected);
+      buffers.pending.delete(params.requestId);
+    }
     const id = ++buffers.requestCounter;
+    const captureSequence = nextCaptureSequence(buffers.capture);
     const partial2 = {
       id,
       requestId: params.requestId,
-      timestamp: new Date(ts * 1e3).toISOString(),
-      timestampMs: Math.floor(ts * 1e3),
+      timestamp: new Date(timestampMs2).toISOString(),
+      timestampMs: timestampMs2,
       method: params.request?.method ?? "GET",
       url: url2,
-      apiName: extractApiName(url2),
+      apiName: mtopApiName ?? requestDisplayName(url2),
       headers: headersObjToArray(params.request?.headers ?? {}),
       postData: parsePostData(params.request?.postData),
       queryString: parseQueryString(url2),
@@ -4445,16 +4725,14 @@ function setupBufferListeners(client2, buffers) {
       isProxy: false,
       proxyRequestUrl: null,
       proxyData: null,
-      startTs: ts
+      startTs: ts,
+      captureSequence,
+      isPending: true,
+      source: isMtop ? "mtop" : "requests",
+      resourceType
     };
     buffers.pending.set(params.requestId, partial2);
-    const captured = appendTrackingEvents(buffers, url2, params.request?.postData, id);
-    if (!captured && params.request?.hasPostData && !params.request?.postData) {
-      client2.sendCommand("Network.getRequestPostData", { requestId: params.requestId }, 1e4).then((result) => {
-        appendTrackingEvents(buffers, url2, result?.postData, id);
-      }).catch(() => {
-      });
-    }
+    appendCapturedRequest(buffers, partial2);
   });
   client2.on("Network.responseReceived", (params) => {
     const partial2 = buffers.pending.get(params.requestId);
@@ -4462,73 +4740,110 @@ function setupBufferListeners(client2, buffers) {
     partial2.status = params.response?.status ?? 0;
     partial2.statusText = params.response?.statusText ?? "";
     partial2.responseHeaders = headersObjToArray(params.response?.headers ?? {});
+    refreshCapturedRequest(buffers, partial2);
   });
   client2.on("Network.loadingFinished", (params) => {
     const partial2 = buffers.pending.get(params.requestId);
     if (!partial2) return;
     buffers.pending.delete(params.requestId);
-    const endTs = params.timestamp ?? Date.now() / 1e3;
-    const duration3 = Math.round((endTs - partial2.startTs) * 1e3);
-    const req = {
-      ...partial2,
-      duration: duration3,
-      isPending: false
-    };
+    const endTs = params.timestamp;
+    const duration3 = endTs !== void 0 && partial2.startTs !== void 0 ? Math.round((endTs - partial2.startTs) * 1e3) : void 0;
+    partial2.duration = duration3;
+    partial2.isPending = false;
+    refreshCapturedRequest(buffers, partial2);
     client2.sendCommand("Network.getResponseBody", { requestId: params.requestId }, 1e4).then((result) => {
-      req.responseBody = result.base64Encoded ? Buffer.from(result.body, "base64").toString("utf-8") : result.body;
-      if (typeof req.responseBody === "string") {
+      partial2.responseBody = result.base64Encoded ? Buffer.from(result.body, "base64").toString("utf-8") : result.body;
+      if (typeof partial2.responseBody === "string") {
         try {
-          req.responseBody = JSON.parse(req.responseBody);
+          partial2.responseBody = JSON.parse(partial2.responseBody);
         } catch {
         }
       }
-      refreshRequestInBuffer(buffers.requests, buffers.requestBufferAccounting, req);
+      refreshCapturedRequest(buffers, partial2);
     }).catch(() => {
     });
-    appendRequestToBuffer(buffers.requests, buffers.requestBufferAccounting, req);
   });
   client2.on("Network.loadingFailed", (params) => {
     const partial2 = buffers.pending.get(params.requestId);
     if (!partial2) return;
     buffers.pending.delete(params.requestId);
-    const req = {
-      ...partial2,
-      status: 0,
-      statusText: params.errorText ?? "Failed",
-      duration: 0,
-      isPending: false
-    };
-    appendRequestToBuffer(buffers.requests, buffers.requestBufferAccounting, req);
+    partial2.status = 0;
+    partial2.statusText = params.errorText ?? "Failed";
+    partial2.duration = params.timestamp !== void 0 && partial2.startTs !== void 0 ? Math.round((params.timestamp - partial2.startTs) * 1e3) : void 0;
+    partial2.isPending = false;
+    refreshCapturedRequest(buffers, partial2);
   });
   client2.on("Runtime.consoleAPICalled", (params) => {
-    const level = params.type ?? "log";
+    const levelMap = {
+      warning: "warn",
+      debug: "debug",
+      info: "info",
+      error: "error",
+      assert: "error"
+    };
+    const level = levelMap[params.type] ?? "log";
     const args = (params.args ?? []).map((arg) => {
       if (arg.type === "string") return arg.value;
       if (arg.value !== void 0) return String(arg.value);
       if (arg.description !== void 0) return arg.description;
       return JSON.stringify(arg);
     });
-    const entry = {
+    appendCapturedLog(buffers, {
       level,
       message: args.join(" "),
-      timestamp: params.timestamp ? Math.floor(params.timestamp * 1e3) : Date.now(),
-      source: "console",
-      args
-    };
-    buffers.logs.push(entry);
-    if (buffers.logs.length > MAX_LOGS) buffers.logs.shift();
+      timestampMs: params.timestamp ?? Date.now(),
+      source: params.stackTrace?.callFrames?.[0]?.url ? `${params.stackTrace.callFrames[0].url.split("/").pop() || params.stackTrace.callFrames[0].url}:${params.stackTrace.callFrames[0].lineNumber + 1}` : "console",
+      args,
+      origin: "console"
+    });
+  });
+  client2.on("Runtime.exceptionThrown", (params) => {
+    const details = params.exceptionDetails ?? {};
+    const exception = details.exception;
+    const message = exception?.description ?? (exception?.value !== void 0 ? String(exception.value) : void 0) ?? details.text ?? "Uncaught exception";
+    const topFrame = details.stackTrace?.callFrames?.[0];
+    const url2 = topFrame?.url || details.url;
+    const lineNumber = topFrame?.lineNumber ?? details.lineNumber;
+    const source = url2 ? `${url2.split("/").pop() || url2}${lineNumber !== void 0 ? `:${lineNumber + 1}` : ""}` : void 0;
+    appendCapturedLog(buffers, {
+      level: "error",
+      message,
+      timestampMs: params.timestamp ?? Date.now(),
+      ...source ? { source } : {},
+      args: [message],
+      origin: "exception"
+    });
   });
   client2.on("Log.entryAdded", (params) => {
-    const entry = {
-      level: params.entry?.level ?? "log",
-      message: params.entry?.text ?? "",
-      timestamp: params.entry?.timestamp ? Math.floor(params.entry.timestamp * 1e3) : Date.now(),
-      source: params.entry?.source ?? "other",
-      args: [params.entry?.text ?? ""]
+    const entry = params.entry ?? {};
+    const levelMap = {
+      verbose: "log",
+      info: "info",
+      warning: "warn",
+      error: "error"
     };
-    buffers.logs.push(entry);
-    if (buffers.logs.length > MAX_LOGS) buffers.logs.shift();
+    const args = (entry.args ?? []).map((arg) => {
+      if (arg.value !== void 0) return String(arg.value);
+      return arg.description ?? `[${arg.type || "Object"}]`;
+    });
+    const message = entry.text || args.join(" ");
+    appendCapturedLog(buffers, {
+      level: levelMap[entry.level] ?? entry.level ?? "log",
+      message,
+      timestampMs: entry.timestamp ?? Date.now(),
+      source: entry.url ? `${entry.url.split("/").pop() || entry.url}${entry.lineNumber !== void 0 ? `:${entry.lineNumber + 1}` : ""}` : entry.source ?? "other",
+      args: args.length > 0 ? args : [message],
+      origin: "browser"
+    });
   });
+  await Promise.all([
+    ensureCdpDomain(client2, "Network", {
+      maxTotalBufferSize: 10 * 1024 * 1024,
+      maxPostDataSize: 5 * 1024 * 1024
+    }),
+    ensureCdpDomain(client2, "Runtime"),
+    ensureCdpDomain(client2, "Log")
+  ]);
 }
 
 // src/cdp-backend/discover.ts
@@ -4687,9 +5002,21 @@ var CdpSession = class {
     } catch {
       client2 = await CdpClient.connect(target.webSocketDebuggerUrl);
     }
-    const buffers = createBuffers();
-    setupBufferListeners(client2, buffers);
+    let tabId;
+    for (const [virtualId, registeredTargetId] of this.tabIdMap) {
+      if (registeredTargetId === target.id) {
+        tabId = virtualId;
+        break;
+      }
+    }
+    if (tabId === void 0) {
+      tabId = this.nextTabId++;
+      this.tabIdMap.set(tabId, target.id);
+    }
+    const buffers = createBuffers(tabId);
+    await setupBufferListeners(client2, buffers);
     const session = {
+      tabId,
       client: client2,
       buffers,
       targetId: target.id,
@@ -5945,6 +6272,143 @@ async function enrichCdpPageChangeSetWithRefs(session, observation) {
   );
 }
 
+// src/cdp-backend/request-handlers.ts
+function filterRequests(buffers, opts) {
+  const pattern = opts.filter ? compileTextPattern(opts.filter) : void 0;
+  return queryCapturedEntries(
+    buffers.requests.filter(
+      (request) => Number.isSafeInteger(request.captureSequence)
+    ),
+    buffers.capture,
+    { after: opts.after, since: opts.since, limit: opts.count ?? 10 },
+    (request) => (!opts.source || opts.source === "all" || request.source === opts.source) && (!pattern || matchesTextPattern(request.url, pattern) || matchesTextPattern(request.apiName, pattern)),
+    buffers.capture.droppedRequestsThroughSequence,
+    "requests"
+  );
+}
+async function cdpGetRequests(session, data) {
+  const opts = {
+    count: data.count ?? 10,
+    filter: data.filter,
+    since: data.since,
+    after: data.after,
+    source: data.source,
+    applyHiddenFilter: data.applyHiddenFilter !== false
+  };
+  const captured = filterRequests(session.buffers, opts);
+  const serializeOpts = {
+    includeBody: data.includeBody !== false,
+    includeHeaders: data.includeHeaders === true,
+    maxBodySize: data.maxBodySize ?? 5e4,
+    fields: data.fields,
+    keysOnly: data.keysOnly === true
+  };
+  return {
+    meta: {
+      count: captured.entries.length,
+      totalMatched: captured.totalMatched,
+      totalInBuffer: session.buffers.requests.length,
+      filter: data.filter,
+      since: data.since,
+      after: data.after,
+      nextCursor: captured.nextCursor,
+      hasMore: captured.hasMore,
+      gap: captured.gap,
+      source: "cdp"
+    },
+    requests: captured.entries.map((r) => serializeRequest(r, serializeOpts))
+  };
+}
+async function cdpGetLogs(session, data) {
+  const { level, since, after, limit = 100, filter } = data;
+  const pattern = filter ? compileTextPattern(filter) : void 0;
+  const captured = queryCapturedEntries(
+    session.buffers.logs,
+    session.buffers.capture,
+    { after, since, limit },
+    (log2) => (!level || level === "all" || log2.level === level) && (!pattern || matchesTextPattern(log2.message, pattern) || log2.args.some((arg) => matchesTextPattern(arg, pattern))),
+    session.buffers.capture.droppedLogsThroughSequence,
+    "logs"
+  );
+  const captureStatus = session.buffers.logs.length === 0 ? "armed" : "active";
+  return {
+    meta: {
+      count: captured.entries.length,
+      totalMatched: captured.totalMatched,
+      totalInBuffer: session.buffers.logs.length,
+      level: level || "all",
+      since,
+      after,
+      filter,
+      nextCursor: captured.nextCursor,
+      hasMore: captured.hasMore,
+      gap: captured.gap,
+      captureStatus,
+      ...captureStatus === "armed" && {
+        hint: "Log capture is active, but this tab has no captured history yet. Reload the current tab or repeat the triggering action, then call get_logs again."
+      },
+      source: "cdp"
+    },
+    logs: captured.entries
+  };
+}
+async function cdpCaptureCheckpoint(session, _data) {
+  return {
+    tabId: session.tabId,
+    cursor: captureCheckpoint(session.buffers.capture),
+    timestampMs: Date.now(),
+    captureStatus: session.buffers.capture.currentSequence === 0 ? "armed" : "active"
+  };
+}
+async function collectCdpPageDiagnostics(session, after, diagnostics) {
+  const result = {};
+  if (diagnostics.logs) {
+    const options = diagnostics.logs === true ? { level: "error", limit: 100 } : { level: "error", limit: 100, ...diagnostics.logs };
+    result.logs = await cdpGetLogs(session, { ...options, after });
+  }
+  if (diagnostics.requests) {
+    const options = diagnostics.requests === true ? { source: "all", includeBody: false, count: 100 } : {
+      source: "all",
+      includeBody: false,
+      count: 100,
+      ...diagnostics.requests
+    };
+    result.requests = await cdpGetRequests(session, { ...options, after });
+  }
+  return result;
+}
+async function cdpGetEvents(session, data) {
+  const { source = "all", event_type, since, limit = 20, filter, includeRaw = false } = data;
+  const response = queryTrackingEvents(session.buffers.events, {
+    source,
+    event_type,
+    since,
+    limit,
+    filter
+  });
+  const captureStatus = response.totalInBuffer === 0 ? "armed" : "active";
+  const hint = response.events.length === 0 && captureStatus === "armed" ? TRACKING_CAPTURE_ARMED_HINT : void 0;
+  return {
+    meta: {
+      count: response.events.length,
+      totalMatched: response.totalMatched,
+      totalInBuffer: response.totalInBuffer,
+      source,
+      captureStatus,
+      captureSource: "cdp",
+      includeRaw,
+      hint
+    },
+    events: response.events.map((event) => formatTrackingEvent(event, includeRaw))
+  };
+}
+registerActions([
+  { name: "capture_checkpoint", session: "page", handler: cdpCaptureCheckpoint },
+  { name: "get_requests", session: "page", handler: cdpGetRequests },
+  { name: "get_logs", session: "page", handler: cdpGetLogs },
+  { name: "get_events", session: "page", handler: cdpGetEvents }
+]);
+
 // src/cdp-backend/composite-handlers.ts
 async function cdpRunActions(session, data, controlSource = "local") {
   const { actions, tabId } = data;
@@ -6020,21 +6484,42 @@ async function cdpRunActions(session, data, controlSource = "local") {
   };
 }
 async function cdpObservedPageAction(session, action, data, controlSource = "local") {
-  const { actionData, observe } = splitObservedActionPayload(data);
-  if (observe === false) {
-    return dispatchCdpAction(session, action, actionData, controlSource);
-  }
+  const { actionData, observe, diagnostics } = splitObservedActionPayload(action, data);
   const { tabId } = actionData;
   if (typeof tabId !== "number") throw new Error(`${action} requires a numeric tabId`);
   const pageSession = await session.getPageSession(tabId);
   await ensureControlledIndicator(pageSession, controlSource);
-  return runPageAct(
+  if (observe === false) {
+    if (!diagnostics) return dispatchCdpAction(session, action, actionData, controlSource);
+    const cursor = captureCheckpoint(pageSession.buffers.capture);
+    let actionResult;
+    let actionError;
+    try {
+      actionResult = await dispatchCdpAction(session, action, actionData, controlSource);
+    } catch (error48) {
+      actionError = error48 instanceof Error ? error48.message : String(error48);
+    }
+    return {
+      action: {
+        name: action,
+        success: actionError === void 0,
+        ...actionResult !== void 0 ? { data: actionResult } : {},
+        ...actionError ? { error: actionError } : {}
+      },
+      diagnostics: await collectCdpPageDiagnostics(pageSession, cursor, diagnostics)
+    };
+  }
+  let diagnosticsCursor;
+  const result = await runPageAct(
     { action, actionData, observe },
     {
       startObservation: () => startPageObservation(pageSession),
       finishObservation: (checkpoint, options) => finishPageObservation(pageSession, checkpoint, options),
       startNavigationObserver: (options) => startCdpNavigationObserver(session, pageSession, options.urlBefore, options),
-      executeAction: (name, params) => dispatchCdpAction(session, name, { ...params, tabId }, controlSource),
+      executeAction: (name, params) => {
+        if (diagnostics) diagnosticsCursor = captureCheckpoint(pageSession.buffers.capture);
+        return dispatchCdpAction(session, name, { ...params, tabId }, controlSource);
+      },
       finalizeObservation: (observation) => {
         if (observation.mode === "delta") {
           return enrichCdpPageChangeSetWithRefs(pageSession, observation);
@@ -6044,6 +6529,11 @@ async function cdpObservedPageAction(session, action, data, controlSource = "loc
       disposeObservation: () => disposePageObservation(pageSession)
     }
   );
+  if (!diagnostics || !diagnosticsCursor) return result;
+  return {
+    ...result,
+    diagnostics: await collectCdpPageDiagnostics(pageSession, diagnosticsCursor, diagnostics)
+  };
 }
 registerActions([{ name: "run_actions", session: "browser", handler: cdpRunActions }]);
 
@@ -6631,112 +7121,6 @@ function listCloudConnectors() {
   return { connectors: pushIfChanged() };
 }
 
-// src/cdp-backend/request-handlers.ts
-function filterRequests(buffers, opts) {
-  let requests = [...buffers.requests];
-  if (opts.since !== void 0) {
-    requests = requests.filter((r) => r.timestampMs >= opts.since);
-  }
-  if (opts.filter) {
-    const pattern = compileTextPattern(opts.filter);
-    requests = requests.filter(
-      (r) => matchesTextPattern(r.url, pattern) || matchesTextPattern(r.apiName, pattern)
-    );
-  }
-  if (opts.source === "mtop") {
-    requests = requests.filter((r) => r.url?.includes("/h5/") || r.url?.includes("mtop"));
-  }
-  const count = opts.count ?? 10;
-  return {
-    requests: requests.slice(-count),
-    totalMatched: requests.length
-  };
-}
-async function cdpGetRequests(session, data) {
-  const opts = {
-    count: data.count ?? 10,
-    filter: data.filter,
-    since: data.since,
-    source: data.source,
-    applyHiddenFilter: data.applyHiddenFilter !== false
-  };
-  const { requests, totalMatched } = filterRequests(session.buffers, opts);
-  const serializeOpts = {
-    includeBody: data.includeBody !== false,
-    includeHeaders: data.includeHeaders === true,
-    maxBodySize: data.maxBodySize ?? 5e4,
-    fields: data.fields,
-    keysOnly: data.keysOnly === true
-  };
-  return {
-    meta: {
-      count: requests.length,
-      totalMatched,
-      totalInBuffer: session.buffers.requests.length,
-      filter: data.filter,
-      since: data.since,
-      source: "cdp"
-    },
-    requests: requests.map((r) => serializeRequest(r, serializeOpts))
-  };
-}
-async function cdpGetLogs(session, data) {
-  const { level, since, limit = 100, filter } = data;
-  let logs = [...session.buffers.logs];
-  if (since !== void 0) {
-    logs = logs.filter((l) => l.timestamp >= since);
-  }
-  if (level && level !== "all") {
-    logs = logs.filter((l) => l.level === level);
-  }
-  if (filter) {
-    const f = filter.toLowerCase();
-    logs = logs.filter((l) => l.message?.toLowerCase().includes(f));
-  }
-  logs = logs.slice(-limit);
-  return {
-    meta: {
-      count: logs.length,
-      totalMatched: logs.length,
-      level: level || "all",
-      since,
-      filter,
-      source: "cdp"
-    },
-    logs
-  };
-}
-async function cdpGetEvents(session, data) {
-  const { source = "all", event_type, since, limit = 20, filter, includeRaw = false } = data;
-  const response = queryTrackingEvents(session.buffers.events, {
-    source,
-    event_type,
-    since,
-    limit,
-    filter
-  });
-  const captureStatus = response.totalInBuffer === 0 ? "armed" : "active";
-  const hint = response.events.length === 0 && captureStatus === "armed" ? TRACKING_CAPTURE_ARMED_HINT : void 0;
-  return {
-    meta: {
-      count: response.events.length,
-      totalMatched: response.totalMatched,
-      totalInBuffer: response.totalInBuffer,
-      source,
-      captureStatus,
-      captureSource: "cdp",
-      includeRaw,
-      hint
-    },
-    events: response.events.map((event) => formatTrackingEvent(event, includeRaw))
-  };
-}
-registerActions([
-  { name: "get_requests", session: "page", handler: cdpGetRequests },
-  { name: "get_logs", session: "page", handler: cdpGetLogs },
-  { name: "get_events", session: "page", handler: cdpGetEvents }
-]);
-
 // src/cdp-backend/send-request.ts
 import { readFile } from "node:fs/promises";
 import { randomUUID as randomUUID2 } from "node:crypto";
@@ -6746,6 +7130,10 @@ function setHeader(headers, name, value) {
   if (existing && existing !== name) delete headers[existing];
   headers[name] = value;
 }
+function removeHeader(headers, name) {
+  const existing = findSendRequestHeaderName(headers, name);
+  if (existing) delete headers[existing];
+}
 function escapeMultipartQuotedValue(value) {
   return value.replace(/\\/g, "\\\\").replace(/"/g, "%22");
 }
@@ -6854,10 +7242,19 @@ async function executeNodeSendRequest(data, cookieMap = /* @__PURE__ */ new Map(
     Accept: "application/json, text/plain, */*",
     "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
     "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
-    Referer: targetUrl.origin + "/mearl",
-    Origin: targetUrl.origin,
     ...headers
   };
+  const resolvedSourceHeaders = getSendRequestSourceHeaders(targetUrl, headers);
+  if (resolvedSourceHeaders.referer) {
+    setHeader(requestHeaders, "Referer", resolvedSourceHeaders.referer);
+  } else {
+    removeHeader(requestHeaders, "Referer");
+  }
+  if (resolvedSourceHeaders.origin) {
+    setHeader(requestHeaders, "Origin", resolvedSourceHeaders.origin);
+  } else {
+    removeHeader(requestHeaders, "Origin");
+  }
   const cookieHeader = [...cookieMap.entries()].map(([key, value]) => `${key}=${value}`).join("; ");
   if (cookieHeader) setHeader(requestHeaders, "Cookie", cookieHeader);
   const xsrfToken = cookieMap.get("XSRF-TOKEN");
@@ -7215,8 +7612,8 @@ registerActions([
 ]);
 
 // src/cdp-backend/tdbank-handlers.ts
-async function cdpFetchTdbank(session, path12, options = {}) {
-  const url2 = new URL(`https://tdbank.alibaba-inc.com${path12}`);
+async function cdpFetchTdbank(session, path13, options = {}) {
+  const url2 = new URL(`https://tdbank.alibaba-inc.com${path13}`);
   for (const [key, value] of Object.entries(options.params ?? {})) {
     if (value !== void 0 && value !== null) {
       url2.searchParams.set(key, String(value));
@@ -7484,6 +7881,14 @@ async function cdpTdbankAccount(cdpSession2, data) {
 registerActions([{ name: "tdbank_account", session: "browser", handler: cdpTdbankAccount }]);
 
 // src/cdp-backend/tab-handlers.ts
+function currentCapture(pageSession) {
+  return {
+    tabId: pageSession.tabId,
+    cursor: captureCheckpoint(pageSession.buffers.capture),
+    timestampMs: Date.now(),
+    captureStatus: pageSession.buffers.capture.currentSequence === 0 ? "armed" : "active"
+  };
+}
 async function cdpTabOpen(session, data, controlSource = "local") {
   const { url: url2, active = false, emulation, reuse = "never", match } = data;
   if (!url2 || typeof url2 !== "string") {
@@ -7510,12 +7915,14 @@ async function cdpTabOpen(session, data, controlSource = "local") {
       const tabId2 = await session.ensureTargetRegistered(existing.targetId);
       const pageSession2 = await session.getPageSession(tabId2);
       await ensureControlledIndicator(pageSession2, controlSource);
+      const capture2 = currentCapture(pageSession2);
       return {
         tabId: tabId2,
         url: existing.url ?? url2,
         title: existing.title ?? "",
         opened: false,
-        reused: true
+        reused: true,
+        capture: capture2
       };
     }
     if (reuse === "require") {
@@ -7530,6 +7937,7 @@ async function cdpTabOpen(session, data, controlSource = "local") {
   const tabId = await session.registerTarget(targetId);
   const pageSession = await session.getPageSession(tabId);
   await ensureControlledIndicator(pageSession, controlSource);
+  const capture = currentCapture(pageSession);
   if (emulationConfig) {
     for (const { method, params } of buildEnableEmulationCommands(emulationConfig)) {
       await pageSession.client.sendCommand(method, params);
@@ -7548,6 +7956,7 @@ async function cdpTabOpen(session, data, controlSource = "local") {
     title: targetInfo?.title ?? "",
     opened: true,
     reused: false,
+    capture,
     ...emulationConfig && {
       emulation: {
         preset: emulationConfig.presetName,
@@ -8506,12 +8915,9 @@ async function getViewportBackendNodeIds(session) {
       includePaintOrder: false
     })
   ]);
-  const viewport = metrics.cssVisualViewport ?? metrics.visualViewport;
-  const left = viewport?.pageX ?? 0;
-  const top = viewport?.pageY ?? 0;
-  const width = viewport?.clientWidth;
-  const height = viewport?.clientHeight;
-  if (!width || !height) throw new Error("page_snapshot: viewport metrics are unavailable");
+  const viewport = resolveDOMSnapshotViewportBounds(metrics);
+  if (!viewport) throw new Error("page_snapshot: viewport metrics are unavailable");
+  const { left, top, width, height } = viewport;
   const right = left + width;
   const bottom = top + height;
   const visible = /* @__PURE__ */ new Set();
@@ -9346,7 +9752,7 @@ import os2 from "node:os";
 import { randomUUID as randomUUID4 } from "node:crypto";
 
 // src/version.ts
-var NATIVE_HOST_VERSION = true ? "2.2.1" : "unknown";
+var NATIVE_HOST_VERSION = true ? "2.3.0" : "unknown";
 
 // src/analytics.ts
 var MEASUREMENT_ID = "G-W84LJDZ6PH";
@@ -10207,17 +10613,51 @@ var AgentChatManager = class {
 
 // src/agent/codex-provider.ts
 import os3 from "node:os";
-import path7 from "node:path";
 import readline from "node:readline";
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 
 // src/agent/executable-resolver.ts
-import fs5 from "node:fs";
-import { spawn as spawn4 } from "node:child_process";
+import fs6 from "node:fs";
+import { spawn as spawn5 } from "node:child_process";
+import path7 from "node:path";
 
-// src/agent/process-env.ts
+// ../setup/dist/process.js
+import fs5 from "node:fs";
 import path6 from "node:path";
-function agentSpawnCommand(executable, args, platform = process.platform, commandInterpreter = process.env.ComSpec) {
+import { spawn as spawn4 } from "node:child_process";
+function isExecutable(filePath, platform = process.platform) {
+  try {
+    fs5.accessSync(filePath, platform === "win32" ? fs5.constants.F_OK : fs5.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function executableNames(name, platform = process.platform) {
+  return platform === "win32" ? [`${name}.cmd`, `${name}.exe`, name] : [name];
+}
+function versionManagerExecutableCandidates(home, names, options = {}) {
+  const env = options.env ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const readdirSync2 = options.readdirSync ?? fs5.readdirSync;
+  const fnmDefaultRoot = env.XDG_DATA_HOME ? path6.join(env.XDG_DATA_HOME, "fnm") : platform === "darwin" ? path6.join(home, "Library", "Application Support", "fnm") : platform === "win32" && env.APPDATA ? path6.join(env.APPDATA, "fnm") : path6.join(home, ".local", "share", "fnm");
+  const roots = [
+    path6.join(env.NVM_DIR || path6.join(home, ".nvm"), "versions", "node"),
+    path6.join(env.FNM_DIR || fnmDefaultRoot, "node-versions"),
+    path6.join(home, ".fnm", "node-versions")
+  ].filter((root, index, all) => all.indexOf(root) === index);
+  return roots.flatMap((root) => {
+    try {
+      return readdirSync2(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).sort((left, right) => right.name.localeCompare(left.name, void 0, { numeric: true })).flatMap((entry) => names.flatMap((name) => [
+        path6.join(root, entry.name, "bin", name),
+        path6.join(root, entry.name, "installation", "bin", name)
+      ]));
+    } catch {
+      return [];
+    }
+  });
+}
+function resolveSpawnCommand(executable, args, platform = process.platform, commandInterpreter = process.env.ComSpec) {
   if (platform === "win32" && /\.(?:cmd|bat)$/i.test(executable)) {
     return {
       command: commandInterpreter || "cmd.exe",
@@ -10226,16 +10666,64 @@ function agentSpawnCommand(executable, args, platform = process.platform, comman
   }
   return { command: executable, args };
 }
-function createAgentChildEnv(sourceEnv = process.env, nodeExecutable = process.execPath) {
-  const pathKey = Object.keys(sourceEnv).find((key) => key.toLowerCase() === "path") || "PATH";
-  const nodeDirectory = path6.dirname(nodeExecutable);
-  const inheritedPath = sourceEnv[pathKey] || "";
-  const pathEntries = inheritedPath.split(path6.delimiter).filter(Boolean);
-  const nextPath = pathEntries.includes(nodeDirectory) ? inheritedPath : [nodeDirectory, ...pathEntries].join(path6.delimiter);
-  return { ...sourceEnv, [pathKey]: nextPath };
+function prependCommandPath(command, env = process.env) {
+  if (!path6.isAbsolute(command))
+    return env;
+  return prependPath(path6.dirname(command), env);
+}
+function prependNodePath(env = process.env, nodeExecutable = process.execPath) {
+  return prependPath(path6.dirname(nodeExecutable), env);
+}
+function prependPath(directory, env) {
+  const pathKey = Object.keys(env).find((key) => key.toLowerCase() === "path") || "PATH";
+  const inherited = env[pathKey] || "";
+  const entries = inherited.split(path6.delimiter).filter(Boolean);
+  if (entries.includes(directory))
+    return env;
+  return { ...env, [pathKey]: [directory, ...entries].join(path6.delimiter) };
 }
 
 // src/agent/executable-resolver.ts
+function agentExecutableCandidatePaths({
+  executableNames: executableNames2,
+  configuredPath,
+  env = process.env,
+  extraUserCandidates = [],
+  home,
+  platform = process.platform,
+  processExecPath = process.execPath,
+  readdirSync: readdirSync2
+}) {
+  const pathKey = Object.keys(env).find((key) => key.toLowerCase() === "path") || "PATH";
+  const pathCandidates = (env[pathKey] || "").split(path7.delimiter).filter(Boolean).flatMap((directory) => executableNames2.map((name) => path7.join(directory, name)));
+  const commonUserDirectories = [
+    path7.join(home, ".local", "bin"),
+    path7.join(home, ".npm-global", "bin"),
+    path7.join(home, ".volta", "bin"),
+    path7.join(home, ".local", "share", "pnpm"),
+    path7.join(home, "Library", "pnpm"),
+    path7.join(home, ".bun", "bin"),
+    ...platform === "win32" && env.APPDATA ? [path7.join(env.APPDATA, "npm")] : []
+  ];
+  const systemDirectories = platform === "win32" ? [] : ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin"];
+  return [
+    configuredPath,
+    ...executableNames2.map((name) => path7.join(path7.dirname(processExecPath), name)),
+    ...commonUserDirectories.flatMap(
+      (directory) => executableNames2.map((name) => path7.join(directory, name))
+    ),
+    ...extraUserCandidates,
+    ...versionManagerExecutableCandidates(home, executableNames2, {
+      env,
+      platform,
+      readdirSync: readdirSync2
+    }),
+    ...systemDirectories.flatMap(
+      (directory) => executableNames2.map((name) => path7.join(directory, name))
+    ),
+    ...pathCandidates
+  ].filter((candidate) => typeof candidate === "string");
+}
 var AgentExecutableResolver = class {
   constructor(options) {
     this.options = options;
@@ -10306,11 +10794,11 @@ function probeAgentExecutable(executable, options) {
   return new Promise((resolve) => {
     let settled = false;
     let stderr = "";
-    const launch = agentSpawnCommand(executable, options.args);
-    const child = spawn4(launch.command, launch.args, {
+    const launch = resolveSpawnCommand(executable, options.args);
+    const child = spawn5(launch.command, launch.args, {
       stdio: ["ignore", "ignore", "pipe"],
       windowsHide: true,
-      env: createAgentChildEnv()
+      env: prependNodePath()
     });
     const finish = (error48) => {
       if (settled) return;
@@ -10337,8 +10825,8 @@ function probeAgentExecutable(executable, options) {
 }
 function isExecutableFile(candidate) {
   try {
-    fs5.accessSync(candidate, process.platform === "win32" ? fs5.constants.F_OK : fs5.constants.X_OK);
-    return fs5.statSync(candidate).isFile();
+    fs6.accessSync(candidate, process.platform === "win32" ? fs6.constants.F_OK : fs6.constants.X_OK);
+    return fs6.statSync(candidate).isFile();
   } catch {
     return false;
   }
@@ -10349,6 +10837,21 @@ var REQUEST_TIMEOUT_MS = 3e4;
 var PROBE_TIMEOUT_MS = 5e3;
 var MAX_MODEL_CHARS = 256;
 var CODEX_NOT_FOUND_ERROR = "Codex CLI was not found. Install @openai/codex or set MEARL_CODEX_PATH.";
+function codexExecutableCandidatePaths(options = {}) {
+  const env = options.env ?? process.env;
+  const home = (options.homedir ?? os3.homedir)();
+  const platform = options.platform ?? process.platform;
+  const executableName = platform === "win32" ? "codex.cmd" : "codex";
+  return agentExecutableCandidatePaths({
+    executableNames: [executableName],
+    configuredPath: env.MEARL_CODEX_PATH,
+    env,
+    home,
+    platform,
+    processExecPath: options.processExecPath,
+    readdirSync: options.readdirSync
+  });
+}
 function codexModelInfo(value) {
   if (typeof value !== "string") return void 0;
   const id = value.trim().slice(0, MAX_MODEL_CHARS);
@@ -10433,7 +10936,7 @@ function externalOpenCommand(url2, platform = process.platform) {
 function openExternalUrl(url2) {
   const { command, args } = externalOpenCommand(url2);
   return new Promise((resolve, reject) => {
-    const child = spawn5(command, args, { stdio: "ignore", windowsHide: true });
+    const child = spawn6(command, args, { stdio: "ignore", windowsHide: true });
     child.once("error", (error48) => {
       reject(new Error(`Unable to open Codex App: ${error48.message}`));
     });
@@ -10664,10 +11167,10 @@ var CodexAgentProvider = class {
       throw new Error(resolution.error);
     }
     const { executable } = resolution;
-    const launch = agentSpawnCommand(executable, ["app-server", "--listen", "stdio://"]);
-    const childEnv = createAgentChildEnv();
+    const launch = resolveSpawnCommand(executable, ["app-server", "--listen", "stdio://"]);
+    const childEnv = prependNodePath();
     if (this.mearlSocketPath) childEnv.MEARL_SOCKET_PATH = this.mearlSocketPath;
-    const child = spawn5(launch.command, launch.args, {
+    const child = spawn6(launch.command, launch.args, {
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true,
       env: childEnv
@@ -10830,26 +11333,15 @@ var CodexAgentProvider = class {
     return this.executableResolver.resolve();
   }
   resolveExecutableCandidates() {
-    const executableName = process.platform === "win32" ? "codex.cmd" : "codex";
-    const configured = process.env.MEARL_CODEX_PATH;
-    const pathCandidates = (process.env.PATH || "").split(path7.delimiter).filter(Boolean).map((dir) => path7.join(dir, executableName));
-    return executableFileCandidates([
-      configured,
-      path7.join(path7.dirname(process.execPath), executableName),
-      path7.join(os3.homedir(), ".local", "bin", executableName),
-      path7.join(os3.homedir(), ".npm-global", "bin", executableName),
-      path7.join(os3.homedir(), ".volta", "bin", executableName),
-      ...process.platform === "win32" ? [] : ["/opt/homebrew/bin/codex", "/usr/local/bin/codex", "/usr/bin/codex"],
-      ...pathCandidates
-    ]);
+    return executableFileCandidates(codexExecutableCandidatePaths());
   }
 };
 
 // src/agent/qoder-provider.ts
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 import os4 from "node:os";
 import path8 from "node:path";
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn7 } 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
@@ -11671,10 +12163,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path12) {
-  if (!path12)
+function getElementAtPath(obj, path13) {
+  if (!path13)
     return obj;
-  return path12.reduce((acc, key) => acc?.[key], obj);
+  return path13.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -12057,11 +12549,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path12, issues) {
+function prefixIssues(path13, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path12);
+    iss.path.unshift(path13);
     return iss;
   });
 }
@@ -12244,7 +12736,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path12 = []) => {
+  const processError = (error49, path13 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -12254,7 +12746,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path12, ...issue2.path];
+        const fullpath = [...path13, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -12286,8 +12778,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path12 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path12) {
+  const path13 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path13) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -24264,13 +24756,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path12 = ref.slice(1).split("/").filter(Boolean);
-  if (path12.length === 0) {
+  const path13 = ref.slice(1).split("/").filter(Boolean);
+  if (path13.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path12[0] === defsKey) {
-    const key = path12[1];
+  if (path13[0] === defsKey) {
+    const key = path13[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -28195,10 +28687,10 @@ function parseQoderSkillsList(output, cwd, home = os4.homedir()) {
   finish();
   return skills;
 }
-function qoderManagedExecutableCandidates(home) {
+function qoderManagedExecutableCandidates(home, readdirSync2 = fs7.readdirSync) {
   const directory = path8.join(home, ".qoder", "bin", "qodercli");
   try {
-    return fs6.readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.startsWith("qodercli-")).sort((left, right) => right.name.localeCompare(left.name, void 0, { numeric: true })).map((entry) => path8.join(directory, entry.name));
+    return readdirSync2(directory, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.startsWith("qodercli-")).sort((left, right) => right.name.localeCompare(left.name, void 0, { numeric: true })).map((entry) => path8.join(directory, entry.name));
   } catch {
     return [];
   }
@@ -28213,6 +28705,25 @@ function isPermissionResponse(value) {
 function qoderInstallCommand(platform = process.platform) {
   return platform === "win32" ? "npm install -g @qoder-ai/qodercli" : "curl -fsSL https://qoder.com/install | bash";
 }
+function qoderExecutableCandidatePaths(options = {}) {
+  const env = options.env ?? process.env;
+  const home = (options.homedir ?? os4.homedir)();
+  const platform = options.platform ?? process.platform;
+  const executableNames2 = platform === "win32" ? ["qodercli.exe", "qodercli.cmd"] : ["qodercli"];
+  return agentExecutableCandidatePaths({
+    executableNames: executableNames2,
+    configuredPath: env.MEARL_QODER_PATH,
+    env,
+    extraUserCandidates: [
+      ...qoderManagedExecutableCandidates(home, options.readdirSync),
+      ...executableNames2.map((name) => path8.join(home, ".qoder", "bin", name))
+    ],
+    home,
+    platform,
+    processExecPath: options.processExecPath,
+    readdirSync: options.readdirSync
+  });
+}
 function sessionOptions(options) {
   const cwd = path8.resolve(options.cwd || os4.homedir());
   return {
@@ -28618,11 +29129,11 @@ ${message}` : message;
       throw new Error(resolution.error);
     }
     const { executable } = resolution;
-    const launch = agentSpawnCommand(executable, ["--acp"]);
-    const child = spawn6(launch.command, launch.args, {
+    const launch = resolveSpawnCommand(executable, ["--acp"]);
+    const child = spawn7(launch.command, launch.args, {
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true,
-      env: createAgentChildEnv()
+      env: prependNodePath()
     });
     this.process = child;
     child.stderr.on("data", (chunk) => {
@@ -28965,12 +29476,12 @@ ${message}` : message;
   }
   runSkillsList(executable, cwd) {
     return new Promise((resolve, reject) => {
-      const launch = agentSpawnCommand(executable, ["skill", "list", "--all"]);
-      const child = spawn6(launch.command, launch.args, {
+      const launch = resolveSpawnCommand(executable, ["skill", "list", "--all"]);
+      const child = spawn7(launch.command, launch.args, {
         cwd,
         stdio: ["ignore", "pipe", "pipe"],
         windowsHide: true,
-        env: createAgentChildEnv()
+        env: prependNodePath()
       });
       let stdout = "";
       let stderr = "";
@@ -29004,89 +29515,60 @@ ${message}` : message;
     return this.executableResolver.resolve();
   }
   resolveExecutableCandidates() {
-    const executableNames = process.platform === "win32" ? ["qodercli.exe", "qodercli.cmd"] : ["qodercli"];
-    const configured = process.env.MEARL_QODER_PATH;
-    const home = os4.homedir();
-    const pathCandidates = (process.env.PATH || "").split(path8.delimiter).filter(Boolean).flatMap((dir) => executableNames.map((name) => path8.join(dir, name)));
-    return executableFileCandidates([
-      configured,
-      ...executableNames.map((name) => path8.join(path8.dirname(process.execPath), name)),
-      ...executableNames.map((name) => path8.join(home, ".local", "bin", name)),
-      ...qoderManagedExecutableCandidates(home),
-      ...executableNames.map((name) => path8.join(home, ".qoder", "bin", name)),
-      ...process.platform === "win32" ? [] : ["/opt/homebrew/bin/qodercli", "/usr/local/bin/qodercli", "/usr/bin/qodercli"],
-      ...pathCandidates
-    ]);
+    return executableFileCandidates(qoderExecutableCandidatePaths());
   }
   emit(event) {
     for (const listener of this.listeners) listener(event);
   }
 };
 
-// src/agent/skill-manager.ts
-import fs7 from "node:fs";
+// ../setup/dist/aliSkills.js
+import fs8 from "node:fs";
 import os5 from "node:os";
 import path9 from "node:path";
-import { spawn as spawn7 } from "node:child_process";
+import { spawn as spawn8 } 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");
-var SETUP_COMMAND = "npm install -g ali-skills";
-function existingExecutable(candidates) {
-  for (const candidate of candidates) {
-    if (!candidate) continue;
-    try {
-      fs7.accessSync(
-        candidate,
-        process.platform === "win32" ? fs7.constants.F_OK : fs7.constants.X_OK
-      );
-      return candidate;
-    } catch {
-    }
-  }
-  return null;
+function existingExecutable(candidates, existsSync4) {
+  return candidates.find((candidate) => candidate && existsSync4(candidate)) ?? null;
 }
-function versionManagerCandidates(home, executableNames) {
-  const roots = [
-    path9.join(home, ".nvm", "versions", "node"),
-    path9.join(home, ".fnm", "node-versions")
-  ];
-  return roots.flatMap((root) => {
-    try {
-      return fs7.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).sort((left, right) => right.name.localeCompare(left.name, void 0, { numeric: true })).flatMap(
-        (entry) => executableNames.flatMap((name) => [
-          path9.join(root, entry.name, "bin", name),
-          path9.join(root, entry.name, "installation", "bin", name)
-        ])
-      );
-    } catch {
-      return [];
-    }
-  });
+function stripAnsi(value) {
+  return value.replace(ANSI_ESCAPE_PATTERN, "");
 }
-function resolveAliSkillsExecutable() {
-  const executableNames = process.platform === "win32" ? ["ali-skills.cmd", "ali-skills.exe", "ali-skills"] : ["ali-skills"];
-  const home = os5.homedir();
-  const pathCandidates = (process.env.PATH || "").split(path9.delimiter).filter(Boolean).flatMap((directory) => executableNames.map((name) => path9.join(directory, name)));
+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 processExecPath = options.processExecPath ?? process.execPath;
+  const readdirSync2 = options.readdirSync ?? fs8.readdirSync;
+  const names = executableNames("ali-skills", platform);
+  const pathKey = Object.keys(env).find((key) => key.toLowerCase() === "path") || "PATH";
+  const pathCandidates = (env[pathKey] || "").split(path9.delimiter).filter(Boolean).flatMap((directory) => names.map((name) => path9.join(directory, name)));
   const candidates = [
-    process.env.MEARL_ALI_SKILLS_PATH,
-    ...executableNames.map((name) => path9.join(path9.dirname(process.execPath), name)),
-    ...executableNames.map((name) => path9.join(home, ".local", "bin", name)),
-    ...executableNames.map((name) => path9.join(home, ".npm-global", "bin", name)),
-    ...executableNames.map((name) => path9.join(home, ".volta", "bin", name)),
-    ...executableNames.map((name) => path9.join(home, ".local", "share", "pnpm", name)),
-    ...executableNames.map((name) => path9.join(home, "Library", "pnpm", name)),
-    ...versionManagerCandidates(home, executableNames),
-    ...process.platform === "win32" ? [] : ["/opt/homebrew/bin/ali-skills", "/usr/local/bin/ali-skills", "/usr/bin/ali-skills"],
+    env.MEARL_ALI_SKILLS_PATH,
+    ...names.map((name) => path9.join(path9.dirname(processExecPath), name)),
+    ...names.map((name) => path9.join(home, ".local", "bin", name)),
+    ...names.map((name) => path9.join(home, ".npm-global", "bin", name)),
+    ...names.map((name) => path9.join(home, ".volta", "bin", name)),
+    ...names.map((name) => path9.join(home, ".local", "share", "pnpm", name)),
+    ...names.map((name) => path9.join(home, "Library", "pnpm", name)),
+    ...versionManagerExecutableCandidates(home, names, {
+      env,
+      platform,
+      readdirSync: readdirSync2
+    }),
+    ...platform === "win32" ? [] : ["/opt/homebrew/bin/ali-skills", "/usr/local/bin/ali-skills", "/usr/bin/ali-skills"],
     ...pathCandidates
   ];
-  return existingExecutable(candidates);
+  return existingExecutable(candidates, existsSync4);
 }
-var runSkillCli = (executable, args, cwd) => new Promise((resolve, reject) => {
-  const launch = agentSpawnCommand(executable, args);
-  const child = spawn7(launch.command, launch.args, {
+var runAliSkillsCli = (executable, args, cwd) => new Promise((resolve, reject) => {
+  const launch = resolveSpawnCommand(executable, args);
+  const child = spawn8(launch.command, launch.args, {
     cwd,
-    env: createAgentChildEnv(),
+    env: prependNodePath(prependCommandPath(executable)),
     stdio: ["ignore", "pipe", "pipe"],
     windowsHide: true
   });
@@ -29095,11 +29577,14 @@ var runSkillCli = (executable, args, cwd) => new Promise((resolve, reject) => {
   let settled = false;
   const append = (current, chunk) => current.length >= MAX_OUTPUT_LENGTH ? current : (current + chunk.toString("utf8")).slice(0, MAX_OUTPUT_LENGTH);
   const finish = (error48) => {
-    if (settled) return;
+    if (settled)
+      return;
     settled = true;
     clearTimeout(timer);
-    if (error48) reject(error48);
-    else resolve({ stdout, stderr });
+    if (error48)
+      reject(error48);
+    else
+      resolve({ stdout, stderr });
   };
   const timer = setTimeout(() => {
     child.kill("SIGTERM");
@@ -29117,9 +29602,10 @@ var runSkillCli = (executable, args, cwd) => new Promise((resolve, reject) => {
     finish(new Error(detail || `Ali Skills command exited with code ${String(code)}`));
   });
 });
-function stripAnsi(value) {
-  return value.replace(ANSI_ESCAPE_PATTERN, "");
-}
+
+// src/agent/skill-manager.ts
+var SETUP_COMMAND = "npm install -g ali-skills";
+var runSkillCli = runAliSkillsCli;
 function validateProvider(value) {
   if (value !== "codex" && value !== "qoder") {
     throw new Error("Skill provider must be codex or qoder");
@@ -29304,7 +29790,7 @@ var CDP_PORT = positivePort(cliOption("--cdp-port"), 9222);
 var CDP_USER_DATA_DIR = cliOption("--cdp-user-data-dir");
 var CDP_BROWSER_ID = cliOption("--browser-id") ?? "cdp";
 var CDP_BROWSER_NAME = cliOption("--browser-name") ?? "CDP";
-if (cliArg === "--init") {
+if (cliArg === "--init" || cliArg === "--uninstall") {
   const { runCli: runCli2 } = await Promise.resolve().then(() => (init_install(), install_exports));
   await runCli2(process.argv.slice(2));
   process.exit(0);
@@ -29323,6 +29809,8 @@ Options:
   --init [--mode <skills|mcp|both>] [--extension-id <id>]
                              Initialize Native Messaging Host
                              (default: both — installs the Skills and MCP hosts)
+  --uninstall [--mode <skills|mcp|both>]
+                             Remove Native Messaging Host registration
   --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
@@ -29340,17 +29828,18 @@ Connection modes (auto-detected at runtime):
 Examples:
   mearl-native-host --init
   mearl-native-host --init --mode skills
+  mearl-native-host --uninstall --mode skills
   mearl-native-host --init --extension-id abcdefghijklmnopqrstuvwxyzabcdef
   mearl-native-host --daemon
   mearl-native-host --version`);
   process.exit(0);
 }
 function socketPathFor(suffix) {
-  return process.platform === "win32" ? `\\\\.\\pipe\\mearl-agent${suffix}` : path11.join(os7.tmpdir(), `mearl-agent${suffix}.sock`);
+  return process.platform === "win32" ? `\\\\.\\pipe\\mearl-agent${suffix}` : path12.join(os7.tmpdir(), `mearl-agent${suffix}.sock`);
 }
 var LEGACY_SOCKET_PATH = socketPathFor("");
 var INSTANCE_SOCKET_PATH = socketPathFor(`-${process.pid}`);
-var LOG_FILE = path11.join(os7.tmpdir(), "mearl-native-host.log");
+var LOG_FILE = path12.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;
@@ -29449,7 +29938,7 @@ function log(...args) {
   const msg = `[${(/* @__PURE__ */ new Date()).toISOString()}] [NativeHost] ${args.join(" ")}
 `;
   try {
-    fs9.appendFileSync(LOG_FILE, msg);
+    fs11.appendFileSync(LOG_FILE, msg);
   } catch {
   }
 }
@@ -29983,7 +30472,7 @@ function onSocketConnection(socket) {
 }
 function isPathAlive(socketPath) {
   return new Promise((resolve) => {
-    if (process.platform !== "win32" && !fs9.existsSync(socketPath)) {
+    if (process.platform !== "win32" && !fs11.existsSync(socketPath)) {
       resolve(false);
       return;
     }
@@ -30006,9 +30495,9 @@ function isPathAlive(socketPath) {
 }
 function listenOn(socketPath) {
   return new Promise((resolve, reject) => {
-    if (process.platform !== "win32" && fs9.existsSync(socketPath)) {
+    if (process.platform !== "win32" && fs11.existsSync(socketPath)) {
       try {
-        fs9.unlinkSync(socketPath);
+        fs11.unlinkSync(socketPath);
       } catch {
       }
     }
@@ -30017,11 +30506,11 @@ function listenOn(socketPath) {
     server.listen(socketPath, () => {
       if (process.platform !== "win32") {
         try {
-          fs9.chmodSync(socketPath, 384);
+          fs11.chmodSync(socketPath, 384);
         } catch (error48) {
           server.close();
           try {
-            fs9.unlinkSync(socketPath);
+            fs11.unlinkSync(socketPath);
           } catch {
           }
           reject(error48);
@@ -30057,7 +30546,7 @@ function releaseLegacySocket() {
   }
   if (process.platform !== "win32") {
     try {
-      if (fs9.existsSync(LEGACY_SOCKET_PATH)) fs9.unlinkSync(LEGACY_SOCKET_PATH);
+      if (fs11.existsSync(LEGACY_SOCKET_PATH)) fs11.unlinkSync(LEGACY_SOCKET_PATH);
     } catch {
     }
   }
@@ -30069,8 +30558,8 @@ async function startSocketServer() {
 function cleanupInstanceSocketFile() {
   if (process.platform === "win32") return;
   try {
-    if (fs9.existsSync(INSTANCE_SOCKET_PATH)) {
-      fs9.unlinkSync(INSTANCE_SOCKET_PATH);
+    if (fs11.existsSync(INSTANCE_SOCKET_PATH)) {
+      fs11.unlinkSync(INSTANCE_SOCKET_PATH);
     }
   } catch (error48) {
     log("cleanup socket file failed:", String(error48));