@nowcrew/daemon 0.6.67 → 0.6.69

package/dist/storage-copy.js

@@ -70,7 +70,8 @@ async function exists(path) {
         throw error;
     }
 }
-async function copyVerifiedFile(source, target, stagingWorkspaceRoot, entry, replaceExisting, afterSourceLstat, afterTargetParentOpen) {
+async function copyVerifiedFile(source, target, stagingWorkspaceRoot, entry, replaceExisting, afterSourceLstat, afterTargetParentOpen, assertHealthy) {
+    assertHealthy?.();
     if (entry.sha256 === undefined)
         throw new Error(`manifest file digest is missing: ${source}`);
     const sourceHandle = await openAnchoredFile(source, constants.O_RDONLY).catch((error) => {
@@ -102,10 +103,12 @@ async function copyVerifiedFile(source, target, stagingWorkspaceRoot, entry, rep
         const sourceStream = sourceHandle.createReadStream({ autoClose: false });
         try {
             for await (const rawChunk of sourceStream) {
+                assertHealthy?.();
                 const chunk = Buffer.from(rawChunk);
                 digest.update(chunk);
                 await targetHandle.write(chunk, 0, chunk.length, null);
             }
+            assertHealthy?.();
             await targetHandle.sync();
             await targetHandle.chmod(Number.parseInt(entry.mode, 8));
         }
@@ -174,7 +177,8 @@ async function mapInBatches(items, concurrency, operation) {
     }
     return results;
 }
-async function transformFile(source, target, stagingWorkspaceRoot, entry, replaceExisting, afterSourceLstat, afterTargetParentOpen) {
+async function transformFile(source, target, stagingWorkspaceRoot, entry, replaceExisting, afterSourceLstat, afterTargetParentOpen, assertHealthy) {
+    assertHealthy?.();
     if (entry.sha256 === undefined)
         throw new Error(`manifest file digest is missing: ${source}`);
     const sourceHandle = await openAnchoredFile(source, constants.O_RDONLY).catch((error) => {
@@ -227,6 +231,7 @@ async function transformFile(source, target, stagingWorkspaceRoot, entry, replac
     });
     const targetOpened = await targetHandle.stat();
     try {
+        assertHealthy?.();
         await targetHandle.writeFile(output, "utf8");
         await targetHandle.sync();
         await targetHandle.chmod(Number.parseInt(entry.targetMode ?? "0600", 8));
@@ -248,6 +253,7 @@ async function transformFile(source, target, stagingWorkspaceRoot, entry, replac
     return Buffer.byteLength(output);
 }
 async function materializeChunkedManifest(input, injected) {
+    injected.assertHealthy?.();
     if (await exists(input.stagingWorkspaceRoot)) {
         if (!(await lstat(input.stagingWorkspaceRoot)).isDirectory()
             || (!input.mergeIntoExisting
@@ -273,13 +279,15 @@ async function materializeChunkedManifest(input, injected) {
             return;
         const batch = pending;
         pending = [];
+        injected.assertHealthy?.();
         const results = await mapInBatches(batch, FILE_OPERATION_CONCURRENCY, async (entry) => {
+            injected.assertHealthy?.();
             const target = containedPath(input.stagingWorkspaceRoot, entry.logicalDestination);
             const source = sourcePath({ sourceRoots: input.sourceRoots, entry });
             if (entry.disposition === "transform") {
-                return { transformed: true, bytesWritten: await transformFile(source, target, input.stagingWorkspaceRoot, entry, input.mergeIntoExisting === true, injected.afterSourceLstat, injected.afterTargetParentOpen) };
+                return { transformed: true, bytesWritten: await transformFile(source, target, input.stagingWorkspaceRoot, entry, input.mergeIntoExisting === true, injected.afterSourceLstat, injected.afterTargetParentOpen, injected.assertHealthy) };
             }
-            await copyVerifiedFile(source, target, input.stagingWorkspaceRoot, entry, input.mergeIntoExisting === true, injected.afterSourceLstat, injected.afterTargetParentOpen);
+            await copyVerifiedFile(source, target, input.stagingWorkspaceRoot, entry, input.mergeIntoExisting === true, injected.afterSourceLstat, injected.afterTargetParentOpen, injected.assertHealthy);
             return { transformed: false, bytesWritten: entry.sizeBytes };
         });
         for (const result of results) {
@@ -291,6 +299,7 @@ async function materializeChunkedManifest(input, injected) {
         }
     };
     for await (const entry of iterateManifestEntries(input.manifest)) {
+        injected.assertHealthy?.();
         if (entry.disposition === "skip" || entry.logicalDestination === null)
             continue;
         const target = containedPath(input.stagingWorkspaceRoot, entry.logicalDestination);
@@ -309,6 +318,7 @@ async function materializeChunkedManifest(input, injected) {
     }
     await flushFiles();
     for await (const entry of iterateManifestEntries(input.manifest)) {
+        injected.assertHealthy?.();
         if (entry.disposition === "skip" || entry.logicalDestination === null || entry.type !== "symlink")
             continue;
         if (entry.link?.classification !== "internal" || !entry.link.portable || entry.link.relativeTarget === undefined)
@@ -322,6 +332,7 @@ async function materializeChunkedManifest(input, injected) {
         copiedSymlinks += 1;
     }
     for await (const entry of iterateManifestEntries(input.manifest)) {
+        injected.assertHealthy?.();
         if (entry.disposition === "skip" || entry.logicalDestination === null || entry.type !== "directory")
             continue;
         chmodAnchoredDirectory(input.stagingWorkspaceRoot, containedPath(input.stagingWorkspaceRoot, entry.logicalDestination), Number.parseInt(entry.mode, 8));
@@ -329,6 +340,7 @@ async function materializeChunkedManifest(input, injected) {
     return Object.freeze({ copiedFiles, transformedFiles, copiedSymlinks, createdDirectories, bytesWritten });
 }
 export async function materializeStorageManifest(input, injected = {}) {
+    injected.assertHealthy?.();
     if (input.manifest.chunkStore !== undefined)
         return materializeChunkedManifest(input, injected);
     const manifest = input.manifest;
@@ -375,28 +387,32 @@ export async function materializeStorageManifest(input, injected = {}) {
         throw new Error(`unsupported copied manifest entry: ${entry.sourcePath}`);
     }
     const fileResults = await mapInBatches(files, FILE_OPERATION_CONCURRENCY, async (entry) => {
+        injected.assertHealthy?.();
         const target = containedPath(input.stagingWorkspaceRoot, entry.logicalDestination);
         const source = sourcePath({ sourceRoots: input.sourceRoots, entry });
         if (entry.disposition === "transform") {
             return {
                 transformed: true,
-                bytesWritten: await transformFile(source, target, input.stagingWorkspaceRoot, entry, input.mergeIntoExisting === true, injected.afterSourceLstat, injected.afterTargetParentOpen),
+                bytesWritten: await transformFile(source, target, input.stagingWorkspaceRoot, entry, input.mergeIntoExisting === true, injected.afterSourceLstat, injected.afterTargetParentOpen, injected.assertHealthy),
             };
         }
-        await copyVerifiedFile(source, target, input.stagingWorkspaceRoot, entry, input.mergeIntoExisting === true, injected.afterSourceLstat, injected.afterTargetParentOpen);
+        await copyVerifiedFile(source, target, input.stagingWorkspaceRoot, entry, input.mergeIntoExisting === true, injected.afterSourceLstat, injected.afterTargetParentOpen, injected.assertHealthy);
         return { transformed: false, bytesWritten: entry.sizeBytes };
     });
     for (const { entry, target } of symlinks) {
+        injected.assertHealthy?.();
         await createSafeParent(input.stagingWorkspaceRoot, target);
         if (input.mergeIntoExisting)
             removeReplaceableTarget(input.stagingWorkspaceRoot, target, entry.logicalDestination ?? entry.sourcePath);
         createAnchoredSymlink(input.stagingWorkspaceRoot, target, entry.link.relativeTarget);
     }
     for (const { entry, target } of symlinks) {
+        injected.assertHealthy?.();
         await assertRealpathWithin(input.stagingWorkspaceRoot, target, `staged symlink escapes workspace: ${entry.sourcePath}`);
     }
     directoryModes.sort((left, right) => right.path.length - left.path.length);
     for (const directory of directoryModes) {
+        injected.assertHealthy?.();
         chmodAnchoredDirectory(input.stagingWorkspaceRoot, directory.path, directory.mode);
     }
     const transformedFiles = fileResults.filter((result) => result.transformed).length;
@@ -454,6 +470,7 @@ async function pruneStaleChunkPaths(root, destinations) {
     }
 }
 export async function reconcileStorageManifest(input) {
+    input.assertHealthy?.();
     if (input.previousManifest.migrationId !== input.manifest.migrationId
         || input.previousManifest.workspaceId !== input.manifest.workspaceId
         || input.previousManifest.targetWorkspaceRoot !== input.manifest.targetWorkspaceRoot) {
@@ -467,13 +484,14 @@ export async function reconcileStorageManifest(input) {
         // Build a bounded destination index, prune stale staging paths, then replay
         // the authenticated final snapshot without retaining manifest entries.
         const destinations = await collectChunkDestinations(input.manifest);
+        input.assertHealthy?.();
         await pruneStaleChunkPaths(input.stagingWorkspaceRoot, destinations);
         return materializeChunkedManifest({
             manifest: input.manifest,
             sourceRoots: input.sourceRoots,
             stagingWorkspaceRoot: input.stagingWorkspaceRoot,
             mergeIntoExisting: true,
-        }, {});
+        }, input.assertHealthy === undefined ? {} : { assertHealthy: input.assertHealthy });
     }
     const previous = copiedEntries(input.previousManifest);
     const next = copiedEntries(input.manifest);
@@ -482,6 +500,7 @@ export async function reconcileStorageManifest(input) {
         return current === undefined || current.type !== entry.type;
     }).sort(([left], [right]) => right.length - left.length);
     for (const [logical] of removals) {
+        input.assertHealthy?.();
         const target = containedPath(input.stagingWorkspaceRoot, logical);
         try {
             removeAnchoredEntry(input.stagingWorkspaceRoot, target);
@@ -501,7 +520,7 @@ export async function reconcileStorageManifest(input) {
         sourceRoots: input.sourceRoots,
         stagingWorkspaceRoot: input.stagingWorkspaceRoot,
         mergeIntoExisting: true,
-    });
+    }, input.assertHealthy === undefined ? {} : { assertHealthy: input.assertHealthy });
 }
 async function inspectStorageFile(root, path, afterTargetLstat) {
     const handle = await openAnchoredFile(path, constants.O_RDONLY).catch((error) => {

package/dist/storage-migration-controller.js

@@ -296,7 +296,9 @@ export async function runStorageMigration(input, dependencies) {
     let targetTouched = false;
     let failureCode = "storage_migration_failed";
     try {
+        input.assertHealthy?.();
         await transition("preflight_passed");
+        input.assertHealthy?.();
         await transition("backing_up");
         receipt = await backupArtifacts(input, receipt).catch((error) => {
             failureCode = "backup_failed";
@@ -308,7 +310,7 @@ export async function runStorageMigration(input, dependencies) {
             manifest: input.doctor.manifest,
             sourceRoots: input.sourceRoots,
             stagingWorkspaceRoot: input.stagingWorkspaceRoot,
-        }).catch((error) => {
+        }, input.assertHealthy === undefined ? {} : { assertHealthy: input.assertHealthy }).catch((error) => {
             failureCode = "initial_sync_failed";
             throw error;
         });
@@ -353,6 +355,7 @@ export async function runStorageMigration(input, dependencies) {
             manifest: finalDoctor.manifest,
             sourceRoots: input.sourceRoots,
             stagingWorkspaceRoot: input.stagingWorkspaceRoot,
+            ...(input.assertHealthy === undefined ? {} : { assertHealthy: input.assertHealthy }),
         }).catch((error) => {
             failureCode = "final_sync_failed";
             throw error;

package/dist/storage-worker-command.js

@@ -12,8 +12,18 @@ export async function runStorageWorkerCommand(args, execute = executeStorageMigr
         throw new Error("Invalid storage migration worker command");
     }
     const stopHeartbeat = await startHeartbeat(path);
+    const assertHeartbeatHealthy = stopHeartbeat.assertHealthy;
     try {
-        await (command === "storage-migration-recover" ? recover(path) : execute(path));
+        if (command === "storage-migration-recover") {
+            await (assertHeartbeatHealthy === undefined
+                ? recover(path)
+                : recover(path, { assertHeartbeatHealthy }));
+        }
+        else {
+            await (assertHeartbeatHealthy === undefined
+                ? execute(path)
+                : execute(path, { assertHeartbeatHealthy }));
+        }
     }
     catch (error) {
         await writeFailure(path, error).catch(() => undefined);

package/dist/storage-worker-executor.js

@@ -7,6 +7,7 @@ import { readManagedServiceRegistry, normalizeManagedServiceRecord, serviceDescr
 import { readInstallations, writeInstallations, } from "./storage-config.js";
 import { runStorageDoctor } from "./storage-doctor.js";
 import { readStorageMigrationReceipt, recoverStorageMigration, runStorageMigration, StorageMigrationFailure, } from "./storage-migration-controller.js";
+import { materializeStorageManifest, publishStagedStorage, reconcileStorageManifest, verifyStagedStorage, } from "./storage-copy.js";
 import { readStorageWorkerHandoff } from "./storage-worker-handoff.js";
 import { readStorageWorkerOperation } from "./storage-worker-operation.js";
 import { storageIdFingerprint } from "./storage-identity.js";
@@ -306,6 +307,7 @@ export async function executeStorageMigrationWorker(handoffPath, injected = {})
     };
     const handoff = await readStorageWorkerHandoff(handoffPath);
     const operation = await readStorageWorkerOperation(handoff.operationPath, handoff.operationSha256);
+    const assertHeartbeatHealthy = dependencies.assertHeartbeatHealthy ?? (() => undefined);
     if (handoff.migrationId !== operation.migrationId || handoff.profile !== operation.profile) {
         throw new StorageMigrationFailure("worker_handoff_mismatch", "worker handoff does not match operation identity");
     }
@@ -323,10 +325,42 @@ export async function executeStorageMigrationWorker(handoffPath, injected = {})
             migrationId: operation.migrationId,
         }, { ...lifecycle, now: dependencies.now });
     }
+    assertHeartbeatHealthy();
     await lifecycle.preflight();
+    assertHeartbeatHealthy();
     const doctor = await dependencies.runDoctor(workerDoctorInput(operation));
+    assertHeartbeatHealthy();
     validateFreshDoctor(operation, doctor);
-    return dependencies.runMigration({
+    const guardedMaterialize = async (input, hooks = {}) => materializeStorageManifest(input, {
+        ...hooks,
+        afterSourceLstat: async (path) => {
+            await hooks.afterSourceLstat?.(path);
+            assertHeartbeatHealthy();
+        },
+        afterTargetParentOpen: async (path) => {
+            await hooks.afterTargetParentOpen?.(path);
+            assertHeartbeatHealthy();
+        },
+    });
+    const guardedVerify = async (input, hooks = {}) => verifyStagedStorage(input, {
+        ...hooks,
+        afterTargetLstat: async (path) => {
+            await hooks.afterTargetLstat?.(path);
+            assertHeartbeatHealthy();
+        },
+    });
+    const guardedReconcile = async (input) => {
+        assertHeartbeatHealthy();
+        const result = await reconcileStorageManifest(input);
+        assertHeartbeatHealthy();
+        return result;
+    };
+    const guardedPublish = async (input, deps = {}) => {
+        assertHeartbeatHealthy();
+        await publishStagedStorage(input, deps);
+        assertHeartbeatHealthy();
+    };
+    const receipt = await dependencies.runMigration({
         doctor,
         sourceRoots: workerSourceRoots(operation),
         stagingWorkspaceRoot: operation.migration.stagingWorkspaceRoot,
@@ -334,9 +368,15 @@ export async function executeStorageMigrationWorker(handoffPath, injected = {})
         backupsRoot: operation.migration.backupsRoot,
         backupArtifacts: operation.migration.backupArtifacts,
         acceptedWarnings: operation.migration.acceptedWarnings,
+        onStatus: () => assertHeartbeatHealthy(),
+        assertHealthy: assertHeartbeatHealthy,
     }, {
         ...lifecycle,
         now: dependencies.now,
+        materialize: guardedMaterialize,
+        reconcile: guardedReconcile,
+        verify: guardedVerify,
+        publish: guardedPublish,
         refreshDoctor: async () => {
             const refreshed = await dependencies.runDoctor(workerDoctorInput(operation, dependencies.now().toISOString()));
             if (refreshed.manifest.migrationId !== operation.migrationId
@@ -348,6 +388,8 @@ export async function executeStorageMigrationWorker(handoffPath, injected = {})
             return refreshed;
         },
     });
+    assertHeartbeatHealthy();
+    return receipt;
 }
 export async function recoverStorageMigrationWorker(handoffPath, injected = {}) {
     const dependencies = {
@@ -361,6 +403,8 @@ export async function recoverStorageMigrationWorker(handoffPath, injected = {})
     };
     const handoff = await readStorageWorkerHandoff(handoffPath);
     const operation = await readStorageWorkerOperation(handoff.operationPath, handoff.operationSha256);
+    const assertHeartbeatHealthy = dependencies.assertHeartbeatHealthy ?? (() => undefined);
+    assertHeartbeatHealthy();
     if (handoff.migrationId !== operation.migrationId || handoff.profile !== operation.profile) {
         throw new StorageMigrationFailure("worker_handoff_mismatch", "worker handoff does not match operation identity");
     }
@@ -374,10 +418,12 @@ export async function recoverStorageMigrationWorker(handoffPath, injected = {})
     }
     if (receipt.status === "completed" || receipt.status === "rolled_back")
         return receipt;
-    return dependencies.recoverMigration({
+    const recovered = await dependencies.recoverMigration({
         backupsRoot: operation.migration.backupsRoot,
         migrationId: operation.migrationId,
     }, { ...dependencies.createServiceLifecycle(operation), now: dependencies.now });
+    assertHeartbeatHealthy();
+    return recovered;
 }
 export function storageWorkerOperationDigest(operation) {
     return createHash("sha256").update(`${JSON.stringify(operation, null, 2)}\n`).digest("hex");

package/dist/storage-worker-status.js

@@ -27,9 +27,9 @@ async function unlinkHeartbeat(path) {
 }
 /**
  * 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.
+ * intentionally plain JavaScript because a worker module 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");
@@ -58,14 +58,14 @@ const removeHeartbeat = async () => {
 let pending = Promise.resolve();
 let stopping = false;
 let firstWrite = true;
-const write = () => {
+const write = (requestedAt) => {
   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(),
+    at: initial && workerData.initialAt ? workerData.initialAt : requestedAt || new Date().toISOString(),
   }, null, 2) + "\n"));
   return pending;
 };
@@ -73,14 +73,20 @@ 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(() => {
+  const timer = workerData.useParentClock ? null : setInterval(() => {
     if (!stopping) void write().catch((error) => report({ type: "error", message: error instanceof Error ? error.message : String(error) }));
   }, workerData.intervalMs);
-  timer.unref?.();
+  timer?.unref?.();
   parentPort.on("message", (message) => {
-    if (stopping || !message || message.type !== "stop") return;
+    if (stopping || !message) return;
+    if (message.type === "tick") {
+      if (!workerData.useParentClock) return;
+      void write(message.at).catch((error) => report({ type: "error", message: error instanceof Error ? error.message : String(error) }));
+      return;
+    }
+    if (message.type !== "stop") return;
     stopping = true;
-    clearInterval(timer);
+    if (timer !== null) clearInterval(timer);
     void pending.then(async () => { await removeHeartbeat(); report({ type: "stopped" }); }, async () => {
       await removeHeartbeat().catch(() => undefined); report({ type: "stopped" });
     });
@@ -112,8 +118,9 @@ 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 intervalMs = z.number().int().min(100).max(15_000).parse(input.intervalMs ?? 5_000);
     const path = storageWorkerHeartbeatPath(identity.stateRoot, identity.migrationId);
+    const initialAt = input.now?.().toISOString();
     // 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, {
@@ -126,7 +133,8 @@ export async function startStorageWorkerHeartbeat(handoffPath, input = {}) {
             path,
             migrationId: identity.migrationId,
             intervalMs,
-            ...(input.now === undefined ? {} : { initialAt: input.now().toISOString() }),
+            useParentClock: input.now !== undefined,
+            ...(initialAt === undefined ? {} : { initialAt }),
         },
     });
     worker.unref();
@@ -173,11 +181,22 @@ export async function startStorageWorkerHeartbeat(handoffPath, input = {}) {
         await unlinkHeartbeat(path).catch(() => undefined);
         throw error;
     });
+    const parentTimer = input.now === undefined ? null : setInterval(() => {
+        try {
+            worker.postMessage({ type: "tick", at: input.now().toISOString() });
+        }
+        catch (error) {
+            heartbeatError = error instanceof Error ? error : new Error(String(error));
+        }
+    }, intervalMs);
+    parentTimer?.unref?.();
     let stopped = false;
-    return async () => {
+    const stop = async () => {
         if (stopped)
             return;
         stopped = true;
+        if (parentTimer !== null)
+            clearInterval(parentTimer);
         await new Promise((resolvePromise) => {
             const onExit = () => {
                 worker.off("exit", onExit);
@@ -193,6 +212,14 @@ export async function startStorageWorkerHeartbeat(handoffPath, input = {}) {
         worker.off("error", onWorkerError);
         await unlinkHeartbeat(path);
     };
+    Object.defineProperty(stop, "assertHealthy", {
+        enumerable: false,
+        value: () => {
+            if (heartbeatError !== null)
+                throw heartbeatError;
+        },
+    });
+    return stop;
 }
 export async function writeStorageWorkerFailureStatus(handoffPath, error) {
     const identity = identityFromHandoffPath(handoffPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.6.67",
+  "version": "0.6.69",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",