@lchase/kiln 0.0.0-stage → 0.3.0

package/dist/serve-page.js

@@ -0,0 +1,216 @@
+import { INVESTIGATION_WORKFLOW } from "./findings.js";
+import { statusDetails } from "./report.js";
+import { JOB_STATES } from "./schemas.js";
+const REFRESH_SECONDS = 3;
+export function renderInbox(css, view) {
+    const waiting = view.jobs.filter((job) => job.state === "needs-human");
+    const body = waiting.length === 0 ? emptyInbox() : waiting.map(renderInboxCard).join("\n");
+    return document({
+        css,
+        title: "Kiln inbox",
+        refresh: true,
+        current: "inbox",
+        main: `<h1>Inbox</h1>
+<p class="lede">Jobs waiting on a person. Approve and reject use the same gate as the CLI.</p>
+${body}`,
+    });
+}
+export function renderBoard(css, view) {
+    const groups = [];
+    const states = [...JOB_STATES, "invalid"];
+    for (const state of states) {
+        const jobs = view.jobs.filter((job) => job.state === state);
+        if (jobs.length === 0)
+            continue;
+        groups.push(`<section class="group" id="state-${escapeHtml(state)}">
+<h2>${escapeHtml(state)} <span class="count">${jobs.length}</span></h2>
+${jobs.map(renderBoardJob).join("\n")}
+</section>`);
+    }
+    const main = groups.length > 0
+        ? groups.join("\n")
+        : `<h1>Board</h1><p class="empty">No jobs.</p>`;
+    const titled = groups.length > 0 ? `<h1>Board</h1>\n${main}` : main;
+    return document({
+        css,
+        title: "Kiln board",
+        refresh: true,
+        current: "board",
+        main: titled,
+    });
+}
+export function renderTextPage(css, title, text) {
+    return document({
+        css,
+        title,
+        refresh: false,
+        current: "inbox",
+        main: `<a class="back" href="/">Inbox</a>
+<h1>${escapeHtml(title)}</h1>
+<pre class="text">${escapeHtml(text)}</pre>`,
+    });
+}
+export function renderMessagePage(css, title, message) {
+    return document({
+        css,
+        title,
+        refresh: false,
+        current: "inbox",
+        main: `<a class="back" href="/">Inbox</a>
+<h1>${escapeHtml(title)}</h1>
+<p class="empty">${escapeHtml(message)}</p>`,
+    });
+}
+function emptyInbox() {
+    return `<p class="empty">Nothing is waiting on a person. The <a href="/board">board</a> lists every job.</p>`;
+}
+function renderInboxCard(job) {
+    const gates = job.gates
+        .map((gate) => {
+        const asking = gate.rendered && gate.rendered !== gate.prompt ? gate.rendered : gate.prompt;
+        const artifacts = gate.artifacts.length === 0
+            ? ""
+            : `<ul class="facts">${gate.artifacts
+                .map((artifact) => `<li><span class="name">${escapeHtml(artifact.name)}</span> ${escapeHtml(artifact.summary)}</li>`)
+                .join("")}</ul>`;
+        const reviews = gate.reviews.length === 0
+            ? ""
+            : `<h4>Reviews</h4><ul class="facts">${gate.reviews
+                .map((review) => `<li><span class="name">${escapeHtml(review.name)}</span> ${escapeHtml(review.summary)}</li>`)
+                .join("")}</ul>`;
+        return `<p class="prompt">${escapeHtml(asking)}</p>${artifacts}${reviews}`;
+    })
+        .join("\n");
+    return `<article class="card" id="job-${escapeHtml(job.jobId)}">
+<h2>${escapeHtml(job.title || job.jobId)}</h2>
+<p class="meta">${escapeHtml(job.repo)} · ${escapeHtml(job.workflow)} · <code>${escapeHtml(job.jobId)}</code>${job.stack ? ' · <span class="chip">stacked</span>' : ""}</p>
+${gates}
+${resourceLinks(job)}
+${actionForms(job)}
+</article>`;
+}
+function renderBoardJob(job) {
+    const deps = job.dependsOn.length === 0
+        ? ""
+        : `<p class="deps">depends on ${job.dependsOn
+            .map((dep) => {
+            const why = dep.blockedDetail ? ` <span class="why">${escapeHtml(dep.blockedDetail)}</span>` : "";
+            return `<a href="/board#job-${encodeURIComponent(dep.jobId)}">${escapeHtml(dep.jobId)}</a> <span class="chip">${escapeHtml(dep.state)}</span>${why}`;
+        })
+            .join(", ")}</p>`;
+    const pr = job.prUrl && (job.state === "in-review" || job.state === "done" || job.state === "failed")
+        ? renderPr(job.prUrl)
+        : "";
+    const details = statusDetails(job);
+    const detailList = details.length === 0
+        ? ""
+        : `<ul class="details">${details
+            .map((line) => `<li class="${detailClass(job.state, line)}">${escapeHtml(line)}</li>`)
+            .join("")}</ul>`;
+    return `<article class="job" id="job-${escapeHtml(job.jobId)}">
+<h3>${escapeHtml(job.title || job.jobId)}</h3>
+<p class="meta">${escapeHtml(job.repo)} · ${escapeHtml(job.workflow)} · <code>${escapeHtml(job.jobId)}</code></p>
+<p class="chips"><span class="chip state-${escapeHtml(job.state)}">${escapeHtml(job.state)}</span>${job.stack ? '<span class="chip">stacked</span>' : ""}</p>
+${deps}
+${pr}
+${detailList}
+${resourceLinks(job)}
+</article>`;
+}
+function detailClass(state, line) {
+    if (line.startsWith("source ") ||
+        line.startsWith("gate ") ||
+        line.startsWith("approve:") ||
+        line.startsWith("reject:") ||
+        line.startsWith("waiting ") ||
+        line.startsWith("blocked on ") ||
+        line.startsWith("fix:")) {
+        return "";
+    }
+    if (state === "failed" || state === "dead")
+        return "bad";
+    return "";
+}
+function renderPr(url) {
+    const safe = httpUrl(url);
+    if (!safe)
+        return `<p class="links">${escapeHtml(url)}</p>`;
+    return `<p class="links"><a href="${escapeHtml(safe)}">Pull request</a></p>`;
+}
+function resourceLinks(job) {
+    const links = [];
+    const id = encodeURIComponent(job.jobId);
+    if (job.specPath)
+        links.push(`<a href="/jobs/${id}/spec">Spec</a>`);
+    if (job.logPath)
+        links.push(`<a href="/jobs/${id}/log">Log</a>`);
+    if (job.workflow === INVESTIGATION_WORKFLOW)
+        links.push(`<a href="/jobs/${id}/findings">Findings</a>`);
+    if (links.length === 0)
+        return "";
+    return `<p class="links">${links.join(" ")}</p>`;
+}
+function actionForms(job) {
+    const forms = [];
+    const id = encodeURIComponent(job.jobId);
+    if (job.canApprove) {
+        forms.push(`<form method="post" action="/api/jobs/${id}/approve"><button class="approve" type="submit">Approve</button></form>`);
+    }
+    if (job.canReject) {
+        forms.push(`<form method="post" action="/api/jobs/${id}/reject"><button class="reject" type="submit">Reject</button></form>`);
+    }
+    if (forms.length === 0)
+        return "";
+    return `<div class="actions">${forms.join("")}</div>`;
+}
+function document(options) {
+    const refresh = options.refresh
+        ? `<meta http-equiv="refresh" content="${REFRESH_SECONDS}">`
+        : "";
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="referrer" content="same-origin">
+${refresh}
+<title>${escapeHtml(options.title)}</title>
+<style>
+${options.css}
+</style>
+</head>
+<body>
+<header class="top">
+  <a class="kiln-mark" href="/">Kiln</a>
+  <nav>
+    <a href="/" ${options.current === "inbox" ? 'aria-current="page"' : ""}>Inbox</a>
+    <a href="/board" ${options.current === "board" ? 'aria-current="page"' : ""}>Board</a>
+  </nav>
+  ${options.refresh ? `<p class="refresh">Refreshes every ${REFRESH_SECONDS}s</p>` : ""}
+</header>
+<main>
+${options.main}
+</main>
+</body>
+</html>
+`;
+}
+export function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+function httpUrl(value) {
+    try {
+        const url = new URL(value);
+        if (url.protocol === "http:" || url.protocol === "https:")
+            return url.href;
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}

package/dist/serve.js

@@ -0,0 +1,351 @@
+import { createServer } from "node:http";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { join, resolve, sep } from "node:path";
+import { answerJob, readStatus, runTick } from "./driver.js";
+import { INVESTIGATION_WORKFLOW } from "./findings.js";
+import { packageRoot } from "./paths.js";
+import { renderBoard, renderInbox, renderMessagePage, renderTextPage } from "./serve-page.js";
+const BODY_LIMIT = 65_536;
+const TEXT_LIMIT = 100_000;
+const JOB_ID = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+/**
+ * Local UI over the same derived job view as `kiln status`.
+ * Listens on 127.0.0.1 only. Resolves when the process is signalled.
+ */
+export function startServe(options) {
+    const css = loadServeCss();
+    const secrets = secretValues(options.config);
+    let port = options.port;
+    return new Promise((resolvePromise, reject) => {
+        const server = createServer((req, res) => {
+            void handle(req, res, options.config, () => port, css, secrets).catch((error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                const status = statusCode(error) ?? 500;
+                sendJson(res, status, { error: redact(message, secrets) }, secrets);
+            });
+        });
+        server.on("error", reject);
+        let stopped = false;
+        let timer;
+        let firstTick;
+        const shutdown = () => {
+            if (stopped)
+                return;
+            stopped = true;
+            if (timer)
+                clearInterval(timer);
+            if (firstTick)
+                clearTimeout(firstTick);
+            server.close(() => resolvePromise());
+        };
+        process.once("SIGINT", shutdown);
+        process.once("SIGTERM", shutdown);
+        server.listen(options.port, "127.0.0.1", () => {
+            const address = server.address();
+            if (!address || typeof address === "string") {
+                reject(new Error("kiln serve did not bind a TCP port."));
+                return;
+            }
+            port = address.port;
+            process.stdout.write(`listening http://${address.address}:${address.port}\n`);
+            if (options.tickSeconds === undefined)
+                return;
+            const tick = () => {
+                if (stopped)
+                    return;
+                safeTick(options.config, secrets);
+            };
+            firstTick = setTimeout(tick, 0);
+            timer = setInterval(tick, options.tickSeconds * 1000);
+        });
+    });
+}
+export function loadServeCss() {
+    const path = join(packageRoot(), "assets", "serve.css");
+    if (!existsSync(path)) {
+        throw new Error(`Kiln serve stylesheet is missing at ${path}.`);
+    }
+    return readFileSync(path, "utf8");
+}
+function safeTick(config, secrets) {
+    try {
+        runTick(config);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`tick: ${redact(message, secrets)}\n`);
+    }
+}
+async function handle(req, res, config, boundPort, css, secrets) {
+    const method = req.method ?? "GET";
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    const path = url.pathname;
+    if (method === "GET" && path === "/favicon.ico") {
+        res.writeHead(204, { Connection: "close", "Cache-Control": "no-store" });
+        res.end();
+        return;
+    }
+    if (method === "POST") {
+        await drain(req);
+        if (!originAllowed(req, boundPort())) {
+            sendJson(res, 403, { error: "Cross-origin request rejected." }, secrets);
+            return;
+        }
+        const action = /^\/api\/jobs\/([^/]+)\/(approve|reject)$/.exec(path);
+        if (!action?.[1] || (action[2] !== "approve" && action[2] !== "reject")) {
+            sendJson(res, 404, { error: "Not found." }, secrets);
+            return;
+        }
+        const jobId = parseJobId(action[1]);
+        if (!jobId) {
+            sendJson(res, 404, { error: "Not found." }, secrets);
+            return;
+        }
+        await answer(req, res, config, css, secrets, jobId, action[2]);
+        return;
+    }
+    if (method !== "GET" && method !== "HEAD") {
+        sendJson(res, 405, { error: "Method not allowed." }, secrets);
+        return;
+    }
+    if (path === "/" || path === "") {
+        sendHtml(res, 200, renderInbox(css, readStatus(config)), secrets);
+        return;
+    }
+    if (path === "/board") {
+        sendHtml(res, 200, renderBoard(css, readStatus(config)), secrets);
+        return;
+    }
+    if (path === "/api/jobs") {
+        sendJson(res, 200, readStatus(config), secrets);
+        return;
+    }
+    const apiJob = /^\/api\/jobs\/([^/]+)$/.exec(path);
+    if (apiJob?.[1]) {
+        const jobId = parseJobId(apiJob[1]);
+        const job = jobId ? findJob(config, jobId) : undefined;
+        if (!job) {
+            sendJson(res, 404, { error: jobId ? `No job ${jobId}.` : "Not found." }, secrets);
+            return;
+        }
+        sendJson(res, 200, job, secrets);
+        return;
+    }
+    const page = /^\/jobs\/([^/]+)\/(spec|log|findings)$/.exec(path);
+    if (page?.[1] && (page[2] === "spec" || page[2] === "log" || page[2] === "findings")) {
+        const jobId = parseJobId(page[1]);
+        const job = jobId ? findJob(config, jobId) : undefined;
+        if (!job) {
+            sendHtml(res, 404, renderMessagePage(css, "Not found", jobId ? `No job ${jobId}.` : "Not found."), secrets);
+            return;
+        }
+        if (page[2] === "findings") {
+            sendFindings(res, config, css, secrets, job);
+            return;
+        }
+        const target = page[2] === "spec" ? job.specPath : job.logPath;
+        if (!target) {
+            sendHtml(res, 404, renderMessagePage(css, "Not found", page[2] === "log" ? "No log yet." : "No spec."), secrets);
+            return;
+        }
+        const text = readInside(config.kilnDir, target);
+        if (text === undefined) {
+            sendHtml(res, 404, renderMessagePage(css, "Not found", "That file is not in the kiln directory."), secrets);
+            return;
+        }
+        const title = page[2] === "spec" ? `${job.title} spec` : `${job.title} log`;
+        sendHtml(res, 200, renderTextPage(css, title, text), secrets);
+        return;
+    }
+    if (path.startsWith("/api/"))
+        sendJson(res, 404, { error: "Not found." }, secrets);
+    else
+        sendHtml(res, 404, renderMessagePage(css, "Not found", "Not found."), secrets);
+}
+async function answer(req, res, config, css, secrets, jobId, choice) {
+    try {
+        answerJob(config, jobId, choice);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const status = message.startsWith("No job ") ? 404 : 409;
+        if (wantsJson(req))
+            sendJson(res, status, { error: message }, secrets);
+        else
+            sendHtml(res, status, renderMessagePage(css, "Could not answer", message), secrets);
+        return;
+    }
+    const job = findJob(config, jobId);
+    if (wantsJson(req)) {
+        sendJson(res, 200, { ok: true, job }, secrets);
+        return;
+    }
+    redirect(res, redirectTarget(req));
+}
+function sendFindings(res, config, css, secrets, job) {
+    if (job.workflow !== INVESTIGATION_WORKFLOW) {
+        sendHtml(res, 404, renderMessagePage(css, "Not found", "Not found."), secrets);
+        return;
+    }
+    if (!job.findingsPath) {
+        sendHtml(res, 404, renderMessagePage(css, "Not found", "No findings yet."), secrets);
+        return;
+    }
+    const text = readInside(config.kilnDir, job.findingsPath);
+    if (text === undefined) {
+        sendHtml(res, 404, renderMessagePage(css, "Not found", "That file is not in the kiln directory."), secrets);
+        return;
+    }
+    sendHtml(res, 200, renderTextPage(css, `${job.title} findings`, text), secrets);
+}
+function findJob(config, jobId) {
+    try {
+        return readStatus(config, jobId).jobs[0];
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message === `No job ${jobId}.`)
+            return undefined;
+        throw error;
+    }
+}
+/**
+ * Browsers send Origin on POST. A cross-site page cannot use this server:
+ * the header has to be exactly `http://127.0.0.1:<bound port>`.
+ * Curl and other non-browser clients omit Origin and are allowed.
+ * `Sec-Fetch-Site: cross-site` is rejected even when Origin is absent.
+ */
+export function originAllowed(req, port) {
+    const fetchSite = req.headers["sec-fetch-site"];
+    if (fetchSite === "cross-site")
+        return false;
+    const origin = req.headers.origin;
+    if (Array.isArray(origin))
+        return false;
+    if (origin === undefined)
+        return true;
+    return origin === `http://127.0.0.1:${port}`;
+}
+function redirectTarget(req) {
+    const referer = req.headers.referer;
+    if (typeof referer !== "string")
+        return "/";
+    try {
+        const url = new URL(referer);
+        if (url.pathname === "/board")
+            return "/board";
+    }
+    catch {
+        return "/";
+    }
+    return "/";
+}
+function wantsJson(req) {
+    const accept = headerValue(req.headers.accept);
+    if (accept.includes("application/json"))
+        return true;
+    return headerValue(req.headers["content-type"]).includes("application/json");
+}
+function headerValue(value) {
+    if (Array.isArray(value))
+        return value.join(",");
+    return value ?? "";
+}
+function parseJobId(raw) {
+    let id;
+    try {
+        id = decodeURIComponent(raw);
+    }
+    catch {
+        return undefined;
+    }
+    if (!JOB_ID.test(id))
+        return undefined;
+    return id;
+}
+function readInside(kilnDir, target) {
+    let root;
+    try {
+        root = realpathSync(resolve(kilnDir));
+    }
+    catch {
+        return undefined;
+    }
+    const resolved = resolve(target);
+    if (resolved !== root && !resolved.startsWith(root + sep))
+        return undefined;
+    let real;
+    try {
+        real = realpathSync(resolved);
+    }
+    catch {
+        return undefined;
+    }
+    if (real !== root && !real.startsWith(root + sep))
+        return undefined;
+    const text = readFileSync(real, "utf8");
+    if (text.length <= TEXT_LIMIT)
+        return text;
+    return `showing the last ${TEXT_LIMIT} characters\n\n${text.slice(text.length - TEXT_LIMIT)}`;
+}
+async function drain(req) {
+    let size = 0;
+    for await (const chunk of req) {
+        size += chunk.length;
+        if (size > BODY_LIMIT) {
+            const error = new Error("Request body is too large.");
+            error.statusCode = 413;
+            throw error;
+        }
+    }
+}
+function statusCode(error) {
+    if (typeof error === "object" && error !== null && "statusCode" in error) {
+        const code = error.statusCode;
+        if (typeof code === "number")
+            return code;
+    }
+    return undefined;
+}
+function sendHtml(res, status, html, secrets) {
+    const body = redact(html, secrets);
+    res.writeHead(status, {
+        "Content-Type": "text/html; charset=utf-8",
+        Connection: "close",
+        "Cache-Control": "no-store",
+        "X-Content-Type-Options": "nosniff",
+        "Content-Security-Policy": "default-src 'none'; style-src 'unsafe-inline'; form-action 'self'; base-uri 'none'; frame-ancestors 'none'",
+        "Referrer-Policy": "same-origin",
+    });
+    res.end(body);
+}
+function sendJson(res, status, value, secrets) {
+    const body = redact(`${JSON.stringify(value, null, 2)}\n`, secrets);
+    res.writeHead(status, {
+        "Content-Type": "application/json; charset=utf-8",
+        Connection: "close",
+        "Cache-Control": "no-store",
+        "X-Content-Type-Options": "nosniff",
+    });
+    res.end(body);
+}
+function redirect(res, location) {
+    res.writeHead(303, { Location: location, Connection: "close", "Cache-Control": "no-store" });
+    res.end();
+}
+function secretValues(config) {
+    const values = [config.jira?.apiToken, process.env.JIRA_API_TOKEN];
+    const found = [];
+    for (const value of values) {
+        const trimmed = value?.trim();
+        if (trimmed && trimmed.length >= 8 && !found.includes(trimmed))
+            found.push(trimmed);
+    }
+    return found;
+}
+function redact(text, secrets) {
+    let out = text;
+    for (const secret of secrets)
+        out = out.split(secret).join("[redacted]");
+    return out;
+}

package/dist/truncate-output.js

@@ -0,0 +1,122 @@
+import { spawn } from "node:child_process";
+import { writeSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+/** Last lines of verify output kept for later prompts. */
+export const VERIFY_MAX_LINES = 200;
+/** Last bytes of verify output kept for later prompts, after the line cut. */
+export const VERIFY_MAX_BYTES = 20 * 1024;
+const RAW_CAP = 1024 * 1024;
+/**
+ * Keep the tail of a verify stream so a long test log cannot land whole in
+ * the next prompt. A cut is marked on the first line.
+ */
+export function truncateCaptured(text, stream) {
+    const lined = lastLines(text, VERIFY_MAX_LINES);
+    const tailed = lastBytes(lined.text, VERIFY_MAX_BYTES);
+    if (!lined.cut && !tailed.cut)
+        return text;
+    const note = `[truncated: showing the last ${VERIFY_MAX_LINES} lines or ${VERIFY_MAX_BYTES} bytes of ${stream}]\n`;
+    return note + tailed.text;
+}
+function lastLines(text, maxLines) {
+    if (text.length === 0)
+        return { text, cut: false };
+    const trailingNewline = text.endsWith("\n");
+    const parts = text.split("\n");
+    if (trailingNewline)
+        parts.pop();
+    if (parts.length <= maxLines)
+        return { text, cut: false };
+    const kept = parts.slice(-maxLines);
+    return { text: kept.join("\n") + (trailingNewline ? "\n" : ""), cut: true };
+}
+function lastBytes(text, maxBytes) {
+    const buf = Buffer.from(text, "utf8");
+    if (buf.length <= maxBytes)
+        return { text, cut: false };
+    let start = buf.length - maxBytes;
+    while (start < buf.length && (buf[start] & 0xc0) === 0x80)
+        start += 1;
+    return { text: buf.subarray(start).toString("utf8"), cut: true };
+}
+function capTail(current, chunk, cap) {
+    let piece = chunk;
+    let cut = false;
+    if (Buffer.byteLength(piece, "utf8") > cap) {
+        piece = lastBytes(piece, cap).text;
+        cut = true;
+        current = "";
+    }
+    const next = current + piece;
+    if (Buffer.byteLength(next, "utf8") <= cap)
+        return { text: next, cut };
+    return { text: lastBytes(next, cap).text, cut: true };
+}
+/**
+ * `process.stdout.write` queues behind an in-flight write. `process.exit`
+ * leaves that queue in the process and the parent's `close` handler never
+ * sees it. A blocking write puts the bytes in the pipe first.
+ */
+function writeAll(fd, text) {
+    if (text.length === 0)
+        return;
+    const buf = Buffer.from(text);
+    let offset = 0;
+    while (offset < buf.length) {
+        let wrote = 0;
+        try {
+            wrote = writeSync(fd, buf, offset);
+        }
+        catch (error) {
+            const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
+            if (code === "EAGAIN" || code === "EWOULDBLOCK")
+                continue;
+            throw error;
+        }
+        if (wrote <= 0)
+            return;
+        offset += wrote;
+    }
+}
+function isDirectRun() {
+    const entry = process.argv[1];
+    if (!entry)
+        return false;
+    return import.meta.url === pathToFileURL(entry).href;
+}
+function main() {
+    const command = process.env.KILN_TEST;
+    if (!command?.trim()) {
+        writeAll(2, "KILN_TEST is empty\n");
+        process.exit(1);
+    }
+    const child = spawn(command, { shell: true, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const finish = (code) => {
+        if (settled)
+            return;
+        settled = true;
+        writeAll(1, truncateCaptured(stdout, "stdout"));
+        writeAll(2, truncateCaptured(stderr, "stderr"));
+        process.exit(code);
+    };
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+        stdout = capTail(stdout, chunk, RAW_CAP).text;
+    });
+    child.stderr?.on("data", (chunk) => {
+        stderr = capTail(stderr, chunk, RAW_CAP).text;
+    });
+    child.on("error", (error) => {
+        stderr += `${error.message}\n`;
+        finish(1);
+    });
+    child.on("close", (code) => {
+        finish(code ?? 1);
+    });
+}
+if (isDirectRun())
+    main();