@astrosheep/keiyaku 2.9.12 → 2.9.13

package/build/core/settlement/verification-supervisor.js

@@ -1,275 +0,0 @@
-import { execFile, spawn } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import { z } from "zod";
-import { PROCESS_GROUP_KILL_GRACE_MS } from "../process-group.js";
-export const VERIFICATION_SUPERVISOR_PROTOCOL_VERSION = 1;
-const configureMessageSchema = z.object({
-    version: z.literal(VERIFICATION_SUPERVISOR_PROTOCOL_VERSION),
-    type: z.literal("configure"),
-    cwd: z.string().min(1),
-    command: z.string().min(1),
-    args: z.array(z.string()),
-    shell: z.boolean(),
-    timeoutMs: z.number().int().positive(),
-}).strict();
-const startMessageSchema = z.object({
-    version: z.literal(VERIFICATION_SUPERVISOR_PROTOCOL_VERSION),
-    type: z.literal("start"),
-}).strict();
-export const supervisorMessageSchema = z.discriminatedUnion("type", [
-    z.object({
-        version: z.literal(VERIFICATION_SUPERVISOR_PROTOCOL_VERSION),
-        type: z.literal("ready"),
-    }).strict(),
-    z.object({
-        version: z.literal(VERIFICATION_SUPERVISOR_PROTOCOL_VERSION),
-        type: z.literal("configured"),
-    }).strict(),
-    z.object({
-        version: z.literal(VERIFICATION_SUPERVISOR_PROTOCOL_VERSION),
-        type: z.literal("started"),
-    }).strict(),
-    z.object({
-        version: z.literal(VERIFICATION_SUPERVISOR_PROTOCOL_VERSION),
-        type: z.literal("terminal"),
-        durationMs: z.number().nonnegative(),
-        outcome: z.discriminatedUnion("kind", [
-            z.object({ kind: z.literal("exit"), code: z.number().int() }).strict(),
-            z.object({ kind: z.literal("signal"), signal: z.string().nullable() }).strict(),
-            z.object({ kind: z.literal("spawn-failed"), message: z.string() }).strict(),
-            z.object({ kind: z.literal("timeout") }).strict(),
-            z.object({ kind: z.literal("tree-termination-failed"), message: z.string() }).strict(),
-        ]),
-    }).strict(),
-]);
-function verificationSupervisorPath() {
-    const extension = import.meta.url.endsWith(".ts") ? "ts" : "js";
-    return fileURLToPath(new URL(`./verification-supervisor.${extension}`, import.meta.url));
-}
-export function verificationSupervisorArguments() {
-    const target = verificationSupervisorPath();
-    return import.meta.url.endsWith(".ts") ? ["--import", "tsx", target] : [target];
-}
-function send(message) {
-    if (process.connected)
-        process.send?.(message);
-}
-function durationMs(started) {
-    return Number((process.hrtime.bigint() - started) / 1000000n);
-}
-function forward(source, destination, outputLost) {
-    source?.on("data", (chunk) => {
-        try {
-            if (!destination.write(chunk)) {
-                source.pause();
-                destination.once("drain", () => source.resume());
-            }
-        }
-        catch {
-            outputLost();
-        }
-    });
-}
-async function drainOutput() {
-    const drains = [];
-    for (const stream of [process.stdout, process.stderr]) {
-        if (!stream.destroyed && !stream.closed && stream.writableNeedDrain) {
-            drains.push(new Promise((resolve) => stream.once("drain", resolve)));
-        }
-    }
-    await Promise.all(drains);
-}
-function defaultTaskkill(pid) {
-    return new Promise((resolve, reject) => {
-        execFile("taskkill", ["/PID", String(pid), "/T", "/F"], { windowsHide: true }, (error) => {
-            if (error)
-                reject(error);
-            else
-                resolve();
-        });
-    });
-}
-export async function terminateWindowsPayloadTree(pid, taskkill = defaultTaskkill) {
-    await taskkill(pid);
-}
-function signalOwnedGroup(signal) {
-    if (process.platform === "win32")
-        return;
-    try {
-        process.kill(-process.pid, signal);
-    }
-    catch (error) {
-        if (!(error && typeof error === "object" && "code" in error && error.code === "ESRCH"))
-            throw error;
-    }
-}
-async function runSupervisor() {
-    if (typeof process.send !== "function")
-        process.exit(2);
-    let payload;
-    let payloadStartedAt;
-    let commandTimer;
-    let killTimer;
-    let shutdown;
-    let finalized = false;
-    let configuration;
-    let payloadClosedAtMs;
-    let windowsTaskkillComplete = false;
-    const finish = async (message) => {
-        if (finalized)
-            return;
-        finalized = true;
-        if (commandTimer)
-            clearTimeout(commandTimer);
-        if (killTimer)
-            clearTimeout(killTimer);
-        await drainOutput();
-        if (message)
-            send(message);
-        if (process.connected)
-            process.disconnect?.();
-        process.exit(0);
-    };
-    const finishShutdown = () => {
-        if (shutdown === "timeout") {
-            void finish({
-                version: VERIFICATION_SUPERVISOR_PROTOCOL_VERSION,
-                type: "terminal",
-                durationMs: payloadClosedAtMs ?? durationMs(payloadStartedAt),
-                outcome: { kind: "timeout" },
-            });
-        }
-        else {
-            void finish();
-        }
-    };
-    const beginShutdown = (reason) => {
-        if (shutdown || finalized)
-            return;
-        shutdown = reason;
-        if (!payload) {
-            void finish();
-            return;
-        }
-        if (process.platform === "win32") {
-            if (!payload.pid) {
-                void finish();
-                return;
-            }
-            void terminateWindowsPayloadTree(payload.pid).then(() => {
-                windowsTaskkillComplete = true;
-                if (payloadClosedAtMs !== undefined)
-                    finishShutdown();
-            }, (error) => {
-                send({
-                    version: VERIFICATION_SUPERVISOR_PROTOCOL_VERSION,
-                    type: "terminal",
-                    durationMs: durationMs(payloadStartedAt),
-                    outcome: {
-                        kind: "tree-termination-failed",
-                        message: error instanceof Error ? error.message : String(error),
-                    },
-                });
-            });
-            return;
-        }
-        signalOwnedGroup("SIGTERM");
-        killTimer = setTimeout(() => signalOwnedGroup("SIGKILL"), PROCESS_GROUP_KILL_GRACE_MS);
-    };
-    process.on("SIGTERM", () => beginShutdown("external"));
-    process.on("disconnect", () => beginShutdown("parent-lost"));
-    const outputLost = () => beginShutdown("parent-lost");
-    process.stdout.once("error", outputLost);
-    process.stdout.once("close", outputLost);
-    process.stderr.once("error", outputLost);
-    process.stderr.once("close", outputLost);
-    process.on("message", (raw) => {
-        const configured = configureMessageSchema.safeParse(raw);
-        if (configured.success && !configuration && !payload && process.connected) {
-            configuration = configured.data;
-            send({ version: VERIFICATION_SUPERVISOR_PROTOCOL_VERSION, type: "configured" });
-            return;
-        }
-        const start = startMessageSchema.safeParse(raw);
-        if (!start.success || !configuration || payload || !process.connected) {
-            void finish();
-            return;
-        }
-        const message = configuration;
-        payloadStartedAt = process.hrtime.bigint();
-        try {
-            payload = spawn(message.command, message.args, {
-                cwd: message.cwd,
-                shell: message.shell,
-                env: process.env,
-                detached: false,
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-        }
-        catch (error) {
-            void finish({
-                version: VERIFICATION_SUPERVISOR_PROTOCOL_VERSION,
-                type: "terminal",
-                durationMs: durationMs(payloadStartedAt),
-                outcome: { kind: "spawn-failed", message: error instanceof Error ? error.message : String(error) },
-            });
-            return;
-        }
-        forward(payload.stdout, process.stdout, outputLost);
-        forward(payload.stderr, process.stderr, outputLost);
-        payload.once("error", (error) => {
-            void finish({
-                version: VERIFICATION_SUPERVISOR_PROTOCOL_VERSION,
-                type: "terminal",
-                durationMs: durationMs(payloadStartedAt),
-                outcome: { kind: "spawn-failed", message: error.message },
-            });
-        });
-        payload.once("close", (code, signal) => {
-            const elapsed = durationMs(payloadStartedAt);
-            payloadClosedAtMs = elapsed;
-            if (shutdown && process.platform === "win32") {
-                if (windowsTaskkillComplete)
-                    finishShutdown();
-                return;
-            }
-            else if (shutdown === "parent-lost") {
-                return;
-            }
-            else if (shutdown === "timeout") {
-                void finish({
-                    version: VERIFICATION_SUPERVISOR_PROTOCOL_VERSION,
-                    type: "terminal",
-                    durationMs: elapsed,
-                    outcome: { kind: "timeout" },
-                });
-            }
-            else if (shutdown) {
-                void finish();
-            }
-            else if (code === null) {
-                void finish({
-                    version: VERIFICATION_SUPERVISOR_PROTOCOL_VERSION,
-                    type: "terminal",
-                    durationMs: elapsed,
-                    outcome: { kind: "signal", signal },
-                });
-            }
-            else {
-                void finish({
-                    version: VERIFICATION_SUPERVISOR_PROTOCOL_VERSION,
-                    type: "terminal",
-                    durationMs: elapsed,
-                    outcome: { kind: "exit", code },
-                });
-            }
-        });
-        commandTimer = setTimeout(() => beginShutdown("timeout"), message.timeoutMs);
-        commandTimer.unref?.();
-        send({ version: VERIFICATION_SUPERVISOR_PROTOCOL_VERSION, type: "started" });
-    });
-    send({ version: VERIFICATION_SUPERVISOR_PROTOCOL_VERSION, type: "ready" });
-}
-if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
-    void runSupervisor();
-}