@reconcrap/boss-recommend-mcp 1.1.4 → 1.1.6

package/src/test-adapters-runtime.js

@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { runRecommendScreenCli, __testables as adapterTestables } from "./adapters.js";
+import { runPipelinePreflight, runRecommendScreenCli, __testables as adapterTestables } from "./adapters.js";
 
 const {
   runProcess,
@@ -149,6 +149,14 @@ async function testResumeRequiresCheckpointFile() {
   }
 }
 
+function testPreflightShouldCheckSharpInsteadOfPython() {
+  const preflight = runPipelinePreflight(process.cwd());
+  const keys = new Set((preflight.checks || []).map((item) => item?.key));
+  assert.equal(keys.has("npm_dep_sharp"), true);
+  assert.equal(keys.has("python_cli"), false);
+  assert.equal(keys.has("python_pillow"), false);
+}
+
 async function main() {
   await testRunProcessHeartbeatAndOutput();
   await testRunProcessAbortSignal();
@@ -157,6 +165,7 @@ async function main() {
   testResolveScreenTimeoutDefaultsTo24Hours();
   testBuildRecommendScreenProcessErrorMapsTimeout();
   await testResumeRequiresCheckpointFile();
+  testPreflightShouldCheckSharpInsteadOfPython();
   console.log("adapters runtime tests passed");
 }
 

package/src/test-pipeline.js

@@ -354,6 +354,505 @@ async function testConsecutiveResumeCaptureFailuresShouldRefreshAndRerunSearchWi
   assert.equal(result.search_params.recent_not_view, "近14天没有");
 }
 
+async function testPageExhaustedBeforeTargetShouldRefreshInPageAndResumeScreen() {
+  const searchCalls = [];
+  const screenCalls = [];
+  let refreshCalls = 0;
+  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(),
+      refreshBossRecommendList: async () => {
+        refreshCalls += 1;
+        return {
+          ok: true,
+          action: "in_page_refresh",
+          state: "RECOMMEND_READY",
+          before_state: {
+            finished_wrap_visible: true,
+            refresh_button_visible: true
+          },
+          after_state: {
+            finished_wrap_visible: false,
+            list_ready: true
+          }
+        };
+      },
+      reloadBossRecommendPage: async () => {
+        reloadCalls += 1;
+        return {
+          ok: true,
+          state: "RECOMMEND_READY",
+          reloaded_url: "https://www.zhipin.com/web/chat/recommend"
+        };
+      },
+      runRecommendSearchCli: async ({ searchParams }) => {
+        searchCalls.push({ ...searchParams });
+        return {
+          ok: true,
+          summary: {
+            candidate_count: 9,
+            applied_filters: searchParams,
+            page_state: { state: "RECOMMEND_READY" }
+          }
+        };
+      },
+      runRecommendScreenCli: async ({ resume }) => {
+        screenCalls.push({ ...resume });
+        if (screenCalls.length === 1) {
+          return {
+            ok: false,
+            error: {
+              code: "TARGET_COUNT_NOT_REACHED_PAGE_EXHAUSTED",
+              message: "推荐列表已到底，但尚未达到目标数。",
+              page_exhaustion: {
+                reason: "bottom_reached",
+                bottom: {
+                  isBottom: true,
+                  finished_wrap_visible: true,
+                  refresh_button_visible: true
+                }
+              }
+            },
+            summary: {
+              processed_count: 4,
+              passed_count: 1,
+              skipped_count: 3,
+              output_csv: "C:/temp/resume.csv",
+              checkpoint_path: "C:/temp/checkpoint.json",
+              completion_reason: "page_exhausted_before_target_count"
+            }
+          };
+        }
+        return {
+          ok: true,
+          summary: {
+            processed_count: 10,
+            passed_count: 3,
+            skipped_count: 7,
+            output_csv: "C:/temp/resume.csv",
+            checkpoint_path: "C:/temp/checkpoint.json",
+            completion_reason: "target_count_reached"
+          }
+        };
+      }
+    }
+  );
+
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(searchCalls.length, 1);
+  assert.equal(searchCalls[0].recent_not_view, "不限");
+  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(refreshCalls, 1);
+  assert.equal(reloadCalls, 0);
+  assert.equal(pageReadyCalls, 1);
+  assert.equal(result.result.candidate_count, null);
+  assert.equal(result.result.completion_reason, "target_count_reached");
+  assert.equal(result.result.auto_recovery.action, "in_page_refresh");
+  assert.equal(result.result.auto_recovery.refresh.ok, true);
+  assert.equal(result.result.auto_recovery.page_exhaustion.reason, "bottom_reached");
+  assert.equal(result.search_params.recent_not_view, "不限");
+}
+
+async function testPageExhaustedBeforeTargetShouldReloadWhenRefreshButtonMissing() {
+  const searchCalls = [];
+  const screenCalls = [];
+  let refreshCalls = 0;
+  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(),
+      refreshBossRecommendList: async () => {
+        refreshCalls += 1;
+        return {
+          ok: false,
+          action: "in_page_refresh",
+          state: "REFRESH_BUTTON_NOT_FOUND",
+          message: "未找到页内刷新按钮。"
+        };
+      },
+      reloadBossRecommendPage: async () => {
+        reloadCalls += 1;
+        return {
+          ok: true,
+          state: "RECOMMEND_READY",
+          reloaded_url: "https://www.zhipin.com/web/chat/recommend"
+        };
+      },
+      runRecommendSearchCli: async ({ searchParams }) => {
+        searchCalls.push({ ...searchParams });
+        return {
+          ok: true,
+          summary: {
+            candidate_count: searchCalls.length === 1 ? 9 : 12,
+            applied_filters: searchParams,
+            page_state: { state: "RECOMMEND_READY" }
+          }
+        };
+      },
+      runRecommendScreenCli: async ({ resume }) => {
+        screenCalls.push({ ...resume });
+        if (screenCalls.length === 1) {
+          return {
+            ok: false,
+            error: {
+              code: "TARGET_COUNT_NOT_REACHED_PAGE_EXHAUSTED",
+              message: "推荐列表已到底，但尚未达到目标数。",
+              page_exhaustion: {
+                reason: "bottom_reached",
+                bottom: {
+                  isBottom: true,
+                  finished_wrap_visible: true,
+                  refresh_button_visible: false
+                }
+              }
+            },
+            summary: {
+              processed_count: 4,
+              passed_count: 1,
+              skipped_count: 3,
+              output_csv: "C:/temp/resume.csv",
+              checkpoint_path: "C:/temp/checkpoint.json",
+              completion_reason: "page_exhausted_before_target_count"
+            }
+          };
+        }
+        return {
+          ok: true,
+          summary: {
+            processed_count: 10,
+            passed_count: 3,
+            skipped_count: 7,
+            output_csv: "C:/temp/resume.csv",
+            checkpoint_path: "C:/temp/checkpoint.json",
+            completion_reason: "target_count_reached"
+          }
+        };
+      }
+    }
+  );
+
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(searchCalls.length, 2);
+  assert.equal(searchCalls[0].recent_not_view, "不限");
+  assert.equal(searchCalls[1].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(refreshCalls, 1);
+  assert.equal(reloadCalls, 1);
+  assert.equal(pageReadyCalls, 2);
+  assert.equal(result.result.candidate_count, 12);
+  assert.equal(result.result.auto_recovery.action, "reload_page_and_rerun_search");
+  assert.equal(result.result.auto_recovery.refresh.state, "REFRESH_BUTTON_NOT_FOUND");
+  assert.equal(result.result.auto_recovery.reload.ok, true);
+  assert.equal(result.search_params.recent_not_view, "近14天没有");
+}
+
+async function testPageExhaustedBeforeTargetShouldReloadWhenRefreshDoesNotRecoverList() {
+  const searchCalls = [];
+  const screenCalls = [];
+  let refreshCalls = 0;
+  let reloadCalls = 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 () => ({ ok: true, state: "RECOMMEND_READY", page_state: { state: "RECOMMEND_READY" } }),
+      listRecommendJobs: async () => createJobListResult(),
+      refreshBossRecommendList: async () => {
+        refreshCalls += 1;
+        return {
+          ok: false,
+          action: "in_page_refresh",
+          state: "LIST_NOT_RELOADED",
+          message: "点击刷新后列表没有重新就绪。"
+        };
+      },
+      reloadBossRecommendPage: async () => {
+        reloadCalls += 1;
+        return {
+          ok: true,
+          state: "RECOMMEND_READY",
+          reloaded_url: "https://www.zhipin.com/web/chat/recommend"
+        };
+      },
+      runRecommendSearchCli: async ({ searchParams }) => {
+        searchCalls.push({ ...searchParams });
+        return {
+          ok: true,
+          summary: {
+            candidate_count: searchCalls.length === 1 ? 9 : 11,
+            applied_filters: searchParams,
+            page_state: { state: "RECOMMEND_READY" }
+          }
+        };
+      },
+      runRecommendScreenCli: async ({ resume }) => {
+        screenCalls.push({ ...resume });
+        if (screenCalls.length === 1) {
+          return {
+            ok: false,
+            error: {
+              code: "TARGET_COUNT_NOT_REACHED_PAGE_EXHAUSTED",
+              message: "推荐列表已到底，但尚未达到目标数。"
+            },
+            summary: {
+              processed_count: 4,
+              passed_count: 1,
+              skipped_count: 3,
+              output_csv: "C:/temp/resume.csv",
+              checkpoint_path: "C:/temp/checkpoint.json",
+              completion_reason: "page_exhausted_before_target_count"
+            }
+          };
+        }
+        return {
+          ok: true,
+          summary: {
+            processed_count: 10,
+            passed_count: 3,
+            skipped_count: 7,
+            output_csv: "C:/temp/resume.csv",
+            checkpoint_path: "C:/temp/checkpoint.json",
+            completion_reason: "target_count_reached"
+          }
+        };
+      }
+    }
+  );
+
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(searchCalls.length, 2);
+  assert.equal(searchCalls[1].recent_not_view, "近14天没有");
+  assert.equal(screenCalls.length, 2);
+  assert.equal(screenCalls[1].resume, true);
+  assert.equal(refreshCalls, 1);
+  assert.equal(reloadCalls, 1);
+  assert.equal(result.result.candidate_count, 11);
+  assert.equal(result.result.auto_recovery.action, "reload_page_and_rerun_search");
+  assert.equal(result.result.auto_recovery.refresh.state, "LIST_NOT_RELOADED");
+  assert.equal(result.search_params.recent_not_view, "近14天没有");
+}
+
+async function testPageExhaustedBeforeTargetShouldFailAfterFiveRecoveryAttempts() {
+  const searchCalls = [];
+  const screenCalls = [];
+  let refreshCalls = 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 () => ({ ok: true, state: "RECOMMEND_READY", page_state: { state: "RECOMMEND_READY" } }),
+      listRecommendJobs: async () => createJobListResult(),
+      refreshBossRecommendList: async () => {
+        refreshCalls += 1;
+        return {
+          ok: true,
+          action: "in_page_refresh",
+          state: "RECOMMEND_READY",
+          before_state: {
+            finished_wrap_visible: true,
+            refresh_button_visible: true
+          },
+          after_state: {
+            finished_wrap_visible: false,
+            list_ready: true
+          }
+        };
+      },
+      runRecommendSearchCli: async ({ searchParams }) => {
+        searchCalls.push({ ...searchParams });
+        return {
+          ok: true,
+          summary: {
+            candidate_count: 9,
+            applied_filters: searchParams,
+            page_state: { state: "RECOMMEND_READY" }
+          }
+        };
+      },
+      runRecommendScreenCli: async ({ resume }) => {
+        screenCalls.push({ ...resume });
+        return {
+          ok: false,
+          error: {
+            code: "TARGET_COUNT_NOT_REACHED_PAGE_EXHAUSTED",
+            message: "推荐列表已到底，但尚未达到目标数。",
+            page_exhaustion: {
+              reason: "bottom_reached",
+              bottom: {
+                isBottom: true,
+                finished_wrap_visible: true,
+                refresh_button_visible: true
+              }
+            }
+          },
+          summary: {
+            processed_count: 4,
+            passed_count: 1,
+            skipped_count: 3,
+            output_csv: "C:/temp/resume.csv",
+            checkpoint_path: "C:/temp/checkpoint.json",
+            completion_reason: "page_exhausted_before_target_count"
+          }
+        };
+      }
+    }
+  );
+
+  assert.equal(result.status, "FAILED");
+  assert.equal(result.error.code, "TARGET_COUNT_NOT_REACHED_PAGE_EXHAUSTED");
+  assert.match(result.error.message, /已达到自动恢复上限 5 次/);
+  assert.equal(searchCalls.length, 1);
+  assert.equal(screenCalls.length, 6);
+  assert.equal(refreshCalls, 5);
+  assert.equal(result.partial_result.output_csv, "C:/temp/resume.csv");
+  assert.equal(result.diagnostics.auto_recovery.attempt, 5);
+  assert.equal(result.diagnostics.auto_recovery.action, "in_page_refresh");
+  assert.equal(result.diagnostics.auto_recovery.partial_result.checkpoint_path, "C:/temp/checkpoint.json");
+}
+
+async function testNullTargetCountShouldKeepPageExhaustedCompletion() {
+  const parsed = createParsed();
+  parsed.screenParams = {
+    ...parsed.screenParams,
+    target_count: null
+  };
+  let receivedScreenParams = null;
+  const result = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "test",
+      confirmation: createJobConfirmedConfirmation(),
+      overrides: {}
+    },
+    {
+      parseRecommendInstruction: () => parsed,
+      runPipelinePreflight: () => ({ ok: true, checks: [], debug_port: 9222 }),
+      ensureBossRecommendPageReady: async () => ({ ok: true, state: "RECOMMEND_READY", page_state: {} }),
+      listRecommendJobs: async () => createJobListResult(),
+      runRecommendSearchCli: async () => ({
+        ok: true,
+        summary: {
+          candidate_count: 9,
+          applied_filters: {},
+          page_state: { state: "RECOMMEND_READY" }
+        }
+      }),
+      runRecommendScreenCli: async ({ screenParams }) => {
+        receivedScreenParams = screenParams;
+        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(receivedScreenParams.target_count, null);
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(result.result.completion_reason, "page_exhausted");
+  assert.equal(result.result.auto_recovery, null);
+}
+
 async function testNeedConfirmationGate() {
   let preflightCalled = false;
   const result = await runRecommendPipeline(
@@ -797,8 +1296,7 @@ async function testPreflightRecoveryPlanOrder() {
         checks: [
           { key: "node_cli", ok: false },
           { key: "npm_dep_ws", ok: false, install_cwd: "C:/workspace/boss-recommend-mcp" },
-          { key: "python_cli", ok: false },
-          { key: "python_pillow", ok: false }
+          { key: "npm_dep_sharp", ok: false, install_cwd: "C:/workspace/boss-recommend-mcp" }
         ]
       }),
       ensureBossRecommendPageReady: async () => ({ ok: true, state: "RECOMMEND_READY", page_state: {} }),
@@ -811,10 +1309,9 @@ async function testPreflightRecoveryPlanOrder() {
   assert.equal(result.error.code, "PIPELINE_PREFLIGHT_FAILED");
   assert.deepEqual(
     result.diagnostics.recovery.ordered_steps.map((item) => item.id),
-    ["install_nodejs", "install_npm_dependencies", "install_python", "install_pillow"]
+    ["install_nodejs", "install_npm_dependencies"]
   );
   assert.deepEqual(result.diagnostics.recovery.ordered_steps[1].blocked_by, ["install_nodejs"]);
-  assert.deepEqual(result.diagnostics.recovery.ordered_steps[3].blocked_by, ["install_python"]);
   assert.equal(result.diagnostics.recovery.agent_prompt.includes("不要并行跳步"), true);
 }
 
@@ -1036,6 +1533,11 @@ async function main() {
   await testResumeFromScreenPauseShouldSkipSearch();
   await testResumeFromPausedBeforeScreenShouldRerunSearch();
   await testConsecutiveResumeCaptureFailuresShouldRefreshAndRerunSearchWithForcedRecentFilter();
+  await testPageExhaustedBeforeTargetShouldRefreshInPageAndResumeScreen();
+  await testPageExhaustedBeforeTargetShouldReloadWhenRefreshButtonMissing();
+  await testPageExhaustedBeforeTargetShouldReloadWhenRefreshDoesNotRecoverList();
+  await testPageExhaustedBeforeTargetShouldFailAfterFiveRecoveryAttempts();
+  await testNullTargetCountShouldKeepPageExhaustedCompletion();
   await testNeedConfirmationGate();
   await testNeedSchoolTagConfirmationGate();
   await testNeedTargetCountConfirmationGate();