@bivy/bivy 0.20.7-staging.2 → 0.20.7-staging.4

package/dist/apps/backend/index.js

@@ -0,0 +1,431 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { parseHttpFile, resolveRequest } from "./http-file.js";
+import { answerChanged, answerChanges, rowChanges } from "./compare.js";
+import { parseRows, readQueryFile } from "./rows.js";
+import { LogBuffer, LogMarks } from "./logs.js";
+import { redactSecrets } from "../../redact.js";
+const REQUEST_TIMEOUT_MS = 10_000;
+const MAX_BODY = 1024 * 1024;
+const QUERY_TIMEOUT_MS = 15_000;
+const MAX_OUTPUT = 4 * 1024 * 1024;
+const MAX_FILES = 50;
+const MAX_FILE_BYTES = 256 * 1024;
+const SHOWN_ROWS = 200;
+const SAFE = ["GET", "HEAD"];
+const LOOPBACK = ["127.0.0.1", "localhost", "[::1]", "::1"];
+/** Files of one kind in a backend view's folder, read fresh (an agent may have just written one). */
+function files(dir, extension) {
+    let names;
+    try {
+        names = fs.readdirSync(dir).filter((name) => name.endsWith(extension)).sort().slice(0, MAX_FILES);
+    }
+    catch {
+        return [];
+    }
+    return names.map((name) => {
+        const file = path.join(dir, name);
+        try {
+            const stat = fs.lstatSync(file);
+            if (!stat.isFile())
+                return { file: name, error: "Not a regular file." };
+            if (stat.size > MAX_FILE_BYTES)
+                return { file: name, error: "Larger than 256 KiB." };
+            return { file: name, text: fs.readFileSync(file, "utf8") };
+        }
+        catch (error) {
+            return { file: name, error: error.message };
+        }
+    });
+}
+export class Backend {
+    registry;
+    terminals;
+    logs = new Map();
+    marks = new LogMarks();
+    taps = new Map();
+    /** A logs view's own command: its terminal, once started. */
+    sources = new Map();
+    answers = new Map();
+    results = new Map();
+    /** When the current agent run began, per session (logs count errors since). */
+    runs = new Map();
+    constructor(registry, terminals) {
+        this.registry = registry;
+        this.terminals = terminals;
+        // What happens in the preview (a page, a form) marks the logs: the gateway says.
+        registry.on("action", (viewId, label) => {
+            const entry = this.registry.getView(viewId);
+            if (entry)
+                this.marks.add(entry.app.id, label, { merge: true });
+        });
+        registry.serverErrors = (viewId, since) => this.serverErrors(viewId, since);
+    }
+    views(sessionId) {
+        return this.registry.list(sessionId).flatMap((app) => app.views.filter((view) => view.kind === "backend").map((view) => this.registry.getView(view.id))).filter(Boolean);
+    }
+    /** A backend view of a kind by app or view ID or name (`bivy app requests`); by default the first. */
+    pick(sessionId, kind, target) {
+        const views = this.views(sessionId).filter((entry) => entry.target.kind === kind);
+        if (!views.length)
+            throw new Error(`This session has no ${kind} view. Add {"kind":"${kind}","name":"…"} to the app's manifest and publish it again.`);
+        if (!target)
+            return views[0];
+        const wanted = target.trim().toLowerCase();
+        const found = views.find((entry) => [entry.view.id, entry.app.id].includes(wanted) || entry.view.name.toLowerCase() === wanted || entry.app.name.toLowerCase() === wanted);
+        if (!found)
+            throw new Error(`No ${kind} view called "${target}". Run bivy app list to see them.`);
+        return found;
+    }
+    // Logs ---------------------------------------------------------------------
+    /** A server Bivy runs has started: follow its output. Every managed server is
+     *  followed, so its logs reach back before anyone opened them. */
+    attach(viewId, termId) {
+        this.taps.get(viewId)?.();
+        const buffer = this.buffer(viewId);
+        const stop = this.terminals.tap?.(termId, (data) => buffer.append(data));
+        if (stop)
+            this.taps.set(viewId, stop);
+    }
+    buffer(key) {
+        let buffer = this.logs.get(key);
+        if (!buffer) {
+            buffer = new LogBuffer();
+            this.logs.set(key, buffer);
+        }
+        return buffer;
+    }
+    /** Where a logs view reads: a view of its app that Bivy runs, or its own command. */
+    logSource(entry) {
+        const source = entry.target.source;
+        if ("command" in source)
+            return { key: entry.view.id, detail: entry.view.kind === "backend" ? entry.view.detail : "", command: source };
+        const servers = entry.app.views.map((view) => this.registry.getView(view.id)).filter((view) => view && ((view.target.kind === "service" && view.target.start) || view.target.kind === "display"));
+        const server = source.view ? servers.find((view) => view.view.name.toLowerCase() === source.view.toLowerCase()) : servers[0];
+        if (!server)
+            throw new Error(source.view ? `${entry.app.name} has no view called "${source.view}" that Bivy runs.` : `${entry.app.name} has no server that Bivy runs. Give the logs view a "source": a file or a command.`);
+        return { key: server.view.id, detail: `${server.view.name} output` };
+    }
+    /** Errors from the servers behind a web view since `since`: its own, if Bivy
+     *  runs it, and what its app's logs views follow. For the preview's Console,
+     *  so a server error shows up next to the page's own. Never starts a source. */
+    serverErrors(viewId, since) {
+        const now = Date.now();
+        const entry = this.registry.getView(viewId);
+        if (!entry)
+            return { now, lines: [] };
+        const keys = new Set([viewId]);
+        for (const view of entry.app.views) {
+            const logs = this.registry.getView(view.id);
+            if (logs?.target.kind !== "logs")
+                continue;
+            try {
+                keys.add(this.logSource(logs).key);
+            }
+            catch { /* no server to follow */ }
+        }
+        const lines = [...keys].flatMap((key) => this.logs.get(key)?.errorsBetween(since, now) ?? []).sort((a, b) => a.at - b.at);
+        return { now, lines: lines.slice(-20) };
+    }
+    async log(entry, since = 0) {
+        if (entry.target.kind !== "logs")
+            throw new Error("Not a logs view.");
+        const source = this.logSource(entry);
+        let running = this.taps.has(source.key);
+        if (source.command) {
+            // Started on first look and kept running, so the next look has what happened in between.
+            let started = this.sources.get(entry.view.id);
+            if (started && !this.terminals.has(await started.catch(() => ""))) {
+                this.sources.delete(entry.view.id);
+                started = undefined;
+            }
+            if (!started) {
+                started = this.terminals.start({ ...source.command, name: `${entry.app.name} · ${entry.view.name}` });
+                this.sources.set(entry.view.id, started);
+                this.attach(source.key, await started);
+            }
+            running = this.terminals.has(await started);
+        }
+        return { detail: source.detail, lines: this.buffer(source.key).read(since), marks: this.marks.read(entry.app.id), running };
+    }
+    // Requests -------------------------------------------------------------------
+    /** The address `{{base}}` stands for: the view's own, or a web server of its app. */
+    base(entry) {
+        const base = entry.target.base;
+        if (base && "url" in base)
+            return base.url;
+        const services = entry.app.views.map((view) => this.registry.getView(view.id)).filter((view) => view?.target.kind === "service");
+        const service = base ? services.find((view) => view.view.name.toLowerCase() === base.view.toLowerCase()) : services[0];
+        return service && service.target.kind === "service" ? `http://127.0.0.1:${service.target.port}` : "";
+    }
+    requestsOf(entry) {
+        if (entry.target.kind !== "requests")
+            throw new Error("Not a requests view.");
+        const requests = [], problems = [];
+        for (const file of files(entry.target.dir, ".http")) {
+            if (file.error !== undefined) {
+                problems.push({ file: file.file, error: file.error });
+                continue;
+            }
+            const parsed = parseHttpFile(file.text);
+            if (!parsed.requests.length)
+                problems.push({ file: file.file, error: "No requests in it. A request is a line like \"GET {{base}}/orders\"." });
+            const seen = new Map();
+            for (const spec of parsed.requests) {
+                // Stable while the file keeps its order: its file and its name.
+                const slug = spec.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60) || "request";
+                const n = (seen.get(slug) ?? 0) + 1;
+                seen.set(slug, n);
+                requests.push({ id: `${file.file.replace(/\.http$/, "")}/${slug}${n > 1 ? `-${n}` : ""}`, file: file.file, spec, variables: parsed.variables });
+            }
+        }
+        return { requests, problems };
+    }
+    /** By ID, or by name for people and agents typing it. */
+    findRequest(entry, id) {
+        const { requests } = this.requestsOf(entry);
+        const found = requests.find((item) => item.id === id) ?? requests.find((item) => item.spec.name.toLowerCase() === id.trim().toLowerCase());
+        if (!found)
+            throw new Error(`No request "${id}"${requests.length ? `. Its requests: ${requests.map((item) => item.spec.name).join(", ")}` : ""}.`);
+        return found;
+    }
+    item(entry, request, base) {
+        const resolved = resolveRequest(request.spec, request.variables, { base });
+        let host;
+        try {
+            host = new URL(resolved.url).host;
+        }
+        catch { /* a path, or unresolved */ }
+        const own = base ? new URL(base).host : undefined;
+        const external = host && host !== own && !LOOPBACK.includes(host.replace(/:\d+$/, "")) ? host : undefined;
+        const kept = this.answers.get(entry.view.id)?.get(request.id);
+        return {
+            id: request.id, file: request.file, name: request.spec.name, method: request.spec.method, url: resolved.url,
+            auto: request.spec.auto || (SAFE.includes(request.spec.method) && !external),
+            ...(external ? { external } : {}), ...(kept?.last ? { last: kept.last } : {}), ...(kept?.before ? { before: kept.before } : {}),
+        };
+    }
+    requests(entry) {
+        const base = this.base(entry);
+        const { requests, problems } = this.requestsOf(entry);
+        return { base, requests: requests.map((request) => this.item(entry, request, base)), problems };
+    }
+    detail(entry, id) {
+        const base = this.base(entry);
+        const request = this.findRequest(entry, id);
+        const item = this.item(entry, request, base);
+        return { item, request: resolveRequest(request.spec, request.variables, { base }), ...(item.before && item.last ? { changes: answerChanges(item.before, item.last) } : {}) };
+    }
+    /** Runs one request now, from this machine. `as`: keep it as the run's "before". */
+    /** `quiet`: Bivy's own before/after runs leave no marker; someone's run does. */
+    async run(entry, id, as = "last", quiet = false) {
+        const base = this.base(entry);
+        const request = this.findRequest(entry, id);
+        const resolved = resolveRequest(request.spec, request.variables, { base });
+        if (!quiet)
+            this.marks.add(entry.app.id, `Ran “${request.spec.name}”`);
+        const answer = await send(resolved);
+        let kept = this.answers.get(entry.view.id);
+        if (!kept) {
+            kept = new Map();
+            this.answers.set(entry.view.id, kept);
+        }
+        kept.set(request.id, as === "before" ? { before: answer, last: answer } : { ...kept.get(request.id), last: answer });
+        return this.detail(entry, request.id);
+    }
+    /** Every request that runs on its own (GET/HEAD to the app's server, or @auto).
+     *  `mark`: someone asked ("Run all"), so the log gets one marker for it. */
+    async runAuto(entry, as = "last", mark) {
+        if (mark)
+            this.marks.add(entry.app.id, mark);
+        for (const item of this.requests(entry).requests.filter((request) => request.auto))
+            await this.run(entry, item.id, as, true).catch(() => { });
+        return this.requests(entry);
+    }
+    // Data -----------------------------------------------------------------------
+    queriesOf(entry) {
+        if (entry.target.kind !== "data")
+            throw new Error("Not a data view.");
+        const queries = [], problems = [];
+        for (const file of files(entry.target.dir, ".sql")) {
+            if (file.error !== undefined)
+                problems.push({ file: file.file, error: file.error });
+            else
+                queries.push({ id: file.file.replace(/\.sql$/, ""), file: file.file, ...readQueryFile(file.text) });
+        }
+        return { queries, problems };
+    }
+    /** Runs a query through the view's client: the query on stdin, rows on stdout. */
+    query(entry, sql) {
+        const target = entry.target;
+        return new Promise((resolve, reject) => {
+            const child = spawn(target.command, target.args, { cwd: target.workspace, stdio: ["pipe", "pipe", "pipe"] });
+            let out = "", err = "";
+            const timer = setTimeout(() => { child.kill("SIGKILL"); reject(new Error(`The query took longer than ${QUERY_TIMEOUT_MS / 1000} seconds.`)); }, QUERY_TIMEOUT_MS);
+            child.stdout.on("data", (chunk) => { out += chunk; if (out.length > MAX_OUTPUT)
+                child.kill("SIGKILL"); });
+            child.stderr.on("data", (chunk) => { err = (err + chunk).slice(-4000); });
+            child.on("error", (error) => { clearTimeout(timer); reject(new Error(error.code === "ENOENT" ? `"${target.command}" isn't installed on this machine.` : error.message)); });
+            child.on("close", (code) => {
+                clearTimeout(timer);
+                if (code !== 0)
+                    reject(new Error(redactSecrets(err.trim()) || `${target.command} exited with ${code}.`));
+                else
+                    resolve(parseRows(out));
+            });
+            child.stdin.on("error", () => { });
+            child.stdin.end(sql.endsWith(";") || /;\s*$/.test(sql) ? `${sql}\n` : `${sql};\n`);
+        });
+    }
+    /** Each saved query's rows and, once a run has begun, what changed since. `run`: query now. */
+    async data(entry, run = false, as = "last") {
+        const { queries, problems } = this.queriesOf(entry);
+        let kept = this.results.get(entry.view.id);
+        if (!kept) {
+            kept = new Map();
+            this.results.set(entry.view.id, kept);
+        }
+        const store = kept;
+        if (run || queries.some((query) => !store.get(query.id)?.last && !store.get(query.id)?.error)) {
+            for (const query of queries) {
+                if (!run && (store.get(query.id)?.last || store.get(query.id)?.error))
+                    continue;
+                try {
+                    const rows = await this.query(entry, query.sql);
+                    store.set(query.id, as === "before" ? { before: rows, last: { ...rows, at: Date.now() } } : { ...store.get(query.id), last: { ...rows, at: Date.now() }, error: undefined });
+                }
+                catch (error) {
+                    store.set(query.id, { ...store.get(query.id), error: error.message });
+                }
+            }
+        }
+        return {
+            detail: entry.view.kind === "backend" ? entry.view.detail : "", problems,
+            queries: queries.map((query) => {
+                const kept = store.get(query.id);
+                const columns = kept?.last?.columns ?? [];
+                const key = query.key ?? (columns.includes("id") ? "id" : columns[0] ?? "id");
+                return {
+                    id: query.id, file: query.file, title: query.title ?? query.id, key, columns,
+                    rows: kept?.last?.rows.slice(0, SHOWN_ROWS) ?? [], count: kept?.last?.rows.length ?? 0,
+                    ...(kept?.last ? { at: kept.last.at } : {}), ...(kept?.error ? { error: kept.error } : {}),
+                    ...(kept?.before && kept.last ? { changes: rowChanges(kept.before.rows, kept.last.rows, key) } : {}),
+                };
+            }),
+        };
+    }
+    // A run's evidence -----------------------------------------------------------
+    /** Before an agent run: the safe requests and every query, as "before". */
+    async baseline(sessionId) {
+        this.runs.set(sessionId, Date.now());
+        for (const app of this.registry.list(sessionId))
+            if (app.views.some((view) => view.kind === "backend"))
+                this.marks.add(app.id, "The agent started working");
+        for (const entry of this.views(sessionId)) {
+            if (entry.target.kind === "requests")
+                await this.runAuto(entry, "before").catch(() => { });
+            if (entry.target.kind === "data")
+                await this.data(entry, true, "before").catch(() => { });
+        }
+    }
+    /** After it: the same again, and one line per thing that changed, per app. */
+    async evidence(sessionId) {
+        const since = this.runs.get(sessionId) ?? Date.now();
+        const out = new Map();
+        const add = (entry, rows) => {
+            const kept = out.get(entry.app.id) ?? { rows: [], changed: false };
+            for (const row of rows)
+                kept.rows.push({ viewId: entry.view.id, view: entry.view.name, backend: entry.target.kind, ...row });
+            kept.changed ||= rows.some((row) => row.tone === "warn" || row.tone === "danger");
+            out.set(entry.app.id, kept);
+        };
+        for (const entry of this.views(sessionId)) {
+            try {
+                if (entry.target.kind === "requests") {
+                    const items = (await this.runAuto(entry)).requests.filter((item) => item.auto && item.before && item.last);
+                    const changed = items.filter((item) => answerChanged(item.before, item.last));
+                    add(entry, [
+                        ...changed.slice(0, 3).map((item) => ({
+                            summary: `${item.method} ${item.name}`, item: item.id,
+                            detail: item.before.status !== item.last.status ? `${item.before.status || "no answer"} → ${item.last.status || "no answer"}` : "answer changed",
+                            tone: (item.last.error || item.last.status >= 500 ? "danger" : "warn"),
+                        })),
+                        ...(changed.length > 3 ? [{ summary: `${changed.length - 3} more answer differently`, tone: "warn" }] : []),
+                        ...(items.length > changed.length ? [{ summary: `${items.length - changed.length} ${items.length - changed.length === 1 ? "request answers" : "requests answer"} the same`, tone: (changed.length ? "neutral" : "ok") }] : []),
+                    ]);
+                }
+                else if (entry.target.kind === "data") {
+                    const queries = (await this.data(entry, true)).queries;
+                    const changed = queries.filter((query) => query.changes && (query.changes.added.length || query.changes.changed.length || query.changes.removed.length));
+                    add(entry, changed.length ? changed.slice(0, 4).map((query) => ({
+                        summary: query.title, item: query.id, tone: "warn",
+                        detail: [query.changes.added.length && `+${query.changes.added.length}`, query.changes.changed.length && `~${query.changes.changed.length}`, query.changes.removed.length && `−${query.changes.removed.length}`].filter(Boolean).join(" "),
+                    })) : queries.some((query) => query.changes) ? [{ summary: "No rows changed", tone: "ok" }] : []);
+                }
+                else {
+                    const log = await this.log(entry, since);
+                    const errors = log.lines.filter((line) => line.level === "error");
+                    add(entry, [errors.length
+                            ? { summary: `${errors.length} new ${errors.length === 1 ? "error" : "errors"}`, detail: errors[0].text.slice(0, 160), tone: "danger" }
+                            : { summary: "No new errors", tone: "ok" }]);
+                }
+            }
+            catch { /* a view that can't answer adds nothing to the card */ }
+        }
+        return out;
+    }
+    /** An app was removed: stop following its sources and forget its results. */
+    forget(viewIds, appId) {
+        for (const id of viewIds) {
+            this.taps.get(id)?.();
+            this.taps.delete(id);
+            this.logs.delete(id);
+            this.answers.delete(id);
+            this.results.delete(id);
+            this.sources.delete(id);
+        }
+        this.marks.forget(appId);
+    }
+}
+/** One request, from this machine. Redirects are shown, not followed: a 302 is an answer. */
+async function send(request) {
+    const at = Date.now();
+    let url;
+    try {
+        url = new URL(request.url);
+    }
+    catch {
+        return { status: 0, statusText: "", ms: 0, at, headers: {}, body: "", error: `“${request.url}” isn't an address. Use {{base}}/path, or a full http(s) URL.` };
+    }
+    if (!["http:", "https:"].includes(url.protocol))
+        return { status: 0, statusText: "", ms: 0, at, headers: {}, body: "", error: "Only http and https requests run." };
+    try {
+        const response = await fetch(url, { method: request.method, headers: request.headers, body: SAFE.includes(request.method) || !request.body ? undefined : request.body, redirect: "manual", signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS) });
+        const reader = response.body?.getReader();
+        const chunks = [];
+        let size = 0, truncated = false;
+        while (reader) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            size += value.length;
+            chunks.push(value);
+            if (size > MAX_BODY) {
+                truncated = true;
+                await reader.cancel();
+                break;
+            }
+        }
+        const body = Buffer.concat(chunks).subarray(0, MAX_BODY).toString("utf8");
+        const type = response.headers.get("content-type") ?? "";
+        const headers = Object.fromEntries([...response.headers].slice(0, 30));
+        return { status: response.status, statusText: response.statusText, ms: Date.now() - at, at, headers, body, ...(/json/i.test(type) ? { json: true } : {}), ...(truncated ? { truncated: true } : {}) };
+    }
+    catch (error) {
+        const reason = error.name === "TimeoutError" ? `No answer within ${REQUEST_TIMEOUT_MS / 1000} seconds.` : (error.cause?.code === "ECONNREFUSED" ? `Nothing is answering at ${url.host}.` : error.message);
+        return { status: 0, statusText: "", ms: Date.now() - at, at, headers: {}, body: "", error: reason };
+    }
+}

package/dist/apps/backend/logs.js

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+import { redactSecrets } from "../../redact.js";
+const MAX_LINES = 2000;
+const MAX_MARKS = 50;
+const MAX_LINE = 2000;
+/** How bad a line is, as rows tried in order. A server's own words decide:
+ *  "error", an exception, a 5xx it answered. Adding a pattern is adding a row. */
+const LEVELS = [
+    { level: "error", pattern: /\b(error|exception|fatal|panic|traceback|uncaught|unhandled|failed)\b|[a-z](?:Error|Exception)\b|\b(?:Completed|status[=: ]+|HTTP\/\d(?:\.\d)?"?\s+)5\d\d\b|\s5\d\d\s+in\s+\d/i },
+    { level: "warn", pattern: /\b(warn|warning|deprecat\w*)\b/i },
+];
+// Terminal colour and cursor codes: a log is read as text.
+// eslint-disable-next-line no-control-regex
+const ANSI = /\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07]*(?:\x07|\x1b\\)|\x1b[@-Z\\-_]/g;
+/** A stack frame or continuation belongs to the line above it. */
+const CONTINUATION = /^(\s+\S|\s*at\s|\s*from\s|\s*File\s"|Caused by:|\s*\.\.\.\s\d+ more)/;
+/** One source's recent lines, each stamped when it arrived. */
+export class LogBuffer {
+    lines = [];
+    partial = "";
+    append(data, at = Date.now()) {
+        const text = this.partial + data.replace(ANSI, "").replace(/\r\n?/g, "\n");
+        const parts = text.split("\n");
+        this.partial = parts.pop().slice(-MAX_LINE);
+        for (const raw of parts) {
+            if (!raw.trim())
+                continue;
+            const line = raw.slice(0, MAX_LINE);
+            const previous = this.lines.at(-1);
+            const level = CONTINUATION.test(line) && previous && previous.level !== "info" ? previous.level : LEVELS.find((row) => row.pattern.test(line))?.level ?? "info";
+            this.lines.push({ at, text: line, level });
+        }
+        if (this.lines.length > MAX_LINES)
+            this.lines = this.lines.slice(-MAX_LINES);
+    }
+    /** Lines since `since`, with secrets taken out: they're shown, and may be sent to an agent. */
+    read(since = 0) {
+        return this.lines.filter((line) => line.at > since).map((line) => ({ ...line, text: redactSecrets(line.text) }));
+    }
+    errorsBetween(from, to = Infinity) {
+        return this.read(from).filter((line) => line.level === "error" && line.at <= to);
+    }
+}
+/** "Your last action" per app: what the person (or the agent) just did, so the
+ *  log can say what came of it. */
+export class LogMarks {
+    marks = new Map();
+    /** `merge`: traffic from the preview, where a page and the requests it makes
+     *  in the same moment are one action. Something run on purpose always counts. */
+    add(appId, label, { at = Date.now(), merge = false } = {}) {
+        const list = this.marks.get(appId) ?? [];
+        if (merge && list.at(-1) && at - list.at(-1).at < 1000)
+            return;
+        list.push({ at, label: label.slice(0, 200) });
+        this.marks.set(appId, list.slice(-MAX_MARKS));
+    }
+    read(appId) { return [...this.marks.get(appId) ?? []]; }
+    forget(appId) { this.marks.delete(appId); }
+}

package/dist/apps/backend/rows.js

@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+const MAX_ROWS = 1000;
+const text = (value) => value === null || value === undefined ? "null" : typeof value === "object" ? JSON.stringify(value) : String(value);
+/** A delimited line, with quotes ("a ""quoted"" value") as CSV writes them. */
+function splitLine(line, delimiter) {
+    const cells = [];
+    let cell = "", quoted = false;
+    for (let i = 0; i < line.length; i++) {
+        const char = line[i];
+        if (quoted) {
+            if (char === "\"" && line[i + 1] === "\"") {
+                cell += "\"";
+                i++;
+            }
+            else if (char === "\"")
+                quoted = false;
+            else
+                cell += char;
+        }
+        else if (char === "\"" && !cell)
+            quoted = true;
+        else if (char === delimiter) {
+            cells.push(cell);
+            cell = "";
+        }
+        else
+            cell += char;
+    }
+    return [...cells, cell];
+}
+function delimited(output, delimiter) {
+    const lines = output.split(/\r?\n/).filter((line) => line.length);
+    if (!lines.length || !lines[0].includes(delimiter))
+        return undefined;
+    const columns = splitLine(lines[0], delimiter);
+    return { columns, rows: lines.slice(1, MAX_ROWS + 1).map((line) => Object.fromEntries(splitLine(line, delimiter).map((cell, i) => [columns[i] ?? `column ${i + 1}`, cell]))) };
+}
+const FORMATS = [
+    { name: "JSON", read: (output) => {
+            let value;
+            try {
+                value = JSON.parse(output);
+            }
+            catch {
+                return undefined;
+            }
+            if (!Array.isArray(value))
+                return undefined;
+            const objects = value.slice(0, MAX_ROWS).filter((row) => !!row && typeof row === "object" && !Array.isArray(row));
+            const columns = [...new Set(objects.flatMap((row) => Object.keys(row)))];
+            return { columns, rows: objects.map((row) => Object.fromEntries(columns.map((column) => [column, text(row[column])]))) };
+        } },
+    { name: "TSV", read: (output) => delimited(output, "\t") },
+    { name: "CSV", read: (output) => delimited(output, ",") },
+    // One column, no delimiter: still a table.
+    { name: "lines", read: (output) => {
+            const lines = output.split(/\r?\n/).filter((line) => line.length);
+            if (!lines.length)
+                return undefined;
+            return { columns: [lines[0]], rows: lines.slice(1, MAX_ROWS + 1).map((line) => ({ [lines[0]]: line })) };
+        } },
+];
+export function parseRows(output) {
+    const trimmed = output.trim();
+    if (!trimmed)
+        return { columns: [], rows: [] };
+    for (const format of FORMATS) {
+        const rows = format.read(trimmed);
+        if (rows)
+            return rows;
+    }
+    return { columns: [], rows: [] };
+}
+/** A saved query's file: the query, and its `-- title:` and `-- key:` comments. */
+export function readQueryFile(text) {
+    const tag = (name) => new RegExp(`^\\s*--\\s*${name}\\s*:\\s*(.+)$`, "im").exec(text)?.[1]?.trim();
+    return { sql: text.trim(), ...(tag("title") ? { title: tag("title") } : {}), ...(tag("key") ? { key: tag("key") } : {}) };
+}