@reconcrap/boss-recommend-mcp 1.3.15 → 1.3.16

package/package.json

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

package/vendor/boss-recommend-screen-cli/boss-recommend-screen-cli.cjs

@@ -3305,6 +3305,60 @@ class RecommendScreenCli {
     return info;
   }
 
+  async resolveDomResumeFallback(candidate, cardProfile) {
+    let domCandidateInfo = await this.extractResumeTextFromDom(candidate);
+    let networkCandidateInfo = null;
+    if (domCandidateInfo && !isDomProfileConsistentWithCard(cardProfile, domCandidateInfo)) {
+      this.recordResumeNetworkDiagnostic({
+        kind: "dom_profile_mismatch",
+        candidate_key: normalizeText(candidate?.key || candidate?.geek_id || ""),
+        card_name: normalizeText(cardProfile?.name || ""),
+        dom_name: normalizeText(domCandidateInfo?.name || ""),
+        card_school: normalizeText(cardProfile?.school || ""),
+        dom_school: normalizeText(domCandidateInfo?.school || "")
+      });
+      log(
+        `[DOM简历疑似错位] candidate=${candidate?.key || candidate?.geek_id || "unknown"} ` +
+        `card=${normalizeText(cardProfile?.name || "-")} dom=${normalizeText(domCandidateInfo?.name || "-")}，尝试重试一次点击+监听。`
+      );
+      try {
+        const retryCaptureStartedAt = Date.now();
+        await this.clickCandidate(candidate);
+        const retryDetailOpen = await this.ensureDetailOpen();
+        if (retryDetailOpen) {
+          networkCandidateInfo = await this.waitForNetworkResumeCandidateInfo(
+            candidate,
+            NETWORK_RESUME_RETRY_WAIT_MS,
+            { minTs: retryCaptureStartedAt }
+          );
+          if (!normalizeText(networkCandidateInfo?.resumeText)) {
+            const retryDomCandidateInfo = await this.extractResumeTextFromDom(candidate);
+            if (retryDomCandidateInfo && isDomProfileConsistentWithCard(cardProfile, retryDomCandidateInfo)) {
+              domCandidateInfo = retryDomCandidateInfo;
+            } else {
+              domCandidateInfo = null;
+            }
+          } else {
+            domCandidateInfo = null;
+          }
+        } else {
+          domCandidateInfo = null;
+        }
+      } catch (retryError) {
+        domCandidateInfo = null;
+        this.recordResumeNetworkDiagnostic({
+          kind: "dom_profile_mismatch_retry_failed",
+          candidate_key: normalizeText(candidate?.key || candidate?.geek_id || ""),
+          error: normalizeText(retryError?.message || retryError)
+        });
+      }
+    }
+    return {
+      domCandidateInfo,
+      networkCandidateInfo
+    };
+  }
+
   handleNetworkRequestWillBeSent(params) {
     const url = normalizeText(params?.request?.url || "");
     const postData = params?.request?.postData || "";
@@ -5222,82 +5276,69 @@ class RecommendScreenCli {
               }
             );
           }
-          if (!normalizeText(networkCandidateInfo?.resumeText)) {
-            domCandidateInfo = await this.extractResumeTextFromDom(nextCandidate);
-            if (domCandidateInfo && !isDomProfileConsistentWithCard(cardProfile, domCandidateInfo)) {
-              this.recordResumeNetworkDiagnostic({
-                kind: "dom_profile_mismatch",
-                candidate_key: normalizeText(nextCandidate?.key || nextCandidate?.geek_id || ""),
-                card_name: normalizeText(cardProfile?.name || ""),
-                dom_name: normalizeText(domCandidateInfo?.name || ""),
-                card_school: normalizeText(cardProfile?.school || ""),
-                dom_school: normalizeText(domCandidateInfo?.school || "")
-              });
-              log(
-                `[DOM简历疑似错位] candidate=${nextCandidate?.key || nextCandidate?.geek_id || "unknown"} ` +
-                `card=${normalizeText(cardProfile?.name || "-")} dom=${normalizeText(domCandidateInfo?.name || "-")}，尝试重试一次点击+监听。`
-              );
-              try {
-                const retryCaptureStartedAt = Date.now();
-                await this.clickCandidate(nextCandidate);
-                const retryDetailOpen = await this.ensureDetailOpen();
-                if (retryDetailOpen) {
-                  networkCandidateInfo = await this.waitForNetworkResumeCandidateInfo(
-                    nextCandidate,
-                    NETWORK_RESUME_RETRY_WAIT_MS,
-                    { minTs: retryCaptureStartedAt }
-                  );
-                  if (!normalizeText(networkCandidateInfo?.resumeText)) {
-                    const retryDomCandidateInfo = await this.extractResumeTextFromDom(nextCandidate);
-                    if (retryDomCandidateInfo && isDomProfileConsistentWithCard(cardProfile, retryDomCandidateInfo)) {
-                      domCandidateInfo = retryDomCandidateInfo;
-                    } else {
-                      domCandidateInfo = null;
-                    }
-                  } else {
-                    domCandidateInfo = null;
-                  }
-                } else {
-                  domCandidateInfo = null;
-                }
-              } catch (retryError) {
-                domCandidateInfo = null;
-                this.recordResumeNetworkDiagnostic({
-                  kind: "dom_profile_mismatch_retry_failed",
-                  candidate_key: normalizeText(nextCandidate?.key || nextCandidate?.geek_id || ""),
-                  error: normalizeText(retryError?.message || retryError)
-                });
-              }
-            }
-          }
-          const resumeCandidateInfo = networkCandidateInfo?.resumeText ? networkCandidateInfo : domCandidateInfo;
-          candidateProfile = mergeCandidateProfiles(
-            resumeCandidateInfo || null,
-            cardProfile || null,
-            {
-              name: nextCandidate.name || "",
-              school: nextCandidate.school || "",
-              major: nextCandidate.major || "",
-              company: nextCandidate.last_company || "",
-              position: nextCandidate.last_position || ""
-            }
-          );
 
           if (networkCandidateInfo?.resumeText) {
             screening = await this.callTextModel(networkCandidateInfo.resumeText);
             resumeSource = "network";
             resumeTextLength = normalizeText(networkCandidateInfo.resumeText).length;
             this.resumeSourceStats.network += 1;
-          } else if (domCandidateInfo?.resumeText) {
-            screening = await this.callTextModel(domCandidateInfo.resumeText);
-            resumeSource = "dom_fallback";
-            resumeTextLength = normalizeText(domCandidateInfo.resumeText).length;
-            this.resumeSourceStats.dom_fallback += 1;
+            candidateProfile = mergeCandidateProfiles(
+              networkCandidateInfo || null,
+              cardProfile || null,
+              {
+                name: nextCandidate.name || "",
+                school: nextCandidate.school || "",
+                major: nextCandidate.major || "",
+                company: nextCandidate.last_company || "",
+                position: nextCandidate.last_position || ""
+              }
+            );
           } else {
-            resumeSource = "image_fallback";
-            capture = await this.captureResumeImage(nextCandidate);
-            screening = await this.callVisionModel(capture.stitchedImage);
-            this.resumeSourceStats.image_fallback += 1;
+            try {
+              resumeSource = "image_fallback";
+              capture = await this.captureResumeImage(nextCandidate);
+              screening = await this.callVisionModel(capture.stitchedImage);
+              this.resumeSourceStats.image_fallback += 1;
+            } catch (imageFallbackError) {
+              const domFallback = await this.resolveDomResumeFallback(nextCandidate, cardProfile || null);
+              if (domFallback?.networkCandidateInfo?.resumeText) {
+                networkCandidateInfo = domFallback.networkCandidateInfo;
+                screening = await this.callTextModel(networkCandidateInfo.resumeText);
+                resumeSource = "network";
+                resumeTextLength = normalizeText(networkCandidateInfo.resumeText).length;
+                this.resumeSourceStats.network += 1;
+                candidateProfile = mergeCandidateProfiles(
+                  networkCandidateInfo || null,
+                  cardProfile || null,
+                  {
+                    name: nextCandidate.name || "",
+                    school: nextCandidate.school || "",
+                    major: nextCandidate.major || "",
+                    company: nextCandidate.last_company || "",
+                    position: nextCandidate.last_position || ""
+                  }
+                );
+              } else if (domFallback?.domCandidateInfo?.resumeText) {
+                domCandidateInfo = domFallback.domCandidateInfo;
+                screening = await this.callTextModel(domCandidateInfo.resumeText);
+                resumeSource = "dom_fallback";
+                resumeTextLength = normalizeText(domCandidateInfo.resumeText).length;
+                this.resumeSourceStats.dom_fallback += 1;
+                candidateProfile = mergeCandidateProfiles(
+                  domCandidateInfo || null,
+                  cardProfile || null,
+                  {
+                    name: nextCandidate.name || "",
+                    school: nextCandidate.school || "",
+                    major: nextCandidate.major || "",
+                    company: nextCandidate.last_company || "",
+                    position: nextCandidate.last_position || ""
+                  }
+                );
+              } else {
+                throw imageFallbackError;
+              }
+            }
           }
           this.resetResumeCaptureFailureStreak();
           log(`筛选结果: ${screening.passed ? "通过" : "不通过"}`);

package/vendor/boss-recommend-screen-cli/test-recoverable-resume-failures.cjs

@@ -467,7 +467,7 @@ async function testRecommendShouldPreferNetworkResumeWhenAvailable() {
   assert.equal(result.result.resume_source, "network");
 }
 
-async function testNetworkMissShouldFallbackToDomBeforeImageCapture() {
+async function testNetworkMissShouldFallbackToImageThenDom() {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-network-dom-fallback-"));
   const candidate = { key: "dom-1", geek_id: "dom-1", name: "dom candidate" };
   const cli = new FakeRecommendScreenCli(createArgs(tempDir), {
@@ -485,13 +485,15 @@ async function testNetworkMissShouldFallbackToDomBeforeImageCapture() {
   });
 
   cli.waitForNetworkResumeCandidateInfo = async () => null;
+  let captureAttempted = false;
   cli.callTextModel = async (resumeText) => ({
     passed: true,
     reason: resumeText.includes("华中科技大学") ? "dom fallback used" : "unexpected",
     summary: "dom fallback used"
   });
   cli.captureResumeImage = async () => {
-    throw new Error("capture should not be called when dom fallback resume exists");
+    captureAttempted = true;
+    throw new Error("capture failed, should fallback to dom");
   };
 
   const result = await cli.run();
@@ -501,6 +503,7 @@ async function testNetworkMissShouldFallbackToDomBeforeImageCapture() {
   assert.equal(cli.passedCandidates.length, 1);
   assert.equal(cli.passedCandidates[0].school, "华中科技大学");
   assert.equal(cli.passedCandidates[0].resumeSource, "dom_fallback");
+  assert.equal(captureAttempted, true);
 }
 
 async function testNetworkMissShouldFallbackToImageCapture() {
@@ -600,7 +603,7 @@ function testLatestPayloadShouldRemainAvailableWhenCandidateKeyMissing() {
     key: "",
     geek_id: ""
   });
-  assert.equal(extracted?.resumeText, "recent resume payload");
+  assert.equal(extracted?.candidateInfo?.resumeText, "recent resume payload");
 }
 
 async function testVisionModelFailureShouldSkipCandidateAndContinue() {
@@ -638,25 +641,44 @@ async function testVisionModelFailureShouldSkipCandidateAndContinue() {
   assert.equal(result.result.skipped_count, 1);
 }
 
-async function testFeaturedNetworkMissShouldSkipWithoutImageCapture() {
+async function testFeaturedNetworkMissShouldFallbackToDomAfterImageFailure() {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-featured-network-only-"));
   const args = createArgs(tempDir);
   args.pageScope = "featured";
   const candidate = { key: "featured-no-network", geek_id: "featured-no-network", name: "featured no network" };
   const cli = new FakeRecommendScreenCli(args, {
-    candidates: [candidate]
+    candidates: [candidate],
+    domResumeByKey: new Map([
+      ["featured-no-network", {
+        name: "featured no network",
+        school: "华中科技大学",
+        major: "软件工程",
+        company: "测试公司",
+        position: "后端工程师",
+        resumeText: "featured network miss 后应在截图失败后走 DOM 兜底。"
+      }]
+    ])
   });
   cli.waitForNetworkResumeCandidateInfo = async () => null;
+  let captureAttempted = false;
+  cli.callTextModel = async () => ({
+    passed: true,
+    reason: "dom fallback used",
+    summary: "dom fallback used"
+  });
   cli.captureResumeImage = async () => {
-    throw new Error("capture should not be called for featured scope");
+    captureAttempted = true;
+    throw new Error("capture failed for featured scope");
   };
 
   const result = await cli.run();
   assert.equal(result.status, "COMPLETED");
   assert.equal(result.result.processed_count, 1);
-  assert.equal(result.result.passed_count, 0);
-  assert.equal(result.result.skipped_count, 1);
-  assert.equal(result.result.resume_source, "network");
+  assert.equal(result.result.passed_count, 1);
+  assert.equal(result.result.skipped_count, 0);
+  assert.equal(result.result.resume_source, "dom_fallback");
+  assert.equal(captureAttempted, true);
+  assert.equal(cli.passedCandidates[0].resumeSource, "dom_fallback");
 }
 
 async function testFeaturedFavoriteShouldNotUseDomFallback() {
@@ -1461,14 +1483,14 @@ async function main() {
   await testTargetCountShouldNotTreatProcessedCountAsReached();
   await testFeaturedShouldUseNetworkResumeOnly();
   await testRecommendShouldPreferNetworkResumeWhenAvailable();
-  await testNetworkMissShouldFallbackToDomBeforeImageCapture();
+  await testNetworkMissShouldFallbackToImageThenDom();
   await testNetworkMissShouldFallbackToImageCapture();
   await testLatestShouldPreferNetworkResumeWhenAvailable();
   await testLatestNetworkMissShouldFallbackToImageCapture();
   testLatestPayloadShouldNotLeakAcrossCandidates();
   testLatestPayloadShouldRemainAvailableWhenCandidateKeyMissing();
   await testVisionModelFailureShouldSkipCandidateAndContinue();
-  await testFeaturedNetworkMissShouldSkipWithoutImageCapture();
+  await testFeaturedNetworkMissShouldFallbackToDomAfterImageFailure();
   await testFeaturedFavoriteShouldNotUseDomFallback();
   await testFeaturedFavoriteShouldSkipClickWhenAlreadyInterested();
   await testFeaturedFavoriteShouldRecognizeAlreadyFavoritedByDelThenAdd();