spawnfile 0.1.25 → 0.1.28

package/dist/cli/paideiaDelegation.js

@@ -1,211 +0,0 @@
-import { spawn } from "node:child_process";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { setTimeout as delay } from "node:timers/promises";
-import { fileURLToPath } from "node:url";
-import { trainingContextSchema } from "../compiler/training/index.js";
-import { launchTrainingContainer } from "../compiler/training/container/index.js";
-import { runTrainingDocker } from "../compiler/training/container/process.js";
-import { prepareTraining } from "../compiler/training/preparation/index.js";
-import { readBoundedJson } from "../compiler/training/preparation/inputs.js";
-import { SpawnfileError } from "../shared/index.js";
-const MAX_LINE_BYTES = 1024 * 1024;
-const validReceipt = (line, dryRun) => {
-    try {
-        const value = JSON.parse(line);
-        if (typeof value !== "object" || value === null)
-            return false;
-        const receipt = value;
-        return dryRun
-            ? receipt.schema === "paideia.training-cost-plan.v1" && receipt.modelCallsMade === 0
-            : receipt.status === "completed" && typeof receipt.index === "string" && receipt.index.length > 0;
-    }
-    catch {
-        return false;
-    }
-};
-const failure = (message) => new SpawnfileError("runtime_error", message);
-const runChild = (options, contextPath) => new Promise((resolve, reject) => {
-    if (options.signal?.aborted) {
-        resolve(130);
-        return;
-    }
-    // Node strips types in a source checkout; the packaged build selects its emitted JS.
-    const extension = path.extname(fileURLToPath(import.meta.url));
-    const supervisor = fileURLToPath(new URL(`./paideiaSupervisor${extension}`, import.meta.url));
-    const child = spawn(process.execPath, ["--experimental-strip-types", supervisor, options.command,
-        "train", "--spawnfile-context", contextPath, ...options.args], {
-        shell: false, detached: true, stdio: ["ignore", "pipe", "pipe", "ipc"]
-    });
-    const pid = child.pid;
-    let stdout = "", stderr = "", lastLine = "";
-    let stopCode, error, outcome;
-    let reaped = false, closed = false, finished = false;
-    let killTimer;
-    const kill = (signal) => {
-        if (pid === undefined || reaped)
-            return;
-        try {
-            process.kill(-pid, signal);
-        }
-        catch (caught) {
-            if (caught.code !== "ESRCH")
-                error = failure("Could not signal the owned Paideia process group");
-        }
-    };
-    const groupExists = () => {
-        if (pid === undefined)
-            return false;
-        try {
-            process.kill(-pid, 0);
-            return true;
-        }
-        catch (caught) {
-            return caught.code !== "ESRCH";
-        }
-    };
-    const stop = (code, cause) => {
-        if (stopCode !== undefined)
-            return;
-        stopCode = code;
-        error = cause;
-        kill("SIGTERM");
-        killTimer = setTimeout(() => kill("SIGKILL"), 1000);
-        killTimer.unref();
-    };
-    const interrupt = () => stop(130), terminate = () => stop(143), abort = () => stop(130);
-    const timer = setTimeout(() => stop(1, failure("Paideia training exceeded its command deadline")), options.timeoutMs);
-    timer.unref();
-    process.once("SIGINT", interrupt);
-    process.once("SIGTERM", terminate);
-    options.signal?.addEventListener("abort", abort, { once: true });
-    if (options.signal?.aborted)
-        abort();
-    const consume = (chunk, channel) => {
-        const lines = ((channel === "stdout" ? stdout : stderr) + chunk).split("\n");
-        const remainder = lines.pop();
-        if ([remainder, ...lines].some((line) => Buffer.byteLength(line, "utf8") > MAX_LINE_BYTES)) {
-            stop(1, failure("Paideia output exceeded the bounded JSON-line contract"));
-            return;
-        }
-        for (const raw of lines) {
-            const line = raw.replace(/\r$/u, "");
-            if (!line.trim())
-                continue;
-            if (channel === "stdout")
-                lastLine = line;
-            options.streams[channel](line);
-        }
-        if (channel === "stdout")
-            stdout = remainder;
-        else
-            stderr = remainder;
-    };
-    child.stdout.setEncoding("utf8").on("data", (chunk) => consume(chunk, "stdout"));
-    child.stderr.setEncoding("utf8").on("data", (chunk) => consume(chunk, "stderr"));
-    child.once("message", (message) => {
-        outcome = message;
-        if (message.type === "paideia.process.launch-error")
-            error = failure(`Could not start Paideia: ${message.message}`);
-        // The native child exited, but our supervisor still holds the group identity.
-        // Stop stragglers before permitting its leader to disappear or reporting completion.
-        kill("SIGKILL");
-    });
-    const finish = async () => {
-        if (finished)
-            return;
-        finished = true;
-        clearTimeout(timer);
-        clearTimeout(killTimer);
-        process.removeListener("SIGINT", interrupt);
-        process.removeListener("SIGTERM", terminate);
-        options.signal?.removeEventListener("abort", abort);
-        const deadline = Date.now() + 1500;
-        // Check only: never signal a numeric group identity after its supervisor was reaped.
-        while ((groupExists() || !closed) && Date.now() < deadline)
-            await delay(20);
-        if (groupExists() || !closed) {
-            error = failure("Paideia process cleanup is incomplete; group or output quiescence is unknown");
-            child.stdout.destroy();
-            child.stderr.destroy();
-        }
-        if (stdout.trim()) {
-            lastLine = stdout;
-            options.streams.stdout(stdout);
-        }
-        if (stderr.trim())
-            options.streams.stderr(stderr);
-        if (error) {
-            reject(error);
-            return;
-        }
-        if (stopCode !== undefined) {
-            resolve(stopCode);
-            return;
-        }
-        if (outcome?.type !== "paideia.process.exited") {
-            reject(failure("Paideia supervisor exited without a native outcome"));
-            return;
-        }
-        if (outcome.signal) {
-            resolve(outcome.signal === "SIGINT" ? 130 : outcome.signal === "SIGTERM" ? 143 : 1);
-            return;
-        }
-        const exitCode = outcome.code ?? 1;
-        if ((exitCode === 0 || exitCode === 1) && !validReceipt(lastLine, options.dryRun)) {
-            reject(failure("Paideia exited without the required final training receipt"));
-            return;
-        }
-        resolve(exitCode);
-    };
-    child.once("error", (caught) => { error = failure(`Could not start Paideia supervisor: ${caught.message}`); });
-    child.once("exit", () => { reaped = true; void finish(); });
-    child.once("close", () => { closed = true; void finish(); });
-});
-/** Delegates through the public CLI, never importing Paideia or selecting a fallback adapter. */
-export const delegatePaideiaTraining = async (options) => {
-    if (options.signal?.aborted)
-        return 130;
-    if (options.repairWitness && !options.repairMeasurements)
-        throw failure("--repair-witness requires --repair-measurements");
-    if (options.trainingConfig) {
-        const config = await readBoundedJson(options.trainingConfig);
-        // Image declarations go through preparation; lowered launch configurations go straight to Docker.
-        if (config.version === "spawnfile.training-container.v2" || (["spawnfile.training-container.v3", "spawnfile.training-container.v4"].includes(String(config.version)) && config.image !== undefined)) {
-            if (options.trainingImage && !options.execution)
-                throw failure("V2 owns its image declaration; --training-image is only for v1");
-            const prepared = await prepareTraining({ configPath: options.trainingConfig, context: options.context, args: options.args,
-                repairMeasurements: options.repairMeasurements, repairWitness: options.repairWitness,
-                execution: options.execution, outputOverride: options.execution?.output, imageOverride: options.execution ? options.trainingImage : undefined,
-                dryRun: options.dryRun, process: runTrainingDocker, timeoutMs: options.timeoutMs, signal: options.signal, streams: options.streams });
-            if (!("dryRun" in prepared))
-                return launchTrainingContainer({ ...prepared,
-                    timeoutMs: options.timeoutMs, signal: options.signal, streams: options.streams });
-            options.streams.stderr(`Training preparation plan ${prepared.digest}; no Docker, auth or filesystem mutations`);
-            options = { ...options, repairMeasurements: undefined, repairWitness: undefined };
-        }
-    }
-    if (options.repairMeasurements)
-        throw failure("Measurement repair requires the v2 preparation declaration");
-    if (!options.dryRun) {
-        if (!options.trainingImage || !options.trainingConfig)
-            throw failure("Actual training requires --training-image and --training-config; host execution is disabled");
-        return launchTrainingContainer({ image: options.trainingImage, configPath: options.trainingConfig,
-            context: options.context, args: options.args, execution: options.execution, timeoutMs: options.timeoutMs, streams: options.streams, signal: options.signal });
-    }
-    if (process.platform === "win32")
-        throw failure("Paideia delegation requires POSIX process-group supervision");
-    const bytes = JSON.stringify(trainingContextSchema.parse(options.context));
-    if (Buffer.byteLength(bytes, "utf8") > MAX_LINE_BYTES)
-        throw new SpawnfileError("validation_error", "Training context exceeds 1 MiB");
-    const temporary = await mkdtemp(path.join(os.tmpdir(), "spawnfile-training-"));
-    const contextPath = path.join(temporary, "context.json");
-    try {
-        await writeFile(contextPath, bytes, { mode: 0o600, flag: "wx" });
-        return await runChild(options, contextPath);
-    }
-    finally {
-        await rm(temporary, { recursive: true, force: true });
-    }
-};

package/dist/cli/paideiaSupervisor.d.ts

@@ -1,17 +0,0 @@
-import { type ChildProcess } from "node:child_process";
-export type PaideiaProcessOutcome = {
-    type: "paideia.process.exited";
-    code: number | null;
-    signal: NodeJS.Signals | null;
-} | {
-    type: "paideia.process.launch-error";
-    message: string;
-};
-type SupervisorProcess = Pick<NodeJS.Process, "send" | "pid" | "on" | "removeListener" | "kill" | "exit">;
-export interface PaideiaSupervisorHost {
-    process: SupervisorProcess;
-    launch(command: string, args: string[]): ChildProcess;
-}
-/** Remains the owned group leader until the parent closes the entire group. */
-export declare const supervisePaideia: (argv: readonly string[], host?: PaideiaSupervisorHost) => (() => void);
-export {};

package/dist/cli/paideiaSupervisor.js

@@ -1,48 +0,0 @@
-import { spawn } from "node:child_process";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-const defaultHost = {
-    process,
-    launch: (command, args) => spawn(command, args, { shell: false, stdio: ["ignore", "inherit", "inherit"] })
-};
-/** Remains the owned group leader until the parent closes the entire group. */
-export const supervisePaideia = (argv, host = defaultHost) => {
-    const [command, ...args] = argv;
-    if (!command || !host.process.send)
-        throw new Error("Paideia supervisor requires an executable and private IPC");
-    const hold = setInterval(() => undefined, 1000);
-    const ignore = () => undefined;
-    const disconnect = () => {
-        // This process is still alive: its own group identity cannot have been recycled.
-        try {
-            host.process.kill(-host.process.pid, "SIGKILL");
-        }
-        finally {
-            host.process.exit(1);
-        }
-    };
-    host.process.on("SIGINT", ignore).on("SIGTERM", ignore).on("disconnect", disconnect);
-    let reported = false;
-    const report = (outcome) => {
-        if (reported)
-            return;
-        reported = true;
-        host.process.send(outcome);
-    };
-    const child = host.launch(command, args);
-    child.once("error", (error) => report({ type: "paideia.process.launch-error", message: error.message }));
-    child.once("exit", (code, signal) => report({ type: "paideia.process.exited", code, signal }));
-    return () => {
-        clearInterval(hold);
-        host.process.removeListener("SIGINT", ignore).removeListener("SIGTERM", ignore).removeListener("disconnect", disconnect);
-    };
-};
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
-    try {
-        supervisePaideia(process.argv.slice(2));
-    }
-    catch (error) {
-        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-        process.exitCode = 1;
-    }
-}