@reconcrap/boss-recommend-mcp 2.0.36 → 2.0.38

package/src/index.js

@@ -46,6 +46,7 @@ import {
   getRecommendPipelineRunTool,
   listRecommendJobsTool,
   pauseRecommendPipelineRunTool,
+  prepareRecommendPipelineRunTool,
   resumeRecommendPipelineRunTool,
   startRecommendPipelineRunTool
 } from "./recommend-mcp.js";
@@ -116,6 +117,16 @@ const FRAMING_LINE = "line";
 const DETACHED_WORKER_FLAG = "--detached-worker";
 const DETACHED_WORKER_RUN_ID_FLAG = "--run-id";
 const DETACHED_WORKER_RESUME_FLAG = "--resume";
+const AGENT_RUNTIME_HINT_KEYS = [
+  "CODEX_CI",
+  "CODEX_THREAD_ID",
+  "CODEX_HOME",
+  "OPENCLAW_HOME",
+  "OPENCLAW",
+  "TRAE_CN",
+  "TRAE_HOME",
+  "TRAE_AGENT"
+];
 const featuredCalibrationUnsupportedCode = "FEATURED_CALIBRATION_UNSUPPORTED_CDP_ONLY";
 const recommendSelfHealApplyUnsupportedCode = "RECOMMEND_SELF_HEAL_APPLY_UNSUPPORTED_CDP_ONLY";
 const detachedLegacyPipelineUnsupportedCode = "DETACHED_LEGACY_PIPELINE_UNSUPPORTED_CDP_ONLY";
@@ -138,6 +149,31 @@ function normalizeText(value) {
   return String(value || "").replace(/\s+/g, " ").trim();
 }
 
+function clonePlain(value, fallback = null) {
+  try {
+    return value === undefined ? fallback : JSON.parse(JSON.stringify(value));
+  } catch {
+    return fallback;
+  }
+}
+
+function isLikelyAgentRuntime() {
+  for (const key of AGENT_RUNTIME_HINT_KEYS) {
+    if (normalizeText(process.env[key] || "")) return true;
+  }
+  const originHints = [
+    normalizeText(process.env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE || ""),
+    normalizeText(process.env.TERM_PROGRAM || "")
+  ].join(" ").toLowerCase();
+  return /codex|openclaw|trae/.test(originHints);
+}
+
+function shouldStartRecommendDetached() {
+  if (normalizeText(process.env.BOSS_RECOMMEND_CDP_INPROC || "") === "1") return false;
+  if (normalizeText(process.env.BOSS_RECOMMEND_CDP_DETACHED || "") === "1") return true;
+  return isLikelyAgentRuntime();
+}
+
 function isUnlimitedTargetCountToken(value) {
   const token = normalizeText(value).toLowerCase();
   if (!token) return false;
@@ -255,17 +291,67 @@ function getDefaultAcceptedMessage(args = {}) {
   return `异步流水线已启动（detached）。默认不自动轮询；如需进度请按需调用 get_recommend_pipeline_run（建议至少每 ${recommendedMinutes} 分钟查询一次）。`;
 }
 
-function getRunArtifacts(runId) {
-  const normalizedRunId = normalizeText(runId);
-  return {
-    run_state_path: path.join(getRunsDir(), `${normalizedRunId}.json`),
-    checkpoint_path: path.join(getRunsDir(), `${normalizedRunId}.checkpoint.json`)
-  };
-}
+function getRunArtifacts(runId) {
+  const normalizedRunId = normalizeText(runId);
+  return {
+    run_state_path: path.join(getRunsDir(), `${normalizedRunId}.json`),
+    checkpoint_path: path.join(getRunsDir(), `${normalizedRunId}.checkpoint.json`),
+    worker_stdout_path: path.join(getRunsDir(), `${normalizedRunId}.worker.stdout.log`),
+    worker_stderr_path: path.join(getRunsDir(), `${normalizedRunId}.worker.stderr.log`)
+  };
+}
+
+function writeRawRunState(runId, payload) {
+  const artifacts = getRunArtifacts(runId);
+  fs.mkdirSync(path.dirname(artifacts.run_state_path), { recursive: true });
+  const tempPath = `${artifacts.run_state_path}.tmp`;
+  fs.writeFileSync(tempPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+  fs.renameSync(tempPath, artifacts.run_state_path);
+  return payload;
+}
+
+function readRawRunState(runId) {
+  const artifacts = getRunArtifacts(runId);
+  try {
+    const parsed = JSON.parse(fs.readFileSync(artifacts.run_state_path, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function patchRawRunState(runId, patch) {
+  const current = readRawRunState(runId);
+  if (!current) return null;
+  const now = new Date().toISOString();
+  const next = {
+    ...current,
+    ...patch,
+    run_id: current.run_id || runId,
+    updated_at: now,
+    heartbeat_at: current.heartbeat_at || now,
+    control: {
+      ...(current.control || {}),
+      ...(patch.control || {})
+    },
+    resume: {
+      ...(current.resume || {}),
+      ...(patch.resume || {})
+    }
+  };
+  return writeRawRunState(runId, next);
+}
+
+function createDetachedRecommendRunId() {
+  const suffix = Math.random().toString(36).slice(2, 10);
+  return `mcp_recommend_${Date.now().toString(36)}_${suffix}`;
+}
 
 function buildRunContext(workspaceRoot, args = {}) {
+  const clonedArgs = clonePlain(args, {});
   return {
     workspace_root: path.resolve(workspaceRoot),
+    args: clonedArgs,
     instruction: String(args?.instruction || ""),
     confirmation: args?.confirmation && typeof args.confirmation === "object" ? args.confirmation : {},
     overrides: args?.overrides && typeof args.overrides === "object" ? args.overrides : {},
@@ -273,25 +359,40 @@ function buildRunContext(workspaceRoot, args = {}) {
   };
 }
 
-function resolveRunContext(snapshot) {
-  const workspaceRoot = normalizeText(snapshot?.context?.workspace_root || "");
-  const instruction = typeof snapshot?.context?.instruction === "string"
-    ? snapshot.context.instruction
-    : "";
-  if (!workspaceRoot || !instruction.trim()) return null;
-  return {
-    workspaceRoot,
-    args: {
+function resolveRunContext(snapshot) {
+  const workspaceRoot = normalizeText(snapshot?.context?.workspace_root || "");
+  const storedArgs = snapshot?.context?.args && typeof snapshot.context.args === "object" && !Array.isArray(snapshot.context.args)
+    ? clonePlain(snapshot.context.args, {})
+    : null;
+  const instruction = typeof storedArgs?.instruction === "string"
+    ? storedArgs.instruction
+    : typeof snapshot?.context?.instruction === "string"
+      ? snapshot.context.instruction
+      : "";
+  const confirmation = storedArgs?.confirmation && typeof storedArgs.confirmation === "object" && !Array.isArray(storedArgs.confirmation)
+    ? storedArgs.confirmation
+    : snapshot?.context?.confirmation && typeof snapshot.context.confirmation === "object"
+      ? snapshot.context.confirmation
+      : {};
+  const overrides = storedArgs?.overrides && typeof storedArgs.overrides === "object" && !Array.isArray(storedArgs.overrides)
+    ? storedArgs.overrides
+    : snapshot?.context?.overrides && typeof snapshot.context.overrides === "object"
+      ? snapshot.context.overrides
+      : {};
+  const followUp = storedArgs && Object.prototype.hasOwnProperty.call(storedArgs, "follow_up")
+    ? storedArgs.follow_up
+    : snapshot?.context?.follow_up && typeof snapshot.context.follow_up === "object"
+      ? snapshot.context.follow_up
+      : null;
+  if (!workspaceRoot || !instruction.trim()) return null;
+  return {
+    workspaceRoot,
+    args: {
+      ...(storedArgs || {}),
       instruction,
-      confirmation: snapshot?.context?.confirmation && typeof snapshot.context.confirmation === "object"
-        ? snapshot.context.confirmation
-        : {},
-      overrides: snapshot?.context?.overrides && typeof snapshot.context.overrides === "object"
-        ? snapshot.context.overrides
-        : {},
-      follow_up: snapshot?.context?.follow_up && typeof snapshot.context.follow_up === "object"
-        ? snapshot.context.follow_up
-        : null
+      confirmation,
+      overrides,
+      follow_up: followUp
     }
   };
 }
@@ -1455,18 +1556,145 @@ function launchDetachedRunWorker({ runId, resumeRun = false }) {
   if (resumeRun) {
     childArgs.push(DETACHED_WORKER_RESUME_FLAG);
   }
-  const child = spawnProcessImpl(process.execPath, childArgs, {
-    detached: true,
-    stdio: "ignore",
-    windowsHide: true,
-    env: process.env
-  });
+  const artifacts = getRunArtifacts(runId);
+  fs.mkdirSync(path.dirname(artifacts.worker_stdout_path), { recursive: true });
+  const stdoutFd = fs.openSync(artifacts.worker_stdout_path, "a");
+  const stderrFd = fs.openSync(artifacts.worker_stderr_path, "a");
+  let child;
+  try {
+    child = spawnProcessImpl(process.execPath, childArgs, {
+      detached: true,
+      stdio: ["ignore", stdoutFd, stderrFd],
+      windowsHide: true,
+      env: process.env
+    });
+  } finally {
+    fs.closeSync(stdoutFd);
+    fs.closeSync(stderrFd);
+  }
+  child.workerLogPaths = {
+    stdoutPath: artifacts.worker_stdout_path,
+    stderrPath: artifacts.worker_stderr_path
+  };
   if (typeof child?.unref === "function") {
     child.unref();
   }
   return child;
 }
 
+function errorToDetachedWorkerPayload(error, fallbackMessage = "detached recommend worker exited unexpectedly") {
+  const message = normalizeText(error?.message || error || fallbackMessage) || fallbackMessage;
+  const payload = {
+    code: normalizeText(error?.code || "") || "RUN_WORKER_UNHANDLED_EXCEPTION",
+    message,
+    retryable: true
+  };
+  if (normalizeText(error?.name || "")) {
+    payload.name = normalizeText(error.name);
+  }
+  if (normalizeText(error?.stack || "")) {
+    payload.stack = String(error.stack).slice(0, 8000);
+  }
+  return payload;
+}
+
+function markDetachedWorkerFailed(runId, error, options = {}) {
+  const normalizedRunId = normalizeText(runId);
+  if (!normalizedRunId) return null;
+  const existing = readRawRunState(normalizedRunId) || {};
+  const existingState = normalizeText(existing.state || existing.status);
+  if (TERMINAL_RUN_STATES.has(existingState)) return existing;
+
+  const now = new Date().toISOString();
+  const artifacts = getRunArtifacts(normalizedRunId);
+  const errorPayload = {
+    ...errorToDetachedWorkerPayload(error, options.message),
+    ...(options.code ? { code: options.code } : {})
+  };
+  const previousResult = existing.result && typeof existing.result === "object" ? existing.result : {};
+  const result = {
+    ...previousResult,
+    status: "FAILED",
+    completion_reason: "failed",
+    error: errorPayload,
+    worker_stdout_path: artifacts.worker_stdout_path,
+    worker_stderr_path: artifacts.worker_stderr_path
+  };
+
+  return writeRawRunState(normalizedRunId, {
+    ...existing,
+    run_id: normalizedRunId,
+    mode: existing.mode || RUN_MODE_ASYNC,
+    state: RUN_STATE_FAILED,
+    status: RUN_STATE_FAILED,
+    stage: existing.stage || RUN_STAGE_PREFLIGHT,
+    started_at: existing.started_at || now,
+    updated_at: now,
+    heartbeat_at: now,
+    completed_at: now,
+    pid: Number.isInteger(existing.pid) && existing.pid > 0 ? existing.pid : process.pid,
+    progress: existing.progress || {},
+    last_message: errorPayload.message,
+    context: existing.context || {},
+    control: existing.control || {
+      pause_requested: false,
+      pause_requested_at: null,
+      pause_requested_by: null,
+      cancel_requested: false
+    },
+    resume: {
+      ...(existing.resume && typeof existing.resume === "object" ? existing.resume : {}),
+      checkpoint_path: existing.resume?.checkpoint_path || artifacts.checkpoint_path,
+      pause_control_path: existing.resume?.pause_control_path || artifacts.run_state_path,
+      worker_stdout_path: artifacts.worker_stdout_path,
+      worker_stderr_path: artifacts.worker_stderr_path
+    },
+    artifacts: {
+      ...(existing.artifacts && typeof existing.artifacts === "object" ? existing.artifacts : {}),
+      worker_stdout_path: artifacts.worker_stdout_path,
+      worker_stderr_path: artifacts.worker_stderr_path
+    },
+    error: errorPayload,
+    result
+  });
+}
+
+function installDetachedWorkerFailureHandlers(runId) {
+  let handled = false;
+  const failOnce = (error, options = {}) => {
+    if (handled) return;
+    handled = true;
+    try {
+      markDetachedWorkerFailed(runId, error, options);
+    } catch (markError) {
+      console.error("[boss-recommend-mcp] failed to persist detached worker failure", markError);
+    }
+  };
+
+  process.on("uncaughtException", (error) => {
+    console.error("[boss-recommend-mcp] detached worker uncaught exception", error);
+    failOnce(error, { code: "RUN_WORKER_UNCAUGHT_EXCEPTION" });
+    process.exit(1);
+  });
+
+  process.on("unhandledRejection", (reason) => {
+    console.error("[boss-recommend-mcp] detached worker unhandled rejection", reason);
+    const error = reason instanceof Error ? reason : new Error(normalizeText(reason) || "Unhandled promise rejection");
+    failOnce(error, { code: "RUN_WORKER_UNHANDLED_REJECTION" });
+    process.exit(1);
+  });
+
+  for (const signal of ["SIGTERM", "SIGINT", "SIGHUP"]) {
+    process.on(signal, () => {
+      const error = new Error(`detached recommend worker received ${signal}`);
+      console.error("[boss-recommend-mcp] detached worker received signal", signal);
+      failOnce(error, { code: "RUN_WORKER_SIGNAL" });
+      const signalExitCodes = { SIGHUP: 129, SIGINT: 130, SIGTERM: 143 };
+      process.exit(signalExitCodes[signal] || 1);
+    });
+  }
+}
+
 function buildWorkerLaunchFailedPayload(message) {
   return {
     status: "FAILED",
@@ -1827,35 +2055,191 @@ async function runDetachedWorker({ runId, resumeRun = false, workerPid = process
       : "detached worker 已启动，准备执行。"
   });
 
-  await executeTrackedPipeline({
-    runId: normalizedRunId,
-    mode: RUN_MODE_ASYNC,
+  const started = await startRecommendPipelineRunTool({
     workspaceRoot: executionContext.workspaceRoot,
     args: executionContext.args,
-    signal: new AbortController().signal,
-    resumeRun
+    runId: normalizedRunId
   });
+  if (started?.status !== "ACCEPTED") {
+    const failedPayload = started?.error || {
+      code: "RUN_WORKER_START_FAILED",
+      message: started?.status || "detached recommend worker failed to start",
+      retryable: true
+    };
+    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 };
+  }
+
+  while (true) {
+    const payload = getRecommendPipelineRunTool({ args: { run_id: normalizedRunId } });
+    const state = normalizeText(payload?.run?.state || payload?.run?.status || "");
+    if (TERMINAL_RUN_STATES.has(state)) break;
+    const persisted = readRawRunState(normalizedRunId);
+    if (persisted?.control?.cancel_requested === true) {
+      cancelRecommendPipelineRunTool({ args: { run_id: normalizedRunId } });
+    } else if (persisted?.control?.pause_requested === true && state === RUN_STATE_RUNNING) {
+      pauseRecommendPipelineRunTool({ args: { run_id: normalizedRunId } });
+    } else if (persisted?.control?.pause_requested === false && state === RUN_STATE_PAUSED) {
+      resumeRecommendPipelineRunTool({ args: { run_id: normalizedRunId } });
+    }
+    await sleepMs(1000);
+  }
   return { ok: true };
 }
-
+
 async function handleStartRunTool({ workspaceRoot, args }) {
-  return startRecommendPipelineRunTool({ workspaceRoot, args });
+  if (!shouldStartRecommendDetached()) {
+    return startRecommendPipelineRunTool({ workspaceRoot, args });
+  }
+
+  const prepared = prepareRecommendPipelineRunTool({ workspaceRoot, args });
+  if (prepared.status !== "READY") return prepared;
+
+  cleanupExpiredRuns();
+  const runId = createDetachedRecommendRunId();
+  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
+      }
+    };
+  }
+
+  let worker;
+  try {
+    worker = launchDetachedRunWorker({ runId });
+    const workerLogPaths = worker.workerLogPaths || {};
+    safeUpdateRunState(runId, {
+      pid: worker.pid || process.pid,
+      resume: {
+        worker_stdout_path: workerLogPaths.stdoutPath || getRunArtifacts(runId).worker_stdout_path,
+        worker_stderr_path: workerLogPaths.stderrPath || getRunArtifacts(runId).worker_stderr_path
+      }
+    });
+  } catch (error) {
+    const failed = buildWorkerLaunchFailedPayload(error?.message || "无法启动 detached recommend worker。");
+    safeUpdateRunState(runId, {
+      state: RUN_STATE_FAILED,
+      stage: RUN_STAGE_PREFLIGHT,
+      last_message: failed.error.message,
+      error: failed.error,
+      result: failed
+    });
+    return failed;
+  }
+
+  const run = readRunState(runId);
+  return {
+    status: "ACCEPTED",
+    run_id: runId,
+    state: "queued",
+    run,
+    poll_after_sec: getRecommendedPollAfterSec(args),
+    message: getDefaultAcceptedMessage(args),
+    post_action: prepared.post_action,
+    target_count_semantics: prepared.target_count_semantics,
+    review: prepared.review
+  };
 }
 
 function handleGetRunTool(args) {
   return getRecommendPipelineRunTool({ args });
 }
 
+function patchDetachedRecommendControl(args, controlPatch, {
+  status,
+  message,
+  lastMessage
+} = {}) {
+  const runId = normalizeText(args?.run_id || args?.runId || "");
+  if (!runId) return null;
+  const current = readRawRunState(runId);
+  const state = normalizeText(current?.state || current?.status || "");
+  if (!current || TERMINAL_RUN_STATES.has(state)) return null;
+  const patched = patchRawRunState(runId, {
+    last_message: lastMessage || message || current.last_message || "",
+    control: controlPatch
+  });
+  if (!patched) return null;
+  return {
+    status,
+    run: patched,
+    message,
+    persistence: {
+      source: "disk",
+      active_control_available: false,
+      detached_control_requested: true
+    },
+    runtime_evaluate_used: false,
+    method_summary: {},
+    method_log: [],
+    chrome: null
+  };
+}
+
 function handleCancelRunTool(args) {
-  return cancelRecommendPipelineRunTool({ args });
+  const result = cancelRecommendPipelineRunTool({ args });
+  if (result?.status === "RUN_STATUS" && result?.persistence?.active_control_available === false) {
+    return patchDetachedRecommendControl(args, {
+      pause_requested: true,
+      pause_requested_at: new Date().toISOString(),
+      pause_requested_by: TOOL_CANCEL_RUN,
+      cancel_requested: true
+    }, {
+      status: "CANCEL_REQUESTED",
+      message: "已收到取消请求，将由 detached worker 在下一个安全边界停止。",
+      lastMessage: "已收到取消请求，将由 detached worker 在下一个安全边界停止。"
+    }) || result;
+  }
+  return result;
 }
 
 function handlePauseRunTool(args) {
-  return pauseRecommendPipelineRunTool({ args });
+  const result = pauseRecommendPipelineRunTool({ args });
+  if (result?.status === "RUN_STATUS" && result?.persistence?.active_control_available === false) {
+    return patchDetachedRecommendControl(args, {
+      pause_requested: true,
+      pause_requested_at: new Date().toISOString(),
+      pause_requested_by: TOOL_PAUSE_RUN,
+      cancel_requested: false
+    }, {
+      status: "PAUSE_REQUESTED",
+      message: "暂停请求已写入 detached run 控制文件。",
+      lastMessage: "暂停请求已写入 detached run 控制文件。"
+    }) || result;
+  }
+  return result;
 }
 
 function handleResumeRunTool(args) {
-  return resumeRecommendPipelineRunTool({ args });
+  const result = resumeRecommendPipelineRunTool({ args });
+  if (result?.status === "FAILED" && result?.error?.code === "RUN_NOT_ACTIVE") {
+    return patchDetachedRecommendControl(args, {
+      pause_requested: false,
+      pause_requested_at: null,
+      pause_requested_by: null,
+      cancel_requested: false
+    }, {
+      status: "RESUME_REQUESTED",
+      message: "恢复请求已写入 detached run 控制文件。",
+      lastMessage: "恢复请求已写入 detached run 控制文件。"
+    }) || result;
+  }
+  return result;
 }
 
 function handleGetFeaturedCalibrationStatusTool(workspaceRoot) {
@@ -2354,6 +2738,7 @@ 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) {
+    installDetachedWorkerFailureHandlers(detachedWorkerOptions.runId);
     runDetachedWorker({
       runId: detachedWorkerOptions.runId,
       resumeRun: detachedWorkerOptions.resumeRun
@@ -2361,7 +2746,9 @@ if (process.argv[1] && path.resolve(process.argv[1]) === thisFilePath) {
       if (!result?.ok) {
         process.exitCode = 1;
       }
-    }).catch(() => {
+    }).catch((error) => {
+      console.error("[boss-recommend-mcp] detached worker failed", error);
+      markDetachedWorkerFailed(detachedWorkerOptions.runId, error);
       process.exitCode = 1;
     });
   } else {