@reconcrap/boss-recommend-mcp 2.1.9 → 2.1.11

package/src/recommend-mcp.js

@@ -75,13 +75,119 @@ let recommendRunService = createRecommendRunService({
 });
 const recommendRunMeta = new Map();
 
-function normalizeText(value) {
-  return String(value || "").replace(/\s+/g, " ").trim();
-}
-
-function parsePositiveInteger(raw, fallback) {
-  const parsed = Number.parseInt(String(raw || ""), 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+function normalizeText(value) {
+  return String(value || "").replace(/\s+/g, " ").trim();
+}
+
+function collectRecommendRouteText(args = {}) {
+  return normalizeText([
+    args.instruction,
+    args.criteria,
+    args.target_url_includes,
+    args.page_scope,
+    args.confirmation?.page_value,
+    args.confirmation?.job_value,
+    args.overrides?.criteria,
+    args.overrides?.page_scope,
+    args.overrides?.job,
+    args.overrides?.target_url_includes
+  ].filter((value) => value !== undefined && value !== null).join(" "));
+}
+
+function findRouteSignals(text, patterns = []) {
+  const signals = [];
+  for (const { label, pattern } of patterns) {
+    if (pattern.test(text)) signals.push(label);
+  }
+  return signals;
+}
+
+function detectNonRecommendRoute(args = {}) {
+  const text = collectRecommendRouteText(args);
+  if (!text) return null;
+  const chatSignals = findRouteSignals(text, [
+    { label: "chat-only", pattern: /\bchat[-\s]?only\b/i },
+    { label: "boss-chat", pattern: /\bboss[-\s]?chat\b/i },
+    { label: "chat page", pattern: /\bchat\s+page\b/i },
+    { label: "chat/index", pattern: /(?:\/web\/chat\/index|chat\/index)/i },
+    { label: "聊天页", pattern: /聊天页/ },
+    { label: "聊天列表", pattern: /聊天列表/ },
+    { label: "未读", pattern: /未读/ },
+    { label: "全部聊天", pattern: /全部聊天|所有聊天/ },
+    { label: "求简历", pattern: /求简历|索要简历|要简历|在线简历/ }
+  ]);
+  if (chatSignals.length) {
+    return {
+      domain: "chat",
+      signals: chatSignals,
+      text
+    };
+  }
+  const searchSignals = findRouteSignals(text, [
+    { label: "search-only", pattern: /\bsearch[-\s]?only\b/i },
+    { label: "search page", pattern: /\bsearch\s+page\b/i },
+    { label: "recruit pipeline", pattern: /\brecruit\s+pipeline\b/i },
+    { label: "chat/search", pattern: /(?:\/web\/chat\/search|chat\/search)/i },
+    { label: "搜索页", pattern: /搜索页/ },
+    { label: "招聘搜索", pattern: /招聘搜索/ }
+  ]);
+  if (searchSignals.length) {
+    return {
+      domain: "search",
+      signals: searchSignals,
+      text
+    };
+  }
+  return null;
+}
+
+function buildWrongRecommendRouteResponse(route) {
+  if (route?.domain === "chat") {
+    return {
+      status: "FAILED",
+      route_guard: true,
+      error: {
+        code: "WRONG_BOSS_TOOL_FOR_CHAT",
+        message: "This request is explicitly chat-only/chat-page work. Do not use recommend tools. Use boss_chat_health_check, then list_boss_chat_jobs or prepare_boss_chat_run, then start_boss_chat_run.",
+        retryable: false
+      },
+      detected_domain: "chat",
+      detected_signals: route.signals || [],
+      recommended_tool_sequence: [
+        "boss_chat_health_check",
+        "list_boss_chat_jobs",
+        "prepare_boss_chat_run",
+        "start_boss_chat_run"
+      ]
+    };
+  }
+  if (route?.domain === "search") {
+    return {
+      status: "FAILED",
+      route_guard: true,
+      error: {
+        code: "WRONG_BOSS_TOOL_FOR_SEARCH",
+        message: "This request is explicitly search/recruit-page work. Do not use recommend tools. Use run_recruit_pipeline or start_recruit_pipeline_run.",
+        retryable: false
+      },
+      detected_domain: "search",
+      detected_signals: route.signals || [],
+      recommended_tool_sequence: [
+        "run_recruit_pipeline",
+        "start_recruit_pipeline_run"
+      ]
+    };
+  }
+  return null;
+}
+
+function guardRecommendRoute(args = {}) {
+  return buildWrongRecommendRouteResponse(detectNonRecommendRoute(args));
+}
+
+function parsePositiveInteger(raw, fallback) {
+  const parsed = Number.parseInt(String(raw || ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
 
 function parseNonNegativeInteger(raw, fallback) {
@@ -345,9 +451,9 @@ function normalizeErrorText(error = {}) {
   ].join(" "));
 }
 
-function classifyRecommendRecovery(error = {}) {
-  const text = normalizeErrorText(error);
-  if (!text) return null;
+function classifyRecommendRecovery(error = {}) {
+  const text = normalizeErrorText(error);
+  if (!text) return null;
   if (/BOSS_LOGIN_REQUIRED/i.test(text)) return "login_required";
   if (/Could not find node with given id|No node with given id|Node is detached|Cannot find node|DETAIL_STALE_NODE|IMAGE_CAPTURE_STALE_NODE/i.test(text)) {
     return "transient_stale_dom";
@@ -358,8 +464,13 @@ function classifyRecommendRecovery(error = {}) {
   if (/(?:aborted|abort|timeout|timed out|fetch failed|socket|network|ECONNRESET|ETIMEDOUT|EAI_AGAIN)/i.test(text)) {
     return "transient_network_or_llm";
   }
-  return null;
-}
+  return null;
+}
+
+function isCancelShutdownError(error = {}) {
+  const text = normalizeErrorText(error);
+  return /socket hang up|ECONNREFUSED|ECONNRESET|WebSocket is not open|Target closed|Session closed|Connection closed|RUN_PROCESS_EXITED|DETACHED_WORKER|RUN_WORKER/i.test(text);
+}
 
 function buildConstrainedAgentRecovery(snapshot = {}, meta = {}, artifacts = null) {
   const error = snapshot?.error || snapshot?.result?.error || null;
@@ -574,15 +685,31 @@ function normalizeRunSnapshot(snapshot) {
   };
 }
 
-function mergePersistedControlRequest(normalized, existing) {
-  const control = {
-    ...(normalized?.control || {})
-  };
-  if (!normalized || TERMINAL_STATUSES.has(normalized.state)) return control;
-  const existingControl = plainRecord(existing?.control);
-  if (existingControl.cancel_requested === true) {
-    return {
-      ...control,
+function mergePersistedControlRequest(normalized, existing) {
+  const control = {
+    ...(normalized?.control || {})
+  };
+  const existingControl = plainRecord(existing?.control);
+  if (!normalized) return control;
+  if (TERMINAL_STATUSES.has(normalized.state)) {
+    if (
+      normalized.state === RUN_STATUS_FAILED
+      && existingControl.cancel_requested === true
+      && isCancelShutdownError(normalized.error || normalized.result?.error || "")
+    ) {
+      return {
+        ...control,
+        pause_requested: true,
+        pause_requested_at: existingControl.pause_requested_at || control.pause_requested_at || new Date().toISOString(),
+        pause_requested_by: existingControl.pause_requested_by || control.pause_requested_by || "cancel_recommend_pipeline_run",
+        cancel_requested: true
+      };
+    }
+    return control;
+  }
+  if (existingControl.cancel_requested === true) {
+    return {
+      ...control,
       pause_requested: true,
       pause_requested_at: existingControl.pause_requested_at || control.pause_requested_at || new Date().toISOString(),
       pause_requested_by: existingControl.pause_requested_by || control.pause_requested_by || "cancel_recommend_pipeline_run",
@@ -605,22 +732,81 @@ function mergePersistedControlRequest(normalized, existing) {
       pause_requested_by: null,
       cancel_requested: false
     };
-  }
-  return control;
-}
-
-function persistRecommendRunSnapshot(snapshot, {
-  persistActiveCheckpoint = false
-} = {}) {
-  const normalized = normalizeRunSnapshot(snapshot);
-  if (!normalized?.run_id) return normalized;
-  const artifacts = getRecommendRunArtifacts(normalized.run_id);
-  if (!artifacts) return normalized;
-  const existing = readJsonFile(artifacts.run_state_path);
-  normalized.control = mergePersistedControlRequest(normalized, existing);
-  if (persistActiveCheckpoint) {
-    persistRecommendCheckpointSnapshot(normalized);
-  }
+  }
+  return control;
+}
+
+function cancelErrorFromShutdown(shutdownError = null) {
+  return {
+    code: "PIPELINE_CANCELED",
+    message: "流水线已取消。",
+    retryable: true,
+    shutdown_error: shutdownError || undefined
+  };
+}
+
+function coerceCanceledTerminalSnapshot(normalized, existing) {
+  const existingControl = plainRecord(existing?.control);
+  const shutdownError = normalized?.error || normalized?.result?.error || null;
+  const shouldWrapCanceledShutdown = (
+    normalized
+    && (
+      (
+        normalized.state === RUN_STATUS_FAILED
+        && existingControl.cancel_requested === true
+      )
+      || normalized.state === RUN_STATUS_CANCELED
+    )
+    && isCancelShutdownError(shutdownError || "")
+  );
+  if (
+    !shouldWrapCanceledShutdown
+  ) {
+    return normalized;
+  }
+  const canceledError = cancelErrorFromShutdown(shutdownError);
+  return {
+    ...normalized,
+    state: RUN_STATUS_CANCELED,
+    status: RUN_STATUS_CANCELED,
+    last_message: "流水线已取消；取消收尾时浏览器连接已关闭。",
+    control: {
+      pause_requested: false,
+      pause_requested_at: null,
+      pause_requested_by: null,
+      cancel_requested: false
+    },
+    error: canceledError,
+    result: normalized.result ? {
+      ...normalized.result,
+      status: "CANCELED",
+      completion_reason: "canceled_by_user",
+      error: canceledError
+    } : {
+      status: "CANCELED",
+      completion_reason: "canceled_by_user",
+      error: canceledError,
+      run_id: normalized.run_id,
+      processed_count: normalized.progress?.processed || 0,
+      screened_count: normalized.progress?.screened || normalized.progress?.processed || 0,
+      passed_count: normalized.progress?.passed || 0
+    }
+  };
+}
+
+function persistRecommendRunSnapshot(snapshot, {
+  persistActiveCheckpoint = false
+} = {}) {
+  let normalized = normalizeRunSnapshot(snapshot);
+  if (!normalized?.run_id) return normalized;
+  const artifacts = getRecommendRunArtifacts(normalized.run_id);
+  if (!artifacts) return normalized;
+  const existing = readJsonFile(artifacts.run_state_path);
+  normalized.control = mergePersistedControlRequest(normalized, existing);
+  normalized = coerceCanceledTerminalSnapshot(normalized, existing);
+  if (persistActiveCheckpoint) {
+    persistRecommendCheckpointSnapshot(normalized);
+  }
   const payload = {
     run_id: normalized.run_id,
     mode: normalized.mode,
@@ -643,29 +829,59 @@ function persistRecommendRunSnapshot(snapshot, {
     summary: normalized.summary,
     artifacts: normalized.artifacts
   };
-  writeJsonAtomic(artifacts.run_state_path, payload);
-  return normalized;
-}
-
-function reconcilePersistedRecommendRunIfNeeded(persisted) {
-  if (!persisted || typeof persisted !== "object") return persisted;
-  const persistedState = normalizeText(persisted.state || persisted.status);
-  if (TERMINAL_STATUSES.has(persistedState)) return persisted;
+  writeJsonAtomic(artifacts.run_state_path, payload);
+  return normalized;
+}
+
+function patchPersistedRecommendRunControl(runId, controlPatch = {}, {
+  message = ""
+} = {}) {
+  const artifacts = getRecommendRunArtifacts(runId);
+  if (!artifacts) return null;
+  const current = readJsonFile(artifacts.run_state_path);
+  const state = normalizeText(current?.state || current?.status || "");
+  if (!current || TERMINAL_STATUSES.has(state)) return null;
+  const now = new Date().toISOString();
+  const patched = {
+    ...current,
+    updated_at: now,
+    heartbeat_at: current.heartbeat_at || now,
+    last_message: message || current.last_message || "",
+    control: {
+      ...(current.control || {}),
+      ...controlPatch
+    }
+  };
+  writeJsonAtomic(artifacts.run_state_path, patched);
+  return patched;
+}
+
+function reconcilePersistedRecommendRunIfNeeded(persisted) {
+  if (!persisted || typeof persisted !== "object") return persisted;
+  const persistedState = normalizeText(persisted.state || persisted.status);
+  if (TERMINAL_STATUSES.has(persistedState)) return persisted;
   if (isProcessAlive(persisted.pid)) return persisted;
 
-  const runId = normalizeRunId(persisted.run_id || persisted.runId);
-  const artifacts = getRecommendRunArtifacts(runId);
-  const checkpoint = artifacts?.checkpoint_path ? readJsonFile(artifacts.checkpoint_path) : null;
-  const now = new Date().toISOString();
-  const error = {
-    code: "RUN_PROCESS_EXITED",
-    message: `检测到推荐任务进程已退出（pid=${persisted.pid || "unknown"}），已自动标记为失败。`,
-    retryable: true
-  };
-  return persistRecommendRunSnapshot({
+  const runId = normalizeRunId(persisted.run_id || persisted.runId);
+  const artifacts = getRecommendRunArtifacts(runId);
+  const checkpoint = artifacts?.checkpoint_path ? readJsonFile(artifacts.checkpoint_path) : null;
+  const now = new Date().toISOString();
+  const cancelRequested = persisted.control?.cancel_requested === true;
+  const processExitedError = {
+    code: "RUN_PROCESS_EXITED",
+    message: `检测到推荐任务进程已退出（pid=${persisted.pid || "unknown"}）。`,
+    retryable: true
+  };
+  const error = cancelRequested
+    ? cancelErrorFromShutdown(processExitedError)
+    : {
+        ...processExitedError,
+        message: `检测到推荐任务进程已退出（pid=${persisted.pid || "unknown"}），已自动标记为失败。`
+      };
+  return persistRecommendRunSnapshot({
     runId,
     name: persisted.name || runId,
-    status: RUN_STATUS_FAILED,
+    status: cancelRequested ? RUN_STATUS_CANCELED : RUN_STATUS_FAILED,
     phase: persisted.stage || persisted.phase || "recommend:orphaned",
     progress: persisted.progress || {},
     context: persisted.context || {},
@@ -745,9 +961,17 @@ async function readRecommendJobOptionsFromSession(session) {
   };
 }
 
-export async function listRecommendJobsTool({ workspaceRoot = "", args = {} } = {}) {
-  const configResolution = resolveBossScreeningConfig(workspaceRoot);
-  const host = normalizeText(args.host) || DEFAULT_RECOMMEND_HOST;
+export async function listRecommendJobsTool({ workspaceRoot = "", args = {} } = {}) {
+  const routeGuard = guardRecommendRoute(args);
+  if (routeGuard) {
+    return {
+      ...routeGuard,
+      stage: "recommend_job_list",
+      message: "list_recommend_jobs is recommend-page only. For chat-only job lists, call list_boss_chat_jobs or prepare_boss_chat_run."
+    };
+  }
+  const configResolution = resolveBossScreeningConfig(workspaceRoot);
+  const host = normalizeText(args.host) || DEFAULT_RECOMMEND_HOST;
   const port = parsePositiveInteger(
     args.port,
     configResolution.ok ? configResolution.config.debugPort : DEFAULT_RECOMMEND_PORT
@@ -1367,8 +1591,10 @@ function getRunOptions(args, parsed, normalized, session, configResolution = nul
   };
 }
 
-function prepareRecommendPipelineStart(args = {}, { workspaceRoot = "" } = {}) {
-  const parsed = parseRecommendPipelineRequest(args);
+function prepareRecommendPipelineStart(args = {}, { workspaceRoot = "" } = {}) {
+  const routeGuard = guardRecommendRoute(args);
+  if (routeGuard) return { response: routeGuard };
+  const parsed = parseRecommendPipelineRequest(args);
   const gate = evaluateRecommendPipelineGate(parsed, args);
   if (gate) return { response: gate };
   const configResolution = resolveBossScreeningConfig(workspaceRoot);
@@ -1813,20 +2039,45 @@ export function cancelRecommendPipelineRunTool({ args = {} } = {}) {
     }, runId);
   } catch {
     const persisted = readRecommendRunState(runId);
-    if (persisted && TERMINAL_STATUSES.has(persisted.state)) {
-      return {
-        status: "CANCEL_IGNORED",
-        run: persisted,
-        message: "目标任务已结束，无需取消。",
+    if (persisted && TERMINAL_STATUSES.has(persisted.state)) {
+      return {
+        status: "CANCEL_IGNORED",
+        run: persisted,
+        message: "目标任务已结束，无需取消。",
         runtime_evaluate_used: false,
         method_summary: {},
         method_log: [],
-        chrome: null
-      };
-    }
-    return getRecommendPipelineRunTool({ args });
-  }
-}
+        chrome: null
+      };
+    }
+    const cancelMessage = "已收到取消请求，将由 detached worker 在下一个安全边界停止。";
+    const patched = patchPersistedRecommendRunControl(runId, {
+      pause_requested: true,
+      pause_requested_at: new Date().toISOString(),
+      pause_requested_by: "cancel_recommend_pipeline_run",
+      cancel_requested: true
+    }, {
+      message: cancelMessage
+    });
+    if (patched) {
+      return {
+        status: "CANCEL_REQUESTED",
+        run: patched,
+        message: cancelMessage,
+        persistence: {
+          source: "disk",
+          active_control_available: false,
+          detached_control_requested: true
+        },
+        runtime_evaluate_used: false,
+        method_summary: {},
+        method_log: [],
+        chrome: null
+      };
+    }
+    return getRecommendPipelineRunTool({ args });
+  }
+}
 
 export function getRecommendMcpHealthSnapshot(runId) {
   const meta = getRecommendRunMeta(runId);