@bli-cockpit/cli 0.2.54 → 0.2.55

package/dist/commands/heartbeat.js

@@ -102,6 +102,12 @@ export function buildCollectorHeartbeat(options) {
         ...(typeof options.facts.sessionsOutsideRoot === "number"
             ? { sessions_outside_root: options.facts.sessionsOutsideRoot }
             : {}),
+        ...(typeof options.facts.sessionsNewThisTick === "number"
+            ? { sessions_new_this_tick: options.facts.sessionsNewThisTick }
+            : {}),
+        ...(typeof options.facts.sessionsPendingUpload === "number"
+            ? { sessions_pending_upload: options.facts.sessionsPendingUpload }
+            : {}),
     };
 }
 /**
@@ -176,6 +182,8 @@ export async function sendCollectorHeartbeatBestEffort(options) {
             sync_reason: heartbeat.last_sync_reason ?? null,
             sessions_observed: heartbeat.sessions_observed ?? null,
             sessions_outside_root: heartbeat.sessions_outside_root ?? null,
+            sessions_new_this_tick: heartbeat.sessions_new_this_tick ?? null,
+            sessions_pending_upload: heartbeat.sessions_pending_upload ?? null,
         }));
         return true;
     }

package/dist/commands/jarvis-contracts.js

@@ -0,0 +1,8 @@
+/**
+ * The parsed `cockpit jarvis` command, and the reply shapes it reads off
+ * `/api/jarvis/cli` and `--threads`/`--history`. Every reply field is loose
+ * and optional on purpose — this package has no dependency on
+ * `apps/dashboard`, so a shape drifting a field should degrade to "say
+ * nothing about it" here, never a crash.
+ */
+export {};

package/dist/commands/jarvis-render.js

@@ -0,0 +1,413 @@
+/**
+ * Everything around a turn that is not the network call itself: getting a
+ * turn ready to send (the question, and the attachment multipart body),
+ * reporting what it did (the failure sentence, the fallback-model receipt,
+ * the latency split), and drawing the answer in a terminal — live, settled,
+ * and its "how I got there" trace — since a terminal cannot unprint.
+ */
+import { colorEnabled, dim, isInteractiveStdin, readPipedText, writeFragment, writeLine } from "./cli-io.js";
+import { attachedFileRefusalSentence, } from "./jarvis-attachment.js";
+import { turnTimingFields } from "../tower-stream.js";
+/**
+ * The dashboard route caps a turn at 120s (`maxDuration = 120`). The client
+ * waits slightly longer so the server's own named failure wins the race
+ * whenever it manages to send one; past that, the terminal names the timeout
+ * itself rather than sitting there.
+ */
+export const TURN_DEADLINE_MS = 125_000;
+export async function resolveOneShotPrompt(command, io) {
+    if (command.prompt)
+        return validatePrompt(command.prompt);
+    if (isInteractiveStdin(io))
+        return null;
+    const piped = await readPipedText(io.stdin, { maxChars: 4000, overflowMessage: "JARVIS questions are limited to 4000 characters." });
+    return validatePrompt(piped);
+}
+export function validatePrompt(raw) {
+    const prompt = raw.trim();
+    if (!prompt)
+        throw new Error("JARVIS needs a non-empty question.");
+    if (prompt.length > 4000) {
+        throw new Error("JARVIS questions are limited to 4000 characters.");
+    }
+    return prompt;
+}
+/**
+ * The multipart body `/api/jarvis/cli` reads when a file is attached
+ * (BLI-3414) — same field names the request handler parses, mirroring the
+ * JSON body's fields plus one `image` file field.
+ */
+export function buildAttachmentForm(command, prompt, attachment) {
+    const form = new FormData();
+    form.set("question", prompt);
+    form.set("thread", command.thread);
+    if (command.subject)
+        form.set("subject", command.subject);
+    if (command.model)
+        form.set("model", command.model);
+    if (command.date)
+        form.set("date", command.date);
+    form.set("image", new File([attachment.bytes], attachment.fileName, { type: attachment.mimeType }));
+    return form;
+}
+/** A refusal caught locally, before any request went out — never a stack trace. */
+export function writeAttachmentRefusal(command, io, refusal, filePath) {
+    const message = attachedFileRefusalSentence(refusal, filePath);
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({ ok: false, error: refusal, detail: message }));
+    }
+    else {
+        writeLine(io.stderr, `JARVIS could not attach that file: ${message}`);
+    }
+    writeLine(io.stderr, `[jarvis cli] attachment refused ${JSON.stringify({ reason: refusal })}`);
+}
+export function writeFailure(command, io, reason, detail) {
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({ ok: false, error: reason, detail }));
+        return;
+    }
+    writeLine(io.stderr, `JARVIS could not answer: ${detail}`);
+}
+/**
+ * One line, only when the answer did not come from what was requested — a
+ * fallback, or an explicit `--model` that landed on a different model
+ * (BLI-3381). Silent otherwise, matching the web panel's own fallback notice.
+ */
+export function writeModelReceipt(io, model) {
+    if (!model)
+        return;
+    const requested = typeof model.requestedModel === "string" ? model.requestedModel : null;
+    const answered = namedModel(model.model);
+    const mismatched = requested !== null && answered !== null && requested !== answered;
+    if (!model.fallback && !mismatched)
+        return;
+    // BLI-3467: never the word "unavailable" — this side cannot know why, and
+    // on 2026-09-01 the real cause was a healthy provider refusing our own tool
+    // schema. Say what the receipt actually reports.
+    writeLine(io.stdout, `Model: ${answered ?? "an unknown model"} answered instead of ${requested ?? "the requested model"}`);
+}
+/** One millisecond span off the wire, or null for anything that is not a number. */
+function latencyMs(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+/** The latency split for `--json`, always the same three keys so a consumer can rely on them. */
+export function latencyFields(latency) {
+    return {
+        wireMs: latencyMs(latency?.wireMs),
+        prepMs: latencyMs(latency?.prepMs),
+        modelTtftMs: latencyMs(latency?.modelTtftMs),
+    };
+}
+/** The same three spans as log fields, snake_case like everything else on that line. */
+export function latencyLogFields(latency) {
+    const split = latencyFields(latency);
+    return {
+        wire_ms: split.wireMs,
+        prep_ms: split.prepMs,
+        model_ttft_ms: split.modelTtftMs,
+    };
+}
+/**
+ * The receipt's `model` field, unless it is the server's own "I could not tell"
+ * sentinel (BLI-3582).
+ *
+ * `modelReceipt` on the dashboard writes the literal string `"unknown"` when
+ * the run reported no model, and this side used to read that as a model NAME —
+ * so a turn whose model was simply unnamed printed
+ * `Model: unknown answered instead of gpt-5.6-terra`, a fallback notice for a
+ * fallback that never happened. Every streamed turn hit it. The dashboard fix
+ * makes the streamed path name the model again; this one makes the sentinel
+ * unable to invent a fallback on any dashboard version, old or new.
+ */
+function namedModel(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed || trimmed.toLowerCase() === "unknown")
+        return null;
+    return trimmed;
+}
+/**
+ * The terminal's own spans as log fields (BLI-3591).
+ *
+ * Deliberately snake_case beside the dashboard's three, and deliberately
+ * distinct names: `model_ttft_ms` is the dashboard's clock, `first_token_ms`
+ * is this one, and confusing them is how a latency line stops being
+ * answerable.
+ */
+export function clientTimingFields(boot, turn) {
+    return {
+        boot_ms: boot.bootMs,
+        session_ms: boot.sessionMs,
+        prompt_ms: boot.promptMs,
+        pre_request_ms: turn.preRequestMs,
+        responded_ms: turn.respondedMs,
+        ...turnTimingFields(turn.timing),
+    };
+}
+/**
+ * A citation line's link, as the dashboard mints it (BLI-3570):
+ * `Source: BLI-1234 — Judge outage <https://linear.app/…>`. The words are the
+ * receipt; the link is not part of the sentence, so the terminal prints it
+ * underneath, dim, rather than dragging a 118-character URL through the answer.
+ */
+const CITATION_LINK = /^(\s*(?:Source|Receipt)s?:.*?)\s*<(https?:\/\/[^>\s]+)>\s*$/i;
+/**
+ * The answer, one line at a time, so a receipt's link gets its own dim line.
+ * Every other line is printed exactly as it arrived — this never rewrites the
+ * words, only where the link sits.
+ */
+export function writeReply(io, prefix, reply) {
+    const styled = colorEnabled(io);
+    const lines = reply.split("\n");
+    lines.forEach((line, index) => {
+        const head = index === 0 ? prefix : "";
+        const citation = line.match(CITATION_LINK);
+        if (!citation) {
+            writeLine(io.stdout, `${head}${line}`);
+            return;
+        }
+        writeLine(io.stdout, `${head}${citation[1]}`);
+        writeLine(io.stdout, dim(`  ${citation[2]}`, styled));
+    });
+}
+/**
+ * The same link rule, applied to text that CONTINUES a line already on screen
+ * (BLI-3517 + BLI-3570).
+ *
+ * When the answer streamed, the citation block arrives after the last token,
+ * so `settle` has a tail to print rather than a whole reply. The first fragment
+ * is deliberately never tested against `CITATION_LINK`: it is the rest of a
+ * sentence the person is already reading, not a line of its own, and a regex
+ * anchored at `^` would be matching against a boundary that is not there.
+ * Every COMPLETE line after it gets the dim link treatment as usual.
+ *
+ * A citation that was already streamed inline cannot be split — a terminal
+ * cannot unprint — and that is the honest limit of this, not a bug to chase.
+ */
+export function writeReplyContinuation(io, tail) {
+    const styled = colorEnabled(io);
+    const [first = "", ...rest] = tail.split("\n");
+    writeFragment(io.stdout, first);
+    for (const line of rest) {
+        writeLine(io.stdout, "");
+        const citation = line.match(CITATION_LINK);
+        if (!citation) {
+            writeFragment(io.stdout, line);
+            continue;
+        }
+        writeFragment(io.stdout, citation[1]);
+        writeLine(io.stdout, "");
+        writeFragment(io.stdout, dim(`  ${citation[2]}`, styled));
+    }
+    writeLine(io.stdout, "");
+}
+/**
+ * What the terminal says when the grounding gate changed an answer it had
+ * already printed. The browser's own mark says the same thing in one word
+ * (`ANSWER_REVISED_NOTE`, `apps/dashboard/src/lib/webchat/tool-trace.ts`);
+ * this package cannot import from the dashboard, so the sentence is written
+ * here in the same register rather than shared through a dependency that does
+ * not exist.
+ */
+const ANSWER_REVISED_LINE = "revised: I checked that against its sources and changed what they did not back up";
+/**
+ * The three lines a correction's rewrite prints (BLI-3567).
+ *
+ * The browsers replace the paragraph where it stands. A terminal cannot —
+ * stdout is a river — so it says the same three things in sequence instead:
+ * that a rewrite is under way, what the paragraph now says, and that the
+ * printed one above it did not change. The last of those is the honest half:
+ * without it a person would have two versions on screen and no idea which one
+ * JARVIS believes.
+ *
+ * `ANSWER_UPDATING_LINE` is the terminal's copy of the browsers'
+ * `ANSWER_UPDATING_LABEL` (`apps/dashboard/src/lib/webchat/tool-trace.ts`),
+ * word for word. This package cannot import from the dashboard, so it is
+ * written out here rather than shared through a dependency that does not exist
+ * — the same arrangement `ANSWER_REVISED_LINE` above already has.
+ */
+export const ANSWER_UPDATING_LINE = "(updating...)";
+const ANSWER_CORRECTED_LINE = "revised after your correction";
+const ANSWER_CORRECTED_NOTE_LINE = "The paragraph printed above is unchanged — a terminal cannot rewrite what it already " +
+    "printed. This is what it says now.";
+const ANSWER_REWRITE_UNVERIFIED_LINE = "Your correction is recorded. I could not verify a rewrite of that paragraph against its " +
+    "sources, so it stays as it was.";
+/**
+ * The answer as it is written, in a terminal (BLI-3517).
+ *
+ * A terminal cannot unprint. That single fact decides everything here:
+ *
+ * - The words stream out under the usual `jarvis> ` prefix, printed the moment
+ *   they arrive rather than after the whole turn (a measured 4-16 s of nothing
+ *   before this ticket).
+ * - A `reset` — the server taking back a draft the model wrote before deciding
+ *   to call a tool — cannot erase what is on screen, so it SAYS so on its own
+ *   line and the replacement follows. Never a retracted sentence left standing
+ *   with nothing marking it.
+ * - The settled reply is the authority. The grounding gate runs on the whole
+ *   text once the stream ends, so the answer can grow (citations, a fallback
+ *   notice) or change. A pure continuation is printed as the remainder; a
+ *   genuine change is reprinted whole under a line saying it was revised.
+ * - `--json` never streams a fragment: that contract is exactly one object on
+ *   stdout, and every method here is a no-op for it.
+ */
+export function createLiveAnswer(command, io) {
+    const styled = colorEnabled(io);
+    const quiet = command.json === true;
+    let printed = "";
+    let opened = false;
+    const open = (subject) => {
+        if (opened)
+            return;
+        opened = true;
+        writeFragment(io.stdout, `jarvis${subject}> `);
+    };
+    return {
+        token(event) {
+            if (quiet)
+                return;
+            const text = event.text ?? "";
+            if (event.reset) {
+                if (printed) {
+                    writeLine(io.stdout, "");
+                    writeLine(io.stdout, dim("  — that draft was replaced —", styled));
+                    opened = false;
+                }
+                printed = "";
+            }
+            if (!text)
+                return;
+            open("");
+            printed += text;
+            writeFragment(io.stdout, text);
+        },
+        interrupt() {
+            if (quiet || !opened)
+                return;
+            writeLine(io.stdout, "");
+            opened = false;
+        },
+        settle(reply, subject, revised) {
+            if (quiet)
+                return;
+            if (!printed) {
+                // Nothing streamed: a non-streaming dashboard, `--no-stream`, or a
+                // turn whose words never arrived. Exactly the pre-ticket line, dim
+                // citation link and all (BLI-3570).
+                writeReply(io, `jarvis${subject}> `, reply);
+                return;
+            }
+            if (reply === printed) {
+                if (opened)
+                    writeLine(io.stdout, "");
+                return;
+            }
+            if (reply.startsWith(printed)) {
+                // The gate only ADDED — citations going back under the answer, a
+                // fallback notice. Print the tail and leave the words alone; the
+                // citation block is exactly the thing BLI-3570 puts its link under, and
+                // it is arriving here rather than in the stream.
+                if (!opened)
+                    writeFragment(io.stdout, `jarvis${subject}> `);
+                writeReplyContinuation(io, reply.slice(printed.length));
+                return;
+            }
+            if (opened)
+                writeLine(io.stdout, "");
+            writeLine(io.stdout, dim(revised ? `  — ${ANSWER_REVISED_LINE} —` : "  — corrected —", styled));
+            writeReply(io, `jarvis${subject}> `, reply);
+        },
+        abandon() {
+            // The turn died with words already on screen. End the line so the
+            // failure sentence does not run on from a half-written answer.
+            if (!quiet && opened)
+                writeLine(io.stdout, "");
+        },
+    };
+}
+/**
+ * Print what a correction did to the answer above, once the turn has settled.
+ *
+ * `--json` prints nothing: that contract is exactly one object on stdout, and
+ * the revision rides it as a field. Every branch either prints or is a
+ * deliberate no-op with a stderr line behind it in `sendOneTurn`.
+ */
+export function writeRevision(command, io, revision) {
+    if (command.json)
+        return;
+    const styled = colorEnabled(io);
+    if (revision.status === "unverified") {
+        writeLine(io.stdout, "");
+        writeLine(io.stdout, dim(`  — ${ANSWER_REWRITE_UNVERIFIED_LINE}`, styled));
+        return;
+    }
+    if (revision.status !== "revised")
+        return;
+    const paragraphs = Array.isArray(revision.paragraphs) ? revision.paragraphs : [];
+    const written = paragraphs.filter((one) => typeof one === "object" && one !== null && typeof one.text === "string");
+    if (written.length === 0)
+        return;
+    writeLine(io.stdout, "");
+    writeLine(io.stdout, dim(`  — ${ANSWER_CORRECTED_LINE} —`, styled));
+    for (const paragraph of written)
+        writeLine(io.stdout, paragraph.text);
+    writeLine(io.stdout, dim(`  ${ANSWER_CORRECTED_NOTE_LINE}`, styled));
+}
+/**
+ * One dim line per tool the turn called (BLI-3381): what it was, how long it
+ * took, and — for a failure — the reason, matching what the web thinking
+ * trace shows (`describeToolTraceEvent` on the server side built these
+ * labels; this only renders them). Silent when no tool ran.
+ */
+export function writeTraceBlock(io, trace) {
+    if (!trace || trace.length === 0)
+        return;
+    for (const step of trace)
+        writeTraceLine(io, step);
+}
+/** The one dim trace line, drawn identically live (BLI-3457) and after the fact. */
+export function writeTraceLine(io, step) {
+    const elapsed = typeof step.elapsedMs === "number" ? ` (${step.elapsedMs}ms)` : "";
+    const failure = step.status === "failed" ? ` — failed: ${step.detail ?? "no reason given"}` : "";
+    writeLine(io.stdout, dim(`  ⏺ ${step.label}${elapsed}${failure}`, colorEnabled(io)));
+}
+/**
+ * Draws one streamed tool call, and says whether it drew anything.
+ *
+ * Only settled steps print: a `running` event is the same tool arriving a
+ * second time, and printing both would double every line in a terminal that
+ * cannot rewrite the one above it.
+ */
+export function writeActivityLine(io, event) {
+    if (event.status !== "done" && event.status !== "failed")
+        return false;
+    const step = activityToStep(event);
+    if (!step)
+        return false;
+    writeTraceLine(io, step);
+    return true;
+}
+/** The settled steps of a streamed turn, in the shape `--json` already promises. */
+export function activityToTrace(activity) {
+    const steps = [];
+    for (const event of activity) {
+        if (event.status !== "done" && event.status !== "failed")
+            continue;
+        const step = activityToStep(event);
+        if (step)
+            steps.push(step);
+    }
+    return steps;
+}
+function activityToStep(event) {
+    if (event.status !== "done" && event.status !== "failed")
+        return null;
+    return {
+        tool: event.tool ?? "unknown_tool",
+        label: event.label ?? event.tool ?? "A tool ran",
+        status: event.status,
+        ...(typeof event.elapsedMs === "number" ? { elapsedMs: event.elapsedMs } : {}),
+        ...(event.detail ? { detail: event.detail } : {}),
+    };
+}