@nowcrew/daemon 0.6.89 → 0.6.90

package/dist/storage-worker-status.js

@@ -1,259 +0,0 @@
-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({
-    version: z.literal(1),
-    migrationId: z.string().uuid(),
-    status: z.literal("failed"),
-    errorCode: z.string().regex(/^[a-z0-9._-]{1,128}$/u),
-    errorMessage: z.string().min(1).max(512),
-    at: z.string().datetime({ offset: true }),
-}).strict();
-const WorkerHeartbeatSchema = z.object({
-    version: z.literal(1),
-    migrationId: z.string().uuid(),
-    pid: z.number().int().positive(),
-    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 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");
-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 = (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 : requestedAt || 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 = 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?.();
-  parentPort.on("message", (message) => {
-    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;
-    if (timer !== null) 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");
-    }
-    const migrationDirectory = dirname(handoffPath);
-    const migrationsDirectory = dirname(migrationDirectory);
-    if (basename(migrationsDirectory) !== "migrations")
-        throw new Error("storage worker handoff path is invalid");
-    return {
-        stateRoot: dirname(migrationsDirectory),
-        migrationId: z.string().uuid().parse(basename(migrationDirectory)).toLowerCase(),
-    };
-}
-export function storageWorkerFailurePath(stateRoot, migrationId) {
-    if (!isAbsolute(stateRoot))
-        throw new Error("storage worker state root must be absolute");
-    return join(stateRoot, "migrations", z.string().uuid().parse(migrationId), "worker-status.json");
-}
-export function storageWorkerHeartbeatPath(stateRoot, migrationId) {
-    if (!isAbsolute(stateRoot))
-        throw new Error("storage worker state root must be absolute");
-    return join(stateRoot, "migrations", z.string().uuid().parse(migrationId), "worker-heartbeat.json");
-}
-export async function startStorageWorkerHeartbeat(handoffPath, input = {}) {
-    const identity = identityFromHandoffPath(handoffPath);
-    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, {
-        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,
-            intervalMs,
-            useParentClock: input.now !== undefined,
-            ...(initialAt === undefined ? {} : { initialAt }),
-        },
-    });
-    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);
-    };
-    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;
-    });
-    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;
-    const stop = async () => {
-        if (stopped)
-            return;
-        stopped = true;
-        if (parentTimer !== null)
-            clearInterval(parentTimer);
-        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);
-    };
-    Object.defineProperty(stop, "assertHealthy", {
-        enumerable: false,
-        value: () => {
-            if (heartbeatError !== null)
-                throw heartbeatError;
-        },
-    });
-    return stop;
-}
-export async function writeStorageWorkerFailureStatus(handoffPath, error) {
-    const identity = identityFromHandoffPath(handoffPath);
-    const rawCode = error instanceof Error && "code" in error ? String(error.code) : "worker_failed";
-    const errorCode = /^[a-z0-9._-]{1,128}$/u.test(rawCode) ? rawCode : "worker_failed";
-    const rawMessage = error instanceof Error ? error.message : String(error);
-    const errorMessage = rawMessage.replaceAll(TOKEN, "<redacted>").slice(0, 512) || "storage worker failed";
-    const status = WorkerFailureSchema.parse({
-        version: 1,
-        migrationId: identity.migrationId,
-        status: "failed",
-        errorCode,
-        errorMessage,
-        at: new Date().toISOString(),
-    });
-    await atomicPrivateWrite(storageWorkerFailurePath(identity.stateRoot, identity.migrationId), `${JSON.stringify(status, null, 2)}\n`);
-}
-export async function readStorageWorkerFailureStatus(stateRoot, migrationId) {
-    try {
-        return WorkerFailureSchema.parse(JSON.parse(await readFile(storageWorkerFailurePath(stateRoot, migrationId), "utf8")));
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return null;
-        throw new Error("Invalid storage worker failure status", { cause: error });
-    }
-}
-export async function readStorageWorkerHeartbeat(stateRoot, migrationId) {
-    try {
-        return WorkerHeartbeatSchema.parse(JSON.parse(await readFile(storageWorkerHeartbeatPath(stateRoot, migrationId), "utf8")));
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return null;
-        throw new Error("Invalid storage worker heartbeat", { cause: error });
-    }
-}