@reconcrap/boss-recommend-mcp 2.0.15 → 2.0.16

package/package.json

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

package/src/domains/chat/detail.js

@@ -39,13 +39,65 @@ import {
 import {
   assertChatShellNotResumeTopLevel,
   getChatTopLevelState,
+  isForbiddenChatResumeTopLevelUrl,
   makeForbiddenChatResumeNavigationError
 } from "./page-guard.js";
 
+export const CHAT_UNSAFE_ONLINE_RESUME_LINK_CODE = "CHAT_UNSAFE_ONLINE_RESUME_LINK";
+
 export function matchesChatProfileNetwork(url) {
   return CHAT_PROFILE_NETWORK_PATTERNS.some((pattern) => pattern.test(String(url || "")));
 }
 
+function looksLikeForbiddenChatResumePath(value = "") {
+  const normalized = String(value || "");
+  return isForbiddenChatResumeTopLevelUrl(normalized)
+    || /(?:^|["'\s=])(?:https?:\/\/[^"'\s>]*zhipin\.com)?\/web\/frame\/c-resume(?:[/?#"' >]|$)/i
+      .test(normalized);
+}
+
+function extractFirstHtmlAttribute(html = "", names = []) {
+  const source = String(html || "");
+  for (const name of names) {
+    const escaped = String(name).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(`${escaped}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'>]+))`, "i");
+    const match = source.match(regex);
+    if (match) return match[1] ?? match[2] ?? match[3] ?? "";
+  }
+  return "";
+}
+
+export function isUnsafeChatOnlineResumeTarget(target = {}, buttonHTML = "") {
+  const attributes = target?.attributes || {};
+  const href = attributes.href
+    || attributes["data-href"]
+    || attributes["data-url"]
+    || attributes.url
+    || extractFirstHtmlAttribute(buttonHTML, ["href", "data-href", "data-url", "url"]);
+  return looksLikeForbiddenChatResumePath(href)
+    || looksLikeForbiddenChatResumePath(buttonHTML);
+}
+
+export function makeUnsafeChatOnlineResumeLinkError(target = {}, buttonHTML = "") {
+  const href = target?.attributes?.href
+    || target?.attributes?.["data-href"]
+    || target?.attributes?.["data-url"]
+    || extractFirstHtmlAttribute(buttonHTML, ["href", "data-href", "data-url", "url"])
+    || null;
+  const error = new Error("CHAT_UNSAFE_ONLINE_RESUME_LINK: refusing to click an online resume link that can navigate the chat tab to /web/frame/c-resume/");
+  error.code = CHAT_UNSAFE_ONLINE_RESUME_LINK_CODE;
+  error.href = href;
+  error.button_selector = target?.selector || null;
+  error.button_text = htmlToText(buttonHTML).slice(0, 120);
+  error.button_html_length = String(buttonHTML || "").length;
+  return error;
+}
+
+export function isUnsafeChatOnlineResumeLinkError(error) {
+  return error?.code === CHAT_UNSAFE_ONLINE_RESUME_LINK_CODE
+    || /CHAT_UNSAFE_ONLINE_RESUME_LINK/i.test(String(error?.message || error || ""));
+}
+
 export function createChatProfileNetworkRecorder(client) {
   const events = [];
   client.Network.responseReceived((event) => {
@@ -673,6 +725,22 @@ export async function openChatOnlineResume(client, {
       buttonHTML = await getOuterHTML(client, buttonState.target.node_id);
     } catch {}
 
+    if (isUnsafeChatOnlineResumeTarget(buttonState.target, buttonHTML)) {
+      const error = makeUnsafeChatOnlineResumeLinkError(buttonState.target, buttonHTML);
+      attempts.push({
+        attempt: index + 1,
+        ok: false,
+        error: error.code,
+        blocked_pre_click: true,
+        button_selector: buttonState.target.selector,
+        button_text: error.button_text,
+        button_href: error.href,
+        button_html_length: buttonHTML.length
+      });
+      error.attempts = attempts;
+      throw error;
+    }
+
     try {
       if (buttonState.target.center) {
         await clickPoint(client, buttonState.target.center.x, buttonState.target.center.y);

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

@@ -49,6 +49,7 @@ import {
   closeChatResumeModal,
   createChatProfileNetworkRecorder,
   extractChatProfileCandidate,
+  isUnsafeChatOnlineResumeLinkError,
   openChatOnlineResume,
   readChatConversationReadyState,
   requestChatResumeForPassedCandidate,
@@ -205,6 +206,8 @@ function createSkippedDetailResult(cardCandidate, reason, error = 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;
+const CHAT_FULL_CV_NETWORK_MIN_RICH_ITEM_COUNT = 3;
 const CHAT_FULL_CV_SECTION_PATTERNS = Object.freeze([
   /教育(?:经历|背景|经验)?/i,
   /工作(?:经历|经验)?/i,
@@ -250,17 +253,32 @@ function isFullCvNetworkProfile(profileResult = {}) {
   const sourceKeys = profileResult.profile?.source_keys || {};
   const textLength = networkProfileTextLength(profileResult);
   const sectionCount = resumeSectionMatchCount(profileResult.profile?.text || "");
+  const richItemCount = [
+    "education_count",
+    "work_count",
+    "project_count",
+    "expectation_count",
+    "certification_count"
+  ].reduce((sum, key) => sum + (Number(sourceKeys[key]) || 0), 0);
+  const hasResumeSections = sectionCount >= 3 || (sectionCount >= 2 && richItemCount >= 2);
+  const hasEnoughNetworkText = textLength >= CHAT_FULL_CV_NETWORK_MIN_TEXT_LENGTH;
 
-  if (sourceKeys.geek_detail_info || sourceKeys.geek_detail) return true;
+  if (sourceKeys.geek_detail_info || sourceKeys.geek_detail) {
+    return hasEnoughNetworkText && (
+      hasResumeSections
+      || richItemCount >= CHAT_FULL_CV_NETWORK_MIN_RICH_ITEM_COUNT
+    );
+  }
   if (sourceKeys.network_html_text) {
-    return textLength >= CHAT_FULL_CV_DOM_MIN_TEXT_LENGTH
-      || sectionCount >= 2;
+    return textLength >= CHAT_FULL_CV_NETWORK_MIN_TEXT_LENGTH
+      && sectionCount >= 2;
   }
   if (sourceKeys.chat_history_resume) {
     const educationCount = Number(sourceKeys.education_count) || 0;
     const workCount = Number(sourceKeys.work_count) || 0;
-    return (educationCount + workCount) > 0
-      && (textLength >= CHAT_FULL_CV_DOM_MIN_SECTION_TEXT_LENGTH || sectionCount >= 2);
+    return (educationCount + workCount) >= 2
+      && textLength >= CHAT_FULL_CV_NETWORK_MIN_TEXT_LENGTH
+      && sectionCount >= 2;
   }
   return false;
 }
@@ -826,28 +844,8 @@ export async function runChatWorkflow({
         }
 
         if (!detailResult) {
-          detailStep = "open_online_resume";
-          networkRecorder.clear();
-          const openedResume = await measureTiming(timings, "detail_open_ms", () => openChatOnlineResume(client, {
-            timeoutMs: readyTimeoutMs
-          }));
           const waitPlan = getCvNetworkWaitPlan(cvAcquisitionState);
-          detailStep = "wait_network";
-          const networkWait = ["network", "cascade"].includes(normalizedDetailSource)
-            ? await measureTiming(timings, "network_cv_wait_ms", () => waitForCvNetworkEvents(
-                waitForChatProfileNetworkEvents,
-                networkRecorder,
-                {
-                  waitPlan,
-                  minCount: 1,
-                  requireLoaded: true,
-                  intervalMs: 200
-                }
-              ))
-            : null;
-          if (networkWait?.elapsed_ms != null) {
-            timings.network_cv_wait_ms = Math.round(Number(networkWait.elapsed_ms) || 0);
-          }
+          let networkWait = null;
           let contentWait = {
             ok: false,
             skipped: false,
@@ -855,39 +853,44 @@ export async function runChatWorkflow({
             elapsed_ms: 0,
             text_length: 0
           };
-          let resumeState = openedResume.resume_state;
+          let resumeState = null;
           let resumeHtml = null;
-          let resumeNetworkEvents = networkRecorder.events.slice();
+          let resumeNetworkEvents = [];
           let parsedNetworkProfileCount = 0;
 
           if (
             ["network", "cascade"].includes(normalizedDetailSource)
-            && networkWait?.count > 0
+            && selectionNetworkEvents.length > 0
           ) {
-            detailStep = "extract_network_profile";
+            detailStep = "extract_selection_network_profile";
             detailResult = await extractChatProfileCandidate(client, {
               cardCandidate,
               cardNodeId: effectiveCardNodeId,
-              resumeState,
-              resumeHtml,
-              networkEvents: selectedDetailNetworkEvents(
-                normalizedDetailSource,
-                selectionNetworkEvents,
-                resumeNetworkEvents
-              ),
+              resumeState: null,
+              resumeHtml: null,
+              networkEvents: selectionNetworkEvents,
               targetUrl,
               closeResume: false,
-              networkParseRetryMs: waitPlan.mode_before === "image" ? 500 : 2200,
-              networkParseIntervalMs: 250
+              networkParseRetryMs: waitPlan.mode_before === "image" ? 250 : 900,
+              networkParseIntervalMs: 150
             });
             addTiming(timings, "late_network_retry_ms", detailResult.network_parse_retry_elapsed_ms);
             parsedNetworkProfileCount = countParsedNetworkProfiles(detailResult);
-            const networkEvidence = summarizeChatFullCvEvidence({ detailResult, contentWait });
-            if (networkEvidence.network_full_cv_count > 0) {
+            const selectionNetworkEvidence = summarizeChatFullCvEvidence({ detailResult, contentWait });
+            if (selectionNetworkEvidence.network_full_cv_count > 0) {
+              networkWait = {
+                ok: true,
+                skipped: true,
+                reason: "selection_network_full_cv_before_online_resume_click",
+                elapsed_ms: detailResult.network_parse_retry_elapsed_ms,
+                count: selectionNetworkEvents.length,
+                total_event_count: selectionNetworkEvents.length,
+                wait_plan: waitPlan
+              };
               contentWait = {
                 ok: true,
                 skipped: true,
-                reason: "network_full_cv_parsed_before_dom_wait",
+                reason: "selection_network_full_cv_before_online_resume_click",
                 elapsed_ms: 0,
                 text_length: 0
               };
@@ -897,32 +900,94 @@ export async function runChatWorkflow({
           }
 
           if (!detailResult) {
-            detailStep = "wait_resume_content";
-            contentWait = await measureTiming(timings, "dom_fallback_ms", () => waitForChatResumeContent(client, {
-              timeoutMs: resumeDomTimeoutMs,
-              intervalMs: 300
+            detailStep = "open_online_resume";
+            networkRecorder.clear();
+            const openedResume = await measureTiming(timings, "detail_open_ms", () => openChatOnlineResume(client, {
+              timeoutMs: readyTimeoutMs
             }));
-            resumeState = contentWait.resume_state || openedResume.resume_state;
-            resumeHtml = contentWait.resume_html || null;
+            resumeState = openedResume.resume_state;
+            detailStep = "wait_network";
+            networkWait = ["network", "cascade"].includes(normalizedDetailSource)
+              ? await measureTiming(timings, "network_cv_wait_ms", () => waitForCvNetworkEvents(
+                  waitForChatProfileNetworkEvents,
+                  networkRecorder,
+                  {
+                    waitPlan,
+                    minCount: 1,
+                    requireLoaded: true,
+                    intervalMs: 200
+                  }
+                ))
+              : null;
+            if (networkWait?.elapsed_ms != null) {
+              timings.network_cv_wait_ms = Math.round(Number(networkWait.elapsed_ms) || 0);
+            }
             resumeNetworkEvents = networkRecorder.events.slice();
-            detailStep = "extract_resume_content";
-            detailResult = await extractChatProfileCandidate(client, {
-              cardCandidate,
-              cardNodeId: effectiveCardNodeId,
-              resumeState,
-              resumeHtml,
-              networkEvents: selectedDetailNetworkEvents(
-                normalizedDetailSource,
-                selectionNetworkEvents,
-                resumeNetworkEvents
-              ),
-              targetUrl,
-              closeResume: false,
-              networkParseRetryMs: waitPlan.mode_before === "image" ? 500 : 2200,
-              networkParseIntervalMs: 250
-            });
-            addTiming(timings, "late_network_retry_ms", detailResult.network_parse_retry_elapsed_ms);
-            parsedNetworkProfileCount = countParsedNetworkProfiles(detailResult);
+
+            if (
+              ["network", "cascade"].includes(normalizedDetailSource)
+              && networkWait?.count > 0
+            ) {
+              detailStep = "extract_network_profile";
+              detailResult = await extractChatProfileCandidate(client, {
+                cardCandidate,
+                cardNodeId: effectiveCardNodeId,
+                resumeState,
+                resumeHtml,
+                networkEvents: selectedDetailNetworkEvents(
+                  normalizedDetailSource,
+                  selectionNetworkEvents,
+                  resumeNetworkEvents
+                ),
+                targetUrl,
+                closeResume: false,
+                networkParseRetryMs: waitPlan.mode_before === "image" ? 500 : 2200,
+                networkParseIntervalMs: 250
+              });
+              addTiming(timings, "late_network_retry_ms", detailResult.network_parse_retry_elapsed_ms);
+              parsedNetworkProfileCount = countParsedNetworkProfiles(detailResult);
+              const networkEvidence = summarizeChatFullCvEvidence({ detailResult, contentWait });
+              if (networkEvidence.network_full_cv_count > 0) {
+                contentWait = {
+                  ok: true,
+                  skipped: true,
+                  reason: "network_full_cv_parsed_before_dom_wait",
+                  elapsed_ms: 0,
+                  text_length: 0
+                };
+              } else {
+                detailResult = null;
+              }
+            }
+
+            if (!detailResult) {
+              detailStep = "wait_resume_content";
+              contentWait = await measureTiming(timings, "dom_fallback_ms", () => waitForChatResumeContent(client, {
+                timeoutMs: resumeDomTimeoutMs,
+                intervalMs: 300
+              }));
+              resumeState = contentWait.resume_state || openedResume.resume_state;
+              resumeHtml = contentWait.resume_html || null;
+              resumeNetworkEvents = networkRecorder.events.slice();
+              detailStep = "extract_resume_content";
+              detailResult = await extractChatProfileCandidate(client, {
+                cardCandidate,
+                cardNodeId: effectiveCardNodeId,
+                resumeState,
+                resumeHtml,
+                networkEvents: selectedDetailNetworkEvents(
+                  normalizedDetailSource,
+                  selectionNetworkEvents,
+                  resumeNetworkEvents
+                ),
+                targetUrl,
+                closeResume: false,
+                networkParseRetryMs: waitPlan.mode_before === "image" ? 500 : 2200,
+                networkParseIntervalMs: 250
+              });
+              addTiming(timings, "late_network_retry_ms", detailResult.network_parse_retry_elapsed_ms);
+              parsedNetworkProfileCount = countParsedNetworkProfiles(detailResult);
+            }
           }
 
           let source = normalizedDetailSource === "dom" ? "dom" : "network";
@@ -1113,6 +1178,13 @@ export async function runChatWorkflow({
           const recovery = await recoverAndReapplyChatContext(detailUnavailableReason, error);
           detailResult = createSkippedDetailResult(cardCandidate, detailUnavailableReason, error);
           detailResult.cv_acquisition.recovery = recovery;
+        } else if (isUnsafeChatOnlineResumeLinkError(error)) {
+          detailUnavailableReason = "unsafe_online_resume_navigation_link";
+          detailResult = createSkippedDetailResult(cardCandidate, detailUnavailableReason, error);
+          detailResult.cv_acquisition.blocked_pre_click = true;
+          detailResult.cv_acquisition.button_href = error.href || null;
+          detailResult.cv_acquisition.button_selector = error.button_selector || null;
+          detailResult.cv_acquisition.attempts = error.attempts || null;
         } else {
           if (!isRecoverableCdpNodeError(error)) throw error;
           detailUnavailableReason = `recoverable_cdp_node_stale:${detailStep}`;