@bli-cockpit/cli 0.2.37 → 0.2.39

package/dist/commands/team.js

@@ -0,0 +1,111 @@
+/**
+ * `cockpit team` — who is on the team, and the two things an admin does to it
+ * (BLI-3461, decision D3: invite and role change ship in the PUBLIC build).
+ *
+ * Same shape as the rest of the CLI-parity surface: this file owns terminal
+ * input and output, the dashboard owns every decision. The roster union, the
+ * super_admin gate, the self-role-change refusal and the audit line all live
+ * server-side, so a stale CLI can be wrong about wording and never about
+ * permission.
+ *
+ * `team invite` and `team role` change what a person can do, so both are
+ * deliberate: the role change asks before it acts unless `--yes` is passed, and
+ * a headless run without `--yes` is refused by name rather than assumed.
+ */
+import { writeLine } from "./cli-io.js";
+import { renderTeamMembers } from "./settings-render.js";
+import { confirmDestructive } from "./settings.js";
+import { asRecord, callTower, openTower, writeCommandFailure, } from "./tower-command.js";
+export async function runTeam(command, io) {
+    const tower = await openTower("team", command, io);
+    if (command.action === "members")
+        return showMembers(command, tower, io);
+    if (command.action === "invite")
+        return invite(command, tower, io);
+    return changeRole(command, tower, io);
+}
+async function showMembers(command, tower, io) {
+    const result = await callTower(tower, { path: "/api/team/members", label: "team members" });
+    if (!result.ok)
+        return writeCommandFailure(io, command.json, result);
+    const body = asRecord(result.body);
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({ ok: true, ...body }));
+        return 0;
+    }
+    for (const line of renderTeamMembers(body))
+        writeLine(io.stdout, line);
+    return 0;
+}
+/**
+ * The invite needs a team, and the obvious one is the caller's own.
+ *
+ * So `--team-id` is optional and the fallback is a real read of
+ * `/api/team/members` rather than a guess. A person with no team gets told
+ * that, which is the truth and is fixable, instead of a uuid validation error
+ * from a body we assembled badly.
+ */
+async function invite(command, tower, io) {
+    let teamId = command.teamId;
+    if (!teamId) {
+        const directory = await callTower(tower, {
+            path: "/api/team/members",
+            label: "team invite lookup",
+        });
+        if (!directory.ok)
+            return writeCommandFailure(io, command.json, directory);
+        const currentTeam = asRecord(asRecord(directory.body).currentTeam);
+        if (typeof currentTeam.id !== "string") {
+            return writeCommandFailure(io, command.json, {
+                reason: "no_current_team",
+                detail: "You do not belong to a team, so there is nowhere to invite them. Pass --team-id <uuid>.",
+            });
+        }
+        teamId = currentTeam.id;
+    }
+    const result = await callTower(tower, {
+        path: "/api/team/invite",
+        method: "POST",
+        label: "team invite",
+        body: { email: command.email, role: command.role, team_id: teamId },
+    });
+    writeLine(io.stderr, `[team cli] invite ${JSON.stringify({
+        role: command.role,
+        team_named: command.teamId != null,
+        outcome: result.ok ? "sent" : result.reason,
+    })}`);
+    if (!result.ok)
+        return writeCommandFailure(io, command.json, result);
+    const body = asRecord(result.body);
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({ ok: true, ...body }));
+        return 0;
+    }
+    writeLine(io.stdout, `Invited ${String(command.email)} as ${String(body.role ?? command.role)}. ` +
+        "Tower emailed them a sign-in link.");
+    return 0;
+}
+async function changeRole(command, tower, io) {
+    const confirmed = await confirmDestructive(command, io, `Change ${command.targetUserId} to ${command.role}? [Y/n] `, "team role");
+    if (!confirmed.ok)
+        return writeCommandFailure(io, command.json, confirmed);
+    const result = await callTower(tower, {
+        path: `/api/team/members/${encodeURIComponent(command.targetUserId ?? "")}/role`,
+        method: "PATCH",
+        label: "team role",
+        body: { role: command.role },
+    });
+    writeLine(io.stderr, `[team cli] role change ${JSON.stringify({
+        to: command.role,
+        outcome: result.ok ? "changed" : result.reason,
+    })}`);
+    if (!result.ok)
+        return writeCommandFailure(io, command.json, result);
+    const body = asRecord(result.body);
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({ ok: true, ...body }));
+        return 0;
+    }
+    writeLine(io.stdout, `${String(body.user_id ?? command.targetUserId)} is now ${String(body.role)}.`);
+    return 0;
+}

package/dist/commands/tower-command.js

@@ -0,0 +1,112 @@
+/**
+ * What every "ask Tower a question as this machine's owner" command needs
+ * (BLI-3461).
+ *
+ * `tower-client.ts` (BLI-3457) already owns the transport: the paired session,
+ * the bearer header, and a failure that names itself rather than throwing. This
+ * module is the thin layer above it that the *command* shape needs — open the
+ * session once, call a route, and turn a refusal into the one thing a person or
+ * a `--json` consumer reads.
+ *
+ * Two rules it exists to keep:
+ *
+ * - **A refusal keeps its HTTP status.** `cockpit settings` shows a section a
+ *   person may not see as "admin only" rather than as an error, and it can only
+ *   tell those apart if the 403 survives the trip. `towerJsonRequest` folds a
+ *   non-2xx into a failure; this keeps `httpStatus` on it.
+ * - **stdout belongs to `--json`.** Every operational line goes to stderr, which
+ *   launchd captures; a `--json` run puts exactly one object on stdout.
+ */
+import { writeLine } from "./cli-io.js";
+import { loadPairedSession, towerFailureDetail, towerJsonRequest, } from "../tower-client.js";
+/** Client-side ceiling. These routes are small reads and writes, not turns. */
+const REQUEST_DEADLINE_MS = 30_000;
+export async function openTower(commandName, command, io) {
+    const session = await loadPairedSession(commandName, command.homeDir);
+    return {
+        dashboardUrl: command.dashboardUrl ?? session.dashboard_url,
+        deviceToken: session.device_token,
+        fetch: io.fetch,
+        log: (line) => writeLine(io.stderr, line),
+    };
+}
+export async function callTower(context, options) {
+    const result = await towerJsonRequest({
+        dashboardUrl: context.dashboardUrl,
+        path: options.path,
+        deviceToken: context.deviceToken,
+        fetch: context.fetch,
+        method: options.method ?? "GET",
+        ...(options.body === undefined ? {} : { body: options.body }),
+        timeoutMs: REQUEST_DEADLINE_MS,
+        label: options.label,
+        log: context.log,
+    });
+    if (result.ok)
+        return result;
+    const failure = result;
+    return {
+        ok: false,
+        reason: failure.reason,
+        detail: towerFailureDetail(failure.reason, failure.detail),
+        ...(failure.httpStatus === undefined ? {} : { httpStatus: failure.httpStatus }),
+    };
+}
+/**
+ * The one way a command reports that it could not do the thing.
+ *
+ * `--json` gets a single object on stdout; a person gets one sentence on
+ * stderr. Both carry the reason label, because "it failed" is not a result.
+ */
+export function writeCommandFailure(io, json, failure) {
+    if (json) {
+        writeLine(io.stdout, JSON.stringify({
+            ok: false,
+            error: failure.reason,
+            detail: failure.detail,
+            ...(failure.httpStatus === undefined ? {} : { httpStatus: failure.httpStatus }),
+        }));
+    }
+    else {
+        writeLine(io.stderr, failure.detail);
+    }
+    return 1;
+}
+/** True when the caller was told, politely, that this is not theirs to see. */
+export function isForbidden(result) {
+    return !result.ok && result.httpStatus === 403;
+}
+/** A record body, or an empty object — never a crash on an unexpected shape. */
+export function asRecord(body) {
+    return body && typeof body === "object" && !Array.isArray(body)
+        ? body
+        : {};
+}
+/** A list body, or an empty list. Same reasoning as `asRecord`. */
+export function asList(value) {
+    return Array.isArray(value) ? value : [];
+}
+/**
+ * `provider:model` → the pair the settings API stores.
+ *
+ * There is deliberately NO allowlist here, matching `cockpit jarvis --model`:
+ * the dashboard holds the list and refuses an unknown key with its own
+ * sentence, so a terminal copy could only ever go stale and start refusing
+ * models that work.
+ */
+export function parseModelKey(key) {
+    const separator = key.indexOf(":");
+    if (separator <= 0 || separator === key.length - 1) {
+        throw new Error(`\`${key}\` is not a model key. Use provider:model, e.g. openai:gpt-5.6-terra.`);
+    }
+    return { provider: key.slice(0, separator), model: key.slice(separator + 1) };
+}
+/** Reads piped stdin whole. Used only for env content, which is never echoed. */
+export async function readAllStdin(stream) {
+    stream.setEncoding("utf8");
+    let text = "";
+    for await (const chunk of stream) {
+        text += chunk;
+    }
+    return text;
+}

package/dist/commands/workbook-render.js

@@ -0,0 +1,196 @@
+/**
+ * How a workbook document and the library shelf read in a terminal.
+ *
+ * Pure functions, no io and no network: `workbook.ts` fetches, this lays out.
+ * Split out by BLI-3460 so the wrapping can be asserted at a fixed width by a
+ * test that never opens a socket.
+ *
+ * The documents are hardcoded prose (BLI-3247: "written, not compiled") walked
+ * into Markdown by the dashboard's `lib/workbook/to-markdown.ts`. Nothing here
+ * summarises, reorders or paraphrases — it wraps, and it strips the emphasis
+ * markers a reader did not ask for. `--markdown` bypasses this file entirely
+ * and prints the server's bytes, which is what lets this layout be opinionated.
+ */
+const DIM = "\x1b[2m";
+const RESET = "\x1b[0m";
+/** One compartment per project, its documents underneath, addressed as typed. */
+export function renderShelf(projects, width) {
+    const docs = projects.reduce((count, project) => count + (project.docs?.length ?? 0), 0);
+    const out = [
+        `WORKBOOK · ${projects.length} project${projects.length === 1 ? "" : "s"} · ${docs} document${docs === 1 ? "" : "s"}`,
+    ];
+    for (const project of projects) {
+        out.push("", (project.title ?? project.slug ?? "").toUpperCase());
+        if (project.line)
+            out.push(...wrap(project.line, width - 2).map((line) => `  ${line}`));
+        for (const doc of project.docs ?? []) {
+            out.push(`  ⏺ cockpit workbook ${project.slug ?? ""} ${doc.slug ?? ""}`);
+            out.push(`    ${doc.title ?? ""} · ${doc.kind ?? ""}`);
+            if (doc.line) {
+                out.push(...wrap(doc.line, width - 4).map((line) => dim(`    ${line}`)));
+            }
+            out.push(dim(`    ${[doc.author, doc.date].filter(Boolean).join(" · ")}`));
+        }
+    }
+    return out;
+}
+/** The document's own header, then its blocks laid out for `width`. */
+export function renderDocText(payload, markdown, width) {
+    const doc = payload.doc ?? {};
+    const out = [];
+    if (doc.title)
+        out.push(...wrap(doc.title.toUpperCase(), width));
+    const meta = [doc.kind, payload.project?.title, doc.author, doc.date].filter(Boolean);
+    if (meta.length > 0)
+        out.push(...wrap(meta.join(" · "), width).map((line) => dim(line)));
+    if (out.length > 0)
+        out.push("");
+    out.push(...renderMarkdownText(markdown, width));
+    return out;
+}
+/**
+ * Markdown to plain text. The block vocabulary is exactly what
+ * `to-markdown.ts` emits — headings, bullet lists, quotes, pipe tables,
+ * paragraphs — so there is no "unknown block" case to guess at; anything else
+ * falls through as a wrapped paragraph rather than being dropped.
+ */
+export function renderMarkdownText(markdown, width) {
+    const out = [];
+    for (const block of markdown.split("\n\n")) {
+        const text = block.trim();
+        if (!text)
+            continue;
+        if (out.length > 0)
+            out.push("");
+        if (text.startsWith("## ")) {
+            out.push(plain(text.slice(3)).toUpperCase());
+            continue;
+        }
+        if (text.startsWith("### ")) {
+            out.push(plain(text.slice(4)));
+            continue;
+        }
+        if (text.startsWith("|")) {
+            out.push(...renderTable(text, width));
+            continue;
+        }
+        if (text.startsWith(">")) {
+            const quote = text
+                .split("\n")
+                .map((line) => plain(line.replace(/^>\s?/, "")))
+                .join(" ")
+                .trim();
+            out.push(...wrap(quote, width - 4).map((line) => dim(`    ${line}`)));
+            continue;
+        }
+        if (text.startsWith("- ")) {
+            for (const item of text.split("\n")) {
+                const body = plain(item.replace(/^-\s+/, ""));
+                const wrapped = wrap(body, width - 4);
+                wrapped.forEach((line, index) => {
+                    out.push(index === 0 ? `  · ${line}` : `    ${line}`);
+                });
+            }
+            continue;
+        }
+        out.push(...wrap(plain(text), width));
+    }
+    return out;
+}
+/**
+ * A GFM pipe table as padded columns. When the padded table would not fit the
+ * width, each row is printed as `header: cell` lines instead — narrower, and
+ * still every cell. Dropping columns to fit is never an option: a table with a
+ * column missing looks complete and is not.
+ */
+function renderTable(block, width) {
+    const rows = block
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith("|"))
+        .map((line) => line
+        .replace(/^\|/, "")
+        .replace(/\|$/, "")
+        .split("|")
+        .map((cell) => plain(cell.trim())))
+        .filter((cells) => !cells.every((cell) => /^-{3,}$/.test(cell)));
+    if (rows.length === 0)
+        return [];
+    const header = rows[0] ?? [];
+    const body = rows.slice(1);
+    const columns = Math.max(...rows.map((cells) => cells.length));
+    const widths = [];
+    for (let index = 0; index < columns; index += 1) {
+        widths.push(Math.max(...rows.map((cells) => (cells[index] ?? "").length)));
+    }
+    const tableWidth = widths.reduce((sum, value) => sum + value, 0) + 2 * (columns - 1);
+    if (tableWidth <= width) {
+        return rows.map((cells) => cells
+            .map((cell, index) => cell.padEnd(index === columns - 1 ? 0 : (widths[index] ?? 0)))
+            .join("  ")
+            .trimEnd());
+    }
+    const out = [];
+    body.forEach((cells, rowIndex) => {
+        if (rowIndex > 0)
+            out.push("");
+        cells.forEach((cell, index) => {
+            const label = header[index];
+            out.push(label ? `  ${label}: ${cell}` : `  ${cell}`);
+        });
+    });
+    return out.length > 0 ? out : rows.map((cells) => cells.join(" · "));
+}
+/**
+ * The Markdown of one section: from its `## Heading` to the next one. Returns
+ * null when the anchor is not in the index or its heading is not in the text —
+ * a wrong slice is worse than a refusal, because it reads as the whole answer.
+ */
+export function sectionSlice(markdown, sections, sectionId) {
+    const wanted = sections.find((section) => section.id === sectionId);
+    if (!wanted?.title)
+        return null;
+    const blocks = markdown.split("\n\n");
+    const start = blocks.findIndex((block) => block.trim() === `## ${wanted.title}`);
+    if (start === -1)
+        return null;
+    const rest = blocks.slice(start + 1);
+    const nextHeading = rest.findIndex((block) => block.trim().startsWith("## "));
+    const end = nextHeading === -1 ? blocks.length : start + 1 + nextHeading;
+    return blocks.slice(start, end).join("\n\n").trim();
+}
+// ----------------------------------------------------------------- small parts
+/** Greedy word wrap. A word longer than the column keeps its own line, uncut. */
+export function wrap(text, width) {
+    const limit = Math.max(20, width);
+    const words = text.split(/\s+/u).filter(Boolean);
+    if (words.length === 0)
+        return [];
+    const lines = [];
+    let line = "";
+    for (const word of words) {
+        if (!line) {
+            line = word;
+            continue;
+        }
+        if (line.length + 1 + word.length <= limit) {
+            line = `${line} ${word}`;
+        }
+        else {
+            lines.push(line);
+            line = word;
+        }
+    }
+    lines.push(line);
+    return lines;
+}
+/** Emphasis markers are Markdown's, not a reader's; plain text drops them. */
+function plain(text) {
+    return text
+        .replace(/\*\*(.+?)\*\*/gu, "$1")
+        .replace(/\*(.+?)\*/gu, "$1")
+        .replace(/\\\|/gu, "|");
+}
+function dim(text) {
+    return `${DIM}${text}${RESET}`;
+}

package/dist/commands/workbook.js

@@ -0,0 +1,180 @@
+/**
+ * `cockpit workbook` — the project document library, read in the terminal
+ * (BLI-3460).
+ *
+ * The documents are hardcoded prose (BLI-3247: "written, not compiled"), and
+ * the dashboard's `lib/workbook/to-markdown.ts` walks that TSX into Markdown
+ * without a browser. This command asks for that Markdown and lays it out for a
+ * width. It renders NOTHING of its own: no summarising, no reordering, no
+ * paraphrase. `--markdown` prints the server's bytes unchanged, which is the
+ * escape hatch for anything this layout does not suit — and the reason the
+ * layout is allowed to be opinionated.
+ *
+ * No pager. A pager owns the terminal, breaks piping, and behaves differently
+ * on the two supported host families; `cockpit workbook tower workbook | less`
+ * is the person's decision to make, not this command's.
+ */
+import { writeLine, writeRaw } from "./cli-io.js";
+import { renderDocText, renderShelf, sectionSlice, } from "./workbook-render.js";
+import { loadPairedSession, towerFailureDetail, towerJsonRequest, } from "../tower-client.js";
+const READ_DEADLINE_MS = 30_000;
+/** The band a document reads well in. Narrower loses the table, wider loses the eye. */
+const WIDTH_FLOOR = 60;
+const WIDTH_CEILING = 100;
+const WIDTH_FALLBACK = 80;
+export async function runWorkbook(command, io) {
+    const session = await loadPairedSession("workbook", command.homeDir);
+    const dashboardUrl = command.dashboardUrl ?? session.dashboard_url;
+    const log = (line) => writeLine(io.stderr, line);
+    const width = resolveWidth(command.width, io);
+    const path = command.project && command.doc
+        ? `/api/cockpit/workbook?project=${encodeURIComponent(command.project)}&doc=${encodeURIComponent(command.doc)}`
+        : "/api/cockpit/workbook";
+    const read = await towerJsonRequest({
+        dashboardUrl,
+        path,
+        method: "GET",
+        deviceToken: session.device_token,
+        fetch: io.fetch,
+        label: command.doc ? "workbook-doc" : "workbook-index",
+        timeoutMs: READ_DEADLINE_MS,
+        log,
+    });
+    if (!read.ok) {
+        writeFailure(command, io, read);
+        return 1;
+    }
+    if (!command.doc) {
+        return writeIndex(command, io, read.body, width);
+    }
+    return writeDoc(command, io, read.body, width);
+}
+// -------------------------------------------------------------------- index
+function writeIndex(command, io, payload, width) {
+    const projects = payload.projects ?? [];
+    if (command.project) {
+        const found = projects.find((project) => project.slug === command.project);
+        if (!found) {
+            const known = projects.map((project) => project.slug ?? "").filter(Boolean);
+            const sentence = `No project "${command.project}" in the workbook library (${known.join(", ") || "none"}).`;
+            writeLine(io.stderr, `[workbook cli] read missed ${JSON.stringify({
+                reason: "workbook_project_not_found",
+                projects: projects.length,
+            })}`);
+            if (command.json) {
+                writeLine(io.stdout, JSON.stringify({ ok: false, error: "workbook_project_not_found", detail: sentence }));
+            }
+            else {
+                writeLine(io.stderr, sentence);
+            }
+            return 1;
+        }
+        if (command.json) {
+            writeLine(io.stdout, JSON.stringify({ ok: true, project: found }));
+        }
+        else {
+            for (const line of renderShelf([found], width))
+                writeLine(io.stdout, line);
+        }
+        logIndexRead(io, [found]);
+        return 0;
+    }
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({ ok: true, projects }));
+    }
+    else {
+        for (const line of renderShelf(projects, width))
+            writeLine(io.stdout, line);
+    }
+    logIndexRead(io, projects);
+    return 0;
+}
+function logIndexRead(io, projects) {
+    writeLine(io.stderr, `[workbook cli] index read ${JSON.stringify({
+        projects: projects.length,
+        docs: projects.reduce((count, project) => count + (project.docs?.length ?? 0), 0),
+    })}`);
+}
+// --------------------------------------------------------------------- doc
+function writeDoc(command, io, payload, width) {
+    const markdown = payload.markdown ?? "";
+    const sections = payload.sections ?? [];
+    let selected = markdown;
+    if (command.section) {
+        const slice = sectionSlice(markdown, sections, command.section);
+        if (slice === null) {
+            const known = sections.map((section) => section.id ?? "").filter(Boolean);
+            const sentence = `No section "${command.section}" in this document (${known.join(", ") || "none"}).`;
+            writeLine(io.stderr, `[workbook cli] section missed ${JSON.stringify({
+                reason: "workbook_section_not_found",
+                sections: sections.length,
+            })}`);
+            if (command.json) {
+                writeLine(io.stdout, JSON.stringify({ ok: false, error: "workbook_section_not_found", detail: sentence }));
+            }
+            else {
+                writeLine(io.stderr, sentence);
+            }
+            return 1;
+        }
+        selected = slice;
+    }
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({
+            ok: true,
+            project: payload.project ?? null,
+            doc: payload.doc ?? null,
+            markdown: selected,
+            sections,
+        }));
+    }
+    else if (command.markdown) {
+        // Verbatim: the bytes the renderer produced, plus the newline a terminal
+        // needs. Nothing is re-wrapped, re-cased, or re-ordered.
+        writeRaw(io.stdout, selected);
+    }
+    else {
+        for (const line of renderDocText(payload, selected, width))
+            writeLine(io.stdout, line);
+    }
+    writeLine(io.stderr, `[workbook cli] doc read ${JSON.stringify({
+        project: payload.project?.slug ?? null,
+        doc: payload.doc?.slug ?? null,
+        markdown_chars: selected.length,
+        sections: sections.length,
+        section_selected: command.section != null,
+        mode: command.json ? "json" : command.markdown ? "markdown" : "text",
+        width,
+    })}`);
+    return 0;
+}
+// ----------------------------------------------------------------- small parts
+/**
+ * The wrap column: an explicit `--width` wins, otherwise the terminal's own
+ * width held between 60 and 100. A pipe with no width reported reads as 80,
+ * the width a terminal has when nobody has said otherwise.
+ */
+export function resolveWidth(explicit, io) {
+    if (explicit !== undefined)
+        return explicit;
+    const columns = io.stdout.columns;
+    const reported = typeof columns === "number" && columns > 0 ? columns : WIDTH_FALLBACK;
+    return Math.min(WIDTH_CEILING, Math.max(WIDTH_FLOOR, reported));
+}
+function writeFailure(command, io, failure) {
+    const detail = towerFailureDetail(failure.reason, failure.detail);
+    writeLine(io.stderr, `[workbook cli] read failed ${JSON.stringify({
+        reason: failure.reason,
+        http_status: failure.httpStatus ?? null,
+    })}`);
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({
+            ok: false,
+            error: failure.reason,
+            detail,
+            httpStatus: failure.httpStatus ?? null,
+        }));
+        return;
+    }
+    writeLine(io.stderr, `The workbook could not be read: ${detail}`);
+}