@reconcrap/boss-recommend-mcp 1.2.5 → 1.2.7

package/src/index.js

@@ -9,6 +9,7 @@ import {
   runRecommendCalibration
 } from "./adapters.js";
 import { runRecommendPipeline } from "./pipeline.js";
+import { runRecommendSelfHeal } from "./self-heal.js";
 import {
   RUN_MODE_ASYNC,
   RUN_STAGE_PREFLIGHT,
@@ -39,6 +40,7 @@ const TOOL_PAUSE_RUN = "pause_recommend_pipeline_run";
 const TOOL_RESUME_RUN = "resume_recommend_pipeline_run";
 const TOOL_RUN_FEATURED_CALIBRATION = "run_featured_calibration";
 const TOOL_GET_FEATURED_CALIBRATION_STATUS = "get_featured_calibration_status";
+const TOOL_RUN_RECOMMEND_SELF_HEAL = "run_recommend_self_heal";
 
 const SERVER_NAME = "boss-recommend-mcp";
 const FRAMING_UNKNOWN = "unknown";
@@ -49,6 +51,7 @@ const DETACHED_WORKER_RUN_ID_FLAG = "--run-id";
 const DETACHED_WORKER_RESUME_FLAG = "--resume";
 
 let runPipelineImpl = runRecommendPipeline;
+let runSelfHealImpl = runRecommendSelfHeal;
 let spawnProcessImpl = spawn;
 const TERMINAL_RUN_STATES = new Set([RUN_STATE_COMPLETED, RUN_STATE_FAILED, RUN_STATE_CANCELED]);
 
@@ -321,6 +324,43 @@ function createRunFeaturedCalibrationInputSchema() {
   };
 }
 
+function createRunRecommendSelfHealInputSchema() {
+  return {
+    type: "object",
+    properties: {
+      mode: {
+        type: "string",
+        enum: ["scan", "apply"],
+        description: "scan=扫描漂移；apply=按 repair_session_id 应用高置信度修复"
+      },
+      scope: {
+        type: "string",
+        enum: ["full", "search_screen", "selectors_only"],
+        description: "扫描范围，默认 full"
+      },
+      validation_profile: {
+        type: "string",
+        enum: ["safe", "full"],
+        description: "校验强度，默认 full"
+      },
+      port: {
+        type: "integer",
+        minimum: 1,
+        description: "可选，Boss Chrome 远程调试端口"
+      },
+      repair_session_id: {
+        type: "string",
+        description: "apply 模式必填，来自 scan 返回值"
+      },
+      confirm_apply: {
+        type: "boolean",
+        description: "apply 模式必填，必须显式传 true"
+      }
+    },
+    additionalProperties: false
+  };
+}
+
 function createToolsSchema() {
   return [
     {
@@ -389,6 +429,11 @@ function createToolsSchema() {
         properties: {},
         additionalProperties: false
       }
+    },
+    {
+      name: TOOL_RUN_RECOMMEND_SELF_HEAL,
+      description: "手动运维自愈工具：扫描 Boss recommend 相关 selector / network 规则漂移，并在确认后应用高置信度修复。",
+      inputSchema: createRunRecommendSelfHealInputSchema()
     }
   ];
 }
@@ -448,6 +493,42 @@ function validateRunFeaturedCalibrationArgs(args) {
   return null;
 }
 
+function validateRunRecommendSelfHealArgs(args) {
+  if (!args || typeof args !== "object" || Array.isArray(args)) {
+    return "arguments must be an object";
+  }
+
+  if (Object.prototype.hasOwnProperty.call(args, "mode")) {
+    const mode = normalizeText(args.mode).toLowerCase();
+    if (!["scan", "apply"].includes(mode)) {
+      return "mode must be one of: scan, apply";
+    }
+  }
+
+  if (Object.prototype.hasOwnProperty.call(args, "scope")) {
+    const scope = normalizeText(args.scope).toLowerCase();
+    if (!["full", "search_screen", "selectors_only"].includes(scope)) {
+      return "scope must be one of: full, search_screen, selectors_only";
+    }
+  }
+
+  if (Object.prototype.hasOwnProperty.call(args, "validation_profile")) {
+    const profile = normalizeText(args.validation_profile).toLowerCase();
+    if (!["safe", "full"].includes(profile)) {
+      return "validation_profile must be one of: safe, full";
+    }
+  }
+
+  if (Object.prototype.hasOwnProperty.call(args, "port")) {
+    const port = Number.parseInt(String(args.port), 10);
+    if (!Number.isFinite(port) || port <= 0) {
+      return "port must be a positive integer";
+    }
+  }
+
+  return null;
+}
+
 function getLastOutputLine(text) {
   const lines = String(text || "")
     .split(/\r?\n/)
@@ -1340,6 +1421,10 @@ async function handleRunFeaturedCalibrationTool({ workspaceRoot, args }) {
   };
 }
 
+async function handleRunRecommendSelfHealTool({ workspaceRoot, args }) {
+  return runSelfHealImpl({ workspaceRoot, args });
+}
+
 async function handleRequest(message, workspaceRoot) {
   if (!message || message.jsonrpc !== "2.0") {
     return createJsonRpcError(null, -32600, "Invalid JSON-RPC request");
@@ -1396,6 +1481,13 @@ async function handleRequest(message, workspaceRoot) {
       }
     }
 
+    if (toolName === TOOL_RUN_RECOMMEND_SELF_HEAL) {
+      const inputError = validateRunRecommendSelfHealArgs(args);
+      if (inputError) {
+        return createJsonRpcError(id, -32602, inputError);
+      }
+    }
+
     if ([TOOL_GET_RUN, TOOL_CANCEL_RUN, TOOL_PAUSE_RUN, TOOL_RESUME_RUN].includes(toolName)) {
       if (!args || typeof args.run_id !== "string" || !normalizeText(args.run_id)) {
         return createJsonRpcError(id, -32602, "run_id is required and must be a string");
@@ -1418,6 +1510,8 @@ async function handleRequest(message, workspaceRoot) {
         payload = handleGetFeaturedCalibrationStatusTool(workspaceRoot);
       } else if (toolName === TOOL_RUN_FEATURED_CALIBRATION) {
         payload = await handleRunFeaturedCalibrationTool({ workspaceRoot, args });
+      } else if (toolName === TOOL_RUN_RECOMMEND_SELF_HEAL) {
+        payload = await handleRunRecommendSelfHealTool({ workspaceRoot, args });
       } else {
         return createJsonRpcError(id, -32602, `Unknown tool: ${toolName || ""}`);
       }
@@ -1553,6 +1647,9 @@ export const __testables = {
   },
   setRunPipelineImplForTests(nextImpl) {
     runPipelineImpl = typeof nextImpl === "function" ? nextImpl : runRecommendPipeline;
+  },
+  setRunSelfHealImplForTests(nextImpl) {
+    runSelfHealImpl = typeof nextImpl === "function" ? nextImpl : runRecommendSelfHeal;
   }
 };
 

package/src/pipeline.js

@@ -16,6 +16,8 @@ import {
 
 const FORCED_RECENT_NOT_VIEW_ON_SCREEN_RECOVERY = "近14天没有";
 const MAX_SCREEN_AUTO_RECOVERY_ATTEMPTS = 5;
+const MAX_SEARCH_NO_IFRAME_RETRY_ATTEMPTS = 1;
+const SEARCH_NO_IFRAME_RETRY_DELAY_MS = 1200;
 const PAGE_SCOPE_TO_TAB_STATUS = {
   recommend: "0",
   latest: "1",
@@ -40,6 +42,10 @@ function normalizeText(value) {
   return String(value || "").replace(/\s+/g, " ").trim();
 }
 
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 function normalizePageScope(value) {
   const normalized = normalizeText(value).toLowerCase();
   if (!normalized) return null;
@@ -886,6 +892,7 @@ export async function runRecommendPipeline(
   let shouldRunSearch = !skipSearchOnResume;
   let screenAutoRecoveryCount = 0;
   let lastAutoRecovery = null;
+  let searchNoIframeRetryCount = 0;
   let activeTabStatus = null;
   let currentResumeConfig = {
     checkpoint_path: resume?.checkpoint_path || null,
@@ -971,11 +978,14 @@ export async function runRecommendPipeline(
       if (!searchResult.ok) {
         const searchErrorCode = String(searchResult.error?.code || "");
         const searchErrorMessage = String(searchResult.error?.message || "");
+        const isNoIframeSearchFailure = (
+          searchErrorCode === "NO_RECOMMEND_IFRAME"
+          || searchErrorMessage.includes("NO_RECOMMEND_IFRAME")
+        );
         const loginRelatedSearchFailure = (
           searchErrorCode === "LOGIN_REQUIRED"
-          || searchErrorCode === "NO_RECOMMEND_IFRAME"
+          || isNoIframeSearchFailure
           || searchErrorMessage.includes("LOGIN_REQUIRED")
-          || searchErrorMessage.includes("NO_RECOMMEND_IFRAME")
         );
         if (loginRelatedSearchFailure) {
           const recheck = await ensureRecommendPageReady(workspaceRoot, {
@@ -1006,6 +1016,28 @@ export async function runRecommendPipeline(
               }
             );
           }
+          if (
+            isNoIframeSearchFailure
+            && recheck.state === "RECOMMEND_READY"
+            && searchNoIframeRetryCount < MAX_SEARCH_NO_IFRAME_RETRY_ATTEMPTS
+          ) {
+            searchNoIframeRetryCount += 1;
+            const retryDelayMs = SEARCH_NO_IFRAME_RETRY_DELAY_MS;
+            const retryDiagnostics = {
+              trigger: "NO_RECOMMEND_IFRAME",
+              attempt: searchNoIframeRetryCount,
+              max_attempts: MAX_SEARCH_NO_IFRAME_RETRY_ATTEMPTS,
+              delay_ms: retryDelayMs,
+              page_state: recheck.page_state || null
+            };
+            runtimeHooks.setStage(
+              "search_recovery",
+              `检测到 recommend iframe 暂未就绪，等待 ${Math.round(retryDelayMs / 1000)} 秒后重试 search（第 ${searchNoIframeRetryCount}/${MAX_SEARCH_NO_IFRAME_RETRY_ATTEMPTS} 次）。`
+            );
+            runtimeHooks.heartbeat("search_recovery", retryDiagnostics);
+            await sleep(retryDelayMs);
+            continue;
+          }
         }
         return buildFailedResponse(
           searchResult.error?.code || "RECOMMEND_SEARCH_FAILED",

package/src/recommend-healing-config.js

@@ -0,0 +1,131 @@
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+
+const require = createRequire(import.meta.url);
+const currentFilePath = fileURLToPath(import.meta.url);
+const defaultRulesPath = path.join(path.dirname(currentFilePath), "recommend-healing-rules.json");
+
+let cachedRulesPath = null;
+let cachedRulesMtime = null;
+let cachedRules = null;
+
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+function normalizePathLike(value) {
+  return String(value || "").trim();
+}
+
+function getNestedValue(root, pathParts = []) {
+  let current = root;
+  for (const part of pathParts) {
+    if (!current || typeof current !== "object" || Array.isArray(current)) {
+      return undefined;
+    }
+    current = current[part];
+  }
+  return current;
+}
+
+export function getRecommendHealingRulesPath() {
+  const fromEnv = normalizePathLike(process.env.BOSS_RECOMMEND_HEALING_RULES_FILE);
+  return fromEnv ? path.resolve(fromEnv) : defaultRulesPath;
+}
+
+export function loadRecommendHealingRules(options = {}) {
+  const fresh = options.fresh === true;
+  const rulesPath = getRecommendHealingRulesPath();
+  const stats = fs.statSync(rulesPath);
+  if (
+    !fresh
+    && cachedRules
+    && cachedRulesPath === rulesPath
+    && cachedRulesMtime === Number(stats.mtimeMs)
+  ) {
+    return clone(cachedRules);
+  }
+  const nextRules = require(rulesPath);
+  cachedRulesPath = rulesPath;
+  cachedRulesMtime = Number(stats.mtimeMs);
+  cachedRules = clone(nextRules);
+  return clone(cachedRules);
+}
+
+export function saveRecommendHealingRules(nextRules) {
+  const rulesPath = getRecommendHealingRulesPath();
+  const serialized = `${JSON.stringify(nextRules, null, 2)}\n`;
+  fs.writeFileSync(rulesPath, serialized, "utf8");
+  cachedRulesPath = rulesPath;
+  cachedRulesMtime = Number(fs.statSync(rulesPath).mtimeMs);
+  cachedRules = clone(nextRules);
+  return rulesPath;
+}
+
+export function getRecommendSelectorRule(pathParts = [], fallback = []) {
+  const value = getNestedValue(loadRecommendHealingRules(), ["selectors", ...pathParts]);
+  return Array.isArray(value) && value.length > 0 ? value.map((item) => String(item)) : fallback.slice();
+}
+
+export function getRecommendNetworkRule(pathParts = [], fallback = null) {
+  const value = getNestedValue(loadRecommendHealingRules(), ["network", ...pathParts]);
+  if (Array.isArray(value)) return value.map((item) => String(item));
+  if (value && typeof value === "object") return clone(value);
+  if (typeof value === "string") return value;
+  if (Array.isArray(fallback)) return fallback.slice();
+  if (fallback && typeof fallback === "object") return clone(fallback);
+  return fallback;
+}
+
+export function compileRegexList(patterns = []) {
+  return (Array.isArray(patterns) ? patterns : [])
+    .map((pattern) => {
+      try {
+        return new RegExp(String(pattern), "i");
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+export function findFirstMatchingPattern(value, patterns = []) {
+  const text = String(value || "");
+  for (const pattern of compileRegexList(patterns)) {
+    if (pattern.test(text)) return pattern.source;
+  }
+  return null;
+}
+
+export function matchesAnyPattern(value, patterns = []) {
+  return Boolean(findFirstMatchingPattern(value, patterns));
+}
+
+export function buildFirstSelectorLookupExpression(selectors = [], rootExpr = "document") {
+  return `(() => {
+    const selectors = ${JSON.stringify(selectors)};
+    for (const selector of selectors) {
+      try {
+        const node = ${rootExpr}.querySelector(selector);
+        if (node) return node;
+      } catch {}
+    }
+    return null;
+  })()`;
+}
+
+export function buildSelectorCollectionExpression(selectors = [], rootExpr = "document") {
+  return `(() => {
+    const selectors = ${JSON.stringify(selectors)};
+    const nodes = [];
+    for (const selector of selectors) {
+      try {
+        nodes.push(...Array.from(${rootExpr}.querySelectorAll(selector)));
+      } catch {}
+    }
+    return Array.from(new Set(nodes));
+  })()`;
+}

package/src/recommend-healing-rules.json

@@ -0,0 +1,261 @@
+{
+  "version": 1,
+  "selectors": {
+    "top": {
+      "recommend_iframe": [
+        "iframe[name=\"recommendFrame\"]",
+        "iframe[src*=\"/web/frame/recommend/\"]",
+        "iframe"
+      ]
+    },
+    "frame": {
+      "tab_items": [
+        "li.tab-item[data-status]",
+        "li[data-status][class*=\"tab\"]"
+      ],
+      "filter_trigger": [
+        ".filter-label-wrap",
+        ".recommend-filter.op-filter"
+      ],
+      "filter_panel": [
+        ".recommend-filter.op-filter .filter-panel",
+        ".recommend-filter .filter-panel",
+        ".filter-panel"
+      ],
+      "filter_confirm_button": [
+        ".recommend-filter.op-filter .filter-panel .btn",
+        ".recommend-filter.op-filter .filter-panel button",
+        ".filter-panel .btn",
+        ".filter-panel button"
+      ],
+      "filter_group_container": [
+        ".check-box"
+      ],
+      "filter_group_school": [
+        ".check-box.school"
+      ],
+      "filter_group_degree": [
+        ".check-box.degree"
+      ],
+      "filter_group_gender": [
+        ".check-box.gender"
+      ],
+      "filter_group_recent_not_view": [
+        ".check-box.recentNotView"
+      ],
+      "filter_option": [
+        ".check-box .default.option",
+        ".check-box .options .option",
+        ".check-box .option"
+      ],
+      "filter_option_all": [
+        ".default.option, .options .option, .option"
+      ],
+      "filter_option_active": [
+        ".default.option.active, .options .option.active, .option.active"
+      ],
+      "filter_scroll_container": [
+        ".recommend-filter.op-filter .filter-panel .top",
+        ".recommend-filter.op-filter .top",
+        ".recommend-filter.op-filter .filter-panel"
+      ],
+      "filter_confirm_candidates": [
+        ".btn, button"
+      ],
+      "job_dropdown_trigger": [
+        ".top-chat-search",
+        ".chat-job-select",
+        ".chat-job-selector",
+        ".job-selecter",
+        ".job-selector",
+        ".job-select-wrap",
+        ".job-select",
+        ".job-select-box",
+        ".job-wrap",
+        ".chat-job-name"
+      ],
+      "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"
+      ],
+      "job_item_label": [
+        ".ui-dropmenu-list .job-list .job-item .label",
+        ".job-list .job-item .label",
+        ".label"
+      ],
+      "job_search_input": [
+        ".top-chat-search"
+      ],
+      "job_selected_label": [
+        ".job-selecter-wrap .ui-dropmenu-label",
+        ".ui-dropmenu-label",
+        ".chat-job-name",
+        ".job-selecter .label",
+        ".job-selecter .job-name",
+        ".job-select .label"
+      ],
+      "recommend_cards": [
+        "ul.card-list > li.card-item"
+      ],
+      "recommend_card_inner": [
+        ".card-inner[data-geekid]"
+      ],
+      "featured_cards": [
+        "li.geek-info-card"
+      ],
+      "featured_card_anchor": [
+        "a[data-geekid]"
+      ],
+      "latest_cards": [
+        ".candidate-card-wrap"
+      ],
+      "latest_card_inner": [
+        ".candidate-card-wrap .card-inner[data-geek]",
+        ".candidate-card-wrap [data-geek]"
+      ],
+      "refresh_finished_wrap": [
+        ".finished-wrap"
+      ],
+      "refresh_button": [
+        ".finished-wrap .btn.btn-refresh",
+        ".finished-wrap .btn-refresh",
+        ".no-data-refresh .btn-refresh"
+      ]
+    },
+    "detail": {
+      "popup": [
+        ".dialog-wrap.active",
+        ".boss-popup__wrapper",
+        ".boss-popup_wrapper",
+        ".boss-dialog_wrapper",
+        ".boss-dialog",
+        ".resume-item-detail",
+        ".geek-detail-modal",
+        "[class*=\"popup\"][class*=\"wrapper\"]",
+        "[class*=\"dialog\"][class*=\"wrapper\"]"
+      ],
+      "resume_iframe": [
+        "iframe[src*=\"/web/frame/c-resume/\"]",
+        "iframe[name*=\"resume\"]"
+      ],
+      "close_button": [
+        ".boss-popup__close",
+        ".popup-close",
+        ".modal-close",
+        ".dialog-close",
+        ".close-btn",
+        "button[aria-label*=\"关闭\"]",
+        "button[title*=\"关闭\"]",
+        ".icon-close"
+      ],
+      "close_fallback_candidates": [
+        "[aria-label*=\"关闭\"]",
+        "[aria-label*=\"返回\"]",
+        "[title*=\"关闭\"]",
+        "[title*=\"返回\"]",
+        "[class*=\"close\"]",
+        "[class*=\"Close\"]",
+        "[class*=\"back\"]",
+        "[class*=\"Back\"]",
+        "button",
+        "a",
+        "i",
+        "span"
+      ],
+      "ack_button": [
+        "button.btn-v2.btn-sure-v2",
+        "button.btn",
+        ".boss-dialog button",
+        ".boss-popup__wrapper button"
+      ],
+      "favorite_button": [
+        ".like-icon-and-text",
+        ".resume-footer.item-operate [class*=\"collect\"]",
+        ".resume-footer.item-operate [class*=\"favorite\"]",
+        ".resume-footer-wrap [class*=\"collect\"]",
+        ".resume-footer-wrap [class*=\"favorite\"]"
+      ],
+      "greet_button_recommend": [
+        "button.btn-v2.btn-sure-v2.btn-greet",
+        ".resume-footer.item-operate button.btn-v2",
+        ".resume-footer-wrap button.btn-v2",
+        ".resume-footer.item-operate button",
+        ".resume-footer-wrap button"
+      ],
+      "greet_button_featured": [
+        "button.btn-v2.position-rights.btn-sure-v2",
+        "button.btn-v2.btn-sure-v2.position-rights",
+        ".resume-footer.item-operate button.btn-v2",
+        ".resume-footer-wrap button.btn-v2",
+        ".resume-footer.item-operate button",
+        ".resume-footer-wrap button"
+      ]
+    }
+  },
+  "network": {
+    "resume": {
+      "info_url_patterns": [
+        "\\/wapi\\/zpjob\\/view\\/geek\\/info\\b",
+        "\\/wapi\\/zpitem\\/web\\/boss\\/[^?#]*\\/geek\\/info\\b",
+        "\\/boss\\/[^?#]*\\/geek\\/info\\b",
+        "\\/geek\\/info\\b",
+        "[?&](?:geekid|geek_id|encryptgeekid|encryptjid|jid|securityid)="
+      ],
+      "related_keywords": [
+        "geek",
+        "resume",
+        "candidate",
+        "friend"
+      ]
+    },
+    "favorite": {
+      "request_source_keywords": [
+        "usermark",
+        "actionlog/common.json"
+      ],
+      "add_patterns": [
+        "(?:^|[_\\W])(add|favorite|collect|interest(?:ed)?)(?:$|[_\\W])",
+        "\\/add(?:\\/|$)|[?&](?:action|op|operation|type)=add\\b|[?&](?:status|p3|favorite|collect|interested)=1\\b"
+      ],
+      "remove_patterns": [
+        "(?:^|[_\\W])(del|delete|remove|cancel|unfavorite|uncollect|uninterest)(?:$|[_\\W])",
+        "\\/del(?:\\/|$)|[?&](?:action|op|operation|type)=del\\b|[?&](?:status|p3|favorite|collect|interested)=0\\b"
+      ],
+      "actionlog_action_name": "star-interest-click",
+      "status_keys": [
+        "p3",
+        "status",
+        "state",
+        "favorite",
+        "collect",
+        "interested",
+        "markstatus",
+        "isfavorite",
+        "iscollect"
+      ],
+      "operation_keys": [
+        "action",
+        "op",
+        "operation",
+        "type",
+        "mode",
+        "mark",
+        "interest"
+      ]
+    },
+    "greet": {
+      "url_patterns": [
+        "greet",
+        "sayhi",
+        "hello",
+        "friend/add",
+        "chat/start",
+        "boss\\/friend",
+        "boss\\/dialog"
+      ]
+    }
+  }
+}