@bli-cockpit/cli 0.2.48 → 0.2.50

package/dist/commands/cli-io.js

@@ -10,6 +10,19 @@ export function writeRaw(stream, text) {
     if (!text.endsWith("\n"))
         stream.write("\n");
 }
+/**
+ * Part of a line, and nothing else (BLI-3517).
+ *
+ * `writeRaw` finishes the line for you, which is right for a whole block of
+ * captured output and wrong for a sentence still being written: a streamed
+ * answer arrives as a dozen fragments and each one would land on its own row.
+ * This adds nothing at all; the caller ends the line when the thought ends.
+ */
+export function writeFragment(stream, text) {
+    if (!text)
+        return;
+    stream.write(text);
+}
 export function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/dist/commands/doctor.js

@@ -10,6 +10,7 @@ import { normalizeCollectionRoots } from "../root-normalization.js";
 import { detectSecondCockpitInstall } from "../second-install.js";
 import { runRawEvidenceLocalGc, rawEvidenceGcSummary } from "../raw-evidence-gc.js";
 import { runBackfillCommand } from "./backfill.js";
+import { installMemoryIntegration, inspectMemoryIntegration, } from "./memory-install.js";
 import { createInteractiveExecRunner } from "../process-runner.js";
 const GC_MIN_INTERVAL_MS = 24 * 60 * 60 * 1000;
 export async function runDoctor(command, io, hooks, overrides = {}) {
@@ -81,6 +82,14 @@ function doctorInvariants() {
             check: (context) => context.deps.checkAutostart(context),
             fix: (context, _state) => context.deps.fixAutostart(context),
         },
+        // BLI-3580. Runs right after autostart because it is the same kind of
+        // thing: a registration on this machine that nobody should have to be
+        // asked about. Its fix writes host configs, never installs software.
+        {
+            id: "memory-registered",
+            check: (context) => context.deps.checkMemory(context),
+            fix: (context, _state) => context.deps.fixMemory(context),
+        },
         {
             id: "backfill-complete",
             check: (context) => context.deps.checkBackfill(context),
@@ -111,6 +120,8 @@ function defaultDoctorDeps(hooks) {
         checkSingleInstall: checkSingleInstallState,
         checkAutostart: checkAutostartState,
         fixAutostart: fixAutostartState,
+        checkMemory: checkMemoryState,
+        fixMemory: fixMemoryState,
         checkBackfill: checkBackfillState,
         fixBackfill: fixBackfillState,
         checkGc: checkGcState,
@@ -307,6 +318,52 @@ async function fixAutostartState(context) {
     }
     return ok("autostart-alive", "installed", "background sync installed and running");
 }
+/**
+ * BLI Memory's registration on this machine (BLI-3580).
+ *
+ * The step owns the CONFIG, never the software: it writes the MCP entry, the
+ * hooks and the Codex table only when `bli-memory-mcp` actually resolves. With
+ * no server it writes NOTHING and reads `skipped bin_missing` — registering
+ * hooks that point at an absent binary would make every Claude Code turn print
+ * a hook failure, which is worse than waiting a day.
+ */
+async function checkMemoryState(context) {
+    const outcome = await inspectMemoryIntegration(memoryCommandFor(context), context.io);
+    return memoryStepState(outcome, "check");
+}
+async function fixMemoryState(context) {
+    const outcome = await installMemoryIntegration(memoryCommandFor(context), context.io);
+    return memoryStepState(outcome, "fix");
+}
+function memoryCommandFor(context) {
+    return {
+        kind: "memory",
+        action: "install",
+        homeDir: context.command.homeDir,
+        dashboardUrl: context.command.dashboardUrl,
+        dryRun: false,
+        json: context.command.json,
+    };
+}
+function memoryStepState(outcome, phase) {
+    const broken = outcome.targets.filter((target) => target.target !== "bin" && target.status === "failed");
+    if (broken.length > 0) {
+        const first = broken[0];
+        const message = `${first?.target ?? "memory"}: ${first?.reason ?? "failed"}`;
+        return phase === "fix"
+            ? fail("memory-registered", first?.reason ?? "memory_install_failed", message)
+            : needsFix("memory-registered", first?.reason ?? "memory_install_failed", message);
+    }
+    const pending = outcome.targets.filter((target) => target.target !== "bin" &&
+        (target.status === "missing" || target.status === "mismatch"));
+    if (pending.length > 0) {
+        return needsFix("memory-registered", "registration_incomplete", `BLI Memory is not registered with ${pending.map((target) => target.target).join(", ")}`);
+    }
+    if (!outcome.bin_found) {
+        return skipped("memory-registered", "bin_missing", "bli-memory-mcp is not on this machine yet; nothing was written and the next run will try again");
+    }
+    return ok("memory-registered", phase === "fix" ? "installed" : "already_installed", "BLI Memory is registered with both agent hosts");
+}
 /**
  * Pure so it can be unit-tested without touching the real machine's home
  * directory (`getCollectorRuntimePaths()` defaults to `os.homedir()` and

package/dist/commands/jarvis-trace.js

@@ -0,0 +1,184 @@
+/**
+ * `cockpit jarvis --trace <id|last>` — the step tree of one turn (BLI-3560).
+ *
+ * The one thing anybody here ever opened Langfuse for, in the terminal where
+ * the turn was asked. Every model step, every tool call, every server-side
+ * memory step (BLI-3416's doubled answer was one of those and no other surface
+ * showed it), with how long each took, which model ran it, what it spent and
+ * whether it failed.
+ *
+ * ## `last` and the remembered receipt
+ *
+ * A turn now hands back its own trace id, and this module writes that id — with
+ * the conversation it belonged to — to one small file beside the collector's
+ * other state. `--trace last` reads it, so the loop is: ask a question, watch
+ * it come back slow, type `cockpit jarvis --trace last`. If the file is not
+ * there (a fresh shell, a machine that has not asked anything since the
+ * release), the file's remembered THREAD is used to ask the server for that
+ * conversation's newest turn instead — and when there is neither, the refusal
+ * says so in words rather than printing nothing.
+ *
+ * The file holds two opaque ids and a timestamp. No question, no answer, no
+ * name; it is a bookmark, not a transcript.
+ *
+ * ## The lines
+ *
+ * Rendered SERVER-SIDE and printed verbatim. That is deliberate: the ops door,
+ * this terminal and JARVIS's own `readTurnTrace` tool all read the same
+ * sentences from `lib/ops/turn-trace-lines.ts`, so an older CLI against a newer
+ * dashboard still prints the current tree rather than its own stale idea of one.
+ */
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { colorEnabled, dim, writeLine } from "./cli-io.js";
+import { getCollectorRuntimePaths } from "../local-state.js";
+import { towerFailureDetail, towerJsonRequest } from "../tower-client.js";
+/** The bookmark file's name, inside the collector's own state directory. */
+const LAST_TURN_FILE = "last-turn-trace.json";
+function bookmarkPath(homeDir) {
+    const paths = getCollectorRuntimePaths(homeDir ?? os.homedir());
+    return path.join(paths.state_dir, LAST_TURN_FILE);
+}
+/**
+ * Remember the turn that just happened. Never throws: a bookmark that could not
+ * be written must not fail the answer a person already received, so the failure
+ * is named on stderr and the turn stands.
+ */
+export async function rememberTurnTrace(turn, io, homeDir) {
+    if (!turn.traceId && !turn.threadId)
+        return;
+    const file = bookmarkPath(homeDir);
+    const payload = {
+        traceId: turn.traceId ?? null,
+        threadId: turn.threadId ?? null,
+        at: new Date().toISOString(),
+    };
+    try {
+        await mkdir(path.dirname(file), { recursive: true });
+        await writeFile(file, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+    }
+    catch (error) {
+        writeLine(io.stderr, `[jarvis cli] could not remember this turn's trace ${JSON.stringify({
+            reason: "bookmark_write_failed",
+            error: error instanceof Error ? error.name : "unknown",
+        })}`);
+    }
+}
+/** The remembered turn, or null when there is not one. Never throws. */
+export async function readRememberedTurn(homeDir) {
+    try {
+        const raw = await readFile(bookmarkPath(homeDir), "utf8");
+        const parsed = JSON.parse(raw);
+        const traceId = typeof parsed.traceId === "string" ? parsed.traceId : null;
+        const threadId = typeof parsed.threadId === "string" ? parsed.threadId : null;
+        if (!traceId && !threadId)
+            return null;
+        return { traceId, threadId, at: typeof parsed.at === "string" ? parsed.at : "" };
+    }
+    catch {
+        // A missing or unreadable bookmark is "nothing is remembered", which is the
+        // exact answer asked for. The caller says so out loud in a sentence.
+        return null;
+    }
+}
+export async function runJarvisTrace(context, io) {
+    const log = (line) => writeLine(io.stderr, line);
+    let traceId = context.requested;
+    let resolvedFrom = "argument";
+    if (context.requested === "last") {
+        const remembered = await readRememberedTurn(context.homeDir);
+        if (!remembered) {
+            return refuse(context, io, "no_remembered_turn", "This machine has not asked JARVIS anything since traces were turned on, so there is no last turn to open. Ask something, then run this again — or pass the trace id from the turn's receipt.");
+        }
+        if (remembered.traceId) {
+            traceId = remembered.traceId;
+            resolvedFrom = "bookmark";
+        }
+        else if (remembered.threadId) {
+            // The bookmark knew the conversation but not the turn (an older receipt).
+            // Ask the server for that conversation's newest turn rather than nothing.
+            const newest = await newestTraceForThread(context, remembered.threadId, io);
+            if (!newest) {
+                return refuse(context, io, "no_traces_in_thread", "That conversation has no recorded turns inside the 30-day retention. Pass a trace id, or ask something new.");
+            }
+            traceId = newest;
+            resolvedFrom = "thread";
+        }
+    }
+    const result = await towerJsonRequest({
+        dashboardUrl: context.dashboardUrl,
+        path: `/api/ops/trace/${encodeURIComponent(traceId)}`,
+        deviceToken: context.deviceToken,
+        fetch: io.fetch,
+        method: "GET",
+        label: "jarvis:trace",
+        timeoutMs: 30_000,
+        log,
+    });
+    if (!result.ok) {
+        return refuse(context, io, result.reason, towerFailureDetail(result.reason, result.detail));
+    }
+    const body = result.body;
+    if (body.ok === false) {
+        return refuse(context, io, body.error ?? "trace_unavailable", body.message ?? "Tower had nothing to show for that turn.");
+    }
+    if (context.json) {
+        writeLine(io.stdout, JSON.stringify(body));
+    }
+    else {
+        writeTraceTree(io, traceId, body);
+    }
+    writeLine(io.stderr, `[jarvis cli] trace read ${JSON.stringify({
+        resolved_from: resolvedFrom,
+        spans: body.trace?.spanCount ?? null,
+        errors: body.trace?.errorCount ?? null,
+        running: body.trace?.runningCount ?? null,
+        duration_ms: body.trace?.durationMs ?? null,
+        truncated: body.truncated ?? null,
+    })}`);
+    return 0;
+}
+async function newestTraceForThread(context, threadId, io) {
+    const result = await towerJsonRequest({
+        dashboardUrl: context.dashboardUrl,
+        path: `/api/ops/trace?thread=${encodeURIComponent(threadId)}&limit=1`,
+        deviceToken: context.deviceToken,
+        fetch: io.fetch,
+        method: "GET",
+        label: "jarvis:trace-thread",
+        timeoutMs: 30_000,
+        log: (line) => writeLine(io.stderr, line),
+    });
+    if (!result.ok)
+        return null;
+    const body = result.body;
+    return body.traces?.[0]?.traceId ?? null;
+}
+function writeTraceTree(io, traceId, body) {
+    const styled = colorEnabled(io);
+    writeLine(io.stdout, `Turn ${traceId}`);
+    if (body.headline)
+        writeLine(io.stdout, dim(body.headline, styled));
+    writeLine(io.stdout, "");
+    for (const line of body.lines ?? [])
+        writeLine(io.stdout, line);
+    if ((body.lines ?? []).length === 0) {
+        // Never a blank screen: an empty tree is a fact and it gets a sentence.
+        writeLine(io.stdout, "That turn recorded no steps.");
+    }
+    if (body.truncated) {
+        writeLine(io.stdout, "");
+        writeLine(io.stdout, dim("Only the first 1000 spans of this turn are shown.", styled));
+    }
+}
+function refuse(context, io, reason, detail) {
+    if (context.json) {
+        writeLine(io.stdout, JSON.stringify({ ok: false, error: reason, detail }));
+    }
+    else {
+        writeLine(io.stderr, detail);
+    }
+    writeLine(io.stderr, `[jarvis cli] trace unavailable ${JSON.stringify({ reason })}`);
+    return 1;
+}