@reconcrap/boss-recommend-mcp 1.1.7 → 1.1.8

package/package.json

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

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,
@@ -33,18 +34,39 @@ const TOOL_CANCEL_RUN = "cancel_recommend_pipeline_run";
 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 SERVER_NAME = "boss-recommend-mcp";
+const FRAMING_UNKNOWN = "unknown";
+const FRAMING_HEADER = "header";
+const FRAMING_LINE = "line";
+const ASYNC_WORKER_FLAG = "--async-worker";
+const thisFilePath = fileURLToPath(import.meta.url);
 
 const activeAsyncRuns = new Map();
 let runPipelineImpl = runRecommendPipeline;
 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();
-}
+function normalizeText(value) {
+  return String(value || "").replace(/\s+/g, " ").trim();
+}
+
+function encodeWorkerPayload(payload) {
+  return Buffer.from(JSON.stringify(payload), "utf8").toString("base64");
+}
+
+function decodeWorkerPayload(encoded) {
+  try {
+    const raw = Buffer.from(String(encoded || ""), "base64").toString("utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function shouldUseInProcessAsyncRunner() {
+  return normalizeText(process.env.BOSS_RECOMMEND_ASYNC_INPROC || "") === "1";
+}
 
 function parsePositiveInteger(raw, fallback) {
   const value = Number.parseInt(String(raw || ""), 10);
@@ -726,14 +748,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: {
@@ -754,8 +776,8 @@ function initializeRunStateOrThrow(runId, mode, workspaceRoot, args) {
   return writeRunState(snapshot);
 }
 
-function launchAsyncRun({ runId, mode, workspaceRoot, args, resumeRun = false }) {
-  const abortController = new AbortController();
+function launchAsyncRun({ runId, mode, workspaceRoot, args, resumeRun = false }) {
+  const abortController = new AbortController();
   const promise = executeTrackedPipeline({
     runId,
     mode,
@@ -769,9 +791,80 @@ function launchAsyncRun({ runId, mode, workspaceRoot, args, resumeRun = false })
   activeAsyncRuns.set(runId, {
     abortController,
     promise
-  });
-  return { abortController, promise };
-}
+  });
+  return { abortController, promise };
+}
+
+function launchDetachedAsyncRun({ runId, mode, workspaceRoot, args, resumeRun = false }) {
+  const payload = encodeWorkerPayload({
+    runId,
+    mode,
+    workspaceRoot,
+    args,
+    resumeRun
+  });
+  const child = spawn(
+    process.execPath,
+    [thisFilePath, ASYNC_WORKER_FLAG, payload],
+    {
+      detached: true,
+      stdio: "ignore",
+      cwd: path.resolve(workspaceRoot),
+      env: process.env
+    }
+  );
+  child.unref();
+  return child;
+}
+
+async function runAsyncWorkerMain(encodedPayload) {
+  const payload = decodeWorkerPayload(encodedPayload);
+  if (!payload) return;
+  const runId = normalizeText(payload.runId);
+  const mode = normalizeText(payload.mode) || RUN_MODE_ASYNC;
+  const workspaceRoot = normalizeText(payload.workspaceRoot);
+  const args = payload.args && typeof payload.args === "object" ? payload.args : {};
+  const resumeRun = payload.resumeRun === true;
+  if (!runId || !workspaceRoot || typeof args.instruction !== "string") return;
+
+  const existing = readRunState(runId);
+  if (!existing) {
+    try {
+      initializeRunStateOrThrow(runId, mode, workspaceRoot, args, process.pid);
+    } catch {
+      return;
+    }
+  } else {
+    safeUpdateRunState(runId, { mode, pid: process.pid });
+  }
+
+  try {
+    await executeTrackedPipeline({
+      runId,
+      mode,
+      workspaceRoot,
+      args,
+      signal: null,
+      resumeRun
+    });
+  } catch (error) {
+    const failedResult = {
+      status: "FAILED",
+      error: {
+        code: "UNEXPECTED_ERROR",
+        message: error?.message || "Unexpected worker error",
+        retryable: true
+      }
+    };
+    safeUpdateRunState(runId, {
+      state: RUN_STATE_FAILED,
+      stage: RUN_STAGE_PREFLIGHT,
+      last_message: failedResult.error.message,
+      error: failedResult.error,
+      result: failedResult
+    });
+  }
+}
 
 async function handleStartRunTool({ workspaceRoot, args }) {
   const precheckArgs = buildAsyncPrecheckArgs(args);
@@ -805,29 +898,58 @@ 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 {
+      }
+    };
+  }
+
+  try {
+    if (shouldUseInProcessAsyncRunner()) {
+      launchAsyncRun({
+        runId,
+        mode: RUN_MODE_ASYNC,
+        workspaceRoot,
+        args
+      });
+    } else {
+      const worker = launchDetachedAsyncRun({
+        runId,
+        mode: RUN_MODE_ASYNC,
+        workspaceRoot,
+        args
+      });
+      safeUpdateRunState(runId, { pid: worker.pid || process.pid });
+    }
+  } catch (error) {
+    const failed = {
+      status: "FAILED",
+      error: {
+        code: "RUN_START_FAILED",
+        message: error?.message || "无法启动异步 worker 进程。",
+        retryable: true
+      }
+    };
+    safeUpdateRunState(runId, {
+      state: RUN_STATE_FAILED,
+      stage: RUN_STAGE_PREFLIGHT,
+      last_message: failed.error.message,
+      error: failed.error,
+      result: failed
+    });
+    return failed;
+  }
+
+  return {
     status: "ACCEPTED",
     run_id: runId,
     state: "queued",
@@ -928,8 +1050,9 @@ function handleCancelRunTool(args) {
     };
   }
 
-  const activeRun = activeAsyncRuns.get(runId);
-  if (!activeRun) {
+  const activeRun = activeAsyncRuns.get(runId);
+  const hasLiveDetachedWorker = isProcessAlive(snapshot.pid);
+  if (!activeRun && !hasLiveDetachedWorker) {
     const canceledResult = {
       status: "FAILED",
       error: {
@@ -1112,15 +1235,45 @@ function handleResumeRunTool(args) {
     }
   })) || readRunState(runId) || snapshot;
 
-  launchAsyncRun({
-    runId,
-    mode: RUN_MODE_ASYNC,
-    workspaceRoot: executionContext.workspaceRoot,
-    args: executionContext.args,
-    resumeRun: true
-  });
-
-  return {
+  try {
+    if (shouldUseInProcessAsyncRunner()) {
+      launchAsyncRun({
+        runId,
+        mode: RUN_MODE_ASYNC,
+        workspaceRoot: executionContext.workspaceRoot,
+        args: executionContext.args,
+        resumeRun: true
+      });
+    } else {
+      const worker = launchDetachedAsyncRun({
+        runId,
+        mode: RUN_MODE_ASYNC,
+        workspaceRoot: executionContext.workspaceRoot,
+        args: executionContext.args,
+        resumeRun: true
+      });
+      safeUpdateRunState(runId, { pid: worker.pid || updated.pid || process.pid });
+    }
+  } catch (error) {
+    const failed = {
+      status: "FAILED",
+      error: {
+        code: "RUN_RESUME_FAILED",
+        message: error?.message || "无法启动继续执行 worker 进程。",
+        retryable: true
+      }
+    };
+    safeUpdateRunState(runId, {
+      state: RUN_STATE_FAILED,
+      stage: updated.stage || RUN_STAGE_PREFLIGHT,
+      last_message: failed.error.message,
+      error: failed.error,
+      result: failed
+    });
+    return failed;
+  }
+
+  return {
     status: "RESUME_REQUESTED",
     run: updated,
     poll_after_sec: getDefaultPollAfterSec(),
@@ -1320,15 +1473,21 @@ 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,
+  activeAsyncRuns,
+  runAsyncWorkerMain,
+  setRunPipelineImplForTests(nextImpl) {
+    runPipelineImpl = typeof nextImpl === "function" ? nextImpl : runRecommendPipeline;
+  }
+};
+
+if (process.argv[1] && path.resolve(process.argv[1]) === thisFilePath) {
+  const workerFlagIndex = process.argv.indexOf(ASYNC_WORKER_FLAG);
+  if (workerFlagIndex !== -1) {
+    const payloadArg = process.argv[workerFlagIndex + 1] || "";
+    runAsyncWorkerMain(payloadArg).catch(() => {});
+  } else {
+    startServer();
+  }
+}