@reconcrap/boss-recommend-mcp 2.0.37 → 2.0.38

package/package.json

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

package/src/domains/recommend/detail.js

@@ -131,21 +131,49 @@ export async function waitForRecommendDetail(client, {
   const started = Date.now();
   let lastState = null;
   while (Date.now() - started <= timeoutMs) {
-    const rootState = await getRecommendRoots(client);
-    const popup = await findVisibleDetailTarget(client, rootState.roots, DETAIL_POPUP_SELECTORS);
-    const resumeIframe = await findVisibleDetailTarget(client, rootState.roots, DETAIL_RESUME_IFRAME_SELECTORS);
-    lastState = {
-      iframe: rootState.iframe,
-      roots: rootState.roots,
-      popup,
-      resumeIframe
-    };
-    if (popup || resumeIframe) return lastState;
+    lastState = await readRecommendDetailState(client);
+    if (lastState?.popup || lastState?.resumeIframe) return lastState;
     await sleep(intervalMs);
   }
   return lastState;
 }
 
+async function readRecommendDetailState(client) {
+  const rootState = await getRecommendRoots(client);
+  const popup = await findVisibleDetailTarget(client, rootState.roots, DETAIL_POPUP_SELECTORS);
+  const resumeIframe = await findVisibleDetailTarget(client, rootState.roots, DETAIL_RESUME_IFRAME_SELECTORS);
+  return {
+    iframe: rootState.iframe,
+    roots: rootState.roots,
+    popup,
+    resumeIframe
+  };
+}
+
+export async function waitForRecommendDetailClosed(client, {
+  timeoutMs = 4000,
+  intervalMs = 250
+} = {}) {
+  const started = Date.now();
+  let lastState = null;
+  while (Date.now() - started <= timeoutMs) {
+    lastState = await readRecommendDetailState(client);
+    if (!lastState?.popup && !lastState?.resumeIframe) {
+      return {
+        closed: true,
+        elapsed_ms: Date.now() - started,
+        state: lastState
+      };
+    }
+    await sleep(intervalMs);
+  }
+  return {
+    closed: false,
+    elapsed_ms: Date.now() - started,
+    state: lastState
+  };
+}
+
 async function findVisibleDetailTarget(client, roots, selectors) {
   for (const root of roots) {
     if (!root?.nodeId) continue;
@@ -397,7 +425,9 @@ export async function openRecommendCardDetailWithFreshRetry(client, {
 }
 
 export async function closeRecommendDetail(client, {
-  attemptsLimit = 3
+  attemptsLimit = 4,
+  closeWaitMs = 5000,
+  escapeWaitMs = 3500
 } = {}) {
   const attempts = [];
   for (let index = 0; index < attemptsLimit; index += 1) {
@@ -433,15 +463,21 @@ export async function closeRecommendDetail(client, {
         await pressEscape(client);
         attempts.push({ mode: "Escape-after-close-selector-error" });
       }
-      await sleep(700);
     } else {
       await pressEscape(client);
       attempts.push({ mode: "Escape" });
-      await sleep(700);
     }
 
-    let state = await waitForRecommendDetail(client, { timeoutMs: 1000 });
-    if (!state?.popup && !state?.resumeIframe) {
+    const closedAfterClick = await waitForRecommendDetailClosed(client, {
+      timeoutMs: closeWaitMs,
+      intervalMs: 250
+    });
+    attempts.push({
+      mode: "wait-closed-after-primary",
+      closed: closedAfterClick.closed,
+      elapsed_ms: closedAfterClick.elapsed_ms
+    });
+    if (closedAfterClick.closed) {
       return {
         closed: true,
         attempts
@@ -450,10 +486,17 @@ export async function closeRecommendDetail(client, {
 
     await pressEscape(client);
     attempts.push({ mode: "Escape-fallback" });
-    await sleep(700);
 
-    state = await waitForRecommendDetail(client, { timeoutMs: 1000 });
-    if (!state?.popup && !state?.resumeIframe) {
+    const closedAfterEscape = await waitForRecommendDetailClosed(client, {
+      timeoutMs: escapeWaitMs,
+      intervalMs: 250
+    });
+    attempts.push({
+      mode: "wait-closed-after-escape",
+      closed: closedAfterEscape.closed,
+      elapsed_ms: closedAfterEscape.elapsed_ms
+    });
+    if (closedAfterEscape.closed) {
       return {
         closed: true,
         attempts

package/src/index.js

@@ -295,7 +295,9 @@ function getRunArtifacts(runId) {
   const normalizedRunId = normalizeText(runId);
   return {
     run_state_path: path.join(getRunsDir(), `${normalizedRunId}.json`),
-    checkpoint_path: path.join(getRunsDir(), `${normalizedRunId}.checkpoint.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`)
   };
 }
 
@@ -1554,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",
@@ -1993,7 +2122,14 @@ async function handleStartRunTool({ workspaceRoot, args }) {
   let worker;
   try {
     worker = launchDetachedRunWorker({ runId });
-    safeUpdateRunState(runId, { pid: worker.pid || process.pid });
+    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, {
@@ -2602,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
@@ -2609,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 {

package/src/recommend-mcp.js

@@ -165,6 +165,8 @@ function getRecommendRunArtifacts(runId) {
     output_dir: outputDir,
     run_state_path: path.join(runsDir, `${normalized}.json`),
     checkpoint_path: path.join(runsDir, `${normalized}.checkpoint.json`),
+    worker_stdout_path: path.join(runsDir, `${normalized}.worker.stdout.log`),
+    worker_stderr_path: path.join(runsDir, `${normalized}.worker.stderr.log`),
     output_csv: path.join(outputDir, `${normalized}.results.csv`),
     report_json: path.join(outputDir, `${normalized}.report.json`)
   };
@@ -557,6 +559,8 @@ function normalizeRunSnapshot(snapshot) {
       checkpoint_path: legacyResult?.checkpoint_path || meta.checkpointPath || artifacts?.checkpoint_path || null,
       pause_control_path: artifacts?.run_state_path || null,
       output_csv: legacyResult?.output_csv || null,
+      worker_stdout_path: artifacts?.worker_stdout_path || null,
+      worker_stderr_path: artifacts?.worker_stderr_path || null,
       resume_count: meta.resumeCount || 0,
       last_resumed_at: meta.lastResumedAt || null,
       last_paused_at: snapshot.status === RUN_STATUS_PAUSED ? snapshot.updatedAt : null

package/src/run-state.js

@@ -160,6 +160,8 @@ function defaultResume(resume = {}) {
     checkpoint_path: normalizeMessage(resume?.checkpoint_path || ""),
     pause_control_path: normalizeMessage(resume?.pause_control_path || ""),
     output_csv: normalizeMessage(resume?.output_csv || ""),
+    worker_stdout_path: normalizeMessage(resume?.worker_stdout_path || ""),
+    worker_stderr_path: normalizeMessage(resume?.worker_stderr_path || ""),
     follow_up_phase: normalizeMessage(resume?.follow_up_phase || ""),
     chat_run_id: normalizeMessage(resume?.chat_run_id || ""),
     chat_state: normalizeMessage(resume?.chat_state || ""),