@bli-cockpit/cli 0.2.184 → 0.2.186

package/dist/commands/local-help-commands-tower.js

@@ -342,7 +342,7 @@ export const TOWER_COMMAND_HELP = [
         "notes",
         [
             "Usage: cockpit notes [list|show <id>|shelf|shelves|folders|mkdir <path>|rmdir <path>|rename <path>|upload <paths...> [--wait]|paste|share <id>|unshare <id>|move <id>|accounts|connect|detach <id>|sync <id>|sync-status [<id>]|recordings <note-id>|recording <id>] [flags]",
-            "Audio uploads: MP3, M4A, WAV, WebM and OGG, up to 4 MB. --wait polls transcription for at most 330 seconds.",
+            "Audio uploads: MP3, M4A, WAV, WebM and OGG, up to 1 GB. Over 4 MB (a whole meeting) the file goes straight to storage and is transcribed in the background; --wait then polls for up to 4 hours and prints progress, otherwise for at most 330 seconds.",
             "",
             "folders [--tree] [--json]: list folders and visible note counts.",
             "mkdir <path> [--json]: create a folder and any missing ancestors.",

package/dist/commands/memory-project-label.js

@@ -0,0 +1,9 @@
+/** Cross-project search always names the project, after the date and before the author. */
+export function memoryProjectPrefix(row) {
+    if (typeof row["project"] !== "string" || !row["project"])
+        return "";
+    const date = typeof row["createdAt"] === "string" ? new Date(row["createdAt"]) : null;
+    const day = date && !Number.isNaN(date.getTime()) ? `[${date.toISOString().slice(0, 10)}] ` : "";
+    const author = typeof row["savedBy"] === "string" && row["savedBy"] ? `(from ${row["savedBy"]}) ` : "";
+    return `${day}[${row["project"]}] ${author}`;
+}

package/dist/commands/memory-store.js

@@ -42,6 +42,7 @@
  * `ps` shows an argument list, shell history keeps it, and a memory with a
  * newline in it cannot be quoted correctly anyway.
  */
+import { memoryProjectPrefix } from "./memory-project-label.js";
 import { resolveContainerTag } from "@bli-cockpit/memory-mcp/dist/container-tag.js";
 import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor, } from "./agent-door.js";
 import { isInteractiveStdin, readPipedText, writeLine } from "./cli-io.js";
@@ -208,7 +209,7 @@ async function searchMemory(command, door) {
     }
     else {
         for (const row of results) {
-            writeLine(door.io.stdout, `${similarityLabel(row)}${oneLine(row["memory"])}`);
+            writeLine(door.io.stdout, `${similarityLabel(row)}${memoryProjectPrefix(row)}${oneLine(row["memory"])}`);
             writeLine(door.io.stdout, `    ${String(row["id"] ?? "")}  ${String(row["containerTag"] ?? "")}${filedByLabel(row)}`);
         }
     }
@@ -217,7 +218,7 @@ async function searchMemory(command, door) {
         writeLine(door.io.stdout, "Recent context:");
         for (const row of recent) {
             const author = typeof row["savedBy"] === "string" && row["savedBy"] ? `(from ${row["savedBy"]}) ` : "";
-            writeLine(door.io.stdout, `  - ${author}${oneLine(row["preview"] ?? row["memory"])}`);
+            writeLine(door.io.stdout, `  - ${memoryProjectPrefix(row)}${row["project"] ? "" : author}${oneLine(row["preview"] ?? row["memory"])}`);
         }
     }
     if (body.degraded) {

package/dist/commands/notes-audio-direct.js

@@ -0,0 +1,77 @@
+/**
+ * `cockpit notes upload` for a whole-meeting recording (BLI-12963).
+ *
+ * A recording over 4 MB cannot pass through the dashboard's upload route (a
+ * Vercel function accepts 4.5 MB). So the file goes straight to storage:
+ *
+ *   1. ask Tower for a signed upload URL        POST /api/notes/audio/target
+ *   2. PUT the file from disk to that URL       (streamed; never held in memory)
+ *   3. tell Tower it is there                   POST /api/notes/audio/saved
+ *
+ * Tower then transcribes it in the background and the note shows progress.
+ * Step 2 goes to the storage host with the signed URL ONLY: the device token is
+ * sent to Tower's own routes in steps 1 and 3 and never to anyone else.
+ *
+ * Nothing here throws; every failure comes back as a closed reason label and
+ * the sentence Tower (or this file) wrote for it.
+ */
+import { createReadStream } from "node:fs";
+import { Readable } from "node:stream";
+import { writeLine } from "./cli-io.js";
+import { ask, TAG } from "./notes-door.js";
+import { noteAudioMime } from "./notes-file.js";
+/** A signed upload URL lives two hours; the PUT must finish inside that. */
+const PUT_DEADLINE_MS = 2 * 60 * 60 * 1000;
+const SMALL_DEADLINE_MS = 60_000;
+export async function uploadAudioDirect(door, input) {
+    const started = Date.now();
+    const mediaType = noteAudioMime(input.fileName) ?? "";
+    const target = await ask(door, {
+        path: "/api/notes/audio/target", method: "POST", label: "notes audio target", timeoutMs: SMALL_DEADLINE_MS,
+        body: { file_name: input.fileName, bytes: input.size, media_type: mediaType },
+    });
+    if (!target.ok)
+        return { ok: false, reason: target.reason, detail: target.detail };
+    const issued = target.body;
+    const url = issued.upload?.url;
+    if (!issued.objectKey || !url) {
+        return { ok: false, reason: "target_unreadable", detail: "Tower answered without an upload link." };
+    }
+    writeLine(door.io.stderr, `Uploading ${input.fileName} (${(input.size / 1_000_000).toFixed(1)} MB) straight to storage...`);
+    let put;
+    try {
+        put = await door.io.fetch(url, {
+            method: issued.upload?.method ?? "PUT",
+            headers: { ...(issued.upload?.headers ?? {}), "content-length": String(input.size) },
+            body: Readable.toWeb(createReadStream(input.filePath)),
+            // Node's fetch requires this for a streamed request body.
+            duplex: "half",
+            signal: AbortSignal.timeout(PUT_DEADLINE_MS),
+        });
+    }
+    catch (error) {
+        writeLine(door.io.stderr, `${TAG} storage put failed ${JSON.stringify({ reason: "storage_unreachable", bytes: input.size })}`);
+        return { ok: false, reason: "storage_unreachable",
+            detail: `Could not reach storage to upload the file (${error instanceof Error ? error.name : "error"}). Nothing was saved; try again.` };
+    }
+    if (!put.ok) {
+        // The storage host's reply can quote the object path; only the status leaves this function.
+        writeLine(door.io.stderr, `${TAG} storage put refused ${JSON.stringify({ reason: `storage_http_${put.status}`, bytes: input.size })}`);
+        return { ok: false, reason: `storage_http_${put.status}`,
+            detail: put.status === 413
+                ? "Storage refused the file as too large. An admin may need to raise the project's storage file size limit."
+                : `Storage refused the upload (HTTP ${put.status}). Nothing was saved; try again.` };
+    }
+    writeLine(door.io.stderr, `${TAG} storage put ok ${JSON.stringify({ bytes: input.size, elapsed_ms: Date.now() - started })}`);
+    const saved = await ask(door, {
+        path: "/api/notes/audio/saved", method: "POST", label: "notes audio saved", timeoutMs: SMALL_DEADLINE_MS,
+        body: {
+            object_key: issued.objectKey, file_name: input.fileName,
+            ...(input.exclude ? { exclusions: input.exclude } : {}),
+            ...(input.folder ? { folder_path: input.folder } : {}),
+        },
+    });
+    if (!saved.ok)
+        return { ok: false, reason: saved.reason, detail: saved.detail };
+    return { ok: true, body: saved.body };
+}

package/dist/commands/notes-file.js

@@ -39,6 +39,15 @@ export function noteAudioMime(name) {
     return mime[name.split(".").at(-1)?.toLowerCase() ?? ""];
 }
 export const NOTE_FILE_MAX_BYTES = 20 * 1024 * 1024;
+/**
+ * The most audio that goes THROUGH the upload route (a Vercel function accepts
+ * 4.5 MB per request). Bigger audio goes straight to storage on a signed URL
+ * and is transcribed in the background (BLI-12963); this mirrors
+ * `AUDIO_MAX_BYTES` in the dashboard's `lib/notes/audio.ts`.
+ */
+export const AUDIO_INLINE_MAX_BYTES = 4_000_000;
+/** The most audio the direct path takes; mirrors the bucket's `file_size_limit`. */
+export const AUDIO_DIRECT_MAX_BYTES = 1_000_000_000;
 /**
  * Above this, the terminal says it is working before it starts. The route's own
  * ceiling is `maxDuration = 300` because reading a note is one model call over
@@ -56,7 +65,7 @@ export function noteFileRefusalSentence(refusal, filePath) {
         case "file_empty":
             return `There is nothing in that file: ${filePath}`;
         case "file_too_big":
-            return "That file is too big. Audio is limited to 4 MB; other notes to 20 MB.";
+            return "That file is too big. Audio is limited to 1 GB (4 MB for anything but `cockpit notes upload`); other notes to 20 MB.";
         case "looks_like_a_key_file":
             // The same rule the server's gate applies, said the same way: the name is
             // all it takes to decide, and looking inside to be sure would already be
@@ -70,7 +79,7 @@ export function noteFileRefusalSentence(refusal, filePath) {
  * The secret-shaped-name check runs FIRST and on the name alone — the bytes are
  * never read for a file it turns away.
  */
-export async function readNoteFile(filePath) {
+export async function readNoteFile(filePath, options = {}) {
     const fileName = path.basename(filePath);
     const extension = path.extname(filePath).toLowerCase();
     if (isSecretLikePathSegment(fileName)) {
@@ -92,10 +101,19 @@ export async function readNoteFile(filePath) {
     }
     if (size === 0)
         return { ok: false, refusal: "file_empty", detail: "byte_size_0" };
-    if (noteAudioMime(fileName) && size > 4_000_000) {
-        return { ok: false, refusal: "file_too_big", detail: "file_too_large: audio limit is 4 MB (4,000,000 bytes)" };
+    if (noteAudioMime(fileName)) {
+        // Only `cockpit notes upload` has a direct-to-storage path; every other
+        // caller wants the bytes, and still refuses audio the route cannot take.
+        const ceiling = options.allowDirectAudio ? AUDIO_DIRECT_MAX_BYTES : AUDIO_INLINE_MAX_BYTES;
+        if (size > ceiling) {
+            return { ok: false, refusal: "file_too_big", detail: `file_too_large: audio limit is ${ceiling} bytes` };
+        }
+        // Big audio is never read into memory here; the upload streams it from disk.
+        if (size > AUDIO_INLINE_MAX_BYTES) {
+            return { ok: true, bytes: Buffer.alloc(0), fileName, extension: extension || "none", size, direct: true };
+        }
     }
-    if (size > NOTE_FILE_MAX_BYTES) {
+    else if (size > NOTE_FILE_MAX_BYTES) {
         return { ok: false, refusal: "file_too_big", detail: `byte_size_${size}` };
     }
     let bytes;
@@ -105,7 +123,7 @@ export async function readNoteFile(filePath) {
     catch (error) {
         return { ok: false, refusal: "file_unreadable", detail: errorMessage(error) };
     }
-    return { ok: true, bytes, fileName, extension: extension || "none" };
+    return { ok: true, bytes, fileName, extension: extension || "none", size, direct: false };
 }
 /**
  * Decodes note/env bytes to text the way an editor would, not the way UTF-8

package/dist/commands/notes-reads.js

@@ -129,6 +129,12 @@ export async function showNote(command, door) {
         writeLine(door.io.stdout, `Invited: ${note.participants.join(", ")}`);
     }
     writeLine(door.io.stdout, note.visibility);
+    // A recording is transcribed in the background: say where that stands, and why
+    // when it has stopped, rather than letting the placeholder body read as the note.
+    if (body.audio?.transcription_status) {
+        const detail = body.audio.transcription_detail ? ` ${body.audio.transcription_detail}` : "";
+        writeLine(door.io.stdout, `Transcription: ${body.audio.transcription_status}.${detail}`);
+    }
     writeLine(door.io.stdout, "");
     writeLine(door.io.stdout, note.content.replace(/^In the room:/gm, "Invited:"));
     return 0;

package/dist/commands/notes-writes.js

@@ -6,6 +6,7 @@
 import { isInteractiveStdin, readPipedText, writeLine, askYesNo } from "./cli-io.js";
 import { NOTE_SLOW_UPLOAD_BYTES, noteAudioMime, decodeTextBytes, noteFileRefusalSentence, readNoteFile, } from "./notes-file.js";
 import { ask, emit, fail, sayUpload, errorText, TAG, READ_DEADLINE_MS } from "./notes-door.js";
+import { uploadAudioDirect } from "./notes-audio-direct.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
@@ -20,7 +21,7 @@ export async function uploadNotes(command, door) {
     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);
+        const read = await readNoteFile(filePath, { allowDirectAudio: true });
         if (!read.ok) {
             const sentence = noteFileRefusalSentence(read.refusal, filePath);
             writeLine(door.io.stderr, `${TAG} file refused ${JSON.stringify({ reason: read.refusal, detail: read.detail })}`);
@@ -30,24 +31,36 @@ export async function uploadNotes(command, door) {
             worstExit = 1;
             continue;
         }
-        if (read.bytes.byteLength >= NOTE_SLOW_UPLOAD_BYTES) {
+        if (!read.direct && 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, { type: noteAudioMime(read.fileName) ?? "" }));
-        if (command.exclude)
-            form.set("exclusions", command.exclude);
-        if (command.folder)
-            form.set("folder_path", command.folder);
-        const answer = await ask(door, {
-            path: "/api/notes/upload",
-            method: "POST",
-            label: "notes upload",
-            timeoutMs: UPLOAD_DEADLINE_MS,
-            body: form,
-        });
+        // A whole-meeting recording (over 4 MB) goes straight to storage and is
+        // transcribed in the background (BLI-12963); everything else keeps the
+        // upload route.
+        let answer;
+        if (read.direct) {
+            const direct = await uploadAudioDirect(door, {
+                filePath, fileName: read.fileName, size: read.size, exclude: command.exclude, folder: command.folder,
+            });
+            answer = direct.ok ? { ok: true, body: direct.body } : { ok: false, reason: direct.reason, detail: direct.detail };
+        }
+        else {
+            const form = new FormData();
+            form.set("file", new File([new Uint8Array(read.bytes)], read.fileName, { type: noteAudioMime(read.fileName) ?? "" }));
+            if (command.exclude)
+                form.set("exclusions", command.exclude);
+            if (command.folder)
+                form.set("folder_path", command.folder);
+            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)
@@ -58,7 +71,7 @@ export async function uploadNotes(command, door) {
         }
         const body = answer.body;
         if (command.wait && body.noteId && body.transcription?.status === "pending") {
-            body.transcription = await waitForTranscription(door, body.noteId);
+            body.transcription = await waitForTranscription(door, body.noteId, read.direct);
         }
         if (body.transcription?.status === "failed")
             worstExit = 1;
@@ -73,7 +86,8 @@ export async function uploadNotes(command, door) {
             stored: body.stored === true,
             note_id: body.noteId ?? null,
             scope: body.scope ?? null,
-            byte_size: read.bytes.byteLength,
+            byte_size: read.size,
+            direct: read.direct,
             extension: read.extension,
         })}`);
     }
@@ -257,22 +271,38 @@ export async function moveNote(command, door) {
         writeLine(door.io.stdout, line);
     return body.ok === true ? 0 : 1;
 }
-/** Bounded polling of the same note read used by the browser and MCP. */
-async function waitForTranscription(door, noteId) {
-    const deadline = Date.now() + 330_000;
-    for (let attempt = 0; attempt < 110 && Date.now() < deadline; attempt++) {
+/**
+ * Bounded polling of the same note read used by the browser and MCP. A small
+ * file is transcribed inside the upload request's own budget, so five and a
+ * half minutes is plenty; a whole-meeting recording is transcribed by the
+ * background job, which can take an hour, so `--wait` there polls for up to
+ * four hours and prints each new progress line.
+ */
+async function waitForTranscription(door, noteId, background = false) {
+    const budgetMs = background ? 4 * 60 * 60 * 1000 : 330_000;
+    const intervalMs = background ? 10_000 : 3000;
+    const deadline = Date.now() + budgetMs;
+    let lastDetail = "";
+    while (Date.now() < deadline) {
         const answer = await ask(door, { path: `/api/notes/library/${encodeURIComponent(noteId)}`,
             method: "GET", label: "notes transcription", timeoutMs: Math.min(10_000, deadline - Date.now()) });
         if (!answer.ok)
             return { status: "failed", reason: answer.reason };
-        const status = answer.body.audio?.transcription_status;
+        const audio = answer.body.audio;
+        const status = audio?.transcription_status;
         if (status === "done")
             return { status: "done" };
         if (status?.startsWith("failed:"))
             return { status: "failed", reason: status.slice(7) };
         if (status !== "pending")
             return { status: "failed", reason: "transcription_status_unavailable" };
-        await new Promise((resolve) => setTimeout(resolve, Math.min(3000, Math.max(0, deadline - Date.now()))));
+        if (audio?.transcription_detail && audio.transcription_detail !== lastDetail) {
+            lastDetail = audio.transcription_detail;
+            if (!door.json)
+                writeLine(door.io.stderr, lastDetail);
+        }
+        const pause = Math.min(intervalMs, Math.max(0, deadline - Date.now()));
+        await (door.io.sleep ? door.io.sleep(pause) : new Promise((resolve) => setTimeout(resolve, pause)));
     }
     return { status: "failed", reason: "transcription_wait_timeout" };
 }

package/dist/commands/public-root.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.184",
+  "version": "0.2.186",
   "private": false,
   "type": "module",
   "bin": {
@@ -27,8 +27,8 @@
     "test": "node dist/cli.js --help && node ../../scripts/assert-public-cli-routing.mjs && node ../../scripts/assert-public-cli-verb-help.mjs && node ../../scripts/assert-public-cli-surface-doors.mjs && node ../../scripts/assert-public-cli-runtime-files.mjs && node ../../scripts/assert-public-cli-exit-contract.mjs && node ../../scripts/assert-public-cli-no-fleet-posts.mjs && node ../../scripts/assert-public-cli-doctor-json.mjs && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
-    "@bli-cockpit/memory-mcp": "0.1.55",
-    "@bli-cockpit/mcp": "0.1.98",
+    "@bli-cockpit/memory-mcp": "0.1.56",
+    "@bli-cockpit/mcp": "0.1.99",
     "@bli-cockpit/telemetry-core": "0.1.66"
   },
   "repository": {