laneyard 0.1.0

package/dist/src/runner/orchestrate.js

@@ -0,0 +1,140 @@
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+import { Workspace } from "../git/workspace.js";
+import { summarizeFailure } from "../heuristics/error-summary.js";
+import { collectArtifacts } from "./artifacts.js";
+import { LiveStepTracker } from "./live-steps.js";
+import { startPty } from "./pty.js";
+import { readReport } from "./report.js";
+/**
+ * Runs a complete run through and sets its state transitions.
+ *
+ * Never throws: every error is converted into a documented `failed` run,
+ * because a run that disappears without a trace is the worst possible
+ * behaviour for a build server.
+ */
+export async function executeRun(opts) {
+    const { runId, runs, logs } = opts;
+    const writer = await logs.open(runId);
+    const tracker = new LiveStepTracker();
+    const emit = async (text) => {
+        const offset = await writer.append(text);
+        tracker.consume(text, offset);
+        opts.onChunk(text, offset);
+    };
+    const fail = async (message) => {
+        await emit(`\n${message}\n`);
+        await writer.close();
+        runs.finish(runId, { status: "failed", exitCode: null, errorSummary: message });
+        return { status: "failed" };
+    };
+    // --- Preparation --------------------------------------------------------
+    runs.setStatus(runId, "preparing");
+    const workspace = new Workspace(opts.workspacePath, opts.gitUrl, opts.gitAuth);
+    let commitSha;
+    try {
+        commitSha = await workspace.prepare(opts.branch, (line) => void emit(`${line}\n`));
+    }
+    catch (cause) {
+        return fail(`Could not prepare the workspace: ${cause.message}`);
+    }
+    runs.markRunning(runId, { branch: opts.branch, commitSha });
+    // The workspace finally exists: only now is the repository's laneyard.yml
+    // readable, so only now are the settings known. The resolution is guarded:
+    // the project may have disappeared from config.yml during preparation,
+    // and a run must never evaporate on an exception.
+    let settings;
+    try {
+        settings = await opts.resolveSettings();
+    }
+    catch (cause) {
+        return fail(`Unreadable project settings: ${cause.message}`);
+    }
+    // --- Execution -----------------------------------------------------------
+    const useBundle = settings.runtime === "bundle";
+    const reportPath = join(opts.workspacePath, settings.fastlane_dir, "report.xml");
+    // A report may still be lying around, left by a previous run that fastlane
+    // didn't have time to overwrite. Without this cleanup, a run that fails
+    // before even reaching fastlane would adopt the previous run's timeline.
+    await rm(reportPath, { force: true });
+    const { done } = startPty({
+        command: useBundle ? "bundle" : "fastlane",
+        args: useBundle
+            ? ["exec", "fastlane", ...laneArgs(opts)]
+            : laneArgs(opts),
+        cwd: opts.workspacePath,
+        env: {
+            ...opts.env,
+            // A non-interactive run fails fast instead of freezing on an invisible prompt.
+            CI: "true",
+            FASTLANE_SKIP_UPDATE_CHECK: "1",
+            FORCE_COLOR: "1",
+        },
+        onData: (chunk) => void emit(chunk),
+        timeoutMs: settings.timeout_minutes * 60_000,
+    });
+    const outcome = await done;
+    await writer.close();
+    // --- Timeline -------------------------------------------------------------
+    // Everything that follows is after-sales service: the timeline and the
+    // artifacts embellish a run that's already finished. A database that
+    // refuses an insert or a file that evaporates must not cost the run's
+    // verdict, nor let an exception bubble up to the server, which has no one
+    // to catch it.
+    try {
+        await recordOutcome();
+    }
+    catch (cause) {
+        await emit(`\nIncomplete timeline or artifacts: ${cause.message}\n`);
+    }
+    if (outcome.exitCode === 0 && !outcome.timedOut) {
+        runs.finish(runId, { status: "success", exitCode: 0, errorSummary: null });
+        return { status: "success" };
+    }
+    const summary = outcome.timedOut
+        ? `Run interrupted after ${settings.timeout_minutes} minutes`
+        : summarizeFailure(await logs.read(runId), outcome.exitCode);
+    runs.finish(runId, { status: "failed", exitCode: outcome.exitCode, errorSummary: summary });
+    return { status: "failed" };
+    async function recordOutcome() {
+        const report = await readReport(reportPath);
+        const live = tracker.steps();
+        if (report) {
+            // The report is authoritative; live spotting only contributes the offsets.
+            const steps = report.map((s, i) => ({
+                idx: s.idx,
+                name: s.name,
+                durationMs: s.durationMs,
+                status: s.status,
+                logOffset: live[i]?.logOffset ?? null,
+                source: "report",
+            }));
+            runs.replaceSteps(runId, steps);
+            await rm(reportPath, { force: true });
+        }
+        else if (live.length > 0) {
+            // Cancelled, timed out, or interrupted run: we keep what was seen, flagging it.
+            runs.replaceSteps(runId, live.map((s, i) => ({
+                idx: i,
+                name: s.name,
+                durationMs: null,
+                status: "unknown",
+                logOffset: s.logOffset,
+                source: "live",
+            })));
+        }
+        // --- Artifacts ----------------------------------------------------------
+        const collected = await collectArtifacts(opts.workspacePath, settings.artifact_globs, opts.artifactsDir);
+        for (const a of collected)
+            runs.addArtifact(runId, a);
+    }
+}
+function laneArgs(opts) {
+    const run = opts.runs.get(opts.runId);
+    if (!run)
+        return [];
+    const args = run.platform ? [run.platform, run.lane] : [run.lane];
+    for (const [key, value] of Object.entries(run.params))
+        args.push(`${key}:${value}`);
+    return args;
+}

package/dist/src/runner/pty.js

@@ -0,0 +1,83 @@
+import pty from "node-pty";
+/**
+ * Runs a command in a pseudo-terminal.
+ *
+ * The PTY serves two purposes: fastlane believes it's in a real terminal and
+ * keeps its usual display, and input remains possible if a run ever needs one.
+ */
+export function startPty(opts) {
+    let proc;
+    try {
+        proc = pty.spawn(opts.command, opts.args, {
+            name: "xterm-256color",
+            cols: 120,
+            rows: 40,
+            cwd: opts.cwd,
+            env: opts.env,
+        });
+    }
+    catch (cause) {
+        // Command not found: depending on the platform, node-pty throws or returns 127.
+        // We normalize so the caller only has one case to handle.
+        opts.onData(`\nCould not launch: ${cause.message}\n`);
+        return {
+            handle: { write: () => { }, kill: () => { } },
+            done: Promise.resolve({ exitCode: 127, signal: null, timedOut: false }),
+        };
+    }
+    let timedOut = false;
+    let timer;
+    proc.onData(opts.onData);
+    const done = new Promise((resolve) => {
+        if (opts.timeoutMs !== undefined) {
+            timer = setTimeout(() => {
+                timedOut = true;
+                // SIGINT first: fastlane cleans up after itself. SIGKILL if it keeps stalling.
+                try {
+                    proc.kill("SIGINT");
+                }
+                catch {
+                    /* the process may have died in the meantime */
+                }
+                setTimeout(() => {
+                    try {
+                        proc.kill("SIGKILL");
+                    }
+                    catch {
+                        /* same */
+                    }
+                }, 5000);
+            }, opts.timeoutMs);
+        }
+        proc.onExit(({ exitCode, signal }) => {
+            if (timer)
+                clearTimeout(timer);
+            // `waitpid` only reports an exit code for a normal end: a process
+            // killed by a signal leaves 0, which would pass a cancellation off
+            // as a success. We apply the shell convention, 128 + signal, so an
+            // exit code always stays interpretable.
+            const killed = signal !== undefined && signal !== 0;
+            resolve({
+                exitCode: killed && exitCode === 0 ? 128 + signal : exitCode,
+                signal: signal ?? null,
+                timedOut,
+            });
+        });
+    });
+    const handle = {
+        write: (input) => proc.write(input),
+        kill: (signal = "SIGINT") => {
+            try {
+                proc.kill(signal);
+            }
+            catch {
+                /* already finished */
+            }
+        },
+    };
+    return { handle, done };
+}
+/** Blocking variant, handy for tests and short commands. */
+export async function runInPty(opts) {
+    return startPty(opts).done;
+}

package/dist/src/runner/report.js

@@ -0,0 +1,86 @@
+import { readFile } from "node:fs/promises";
+// The self-closing branch comes first: fastlane writes successful actions
+// as `<testcase … />` and only failed ones have a body. In the other order,
+// `[^>]*` would swallow the final `/` and the lazy body would run up to the
+// next `</testcase>`, merging two actions and blaming the failure on the wrong one.
+const TESTCASE = /<testcase\b([^>]*?)\/>|<testcase\b([^>]*)>([\s\S]*?)<\/testcase>/g;
+// `\b` is mandatory: without it, searching for `name=` first finds the end
+// of `classname=`, which fastlane systematically writes as the first attribute.
+/**
+ * Decodes the XML entities of an attribute value.
+ *
+ * Essential: a `sh` action's name contains the entire command, so it
+ * readily includes a `&&` or a redirection, which the report writes as
+ * `&amp;&amp;` and `&gt;`. Without decoding, the interface would display the escaping.
+ */
+const ENTITIES = {
+    amp: "&",
+    lt: "<",
+    gt: ">",
+    quot: '"',
+    apos: "'",
+};
+const decodeXml = (value) => value.replace(/&(#x?[0-9a-fA-F]+|[a-z]+);/g, (whole, code) => {
+    // An out-of-range code point would make String.fromCodePoint throw: we
+    // return the entity as-is rather than crash the report reading.
+    const point = code.startsWith("#x") || code.startsWith("#X")
+        ? parseInt(code.slice(2), 16)
+        : code.startsWith("#")
+            ? Number(code.slice(1))
+            : null;
+    if (point !== null) {
+        return Number.isInteger(point) && point >= 0 && point <= 0x10ffff
+            ? String.fromCodePoint(point)
+            : whole;
+    }
+    return ENTITIES[code] ?? whole;
+});
+const ATTR = (source, name) => {
+    const raw = new RegExp(`\\b${name}="([^"]*)"`).exec(source)?.[1];
+    return raw === undefined ? null : decodeXml(raw);
+};
+/**
+ * Reads the JUnit report that fastlane writes on every run.
+ * It's the authoritative source for names, order, durations, and failures.
+ *
+ * Returns null if the report is missing or unreadable — the normal case for
+ * a cancelled, timed-out, or interrupted run, or one that failed before even
+ * reaching fastlane.
+ */
+export async function readReport(path) {
+    let xml;
+    try {
+        xml = await readFile(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+    if (!xml.includes("<testsuite"))
+        return null;
+    const steps = [];
+    for (const m of xml.matchAll(TESTCASE)) {
+        const attrs = m[1] ?? m[2] ?? "";
+        const body = m[3] ?? "";
+        const rawName = ATTR(attrs, "name");
+        if (rawName === null)
+            continue;
+        // fastlane names its cases "<index>: <action>".
+        const named = /^(\d+):\s*(.+)$/.exec(rawName);
+        const time = ATTR(attrs, "time");
+        steps.push({
+            idx: named ? Number(named[1]) : steps.length,
+            name: named ? named[2].trim() : rawName.trim(),
+            durationMs: time === null ? null : Math.round(Number(time) * 1000),
+            status: body.includes("<failure") ? "failed" : "success",
+        });
+    }
+    if (steps.length === 0)
+        return null;
+    // The index comes from the name, not the position: nothing guarantees its
+    // uniqueness. A report with several testsuites, or mixing numbered and
+    // unnumbered cases, produces duplicates — and `run_step` has a primary key
+    // (run_id, idx). So we renumber after sorting, keeping the announced order.
+    return steps
+        .sort((a, b) => a.idx - b.idx)
+        .map((step, position) => ({ ...step, idx: position }));
+}

package/dist/src/server/app.js

@@ -0,0 +1,84 @@
+import cookie from "@fastify/cookie";
+import fastifyStatic from "@fastify/static";
+import Fastify from "fastify";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { RunStore } from "../db/runs.js";
+import { Workspace } from "../git/workspace.js";
+import { LogStore } from "../logs/store.js";
+import { LoginThrottle, SESSION_COOKIE, SessionStore, verifyPassword } from "./auth.js";
+import { registerProjectRoutes } from "./routes/projects.js";
+import { registerRunRoutes } from "./routes/runs.js";
+import { registerWebSocket } from "./ws.js";
+export async function buildApp(deps) {
+    const app = Fastify({ logger: false });
+    await app.register(cookie);
+    const workspacePath = (slug) => join(deps.root, "workspaces", slug);
+    const ctx = {
+        ...deps,
+        runs: new RunStore(deps.db),
+        logs: new LogStore(join(deps.root, "logs")),
+        sessions: new SessionStore(),
+        workspacePath,
+        artifactsDir: (runId) => join(deps.root, "artifacts", String(runId)),
+        ensureWorkspace: async (slug) => {
+            const entry = deps.config.project(slug);
+            if (!entry)
+                throw new Error(`Unknown project: ${slug}`);
+            await new Workspace(workspacePath(slug), entry.git_url, entry.git_auth).ensureCloned();
+        },
+    };
+    const throttle = new LoginThrottle();
+    app.post("/api/login", async (req, reply) => {
+        const { password } = req.body;
+        const hash = deps.config.server()?.password_hash;
+        const waitMs = throttle.retryAfterMs();
+        if (waitMs > 0) {
+            return reply
+                .code(429)
+                .header("retry-after", Math.ceil(waitMs / 1000))
+                .send({ error: `Too many attempts. Try again in ${Math.ceil(waitMs / 1000)}s.` });
+        }
+        if (!password || !hash || !(await verifyPassword(password, hash))) {
+            throttle.recordFailure();
+            return reply.code(401).send({ error: "Incorrect password" });
+        }
+        throttle.recordSuccess();
+        const token = ctx.sessions.issue();
+        return reply
+            .setCookie(SESSION_COOKIE, token, { path: "/", httpOnly: true, sameSite: "lax" })
+            .send({ ok: true });
+    });
+    // Every /api route except /api/login requires a session.
+    app.addHook("onRequest", async (req, reply) => {
+        if (!req.url.startsWith("/api") || req.url === "/api/login")
+            return;
+        if (!ctx.sessions.valid(req.cookies[SESSION_COOKIE])) {
+            return reply.code(401).send({ error: "Session required" });
+        }
+    });
+    ctx.sockets = await registerWebSocket(app, ctx);
+    await registerProjectRoutes(app, ctx);
+    await registerRunRoutes(app, ctx);
+    // Resolved from the module's location, not from the data folder:
+    // `deps.root` is ~/.laneyard, the built SPA lives in the repository. Two
+    // relative positions, depending on whether we're running on the sources
+    // (`src/server`) or on the build (`dist/src/server`); both point to
+    // `dist/web`, never the source `web/` folder whose `index.html` isn't built.
+    const here = dirname(fileURLToPath(import.meta.url));
+    const webRoot = [
+        join(here, "..", "..", "dist", "web"),
+        join(here, "..", "..", "..", "dist", "web"),
+    ].find((candidate) => existsSync(join(candidate, "index.html")));
+    if (webRoot) {
+        await app.register(fastifyStatic, { root: webRoot });
+        // Routing lives on the browser side: any unknown URL renders the app.
+        app.setNotFoundHandler((req, reply) => {
+            if (req.url.startsWith("/api"))
+                return reply.code(404).send({ error: "Unknown route" });
+            return reply.sendFile("index.html");
+        });
+    }
+    return app;
+}

package/dist/src/server/auth.js

@@ -0,0 +1,81 @@
+import { randomBytes, scrypt, scryptSync, timingSafeEqual } from "node:crypto";
+/**
+ * scrypt from the standard library: no extra native dependency, and enough
+ * computational resistance for a single local password.
+ * Format: scrypt$<hex salt>$<hex key>.
+ */
+export function hashPassword(password) {
+    const salt = randomBytes(16);
+    const key = scryptSync(password, salt, 32);
+    return `scrypt$${salt.toString("hex")}$${key.toString("hex")}`;
+}
+/**
+ * Verifies a password without blocking the event loop.
+ *
+ * scrypt costs some thirty milliseconds per call — that's the point. But in
+ * its synchronous form, every login attempt would freeze the whole server
+ * for that long: live logs of runs in progress would stop dead. Anyone on
+ * the network could paralyze the machine with a curl loop.
+ *
+ * Never throws: a corrupted `password_hash` must refuse the login, not
+ * turn a configuration error into a 500.
+ */
+export async function verifyPassword(password, stored) {
+    const [scheme, saltHex, keyHex] = stored.split("$");
+    if (scheme !== "scrypt" || !saltHex || !keyHex)
+        return false;
+    const expected = Buffer.from(keyHex, "hex");
+    if (expected.length === 0)
+        return false;
+    try {
+        const actual = await new Promise((resolve, reject) => {
+            scrypt(password, Buffer.from(saltHex, "hex"), expected.length, (err, key) => err ? reject(err) : resolve(key));
+        });
+        return timingSafeEqual(expected, actual);
+    }
+    catch {
+        return false;
+    }
+}
+/** In-memory sessions: they don't survive a restart, and that's just fine. */
+export class SessionStore {
+    tokens = new Set();
+    issue() {
+        const token = randomBytes(32).toString("hex");
+        this.tokens.add(token);
+        return token;
+    }
+    valid(token) {
+        return token !== undefined && this.tokens.has(token);
+    }
+    revoke(token) {
+        this.tokens.delete(token);
+    }
+}
+export const SESSION_COOKIE = "laneyard_session";
+/**
+ * Slows down repeated login attempts.
+ *
+ * Without this, a network neighbour could try passwords as fast as the
+ * server responds. The delay grows with failures and resets to zero on a
+ * success: the legitimate user who mistypes once doesn't feel it.
+ */
+export class LoginThrottle {
+    failures = 0;
+    until = 0;
+    /** Milliseconds left to wait, 0 if the way is clear. */
+    retryAfterMs(now = Date.now()) {
+        return Math.max(0, this.until - now);
+    }
+    recordFailure(now = Date.now()) {
+        this.failures += 1;
+        // 0, 0, 0, then 1s, 2s, 4s… capped at one minute.
+        if (this.failures > 3) {
+            this.until = now + Math.min(60_000, 2 ** (this.failures - 4) * 1000);
+        }
+    }
+    recordSuccess() {
+        this.failures = 0;
+        this.until = 0;
+    }
+}

package/dist/src/server/routes/projects.js

@@ -0,0 +1,35 @@
+export async function registerProjectRoutes(app, ctx) {
+    app.get("/api/projects", async () => ctx.config.projects().map((p) => {
+        const last = ctx.runs.listByProject(p.slug, 1)[0] ?? null;
+        return {
+            slug: p.slug,
+            name: p.name,
+            color: p.color,
+            lastRun: last && { id: last.id, status: last.status, lane: last.lane, finishedAt: last.finishedAt },
+        };
+    }));
+    app.get("/api/projects/:slug/lanes", async (req, reply) => {
+        const { slug } = req.params;
+        const entry = ctx.config.project(slug);
+        if (!entry)
+            return reply.code(404).send({ error: "Unknown project" });
+        try {
+            // Lanes live in the repository: with no clone, there's nothing to read.
+            // A freshly declared project must be usable without launching a run blind.
+            await ctx.ensureWorkspace(slug);
+            const resolved = await ctx.config.resolve(slug, ctx.workspacePath(slug));
+            return await ctx.lanes(slug, ctx.workspacePath(slug), resolved.settings.fastlane_dir);
+        }
+        catch (cause) {
+            // Workspace not cloned yet, broken Fastfile, sidecar failure: the
+            // interface must be able to tell the user, rather than show an empty list.
+            return reply.code(503).send({ error: cause.message });
+        }
+    });
+    app.get("/api/projects/:slug/runs", async (req, reply) => {
+        const { slug } = req.params;
+        if (!ctx.config.project(slug))
+            return reply.code(404).send({ error: "Unknown project" });
+        return ctx.runs.listByProject(slug);
+    });
+}

package/dist/src/server/routes/runs.js

@@ -0,0 +1,100 @@
+import { createReadStream } from "node:fs";
+import { executeRun } from "../../runner/orchestrate.js";
+export async function registerRunRoutes(app, ctx) {
+    app.post("/api/projects/:slug/runs", async (req, reply) => {
+        const { slug } = req.params;
+        const body = req.body;
+        const entry = ctx.config.project(slug);
+        if (!entry)
+            return reply.code(404).send({ error: "Unknown project" });
+        if (!body.lane)
+            return reply.code(400).send({ error: "Missing lane" });
+        // Only one run at a time per project: they share the same git workspace.
+        // Two concurrent runs would silently trip over each other — one would
+        // change the commit out from under the other, carry off its artifacts
+        // and delete its report. The real queue comes at the next milestone;
+        // this refusal, for its part, already prevents false results.
+        const last = ctx.runs.listByProject(slug, 1)[0];
+        if (last && ["queued", "preparing", "running"].includes(last.status)) {
+            return reply.code(409).send({
+                error: `Run #${last.id} is still in progress on this project. Wait for it to finish.`,
+            });
+        }
+        // We check that the lane genuinely exists before creating a run doomed to fail.
+        try {
+            await ctx.ensureWorkspace(slug);
+            const resolved = await ctx.config.resolve(slug, ctx.workspacePath(slug));
+            const lanes = await ctx.lanes(slug, ctx.workspacePath(slug), resolved.settings.fastlane_dir);
+            if (!lanes.some((l) => l.name === body.lane)) {
+                return reply.code(400).send({ error: `Unknown lane: ${body.lane}` });
+            }
+        }
+        catch {
+            // Unreadable lanes: we let it through, the run will fail with a clear message.
+        }
+        const id = ctx.runs.create({
+            projectSlug: slug,
+            lane: body.lane,
+            platform: body.platform ?? null,
+            params: body.params ?? {},
+        });
+        // Launched without waiting: the HTTP response mustn't take as long as a build.
+        void executeRun({
+            runId: id,
+            runs: ctx.runs,
+            logs: ctx.logs,
+            workspacePath: ctx.workspacePath(slug),
+            artifactsDir: ctx.artifactsDir(id),
+            gitUrl: entry.git_url,
+            gitAuth: entry.git_auth,
+            branch: entry.default_branch,
+            // Resolved after the clone, once the repository's laneyard.yml is finally readable.
+            resolveSettings: async () => {
+                const r = await ctx.config.resolve(slug, ctx.workspacePath(slug));
+                return r.settings;
+            },
+            env: process.env,
+            onChunk: (chunk, offset) => app.broadcastRunChunk?.(id, chunk, offset),
+        })
+            .then((r) => ctx.sockets?.finish(id, r.status))
+            .catch((cause) => {
+            // Last safety net. `executeRun` commits to never throwing, but a
+            // rejected promise with no handler brings down the whole Node
+            // process — and with it, the other runs in progress. The cost of
+            // forgetting this would be disproportionate.
+            ctx.runs.finish(id, {
+                status: "failed",
+                exitCode: null,
+                errorSummary: `Unexpected failure: ${cause.message}`,
+            });
+            ctx.sockets?.finish(id, "failed");
+        });
+        return reply.code(201).send({ id });
+    });
+    app.get("/api/runs/:id", async (req, reply) => {
+        const id = Number(req.params.id);
+        const run = ctx.runs.get(id);
+        if (!run)
+            return reply.code(404).send({ error: "Unknown run" });
+        return { ...run, steps: ctx.runs.steps(id), artifacts: ctx.runs.artifacts(id) };
+    });
+    app.get("/api/runs/:id/log", async (req, reply) => {
+        const id = Number(req.params.id);
+        const from = Number(req.query.from ?? 0);
+        if (!ctx.runs.get(id))
+            return reply.code(404).send({ error: "Unknown run" });
+        return reply.type("text/plain; charset=utf-8").send(await ctx.logs.read(id, from));
+    });
+    app.get("/api/runs/:id/artifacts/:artifactId", async (req, reply) => {
+        const { id, artifactId } = req.params;
+        const artifact = ctx.runs.artifacts(Number(id)).find((a) => a.id === Number(artifactId));
+        if (!artifact)
+            return reply.code(404).send({ error: "Unknown artifact" });
+        return reply
+            // A file from the repository can carry a quote in its name: without
+            // escaping it would break the header.
+            .header("Content-Disposition", `attachment; filename="${artifact.filename.replace(/["\\]/g, "_")}"`)
+            .type("application/octet-stream")
+            .send(createReadStream(artifact.path));
+    });
+}

package/dist/src/server/ws.js

@@ -0,0 +1,66 @@
+import websocket from "@fastify/websocket";
+import { SESSION_COOKIE } from "./auth.js";
+/**
+ * Broadcasts output fragments to browsers watching a run.
+ *
+ * Every message carries its byte offset: a client that reconnects requests
+ * the log from its last known offset and loses nothing.
+ */
+export class RunSockets {
+    byRun = new Map();
+    subscribe(runId, sink) {
+        const set = this.byRun.get(runId) ?? new Set();
+        set.add(sink);
+        this.byRun.set(runId, set);
+    }
+    unsubscribe(runId, sink) {
+        const set = this.byRun.get(runId);
+        if (!set)
+            return;
+        set.delete(sink);
+        if (set.size === 0)
+            this.byRun.delete(runId);
+    }
+    emit(runId, payload) {
+        const set = this.byRun.get(runId);
+        if (!set)
+            return;
+        const data = JSON.stringify(payload);
+        for (const sink of set) {
+            try {
+                sink.send(data);
+            }
+            catch {
+                // A dead client must never interrupt the broadcast to the others.
+                set.delete(sink);
+            }
+        }
+    }
+    broadcast(runId, chunk, offset) {
+        this.emit(runId, { type: "chunk", offset, data: chunk });
+    }
+    finish(runId, status) {
+        this.emit(runId, { type: "finished", status });
+    }
+}
+export async function registerWebSocket(app, ctx) {
+    const hub = new RunSockets();
+    await app.register(websocket);
+    app.get("/api/runs/:id/stream", { websocket: true }, (socket, req) => {
+        // Deliberate redundancy: `app.ts`'s global hook already refuses every
+        // `/api` route without a session, and does so right at the handshake —
+        // an unauthenticated client gets a 401 HTTP response and never reaches
+        // here. This guard costs nothing and prevents a future exemption of
+        // that hook from silently opening the stream.
+        if (!ctx.sessions.valid(req.cookies[SESSION_COOKIE])) {
+            socket.close(4001, "Session required");
+            return;
+        }
+        const runId = Number(req.params.id);
+        const sink = { send: (d) => socket.send(d) };
+        hub.subscribe(runId, sink);
+        socket.on("close", () => hub.unsubscribe(runId, sink));
+    });
+    app.decorate("broadcastRunChunk", (runId, chunk, offset) => hub.broadcast(runId, chunk, offset));
+    return hub;
+}