@reconcrap/boss-recommend-mcp 2.0.7 → 2.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reconcrap/boss-recommend-mcp",
-  "version": "2.0.7",
+  "version": "2.0.9",
   "description": "Unified MCP pipeline for recommend-page filtering and screening on Boss Zhipin",
   "keywords": [
     "boss",

package/src/chat-mcp.js

@@ -863,15 +863,24 @@ function getRunOptions(args, normalized, session, { workspaceRoot = "", configRe
     llmConfig: resolvedConfig.ok ? {
       ...resolvedConfig.config
     } : null,
-    llmTimeoutMs: parsePositiveInteger(args.llm_timeout_ms, slowLive ? 180000 : 120000),
-    llmImageLimit: parsePositiveInteger(args.llm_image_limit, 8),
-    llmImageDetail: normalizeText(args.llm_image_detail) || "high",
+    llmTimeoutMs: parsePositiveInteger(
+      args.llm_timeout_ms,
+      parsePositiveInteger(resolvedConfig.config?.llmTimeoutMs || resolvedConfig.config?.timeoutMs, slowLive ? 180000 : 120000)
+    ),
+    llmImageLimit: parsePositiveInteger(
+      args.llm_image_limit,
+      parsePositiveInteger(resolvedConfig.config?.llmImageLimit || resolvedConfig.config?.imageLimit, 8)
+    ),
+    llmImageDetail: normalizeText(
+      args.llm_image_detail || resolvedConfig.config?.llmImageDetail || resolvedConfig.config?.imageDetail
+    ) || "low",
     screeningMode: normalizeScreeningModeArg(args),
     listMaxScrolls: parsePositiveInteger(args.list_max_scrolls, 200),
     listStableSignatureLimit: parsePositiveInteger(args.list_stable_signature_limit, 2),
     listWheelDeltaY: parsePositiveInteger(args.list_wheel_delta_y, 850),
     listSettleMs: parsePositiveInteger(args.list_settle_ms, slowLive ? 1800 : 1200),
     listFallbackPoint: null,
+    imageOutputDir: resolveBossConfiguredOutputDir("", getChatRunsDir()),
     name: "mcp-boss-chat-run"
   };
 }

package/src/core/boss-cards/index.js

@@ -0,0 +1,199 @@
+import { htmlToText, normalizeText } from "../screening/index.js";
+
+function uniqueTexts(values = []) {
+  return Array.from(new Set(values.map((value) => normalizeText(value)).filter(Boolean)));
+}
+
+function classList(value = "") {
+  return String(value || "").split(/\s+/).map((item) => item.trim()).filter(Boolean);
+}
+
+function hasAllClasses(classValue = "", requiredClasses = []) {
+  const classes = classList(classValue);
+  return requiredClasses.every((required) => classes.includes(required));
+}
+
+function findClassAttributeIndex(html = "", requiredClasses = [], startIndex = 0) {
+  const regex = /class=(["'])(.*?)\1/gi;
+  regex.lastIndex = Math.max(0, Number(startIndex) || 0);
+  let match;
+  while ((match = regex.exec(String(html || "")))) {
+    if (hasAllClasses(match[2], requiredClasses)) return match.index;
+  }
+  return -1;
+}
+
+function sectionByClasses(html = "", startClasses = [], endClassGroups = []) {
+  const source = String(html || "");
+  const classIndex = findClassAttributeIndex(source, startClasses);
+  if (classIndex < 0) return "";
+  const start = Math.max(0, source.lastIndexOf("<", classIndex));
+  let end = source.length;
+  for (const group of endClassGroups) {
+    const found = findClassAttributeIndex(source, group, classIndex + 1);
+    if (found >= 0) {
+      const tagStart = source.lastIndexOf("<", found);
+      end = Math.min(end, tagStart >= 0 ? tagStart : found);
+    }
+  }
+  return source.slice(start, end);
+}
+
+function textFromHtmlFragment(fragment = "") {
+  return normalizeText(htmlToText(fragment).replace(/\n+/g, " "));
+}
+
+function stripNameSuffixes(value = "") {
+  return normalizeText(value)
+    .replace(/\s*(在线|刚刚活跃|今日活跃|本周活跃|本月活跃)$/u, "")
+    .trim();
+}
+
+function extractFirstSpanWithClass(html = "", className = "") {
+  const regex = /<span\b[^>]*class=(["'])(.*?)\1[^>]*>([\s\S]*?)<\/span>/gi;
+  let match;
+  while ((match = regex.exec(String(html || "")))) {
+    if (classList(match[2]).includes(className)) {
+      return textFromHtmlFragment(match[3]);
+    }
+  }
+  return "";
+}
+
+function extractSpanTexts(fragment = "") {
+  const values = [];
+  const regex = /<span\b[^>]*>([\s\S]*?)<\/span>/gi;
+  let match;
+  while ((match = regex.exec(String(fragment || "")))) {
+    values.push(textFromHtmlFragment(match[1]));
+  }
+  return uniqueTexts(values);
+}
+
+function extractDivTextsWithClasses(fragment = "", requiredClasses = []) {
+  const values = [];
+  const regex = /<div\b[^>]*class=(["'])(.*?)\1[^>]*>([\s\S]*?)<\/div>/gi;
+  let match;
+  while ((match = regex.exec(String(fragment || "")))) {
+    if (hasAllClasses(match[2], requiredClasses)) {
+      values.push(extractSpanTexts(match[3]));
+    }
+  }
+  return values.filter((items) => items.length);
+}
+
+function parseAgeValue(value = "") {
+  const match = normalizeText(value).match(/^(\d{2})岁$/u);
+  if (!match) return null;
+  const age = Number.parseInt(match[1], 10);
+  return Number.isFinite(age) ? age : null;
+}
+
+function parseDegreeValue(value = "") {
+  const normalized = normalizeText(value);
+  const match = normalized.match(/博士|硕士|本科|大专|专科|高中|中专\/中技|中专|中技|初中及以下/u);
+  return match ? match[0] : "";
+}
+
+function isSalaryLike(value = "") {
+  const normalized = normalizeText(value);
+  return Boolean(
+    /^(?:面议|薪资面议)$/i.test(normalized)
+    || /^\d+(?:\.\d+)?(?:\s*-\s*\d+(?:\.\d+)?)?\s*[kK](?:\s*[·xX*]\s*\d+\s*薪?)?$/.test(normalized)
+    || /^\d+\s*-\s*\d+\s*元\s*\/\s*天$/.test(normalized)
+  );
+}
+
+function extractSalary(html = "") {
+  const section = sectionByClasses(html, ["salary-wrap"], [
+    ["name-wrap"],
+    ["col-2"]
+  ]);
+  return extractSpanTexts(section).find(isSalaryLike) || "";
+}
+
+function extractBaseInfo(html = "") {
+  const section = sectionByClasses(html, ["base-info"], [
+    ["expect-wrap"],
+    ["geek-desc"],
+    ["timeline-wrap"]
+  ]);
+  const parts = extractSpanTexts(section);
+  return {
+    parts,
+    age: parts.map(parseAgeValue).find((value) => value != null) ?? null,
+    degree: parts.map(parseDegreeValue).find(Boolean) || ""
+  };
+}
+
+function extractFirstTimelineContent(html = "", timelineClass = "") {
+  const section = sectionByClasses(html, ["timeline-wrap", timelineClass], [
+    timelineClass === "work-exps" ? ["timeline-wrap", "edu-exps"] : ["card-btns"],
+    ["action-wrap"]
+  ]);
+  const contentRows = extractDivTextsWithClasses(section, ["join-text-wrap", "content"]);
+  return contentRows[0] || [];
+}
+
+function extractTagTexts(html = "") {
+  const tags = [];
+  const regex = /<span\b[^>]*class=(["'])(.*?)\1[^>]*>([\s\S]*?)<\/span>/gi;
+  let match;
+  while ((match = regex.exec(String(html || "")))) {
+    if (classList(match[2]).includes("tag-item")) {
+      tags.push(textFromHtmlFragment(match[3]));
+    }
+  }
+  return uniqueTexts(tags);
+}
+
+export function parseBossCandidateCardFieldsFromHtml(html = "") {
+  const name = stripNameSuffixes(extractFirstSpanWithClass(html, "name"));
+  const baseInfo = extractBaseInfo(html);
+  const work = extractFirstTimelineContent(html, "work-exps");
+  const education = extractFirstTimelineContent(html, "edu-exps");
+  const educationDegree = education.map(parseDegreeValue).find(Boolean) || "";
+  return {
+    identity: {
+      name: name && !isSalaryLike(name) ? name : "",
+      current_company: work[0] || "",
+      current_position: work[1] || "",
+      school: education[0] || "",
+      major: education[1] || "",
+      degree: educationDegree || baseInfo.degree || "",
+      age: baseInfo.age
+    },
+    salary: extractSalary(html),
+    base_info: baseInfo.parts,
+    work,
+    education,
+    tags: extractTagTexts(html)
+  };
+}
+
+export function mergeBossCandidateCardFields(candidate, outerHTML = "", {
+  metadataKey = "boss_card_fields"
+} = {}) {
+  const parsed = parseBossCandidateCardFieldsFromHtml(outerHTML);
+  const identity = { ...(candidate.identity || {}) };
+  for (const [key, value] of Object.entries(parsed.identity || {})) {
+    if (value !== "" && value !== null && value !== undefined) {
+      identity[key] = value;
+    }
+  }
+  return {
+    ...candidate,
+    identity,
+    tags: uniqueTexts([...(candidate.tags || []), ...(parsed.tags || [])]),
+    metadata: {
+      ...(candidate.metadata || {}),
+      [metadataKey]: {
+        salary: parsed.salary || "",
+        base_info: parsed.base_info || [],
+        work: parsed.work || [],
+        education: parsed.education || [],
+        tags: parsed.tags || []
+      }
+    }
+  };
+}

package/src/core/capture/index.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import crypto from "node:crypto";
 import path from "node:path";
+import sharp from "sharp";
 import {
   getAttributesMap,
   getNodeBox,
@@ -149,6 +150,63 @@ function screenshotHash(buffer) {
   return crypto.createHash("sha256").update(buffer).digest("hex");
 }
 
+async function optimizeScreenshotBuffer(buffer, {
+  enabled = false,
+  format = "png",
+  quality,
+  resizeMaxWidth = 0
+} = {}) {
+  if (!enabled && !resizeMaxWidth) {
+    return {
+      buffer,
+      optimized: false,
+      optimization_error: null
+    };
+  }
+  try {
+    const normalizedFormat = format === "jpg" ? "jpeg" : format;
+    let pipeline = sharp(buffer, { failOn: "none" });
+    const metadata = await pipeline.metadata();
+    const width = Number(metadata.width) || 0;
+    const safeMaxWidth = Math.max(0, Number(resizeMaxWidth) || 0);
+    if (safeMaxWidth > 0 && width > safeMaxWidth) {
+      pipeline = pipeline.resize({
+        width: safeMaxWidth,
+        withoutEnlargement: true
+      });
+    }
+    if (normalizedFormat === "jpeg") {
+      pipeline = pipeline.jpeg({
+        quality: quality == null ? 72 : Math.max(35, Math.min(95, Number(quality) || 72)),
+        mozjpeg: true
+      });
+    } else if (normalizedFormat === "webp") {
+      pipeline = pipeline.webp({
+        quality: quality == null ? 76 : Math.max(35, Math.min(95, Number(quality) || 76))
+      });
+    } else {
+      pipeline = pipeline.png({
+        compressionLevel: 9,
+        adaptiveFiltering: true
+      });
+    }
+    const optimizedBuffer = await pipeline.toBuffer();
+    return {
+      buffer: optimizedBuffer,
+      optimized: true,
+      original_byte_length: buffer.length,
+      optimization_error: null
+    };
+  } catch (error) {
+    return {
+      buffer,
+      optimized: false,
+      original_byte_length: buffer.length,
+      optimization_error: error?.message || String(error)
+    };
+  }
+}
+
 export async function captureScrolledNodeScreenshots(client, nodeId, {
   filePath,
   format = "png",
@@ -156,21 +214,34 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
   padding = 0,
   captureBeyondViewport = true,
   fromSurface = true,
+  captureViewport = false,
   maxScreenshots = 6,
   wheelDeltaY = 650,
   settleMs = 900,
   duplicateStopCount = 2,
+  skipDuplicateScreenshots = false,
+  optimize = false,
+  resizeMaxWidth = 0,
   metadata = {}
 } = {}) {
   if (!nodeId) throw new Error("captureScrolledNodeScreenshots requires nodeId");
+  const sequenceStarted = Date.now();
   const screenshots = [];
   let consecutiveDuplicates = 0;
   let previousHash = "";
+  let captureCount = 0;
+  let droppedDuplicateCount = 0;
 
   for (let index = 0; index < Math.max(1, Number(maxScreenshots) || 1); index += 1) {
+    captureCount += 1;
+    const captureStarted = Date.now();
     const box = await getNodeBox(client, nodeId);
     const clip = withPadding(box.rect, padding);
-    const captureOptions = {
+    const captureOptions = captureViewport ? {
+      format,
+      fromSurface,
+      captureBeyondViewport: false
+    } : {
       format,
       fromSurface,
       captureBeyondViewport,
@@ -180,7 +251,14 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
       captureOptions.quality = quality;
     }
     const screenshot = await client.Page.captureScreenshot(captureOptions);
-    const buffer = Buffer.from(screenshot.data || "", "base64");
+    const originalBuffer = Buffer.from(screenshot.data || "", "base64");
+    const optimized = await optimizeScreenshotBuffer(originalBuffer, {
+      enabled: optimize,
+      format,
+      quality,
+      resizeMaxWidth
+    });
+    const buffer = optimized.buffer;
     const hash = screenshotHash(buffer);
     const duplicateOfPrevious = previousHash && previousHash === hash;
     if (duplicateOfPrevious) {
@@ -189,29 +267,40 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
       consecutiveDuplicates = 0;
     }
 
-    const outputPath = filePath ? filePathForSequence(filePath, index, format) : null;
-    if (outputPath) {
-      fs.writeFileSync(outputPath, buffer);
-    }
+    let outputPath = null;
+    if (duplicateOfPrevious && skipDuplicateScreenshots) {
+      droppedDuplicateCount += 1;
+    } else {
+      outputPath = filePath ? filePathForSequence(filePath, screenshots.length, format) : null;
+      if (outputPath) {
+        fs.writeFileSync(outputPath, buffer);
+      }
 
-    screenshots.push({
-      index,
-      source: "image",
-      captured_at: nowIso(),
-      node_id: nodeId,
-      format,
-      mime_type: `image/${format === "jpeg" ? "jpeg" : "png"}`,
-      byte_length: buffer.length,
-      file_path: outputPath,
-      sha256: hash,
-      duplicate_of_previous: Boolean(duplicateOfPrevious),
-      clip,
-      node_rect: box.rect,
-      scroll: index === 0
-        ? { before_capture: "initial" }
-        : { before_capture: `wheel_down_${index}` },
-      metadata
-    });
+      screenshots.push({
+        index: screenshots.length,
+        capture_index: index,
+        source: "image",
+        captured_at: nowIso(),
+        node_id: nodeId,
+        format,
+        mime_type: `image/${format === "jpeg" ? "jpeg" : "png"}`,
+        byte_length: buffer.length,
+        original_byte_length: optimized.original_byte_length || originalBuffer.length,
+        optimized: Boolean(optimized.optimized),
+        optimization_error: optimized.optimization_error || null,
+        elapsed_ms: Date.now() - captureStarted,
+        file_path: outputPath,
+        sha256: hash,
+        duplicate_of_previous: Boolean(duplicateOfPrevious),
+        clip,
+        capture_viewport: Boolean(captureViewport),
+        node_rect: box.rect,
+        scroll: index === 0
+          ? { before_capture: "initial" }
+          : { before_capture: `wheel_down_${index}` },
+        metadata
+      });
+    }
 
     previousHash = hash;
     if (consecutiveDuplicates >= Math.max(1, Number(duplicateStopCount) || 1)) {
@@ -238,8 +327,21 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
     source: "image-scroll-sequence",
     captured_at: nowIso(),
     node_id: nodeId,
+    elapsed_ms: Date.now() - sequenceStarted,
+    capture_count: captureCount,
     screenshot_count: screenshots.length,
     unique_screenshot_count: new Set(screenshots.map((item) => item.sha256)).size,
+    duplicate_screenshot_count: captureCount - new Set(screenshots.map((item) => item.sha256)).size,
+    dropped_duplicate_count: droppedDuplicateCount,
+    total_byte_length: screenshots.reduce((sum, item) => sum + (Number(item.byte_length) || 0), 0),
+    original_total_byte_length: screenshots.reduce((sum, item) => sum + (Number(item.original_byte_length) || 0), 0),
+    optimization: {
+      enabled: Boolean(optimize),
+      resize_max_width: Math.max(0, Number(resizeMaxWidth) || 0),
+      capture_viewport: Boolean(captureViewport),
+      format,
+      quality: quality ?? null
+    },
     file_paths: screenshots.map((item) => item.file_path).filter(Boolean),
     screenshots,
     metadata

package/src/core/cv-acquisition/index.js

@@ -125,8 +125,14 @@ export function summarizeImageEvidence(imageEvidence = null) {
   if (!imageEvidence) return null;
   return {
     source: imageEvidence.source || "",
+    elapsed_ms: imageEvidence.elapsed_ms || 0,
+    capture_count: imageEvidence.capture_count || imageEvidence.screenshot_count || 0,
     screenshot_count: imageEvidence.screenshot_count || 0,
     unique_screenshot_count: imageEvidence.unique_screenshot_count || 0,
+    dropped_duplicate_count: imageEvidence.dropped_duplicate_count || 0,
+    total_byte_length: imageEvidence.total_byte_length || 0,
+    original_total_byte_length: imageEvidence.original_total_byte_length || 0,
+    optimization: imageEvidence.optimization || null,
     file_paths: imageEvidence.file_paths || [],
     first_clip: imageEvidence.screenshots?.[0]?.clip || imageEvidence.clip || null
   };

package/src/core/reporting/legacy-csv.js

@@ -227,8 +227,17 @@ function pickCandidate(row = {}) {
 
 function timingValue(row = {}, ...keys) {
   const timings = row.timings || row.timing || {};
+  const detail = row.detail || {};
+  const acquisition = detail.cv_acquisition || {};
+  const fallbackByKey = {
+    network_cv_wait_ms: acquisition.network_wait?.elapsed_ms,
+    screenshot_capture_ms: acquisition.image_evidence?.elapsed_ms || detail.image_evidence?.elapsed_ms,
+    dom_fallback_ms: acquisition.content_wait?.elapsed_ms,
+    close_detail_ms: detail.close_result?.elapsed_ms,
+    post_action_ms: row.post_action?.elapsed_ms
+  };
   for (const key of keys) {
-    const value = firstDefined(row[key], timings[key]);
+    const value = firstDefined(row[key], timings[key], fallbackByKey[key]);
     if (value !== "") return value;
   }
   return "";

package/src/core/run/timing.js

@@ -0,0 +1,33 @@
+import path from "node:path";
+
+export function addTiming(timings, key, value) {
+  if (!timings || !key) return;
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric) || numeric < 0) return;
+  timings[key] = (Number(timings[key]) || 0) + Math.round(numeric);
+}
+
+export async function measureTiming(timings, key, task) {
+  const started = Date.now();
+  try {
+    return await task();
+  } finally {
+    addTiming(timings, key, Date.now() - started);
+  }
+}
+
+export function imageEvidenceFilePath({
+  imageOutputDir = "",
+  domain = "candidate",
+  runId = "",
+  index = 0,
+  extension = "png"
+} = {}) {
+  const dir = String(imageOutputDir || "").trim();
+  if (!dir) return "";
+  const safeDomain = String(domain || "candidate").replace(/[^\w.-]+/g, "_");
+  const safeRunId = String(runId || `${safeDomain}-run`).replace(/[^\w.-]+/g, "_");
+  const safeIndex = String((Number(index) || 0) + 1).padStart(3, "0");
+  const safeExt = String(extension || "png").replace(/^\./, "") || "png";
+  return path.join(dir, safeRunId, `${safeDomain}-candidate-${safeIndex}.${safeExt}`);
+}