@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/core/run-control/detached-lease-bootstrap.js

@@ -1,208 +0,0 @@
-import { launchDetachedProcess } from "./detached-process.js";
-import { terminateProcessGroup } from "./process-tree.js";
-import { acquireRunnerLeaseTransferTarget, observeRunnerLease, } from "./runner-lease.js";
-export const RUN_CONTROL_BOOTSTRAP_ENV = "KEIYAKU_RUN_CONTROL_BOOTSTRAP";
-function detail(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function send(child, message) {
-    return new Promise((resolve, reject) => {
-        if (!child.send || !child.connected)
-            return reject(new Error("bootstrap channel is unavailable"));
-        child.send(message, (error) => error ? reject(error) : resolve());
-    });
-}
-function waitForMessage(child, coordinate, expected, deadline, now, setTimer, clearTimer) {
-    return new Promise((resolve, reject) => {
-        const cleanup = () => {
-            child.off("message", onMessage);
-            child.off("error", onError);
-            child.off("exit", onExit);
-            clearTimer(timer);
-        };
-        const onMessage = (value) => {
-            const message = value;
-            if (message.coordinate !== coordinate || message.kind !== expected)
-                return;
-            cleanup();
-            resolve();
-        };
-        const onError = (error) => { cleanup(); reject(error); };
-        const onExit = () => onError(new Error("child exited during bootstrap"));
-        const remaining = deadline - now();
-        const timer = setTimer(() => onError(new Error(`bootstrap deadline passed before ${expected}`)), Math.max(0, remaining));
-        child.on("message", onMessage);
-        child.on("error", onError);
-        child.on("exit", onExit);
-    });
-}
-async function stop(child, prefix, terminate) {
-    try {
-        await terminate(child);
-        return { status: "failed", stage: "transfer", detail: prefix };
-    }
-    catch (error) {
-        return { status: "failed", stage: "cleanup", detail: `${prefix}; termination could not be verified: ${detail(error)}` };
-    }
-}
-export async function openDetachedLeaseBootstrap(input) {
-    const terminate = input.terminate ?? terminateProcessGroup;
-    const now = input.now ?? Date.now;
-    let child;
-    try {
-        child = launchDetachedProcess(input.launch, input.spawn);
-    }
-    catch (error) {
-        try {
-            input.parentLease.close();
-            return { status: "failed", stage: "spawn", detail: detail(error) };
-        }
-        catch (closeError) {
-            return { status: "failed", stage: "cleanup", detail: `${detail(error)}; parent lease release failed: ${detail(closeError)}` };
-        }
-    }
-    const ready = waitForMessage(child, input.coordinate, "transfer-ready", input.deadline, now, setTimeout, clearTimeout);
-    const acquired = waitForMessage(child, input.coordinate, "ownership-acquired", input.deadline, now, setTimeout, clearTimeout);
-    void acquired.catch(() => { });
-    try {
-        await ready;
-    }
-    catch (error) {
-        let failure = detail(error);
-        try {
-            input.parentLease.close();
-        }
-        catch (closeError) {
-            failure += `; parent lease release failed: ${detail(closeError)}`;
-        }
-        return stop(child, failure, terminate);
-    }
-    let decision;
-    let result;
-    return {
-        status: "ready",
-        bootstrap: {
-            child,
-            async authorize() {
-                if (decision === "reject")
-                    return { status: "failed", stage: "transfer", detail: "bootstrap was already rejected" };
-                if (decision)
-                    return result;
-                decision = "authorize";
-                result = (async () => {
-                    let transferFailure;
-                    let transferMayBeOwnedByChild = false;
-                    try {
-                        input.parentLease.releaseReservationForTransfer();
-                        await send(child, { kind: "promote", coordinate: input.coordinate });
-                        transferMayBeOwnedByChild = true;
-                        try {
-                            input.parentLease.close();
-                        }
-                        catch (error) {
-                            transferFailure = error;
-                        }
-                        try {
-                            await acquired;
-                        }
-                        catch (error) {
-                            transferFailure ??= error;
-                        }
-                        if (transferFailure && observeRunnerLease(input.leasePath).state !== "held")
-                            throw transferFailure;
-                        await send(child, { kind: "authorize", coordinate: input.coordinate });
-                        return { status: "authorized", child };
-                    }
-                    catch (error) {
-                        try {
-                            input.parentLease.close();
-                        }
-                        catch { /* cleanup detail is secondary to transfer failure */ }
-                        if (transferMayBeOwnedByChild && observeRunnerLease(input.leasePath).state === "held") {
-                            try {
-                                await send(child, { kind: "authorize", coordinate: input.coordinate });
-                            }
-                            catch { /* held lease already proves authority */ }
-                            return { status: "authorized", child };
-                        }
-                        return stop(child, detail(error), terminate);
-                    }
-                })();
-                return result;
-            },
-            async reject() {
-                if (decision === "authorize")
-                    return { status: "failed", stage: "transfer", detail: "bootstrap was already authorized" };
-                if (decision)
-                    return result;
-                decision = "reject";
-                result = (async () => {
-                    try {
-                        await send(child, { kind: "reject", coordinate: input.coordinate });
-                    }
-                    catch { /* termination proves rejection */ }
-                    let failure = "launch rejected";
-                    try {
-                        input.parentLease.close();
-                    }
-                    catch (error) {
-                        failure += `; parent lease release failed: ${detail(error)}`;
-                    }
-                    const stopped = await stop(child, failure, terminate);
-                    return stopped.stage === "cleanup" ? stopped : { status: "rejected" };
-                })();
-                return result;
-            },
-        },
-    };
-}
-function sendUpstream(message) {
-    return new Promise((resolve, reject) => {
-        if (!process.send || !process.connected)
-            return reject(new Error("bootstrap channel is unavailable"));
-        process.send(message, (error) => error ? reject(error) : resolve());
-    });
-}
-function receive(coordinate, expected) {
-    return new Promise((resolve, reject) => {
-        const cleanup = () => {
-            process.off("message", onMessage);
-            process.off("disconnect", onDisconnect);
-        };
-        const onDisconnect = () => { cleanup(); reject(new Error("bootstrap channel disconnected")); };
-        const onMessage = (value) => {
-            const message = value;
-            if (message.coordinate !== coordinate || (message.kind !== expected && message.kind !== "reject"))
-                return;
-            cleanup();
-            resolve(message);
-        };
-        process.on("message", onMessage);
-        process.on("disconnect", onDisconnect);
-    });
-}
-export async function receiveDetachedLease(input) {
-    if (process.env[RUN_CONTROL_BOOTSTRAP_ENV] !== "1")
-        throw new Error("process lacks bootstrap authority");
-    let target;
-    let lease;
-    try {
-        target = acquireRunnerLeaseTransferTarget(input.leasePath);
-        await sendUpstream({ kind: "transfer-ready", coordinate: input.coordinate });
-        if ((await receive(input.coordinate, "promote")).kind === "reject")
-            return { status: "rejected" };
-        lease = target.promote();
-        target = undefined;
-        await sendUpstream({ kind: "ownership-acquired", coordinate: input.coordinate });
-        if ((await receive(input.coordinate, "authorize")).kind === "reject")
-            return { status: "rejected" };
-        process.disconnect?.();
-        const owned = lease;
-        lease = undefined;
-        return { status: "authorized", lease: owned };
-    }
-    finally {
-        lease?.close();
-        target?.close();
-    }
-}

package/build/core/run-control/detached-process.js

@@ -1,14 +0,0 @@
-import { spawn as nodeSpawn } from "node:child_process";
-/** Launches a process in its own POSIX process group when the platform supports it. */
-export function launchDetachedProcess(input, spawnProcess = nodeSpawn) {
-    const child = spawnProcess(input.command, input.args, {
-        ...input.options,
-        detached: process.platform !== "win32",
-    });
-    if (child.pid === undefined) {
-        throw new Error("detached process did not expose a process id");
-    }
-    if (input.unref)
-        child.unref();
-    return child;
-}

package/build/core/run-control/index.js

@@ -1,6 +0,0 @@
-export { PROCESS_GROUP_KILL_GRACE_MS, ProcessTreeTerminationError, ownedProcessIdentity, ownedProcessIsLive, terminateOwnedProcess, terminateProcessGroup, } from "./process-tree.js";
-export { launchDetachedProcess, } from "./detached-process.js";
-export { openDetachedLeaseBootstrap, receiveDetachedLease, RUN_CONTROL_BOOTSTRAP_ENV, } from "./detached-lease-bootstrap.js";
-export { initializeRunnerLeaseDatabase, acquireRunnerLease, acquireRunnerLeaseTransferTarget, acquireRunnerLostProof, observeRunnerLease, RunnerLeaseUnavailableError, } from "./runner-lease.js";
-export { beginConnectionBoundRunnerClose, } from "./connection-bound-close.js";
-export { acquireSqliteProcessLifetimeLock, initializeSqliteProcessLifetimeLockDatabase, isSqliteProcessLifetimeLockContention, openSqliteProcessLifetimeLockTransaction, SqliteProcessLifetimeLockError, sqliteProcessLifetimeLockErrorDetail, } from "./sqlite-process-lifetime-lock.js";

package/build/core/run-control/process-tree.js

@@ -1,139 +0,0 @@
-import { execFile } from "node:child_process";
-export const PROCESS_GROUP_KILL_GRACE_MS = 10_000;
-const PROCESS_DISAPPEARANCE_POLL_MS = 25;
-export class ProcessTreeTerminationError extends Error {
-    code = "TREE_TERMINATION_FAILED";
-    constructor(message, options) {
-        super(message, options);
-        this.name = "ProcessTreeTerminationError";
-    }
-}
-function defaultWait(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function isMissingProcessError(error) {
-    return Boolean(error && typeof error === "object" && "code" in error && error.code === "ESRCH");
-}
-export function ownedProcessIdentity(child, platform = process.platform) {
-    if (!child.pid)
-        return undefined;
-    return { pid: child.pid, platform: platform === "win32" ? "win32" : "posix" };
-}
-export function ownedProcessIsLive(identity) {
-    try {
-        process.kill(identity.platform === "posix" ? -identity.pid : identity.pid, 0);
-        return true;
-    }
-    catch (error) {
-        return !isMissingProcessError(error);
-    }
-}
-function signalOwnedProcess(identity, signal) {
-    try {
-        process.kill(identity.platform === "posix" ? -identity.pid : identity.pid, signal);
-    }
-    catch (error) {
-        if (!isMissingProcessError(error))
-            throw error;
-    }
-}
-async function waitForDisappearance(identity, timeoutMs, wait) {
-    const deadline = Date.now() + timeoutMs;
-    while (ownedProcessIsLive(identity)) {
-        const remaining = deadline - Date.now();
-        if (remaining <= 0)
-            return false;
-        await wait(Math.min(PROCESS_DISAPPEARANCE_POLL_MS, remaining));
-    }
-    return true;
-}
-function waitForChildClose(child) {
-    return new Promise((resolve) => {
-        child.once("close", resolve);
-        child.once("error", resolve);
-    });
-}
-function defaultTaskkill(pid) {
-    return new Promise((resolve, reject) => {
-        execFile("taskkill", ["/PID", String(pid), "/T", "/F"], { windowsHide: true }, (error) => {
-            if (error)
-                reject(error);
-            else
-                resolve();
-        });
-    });
-}
-async function terminateIdentity(identity, options) {
-    if (!ownedProcessIsLive(identity))
-        return;
-    if (identity.platform === "win32") {
-        try {
-            await options.taskkill(identity.pid);
-        }
-        catch (error) {
-            if (!ownedProcessIsLive(identity))
-                return;
-            throw error;
-        }
-        if (!await waitForDisappearance(identity, options.graceMs, options.wait)) {
-            throw new Error(`owned process tree ${identity.pid} remained after taskkill`);
-        }
-        return;
-    }
-    signalOwnedProcess(identity, "SIGTERM");
-    if (await waitForDisappearance(identity, options.graceMs, options.wait))
-        return;
-    signalOwnedProcess(identity, "SIGKILL");
-    if (!await waitForDisappearance(identity, options.graceMs, options.wait)) {
-        throw new Error(`owned process group ${identity.pid} remained after SIGKILL`);
-    }
-}
-/** Terminate an orphaned process identity retained by caller-owned coordination. */
-export async function terminateOwnedProcess(identity, options = {}) {
-    try {
-        await terminateIdentity(identity, {
-            graceMs: options.graceMs ?? PROCESS_GROUP_KILL_GRACE_MS,
-            wait: options.wait ?? defaultWait,
-            taskkill: options.taskkill ?? defaultTaskkill,
-        });
-    }
-    catch (error) {
-        throw new ProcessTreeTerminationError(error instanceof Error ? error.message : String(error), { cause: error });
-    }
-}
-/** Terminate a detached child tree, then await group disappearance and pipe-draining close. */
-export async function terminateProcessGroup(child, options = {}) {
-    const graceMs = options.graceMs ?? PROCESS_GROUP_KILL_GRACE_MS;
-    const wait = options.wait ?? defaultWait;
-    const platform = options.platform ?? process.platform;
-    const identity = ownedProcessIdentity(child, platform);
-    const closed = waitForChildClose(child);
-    try {
-        if (platform === "win32" && identity) {
-            await Promise.all([
-                (options.taskkill ?? defaultTaskkill)(identity.pid),
-                closed,
-            ]);
-            return;
-        }
-        if (identity) {
-            await Promise.all([
-                terminateIdentity(identity, {
-                    graceMs,
-                    wait,
-                    taskkill: options.taskkill ?? defaultTaskkill,
-                }),
-                closed,
-            ]);
-            return;
-        }
-        child.kill("SIGTERM");
-        await wait(graceMs);
-        if (child.exitCode === null && child.signalCode === null)
-            child.kill("SIGKILL");
-        await closed;
-    }
-    catch (error) {
-        throw new ProcessTreeTerminationError(error instanceof Error ? error.message : String(error), { cause: error });
-    }
-}

package/build/core/run-control/runner-lease.js

@@ -1,172 +0,0 @@
-import { initializeSqliteProcessLifetimeLockDatabase, isSqliteProcessLifetimeLockContention, openSqliteProcessLifetimeLockTransaction, SqliteProcessLifetimeLockError, sqliteProcessLifetimeLockErrorDetail, } from "./sqlite-process-lifetime-lock.js";
-export class RunnerLeaseUnavailableError extends Error {
-    code = "RUNNER_LEASE_UNAVAILABLE";
-    constructor(message, options) {
-        super(message, options);
-        this.name = "RunnerLeaseUnavailableError";
-    }
-}
-function errorDetail(error) {
-    return sqliteProcessLifetimeLockErrorDetail(error);
-}
-function isContention(error) {
-    return isSqliteProcessLifetimeLockContention(error)
-        || (error instanceof SqliteProcessLifetimeLockError && error.reason === "busy");
-}
-function openGuard(lockPath, busyTimeoutMs) {
-    return openSqliteProcessLifetimeLockTransaction({ path: lockPath, mode: "deferred", busyTimeoutMs });
-}
-function openReservation(lockPath, busyTimeoutMs) {
-    return openSqliteProcessLifetimeLockTransaction({ path: lockPath, mode: "immediate", busyTimeoutMs });
-}
-function closeTransaction(transaction) {
-    try {
-        transaction.close();
-    }
-    catch (error) {
-        return error;
-    }
-}
-function createHeldLock(lockPath, busyTimeoutMs, guard, initialReservation) {
-    let closed = false;
-    let reservation = initialReservation;
-    return {
-        releaseReservationForTransfer() {
-            if (closed || reservation === undefined)
-                return;
-            const released = reservation;
-            reservation = undefined;
-            const failure = closeTransaction(released);
-            if (failure !== undefined)
-                throw new RunnerLeaseUnavailableError(`runner lease reservation release failed: ${errorDetail(failure)}`, { cause: failure });
-        },
-        reclaimReservation() {
-            if (closed || reservation !== undefined)
-                return;
-            try {
-                reservation = openReservation(lockPath, busyTimeoutMs);
-            }
-            catch (error) {
-                throw new RunnerLeaseUnavailableError(`runner lease reservation reclaim failed: ${errorDetail(error)}`, { cause: error });
-            }
-        },
-        close() {
-            if (closed)
-                return;
-            closed = true;
-            let failure;
-            if (reservation !== undefined)
-                failure = closeTransaction(reservation);
-            failure ??= closeTransaction(guard);
-            if (failure !== undefined)
-                throw new RunnerLeaseUnavailableError(`runner lease release failed: ${errorDetail(failure)}`, { cause: failure });
-        },
-    };
-}
-function unavailable(operation, error) {
-    return new RunnerLeaseUnavailableError(`${operation}: ${errorDetail(error)}`, { cause: error });
-}
-export function initializeRunnerLeaseDatabase(leasePath) {
-    try {
-        return initializeSqliteProcessLifetimeLockDatabase(leasePath);
-    }
-    catch (error) {
-        throw unavailable("runner lease database could not be initialized", error);
-    }
-}
-export function acquireRunnerLease(lockPath, busyTimeoutMs = 0) {
-    let guard;
-    try {
-        guard = openGuard(lockPath, busyTimeoutMs);
-    }
-    catch (error) {
-        throw unavailable("runner lease database could not be opened", error);
-    }
-    try {
-        return createHeldLock(lockPath, busyTimeoutMs, guard, openReservation(lockPath, busyTimeoutMs));
-    }
-    catch (error) {
-        closeTransaction(guard);
-        if (isContention(error))
-            throw new RunnerLeaseUnavailableError("runner lease is already held", { cause: error });
-        throw unavailable("runner lease acquisition failed", error);
-    }
-}
-export function acquireRunnerLeaseTransferTarget(lockPath, busyTimeoutMs = 0) {
-    let guard;
-    try {
-        guard = openGuard(lockPath, busyTimeoutMs);
-    }
-    catch (error) {
-        throw unavailable("runner lease transfer acquisition failed", error);
-    }
-    let closed = false;
-    return {
-        promote() {
-            if (closed)
-                throw new RunnerLeaseUnavailableError("runner lease transfer target is closed");
-            try {
-                const reservation = openReservation(lockPath, busyTimeoutMs);
-                closed = true;
-                return createHeldLock(lockPath, busyTimeoutMs, guard, reservation);
-            }
-            catch (error) {
-                throw unavailable("runner lease transfer promotion failed", error);
-            }
-        },
-        close() {
-            if (closed)
-                return;
-            closed = true;
-            const failure = closeTransaction(guard);
-            if (failure !== undefined)
-                throw unavailable("runner lease transfer release failed", failure);
-        },
-    };
-}
-export function acquireRunnerLostProof(lockPath, busyTimeoutMs = 0) {
-    let transaction;
-    try {
-        transaction = openSqliteProcessLifetimeLockTransaction({ path: lockPath, mode: "exclusive", busyTimeoutMs });
-    }
-    catch (error) {
-        if (isContention(error))
-            throw new RunnerLeaseUnavailableError("runner lease is already held", { cause: error });
-        throw unavailable("runner lost proof acquisition failed", error);
-    }
-    let closed = false;
-    return {
-        close() {
-            if (closed)
-                return;
-            closed = true;
-            const failure = closeTransaction(transaction);
-            if (failure !== undefined)
-                throw unavailable("runner lost proof release failed", failure);
-        },
-    };
-}
-/** Positive death probe without creating a missing lock database. */
-export function observeRunnerLease(lockPath) {
-    let probe;
-    try {
-        probe = openSqliteProcessLifetimeLockTransaction({ path: lockPath, mode: "exclusive", busyTimeoutMs: 0 });
-        return { state: "released" };
-    }
-    catch (error) {
-        if (isContention(error))
-            return { state: "held" };
-        const detail = errorDetail(error);
-        return {
-            state: "unknown",
-            reason: detail.includes("rollback-journal") ? "unsupported-journal-mode" : "probe-failed",
-            detail,
-        };
-    }
-    finally {
-        try {
-            probe?.close();
-        }
-        catch { /* no probe cleanup result is death evidence */ }
-    }
-}