@bli-cockpit/cli 0.2.117 → 0.2.121

package/dist/commands/analyze.js

@@ -4,6 +4,13 @@ import { runSync } from "./sync.js";
 import { describeError, isMissingFileFailure } from "../health-detail.js";
 import { DEFAULT_DASHBOARD_URL, getCollectorRuntimePaths, readLocalCollectorSessionFile, } from "../local-state.js";
 export async function runAnalyze(command, io) {
+    const sync = await runAnalysisSync(command, io);
+    if (sync.exitCode !== 0 || !isUploadedSyncResult(sync.output)) {
+        return writeIncompleteSync(command, io, sync);
+    }
+    return queueAnalysis(command, io, sync);
+}
+async function runAnalysisSync(command, io) {
     const syncStdout = [];
     const syncStderr = [];
     const syncIo = {
@@ -17,39 +24,33 @@ export async function runAnalyze(command, io) {
         json: true,
     };
     const syncExitCode = await runSync(syncCommand, syncIo);
-    const syncOutput = parseCapturedJson(syncStdout);
-    if (syncExitCode !== 0 || !isUploadedSyncResult(syncOutput)) {
-        if (command.json) {
-            writeLine(io.stdout, JSON.stringify({
-                status: syncExitCode === 0 ? "sync_not_completed" : "sync_failed",
-                sync: syncOutput,
-                error: syncStderr.join("").trim()
-                    || (syncExitCode === 0
-                        ? "Tower sync did not upload fresh evidence."
-                        : "Tower sync failed."),
-            }, null, 2));
-        }
-        else {
-            replayCaptured(io.stderr, syncStderr);
-            writeLine(io.stderr, syncExitCode === 0
-                ? "Analysis was not queued because a fresh upload did not complete."
-                : "Analysis was not queued because the latest upload failed.");
-        }
-        return syncExitCode === 0 ? 1 : syncExitCode;
+    return { exitCode: syncExitCode, output: parseCapturedJson(syncStdout), stderr: syncStderr };
+}
+function writeIncompleteSync(command, io, sync) {
+    const error = syncFailureMessage(sync);
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({
+            status: sync.exitCode === 0 ? "sync_not_completed" : "sync_failed",
+            sync: sync.output,
+            error,
+        }, null, 2));
     }
-    const paths = getCollectorRuntimePaths(command.homeDir);
-    const session = await readLocalCollectorSessionFile(paths).catch((error) => {
-        // "Not signed in" is the right sentence for an absent session file and the
-        // wrong one for a corrupt one, which `cockpit login` will not repair
-        // (BLI-3238).
-        if (!isMissingFileFailure(error)) {
-            console.error("[cockpit-analyze] session file present but unreadable, reporting as not signed in", JSON.stringify({
-                reason: "session_file_unusable",
-                ...describeError(error),
-            }));
-        }
-        throw new Error("Tower is not signed in. Run `cockpit onboard` or `cockpit login` first.");
-    });
+    else {
+        replayCaptured(io.stderr, sync.stderr);
+        writeLine(io.stderr, sync.exitCode === 0
+            ? "Analysis was not queued because a fresh upload did not complete."
+            : "Analysis was not queued because the latest upload failed.");
+    }
+    return sync.exitCode === 0 ? 1 : sync.exitCode;
+}
+function syncFailureMessage(sync) {
+    return sync.stderr.join("").trim()
+        || (sync.exitCode === 0
+            ? "Tower sync did not upload fresh evidence."
+            : "Tower sync failed.");
+}
+async function queueAnalysis(command, io, sync) {
+    const session = await readAnalyzeSession(command.homeDir);
     const dashboardUrl = normalizeUrl(command.dashboardUrl ?? session.dashboard_url ?? DEFAULT_DASHBOARD_URL);
     const response = await io.fetch(`${dashboardUrl}/api/ambient/analyze`, {
         method: "POST",
@@ -60,40 +61,59 @@ export async function runAnalyze(command, io) {
         body: "{}",
     });
     const body = await readAnalyzeApiResponse(response);
-    if (!response.ok) {
-        const message = typeof body.message === "string"
-            ? body.message
-            : `Analysis request failed with HTTP ${response.status}.`;
-        if (command.json) {
-            writeLine(io.stdout, JSON.stringify({
-                status: "analyze_failed",
-                sync: syncOutput,
-                http_status: response.status,
-                code: typeof body.code === "string" ? body.code : null,
-                message,
-                retry_after_seconds: typeof body.retry_after_seconds === "number"
-                    ? body.retry_after_seconds
-                    : null,
-            }, null, 2));
-        }
-        else {
-            replayCaptured(io.stderr, syncStderr);
-            writeLine(io.stderr, `Analysis was not queued: ${message}`);
+    if (!response.ok)
+        return writeFailedAnalysis(command, io, sync, response, body);
+    return writeQueuedAnalysis(command, io, sync, dashboardUrl, body);
+}
+async function readAnalyzeSession(homeDir) {
+    const paths = getCollectorRuntimePaths(homeDir);
+    return readLocalCollectorSessionFile(paths).catch((error) => {
+        // "Not signed in" is the right sentence for an absent session file and the
+        // wrong one for a corrupt one, which `cockpit login` will not repair
+        // (BLI-3238).
+        if (!isMissingFileFailure(error)) {
+            console.error("[cockpit-analyze] session file present but unreadable, reporting as not signed in", JSON.stringify({
+                reason: "session_file_unusable",
+                ...describeError(error),
+            }));
         }
-        return 1;
+        throw new Error("Tower is not signed in. Run `cockpit onboard` or `cockpit login` first.");
+    });
+}
+function writeFailedAnalysis(command, io, sync, response, body) {
+    const message = typeof body.message === "string"
+        ? body.message
+        : `Analysis request failed with HTTP ${response.status}.`;
+    const retryAfterSeconds = typeof body.retry_after_seconds === "number" ? body.retry_after_seconds : null;
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({
+            status: "analyze_failed",
+            sync: sync.output,
+            http_status: response.status,
+            code: typeof body.code === "string" ? body.code : null,
+            message,
+            retry_after_seconds: retryAfterSeconds,
+        }, null, 2));
     }
+    else {
+        replayCaptured(io.stderr, sync.stderr);
+        writeLine(io.stderr, `Analysis was not queued: ${message}`);
+    }
+    return 1;
+}
+function writeQueuedAnalysis(command, io, sync, dashboardUrl, body) {
     const jobId = typeof body.job?.id === "string" ? body.job.id : null;
     const jobStatus = typeof body.job?.status === "string" ? body.job.status : "pending";
     if (command.json) {
         writeLine(io.stdout, JSON.stringify({
             status: "queued",
-            sync: syncOutput,
+            sync: sync.output,
             job: body.job ?? null,
             dashboard_url: `${dashboardUrl}/my-work`,
         }, null, 2));
         return 0;
     }
-    replayCaptured(io.stderr, syncStderr);
+    replayCaptured(io.stderr, sync.stderr);
     writeLine(io.stdout, "Tower uploaded your latest work.");
     writeLine(io.stdout, "Tower analysis queued.");
     if (jobId)

package/dist/commands/brief-rewrite.js

@@ -42,23 +42,64 @@ export async function runBriefRewrite(command, io, watchOptions = {}) {
     const log = (line) => writeLine(io.stderr, line);
     const styled = colorEnabled(io);
     const startedAt = Date.now();
+    const target = await readRewriteTarget(command, io, session.device_token, dashboardUrl, log);
+    if (!target.ok)
+        return target.exitCode;
+    const queued = await queueBriefRewrite(command, io, session.device_token, dashboardUrl, log, target.personId, target.displayName);
+    if (!queued.ok)
+        return queued.exitCode;
+    const { answer, request, whose } = queued;
+    const scheduled = answer.compileScheduled !== false;
+    writeQueueReceipt(io, request.requestId, answer, command.wait !== false);
+    if (!scheduled) {
+        return reportQueueOnly(command, io, request.requestId, target.personId, answer, whose);
+    }
+    if (command.wait === false) {
+        return reportQueuedRewrite(command, io, request.requestId, target.personId, whose, styled);
+    }
+    return watchQueuedRewrite({
+        command,
+        io,
+        session,
+        dashboardUrl,
+        log,
+        styled,
+        startedAt,
+        beforePageId: target.beforePageId,
+        personId: target.personId,
+        requestId: request.requestId,
+        whose,
+        watchOptions,
+    });
+}
+async function readRewriteTarget(command, io, deviceToken, dashboardUrl, log) {
     // Which page, and what it looks like NOW — the "before" the poll compares
     // against. Read first for a second reason: it is the only way this command
     // learns the person id, and it is the same read that decides whether this
     // caller may see that page at all.
-    const before = await readPage(command, io, session.device_token, dashboardUrl, log);
+    const before = await readPage(command, io, deviceToken, dashboardUrl, log);
     if (!before.ok)
-        return fail(command, io, before.reason, before.detail);
+        return { ok: false, exitCode: fail(command, io, before.reason, before.detail) };
     const personId = before.page.page?.personId;
     if (!personId) {
-        return fail(command, io, before.page.error ?? "no_page", before.page.reply ??
-            "There is no page here to write again yet. The first one is compiled by the daily job.");
+        return {
+            ok: false,
+            exitCode: fail(command, io, before.page.error ?? "no_page", before.page.reply ??
+                "There is no page here to write again yet. The first one is compiled by the daily job."),
+        };
     }
-    const beforePageId = before.page.page?.pageId ?? null;
+    return {
+        ok: true,
+        personId,
+        beforePageId: before.page.page?.pageId ?? null,
+        displayName: before.page.page?.displayName,
+    };
+}
+async function queueBriefRewrite(command, io, deviceToken, dashboardUrl, log, personId, displayName) {
     const queued = await towerJsonRequest({
         dashboardUrl,
         path: "/api/jarvis/recompile",
-        deviceToken: session.device_token,
+        deviceToken,
         fetch: io.fetch,
         label: "brief:rewrite",
         timeoutMs: REQUEST_DEADLINE_MS,
@@ -66,91 +107,108 @@ export async function runBriefRewrite(command, io, watchOptions = {}) {
         body: { personIds: [personId], mode: "queue" },
     });
     if (!queued.ok)
-        return fail(command, io, queued.reason, queued.detail);
+        return { ok: false, exitCode: fail(command, io, queued.reason, queued.detail) };
     const answer = queued.body;
     const request = (answer.queued ?? [])[0];
     if (!answer.ok || !request?.requestId) {
-        return fail(command, io, "not_queued", answer.reply ?? "Tower did not accept that ask.");
+        return {
+            ok: false,
+            exitCode: fail(command, io, "not_queued", answer.reply ?? "Tower did not accept that ask."),
+        };
     }
-    const whose = request.name ?? before.page.page?.displayName ?? "that page";
-    const scheduled = answer.compileScheduled !== false;
+    return {
+        ok: true,
+        answer,
+        request: { requestId: request.requestId, name: request.name },
+        whose: request.name ?? displayName ?? "that page",
+    };
+}
+function writeQueueReceipt(io, requestId, answer, waiting) {
     writeLine(io.stderr, `[brief rewrite] queued ${JSON.stringify({
-        request_id: request.requestId,
-        compile_scheduled: scheduled,
+        request_id: requestId,
+        compile_scheduled: answer.compileScheduled !== false,
         compile_reason: answer.compileReason ?? null,
-        waiting: command.wait !== false,
+        waiting,
     })}`);
-    if (!scheduled) {
-        // Queue-only, said as queue-only. The ask is a real row; what is missing is
-        // somebody to run it in the next minute, and pretending otherwise would
-        // leave a person watching a page that was never going to change.
-        const sentence = `${whose} is on the list to be written again, but this Tower could not start the work now ` +
-            `(${answer.compileReason ?? "no reason given"}). The daily compile will reach it. Nothing is lost.`;
-        if (command.json) {
-            writeLine(io.stdout, JSON.stringify({
-                ok: true,
-                outcome: "queued_only",
-                requestId: request.requestId,
-                personId,
-                compileScheduled: false,
-                compileReason: answer.compileReason ?? null,
-            }));
-        }
-        else {
-            writeLine(io.stdout, sentence);
-        }
-        return 0;
+}
+function reportQueueOnly(command, io, requestId, personId, answer, whose) {
+    // Queue-only, said as queue-only. The ask is a real row; what is missing is
+    // somebody to run it in the next minute, and pretending otherwise would
+    // leave a person watching a page that was never going to change.
+    const sentence = `${whose} is on the list to be written again, but this Tower could not start the work now ` +
+        `(${answer.compileReason ?? "no reason given"}). The daily compile will reach it. Nothing is lost.`;
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({
+            ok: true,
+            outcome: "queued_only",
+            requestId,
+            personId,
+            compileScheduled: false,
+            compileReason: answer.compileReason ?? null,
+        }));
     }
-    if (command.wait === false) {
-        if (command.json) {
-            writeLine(io.stdout, JSON.stringify({
-                ok: true,
-                outcome: "queued",
-                requestId: request.requestId,
-                personId,
-                compileScheduled: true,
-            }));
-        }
-        else {
-            writeLine(io.stdout, `Asked. ${whose} is being written again.`);
-            writeLine(io.stdout, dim("Run `cockpit brief` in a few minutes to read it.", styled));
-        }
-        return 0;
+    else {
+        writeLine(io.stdout, sentence);
+    }
+    return 0;
+}
+function reportQueuedRewrite(command, io, requestId, personId, whose, styled) {
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({
+            ok: true,
+            outcome: "queued",
+            requestId,
+            personId,
+            compileScheduled: true,
+        }));
+    }
+    else {
+        writeLine(io.stdout, `Asked. ${whose} is being written again.`);
+        writeLine(io.stdout, dim("Run `cockpit brief` in a few minutes to read it.", styled));
     }
-    writeLine(io.stderr, dim(`Writing ${whose} again. This takes a few minutes; watching for the new version…`, styled));
+    return 0;
+}
+async function watchQueuedRewrite(input) {
+    writeLine(input.io.stderr, dim(`Writing ${input.whose} again. This takes a few minutes; watching for the new version…`, input.styled));
     const watched = await watchForNewVersion({
-        command,
-        io,
-        deviceToken: session.device_token,
-        dashboardUrl,
-        beforePageId,
-        log,
-        pollEveryMs: watchOptions.pollEveryMs ?? POLL_EVERY_MS,
-        ceilingMs: watchOptions.ceilingMs ?? WATCH_CEILING_MS,
+        command: input.command,
+        io: input.io,
+        deviceToken: input.session.device_token,
+        dashboardUrl: input.dashboardUrl,
+        beforePageId: input.beforePageId,
+        log: input.log,
+        pollEveryMs: input.watchOptions.pollEveryMs ?? POLL_EVERY_MS,
+        ceilingMs: input.watchOptions.ceilingMs ?? WATCH_CEILING_MS,
     });
     if (watched.outcome === "written") {
-        if (command.json) {
-            writeLine(io.stdout, JSON.stringify({
-                ok: true,
-                outcome: "written",
-                requestId: request.requestId,
-                personId,
-                pageId: watched.pageId,
-                waitedMs: watched.waitedMs,
-            }));
-        }
-        else {
-            writeLine(io.stdout, `${whose} has been written again.`);
-            writeLine(io.stdout, dim("Run `cockpit brief` to read it.", styled));
-        }
-        writeLine(io.stderr, `[brief rewrite] written ${JSON.stringify({
-            request_id: request.requestId,
-            polls: watched.polls,
-            waited_ms: watched.waitedMs,
-            elapsed_ms: Date.now() - startedAt,
-        })}`);
-        return 0;
+        return reportWrittenRewrite(input, watched);
     }
+    return reportUnconfirmedRewrite(input.command, input.io, input.requestId, input.personId, input.whose, watched);
+}
+function reportWrittenRewrite(input, watched) {
+    if (input.command.json) {
+        writeLine(input.io.stdout, JSON.stringify({
+            ok: true,
+            outcome: "written",
+            requestId: input.requestId,
+            personId: input.personId,
+            pageId: watched.pageId,
+            waitedMs: watched.waitedMs,
+        }));
+    }
+    else {
+        writeLine(input.io.stdout, `${input.whose} has been written again.`);
+        writeLine(input.io.stdout, dim("Run `cockpit brief` to read it.", input.styled));
+    }
+    writeLine(input.io.stderr, `[brief rewrite] written ${JSON.stringify({
+        request_id: input.requestId,
+        polls: watched.polls,
+        waited_ms: watched.waitedMs,
+        elapsed_ms: Date.now() - input.startedAt,
+    })}`);
+    return 0;
+}
+function reportUnconfirmedRewrite(command, io, requestId, personId, whose, watched) {
     // Not a failure, and named so it cannot be read as one. Nothing observed here
     // says the compile stopped — only that this command stopped watching.
     const sentence = watched.outcome === "watch_failed"
@@ -163,7 +221,7 @@ export async function runBriefRewrite(command, io, watchOptions = {}) {
         writeLine(io.stdout, JSON.stringify({
             ok: false,
             outcome: watched.outcome,
-            requestId: request.requestId,
+            requestId,
             personId,
             waitedMs: watched.waitedMs,
             ...(watched.outcome === "watch_failed" ? { detail: watched.detail } : {}),
@@ -173,7 +231,7 @@ export async function runBriefRewrite(command, io, watchOptions = {}) {
         writeLine(io.stderr, sentence);
     }
     writeLine(io.stderr, `[brief rewrite] not confirmed ${JSON.stringify({
-        request_id: request.requestId,
+        request_id: requestId,
         reason: watched.outcome,
         polls: watched.polls,
         waited_ms: watched.waitedMs,
@@ -194,30 +252,35 @@ async function watchForNewVersion(input) {
     while (Date.now() - startedAt < input.ceilingMs) {
         await sleep(input.pollEveryMs);
         polls += 1;
-        const read = await readPage(input.command, input.io, input.deviceToken, input.dashboardUrl, input.log);
-        const waitedMs = Date.now() - startedAt;
-        if (!read.ok) {
-            // A single blip while waiting is not an answer about the compile. Only a
-            // refusal is, and that one stops the watch rather than spinning.
-            if (read.httpStatus === 403 || read.httpStatus === 401) {
-                return { outcome: "watch_failed", detail: read.detail, polls, waitedMs };
-            }
-            input.log(`[brief rewrite] poll failed ${JSON.stringify({ poll: polls, reason: read.reason })}`);
-            continue;
-        }
-        const pageId = read.page.page?.pageId ?? null;
-        input.log(`[brief rewrite] polled ${JSON.stringify({
-            poll: polls,
-            changed: pageId != null && pageId !== input.beforePageId,
-            compiled_at: read.page.page?.compiledAt ?? null,
-            waited_ms: waitedMs,
-        })}`);
-        if (pageId && pageId !== input.beforePageId) {
-            return { outcome: "written", pageId, polls, waitedMs };
-        }
+        const result = await readNextPageVersion(input, polls, startedAt);
+        if (result)
+            return result;
     }
     return { outcome: "still_running", polls, waitedMs: Date.now() - startedAt };
 }
+async function readNextPageVersion(input, polls, startedAt) {
+    const read = await readPage(input.command, input.io, input.deviceToken, input.dashboardUrl, input.log);
+    const waitedMs = Date.now() - startedAt;
+    if (!read.ok) {
+        // A single blip while waiting is not an answer about the compile. Only a
+        // refusal is, and that one stops the watch rather than spinning.
+        if (read.httpStatus === 403 || read.httpStatus === 401) {
+            return { outcome: "watch_failed", detail: read.detail, polls, waitedMs };
+        }
+        input.log(`[brief rewrite] poll failed ${JSON.stringify({ poll: polls, reason: read.reason })}`);
+        return null;
+    }
+    const pageId = read.page.page?.pageId ?? null;
+    input.log(`[brief rewrite] polled ${JSON.stringify({
+        poll: polls,
+        changed: pageId != null && pageId !== input.beforePageId,
+        compiled_at: read.page.page?.compiledAt ?? null,
+        waited_ms: waitedMs,
+    })}`);
+    return pageId && pageId !== input.beforePageId
+        ? { outcome: "written", pageId, polls, waitedMs }
+        : null;
+}
 async function readPage(command, io, deviceToken, dashboardUrl, log) {
     const params = new URLSearchParams({ tldr: "1" });
     if (command.subject)

package/dist/commands/brief.js

@@ -23,10 +23,18 @@ export async function runBrief(command, io) {
     if (command.action === "status") {
         return runBriefStatus(command, io, dashboardUrl, session.device_token, startedAt);
     }
+    const body = await requestBrief(command, io, dashboardUrl, session.device_token);
+    if (!body)
+        return 1;
+    writeBriefReply(command, io, body);
+    logBriefRead(command, io, body, startedAt);
+    return 0;
+}
+async function requestBrief(command, io, dashboardUrl, deviceToken) {
     const result = await towerJsonRequest({
         dashboardUrl,
         path: `/api/jarvis/brief${queryFor(command)}`,
-        deviceToken: session.device_token,
+        deviceToken,
         fetch: io.fetch,
         method: "GET",
         label: "brief",
@@ -39,20 +47,25 @@ export async function runBrief(command, io) {
         // 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;
+        return undefined;
     }
     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;
+        return undefined;
     }
+    return body;
+}
+function writeBriefReply(command, io, body) {
     if (command.json) {
         writeLine(io.stdout, JSON.stringify(body));
     }
     else {
         writeHuman(io, command, body);
     }
+}
+function logBriefRead(command, io, body, startedAt) {
     writeLine(io.stderr, `[brief cli] read ${JSON.stringify({
         text_length: body.text.length,
         cadence: body.page?.cadence ?? null,
@@ -70,7 +83,6 @@ export async function runBrief(command, io) {
         claim_count: body.claims?.length ?? null,
         elapsed_ms: Date.now() - startedAt,
     })}`);
-    return 0;
 }
 /**
  * `cockpit brief status` (BLI-3462) — why a brief was or was not delivered.
@@ -157,15 +169,7 @@ function writeHuman(io, command, body) {
     // Decided once per page: colour only for a real terminal that has not said
     // NO_COLOR, so `cockpit brief > page.txt` is text and nothing else (BLI-3482).
     const styled = colorEnabled(io);
-    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}` : "";
-    // BLI-3484: which day, in the SUBJECT's zone, said with the zone beside it so
-    // nobody has to work out whose midnight this is.
-    const day = body.day?.date ? ` · ${body.day.date}${body.day.zone ? ` ${body.day.zone}` : ""}` : "";
-    writeLine(io.stdout, dim(`${whose}${pinned}${day}`, styled));
+    writeBriefHeading(io, body, styled);
     // `history` lists days and prints no page — a list of dates under a full
     // brief would bury the thing somebody asked for.
     if (command.action === "history") {
@@ -176,6 +180,22 @@ function writeHuman(io, command, body) {
     writeLine(io.stdout, body.text ?? "");
     if (command.delta)
         writeDelta(io, body, styled);
+    writeBriefClaims(io, body, styled);
+    writeBriefVersions(io, body, styled);
+    writeOtherBriefPages(io, command, body, styled);
+}
+function writeBriefHeading(io, body, styled) {
+    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}` : "";
+    // BLI-3484: which day, in the SUBJECT's zone, said with the zone beside it so
+    // nobody has to work out whose midnight this is.
+    const day = body.day?.date ? ` · ${body.day.date}${body.day.zone ? ` ${body.day.zone}` : ""}` : "";
+    writeLine(io.stdout, dim(`${whose}${pinned}${day}`, styled));
+}
+function writeBriefClaims(io, body, styled) {
     if (body.claims && body.claims.length > 0) {
         writeLine(io.stdout, "");
         writeLine(io.stdout, dim("Claim ids — pass one to `cockpit correct --claim`:", styled));
@@ -183,6 +203,8 @@ function writeHuman(io, command, body) {
             writeLine(io.stdout, `${dim(`  [${claim.claimId}]`, styled)} ${claim.text ?? ""}`);
         }
     }
+}
+function writeBriefVersions(io, body, styled) {
     if (body.versions) {
         writeLine(io.stdout, "");
         if (body.versions.length === 0) {
@@ -198,7 +220,10 @@ function writeHuman(io, command, body) {
             }
         }
     }
+}
+function writeOtherBriefPages(io, command, body, styled) {
     if (!command.subject && body.people && body.people.length > 1) {
+        const page = body.page ?? {};
         const others = body.people
             .filter((person) => person.personId !== page.personId)
             .map((person) => person.slug)