@reconcrap/boss-recommend-mcp 2.0.33 → 2.0.35

package/package.json

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

package/src/domains/chat/page-guard.js

@@ -1,5 +1,6 @@
 import {
   getMainFrameUrl,
+  sleep,
   waitForMainFrameUrl
 } from "../../core/browser/index.js";
 import { CHAT_TARGET_URL } from "./constants.js";
@@ -60,19 +61,25 @@ export async function assertChatShellNotResumeTopLevel(client, {
 export async function recoverChatShell(client, {
   targetUrl = CHAT_TARGET_URL,
   timeoutMs = 60000,
-  intervalMs = 500
+  intervalMs = 500,
+  forceNavigate = false,
+  settleMs = 1200
 } = {}) {
   const before = await getChatTopLevelState(client);
-  if (before.is_chat_shell) {
+  if (before.is_chat_shell && !forceNavigate) {
     return {
       recovered: false,
       before,
       after: before,
-      navigate_url: null
+      navigate_url: null,
+      force_navigate: false
     };
   }
 
-  await client.Page.navigate({ url: targetUrl });
+  const navigateResult = await client.Page.navigate({ url: targetUrl });
+  if (forceNavigate && settleMs > 0) {
+    await sleep(settleMs);
+  }
   const waited = await waitForMainFrameUrl(client, isChatShellUrl, {
     timeoutMs,
     intervalMs
@@ -80,9 +87,12 @@ export async function recoverChatShell(client, {
   const after = await getChatTopLevelState(client);
   return {
     recovered: waited.ok && after.is_chat_shell,
+    refreshed: Boolean(forceNavigate && before.is_chat_shell && after.is_chat_shell),
     before,
     after,
     wait: waited,
-    navigate_url: targetUrl
+    navigate_result: navigateResult || null,
+    navigate_url: targetUrl,
+    force_navigate: Boolean(forceNavigate)
   };
 }

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

@@ -161,6 +161,17 @@ function resultOpenedDetail(result) {
   return Boolean(result?.detail && !result.detail?.cv_acquisition?.skipped);
 }
 
+export function countChatResultStatuses(results = []) {
+  return {
+    processed: results.length,
+    screened: results.length,
+    detail_opened: results.filter(resultOpenedDetail).length,
+    llm_screened: results.filter((item) => item.detail?.llm_screening || item.llm_screening).length,
+    passed: results.filter((item) => item.screening?.passed).length,
+    skipped: results.filter((item) => item.screening?.status === "skip").length
+  };
+}
+
 export function chatDetailSkipReasonFromReadyState(state = {}) {
   if (state?.attachment_resume_enabled) return "attachment_resume_already_available";
   return "";
@@ -173,6 +184,11 @@ export function makeChatResumeModalOpenBeforeCandidateClickError(closeResult = n
   return error;
 }
 
+export function isChatResumeModalCloseFailureError(error) {
+  return error?.code === "CHAT_RESUME_MODAL_OPEN_BEFORE_CANDIDATE_CLICK"
+    || /CHAT_RESUME_MODAL_OPEN_BEFORE_CANDIDATE_CLICK/i.test(String(error?.message || error || ""));
+}
+
 export async function ensureNoOpenChatResumeModalBeforeCandidateClick(client, {
   closeAttempts = 3
 } = {}) {
@@ -319,12 +335,24 @@ function createSkippedDetailResult(cardCandidate, reason, error = null) {
     cv_acquisition: {
       source: reason,
       skipped: true,
-      error: error?.message || null
+      error: error?.message || null,
+      error_code: error?.code || null
     },
     close_result: null
   };
 }
 
+function compactChatRuntimeError(error) {
+  if (!error) return null;
+  return {
+    name: error.name || "Error",
+    code: error.code || null,
+    message: error.message || String(error),
+    close_result: error.close_result || null,
+    page_state: error.page_state || null
+  };
+}
+
 const CHAT_FULL_CV_DOM_MIN_TEXT_LENGTH = 500;
 const CHAT_FULL_CV_DOM_MIN_SECTION_TEXT_LENGTH = 180;
 const CHAT_FULL_CV_NETWORK_MIN_TEXT_LENGTH = 650;
@@ -745,21 +773,25 @@ export async function runChatWorkflow({
     chat_context: contextSetup
   });
 
-  async function recoverAndReapplyChatContext(reason, error = null) {
+  async function recoverAndReapplyChatContext(reason, error = null, {
+    forceRefresh = false
+  } = {}) {
     runControl.setPhase("chat:recover_shell");
-    const recovery = await recoverChatShell(client, {
+    const shellRecovery = await recoverChatShell(client, {
       targetUrl,
-      timeoutMs: readyTimeoutMs
+      timeoutMs: readyTimeoutMs,
+      forceNavigate: forceRefresh
     });
     runControl.checkpoint({
       chat_shell_recovery: {
         reason,
         error: error?.message || null,
-        ...recovery
+        total_refresh: Boolean(forceRefresh),
+        ...shellRecovery
       }
     });
-    if (!recovery.recovered && !recovery.after?.is_chat_shell) {
-      throw new Error(`Chat shell recovery failed after ${reason}: ${recovery.after?.url || recovery.before?.url || "unknown"}`);
+    if (!shellRecovery.recovered && !shellRecovery.after?.is_chat_shell) {
+      throw new Error(`Chat shell recovery failed after ${reason}: ${shellRecovery.after?.url || shellRecovery.before?.url || "unknown"}`);
     }
     await closeChatResumeModal(client, { attemptsLimit: 2 });
     const recoveredSetup = await setupChatRunContext(client, {
@@ -771,6 +803,24 @@ export async function runChatWorkflow({
       ensureViewport: ensureChatViewport
     });
     rootState = recoveredSetup.rootState;
+    const counters = countChatResultStatuses(results);
+    const candidateList = resetInfiniteListForRefreshRound(listState, {
+      reason,
+      round: listState.ledger?.length || 0,
+      method: forceRefresh ? "total_refresh_reapply_chat_context" : "reapply_chat_context",
+      metadata: {
+        processed: counters.processed,
+        passed: counters.passed,
+        skipped: counters.skipped
+      }
+    });
+    const recovery = {
+      reason,
+      total_refresh: Boolean(forceRefresh),
+      shell: shellRecovery,
+      candidate_list: candidateList,
+      counters
+    };
     contextSetup = {
       ...recoveredSetup.contextSetup,
       recovered_from: reason,
@@ -778,7 +828,8 @@ export async function runChatWorkflow({
       previous_context: contextSetup
     };
     runControl.checkpoint({
-      chat_context: contextSetup
+      chat_context: contextSetup,
+      candidate_list: candidateList
     });
     return recovery;
   }
@@ -811,6 +862,7 @@ export async function runChatWorkflow({
       detail_opened: 0,
       llm_screened: 0,
       passed: 0,
+      skipped: 0,
       requested: 0,
       request_satisfied: 0,
       request_skipped: 0,
@@ -846,6 +898,7 @@ export async function runChatWorkflow({
       detail_opened: 0,
       llm_screened: 0,
       passed: 0,
+      skipped: 0,
       requested: requestedCount,
       request_satisfied: requestSatisfiedCount,
       request_skipped: requestSkippedCount,
@@ -863,6 +916,7 @@ export async function runChatWorkflow({
     detail_opened: 0,
     llm_screened: 0,
     passed: 0,
+    skipped: 0,
     requested: 0,
     request_satisfied: 0,
     request_skipped: 0,
@@ -1000,11 +1054,23 @@ export async function runChatWorkflow({
     let detailUnavailableReason = "";
     if (index < detailCountLimit) {
       let detailStep = "start";
+      const checkpointInProgressCandidate = (patch = {}) => runControl.checkpoint({
+        in_progress_candidate: {
+          index,
+          key: candidateKey,
+          card_node_id: effectiveCardNodeId || cardNodeId,
+          candidate: compactCandidate(cardCandidate),
+          detail_step: detailStep,
+          counters: countChatResultStatuses(results),
+          ...patch
+        }
+      });
       try {
         await runControl.waitIfPaused();
         runControl.throwIfCanceled();
         runControl.setPhase("chat:detail");
         rootState = await ensureChatViewport(rootState, "detail");
+        checkpointInProgressCandidate({ event: "detail_start" });
 
         detailStep = "select_candidate";
         networkRecorder.clear();
@@ -1402,11 +1468,23 @@ export async function runChatWorkflow({
           }
 
           let closeResult = null;
+          let closeRecovery = null;
           if (closeResume) {
             detailStep = "close_resume_modal";
+            checkpointInProgressCandidate({
+              event: "before_close_resume_modal",
+              source,
+              image_evidence: summarizeImageEvidence(imageEvidence),
+              llm_screening: compactLlmResult(llmResult),
+              full_cv_evidence: fullCvEvidence
+            });
             closeResult = await measureTiming(timings, "close_detail_ms", () => closeChatResumeModal(client));
             if (!closeResult?.closed) {
-              throw makeChatResumeModalOpenBeforeCandidateClickError(closeResult);
+              closeRecovery = await recoverAndReapplyChatContext(
+                "resume_modal_close_failed:close_resume_modal",
+                makeChatResumeModalOpenBeforeCandidateClickError(closeResult),
+                { forceRefresh: true }
+              );
             }
           }
           detailResult.close_result = closeResult;
@@ -1435,15 +1513,28 @@ export async function runChatWorkflow({
             image_evidence: summarizeImageEvidence(imageEvidence),
             capture_target: captureTarget || null,
             capture_target_wait: captureTargetWait,
-            full_cv_evidence: fullCvEvidence
+            full_cv_evidence: fullCvEvidence,
+            close_recovery: closeRecovery
           };
         }
       } catch (error) {
+        checkpointInProgressCandidate({
+          event: "detail_error",
+          error: compactChatRuntimeError(error)
+        });
         if (isForbiddenChatResumeNavigationError(error)) {
           detailUnavailableReason = "forbidden_top_level_resume_navigation";
           const recovery = await recoverAndReapplyChatContext(detailUnavailableReason, error);
           detailResult = createSkippedDetailResult(cardCandidate, detailUnavailableReason, error);
           detailResult.cv_acquisition.recovery = recovery;
+        } else if (isChatResumeModalCloseFailureError(error)) {
+          const recoveryReason = `resume_modal_close_failed:${detailStep}`;
+          const recovery = await recoverAndReapplyChatContext(recoveryReason, error, { forceRefresh: true });
+          checkpointInProgressCandidate({
+            event: "retry_after_modal_recovery",
+            recovery
+          });
+          continue;
         } else if (isUnsafeChatOnlineResumeLinkError(error)) {
           detailUnavailableReason = "unsafe_online_resume_navigation_link";
           detailResult = createSkippedDetailResult(cardCandidate, detailUnavailableReason, error);
@@ -1516,16 +1607,18 @@ export async function runChatWorkflow({
       }
     });
 
+    const counters = countChatResultStatuses(results);
     runControl.updateProgress({
       card_count: cardNodeIds.length,
       target_count: passTarget || (processUntilListEnd ? "all" : processedLimit),
       target_pass_count: passTarget,
       processed_limit: processedLimit,
-      processed: results.length,
-      screened: results.length,
-      detail_opened: results.filter(resultOpenedDetail).length,
-      llm_screened: results.filter((item) => item.detail?.llm_screening || item.llm_screening).length,
-      passed: results.filter((item) => item.screening.passed).length,
+      processed: counters.processed,
+      screened: counters.screened,
+      detail_opened: counters.detail_opened,
+      llm_screened: counters.llm_screened,
+      passed: counters.passed,
+      skipped: counters.skipped,
       requested: requestedCount,
       request_satisfied: requestSatisfiedCount,
       request_skipped: requestSkippedCount,
@@ -1541,6 +1634,7 @@ export async function runChatWorkflow({
     const checkpointStarted = Date.now();
     runControl.checkpoint({
       results,
+      in_progress_candidate: null,
       last_candidate: {
         id: screeningCandidate.id || null,
         key: candidateKey,
@@ -1564,6 +1658,7 @@ export async function runChatWorkflow({
   }
 
   runControl.setPhase("chat:done");
+  const finalCounters = countChatResultStatuses(results);
   return {
     domain: "chat",
     target_url: targetUrl,
@@ -1579,11 +1674,12 @@ export async function runChatWorkflow({
     process_until_list_end: Boolean(processUntilListEnd),
     processed_limit: processedLimit,
     detail_source: normalizedDetailSource,
-    processed: results.length,
-    screened: results.length,
-    detail_opened: results.filter(resultOpenedDetail).length,
-    llm_screened: results.filter((item) => item.detail?.llm_screening || item.llm_screening).length,
-    passed: results.filter((item) => item.screening.passed).length,
+    processed: finalCounters.processed,
+    screened: finalCounters.screened,
+    detail_opened: finalCounters.detail_opened,
+    llm_screened: finalCounters.llm_screened,
+    passed: finalCounters.passed,
+    skipped: finalCounters.skipped,
     requested: requestedCount,
     request_satisfied: requestSatisfiedCount,
     request_skipped: requestSkippedCount,
@@ -1685,6 +1781,7 @@ export function createChatRunService({
         detail_opened: 0,
         llm_screened: 0,
         passed: 0,
+        skipped: 0,
         requested: 0,
         request_satisfied: 0,
         request_skipped: 0

package/src/domains/recommend/refresh.js

@@ -4,7 +4,8 @@ import {
   waitForRecommendCardNodeIds
 } from "./cards.js";
 import {
-  RECOMMEND_RECENT_NOT_VIEW_LABEL
+  RECOMMEND_RECENT_NOT_VIEW_LABEL,
+  RECOMMEND_TARGET_URL
 } from "./constants.js";
 import { selectAndConfirmFirstSafeFilter } from "./filters.js";
 import { selectRecommendJob } from "./jobs.js";
@@ -94,6 +95,8 @@ export async function refreshRecommendListAtEnd(client, {
   fallbackPageScope = "recommend",
   filter = {},
   preferEndRefreshButton = true,
+  forceNavigate = false,
+  targetUrl = RECOMMEND_TARGET_URL,
   forceRecentNotView = true,
   cardTimeoutMs = 30000,
   buttonSettleMs = 8000,
@@ -156,8 +159,17 @@ export async function refreshRecommendListAtEnd(client, {
     }
   }
 
+  let fallbackMethod = "page_reload";
   try {
-    await client.Page.reload({ ignoreCache: true });
+    let method = "page_reload";
+    if (forceNavigate && typeof client?.Page?.navigate === "function") {
+      await client.Page.navigate({ url: targetUrl || RECOMMEND_TARGET_URL });
+      method = "page_navigate";
+      fallbackMethod = method;
+    } else {
+      await client.Page.reload({ ignoreCache: true });
+      fallbackMethod = method;
+    }
     if (reloadSettleMs > 0) await sleep(reloadSettleMs);
     currentRootState = await waitForRecommendRoots(client, {
       timeoutMs: Math.max(30000, reloadSettleMs * 4),
@@ -202,8 +214,9 @@ export async function refreshRecommendListAtEnd(client, {
     });
     return {
       ok: cardNodeIds.length > 0,
-      method: "page_reload",
+      method,
       attempts,
+      target_url: method === "page_navigate" ? (targetUrl || RECOMMEND_TARGET_URL) : null,
       job_selection: jobSelection,
       page_scope: pageScopeResult,
       filter: filterResult,
@@ -214,10 +227,11 @@ export async function refreshRecommendListAtEnd(client, {
   } catch (error) {
     return {
       ok: false,
-      method: "page_reload",
-      reason: "page_reload_failed",
+      method: fallbackMethod,
+      reason: fallbackMethod === "page_navigate" ? "page_navigate_failed" : "page_reload_failed",
       error: error?.message || String(error),
       attempts,
+      target_url: fallbackMethod === "page_navigate" ? (targetUrl || RECOMMEND_TARGET_URL) : null,
       card_count: 0,
       root_state: currentRootState,
       forced_recent_not_view: forceRecentNotView