@reconcrap/boss-recommend-mcp 1.3.38 → 2.0.0

package/src/domains/recommend/scopes.js

@@ -0,0 +1,245 @@
+import {
+  clickNodeCenter,
+  getAttributesMap,
+  getNodeBox,
+  getOuterHTML,
+  querySelectorAll,
+  sleep
+} from "../../core/browser/index.js";
+import {
+  htmlToText,
+  normalizeText
+} from "../../core/screening/index.js";
+import {
+  RECOMMEND_CARD_SELECTOR,
+  RECOMMEND_PAGE_SCOPE_DEFAULT,
+  RECOMMEND_PAGE_SCOPE_LABELS,
+  RECOMMEND_PAGE_SCOPE_STATUS,
+  RECOMMEND_PAGE_SCOPE_TAB_SELECTOR
+} from "./constants.js";
+
+const SCOPE_ALIASES = Object.freeze({
+  recommend: "recommend",
+  "推荐": "recommend",
+  "推荐页": "recommend",
+  "推荐页面": "recommend",
+  latest: "latest",
+  "最新": "latest",
+  "最新页": "latest",
+  "最新页面": "latest",
+  featured: "featured",
+  "精选": "featured",
+  "精选页": "featured",
+  "精选页面": "featured",
+  "精选牛人": "featured"
+});
+
+const STATUS_TO_SCOPE = Object.freeze(
+  Object.fromEntries(
+    Object.entries(RECOMMEND_PAGE_SCOPE_STATUS).map(([scope, status]) => [status, scope])
+  )
+);
+
+function compactTab(tab) {
+  return {
+    scope: tab.scope,
+    label: tab.label,
+    title: tab.title,
+    status: tab.status,
+    current: Boolean(tab.current),
+    visible: Boolean(tab.visible),
+    class_name: tab.class_name,
+    node_id: tab.node_id,
+    center: tab.center,
+    rect: tab.rect
+  };
+}
+
+function inferScopeFromText(text = "") {
+  const normalized = normalizeText(text).replace(/\s+/g, "");
+  if (!normalized) return null;
+  if (/^推荐/.test(normalized)) return "recommend";
+  if (/^精选/.test(normalized)) return "featured";
+  if (/^最新/.test(normalized)) return "latest";
+  return null;
+}
+
+function isVisibleBox(box) {
+  return Boolean(box && box.rect.width > 4 && box.rect.height > 4);
+}
+
+export function normalizeRecommendPageScope(value) {
+  const raw = normalizeText(value);
+  if (!raw) return null;
+  const lower = raw.toLowerCase();
+  return SCOPE_ALIASES[lower] || SCOPE_ALIASES[raw] || null;
+}
+
+export function getRecommendPageScopeStatus(scope) {
+  const normalized = normalizeRecommendPageScope(scope) || RECOMMEND_PAGE_SCOPE_DEFAULT;
+  return RECOMMEND_PAGE_SCOPE_STATUS[normalized] || RECOMMEND_PAGE_SCOPE_STATUS.recommend;
+}
+
+export function getRecommendPageScopeLabel(scope) {
+  const normalized = normalizeRecommendPageScope(scope) || RECOMMEND_PAGE_SCOPE_DEFAULT;
+  return RECOMMEND_PAGE_SCOPE_LABELS[normalized] || RECOMMEND_PAGE_SCOPE_LABELS.recommend;
+}
+
+async function readPageScopeTab(client, nodeId, index) {
+  const [attributes, outerHTML] = await Promise.all([
+    getAttributesMap(client, nodeId),
+    getOuterHTML(client, nodeId)
+  ]);
+  const label = normalizeText(htmlToText(outerHTML));
+  const status = attributes["data-status"] || "";
+  const title = attributes.title || "";
+  const scope = STATUS_TO_SCOPE[status] || inferScopeFromText(`${title} ${label}`);
+  let box = null;
+  try {
+    box = await getNodeBox(client, nodeId);
+  } catch {}
+  const className = attributes.class || "";
+  return {
+    node_id: nodeId,
+    index,
+    scope,
+    status,
+    label,
+    title,
+    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 listRecommendPageScopeTabs(client, frameNodeId, {
+  selector = RECOMMEND_PAGE_SCOPE_TAB_SELECTOR
+} = {}) {
+  const nodeIds = await querySelectorAll(client, frameNodeId, selector);
+  const tabs = [];
+  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 tab = await readPageScopeTab(client, nodeId, index);
+    if (!tab.scope) continue;
+    tabs.push(tab);
+  }
+  return tabs;
+}
+
+export async function getActiveRecommendPageScope(client, frameNodeId) {
+  const tabs = await listRecommendPageScopeTabs(client, frameNodeId);
+  const current = tabs.find((tab) => tab.current);
+  return {
+    scope: current?.scope || null,
+    tab: current ? compactTab(current) : null,
+    tabs: tabs.map(compactTab)
+  };
+}
+
+async function waitForRecommendPageScope(client, frameNodeId, scope, {
+  timeoutMs = 10000,
+  intervalMs = 300
+} = {}) {
+  const started = Date.now();
+  let lastState = null;
+  while (Date.now() - started <= timeoutMs) {
+    const active = await getActiveRecommendPageScope(client, frameNodeId);
+    const cardCount = (await querySelectorAll(client, frameNodeId, RECOMMEND_CARD_SELECTOR)).length;
+    lastState = {
+      ...active,
+      card_count: cardCount
+    };
+    if (active.scope === scope && cardCount > 0) {
+      return {
+        ok: true,
+        elapsed_ms: Date.now() - started,
+        ...lastState
+      };
+    }
+    await sleep(intervalMs);
+  }
+  return {
+    ok: false,
+    elapsed_ms: Date.now() - started,
+    ...lastState
+  };
+}
+
+export async function selectRecommendPageScope(client, frameNodeId, {
+  pageScope = RECOMMEND_PAGE_SCOPE_DEFAULT,
+  fallbackScope = RECOMMEND_PAGE_SCOPE_DEFAULT,
+  settleMs = 1200,
+  timeoutMs = 15000
+} = {}) {
+  const requested = normalizeRecommendPageScope(pageScope) || RECOMMEND_PAGE_SCOPE_DEFAULT;
+  const fallback = normalizeRecommendPageScope(fallbackScope) || RECOMMEND_PAGE_SCOPE_DEFAULT;
+  const tabs = await listRecommendPageScopeTabs(client, frameNodeId);
+  const availableScopes = Array.from(new Set(tabs.map((tab) => tab.scope)));
+  const requestedTab = tabs.find((tab) => tab.scope === requested && tab.visible)
+    || tabs.find((tab) => tab.scope === requested);
+  const fallbackTab = tabs.find((tab) => tab.scope === fallback && tab.visible)
+    || tabs.find((tab) => tab.scope === fallback);
+  const targetTab = requestedTab || fallbackTab;
+  const effectiveScope = requestedTab ? requested : fallback;
+
+  if (!targetTab) {
+    return {
+      requested_scope: requested,
+      effective_scope: null,
+      fallback_scope: fallback,
+      fallback_applied: !requestedTab,
+      selected: false,
+      reason: "scope_tab_not_found",
+      available_scopes: availableScopes,
+      tabs: tabs.map(compactTab)
+    };
+  }
+
+  if (targetTab.current) {
+    const active = await getActiveRecommendPageScope(client, frameNodeId);
+    const cardCount = (await querySelectorAll(client, frameNodeId, RECOMMEND_CARD_SELECTOR)).length;
+    return {
+      requested_scope: requested,
+      effective_scope: effectiveScope,
+      fallback_scope: fallback,
+      fallback_applied: requested !== effectiveScope,
+      selected: true,
+      already_current: true,
+      selected_tab: compactTab(targetTab),
+      available_scopes: availableScopes,
+      tabs: tabs.map(compactTab),
+      after: {
+        ...active,
+        card_count: cardCount
+      }
+    };
+  }
+
+  const clickBox = await clickNodeCenter(client, targetTab.node_id);
+  if (settleMs > 0) await sleep(settleMs);
+  const after = await waitForRecommendPageScope(client, frameNodeId, effectiveScope, {
+    timeoutMs,
+    intervalMs: Math.max(250, Math.min(500, Math.floor(timeoutMs / 30)))
+  });
+  return {
+    requested_scope: requested,
+    effective_scope: effectiveScope,
+    fallback_scope: fallback,
+    fallback_applied: requested !== effectiveScope,
+    selected: after.ok,
+    already_current: false,
+    selected_tab: compactTab(targetTab),
+    available_scopes: availableScopes,
+    tabs: tabs.map(compactTab),
+    click_box: {
+      center: clickBox.center,
+      rect: clickBox.rect
+    },
+    after
+  };
+}

package/src/domains/recruit/actions.js

@@ -0,0 +1,277 @@
+import {
+  clickNodeCenter,
+  getAttributesMap,
+  getNodeBox,
+  getOuterHTML,
+  querySelectorAll,
+  sleep
+} from "../../core/browser/index.js";
+import {
+  htmlToText,
+  normalizeText
+} from "../../core/screening/index.js";
+import {
+  assertGreetQuotaAvailable,
+  parseGreetQuota
+} from "../../core/greet-quota/index.js";
+
+const ACTION_SELECTOR = [
+  "button",
+  '[role="button"]',
+  ".btn",
+  '[class*="btn"]',
+  '[class*="chat"]',
+  '[class*="greet"]',
+  '[ka*="chat"]',
+  '[ka*="greet"]',
+  '[ka*="contact"]'
+].join(", ");
+
+const DISABLED_PATTERN = /\b(disabled|disable|ui-disabled|is-disabled)\b/i;
+const CONTINUE_CHAT_PATTERN = /继续沟通|继续聊天|查看沟通|已沟通/i;
+const GREET_PATTERN = /打招呼|立即沟通|立即聊天|聊一聊|开聊|沟通/i;
+const GREET_LABEL_PATTERN = /^(打招呼|立即沟通|立即聊天|聊一聊|开聊|沟通)(?:[\(（]\d+\s*[/／]\s*\d+[\)）])?$/i;
+const FAVORITE_PATTERN = /收藏|感兴趣/i;
+const FAVORITE_LABEL_PATTERN = /^(收藏|感兴趣)$/i;
+const OPEN_RESUME_KA_PATTERN = /search_click_open_resume|open_resume|resume/i;
+const EXTERNAL_URL_PATTERN = /(?:https?:)?\/\/|github\.com|gitlab\.com|gitee\.com/i;
+const MAX_ACTION_LABEL_LENGTH = 80;
+
+function openingTagName(outerHTML = "") {
+  const match = String(outerHTML || "").match(/^<\s*([a-z0-9-]+)/i);
+  return match ? match[1].toLowerCase() : "";
+}
+
+function isButtonLike(attributes = {}, outerHTML = "") {
+  const tagName = openingTagName(outerHTML);
+  const className = normalizeText(attributes.class);
+  const role = normalizeText(attributes.role).toLowerCase();
+  const ka = normalizeText(attributes.ka || attributes["data-ka"]);
+  return tagName === "button"
+    || role === "button"
+    || /\bbtn\b|button|chat|greet/i.test(className)
+    || /greet|chat|contact/i.test(ka);
+}
+
+function isUnsafeLinkOrCard(attributes = {}, outerHTML = "") {
+  const tagName = openingTagName(outerHTML);
+  const href = normalizeText(attributes.href);
+  const ka = normalizeText(attributes.ka || attributes["data-ka"]);
+  const className = normalizeText(attributes.class);
+  const joined = [href, ka, className, String(outerHTML || "").slice(0, 500)].join(" ");
+  if (OPEN_RESUME_KA_PATTERN.test(ka)) return true;
+  if (tagName === "a" && href && !/^#|^javascript:/i.test(href)) return true;
+  if (EXTERNAL_URL_PATTERN.test(joined) && tagName === "a") return true;
+  return false;
+}
+
+function nodeIsDisabled(attributes = {}, outerHTML = "") {
+  const joined = [
+    attributes.class,
+    attributes.disabled,
+    attributes["aria-disabled"],
+    attributes["data-disabled"],
+    String(outerHTML || "").slice(0, 500)
+  ].map(normalizeText).join(" ");
+  return DISABLED_PATTERN.test(joined)
+    || attributes.disabled !== undefined
+    || normalizeText(attributes["aria-disabled"]).toLowerCase() === "true";
+}
+
+function classifyRecruitAction({ text = "", attributes = {}, outerHTML = "" } = {}) {
+  if (isUnsafeLinkOrCard(attributes, outerHTML)) return null;
+  const joined = [
+    text,
+    attributes.class,
+    attributes.ka,
+    attributes["data-ka"],
+    attributes.title,
+    attributes["aria-label"]
+  ].map(normalizeText).join(" ");
+  const label = normalizeText(text);
+  const buttonLike = isButtonLike(attributes, outerHTML);
+  const continueChat = CONTINUE_CHAT_PATTERN.test(joined);
+  const greetQuota = parseGreetQuota(label);
+  if (continueChat) {
+    return {
+      kind: "greet",
+      continue_chat: true,
+      available: false,
+      greet_quota: null
+    };
+  }
+  if (GREET_PATTERN.test(joined) && buttonLike && (label.length <= MAX_ACTION_LABEL_LENGTH || GREET_LABEL_PATTERN.test(label))) {
+    return {
+      kind: "greet",
+      continue_chat: false,
+      available: !nodeIsDisabled(attributes, outerHTML),
+      greet_quota: greetQuota.found ? greetQuota : null
+    };
+  }
+  if (FAVORITE_PATTERN.test(joined) && buttonLike && (label.length <= MAX_ACTION_LABEL_LENGTH || FAVORITE_LABEL_PATTERN.test(label))) {
+    return {
+      kind: "favorite",
+      continue_chat: false,
+      available: !nodeIsDisabled(attributes, outerHTML)
+    };
+  }
+  return null;
+}
+
+function scoreRecruitAction(control) {
+  let score = 0;
+  if (control.kind === "greet") score += 100;
+  if (control.available) score += 20;
+  if (!control.continue_chat) score += 10;
+  if (/打招呼/.test(control.label)) score += 10;
+  if (/立即沟通|聊一聊|开聊/.test(control.label)) score += 6;
+  if (/btn|button/i.test(control.class_name)) score += 3;
+  return score;
+}
+
+async function readRecruitActionControl(client, nodeId, {
+  selector = "",
+  index = 0
+} = {}) {
+  let attributes;
+  let outerHTML;
+  try {
+    [attributes, outerHTML] = await Promise.all([
+      getAttributesMap(client, nodeId),
+      getOuterHTML(client, nodeId)
+    ]);
+  } catch {
+    return null;
+  }
+  const text = normalizeText(htmlToText(outerHTML));
+  const classified = classifyRecruitAction({ text, attributes, outerHTML });
+  if (!classified) return null;
+  let box = null;
+  try {
+    box = await getNodeBox(client, nodeId);
+  } catch {
+    return null;
+  }
+  if (!box?.rect || box.rect.width < 4 || box.rect.height < 4) return null;
+  const control = {
+    node_id: nodeId,
+    selector,
+    index,
+    kind: classified.kind,
+    label: text,
+    class_name: attributes.class || "",
+    attributes: {
+      ka: attributes.ka || attributes["data-ka"] || "",
+      href: attributes.href || "",
+      role: attributes.role || "",
+      title: attributes.title || "",
+      aria_label: attributes["aria-label"] || ""
+    },
+    tag_name: openingTagName(outerHTML),
+    disabled: nodeIsDisabled(attributes, outerHTML),
+    available: Boolean(classified.available),
+    continue_chat: Boolean(classified.continue_chat),
+    greet_quota: classified.greet_quota || null,
+    center: box.center,
+    rect: box.rect
+  };
+  control.score = scoreRecruitAction(control);
+  return control;
+}
+
+export async function discoverRecruitDetailActionControls(client, rootNodeIds = []) {
+  const controls = [];
+  const seen = new Set();
+  for (const rootNodeId of rootNodeIds.filter(Boolean)) {
+    let nodeIds = [];
+    try {
+      nodeIds = await querySelectorAll(client, rootNodeId, ACTION_SELECTOR);
+    } catch {
+      continue;
+    }
+    for (let index = 0; index < nodeIds.length; index += 1) {
+      const nodeId = nodeIds[index];
+      if (!nodeId || seen.has(nodeId)) continue;
+      seen.add(nodeId);
+      const control = await readRecruitActionControl(client, nodeId, {
+        selector: ACTION_SELECTOR,
+        index
+      });
+      if (control) controls.push(control);
+    }
+  }
+  controls.sort((left, right) => right.score - left.score);
+  return controls;
+}
+
+export function summarizeRecruitActionControls(controls = []) {
+  const greetControls = controls.filter((control) => control.kind === "greet");
+  const favoriteControls = controls.filter((control) => control.kind === "favorite");
+  const actionableGreet = greetControls.find((control) => control.available && !control.continue_chat) || null;
+  const continueGreet = greetControls.find((control) => control.continue_chat) || null;
+  const actionableFavorite = favoriteControls.find((control) => control.available) || null;
+  return {
+    greet: {
+      found: Boolean(actionableGreet || continueGreet),
+      available: Boolean(actionableGreet),
+      continue_chat: Boolean(continueGreet && !actionableGreet),
+      greet_quota: actionableGreet?.greet_quota || continueGreet?.greet_quota || null,
+      control: actionableGreet || continueGreet
+    },
+    favorite: {
+      found: Boolean(actionableFavorite),
+      available: Boolean(actionableFavorite),
+      control: actionableFavorite
+    }
+  };
+}
+
+export async function waitForRecruitDetailActionControls(client, {
+  rootNodeIds = [],
+  timeoutMs = 8000,
+  intervalMs = 400,
+  requireAny = false
+} = {}) {
+  const started = Date.now();
+  let controls = [];
+  while (Date.now() - started <= timeoutMs) {
+    controls = await discoverRecruitDetailActionControls(client, rootNodeIds);
+    const summary = summarizeRecruitActionControls(controls);
+    if (!requireAny || summary.greet.found || summary.favorite.found) {
+      return {
+        ok: summary.greet.found || summary.favorite.found,
+        elapsed_ms: Date.now() - started,
+        controls,
+        summary
+      };
+    }
+    await sleep(intervalMs);
+  }
+  return {
+    ok: false,
+    elapsed_ms: Date.now() - started,
+    controls,
+    summary: summarizeRecruitActionControls(controls)
+  };
+}
+
+export async function clickRecruitActionControl(client, control, {
+  delayMs = 120
+} = {}) {
+  if (!control?.node_id) throw new Error("Recruit action control is missing node_id");
+  const greetQuota = control.kind === "greet"
+    ? assertGreetQuotaAvailable(control.greet_quota || control.label || "")
+    : null;
+  const box = await clickNodeCenter(client, control.node_id, {
+    scrollIntoView: true,
+    delayMs
+  });
+  return {
+    clicked: true,
+    kind: control.kind,
+    label: control.label,
+    greet_quota: greetQuota?.found ? greetQuota : null,
+    node_id: control.node_id,
+    box
+  };
+}

package/src/domains/recruit/cards.js

@@ -0,0 +1,67 @@
+import {
+  getAttributesMap,
+  getOuterHTML,
+  querySelectorAll,
+  sleep
+} from "../../core/browser/index.js";
+import { normalizeCandidateFromHtml } from "../../core/screening/index.js";
+import { RECRUIT_CARD_SELECTOR } from "./constants.js";
+
+export async function findRecruitCardNodeIds(client, frameNodeId, {
+  selector = RECRUIT_CARD_SELECTOR
+} = {}) {
+  return querySelectorAll(client, frameNodeId, selector);
+}
+
+export async function waitForRecruitCardNodeIds(client, frameNodeId, {
+  selector = RECRUIT_CARD_SELECTOR,
+  timeoutMs = 12000,
+  intervalMs = 300
+} = {}) {
+  const started = Date.now();
+  let nodeIds = [];
+  while (Date.now() - started <= timeoutMs) {
+    nodeIds = await findRecruitCardNodeIds(client, frameNodeId, { selector });
+    if (nodeIds.length) return nodeIds;
+    await sleep(intervalMs);
+  }
+  return nodeIds;
+}
+
+export async function readRecruitCardCandidate(client, cardNodeId, {
+  targetUrl = "",
+  source = "recruit-domain-card",
+  metadata = {}
+} = {}) {
+  const [attributes, outerHTML] = await Promise.all([
+    getAttributesMap(client, cardNodeId),
+    getOuterHTML(client, cardNodeId)
+  ]);
+  return normalizeCandidateFromHtml({
+    domain: "recruit",
+    source,
+    html: outerHTML,
+    attributes,
+    metadata: {
+      target_url: targetUrl,
+      card_node_id: cardNodeId,
+      ...metadata
+    }
+  });
+}
+
+export async function readFirstRecruitCardCandidate(client, frameNodeId, options = {}) {
+  const cardNodeIds = await findRecruitCardNodeIds(client, frameNodeId, options);
+  if (!cardNodeIds.length) {
+    throw new Error("No recruit/search candidate cards found");
+  }
+
+  const candidate = await readRecruitCardCandidate(client, cardNodeIds[0], options);
+  return {
+    card_count: cardNodeIds.length,
+    first_card_node_id: cardNodeIds[0],
+    card_node_ids: cardNodeIds,
+    candidate
+  };
+}
+