@reconcrap/boss-recommend-mcp 1.1.12 → 1.2.1

package/src/index.js

@@ -1,8 +1,9 @@
 import fs from "node:fs";
 import path from "node:path";
-import { createRequire } from "node:module";
-import process from "node:process";
-import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
 import { runRecommendPipeline } from "./pipeline.js";
 import {
   RUN_MODE_ASYNC,
@@ -34,13 +35,16 @@ const TOOL_PAUSE_RUN = "pause_recommend_pipeline_run";
 const TOOL_RESUME_RUN = "resume_recommend_pipeline_run";
 
 const SERVER_NAME = "boss-recommend-mcp";
-const FRAMING_UNKNOWN = "unknown";
-const FRAMING_HEADER = "header";
-const FRAMING_LINE = "line";
-
-const activeAsyncRuns = new Map();
-let runPipelineImpl = runRecommendPipeline;
-const TERMINAL_RUN_STATES = new Set([RUN_STATE_COMPLETED, RUN_STATE_FAILED, RUN_STATE_CANCELED]);
+const FRAMING_UNKNOWN = "unknown";
+const FRAMING_HEADER = "header";
+const FRAMING_LINE = "line";
+const DETACHED_WORKER_FLAG = "--detached-worker";
+const DETACHED_WORKER_RUN_ID_FLAG = "--run-id";
+const DETACHED_WORKER_RESUME_FLAG = "--resume";
+
+let runPipelineImpl = runRecommendPipeline;
+let spawnProcessImpl = spawn;
+const TERMINAL_RUN_STATES = new Set([RUN_STATE_COMPLETED, RUN_STATE_FAILED, RUN_STATE_CANCELED]);
 
 function normalizeText(value) {
   return String(value || "").replace(/\s+/g, " ").trim();
@@ -151,7 +155,7 @@ function createRunInputSchema() {
           page_confirmed: { type: "boolean" },
           page_value: {
             type: "string",
-            enum: ["recommend", "featured"]
+            enum: ["recommend", "featured", "latest"]
           },
           filters_confirmed: { type: "boolean" },
           school_tag_confirmed: { type: "boolean" },
@@ -227,7 +231,7 @@ function createRunInputSchema() {
         properties: {
           page_scope: {
             type: "string",
-            enum: ["recommend", "featured"]
+            enum: ["recommend", "featured", "latest"]
           },
           school_tag: {
             oneOf: [
@@ -470,9 +474,6 @@ function reconcileOrphanRunIfNeeded(runId, snapshot) {
   if (snapshot.state === RUN_STATE_PAUSED) {
     return snapshot;
   }
-  if (activeAsyncRuns.has(runId)) {
-    return snapshot;
-  }
   if (isProcessAlive(snapshot.pid)) {
     return snapshot;
   }
@@ -511,6 +512,71 @@ function reconcileOrphanRunIfNeeded(runId, snapshot) {
   });
   return recovered || readRunState(runId) || snapshot;
 }
+
+function parseDetachedWorkerOptions(argv = process.argv.slice(2)) {
+  if (!Array.isArray(argv) || !argv.includes(DETACHED_WORKER_FLAG)) {
+    return null;
+  }
+  const runIdFlagIndex = argv.indexOf(DETACHED_WORKER_RUN_ID_FLAG);
+  const runId = runIdFlagIndex >= 0 ? normalizeText(argv[runIdFlagIndex + 1]) : "";
+  return {
+    runId,
+    resumeRun: argv.includes(DETACHED_WORKER_RESUME_FLAG)
+  };
+}
+
+function launchDetachedRunWorker({ runId, resumeRun = false }) {
+  const childArgs = [thisFilePath, DETACHED_WORKER_FLAG, DETACHED_WORKER_RUN_ID_FLAG, String(runId)];
+  if (resumeRun) {
+    childArgs.push(DETACHED_WORKER_RESUME_FLAG);
+  }
+  const child = spawnProcessImpl(process.execPath, childArgs, {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true,
+    env: process.env
+  });
+  if (typeof child?.unref === "function") {
+    child.unref();
+  }
+  return child;
+}
+
+function buildWorkerLaunchFailedPayload(message) {
+  return {
+    status: "FAILED",
+    error: {
+      code: "RUN_WORKER_LAUNCH_FAILED",
+      message,
+      retryable: true
+    }
+  };
+}
+
+function finalizeCanceledRun(runId, snapshot) {
+  const canceledResult = {
+    status: "FAILED",
+    error: {
+      code: "PIPELINE_CANCELED",
+      message: "流水线已取消。",
+      retryable: true
+    },
+    partial_result: snapshot?.result?.partial_result || snapshot?.result?.result || null
+  };
+  return safeUpdateRunState(runId, {
+    state: RUN_STATE_CANCELED,
+    stage: snapshot?.stage || RUN_STAGE_PREFLIGHT,
+    last_message: "流水线已取消。",
+    control: {
+      pause_requested: false,
+      pause_requested_at: null,
+      pause_requested_by: null,
+      cancel_requested: false
+    },
+    error: canceledResult.error,
+    result: canceledResult
+  }) || readRunState(runId) || snapshot;
+}
 
 function createRuntimeCallbacks(runId, heartbeatIntervalMs) {
   let lastStage = RUN_STAGE_PREFLIGHT;
@@ -735,14 +801,14 @@ async function executeTrackedPipeline({
   };
 }
 
-function initializeRunStateOrThrow(runId, mode, workspaceRoot, args) {
-  const artifacts = getRunArtifacts(runId);
-  const snapshot = createRunStateSnapshot({
-    runId,
-    mode,
-    state: "queued",
-    stage: RUN_STAGE_PREFLIGHT,
-    pid: process.pid,
+function initializeRunStateOrThrow(runId, mode, workspaceRoot, args, pid = process.pid) {
+  const artifacts = getRunArtifacts(runId);
+  const snapshot = createRunStateSnapshot({
+    runId,
+    mode,
+    state: "queued",
+    stage: RUN_STAGE_PREFLIGHT,
+    pid,
     lastMessage: "流水线任务已创建，等待执行。",
     context: buildRunContext(workspaceRoot, args),
     control: {
@@ -759,28 +825,59 @@ function initializeRunStateOrThrow(runId, mode, workspaceRoot, args) {
       last_resumed_at: null,
       last_paused_at: null
     }
-  });
-  return writeRunState(snapshot);
-}
-
-function launchAsyncRun({ runId, mode, workspaceRoot, args, resumeRun = false }) {
-  const abortController = new AbortController();
-  const promise = executeTrackedPipeline({
-    runId,
-    mode,
-    workspaceRoot,
-    args,
-    signal: abortController.signal,
-    resumeRun
-  }).finally(() => {
-    activeAsyncRuns.delete(runId);
-  });
-  activeAsyncRuns.set(runId, {
-    abortController,
-    promise
-  });
-  return { abortController, promise };
-}
+  });
+  return writeRunState(snapshot);
+}
+
+async function runDetachedWorker({ runId, resumeRun = false, workerPid = process.pid }) {
+  const normalizedRunId = normalizeText(runId);
+  if (!normalizedRunId) {
+    return { ok: false, error: "run_id is required" };
+  }
+  const snapshot = readRunState(normalizedRunId);
+  if (!snapshot) {
+    return { ok: false, error: `run_id=${normalizedRunId} not found` };
+  }
+
+  const executionContext = resolveRunContext(snapshot);
+  if (!executionContext) {
+    const failedPayload = {
+      code: "RUN_CONTEXT_MISSING",
+      message: "run 缺少可恢复的执行上下文，无法继续。",
+      retryable: false
+    };
+    safeUpdateRunState(normalizedRunId, {
+      state: RUN_STATE_FAILED,
+      stage: snapshot.stage || RUN_STAGE_PREFLIGHT,
+      last_message: failedPayload.message,
+      error: failedPayload,
+      result: {
+        status: "FAILED",
+        error: failedPayload
+      }
+    });
+    return { ok: false, error: failedPayload.message };
+  }
+
+  safeUpdateRunState(normalizedRunId, {
+    pid: Number.isInteger(workerPid) && workerPid > 0 ? workerPid : process.pid,
+    mode: RUN_MODE_ASYNC,
+    state: "queued",
+    last_message: resumeRun
+      ? "detached worker 已启动，准备恢复执行。"
+      : "detached worker 已启动，准备执行。"
+  });
+
+  await executeTrackedPipeline({
+    runId: normalizedRunId,
+    mode: RUN_MODE_ASYNC,
+    workspaceRoot: executionContext.workspaceRoot,
+    args: executionContext.args,
+    signal: new AbortController().signal,
+    resumeRun
+  });
+  return { ok: true };
+}
 
 async function handleStartRunTool({ workspaceRoot, args }) {
   const precheckArgs = buildAsyncPrecheckArgs(args);
@@ -814,36 +911,57 @@ async function handleStartRunTool({ workspaceRoot, args }) {
     return precheckResult;
   }
 
-  cleanupExpiredRuns();
-  const runId = createRunId();
-  try {
-    initializeRunStateOrThrow(runId, RUN_MODE_ASYNC, workspaceRoot, args);
-  } catch (error) {
-    return {
-      status: "FAILED",
+  cleanupExpiredRuns();
+  const runId = createRunId();
+  try {
+    initializeRunStateOrThrow(runId, RUN_MODE_ASYNC, workspaceRoot, args, process.pid);
+  } catch (error) {
+    return {
+      status: "FAILED",
       error: {
         code: "RUN_STATE_IO_ERROR",
         message: `无法写入运行状态目录：${error.message || "unknown"}`,
         retryable: false
-      }
-    };
-  }
-
-  launchAsyncRun({
-    runId,
-    mode: RUN_MODE_ASYNC,
-    workspaceRoot,
-    args
-  });
-
-  return {
-    status: "ACCEPTED",
-    run_id: runId,
-    state: "queued",
-    poll_after_sec: getDefaultPollAfterSec(),
-    message: "异步流水线已启动。默认不自动轮询；如需进度请按需调用 get_recommend_pipeline_run。"
-  };
-}
+      }
+    };
+  }
+
+  let worker;
+  try {
+    worker = launchDetachedRunWorker({
+      runId,
+      resumeRun: false
+    });
+  } catch (error) {
+    const failedMessage = `无法启动 detached 运行进程：${error?.message || "unknown"}`;
+    safeUpdateRunState(runId, {
+      state: RUN_STATE_FAILED,
+      stage: RUN_STAGE_PREFLIGHT,
+      last_message: failedMessage,
+      error: {
+        code: "RUN_WORKER_LAUNCH_FAILED",
+        message: failedMessage,
+        retryable: true
+      },
+      result: buildWorkerLaunchFailedPayload(failedMessage)
+    });
+    return buildWorkerLaunchFailedPayload(failedMessage);
+  }
+
+  safeUpdateRunState(runId, {
+    pid: worker?.pid,
+    state: "queued",
+    last_message: "异步流水线已启动（detached）。"
+  });
+
+  return {
+    status: "ACCEPTED",
+    run_id: runId,
+    state: "queued",
+    poll_after_sec: getDefaultPollAfterSec(),
+    message: "异步流水线已启动（detached）。默认不自动轮询；如需进度请按需调用 get_recommend_pipeline_run。"
+  };
+}
 
 function handleGetRunTool(args) {
   cleanupExpiredRuns();
@@ -876,7 +994,7 @@ function handleGetRunTool(args) {
   };
 }
 
-function handleCancelRunTool(args) {
+function handleCancelRunTool(args) {
   const runId = normalizeText(args?.run_id);
   if (!runId) {
     return {
@@ -888,8 +1006,8 @@ function handleCancelRunTool(args) {
       }
     };
   }
-  const snapshot = readRunState(runId);
-  if (!snapshot) {
+  const snapshot = readRunState(runId);
+  if (!snapshot) {
     return {
       status: "FAILED",
       error: {
@@ -898,93 +1016,43 @@ function handleCancelRunTool(args) {
         retryable: false
       }
     };
-  }
-
-  if (TERMINAL_RUN_STATES.has(snapshot.state)) {
-    return {
-      status: "CANCEL_IGNORED",
-      run: snapshot,
-      message: "目标任务已结束，无需取消。"
-    };
-  }
-
-  if (snapshot.state === RUN_STATE_PAUSED) {
-    const canceledResult = {
-      status: "FAILED",
-      error: {
-        code: "PIPELINE_CANCELED",
-        message: "流水线已取消。",
-        retryable: true
-      },
-      partial_result: snapshot.result?.partial_result || snapshot.result?.result || null
-    };
-    const canceledRun = safeUpdateRunState(runId, {
-      state: RUN_STATE_CANCELED,
-      stage: snapshot.stage || RUN_STAGE_PREFLIGHT,
-      last_message: "流水线已取消。",
-      control: {
-        pause_requested: false,
-        pause_requested_at: null,
-        pause_requested_by: null,
-        cancel_requested: false
-      },
-      error: canceledResult.error,
-      result: canceledResult
-    }) || readRunState(runId) || snapshot;
-    return {
-      status: "CANCEL_REQUESTED",
-      run: canceledRun
-    };
-  }
-
-  const activeRun = activeAsyncRuns.get(runId);
-  if (!activeRun) {
-    const canceledResult = {
-      status: "FAILED",
-      error: {
-        code: "PIPELINE_CANCELED",
-        message: "流水线已取消。",
-        retryable: true
-      },
-      partial_result: snapshot.result?.partial_result || snapshot.result?.result || null
-    };
-    const canceledRun = safeUpdateRunState(runId, {
-      state: RUN_STATE_CANCELED,
-      stage: snapshot.stage || RUN_STAGE_PREFLIGHT,
-      last_message: "流水线已取消。",
-      control: {
-        pause_requested: false,
-        pause_requested_at: null,
-        pause_requested_by: null,
-        cancel_requested: false
-      },
-      error: canceledResult.error,
-      result: canceledResult
-    }) || readRunState(runId) || snapshot;
-    return {
-      status: "CANCEL_REQUESTED",
-      run: canceledRun
-    };
-  }
-  safeUpdateRunState(runId, {
-    stage: snapshot.stage || RUN_STAGE_PREFLIGHT,
-    last_message: "已收到取消请求，将在当前候选人处理完成后安全停止并落盘 CSV。",
-    control: {
+  }
+  const reconciled = reconcileOrphanRunIfNeeded(runId, snapshot) || snapshot;
+
+  if (TERMINAL_RUN_STATES.has(reconciled.state)) {
+    return {
+      status: "CANCEL_IGNORED",
+      run: reconciled,
+      message: "目标任务已结束，无需取消。"
+    };
+  }
+
+  if (reconciled.state === RUN_STATE_PAUSED || !isProcessAlive(reconciled.pid)) {
+    const canceledRun = finalizeCanceledRun(runId, reconciled);
+    return {
+      status: "CANCEL_REQUESTED",
+      run: canceledRun
+    };
+  }
+  safeUpdateRunState(runId, {
+    stage: reconciled.stage || RUN_STAGE_PREFLIGHT,
+    last_message: "已收到取消请求，将在当前候选人处理完成后安全停止并落盘 CSV。",
+    control: {
       pause_requested: true,
       pause_requested_at: new Date().toISOString(),
       pause_requested_by: TOOL_CANCEL_RUN,
       cancel_requested: true
     }
-  });
-
-  const latest = readRunState(runId) || snapshot;
-  return {
-    status: "CANCEL_REQUESTED",
+  });
+
+  const latest = readRunState(runId) || reconciled;
+  return {
+    status: "CANCEL_REQUESTED",
     run: latest
   };
 }
 
-function handlePauseRunTool(args) {
+function handlePauseRunTool(args) {
   const runId = normalizeText(args?.run_id);
   if (!runId) {
     return {
@@ -996,8 +1064,8 @@ function handlePauseRunTool(args) {
       }
     };
   }
-  const snapshot = readRunState(runId);
-  if (!snapshot) {
+  const snapshot = readRunState(runId);
+  if (!snapshot) {
     return {
       status: "FAILED",
       error: {
@@ -1006,22 +1074,23 @@ function handlePauseRunTool(args) {
         retryable: false
       }
     };
-  }
-
-  if (TERMINAL_RUN_STATES.has(snapshot.state)) {
-    return {
-      status: "PAUSE_IGNORED",
-      run: snapshot,
-      message: "目标任务已结束，无需暂停。"
-    };
-  }
-  if (snapshot.state === RUN_STATE_PAUSED) {
-    return {
-      status: "PAUSE_IGNORED",
-      run: snapshot,
-      message: "目标任务已经处于 paused 状态。"
-    };
-  }
+  }
+  const reconciled = reconcileOrphanRunIfNeeded(runId, snapshot) || snapshot;
+
+  if (TERMINAL_RUN_STATES.has(reconciled.state)) {
+    return {
+      status: "PAUSE_IGNORED",
+      run: reconciled,
+      message: "目标任务已结束，无需暂停。"
+    };
+  }
+  if (reconciled.state === RUN_STATE_PAUSED) {
+    return {
+      status: "PAUSE_IGNORED",
+      run: reconciled,
+      message: "目标任务已经处于 paused 状态。"
+    };
+  }
 
   const requestedRun = safeUpdateRunState(runId, {
     control: {
@@ -1031,15 +1100,15 @@ function handlePauseRunTool(args) {
       cancel_requested: false
     },
     last_message: "已收到暂停请求，将在当前候选人处理完成后暂停。"
-  }) || readRunState(runId) || snapshot;
-  return {
+  }) || readRunState(runId) || reconciled;
+  return {
     status: "PAUSE_REQUESTED",
     run: requestedRun,
     message: "暂停请求已接收，将在当前候选人处理完成后进入 paused。"
   };
 }
 
-function handleResumeRunTool(args) {
+function handleResumeRunTool(args) {
   const runId = normalizeText(args?.run_id);
   if (!runId) {
     return {
@@ -1051,8 +1120,8 @@ function handleResumeRunTool(args) {
       }
     };
   }
-  const snapshot = readRunState(runId);
-  if (!snapshot) {
+  const snapshot = readRunState(runId);
+  if (!snapshot) {
     return {
       status: "FAILED",
       error: {
@@ -1061,38 +1130,32 @@ function handleResumeRunTool(args) {
         retryable: false
       }
     };
-  }
-  if (TERMINAL_RUN_STATES.has(snapshot.state)) {
-    return {
-      status: "FAILED",
+  }
+  const reconciled = reconcileOrphanRunIfNeeded(runId, snapshot) || snapshot;
+  if (TERMINAL_RUN_STATES.has(reconciled.state)) {
+    return {
+      status: "FAILED",
       error: {
         code: "RUN_ALREADY_TERMINATED",
         message: "目标任务已结束，无法继续。",
         retryable: false
       }
     };
-  }
-  if (snapshot.state !== RUN_STATE_PAUSED) {
-    return {
-      status: "FAILED",
+  }
+  if (reconciled.state !== RUN_STATE_PAUSED) {
+    return {
+      status: "FAILED",
       error: {
         code: "RUN_NOT_PAUSED",
         message: "仅 paused 状态的 run 才能继续。",
         retryable: true
       },
-      run: snapshot
-    };
-  }
-  if (activeAsyncRuns.has(runId)) {
-    return {
-      status: "RESUME_IGNORED",
-      run: snapshot,
-      message: "该 run 当前已在执行，无需继续。"
-    };
-  }
-
-  const executionContext = resolveRunContext(snapshot);
-  if (!executionContext) {
+      run: reconciled
+    };
+  }
+
+  const executionContext = resolveRunContext(reconciled);
+  if (!executionContext) {
     return {
       status: "FAILED",
       error: {
@@ -1119,23 +1182,43 @@ function handleResumeRunTool(args) {
       resume_count: Number.isInteger(current?.resume?.resume_count) ? current.resume.resume_count + 1 : 1,
       last_resumed_at: new Date().toISOString()
     }
-  })) || readRunState(runId) || snapshot;
-
-  launchAsyncRun({
-    runId,
-    mode: RUN_MODE_ASYNC,
-    workspaceRoot: executionContext.workspaceRoot,
-    args: executionContext.args,
-    resumeRun: true
-  });
-
-  return {
-    status: "RESUME_REQUESTED",
-    run: updated,
-    poll_after_sec: getDefaultPollAfterSec(),
-    message: "已恢复 Recommend 流水线。默认不自动轮询；如需进度请按需调用 get_recommend_pipeline_run。"
-  };
-}
+  })) || readRunState(runId) || reconciled;
+
+  let worker;
+  try {
+    worker = launchDetachedRunWorker({
+      runId,
+      resumeRun: true
+    });
+  } catch (error) {
+    const failedMessage = `无法启动 detached 恢复进程：${error?.message || "unknown"}`;
+    safeUpdateRunState(runId, {
+      state: RUN_STATE_FAILED,
+      stage: reconciled.stage || RUN_STAGE_PREFLIGHT,
+      last_message: failedMessage,
+      error: {
+        code: "RUN_WORKER_LAUNCH_FAILED",
+        message: failedMessage,
+        retryable: true
+      },
+      result: buildWorkerLaunchFailedPayload(failedMessage)
+    });
+    return buildWorkerLaunchFailedPayload(failedMessage);
+  }
+
+  const started = safeUpdateRunState(runId, {
+    pid: worker?.pid,
+    state: "queued",
+    last_message: "已恢复 Recommend 流水线（detached）。"
+  }) || readRunState(runId) || updated;
+
+  return {
+    status: "RESUME_REQUESTED",
+    run: started,
+    poll_after_sec: getDefaultPollAfterSec(),
+    message: "已恢复 Recommend 流水线（detached）。默认不自动轮询；如需进度请按需调用 get_recommend_pipeline_run。"
+  };
+}
 
 async function handleRequest(message, workspaceRoot) {
   if (!message || message.jsonrpc !== "2.0") {
@@ -1329,15 +1412,34 @@ export function startServer() {
   });
 }
 
-export const __testables = {
-  handleRequest,
-  activeAsyncRuns,
-  setRunPipelineImplForTests(nextImpl) {
-    runPipelineImpl = typeof nextImpl === "function" ? nextImpl : runRecommendPipeline;
-  }
-};
-
-const thisFilePath = fileURLToPath(import.meta.url);
-if (process.argv[1] && path.resolve(process.argv[1]) === thisFilePath) {
-  startServer();
-}
+export const __testables = {
+  handleRequest,
+  runDetachedWorkerForTests(options = {}) {
+    return runDetachedWorker(options);
+  },
+  setSpawnProcessImplForTests(nextImpl) {
+    spawnProcessImpl = typeof nextImpl === "function" ? nextImpl : spawn;
+  },
+  setRunPipelineImplForTests(nextImpl) {
+    runPipelineImpl = typeof nextImpl === "function" ? nextImpl : runRecommendPipeline;
+  }
+};
+
+const thisFilePath = fileURLToPath(import.meta.url);
+if (process.argv[1] && path.resolve(process.argv[1]) === thisFilePath) {
+  const detachedWorkerOptions = parseDetachedWorkerOptions(process.argv.slice(2));
+  if (detachedWorkerOptions) {
+    runDetachedWorker({
+      runId: detachedWorkerOptions.runId,
+      resumeRun: detachedWorkerOptions.resumeRun
+    }).then((result) => {
+      if (!result?.ok) {
+        process.exitCode = 1;
+      }
+    }).catch(() => {
+      process.exitCode = 1;
+    });
+  } else {
+    startServer();
+  }
+}