oakode 0.0.0-stage → 0.5.1

package/dist/oicki.js

@@ -0,0 +1,475 @@
+/** Thin client for OICKI's public HTTP API (OpenAI-compatible chat completions + model discovery). */
+import { VERSION } from "./config.js";
+export const REASONING_EFFORTS = ["none", "minimal", "low", "medium", "high", "xhigh"];
+/**
+ * A stored message as the API wants it: images become content parts, and reasoning is sent back only to the model
+ * that produced it (another provider may reject a foreign format).
+ */
+export function toWire(m, vision, model) {
+    if (m.role === "assistant") {
+        const { reasoning_details, reasoning_model, ...rest } = m;
+        return reasoning_details?.length && reasoning_model === model ? { ...rest, reasoning_details } : rest;
+    }
+    // always a copy: cache breakpoints are added to the wire messages, and must never change the stored conversation
+    if (m.role !== "user" || !m.images?.length)
+        return m.role === "user" ? { role: m.role, content: m.content } : { ...m };
+    if (!vision)
+        return { role: "user", content: `${m.content}\n[${m.images.length} image${m.images.length > 1 ? "s" : ""} not sent: this model cannot receive images (${m.images.map((i) => i.path).join(", ")})]` };
+    return {
+        role: "user",
+        content: [{ type: "text", text: m.content }, ...m.images.map((i) => ({ type: "image_url", image_url: { url: `data:${i.mime};base64,${i.data}` } }))],
+    };
+}
+const EPHEMERAL = { type: "ephemeral" };
+/** Puts a cache breakpoint on a wire message's last text part (strings become one text part). */
+function markCache(w) {
+    if (typeof w.content === "string") {
+        if (!w.content)
+            return false;
+        w.content = [{ type: "text", text: w.content, cache_control: EPHEMERAL }];
+        return true;
+    }
+    const part = Array.isArray(w.content) ? w.content.findLast((p) => p.type === "text" && p.text) : undefined;
+    if (!part)
+        return false;
+    part.cache_control = EPHEMERAL;
+    return true;
+}
+/**
+ * Prompt-cache breakpoints for models with explicit caching: the system prompt (which, with the tools before it, is the
+ * same for the whole session) and the last two user/tool messages, so each request reads what the previous one wrote
+ * and writes a new prefix for the next. Assistant messages cannot carry markers. OICKI uses at most 4.
+ */
+export function addCacheBreakpoints(wire) {
+    if (wire[0]?.role === "system")
+        markCache(wire[0]);
+    let marked = 0;
+    for (let i = wire.length - 1; i > 0 && marked < 2; i--)
+        if ((wire[i].role === "user" || wire[i].role === "tool") && markCache(wire[i]))
+            marked++;
+}
+/**
+ * Streamed reasoning arrives in pieces. Pieces of the same block (same `index`, or adjacent pieces of the same type
+ * without one) are joined: text is concatenated, other fields (a signature, an id) take the latest value. The result
+ * has the shape a non-streamed reply would have.
+ */
+export function mergeReasoning(pieces) {
+    const out = [];
+    for (const p of pieces) {
+        if (!p || typeof p !== "object")
+            continue;
+        const last = out.at(-1);
+        // Without an index, a block that already got its signature is finished: the next piece starts a new one.
+        const same = last && last.type === p.type && (p.index !== undefined ? last.index === p.index : last.index === undefined && !last.signature);
+        if (!same) {
+            out.push({ ...p });
+            continue;
+        }
+        for (const [k, v] of Object.entries(p)) {
+            if ((k === "text" || k === "summary" || k === "data") && typeof v === "string" && typeof last[k] === "string")
+                last[k] += v;
+            else if (v !== undefined && v !== null && v !== "")
+                last[k] = v;
+        }
+    }
+    return out;
+}
+export class OickiError extends Error {
+    status;
+    code;
+    requestId;
+    /** What had streamed when a request failed after it started (never retried automatically). */
+    partial;
+    constructor(status, code, message, requestId) {
+        super(message);
+        this.name = "OickiError";
+        this.status = status;
+        this.code = code;
+        this.requestId = requestId;
+    }
+    /** Actionable advice for the user, when we know it. */
+    get hint() {
+        switch (this.code) {
+            case "not_logged_in":
+                return "Sign in with `oakode login` (or use an API key: `oakode login --api-key`, or set OICKI_API_KEY).";
+            case "session_expired":
+                return "Sign in again with `oakode login`. Your sessions and settings are kept.";
+            case "wrong_server":
+                return undefined;
+            case "unauthorized":
+                return "OICKI did not accept the credentials. Check them with `oakode status`; replace the key with `oakode login --api-key` (keys: https://oicki.vercel.app/dashboard/developer).";
+            case "insufficient_scope":
+                return "If this model is expensive: `oakode login --expensive` (OAuth) or enable \"Allow expensive models\" on your API key. Otherwise re-login to grant the missing scope, or pick another model with /model.";
+            case "insufficient_credits":
+            case "insufficient_super_credits":
+                return "Not enough credits. Add credits or wait for your plan to renew; retrying will not help.";
+            case "quota_exceeded":
+                return "A usage limit was reached. Waiting will not clear it; raise the limit in your OICKI account.";
+            case "app_limit_exceeded":
+                return "This would go over the monthly credit limit you set for OAKODE. Raise it under Account → Connected apps on OICKI (it resets on the 1st), or lower the reply budget (`maxOutputTokens` in ~/.oakode/config.json) so smaller requests fit.";
+            case "content_filtered":
+                return "The model provider's safety filter refused this request (not billed). Rephrase it or switch models (/model).";
+            case "context_length_exceeded":
+                return "Conversation too long for this model. Use /compact or switch to a larger-context model.";
+            case "invalid_request":
+                if (this.status === 413)
+                    return "The request is larger than OICKI accepts (4 MB), usually because of an image. Ask for a smaller image, or start a fresh conversation with /clear.";
+                return undefined;
+            case "over_budget":
+                return "The subagent's credit budget is used up; its partial work is kept. A new delegation with a larger budget can continue it.";
+            case "ai_disabled":
+                return "AI is disabled for this account.";
+            case "provider_unavailable":
+                return "The model's provider is busy. Try again shortly, or pick another model with /model.";
+            case "provider_rejected":
+                return "OICKI's provider account refused this request (not billed). Try again later or another model (/model).";
+            case "connection_failed":
+                return "The request was never sent, so nothing was billed. Check your connection (or proxy); `oakode doctor` tests it. /retry when it is back.";
+            case "stream_incomplete":
+            case "provider_error":
+            case "usage_unavailable":
+            case "usage_settlement_failed":
+            case "timeout":
+            case "network_error":
+                if (this.status === 0 || this.status === 200)
+                    return "The request may have been processed and billed. OAKODE does not retry these automatically; /retry sends a new request.";
+                return undefined;
+        }
+    }
+}
+/** Raised when a stream fails after it started. The request may have been billed: never auto-retry. */
+export class StreamError extends OickiError {
+}
+/** How long to keep retrying requests that could not connect at all, and the longest Retry-After waited out. */
+const MAX_OFFLINE_MS = 5 * 60_000;
+const MAX_RETRY_AFTER_S = 60;
+/**
+ * Errors that mean the connection was never established (DNS, refused, unreachable, connect timeout). The code alone
+ * is not enough: an established socket can also fail with EHOSTUNREACH, after the request was written. So each error
+ * must come from the connect or DNS step (every one of a happy-eyeballs AggregateError's).
+ */
+const CONNECT_CODES = new Set(["ENOTFOUND", "EAI_AGAIN", "ECONNREFUSED", "ENETUNREACH", "EHOSTUNREACH", "EADDRNOTAVAIL"]);
+export function connectFailure(e) {
+    const c = e?.cause;
+    if (c?.code === "UND_ERR_CONNECT_TIMEOUT")
+        return c.code; // undici: TCP + TLS handshake, before any request bytes
+    const all = c?.errors?.length ? c.errors : c ? [c] : [];
+    const ok = all.length > 0 && all.every((x) => x?.code && CONNECT_CODES.has(x.code) && (x.syscall === "connect" || x.syscall === "getaddrinfo"));
+    return ok ? all[0].code : undefined;
+}
+/** Retry-After in seconds: delta-seconds or an HTTP date. */
+export function retryAfter(v) {
+    const s = v?.trim() ?? "";
+    if (/^\d+$/.test(s))
+        return Number(s);
+    const at = /[a-z]/i.test(s) ? Date.parse(s) : NaN; // an HTTP date has a day name; Date.parse("-5") is a year
+    return Number.isFinite(at) ? Math.max(0, (at - Date.now()) / 1000) : undefined;
+}
+const sleep = (ms, signal) => new Promise((resolve, reject) => {
+    if (signal?.aborted)
+        return reject(new DOMException("aborted", "AbortError"));
+    const t = setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => (clearTimeout(t), reject(new DOMException("aborted", "AbortError"))), {
+        once: true,
+    });
+});
+export class OickiClient {
+    baseUrl;
+    auth;
+    constructor(baseUrl, auth) {
+        this.baseUrl = baseUrl.replace(/\/+$/, "");
+        this.auth = auth;
+    }
+    /**
+     * `onWait(true)` / `onWait(false)` bracket retry waits (a chat request pauses its no-data timer meanwhile);
+     * `onRetry` says why each wait happens. Only callers that pass it wait for a connection: the others (model lists,
+     * doctor) fail at once instead of hanging silently.
+     */
+    async request(path, init = {}, onWait, onRetry) {
+        let refreshed = false;
+        let offlineSince = 0; // when the first connection attempt failed
+        let connects = 0, limited = 0, busy = 0;
+        for (;;) {
+            const headers = new Headers(init.headers);
+            const token = await this.auth.token();
+            headers.set("Authorization", `Bearer ${token}`);
+            headers.set("User-Agent", `oakode/${VERSION}`);
+            let res;
+            try {
+                res = await fetch(this.baseUrl + path, { ...init, headers });
+            }
+            catch (e) {
+                // A connection that was never established cannot have delivered the request, so it cannot have been billed:
+                // the one network failure that is safe to resend. Anything after connecting (a reset, a cut) might have been.
+                const code = connectFailure(e);
+                if (!code || !onRetry || init.signal?.aborted)
+                    throw e;
+                offlineSince ||= Date.now();
+                const offline = Date.now() - offlineSince;
+                const delay = Math.min(30_000, 2000 * 2 ** Math.min(connects++, 4)) * (0.9 + Math.random() * 0.2);
+                if (offline + delay > MAX_OFFLINE_MS)
+                    throw new OickiError(0, "connection_failed", `Could not connect to ${new URL(this.baseUrl).host} (${code}) for ${Math.round(offline / 1000)} s.`);
+                onRetry(`No connection to ${new URL(this.baseUrl).host} (${code}); the request was not sent. Retrying in ${Math.round(delay / 1000)} s (Esc stops).`);
+                await this.wait(delay, init.signal ?? undefined, onWait);
+                continue;
+            }
+            if (res.ok)
+                return res;
+            if (res.status === 401 && !refreshed && this.auth.refresh && (await this.auth.refresh(token))) {
+                refreshed = true;
+                continue;
+            }
+            const err = await parseError(res);
+            // Automatic retries only where the API documents "not billed, wait and resend": `429 rate_limited` with
+            // Retry-After, and `503 provider_unavailable`. Everything else (502 provider_error, dropped connections,
+            // timeouts) may have been processed and is surfaced instead.
+            const wait = retryAfter(res.headers.get("retry-after"));
+            if (err.code === "rate_limited" && wait !== undefined && limited < 3) {
+                // never sooner than the server asked: an early retry is refused again and wastes the attempt
+                if (wait > MAX_RETRY_AFTER_S) {
+                    err.message += ` OICKI asked to wait ${Math.round(wait)} s before retrying.`;
+                    throw err;
+                }
+                limited++;
+                onRetry?.(`Rate limited by OICKI: retrying in ${Math.max(1, Math.round(wait))} s (${limited}/3).`);
+                await this.wait(wait * 1000, init.signal ?? undefined, onWait);
+                continue;
+            }
+            if (err.code === "provider_unavailable" && res.status === 503 && busy < 2) {
+                const delay = Math.min(wait ?? 2, MAX_RETRY_AFTER_S) * 1000 * (0.9 + Math.random() * 0.2);
+                busy++;
+                onRetry?.(`The model's provider is busy (not billed): retrying in ${Math.max(1, Math.round(delay / 1000))} s (${busy}/2).`);
+                await this.wait(delay, init.signal ?? undefined, onWait);
+                continue;
+            }
+            throw err;
+        }
+    }
+    async wait(ms, signal, onWait) {
+        onWait?.(true);
+        await sleep(ms, signal);
+        onWait?.(false);
+    }
+    async listModels(signal) {
+        const res = await this.request("/v1/models", { signal });
+        return (await res.json()).data;
+    }
+    async getModel(id, signal) {
+        const res = await this.request(`/v1/models/${encodeURIComponent(id)}`, { signal });
+        return (await res.json());
+    }
+    /**
+     * Plan and credits of the signed-in person. Undefined for API keys (OICKI does not show balances to keys) and when
+     * the person did not grant billing:read. Not billed.
+     */
+    async billing(signal) {
+        if (this.auth.kind() !== "oauth")
+            return undefined;
+        let b;
+        try {
+            b = await (await this.request("/v1/widget/summary", { signal })).json();
+        }
+        catch (e) {
+            if (e instanceof OickiError && e.code === "insufficient_scope")
+                return undefined;
+            throw e;
+        }
+        // shown in the status line: anything that does not have the documented shape is treated as unknown, never trusted
+        const str = (x) => typeof x === "string";
+        const num = (x) => typeof x === "number" && Number.isFinite(x);
+        const ok = b && typeof b === "object" && ["no_plan", "past_due", "exhausted", "low", "active"].includes(b.state) && str(b.headline) && str(b.message) &&
+            b.credits && num(b.credits.total) && num(b.credits.standard) && num(b.credits.super) &&
+            b.plan && typeof b.plan === "object" && (b.action === null || (b.action && str(b.action.label) && str(b.action.href))) &&
+            (b.usage === undefined || (b.usage && num(b.usage.cycleCredits) && str(b.usage.period))) &&
+            (b.allowance === null || b.allowance === undefined || (num(b.allowance.usedTokens) && num(b.allowance.capTokens))) &&
+            (b.appLimit === null || b.appLimit === undefined || (["credits", "tokens"].includes(b.appLimit.unit) && num(b.appLimit.used) && num(b.appLimit.cap)));
+        return ok ? b : undefined;
+    }
+    /** The signed-in person's opaque id (GET /oauth/userinfo): proves an OAuth sign-in works. Not billed. */
+    async whoami(signal) {
+        return String((await (await this.request("/oauth/userinfo", { signal })).json()).sub ?? "");
+    }
+    /** Credits for OAuth sessions (needs billing:read), request totals for API keys. */
+    async account(signal) {
+        const path = this.auth.kind() === "oauth" ? "/v1/widget/summary" : "/v1/usage";
+        return (await this.request(path, { signal })).json();
+    }
+    async chat(opts) {
+        const ctl = new AbortController();
+        const onAbort = () => ctl.abort();
+        opts.signal?.addEventListener("abort", onAbort, { once: true });
+        if (opts.signal?.aborted)
+            ctl.abort();
+        let idle;
+        let timedOut = false;
+        const bump = () => {
+            clearTimeout(idle);
+            idle = setTimeout(() => ((timedOut = true), ctl.abort()), opts.idleTimeoutMs ?? 90_000);
+        };
+        const out = { content: "", tool_calls: [], finish_reason: null, aborted: false };
+        const acc = new Map();
+        const reasoning = [];
+        let started = false; // true once the server answered; failures after this point may have been billed
+        const withPartial = (e) => {
+            if (started)
+                e.partial = { content: out.content, toolCalls: [...acc.values()].map((c) => ({ name: c.function.name, argChars: c.function.arguments.length })) };
+            return e;
+        };
+        const wire = opts.messages.map((m) => toWire(m, opts.vision !== false, opts.reasoningModel ?? opts.model));
+        if (opts.cache)
+            addCacheBreakpoints(wire);
+        const body = () => JSON.stringify({
+            model: opts.model,
+            messages: wire,
+            ...(opts.tools?.length ? { tools: opts.tools, parallel_tool_calls: true } : {}),
+            ...(opts.maxTokens ? { max_tokens: opts.maxTokens } : {}),
+            ...(opts.reasoningEffort ? { reasoning_effort: opts.reasoningEffort } : {}),
+            stream: true,
+            stream_options: { include_usage: true },
+        });
+        out.droppedImages = fitImages(wire, body);
+        try {
+            bump();
+            const res = await this.request("/v1/chat/completions", {
+                method: "POST",
+                headers: { "Content-Type": "application/json", Accept: "text/event-stream" },
+                body: body(),
+                signal: ctl.signal,
+            }, (waiting) => (waiting ? clearTimeout(idle) : bump()), opts.onRetry);
+            started = true;
+            let done = false;
+            let skipped = 0;
+            for await (const ev of sseEvents(res.body, bump)) {
+                if (ev === "[DONE]") {
+                    done = true;
+                    break;
+                }
+                let chunk;
+                try {
+                    chunk = JSON.parse(ev);
+                }
+                catch {
+                    skipped++; // one garbled event must not throw away a reply that is being paid for
+                    continue;
+                }
+                if (chunk.error) {
+                    throw new StreamError(200, chunk.error.code ?? "provider_error", chunk.error.message ?? "stream failed", chunk.error.request_id);
+                }
+                if (chunk.model)
+                    out.model = chunk.model;
+                if (chunk.usage)
+                    out.usage = chunk.usage;
+                const choice = chunk.choices?.[0];
+                if (!choice)
+                    continue;
+                const d = choice.delta ?? {};
+                if (d.content) {
+                    out.content += d.content;
+                    opts.onText?.(d.content);
+                }
+                if (typeof d.reasoning_content === "string" && d.reasoning_content)
+                    opts.onReasoning?.(d.reasoning_content);
+                if (Array.isArray(d.reasoning_details))
+                    reasoning.push(...d.reasoning_details);
+                for (const tc of d.tool_calls ?? []) {
+                    const cur = acc.get(tc.index) ?? { id: "", type: "function", function: { name: "", arguments: "" } };
+                    if (tc.id)
+                        cur.id = tc.id;
+                    if (tc.function?.name)
+                        cur.function.name += tc.function.name;
+                    if (tc.function?.arguments)
+                        cur.function.arguments += tc.function.arguments;
+                    acc.set(tc.index, cur);
+                }
+                if (choice.finish_reason)
+                    out.finish_reason = choice.finish_reason;
+                if (chunk.oicki?.finish_detail)
+                    out.finish_detail = chunk.oicki.finish_detail;
+            }
+            // A stream that just stops (no finish reason and no [DONE]) was cut off, not finished: a gateway or connection
+            // ended it. Treating it as complete would record half an answer as the final one.
+            if (!done && out.finish_reason === null)
+                throw new StreamError(200, "stream_incomplete", "The response stream ended before the reply was complete (the connection was closed early).");
+            out.tool_calls = [...acc.entries()].sort((a, b) => a[0] - b[0]).map(([, v]) => v);
+            if (reasoning.length)
+                out.reasoning_details = mergeReasoning(reasoning);
+            if (skipped)
+                out.skippedEvents = skipped;
+            return out;
+        }
+        catch (e) {
+            if (opts.signal?.aborted) {
+                out.aborted = true; // user interrupt: hand back what streamed so far
+                return out;
+            }
+            if (timedOut)
+                throw withPartial(new StreamError(0, "timeout", `No data from the server for ${(opts.idleTimeoutMs ?? 90_000) / 1000}s.`));
+            if (e instanceof OickiError)
+                throw withPartial(e);
+            const cause = e.cause;
+            throw withPartial(new OickiError(0, "network_error", `Network error: ${e.message}${cause ? ` (${cause.code ?? cause.message})` : ""}`));
+        }
+        finally {
+            clearTimeout(idle);
+            opts.signal?.removeEventListener("abort", onAbort);
+        }
+    }
+}
+/** OICKI refuses chat bodies over 4,000,000 bytes and more than 50 images; stay a little under. */
+export const MAX_BODY_BYTES = 3_900_000;
+export const MAX_IMAGES = 50;
+/** Replaces the oldest image parts with a short note until the request fits. Returns how many were left out. */
+export function fitImages(wire, body) {
+    const parts = wire.flatMap((m) => (Array.isArray(m.content) ? m.content.filter((p) => p.type === "image_url") : []));
+    let dropped = 0;
+    const tooBig = () => parts.length - dropped > MAX_IMAGES || Buffer.byteLength(body()) > MAX_BODY_BYTES;
+    while (dropped < parts.length && tooBig()) {
+        const p = parts[dropped++];
+        delete p.image_url;
+        p.type = "text";
+        p.text = "[image left out: the request would be over OICKI's size limit]";
+    }
+    return dropped;
+}
+async function parseError(res) {
+    const rid = res.headers.get("x-request-id") ?? undefined;
+    let code = `http_${res.status}`;
+    let message = res.statusText || `HTTP ${res.status}`;
+    try {
+        const body = (await res.json());
+        if (body?.error && typeof body.error === "object") {
+            code = body.error.code ?? code;
+            message = body.error.message ?? message;
+        }
+        else if (typeof body?.error === "string") {
+            code = body.error; // OAuth-style
+            message = body.error_description ?? message;
+        }
+    }
+    catch { }
+    return new OickiError(res.status, code, message, rid);
+}
+/** Yields the `data:` payload of each server-sent event. */
+export async function* sseEvents(body, onBytes) {
+    const dec = new TextDecoder();
+    let buf = "";
+    for await (const part of body) {
+        onBytes?.();
+        buf += dec.decode(part, { stream: true });
+        let i;
+        while ((i = buf.search(/\r?\n\r?\n/)) >= 0) {
+            const block = buf.slice(0, i);
+            buf = buf.slice(i).replace(/^\r?\n\r?\n/, "");
+            const data = block
+                .split(/\r?\n/)
+                .filter((l) => l.startsWith("data:"))
+                .map((l) => l.slice(5).replace(/^ /, ""))
+                .join("\n");
+            if (data)
+                yield data;
+        }
+    }
+    const tail = buf.split(/\r?\n/).filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trim()).join("\n");
+    if (tail)
+        yield tail;
+}

package/dist/output.js

@@ -0,0 +1,101 @@
+/** Cleans command output before it reaches the model: no terminal escapes, no progress-bar rewrites, no endless repeats. */
+const ANSI = /\x1b\[[0-?]*[ -\/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[()][A-Z0-9]|\x1b[=>78]/g;
+export const stripEscapes = (s) => s.replace(ANSI, "");
+const HEAD = 60;
+const TAIL = 300;
+/**
+ * At most `maxBytes` of `text`, keeping both ends: compilers print the first (root) error at the top and test runners
+ * print the summary at the bottom. A third comes from the start and two thirds from the end, cut on line boundaries
+ * where possible and never inside a UTF-8 character.
+ */
+export function keepEnds(text, maxBytes) {
+    const buf = Buffer.from(text);
+    if (buf.length <= maxBytes)
+        return { text, truncated: false };
+    let headEnd = Math.floor(maxBytes / 3);
+    while (headEnd > 0 && (buf[headEnd] & 0xc0) === 0x80)
+        headEnd--; // back to the start of a character
+    let tailStart = buf.length - (maxBytes - Math.floor(maxBytes / 3));
+    while (tailStart < buf.length && (buf[tailStart] & 0xc0) === 0x80)
+        tailStart++;
+    let head = buf.subarray(0, headEnd).toString("utf8");
+    let tail = buf.subarray(tailStart).toString("utf8");
+    const nl = head.lastIndexOf("\n");
+    if (nl > head.length / 2)
+        head = head.slice(0, nl);
+    const nl2 = tail.indexOf("\n");
+    if (nl2 >= 0 && nl2 < tail.length / 2)
+        tail = tail.slice(nl2 + 1);
+    const omitted = buf.length - Buffer.byteLength(head) - Buffer.byteLength(tail);
+    return { text: `${head}\n… ${omitted.toLocaleString("en-US")} bytes omitted from the middle …\n${tail}`, truncated: true };
+}
+/**
+ * Collects a stream's bytes in bounded memory: the first `head` bytes and the last `tail` bytes, counting what was
+ * dropped in between. Keeping only the end would lose the first error of a long build.
+ */
+export class HeadTail {
+    headBuf = [];
+    headLen = 0;
+    tailBuf = [];
+    tailLen = 0;
+    omitted = 0;
+    headMax;
+    tailMax;
+    constructor(headMax, tailMax) {
+        this.headMax = headMax;
+        this.tailMax = tailMax;
+    }
+    push(b) {
+        if (this.headLen < this.headMax) {
+            const take = b.subarray(0, this.headMax - this.headLen);
+            this.headBuf.push(take);
+            this.headLen += take.length;
+            b = b.subarray(take.length);
+        }
+        if (!b.length)
+            return;
+        this.tailBuf.push(b);
+        this.tailLen += b.length;
+        while (this.tailLen - this.tailBuf[0].length >= this.tailMax) {
+            this.omitted += this.tailBuf[0].length;
+            this.tailLen -= this.tailBuf.shift().length;
+        }
+        if (this.tailLen > this.tailMax) {
+            const extra = this.tailLen - this.tailMax;
+            this.tailBuf[0] = this.tailBuf[0].subarray(extra);
+            this.tailLen -= extra;
+            this.omitted += extra;
+        }
+    }
+    text() {
+        const head = Buffer.concat(this.headBuf).toString("utf8");
+        const tail = Buffer.concat(this.tailBuf).toString("utf8");
+        return this.omitted ? `${head}\n… ${this.omitted.toLocaleString("en-US")} bytes omitted from the middle …\n${tail}` : head + tail;
+    }
+}
+/** `changed` is true when anything was dropped or collapsed other than escapes, so the caller can keep the full text on disk. */
+export function condenseOutput(raw) {
+    const lines = stripEscapes(raw)
+        .replace(/\r\n/g, "\n")
+        .split("\n")
+        .map((l) => (l.includes("\r") ? l.slice(l.lastIndexOf("\r", l.length - 2) + 1).replace(/\r$/, "") : l)); // progress bars: keep the last redraw
+    let changed = lines.length !== raw.split("\n").length;
+    const out = [];
+    for (let i = 0; i < lines.length;) {
+        let j = i + 1;
+        while (j < lines.length && lines[j] === lines[i])
+            j++;
+        if (j - i >= 4 && lines[i].trim()) {
+            out.push(lines[i], `… (the line above repeated ${j - i - 1} more times)`);
+            changed = true;
+        }
+        else
+            out.push(...lines.slice(i, j));
+        i = j;
+    }
+    if (out.length > HEAD + TAIL + 20) {
+        const cut = out.length - HEAD - TAIL;
+        return { text: [...out.slice(0, HEAD), `… ${cut} lines omitted from the middle …`, ...out.slice(-TAIL)].join("\n"), changed: true };
+    }
+    return { text: out.join("\n"), changed };
+}