@bli-cockpit/cli 0.2.57 → 0.2.58

package/dist/commands/notes.js

@@ -22,20 +22,23 @@
  *    `--yes` without one. `--json` implies `--yes`, because a machine-readable
  *    run has nobody to ask and asking it to guess is worse than the flag it
  *    already typed the command for.
+ *
+ * This file is the dispatch table (BLI-3717 readability pass, 680 lines to a
+ * table of contents). Every responsibility lives in a `notes-*.ts` sibling:
+ *
+ *  - `notes-reads.ts` — the library, shelves list, one note, your own shelf.
+ *  - `notes-writes.ts` — upload, paste, share/unshare, move.
+ *  - `notes-door.ts` — the one HTTP request, and the shared answer / refusal /
+ *    emit / say-* rendering both halves above call.
+ *
+ * Every public name is still importable from this file.
  */
-import { isInteractiveStdin, readLine, readPipedText, writeLine, yesByDefault } from "./cli-io.js";
-import { NOTE_SLOW_UPLOAD_BYTES, decodeTextBytes, noteFileRefusalSentence, readNoteFile, } from "./notes-file.js";
-import { loadPairedSession, towerFailureDetail, towerRequest, } from "../tower-client.js";
-import { readResponseJson } from "../upload-http.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 READ_DEADLINE_MS = 60_000;
-const PASTE_MAX_CHARS = 2_000_000;
-const TAG = "[notes cli]";
+import { loadPairedSession } from "../tower-client.js";
+import { listNotes, listShelves, showNote, showShelf } from "./notes-reads.js";
+import { uploadNotes, pasteNote, shareNote, moveNote } from "./notes-writes.js";
+export { listNotes, listShelves, showNote, showShelf } from "./notes-reads.js";
+export { uploadNotes, pasteNote, shareNote, moveNote } from "./notes-writes.js";
+export { ask, emit, fail, sayUpload, sayScope, errorText, TAG, } from "./notes-door.js";
 export async function runNotes(command, io) {
     const session = await loadPairedSession("notes", command.homeDir);
     const door = {
@@ -63,433 +66,4 @@ export async function runNotes(command, io) {
         case "move":
             return moveNote(command, door);
     }
-}
-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}`;
-}
-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;
-}
-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;
-}
-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;
-}
-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;
-}
-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;
-}
-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;
-}
-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;
-}
-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;
-}
-/**
- * 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.
- */
-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. */
-function emit(door, body, exitCode = 0) {
-    writeLine(door.io.stdout, JSON.stringify(body));
-    return exitCode;
-}
-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.
- */
-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.
- */
-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.");
-}
-function errorText(error) {
-    return error instanceof Error ? error.message : String(error);
 }

package/dist/commands/ops-render.js

@@ -19,6 +19,11 @@ export function verdictWord(verdict) {
             return "ok";
         case "stale":
             return "STALE";
+        // BLI-3723. Its own word, not a shade of STALE: a `failing` reader's input
+        // is CURRENT and its answer is bad, which sends a person to a laptop
+        // rather than to a cron config.
+        case "failing":
+            return "BAD";
         case "never_produced":
             return "EMPTY";
         case "unreadable":
@@ -69,7 +74,9 @@ export function renderOpsStatus(payload, dim) {
     for (const row of rows) {
         const verdict = verdictWord(row.verdict).padEnd(6);
         const id = (row.id ?? "?").padEnd(idWidth);
-        const age = ageWord(row.ageHours).padStart(7);
+        // BLI-3723: a row that has no age BY DESIGN says `n/a`, never `—`. The two
+        // look alike and mean opposite things — `—` is "the table is empty".
+        const age = (row.ageAbsence ? "n/a" : ageWord(row.ageHours)).padStart(7);
         // BLI-3722: name the device this age belongs to right in the row — a bare
         // `STALE collector-fleet 11h` was already misread once (BLI-3699) as "the
         // fleet", not "one machine in it", and the name is otherwise buried in
@@ -77,6 +84,10 @@ export function renderOpsStatus(payload, dim) {
         const staleName = row.verdict === "stale" && row.staleDeviceName ? ` ${dim(`(${row.staleDeviceName})`)}` : "";
         lines.push(`${verdict} ${id}  ${age}${staleName}  ${dim(intervalWord(row))}`);
         if (row.verdict !== "healthy") {
+            // The absence of an age is explained BEFORE the detail, because it is
+            // the first thing a reader's eye stopped on.
+            if (row.ageAbsence)
+                lines.push(dim(`       no age: ${row.ageAbsence}`));
             if (row.detail)
                 lines.push(dim(`       ${row.detail}`));
             if (row.caveat)

package/dist/commands/ops.js

@@ -12,7 +12,7 @@
  *
  * **Exit codes are the whole point of running this in a script.** Zero when
  * every job that CAN be answered for is healthy; 1 when anything is stale,
- * empty or unreadable. `no_artifact` — a job that writes no row — does not fail
+ * failing, empty or unreadable. `no_artifact` — a job that writes no row — does not fail
  * the command, and it does not pass silently either: it prints as `n/a` with
  * the reason there is nothing to read.
  *
@@ -60,7 +60,14 @@ async function runOpsStatus(command, io, tower) {
     }
     const payload = asRecord(result.body);
     const rows = payload.pipelines ?? [];
-    const unhealthy = rows.filter((row) => row.verdict === "stale" || row.verdict === "never_produced" || row.verdict === "unreadable");
+    // BLI-3723: `failing` joins the list. An older CLI that has never heard of it
+    // simply does not count it — which is why the server keeps the sentence in
+    // `detail`, so an un-upgraded terminal still PRINTS the outage even when it
+    // exits 0 over it.
+    const unhealthy = rows.filter((row) => row.verdict === "stale" ||
+        row.verdict === "never_produced" ||
+        row.verdict === "unreadable" ||
+        row.verdict === "failing");
     if (command.json) {
         writeLine(io.stdout, JSON.stringify(payload));
     }

package/dist/commands/project.js

@@ -0,0 +1,38 @@
+/**
+ * `cockpit project list` — the projects issues are filed under (BLI-3716).
+ *
+ * One verb, because `GET /api/work/projects` is the whole of the Work
+ * surface's project door today (BLI-3703 scoped projects to list-only; there
+ * is no create/update/delete route to put a terminal in front of). Its own
+ * command rather than `cockpit issue projects` because a person says
+ * "projects", and `cockpit issue list --project <name>` resolves a name
+ * against exactly this list.
+ */
+import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+const TAG = "[project cli]";
+const READ_DEADLINE_MS = 30_000;
+export async function runProject(command, io) {
+    const door = await openAgentDoor("project", command, io);
+    const answer = await askAgentDoor(door, {
+        path: `/api/work/projects${command.includeArchived ? "?include_archived=true" : ""}`,
+        method: "GET",
+        label: "project list",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const projects = answer.body.projects ?? [];
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, projects });
+    if (projects.length === 0) {
+        writeLine(door.io.stdout, "No projects.");
+        return 0;
+    }
+    for (const project of projects) {
+        writeLine(door.io.stdout, `${project.id}  ${project.archived_at ? "archived" : "active  "}  ${project.name}`);
+    }
+    writeLine(door.io.stdout, "");
+    writeLine(door.io.stdout, `${projects.length} project(s).`);
+    return 0;
+}

package/dist/commands/public-root.js

@@ -15,7 +15,7 @@ export async function runCockpitCli(argv, io) {
   }
 
   if (command === "--version" || command === "-V" || command === "version") {
-    writeLine(io?.stdout ?? process.stdout, "0.2.57");
+    writeLine(io?.stdout ?? process.stdout, "0.2.58");
     return 0;
   }
 

package/dist/repo-identity-fingerprint.js

@@ -0,0 +1,88 @@
+/**
+ * Turning a filesystem path or a git origin URL into the stable ids this
+ * package hands out (`repo_fingerprint`, `worktree_fingerprint`, the label),
+ * plus the collection-root canonicalization built on the same realpath call.
+ * Sibling of `repo-identity.ts`, named in its header.
+ */
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+export async function stableWorktreeRoot(repoRoot) {
+    const resolvedRoot = path.resolve(repoRoot);
+    return fs.realpath(resolvedRoot).catch(() => resolvedRoot);
+}
+/**
+ * Canonicalizes existing collection roots through the filesystem so transcript
+ * paths and consent roots use the same spelling (for example `/private/var`
+ * versus the `/var` symlink on macOS). Missing roots remain resolved as typed.
+ */
+export async function canonicalizeCollectionRootPaths(roots) {
+    const canonical = await Promise.all(roots.map(stableWorktreeRoot));
+    return [...new Set(canonical)];
+}
+/**
+ * Returns the operator-entered resolved paths plus filesystem-canonical aliases.
+ * Both are needed for absent child repos because the child itself cannot be
+ * realpathed after deletion, while its transcript may retain either spelling.
+ */
+export async function collectionRootPathAliases(roots) {
+    const resolved = roots.map((root) => path.resolve(root));
+    const canonical = await canonicalizeCollectionRootPaths(resolved);
+    return [...new Set([...resolved, ...canonical])];
+}
+function normalizeFingerprintPath(repoRoot, pathApi = path) {
+    const resolved = pathApi.resolve(repoRoot);
+    return pathApi.sep === "\\" ? resolved.toLowerCase() : resolved;
+}
+export function stableWorktreeFingerprint(repoRoot, pathApi = path) {
+    return `wt-${sha256(`worktree:${normalizeFingerprintPath(repoRoot, pathApi)}`).slice(0, 24)}`;
+}
+export function repoFingerprintFromLocalRoot(root, pathApi = path) {
+    return `repo-${sha256(`local:${normalizeFingerprintPath(root, pathApi)}`).slice(0, 24)}`;
+}
+export function repoFingerprintFromOrigin(origin) {
+    const normalizedOrigin = normalizeGitOrigin(origin);
+    return `repo-${sha256(`origin:${normalizedOrigin}`).slice(0, 24)}`;
+}
+export function normalizeGitOrigin(rawOrigin) {
+    const trimmed = rawOrigin.trim();
+    if (!trimmed)
+        return "";
+    const scpLike = trimmed.match(/^(?:[^@]+@)?([^:]+):(.+)$/);
+    if (scpLike && !trimmed.includes("://")) {
+        return normalizeOriginParts(scpLike[1] ?? "", scpLike[2] ?? "");
+    }
+    try {
+        const url = new URL(trimmed);
+        return normalizeOriginParts(url.hostname, url.pathname);
+    }
+    catch {
+        // Deliberately silent (BLI-3238). `new URL` is being used as the test for
+        // "is this origin URL-shaped?", and a plain path or an unusual remote form
+        // failing to parse IS the answer — the fallback below is the intended
+        // normalization for exactly that case, not a degradation.
+        return trimmed
+            .replace(/\.git$/i, "")
+            .replace(/^\/+|\/+$/g, "")
+            .toLowerCase();
+    }
+}
+export function repoLabelFromOrigin(origin) {
+    const segments = origin.split("/").filter(Boolean);
+    return segments.at(-1) ?? origin;
+}
+function normalizeOriginParts(host, repoPath) {
+    return [
+        host.trim().toLowerCase(),
+        repoPath
+            .trim()
+            .replace(/\.git$/i, "")
+            .replace(/^\/+|\/+$/g, "")
+            .toLowerCase(),
+    ]
+        .filter(Boolean)
+        .join("/");
+}
+export function sha256(value) {
+    return crypto.createHash("sha256").update(value, "utf8").digest("hex");
+}