@nowcrew/daemon 0.5.12 → 0.5.13

package/dist/execution-supervisor-child.js

@@ -0,0 +1,185 @@
+import spawn from "cross-spawn";
+import { z } from "zod";
+import { pathToFileURL } from "node:url";
+const LaunchSchema = z.object({
+    command: z.string().min(1),
+    args: z.array(z.string()),
+    cwd: z.string().min(1),
+    env: z.record(z.string()),
+    stdinText: z.string().optional(),
+}).strict();
+function send(message, callback) {
+    if (!process.connected) {
+        callback?.();
+        return;
+    }
+    process.send?.(message, () => callback?.());
+}
+/**
+ * Keep consuming runtime output even when the daemon-side pipe disappears. A direct `pipe()` can
+ * crash this supervisor with EPIPE and orphan the runtime. While connected, source pause/resume
+ * preserves authoritative final output. Once disconnected, the source remains drained and discarded.
+ */
+function forwardWhileWritable(source, destination) {
+    if (source === null)
+        return { discard: () => undefined };
+    let blocked = false;
+    let broken = destination.destroyed;
+    const discard = () => {
+        broken = true;
+        blocked = false;
+        source.resume();
+    };
+    destination.on("error", discard);
+    destination.on("close", discard);
+    destination.on("drain", () => {
+        if (broken)
+            return;
+        blocked = false;
+        source.resume();
+    });
+    source.on("data", (chunk) => {
+        if (broken)
+            return;
+        try {
+            if (!destination.write(chunk)) {
+                blocked = true;
+                source.pause();
+            }
+        }
+        catch {
+            discard();
+        }
+    });
+    source.on("error", () => undefined);
+    return { discard };
+}
+export function runExecutionSupervisorChild() {
+    let launch = null;
+    let released = false;
+    let runtime = null;
+    let settled = false;
+    let cleaningTree = false;
+    const outputForwarders = [];
+    const terminateOwnedTree = () => {
+        if (cleaningTree)
+            return;
+        cleaningTree = true;
+        for (const forwarder of outputForwarders)
+            forwarder.discard();
+        if (process.platform === "win32") {
+            process.exit(1);
+            return;
+        }
+        try {
+            process.kill(-process.pid, "SIGTERM");
+        }
+        catch (error) {
+            if (error.code !== "ESRCH")
+                throw error;
+        }
+        setTimeout(() => {
+            try {
+                process.kill(-process.pid, "SIGKILL");
+            }
+            catch (error) {
+                if (error.code !== "ESRCH")
+                    throw error;
+                process.exit();
+            }
+        }, 250);
+    };
+    const stopBeforeRelease = () => {
+        if (released || settled)
+            return;
+        settled = true;
+        process.exit(0);
+    };
+    process.on("SIGTERM", () => {
+        if (released)
+            terminateOwnedTree();
+        else
+            stopBeforeRelease();
+    });
+    process.on("SIGINT", () => {
+        if (released)
+            terminateOwnedTree();
+        else
+            stopBeforeRelease();
+    });
+    process.on("disconnect", () => {
+        if (released)
+            terminateOwnedTree();
+        else
+            stopBeforeRelease();
+    });
+    process.on("message", (raw) => {
+        if (raw.type === "launch") {
+            if (launch !== null) {
+                process.exitCode = 2;
+                return;
+            }
+            const parsed = LaunchSchema.safeParse(raw.launch);
+            if (!parsed.success) {
+                send({ type: "runtime-spawn-error", message: parsed.error.message });
+                process.exit(2);
+                return;
+            }
+            launch = parsed.data;
+            send({ type: "ready" });
+            return;
+        }
+        if (raw.type === "abort") {
+            if (runtime === null)
+                stopBeforeRelease();
+            else
+                runtime.kill("SIGTERM");
+            return;
+        }
+        if (raw.type !== "release" || released || launch === null)
+            return;
+        released = true;
+        const child = spawn(launch.command, launch.args, {
+            cwd: launch.cwd,
+            env: launch.env,
+            detached: false,
+            stdio: [launch.stdinText === undefined ? "ignore" : "pipe", "pipe", "pipe"],
+        });
+        runtime = child;
+        outputForwarders.push(forwardWhileWritable(child.stdout, process.stdout), forwardWhileWritable(child.stderr, process.stderr));
+        child.once("spawn", () => {
+            send({ type: "runtime-started" });
+            if (launch?.stdinText !== undefined && child.stdin !== null) {
+                child.stdin.on("error", () => undefined);
+                child.stdin.end(launch.stdinText);
+            }
+        });
+        child.once("error", (error) => {
+            send({ type: "runtime-spawn-error", message: error.message });
+        });
+        child.once("close", (code, signal) => {
+            const exitMessage = {
+                type: "runtime-exit",
+                exitCode: code ?? 128,
+                ...(signal === null ? {} : { terminationSignal: signal }),
+            };
+            settled = true;
+            process.exitCode = code ?? 128;
+            let cleanupStarted = false;
+            const cleanup = () => {
+                if (cleanupStarted)
+                    return;
+                cleanupStarted = true;
+                terminateOwnedTree();
+            };
+            const fallback = setTimeout(cleanup, 50);
+            send(exitMessage, () => {
+                clearTimeout(fallback);
+                cleanup();
+            });
+        });
+    });
+}
+if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    runExecutionSupervisorChild();
+}

package/dist/execution-supervisor.js

@@ -0,0 +1,209 @@
+import { fork } from "node:child_process";
+import { fileURLToPath } from "node:url";
+const DEFAULT_ABORT_TIMEOUT_MS = 5_000;
+const DEFAULT_HANDSHAKE_TIMEOUT_MS = 5_000;
+const DEFAULT_TASKKILL_TIMEOUT_MS = 5_000;
+function messageError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+async function waitForExit(exit, timeoutMs, pid) {
+    let timer;
+    try {
+        await Promise.race([
+            exit.then(() => undefined),
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new Error(`Supervisor ${pid} did not exit within ${timeoutMs}ms`)), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+async function withTimeout(promise, timeoutMs, phase) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new Error(`Supervisor ${phase} timed out after ${timeoutMs}ms`)), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+/** Terminate only a supervisor-created process tree. Never use this for arbitrary child PIDs. */
+export async function signalSupervisorTree(pid, signal, platform = process.platform) {
+    if (platform === "win32") {
+        const { execFile } = await import("node:child_process");
+        await new Promise((resolve, reject) => {
+            const args = ["/PID", String(pid), "/T", ...(signal === "SIGKILL" ? ["/F"] : [])];
+            const abort = new AbortController();
+            const timeout = setTimeout(() => abort.abort(), DEFAULT_TASKKILL_TIMEOUT_MS);
+            execFile("taskkill.exe", args, { signal: abort.signal }, (error, stdout, stderr) => {
+                clearTimeout(timeout);
+                if (error === null) {
+                    resolve();
+                    return;
+                }
+                const detail = `${stdout} ${stderr} ${error.message}`;
+                if (/not found|no running instance|不存在|找不到/i.test(detail))
+                    resolve();
+                else
+                    reject(error);
+            });
+        });
+        return;
+    }
+    process.kill(-pid, signal);
+}
+export async function startDormantSupervisor(launch, options = {}) {
+    const platform = options.platform ?? process.platform;
+    if (platform === "win32") {
+        throw new Error("Execution supervisor is unsupported on Windows without Job Object ownership");
+    }
+    const childEntry = options.childEntry
+        ?? fileURLToPath(new URL("./execution-supervisor-child.js", import.meta.url));
+    const abortTimeoutMs = options.abortTimeoutMs ?? DEFAULT_ABORT_TIMEOUT_MS;
+    const handshakeTimeoutMs = options.handshakeTimeoutMs ?? DEFAULT_HANDSHAKE_TIMEOUT_MS;
+    if (!Number.isFinite(handshakeTimeoutMs) || handshakeTimeoutMs <= 0) {
+        throw new RangeError("handshakeTimeoutMs must be a positive finite number");
+    }
+    const env = Object.fromEntries(Object.entries(launch.env).filter((entry) => entry[1] !== undefined));
+    const child = fork(childEntry, [], {
+        detached: true,
+        env: { ...process.env, ...options.childEnv },
+        execArgv: options.execArgv === undefined ? process.execArgv : [...options.execArgv],
+        stdio: ["ignore", "pipe", "pipe", "ipc"],
+    });
+    const pid = child.pid;
+    if (pid === undefined || child.stdout === null || child.stderr === null) {
+        child.kill("SIGKILL");
+        throw new Error("Supervisor failed to expose a process identity and output pipes");
+    }
+    let runtimeResult;
+    let supervisorSpawnError;
+    const exit = new Promise((resolve) => {
+        child.once("error", (error) => { supervisorSpawnError = error.message; });
+        child.once("close", (code, signal) => resolve(runtimeResult ?? {
+            exitCode: supervisorSpawnError === undefined ? (code ?? 128) : -1,
+            ...(supervisorSpawnError === undefined ? {} : { spawnError: supervisorSpawnError }),
+            ...(supervisorSpawnError === undefined && signal !== null ? { terminationSignal: signal } : {}),
+        }));
+    });
+    const supervisorClosed = new Promise((resolve) => child.once("close", () => resolve()));
+    let readyResolve;
+    let readyReject;
+    const ready = new Promise((resolve, reject) => {
+        readyResolve = resolve;
+        readyReject = reject;
+    });
+    let releaseResolve;
+    let releaseReject;
+    let released = false;
+    child.on("message", (raw) => {
+        if (raw.type === "ready")
+            readyResolve?.();
+        if (raw.type === "runtime-started")
+            releaseResolve?.();
+        if (raw.type === "runtime-spawn-error") {
+            runtimeResult ??= { exitCode: -1, spawnError: raw.message };
+            releaseReject?.(new Error(raw.message));
+        }
+        if (raw.type === "runtime-exit") {
+            runtimeResult ??= {
+                exitCode: raw.exitCode,
+                ...(raw.terminationSignal === undefined ? {} : { terminationSignal: raw.terminationSignal }),
+            };
+        }
+    });
+    child.once("error", (error) => {
+        readyReject?.(error);
+        releaseReject?.(error);
+    });
+    child.once("close", (code, signal) => {
+        const error = new Error(`Supervisor exited before launch: code=${code} signal=${signal}`);
+        readyReject?.(error);
+        releaseReject?.(error);
+    });
+    const abort = async () => {
+        if (child.exitCode !== null || child.signalCode !== null) {
+            await supervisorClosed;
+            return;
+        }
+        try {
+            await signalSupervisorTree(pid, "SIGTERM", platform);
+        }
+        catch (error) {
+            const code = error instanceof Error && "code" in error ? error.code : undefined;
+            if (code !== "ESRCH")
+                throw error;
+        }
+        try {
+            await waitForExit(supervisorClosed.then(() => ({ exitCode: 0 })), abortTimeoutMs, pid);
+        }
+        catch (error) {
+            try {
+                await signalSupervisorTree(pid, "SIGKILL", platform);
+            }
+            catch (killError) {
+                const code = killError instanceof Error && "code" in killError ? killError.code : undefined;
+                if (code !== "ESRCH")
+                    throw new AggregateError([error, killError], "Supervisor abort failed");
+            }
+            await waitForExit(supervisorClosed.then(() => ({ exitCode: 0 })), abortTimeoutMs, pid);
+        }
+    };
+    try {
+        await new Promise((resolve, reject) => {
+            child.send({ type: "launch", launch: { ...launch, args: [...launch.args], env } }, (error) => {
+                if (error === null)
+                    resolve();
+                else
+                    reject(error);
+            });
+        });
+        await withTimeout(ready, handshakeTimeoutMs, "ready handshake");
+    }
+    catch (error) {
+        await abort().catch((abortError) => {
+            throw new AggregateError([messageError(error), messageError(abortError)], "Supervisor start failed");
+        });
+        throw error;
+    }
+    return {
+        pid,
+        parentExitGuard: "pipe-eof",
+        stdout: child.stdout,
+        stderr: child.stderr,
+        exit,
+        release: async () => {
+            if (released)
+                return;
+            released = true;
+            const acknowledgement = new Promise((resolve, reject) => {
+                releaseResolve = resolve;
+                releaseReject = reject;
+                child.send({ type: "release" }, (error) => {
+                    if (error !== null)
+                        reject(error);
+                });
+            });
+            try {
+                await withTimeout(acknowledgement, handshakeTimeoutMs, "release handshake");
+            }
+            catch (error) {
+                await abort().catch((abortError) => {
+                    throw new AggregateError([messageError(error), messageError(abortError)], "Supervisor release failed");
+                });
+                throw error;
+            }
+        },
+        abort,
+        cancel: abort,
+    };
+}