@reconcrap/boss-recommend-mcp 2.1.22 → 2.1.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reconcrap/boss-recommend-mcp",
-  "version": "2.1.22",
+  "version": "2.1.23",
   "description": "Unified MCP pipeline for recommend-page filtering and screening on Boss Zhipin",
   "keywords": [
     "boss",
@@ -37,6 +37,7 @@
     "test:recommend-domain": "node src/test-recommend-domain.js",
     "test:recommend-run-service": "node src/test-recommend-run-service.js",
     "test:recommend-mcp": "node src/test-recommend-mcp.js",
+    "test:live-recommend-mcp-smoke": "node src/test-live-recommend-mcp-smoke.js",
     "test:recruit-domain": "node src/test-recruit-domain.js",
     "test:recruit-mcp": "node src/test-recruit-mcp.js",
     "test:chat-domain": "node src/test-chat-domain.js",
@@ -64,10 +65,10 @@
     "live:self-heal": "node scripts/live-self-heal-smoke.js",
     "live:recommend-actions": "node scripts/live-recommend-actions-smoke.js",
     "live:recommend-phase10-full": "node scripts/live-recommend-phase10-full.js",
-    "live:recommend-domain": "node scripts/live-recommend-domain-smoke.js",
-    "live:recommend-run-service": "node scripts/live-recommend-run-service-smoke.js",
-    "live:recommend-mcp": "node scripts/live-recommend-mcp-smoke.js",
-    "live:search-phase10-full": "node scripts/live-search-phase10-full.js",
+    "live:recommend-domain": "node scripts/live-recommend-domain-smoke.js",
+    "live:recommend-run-service": "node scripts/live-recommend-run-service-smoke.js",
+    "live:recommend-mcp": "node scripts/live-recommend-mcp-smoke.js",
+    "live:search-phase10-full": "node scripts/live-search-phase10-full.js",
     "live:recruit-domain": "node scripts/live-recruit-domain-smoke.js",
     "live:recruit-run-service": "node scripts/live-recruit-run-service-smoke.js",
     "live:recruit-mcp": "node scripts/live-recruit-mcp-smoke.js",
@@ -82,9 +83,9 @@
   "files": [
     "bin",
     "config/screening-config.example.json",
-    "skills",
-    "scripts/install-macos.sh",
-    "scripts/postinstall.cjs",
+    "skills",
+    "scripts/install-macos.sh",
+    "scripts/postinstall.cjs",
     "src/core",
     "src/domains",
     "src/chat-mcp.js",

package/src/core/browser/index.js

@@ -1691,14 +1691,34 @@ export function isClosedCdpTransportError(error) {
   return CDP_CLOSED_TRANSPORT_PATTERN.test(String(error?.message || error || ""));
 }
 
-function cloneCdpParams(params = {}) {
-  if (!params || typeof params !== "object" || typeof params === "function") return params;
-  try {
-    return JSON.parse(JSON.stringify(params));
-  } catch {
-    return { ...params };
-  }
-}
+function cloneCdpParams(params = {}) {
+  if (!params || typeof params !== "object" || typeof params === "function") return params;
+  try {
+    return JSON.parse(JSON.stringify(params));
+  } catch {
+    return { ...params };
+  }
+}
+
+function annotateCdpError(error, method, params = {}) {
+  if (!error || (typeof error !== "object" && typeof error !== "function")) return error;
+  if (!error.cdp_method) error.cdp_method = String(method || "");
+  if (!error.cdp_at) error.cdp_at = nowIso();
+  const nodeId = Number(params?.nodeId);
+  const backendNodeId = Number(params?.backendNodeId);
+  const searchId = String(params?.searchId || "").trim();
+  if (Number.isInteger(nodeId) && nodeId > 0 && !error.cdp_node_id) {
+    error.cdp_node_id = nodeId;
+  }
+  if (Number.isInteger(backendNodeId) && backendNodeId > 0 && !error.cdp_backend_node_id) {
+    error.cdp_backend_node_id = backendNodeId;
+  }
+  if (searchId && !error.cdp_search_id) error.cdp_search_id = searchId;
+  if (!Array.isArray(error.cdp_param_keys)) {
+    error.cdp_param_keys = Object.keys(params || {}).sort();
+  }
+  return error;
+}
 
 function shouldReplayCdpSetupCall(domain, method) {
   return method === "enable"
@@ -1745,23 +1765,28 @@ export function createGuardedCdpClient(client, { methodLog = [], reconnect = nul
     return reconnectInFlight;
   }
 
-  async function invokeWithReconnect({
-    methodNameForLog,
-    invoke,
-    retryable = true
-  }) {
+  async function invokeWithReconnect({
+    methodNameForLog,
+    invoke,
+    params = {},
+    retryable = true
+  }) {
     recordMethod(methodLog, methodNameForLog);
     try {
       return await invoke(currentClient);
-    } catch (error) {
-      if (!retryable || !isClosedCdpTransportError(error) || typeof reconnect !== "function") {
-        throw error;
-      }
-      await reconnectClient();
-      recordMethod(methodLog, `${methodNameForLog}:retry_after_reconnect`);
-      return invoke(currentClient);
-    }
-  }
+    } catch (error) {
+      if (!retryable || !isClosedCdpTransportError(error) || typeof reconnect !== "function") {
+        throw annotateCdpError(error, methodNameForLog, params);
+      }
+      await reconnectClient();
+      recordMethod(methodLog, `${methodNameForLog}:retry_after_reconnect`);
+      try {
+        return await invoke(currentClient);
+      } catch (retryError) {
+        throw annotateCdpError(retryError, methodNameForLog, params);
+      }
+    }
+  }
 
   return new Proxy({}, {
     get(_target, property, receiver) {
@@ -1770,10 +1795,11 @@ export function createGuardedCdpClient(client, { methodLog = [], reconnect = nul
           if (isForbiddenMethod(method)) {
             throw new Error(`Forbidden CDP method blocked: ${method}`);
           }
-          return invokeWithReconnect({
-            methodNameForLog: method,
-            invoke: (activeClient) => activeClient.send(method, params)
-          });
+          return invokeWithReconnect({
+            methodNameForLog: method,
+            params,
+            invoke: (activeClient) => activeClient.send(method, params)
+          });
         };
       }
 
@@ -1813,9 +1839,10 @@ export function createGuardedCdpClient(client, { methodLog = [], reconnect = nul
                 params: cloneCdpParams(params)
               });
             }
-            return invokeWithReconnect({
-              methodNameForLog: fullMethod,
-              invoke: (activeClient) => {
+            return invokeWithReconnect({
+              methodNameForLog: fullMethod,
+              params,
+              invoke: (activeClient) => {
                 const activeDomain = activeClient?.[property];
                 const activeMethod = activeDomain?.[method];
                 if (typeof activeMethod !== "function") {

package/src/core/infinite-list/index.js

@@ -889,12 +889,13 @@ export async function detectInfiniteListBottomMarker(client, {
   };
 }
 
-export async function readVisibleInfiniteListItems({
-  nodeIds = [],
-  readCandidate,
-  keyForCandidate = candidateKeyFromProfile,
-  state = null
-} = {}) {
+export async function readVisibleInfiniteListItems({
+  nodeIds = [],
+  readCandidate,
+  keyForCandidate = candidateKeyFromProfile,
+  state = null,
+  shouldRethrowReadError = null
+} = {}) {
   if (typeof readCandidate !== "function") {
     throw new Error("readVisibleInfiniteListItems requires readCandidate");
   }
@@ -904,19 +905,25 @@ export async function readVisibleInfiniteListItems({
     let candidate;
     try {
       candidate = await readCandidate(nodeId, { visibleIndex });
-    } catch (error) {
-      if (state) {
-        state.read_error_count = (state.read_error_count || 0) + 1;
+    } catch (error) {
+      if (state) {
+        state.read_error_count = (state.read_error_count || 0) + 1;
         state.ledger?.push({
           at: nowIso(),
           event: "candidate_read_error",
           node_id: nodeId,
           visible_index: visibleIndex,
-          error: error?.message || String(error)
-        });
-      }
-      continue;
-    }
+          error: error?.message || String(error)
+        });
+      }
+      if (
+        typeof shouldRethrowReadError === "function"
+        && shouldRethrowReadError(error, { nodeId, visibleIndex })
+      ) {
+        throw error;
+      }
+      continue;
+    }
     const key = keyForCandidate(candidate, {
       nodeId,
       visibleIndex,
@@ -1132,8 +1139,9 @@ export async function getNextInfiniteListCandidate({
   state,
   findNodeIds,
   readCandidate,
-  detectBottomMarker = null,
-  keyForCandidate = candidateKeyFromProfile,
+  detectBottomMarker = null,
+  keyForCandidate = candidateKeyFromProfile,
+  shouldRethrowReadError = null,
   maxScrolls = 20,
   stableSignatureLimit = 2,
   minScrollsBeforeEnd = 3,
@@ -1156,12 +1164,13 @@ export async function getNextInfiniteListCandidate({
   const maxAttempts = Math.max(0, Number(maxScrolls) || 0);
   for (let scrollAttempt = 0; scrollAttempt <= maxAttempts; scrollAttempt += 1) {
     const nodeIds = await findNodeIds();
-    const items = await readVisibleInfiniteListItems({
-      nodeIds,
-      readCandidate,
-      keyForCandidate,
-      state
-    });
+    const items = await readVisibleInfiniteListItems({
+      nodeIds,
+      readCandidate,
+      keyForCandidate,
+      state,
+      shouldRethrowReadError
+    });
     const signature = updateInfiniteListVisibleSignature(state, items);
     const next = firstUnseenInfiniteListItem(state, items);
     attempts.push({

package/src/core/run/index.js

@@ -32,15 +32,32 @@ function clone(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
-function errorDiagnostic(error) {
+function errorDiagnostic(error) {
   if (!error) return null;
   const diagnostic = {
     name: error?.name || "Error",
     message: error?.message || String(error)
-  };
-  if (error?.code) diagnostic.code = error.code;
-  return diagnostic;
-}
+  };
+  if (error?.code) diagnostic.code = error.code;
+  if (error?.cdp_method) diagnostic.cdp_method = error.cdp_method;
+  if (error?.cdp_at) diagnostic.cdp_at = error.cdp_at;
+  if (Number.isInteger(error?.cdp_node_id)) diagnostic.cdp_node_id = error.cdp_node_id;
+  if (Number.isInteger(error?.cdp_backend_node_id)) diagnostic.cdp_backend_node_id = error.cdp_backend_node_id;
+  if (error?.cdp_search_id) diagnostic.cdp_search_id = error.cdp_search_id;
+  if (Array.isArray(error?.cdp_param_keys)) diagnostic.cdp_param_keys = error.cdp_param_keys.slice(0, 20);
+  if (error?.stack) diagnostic.stack = String(error.stack).split(/\r?\n/).slice(0, 12).join("\n");
+  if (error?.cause && error.cause !== error) {
+    diagnostic.cause = {
+      name: error.cause?.name || "Error",
+      message: error.cause?.message || String(error.cause),
+      code: error.cause?.code || undefined,
+      cdp_method: error.cause?.cdp_method || undefined,
+      cdp_at: error.cause?.cdp_at || undefined,
+      cdp_node_id: Number.isInteger(error.cause?.cdp_node_id) ? error.cause.cdp_node_id : undefined
+    };
+  }
+  return diagnostic;
+}
 
 function createDeferred() {
   let resolve;

package/src/domains/recommend/detail.js

@@ -387,10 +387,19 @@ export async function readRecommendDetailHtml(client, detailState) {
   };
 }
 
-export function isStaleRecommendNodeError(error) {
-  const message = String(error?.message || error || "");
-  return /Could not find node with given id|No node with given id|Node is detached|Cannot find node|Could not compute box model/i.test(message);
-}
+export function isStaleRecommendNodeError(error) {
+  const pattern = /Could not find node with given id|No node with given id|Node is detached|Cannot find node|Could not compute box model/i;
+  const seen = new Set();
+  let current = error;
+  for (let depth = 0; current && depth < 5; depth += 1) {
+    if ((typeof current === "object" || typeof current === "function") && seen.has(current)) break;
+    if (typeof current === "object" || typeof current === "function") seen.add(current);
+    const message = String(current?.message || current || "");
+    if (pattern.test(message)) return true;
+    current = current?.cause || null;
+  }
+  return false;
+}
 
 export function isRecommendDetailOpenMissError(error) {
   const message = String(error?.message || error || "");

package/src/domains/recommend/refresh.js

@@ -136,12 +136,88 @@ export async function applyRecommendFilterEnvelopeStages(filter = {}, {
 
 function refreshFailureReason(method = "") {
   return method === "page_navigate" ? "page_navigate_failed" : "page_reload_failed";
-}
-
-export function isRetryableRecommendFilterReapplyError(error) {
-  const message = String(error?.message || error || "");
-  return /Recommend filter panel did not open|Recommend filter trigger was not found|Recommend filter confirm button was not found|No matching recommend filter option/i.test(message);
-}
+}
+
+function safeDiagnosticText(value, maxLength = 4000) {
+  const text = String(value ?? "");
+  return text.length > maxLength ? `${text.slice(0, maxLength)}…` : text;
+}
+
+function safeDiagnosticStack(stack) {
+  if (!stack) return null;
+  return safeDiagnosticText(stack, 8000)
+    .split(/\r?\n/)
+    .slice(0, 12)
+    .join("\n");
+}
+
+function buildErrorDiagnostic(error, {
+  depth = 0,
+  seen = new Set()
+} = {}) {
+  if (!error) return null;
+  const isRecord = typeof error === "object" || typeof error === "function";
+  if (isRecord && seen.has(error)) {
+    return {
+      name: error?.name || "Error",
+      message: safeDiagnosticText(error?.message || String(error)),
+      circular: true
+    };
+  }
+  if (isRecord) seen.add(error);
+  const diagnostic = {
+    name: error?.name || "Error",
+    message: safeDiagnosticText(error?.message || String(error))
+  };
+  if (error?.code !== undefined && error?.code !== null && error.code !== "") {
+    diagnostic.code = typeof error.code === "number"
+      ? error.code
+      : safeDiagnosticText(error.code, 300);
+  }
+  if (error?.phase) diagnostic.phase = safeDiagnosticText(error.phase, 300);
+  if (error?.cdp_method) diagnostic.cdp_method = safeDiagnosticText(error.cdp_method, 300);
+  if (error?.cdp_at) diagnostic.cdp_at = safeDiagnosticText(error.cdp_at, 100);
+  if (Number.isInteger(error?.cdp_node_id)) diagnostic.cdp_node_id = error.cdp_node_id;
+  if (Number.isInteger(error?.cdp_backend_node_id)) {
+    diagnostic.cdp_backend_node_id = error.cdp_backend_node_id;
+  }
+  if (Number.isInteger(error?.node_id)) diagnostic.node_id = error.node_id;
+  if (Number.isInteger(error?.backend_node_id)) diagnostic.backend_node_id = error.backend_node_id;
+  if (error?.cdp_search_id) diagnostic.cdp_search_id = safeDiagnosticText(error.cdp_search_id, 300);
+  if (Array.isArray(error?.cdp_param_keys)) {
+    diagnostic.cdp_param_keys = error.cdp_param_keys
+      .slice(0, 20)
+      .map((key) => safeDiagnosticText(key, 100));
+  }
+  const stack = safeDiagnosticStack(error?.stack);
+  if (stack) diagnostic.stack = stack;
+  if (depth < 2 && error?.cause && error.cause !== error) {
+    diagnostic.cause = buildErrorDiagnostic(error.cause, {
+      depth: depth + 1,
+      seen
+    });
+  }
+  return diagnostic;
+}
+
+export function compactRecommendRefreshErrorDiagnostic(error) {
+  return buildErrorDiagnostic(error);
+}
+
+export function isRetryableRecommendFilterReapplyError(error) {
+  const messages = [];
+  const seen = new Set();
+  let current = error;
+  for (let depth = 0; current && depth < 4; depth += 1) {
+    if ((typeof current === "object" || typeof current === "function") && seen.has(current)) break;
+    if (typeof current === "object" || typeof current === "function") seen.add(current);
+    if (isStaleRecommendNodeError(current)) return true;
+    messages.push(String(current?.message || current || ""));
+    current = current?.cause;
+  }
+  const message = messages.join("\n");
+  return /Recommend filter panel did not open|Recommend filter trigger was not found|Recommend filter confirm button was not found|No matching recommend filter option|Invalid (?:backend )?node(?:\s*id)?|Node with given id does not exist|No node found for given backend id/i.test(message);
+}
 
 function compactFilterReapplyError(error) {
   return error?.message || String(error || "Recommend filter reapply failed");
@@ -163,9 +239,10 @@ function compactJobSelectionAttempt({
   return {
     ok: Boolean(ok),
     method: "job_select",
-    reason: error ? "job_select_failed" : null,
-    error: error ? (error?.message || String(error)) : null,
-    attempt,
+    reason: error ? "job_select_failed" : null,
+    error: error ? (error?.message || String(error)) : null,
+    error_diagnostic: error ? compactRecommendRefreshErrorDiagnostic(error) : null,
+    attempt,
     iframe_document_node_id: iframeDocumentNodeId || 0,
     selected: Boolean(selection?.selected),
     selection_reason: selection?.reason || null,
@@ -324,9 +401,10 @@ async function selectAndConfirmRefreshFilter(client, rootState, filterOptions, {
       attempts.push({
         ok: false,
         method: "filter_reapply",
-        reason: "filter_reapply_failed",
-        error: compactFilterReapplyError(error),
-        attempt
+        reason: "filter_reapply_failed",
+        error: compactFilterReapplyError(error),
+        error_diagnostic: compactRecommendRefreshErrorDiagnostic(error),
+        attempt
       });
       if (attempt >= maxAttempts || !isRetryableRecommendFilterReapplyError(error)) {
         break;
@@ -387,6 +465,7 @@ async function ensureRefreshCurrentCityOnly(client, rootState, {
         method: "current_city_only_reapply",
         reason: "current_city_only_reapply_failed",
         error: compactCurrentCityOnlyReapplyError(error),
+        error_diagnostic: compactRecommendRefreshErrorDiagnostic(error),
         attempt
       });
       if (attempt >= maxAttempts || !isRetryableRecommendCurrentCityOnlyReapplyError(error)) {
@@ -525,8 +604,9 @@ async function applyRefreshMethod(client, method, {
     return {
       ok: false,
       method,
-      reason: refreshFailureReason(method),
-      error: error?.message || String(error),
+      reason: refreshFailureReason(method),
+      error: error?.message || String(error),
+      error_diagnostic: compactRecommendRefreshErrorDiagnostic(error),
       target_url: method === "page_navigate" ? (targetUrl || RECOMMEND_TARGET_URL) : null,
       job_selection: jobSelection,
       job_selection_attempts: error?.job_selection_attempts || jobSelectionAttempts,
@@ -639,6 +719,7 @@ export async function refreshRecommendListAtEnd(client, {
           method: "end_refresh_button_after_click",
           reason: "end_refresh_reapply_failed",
           error: error?.message || String(error),
+          error_diagnostic: compactRecommendRefreshErrorDiagnostic(error),
           page_scope: pageScopeResult,
           current_city_only: currentCityOnlyResult,
           current_city_only_attempts: error?.current_city_only_attempts || currentCityOnlyAttempts,