@reconcrap/boss-recommend-mcp 1.2.6 → 1.2.8

package/vendor/boss-recommend-screen-cli/test-recoverable-resume-failures.cjs

@@ -124,6 +124,30 @@ class FakeRecommendScreenCli extends RecommendScreenCli {
   saveCheckpoint() {}
 }
 
+class FakeDetailCloseProbeCli extends RecommendScreenCli {
+  constructor(args, options = {}) {
+    super(args);
+    this.listReady = options.listReady === true;
+    this.evaluateCallCount = 0;
+  }
+
+  async getDetailClosedState() {
+    return { closed: false, reason: "popup visible: .boss-popup__wrapper" };
+  }
+
+  async evaluate() {
+    this.evaluateCallCount += 1;
+    if (this.evaluateCallCount >= 2) {
+      return this.listReady
+        ? { ok: true, candidate_count: 1 }
+        : { ok: false, error: "LIST_NOT_READY" };
+    }
+    return { ok: false, error: "CLOSE_ACTION_NOOP" };
+  }
+
+  async pressEsc() {}
+}
+
 function createResumeCaptureError(message = "Resume canvas not found") {
   const error = new Error(message);
   error.code = "RESUME_CAPTURE_FAILED";
@@ -306,6 +330,55 @@ async function testPageExhaustedWithoutTargetShouldStillComplete() {
   assert.equal(result.result.completion_reason, "page_exhausted");
 }
 
+async function testTargetCountShouldStopWhenPassedCountReached() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-target-pass-stop-"));
+  const args = createArgs(tempDir);
+  args.targetCount = 1;
+  const first = { key: "pass-1", geek_id: "pass-1", name: "pass-1" };
+  const second = { key: "skip-2", geek_id: "skip-2", name: "skip-2" };
+  const cli = new FakeRecommendScreenCli(args, {
+    candidates: [first, second],
+    screeningByKey: new Map([
+      ["pass-1", { passed: true, reason: "matched", summary: "matched" }],
+      ["skip-2", { passed: false, reason: "not matched", summary: "not matched" }]
+    ])
+  });
+
+  const result = await cli.run();
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(result.result.processed_count, 1);
+  assert.equal(result.result.passed_count, 1);
+  assert.equal(result.result.skipped_count, 0);
+  assert.equal(result.result.completion_reason, "target_count_reached");
+}
+
+async function testTargetCountShouldNotTreatProcessedCountAsReached() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-target-pass-only-"));
+  const args = createArgs(tempDir);
+  args.targetCount = 1;
+  const first = { key: "skip-a", geek_id: "skip-a", name: "skip-a" };
+  const second = { key: "skip-b", geek_id: "skip-b", name: "skip-b" };
+  const cli = new FakeRecommendScreenCli(args, {
+    candidates: [first, second],
+    screeningByKey: new Map([
+      ["skip-a", { passed: false, reason: "not matched", summary: "not matched" }],
+      ["skip-b", { passed: false, reason: "not matched", summary: "not matched" }]
+    ])
+  });
+
+  await assert.rejects(
+    () => cli.run(),
+    (error) => {
+      assert.equal(error.code, "TARGET_COUNT_NOT_REACHED_PAGE_EXHAUSTED");
+      assert.equal(error.retryable, true);
+      assert.equal(error.partial_result?.processed_count, 2);
+      assert.equal(error.partial_result?.passed_count, 0);
+      assert.equal(error.partial_result?.completion_reason, "page_exhausted_before_target_count");
+      return true;
+    }
+  );
+}
+
 async function testFeaturedShouldUseNetworkResumeOnly() {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-network-first-"));
   const candidate = { key: "net-1", geek_id: "net-1", name: "network candidate" };
@@ -842,12 +915,152 @@ function testParseArgsShouldSupportLatestPageScope() {
   assert.equal(parsed.port, 9222);
 }
 
+async function testCallTextModelShouldNotTruncateLongResume() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-text-full-"));
+  const cli = new RecommendScreenCli(createArgs(tempDir));
+  const marker = "__END_OF_RESUME_MARKER__";
+  const resumeText = `${"A".repeat(32000)}${marker}`;
+  const originalFetch = global.fetch;
+  let capturedUserContent = "";
+  global.fetch = async (_url, options = {}) => {
+    const payload = JSON.parse(String(options.body || "{}"));
+    capturedUserContent = String(payload?.messages?.[1]?.content || "");
+    return {
+      ok: true,
+      status: 200,
+      async json() {
+        return {
+          choices: [
+            {
+              message: {
+                content: "{\"passed\": false, \"reason\": \"not matched\", \"summary\": \"not matched\", \"evidence\": [\"A\"]}"
+              }
+            }
+          ]
+        };
+      }
+    };
+  };
+  try {
+    const result = await cli.callTextModel(resumeText);
+    assert.equal(result.passed, false);
+    assert.equal(capturedUserContent.includes(marker), true);
+  } finally {
+    global.fetch = originalFetch;
+  }
+}
+
+async function testCallTextModelShouldFallbackToChunkModeOnContextLimit() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-text-chunk-fallback-"));
+  const cli = new RecommendScreenCli(createArgs(tempDir));
+  const originalFetch = global.fetch;
+  const prevChunkSize = process.env.BOSS_RECOMMEND_TEXT_CHUNK_SIZE_CHARS;
+  const prevChunkOverlap = process.env.BOSS_RECOMMEND_TEXT_CHUNK_OVERLAP_CHARS;
+  const prevMaxChunks = process.env.BOSS_RECOMMEND_TEXT_MAX_CHUNKS;
+  process.env.BOSS_RECOMMEND_TEXT_CHUNK_SIZE_CHARS = "80";
+  process.env.BOSS_RECOMMEND_TEXT_CHUNK_OVERLAP_CHARS = "0";
+  process.env.BOSS_RECOMMEND_TEXT_MAX_CHUNKS = "6";
+
+  const passMarker = "PASS_MARKER_ABC";
+  const resumeText = `${"x".repeat(120)}${passMarker}${"y".repeat(120)}`;
+  let callCount = 0;
+  global.fetch = async (_url, options = {}) => {
+    callCount += 1;
+    if (callCount === 1) {
+      return {
+        ok: false,
+        status: 400,
+        async text() {
+          return "maximum context length exceeded";
+        }
+      };
+    }
+
+    const payload = JSON.parse(String(options.body || "{}"));
+    const userContent = String(payload?.messages?.[1]?.content || "");
+    const passed = userContent.includes(passMarker);
+    const response = passed
+      ? "{\"passed\": true, \"reason\": \"命中证据\", \"summary\": \"命中\", \"evidence\": [\"PASS_MARKER_ABC\"]}"
+      : "{\"passed\": false, \"reason\": \"本段证据不足\", \"summary\": \"不足\", \"evidence\": []}";
+    return {
+      ok: true,
+      status: 200,
+      async json() {
+        return {
+          choices: [
+            {
+              message: {
+                content: response
+              }
+            }
+          ]
+        };
+      }
+    };
+  };
+  try {
+    const result = await cli.callTextModel(resumeText);
+    assert.equal(result.passed, true);
+    assert.equal(callCount >= 2, true);
+    assert.equal(Array.isArray(result.evidence), true);
+  } finally {
+    global.fetch = originalFetch;
+    if (prevChunkSize === undefined) {
+      delete process.env.BOSS_RECOMMEND_TEXT_CHUNK_SIZE_CHARS;
+    } else {
+      process.env.BOSS_RECOMMEND_TEXT_CHUNK_SIZE_CHARS = prevChunkSize;
+    }
+    if (prevChunkOverlap === undefined) {
+      delete process.env.BOSS_RECOMMEND_TEXT_CHUNK_OVERLAP_CHARS;
+    } else {
+      process.env.BOSS_RECOMMEND_TEXT_CHUNK_OVERLAP_CHARS = prevChunkOverlap;
+    }
+    if (prevMaxChunks === undefined) {
+      delete process.env.BOSS_RECOMMEND_TEXT_MAX_CHUNKS;
+    } else {
+      process.env.BOSS_RECOMMEND_TEXT_MAX_CHUNKS = prevMaxChunks;
+    }
+  }
+}
+
+async function testPrepareVisionImageSegmentsShouldSplitLongImage() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-vision-segments-"));
+  const cli = new RecommendScreenCli(createArgs(tempDir));
+  const imagePath = path.join(tempDir, "long.png");
+  await sharp({
+    create: { width: 400, height: 1200, channels: 3, background: { r: 240, g: 240, b: 240 } }
+  }).png().toFile(imagePath);
+
+  const prepared = await cli.prepareVisionImageSegmentsForModel(imagePath, 120000, "test");
+  assert.equal(Array.isArray(prepared.imagePaths), true);
+  assert.equal(prepared.imagePaths.length > 1, true);
+  for (const segmentPath of prepared.imagePaths) {
+    assert.equal(fs.existsSync(segmentPath), true);
+  }
+}
+
+async function testCloseDetailPageShouldFailWhenDetailStillOpenAndListNotReady() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-close-detail-fail-"));
+  const cli = new FakeDetailCloseProbeCli(createArgs(tempDir), { listReady: false });
+  const closed = await cli.closeDetailPage(1);
+  assert.equal(closed, false);
+}
+
+async function testCloseDetailPageShouldContinueWhenListReady() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-close-detail-list-ready-"));
+  const cli = new FakeDetailCloseProbeCli(createArgs(tempDir), { listReady: true });
+  const closed = await cli.closeDetailPage(1);
+  assert.equal(closed, true);
+}
+
 async function main() {
   testShouldAbortResumeProbeEarly();
   await testSingleResumeCaptureFailureIsSkipped();
   await testConsecutiveResumeCaptureFailuresStillAbort();
   await testPageExhaustedBeforeTargetShouldRaiseRecoverableError();
   await testPageExhaustedWithoutTargetShouldStillComplete();
+  await testTargetCountShouldStopWhenPassedCountReached();
+  await testTargetCountShouldNotTreatProcessedCountAsReached();
   await testFeaturedShouldUseNetworkResumeOnly();
   await testRecommendShouldPreferNetworkResumeWhenAvailable();
   await testNetworkMissShouldFallbackToImageCapture();
@@ -871,6 +1084,11 @@ async function main() {
   testStitchWithAvailablePythonShouldFailWhenScriptMissing();
   testParseArgsShouldSupportFeaturedAliasesAndInlinePort();
   testParseArgsShouldSupportLatestPageScope();
+  await testCallTextModelShouldNotTruncateLongResume();
+  await testCallTextModelShouldFallbackToChunkModeOnContextLimit();
+  await testPrepareVisionImageSegmentsShouldSplitLongImage();
+  await testCloseDetailPageShouldFailWhenDetailStillOpenAndListNotReady();
+  await testCloseDetailPageShouldContinueWhenListReady();
   console.log("recoverable resume failure tests passed");
 }
 

package/vendor/boss-recommend-search-cli/src/cli.js

@@ -1,8 +1,13 @@
 #!/usr/bin/env node
 import process from "node:process";
 import readline from "node:readline";
+import { createRequire } from "node:module";
 import { pathToFileURL } from "node:url";
 import CDP from "chrome-remote-interface";
+import {
+  buildFirstSelectorLookupExpression,
+  getRecommendSelectorRule
+} from "../../../src/recommend-healing-config.js";
 
 const DEFAULT_PORT = 9222;
 const RECOMMEND_URL_FRAGMENT = "/web/chat/recommend";
@@ -14,6 +19,56 @@ const DEGREE_OPTIONS = ["不限", "初中及以下", "中专/中技", "高中",
 const DEGREE_ORDER = ["初中及以下", "中专/中技", "高中", "大专", "本科", "硕士", "博士"];
 const GENDER_OPTIONS = ["不限", "男", "女"];
 const RECENT_NOT_VIEW_OPTIONS = ["不限", "近14天没有"];
+const require = createRequire(import.meta.url);
+require("../../../src/recommend-healing-rules.json");
+const RECOMMEND_IFRAME_SELECTORS = getRecommendSelectorRule(
+  ["top", "recommend_iframe"],
+  ['iframe[name="recommendFrame"]', 'iframe[src*="/web/frame/recommend/"]', "iframe"]
+);
+const FILTER_TRIGGER_SELECTORS = getRecommendSelectorRule(
+  ["frame", "filter_trigger"],
+  [".filter-label-wrap", ".recommend-filter.op-filter"]
+);
+const JOB_DROPDOWN_TRIGGER_SELECTORS = getRecommendSelectorRule(
+  ["frame", "job_dropdown_trigger"],
+  [
+    ".chat-job-select",
+    ".chat-job-selector",
+    ".job-selecter",
+    ".job-selector",
+    ".job-select-wrap",
+    ".job-select",
+    ".job-select-box",
+    ".job-wrap",
+    ".chat-job-name",
+    ".top-chat-search"
+  ]
+);
+const JOB_LIST_ITEM_SELECTORS = getRecommendSelectorRule(
+  ["frame", "job_list_items"],
+  [
+    ".ui-dropmenu-list .job-list .job-item",
+    ".job-selecter-options .job-list .job-item",
+    ".job-selector-options .job-list .job-item",
+    ".dropmenu-list .job-list .job-item",
+    ".job-list .job-item"
+  ]
+);
+const JOB_SELECTED_LABEL_SELECTORS = getRecommendSelectorRule(
+  ["frame", "job_selected_label"],
+  [".chat-job-name", ".job-selecter .label", ".job-selecter .job-name", ".job-select .label"]
+);
+const RECOMMEND_CARD_SELECTORS = getRecommendSelectorRule(["frame", "recommend_cards"], ["ul.card-list > li.card-item"]);
+const FEATURED_CARD_SELECTORS = getRecommendSelectorRule(["frame", "featured_cards"], ["li.geek-info-card"]);
+const LATEST_CARD_SELECTORS = getRecommendSelectorRule(["frame", "latest_cards"], [".candidate-card-wrap"]);
+const RECOMMEND_TAB_SELECTORS = getRecommendSelectorRule(
+  ["frame", "tab_items"],
+  ["li.tab-item[data-status]", 'li[data-status][class*="tab"]']
+);
+
+function buildRecommendFrameExpression() {
+  return buildFirstSelectorLookupExpression(RECOMMEND_IFRAME_SELECTORS);
+}
 
 function normalizeText(value) {
   return String(value || "").replace(/\s+/g, " ").trim();
@@ -419,9 +474,7 @@ class RecommendSearchCli {
           title
         };
       }
-      const frame = document.querySelector('iframe[name="recommendFrame"]')
-        || document.querySelector('iframe[src*="/web/frame/recommend/"]')
-        || document.querySelector('iframe');
+      const frame = ${buildRecommendFrameExpression()};
       if (!frame || !frame.contentDocument) {
         return { ok: false, error: 'NO_RECOMMEND_IFRAME', currentUrl, title };
       }
@@ -438,14 +491,16 @@ class RecommendSearchCli {
 
   async getFilterEntryPoint() {
     return this.evaluate(`(() => {
-      const frame = document.querySelector('iframe[name="recommendFrame"]')
-        || document.querySelector('iframe[src*="/web/frame/recommend/"]')
-        || document.querySelector('iframe');
+      const frame = ${buildRecommendFrameExpression()};
       if (!frame || !frame.contentDocument) {
         return { ok: false, error: 'NO_RECOMMEND_IFRAME' };
       }
       const doc = frame.contentDocument;
-      const el = doc.querySelector('.filter-label-wrap') || doc.querySelector('.recommend-filter.op-filter');
+      const el = ${JSON.stringify(FILTER_TRIGGER_SELECTORS)}
+        .map((selector) => {
+          try { return doc.querySelector(selector); } catch { return null; }
+        })
+        .find((node) => node) || null;
       if (!el) {
         return { ok: false, error: 'FILTER_TRIGGER_NOT_FOUND' };
       }
@@ -461,9 +516,7 @@ class RecommendSearchCli {
 
   async getJobListState() {
     return this.evaluate(`(() => {
-      const frame = document.querySelector('iframe[name="recommendFrame"]')
-        || document.querySelector('iframe[src*="/web/frame/recommend/"]')
-        || document.querySelector('iframe');
+      const frame = ${buildRecommendFrameExpression()};
       if (!frame || !frame.contentDocument) {
         return { ok: false, error: 'NO_RECOMMEND_IFRAME' };
       }
@@ -491,13 +544,10 @@ class RecommendSearchCli {
         return rect.width > 2 && rect.height > 2;
       };
 
-      const items = Array.from(doc.querySelectorAll([
-        '.ui-dropmenu-list .job-list .job-item',
-        '.job-selecter-options .job-list .job-item',
-        '.job-selector-options .job-list .job-item',
-        '.dropmenu-list .job-list .job-item',
-        '.job-list .job-item'
-      ].join(',')));
+      const items = ${JSON.stringify(JOB_LIST_ITEM_SELECTORS)}
+        .flatMap((selector) => {
+          try { return Array.from(doc.querySelectorAll(selector)); } catch { return []; }
+        });
       const jobs = [];
       const seen = new Set();
       for (const item of items) {
@@ -516,7 +566,11 @@ class RecommendSearchCli {
         });
       }
 
-      const selectedLabelNode = doc.querySelector('.chat-job-name, .job-selecter .label, .job-selecter .job-name, .job-select .label');
+      const selectedLabelNode = ${JSON.stringify(JOB_SELECTED_LABEL_SELECTORS)}
+        .map((selector) => {
+          try { return doc.querySelector(selector); } catch { return null; }
+        })
+        .find((node) => node) || null;
       return {
         ok: true,
         jobs,
@@ -530,25 +584,12 @@ class RecommendSearchCli {
 
   async clickJobDropdownTriggerBySelector() {
     return this.evaluate(`(() => {
-      const frame = document.querySelector('iframe[name="recommendFrame"]')
-        || document.querySelector('iframe[src*="/web/frame/recommend/"]')
-        || document.querySelector('iframe');
+      const frame = ${buildRecommendFrameExpression()};
       if (!frame || !frame.contentDocument) {
         return { ok: false, error: 'NO_RECOMMEND_IFRAME' };
       }
       const doc = frame.contentDocument;
-      const selectors = [
-        '.chat-job-select',
-        '.chat-job-selector',
-        '.job-selecter',
-        '.job-selector',
-        '.job-select-wrap',
-        '.job-select',
-        '.job-select-box',
-        '.job-wrap',
-        '.chat-job-name',
-        '.top-chat-search'
-      ];
+      const selectors = ${JSON.stringify(JOB_DROPDOWN_TRIGGER_SELECTORS)};
       const isVisible = (el) => {
         if (!el) return false;
         const style = getComputedStyle(el);
@@ -615,9 +656,7 @@ class RecommendSearchCli {
 
   async clickJobBySelector(job) {
     return this.evaluate(`((job) => {
-      const frame = document.querySelector('iframe[name="recommendFrame"]')
-        || document.querySelector('iframe[src*="/web/frame/recommend/"]')
-        || document.querySelector('iframe');
+      const frame = ${buildRecommendFrameExpression()};
       if (!frame || !frame.contentDocument) {
         return { ok: false, error: 'NO_RECOMMEND_IFRAME' };
       }
@@ -635,13 +674,10 @@ class RecommendSearchCli {
           .trim();
         return strippedSingle || byGap;
       };
-      const items = Array.from(doc.querySelectorAll([
-        '.ui-dropmenu-list .job-list .job-item',
-        '.job-selecter-options .job-list .job-item',
-        '.job-selector-options .job-list .job-item',
-        '.dropmenu-list .job-list .job-item',
-        '.job-list .job-item'
-      ].join(',')));
+      const items = ${JSON.stringify(JOB_LIST_ITEM_SELECTORS)}
+        .flatMap((selector) => {
+          try { return Array.from(doc.querySelectorAll(selector)); } catch { return []; }
+        });
       const target = items.find((item) => {
         const value = normalize(item.getAttribute('value') || item.dataset?.value || '');
         const label = normalize(item.querySelector('.label')?.textContent || item.textContent || '');
@@ -1439,20 +1475,30 @@ class RecommendSearchCli {
 
   async countCandidates() {
     return this.evaluate(`(() => {
-      const frame = document.querySelector('iframe[name="recommendFrame"]')
-        || document.querySelector('iframe[src*="/web/frame/recommend/"]')
-        || document.querySelector('iframe');
+      const frame = ${buildRecommendFrameExpression()};
       if (!frame || !frame.contentDocument) {
         return { ok: false, error: 'NO_RECOMMEND_IFRAME' };
       }
       const doc = frame.contentDocument;
-      const cards = Array.from(doc.querySelectorAll('ul.card-list > li.card-item'));
+      const cards = ${JSON.stringify(RECOMMEND_CARD_SELECTORS)}
+        .flatMap((selector) => {
+          try { return Array.from(doc.querySelectorAll(selector)); } catch { return []; }
+        });
       const recommendCandidates = cards.filter((card) => card.querySelector('.card-inner[data-geekid]'));
-      const featuredCards = Array.from(doc.querySelectorAll('li.geek-info-card'));
+      const featuredCards = ${JSON.stringify(FEATURED_CARD_SELECTORS)}
+        .flatMap((selector) => {
+          try { return Array.from(doc.querySelectorAll(selector)); } catch { return []; }
+        });
       const featuredCandidates = featuredCards.filter((card) => card.querySelector('a[data-geekid]'));
-      const latestCards = Array.from(doc.querySelectorAll('.candidate-card-wrap'));
+      const latestCards = ${JSON.stringify(LATEST_CARD_SELECTORS)}
+        .flatMap((selector) => {
+          try { return Array.from(doc.querySelectorAll(selector)); } catch { return []; }
+        });
       const latestCandidates = latestCards.filter((card) => card.querySelector('.card-inner[data-geek], [data-geek]'));
-      const tabs = Array.from(doc.querySelectorAll('li.tab-item[data-status], li[data-status][class*="tab"]'));
+      const tabs = ${JSON.stringify(RECOMMEND_TAB_SELECTORS)}
+        .flatMap((selector) => {
+          try { return Array.from(doc.querySelectorAll(selector)); } catch { return []; }
+        });
       const activeTab = tabs.find((node) => {
         const className = String(node.className || '');
         const selected = String(node.getAttribute('aria-selected') || '').toLowerCase() === 'true';
@@ -1648,3 +1694,5 @@ export {
   normalizeJobTitle,
   parseArgs
 };
+
+