@bli-cockpit/cli 0.2.38 → 0.2.39

package/dist/commands/brief.js

@@ -0,0 +1,133 @@
+/**
+ * `cockpit brief` — the TODAY page, read from a terminal (BLI-3458).
+ *
+ * This file owns terminal output only. The page itself, whose it is, whether
+ * this person may open it and which version they asked for are all decided by
+ * `GET /api/jarvis/brief`, which calls the SAME `loadBriefView` the website's
+ * home page calls. There is deliberately no local rendering of a `JarvisPage`
+ * here: the dashboard hands back finished text (the serializer's
+ * `TERMINAL_FLAVOR`), so the terminal and the browser cannot drift into showing
+ * two different briefs.
+ *
+ * Identity is the existing paired device session. `--for` changes WHOSE page is
+ * asked for, never who is asking — the same rule `cockpit jarvis --as` follows.
+ */
+import { writeLine } from "./cli-io.js";
+import { loadPairedSession, towerJsonRequest } from "../tower-client.js";
+const DIM = "\x1b[2m";
+const RESET = "\x1b[0m";
+const REQUEST_DEADLINE_MS = 30_000;
+export async function runBrief(command, io) {
+    const session = await loadPairedSession("brief", command.homeDir);
+    const dashboardUrl = command.dashboardUrl ?? session.dashboard_url;
+    const startedAt = Date.now();
+    const result = await towerJsonRequest({
+        dashboardUrl,
+        path: `/api/jarvis/brief${queryFor(command)}`,
+        deviceToken: session.device_token,
+        fetch: io.fetch,
+        method: "GET",
+        label: "brief",
+        timeoutMs: REQUEST_DEADLINE_MS,
+        log: (line) => writeLine(io.stderr, line),
+    });
+    if (!result.ok) {
+        // `towerJsonRequest` already turned a non-2xx into the server's own
+        // sentence, which for this route is the plain-words notice a person reads
+        // on the page ("Nothing has been written for you yet."). Relayed verbatim
+        // rather than translated into a code.
+        writeFailure(command, io, result.reason, result.detail);
+        return 1;
+    }
+    const body = result.body;
+    if (!body.ok || typeof body.text !== "string") {
+        const detail = body.reply ?? body.error ?? "Tower answered without a page.";
+        writeFailure(command, io, body.error ?? "no_page", detail);
+        return 1;
+    }
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify(body));
+    }
+    else {
+        writeHuman(io, command, body);
+    }
+    writeLine(io.stderr, `[brief cli] read ${JSON.stringify({
+        text_length: body.text.length,
+        cadence: body.page?.cadence ?? null,
+        visible_because: body.visibleBecause ?? null,
+        tldr: Boolean(command.tldr),
+        pinned_version: command.version != null,
+        subject: command.subject ? "selected" : "caller",
+        version_count: body.versions?.length ?? null,
+        versions_reason: body.versionsReason ?? null,
+        claim_count: body.claims?.length ?? null,
+        elapsed_ms: Date.now() - startedAt,
+    })}`);
+    return 0;
+}
+function queryFor(command) {
+    const params = new URLSearchParams();
+    if (command.subject)
+        params.set("p", command.subject);
+    if (command.version)
+        params.set("v", command.version);
+    if (command.tldr)
+        params.set("tldr", "1");
+    if (command.versions)
+        params.set("versions", "1");
+    if (command.claims)
+        params.set("claims", "1");
+    const query = params.toString();
+    return query ? `?${query}` : "";
+}
+function writeHuman(io, command, body) {
+    const page = body.page ?? {};
+    // Whose page, and — when it is not the newest — that it is a record of a
+    // moment rather than something that failed to update.
+    const whose = page.displayName ? `${page.displayName}'s page` : "This page";
+    const pinned = page.olderVersionLabel ? ` · version from ${page.olderVersionLabel}` : "";
+    writeLine(io.stdout, `${DIM}${whose}${pinned}${RESET}`);
+    writeLine(io.stdout, "");
+    writeLine(io.stdout, body.text ?? "");
+    if (body.claims && body.claims.length > 0) {
+        writeLine(io.stdout, "");
+        writeLine(io.stdout, `${DIM}Claim ids — pass one to \`cockpit correct --claim\`:${RESET}`);
+        for (const claim of body.claims) {
+            writeLine(io.stdout, `${DIM}  [${claim.claimId}]${RESET} ${claim.text ?? ""}`);
+        }
+    }
+    if (body.versions) {
+        writeLine(io.stdout, "");
+        if (body.versions.length === 0) {
+            // Never "there is one version". An empty list with a reason is an
+            // answer; an empty list without one is a wrong answer.
+            writeLine(io.stdout, `${DIM}Earlier versions could not be listed (${body.versionsReason ?? "no reason given"}).${RESET}`);
+        }
+        else {
+            writeLine(io.stdout, `${DIM}Versions — pass one to \`cockpit brief --version\`:${RESET}`);
+            for (const version of body.versions) {
+                const headline = version.headline ? ` — ${version.headline}` : "";
+                writeLine(io.stdout, `${DIM}  ${version.version}/${version.of}  ${version.pageId}  ${version.asOf}${headline}${RESET}`);
+            }
+        }
+    }
+    if (!command.subject && body.people && body.people.length > 1) {
+        const others = body.people
+            .filter((person) => person.personId !== page.personId)
+            .map((person) => person.slug)
+            .filter(Boolean);
+        if (others.length > 0) {
+            writeLine(io.stdout, "");
+            writeLine(io.stdout, `${DIM}You can also open: ${others.join(", ")} (\`--for <name>\`)${RESET}`);
+        }
+    }
+}
+function writeFailure(command, io, reason, detail) {
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({ ok: false, error: reason, detail }));
+    }
+    else {
+        writeLine(io.stderr, detail);
+    }
+    writeLine(io.stderr, `[brief cli] not read ${JSON.stringify({ reason })}`);
+}

package/dist/commands/correct.js

@@ -0,0 +1,160 @@
+/**
+ * `cockpit correct` — say that one line on the page is wrong (BLI-3458).
+ *
+ * Two requests, in this order, and the order matters:
+ *
+ *   1. `GET /api/jarvis/brief?claims=1` — resolve WHICH page and WHOSE, and
+ *      look up the line the person named. That read is also what supplies the
+ *      two facts the correction door needs and a terminal cannot know:
+ *      whether the clause rests on a machine record (`observed`, which decides
+ *      tier 2 vs tier 3) and the receipt links the live ground-truth check
+ *      mines for an identifier.
+ *   2. `POST /api/jarvis/corrections` — the same door the panel's form uses,
+ *      which checks the claim against the live record BEFORE writing, and can
+ *      answer back that the record disagrees.
+ *
+ * A claim id the page does not carry is refused HERE, before any write, with
+ * the fix named — `cockpit brief --claims` prints every id. Filing it anyway
+ * would land a correction on a clause nobody can find, which is how a ledger
+ * fills with rows that mean nothing.
+ *
+ * The push-back is the point of this command, not an error path: when JARVIS
+ * says the record disagrees, that sentence is what the person came for, and it
+ * is printed on stdout with an exit code of 0 — the correction WAS filed, with
+ * its outcome recorded. Only a failure to file at all is a non-zero exit.
+ */
+import { isInteractiveStdin, writeLine } from "./cli-io.js";
+import { loadPairedSession, towerJsonRequest } from "../tower-client.js";
+const DIM = "\x1b[2m";
+const RESET = "\x1b[0m";
+const REQUEST_DEADLINE_MS = 60_000;
+const MAX_CORRECTION_LENGTH = 4000;
+export async function runCorrect(command, io) {
+    const session = await loadPairedSession("correct", command.homeDir);
+    const dashboardUrl = command.dashboardUrl ?? session.dashboard_url;
+    const log = (line) => writeLine(io.stderr, line);
+    const startedAt = Date.now();
+    const text = await resolveText(command, io);
+    if (!text) {
+        writeFailure(command, io, "no_correction_text", 'Say what is wrong: `cockpit correct --claim <id> --text "..."`, or pipe it in on stdin.');
+        return 1;
+    }
+    // Step one: which page, whose, and does that line exist.
+    const read = await towerJsonRequest({
+        dashboardUrl,
+        path: `/api/jarvis/brief${briefQuery(command)}`,
+        deviceToken: session.device_token,
+        fetch: io.fetch,
+        method: "GET",
+        label: "correct:brief",
+        timeoutMs: REQUEST_DEADLINE_MS,
+        log,
+    });
+    if (!read.ok) {
+        writeFailure(command, io, read.reason, read.detail);
+        return 1;
+    }
+    const brief = read.body;
+    const personId = brief.page?.personId;
+    if (!brief.ok || !personId) {
+        writeFailure(command, io, brief.error ?? "no_page", brief.reply ?? "There is no page to correct.");
+        return 1;
+    }
+    const claim = (brief.claims ?? []).find((candidate) => candidate.claimId === command.claimId);
+    if (!claim) {
+        writeFailure(command, io, "unknown_claim", `That page has no line called “${command.claimId}”. Run \`cockpit brief --claims\` to see the ids.`);
+        return 1;
+    }
+    // Step two: the same door the panel's form posts to.
+    const written = await towerJsonRequest({
+        dashboardUrl,
+        path: "/api/jarvis/corrections",
+        deviceToken: session.device_token,
+        fetch: io.fetch,
+        label: "correct",
+        timeoutMs: REQUEST_DEADLINE_MS,
+        log,
+        body: {
+            personId,
+            pageId: brief.page?.pageId ?? null,
+            claimId: command.claimId,
+            // The line as it reads now, so the ledger records what was disputed and
+            // the live check has the sentence to work from.
+            quotedText: claim.text ?? null,
+            correctionText: text,
+            contextLinks: claim.links ?? [],
+            clauseOnPage: true,
+            clauseIsObserved: Boolean(claim.observed),
+            ...(command.supersedes ? { supersedes: command.supersedes } : {}),
+        },
+    });
+    if (!written.ok) {
+        writeFailure(command, io, written.reason, written.detail);
+        return 1;
+    }
+    const filed = written.body;
+    if (!filed.correctionId) {
+        writeFailure(command, io, "not_filed", filed.error ?? "Tower did not record that correction.");
+        return 1;
+    }
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({ ok: true, ...filed }));
+    }
+    else {
+        writeLine(io.stdout, filed.reply ?? "Filed.");
+        if (filed.finding)
+            writeLine(io.stdout, `${DIM}The record says: ${filed.finding}${RESET}`);
+        if (filed.link)
+            writeLine(io.stdout, `${DIM}${filed.link}${RESET}`);
+    }
+    writeLine(io.stderr, `[correct cli] filed ${JSON.stringify({
+        tier: filed.tier ?? null,
+        outcome: filed.outcome ?? null,
+        pushed_back: Boolean(filed.pushBack),
+        observed_clause: Boolean(claim.observed),
+        context_links: (claim.links ?? []).length,
+        supersedes: command.supersedes != null,
+        subject: command.subject ? "selected" : "caller",
+        text_length: text.length,
+        elapsed_ms: Date.now() - startedAt,
+    })}`);
+    return 0;
+}
+function briefQuery(command) {
+    const params = new URLSearchParams({ claims: "1" });
+    if (command.subject)
+        params.set("p", command.subject);
+    if (command.version)
+        params.set("v", command.version);
+    return `?${params.toString()}`;
+}
+/** `--text`, or whatever was piped in. Never a prompt — this may run headless. */
+async function resolveText(command, io) {
+    if (command.text)
+        return command.text;
+    if (isInteractiveStdin(io))
+        return null;
+    const piped = await readAll(io.stdin);
+    const trimmed = piped.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+async function readAll(stream) {
+    stream.setEncoding("utf8");
+    let text = "";
+    for await (const chunk of stream) {
+        text += chunk;
+        if (text.length > MAX_CORRECTION_LENGTH) {
+            throw new Error(`A correction is limited to ${MAX_CORRECTION_LENGTH} characters.`);
+        }
+    }
+    return text;
+}
+function writeFailure(command, io, reason, detail) {
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({ ok: false, error: reason, detail }));
+    }
+    else {
+        writeLine(io.stderr, detail);
+    }
+    writeLine(io.stderr, `[correct cli] not filed ${JSON.stringify({ reason })}`);
+}

package/dist/commands/jarvis.js

@@ -7,7 +7,7 @@
  */
 import { isInteractiveStdin, readLine, writeLine } from "./cli-io.js";
 import { attachedFileRefusalSentence, readAttachedImage, } from "./jarvis-attachment.js";
-import { loadPairedSession, towerFailureDetail, towerRequest, } from "../tower-client.js";
+import { loadPairedSession, towerFailureDetail, towerJsonRequest, towerRequest, } from "../tower-client.js";
 import { readTowerTurn, streamFailureDetail, } from "../tower-stream.js";
 const TRACE_DIM = "\x1b[2m";
 const TRACE_RESET = "\x1b[0m";
@@ -21,6 +21,12 @@ const TURN_DEADLINE_MS = 125_000;
 export async function runJarvis(command, io) {
     const session = await loadPairedSession("jarvis", command.homeDir);
     const dashboardUrl = command.dashboardUrl ?? session.dashboard_url;
+    // BLI-3458: reading back what was already said. No turn, no model, no
+    // conversation-ledger write — and, on the server, only ever THIS device
+    // holder's own terminal rows.
+    if (command.threads || command.history) {
+        return readHistory({ command, dashboardUrl, deviceToken: session.device_token }, io);
+    }
     const oneShotPrompt = await resolveOneShotPrompt(command, io);
     if (oneShotPrompt !== null) {
         return sendOneTurn({ command, dashboardUrl, deviceToken: session.device_token }, oneShotPrompt, io);
@@ -40,6 +46,91 @@ export async function runJarvis(command, io) {
             return exitCode;
     }
 }
+/**
+ * `--threads` and `--thread <name> --history`.
+ *
+ * The whole conversation lives on the server; nothing is cached locally, so a
+ * person who moves between machines sees the same history on both. The server
+ * scopes it to the device holder's own account — this command cannot ask for
+ * anybody else's, and there is no flag that would let it.
+ */
+async function readHistory(context, io) {
+    const { command } = context;
+    const params = new URLSearchParams();
+    if (command.history) {
+        params.set("thread", command.thread);
+        if (command.limit)
+            params.set("limit", String(command.limit));
+    }
+    else {
+        params.set("threads", "1");
+    }
+    const result = await towerJsonRequest({
+        dashboardUrl: context.dashboardUrl,
+        path: `/api/jarvis/cli?${params.toString()}`,
+        deviceToken: context.deviceToken,
+        fetch: io.fetch,
+        method: "GET",
+        label: command.history ? "jarvis:thread" : "jarvis:threads",
+        timeoutMs: 30_000,
+        log: (line) => writeLine(io.stderr, line),
+    });
+    if (!result.ok) {
+        writeFailure(command, io, result.reason, result.detail);
+        return 1;
+    }
+    const body = result.body;
+    if (body.ok === false) {
+        writeFailure(command, io, "history_unavailable", body.reply ?? "Tower had nothing to show.");
+        return 1;
+    }
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify(body));
+    }
+    else if (command.history) {
+        writeThreadHistory(io, body);
+    }
+    else {
+        writeThreadList(io, body.threads ?? []);
+    }
+    writeLine(io.stderr, `[jarvis cli] history read ${JSON.stringify({
+        mode: command.history ? "thread" : "threads",
+        thread_count: body.threads?.length ?? null,
+        message_count: body.messages?.length ?? null,
+        truncated: body.truncated ?? null,
+    })}`);
+    return 0;
+}
+function writeThreadList(io, threads) {
+    if (threads.length === 0) {
+        // A real answer, not a blank. Nothing here means nothing was ever asked
+        // from this terminal, which is worth saying rather than implying.
+        writeLine(io.stdout, "No terminal conversations yet. Ask something with `cockpit jarvis`.");
+        return;
+    }
+    for (const thread of threads) {
+        const turns = thread.turnCount === 1 ? "1 turn" : `${thread.turnCount ?? 0} turns`;
+        writeLine(io.stdout, `${thread.name}  ${TRACE_DIM}${turns} · ${thread.lastAt ?? "unknown"}${TRACE_RESET}`);
+        if (thread.preview)
+            writeLine(io.stdout, `${TRACE_DIM}  ${thread.preview}${TRACE_RESET}`);
+    }
+    writeLine(io.stdout, "");
+    writeLine(io.stdout, `${TRACE_DIM}Replay one with \`cockpit jarvis --thread <name> --history\`.${TRACE_RESET}`);
+}
+function writeThreadHistory(io, body) {
+    const messages = body.messages ?? [];
+    if (messages.length === 0) {
+        writeLine(io.stdout, `Nothing has been said in “${body.thread ?? "that thread"}” yet.`);
+        return;
+    }
+    if (body.truncated) {
+        writeLine(io.stdout, `${TRACE_DIM}Showing the most recent ${messages.length}; there is more before this (\`--limit\`).${TRACE_RESET}`);
+    }
+    for (const message of messages) {
+        const speaker = message.role === "you" ? "you" : "jarvis";
+        writeLine(io.stdout, `${speaker}> ${message.text ?? ""}`);
+    }
+}
 async function resolveOneShotPrompt(command, io) {
     if (command.prompt)
         return validatePrompt(command.prompt);
@@ -257,7 +348,10 @@ function writeModelReceipt(io, model) {
     const mismatched = requested !== null && answered !== null && requested !== answered;
     if (!model.fallback && !mismatched)
         return;
-    writeLine(io.stdout, `Model: ${answered ?? "an unknown model"} answered (${requested ?? "the requested model"} unavailable)`);
+    // 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"}`);
 }
 function writeFailure(command, io, reason, detail) {
     if (command.json) {