@reconcrap/boss-recommend-mcp 2.0.40 → 2.0.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reconcrap/boss-recommend-mcp",
-  "version": "2.0.40",
+  "version": "2.0.42",
   "description": "Unified MCP pipeline for recommend-page filtering and screening on Boss Zhipin",
   "keywords": [
     "boss",
@@ -60,6 +60,7 @@
     "live:infinite-list": "node scripts/live-infinite-list-smoke.js",
     "live:scroll-end": "node scripts/live-scroll-end-screenshot.js",
     "live:refresh-round": "node scripts/live-refresh-round-smoke.js",
+    "live:recommend-recovery": "node scripts/live-recommend-recovery-smoke.js",
     "live:self-heal": "node scripts/live-self-heal-smoke.js",
     "live:recommend-actions": "node scripts/live-recommend-actions-smoke.js",
     "live:recommend-phase10-full": "node scripts/live-recommend-phase10-full.js",
@@ -82,6 +83,7 @@
     "config/screening-config.example.json",
     "skills",
     "scripts/postinstall.cjs",
+    "scripts/live-recommend-recovery-smoke.js",
     "src/core",
     "src/domains",
     "src/chat-mcp.js",

package/scripts/live-recommend-recovery-smoke.js

@@ -0,0 +1,305 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import {
+  assertNoForbiddenCdpCalls,
+  assertRuntimeEvaluateBlocked,
+  bringPageToFront,
+  connectToChromeTarget,
+  enableDomains,
+  getAttributesMap,
+  getOuterHTML,
+  querySelector,
+  sleep
+} from "../src/core/browser/index.js";
+import {
+  htmlToText,
+  normalizeText
+} from "../src/core/screening/index.js";
+import {
+  findRecommendJobTrigger,
+  getRecommendRoots,
+  refreshRecommendListAtEnd,
+  RECOMMEND_TARGET_URL,
+  waitForRecommendCardNodeIds
+} from "../src/domains/recommend/index.js";
+
+function parseArgs(argv) {
+  const options = {
+    host: "127.0.0.1",
+    port: 9222,
+    targetUrl: RECOMMEND_TARGET_URL,
+    targetUrlIncludes: RECOMMEND_TARGET_URL,
+    jobLabel: "",
+    pageScope: "recommend",
+    fallbackPageScope: "recommend",
+    forceNavigate: true,
+    forceRecentNotView: true,
+    reloadSettleMs: 12000,
+    cardTimeoutMs: 60000,
+    saveReport: ".live-artifacts/recommend-recovery-smoke.json",
+    filterGroups: [
+      {
+        group: "degree",
+        labels: ["本科", "硕士", "博士"],
+        selectAllLabels: true
+      },
+      {
+        group: "school",
+        labels: ["985", "211", "双一流院校", "国内外名校"],
+        selectAllLabels: true
+      }
+    ]
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--host") options.host = argv[++index];
+    if (arg === "--port") options.port = Number(argv[++index]);
+    if (arg === "--target-url") options.targetUrl = argv[++index];
+    if (arg === "--target-url-includes") options.targetUrlIncludes = argv[++index];
+    if (arg === "--job") options.jobLabel = argv[++index];
+    if (arg === "--page-scope") options.pageScope = argv[++index];
+    if (arg === "--fallback-page-scope") options.fallbackPageScope = argv[++index];
+    if (arg === "--no-force-navigate") options.forceNavigate = false;
+    if (arg === "--no-recent-not-view") options.forceRecentNotView = false;
+    if (arg === "--reload-settle-ms") options.reloadSettleMs = Number(argv[++index]);
+    if (arg === "--card-timeout-ms") options.cardTimeoutMs = Number(argv[++index]);
+    if (arg === "--save-report") options.saveReport = argv[++index];
+    if (arg === "--no-save-report") options.saveReport = "";
+    if (arg === "--no-default-filter") options.filterGroups = [];
+    if (arg === "--filter") {
+      const raw = String(argv[++index] || "");
+      const [group, labelsRaw = ""] = raw.split(/[:=]/);
+      options.filterGroups.push({
+        group: group.trim(),
+        labels: labelsRaw.split(/[，,、|/]/).map((item) => item.trim()).filter(Boolean),
+        selectAllLabels: true
+      });
+    }
+  }
+
+  return options;
+}
+
+function methodSummary(methodLog) {
+  const summary = {};
+  for (const entry of methodLog) {
+    summary[entry.method] = (summary[entry.method] || 0) + 1;
+  }
+  return summary;
+}
+
+function writeJsonFile(filePath, payload) {
+  const resolved = path.resolve(filePath);
+  fs.mkdirSync(path.dirname(resolved), { recursive: true });
+  fs.writeFileSync(resolved, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+  return resolved;
+}
+
+async function connectToRecommendSession(options) {
+  try {
+    return await connectToChromeTarget({
+      host: options.host,
+      port: options.port,
+      targetUrlIncludes: options.targetUrlIncludes
+    });
+  } catch (error) {
+    return connectToChromeTarget({
+      host: options.host,
+      port: options.port,
+      targetPredicate: (target) => (
+        target?.type === "page"
+        && String(target?.url || "").includes("zhipin.com/web/chat")
+      )
+    });
+  }
+}
+
+async function readCurrentJobLabel(client, frameDocumentNodeId) {
+  const labelNodeId = await querySelector(
+    client,
+    frameDocumentNodeId,
+    ".job-selecter-wrap .ui-dropmenu-label, .ui-dropmenu-label"
+  );
+  if (!labelNodeId) return "";
+  const html = await getOuterHTML(client, labelNodeId);
+  return normalizeText(htmlToText(html));
+}
+
+async function summarizeRecommendState(client) {
+  const roots = await getRecommendRoots(client);
+  const iframeAttributes = await getAttributesMap(client, roots.iframe.nodeId).catch(() => ({}));
+  const cardNodeIds = await waitForRecommendCardNodeIds(client, roots.iframe.documentNodeId, {
+    timeoutMs: 1200,
+    intervalMs: 200
+  }).catch(() => []);
+  const trigger = await findRecommendJobTrigger(client, roots.iframe.documentNodeId).catch(() => null);
+  const currentJobLabel = trigger
+    ? await readCurrentJobLabel(client, roots.iframe.documentNodeId).catch(() => "")
+    : "";
+
+  return {
+    roots,
+    summary: {
+      iframe_selector: roots.iframe.selector || "",
+      iframe_node_id: roots.iframe.nodeId,
+      iframe_document_node_id: roots.iframe.documentNodeId,
+      iframe_src: iframeAttributes.src || "",
+      current_job_label: currentJobLabel,
+      job_trigger_found: Boolean(trigger),
+      job_trigger_rect: trigger?.rect || null,
+      card_count: cardNodeIds.length
+    }
+  };
+}
+
+function compactRefreshResult(refreshResult = {}) {
+  return {
+    ok: Boolean(refreshResult.ok),
+    method: refreshResult.method || "",
+    reason: refreshResult.reason || null,
+    error: refreshResult.error || null,
+    forced_recent_not_view: Boolean(refreshResult.forced_recent_not_view),
+    target_url: refreshResult.target_url || null,
+    card_count: refreshResult.card_count || 0,
+    elapsed_ms: refreshResult.elapsed_ms || 0,
+    attempts: (refreshResult.attempts || []).map((attempt) => ({
+      ok: Boolean(attempt.ok),
+      method: attempt.method || "",
+      reason: attempt.reason || null,
+      error: attempt.error || null,
+      card_count: attempt.card_count || 0,
+      elapsed_ms: attempt.elapsed_ms || 0,
+      job_selection_attempts: attempt.job_selection_attempts || []
+    })),
+    job_selection: refreshResult.job_selection
+      ? {
+        requested: refreshResult.job_selection.requested,
+        selected: Boolean(refreshResult.job_selection.selected),
+        already_current: Boolean(refreshResult.job_selection.already_current),
+        reason: refreshResult.job_selection.reason || null,
+        selected_option: refreshResult.job_selection.selected_option || null,
+        refresh_attempts: refreshResult.job_selection.refresh_attempts || []
+      }
+      : null,
+    job_selection_attempts: refreshResult.job_selection_attempts || [],
+    page_scope: refreshResult.page_scope
+      ? {
+        requested_scope: refreshResult.page_scope.requested_scope,
+        effective_scope: refreshResult.page_scope.effective_scope,
+        selected: Boolean(refreshResult.page_scope.selected),
+        fallback_applied: Boolean(refreshResult.page_scope.fallback_applied),
+        reason: refreshResult.page_scope.reason || null,
+        card_count: refreshResult.page_scope.card_count || refreshResult.page_scope.after?.card_count || 0
+      }
+      : null,
+    filter: refreshResult.filter
+      ? {
+        confirmed: Boolean(refreshResult.filter.confirmed),
+        selected_option: refreshResult.filter.selected_option || null,
+        selected_options: refreshResult.filter.selected_options || []
+      }
+      : null,
+    filter_reapply_attempts: refreshResult.filter_reapply_attempts || []
+  };
+}
+
+async function run() {
+  const options = parseArgs(process.argv.slice(2));
+  let session;
+  const result = {
+    status: "UNKNOWN",
+    generated_at: new Date().toISOString(),
+    chrome: {
+      host: options.host,
+      port: options.port,
+      target_url_includes: options.targetUrlIncludes
+    },
+    input: {
+      target_url: options.targetUrl,
+      job_label: options.jobLabel,
+      page_scope: options.pageScope,
+      fallback_page_scope: options.fallbackPageScope,
+      force_navigate: options.forceNavigate,
+      force_recent_not_view: options.forceRecentNotView,
+      reload_settle_ms: options.reloadSettleMs,
+      card_timeout_ms: options.cardTimeoutMs,
+      filter_groups: options.filterGroups
+    },
+    before: null,
+    refresh: null,
+    after: null
+  };
+
+  try {
+    session = await connectToRecommendSession(options);
+    const { client, methodLog, target } = session;
+    result.chrome.target = {
+      id: target.id,
+      type: target.type,
+      url: target.url,
+      title: target.title
+    };
+    result.runtime_guard_probe = await assertRuntimeEvaluateBlocked(client);
+    await enableDomains(client, ["Page", "DOM", "Input", "Accessibility"]);
+    await bringPageToFront(client);
+
+    const beforeState = await summarizeRecommendState(client);
+    result.before = beforeState.summary;
+    const jobLabel = options.jobLabel || beforeState.summary.current_job_label;
+    if (!jobLabel) {
+      throw new Error("No recommend job label was provided or detectable; pass --job");
+    }
+    result.input.job_label = jobLabel;
+
+    const refreshResult = await refreshRecommendListAtEnd(client, {
+      rootState: beforeState.roots,
+      jobLabel,
+      pageScope: options.pageScope,
+      fallbackPageScope: options.fallbackPageScope,
+      filter: { filterGroups: options.filterGroups },
+      preferEndRefreshButton: false,
+      forceNavigate: options.forceNavigate,
+      targetUrl: options.targetUrl,
+      forceRecentNotView: options.forceRecentNotView,
+      cardTimeoutMs: options.cardTimeoutMs,
+      reloadSettleMs: options.reloadSettleMs
+    });
+    result.refresh = compactRefreshResult(refreshResult);
+
+    await sleep(1000);
+    const afterState = await summarizeRecommendState(client);
+    result.after = afterState.summary;
+    result.method_summary = methodSummary(methodLog);
+    assertNoForbiddenCdpCalls(methodLog);
+
+    if (!refreshResult.ok) {
+      throw new Error(`Recommend recovery refresh failed: ${refreshResult.reason || refreshResult.error || "unknown"}`);
+    }
+    if (!refreshResult.job_selection?.selected) {
+      throw new Error("Recommend recovery smoke did not select the requested job");
+    }
+    if (!refreshResult.card_count) {
+      throw new Error("Recommend recovery smoke found no cards after refresh");
+    }
+
+    result.status = "PASS";
+  } catch (error) {
+    result.status = "FAIL";
+    result.error = {
+      message: error?.message || String(error),
+      stack: error?.stack || ""
+    };
+    process.exitCode = 1;
+  } finally {
+    if (session) await session.close().catch(() => null);
+    if (options.saveReport) {
+      result.report_path = writeJsonFile(options.saveReport, result);
+    }
+    console.log(JSON.stringify(result, null, 2));
+  }
+}
+
+await run();

package/src/domains/recommend/refresh.js

@@ -101,6 +101,91 @@ function compactFilterReapplyError(error) {
   return error?.message || String(error || "Recommend filter reapply failed");
 }
 
+export function isRetryableRecommendJobSelectionError(error) {
+  const message = String(error?.message || error || "");
+  return /Recommend job trigger was not found|Recommend job dropdown did not mount options/i.test(message);
+}
+
+function compactJobSelectionAttempt({
+  ok = false,
+  attempt = 0,
+  iframeDocumentNodeId = 0,
+  error = null,
+  selection = null
+} = {}) {
+  return {
+    ok: Boolean(ok),
+    method: "job_select",
+    reason: error ? "job_select_failed" : null,
+    error: error ? (error?.message || String(error)) : null,
+    attempt,
+    iframe_document_node_id: iframeDocumentNodeId || 0,
+    selected: Boolean(selection?.selected),
+    selection_reason: selection?.reason || null
+  };
+}
+
+export async function selectRecommendJobWithRootRefresh(client, rootState, {
+  jobLabel = "",
+  settleMs = 6000,
+  dropdownTimeoutMs = 4000,
+  totalTimeoutMs = 30000,
+  retryDelayMs = 1000
+} = {}) {
+  const started = Date.now();
+  const attempts = [];
+  let currentRootState = rootState || null;
+  let lastError = null;
+  let attempt = 0;
+
+  while (Date.now() - started <= totalTimeoutMs) {
+    attempt += 1;
+    if (!currentRootState?.iframe?.documentNodeId) {
+      currentRootState = await getRecommendRoots(client);
+    }
+    const iframeDocumentNodeId = currentRootState?.iframe?.documentNodeId || 0;
+    try {
+      const selection = await selectRecommendJob(client, iframeDocumentNodeId, {
+        jobLabel,
+        settleMs,
+        dropdownTimeoutMs
+      });
+      attempts.push(compactJobSelectionAttempt({
+        ok: true,
+        attempt,
+        iframeDocumentNodeId,
+        selection
+      }));
+      return {
+        job_selection: {
+          ...selection,
+          refresh_attempts: attempts
+        },
+        root_state: currentRootState,
+        attempts
+      };
+    } catch (error) {
+      lastError = error;
+      attempts.push(compactJobSelectionAttempt({
+        ok: false,
+        attempt,
+        iframeDocumentNodeId,
+        error
+      }));
+      if (!isRetryableRecommendJobSelectionError(error) || Date.now() - started >= totalTimeoutMs) {
+        break;
+      }
+      if (retryDelayMs > 0) await sleep(retryDelayMs);
+      currentRootState = await getRecommendRoots(client);
+    }
+  }
+
+  const wrapped = new Error(lastError?.message || "Recommend job selection failed after refresh reload");
+  wrapped.cause = lastError;
+  wrapped.job_selection_attempts = attempts;
+  throw wrapped;
+}
+
 async function selectAndConfirmRefreshFilter(client, rootState, filterOptions, {
   maxAttempts = 3,
   retryDelayMs = 1500
@@ -162,6 +247,7 @@ async function applyRefreshMethod(client, method, {
   const started = Date.now();
   let currentRootState = null;
   let jobSelection = null;
+  let jobSelectionAttempts = [];
   let pageScopeResult = null;
   let filterResult = null;
   let filterReapplyAttempts = [];
@@ -180,16 +266,19 @@ async function applyRefreshMethod(client, method, {
       throw new Error("Recommend iframe was not ready after refresh reload");
     }
     if (jobLabel) {
-      const jobDropdownTimeoutMs = reloadSettleMs > 10000 ? 15000 : 12000;
-      jobSelection = await selectRecommendJob(client, currentRootState.iframe.documentNodeId, {
+      const jobSelectionResult = await selectRecommendJobWithRootRefresh(client, currentRootState, {
         jobLabel,
         settleMs: reloadSettleMs > 10000 ? 12000 : 6000,
-        dropdownTimeoutMs: jobDropdownTimeoutMs
+        dropdownTimeoutMs: 4000,
+        totalTimeoutMs: reloadSettleMs > 10000 ? 45000 : 30000,
+        retryDelayMs: 1200
       });
+      jobSelection = jobSelectionResult.job_selection;
+      jobSelectionAttempts = jobSelectionResult.attempts;
       if (!jobSelection.selected) {
         throw new Error(`Requested recommend job was not selected after refresh reload: ${jobSelection.reason}`);
       }
-      currentRootState = await getRecommendRoots(client);
+      currentRootState = jobSelectionResult.root_state || await getRecommendRoots(client);
     }
     pageScopeResult = await selectRecommendPageScope(
       client,
@@ -228,6 +317,7 @@ async function applyRefreshMethod(client, method, {
       method,
       target_url: method === "page_navigate" ? (targetUrl || RECOMMEND_TARGET_URL) : null,
       job_selection: jobSelection,
+      job_selection_attempts: jobSelectionAttempts,
       page_scope: pageScopeResult,
       filter: filterResult,
       filter_reapply_attempts: filterReapplyAttempts,
@@ -244,6 +334,7 @@ async function applyRefreshMethod(client, method, {
       error: error?.message || String(error),
       target_url: method === "page_navigate" ? (targetUrl || RECOMMEND_TARGET_URL) : null,
       job_selection: jobSelection,
+      job_selection_attempts: error?.job_selection_attempts || jobSelectionAttempts,
       page_scope: pageScopeResult,
       filter: filterResult,
       filter_reapply_attempts: error?.filter_reapply_attempts || filterReapplyAttempts,

package/src/domains/recommend/run-service.js

@@ -379,6 +379,16 @@ function compactRefreshAttempt(refreshAttempt) {
       error: attempt.error || null,
       attempt: attempt.attempt || 0
     })),
+    job_selection_attempts: (refreshAttempt.job_selection_attempts || []).map((attempt) => ({
+      ok: Boolean(attempt.ok),
+      method: attempt.method || "job_select",
+      reason: attempt.reason || null,
+      error: attempt.error || null,
+      attempt: attempt.attempt || 0,
+      iframe_document_node_id: attempt.iframe_document_node_id || 0,
+      selected: Boolean(attempt.selected),
+      selection_reason: attempt.selection_reason || null
+    })),
     job_selection: compactJobSelection(refreshAttempt.job_selection),
     page_scope: compactPageScopeSelection(refreshAttempt.page_scope),
     filter: compactFilterResult(refreshAttempt.filter)