@reconcrap/boss-recommend-mcp 2.0.41 → 2.0.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reconcrap/boss-recommend-mcp",
-  "version": "2.0.41",
+  "version": "2.0.43",
   "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/detail.js

@@ -22,12 +22,21 @@ import {
 import {
   getRecommendRoots
 } from "./roots.js";
-import {
-  findRecommendCardNodeIds,
-  readRecommendCardCandidate
-} from "./cards.js";
-
-export function matchesRecommendDetailNetwork(url) {
+import {
+  findRecommendCardNodeIds,
+  readRecommendCardCandidate
+} from "./cards.js";
+
+const DETAIL_OUTSIDE_CLOSE_BOUNDARY_SELECTORS = Object.freeze([
+  ".resume-center-side .resume-detail-wrap",
+  ".resume-detail-wrap",
+  ".boss-popup__wrapper .boss-popup__body",
+  ".boss-popup__wrapper .dialog-body",
+  ".dialog-wrap.active .resume-detail-wrap",
+  ".geek-detail-modal .resume-detail-wrap"
+]);
+
+export function matchesRecommendDetailNetwork(url) {
   return DETAIL_NETWORK_PATTERNS.some((pattern) => pattern.test(String(url || "")));
 }
 
@@ -150,10 +159,10 @@ async function readRecommendDetailState(client) {
   };
 }
 
-export async function waitForRecommendDetailClosed(client, {
-  timeoutMs = 4000,
-  intervalMs = 250
-} = {}) {
+export async function waitForRecommendDetailClosed(client, {
+  timeoutMs = 4000,
+  intervalMs = 250
+} = {}) {
   const started = Date.now();
   let lastState = null;
   while (Date.now() - started <= timeoutMs) {
@@ -171,12 +180,67 @@ export async function waitForRecommendDetailClosed(client, {
     closed: false,
     elapsed_ms: Date.now() - started,
     state: lastState
-  };
-}
-
-async function findVisibleDetailTarget(client, roots, selectors) {
-  for (const root of roots) {
-    if (!root?.nodeId) continue;
+  };
+}
+
+function compactRect(rect) {
+  if (!rect) return null;
+  return {
+    x: Math.round(Number(rect.x) || 0),
+    y: Math.round(Number(rect.y) || 0),
+    width: Math.round(Number(rect.width) || 0),
+    height: Math.round(Number(rect.height) || 0)
+  };
+}
+
+function compactDetailTarget(target) {
+  if (!target) return null;
+  return {
+    root: target.root || "",
+    root_node_id: target.root_node_id || null,
+    selector: target.selector || "",
+    node_id: target.node_id || null,
+    rect: compactRect(target.rect)
+  };
+}
+
+function compactDetailOpenState(state) {
+  if (!state) {
+    return {
+      open: false,
+      popup: null,
+      resume_iframe: null,
+      iframe_document_node_id: null
+    };
+  }
+  return {
+    open: Boolean(state.popup || state.resumeIframe),
+    popup: compactDetailTarget(state.popup),
+    resume_iframe: compactDetailTarget(state.resumeIframe),
+    iframe_document_node_id: state.iframe?.documentNodeId || null
+  };
+}
+
+async function verifyRecommendDetailStillOpen(client, {
+  settleMs = 350
+} = {}) {
+  const firstState = await readRecommendDetailState(client);
+  if (settleMs > 0) await sleep(settleMs);
+  const secondState = await readRecommendDetailState(client);
+  const first = compactDetailOpenState(firstState);
+  const second = compactDetailOpenState(secondState);
+  const stableOpen = Boolean(first.open && second.open);
+  return {
+    open: Boolean(second.open),
+    stable_open: stableOpen,
+    first,
+    second
+  };
+}
+
+async function findVisibleDetailTarget(client, roots, selectors) {
+  for (const root of roots) {
+    if (!root?.nodeId) continue;
     for (const selector of selectors) {
       const nodeIds = await querySelectorAll(client, root.nodeId, selector);
       for (const nodeId of nodeIds) {
@@ -477,15 +541,35 @@ export async function closeRecommendDetail(client, {
       closed: closedAfterClick.closed,
       elapsed_ms: closedAfterClick.elapsed_ms
     });
-    if (closedAfterClick.closed) {
-      return {
-        closed: true,
-        attempts
-      };
-    }
-
-    await pressEscape(client);
-    attempts.push({ mode: "Escape-fallback" });
+    if (closedAfterClick.closed) {
+      return {
+        closed: true,
+        attempts
+      };
+    }
+
+    const outsideClick = await clickOutsideRecommendDetail(client, closedAfterClick.state || existingState);
+    attempts.push(outsideClick);
+    if (outsideClick.clicked) {
+      const closedAfterOutsideClick = await waitForRecommendDetailClosed(client, {
+        timeoutMs: closeWaitMs,
+        intervalMs: 250
+      });
+      attempts.push({
+        mode: "wait-closed-after-outside-click",
+        closed: closedAfterOutsideClick.closed,
+        elapsed_ms: closedAfterOutsideClick.elapsed_ms
+      });
+      if (closedAfterOutsideClick.closed) {
+        return {
+          closed: true,
+          attempts
+        };
+      }
+    }
+
+    await pressEscape(client);
+    attempts.push({ mode: "Escape-fallback" });
 
     const closedAfterEscape = await waitForRecommendDetailClosed(client, {
       timeoutMs: escapeWaitMs,
@@ -502,13 +586,33 @@ export async function closeRecommendDetail(client, {
         attempts
       };
     }
-  }
-
-  return {
-    closed: false,
-    attempts
-  };
-}
+  }
+
+  const verification = await verifyRecommendDetailStillOpen(client);
+  attempts.push({
+    mode: "final-close-verification",
+    open: verification.open,
+    stable_open: verification.stable_open,
+    popup: verification.second.popup,
+    resume_iframe: verification.second.resume_iframe
+  });
+  if (!verification.open) {
+    return {
+      closed: true,
+      attempts,
+      verification
+    };
+  }
+
+  return {
+    closed: false,
+    reason: verification.stable_open
+      ? "detail_still_visible_after_close_attempts"
+      : "detail_visibility_ambiguous_after_close_attempts",
+    attempts,
+    verification
+  };
+}
 
 async function findVisibleCloseTarget(client, roots, selectors) {
   let fallback = null;
@@ -540,15 +644,107 @@ async function findVisibleCloseTarget(client, roots, selectors) {
   return fallback;
 }
 
-async function pressEscape(client) {
-  await pressKey(client, "Escape", {
-    code: "Escape",
-    windowsVirtualKeyCode: 27,
-    nativeVirtualKeyCode: 27
-  });
-}
-
-export async function extractRecommendDetailCandidate(client, {
+async function pressEscape(client) {
+  await pressKey(client, "Escape", {
+    code: "Escape",
+    windowsVirtualKeyCode: 27,
+    nativeVirtualKeyCode: 27
+  });
+}
+
+function clampPointCoordinate(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+async function getClickViewport(client) {
+  try {
+    const metrics = typeof client?.Page?.getLayoutMetrics === "function"
+      ? await client.Page.getLayoutMetrics()
+      : null;
+    const viewport = metrics?.cssLayoutViewport || metrics?.layoutViewport || metrics?.visualViewport || {};
+    return {
+      width: Number(viewport.clientWidth || viewport.width || 1440),
+      height: Number(viewport.clientHeight || viewport.height || 900)
+    };
+  } catch {
+    return {
+      width: 1440,
+      height: 900
+    };
+  }
+}
+
+function getOutsideClickPoint(rect, viewport) {
+  if (!rect || rect.width <= 2 || rect.height <= 2) return null;
+  const margin = 24;
+  const minX = 8;
+  const minY = 8;
+  const maxX = Math.max(minX, (Number(viewport?.width) || 1440) - 8);
+  const maxY = Math.max(minY, (Number(viewport?.height) || 900) - 8);
+  const midX = rect.x + rect.width / 2;
+  const midY = rect.y + Math.min(Math.max(rect.height * 0.2, 48), Math.max(48, rect.height - 24));
+  const candidates = [
+    { side: "left", x: rect.x - margin, y: midY },
+    { side: "right", x: rect.x + rect.width + margin, y: midY },
+    { side: "above", x: midX, y: rect.y - margin },
+    { side: "below", x: midX, y: rect.y + rect.height + margin },
+    { side: "viewport-corner", x: 16, y: 16 }
+  ];
+
+  for (const candidate of candidates) {
+    const x = clampPointCoordinate(candidate.x, minX, maxX);
+    const y = clampPointCoordinate(candidate.y, minY, maxY);
+    const insideRect = (
+      x >= rect.x
+      && x <= rect.x + rect.width
+      && y >= rect.y
+      && y <= rect.y + rect.height
+    );
+    if (!insideRect) {
+      return {
+        ...candidate,
+        x,
+        y
+      };
+    }
+  }
+  return null;
+}
+
+async function clickOutsideRecommendDetail(client, detailState) {
+  const rootState = detailState?.roots?.length
+    ? detailState
+    : await readRecommendDetailState(client);
+  const boundaryTarget = await findVisibleDetailTarget(
+    client,
+    rootState.roots || [],
+    DETAIL_OUTSIDE_CLOSE_BOUNDARY_SELECTORS
+  );
+  const target = boundaryTarget || rootState.resumeIframe || rootState.popup || null;
+  const viewport = await getClickViewport(client);
+  const point = getOutsideClickPoint(target?.rect, viewport);
+  if (!point) {
+    return {
+      clicked: false,
+      mode: "outside-modal-click",
+      reason: "no_outside_click_point",
+      selector: target?.selector || null,
+      root: target?.root || null
+    };
+  }
+  await clickPoint(client, point.x, point.y);
+  return {
+    clicked: true,
+    mode: "outside-modal-click",
+    selector: target?.selector || null,
+    root: target?.root || null,
+    side: point.side,
+    x: Math.round(point.x),
+    y: Math.round(point.y)
+  };
+}
+
+export async function extractRecommendDetailCandidate(client, {
   cardCandidate,
   cardNodeId,
   detailState,

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

@@ -420,17 +420,31 @@ export function countRecommendResultStatuses(results = [], {
   };
 }
 
-function countPassedResults(results = []) {
-  return countRecommendResultStatuses(results).passed;
-}
-
-function compactError(error, fallbackCode = "RECOMMEND_RUN_ERROR") {
-  if (!error) return null;
-  return {
-    code: error.code || fallbackCode,
-    message: error.message || String(error)
-  };
-}
+function countPassedResults(results = []) {
+  return countRecommendResultStatuses(results).passed;
+}
+
+function compactCloseResult(closeResult) {
+  if (!closeResult) return null;
+  return {
+    closed: Boolean(closeResult.closed),
+    reason: closeResult.reason || null,
+    attempts: closeResult.attempts || [],
+    verification: closeResult.verification || null
+  };
+}
+
+function compactError(error, fallbackCode = "RECOMMEND_RUN_ERROR") {
+  if (!error) return null;
+  const result = {
+    code: error.code || fallbackCode,
+    message: error.message || String(error)
+  };
+  if (error.close_result) {
+    result.close_result = compactCloseResult(error.close_result);
+  }
+  return result;
+}
 
 function createRecommendCloseFailureError(closeResult) {
   const error = new Error(closeResult?.reason || "Recommend detail did not close before recovery");