@bli-cockpit/cli 0.2.40 → 0.2.42

package/dist/commands/brief-rewrite.js

@@ -0,0 +1,260 @@
+/**
+ * `cockpit brief rewrite` — ask for the page to be written again (BLI-3458, S2.8).
+ *
+ * The website has a button; this is that button. What is different here is not
+ * the permission — an admin may ask about anybody, everyone else about their own
+ * page, decided by the row policy on `jarvis_recompile_requests` and nowhere
+ * else — it is the WAITING.
+ *
+ * **Why this polls instead of holding the connection.** Writing a page is a
+ * multi-minute job: `/api/jarvis/recompile` is budgeted to 800 seconds and a
+ * real run has taken seven attempts. A terminal's own fetch wall is 300. So a
+ * synchronous ask would abort ON THIS SIDE with the compile still running, and
+ * "it timed out" would be indistinguishable from "it failed" — the exact
+ * confusion this repo keeps paying for. Instead `mode: "queue"` answers 202 the
+ * moment the ask exists, and this command watches the person's own page until a
+ * new version shows up.
+ *
+ * Three outcomes, and they are kept apart on purpose:
+ *
+ *   - **written** — a new page id appeared. Exit 0.
+ *   - **still running** — the wait ran out. The compile is very likely still
+ *     going; this is NOT a failure and says so, with the one command that will
+ *     show the answer later. Exit non-zero, because what was asked for has not
+ *     happened yet.
+ *   - **queue only** — the deployment could not schedule the compile at all
+ *     (`compileScheduled: false`). The ask is on the record and the daily job
+ *     will reach it; nothing is pretended.
+ */
+import { colorEnabled, dim, writeLine } from "./cli-io.js";
+import { loadPairedSession, towerJsonRequest } from "../tower-client.js";
+const REQUEST_DEADLINE_MS = 60_000;
+/**
+ * How long to watch. The server's own compile budget is 800s; this allows for
+ * that plus the queue's own latency, and then says plainly that it stopped
+ * watching rather than that anything failed.
+ */
+const WATCH_CEILING_MS = 900_000;
+const POLL_EVERY_MS = 10_000;
+export async function runBriefRewrite(command, io, watchOptions = {}) {
+    const session = await loadPairedSession("brief rewrite", command.homeDir);
+    const dashboardUrl = command.dashboardUrl ?? session.dashboard_url;
+    const log = (line) => writeLine(io.stderr, line);
+    const styled = colorEnabled(io);
+    const startedAt = Date.now();
+    // 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);
+    if (!before.ok)
+        return 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.");
+    }
+    const beforePageId = before.page.page?.pageId ?? null;
+    const queued = await towerJsonRequest({
+        dashboardUrl,
+        path: "/api/jarvis/recompile",
+        deviceToken: session.device_token,
+        fetch: io.fetch,
+        label: "brief:rewrite",
+        timeoutMs: REQUEST_DEADLINE_MS,
+        log,
+        body: { personIds: [personId], mode: "queue" },
+    });
+    if (!queued.ok)
+        return 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.");
+    }
+    const whose = request.name ?? before.page.page?.displayName ?? "that page";
+    const scheduled = answer.compileScheduled !== false;
+    writeLine(io.stderr, `[brief rewrite] queued ${JSON.stringify({
+        request_id: request.requestId,
+        compile_scheduled: scheduled,
+        compile_reason: answer.compileReason ?? null,
+        waiting: command.wait !== false,
+    })}`);
+    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;
+    }
+    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;
+    }
+    writeLine(io.stderr, dim(`Writing ${whose} again. This takes a few minutes; watching for the new version…`, 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,
+    });
+    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;
+    }
+    // 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"
+        ? `I stopped being able to read the page while waiting (${watched.detail}). The rewrite may ` +
+            "still finish; run `cockpit brief` in a few minutes."
+        : `Still running after ${Math.round(watched.waitedMs / 1000)}s. Tower has not finished writing ` +
+            `${whose} yet — that is normal for a long page, and the work is still going. Run ` +
+            "`cockpit brief` in a few minutes.";
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({
+            ok: false,
+            outcome: watched.outcome,
+            requestId: request.requestId,
+            personId,
+            waitedMs: watched.waitedMs,
+            ...(watched.outcome === "watch_failed" ? { detail: watched.detail } : {}),
+        }));
+    }
+    else {
+        writeLine(io.stderr, sentence);
+    }
+    writeLine(io.stderr, `[brief rewrite] not confirmed ${JSON.stringify({
+        request_id: request.requestId,
+        reason: watched.outcome,
+        polls: watched.polls,
+        waited_ms: watched.waitedMs,
+    })}`);
+    return 1;
+}
+/**
+ * Watch the person's own page until its id changes.
+ *
+ * The page id, not `compiledAt`: a new version is a new row, and an id that
+ * differs is the one signal that cannot be produced by a clock skew or by a
+ * re-read of the same row. `compiledAt` is logged alongside because it is what a
+ * human reads, but the decision is the id.
+ */
+async function watchForNewVersion(input) {
+    const startedAt = Date.now();
+    let polls = 0;
+    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 };
+        }
+    }
+    return { outcome: "still_running", polls, waitedMs: Date.now() - startedAt };
+}
+async function readPage(command, io, deviceToken, dashboardUrl, log) {
+    const params = new URLSearchParams({ tldr: "1" });
+    if (command.subject)
+        params.set("p", command.subject);
+    const result = await towerJsonRequest({
+        dashboardUrl,
+        path: `/api/jarvis/brief?${params.toString()}`,
+        deviceToken,
+        fetch: io.fetch,
+        method: "GET",
+        label: "brief:rewrite:read",
+        timeoutMs: REQUEST_DEADLINE_MS,
+        log,
+    });
+    if (!result.ok) {
+        return {
+            ok: false,
+            reason: result.reason,
+            detail: result.detail,
+            ...(result.httpStatus === undefined ? {} : { httpStatus: result.httpStatus }),
+        };
+    }
+    return { ok: true, page: result.body };
+}
+/** Injected nowhere: a real pause. Tests drive the clock through `io.fetch`. */
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function fail(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 rewrite] not asked ${JSON.stringify({ reason })}`);
+    return 1;
+}

package/dist/commands/brief.js

@@ -12,10 +12,8 @@
  * 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 { colorEnabled, dim, 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);
@@ -81,19 +79,22 @@ function queryFor(command) {
     return query ? `?${query}` : "";
 }
 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}` : "";
-    writeLine(io.stdout, `${DIM}${whose}${pinned}${RESET}`);
+    writeLine(io.stdout, dim(`${whose}${pinned}`, styled));
     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}`);
+        writeLine(io.stdout, dim("Claim ids — pass one to `cockpit correct --claim`:", styled));
         for (const claim of body.claims) {
-            writeLine(io.stdout, `${DIM}  [${claim.claimId}]${RESET} ${claim.text ?? ""}`);
+            writeLine(io.stdout, `${dim(`  [${claim.claimId}]`, styled)} ${claim.text ?? ""}`);
         }
     }
     if (body.versions) {
@@ -101,13 +102,13 @@ function writeHuman(io, command, body) {
         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}`);
+            writeLine(io.stdout, dim(`Earlier versions could not be listed (${body.versionsReason ?? "no reason given"}).`, styled));
         }
         else {
-            writeLine(io.stdout, `${DIM}Versions — pass one to \`cockpit brief --version\`:${RESET}`);
+            writeLine(io.stdout, dim("Versions — pass one to `cockpit brief --version`:", styled));
             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}`);
+                writeLine(io.stdout, dim(`  ${version.version}/${version.of}  ${version.pageId}  ${version.asOf}${headline}`, styled));
             }
         }
     }
@@ -118,7 +119,7 @@ function writeHuman(io, command, body) {
             .filter(Boolean);
         if (others.length > 0) {
             writeLine(io.stdout, "");
-            writeLine(io.stdout, `${DIM}You can also open: ${others.join(", ")} (\`--for <name>\`)${RESET}`);
+            writeLine(io.stdout, dim(`You can also open: ${others.join(", ")} (\`--for <name>\`)`, styled));
         }
     }
 }

package/dist/commands/cli-io.js

@@ -13,6 +13,35 @@ export function writeRaw(stream, text) {
 export function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+// ------------------------------------------------------------------- styling
+const SGR_DIM = "\x1b[2m";
+const SGR_RESET = "\x1b[0m";
+/**
+ * Whether this run may put colour escapes on stdout (BLI-3482). Five commands
+ * had their own copy of the same two escape constants and none of them asked
+ * this question, so `cockpit brief > page.txt` wrote `ESC[2m` into the file and
+ * `cockpit scout | grep` matched against bytes nobody typed.
+ *
+ * Two conditions, both from `io` rather than the process so a test can state
+ * them: stdout is a real terminal, and NO_COLOR is absent or empty
+ * (no-color.org — any non-empty value, whatever it says, means no colour).
+ * `defaultIo()` passes `process.env`, so in production this IS `process.env`.
+ */
+export function colorEnabled(io) {
+    if ((io.env["NO_COLOR"] ?? "") !== "")
+        return false;
+    return Boolean(io.stdout.isTTY);
+}
+/**
+ * The one dim-text helper. `enabled` is an explicit argument, never read from
+ * the process here, so the pure render modules stay deterministic and a caller
+ * cannot forget the gate without the compiler saying so.
+ */
+export function dim(text, enabled) {
+    if (!enabled || text === "")
+        return text;
+    return `${SGR_DIM}${text}${SGR_RESET}`;
+}
 export function writeExecOutput(io, result, options) {
     if (options.stdout)
         writeRaw(io.stdout, result.stdout);

package/dist/commands/correct.js

@@ -23,10 +23,8 @@
  * 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, readPipedText, writeLine } from "./cli-io.js";
+import { colorEnabled, dim, isInteractiveStdin, readPipedText, 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) {
@@ -101,11 +99,12 @@ export async function runCorrect(command, io) {
         writeLine(io.stdout, JSON.stringify({ ok: true, ...filed }));
     }
     else {
+        const styled = colorEnabled(io);
         writeLine(io.stdout, filed.reply ?? "Filed.");
         if (filed.finding)
-            writeLine(io.stdout, `${DIM}The record says: ${filed.finding}${RESET}`);
+            writeLine(io.stdout, dim(`The record says: ${filed.finding}`, styled));
         if (filed.link)
-            writeLine(io.stdout, `${DIM}${filed.link}${RESET}`);
+            writeLine(io.stdout, dim(filed.link, styled));
     }
     writeLine(io.stderr, `[correct cli] filed ${JSON.stringify({
         tier: filed.tier ?? null,

package/dist/commands/editor.js

@@ -0,0 +1,204 @@
+/**
+ * Opening the person's own editor on a temp file (BLI-3458, slice S2.7).
+ *
+ * This is the ONE place in the collector that starts a child process for a
+ * PERSON rather than for a tool we chose, so the rules are written here and
+ * nowhere else:
+ *
+ * 1. **`spawnSync` with an ARRAY of arguments, never a shell string.** A
+ *    person's `$EDITOR` is theirs — `code -w`, `"C:\\Program Files\\…\\Code.exe"
+ *    -w`, `emacsclient -nw`. Building `${editor} ${path}` and handing it to a
+ *    shell would make a path with a space into two arguments and a path with a
+ *    semicolon into two commands. `shell: false` is the default and stays the
+ *    default; nothing here interpolates.
+ * 2. **`EDITOR` / `VISUAL` are taken VERBATIM as the program**, after one
+ *    tokenisation that understands quotes — because that is how every other
+ *    tool on the machine reads them, and a person who wrote `code -w` means the
+ *    flag. The tokeniser splits on unquoted whitespace and nothing else: it
+ *    performs no expansion, no globbing, and no substitution, so a token can
+ *    never turn into a command.
+ * 3. **On Windows the program is spawned as given.** Node resolves `notepad`,
+ *    `notepad.exe` and an absolute `.exe` path itself; a `.cmd`/`.bat` shim
+ *    needs `shell: true`, which is exactly what rule 1 forbids, so it is
+ *    REFUSED by name with the fix (point EDITOR at the `.exe`) rather than run
+ *    through cmd.exe with a person's own path interpolated into a command line.
+ *    That refusal is deliberate and is the only thing this module will not do.
+ *
+ * The file itself carries page text, which is not a secret — but it is somebody
+ * else's writing, so it lives in the OS temp directory with a random name and is
+ * deleted in a `finally`, whatever happened.
+ */
+import { spawnSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { stripLeadingBom } from "./cli-io.js";
+/**
+ * The editor a person has actually chosen, or the platform's last resort.
+ *
+ * `VISUAL` wins over `EDITOR` — that is the POSIX order and every other tool on
+ * the machine follows it. Windows falls back to `notepad`, which is present on
+ * every install and needs no shell; macOS and Linux do NOT fall back, because
+ * guessing `vi` at somebody who has never used it strands them in a modal editor
+ * with no way out that they know. They get a named reason and a one-line fix.
+ */
+export function resolveEditorCommand(env, platform = process.platform) {
+    const configured = (env["VISUAL"] ?? env["EDITOR"] ?? "").trim();
+    if (configured) {
+        const tokens = tokenizeCommand(configured);
+        const program = tokens[0];
+        if (program)
+            return { program, args: tokens.slice(1) };
+    }
+    if (platform === "win32")
+        return { program: "notepad", args: [] };
+    return null;
+}
+/**
+ * Splits a configured editor into program and arguments.
+ *
+ * Quotes are honoured because a Windows editor path routinely contains a space
+ * (`"C:\Program Files\Microsoft VS Code\Code.exe" -w`). NOTHING else is
+ * interpreted: no `$VAR`, no `~`, no globbing, no `&&`. A token comes out of
+ * this function exactly as it went in, minus the quotes that grouped it, and
+ * goes into `spawnSync`'s array — so there is no stage at which a shell could
+ * see any of it.
+ */
+export function tokenizeCommand(command) {
+    const tokens = [];
+    let current = "";
+    let quote = null;
+    let started = false;
+    for (const char of command) {
+        if (quote) {
+            if (char === quote)
+                quote = null;
+            else
+                current += char;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            started = true;
+            continue;
+        }
+        if (/\s/u.test(char)) {
+            if (started)
+                tokens.push(current);
+            current = "";
+            started = false;
+            continue;
+        }
+        current += char;
+        started = true;
+    }
+    if (started)
+        tokens.push(current);
+    return tokens;
+}
+/**
+ * Writes `contents` to a temp file, opens the editor on it, and hands back what
+ * was there when the editor closed. Never throws.
+ */
+export async function editInEditor(options) {
+    const platform = options.platform ?? process.platform;
+    const log = options.log ?? ((line) => console.error(line));
+    const chosen = resolveEditorCommand(options.env, platform);
+    if (!chosen) {
+        return {
+            ok: false,
+            reason: "no_editor_configured",
+            detail: "No editor is configured. Set EDITOR (or VISUAL) — for example `export EDITOR=nano` — " +
+                "or pipe the edited page in on stdin instead.",
+        };
+    }
+    // A `.cmd` or `.bat` is a batch script; Node cannot execute one without
+    // handing the whole line to cmd.exe, and that is the one thing this module
+    // will not do with a person's own path in it.
+    if (platform === "win32" && /\.(cmd|bat)$/i.test(chosen.program)) {
+        return {
+            ok: false,
+            reason: "editor_needs_a_shell",
+            detail: `EDITOR points at a .cmd/.bat wrapper (${basenameOf(chosen.program)}), which cannot be ` +
+                "started without a shell. Point EDITOR at the editor's .exe instead — for example " +
+                "notepad, or the full path to Code.exe.",
+        };
+    }
+    let directory;
+    let file;
+    try {
+        directory = await mkdtemp(join(tmpdir(), "cockpit-brief-"));
+        file = join(directory, `brief-${randomBytes(4).toString("hex")}${options.suffix ?? ".md"}`);
+        await writeFile(file, options.contents, "utf8");
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reason: "scratch_file_failed",
+            detail: `The page could not be written to a scratch file (${messageOf(error)}).`,
+        };
+    }
+    try {
+        const spawn = options.spawn ?? spawnSync;
+        log(`[brief edit] editor opening ${JSON.stringify({
+            program: basenameOf(chosen.program),
+            extra_args: chosen.args.length,
+            bytes: Buffer.byteLength(options.contents, "utf8"),
+        })}`);
+        // `stdio: "inherit"` hands the terminal over: a full-screen editor needs the
+        // real tty. `shell: false` is the default and is stated to make the rule
+        // above impossible to lose in a refactor.
+        const result = spawn(chosen.program, [...chosen.args, file], {
+            stdio: "inherit",
+            shell: false,
+            env: options.env,
+        });
+        if (result.error) {
+            return {
+                ok: false,
+                reason: "editor_not_started",
+                detail: `Your editor (${basenameOf(chosen.program)}) could not be started ` +
+                    `(${messageOf(result.error)}). Check EDITOR, or pipe the edited page in on stdin.`,
+            };
+        }
+        if (typeof result.status === "number" && result.status !== 0) {
+            return {
+                ok: false,
+                reason: "editor_exited_nonzero",
+                detail: `Your editor exited with status ${result.status}, so nothing was changed. ` +
+                    "Nothing has been sent to Tower.",
+            };
+        }
+        const text = stripLeadingBom(await readFile(file, "utf8"));
+        log(`[brief edit] editor closed ${JSON.stringify({
+            program: basenameOf(chosen.program),
+            status: result.status ?? null,
+            bytes: Buffer.byteLength(text, "utf8"),
+        })}`);
+        return { ok: true, text, program: basenameOf(chosen.program) };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reason: "scratch_file_failed",
+            detail: `The edited page could not be read back (${messageOf(error)}).`,
+        };
+    }
+    finally {
+        // Whatever happened. The page is not a secret, but it is somebody's writing
+        // and it does not belong in /tmp after the command returns.
+        await rm(directory, { recursive: true, force: true }).catch(() => {
+            // Deliberately silent: the temp directory is the OS's to reap, and a
+            // failure to remove it must not turn a saved edit into a failed command.
+        });
+    }
+}
+/** The program's own name, never the directories around it. */
+function basenameOf(program) {
+    const parts = program.split(/[\\/]/u);
+    return parts[parts.length - 1] || program;
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message.split("\n")[0] ?? error.name : String(error);
+}

package/dist/commands/jarvis.js

@@ -5,12 +5,10 @@
  * existing paired device session, and every turn is executed by the dashboard
  * through the same JARVIS runtime used by web chat and Slack.
  */
-import { isInteractiveStdin, readLine, readPipedText, writeLine } from "./cli-io.js";
+import { colorEnabled, dim, isInteractiveStdin, readLine, readPipedText, writeLine, } from "./cli-io.js";
 import { attachedFileRefusalSentence, readAttachedImage, } from "./jarvis-attachment.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";
 /**
  * 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
@@ -108,14 +106,15 @@ function writeThreadList(io, threads) {
         writeLine(io.stdout, "No terminal conversations yet. Ask something with `cockpit jarvis`.");
         return;
     }
+    const styled = colorEnabled(io);
     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}`);
+        writeLine(io.stdout, `${thread.name}  ${dim(`${turns} · ${thread.lastAt ?? "unknown"}`, styled)}`);
         if (thread.preview)
-            writeLine(io.stdout, `${TRACE_DIM}  ${thread.preview}${TRACE_RESET}`);
+            writeLine(io.stdout, dim(`  ${thread.preview}`, styled));
     }
     writeLine(io.stdout, "");
-    writeLine(io.stdout, `${TRACE_DIM}Replay one with \`cockpit jarvis --thread <name> --history\`.${TRACE_RESET}`);
+    writeLine(io.stdout, dim("Replay one with `cockpit jarvis --thread <name> --history`.", styled));
 }
 function writeThreadHistory(io, body) {
     const messages = body.messages ?? [];
@@ -124,7 +123,7 @@ function writeThreadHistory(io, body) {
         return;
     }
     if (body.truncated) {
-        writeLine(io.stdout, `${TRACE_DIM}Showing the most recent ${messages.length}; there is more before this (\`--limit\`).${TRACE_RESET}`);
+        writeLine(io.stdout, dim(`Showing the most recent ${messages.length}; there is more before this (\`--limit\`).`, colorEnabled(io)));
     }
     for (const message of messages) {
         const speaker = message.role === "you" ? "you" : "jarvis";
@@ -294,7 +293,7 @@ function writeTraceBlock(io, trace) {
 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, `${TRACE_DIM}  ⏺ ${step.label}${elapsed}${failure}${TRACE_RESET}`);
+    writeLine(io.stdout, dim(`  ⏺ ${step.label}${elapsed}${failure}`, colorEnabled(io)));
 }
 /**
  * Draws one streamed tool call, and says whether it drew anything.