@reconcrap/boss-recommend-mcp 2.0.4 → 2.0.6

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

@@ -22,6 +22,7 @@ import {
   getNextInfiniteListCandidate,
   markInfiniteListCandidateProcessed
 } from "../../core/infinite-list/index.js";
+import { createViewportRunGuard } from "../../core/self-heal/index.js";
 import { createRunLifecycleManager } from "../../core/run/index.js";
 import {
   callScreeningLlm,
@@ -250,9 +251,13 @@ async function setupChatRunContext(client, {
   normalizedStartFrom,
   readyTimeoutMs,
   listSettleMs,
-  runControl
+  runControl,
+  ensureViewport = null
 } = {}) {
-  const rootState = await getChatRoots(client);
+  let rootState = await getChatRoots(client);
+  if (ensureViewport) {
+    rootState = await ensureViewport(rootState, "context_roots");
+  }
   runControl.checkpoint({
     top_document_node_id: rootState.rootNodes.top
   });
@@ -280,6 +285,10 @@ async function setupChatRunContext(client, {
   if (normalizeText(job) && !jobSelection.selected) {
     throw new Error(`Chat job selection failed: ${jobSelection.reason || "unknown"}`);
   }
+  rootState = await getChatRoots(client);
+  if (ensureViewport) {
+    rootState = await ensureViewport(rootState, "context_job");
+  }
   runControl.checkpoint({
     chat_context_step: "job_selection",
     primary_label: primaryLabel,
@@ -294,6 +303,10 @@ async function setupChatRunContext(client, {
   if (!startFilter.ok) {
     throw new Error(`Chat start filter selection failed: ${startFilter.error || "unknown"}`);
   }
+  rootState = await getChatRoots(client);
+  if (ensureViewport) {
+    rootState = await ensureViewport(rootState, "context_start_filter");
+  }
   runControl.checkpoint({
     chat_context_step: "start_filter",
     primary_label: primaryLabel,
@@ -362,6 +375,18 @@ export async function runChatWorkflow({
     domain: "chat",
     listName: "chat-candidates"
   });
+  const viewportGuard = createViewportRunGuard({
+    client,
+    domain: "chat",
+    root: "top",
+    frameOwnerRoot: "top",
+    runControl,
+    getRoots: getChatRoots
+  });
+  async function ensureChatViewport(rootState, phase) {
+    const result = await viewportGuard.ensure(rootState, { phase });
+    return result.rootState || rootState;
+  }
   const results = [];
   let cardNodeIds = [];
   let listEndReason = "";
@@ -398,7 +423,8 @@ export async function runChatWorkflow({
     normalizedStartFrom,
     readyTimeoutMs,
     listSettleMs,
-    runControl
+    runControl,
+    ensureViewport: ensureChatViewport
   });
   let rootState = setup.rootState;
   contextSetup = {
@@ -431,7 +457,8 @@ export async function runChatWorkflow({
       normalizedStartFrom,
       readyTimeoutMs,
       listSettleMs,
-      runControl
+      runControl,
+      ensureViewport: ensureChatViewport
     });
     rootState = recoveredSetup.rootState;
     contextSetup = {
@@ -449,7 +476,7 @@ export async function runChatWorkflow({
   await runControl.waitIfPaused();
   runControl.throwIfCanceled();
   runControl.setPhase("chat:cards");
-  const cardRootState = await getChatRoots(client);
+  const cardRootState = await ensureChatViewport(await getChatRoots(client), "cards");
   const initialCards = await waitForChatCandidateNodeIds(client, cardRootState.rootNodes.top, {
     timeoutMs: cardTimeoutMs,
     intervalMs: 500
@@ -479,7 +506,9 @@ export async function runChatWorkflow({
       request_skipped: 0,
       unique_seen: compactInfiniteListState(listState).seen_count,
       scroll_count: compactInfiniteListState(listState).scroll_count,
-      list_end_reason: listEndReason
+      list_end_reason: listEndReason,
+      viewport_checks: viewportGuard.getStats().checks,
+      viewport_recoveries: viewportGuard.getStats().recoveries
     });
     runControl.setPhase("chat:done");
     return {
@@ -493,6 +522,10 @@ export async function runChatWorkflow({
         requested_start_from: normalizedStartFrom
       },
       candidate_list: compactInfiniteListState(listState),
+      viewport_health: {
+        stats: viewportGuard.getStats(),
+        events: viewportGuard.getEvents()
+      },
       list_end_reason: listEndReason,
       target_pass_count: passTarget,
       process_until_list_end: Boolean(processUntilListEnd),
@@ -524,7 +557,9 @@ export async function runChatWorkflow({
     request_satisfied: 0,
     request_skipped: 0,
     unique_seen: compactInfiniteListState(listState).seen_count,
-    scroll_count: 0
+    scroll_count: 0,
+    viewport_checks: viewportGuard.getStats().checks,
+    viewport_recoveries: viewportGuard.getStats().recoveries
   });
 
   while (
@@ -537,6 +572,7 @@ export async function runChatWorkflow({
     await runControl.waitIfPaused();
     runControl.throwIfCanceled();
     runControl.setPhase("chat:candidate");
+    rootState = await ensureChatViewport(rootState, "candidate_loop");
     const loopTopLevelState = await getChatTopLevelState(client);
     if (!loopTopLevelState.is_chat_shell) {
       await recoverAndReapplyChatContext("candidate_loop_non_chat_shell", {
@@ -554,7 +590,8 @@ export async function runChatWorkflow({
       settleMs: listSettleMs,
       fallbackPoint: listFallbackPoint,
       findNodeIds: async () => {
-        const currentRootState = await getChatRoots(client);
+        const currentRootState = await ensureChatViewport(await getChatRoots(client), "candidate_find_nodes");
+        rootState = currentRootState;
         const currentCards = await waitForChatCandidateNodeIds(client, currentRootState.rootNodes.top, {
           timeoutMs: Math.min(cardTimeoutMs, 8000),
           intervalMs: 500
@@ -609,6 +646,7 @@ export async function runChatWorkflow({
         await runControl.waitIfPaused();
         runControl.throwIfCanceled();
         runControl.setPhase("chat:detail");
+        rootState = await ensureChatViewport(rootState, "detail");
 
         detailStep = "select_candidate";
         networkRecorder.clear();
@@ -921,6 +959,8 @@ export async function runChatWorkflow({
       unique_seen: compactInfiniteListState(listState).seen_count,
       scroll_count: compactInfiniteListState(listState).scroll_count,
       list_end_reason: listEndReason || null,
+      viewport_checks: viewportGuard.getStats().checks,
+      viewport_recoveries: viewportGuard.getStats().recoveries,
       last_candidate_id: screeningCandidate.id || null,
       last_candidate_key: candidateKey,
       last_score: screening.score
@@ -950,6 +990,10 @@ export async function runChatWorkflow({
     card_count: cardNodeIds.length,
     context_setup: contextSetup,
     candidate_list: compactInfiniteListState(listState),
+    viewport_health: {
+      stats: viewportGuard.getStats(),
+      events: viewportGuard.getEvents()
+    },
     list_end_reason: listEndReason || null,
     target_pass_count: passTarget,
     process_until_list_end: Boolean(processUntilListEnd),

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/roots.js

@@ -25,7 +25,8 @@ export async function getRecommendRoots(client, {
     ].filter(Boolean),
     rootNodes: {
       top: topRoot.nodeId,
-      frame: iframe?.documentNodeId || 0
+      frame: iframe?.documentNodeId || 0,
+      frameOwner: iframe?.nodeId || 0
     }
   };
 }
@@ -49,7 +50,8 @@ export async function waitForRecommendRoots(client, {
         roots: [],
         rootNodes: {
           top: 0,
-          frame: 0
+          frame: 0,
+          frameOwner: 0
         }
       };
     }

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

@@ -20,12 +20,13 @@ import {
   markInfiniteListCandidateProcessed,
   resetInfiniteListForRefreshRound
 } from "../../core/infinite-list/index.js";
+import { createViewportRunGuard } from "../../core/self-heal/index.js";
 import { screenCandidate } from "../../core/screening/index.js";
 import {
   closeRecommendDetail,
   createRecommendDetailNetworkRecorder,
   extractRecommendDetailCandidate,
-  openRecommendCardDetail,
+  openRecommendCardDetailWithFreshRetry,
   waitForRecommendDetailNetworkEvents
 } from "./detail.js";
 import {
@@ -372,6 +373,18 @@ export async function runRecommendWorkflow({
     domain: "recommend",
     listName: "recommend-candidates"
   });
+  const viewportGuard = createViewportRunGuard({
+    client,
+    domain: "recommend",
+    root: "frame",
+    frameOwnerRoot: "frameOwner",
+    runControl,
+    getRoots: getRecommendRoots
+  });
+  async function ensureRecommendViewport(rootState, phase) {
+    const result = await viewportGuard.ensure(rootState, { phase });
+    return result.rootState || rootState;
+  }
   const results = [];
   const refreshAttempts = [];
   let refreshRounds = 0;
@@ -389,6 +402,7 @@ export async function runRecommendWorkflow({
   runControl.throwIfCanceled();
   runControl.setPhase("recommend:roots");
   let rootState = await getRecommendRoots(client);
+  rootState = await ensureRecommendViewport(rootState, "roots");
   runControl.checkpoint({
     iframe_selector: rootState.iframe.selector,
     iframe_document_node_id: rootState.iframe.documentNodeId
@@ -406,6 +420,7 @@ export async function runRecommendWorkflow({
       throw new Error(`Requested recommend job was not selected: ${jobSelection.reason}`);
     }
     rootState = await getRecommendRoots(client);
+    rootState = await ensureRecommendViewport(rootState, "job");
     runControl.checkpoint({
       job_selection: compactJobSelection(jobSelection)
     });
@@ -424,6 +439,7 @@ export async function runRecommendWorkflow({
     throw new Error(`Recommend page scope was not selected: ${pageScopeSelection.reason || pageScopeSelection.effective_scope || requestedPageScope}`);
   }
   rootState = await getRecommendRoots(client);
+  rootState = await ensureRecommendViewport(rootState, "page_scope");
   runControl.checkpoint({
     page_scope: compactPageScopeSelection(pageScopeSelection)
   });
@@ -440,6 +456,8 @@ export async function runRecommendWorkflow({
     if (!filterResult.confirmed) {
       throw new Error("Recommend run filter selection was not confirmed");
     }
+    rootState = await getRecommendRoots(client);
+    rootState = await ensureRecommendViewport(rootState, "filter");
     runControl.checkpoint({
       filter: compactFilterResult(filterResult)
     });
@@ -448,6 +466,7 @@ export async function runRecommendWorkflow({
   await runControl.waitIfPaused();
   runControl.throwIfCanceled();
   runControl.setPhase("recommend:cards");
+  rootState = await ensureRecommendViewport(rootState, "cards");
   cardNodeIds = await waitForRecommendCardNodeIds(client, rootState.iframe.documentNodeId, {
     timeoutMs: cardTimeoutMs,
     intervalMs: 300
@@ -468,13 +487,16 @@ export async function runRecommendWorkflow({
     unique_seen: compactInfiniteListState(listState).seen_count,
     scroll_count: 0,
     refresh_rounds: 0,
-    refresh_attempts: 0
+    refresh_attempts: 0,
+    viewport_checks: viewportGuard.getStats().checks,
+    viewport_recoveries: viewportGuard.getStats().recoveries
   });
 
   while (results.length < limit) {
     await runControl.waitIfPaused();
     runControl.throwIfCanceled();
     runControl.setPhase("recommend:candidate");
+    rootState = await ensureRecommendViewport(rootState, "candidate_loop");
 
     const nextCandidateResult = await getNextInfiniteListCandidate({
       client,
@@ -485,7 +507,9 @@ export async function runRecommendWorkflow({
       settleMs: listSettleMs,
       fallbackPoint: listFallbackPoint,
       findNodeIds: async () => {
-        const currentRootState = await getRecommendRoots(client);
+        let currentRootState = await getRecommendRoots(client);
+        currentRootState = await ensureRecommendViewport(currentRootState, "candidate_find_nodes");
+        rootState = currentRootState;
         const currentCardNodeIds = await waitForRecommendCardNodeIds(client, currentRootState.iframe.documentNodeId, {
           timeoutMs: Math.min(cardTimeoutMs, 5000),
           intervalMs: 300
@@ -544,10 +568,13 @@ export async function runRecommendWorkflow({
           refresh_attempts: refreshAttempts.length,
           refresh_method: refreshResult.method || null,
           refresh_forced_recent_not_view: true,
-          list_end_reason: listEndReason
+          list_end_reason: listEndReason,
+          viewport_checks: viewportGuard.getStats().checks,
+          viewport_recoveries: viewportGuard.getStats().recoveries
         });
         if (refreshResult.ok) {
           rootState = refreshResult.root_state || await getRecommendRoots(client);
+          rootState = await ensureRecommendViewport(rootState, "refresh_after");
           cardNodeIds = await waitForRecommendCardNodeIds(client, rootState.iframe.documentNodeId, {
             timeoutMs: cardTimeoutMs,
             intervalMs: 300
@@ -569,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;
@@ -579,8 +606,19 @@ export async function runRecommendWorkflow({
       await runControl.waitIfPaused();
       runControl.throwIfCanceled();
       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,
@@ -719,6 +757,8 @@ export async function runRecommendWorkflow({
       refresh_rounds: refreshRounds,
       refresh_attempts: refreshAttempts.length,
       list_end_reason: listEndReason || null,
+      viewport_checks: viewportGuard.getStats().checks,
+      viewport_recoveries: viewportGuard.getStats().recoveries,
       last_candidate_id: screeningCandidate.id || null,
       last_candidate_key: candidateKey,
       last_score: screening.score
@@ -756,6 +796,10 @@ export async function runRecommendWorkflow({
     filter: compactFilterResult(filterResult),
     card_count: cardNodeIds.length,
     candidate_list: compactInfiniteListState(listState),
+    viewport_health: {
+      stats: viewportGuard.getStats(),
+      events: viewportGuard.getEvents()
+    },
     list_end_reason: listEndReason || null,
     refresh_rounds: refreshRounds,
     refresh_attempts: refreshAttempts,

package/src/domains/recruit/roots.js

@@ -25,7 +25,8 @@ export async function getRecruitRoots(client, {
     ].filter(Boolean),
     rootNodes: {
       top: topRoot.nodeId,
-      frame: iframe?.documentNodeId || 0
+      frame: iframe?.documentNodeId || 0,
+      frameOwner: iframe?.nodeId || 0
     }
   };
 }