@nowcrew/daemon 0.6.65 → 0.6.67

package/dist/storage-worker-status.js

@@ -1,5 +1,6 @@
 import { readFile, unlink } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join } from "node:path";
+import { Worker } from "node:worker_threads";
 import { z } from "zod";
 import { atomicPrivateWrite } from "./atomic-private-write.js";
 const WorkerFailureSchema = z.object({
@@ -17,6 +18,75 @@ const WorkerHeartbeatSchema = z.object({
     at: z.string().datetime({ offset: true }),
 }).strict();
 const TOKEN = /(?:\bsk_(?:machine|user|agent)_[A-Za-z0-9_-]{4,}\b|\bbearer\s+[^\s]+|(?:password|secret|token)\s*[:=]\s*[^\s]+)/giu;
+const HEARTBEAT_WORKER_KIND = "nowwork-storage-worker-heartbeat-v1";
+async function unlinkHeartbeat(path) {
+    await unlink(path).catch((error) => {
+        if (error.code !== "ENOENT")
+            throw error;
+    });
+}
+/**
+ * Keep the liveness writer in a worker with its own event loop. The source is
+ * intentionally plain JavaScript because `new Worker(new URL(import.meta.url))`
+ * cannot resolve the source tree's `.js` specifiers under tsx/Vitest; production
+ * builds and tests therefore exercise the same isolated execution boundary.
+ */
+const HEARTBEAT_WORKER_SOURCE = String.raw `
+const { parentPort, workerData } = require("node:worker_threads");
+const { mkdir, chmod, rename, rm, unlink, writeFile } = require("node:fs/promises");
+const { dirname } = require("node:path");
+const { randomUUID } = require("node:crypto");
+
+const atomicPrivateWrite = async (path, content) => {
+  const directory = dirname(path);
+  await mkdir(directory, { recursive: true, mode: 0o700 });
+  await chmod(directory, 0o700);
+  const temporary = path + "." + randomUUID() + ".tmp";
+  try {
+    await writeFile(temporary, content, { encoding: "utf8", mode: 0o600, flag: "wx" });
+    await rename(temporary, path);
+    await chmod(path, 0o600);
+  } finally {
+    await rm(temporary, { force: true });
+  }
+};
+const removeHeartbeat = async () => {
+  try { await unlink(workerData.path); } catch (error) {
+    if (error && error.code !== "ENOENT") throw error;
+  }
+};
+let pending = Promise.resolve();
+let stopping = false;
+let firstWrite = true;
+const write = () => {
+  const initial = firstWrite;
+  firstWrite = false;
+  pending = pending.catch(() => undefined).then(() => atomicPrivateWrite(workerData.path, JSON.stringify({
+    version: 1,
+    migrationId: workerData.migrationId,
+    pid: process.pid,
+    at: initial && workerData.initialAt ? workerData.initialAt : new Date().toISOString(),
+  }, null, 2) + "\n"));
+  return pending;
+};
+const report = (message) => { try { parentPort.postMessage(message); } catch {} };
+(async () => {
+  try { await write(); report({ type: "ready" }); }
+  catch (error) { report({ type: "error", message: error instanceof Error ? error.message : String(error) }); return; }
+  const timer = setInterval(() => {
+    if (!stopping) void write().catch((error) => report({ type: "error", message: error instanceof Error ? error.message : String(error) }));
+  }, workerData.intervalMs);
+  timer.unref?.();
+  parentPort.on("message", (message) => {
+    if (stopping || !message || message.type !== "stop") return;
+    stopping = true;
+    clearInterval(timer);
+    void pending.then(async () => { await removeHeartbeat(); report({ type: "stopped" }); }, async () => {
+      await removeHeartbeat().catch(() => undefined); report({ type: "stopped" });
+    });
+  });
+})();
+`;
 function identityFromHandoffPath(handoffPath) {
     if (!isAbsolute(handoffPath) || basename(handoffPath) !== "handoff.json") {
         throw new Error("storage worker handoff path is invalid");
@@ -43,28 +113,85 @@ export function storageWorkerHeartbeatPath(stateRoot, migrationId) {
 export async function startStorageWorkerHeartbeat(handoffPath, input = {}) {
     const identity = identityFromHandoffPath(handoffPath);
     const intervalMs = z.number().int().min(100).max(60_000).parse(input.intervalMs ?? 5_000);
-    const now = input.now ?? (() => new Date());
     const path = storageWorkerHeartbeatPath(identity.stateRoot, identity.migrationId);
-    let pending = Promise.resolve();
-    const write = () => {
-        pending = pending.catch(() => undefined).then(() => atomicPrivateWrite(path, `${JSON.stringify(WorkerHeartbeatSchema.parse({
-            version: 1,
+    // The worker owns heartbeat I/O so a synchronous CPU-heavy scan in the
+    // migration process cannot delay the monitor's 30-second freshness window.
+    const worker = new Worker(HEARTBEAT_WORKER_SOURCE, {
+        eval: true,
+        // `--input-type=module` is inherited by workers launched from an eval
+        // smoke test; strip it so the plain CommonJS worker source can use require.
+        execArgv: process.execArgv.filter((arg) => !arg.startsWith("--input-type=")),
+        workerData: {
+            kind: HEARTBEAT_WORKER_KIND,
+            path,
             migrationId: identity.migrationId,
-            pid: process.pid,
-            at: now().toISOString(),
-        }), null, 2)}\n`));
-        return pending;
+            intervalMs,
+            ...(input.now === undefined ? {} : { initialAt: input.now().toISOString() }),
+        },
+    });
+    worker.unref();
+    let startupSettled = false;
+    let heartbeatError = null;
+    let stopResolve = null;
+    const onWorkerMessage = (message) => {
+        if (message.type === "error") {
+            heartbeatError = new Error(`storage worker heartbeat failed: ${message.message}`);
+            if (!startupSettled)
+                startupReject?.(heartbeatError);
+        }
+        else if (message.type === "stopped") {
+            stopResolve?.();
+            stopResolve = null;
+        }
+    };
+    let startupReject = null;
+    worker.on("message", onWorkerMessage);
+    // Keep this listener for the entire worker lifetime. A heartbeat write may
+    // fail after startup; dropping the listener would turn that operational
+    // error into an unhandled Worker 'error' event and crash the parent.
+    const onWorkerError = (error) => {
+        heartbeatError = error;
+        if (!startupSettled)
+            startupReject?.(error);
     };
-    await write();
-    const timer = setInterval(() => { void write(); }, intervalMs);
-    timer.unref?.();
+    worker.on("error", onWorkerError);
+    await new Promise((resolvePromise, reject) => {
+        startupReject = reject;
+        const onReady = (message) => {
+            if (message.type !== "ready")
+                return;
+            startupSettled = true;
+            worker.off("message", onReady);
+            resolvePromise();
+        };
+        worker.on("message", onReady);
+    }).catch(async (error) => {
+        startupSettled = true;
+        await worker.terminate().catch(() => undefined);
+        worker.off("message", onWorkerMessage);
+        worker.off("error", onWorkerError);
+        await unlinkHeartbeat(path).catch(() => undefined);
+        throw error;
+    });
+    let stopped = false;
     return async () => {
-        clearInterval(timer);
-        await pending.catch(() => undefined);
-        await unlink(path).catch((error) => {
-            if (error.code !== "ENOENT")
-                throw error;
+        if (stopped)
+            return;
+        stopped = true;
+        await new Promise((resolvePromise) => {
+            const onExit = () => {
+                worker.off("exit", onExit);
+                stopResolve = null;
+                resolvePromise();
+            };
+            stopResolve = resolvePromise;
+            worker.once("exit", onExit);
+            worker.postMessage({ type: "stop" });
         });
+        await worker.terminate().catch(() => undefined);
+        worker.off("message", onWorkerMessage);
+        worker.off("error", onWorkerError);
+        await unlinkHeartbeat(path);
     };
 }
 export async function writeStorageWorkerFailureStatus(handoffPath, error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.6.65",
+  "version": "0.6.67",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",
@@ -16,14 +16,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "daemon": "pnpm --filter @nowcrew/cli build && tsx src/main.ts",
-    "build": "tsc -p tsconfig.json",
-    "codex-home:migrate": "tsx src/runtimes/codex-home-migration-cli.ts",
-    "prepublishOnly": "pnpm build && node ../scripts/daemon-release-artifact.mjs --strict-registry",
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit"
-  },
   "dependencies": {
     "@agentclientprotocol/sdk": "1.2.1",
     "@nowcrew/cli": "^0.4.13",
@@ -42,5 +34,12 @@
     "tsx": "^4.19.0",
     "typescript": "^5.6.0",
     "vitest": "^2.1.0"
+  },
+  "scripts": {
+    "daemon": "pnpm --filter @nowcrew/cli build && tsx src/main.ts",
+    "build": "tsc -p tsconfig.json",
+    "codex-home:migrate": "tsx src/runtimes/codex-home-migration-cli.ts",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
   }
-}
+}