@reconcrap/boss-recommend-mcp 1.0.19 → 1.1.0

package/package.json

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

package/src/adapters.js

@@ -1599,6 +1599,38 @@ export async function runRecommendScreenCli({ workspaceRoot, screenParams, resum
   const pauseControlPath = normalizeText(resume?.pause_control_path || "")
     ? path.resolve(String(resume.pause_control_path))
     : null;
+  const resumeRequested = resume?.resume === true;
+  const requireCheckpoint = resume?.require_checkpoint === true;
+  if (resumeRequested && requireCheckpoint) {
+    if (!checkpointPath) {
+      return {
+        ok: false,
+        paused: false,
+        stdout: "",
+        stderr: "",
+        structured: null,
+        summary: null,
+        error: {
+          code: "RESUME_CHECKPOINT_MISSING",
+          message: "恢复执行缺少 checkpoint_path，无法从上次进度继续。"
+        }
+      };
+    }
+    if (!fs.existsSync(checkpointPath)) {
+      return {
+        ok: false,
+        paused: false,
+        stdout: "",
+        stderr: "",
+        structured: null,
+        summary: null,
+        error: {
+          code: "RESUME_CHECKPOINT_MISSING",
+          message: `恢复执行未找到 checkpoint 文件：${checkpointPath}`
+        }
+      };
+    }
+  }
 
   const cliPath = resolveRecommendScreenCliEntry(screenDir);
   const args = [
@@ -1641,7 +1673,7 @@ export async function runRecommendScreenCli({ workspaceRoot, screenParams, resum
   if (pauseControlPath) {
     args.push("--pause-control-path", pauseControlPath);
   }
-  if (resume?.resume === true) {
+  if (resumeRequested) {
     args.push("--resume");
   }
 

package/src/index.js

@@ -110,6 +110,14 @@ function getOutputCsvFromResult(result) {
   return null;
 }
 
+function getCompletionReasonFromResult(result) {
+  const direct = normalizeText(result?.result?.completion_reason || "");
+  if (direct) return direct;
+  const partial = normalizeText(result?.partial_result?.completion_reason || "");
+  if (partial) return partial;
+  return null;
+}
+
 function writeMessage(message, framing = FRAMING_LINE) {
   const body = JSON.stringify(message);
   if (framing === FRAMING_HEADER) {
@@ -496,7 +504,8 @@ async function executeTrackedPipeline({
     resume: resumeRun === true,
     checkpoint_path: normalizeText(existingSnapshot?.resume?.checkpoint_path || artifacts.checkpoint_path),
     pause_control_path: normalizeText(existingSnapshot?.resume?.pause_control_path || artifacts.run_state_path),
-    output_csv: normalizeText(existingSnapshot?.resume?.output_csv || "") || null
+    output_csv: normalizeText(existingSnapshot?.resume?.output_csv || "") || null,
+    previous_completion_reason: getCompletionReasonFromResult(existingSnapshot?.result || null)
   };
   safeUpdateRunState(runId, {
     state: RUN_STATE_RUNNING,

package/src/pipeline.js

@@ -805,90 +805,102 @@ export async function runRecommendPipeline(
     };
   }
 
-  ensurePipelineNotAborted(runtimeHooks.signal);
-  runtimeHooks.setStage("search", "岗位已确认，开始执行 recommend search。");
-  runtimeHooks.heartbeat("search");
-  const searchResult = await searchCli({
-    workspaceRoot,
-    searchParams: parsed.searchParams,
-    selectedJob: selectedJobToken,
-    runtime: runtimeHooks.adapterRuntime("search")
-  });
-  ensurePipelineNotAborted(runtimeHooks.signal);
-  if (isProcessAbortError(searchResult.error)) {
-    throw new PipelineAbortError(searchResult.error?.message || "推荐筛选已取消。");
-  }
-  if (!searchResult.ok) {
-    const searchErrorCode = String(searchResult.error?.code || "");
-    const searchErrorMessage = String(searchResult.error?.message || "");
-    const loginRelatedSearchFailure = (
-      searchErrorCode === "LOGIN_REQUIRED"
-      || searchErrorCode === "NO_RECOMMEND_IFRAME"
-      || searchErrorMessage.includes("LOGIN_REQUIRED")
-      || searchErrorMessage.includes("NO_RECOMMEND_IFRAME")
-    );
-    if (loginRelatedSearchFailure) {
-      const recheck = await ensureRecommendPageReady(workspaceRoot, {
-        port: preflight.debug_port
-      });
-      if (recheck.state === "LOGIN_REQUIRED" || recheck.state === "LOGIN_REQUIRED_AFTER_REDIRECT") {
-        const guidance = buildChromeSetupGuidance({
-          debugPort: preflight.debug_port,
-          pageState: recheck.page_state
+  const resumeCompletionReason = normalizeText(resume?.previous_completion_reason || "").toLowerCase();
+  const isResumeRun = resume?.resume === true;
+  const resumeFromPausedBeforeScreen = isResumeRun && resumeCompletionReason === "paused_before_screen";
+  const skipSearchOnResume = isResumeRun && !resumeFromPausedBeforeScreen;
+  let searchSummary = null;
+
+  if (!skipSearchOnResume) {
+    ensurePipelineNotAborted(runtimeHooks.signal);
+    runtimeHooks.setStage("search", "岗位已确认，开始执行 recommend search。");
+    runtimeHooks.heartbeat("search");
+    const searchResult = await searchCli({
+      workspaceRoot,
+      searchParams: parsed.searchParams,
+      selectedJob: selectedJobToken,
+      runtime: runtimeHooks.adapterRuntime("search")
+    });
+    ensurePipelineNotAborted(runtimeHooks.signal);
+    if (isProcessAbortError(searchResult.error)) {
+      throw new PipelineAbortError(searchResult.error?.message || "推荐筛选已取消。");
+    }
+    if (!searchResult.ok) {
+      const searchErrorCode = String(searchResult.error?.code || "");
+      const searchErrorMessage = String(searchResult.error?.message || "");
+      const loginRelatedSearchFailure = (
+        searchErrorCode === "LOGIN_REQUIRED"
+        || searchErrorCode === "NO_RECOMMEND_IFRAME"
+        || searchErrorMessage.includes("LOGIN_REQUIRED")
+        || searchErrorMessage.includes("NO_RECOMMEND_IFRAME")
+      );
+      if (loginRelatedSearchFailure) {
+        const recheck = await ensureRecommendPageReady(workspaceRoot, {
+          port: preflight.debug_port
         });
-        return buildFailedResponse(
-          "BOSS_LOGIN_REQUIRED",
-          "检测到当前 Boss 处于未登录状态，请先登录后再继续。登录页：https://www.zhipin.com/web/user/?ka=bticket",
-          {
-            search_params: parsed.searchParams,
-            screen_params: parsed.screenParams,
-            selected_job: selectedJob,
-            required_user_action: "prepare_boss_recommend_page",
-            guidance,
-            diagnostics: {
-              debug_port: preflight.debug_port,
-              page_state: recheck.page_state,
-              stdout: searchResult.stdout?.slice(-1000),
-              stderr: searchResult.stderr?.slice(-1000),
-              result: searchResult.structured || null
+        if (recheck.state === "LOGIN_REQUIRED" || recheck.state === "LOGIN_REQUIRED_AFTER_REDIRECT") {
+          const guidance = buildChromeSetupGuidance({
+            debugPort: preflight.debug_port,
+            pageState: recheck.page_state
+          });
+          return buildFailedResponse(
+            "BOSS_LOGIN_REQUIRED",
+            "检测到当前 Boss 处于未登录状态，请先登录后再继续。登录页：https://www.zhipin.com/web/user/?ka=bticket",
+            {
+              search_params: parsed.searchParams,
+              screen_params: parsed.screenParams,
+              selected_job: selectedJob,
+              required_user_action: "prepare_boss_recommend_page",
+              guidance,
+              diagnostics: {
+                debug_port: preflight.debug_port,
+                page_state: recheck.page_state,
+                stdout: searchResult.stdout?.slice(-1000),
+                stderr: searchResult.stderr?.slice(-1000),
+                result: searchResult.structured || null
+              }
             }
-          }
-        );
+          );
+        }
       }
+      return buildFailedResponse(
+        searchResult.error?.code || "RECOMMEND_SEARCH_FAILED",
+        searchResult.error?.message || "推荐页筛选执行失败。",
+        {
+          search_params: parsed.searchParams,
+          screen_params: parsed.screenParams,
+          selected_job: selectedJob,
+          diagnostics: {
+            debug_port: preflight.debug_port,
+            stdout: searchResult.stdout?.slice(-1000),
+            stderr: searchResult.stderr?.slice(-1000),
+            result: searchResult.structured || null
+          }
+        }
+      );
     }
-    return buildFailedResponse(
-      searchResult.error?.code || "RECOMMEND_SEARCH_FAILED",
-      searchResult.error?.message || "推荐页筛选执行失败。",
-      {
+
+    searchSummary = searchResult.summary || {};
+    if (isPauseRequested(runtimeHooks)) {
+      return buildPausedResponse("已在 screen 阶段开始前暂停 Recommend 流水线。", {
         search_params: parsed.searchParams,
         screen_params: parsed.screenParams,
         selected_job: selectedJob,
-        diagnostics: {
-          debug_port: preflight.debug_port,
-          stdout: searchResult.stdout?.slice(-1000),
-          stderr: searchResult.stderr?.slice(-1000),
-          result: searchResult.structured || null
-        }
-      }
-    );
-  }
-
-  if (isPauseRequested(runtimeHooks)) {
-    return buildPausedResponse("已在 screen 阶段开始前暂停 Recommend 流水线。", {
-      search_params: parsed.searchParams,
-      screen_params: parsed.screenParams,
-      selected_job: selectedJob,
-      partial_result: {
-        candidate_count: searchResult.summary?.candidate_count ?? null,
-        applied_filters: searchResult.summary?.applied_filters || parsed.searchParams,
-        output_csv: resume?.output_csv || null,
-        completion_reason: "paused_before_screen"
-      }
-    });
+        partial_result: {
+          candidate_count: searchSummary.candidate_count ?? null,
+          applied_filters: searchSummary.applied_filters || parsed.searchParams,
+          output_csv: resume?.output_csv || null,
+          completion_reason: "paused_before_screen"
+        }
+      });
+    }
+    ensurePipelineNotAborted(runtimeHooks.signal);
+    runtimeHooks.setStage("screen", "search 完成，开始执行 recommend screen。");
+  } else {
+    ensurePipelineNotAborted(runtimeHooks.signal);
+    runtimeHooks.setStage("screen", "检测到可续跑 checkpoint，跳过 search，直接恢复 recommend screen。");
   }
 
-  ensurePipelineNotAborted(runtimeHooks.signal);
-  runtimeHooks.setStage("screen", "search 完成，开始执行 recommend screen。");
   runtimeHooks.heartbeat("screen");
   const screenResult = await screenCli({
     workspaceRoot,
@@ -897,7 +909,8 @@ export async function runRecommendPipeline(
       checkpoint_path: resume?.checkpoint_path || null,
       pause_control_path: resume?.pause_control_path || null,
       output_csv: resume?.output_csv || null,
-      resume: resume?.resume === true
+      resume: resume?.resume === true,
+      require_checkpoint: skipSearchOnResume
     },
     runtime: runtimeHooks.adapterRuntime("screen")
   });
@@ -936,7 +949,7 @@ export async function runRecommendPipeline(
   runtimeHooks.setStage("finalize", "screen 完成，正在汇总结果。");
   runtimeHooks.heartbeat("finalize");
   const durationSec = Math.max(1, Math.round((Date.now() - startedAt) / 1000));
-  const searchSummary = searchResult.summary || {};
+  const finalSearchSummary = searchSummary || {};
   const screenSummary = screenResult.summary || {};
   runtimeHooks.progress("finalize", {
     processed: screenSummary.processed_count ?? 0,
@@ -949,17 +962,17 @@ export async function runRecommendPipeline(
     status: "COMPLETED",
     search_params: parsed.searchParams,
     screen_params: parsed.screenParams,
-    result: {
-      candidate_count: searchSummary.candidate_count ?? null,
-      applied_filters: searchSummary.applied_filters || parsed.searchParams,
-      processed_count: screenSummary.processed_count ?? 0,
-      passed_count: screenSummary.passed_count ?? 0,
+    result: {
+      candidate_count: finalSearchSummary.candidate_count ?? null,
+      applied_filters: finalSearchSummary.applied_filters || parsed.searchParams,
+      processed_count: screenSummary.processed_count ?? 0,
+      passed_count: screenSummary.passed_count ?? 0,
       skipped_count: screenSummary.skipped_count ?? 0,
       duration_sec: durationSec,
       output_csv: screenSummary.output_csv || null,
       completion_reason: screenSummary.completion_reason || "screen_completed",
-      page_state: searchSummary.page_state || pageCheck.page_state,
-      selected_job: searchSummary.selected_job || selectedJob,
+      page_state: finalSearchSummary.page_state || pageCheck.page_state,
+      selected_job: finalSearchSummary.selected_job || selectedJob,
       post_action: parsed.screenParams.post_action,
       max_greet_count: parsed.screenParams.max_greet_count,
       greet_count: screenSummary.greet_count ?? 0,

package/src/test-adapters-runtime.js

@@ -1,5 +1,8 @@
 import assert from "node:assert/strict";
-import { __testables as adapterTestables } from "./adapters.js";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { runRecommendScreenCli, __testables as adapterTestables } from "./adapters.js";
 
 const { runProcess, parseJsonOutput } = adapterTestables;
 
@@ -54,10 +57,53 @@ function testParsePausedStructuredOutput() {
   assert.equal(parsed?.result?.processed_count, 3);
 }
 
+async function testResumeRequiresCheckpointFile() {
+  const previousHome = process.env.BOSS_RECOMMEND_HOME;
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-resume-"));
+  process.env.BOSS_RECOMMEND_HOME = tempHome;
+  try {
+    const configPath = path.join(tempHome, "screening-config.json");
+    fs.writeFileSync(configPath, JSON.stringify({
+      baseUrl: "https://api.openai.com/v1",
+      apiKey: "sk-test-valid",
+      model: "gpt-4.1-mini"
+    }, null, 2));
+
+    const missingCheckpoint = path.join(tempHome, "missing-checkpoint.json");
+    const result = await runRecommendScreenCli({
+      workspaceRoot: process.cwd(),
+      screenParams: {
+        criteria: "有MCP经验",
+        target_count: 10,
+        post_action: "favorite",
+        max_greet_count: null
+      },
+      resume: {
+        resume: true,
+        require_checkpoint: true,
+        checkpoint_path: missingCheckpoint,
+        pause_control_path: path.join(tempHome, "run-state.json"),
+        output_csv: path.join(tempHome, "resume.csv")
+      }
+    });
+
+    assert.equal(result.ok, false);
+    assert.equal(result.error?.code, "RESUME_CHECKPOINT_MISSING");
+  } finally {
+    if (previousHome === undefined) {
+      delete process.env.BOSS_RECOMMEND_HOME;
+    } else {
+      process.env.BOSS_RECOMMEND_HOME = previousHome;
+    }
+    fs.rmSync(tempHome, { recursive: true, force: true });
+  }
+}
+
 async function main() {
   await testRunProcessHeartbeatAndOutput();
   await testRunProcessAbortSignal();
   testParsePausedStructuredOutput();
+  await testResumeRequiresCheckpointFile();
   console.log("adapters runtime tests passed");
 }
 

package/src/test-pipeline.js

@@ -154,6 +154,104 @@ async function testPausedScreenResultShouldBubbleUp() {
   assert.equal(result.partial_result.completion_reason, "paused");
 }
 
+async function testResumeFromScreenPauseShouldSkipSearch() {
+  let searchCalled = false;
+  let receivedResume = null;
+  const result = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "test",
+      confirmation: createJobConfirmedConfirmation(),
+      overrides: {},
+      resume: {
+        resume: true,
+        output_csv: "C:/temp/resume.csv",
+        checkpoint_path: "C:/temp/checkpoint.json",
+        pause_control_path: "C:/temp/run.json",
+        previous_completion_reason: "paused"
+      }
+    },
+    {
+      parseRecommendInstruction: () => createParsed(),
+      runPipelinePreflight: () => ({ ok: true, checks: [], debug_port: 9222 }),
+      ensureBossRecommendPageReady: async () => ({ ok: true, state: "RECOMMEND_READY", page_state: {} }),
+      listRecommendJobs: async () => createJobListResult(),
+      runRecommendSearchCli: async () => {
+        searchCalled = true;
+        return { ok: true, summary: { candidate_count: 9, applied_filters: {} } };
+      },
+      runRecommendScreenCli: async ({ resume }) => {
+        receivedResume = resume;
+        return {
+          ok: true,
+          summary: {
+            processed_count: 6,
+            passed_count: 2,
+            skipped_count: 4,
+            output_csv: "C:/temp/resume.csv",
+            completion_reason: "page_exhausted"
+          }
+        };
+      }
+    }
+  );
+
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(searchCalled, false);
+  assert.equal(receivedResume.resume, true);
+  assert.equal(receivedResume.require_checkpoint, true);
+  assert.equal(result.result.candidate_count, null);
+}
+
+async function testResumeFromPausedBeforeScreenShouldRerunSearch() {
+  let searchCalled = false;
+  let receivedResume = null;
+  const result = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "test",
+      confirmation: createJobConfirmedConfirmation(),
+      overrides: {},
+      resume: {
+        resume: true,
+        output_csv: "C:/temp/resume.csv",
+        checkpoint_path: "C:/temp/checkpoint.json",
+        pause_control_path: "C:/temp/run.json",
+        previous_completion_reason: "paused_before_screen"
+      }
+    },
+    {
+      parseRecommendInstruction: () => createParsed(),
+      runPipelinePreflight: () => ({ ok: true, checks: [], debug_port: 9222 }),
+      ensureBossRecommendPageReady: async () => ({ ok: true, state: "RECOMMEND_READY", page_state: {} }),
+      listRecommendJobs: async () => createJobListResult(),
+      runRecommendSearchCli: async () => {
+        searchCalled = true;
+        return { ok: true, summary: { candidate_count: 9, applied_filters: { degree: ["本科"] } } };
+      },
+      runRecommendScreenCli: async ({ resume }) => {
+        receivedResume = resume;
+        return {
+          ok: true,
+          summary: {
+            processed_count: 4,
+            passed_count: 1,
+            skipped_count: 3,
+            output_csv: "C:/temp/resume.csv",
+            completion_reason: "page_exhausted"
+          }
+        };
+      }
+    }
+  );
+
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(searchCalled, true);
+  assert.equal(receivedResume.resume, true);
+  assert.equal(receivedResume.require_checkpoint, false);
+  assert.equal(result.result.candidate_count, 9);
+}
+
 async function testNeedConfirmationGate() {
   let preflightCalled = false;
   const result = await runRecommendPipeline(
@@ -833,6 +931,8 @@ async function testScreenConfigRecoveryStepShouldBeFirst() {
 async function main() {
   await testPauseRequestedBeforeScreenShouldReturnPaused();
   await testPausedScreenResultShouldBubbleUp();
+  await testResumeFromScreenPauseShouldSkipSearch();
+  await testResumeFromPausedBeforeScreenShouldRerunSearch();
   await testNeedConfirmationGate();
   await testNeedSchoolTagConfirmationGate();
   await testNeedTargetCountConfirmationGate();