@reconcrap/boss-recommend-mcp 1.1.3 → 1.1.4

package/src/test-index-async.js

@@ -1,236 +1,236 @@
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { __testables } from "./index.js";
-
-const {
-  handleRequest,
-  activeAsyncRuns,
-  setRunPipelineImplForTests
-} = __testables;
-
-const TOOL_START_RUN = "start_recommend_pipeline_run";
-const TOOL_GET_RUN = "get_recommend_pipeline_run";
-const TOOL_CANCEL_RUN = "cancel_recommend_pipeline_run";
-const TOOL_PAUSE_RUN = "pause_recommend_pipeline_run";
-const TOOL_RESUME_RUN = "resume_recommend_pipeline_run";
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function makeToolCall(id, name, args = {}) {
-  return {
-    jsonrpc: "2.0",
-    id,
-    method: "tools/call",
-    params: {
-      name,
-      arguments: args
-    }
-  };
-}
-
-async function readToolPayload(response) {
-  return response?.result?.structuredContent;
-}
-
-async function callTool(name, args, id = 1) {
-  const response = await handleRequest(
-    makeToolCall(id, name, args),
-    process.cwd()
-  );
-  return readToolPayload(response);
-}
-
-async function waitForRunState(runId, acceptedStates, timeoutMs = 6000) {
-  const accepted = new Set(acceptedStates.map((item) => String(item).toLowerCase()));
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    const payload = await callTool(TOOL_GET_RUN, { run_id: runId }, 1001);
-    const state = String(payload?.run?.state || "").toLowerCase();
-    if (accepted.has(state)) return payload.run;
-    await sleep(80);
-  }
-  throw new Error(`Timed out waiting run state (${Array.from(accepted).join(", ")}) for run_id=${runId}`);
-}
-
-async function startAcceptedRun(instruction, idSeed = 1) {
-  const payload = await callTool(TOOL_START_RUN, {
-    instruction,
-    confirmation: {
-      job_confirmed: true,
-      job_value: "mock job",
-      final_confirmed: true
-    }
-  }, idSeed);
-  assert.equal(payload.status, "ACCEPTED");
-  assert.equal(typeof payload.run_id, "string");
-  return payload.run_id;
-}
-
-function setupPipelineMock() {
-  const checkpointStore = new Map();
-  setRunPipelineImplForTests(async (input, _deps, runtime) => {
-    if (input.confirmation?.job_confirmed !== true) {
-      return {
-        status: "NEED_CONFIRMATION",
-        required_confirmations: ["job"],
-        pending_questions: [{ field: "job", question: "请确认岗位" }]
-      };
-    }
-    if (input.confirmation?.final_confirmed !== true) {
-      return {
-        status: "NEED_CONFIRMATION",
-        required_confirmations: ["final_review"],
-        pending_questions: [{ field: "final_review", question: "请最终确认" }]
-      };
-    }
-
-    runtime?.onStage?.({ stage: "preflight", message: "preflight started" });
-    await sleep(30);
-    runtime?.onStage?.({ stage: "screen", message: "screen running" });
-
-    const checkpointPath = String(input.resume?.checkpoint_path || "mem://default");
-    const outputCsv = String(input.resume?.output_csv || "C:/tmp/mock.csv");
-    const total = 12;
-    let processed = input.resume?.resume === true ? Number(checkpointStore.get(checkpointPath) || 0) : 0;
-    if (!Number.isInteger(processed) || processed < 0) processed = 0;
-
-    while (processed < total) {
-      processed += 1;
-      runtime?.onProgress?.({
-        stage: "screen",
-        processed,
-        passed: Math.floor(processed / 3),
-        skipped: processed - Math.floor(processed / 3),
-        greet_count: 0,
-        line: `处理第 ${processed} 位候选人`
-      });
-      await sleep(25);
-      if (runtime?.isPauseRequested?.() === true) {
-        checkpointStore.set(checkpointPath, processed);
-        return {
-          status: "PAUSED",
-          result: {
-            processed_count: processed,
-            passed_count: Math.floor(processed / 3),
-            skipped_count: processed - Math.floor(processed / 3),
-            greet_count: 0,
-            output_csv: outputCsv,
-            checkpoint_path: checkpointPath,
-            completion_reason: "paused"
-          }
-        };
-      }
-    }
-
-    checkpointStore.delete(checkpointPath);
-    return {
-      status: "COMPLETED",
-      result: {
-        processed_count: total,
-        passed_count: Math.floor(total / 3),
-        skipped_count: total - Math.floor(total / 3),
-        greet_count: 0,
-        output_csv: outputCsv,
-        completion_reason: "screen_completed"
-      }
-    };
-  });
-}
-
-async function testPauseAndResumeFlow() {
-  const runId = await startAcceptedRun("run for pause and resume", 11);
-  await waitForRunState(runId, ["running"]);
-
-  const pausePayload = await callTool(TOOL_PAUSE_RUN, { run_id: runId }, 12);
-  assert.equal(pausePayload.status, "PAUSE_REQUESTED");
-
-  const pausedRun = await waitForRunState(runId, ["paused"]);
-  assert.equal(pausedRun.state, "paused");
-  assert.equal(pausedRun.result?.status, "PAUSED");
-  assert.equal(Boolean(pausedRun.resume?.output_csv), true);
-
-  const resumePayload = await callTool(TOOL_RESUME_RUN, { run_id: runId }, 13);
-  assert.equal(resumePayload.status, "RESUME_REQUESTED");
-  assert.equal(resumePayload.run.run_id, runId);
-
-  const completedRun = await waitForRunState(runId, ["completed"]);
-  assert.equal(completedRun.state, "completed");
-  assert.equal(completedRun.result?.status, "COMPLETED");
-}
-
-async function testResumeAfterProcessRestartSimulation() {
-  const runId = await startAcceptedRun("run for restart resume", 21);
-  await waitForRunState(runId, ["running"]);
-
-  const pausePayload = await callTool(TOOL_PAUSE_RUN, { run_id: runId }, 22);
-  assert.equal(pausePayload.status, "PAUSE_REQUESTED");
-  await waitForRunState(runId, ["paused"]);
-
-  // 模拟服务重启后内存态丢失：active map 为空，仅依赖 run-state 持久化恢复。
-  activeAsyncRuns.clear();
-
-  const resumePayload = await callTool(TOOL_RESUME_RUN, { run_id: runId }, 23);
-  assert.equal(resumePayload.status, "RESUME_REQUESTED");
-  assert.equal(resumePayload.run.run_id, runId);
-
-  const completedRun = await waitForRunState(runId, ["completed"]);
-  assert.equal(completedRun.state, "completed");
-}
-
-async function testCancelPausedRun() {
-  const runId = await startAcceptedRun("run for cancel paused", 31);
-  await waitForRunState(runId, ["running"]);
-
-  const pausePayload = await callTool(TOOL_PAUSE_RUN, { run_id: runId }, 32);
-  assert.equal(pausePayload.status, "PAUSE_REQUESTED");
-  await waitForRunState(runId, ["paused"]);
-
-  const cancelPayload = await callTool(TOOL_CANCEL_RUN, { run_id: runId }, 33);
-  assert.equal(cancelPayload.status, "CANCEL_REQUESTED");
-
-  const canceledRun = await waitForRunState(runId, ["canceled"]);
-  assert.equal(canceledRun.state, "canceled");
-}
-
-async function testCancelRunningRunKeepsCsv() {
-  const runId = await startAcceptedRun("run for cancel while running", 41);
-  await waitForRunState(runId, ["running"]);
-
-  const cancelPayload = await callTool(TOOL_CANCEL_RUN, { run_id: runId }, 42);
-  assert.equal(cancelPayload.status, "CANCEL_REQUESTED");
-
-  const canceledRun = await waitForRunState(runId, ["canceled"]);
-  assert.equal(canceledRun.state, "canceled");
-  assert.equal(canceledRun.error?.code, "PIPELINE_CANCELED");
-  assert.equal(Boolean(canceledRun.resume?.output_csv), true);
-}
-
-async function main() {
-  const previousHome = process.env.BOSS_RECOMMEND_HOME;
-  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-index-async-"));
-  process.env.BOSS_RECOMMEND_HOME = tempHome;
-  setupPipelineMock();
-
-  try {
-    await testPauseAndResumeFlow();
-    await testResumeAfterProcessRestartSimulation();
-    await testCancelPausedRun();
-    await testCancelRunningRunKeepsCsv();
-    console.log("index async tests passed");
-  } finally {
-    setRunPipelineImplForTests(null);
-    activeAsyncRuns.clear();
-    if (previousHome === undefined) {
-      delete process.env.BOSS_RECOMMEND_HOME;
-    } else {
-      process.env.BOSS_RECOMMEND_HOME = previousHome;
-    }
-    fs.rmSync(tempHome, { recursive: true, force: true });
-  }
-}
-
-await main();
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { __testables } from "./index.js";
+
+const {
+  handleRequest,
+  activeAsyncRuns,
+  setRunPipelineImplForTests
+} = __testables;
+
+const TOOL_START_RUN = "start_recommend_pipeline_run";
+const TOOL_GET_RUN = "get_recommend_pipeline_run";
+const TOOL_CANCEL_RUN = "cancel_recommend_pipeline_run";
+const TOOL_PAUSE_RUN = "pause_recommend_pipeline_run";
+const TOOL_RESUME_RUN = "resume_recommend_pipeline_run";
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function makeToolCall(id, name, args = {}) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    method: "tools/call",
+    params: {
+      name,
+      arguments: args
+    }
+  };
+}
+
+async function readToolPayload(response) {
+  return response?.result?.structuredContent;
+}
+
+async function callTool(name, args, id = 1) {
+  const response = await handleRequest(
+    makeToolCall(id, name, args),
+    process.cwd()
+  );
+  return readToolPayload(response);
+}
+
+async function waitForRunState(runId, acceptedStates, timeoutMs = 6000) {
+  const accepted = new Set(acceptedStates.map((item) => String(item).toLowerCase()));
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const payload = await callTool(TOOL_GET_RUN, { run_id: runId }, 1001);
+    const state = String(payload?.run?.state || "").toLowerCase();
+    if (accepted.has(state)) return payload.run;
+    await sleep(80);
+  }
+  throw new Error(`Timed out waiting run state (${Array.from(accepted).join(", ")}) for run_id=${runId}`);
+}
+
+async function startAcceptedRun(instruction, idSeed = 1) {
+  const payload = await callTool(TOOL_START_RUN, {
+    instruction,
+    confirmation: {
+      job_confirmed: true,
+      job_value: "mock job",
+      final_confirmed: true
+    }
+  }, idSeed);
+  assert.equal(payload.status, "ACCEPTED");
+  assert.equal(typeof payload.run_id, "string");
+  return payload.run_id;
+}
+
+function setupPipelineMock() {
+  const checkpointStore = new Map();
+  setRunPipelineImplForTests(async (input, _deps, runtime) => {
+    if (input.confirmation?.job_confirmed !== true) {
+      return {
+        status: "NEED_CONFIRMATION",
+        required_confirmations: ["job"],
+        pending_questions: [{ field: "job", question: "请确认岗位" }]
+      };
+    }
+    if (input.confirmation?.final_confirmed !== true) {
+      return {
+        status: "NEED_CONFIRMATION",
+        required_confirmations: ["final_review"],
+        pending_questions: [{ field: "final_review", question: "请最终确认" }]
+      };
+    }
+
+    runtime?.onStage?.({ stage: "preflight", message: "preflight started" });
+    await sleep(30);
+    runtime?.onStage?.({ stage: "screen", message: "screen running" });
+
+    const checkpointPath = String(input.resume?.checkpoint_path || "mem://default");
+    const outputCsv = String(input.resume?.output_csv || "C:/tmp/mock.csv");
+    const total = 12;
+    let processed = input.resume?.resume === true ? Number(checkpointStore.get(checkpointPath) || 0) : 0;
+    if (!Number.isInteger(processed) || processed < 0) processed = 0;
+
+    while (processed < total) {
+      processed += 1;
+      runtime?.onProgress?.({
+        stage: "screen",
+        processed,
+        passed: Math.floor(processed / 3),
+        skipped: processed - Math.floor(processed / 3),
+        greet_count: 0,
+        line: `处理第 ${processed} 位候选人`
+      });
+      await sleep(25);
+      if (runtime?.isPauseRequested?.() === true) {
+        checkpointStore.set(checkpointPath, processed);
+        return {
+          status: "PAUSED",
+          result: {
+            processed_count: processed,
+            passed_count: Math.floor(processed / 3),
+            skipped_count: processed - Math.floor(processed / 3),
+            greet_count: 0,
+            output_csv: outputCsv,
+            checkpoint_path: checkpointPath,
+            completion_reason: "paused"
+          }
+        };
+      }
+    }
+
+    checkpointStore.delete(checkpointPath);
+    return {
+      status: "COMPLETED",
+      result: {
+        processed_count: total,
+        passed_count: Math.floor(total / 3),
+        skipped_count: total - Math.floor(total / 3),
+        greet_count: 0,
+        output_csv: outputCsv,
+        completion_reason: "screen_completed"
+      }
+    };
+  });
+}
+
+async function testPauseAndResumeFlow() {
+  const runId = await startAcceptedRun("run for pause and resume", 11);
+  await waitForRunState(runId, ["running"]);
+
+  const pausePayload = await callTool(TOOL_PAUSE_RUN, { run_id: runId }, 12);
+  assert.equal(pausePayload.status, "PAUSE_REQUESTED");
+
+  const pausedRun = await waitForRunState(runId, ["paused"]);
+  assert.equal(pausedRun.state, "paused");
+  assert.equal(pausedRun.result?.status, "PAUSED");
+  assert.equal(Boolean(pausedRun.resume?.output_csv), true);
+
+  const resumePayload = await callTool(TOOL_RESUME_RUN, { run_id: runId }, 13);
+  assert.equal(resumePayload.status, "RESUME_REQUESTED");
+  assert.equal(resumePayload.run.run_id, runId);
+
+  const completedRun = await waitForRunState(runId, ["completed"]);
+  assert.equal(completedRun.state, "completed");
+  assert.equal(completedRun.result?.status, "COMPLETED");
+}
+
+async function testResumeAfterProcessRestartSimulation() {
+  const runId = await startAcceptedRun("run for restart resume", 21);
+  await waitForRunState(runId, ["running"]);
+
+  const pausePayload = await callTool(TOOL_PAUSE_RUN, { run_id: runId }, 22);
+  assert.equal(pausePayload.status, "PAUSE_REQUESTED");
+  await waitForRunState(runId, ["paused"]);
+
+  // 模拟服务重启后内存态丢失：active map 为空，仅依赖 run-state 持久化恢复。
+  activeAsyncRuns.clear();
+
+  const resumePayload = await callTool(TOOL_RESUME_RUN, { run_id: runId }, 23);
+  assert.equal(resumePayload.status, "RESUME_REQUESTED");
+  assert.equal(resumePayload.run.run_id, runId);
+
+  const completedRun = await waitForRunState(runId, ["completed"]);
+  assert.equal(completedRun.state, "completed");
+}
+
+async function testCancelPausedRun() {
+  const runId = await startAcceptedRun("run for cancel paused", 31);
+  await waitForRunState(runId, ["running"]);
+
+  const pausePayload = await callTool(TOOL_PAUSE_RUN, { run_id: runId }, 32);
+  assert.equal(pausePayload.status, "PAUSE_REQUESTED");
+  await waitForRunState(runId, ["paused"]);
+
+  const cancelPayload = await callTool(TOOL_CANCEL_RUN, { run_id: runId }, 33);
+  assert.equal(cancelPayload.status, "CANCEL_REQUESTED");
+
+  const canceledRun = await waitForRunState(runId, ["canceled"]);
+  assert.equal(canceledRun.state, "canceled");
+}
+
+async function testCancelRunningRunKeepsCsv() {
+  const runId = await startAcceptedRun("run for cancel while running", 41);
+  await waitForRunState(runId, ["running"]);
+
+  const cancelPayload = await callTool(TOOL_CANCEL_RUN, { run_id: runId }, 42);
+  assert.equal(cancelPayload.status, "CANCEL_REQUESTED");
+
+  const canceledRun = await waitForRunState(runId, ["canceled"]);
+  assert.equal(canceledRun.state, "canceled");
+  assert.equal(canceledRun.error?.code, "PIPELINE_CANCELED");
+  assert.equal(Boolean(canceledRun.resume?.output_csv), true);
+}
+
+async function main() {
+  const previousHome = process.env.BOSS_RECOMMEND_HOME;
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-index-async-"));
+  process.env.BOSS_RECOMMEND_HOME = tempHome;
+  setupPipelineMock();
+
+  try {
+    await testPauseAndResumeFlow();
+    await testResumeAfterProcessRestartSimulation();
+    await testCancelPausedRun();
+    await testCancelRunningRunKeepsCsv();
+    console.log("index async tests passed");
+  } finally {
+    setRunPipelineImplForTests(null);
+    activeAsyncRuns.clear();
+    if (previousHome === undefined) {
+      delete process.env.BOSS_RECOMMEND_HOME;
+    } else {
+      process.env.BOSS_RECOMMEND_HOME = previousHome;
+    }
+    fs.rmSync(tempHome, { recursive: true, force: true });
+  }
+}
+
+await main();

package/src/test-pipeline.js

@@ -252,6 +252,108 @@ async function testResumeFromPausedBeforeScreenShouldRerunSearch() {
   assert.equal(result.result.candidate_count, 9);
 }
 
+async function testConsecutiveResumeCaptureFailuresShouldRefreshAndRerunSearchWithForcedRecentFilter() {
+  const searchCalls = [];
+  const screenCalls = [];
+  let reloadCalls = 0;
+  let pageReadyCalls = 0;
+  const parsed = createParsed();
+  parsed.searchParams = {
+    ...parsed.searchParams,
+    recent_not_view: "不限"
+  };
+  const result = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "test",
+      confirmation: createJobConfirmedConfirmation(),
+      overrides: {},
+      resume: {
+        resume: false,
+        output_csv: "C:/temp/resume.csv",
+        checkpoint_path: "C:/temp/checkpoint.json",
+        pause_control_path: "C:/temp/run.json",
+        previous_completion_reason: ""
+      }
+    },
+    {
+      parseRecommendInstruction: () => parsed,
+      runPipelinePreflight: () => ({ ok: true, checks: [], debug_port: 9222 }),
+      ensureBossRecommendPageReady: async () => {
+        pageReadyCalls += 1;
+        return { ok: true, state: "RECOMMEND_READY", page_state: { state: "RECOMMEND_READY" } };
+      },
+      listRecommendJobs: async () => createJobListResult(),
+      reloadBossRecommendPage: async () => {
+        reloadCalls += 1;
+        return {
+          ok: true,
+          state: "RECOMMEND_READY",
+          reloaded_url: "https://www.zhipin.com/web/chat/recommend"
+        };
+      },
+      runRecommendSearchCli: async ({ searchParams, selectedJob }) => {
+        searchCalls.push({
+          searchParams,
+          selectedJob
+        });
+        return {
+          ok: true,
+          summary: {
+            candidate_count: 9,
+            applied_filters: searchParams,
+            selected_job: selectedJob,
+            page_state: { state: "RECOMMEND_READY" }
+          }
+        };
+      },
+      runRecommendScreenCli: async ({ resume }) => {
+        screenCalls.push(resume);
+        if (screenCalls.length === 1) {
+          return {
+            ok: false,
+            error: {
+              code: "RESUME_CAPTURE_FAILED_CONSECUTIVE_LIMIT",
+              message: "连续 10 位候选人截图失败"
+            },
+            summary: {
+              processed_count: 216,
+              passed_count: 83,
+              skipped_count: 133,
+              output_csv: "C:/temp/resume.csv"
+            }
+          };
+        }
+        return {
+          ok: true,
+          summary: {
+            processed_count: 240,
+            passed_count: 90,
+            skipped_count: 150,
+            output_csv: "C:/temp/resume.csv",
+            completion_reason: "page_exhausted"
+          }
+        };
+      }
+    }
+  );
+
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(searchCalls.length, 2);
+  assert.equal(searchCalls[0].searchParams.recent_not_view, "不限");
+  assert.equal(searchCalls[1].searchParams.recent_not_view, "近14天没有");
+  assert.equal(screenCalls.length, 2);
+  assert.equal(screenCalls[0].resume, false);
+  assert.equal(screenCalls[1].resume, true);
+  assert.equal(screenCalls[1].require_checkpoint, true);
+  assert.equal(screenCalls[1].output_csv, "C:/temp/resume.csv");
+  assert.equal(reloadCalls, 1);
+  assert.equal(pageReadyCalls, 2);
+  assert.equal(result.result.output_csv, "C:/temp/resume.csv");
+  assert.equal(result.result.auto_recovery.reload.ok, true);
+  assert.equal(result.search_params.recent_not_view, "近14天没有");
+}
+
 async function testNeedConfirmationGate() {
   let preflightCalled = false;
   const result = await runRecommendPipeline(
@@ -933,6 +1035,7 @@ async function main() {
   await testPausedScreenResultShouldBubbleUp();
   await testResumeFromScreenPauseShouldSkipSearch();
   await testResumeFromPausedBeforeScreenShouldRerunSearch();
+  await testConsecutiveResumeCaptureFailuresShouldRefreshAndRerunSearchWithForcedRecentFilter();
   await testNeedConfirmationGate();
   await testNeedSchoolTagConfirmationGate();
   await testNeedTargetCountConfirmationGate();