@reconcrap/boss-recommend-mcp 1.2.2 → 1.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reconcrap/boss-recommend-mcp",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "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

@@ -690,6 +690,121 @@ function parseGeekIdFromUrl(url) {
   return null;
 }
 
+function collectGeekIdsFromPayload(payload, fallbackGeekId = null) {
+  if (!payload || typeof payload !== "object") return [];
+  const geekDetail = payload?.geekDetail || payload;
+  const baseInfo = geekDetail?.geekBaseInfo || {};
+  const ids = [
+    fallbackGeekId,
+    baseInfo.geekId,
+    baseInfo.encryptGeekId,
+    baseInfo.securityId,
+    geekDetail?.geekId,
+    geekDetail?.encryptGeekId,
+    geekDetail?.securityId,
+    payload?.geekId,
+    payload?.encryptGeekId,
+    payload?.securityId
+  ].map((value) => normalizeText(value)).filter(Boolean);
+  return Array.from(new Set(ids));
+}
+
+function hasResumePayloadShape(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return false;
+  const geekDetail = payload?.geekDetail && typeof payload.geekDetail === "object"
+    ? payload.geekDetail
+    : payload;
+  const baseInfo = geekDetail?.geekBaseInfo || {};
+  const hasIdentity = Boolean(
+    normalizeText(
+      baseInfo?.name
+      || geekDetail?.geekName
+      || payload?.geekName
+      || baseInfo?.geekId
+      || baseInfo?.encryptGeekId
+      || baseInfo?.securityId
+      || geekDetail?.geekId
+      || geekDetail?.encryptGeekId
+      || geekDetail?.securityId
+      || payload?.geekId
+      || payload?.encryptGeekId
+      || payload?.securityId
+      || ""
+    )
+  );
+  const hasResumeSections = [
+    geekDetail?.geekExpectList,
+    geekDetail?.geekWorkExpList,
+    geekDetail?.geekProjExpList,
+    geekDetail?.geekEduExpList,
+    geekDetail?.geekEducationList,
+    geekDetail?.geekSkillList
+  ].some((section) => Array.isArray(section) && section.length > 0);
+  const hasResumeTextFields = Boolean(
+    normalizeText(
+      geekDetail?.geekAdvantage
+      || baseInfo?.userDesc
+      || baseInfo?.userDescription
+      || ""
+    )
+  );
+  return hasIdentity && (hasResumeSections || hasResumeTextFields);
+}
+
+function findResumePayloadInObject(root, maxDepth = 4, visited = new Set()) {
+  if (root === null || root === undefined || maxDepth < 0) return null;
+  if (typeof root !== "object") return null;
+  if (visited.has(root)) return null;
+  visited.add(root);
+
+  if (hasResumePayloadShape(root)) {
+    return root;
+  }
+
+  if (maxDepth === 0) return null;
+
+  if (Array.isArray(root)) {
+    for (const item of root) {
+      const found = findResumePayloadInObject(item, maxDepth - 1, visited);
+      if (found) return found;
+    }
+    return null;
+  }
+
+  const priorityKeys = [
+    "zpData",
+    "data",
+    "result",
+    "geekDetail",
+    "detail",
+    "info"
+  ];
+  for (const key of priorityKeys) {
+    if (!(key in root)) continue;
+    const found = findResumePayloadInObject(root[key], maxDepth - 1, visited);
+    if (found) return found;
+  }
+
+  for (const value of Object.values(root)) {
+    const found = findResumePayloadInObject(value, maxDepth - 1, visited);
+    if (found) return found;
+  }
+  return null;
+}
+
+function extractResumePayloadFromResponseBody(parsedBody) {
+  return findResumePayloadInObject(parsedBody, 4) || null;
+}
+
+function isResumeInfoRequestUrl(url) {
+  const normalizedUrl = normalizeText(url).toLowerCase();
+  if (!normalizedUrl || !normalizedUrl.includes("/wapi/")) return false;
+  if (!normalizedUrl.includes("geek") || !normalizedUrl.includes("info")) return false;
+  if (/\/boss\/[^?#]*\/geek\/info\b/.test(normalizedUrl)) return true;
+  if (/\/geek\/info\b/.test(normalizedUrl)) return true;
+  return /[?&](?:geekid|geek_id|encryptgeekid|securityid)=/.test(normalizedUrl);
+}
+
 function formatResumeApiData(data) {
   const parts = [];
   const geekDetail = data?.geekDetail || data || {};
@@ -2074,14 +2189,8 @@ class RecommendScreenCli {
     if (!payload || typeof payload !== "object") return;
     const geekDetail = payload.geekDetail || payload;
     const baseInfo = geekDetail.geekBaseInfo || {};
-    const geekId = normalizeText(
-      fallbackGeekId
-      || baseInfo.geekId
-      || baseInfo.encryptGeekId
-      || geekDetail.geekId
-      || payload.geekId
-      || ""
-    ) || null;
+    const geekIds = collectGeekIdsFromPayload(payload, fallbackGeekId);
+    const geekId = geekIds[0] || null;
     const candidateInfo = {
       name: baseInfo.name || geekDetail.geekName || payload.geekName || "",
       school: (geekDetail.geekEduExpList && geekDetail.geekEduExpList[0]?.school)
@@ -2093,17 +2202,18 @@ class RecommendScreenCli {
       company: (geekDetail.geekWorkExpList && geekDetail.geekWorkExpList[0]?.company) || "",
       position: (geekDetail.geekWorkExpList && geekDetail.geekWorkExpList[0]?.positionName) || "",
       resumeText: formatResumeApiData(payload),
-      alreadyInterested: payload.alreadyInterested === true
+      alreadyInterested: payload.alreadyInterested === true || geekDetail.alreadyInterested === true
     };
     const wrapped = {
       ts: Date.now(),
       geekId: geekId || null,
+      geekIds,
       data: payload,
       candidateInfo
     };
     this.latestResumeNetworkPayload = wrapped;
-    if (geekId) {
-      this.resumeNetworkByGeekId.set(geekId, wrapped);
+    for (const id of geekIds) {
+      this.resumeNetworkByGeekId.set(id, wrapped);
     }
   }
 
@@ -2136,7 +2246,7 @@ class RecommendScreenCli {
   handleNetworkRequestWillBeSent(params) {
     const url = normalizeText(params?.request?.url || "");
     if (!url) return;
-    if (url.includes("/wapi/zpitem/web/boss/search/geek/info")) {
+    if (isResumeInfoRequestUrl(url)) {
       const geekId = parseGeekIdFromUrl(url);
       this.resumeNetworkRequests.set(params.requestId, {
         ts: Date.now(),
@@ -2206,9 +2316,13 @@ class RecommendScreenCli {
     try {
       const responseBody = await this.Network.getResponseBody({ requestId: params.requestId });
       if (!responseBody?.body) return;
-      const parsed = JSON.parse(responseBody.body);
-      if (parsed?.zpData) {
-        this.cacheResumeNetworkPayload(parsed.zpData, requestMeta.geekId);
+      const rawBody = responseBody.base64Encoded
+        ? Buffer.from(responseBody.body, "base64").toString("utf8")
+        : responseBody.body;
+      const parsed = JSON.parse(rawBody);
+      const resumePayload = extractResumePayloadFromResponseBody(parsed);
+      if (resumePayload) {
+        this.cacheResumeNetworkPayload(resumePayload, requestMeta.geekId);
       }
     } catch {}
   }
@@ -3457,10 +3571,11 @@ class RecommendScreenCli {
           }
 
           const isFeaturedScope = this.args.pageScope === "featured";
+          const allowImageFallback = !isFeaturedScope;
           let capture = null;
           let screening = null;
           let resumeSource = isFeaturedScope ? "network" : "image_fallback";
-          const networkCandidateInfo = await this.waitForNetworkResumeCandidateInfo(nextCandidate, 2400);
+          const networkCandidateInfo = await this.waitForNetworkResumeCandidateInfo(nextCandidate, allowImageFallback ? 4200 : 2400);
           const candidateProfile = {
             name: networkCandidateInfo?.name || nextCandidate.name || "",
             school: networkCandidateInfo?.school || nextCandidate.school || "",
@@ -3479,6 +3594,10 @@ class RecommendScreenCli {
             screening = await this.callTextModel(networkCandidateInfo.resumeText);
             resumeSource = "network";
             this.resumeSourceStats.network += 1;
+          } else if (networkCandidateInfo?.resumeText) {
+            screening = await this.callTextModel(networkCandidateInfo.resumeText);
+            resumeSource = "network";
+            this.resumeSourceStats.network += 1;
           } else {
             capture = await this.captureResumeImage(nextCandidate);
             screening = await this.callVisionModel(capture.stitchedImage);

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

@@ -338,29 +338,28 @@ async function testFeaturedShouldUseNetworkResumeOnly() {
   assert.equal(result.result.resume_source, "network");
 }
 
-async function testRecommendShouldKeepImageCaptureEvenWhenNetworkResumeExists() {
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-recommend-image-main-"));
-  const candidate = { key: "img-main-1", geek_id: "img-main-1", name: "recommend image main candidate" };
+async function testRecommendShouldPreferNetworkResumeWhenAvailable() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-recommend-network-main-"));
+  const candidate = { key: "net-main-1", geek_id: "net-main-1", name: "recommend network main candidate" };
   const cli = new FakeRecommendScreenCli(createArgs(tempDir), {
-    candidates: [candidate],
-    captureOutcomes: new Map([
-      ["img-main-1", { stitchedImage: path.join(tempDir, "img-main-1.png") }]
-    ]),
-    screeningByKey: new Map([
-      ["img-main-1", { passed: true, reason: "image path used", summary: "image path used" }]
-    ])
+    candidates: [candidate]
   });
   cli.waitForNetworkResumeCandidateInfo = async () => ({
-    resumeText: "这段 network 文本在 recommend 页面不应被用于筛选"
+    resumeText: "这段 network 文本在 recommend 页面应优先用于筛选"
   });
-  cli.callTextModel = async () => {
-    throw new Error("text model should not be called for recommend scope");
+  cli.callTextModel = async () => ({
+    passed: true,
+    reason: "network used",
+    summary: "network used"
+  });
+  cli.captureResumeImage = async () => {
+    throw new Error("capture should not be called when recommend network resume exists");
   };
 
   const result = await cli.run();
   assert.equal(result.status, "COMPLETED");
   assert.equal(result.result.passed_count, 1);
-  assert.equal(result.result.resume_source, "image_fallback");
+  assert.equal(result.result.resume_source, "network");
 }
 
 async function testNetworkMissShouldFallbackToImageCapture() {
@@ -382,6 +381,53 @@ async function testNetworkMissShouldFallbackToImageCapture() {
   assert.equal(result.result.resume_source, "image_fallback");
 }
 
+async function testLatestShouldPreferNetworkResumeWhenAvailable() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-latest-network-main-"));
+  const args = createArgs(tempDir);
+  args.pageScope = "latest";
+  const candidate = { key: "latest-net-1", geek_id: "latest-net-1", name: "latest network candidate" };
+  const cli = new FakeRecommendScreenCli(args, {
+    candidates: [candidate]
+  });
+  cli.waitForNetworkResumeCandidateInfo = async () => ({
+    resumeText: "最新页 network 简历可用"
+  });
+  cli.callTextModel = async () => ({
+    passed: true,
+    reason: "network used",
+    summary: "network used"
+  });
+  cli.captureResumeImage = async () => {
+    throw new Error("capture should not be called when latest network resume exists");
+  };
+
+  const result = await cli.run();
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(result.result.passed_count, 1);
+  assert.equal(result.result.resume_source, "network");
+}
+
+async function testLatestNetworkMissShouldFallbackToImageCapture() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-latest-network-fallback-"));
+  const args = createArgs(tempDir);
+  args.pageScope = "latest";
+  const candidate = { key: "latest-img-1", geek_id: "latest-img-1", name: "latest image candidate" };
+  const cli = new FakeRecommendScreenCli(args, {
+    candidates: [candidate],
+    captureOutcomes: new Map([
+      ["latest-img-1", { stitchedImage: path.join(tempDir, "latest-img-1.png") }]
+    ]),
+    screeningByKey: new Map([
+      ["latest-img-1", { passed: false, reason: "image fallback used", summary: "image fallback used" }]
+    ])
+  });
+  cli.waitForNetworkResumeCandidateInfo = async () => null;
+
+  const result = await cli.run();
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(result.result.resume_source, "image_fallback");
+}
+
 async function testVisionModelFailureShouldSkipCandidateAndContinue() {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-vision-failure-skip-"));
   const first = { key: "vision-fail-1", geek_id: "vision-fail-1", name: "vision-fail-1" };
@@ -803,8 +849,10 @@ async function main() {
   await testPageExhaustedBeforeTargetShouldRaiseRecoverableError();
   await testPageExhaustedWithoutTargetShouldStillComplete();
   await testFeaturedShouldUseNetworkResumeOnly();
-  await testRecommendShouldKeepImageCaptureEvenWhenNetworkResumeExists();
+  await testRecommendShouldPreferNetworkResumeWhenAvailable();
   await testNetworkMissShouldFallbackToImageCapture();
+  await testLatestShouldPreferNetworkResumeWhenAvailable();
+  await testLatestNetworkMissShouldFallbackToImageCapture();
   await testVisionModelFailureShouldSkipCandidateAndContinue();
   await testFeaturedNetworkMissShouldSkipWithoutImageCapture();
   await testFeaturedFavoriteShouldNotUseDomFallback();