@reconcrap/boss-recommend-mcp 1.1.3 → 1.1.4

package/src/test-run-state.js

@@ -1,152 +1,152 @@
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import {
-  RUN_MODE_ASYNC,
-  RUN_STATE_PAUSED,
-  RUN_STAGE_SCREEN,
-  RUN_STATE_COMPLETED,
-  RUN_STATE_QUEUED,
-  RUN_STATE_RUNNING,
-  cleanupExpiredRuns,
-  createRunId,
-  createRunStateSnapshot,
-  getRunsDir,
-  readRunState,
-  touchRunHeartbeat,
-  updateRunProgress,
-  updateRunState,
-  writeRunState
-} from "./run-state.js";
-
-function withTempHome(testFn) {
-  const previous = process.env.BOSS_RECOMMEND_HOME;
-  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-run-state-"));
-  process.env.BOSS_RECOMMEND_HOME = tempHome;
-  try {
-    testFn(tempHome);
-  } finally {
-    if (previous === undefined) {
-      delete process.env.BOSS_RECOMMEND_HOME;
-    } else {
-      process.env.BOSS_RECOMMEND_HOME = previous;
-    }
-    fs.rmSync(tempHome, { recursive: true, force: true });
-  }
-}
-
-function testRunStateLifecycle() {
-  withTempHome(() => {
-    const runId = createRunId();
-    const queued = writeRunState(createRunStateSnapshot({
-      runId,
-      mode: RUN_MODE_ASYNC,
-      state: RUN_STATE_QUEUED,
-      stage: "preflight",
-      context: {
-        workspace_root: "C:/workspace",
-        instruction: "筛选有 MCP 经验候选人",
-        confirmation: {
-          final_confirmed: true
-        }
-      },
-      control: {
-        pause_requested: false
-      },
-      resume: {
-        checkpoint_path: `C:/workspace/.state/${runId}.checkpoint.json`,
-        pause_control_path: `C:/workspace/.state/${runId}.json`,
-        output_csv: "C:/workspace/result.csv"
-      }
-    }));
-    assert.equal(queued.run_id, runId);
-    assert.equal(queued.state, RUN_STATE_QUEUED);
-    assert.equal(queued.context.workspace_root, "C:/workspace");
-    assert.equal(queued.resume.output_csv, "C:/workspace/result.csv");
-    assert.equal(queued.control.cancel_requested, false);
-
-    const running = updateRunState(runId, {
-      state: RUN_STATE_RUNNING,
-      stage: RUN_STAGE_SCREEN,
-      last_message: "screening in progress"
-    });
-    assert.equal(running.state, RUN_STATE_RUNNING);
-    assert.equal(running.stage, RUN_STAGE_SCREEN);
-    const heartbeatBeforeProgress = running.heartbeat_at;
-
-    const progressed = updateRunProgress(runId, {
-      processed: 7,
-      passed: 2,
-      skipped: 5,
-      greet_count: 1
-    });
-    assert.equal(progressed.progress.processed, 7);
-    assert.equal(progressed.progress.passed, 2);
-    assert.equal(progressed.progress.skipped, 5);
-    assert.equal(progressed.progress.greet_count, 1);
-    assert.equal(progressed.heartbeat_at, heartbeatBeforeProgress);
-
-    const paused = updateRunState(runId, {
-      state: RUN_STATE_PAUSED,
-      control: {
-        pause_requested: true,
-        pause_requested_at: "2026-01-01T00:00:00.000Z",
-        pause_requested_by: "pause_recommend_pipeline_run",
-        cancel_requested: true
-      },
-      resume: {
-        output_csv: "C:/workspace/result-partial.csv",
-        last_paused_at: "2026-01-01T00:00:01.000Z"
-      }
-    });
-    assert.equal(paused.state, RUN_STATE_PAUSED);
-    assert.equal(paused.control.pause_requested, true);
-    assert.equal(paused.control.pause_requested_by, "pause_recommend_pipeline_run");
-    assert.equal(paused.control.cancel_requested, true);
-    assert.equal(paused.resume.output_csv, "C:/workspace/result-partial.csv");
-
-    const heartbeated = touchRunHeartbeat(runId, "still running");
-    assert.equal(heartbeated.last_message, "still running");
-    assert.equal(Date.parse(heartbeated.heartbeat_at) >= Date.parse(heartbeatBeforeProgress), true);
-
-    const completed = updateRunState(runId, {
-      state: RUN_STATE_COMPLETED,
-      stage: "finalize",
-      result: {
-        status: "COMPLETED",
-        result: {
-          processed_count: 7
-        }
-      }
-    });
-    assert.equal(completed.state, RUN_STATE_COMPLETED);
-    assert.equal(completed.result.status, "COMPLETED");
-
-    const reloaded = readRunState(runId);
-    assert.equal(reloaded.state, RUN_STATE_COMPLETED);
-    assert.equal(reloaded.progress.processed, 7);
-  });
-}
-
-function testRunStateCleanup() {
-  withTempHome(() => {
-    const runId = createRunId();
-    writeRunState(createRunStateSnapshot({ runId, mode: RUN_MODE_ASYNC }));
-    const runFile = path.join(getRunsDir(), `${runId}.json`);
-    const oldSeconds = Math.floor((Date.now() - 3 * 24 * 60 * 60 * 1000) / 1000);
-    fs.utimesSync(runFile, oldSeconds, oldSeconds);
-
-    const cleaned = cleanupExpiredRuns(1000);
-    assert.equal(cleaned.removed.some((item) => item.endsWith(`${runId}.json`)), true);
-    assert.equal(fs.existsSync(runFile), false);
-  });
-}
-
-function main() {
-  testRunStateLifecycle();
-  testRunStateCleanup();
-  console.log("run-state tests passed");
-}
-
-main();
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+  RUN_MODE_ASYNC,
+  RUN_STATE_PAUSED,
+  RUN_STAGE_SCREEN,
+  RUN_STATE_COMPLETED,
+  RUN_STATE_QUEUED,
+  RUN_STATE_RUNNING,
+  cleanupExpiredRuns,
+  createRunId,
+  createRunStateSnapshot,
+  getRunsDir,
+  readRunState,
+  touchRunHeartbeat,
+  updateRunProgress,
+  updateRunState,
+  writeRunState
+} from "./run-state.js";
+
+function withTempHome(testFn) {
+  const previous = process.env.BOSS_RECOMMEND_HOME;
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-run-state-"));
+  process.env.BOSS_RECOMMEND_HOME = tempHome;
+  try {
+    testFn(tempHome);
+  } finally {
+    if (previous === undefined) {
+      delete process.env.BOSS_RECOMMEND_HOME;
+    } else {
+      process.env.BOSS_RECOMMEND_HOME = previous;
+    }
+    fs.rmSync(tempHome, { recursive: true, force: true });
+  }
+}
+
+function testRunStateLifecycle() {
+  withTempHome(() => {
+    const runId = createRunId();
+    const queued = writeRunState(createRunStateSnapshot({
+      runId,
+      mode: RUN_MODE_ASYNC,
+      state: RUN_STATE_QUEUED,
+      stage: "preflight",
+      context: {
+        workspace_root: "C:/workspace",
+        instruction: "筛选有 MCP 经验候选人",
+        confirmation: {
+          final_confirmed: true
+        }
+      },
+      control: {
+        pause_requested: false
+      },
+      resume: {
+        checkpoint_path: `C:/workspace/.state/${runId}.checkpoint.json`,
+        pause_control_path: `C:/workspace/.state/${runId}.json`,
+        output_csv: "C:/workspace/result.csv"
+      }
+    }));
+    assert.equal(queued.run_id, runId);
+    assert.equal(queued.state, RUN_STATE_QUEUED);
+    assert.equal(queued.context.workspace_root, "C:/workspace");
+    assert.equal(queued.resume.output_csv, "C:/workspace/result.csv");
+    assert.equal(queued.control.cancel_requested, false);
+
+    const running = updateRunState(runId, {
+      state: RUN_STATE_RUNNING,
+      stage: RUN_STAGE_SCREEN,
+      last_message: "screening in progress"
+    });
+    assert.equal(running.state, RUN_STATE_RUNNING);
+    assert.equal(running.stage, RUN_STAGE_SCREEN);
+    const heartbeatBeforeProgress = running.heartbeat_at;
+
+    const progressed = updateRunProgress(runId, {
+      processed: 7,
+      passed: 2,
+      skipped: 5,
+      greet_count: 1
+    });
+    assert.equal(progressed.progress.processed, 7);
+    assert.equal(progressed.progress.passed, 2);
+    assert.equal(progressed.progress.skipped, 5);
+    assert.equal(progressed.progress.greet_count, 1);
+    assert.equal(progressed.heartbeat_at, heartbeatBeforeProgress);
+
+    const paused = updateRunState(runId, {
+      state: RUN_STATE_PAUSED,
+      control: {
+        pause_requested: true,
+        pause_requested_at: "2026-01-01T00:00:00.000Z",
+        pause_requested_by: "pause_recommend_pipeline_run",
+        cancel_requested: true
+      },
+      resume: {
+        output_csv: "C:/workspace/result-partial.csv",
+        last_paused_at: "2026-01-01T00:00:01.000Z"
+      }
+    });
+    assert.equal(paused.state, RUN_STATE_PAUSED);
+    assert.equal(paused.control.pause_requested, true);
+    assert.equal(paused.control.pause_requested_by, "pause_recommend_pipeline_run");
+    assert.equal(paused.control.cancel_requested, true);
+    assert.equal(paused.resume.output_csv, "C:/workspace/result-partial.csv");
+
+    const heartbeated = touchRunHeartbeat(runId, "still running");
+    assert.equal(heartbeated.last_message, "still running");
+    assert.equal(Date.parse(heartbeated.heartbeat_at) >= Date.parse(heartbeatBeforeProgress), true);
+
+    const completed = updateRunState(runId, {
+      state: RUN_STATE_COMPLETED,
+      stage: "finalize",
+      result: {
+        status: "COMPLETED",
+        result: {
+          processed_count: 7
+        }
+      }
+    });
+    assert.equal(completed.state, RUN_STATE_COMPLETED);
+    assert.equal(completed.result.status, "COMPLETED");
+
+    const reloaded = readRunState(runId);
+    assert.equal(reloaded.state, RUN_STATE_COMPLETED);
+    assert.equal(reloaded.progress.processed, 7);
+  });
+}
+
+function testRunStateCleanup() {
+  withTempHome(() => {
+    const runId = createRunId();
+    writeRunState(createRunStateSnapshot({ runId, mode: RUN_MODE_ASYNC }));
+    const runFile = path.join(getRunsDir(), `${runId}.json`);
+    const oldSeconds = Math.floor((Date.now() - 3 * 24 * 60 * 60 * 1000) / 1000);
+    fs.utimesSync(runFile, oldSeconds, oldSeconds);
+
+    const cleaned = cleanupExpiredRuns(1000);
+    assert.equal(cleaned.removed.some((item) => item.endsWith(`${runId}.json`)), true);
+    assert.equal(fs.existsSync(runFile), false);
+  });
+}
+
+function main() {
+  testRunStateLifecycle();
+  testRunStateCleanup();
+  console.log("run-state tests passed");
+}
+
+main();

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

@@ -12,6 +12,7 @@ const CSV_HEADER = ["姓名", "最高学历学校", "最高学历专业", "最
 const RESUME_CAPTURE_WAIT_MS = 60000;
 const RESUME_CAPTURE_MAX_ATTEMPTS = 4;
 const RESUME_CAPTURE_RETRY_DELAY_MS = 1200;
+const MAX_CONSECUTIVE_RESUME_CAPTURE_FAILURES = 10;
 
 function log(...args) {
   console.error(...args);
@@ -1053,6 +1054,8 @@ class RecommendScreenCli {
     this.skippedCount = 0;
     this.greetCount = 0;
     this.greetLimitFallbackCount = 0;
+    this.consecutiveResumeCaptureFailures = 0;
+    this.resumeCaptureFailureStreakKeys = [];
     this.restCounter = 0;
     this.restThreshold = 25 + Math.floor(Math.random() * 8);
     this.checkpointPath = this.args.checkpointPath ? path.resolve(this.args.checkpointPath) : null;
@@ -1110,6 +1113,49 @@ class RecommendScreenCli {
     };
   }
 
+  resetResumeCaptureFailureStreak() {
+    this.consecutiveResumeCaptureFailures = 0;
+    this.resumeCaptureFailureStreakKeys = [];
+  }
+
+  recordResumeCaptureFailure(candidateKey) {
+    this.consecutiveResumeCaptureFailures += 1;
+    if (candidateKey) {
+      this.resumeCaptureFailureStreakKeys.push(candidateKey);
+    }
+  }
+
+  rollbackResumeCaptureFailureStreak(currentCandidateKey = null) {
+    const streakKeys = Array.from(new Set([
+      ...this.resumeCaptureFailureStreakKeys,
+      ...(currentCandidateKey ? [currentCandidateKey] : [])
+    ].filter(Boolean)));
+    const rollbackCount = streakKeys.length;
+    if (rollbackCount <= 0) {
+      this.resetResumeCaptureFailureStreak();
+      return {
+        rollback_count: 0,
+        processed_count: this.processedCount,
+        skipped_count: this.skippedCount,
+        rolled_back_keys: []
+      };
+    }
+
+    this.processedCount = Math.max(0, this.processedCount - rollbackCount);
+    this.skippedCount = Math.max(0, this.skippedCount - rollbackCount);
+    for (const key of streakKeys) {
+      this.processedKeys.delete(key);
+      this.discoveredKeys.delete(key);
+    }
+    this.resetResumeCaptureFailureStreak();
+    return {
+      rollback_count: rollbackCount,
+      processed_count: this.processedCount,
+      skipped_count: this.skippedCount,
+      rolled_back_keys: streakKeys
+    };
+  }
+
   saveCheckpoint() {
     if (!this.checkpointPath) return;
     const payload = this.buildCheckpointPayload();
@@ -1935,6 +1981,7 @@ class RecommendScreenCli {
         this.scrollRetryCount = 0;
         this.processedCount += 1;
         log(`处理第 ${this.processedCount} 位候选人: ${nextCandidate.name || nextCandidate.geek_id}`);
+        let shouldMarkProcessed = true;
 
         try {
           await this.clickCandidate(nextCandidate);
@@ -1944,6 +1991,7 @@ class RecommendScreenCli {
           }
 
           const capture = await this.captureResumeImage(nextCandidate);
+          this.resetResumeCaptureFailureStreak();
           const screening = await this.callVisionModel(capture.stitchedImage);
           log(`筛选结果: ${screening.passed ? "通过" : "不通过"}`);
 
@@ -1984,7 +2032,30 @@ class RecommendScreenCli {
         } catch (error) {
           this.skippedCount += 1;
           log(`候选人处理失败: ${error.code || error.message}`);
-          if (["RESUME_CAPTURE_FAILED", "VISION_MODEL_FAILED"].includes(error.code)) {
+          if (error.code === "RESUME_CAPTURE_FAILED") {
+            this.recordResumeCaptureFailure(nextCandidate.key);
+            log(
+              `[候选人跳过] ${nextCandidate.name || nextCandidate.geek_id || "unknown"} 简历截图失败，` +
+              `已跳过当前候选人；连续失败 ${this.consecutiveResumeCaptureFailures}/${MAX_CONSECUTIVE_RESUME_CAPTURE_FAILURES}`
+            );
+            if (this.consecutiveResumeCaptureFailures >= MAX_CONSECUTIVE_RESUME_CAPTURE_FAILURES) {
+              shouldMarkProcessed = false;
+              const rollback = this.rollbackResumeCaptureFailureStreak(nextCandidate.key);
+              throw this.buildError(
+                "RESUME_CAPTURE_FAILED_CONSECUTIVE_LIMIT",
+                `连续 ${MAX_CONSECUTIVE_RESUME_CAPTURE_FAILURES} 位候选人简历捕获失败，已停止运行以避免错误跳过。` +
+                `已回滚这 ${rollback.rollback_count} 个失败样本的计数；最后错误: ${error.message || error}`,
+                true,
+                {
+                  cause_code: error.code,
+                  rollback
+                }
+              );
+            }
+          } else {
+            this.resetResumeCaptureFailureStreak();
+          }
+          if (["VISION_MODEL_FAILED"].includes(error.code)) {
             throw error;
           }
         } finally {
@@ -1992,7 +2063,9 @@ class RecommendScreenCli {
           if (!closed) {
             throw this.buildError("DETAIL_CLOSE_FAILED", "详情页未能正确关闭");
           }
-          this.processedKeys.add(nextCandidate.key);
+          if (shouldMarkProcessed) {
+            this.processedKeys.add(nextCandidate.key);
+          }
         }
 
         await this.takeBreakIfNeeded();
@@ -2069,17 +2142,30 @@ async function main() {
   console.log(JSON.stringify(result));
 }
 
-main().catch((error) => {
-  const payload = {
-    status: "FAILED",
-    error: {
-      code: error.code || "RECOMMEND_SCREEN_FAILED",
-      message: error.message || "推荐页筛选执行失败。",
-      retryable: error.retryable !== false
-    },
-    result: error.partial_result || null
+if (require.main === module) {
+  main().catch((error) => {
+    const payload = {
+      status: "FAILED",
+      error: {
+        code: error.code || "RECOMMEND_SCREEN_FAILED",
+        message: error.message || "推荐页筛选执行失败。",
+        retryable: error.retryable !== false
+      },
+      result: error.partial_result || null
+    };
+    console.log(JSON.stringify(payload));
+    process.exitCode = 1;
+  });
+} else {
+  module.exports = {
+    RecommendScreenCli,
+    parseArgs,
+    promptMissingInputs,
+    __testables: {
+      MAX_CONSECUTIVE_RESUME_CAPTURE_FAILURES,
+      RESUME_CAPTURE_MAX_ATTEMPTS,
+      RESUME_CAPTURE_WAIT_MS
+    }
   };
-  console.log(JSON.stringify(payload));
-  process.exitCode = 1;
-});
+}