@mearl/native-host 2.2.2 → 2.3.0

package/dist/index.js

@@ -325,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;
@@ -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;
@@ -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
@@ -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();
@@ -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");
@@ -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.3.0" : "unknown";
 
 // src/analytics.ts
 var MEASUREMENT_ID = "G-W84LJDZ6PH";
@@ -10294,13 +10613,13 @@ 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";
@@ -10317,6 +10636,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 {
@@ -10344,6 +10684,46 @@ function prependPath(directory, env) {
 }
 
 // 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 +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);
@@ -10938,18 +11333,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());
   }
 };
 
@@ -28303,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 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 +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 {
@@ -29112,19 +29515,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 +29533,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 +29554,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
   ];