@mearl/native-host 2.2.2 → 2.4.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,20 +46,20 @@ function uninstallNativeHostArtifacts(options = {}, dependencies = {}) {
       writeLine(line);
   };
   try {
-    const existsSync4 = dependencies.existsSync ?? fs9.existsSync;
+    const existsSync4 = 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))
@@ -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 fileURLToPath2 } 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,26 @@ var init_install = __esm({
     "use strict";
     init_nativeHost();
     DEFAULT_EXTENSION_ID = "aoehhjnofngknnjefamjbplchbolghkm";
-    __filename = fileURLToPath(import.meta.url);
-    __dirname = path11.dirname(__filename);
+    __filename = fileURLToPath2(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 fs13 from "node:fs";
 import http5 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 fileURLToPath3 } from "node:url";
 
 // src/cdp-backend/cdp-session.ts
 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;
@@ -406,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,
@@ -559,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) {
@@ -754,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;
@@ -1163,13 +1166,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);
@@ -1181,10 +1184,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}`);
@@ -1202,8 +1205,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)
@@ -1212,8 +1215,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];
@@ -1287,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;
@@ -1411,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;
@@ -1424,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
@@ -2741,19 +2752,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)
@@ -2763,7 +2774,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");
@@ -3470,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,
@@ -3512,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,
@@ -3558,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) {
@@ -4269,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();
@@ -4371,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 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) {
@@ -4384,7 +4422,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');
   }
@@ -4394,9 +4432,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
   };
 }
@@ -4423,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 = {}) {
@@ -4444,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) {
@@ -4467,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;
   }
@@ -4503,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),
@@ -4535,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);
@@ -4552,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
@@ -4777,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,
@@ -6035,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;
@@ -6110,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);
@@ -6134,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 }]);
 
@@ -6721,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";
@@ -6836,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");
 }
@@ -6944,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");
@@ -7305,8 +7612,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));
@@ -7574,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") {
@@ -7600,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") {
@@ -7620,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);
@@ -7638,6 +7956,7 @@ async function cdpTabOpen(session, data, controlSource = "local") {
     title: targetInfo?.title ?? "",
     opened: true,
     reused: false,
+    capture,
     ...emulationConfig && {
       emulation: {
         preset: emulationConfig.presetName,
@@ -9433,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.2" : "unknown";
+var NATIVE_HOST_VERSION = true ? "2.4.0" : "unknown";
 
 // src/analytics.ts
 var MEASUREMENT_ID = "G-W84LJDZ6PH";
@@ -10294,18 +10613,19 @@ 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 spawn6 } from "node:child_process";
 
 // src/agent/executable-resolver.ts
 import fs6 from "node:fs";
 import { spawn as spawn5 } 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";
+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);
@@ -10317,6 +10637,27 @@ function isExecutable(filePath, platform = process.platform) {
 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 {
@@ -10329,12 +10670,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);
@@ -10342,8 +10683,101 @@ 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 existsSync4 = 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 (existsSync4(candidate))
+        return candidate;
+    }
+  }
+  return null;
+}
+var runCommand = (command, args, options = {}) => new Promise((resolve, reject) => {
+  const capture = options.capture === true;
+  const launch = resolveSpawnCommand(command, args);
+  const child = spawn4(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
+      resolve({ 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({
+  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;
@@ -10457,6 +10891,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);
@@ -10938,18 +11387,7 @@ 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());
   }
 };
 
@@ -11779,10 +12217,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);
@@ -12165,11 +12603,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;
   });
 }
@@ -12352,7 +12790,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) {
@@ -12362,7 +12800,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;
@@ -12394,8 +12832,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")
@@ -24372,13 +24810,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}`);
     }
@@ -28303,10 +28741,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 fs7.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 [];
   }
@@ -28321,6 +28759,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 {
@@ -29112,19 +29569,7 @@ ${message}` : message;
     return this.executableResolver.resolve();
   }
   resolveExecutableCandidates() {
-    const executableNames2 = 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) => executableNames2.map((name) => path8.join(dir, name)));
-    return executableFileCandidates([
-      configured,
-      ...executableNames2.map((name) => path8.join(path8.dirname(process.execPath), name)),
-      ...executableNames2.map((name) => path8.join(home, ".local", "bin", name)),
-      ...qoderManagedExecutableCandidates(home),
-      ...executableNames2.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);
@@ -29142,22 +29587,6 @@ var ANSI_ESCAPE_PATTERN = new RegExp(String.raw`\u001B\[[0-?]*[ -/]*[@-~]`, "g")
 function existingExecutable(candidates, existsSync4) {
   return candidates.find((candidate) => candidate && existsSync4(candidate)) ?? null;
 }
-function versionManagerCandidates(home, executableNames2, readdirSync2) {
-  const roots = [
-    path9.join(home, ".nvm", "versions", "node"),
-    path9.join(home, ".fnm", "node-versions")
-  ];
-  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) => executableNames2.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, "");
 }
@@ -29179,7 +29608,11 @@ function resolveAliSkillsExecutable(options = {}) {
     ...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)),
-    ...versionManagerCandidates(home, names, readdirSync2),
+    ...versionManagerExecutableCandidates(home, names, {
+      env,
+      platform,
+      readdirSync: readdirSync2
+    }),
     ...platform === "win32" ? [] : ["/opt/homebrew/bin/ali-skills", "/usr/local/bin/ali-skills", "/usr/bin/ali-skills"],
     ...pathCandidates
   ];
@@ -29390,6 +29823,409 @@ function createExtensionRequestMessage(id, action, data, trustedInternal = false
   };
 }
 
+// src/host-updater.ts
+import fs10 from "node:fs";
+import path11 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// ../setup/dist/packageManager.js
+import fs9 from "node:fs";
+import path10 from "node:path";
+function normalizePath(filePath) {
+  return filePath.replaceAll("\\", "/").replace(/\/+$/, "");
+}
+function firstExisting(candidates, existsSync4) {
+  return candidates.find((candidate) => existsSync4(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 existsSync4 = 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))
+    ], existsSync4) ?? fallbackCommand("pnpm", platform);
+    return { manager: "pnpm", command, binDirectory: pnpmHome };
+  }
+  const bunMarker = `/.bun/install/global/node_modules/${lowerPackageName}`;
+  if (lowerRoot.endsWith(bunMarker)) {
+    const bunHome = normalizedRoot.slice(0, lowerRoot.indexOf("/.bun/"));
+    const command = firstExisting(executableNames("bun", platform).map((name) => path10.join(bunHome, ".bun", "bin", name)), existsSync4) ?? fallbackCommand("bun", platform);
+    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))
+    ], existsSync4) ?? findExecutable("yarn", { env, existsSync: existsSync4, platform }) ?? fallbackCommand("yarn", platform);
+    return { manager: "yarn", command, binDirectory };
+  }
+  if (lowerRoot.includes("/.volta/tools/image/packages/") && lowerRoot.endsWith(`/lib/node_modules/${lowerPackageName}`)) {
+    const voltaHome = normalizedRoot.slice(0, lowerRoot.indexOf("/.volta/"));
+    const command = firstExisting(executableNames("volta", platform).map((name) => path10.join(voltaHome, ".volta", "bin", name)), existsSync4) ?? fallbackCommand("volta", platform);
+    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))
+    ], existsSync4) ?? 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))
+      ], existsSync4) ?? 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((resolve) => setTimeout(resolve, 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(fileURLToPath(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];
@@ -29456,11 +30292,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;
@@ -29559,7 +30395,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 {
   }
 }
@@ -29571,6 +30407,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() {
@@ -29681,6 +30525,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") {
@@ -29964,7 +30809,7 @@ async function handleSocketLine(socket, line) {
         return result2.cookies ?? [];
       } : (domains) => cdpExportCookies(getCdpSession(), domains);
       const result = await launchManagedBrowser(data, {
-        nativeHostScript: fileURLToPath2(import.meta.url),
+        nativeHostScript: fileURLToPath3(import.meta.url),
         prepareTdbankSso,
         exportCookies,
         log
@@ -30093,7 +30938,7 @@ function onSocketConnection(socket) {
 }
 function isPathAlive(socketPath) {
   return new Promise((resolve) => {
-    if (process.platform !== "win32" && !fs11.existsSync(socketPath)) {
+    if (process.platform !== "win32" && !fs13.existsSync(socketPath)) {
       resolve(false);
       return;
     }
@@ -30116,9 +30961,9 @@ function isPathAlive(socketPath) {
 }
 function listenOn(socketPath) {
   return new Promise((resolve, reject) => {
-    if (process.platform !== "win32" && fs11.existsSync(socketPath)) {
+    if (process.platform !== "win32" && fs13.existsSync(socketPath)) {
       try {
-        fs11.unlinkSync(socketPath);
+        fs13.unlinkSync(socketPath);
       } catch {
       }
     }
@@ -30127,11 +30972,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);
@@ -30167,7 +31012,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 {
     }
   }
@@ -30179,8 +31024,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));
@@ -30207,6 +31052,11 @@ function cleanupAndExit(code) {
   }
   finish();
 }
+function restartAfterUpdate() {
+  const forcedExit = setTimeout(() => process.exit(0), 2e3);
+  forcedExit.unref();
+  cleanupAndExit(0);
+}
 async function main() {
   initBrowserRegistry({ log });
   pruneDeadBrowsers();