@reconcrap/boss-recommend-mcp 2.0.5 → 2.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reconcrap/boss-recommend-mcp",
-  "version": "2.0.5",
+  "version": "2.0.6",
   "description": "Unified MCP pipeline for recommend-page filtering and screening on Boss Zhipin",
   "keywords": [
     "boss",

package/src/domains/recommend/detail.js

@@ -8,6 +8,7 @@ import {
   querySelectorAll,
   sleep
 } from "../../core/browser/index.js";
+import { candidateKeyFromProfile } from "../../core/infinite-list/index.js";
 import {
   buildScreeningCandidateFromDetail,
   htmlToText
@@ -22,6 +23,10 @@ import {
   getRecommendRoots,
   queryFirstAcrossRoots
 } from "./roots.js";
+import {
+  findRecommendCardNodeIds,
+  readRecommendCardCandidate
+} from "./cards.js";
 
 export function matchesRecommendDetailNetwork(url) {
   return DETAIL_NETWORK_PATTERNS.some((pattern) => pattern.test(String(url || "")));
@@ -146,14 +151,36 @@ export async function readRecommendDetailHtml(client, detailState) {
   let popupHTML = "";
   let resumeHTML = "";
   let resumeIframeDocumentNodeId = null;
+  const errors = [];
 
   if (detailState?.popup?.node_id) {
-    popupHTML = await getOuterHTML(client, detailState.popup.node_id);
+    try {
+      popupHTML = await getOuterHTML(client, detailState.popup.node_id);
+    } catch (error) {
+      errors.push({
+        source: "popup",
+        node_id: detailState.popup.node_id,
+        stale_node: isStaleRecommendNodeError(error),
+        error: error?.message || String(error)
+      });
+    }
   }
 
   if (detailState?.resumeIframe?.node_id) {
-    resumeIframeDocumentNodeId = await getFrameDocumentNodeId(client, detailState.resumeIframe.node_id);
-    resumeHTML = await getOuterHTML(client, resumeIframeDocumentNodeId);
+    try {
+      resumeIframeDocumentNodeId = await getFrameDocumentNodeId(client, detailState.resumeIframe.node_id);
+      resumeHTML = await getOuterHTML(client, resumeIframeDocumentNodeId);
+    } catch (error) {
+      errors.push({
+        source: "resume_iframe",
+        node_id: detailState.resumeIframe.node_id,
+        document_node_id: resumeIframeDocumentNodeId,
+        stale_node: isStaleRecommendNodeError(error),
+        error: error?.message || String(error)
+      });
+      resumeIframeDocumentNodeId = null;
+      resumeHTML = "";
+    }
   }
 
   return {
@@ -161,7 +188,90 @@ export async function readRecommendDetailHtml(client, detailState) {
     resumeHTML,
     resumeIframeDocumentNodeId,
     popupText: htmlToText(popupHTML),
-    resumeText: htmlToText(resumeHTML)
+    resumeText: htmlToText(resumeHTML),
+    errors
+  };
+}
+
+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/i.test(message);
+}
+
+export async function findRecommendCardNodeForCandidateKey(client, {
+  candidateKey = "",
+  rootState = null,
+  targetUrl = "",
+  source = "recommend-run-card-retry",
+  timeoutMs = 5000,
+  intervalMs = 250
+} = {}) {
+  if (!candidateKey) {
+    return {
+      ok: false,
+      reason: "candidate_key_required"
+    };
+  }
+
+  const started = Date.now();
+  let lastError = null;
+  let lastCardCount = 0;
+  while (Date.now() - started <= timeoutMs) {
+    const currentRootState = rootState?.iframe?.documentNodeId
+      ? rootState
+      : await getRecommendRoots(client);
+    const frameNodeId = currentRootState?.iframe?.documentNodeId;
+    if (!frameNodeId) {
+      return {
+        ok: false,
+        reason: "recommend_frame_not_found"
+      };
+    }
+
+    const nodeIds = await findRecommendCardNodeIds(client, frameNodeId);
+    lastCardCount = nodeIds.length;
+    for (let visibleIndex = 0; visibleIndex < nodeIds.length; visibleIndex += 1) {
+      const nodeId = nodeIds[visibleIndex];
+      try {
+        const candidate = await readRecommendCardCandidate(client, nodeId, {
+          targetUrl,
+          source,
+          metadata: {
+            visible_index: visibleIndex,
+            retry_reason: "stale_detail_node"
+          }
+        });
+        const key = candidateKeyFromProfile(candidate, {
+          nodeId,
+          visibleIndex,
+          attributes: candidate?.attributes || candidate?.metadata?.attributes || {}
+        });
+        if (key === candidateKey) {
+          return {
+            ok: true,
+            node_id: nodeId,
+            visible_index: visibleIndex,
+            candidate,
+            key,
+            root_state: currentRootState,
+            card_count: nodeIds.length
+          };
+        }
+      } catch (error) {
+        lastError = error;
+      }
+    }
+
+    if (intervalMs > 0) await sleep(intervalMs);
+    rootState = null;
+  }
+
+  return {
+    ok: false,
+    reason: "candidate_key_not_mounted",
+    candidate_key: candidateKey,
+    last_card_count: lastCardCount,
+    error: lastError?.message || null
   };
 }
 
@@ -181,6 +291,77 @@ export async function openRecommendCardDetail(client, cardNodeId, {
   };
 }
 
+export async function openRecommendCardDetailWithFreshRetry(client, {
+  cardNodeId,
+  candidateKey = "",
+  cardCandidate = null,
+  rootState = null,
+  targetUrl = "",
+  timeoutMs = 12000,
+  scrollIntoView = true,
+  retryTimeoutMs = 5000,
+  retryIntervalMs = 250,
+  maxAttempts = 2
+} = {}) {
+  let currentNodeId = cardNodeId;
+  let currentCandidate = cardCandidate;
+  let currentRootState = rootState;
+  const attempts = [];
+  const limit = Math.max(1, Number(maxAttempts) || 1);
+
+  for (let attemptIndex = 0; attemptIndex < limit; attemptIndex += 1) {
+    try {
+      const opened = await openRecommendCardDetail(client, currentNodeId, {
+        timeoutMs,
+        scrollIntoView
+      });
+      return {
+        ...opened,
+        card_node_id: currentNodeId,
+        card_candidate: currentCandidate,
+        retry_attempts: attempts
+      };
+    } catch (error) {
+      const stale = isStaleRecommendNodeError(error);
+      attempts.push({
+        attempt: attemptIndex + 1,
+        node_id: currentNodeId,
+        stale_node: stale,
+        error: error?.message || String(error)
+      });
+      if (!stale || attemptIndex >= limit - 1 || !candidateKey) {
+        error.recommend_detail_open_attempts = attempts;
+        throw error;
+      }
+
+      const resolved = await findRecommendCardNodeForCandidateKey(client, {
+        candidateKey,
+        rootState: currentRootState,
+        targetUrl,
+        timeoutMs: retryTimeoutMs,
+        intervalMs: retryIntervalMs
+      });
+      attempts[attempts.length - 1].refresh_lookup = {
+        ok: Boolean(resolved.ok),
+        node_id: resolved.node_id || null,
+        visible_index: resolved.visible_index ?? null,
+        card_count: resolved.card_count || resolved.last_card_count || 0,
+        reason: resolved.reason || null,
+        error: resolved.error || null
+      };
+      if (!resolved.ok || !resolved.node_id) {
+        error.recommend_detail_open_attempts = attempts;
+        throw error;
+      }
+      currentNodeId = resolved.node_id;
+      currentCandidate = resolved.candidate || currentCandidate;
+      currentRootState = resolved.root_state || null;
+    }
+  }
+
+  throw new Error("Recommend detail retry exhausted");
+}
+
 export async function closeRecommendDetail(client, {
   attemptsLimit = 3
 } = {}) {
@@ -317,7 +498,8 @@ export async function extractRecommendDetailCandidate(client, {
       detail_popup_root: detailState?.popup?.root || null,
       resume_iframe_selector: detailState?.resumeIframe?.selector || null,
       resume_iframe_root: detailState?.resumeIframe?.root || null,
-      resume_iframe_document_node_id: detailHtml.resumeIframeDocumentNodeId
+      resume_iframe_document_node_id: detailHtml.resumeIframeDocumentNodeId,
+      detail_html_errors: detailHtml.errors || []
     }
   });
 
@@ -334,7 +516,8 @@ export async function extractRecommendDetailCandidate(client, {
       popup_text: detailHtml.popupText,
       resume_text: detailHtml.resumeText,
       popup_html_length: detailHtml.popupHTML.length,
-      resume_html_length: detailHtml.resumeHTML.length
+      resume_html_length: detailHtml.resumeHTML.length,
+      html_errors: detailHtml.errors || []
     },
     close_result: closeResult
   };

package/src/domains/recommend/run-service.js

@@ -26,7 +26,7 @@ import {
   closeRecommendDetail,
   createRecommendDetailNetworkRecorder,
   extractRecommendDetailCandidate,
-  openRecommendCardDetail,
+  openRecommendCardDetailWithFreshRetry,
   waitForRecommendDetailNetworkEvents
 } from "./detail.js";
 import {
@@ -596,9 +596,9 @@ export async function runRecommendWorkflow({
     }
 
     const index = results.length;
-    const cardNodeId = nextCandidateResult.item.node_id;
+    let cardNodeId = nextCandidateResult.item.node_id;
     const candidateKey = nextCandidateResult.item.key;
-    const cardCandidate = nextCandidateResult.item.candidate;
+    let cardCandidate = nextCandidateResult.item.candidate;
 
     let screeningCandidate = cardCandidate;
     let detailResult = null;
@@ -608,7 +608,17 @@ export async function runRecommendWorkflow({
       runControl.setPhase("recommend:detail");
       rootState = await ensureRecommendViewport(rootState, "detail");
       networkRecorder.clear();
-      const openedDetail = await openRecommendCardDetail(client, cardNodeId);
+      const openedDetail = await openRecommendCardDetailWithFreshRetry(client, {
+        cardNodeId,
+        candidateKey,
+        cardCandidate,
+        rootState,
+        targetUrl,
+        maxAttempts: 2
+      });
+      cardNodeId = openedDetail.card_node_id || cardNodeId;
+      cardCandidate = openedDetail.card_candidate || cardCandidate;
+      screeningCandidate = cardCandidate;
       const waitPlan = getCvNetworkWaitPlan(cvAcquisitionState);
       const networkWait = await waitForCvNetworkEvents(
         waitForRecommendDetailNetworkEvents,