@astrosheep/keiyaku 2.9.12 → 4.0.0

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

@@ -1,305 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { DatabaseSync } from "node:sqlite";
-import { z } from "zod";
-const COORDINATION_SCHEMA_VERSION = 1;
-const MAX_RECEIPT_BYTES = 1_048_576;
-const DATABASE_BUSY_TIMEOUT_MS = 5_000;
-export const VERIFICATION_COMPLETED_RECEIPT_LIMIT = 8;
-const outputTailSchema = z.object({
-    tail: z.string(),
-    truncated: z.boolean(),
-    omittedBytes: z.number().int().nonnegative(),
-}).strict();
-const executionSchema = z.discriminatedUnion("status", [
-    z.object({
-        status: z.literal("executed"),
-        code: z.number().int(),
-        durationMs: z.number().nonnegative(),
-        stdout: outputTailSchema,
-        stderr: outputTailSchema,
-    }).strict(),
-    z.object({
-        status: z.literal("runner_failed"),
-        durationMs: z.number().nonnegative(),
-        stdout: outputTailSchema,
-        stderr: outputTailSchema,
-        cause: z.object({
-            code: z.enum(["SPAWN_FAILED", "PROCESS_TERMINATED", "TIMED_OUT", "CANCELLED", "TREE_TERMINATION_FAILED"]),
-            message: z.string(),
-        }).strict(),
-    }).strict(),
-]);
-const resultSchema = z.object({
-    source: z.enum(["contract", "repository-gate"]),
-    label: z.string(),
-    declaration: z.string(),
-    command: z.string(),
-    args: z.array(z.string()),
-    shell: z.boolean(),
-    timeoutMs: z.number().int().positive(),
-    candidate: z.object({ head: z.string(), tree: z.string() }).strict(),
-    executor: z.string(),
-    execution: executionSchema,
-}).strict();
-const receiptSchema = z.object({
-    version: z.literal(COORDINATION_SCHEMA_VERSION),
-    results: z.array(resultSchema),
-}).strict();
-function processIsLive(pid) {
-    if (pid <= 0)
-        return false;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        return !(error && typeof error === "object" && "code" in error && error.code === "ESRCH");
-    }
-}
-function rollbackQuietly(database) {
-    try {
-        database.exec("ROLLBACK");
-    }
-    catch { }
-}
-function pragmaNumber(database, name) {
-    const row = database.prepare(`PRAGMA ${name}`).get();
-    const value = row ? Object.values(row)[0] : undefined;
-    if (typeof value !== "number" && typeof value !== "bigint") {
-        throw new Error(`verification coordination PRAGMA ${name} is invalid`);
-    }
-    return Number(value);
-}
-function initializeOrValidate(database) {
-    database.exec("BEGIN EXCLUSIVE");
-    try {
-        const version = pragmaNumber(database, "user_version");
-        const objects = database.prepare(`
-      SELECT name, type FROM sqlite_schema
-      WHERE name NOT LIKE 'sqlite_%' ORDER BY name
-    `).all();
-        if (version === 0 && objects.length === 0) {
-            database.exec(`
-        CREATE TABLE verification_coordination_schema (
-          singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
-          version INTEGER NOT NULL CHECK (version = ${COORDINATION_SCHEMA_VERSION})
-        ) STRICT;
-        CREATE TABLE verification_executions (
-          fingerprint TEXT PRIMARY KEY CHECK (length(fingerprint) = 64),
-          owner_token TEXT NOT NULL CHECK (length(owner_token) > 0),
-          owner_pid INTEGER NOT NULL CHECK (owner_pid >= 0),
-          started_at_ms INTEGER NOT NULL CHECK (started_at_ms >= 0),
-          supervisor_pid INTEGER CHECK (supervisor_pid IS NULL OR supervisor_pid > 0),
-          supervisor_platform TEXT CHECK (supervisor_platform IS NULL OR supervisor_platform IN ('posix', 'win32')),
-          completed_at_ms INTEGER CHECK (completed_at_ms IS NULL OR completed_at_ms >= 0),
-          receipt_json TEXT CHECK (receipt_json IS NULL OR json_valid(receipt_json)),
-          CHECK ((supervisor_pid IS NULL) = (supervisor_platform IS NULL)),
-          CHECK ((receipt_json IS NULL) = (completed_at_ms IS NULL)),
-          CHECK (receipt_json IS NULL OR (owner_pid = 0 AND supervisor_pid IS NULL))
-        ) STRICT;
-      `);
-            database.prepare("INSERT INTO verification_coordination_schema (singleton, version) VALUES (1, ?)")
-                .run(COORDINATION_SCHEMA_VERSION);
-            database.exec(`PRAGMA user_version = ${COORDINATION_SCHEMA_VERSION}`);
-        }
-        else if (version !== COORDINATION_SCHEMA_VERSION) {
-            throw new Error(`incompatible verification coordination schema version ${version}; expected ${COORDINATION_SCHEMA_VERSION}`);
-        }
-        const signature = database.prepare(`
-      SELECT name, type FROM sqlite_schema
-      WHERE name NOT LIKE 'sqlite_%' ORDER BY name
-    `).all().map((object) => {
-            const row = object;
-            return `${row.type}:${row.name}`;
-        }).join(",");
-        if (signature !== "table:verification_coordination_schema,table:verification_executions") {
-            throw new Error(`verification coordination schema contains unexpected objects: ${signature || "none"}`);
-        }
-        const columns = database.prepare("PRAGMA table_info(verification_executions)").all();
-        const columnSignature = columns
-            .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
-            .join(",");
-        if (columnSignature !== "fingerprint:TEXT:1:1,owner_token:TEXT:1:0,owner_pid:INTEGER:1:0,started_at_ms:INTEGER:1:0,supervisor_pid:INTEGER:0:0,supervisor_platform:TEXT:0:0,completed_at_ms:INTEGER:0:0,receipt_json:TEXT:0:0") {
-            throw new Error("verification coordination execution schema is malformed");
-        }
-        const metadata = database.prepare("SELECT singleton, version FROM verification_coordination_schema").all();
-        if (metadata.length !== 1 || Number(metadata[0].singleton) !== 1 || Number(metadata[0].version) !== COORDINATION_SCHEMA_VERSION) {
-            throw new Error("verification coordination schema metadata is malformed");
-        }
-        const quickCheck = database.prepare("PRAGMA quick_check").get();
-        if (!quickCheck || Object.values(quickCheck)[0] !== "ok") {
-            throw new Error("verification coordination database failed quick_check");
-        }
-        database.exec("COMMIT");
-    }
-    catch (error) {
-        rollbackQuietly(database);
-        throw error;
-    }
-}
-function parseReceipt(raw) {
-    if (Buffer.byteLength(raw) > MAX_RECEIPT_BYTES)
-        throw new Error("verification receipt exceeds its size bound");
-    return receiptSchema.parse(JSON.parse(raw)).results;
-}
-function serializeReceipt(results) {
-    const raw = JSON.stringify(receiptSchema.parse({ version: COORDINATION_SCHEMA_VERSION, results }));
-    if (Buffer.byteLength(raw) > MAX_RECEIPT_BYTES)
-        throw new Error("verification receipt exceeds its size bound");
-    return raw;
-}
-export class VerificationCoordination {
-    #databasePath;
-    constructor(repositoryRoot) {
-        const directory = path.join(repositoryRoot, ".keiyaku", "runtime");
-        fs.mkdirSync(directory, { recursive: true });
-        this.#databasePath = path.join(directory, "verification.sqlite");
-        this.#withDatabase(() => undefined);
-    }
-    fingerprint(key) {
-        return createHash("sha256").update(key).digest("hex");
-    }
-    claim(fingerprint, staleAfterMs, nowMs = Date.now()) {
-        return this.#withTransaction((database) => {
-            const row = database.prepare(`
-        SELECT owner_token, owner_pid, started_at_ms, supervisor_pid, supervisor_platform, completed_at_ms, receipt_json
-        FROM verification_executions WHERE fingerprint = ?
-      `).get(fingerprint);
-            if (row?.receipt_json !== null && row?.receipt_json !== undefined) {
-                return { status: "receipt", results: parseReceipt(row.receipt_json) };
-            }
-            const token = randomUUID();
-            if (!row) {
-                database.prepare(`
-          INSERT INTO verification_executions
-            (fingerprint, owner_token, owner_pid, started_at_ms, supervisor_pid, supervisor_platform, completed_at_ms, receipt_json)
-          VALUES (?, ?, ?, ?, NULL, NULL, NULL, NULL)
-        `).run(fingerprint, token, process.pid, nowMs);
-                return { status: "owner", token };
-            }
-            const ownerPid = Number(row.owner_pid);
-            const stale = nowMs - Number(row.started_at_ms) > staleAfterMs;
-            if (processIsLive(ownerPid) && !stale)
-                return { status: "wait" };
-            database.prepare(`
-        UPDATE verification_executions
-        SET owner_token = ?, owner_pid = ?, started_at_ms = ?
-        WHERE fingerprint = ?
-      `).run(token, process.pid, nowMs, fingerprint);
-            const platform = row.supervisor_platform;
-            const supervisorPid = row.supervisor_pid === null ? undefined : Number(row.supervisor_pid);
-            return {
-                status: "owner",
-                token,
-                ...(supervisorPid && (platform === "posix" || platform === "win32")
-                    ? { priorSupervisor: { pid: supervisorPid, platform } }
-                    : {}),
-            };
-        });
-    }
-    recordSupervisor(fingerprint, token, identity) {
-        this.#ownedUpdate(fingerprint, token, (database) => {
-            database.prepare(`
-        UPDATE verification_executions SET supervisor_pid = ?, supervisor_platform = ?
-        WHERE fingerprint = ? AND owner_token = ? AND receipt_json IS NULL
-      `).run(identity.pid, identity.platform, fingerprint, token);
-        });
-    }
-    clearSupervisor(fingerprint, token) {
-        this.#ownedUpdate(fingerprint, token, (database) => {
-            database.prepare(`
-        UPDATE verification_executions SET supervisor_pid = NULL, supervisor_platform = NULL
-        WHERE fingerprint = ? AND owner_token = ? AND receipt_json IS NULL
-      `).run(fingerprint, token);
-        });
-    }
-    complete(fingerprint, token, results, completedAtMs = Date.now()) {
-        const recoveryRequired = results.some((result) => result.execution.status === "runner_failed"
-            && result.execution.cause.code === "TREE_TERMINATION_FAILED");
-        return this.#withTransaction((database) => {
-            if (recoveryRequired) {
-                const changed = database.prepare(`
-          UPDATE verification_executions
-          SET owner_pid = 0, started_at_ms = 0
-          WHERE fingerprint = ? AND owner_token = ? AND receipt_json IS NULL
-        `).run(fingerprint, token).changes;
-                return Number(changed) === 1
-                    ? { status: "recovery-required" }
-                    : { status: "ownership-lost" };
-            }
-            const receipt = serializeReceipt(results);
-            const changed = database.prepare(`
-        UPDATE verification_executions
-        SET owner_pid = 0, supervisor_pid = NULL, supervisor_platform = NULL, completed_at_ms = ?, receipt_json = ?
-        WHERE fingerprint = ? AND owner_token = ? AND receipt_json IS NULL
-      `).run(completedAtMs, receipt, fingerprint, token).changes;
-            if (Number(changed) !== 1)
-                return { status: "ownership-lost" };
-            const countRow = database.prepare(`
-        SELECT count(*) AS count FROM verification_executions WHERE receipt_json IS NOT NULL
-      `).get();
-            const excess = Number(countRow.count) - VERIFICATION_COMPLETED_RECEIPT_LIMIT;
-            if (excess > 0) {
-                database.prepare(`
-          DELETE FROM verification_executions
-          WHERE fingerprint IN (
-            SELECT fingerprint FROM verification_executions
-            WHERE receipt_json IS NOT NULL
-            ORDER BY completed_at_ms ASC, fingerprint ASC
-            LIMIT ?
-          )
-        `).run(excess);
-            }
-            return { status: "published" };
-        });
-    }
-    releaseForTakeover(fingerprint, token) {
-        this.#withTransaction((database) => {
-            database.prepare(`
-        UPDATE verification_executions SET owner_pid = 0, started_at_ms = 0
-        WHERE fingerprint = ? AND owner_token = ? AND receipt_json IS NULL
-      `).run(fingerprint, token);
-        });
-    }
-    #ownedUpdate(fingerprint, token, update) {
-        this.#withTransaction((database) => {
-            update(database);
-            const row = database.prepare(`
-        SELECT owner_token FROM verification_executions
-        WHERE fingerprint = ? AND receipt_json IS NULL
-      `).get(fingerprint);
-            if (row?.owner_token !== token)
-                throw new Error("verification coordination ownership changed");
-        });
-    }
-    #withTransaction(operation) {
-        return this.#withDatabase((database) => {
-            database.exec("BEGIN IMMEDIATE");
-            try {
-                const result = operation(database);
-                database.exec("COMMIT");
-                return result;
-            }
-            catch (error) {
-                rollbackQuietly(database);
-                throw error;
-            }
-        });
-    }
-    #withDatabase(operation) {
-        const database = new DatabaseSync(this.#databasePath, {
-            enableDoubleQuotedStringLiterals: false,
-            allowExtension: false,
-        });
-        try {
-            database.exec(`PRAGMA busy_timeout = ${DATABASE_BUSY_TIMEOUT_MS}`);
-            initializeOrValidate(database);
-            return operation(database);
-        }
-        finally {
-            database.close();
-        }
-    }
-}

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();
-}