@reconcrap/boss-recommend-mcp 1.1.1 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reconcrap/boss-recommend-mcp",
-  "version": "1.1.1",
+  "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();