@bli-cockpit/cli 0.2.183 → 0.2.185

package/dist/commands/cal.js

@@ -164,8 +164,9 @@ function eventLine(event, zone) {
     const when = event.all_day ? allDayLabel(event.starts_at, event.ends_at) : `${clock(event.starts_at, zone)}–${clock(event.ends_at, zone)}`;
     const marks = `${event.recurring ? "↻" : " "}${event.status === "tentative" ? "?" : " "}`;
     const where = event.location ? `  @ ${event.location.slice(0, 40)}` : "";
+    const meeting = meetingLinkText(event);
     const who = event.attendee_count > 0 ? `  (${event.attendee_count})` : "";
-    return `${marks} ${when.padEnd(13)}  ${event.title.slice(0, 52).padEnd(52)}${where}${who}`;
+    return `${marks} ${when.padEnd(13)}  ${event.title.slice(0, 52).padEnd(52)}${where}${who}${meeting}`;
 }
 /**
  * BLI-3825: an all-day event spanning several days is ONE row from the door
@@ -229,7 +230,7 @@ async function find(command, door) {
         const when = match.next_occurrence
             ? `${dayLabel(match.next_occurrence, zone)} ${clock(match.next_occurrence, zone)}`
             : `last on ${dayLabel(match.starts_at, zone)}`;
-        writeLine(door.io.stdout, `${match.recurring ? "↻" : " "} ${when.padEnd(20)}  ${match.title.slice(0, 50).padEnd(50)}  ${match.calendar_name}`);
+        writeLine(door.io.stdout, `${match.recurring ? "↻" : " "} ${when.padEnd(20)}  ${match.title.slice(0, 50).padEnd(50)}  ${match.calendar_name}${meetingLinkText(match)}`);
     }
     writeLine(door.io.stdout, "");
     writeLine(door.io.stdout, `${matches.length} match(es). Times are ${zone}.`);
@@ -307,4 +308,10 @@ async function create(command, door) {
         writeLine(door.io.stdout, `Invitations went to ${command.attendees.join(", ")} from Google.`);
     }
     return 0;
+}
+function meetingLinkText(event) {
+    const label = { meet: "Meet link", zoom: "Zoom link", teams: "Teams link" }[event.meeting_kind ?? ""] ?? "Meeting link";
+    const meeting = event.meeting_url ? `  ${label}: ${event.meeting_url}` : "";
+    console.error("[cal render] meeting link", JSON.stringify({ reason: event.meeting_url ? "meeting_link_shown" : "no_meeting_link" }));
+    return meeting;
 }

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/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

@@ -126,11 +126,17 @@ export async function showNote(command, door) {
     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, `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);
+    writeLine(door.io.stdout, note.content.replace(/^In the room:/gm, "Invited:"));
     return 0;
 }
 export async function showShelf(command, door) {

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,37 @@ 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);
+        }
+        await new Promise((resolve) => setTimeout(resolve, Math.min(intervalMs, Math.max(0, deadline - Date.now()))));
     }
     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.183");
+    writeLine(io?.stdout ?? process.stdout, "0.2.185");
     return 0;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.183",
+  "version": "0.2.185",
   "private": false,
   "type": "module",
   "bin": {
@@ -28,7 +28,7 @@
   },
   "dependencies": {
     "@bli-cockpit/memory-mcp": "0.1.55",
-    "@bli-cockpit/mcp": "0.1.97",
+    "@bli-cockpit/mcp": "0.1.99",
     "@bli-cockpit/telemetry-core": "0.1.66"
   },
   "repository": {