@nowcrew/daemon 0.5.28 → 0.5.29

package/dist/execution-supervisor-child.js

@@ -0,0 +1,236 @@
+import spawn from "cross-spawn";
+import { z } from "zod";
+import { pathToFileURL } from "node:url";
+import { assignProcessToJob, createKillOnCloseJob, terminateJob, } from "./win32-job-object.js";
+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 messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+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;
+    // 是否用 Job Object 拥有 runtime 树。由 parent 依据「durable + win32 + Job Object 后端已选中」决定并下发;
+    // legacy(process-lifetime)路径恒为 false —— 关键:不能仅凭 process.platform 就建 Job,否则灰度关时
+    // legacy Windows 执行会被强行套 Job,且 koffi 加载失败会误杀 legacy runtime(退回 fail-closed 承诺被破坏)。
+    let useJobObject = false;
+    let released = false;
+    let runtime = null;
+    let settled = false;
+    let cleaningTree = false;
+    // win32:本 child 创建并持有的 Job(KILL_ON_JOB_CLOSE)。持有它 = 拥有整棵 runtime 进程树:
+    // 本进程一死(含崩溃)内核即回收 Job 内全部进程,等价于 POSIX killpg 且覆盖 supervisor 自身崩溃。
+    let jobHandle = null;
+    const outputForwarders = [];
+    const terminateOwnedTree = () => {
+        if (cleaningTree)
+            return;
+        cleaningTree = true;
+        for (const forwarder of outputForwarders)
+            forwarder.discard();
+        if (process.platform === "win32") {
+            // 显式一次性杀光 Job 内进程;即便这里失败,process.exit 关闭 job handle 也会触发内核回收。
+            if (jobHandle !== null) {
+                try {
+                    terminateJob(jobHandle);
+                }
+                catch {
+                    // handle 随进程退出自动关闭,KILL_ON_JOB_CLOSE 兜底。
+                }
+            }
+            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;
+            useJobObject = raw.useJobObject === true;
+            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;
+        if (useJobObject) {
+            // 所有权链条落地(仅 durable win32):先建 Job(带 KILL_ON_JOB_CLOSE),再 spawn,spawn 后立即 assign。
+            // 建 Job 失败即无法保证所有权 → 宁可不 spawn,报 spawn-error 让上层 fail-closed。
+            try {
+                jobHandle = createKillOnCloseJob();
+            }
+            catch (error) {
+                send({ type: "runtime-spawn-error", message: `Job Object creation failed: ${messageOf(error)}` });
+                process.exit(2);
+                return;
+            }
+        }
+        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;
+        if (jobHandle !== null && child.pid !== undefined) {
+            // spawn 返回后 child.pid 同步可用,此刻立即 assign,把「assign 前已 fork 孙进程」的窗口压到最小。
+            try {
+                assignProcessToJob(jobHandle, child.pid);
+            }
+            catch (error) {
+                // 无法建立所有权:杀掉刚起的 runtime 并拆除,不让它脱离 Job 裸奔。
+                send({ type: "runtime-spawn-error", message: `AssignProcessToJobObject failed: ${messageOf(error)}` });
+                try {
+                    child.kill("SIGKILL");
+                }
+                catch {
+                    // 已退出。
+                }
+                terminateOwnedTree();
+                return;
+            }
+        }
+        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,316 @@
+import { fork } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { executionBackendCapability, ownsRuntimeViaJobObject } from "./execution-backend.js";
+const DEFAULT_ABORT_TIMEOUT_MS = 5_000;
+const DEFAULT_HANDSHAKE_TIMEOUT_MS = 5_000;
+const DEFAULT_TASKKILL_TIMEOUT_MS = 5_000;
+const PROCESS_GROUP_POLL_MS = 10;
+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 waitForProcessGroupExit(pid, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        try {
+            process.kill(-pid, 0);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "ESRCH")
+                return;
+            // POSIX defines EPERM here as "the process group exists, but is not signalable".
+            // It is therefore an alive observation, not a completed cleanup or an API failure.
+            if (code !== "EPERM")
+                throw error;
+        }
+        if (Date.now() >= deadline) {
+            throw new Error(`Supervisor process group ${pid} did not exit within ${timeoutMs}ms`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, PROCESS_GROUP_POLL_MS));
+    }
+}
+async function processGroupExists(pid) {
+    try {
+        process.kill(-pid, 0);
+        return true;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ESRCH")
+            return false;
+        if (code === "EPERM")
+            return true;
+        throw error;
+    }
+}
+async function signalOwnedTreeIfPresent(pid, signal, platform, signalTree) {
+    try {
+        await signalTree(pid, signal, platform);
+    }
+    catch (error) {
+        if (error.code !== "ESRCH")
+            throw error;
+    }
+}
+async function terminateAndConfirmOwnedTree(pid, platform, timeoutMs, supervisorExited, hasSupervisorExited, signalTree) {
+    const waitUntilStopped = () => platform === "win32"
+        ? waitForExit(supervisorExited.then(() => ({ exitCode: 0 })), timeoutMs, pid)
+        : waitForProcessGroupExit(pid, timeoutMs);
+    if (platform === "win32" && hasSupervisorExited())
+        return;
+    let termError;
+    try {
+        await signalOwnedTreeIfPresent(pid, "SIGTERM", platform, signalTree);
+        await waitUntilStopped();
+        return;
+    }
+    catch (error) {
+        if (platform === "win32" && hasSupervisorExited())
+            return;
+        termError = error;
+    }
+    try {
+        await signalOwnedTreeIfPresent(pid, "SIGKILL", platform, signalTree);
+        await waitUntilStopped();
+    }
+    catch (killError) {
+        if (platform === "win32" && hasSupervisorExited())
+            return;
+        throw new AggregateError([termError, killError], "Supervisor process-tree termination failed");
+    }
+}
+async function confirmOrTerminateOwnedTree(pid, platform, timeoutMs, supervisorExited, hasSupervisorExited, signalTree) {
+    if (platform !== "win32" && !(await processGroupExists(pid)))
+        return;
+    await terminateAndConfirmOwnedTree(pid, platform, timeoutMs, supervisorExited, hasSupervisorExited, signalTree);
+}
+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;
+    const ownershipMode = options.ownershipMode ?? "durable";
+    if (ownershipMode === "durable") {
+        const backend = executionBackendCapability(platform);
+        if (!backend.supported)
+            throw new Error(backend.reason);
+    }
+    // 仅 durable + win32 + Job Object 后端已选中才让 child 套 Job;legacy 恒 false(见 ownsRuntimeViaJobObject)。
+    const useJobObject = ownsRuntimeViaJobObject(ownershipMode, platform);
+    const signalTree = options.signalTree ?? signalSupervisorTree;
+    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 supervisorExit = 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()));
+    // Windows PID ownership ends at `exit`; `close` may lag while stdio/IPC handles drain.
+    let didSupervisorExit = false;
+    const supervisorExited = new Promise((resolve) => {
+        child.once("exit", () => {
+            didSupervisorExit = true;
+            resolve();
+        });
+    });
+    let treeStopPromise = null;
+    const ensureTreeStopped = () => {
+        treeStopPromise ??= confirmOrTerminateOwnedTree(pid, platform, abortTimeoutMs, supervisorExited, () => didSupervisorExit, signalTree);
+        return treeStopPromise;
+    };
+    const exit = supervisorExit.then(async (result) => {
+        await ensureTreeStopped();
+        return result;
+    });
+    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;
+            await ensureTreeStopped();
+            return;
+        }
+        await ensureTreeStopped();
+        await waitForExit(supervisorClosed.then(() => ({ exitCode: 0 })), abortTimeoutMs, pid);
+        await ensureTreeStopped();
+    };
+    const cancel = async () => {
+        if (child.exitCode !== null || child.signalCode !== null) {
+            await supervisorClosed;
+            await ensureTreeStopped();
+            return;
+        }
+        try {
+            await new Promise((resolve, reject) => {
+                child.send({ type: "abort" }, (error) => error === null ? resolve() : reject(error));
+            });
+            if (platform === "win32") {
+                await ensureTreeStopped();
+            }
+            else {
+                await waitForExit(supervisorClosed.then(() => ({ exitCode: 0 })), abortTimeoutMs, pid);
+                await ensureTreeStopped();
+            }
+        }
+        catch {
+            await abort();
+        }
+    };
+    try {
+        await new Promise((resolve, reject) => {
+            child.send({ type: "launch", launch: { ...launch, args: [...launch.args], env }, useJobObject }, (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;
+    }
+    const handle = {
+        pid,
+        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,
+    };
+    return ownershipMode === "durable"
+        ? { ...handle, ownershipMode, parentExitGuard: "pipe-eof" }
+        : { ...handle, ownershipMode };
+}

package/dist/execution-telemetry-journal.js

@@ -0,0 +1,71 @@
+import { access, open, mkdir, readdir, readFile, rename, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { DaemonToServerExecutionFrameSchema, } from "./execution-protocol.js";
+const MAX_PENDING_FILES = 4_096;
+const fileName = (frame) => `${frame.executionId}.${frame.type === "execution:activity" ? "activity" : "console"}.${frame.seq}.json`;
+export class ExecutionTelemetryJournal {
+    directory;
+    constructor(agentsRoot) {
+        this.directory = join(agentsRoot, ".execution-telemetry");
+    }
+    async append(frame) {
+        await mkdir(this.directory, { recursive: true, mode: 0o700 });
+        const path = join(this.directory, fileName(frame));
+        if (await access(path).then(() => true, () => false))
+            return;
+        const pending = await readdir(this.directory);
+        if (pending.length >= MAX_PENDING_FILES) {
+            throw new Error(`execution telemetry journal is full (${MAX_PENDING_FILES} frames)`);
+        }
+        const tempPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+        let handle;
+        try {
+            handle = await open(tempPath, "wx", 0o600);
+            await handle.writeFile(JSON.stringify(frame), "utf8");
+            await handle.sync();
+            await handle.close();
+            handle = undefined;
+            await rename(tempPath, path);
+        }
+        catch (error) {
+            await unlink(tempPath).catch(() => { });
+            if (error.code !== "EEXIST")
+                throw error;
+        }
+        finally {
+            await handle?.close();
+        }
+    }
+    async acknowledge(executionId, kind, seq) {
+        await unlink(join(this.directory, `${executionId}.${kind}.${seq}.json`)).catch((error) => {
+            if (error.code !== "ENOENT")
+                throw error;
+        });
+    }
+    async replay() {
+        const names = await readdir(this.directory).catch((error) => {
+            if (error.code === "ENOENT")
+                return [];
+            throw error;
+        });
+        const frames = [];
+        for (const name of names.filter((entry) => entry.endsWith(".json")).sort()) {
+            let raw;
+            try {
+                raw = JSON.parse(await readFile(join(this.directory, name), "utf8"));
+            }
+            catch (error) {
+                throw new Error(`invalid execution telemetry journal entry: ${name}`, { cause: error });
+            }
+            const parsed = DaemonToServerExecutionFrameSchema.safeParse(raw);
+            if (!parsed.success || (parsed.data.type !== "execution:activity" && parsed.data.type !== "execution:console")) {
+                throw new Error(`invalid execution telemetry journal entry: ${name}`);
+            }
+            frames.push(parsed.data);
+        }
+        return frames.sort((left, right) => left.at.localeCompare(right.at)
+            || left.type.localeCompare(right.type) || left.seq - right.seq);
+    }
+}
+export const createExecutionTelemetryJournal = (agentsRoot) => new ExecutionTelemetryJournal(agentsRoot);