@reconcrap/boss-recommend-mcp 1.3.38 → 2.0.0

package/src/domains/recommend/constants.js

@@ -0,0 +1,141 @@
+export const RECOMMEND_TARGET_URL = "https://www.zhipin.com/web/chat/recommend";
+
+export const RECOMMEND_PAGE_SCOPE_DEFAULT = "recommend";
+
+export const RECOMMEND_PAGE_SCOPE_STATUS = Object.freeze({
+  recommend: "0",
+  latest: "1",
+  featured: "3"
+});
+
+export const RECOMMEND_PAGE_SCOPE_LABELS = Object.freeze({
+  recommend: "推荐",
+  latest: "最新",
+  featured: "精选"
+});
+
+export const RECOMMEND_IFRAME_SELECTORS = Object.freeze([
+  'iframe[name="recommendFrame"]',
+  'iframe[src*="/web/frame/recommend/"]',
+  "iframe"
+]);
+
+export const RECOMMEND_PAGE_SCOPE_TAB_SELECTOR = [
+  ".tab-list .tab-item[data-status]",
+  ".tab-wrap .tab-item[data-status]",
+  ".tab-item[data-status]",
+  "[data-status]"
+].join(", ");
+
+export const RECOMMEND_FILTER_SELECTORS = Object.freeze({
+  trigger: ".filter-label-wrap",
+  panel: ".filter-panel",
+  groups: Object.freeze({
+    recentNotView: ".filter-panel .check-box.recentNotView",
+    degree: ".filter-panel .check-box.degree",
+    gender: ".filter-panel .check-box.gender",
+    school: ".filter-panel .check-box.school"
+  }),
+  option: ".default.option, .options .option, .option",
+  activeOption: ".default.option.active, .options .option.active, .option.active",
+  confirmButton: ".filter-panel .btn, .filter-panel button",
+  checkBox: ".filter-panel .check-box"
+});
+
+export const RECOMMEND_FILTER_GROUP_ORDER = Object.freeze([
+  "recentNotView",
+  "degree",
+  "gender",
+  "school"
+]);
+
+export const RECOMMEND_RECENT_NOT_VIEW_LABEL = "近14天没有";
+
+export const RECOMMEND_CARD_SELECTOR = [
+  ".candidate-card-wrap .card-inner[data-geek]",
+  ".candidate-card-wrap [data-geek]",
+  "li.geek-info-card a[data-geekid]",
+  "a[data-geekid]"
+].join(", ");
+
+export const RECOMMEND_END_REFRESH_SELECTOR = [
+  ".btn",
+  "button",
+  '[role="button"]',
+  '[class*="refresh"]',
+  '[ka*="refresh"]',
+  "a"
+].join(", ");
+
+export const DETAIL_POPUP_SELECTORS = Object.freeze([
+  ".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"]'
+]);
+
+export const DETAIL_RESUME_IFRAME_SELECTORS = Object.freeze([
+  'iframe[src*="/web/frame/c-resume/"]',
+  'iframe[name*="resume"]'
+]);
+
+export const DETAIL_CLOSE_SELECTORS = Object.freeze([
+  ".boss-popup__close",
+  ".popup-close",
+  ".modal-close",
+  ".dialog-close",
+  ".close-btn",
+  'button[aria-label*="关闭"]',
+  'button[title*="关闭"]',
+  ".icon-close",
+  '[aria-label*="关闭"]',
+  '[title*="关闭"]',
+  '[class*="close"]'
+]);
+
+export const DETAIL_NETWORK_PATTERNS = Object.freeze([
+  /\/wapi\/zpjob\/view\/geek\/info\b/i,
+  /\/wapi\/zpitem\/web\/boss\/[^?#]*\/geek\/info\b/i,
+  /\/boss\/[^?#]*\/geek\/info\b/i,
+  /\/geek\/info\b/i,
+  /\/web\/frame\/c-resume\//i,
+  /resume/i
+]);
+
+export const FAVORITE_BUTTON_SELECTORS = Object.freeze([
+  ".like-icon-and-text",
+  ".resume-footer.item-operate [class*=\"collect\"]",
+  ".resume-footer.item-operate [class*=\"favorite\"]",
+  ".resume-footer.item-operate [class*=\"like\"]",
+  ".resume-footer-wrap [class*=\"collect\"]",
+  ".resume-footer-wrap [class*=\"favorite\"]",
+  ".resume-footer-wrap [class*=\"like\"]",
+  ".resume-footer [class*=\"collect\"]",
+  ".resume-footer [class*=\"favorite\"]",
+  ".resume-footer [class*=\"like\"]",
+  ".resume-footer.item-operate button",
+  ".resume-footer.item-operate .btn",
+  ".resume-footer.item-operate span",
+  ".resume-footer-wrap button",
+  ".resume-footer-wrap .btn",
+  ".resume-footer-wrap span",
+  ".resume-footer button",
+  ".resume-footer .btn",
+  ".resume-footer span"
+]);
+
+export const GREET_BUTTON_RECOMMEND_SELECTORS = Object.freeze([
+  "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",
+  ".resume-footer button",
+  "button[class*=\"greet\"]",
+  "button[class*=\"sure\"]"
+]);

package/src/domains/recommend/detail.js

@@ -0,0 +1,341 @@
+import {
+  clickNodeCenter,
+  clickPoint,
+  getFrameDocumentNodeId,
+  getNodeBox,
+  getOuterHTML,
+  pressKey,
+  querySelectorAll,
+  sleep
+} from "../../core/browser/index.js";
+import {
+  buildScreeningCandidateFromDetail,
+  htmlToText
+} from "../../core/screening/index.js";
+import {
+  DETAIL_CLOSE_SELECTORS,
+  DETAIL_NETWORK_PATTERNS,
+  DETAIL_POPUP_SELECTORS,
+  DETAIL_RESUME_IFRAME_SELECTORS
+} from "./constants.js";
+import {
+  getRecommendRoots,
+  queryFirstAcrossRoots
+} from "./roots.js";
+
+export function matchesRecommendDetailNetwork(url) {
+  return DETAIL_NETWORK_PATTERNS.some((pattern) => pattern.test(String(url || "")));
+}
+
+export function createRecommendDetailNetworkRecorder(client) {
+  const events = [];
+  client.Network.responseReceived((event) => {
+    const url = event?.response?.url || "";
+    if (!matchesRecommendDetailNetwork(url)) return;
+    events.push({
+      requestId: event.requestId,
+      url,
+      status: event.response?.status,
+      mimeType: event.response?.mimeType,
+      type: event.type
+    });
+  });
+  if (typeof client.Network.loadingFinished === "function") {
+    client.Network.loadingFinished((event) => {
+      const found = events.find((item) => item.requestId === event.requestId);
+      if (!found) return;
+      found.loading_finished = true;
+      found.encodedDataLength = event.encodedDataLength;
+    });
+  }
+  if (typeof client.Network.loadingFailed === "function") {
+    client.Network.loadingFailed((event) => {
+      const found = events.find((item) => item.requestId === event.requestId);
+      if (!found) return;
+      found.loading_failed = true;
+      found.loading_error = event.errorText || event.blockedReason || "Network loading failed";
+    });
+  }
+  return {
+    events,
+    clear() {
+      events.length = 0;
+    }
+  };
+}
+
+export async function waitForRecommendDetailNetworkEvents(recorder, {
+  minCount = 1,
+  requireLoaded = true,
+  timeoutMs = 3500,
+  intervalMs = 100
+} = {}) {
+  const started = Date.now();
+  const events = Array.isArray(recorder) ? recorder : recorder?.events || [];
+  let matching = [];
+  while (Date.now() - started <= timeoutMs) {
+    matching = events.filter((event) => (
+      !requireLoaded
+      || event.loading_finished === true
+      || event.loading_failed === true
+    ));
+    if (matching.length >= minCount) {
+      return {
+        ok: true,
+        elapsed_ms: Date.now() - started,
+        count: matching.length,
+        events: matching
+      };
+    }
+    await sleep(intervalMs);
+  }
+  return {
+    ok: false,
+    elapsed_ms: Date.now() - started,
+    count: matching.length,
+    events: matching,
+    total_event_count: events.length
+  };
+}
+
+export async function readRecommendDetailNetworkBodies(client, events = [], {
+  limit = 10
+} = {}) {
+  const bodies = [];
+  for (const event of events.slice(0, limit)) {
+    try {
+      const body = await client.Network.getResponseBody({ requestId: event.requestId });
+      bodies.push({
+        ...event,
+        body,
+        body_length: String(body?.body || "").length
+      });
+    } catch (error) {
+      bodies.push({
+        ...event,
+        body_error: error?.message || String(error)
+      });
+    }
+  }
+  return bodies;
+}
+
+export async function waitForRecommendDetail(client, {
+  timeoutMs = 10000,
+  intervalMs = 250
+} = {}) {
+  const started = Date.now();
+  let lastState = null;
+  while (Date.now() - started <= timeoutMs) {
+    const rootState = await getRecommendRoots(client);
+    const popup = await queryFirstAcrossRoots(client, rootState.roots, DETAIL_POPUP_SELECTORS);
+    const resumeIframe = await queryFirstAcrossRoots(client, rootState.roots, DETAIL_RESUME_IFRAME_SELECTORS);
+    lastState = {
+      iframe: rootState.iframe,
+      roots: rootState.roots,
+      popup,
+      resumeIframe
+    };
+    if (popup || resumeIframe) return lastState;
+    await sleep(intervalMs);
+  }
+  return lastState;
+}
+
+export async function readRecommendDetailHtml(client, detailState) {
+  let popupHTML = "";
+  let resumeHTML = "";
+  let resumeIframeDocumentNodeId = null;
+
+  if (detailState?.popup?.node_id) {
+    popupHTML = await getOuterHTML(client, detailState.popup.node_id);
+  }
+
+  if (detailState?.resumeIframe?.node_id) {
+    resumeIframeDocumentNodeId = await getFrameDocumentNodeId(client, detailState.resumeIframe.node_id);
+    resumeHTML = await getOuterHTML(client, resumeIframeDocumentNodeId);
+  }
+
+  return {
+    popupHTML,
+    resumeHTML,
+    resumeIframeDocumentNodeId,
+    popupText: htmlToText(popupHTML),
+    resumeText: htmlToText(resumeHTML)
+  };
+}
+
+export async function openRecommendCardDetail(client, cardNodeId, {
+  timeoutMs = 12000,
+  scrollIntoView = true
+} = {}) {
+  const cardBox = await clickNodeCenter(client, cardNodeId, { scrollIntoView });
+  const detailState = await waitForRecommendDetail(client, { timeoutMs });
+  if (!detailState?.popup && !detailState?.resumeIframe) {
+    throw new Error("Candidate detail did not open or no known detail selectors mounted");
+  }
+
+  return {
+    card_box: cardBox,
+    detail_state: detailState
+  };
+}
+
+export async function closeRecommendDetail(client, {
+  attemptsLimit = 3
+} = {}) {
+  const attempts = [];
+  for (let index = 0; index < attemptsLimit; index += 1) {
+    const existingState = await waitForRecommendDetail(client, { timeoutMs: 500 });
+    if (!existingState?.popup && !existingState?.resumeIframe) {
+      return {
+        closed: true,
+        attempts
+      };
+    }
+
+    const rootState = await getRecommendRoots(client);
+    const closeTarget = await findVisibleCloseTarget(client, rootState.roots, DETAIL_CLOSE_SELECTORS);
+    if (closeTarget) {
+      try {
+        if (closeTarget.center) {
+          await clickPoint(client, closeTarget.center.x, closeTarget.center.y);
+        } else {
+          await clickNodeCenter(client, closeTarget.node_id);
+        }
+        attempts.push({
+          mode: "close-selector",
+          selector: closeTarget.selector,
+          root: closeTarget.root
+        });
+      } catch (error) {
+        attempts.push({
+          mode: "close-selector-error",
+          selector: closeTarget.selector,
+          root: closeTarget.root,
+          error: error?.message || String(error)
+        });
+        await pressEscape(client);
+        attempts.push({ mode: "Escape-after-close-selector-error" });
+      }
+      await sleep(700);
+    } else {
+      await pressEscape(client);
+      attempts.push({ mode: "Escape" });
+      await sleep(700);
+    }
+
+    let state = await waitForRecommendDetail(client, { timeoutMs: 1000 });
+    if (!state?.popup && !state?.resumeIframe) {
+      return {
+        closed: true,
+        attempts
+      };
+    }
+
+    await pressEscape(client);
+    attempts.push({ mode: "Escape-fallback" });
+    await sleep(700);
+
+    state = await waitForRecommendDetail(client, { timeoutMs: 1000 });
+    if (!state?.popup && !state?.resumeIframe) {
+      return {
+        closed: true,
+        attempts
+      };
+    }
+  }
+
+  return {
+    closed: false,
+    attempts
+  };
+}
+
+async function findVisibleCloseTarget(client, roots, selectors) {
+  let fallback = null;
+  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) {
+        const target = {
+          root: root.name,
+          root_node_id: root.nodeId,
+          selector,
+          node_id: nodeId
+        };
+        if (!fallback) fallback = target;
+        try {
+          const box = await getNodeBox(client, nodeId);
+          if (box.rect.width > 2 && box.rect.height > 2) {
+            return {
+              ...target,
+              center: box.center,
+              rect: box.rect
+            };
+          }
+        } catch {}
+      }
+    }
+  }
+  return fallback;
+}
+
+async function pressEscape(client) {
+  await pressKey(client, "Escape", {
+    code: "Escape",
+    windowsVirtualKeyCode: 27,
+    nativeVirtualKeyCode: 27
+  });
+}
+
+export async function extractRecommendDetailCandidate(client, {
+  cardCandidate,
+  cardNodeId,
+  detailState,
+  networkEvents = [],
+  targetUrl = "",
+  closeDetail = true
+} = {}) {
+  await sleep(1000);
+  const networkBodies = await readRecommendDetailNetworkBodies(client, networkEvents);
+  const detailHtml = await readRecommendDetailHtml(client, detailState);
+  const detailText = [
+    detailHtml.popupText,
+    detailHtml.resumeText
+  ].filter(Boolean).join("\n\n");
+
+  const detailCandidateResult = buildScreeningCandidateFromDetail({
+    cardCandidate,
+    detailText,
+    networkBodies,
+    metadata: {
+      target_url: targetUrl,
+      card_node_id: cardNodeId,
+      detail_popup_selector: detailState?.popup?.selector || null,
+      detail_popup_root: detailState?.popup?.root || null,
+      resume_iframe_selector: detailState?.resumeIframe?.selector || null,
+      resume_iframe_root: detailState?.resumeIframe?.root || null,
+      resume_iframe_document_node_id: detailHtml.resumeIframeDocumentNodeId
+    }
+  });
+
+  let closeResult = null;
+  if (closeDetail) {
+    closeResult = await closeRecommendDetail(client);
+  }
+
+  return {
+    candidate: detailCandidateResult.candidate,
+    parsed_network_profiles: detailCandidateResult.parsed_network_profiles,
+    network_bodies: networkBodies,
+    detail: {
+      popup_text: detailHtml.popupText,
+      resume_text: detailHtml.resumeText,
+      popup_html_length: detailHtml.popupHTML.length,
+      resume_html_length: detailHtml.resumeHTML.length
+    },
+    close_result: closeResult
+  };
+}