@bli-cockpit/cli 0.2.57 → 0.2.58

package/dist/commands/notes-door.js

@@ -0,0 +1,120 @@
+/**
+ * `cockpit notes` plumbing: one HTTP request through the paired session, and
+ * the shared answer/refusal shapes `notes-reads.ts` and `notes-writes.ts`
+ * both render. Sibling of `notes.ts`, named in its header.
+ */
+import { writeLine } from "./cli-io.js";
+import { towerFailureDetail, towerRequest } from "../tower-client.js";
+import { readResponseJson } from "../upload-http.js";
+export const TAG = "[notes cli]";
+/** Every read in this surface shares one timeout; every write earns its own
+ * (a paste or an upload can run far longer). */
+export const READ_DEADLINE_MS = 60_000;
+/**
+ * One request, and a refusal that keeps the ROUTE'S own words.
+ *
+ * `towerJsonRequest` maps a non-2xx through `responseErrorMessage`, which looks
+ * for `message` or `error` — the shape the ingest routes answer with. Every
+ * notes door answers in the browser's shape instead (`headline` plus `lines`,
+ * with a `reason` label beside them), because the same body is what the page
+ * renders. Reading it here rather than widening `responseErrorMessage` keeps one
+ * meaning per field: the sentence is written where the outcome is known, and the
+ * terminal relays it rather than inventing a second wording for the same thing.
+ */
+export async function ask(door, options) {
+    const result = await towerRequest({
+        dashboardUrl: door.dashboardUrl,
+        path: options.path,
+        deviceToken: door.deviceToken,
+        fetch: door.io.fetch,
+        method: options.method,
+        label: options.label,
+        timeoutMs: options.timeoutMs,
+        ...(options.body === undefined ? {} : { body: options.body }),
+        log: (line) => writeLine(door.io.stderr, line),
+    });
+    if (!result.ok) {
+        const failure = result;
+        return {
+            ok: false,
+            reason: failure.reason,
+            detail: towerFailureDetail(failure.reason, failure.detail),
+        };
+    }
+    const body = await readResponseJson(result.response);
+    if (!result.response.ok) {
+        const status = result.response.status;
+        return {
+            ok: false,
+            reason: refusalReason(body) ?? `http_${status}`,
+            detail: refusalSentence(body) ?? `Tower answered ${status} and said nothing about why.`,
+        };
+    }
+    return { ok: true, body };
+}
+function refusalReason(body) {
+    if (!body || typeof body !== "object")
+        return null;
+    const record = body;
+    for (const key of ["reason", "error", "code"]) {
+        const value = record[key];
+        if (typeof value === "string" && value.trim() !== "")
+            return value;
+    }
+    return null;
+}
+function refusalSentence(body) {
+    if (!body || typeof body !== "object")
+        return null;
+    const record = body;
+    const headline = typeof record["headline"] === "string" ? record["headline"] : null;
+    const message = typeof record["message"] === "string" ? record["message"] : null;
+    const lines = Array.isArray(record["lines"])
+        ? record["lines"].filter((line) => typeof line === "string")
+        : [];
+    const said = [headline ?? message, ...lines].filter(Boolean);
+    return said.length > 0 ? said.join(" ") : null;
+}
+/** One machine-readable object on stdout, and nothing else on it. */
+export function emit(door, body, exitCode = 0) {
+    writeLine(door.io.stdout, JSON.stringify(body));
+    return exitCode;
+}
+export function fail(door, reason, detail) {
+    writeLine(door.io.stderr, `${TAG} refused ${JSON.stringify({ reason })}`);
+    if (door.json) {
+        writeLine(door.io.stdout, JSON.stringify({ ok: false, error: reason, detail }));
+    }
+    else {
+        writeLine(door.io.stderr, detail);
+    }
+    return 1;
+}
+/**
+ * The route's own words for what happened. Never rephrased here — the sentences
+ * are written where the outcome is known, and a second wording in the terminal
+ * would be a second thing to keep in step.
+ */
+export function sayUpload(door, body) {
+    writeLine(door.io.stdout, body.headline ?? "Tower answered without a sentence.");
+    for (const line of body.lines ?? [])
+        writeLine(door.io.stdout, line);
+    if (body.noteId)
+        writeLine(door.io.stdout, `Note id: ${body.noteId}`);
+}
+/**
+ * Says out loud when an answer is narrower than the one a browser would give.
+ *
+ * A degraded read is still a real answer and is never withheld — but a person
+ * who cannot see their own unshared note has to be told that is why, not left
+ * to conclude it was never stored.
+ */
+export function sayScope(door, body) {
+    if (!body.degradedBecause)
+        return;
+    writeLine(door.io.stderr, `${TAG} narrowed ${JSON.stringify({ scope: body.scope ?? null, reason: body.degradedBecause })}`);
+    writeLine(door.io.stderr, body.degradedNote ?? "This answer is narrower than the browser's.");
+}
+export function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/commands/notes-reads.js

@@ -0,0 +1,134 @@
+/**
+ * `cockpit notes` reads: the library, one note, and your own shelf. Sibling
+ * of `notes.ts`, named in its header.
+ */
+import { writeLine } from "./cli-io.js";
+import { ask, fail, emit, sayScope, READ_DEADLINE_MS } from "./notes-door.js";
+function libraryQuery(command) {
+    const query = new URLSearchParams();
+    if (command.series)
+        query.set("series", command.series);
+    if (command.meetingKind)
+        query.set("kind", command.meetingKind);
+    if (command.since)
+        query.set("since", command.since);
+    if (command.until)
+        query.set("until", command.until);
+    if (command.limit !== undefined)
+        query.set("limit", String(command.limit));
+    const rendered = query.toString();
+    return rendered === "" ? "" : `?${rendered}`;
+}
+export async function listNotes(command, door) {
+    const answer = await ask(door, {
+        path: `/api/notes/library${libraryQuery(command)}`,
+        method: "GET",
+        label: "notes list",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return fail(door, answer.reason, answer.detail);
+    const body = answer.body;
+    if (door.json)
+        return emit(door, body);
+    sayScope(door, body);
+    const series = body.series ?? [];
+    if (series.length === 0) {
+        writeLine(door.io.stdout, "No meeting notes matched.");
+        return 0;
+    }
+    for (const one of series) {
+        writeLine(door.io.stdout, "");
+        writeLine(door.io.stdout, `${one.heading} (${one.notes.length})`);
+        for (const note of one.notes) {
+            const who = note.participants.length > 0 ? ` — ${note.participants.join(", ")}` : "";
+            writeLine(door.io.stdout, `  ${note.meetingDate}  ${note.id}  ${note.fileName}${who}`);
+        }
+    }
+    writeLine(door.io.stdout, "");
+    writeLine(door.io.stdout, `${body.count ?? 0} note(s)${body.more ? ", and more exist beyond the limit" : ""}.`);
+    return 0;
+}
+export async function listShelves(command, door) {
+    const answer = await ask(door, {
+        path: `/api/notes/library${libraryQuery(command)}`,
+        method: "GET",
+        label: "notes shelves",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return fail(door, answer.reason, answer.detail);
+    const body = answer.body;
+    const shelves = (body.series ?? []).map((one) => ({
+        shelf: one.heading,
+        notes: one.notes.length,
+        // A shelf somebody typed, rather than the one a kind implies. Only the
+        // first kind is reported: a shelf is free text and can hold any of them.
+        custom: (body.categories ?? []).includes(one.heading),
+    }));
+    if (door.json)
+        return emit(door, { scope: body.scope, shelves });
+    sayScope(door, body);
+    if (shelves.length === 0) {
+        writeLine(door.io.stdout, "No shelves yet.");
+        return 0;
+    }
+    for (const shelf of shelves) {
+        writeLine(door.io.stdout, `${String(shelf.notes).padStart(4)}  ${shelf.shelf}${shelf.custom ? "" : "  (from the meeting kind)"}`);
+    }
+    return 0;
+}
+export async function showNote(command, door) {
+    const answer = await ask(door, {
+        path: `/api/notes/library/${encodeURIComponent(command.noteId ?? "")}`,
+        method: "GET",
+        label: "notes show",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return fail(door, answer.reason, answer.detail);
+    const body = answer.body;
+    if (door.json)
+        return emit(door, body);
+    const note = body.note;
+    if (!note)
+        return fail(door, "no_note_in_answer", "Tower answered without a note.");
+    sayScope(door, body);
+    writeLine(door.io.stdout, note.title);
+    writeLine(door.io.stdout, `${note.meetingDate}  ·  ${note.shelf}  ·  ${note.fileName}  ·  ${note.lineCount} lines`);
+    if (note.participants.length > 0) {
+        writeLine(door.io.stdout, `In the room: ${note.participants.join(", ")}`);
+    }
+    writeLine(door.io.stdout, note.visibility);
+    writeLine(door.io.stdout, "");
+    writeLine(door.io.stdout, note.content);
+    return 0;
+}
+export async function showShelf(command, door) {
+    const query = command.limit === undefined ? "" : `?limit=${command.limit}`;
+    const answer = await ask(door, {
+        path: `/api/notes/shelf${query}`,
+        method: "GET",
+        label: "notes shelf",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return fail(door, answer.reason, answer.detail);
+    const body = answer.body;
+    if (door.json)
+        return emit(door, body);
+    sayScope(door, body);
+    const notes = body.notes ?? [];
+    if (notes.length === 0) {
+        writeLine(door.io.stdout, "You have not put any notes in yet.");
+        return 0;
+    }
+    for (const note of notes) {
+        const counts = note.countsKnown
+            ? `${note.statements} statements, ${note.openToTheTeam} open to the team, ${note.keptBack} kept back`
+            : "counts unknown on this server";
+        writeLine(door.io.stdout, `${note.meetingDate}  ${note.id}  ${note.shared ? "shared " : "yours  "}  ${note.name}`);
+        writeLine(door.io.stdout, `            ${counts}`);
+    }
+    return 0;
+}

package/dist/commands/notes-writes.js

@@ -0,0 +1,208 @@
+/**
+ * `cockpit notes` writes: putting a note in from a file or the clipboard,
+ * sharing it and taking it back, and moving it to another shelf. Sibling of
+ * `notes.ts`, named in its header.
+ */
+import { isInteractiveStdin, readLine, readPipedText, writeLine, yesByDefault } from "./cli-io.js";
+import { NOTE_SLOW_UPLOAD_BYTES, decodeTextBytes, noteFileRefusalSentence, readNoteFile, } from "./notes-file.js";
+import { ask, emit, fail, sayUpload, errorText, TAG, READ_DEADLINE_MS } from "./notes-door.js";
+/**
+ * The upload route's own ceiling is `maxDuration = 300` — reading a note is one
+ * model call over the whole file. The client waits slightly longer so the
+ * server's named failure wins the race whenever it manages to send one.
+ */
+const UPLOAD_DEADLINE_MS = 305_000;
+const PASTE_MAX_CHARS = 2_000_000;
+export async function uploadNotes(command, door) {
+    const paths = command.paths ?? [];
+    const results = [];
+    let worstExit = 0;
+    for (const filePath of paths) {
+        // Read and screen locally BEFORE any network call — a refusal here never
+        // reaches the dashboard, same discipline as `cockpit jarvis --image`.
+        const read = await readNoteFile(filePath);
+        if (!read.ok) {
+            const sentence = noteFileRefusalSentence(read.refusal, filePath);
+            writeLine(door.io.stderr, `${TAG} file refused ${JSON.stringify({ reason: read.refusal, detail: read.detail })}`);
+            if (!door.json)
+                writeLine(door.io.stderr, sentence);
+            results.push({ path: filePath, ok: false, reason: read.refusal });
+            worstExit = 1;
+            continue;
+        }
+        if (read.bytes.byteLength >= NOTE_SLOW_UPLOAD_BYTES) {
+            // The route reads the whole note with one model call and may take
+            // minutes. A still cursor reads as a hang, so say what is happening.
+            writeLine(door.io.stderr, `Reading ${read.fileName} (${Math.round(read.bytes.byteLength / 1024)} KB). This can take a couple of minutes.`);
+        }
+        const form = new FormData();
+        form.set("file", new File([new Uint8Array(read.bytes)], read.fileName));
+        if (command.exclude)
+            form.set("exclusions", command.exclude);
+        const answer = await ask(door, {
+            path: "/api/notes/upload",
+            method: "POST",
+            label: "notes upload",
+            timeoutMs: UPLOAD_DEADLINE_MS,
+            body: form,
+        });
+        if (!answer.ok) {
+            writeLine(door.io.stderr, `${TAG} upload failed ${JSON.stringify({ reason: answer.reason })}`);
+            if (!door.json)
+                writeLine(door.io.stderr, `${read.fileName}: ${answer.detail}`);
+            results.push({ path: filePath, ok: false, reason: answer.reason });
+            worstExit = 1;
+            continue;
+        }
+        const body = answer.body;
+        results.push({ path: filePath, ok: body.stored === true, body });
+        if (body.stored !== true)
+            worstExit = 1;
+        if (!door.json)
+            sayUpload(door, body);
+        writeLine(door.io.stderr, `${TAG} upload answered ${JSON.stringify({
+            stored: body.stored === true,
+            note_id: body.noteId ?? null,
+            scope: body.scope ?? null,
+            byte_size: read.bytes.byteLength,
+            extension: read.extension,
+        })}`);
+    }
+    if (door.json) {
+        emit(door, { ok: worstExit === 0, uploaded: results.length, results });
+    }
+    return worstExit;
+}
+export async function pasteNote(command, door) {
+    let text;
+    if (command.filePath) {
+        const read = await readNoteFile(command.filePath);
+        if (!read.ok) {
+            const sentence = noteFileRefusalSentence(read.refusal, command.filePath);
+            writeLine(door.io.stderr, `${TAG} file refused ${JSON.stringify({ reason: read.refusal, detail: read.detail })}`);
+            return fail(door, read.refusal, sentence);
+        }
+        const decoded = decodeTextBytes(read.bytes);
+        if (!decoded.ok) {
+            writeLine(door.io.stderr, `${TAG} file refused ${JSON.stringify({ reason: decoded.reason })}`);
+            return fail(door, decoded.reason, "That file is not text this command can decode (it may be a binary or an unusual encoding). Nothing was sent.");
+        }
+        text = decoded.text;
+    }
+    else {
+        if (isInteractiveStdin(door.io)) {
+            return fail(door, "nothing_piped", "Pass --file <path> (safest on Windows), or pipe the note in "
+                + "(`pbpaste | cockpit notes paste` on macOS; on Windows use PowerShell 7 — "
+                + "Windows PowerShell 5.1 turns non-ASCII into `?` on pipes).");
+        }
+        try {
+            text = await readPipedText(door.io.stdin, {
+                maxChars: PASTE_MAX_CHARS,
+                overflowMessage: `A pasted note is limited to ${PASTE_MAX_CHARS} characters. Save it to a file and use --file instead.`,
+            });
+        }
+        catch (error) {
+            return fail(door, "paste_too_long", errorText(error));
+        }
+    }
+    if (text.trim() === "") {
+        return fail(door, "empty_paste", "There was nothing to paste. Nothing was sent.");
+    }
+    const form = new FormData();
+    form.set("text", text);
+    if (command.name)
+        form.set("name", command.name);
+    if (command.exclude)
+        form.set("exclusions", command.exclude);
+    // Bytes, not `.length` (BLI-3482). `NOTE_SLOW_UPLOAD_BYTES` is a BYTE
+    // threshold, and the file path above already compares `bytes.byteLength`
+    // against it; `text.length` counts UTF-16 units, so a note in any non-Latin
+    // script was measured at a third to a half of the size actually being sent
+    // and the "this will take a while" line stayed silent through the wait.
+    const pastedBytes = Buffer.byteLength(text, "utf8");
+    if (pastedBytes >= NOTE_SLOW_UPLOAD_BYTES) {
+        writeLine(door.io.stderr, `Reading ${Math.round(pastedBytes / 1024)} KB of pasted text. This can take a couple of minutes.`);
+    }
+    const answer = await ask(door, {
+        path: "/api/notes/upload",
+        method: "POST",
+        label: "notes paste",
+        timeoutMs: UPLOAD_DEADLINE_MS,
+        body: form,
+    });
+    if (!answer.ok)
+        return fail(door, answer.reason, answer.detail);
+    const body = answer.body;
+    writeLine(door.io.stderr, `${TAG} paste answered ${JSON.stringify({
+        stored: body.stored === true,
+        note_id: body.noteId ?? null,
+        scope: body.scope ?? null,
+        chars: text.length,
+        byte_size: pastedBytes,
+        named_by_caller: Boolean(command.name),
+    })}`);
+    if (door.json)
+        return emit(door, body, body.stored === true ? 0 : 1);
+    sayUpload(door, body);
+    return body.stored === true ? 0 : 1;
+}
+export async function shareNote(command, door) {
+    const wantsToShare = command.action === "share";
+    // Only sharing asks. Taking a note back narrows who can read it, and nobody
+    // needs to be talked out of that.
+    if (wantsToShare && !command.yes) {
+        if (!isInteractiveStdin(door.io)) {
+            return fail(door, "confirmation_required", "Sharing a note lets everyone signed in read it. Pass --yes to do it without being asked.");
+        }
+        const answer = await readLine(door.io, "Share this note with everyone signed in? [Y/n] ");
+        if (!yesByDefault(answer)) {
+            writeLine(door.io.stderr, `${TAG} share declined ${JSON.stringify({ reason: "operator_said_no" })}`);
+            writeLine(door.io.stdout, "Left alone. Nothing changed.");
+            return 0;
+        }
+    }
+    const answer = await ask(door, {
+        path: "/api/notes/share",
+        method: "POST",
+        label: wantsToShare ? "notes share" : "notes unshare",
+        timeoutMs: READ_DEADLINE_MS,
+        body: { note_id: command.noteId, share: wantsToShare },
+    });
+    if (!answer.ok)
+        return fail(door, answer.reason, answer.detail);
+    const body = answer.body;
+    writeLine(door.io.stderr, `${TAG} ${wantsToShare ? "shared" : "taken back"} ${JSON.stringify({
+        note_id: command.noteId ?? null,
+        stored: body.stored === true,
+    })}`);
+    if (door.json)
+        return emit(door, body);
+    sayUpload(door, body);
+    return 0;
+}
+export async function moveNote(command, door) {
+    const answer = await ask(door, {
+        path: "/api/notes/move",
+        method: "POST",
+        label: "notes move",
+        timeoutMs: READ_DEADLINE_MS,
+        // `--clear-shelf` sends the empty string, which is what the browser's own
+        // move box sends when a person empties it.
+        body: { note_id: command.noteId, category: command.clearShelf ? "" : command.to },
+    });
+    if (!answer.ok)
+        return fail(door, answer.reason, answer.detail);
+    const body = answer.body;
+    writeLine(door.io.stderr, `${TAG} move answered ${JSON.stringify({
+        note_id: command.noteId ?? null,
+        ok: body.ok === true,
+        reason: body.reason ?? null,
+        cleared: Boolean(command.clearShelf),
+    })}`);
+    if (door.json)
+        return emit(door, body, body.ok === true ? 0 : 1);
+    writeLine(door.io.stdout, body.headline ?? "Tower answered without a sentence.");
+    for (const line of body.lines ?? [])
+        writeLine(door.io.stdout, line);
+    return body.ok === true ? 0 : 1;
+}