@reconcrap/boss-recruit-mcp 1.0.20 → 1.0.21

package/src/parser.js

@@ -31,8 +31,6 @@ const DEFAULT_PARAM_LABELS = {
 };
 const DEGREE_VALUES = new Set(["不限", "本科", "本科及以上", "硕士及以上", "博士"]);
 const CITY_STOP_PATTERN = /(?:筛选|搜索|查找|找|做过|从事过|有过|相关|的人选|的人|并且|且|学历|学校|目标|必须|优先|，|。|；|;|,)/;
-const SEARCH_INTENT_LEADING_PATTERN = /^(?:帮我|请)?(?:在boss上|在boss直聘上)?(?:找|筛选|搜索|查找)/i;
-const SEARCH_INTENT_META_PATTERN = /(?:城市|地点|学历|学校|目标|人数|候选人|人选|岗位|职位|做过|有过|从事过|本科|硕士|博士)/i;
 
 function normalizeText(input) {
   return String(input || "").replace(/\s+/g, " ").trim();
@@ -93,19 +91,6 @@ function extractCity(text) {
     }
   }
 
-  const implicitPatterns = [
-    /(?:^|[，,。；;\n])(?:帮我|请)?(?:在boss上|在boss直聘上)?(?:找|筛选|搜索|查找)\s*([^\s，。；;、]{2,12}?)(?=(?:本科|硕士|博士|做过|有过|从事过|的人选|的人|候选人|工程师|研究员|岗位|职位|，|。|；|;|,|$))/i,
-    /(?:^|[，,。；;\n])在\s*([^\s，。；;、]{2,12}?)(?=(?:招|招聘|找|筛选|搜索|查找|本科|硕士|博士|做过|有过|从事过|的人选|的人|候选人|工程师|研究员|岗位|职位|，|。|；|;|,|$))/i
-  ];
-
-  for (const pattern of implicitPatterns) {
-    const m = text.match(pattern);
-    if (m && m[1]) {
-      const city = sanitizeCityCandidate(m[1]);
-      if (city) return city;
-    }
-  }
-
   return null;
 }
 
@@ -198,9 +183,9 @@ function extractKeywordExplicit(text) {
 
 function extractKeywordAuto(text) {
   const patterns = [
-    /做(?:过)?\s*([\u4e00-\u9fa5A-Za-z0-9+#./\-\s]{2,40}?)(?:的人选|的人|相关|并且|且|，|。|,|$)/i,
-    /有过\s*([\u4e00-\u9fa5A-Za-z0-9+#./\-\s]{2,40}?)(?:经验|背景|的人选|并且|且|，|。|,|$)/i,
-    /从事过\s*([\u4e00-\u9fa5A-Za-z0-9+#./\-\s]{2,40}?)(?:相关|的人选|并且|且|，|。|,|$)/i
+    /做过\s*([A-Za-z0-9+#./\-\s]{2,40}?)(?:的人选|的人|相关|并且|且|，|。|,|$)/i,
+    /有过\s*([A-Za-z0-9+#./\-\s]{2,40}?)(?:经验|背景|的人选|并且|且|，|。|,|$)/i,
+    /从事过\s*([A-Za-z0-9+#./\-\s]{2,40}?)(?:相关|的人选|并且|且|，|。|,|$)/i
   ];
 
   for (const pattern of patterns) {
@@ -231,21 +216,6 @@ function extractTargetCount(text) {
   return null;
 }
 
-function extractExplicitCriteria(text) {
-  const patterns = [
-    /(?:筛选条件|筛选要求|硬性条件|筛选标准|要求)(?:为|是|:|：)\s*([^\n]+)/i
-  ];
-
-  for (const pattern of patterns) {
-    const m = text.match(pattern);
-    if (m && m[1]) {
-      const criteria = m[1].trim();
-      if (criteria) return criteria;
-    }
-  }
-  return null;
-}
-
 function sanitizeClause(clause) {
   return clause
     .replace(/^使用boss-recruit-pipeline skills/i, "")
@@ -262,11 +232,6 @@ function isCountPlanningClause(clause) {
 }
 
 function buildScreenCriteria(text, searchParams) {
-  const explicitCriteria = extractExplicitCriteria(text);
-  if (explicitCriteria) {
-    return explicitCriteria;
-  }
-
   const clauses = text
     .split(/[，,。；;\n]/)
     .map((s) => sanitizeClause(s))
@@ -277,7 +242,6 @@ function buildScreenCriteria(text, searchParams) {
     if (/地点|城市/.test(clause)) return false;
     if (/近?14天(?:内)?查看(?:过)?|过滤近14天查看/.test(clause)) return false;
     if (isCountPlanningClause(clause)) return false;
-    if (SEARCH_INTENT_LEADING_PATTERN.test(clause) && SEARCH_INTENT_META_PATTERN.test(clause)) return false;
     return true;
   });
 
@@ -479,7 +443,7 @@ export function parseRecruitInstruction({ instruction, confirmation, overrides }
   if (!baseSearchParams.city) missingBeforeDefaults.push("city");
   if (!baseSearchParams.degree) missingBeforeDefaults.push("degree");
   if (!baseSearchParams.schools || baseSearchParams.schools.length === 0) missingBeforeDefaults.push("schools");
-  if (!baseSearchParams.keyword && !keywordResolution.needsConfirmation) missingBeforeDefaults.push("keyword");
+  if (!baseSearchParams.keyword) missingBeforeDefaults.push("keyword");
   if (!baseScreenParams.target_count) missingBeforeDefaults.push("target_count");
 
   const useDefaultForMissing = confirmation?.use_default_for_missing === true;

package/src/pipeline.js

@@ -8,10 +8,16 @@ import {
   runScreenCli
 } from "./adapters.js";
 
+export const PIPELINE_STATUS_READY_TO_START_ASYNC = "READY_TO_START_ASYNC";
+
 function dedupe(values = []) {
   return [...new Set(values.filter(Boolean))];
 }
 
+function normalizeText(value) {
+  return String(value || "").replace(/\s+/g, " ").trim();
+}
+
 function failedCheckSet(checks = []) {
   const failed = checks
     .filter((item) => item && item.ok === false && typeof item.key === "string")
@@ -195,6 +201,99 @@ function buildFailedResponse(code, message, extra = {}) {
   };
 }
 
+class PipelineAbortError extends Error {
+  constructor(message = "Pipeline execution aborted") {
+    super(message);
+    this.name = "PipelineAbortError";
+    this.code = "PIPELINE_ABORTED";
+  }
+}
+
+function isAbortSignalTriggered(signal) {
+  return Boolean(signal && signal.aborted);
+}
+
+function ensurePipelineNotAborted(signal) {
+  if (isAbortSignalTriggered(signal)) {
+    throw new PipelineAbortError("Pipeline execution aborted by caller.");
+  }
+}
+
+function safeInvokeRuntimeCallback(callback, payload) {
+  if (typeof callback !== "function") return;
+  try {
+    callback(payload);
+  } catch {
+    // Keep pipeline stable even if runtime callback fails.
+  }
+}
+
+function createPipelineRuntime(runtime = null) {
+  const signal = runtime?.signal;
+  const heartbeatIntervalMs = Number.isFinite(runtime?.heartbeatIntervalMs) && runtime.heartbeatIntervalMs > 0
+    ? runtime.heartbeatIntervalMs
+    : 10_000;
+  const precheckOnly = runtime?.precheckOnly === true;
+
+  function setStage(stage, message = null) {
+    safeInvokeRuntimeCallback(runtime?.onStage, {
+      stage,
+      message: normalizeText(message || "") || null,
+      at: new Date().toISOString()
+    });
+  }
+
+  function heartbeat(stage, details = null) {
+    safeInvokeRuntimeCallback(runtime?.onHeartbeat, {
+      stage,
+      details: details || null,
+      at: new Date().toISOString()
+    });
+  }
+
+  function output(stage, event) {
+    safeInvokeRuntimeCallback(runtime?.onOutput, {
+      stage,
+      ...(event || {}),
+      at: new Date().toISOString()
+    });
+  }
+
+  function progress(stage, payload) {
+    safeInvokeRuntimeCallback(runtime?.onProgress, {
+      stage,
+      ...(payload || {}),
+      at: new Date().toISOString()
+    });
+  }
+
+  function adapterRuntime(stage) {
+    return {
+      signal,
+      heartbeatIntervalMs,
+      onOutput: (event) => output(stage, event),
+      onHeartbeat: (event) => heartbeat(stage, event),
+      onProgress: (payload) => progress(stage, payload)
+    };
+  }
+
+  return {
+    signal,
+    heartbeatIntervalMs,
+    precheckOnly,
+    setStage,
+    heartbeat,
+    output,
+    progress,
+    adapterRuntime
+  };
+}
+
+function isProcessAbortError(errorLike) {
+  const code = normalizeText(errorLike?.code || errorLike?.error_code || "").toUpperCase();
+  return code === "PROCESS_ABORTED" || code === "ABORTED";
+}
+
 function normalizeCsvPath(csvPath) {
   if (typeof csvPath !== "string") return null;
   const trimmed = csvPath.trim();
@@ -365,12 +464,16 @@ const defaultDependencies = {
   runScreenCli
 };
 
-export async function runRecruitPipeline({
-  workspaceRoot,
-  instruction,
-  confirmation,
-  overrides
-}, dependencies = defaultDependencies) {
+export async function runRecruitPipeline(
+  {
+    workspaceRoot,
+    instruction,
+    confirmation,
+    overrides
+  },
+  dependencies = defaultDependencies,
+  runtime = null
+) {
   const {
     parseRecruitInstruction: parseInstruction,
     ensureBossSearchPageReady: ensureSearchPageReady,
@@ -378,6 +481,8 @@ export async function runRecruitPipeline({
     runSearchCli: searchCli,
     runScreenCli: screenCli
   } = dependencies;
+  const runtimeHooks = createPipelineRuntime(runtime);
+  ensurePipelineNotAborted(runtimeHooks.signal);
   const startedAt = Date.now();
   const parsed = parseInstruction({
     instruction,
@@ -398,8 +503,14 @@ export async function runRecruitPipeline({
     return buildNeedConfirmationResponse(parsed);
   }
 
+  ensurePipelineNotAborted(runtimeHooks.signal);
+  runtimeHooks.setStage("preflight", "开始执行 preflight 检查。");
+  runtimeHooks.heartbeat("preflight");
   const preflight = runPreflight(workspaceRoot);
   if (!preflight.ok) {
+    runtimeHooks.heartbeat("preflight", {
+      status: "failed"
+    });
     const recovery = buildPreflightRecovery(preflight.checks, workspaceRoot);
     return buildFailedResponse(
       "PIPELINE_PREFLIGHT_FAILED",
@@ -429,12 +540,70 @@ export async function runRecruitPipeline({
     );
   }
 
+  ensurePipelineNotAborted(runtimeHooks.signal);
+  runtimeHooks.setStage("page_ready", "preflight 完成，开始检查 search 页面就绪状态。");
+  runtimeHooks.heartbeat("page_ready");
+  const initialPageCheck = await ensureSearchPageReady(workspaceRoot, {
+    port: preflight.debug_port
+  });
+  if (!initialPageCheck.ok) {
+    if (
+      initialPageCheck.state === "LOGIN_REQUIRED"
+      || initialPageCheck.state === "LOGIN_REQUIRED_AFTER_REDIRECT"
+    ) {
+      return buildFailedResponse(
+        "BOSS_LOGIN_REQUIRED",
+        "Boss 页面未稳定停留在 search 页面，疑似未登录或登录态失效。请先在当前 Chrome 窗口手动登录 Boss，登录完成后再继续搜索和筛选。",
+        {
+          search_params: parsed.searchParams,
+          screen_params: parsed.screenParams,
+          diagnostics: buildProgressDiagnostics({
+            preflight,
+            totalProcessedCount: 0,
+            totalPassedCount: 0,
+            roundCount: 0,
+            extra: {
+              page_state: initialPageCheck.page_state
+            }
+          })
+        }
+      );
+    }
+    return buildFailedResponse(
+      "BOSS_SEARCH_PAGE_NOT_READY",
+      "无法确认 Boss search 页面已就绪。请先确保 Chrome 调试端口可连，并且页面能稳定停留在 https://www.zhipin.com/web/chat/search。",
+      {
+        search_params: parsed.searchParams,
+        screen_params: parsed.screenParams,
+        diagnostics: buildProgressDiagnostics({
+          preflight,
+          totalProcessedCount: 0,
+          totalPassedCount: 0,
+          roundCount: 0,
+          extra: {
+            page_state: initialPageCheck.page_state
+          }
+        })
+      }
+    );
+  }
+
+  if (runtimeHooks.precheckOnly) {
+    return {
+      status: PIPELINE_STATUS_READY_TO_START_ASYNC,
+      search_params: parsed.searchParams,
+      screen_params: parsed.screenParams,
+      message: "前置门禁检查通过，可启动异步流水线。"
+    };
+  }
+
   let totalProcessedCount = 0;
   let totalPassedCount = 0;
   let roundCount = 0;
   const roundOutputCsvPaths = [];
 
   while (totalProcessedCount < initialTargetCount) {
+    ensurePipelineNotAborted(runtimeHooks.signal);
     roundCount += 1;
 
     const remainingTargetCount = Math.max(0, initialTargetCount - totalProcessedCount);
@@ -447,9 +616,17 @@ export async function runRecruitPipeline({
       target_count: remainingTargetCount
     };
 
-    const pageCheck = await ensureSearchPageReady(workspaceRoot, {
-      port: preflight.debug_port
-    });
+    if (roundCount > 1) {
+      runtimeHooks.setStage("page_ready", `第 ${roundCount} 轮：检查 search 页面就绪状态。`);
+      runtimeHooks.heartbeat("page_ready", {
+        round: roundCount
+      });
+    }
+    const pageCheck = roundCount === 1
+      ? initialPageCheck
+      : await ensureSearchPageReady(workspaceRoot, {
+          port: preflight.debug_port
+        });
     if (!pageCheck.ok) {
       if (
         pageCheck.state === "LOGIN_REQUIRED"
@@ -493,10 +670,20 @@ export async function runRecruitPipeline({
       );
     }
 
+    ensurePipelineNotAborted(runtimeHooks.signal);
+    runtimeHooks.setStage("search", `第 ${roundCount} 轮：开始执行 search。`);
+    runtimeHooks.heartbeat("search", {
+      round: roundCount
+    });
     const searchResult = await searchCli({
       workspaceRoot,
-      searchParams: roundSearchParams
+      searchParams: roundSearchParams,
+      runtime: runtimeHooks.adapterRuntime("search")
     });
+    ensurePipelineNotAborted(runtimeHooks.signal);
+    if (isProcessAbortError(searchResult)) {
+      throw new PipelineAbortError("搜索流程已取消。");
+    }
 
     if (!searchResult.ok) {
       const failure = classifySearchFailure(searchResult);
@@ -545,6 +732,14 @@ export async function runRecruitPipeline({
 
     const exhaustedByTipNoData = searchResult.no_data_tip_present === true;
     if (exhaustedByTipNoData || searchResult.candidate_count === 0) {
+      runtimeHooks.setStage("finalize", "候选池已耗尽，正在汇总结果。");
+      runtimeHooks.heartbeat("finalize");
+      runtimeHooks.progress("finalize", {
+        processed: totalProcessedCount,
+        passed: totalPassedCount,
+        skipped: Math.max(totalProcessedCount - totalPassedCount, 0),
+        greet_count: 0
+      });
       const durationSec = Math.max(1, Math.round((Date.now() - startedAt) / 1000));
       const mergedCsvPath = mergeRoundCsvFiles(roundOutputCsvPaths);
       return {
@@ -568,10 +763,20 @@ export async function runRecruitPipeline({
       };
     }
 
+    ensurePipelineNotAborted(runtimeHooks.signal);
+    runtimeHooks.setStage("screen", `第 ${roundCount} 轮：开始执行 screen。`);
+    runtimeHooks.heartbeat("screen", {
+      round: roundCount
+    });
     const screenResult = await screenCli({
       workspaceRoot,
-      screenParams: roundScreenParams
+      screenParams: roundScreenParams,
+      runtime: runtimeHooks.adapterRuntime("screen")
     });
+    ensurePipelineNotAborted(runtimeHooks.signal);
+    if (isProcessAbortError(screenResult)) {
+      throw new PipelineAbortError("筛选流程已取消。");
+    }
 
     if (!screenResult.ok) {
       const failure = classifyScreenFailure(screenResult);
@@ -634,10 +839,24 @@ export async function runRecruitPipeline({
         : 0;
     totalProcessedCount += roundProcessedCount;
     totalPassedCount += roundPassedCount;
+    runtimeHooks.progress("screen", {
+      processed: totalProcessedCount,
+      passed: totalPassedCount,
+      skipped: Math.max(totalProcessedCount - totalPassedCount, 0),
+      greet_count: 0
+    });
   }
 
+  runtimeHooks.setStage("finalize", "筛选完成，正在汇总结果。");
+  runtimeHooks.heartbeat("finalize");
   const durationSec = Math.max(1, Math.round((Date.now() - startedAt) / 1000));
   const mergedCsvPath = mergeRoundCsvFiles(roundOutputCsvPaths);
+  runtimeHooks.progress("finalize", {
+    processed: totalProcessedCount,
+    passed: totalPassedCount,
+    skipped: Math.max(totalProcessedCount - totalPassedCount, 0),
+    greet_count: 0
+  });
   return {
     status: "COMPLETED",
     search_params: parsed.searchParams,