sparta_worlds 0.6.0

package/dist/cli/run.js

@@ -0,0 +1,266 @@
+import { spawn, spawnSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { appendFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { createServer as createNetServer } from "node:net";
+import { constants, tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { buildServer } from "#server";
+import { createAdminCall } from "./passk.js";
+import { preloadEnabled, preloadEnv } from "./preload.js";
+export class RunSetupError extends Error {
+    code;
+    constructor(message, code = 3) {
+        super(message);
+        this.code = code;
+    }
+}
+const HEALTH_TIMEOUT_MS = 15_000;
+export function pidOnPort(port) {
+    try {
+        const res = spawnSync("lsof", ["-ti", `tcp:${port}`, "-sTCP:LISTEN"], { encoding: "utf8", timeout: 3000 });
+        const first = res.stdout.trim().split("\n")[0];
+        return first && /^\d+$/.test(first) ? Number(first) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function checkPortFree(port, host) {
+    return new Promise((resolvePromise, reject) => {
+        const probe = createNetServer();
+        probe.once("error", (err) => {
+            if (err.code === "EADDRINUSE") {
+                const pid = pidOnPort(port);
+                reject(new RunSetupError(`port ${port} is in use${pid !== undefined ? ` by pid ${pid}` : ""}`));
+            }
+            else
+                reject(new RunSetupError(`port ${port} cannot be bound on ${host}: ${err.message}`));
+        });
+        probe.listen(port, host, () => probe.close(() => resolvePromise()));
+    });
+}
+export async function startServer(opts = {}) {
+    const host = opts.host ?? "127.0.0.1";
+    const log = opts.log ?? (() => { });
+    for (const [flag, dir] of [
+        ["--seeds-dir", opts.seedsDir],
+        ["--scenarios-dir", opts.scenariosDir],
+    ])
+        if (dir !== undefined && !existsSync(resolve(dir)))
+            throw new RunSetupError(`${flag} ${resolve(dir)} does not exist`);
+    if (opts.port !== undefined)
+        await checkPortFree(opts.port, host);
+    const dataDir = opts.dataDir !== undefined ? resolve(opts.dataDir) : mkdtempSync(join(tmpdir(), "worlds-run-"));
+    mkdirSync(dataDir, { recursive: true });
+    const logFile = join(dataDir, "run.log");
+    writeFileSync(logFile, "");
+    const note = (line) => {
+        appendFileSync(logFile, `${line}\n`);
+        log(line);
+    };
+    const token = `tlr_${randomBytes(32).toString("base64url")}`;
+    const server = buildServer({
+        dataDir,
+        seedsDir: opts.seedsDir,
+        scenariosDir: opts.scenariosDir,
+        auth: { mode: "required", operatorToken: token },
+    });
+    let url;
+    try {
+        url = await server.listen(opts.port ?? 0, host);
+    }
+    catch (err) {
+        await server.close().catch(() => { });
+        if (opts.dataDir === undefined)
+            rmSync(dataDir, { recursive: true, force: true });
+        const code = err.code;
+        const pid = code === "EADDRINUSE" && opts.port !== undefined ? pidOnPort(opts.port) : undefined;
+        throw new RunSetupError(code === "EADDRINUSE"
+            ? `port ${opts.port} is in use${pid !== undefined ? ` by pid ${pid}` : ""}`
+            : `the server could not start: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const deadline = Date.now() + HEALTH_TIMEOUT_MS;
+    for (;;) {
+        try {
+            const res = await fetch(`${url}/admin/health`);
+            if (res.ok)
+                break;
+        }
+        catch {
+        }
+        if (Date.now() > deadline) {
+            await server.close();
+            throw new RunSetupError(`the server did not answer ${url}/admin/health within ${HEALTH_TIMEOUT_MS / 1000}s`);
+        }
+        await new Promise((r) => setTimeout(r, 50));
+    }
+    note(`run: worlds server at ${url} (auth required; data ${dataDir})`);
+    let closed = false;
+    return {
+        url,
+        token,
+        dataDir,
+        logFile,
+        admin: createAdminCall(url, token),
+        note,
+        close: async () => {
+            if (closed)
+                return;
+            closed = true;
+            await server.close();
+            if (opts.keep)
+                log(`run: kept ${dataDir} (the worlds' files; worlds serve --data-dir ${dataDir} reopens them)`);
+            else if (opts.dataDir === undefined)
+                rmSync(dataDir, { recursive: true, force: true });
+        },
+    };
+}
+export async function exportEvidence(s, dir) {
+    const written = [];
+    mkdirSync(dir, { recursive: true });
+    let worlds = [];
+    try {
+        worlds = (await s.admin("GET", "/admin/worlds")).worlds;
+        writeFileSync(join(dir, "worlds.json"), `${JSON.stringify(worlds, null, 2)}\n`);
+        written.push("worlds.json");
+    }
+    catch (err) {
+        s.note(`run: could not list the worlds for the evidence: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    for (const w of worlds) {
+        for (const [file, path] of [
+            ["dump.json", `/admin/worlds/${w.world_id}/dump`],
+            ["requests.json", `/admin/worlds/${w.world_id}/requests`],
+        ]) {
+            try {
+                const body = await s.admin("GET", path);
+                mkdirSync(join(dir, w.world_id), { recursive: true });
+                writeFileSync(join(dir, w.world_id, file), `${JSON.stringify(body, null, 2)}\n`);
+                written.push(`${w.world_id}/${file}`);
+            }
+            catch (err) {
+                s.note(`run: could not capture ${path}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    try {
+        writeFileSync(join(dir, "run.log"), `${readLog(s.logFile)}`);
+        written.push("run.log");
+    }
+    catch {
+    }
+    return written;
+}
+const readLog = (file) => {
+    try {
+        return readFileSync(file, "utf8");
+    }
+    catch {
+        return "";
+    }
+};
+function killTree(child, signal) {
+    const pid = child.pid;
+    if (pid === undefined)
+        return;
+    if (process.platform === "win32") {
+        child.kill(signal === "SIGKILL" ? "SIGKILL" : "SIGTERM");
+        return;
+    }
+    try {
+        process.kill(-pid, signal);
+    }
+    catch {
+        child.kill(signal);
+    }
+}
+export async function runCommand(opts) {
+    const s = await startServer({
+        port: opts.port,
+        seedsDir: opts.seedsDir,
+        scenariosDir: opts.scenariosDir,
+        keep: opts.keep,
+        log: opts.log,
+    });
+    const env = { WORLDS_URL: s.url, WORLDS_ADMIN_TOKEN: s.token, WORLDS_PUBLIC_URL: s.url };
+    let code = 1;
+    try {
+        if (opts.seed !== undefined) {
+            let world;
+            try {
+                world = await s.admin("POST", "/admin/worlds", { seed: opts.seed });
+            }
+            catch (err) {
+                throw new RunSetupError(`--seed ${opts.seed}: ${err instanceof Error ? err.message : String(err)}`, 2);
+            }
+            Object.assign(env, {
+                WORLDS_BASE_URL: world.base_url,
+                WORLDS_API_KEY: world.api_key,
+                STRIPE_SECRET_KEY: world.api_key,
+                STRIPE_API_KEY: world.api_key,
+                WORLDS_WORLD_ID: world.world_id,
+            });
+            s.note(`run: world ${world.world_id} from ${opts.seed} — WORLDS_BASE_URL, WORLDS_API_KEY, WORLDS_WORLD_ID exported (the key as STRIPE_SECRET_KEY / STRIPE_API_KEY too)`);
+            if (preloadEnabled(opts.preload)) {
+                Object.assign(env, preloadEnv(process.env));
+                s.note("run: the SDK preload is on — a stock stripe-node or stripe-python in the command reaches the world with no host set (NODE_OPTIONS --import, PYTHONPATH; --no-preload turns it off)");
+            }
+        }
+        s.note(`run: ${opts.command.join(" ")}`);
+        const child = spawn(opts.command[0], opts.command.slice(1), {
+            stdio: "inherit",
+            env: { ...process.env, ...env },
+            detached: process.platform !== "win32",
+        });
+        let timedOut = false;
+        let signalled = null;
+        const timer = opts.timeoutSec !== undefined
+            ? setTimeout(() => {
+                timedOut = true;
+                s.note(`run: the command did not finish within ${opts.timeoutSec}s — killing its tree`);
+                killTree(child, "SIGKILL");
+            }, opts.timeoutSec * 1000)
+            : undefined;
+        const onSignal = (signal) => {
+            if (signalled)
+                return;
+            signalled = signal;
+            s.note(`run: ${signal} — stopping the command, then the server`);
+            killTree(child, signal);
+        };
+        const handlers = ["SIGINT", "SIGTERM"].map((sig) => [sig, () => onSignal(sig)]);
+        for (const [sig, h] of handlers)
+            process.on(sig, h);
+        try {
+            code = await new Promise((resolvePromise, reject) => {
+                child.on("error", (err) => reject(new RunSetupError(`could not run '${opts.command[0]}': ${err.message}`, 2)));
+                child.on("exit", (exit, signal) => {
+                    if (timedOut)
+                        resolvePromise(124);
+                    else if (exit !== null)
+                        resolvePromise(exit);
+                    else
+                        resolvePromise(128 + (signal ? (constants.signals[signal] ?? 0) : 0));
+                });
+            });
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+            for (const [sig, h] of handlers)
+                process.removeListener(sig, h);
+        }
+        s.note(`run: the command exited ${code}${timedOut ? " (timed out)" : signalled ? ` (${signalled})` : ""}`);
+        if (code !== 0 && !signalled) {
+            const dir = opts.evidence !== undefined ? resolve(opts.evidence) : mkdtempSync(join(tmpdir(), "worlds-run-evidence-"));
+            const files = await exportEvidence(s, dir);
+            opts.log(`run: evidence in ${dir} (${files.length} file${files.length === 1 ? "" : "s"}: ${files.slice(0, 4).join(", ")}${files.length > 4 ? ", …" : ""})`);
+        }
+        if (signalled)
+            code = 128 + (constants.signals[signalled] ?? 0);
+    }
+    finally {
+        await s.close();
+    }
+    return code;
+}