@reconcrap/boss-recommend-mcp 1.3.38 → 2.0.0

package/src/domains/recommend/jobs.js

@@ -0,0 +1,232 @@
+import {
+  clickNodeCenter,
+  getAttributesMap,
+  getNodeBox,
+  getOuterHTML,
+  pressKey,
+  querySelectorAll,
+  sleep,
+  waitForSelector
+} from "../../core/browser/index.js";
+import {
+  htmlToText,
+  normalizeText
+} from "../../core/screening/index.js";
+
+export const RECOMMEND_JOB_SELECTORS = Object.freeze({
+  trigger: ".job-selecter-wrap, [class*=\"job-selecter-wrap\"], .ui-dropmenu",
+  option: ".job-selecter-options .job-item, .job-list .job-item, .job-item",
+  current: ".job-selecter-options .job-item.curr, .job-list .job-item.curr, .job-item.curr"
+});
+
+function normalizeJobText(value) {
+  return normalizeText(value).replace(/\s+/g, "");
+}
+
+function trimSalarySuffix(label) {
+  return normalizeText(label)
+    .replace(/\s+(?:\d+(?:-\d+)?K|面议|\d+-\d+元\/天).*$/i, "")
+    .trim();
+}
+
+export function jobLabelMatches(optionLabel, targetLabel) {
+  const option = normalizeJobText(optionLabel);
+  const target = normalizeJobText(targetLabel);
+  if (!option || !target) return false;
+  return option === target
+    || option.startsWith(target)
+    || normalizeJobText(trimSalarySuffix(optionLabel)) === target;
+}
+
+function isVisibleBox(box) {
+  return Boolean(box && box.rect.width > 4 && box.rect.height > 4);
+}
+
+async function readJobOption(client, nodeId, index) {
+  const [attributes, outerHTML] = await Promise.all([
+    getAttributesMap(client, nodeId),
+    getOuterHTML(client, nodeId)
+  ]);
+  const label = normalizeText(htmlToText(outerHTML));
+  let box = null;
+  try {
+    box = await getNodeBox(client, nodeId);
+  } catch {}
+  const className = attributes.class || "";
+  return {
+    node_id: nodeId,
+    index,
+    label,
+    label_without_salary: trimSalarySuffix(label),
+    class_name: className,
+    current: /\bcurr\b|\bactive\b|\bselected\b/.test(className),
+    visible: isVisibleBox(box),
+    center: box?.center || null,
+    rect: box?.rect || null
+  };
+}
+
+export async function findRecommendJobTrigger(client, frameNodeId) {
+  const nodeIds = await querySelectorAll(client, frameNodeId, RECOMMEND_JOB_SELECTORS.trigger);
+  for (const nodeId of nodeIds) {
+    try {
+      const box = await getNodeBox(client, nodeId);
+      if (isVisibleBox(box)) {
+        return {
+          node_id: nodeId,
+          center: box.center,
+          rect: box.rect
+        };
+      }
+    } catch {}
+  }
+  return null;
+}
+
+export async function openRecommendJobDropdown(client, frameNodeId, {
+  timeoutMs = 4000
+} = {}) {
+  const trigger = await findRecommendJobTrigger(client, frameNodeId);
+  if (!trigger) {
+    throw new Error("Recommend job trigger was not found");
+  }
+
+  let optionNodeId = await waitForSelector(client, frameNodeId, RECOMMEND_JOB_SELECTORS.option, {
+    timeoutMs: 300,
+    intervalMs: 100
+  });
+  if (optionNodeId) {
+    const options = await listRecommendJobOptions(client, frameNodeId, { openDropdown: false });
+    if (options.some((option) => option.visible)) {
+      return {
+        opened: true,
+        already_open: true,
+        trigger,
+        options
+      };
+    }
+  }
+
+  await clickNodeCenter(client, trigger.node_id);
+  optionNodeId = await waitForSelector(client, frameNodeId, RECOMMEND_JOB_SELECTORS.option, {
+    timeoutMs,
+    intervalMs: 200
+  });
+  if (!optionNodeId) {
+    throw new Error("Recommend job dropdown did not mount options after trigger click");
+  }
+  const options = await listRecommendJobOptions(client, frameNodeId, { openDropdown: false });
+  return {
+    opened: true,
+    already_open: false,
+    trigger,
+    options
+  };
+}
+
+export async function listRecommendJobOptions(client, frameNodeId, {
+  openDropdown = true
+} = {}) {
+  if (openDropdown) {
+    await openRecommendJobDropdown(client, frameNodeId);
+  }
+
+  const nodeIds = await querySelectorAll(client, frameNodeId, RECOMMEND_JOB_SELECTORS.option);
+  const options = [];
+  const seen = new Set();
+  for (let index = 0; index < nodeIds.length; index += 1) {
+    const nodeId = nodeIds[index];
+    if (seen.has(nodeId)) continue;
+    seen.add(nodeId);
+    const option = await readJobOption(client, nodeId, index);
+    if (!option.label) continue;
+    if (option.label.length > 120) continue;
+    options.push(option);
+  }
+  return options;
+}
+
+export async function closeRecommendJobDropdown(client) {
+  await pressKey(client, "Escape", {
+    code: "Escape",
+    windowsVirtualKeyCode: 27,
+    nativeVirtualKeyCode: 27
+  });
+  await sleep(300);
+}
+
+export async function selectRecommendJob(client, frameNodeId, {
+  jobLabel = "",
+  settleMs = 6000
+} = {}) {
+  const target = normalizeText(jobLabel);
+  if (!target) {
+    return {
+      requested: "",
+      selected: false,
+      reason: "no_job_requested",
+      options: []
+    };
+  }
+
+  const opened = await openRecommendJobDropdown(client, frameNodeId);
+  const options = opened.options.length
+    ? opened.options
+    : await listRecommendJobOptions(client, frameNodeId, { openDropdown: false });
+  const visibleOptions = options.filter((option) => option.visible);
+  const match = visibleOptions.find((option) => jobLabelMatches(option.label, target))
+    || options.find((option) => jobLabelMatches(option.label, target));
+
+  if (!match) {
+    await closeRecommendJobDropdown(client);
+    return {
+      requested: target,
+      selected: false,
+      reason: "job_not_found",
+      options: options.map(compactJobOption)
+    };
+  }
+
+  if (match.current) {
+    await closeRecommendJobDropdown(client);
+    return {
+      requested: target,
+      selected: true,
+      already_current: true,
+      selected_option: compactJobOption(match),
+      options: options.map(compactJobOption)
+    };
+  }
+
+  if (!match.center) {
+    await closeRecommendJobDropdown(client);
+    throw new Error(`Matched recommend job has no clickable center: ${match.label}`);
+  }
+
+  const clickedBox = await clickNodeCenter(client, match.node_id);
+  if (settleMs > 0) await sleep(settleMs);
+  return {
+    requested: target,
+    selected: true,
+    already_current: false,
+    selected_option: compactJobOption(match),
+    click_box: {
+      center: clickedBox.center,
+      rect: clickedBox.rect
+    },
+    options: options.map(compactJobOption)
+  };
+}
+
+function compactJobOption(option) {
+  return {
+    label: option.label,
+    label_without_salary: option.label_without_salary,
+    current: Boolean(option.current),
+    visible: Boolean(option.visible),
+    class_name: option.class_name,
+    node_id: option.node_id,
+    center: option.center,
+    rect: option.rect
+  };
+}

package/src/domains/recommend/refresh.js

@@ -0,0 +1,204 @@
+import { sleep } from "../../core/browser/index.js";
+import {
+  clickRecommendEndRefreshButton,
+  waitForRecommendCardNodeIds
+} from "./cards.js";
+import {
+  RECOMMEND_RECENT_NOT_VIEW_LABEL
+} from "./constants.js";
+import { selectAndConfirmFirstSafeFilter } from "./filters.js";
+import { selectRecommendJob } from "./jobs.js";
+import { selectRecommendPageScope } from "./scopes.js";
+import {
+  getRecommendRoots,
+  waitForRecommendRoots
+} from "./roots.js";
+
+function normalizeLabels(labels = []) {
+  return labels.map((label) => String(label || "").trim()).filter(Boolean);
+}
+
+function normalizeFilterGroup(spec = {}) {
+  return {
+    group: String(spec.group || "").trim(),
+    labels: normalizeLabels(spec.labels || spec.filterLabels || []),
+    selectAllLabels: spec.selectAllLabels !== false
+  };
+}
+
+export function buildRecommendFilterGroups(filter = {}, {
+  forceRecentNotView = false
+} = {}) {
+  const groups = [];
+  const sourceGroups = Array.isArray(filter.filterGroups)
+    ? filter.filterGroups
+    : Array.isArray(filter.groups)
+      ? filter.groups
+      : [];
+
+  for (const spec of sourceGroups) {
+    const group = normalizeFilterGroup(spec);
+    if (group.group || group.labels.length) groups.push(group);
+  }
+
+  const rootGroup = normalizeFilterGroup(filter);
+  if ((rootGroup.group || rootGroup.labels.length) && !groups.length) {
+    groups.push(rootGroup);
+  }
+
+  if (forceRecentNotView) {
+    const recentGroup = groups.find((item) => item.group === "recentNotView");
+    if (recentGroup) {
+      if (!recentGroup.labels.some((label) => label.replace(/\s+/g, "") === RECOMMEND_RECENT_NOT_VIEW_LABEL)) {
+        recentGroup.labels.push(RECOMMEND_RECENT_NOT_VIEW_LABEL);
+      }
+      recentGroup.selectAllLabels = true;
+    } else {
+      groups.unshift({
+        group: "recentNotView",
+        labels: [RECOMMEND_RECENT_NOT_VIEW_LABEL],
+        selectAllLabels: true
+      });
+    }
+  }
+
+  return groups;
+}
+
+export function buildRecommendFilterSelectionOptions(filter = {}, {
+  forceRecentNotView = false
+} = {}) {
+  const filterGroups = buildRecommendFilterGroups(filter, { forceRecentNotView });
+  if (filterGroups.length > 1 || forceRecentNotView || Array.isArray(filter.filterGroups) || Array.isArray(filter.groups)) {
+    return { filterGroups };
+  }
+  const [singleGroup] = filterGroups;
+  if (singleGroup) {
+    return {
+      group: singleGroup.group,
+      labels: singleGroup.labels,
+      selectAllLabels: singleGroup.selectAllLabels
+    };
+  }
+  return {
+    group: filter.group || "",
+    labels: normalizeLabels(filter.labels || filter.filterLabels || []),
+    selectAllLabels: filter.selectAllLabels !== false
+  };
+}
+
+export async function refreshRecommendListAtEnd(client, {
+  rootState = null,
+  jobLabel = "",
+  pageScope = "recommend",
+  fallbackPageScope = "recommend",
+  filter = {},
+  preferEndRefreshButton = true,
+  forceRecentNotView = true,
+  cardTimeoutMs = 30000,
+  buttonSettleMs = 8000,
+  reloadSettleMs = 8000
+} = {}) {
+  const attempts = [];
+  let currentRootState = rootState || await getRecommendRoots(client);
+
+  if (preferEndRefreshButton) {
+    const buttonResult = await clickRecommendEndRefreshButton(
+      client,
+      currentRootState.iframe.documentNodeId,
+      { settleMs: buttonSettleMs }
+    );
+    attempts.push(buttonResult);
+    if (buttonResult.ok) {
+      currentRootState = await getRecommendRoots(client);
+      const pageScopeResult = await selectRecommendPageScope(
+        client,
+        currentRootState.iframe.documentNodeId,
+        {
+          pageScope,
+          fallbackScope: fallbackPageScope,
+          settleMs: buttonSettleMs > 10000 ? 3000 : 1200,
+          timeoutMs: Math.max(10000, Math.min(cardTimeoutMs, 60000))
+        }
+      );
+      if (!pageScopeResult.selected) {
+        throw new Error(`Recommend page scope was not selected after end refresh: ${pageScopeResult.reason || pageScope}`);
+      }
+      currentRootState = await getRecommendRoots(client);
+      const filterResult = await selectAndConfirmFirstSafeFilter(
+        client,
+        currentRootState.iframe.documentNodeId,
+        buildRecommendFilterSelectionOptions(filter, { forceRecentNotView })
+      );
+      const cardNodeIds = await waitForRecommendCardNodeIds(client, currentRootState.iframe.documentNodeId, {
+        timeoutMs: cardTimeoutMs,
+        intervalMs: 500
+      });
+      return {
+        ok: cardNodeIds.length > 0,
+        method: "end_refresh_button",
+        attempts,
+        page_scope: pageScopeResult,
+        filter: filterResult,
+        card_count: cardNodeIds.length,
+        root_state: currentRootState,
+        forced_recent_not_view: forceRecentNotView
+      };
+    }
+  }
+
+  await client.Page.reload({ ignoreCache: true });
+  if (reloadSettleMs > 0) await sleep(reloadSettleMs);
+  currentRootState = await waitForRecommendRoots(client, {
+    timeoutMs: Math.max(30000, reloadSettleMs * 4),
+    intervalMs: 500
+  });
+  if (!currentRootState?.iframe?.documentNodeId) {
+    throw new Error("Recommend iframe was not ready after refresh reload");
+  }
+  let jobSelection = null;
+  if (jobLabel) {
+    jobSelection = await selectRecommendJob(client, currentRootState.iframe.documentNodeId, {
+      jobLabel,
+      settleMs: reloadSettleMs > 10000 ? 12000 : 6000
+    });
+    if (!jobSelection.selected) {
+      throw new Error(`Requested recommend job was not selected after refresh reload: ${jobSelection.reason}`);
+    }
+    currentRootState = await getRecommendRoots(client);
+  }
+  const pageScopeResult = await selectRecommendPageScope(
+    client,
+    currentRootState.iframe.documentNodeId,
+    {
+      pageScope,
+      fallbackScope: fallbackPageScope,
+      settleMs: reloadSettleMs > 10000 ? 3000 : 1200,
+      timeoutMs: Math.max(10000, Math.min(cardTimeoutMs, 60000))
+    }
+  );
+  if (!pageScopeResult.selected) {
+    throw new Error(`Recommend page scope was not selected after refresh reload: ${pageScopeResult.reason || pageScope}`);
+  }
+  currentRootState = await getRecommendRoots(client);
+  const filterResult = await selectAndConfirmFirstSafeFilter(
+    client,
+    currentRootState.iframe.documentNodeId,
+    buildRecommendFilterSelectionOptions(filter, { forceRecentNotView })
+  );
+  const cardNodeIds = await waitForRecommendCardNodeIds(client, currentRootState.iframe.documentNodeId, {
+    timeoutMs: cardTimeoutMs,
+    intervalMs: 500
+  });
+  return {
+    ok: cardNodeIds.length > 0,
+    method: "page_reload",
+    attempts,
+    job_selection: jobSelection,
+    page_scope: pageScopeResult,
+    filter: filterResult,
+    card_count: cardNodeIds.length,
+    root_state: currentRootState,
+    forced_recent_not_view: forceRecentNotView
+  };
+}

package/src/domains/recommend/roots.js

@@ -0,0 +1,78 @@
+import {
+  findIframeDocument,
+  getDocumentRoot,
+  querySelector,
+  sleep
+} from "../../core/browser/index.js";
+import { RECOMMEND_IFRAME_SELECTORS } from "./constants.js";
+
+export async function getRecommendRoots(client, {
+  iframeSelectors = RECOMMEND_IFRAME_SELECTORS,
+  requireFrame = true
+} = {}) {
+  const topRoot = await getDocumentRoot(client);
+  const iframe = await findIframeDocument(client, topRoot.nodeId, iframeSelectors);
+  if (!iframe && requireFrame) {
+    throw new Error("recommendFrame iframe was not found");
+  }
+
+  return {
+    topRoot,
+    iframe,
+    roots: [
+      { name: "top", nodeId: topRoot.nodeId },
+      iframe ? { name: "recommend-frame", nodeId: iframe.documentNodeId } : null
+    ].filter(Boolean),
+    rootNodes: {
+      top: topRoot.nodeId,
+      frame: iframe?.documentNodeId || 0
+    }
+  };
+}
+
+export async function waitForRecommendRoots(client, {
+  timeoutMs = 10000,
+  intervalMs = 250,
+  iframeSelectors = RECOMMEND_IFRAME_SELECTORS
+} = {}) {
+  const started = Date.now();
+  let lastState = null;
+  while (Date.now() - started <= timeoutMs) {
+    try {
+      lastState = await getRecommendRoots(client, {
+        iframeSelectors,
+        requireFrame: false
+      });
+    } catch (error) {
+      lastState = {
+        error: error?.message || String(error),
+        roots: [],
+        rootNodes: {
+          top: 0,
+          frame: 0
+        }
+      };
+    }
+    if (lastState.iframe?.documentNodeId) return lastState;
+    await sleep(intervalMs);
+  }
+  return lastState;
+}
+
+export async function queryFirstAcrossRoots(client, roots, selectors) {
+  for (const root of roots) {
+    if (!root?.nodeId) continue;
+    for (const selector of selectors) {
+      const nodeId = await querySelector(client, root.nodeId, selector);
+      if (nodeId) {
+        return {
+          root: root.name,
+          root_node_id: root.nodeId,
+          selector,
+          node_id: nodeId
+        };
+      }
+    }
+  }
+  return null;
+}