@reconcrap/boss-recommend-mcp 1.2.5 → 1.2.7

package/src/test-pipeline.js

@@ -1505,6 +1505,72 @@ async function testSearchNoIframeWithLoginShouldReturnLoginRequired() {
   assert.equal(result.guidance.agent_prompt.includes("https://www.zhipin.com/web/user/?ka=bticket"), true);
 }
 
+async function testSearchNoIframeShouldRetryOnceWhenPageRecheckReady() {
+  let searchCallCount = 0;
+  let recheckCount = 0;
+  const result = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "test",
+      confirmation: createJobConfirmedConfirmation(),
+      overrides: {}
+    },
+    {
+      parseRecommendInstruction: () => createParsed(),
+      runPipelinePreflight: () => ({ ok: true, checks: [], debug_port: 9222 }),
+      ensureBossRecommendPageReady: async () => {
+        recheckCount += 1;
+        return {
+          ok: true,
+          debug_port: 9222,
+          state: "RECOMMEND_READY",
+          page_state: {
+            state: "RECOMMEND_READY",
+            expected_url: "https://www.zhipin.com/web/chat/recommend",
+            current_url: "https://www.zhipin.com/web/chat/recommend"
+          }
+        };
+      },
+      listRecommendJobs: async () => createJobListResult(),
+      runRecommendSearchCli: async () => {
+        searchCallCount += 1;
+        if (searchCallCount === 1) {
+          return {
+            ok: false,
+            stdout: "",
+            stderr: "NO_RECOMMEND_IFRAME",
+            structured: null,
+            error: {
+              code: "NO_RECOMMEND_IFRAME",
+              message: "NO_RECOMMEND_IFRAME"
+            }
+          };
+        }
+        return {
+          ok: true,
+          summary: {
+            candidate_count: 5,
+            applied_filters: {}
+          }
+        };
+      },
+      runRecommendScreenCli: async () => ({
+        ok: true,
+        summary: {
+          processed_count: 2,
+          passed_count: 1,
+          skipped_count: 1,
+          output_csv: "C:/temp/retry.csv"
+        }
+      })
+    }
+  );
+
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(searchCallCount, 2);
+  assert.equal(recheckCount >= 2, true);
+}
+
 async function testJobTriggerNotFoundShouldMapToLoginRequiredWhenRecheckShowsLogin() {
   const result = await runRecommendPipeline(
     {
@@ -1940,6 +2006,7 @@ async function main() {
   await testCompletedPipeline();
   await testSearchFailure();
   await testSearchNoIframeWithLoginShouldReturnLoginRequired();
+  await testSearchNoIframeShouldRetryOnceWhenPageRecheckReady();
   await testJobTriggerNotFoundShouldMapToLoginRequiredWhenRecheckShowsLogin();
   await testLoginRequiredShouldReturnGuidance();
   await testDebugPortUnreachableShouldReturnConnectionCode();

package/src/test-self-heal.js

@@ -0,0 +1,224 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { __testables as indexTestables } from "./index.js";
+import { runRecommendSelfHeal, __testables as selfHealTestables } from "./self-heal.js";
+
+const {
+  handleRequest,
+  setRunSelfHealImplForTests
+} = indexTestables;
+
+const TOOL_RUN_RECOMMEND_SELF_HEAL = "run_recommend_self_heal";
+
+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 {
+    payload: await readToolPayload(response),
+    response
+  };
+}
+
+async function testToolsListShouldIncludeSelfHeal() {
+  const response = await handleRequest({ jsonrpc: "2.0", id: 1, method: "tools/list", params: {} }, process.cwd());
+  const tools = response?.result?.tools || [];
+  assert.equal(tools.some((tool) => tool?.name === TOOL_RUN_RECOMMEND_SELF_HEAL), true);
+}
+
+async function testIndexShouldRouteSelfHealTool() {
+  setRunSelfHealImplForTests(async () => ({ status: "HEALTHY", message: "ok" }));
+  try {
+    const { payload } = await callTool(TOOL_RUN_RECOMMEND_SELF_HEAL, {}, 2);
+    assert.equal(payload?.status, "HEALTHY");
+  } finally {
+    setRunSelfHealImplForTests(null);
+  }
+}
+
+async function testScanShouldCreateRepairSession() {
+  const previousHome = process.env.BOSS_RECOMMEND_HOME;
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-self-heal-home-"));
+  process.env.BOSS_RECOMMEND_HOME = tempHome;
+  try {
+    const result = await runRecommendSelfHeal(
+      { workspaceRoot: process.cwd(), args: { mode: "scan" } },
+      {
+        scanRuntimeSurface: async () => ({
+          selector_checks: [
+            {
+              rule_id: "filter_trigger",
+              path: ["frame", "filter_trigger"],
+              root: "frame",
+              matches: [
+                { selector: ".filter-label-wrap", index: 0, count: 0 },
+                { selector: ".recommend-filter.op-filter", index: 1, count: 1 }
+              ]
+            }
+          ],
+          network_checks: [],
+          side_effect_summary: { opened_candidate_detail: false }
+        })
+      }
+    );
+    assert.equal(result.status, "NEED_CONFIRMATION");
+    assert.equal(typeof result.repair_session_id, "string");
+    assert.equal(result.proposed_repairs.length, 1);
+    const sessionPath = path.join(selfHealTestables.getSelfHealSessionsDir(), `${result.repair_session_id}.json`);
+    assert.equal(fs.existsSync(sessionPath), true);
+  } 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 testOptionalSelectorMissShouldNotBecomeDrift() {
+  const drifts = selfHealTestables.analyzeSelectorChecks([
+    {
+      rule_id: "featured_cards",
+      path: ["frame", "featured_cards"],
+      root: "frame",
+      required: false,
+      report_on_no_match: false,
+      skipped: false,
+      matches: [
+        { selector: "li.geek-info-card", index: 0, count: 0 }
+      ]
+    }
+  ]);
+  assert.equal(drifts.length, 0);
+}
+
+async function testApplyShouldRequireConfirmation() {
+  const previousHome = process.env.BOSS_RECOMMEND_HOME;
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-self-heal-apply-home-"));
+  process.env.BOSS_RECOMMEND_HOME = tempHome;
+  try {
+    const scanResult = await runRecommendSelfHeal(
+      { workspaceRoot: process.cwd(), args: { mode: "scan" } },
+      {
+        scanRuntimeSurface: async () => ({
+          selector_checks: [
+            {
+              rule_id: "filter_trigger",
+              path: ["frame", "filter_trigger"],
+              root: "frame",
+              matches: [
+                { selector: ".filter-label-wrap", index: 0, count: 0 },
+                { selector: ".recommend-filter.op-filter", index: 1, count: 1 }
+              ]
+            }
+          ],
+          network_checks: [],
+          side_effect_summary: null
+        })
+      }
+    );
+    const result = await runRecommendSelfHeal({
+      workspaceRoot: process.cwd(),
+      args: {
+        mode: "apply",
+        repair_session_id: scanResult.repair_session_id
+      }
+    });
+    assert.equal(result.status, "FAILED");
+    assert.equal(result.error?.code, "SELF_HEAL_CONFIRMATION_REQUIRED");
+  } 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 testApplyShouldUpdateRulesFile() {
+  const previousHome = process.env.BOSS_RECOMMEND_HOME;
+  const previousRulesPath = process.env.BOSS_RECOMMEND_HEALING_RULES_FILE;
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-self-heal-rules-home-"));
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-self-heal-rules-"));
+  const rulesSourcePath = path.join(process.cwd(), "src", "recommend-healing-rules.json");
+  const tempRulesPath = path.join(tempDir, "recommend-healing-rules.json");
+  fs.copyFileSync(rulesSourcePath, tempRulesPath);
+  process.env.BOSS_RECOMMEND_HOME = tempHome;
+  process.env.BOSS_RECOMMEND_HEALING_RULES_FILE = tempRulesPath;
+  try {
+    const scanResult = await runRecommendSelfHeal(
+      { workspaceRoot: process.cwd(), args: { mode: "scan" } },
+      {
+        scanRuntimeSurface: async () => ({
+          selector_checks: [
+            {
+              rule_id: "filter_trigger",
+              path: ["frame", "filter_trigger"],
+              root: "frame",
+              matches: [
+                { selector: ".filter-label-wrap", index: 0, count: 0 },
+                { selector: ".recommend-filter.op-filter", index: 1, count: 1 }
+              ]
+            }
+          ],
+          network_checks: [],
+          side_effect_summary: null
+        })
+      }
+    );
+    const result = await runRecommendSelfHeal({
+      workspaceRoot: process.cwd(),
+      args: {
+        mode: "apply",
+        repair_session_id: scanResult.repair_session_id,
+        confirm_apply: true
+      }
+    });
+    assert.equal(result.status, "REPAIRED");
+    const updatedRules = JSON.parse(fs.readFileSync(tempRulesPath, "utf8"));
+    assert.equal(updatedRules.selectors.frame.filter_trigger[0], ".recommend-filter.op-filter");
+  } finally {
+    if (previousHome === undefined) {
+      delete process.env.BOSS_RECOMMEND_HOME;
+    } else {
+      process.env.BOSS_RECOMMEND_HOME = previousHome;
+    }
+    if (previousRulesPath === undefined) {
+      delete process.env.BOSS_RECOMMEND_HEALING_RULES_FILE;
+    } else {
+      process.env.BOSS_RECOMMEND_HEALING_RULES_FILE = previousRulesPath;
+    }
+    fs.rmSync(tempHome, { recursive: true, force: true });
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+async function main() {
+  await testToolsListShouldIncludeSelfHeal();
+  await testIndexShouldRouteSelfHealTool();
+  await testScanShouldCreateRepairSession();
+  await testOptionalSelectorMissShouldNotBecomeDrift();
+  await testApplyShouldRequireConfirmation();
+  await testApplyShouldUpdateRulesFile();
+  console.log("self-heal tests passed");
+}
+
+await main();