@reconcrap/boss-recommend-mcp 1.1.0 → 1.1.2

package/package.json

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

package/src/adapters.js

@@ -16,6 +16,7 @@ const screenConfigTemplateDefaults = {
   apiKey: "replace-with-openai-api-key",
   model: "gpt-4.1-mini"
 };
+const DEFAULT_RECOMMEND_SCREEN_TIMEOUT_MS = 24 * 60 * 60 * 1000;
 
 function getCodexHome() {
   return process.env.CODEX_HOME
@@ -830,7 +831,39 @@ function parseJsonOutput(text) {
   return null;
 }
 
-function parseScreenProgressLine(line, currentProgress = {}) {
+function createScreenProgressTracker(currentTracker = {}) {
+  const outcome = String(currentTracker.outcome || "").trim();
+  return {
+    candidate_index: Number.isInteger(currentTracker.candidate_index) ? currentTracker.candidate_index : null,
+    outcome: outcome === "pass" || outcome === "skip" ? outcome : null,
+    action_failed: currentTracker.action_failed === true
+  };
+}
+
+function finalizeCandidateProgress(progress, tracker) {
+  if (!Number.isInteger(tracker.candidate_index)) {
+    return false;
+  }
+
+  let changed = false;
+  if (tracker.action_failed === true) {
+    progress.skipped += 1;
+    changed = true;
+  } else if (tracker.outcome === "pass") {
+    progress.passed += 1;
+    changed = true;
+  } else if (tracker.outcome === "skip") {
+    progress.skipped += 1;
+    changed = true;
+  }
+
+  tracker.candidate_index = null;
+  tracker.outcome = null;
+  tracker.action_failed = false;
+  return changed;
+}
+
+function parseScreenProgressLine(line, currentProgress = {}, currentTracker = {}) {
   const normalizedLine = String(line || "").replace(/\s+/g, " ").trim();
   if (!normalizedLine) return null;
 
@@ -840,23 +873,56 @@ function parseScreenProgressLine(line, currentProgress = {}) {
     skipped: Number.isInteger(currentProgress.skipped) ? currentProgress.skipped : 0,
     greet_count: Number.isInteger(currentProgress.greet_count) ? currentProgress.greet_count : 0
   };
+  const nextTracker = createScreenProgressTracker(currentTracker);
 
   let changed = false;
   const processedMatch = normalizedLine.match(/处理第\s*(\d+)\s*位候选人/u);
   if (processedMatch) {
+    if (finalizeCandidateProgress(nextProgress, nextTracker)) {
+      changed = true;
+    }
     const processed = Number.parseInt(processedMatch[1], 10);
     if (Number.isInteger(processed) && processed >= 0 && processed !== nextProgress.processed) {
       nextProgress.processed = processed;
       changed = true;
     }
+    nextTracker.candidate_index = processed;
+    nextTracker.outcome = null;
+    nextTracker.action_failed = false;
   }
 
   if (/筛选结果:\s*通过/u.test(normalizedLine)) {
-    nextProgress.passed += 1;
-    changed = true;
+    if (nextTracker.outcome !== "pass" || nextTracker.action_failed) {
+      changed = true;
+    }
+    nextTracker.outcome = "pass";
+    nextTracker.action_failed = false;
   } else if (/筛选结果:\s*不通过/u.test(normalizedLine)) {
-    nextProgress.skipped += 1;
-    changed = true;
+    if (nextTracker.outcome !== "skip" || nextTracker.action_failed) {
+      changed = true;
+    }
+    nextTracker.outcome = "skip";
+    nextTracker.action_failed = false;
+  }
+
+  if (/候选人处理失败\s*:/u.test(normalizedLine)) {
+    if (!nextTracker.action_failed) {
+      changed = true;
+    }
+    nextTracker.action_failed = true;
+  }
+
+  if (/^\[关闭详情\].*成功/u.test(normalizedLine)) {
+    if (finalizeCandidateProgress(nextProgress, nextTracker)) {
+      changed = true;
+    }
+  }
+
+  const finalStateLine = /Process timed out after|status"\s*:\s*"(?:COMPLETED|PAUSED|FAILED)"/iu.test(normalizedLine);
+  if (finalStateLine) {
+    if (finalizeCandidateProgress(nextProgress, nextTracker)) {
+      changed = true;
+    }
   }
 
   const greetMatch = normalizedLine.match(/greet[_\s-]*count\s*[:=]\s*(\d+)/iu);
@@ -871,7 +937,34 @@ function parseScreenProgressLine(line, currentProgress = {}) {
   if (!changed) return null;
   return {
     line: normalizedLine,
-    progress: nextProgress
+    progress: nextProgress,
+    tracker: nextTracker
+  };
+}
+
+function resolveRecommendScreenTimeoutMs(runtime = null) {
+  const runtimeTimeoutMs = parsePositiveInteger(runtime?.timeoutMs);
+  const envTimeoutMs = parsePositiveInteger(process.env.BOSS_RECOMMEND_SCREEN_TIMEOUT_MS);
+  return runtimeTimeoutMs || envTimeoutMs || DEFAULT_RECOMMEND_SCREEN_TIMEOUT_MS;
+}
+
+function buildRecommendScreenProcessError(result, screenTimeoutMs) {
+  if (result.code === 0) return null;
+  if (result.error_code === "TIMEOUT") {
+    return {
+      code: "TIMEOUT",
+      message: `推荐页筛选命令执行超时（${screenTimeoutMs}ms）。`
+    };
+  }
+  if (result.error_code === "ABORTED") {
+    return {
+      code: "PROCESS_ABORTED",
+      message: "推荐页筛选命令已取消。"
+    };
+  }
+  return {
+    code: "RECOMMEND_SCREEN_FAILED",
+    message: "推荐页筛选命令执行失败。"
   };
 }
 
@@ -1683,21 +1776,24 @@ export async function runRecommendScreenCli({ workspaceRoot, screenParams, resum
     skipped: 0,
     greet_count: 0
   };
+  let inferredTracker = createScreenProgressTracker();
+  const screenTimeoutMs = resolveRecommendScreenTimeoutMs(runtime);
 
   const result = await runProcess({
     command: "node",
     args,
     cwd: screenDir,
-    timeoutMs: 60 * 60 * 1000,
+    timeoutMs: screenTimeoutMs,
     heartbeatIntervalMs: runtime?.heartbeatIntervalMs,
     signal: runtime?.signal,
     onOutput: (event) => {
       safeInvokeCallback(runtime?.onOutput, event);
     },
     onLine: (event) => {
-      const parsed = parseScreenProgressLine(event?.line, inferredProgress);
+      const parsed = parseScreenProgressLine(event?.line, inferredProgress, inferredTracker);
       if (!parsed) return;
       inferredProgress = parsed.progress;
+      inferredTracker = parsed.tracker;
       safeInvokeCallback(runtime?.onProgress, {
         ...inferredProgress,
         line: parsed.line
@@ -1731,24 +1827,14 @@ export async function runRecommendScreenCli({ workspaceRoot, screenParams, resum
     stderr: result.stderr,
     structured,
     summary,
-    error: structured?.error || missingOutputError || (
-      result.code === 0
-        ? null
-        : result.error_code === "ABORTED"
-          ? {
-              code: "PROCESS_ABORTED",
-              message: "推荐页筛选命令已取消。"
-            }
-          : {
-              code: "RECOMMEND_SCREEN_FAILED",
-              message: "推荐页筛选命令执行失败。"
-            }
-    )
+    error: structured?.error || missingOutputError || buildRecommendScreenProcessError(result, screenTimeoutMs)
   };
 }
 
 export const __testables = {
   runProcess,
   parseJsonOutput,
-  parseScreenProgressLine
+  parseScreenProgressLine,
+  resolveRecommendScreenTimeoutMs,
+  buildRecommendScreenProcessError
 };

package/src/parser.js

@@ -192,7 +192,10 @@ function expandDegreeAtOrAbove(value) {
 function parseDegreeSelectionsFromText(text) {
   const normalizedText = normalizeText(text);
   if (!normalizedText) return [];
-  if (/(?:学历|学位|教育)[^。；;\n]{0,6}不限|不限[^。；;\n]{0,6}(?:学历|学位|教育)/i.test(normalizedText)) {
+  if (
+    /(?:学历|学位|教育)(?:要求)?\s*(?:[:：]\s*)?(?:不限|不限制|无要求)|(?:不限|不限制)\s*(?:[:：]\s*)?(?:学历|学位|教育)(?:要求)?/i
+      .test(normalizedText)
+  ) {
     return ["不限"];
   }
 

package/src/test-adapters-runtime.js

@@ -4,7 +4,13 @@ import os from "node:os";
 import path from "node:path";
 import { runRecommendScreenCli, __testables as adapterTestables } from "./adapters.js";
 
-const { runProcess, parseJsonOutput } = adapterTestables;
+const {
+  runProcess,
+  parseJsonOutput,
+  parseScreenProgressLine,
+  resolveRecommendScreenTimeoutMs,
+  buildRecommendScreenProcessError
+} = adapterTestables;
 
 async function testRunProcessHeartbeatAndOutput() {
   const heartbeats = [];
@@ -57,6 +63,50 @@ function testParsePausedStructuredOutput() {
   assert.equal(parsed?.result?.processed_count, 3);
 }
 
+function testParseScreenProgressLineShouldCountFavoriteFailureAsSkipped() {
+  let progress = { processed: 0, passed: 0, skipped: 0, greet_count: 0 };
+  let tracker = {};
+  const feed = (line) => {
+    const parsed = parseScreenProgressLine(line, progress, tracker);
+    if (!parsed) return;
+    progress = parsed.progress;
+    tracker = parsed.tracker;
+  };
+
+  feed("处理第 1 位候选人: 甲");
+  feed("筛选结果: 通过");
+  feed("[关闭详情] 成功: no popup or detail signal visible");
+  feed("处理第 2 位候选人: 乙");
+  feed("筛选结果: 通过");
+  feed("候选人处理失败: FAVORITE_BUTTON_FAILED");
+  feed("[关闭详情] 成功: no popup or detail signal visible");
+
+  assert.equal(progress.processed, 2);
+  assert.equal(progress.passed, 1);
+  assert.equal(progress.skipped, 1);
+}
+
+function testResolveScreenTimeoutDefaultsTo24Hours() {
+  const previous = process.env.BOSS_RECOMMEND_SCREEN_TIMEOUT_MS;
+  delete process.env.BOSS_RECOMMEND_SCREEN_TIMEOUT_MS;
+  try {
+    assert.equal(resolveRecommendScreenTimeoutMs(null), 24 * 60 * 60 * 1000);
+    assert.equal(resolveRecommendScreenTimeoutMs({ timeoutMs: 1234 }), 1234);
+  } finally {
+    if (previous === undefined) {
+      delete process.env.BOSS_RECOMMEND_SCREEN_TIMEOUT_MS;
+    } else {
+      process.env.BOSS_RECOMMEND_SCREEN_TIMEOUT_MS = previous;
+    }
+  }
+}
+
+function testBuildRecommendScreenProcessErrorMapsTimeout() {
+  const error = buildRecommendScreenProcessError({ code: -1, error_code: "TIMEOUT" }, 86400000);
+  assert.equal(error?.code, "TIMEOUT");
+  assert.equal(String(error?.message || "").includes("86400000"), true);
+}
+
 async function testResumeRequiresCheckpointFile() {
   const previousHome = process.env.BOSS_RECOMMEND_HOME;
   const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-resume-"));
@@ -103,6 +153,9 @@ async function main() {
   await testRunProcessHeartbeatAndOutput();
   await testRunProcessAbortSignal();
   testParsePausedStructuredOutput();
+  testParseScreenProgressLineShouldCountFavoriteFailureAsSkipped();
+  testResolveScreenTimeoutDefaultsTo24Hours();
+  testBuildRecommendScreenProcessErrorMapsTimeout();
   await testResumeRequiresCheckpointFile();
   console.log("adapters runtime tests passed");
 }

package/src/test-parser.js

@@ -172,6 +172,17 @@ function testDegreeAtOrAboveExpansion() {
   assert.deepEqual(result.searchParams.degree, ["大专", "本科", "硕士", "博士"]);
 }
 
+function testDegreeShouldNotBeOverwrittenBySchoolTagUnlimitedClause() {
+  const result = parseRecommendInstruction({
+    instruction: "学校标签不限，学历要求大专及以上，性别不限，过滤近14天已看",
+    confirmation: null,
+    overrides: null
+  });
+
+  assert.deepEqual(result.searchParams.school_tag, ["不限"]);
+  assert.deepEqual(result.searchParams.degree, ["大专", "本科", "硕士", "博士"]);
+}
+
 function testDegreeExplicitListOnly() {
   const result = parseRecommendInstruction({
     instruction: "推荐页筛选大专、本科，近14天没有，有Agent经验",
@@ -420,6 +431,7 @@ function main() {
   testMultipleSchoolTagsMarkedSuspicious();
   testDegreeCanBeExtracted();
   testDegreeAtOrAboveExpansion();
+  testDegreeShouldNotBeOverwrittenBySchoolTagUnlimitedClause();
   testDegreeExplicitListOnly();
   testDegreeOverrideCanBeArray();
   testSchoolTagOverrideCanBeArray();

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

@@ -9,6 +9,9 @@ const { captureFullResumeCanvas } = require("./scripts/capture-full-resume-canva
 const DEFAULT_PORT = 9222;
 const RECOMMEND_URL_FRAGMENT = "/web/chat/recommend";
 const CSV_HEADER = ["姓名", "最高学历学校", "最高学历专业", "最近工作公司", "最近工作职位", "评估通过详细原因"].join(",");
+const RESUME_CAPTURE_WAIT_MS = 60000;
+const RESUME_CAPTURE_MAX_ATTEMPTS = 4;
+const RESUME_CAPTURE_RETRY_DELAY_MS = 1200;
 
 function log(...args) {
   console.error(...args);
@@ -1531,18 +1534,40 @@ class RecommendScreenCli {
   }
 
   async captureResumeImage(candidate) {
-    const outPrefix = path.join(this.debugDir, `${candidate.geek_id}_${Date.now()}`);
-    try {
-      return await captureFullResumeCanvas({
-        port: this.args.port,
-        outPrefix,
-        targetPattern: RECOMMEND_URL_FRAGMENT,
-        waitResumeMs: 30000,
-        scrollSettleMs: 500
-      });
-    } catch (error) {
-      throw this.buildError("RESUME_CAPTURE_FAILED", error.message || "Failed to capture resume image.");
+    const candidateLabel = normalizeText(candidate?.geek_id || candidate?.name || "unknown");
+    const candidateKey = String(candidate?.geek_id || candidate?.name || "candidate")
+      .replace(/[^\w.-]+/g, "_")
+      .slice(0, 80) || "candidate";
+    const attemptSummaries = [];
+    let lastError = null;
+
+    for (let attempt = 1; attempt <= RESUME_CAPTURE_MAX_ATTEMPTS; attempt += 1) {
+      const outPrefix = path.join(this.debugDir, `${candidateKey}_${Date.now()}_a${attempt}`);
+      try {
+        return await captureFullResumeCanvas({
+          port: this.args.port,
+          outPrefix,
+          targetPattern: RECOMMEND_URL_FRAGMENT,
+          waitResumeMs: RESUME_CAPTURE_WAIT_MS,
+          scrollSettleMs: 500
+        });
+      } catch (error) {
+        lastError = error;
+        const message = normalizeText(error?.message || String(error) || "Failed to capture resume image.");
+        attemptSummaries.push(`a${attempt}/${RESUME_CAPTURE_MAX_ATTEMPTS}:${message.slice(0, 320)}`);
+        log(`[简历截图失败] candidate=${candidateLabel} attempt=${attempt}/${RESUME_CAPTURE_MAX_ATTEMPTS} error=${message}`);
+        if (attempt < RESUME_CAPTURE_MAX_ATTEMPTS) {
+          await sleep(RESUME_CAPTURE_RETRY_DELAY_MS);
+        }
+      }
     }
+
+    const lastMessage = normalizeText(lastError?.message || "Failed to capture resume image.");
+    const attemptsText = attemptSummaries.join(" | ");
+    throw this.buildError(
+      "RESUME_CAPTURE_FAILED",
+      `Resume capture failed after ${RESUME_CAPTURE_MAX_ATTEMPTS} attempts; last_error=${lastMessage}; attempts=${attemptsText}`
+    );
   }
 
   async callVisionModel(imagePath) {

package/vendor/boss-recommend-screen-cli/scripts/capture-full-resume-canvas.cjs

@@ -39,6 +39,36 @@ function pickTarget(targets, targetPattern) {
   );
 }
 
+function oneLineJson(value, maxLength = 1200) {
+  try {
+    const text = JSON.stringify(value);
+    if (text.length <= maxLength) return text;
+    return `${text.slice(0, maxLength)}...`;
+  } catch {
+    return "\"<unserializable>\"";
+  }
+}
+
+function summarizeProbeReason(probe) {
+  if (!probe || typeof probe !== "object") return "NO_PROBE";
+  if (probe.ok === true) return "INVALID_CLIP";
+  return String(probe.reason || "UNKNOWN");
+}
+
+function buildResumeProbeTimeoutMessage(waitResumeMs, probe) {
+  const reason = summarizeProbeReason(probe);
+  const payload = {
+    reason,
+    clip: probe?.clip || null,
+    scroll_top: Number.isFinite(Number(probe?.scrollTop)) ? Number(probe.scrollTop) : null,
+    client_height: Number.isFinite(Number(probe?.clientHeight)) ? Number(probe.clientHeight) : null,
+    scroll_height: Number.isFinite(Number(probe?.scrollHeight)) ? Number(probe.scrollHeight) : null,
+    max_scroll: Number.isFinite(Number(probe?.maxScroll)) ? Number(probe.maxScroll) : null,
+    debug: probe?.debug || null
+  };
+  return `Resume canvas not found: wait_resume_ms=${waitResumeMs}; last_reason=${reason}; probe=${oneLineJson(payload)}`;
+}
+
 function buildResumeProbeExpr({ init, targetScroll }) {
   const initLiteral = init ? "true" : "false";
   const scrollLiteral = typeof targetScroll === "number" && Number.isFinite(targetScroll)
@@ -110,12 +140,22 @@ function buildResumeProbeExpr({ init, targetScroll }) {
         || document.querySelector('iframe');
       const recommendDoc = recommendFrame && recommendFrame.contentDocument;
       if (!recommendFrame || !recommendDoc) {
-        return { ok: false, reason: 'NO_RECOMMEND_IFRAME' };
+        return {
+          ok: false,
+          reason: 'NO_RECOMMEND_IFRAME',
+          debug: {
+            topIframeCount: document.querySelectorAll('iframe').length
+          }
+        };
       }
 
       const scopes = Array.from(
         recommendDoc.querySelectorAll('.dialog-wrap.active, .boss-popup__wrapper.boss-dialog, .boss-dialog__wrapper')
       ).filter(isVisible);
+      const allResumeFrames = Array.from(
+        recommendDoc.querySelectorAll('iframe[src*="/web/frame/c-resume/"], iframe[name*="resume"]')
+      );
+      const visibleResumeFrames = allResumeFrames.filter(isVisible);
 
       let resumeFrame = null;
       for (const scope of scopes) {
@@ -127,13 +167,22 @@ function buildResumeProbeExpr({ init, targetScroll }) {
       }
 
       if (!resumeFrame) {
-        resumeFrame = Array.from(
-          recommendDoc.querySelectorAll('iframe[src*="/web/frame/c-resume/"], iframe[name*="resume"]')
-        ).find(isVisible) || null;
+        resumeFrame = visibleResumeFrames[0] || null;
       }
 
       if (!resumeFrame) {
-        return { ok: false, reason: 'NO_CRESUME_IFRAME' };
+        return {
+          ok: false,
+          reason: 'NO_CRESUME_IFRAME',
+          debug: {
+            activeScopeCount: scopes.length,
+            totalResumeIframes: allResumeFrames.length,
+            visibleResumeIframes: visibleResumeFrames.length,
+            recommendFrameUrl: (() => {
+              try { return String(recommendFrame.contentWindow.location.href || ''); } catch { return ''; }
+            })()
+          }
+        };
       }
 
       const resumeDoc = resumeFrame.contentDocument;
@@ -143,7 +192,19 @@ function buildResumeProbeExpr({ init, targetScroll }) {
         || chooseScrollableAncestor(resumeFrame)
         || null;
       if (!scroller || !isVisible(scroller)) {
-        return { ok: false, reason: 'NO_SCROLL_CONTAINER' };
+        return {
+          ok: false,
+          reason: 'NO_SCROLL_CONTAINER',
+          debug: {
+            activeScopeCount: scopes.length,
+            totalResumeIframes: allResumeFrames.length,
+            visibleResumeIframes: visibleResumeFrames.length,
+            resumeFrameSrc: String(resumeFrame.src || ''),
+            scrollerFound: Boolean(scroller),
+            scrollerVisible: Boolean(scroller && isVisible(scroller)),
+            scrollerClass: scroller ? String(scroller.className || '') : ''
+          }
+        };
       }
 
       return {
@@ -285,9 +346,23 @@ async function captureFullResumeCanvas(options = {}) {
     await send("Page.bringToFront");
 
     let probe = null;
+    let lastProbe = null;
     const startTime = Date.now();
     while (Date.now() - startTime < waitResumeMs) {
-      probe = await evaluate(buildResumeProbeExpr({ init: true, targetScroll: 0 }));
+      try {
+        probe = await evaluate(buildResumeProbeExpr({ init: true, targetScroll: 0 }));
+      } catch (error) {
+        probe = {
+          ok: false,
+          reason: "PROBE_EVALUATE_FAILED",
+          debug: {
+            message: String(error?.message || error || "unknown")
+          }
+        };
+      }
+      if (probe && typeof probe === "object") {
+        lastProbe = probe;
+      }
       if (probe?.ok && probe.clip?.height > 80 && probe.clip?.width > 120) {
         break;
       }
@@ -295,7 +370,7 @@ async function captureFullResumeCanvas(options = {}) {
     }
 
     if (!probe?.ok) {
-      throw new Error(`Resume canvas not found in ${waitResumeMs}ms.`);
+      throw new Error(buildResumeProbeTimeoutMessage(waitResumeMs, lastProbe || probe));
     }
 
     const maxScroll = Math.max(0, Number(probe.maxScroll || 0));