@bli-cockpit/cli 0.2.275 → 0.2.276

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

@@ -6,7 +6,7 @@ export const NOTES_HELP = [
             "Usage: cockpit notes [list|show <id>|shelf|shelves|folders|mkdir <path>|rmdir <path>|rename <path>|upload <paths...> [--wait]|paste|share <id>|unshare <id>|summarize <id>|move <id>|accounts|connect|detach <id>|sync <id>|sync-status [<id>]|recordings <note-id>|recording <id>|record start|stop|status|cancel|app install|uninstall|status] [flags]",
             "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.",
             "",
-            "record start|stop [<session-id>]|status|cancel — record a meeting in a room from this machine's microphone (Apple Silicon macOS and Windows; Linux says it is not supported). On Windows the microphone needs Settings > Privacy & security > Microphone on, including Let desktop apps access your microphone. Nothing leaves the machine while recording and there is no auto-stop. `stop` trims the silence away locally, uploads only the speech, and Tower writes a note with Speaker 1, Speaker 2... lines (add --wait to watch the transcription). `cancel` stops and KEEPS the file; `status` lists what is recording or waiting; `stop <session-id>` finishes a cancelled or crashed session. The original recording stays on this machine.",
+            "record start|stop [<session-id>]|status|cancel — record a meeting in a room from this machine's microphone (Apple Silicon macOS and Windows; Linux says it is not supported). On Windows the microphone needs Settings > Privacy & security > Microphone on, including Let desktop apps access your microphone. Nothing leaves the machine while recording; the recorder stops by itself after 8 hours (under the 1 GB upload limit). `stop` uploads the whole original recording, silence included, and Tower writes a note with Speaker 1, Speaker 2... lines, or says no speech was detected (add --wait to watch the transcription). `cancel` stops and KEEPS the file; `status` lists what is recording and every session waiting for upload (`needs_upload`); `stop <session-id>` uploads a cancelled, crashed or auto-stopped session. The BLI Notetaker app uploads waiting sessions by itself. The recording also stays on this machine.",
             "app install|uninstall|status [--json] — the BLI Notetaker app (Apple Silicon macOS menu bar, or 64-bit Windows 10/11 taskbar notification area; Linux and Windows on Arm say they are not supported yet). `install` asks Tower for the newest release for this machine, downloads it, refuses it if its sha256 differs, and starts it at login: on the Mac it goes in ~/Applications/BLI Notetaker.app (replacing an older one, download quarantine cleared) with a LaunchAgent; on Windows it goes in %LOCALAPPDATA%\\Programs\\BLI Notetaker\\bli-notetaker.exe with a Startup entry (HKCU Run value, no admin; Windows does not block it because the CLI downloaded it). The menu runs the `record` verbs above: Record, Stop, Open last note, Finish last recording. Log: ~/Library/Logs/BLI Notetaker.log on the Mac, %LOCALAPPDATA%\\BLI Notetaker\\notetaker.log on Windows. `uninstall` removes the app and its startup entry and keeps your recordings and the log; `status` says what is installed, whether it runs, whether it starts at login, and whether a newer release exists.",
             "folders [--tree] [--json]: list folders and visible note counts.",
             "mkdir <path> [--json]: create a folder and any missing ancestors.",

package/dist/commands/notes-record-capture.js

@@ -18,6 +18,12 @@
  * always closes the file itself. It writes `ready` once the microphone is
  * really open and `failed.txt` (a closed reason label) if it cannot be.
  *
+ * BLI-23382: it also stops by itself once the file holds
+ * `MAX_RECORDING_SECONDS` of audio (8 hours, about 922 MB of 16 kHz mono
+ * 16-bit, under the 1,000,000,000-byte storage limit), writing `ended.txt`
+ * (`max_duration_reached`) and `done`. `status` then shows the session as
+ * stopped and waiting for upload.
+ *
  * Everything in a session lives in one directory under the collector's state
  * dir. Nothing here touches the network.
  */
@@ -28,6 +34,14 @@ import { randomBytes } from "node:crypto";
 import { getCollectorRuntimePaths } from "../local-state-paths.js";
 import { launchRecorderWin32, RECORDER_SCRIPT_WIN32 } from "./notes-record-capture-win32.js";
 export const RECORDING_SAMPLE_RATE = 16_000;
+/** The recorder stops by itself after this much audio (BLI-23382): 8 hours. */
+export const MAX_RECORDING_SECONDS = 28_800;
+/** What `MAX_RECORDING_SECONDS` of 16 kHz mono 16-bit audio weighs: 921,600,000 bytes, under the bucket's 1,000,000,000. */
+export const MAX_RECORDING_BYTES = MAX_RECORDING_SECONDS * RECORDING_SAMPLE_RATE * 2;
+/** The marker a recorder writes when it ended by itself, holding one closed reason label. */
+export const ENDED_MARKER = "ended.txt";
+/** The only reason a recorder ends by itself today. */
+export const MAX_DURATION_REASON = "max_duration_reached";
 /** The JXA recorder. `argv[0]` is the session directory. Reasons it writes to `failed.txt`: mic_denied, recorder_failed. */
 export const RECORDER_SCRIPT = `ObjC.import('AVFoundation');
 ObjC.import('Foundation');
@@ -55,6 +69,13 @@ function run(argv) {
     if (now === 1 || now === 2) { recorder.stop; writeText(dir + '/failed.txt', 'mic_denied'); $.exit(3); }
     if (!announced && now === 3) { announced = true; writeText(dir + '/ready', 'ok'); }
     if (!announced && waited > 120) { recorder.stop; writeText(dir + '/failed.txt', 'mic_permission_unanswered'); $.exit(5); }
+    // currentTime is the audio in the file, so it bounds the file size; the tick count is a backstop if it ever reads wrong.
+    if (recorder.currentTime >= ${MAX_RECORDING_SECONDS} || waited >= ${MAX_RECORDING_SECONDS + 600}) {
+      recorder.stop;
+      writeText(dir + '/${ENDED_MARKER}', '${MAX_DURATION_REASON}');
+      writeText(dir + '/done', 'ok');
+      $.exit(0);
+    }
   }
   recorder.stop;
   writeText(dir + '/done', 'ok');
@@ -66,7 +87,8 @@ export function recordingsRoot(homeDir) {
 }
 export const sessionDir = (root, id) => path.join(root, id);
 export const audioPath = (root, id) => path.join(root, id, "audio.wav");
-export const trimmedPath = (root, id) => path.join(root, id, `meeting-${id.slice(0, 13)}.wav`);
+/** The name Tower sees: a hard link to `audio.wav` (the same bytes), so the note is named after the meeting's time. */
+export const uploadPath = (root, id) => path.join(root, id, `meeting-${id.slice(0, 13)}.wav`);
 export function newSessionId(now) {
     const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\..*$/, "").replace("T", "-");
     return `${stamp}-${randomBytes(2).toString("hex")}`;
@@ -119,6 +141,15 @@ export async function readReason(root, id) {
         return null;
     }
 }
+/** The closed reason a recorder wrote when it ended by itself (`ended.txt`), or null. */
+export async function readEndedReason(root, id) {
+    try {
+        return (await readFile(path.join(root, id, ENDED_MARKER), "utf8")).trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
 export async function requestStop(root, id) {
     await writeFile(path.join(root, id, "stop"), "stop\n", { mode: 0o600 });
 }

package/dist/commands/notes-record-wav.js

@@ -1,37 +1,14 @@
 /**
- * BLI-22979: the WAV file `cockpit notes record` writes, and the speech trim
- * that runs on it when a recording stops.
+ * BLI-22979: the WAV file `cockpit notes record` writes.
  *
- * The recorder (see `notes-record-capture.ts`) writes 16 kHz mono 16-bit PCM,
- * so a trim is plain arithmetic on samples: no codec, no native module, and it
- * runs the same on every machine. A recording that was killed leaves a header
- * that still says "0 bytes of audio"; `repairWavHeader` rewrites the two size
- * fields from the real file length so the file plays and trims again (R37: a
- * crashed session is recoverable, never lost).
- *
- * The trim is a voice-activity detector with a floor learned from the file
- * itself, so a quiet speaker in a quiet room is kept and a loud room is not
- * mistaken for speech. Every kept span is padded on both sides so a soft word
- * start or a trailing consonant is not clipped. The original file is never
- * modified by the trim; the caller keeps it.
+ * The recorder (see `notes-record-capture.ts`) writes 16 kHz mono 16-bit PCM.
+ * A recording that was killed leaves a header that still says "0 bytes of
+ * audio"; `repairWavHeader` rewrites the two size fields from the real file
+ * length so the file plays (R37: a crashed session is recoverable, never lost).
+ * That is the only change ever made to the file: BLI-23382 removed the local
+ * speech trim, so Tower receives the original recording, silence included.
  */
 import { open, stat } from "node:fs/promises";
-/** Frame length the detector measures, in seconds. */
-export const VAD_FRAME_SECONDS = 0.03;
-/** Padding kept on both sides of every speech span, in seconds. */
-export const VAD_PAD_SECONDS = 0.6;
-/** Silence shorter than this between two bursts of speech does not split them. */
-export const VAD_JOIN_GAP_SECONDS = 0.8;
-/** A burst shorter than this is a click or a cough, not speech. */
-export const VAD_MIN_SPEECH_SECONDS = 0.3;
-/** A frame must sit this far above the learned noise floor to count as speech. */
-export const VAD_MARGIN_DB = 12;
-/** Nothing quieter than this is ever speech, whatever the floor says. */
-export const VAD_ABSOLUTE_MIN_DB = -55;
-/** The bar never rises above this, so a file that is nearly all speech (a high floor) is still kept. */
-export const VAD_MAX_THRESHOLD_DB = -35;
-/** Less speech than this in total is "no speech": nothing is submitted. */
-export const VAD_MIN_TOTAL_SPEECH_SECONDS = 0.6;
 const HEADER_SCAN_BYTES = 4096;
 export async function readWavInfo(filePath) {
     const handle = await open(filePath, "r");
@@ -99,146 +76,4 @@ export async function repairWavHeader(filePath) {
         await handle.close();
     }
     return { ok: true, info: { ...read.info, dataBytes: read.info.dataBytes } };
-}
-/**
- * Speech spans (padded, merged) from per-frame loudness in dBFS. Pure, so the
- * trimming rules are tested without a file.
- */
-export function detectSpeechSpans(frameDb, frameSeconds = VAD_FRAME_SECONDS) {
-    const count = frameDb.length;
-    if (count === 0)
-        return { spans: [], speechSeconds: 0, noiseFloorDb: VAD_ABSOLUTE_MIN_DB, thresholdDb: VAD_ABSOLUTE_MIN_DB };
-    const sorted = Array.from({ length: count }, (_, i) => frameDb[i]).sort((a, b) => a - b);
-    const noiseFloorDb = sorted[Math.floor(count * 0.1)];
-    const thresholdDb = Math.min(Math.max(noiseFloorDb + VAD_MARGIN_DB, VAD_ABSOLUTE_MIN_DB), VAD_MAX_THRESHOLD_DB);
-    const total = count * frameSeconds;
-    // 1. Raw runs of loud frames.
-    let runs = [];
-    let runStart = -1;
-    for (let i = 0; i <= count; i += 1) {
-        const loud = i < count && frameDb[i] > thresholdDb;
-        if (loud && runStart < 0)
-            runStart = i;
-        if (!loud && runStart >= 0) {
-            runs.push({ startSeconds: runStart * frameSeconds, endSeconds: i * frameSeconds });
-            runStart = -1;
-        }
-    }
-    // 2. Join runs separated by a short gap, so a pause between words is not a cut.
-    const joined = [];
-    for (const run of runs) {
-        const last = joined.at(-1);
-        if (last && run.startSeconds - last.endSeconds <= VAD_JOIN_GAP_SECONDS)
-            last.endSeconds = run.endSeconds;
-        else
-            joined.push({ ...run });
-    }
-    // 3. Drop bursts too short to be speech.
-    runs = joined.filter((run) => run.endSeconds - run.startSeconds >= VAD_MIN_SPEECH_SECONDS);
-    const speechSeconds = runs.reduce((sum, run) => sum + (run.endSeconds - run.startSeconds), 0);
-    if (speechSeconds < VAD_MIN_TOTAL_SPEECH_SECONDS)
-        return { spans: [], speechSeconds, noiseFloorDb, thresholdDb };
-    // 4. Pad every span, clamp to the file, merge spans the padding made overlap.
-    const padded = [];
-    for (const run of runs) {
-        const span = { startSeconds: Math.max(0, run.startSeconds - VAD_PAD_SECONDS), endSeconds: Math.min(total, run.endSeconds + VAD_PAD_SECONDS) };
-        const last = padded.at(-1);
-        if (last && span.startSeconds <= last.endSeconds)
-            last.endSeconds = Math.max(last.endSeconds, span.endSeconds);
-        else
-            padded.push(span);
-    }
-    return { spans: padded, speechSeconds, noiseFloorDb, thresholdDb };
-}
-const CHUNK_BYTES = 1 << 20;
-/** Loudness of every frame, read in chunks so a long meeting is never held in memory. */
-export async function measureFrames(filePath, info) {
-    const frameSamples = Math.max(1, Math.round(info.sampleRate * VAD_FRAME_SECONDS));
-    const bytesPerFrame = frameSamples * info.channels * 2;
-    const frames = Math.floor(info.dataBytes / bytesPerFrame);
-    const out = new Float32Array(frames);
-    const handle = await open(filePath, "r");
-    try {
-        const framesPerChunk = Math.max(1, Math.floor(CHUNK_BYTES / bytesPerFrame));
-        const buffer = Buffer.alloc(framesPerChunk * bytesPerFrame);
-        for (let first = 0; first < frames; first += framesPerChunk) {
-            const want = Math.min(framesPerChunk, frames - first);
-            const { bytesRead } = await handle.read(buffer, 0, want * bytesPerFrame, info.dataOffset + first * bytesPerFrame);
-            const got = Math.floor(bytesRead / bytesPerFrame);
-            for (let f = 0; f < got; f += 1) {
-                let sum = 0;
-                const base = f * bytesPerFrame;
-                // First channel only: the recorder writes mono; a stereo file is judged on its left side.
-                for (let s = 0; s < frameSamples; s += 1) {
-                    const v = buffer.readInt16LE(base + s * info.channels * 2) / 32768;
-                    sum += v * v;
-                }
-                out[first + f] = 10 * Math.log10(Math.max(sum / frameSamples, 1e-10));
-            }
-        }
-    }
-    finally {
-        await handle.close();
-    }
-    return out;
-}
-/** Write only the padded speech spans of `inputPath` to `outputPath`. Writes nothing when no speech remains. */
-export async function trimToSpeech(inputPath, outputPath) {
-    const read = await readWavInfo(inputPath);
-    if (!read.ok)
-        return read;
-    const { info } = read;
-    const db = await measureFrames(inputPath, info);
-    const frameSeconds = Math.max(1, Math.round(info.sampleRate * VAD_FRAME_SECONDS)) / info.sampleRate;
-    const totalSeconds = info.dataBytes / (info.sampleRate * info.channels * 2);
-    const found = detectSpeechSpans(db, frameSeconds);
-    if (found.spans.length === 0) {
-        return { ok: true, speech: false, totalSeconds, speechSeconds: found.speechSeconds, noiseFloorDb: found.noiseFloorDb };
-    }
-    const frameBytes = info.channels * 2;
-    const ranges = found.spans.map((span) => {
-        const start = Math.floor(span.startSeconds * info.sampleRate) * frameBytes;
-        const end = Math.min(info.dataBytes - (info.dataBytes % frameBytes), Math.floor(span.endSeconds * info.sampleRate) * frameBytes);
-        return { start, end };
-    });
-    const dataBytes = ranges.reduce((sum, range) => sum + (range.end - range.start), 0);
-    const header = Buffer.alloc(44);
-    header.write("RIFF", 0, "ascii");
-    header.writeUInt32LE(36 + dataBytes, 4);
-    header.write("WAVEfmt ", 8, "ascii");
-    header.writeUInt32LE(16, 16);
-    header.writeUInt16LE(1, 20);
-    header.writeUInt16LE(info.channels, 22);
-    header.writeUInt32LE(info.sampleRate, 24);
-    header.writeUInt32LE(info.sampleRate * info.channels * 2, 28);
-    header.writeUInt16LE(info.channels * 2, 32);
-    header.writeUInt16LE(16, 34);
-    header.write("data", 36, "ascii");
-    header.writeUInt32LE(dataBytes, 40);
-    const source = await open(inputPath, "r");
-    const target = await open(outputPath, "w", 0o600);
-    try {
-        await target.write(header, 0, header.length, 0);
-        let position = header.length;
-        const buffer = Buffer.alloc(CHUNK_BYTES);
-        for (const range of ranges) {
-            for (let at = range.start; at < range.end;) {
-                const want = Math.min(buffer.length, range.end - at);
-                const { bytesRead } = await source.read(buffer, 0, want, info.dataOffset + at);
-                if (bytesRead === 0)
-                    break;
-                await target.write(buffer, 0, bytesRead, position);
-                position += bytesRead;
-                at += bytesRead;
-            }
-        }
-    }
-    finally {
-        await source.close();
-        await target.close();
-    }
-    return {
-        ok: true, speech: true, totalSeconds, speechSeconds: found.speechSeconds,
-        keptSeconds: dataBytes / (info.sampleRate * info.channels * 2), spans: found.spans.length, bytes: header.length + dataBytes,
-    };
 }

package/dist/commands/notes-record-win32-script.js

@@ -3,11 +3,17 @@
  * `notes-record-capture-win32.ts` (which launches it) so each file stays readable; the design notes live there.
  * Pure text: nothing here runs on import.
  */
+/**
+ * BLI-23382: the recorder stops by itself once it has written this many audio bytes: 8 hours of 16 kHz mono
+ * 16-bit (`MAX_RECORDING_BYTES` in `notes-record-capture.ts`, which imports this file, so the number is
+ * repeated here and a test pins the two together).
+ */
+export const WIN32_MAX_RECORDING_BYTES = 921_600_000;
 /**
  * The C# recorder. C# 5 and APIs of .NET Framework 4.x AND .NET 6+ only, so it
  * compiles under Windows PowerShell 5.1 (CodeDom) and PowerShell 7 (Roslyn).
  * Unmanaged WAVEHDRs and buffers, polled for WHDR_DONE: no delegate callback
- * that the GC could collect. Exit codes: 0 stopped, 2 no microphone, 3 mic
+ * that the GC could collect. Exit codes: 0 stopped (by `stop` or at the 8-hour cap, BLI-23382), 2 no microphone, 3 mic
  * denied, 4 recorder failed.
  */
 const RECORDER_CSHARP = String.raw `using System;
@@ -58,7 +64,8 @@ public sealed class BliRecorder
     const uint WhdrDone = 1;
     const int BufferCount = 8;
     const int BufferBytes = 3200;
-    const string Consent = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\CapabilityAccessManager\\ConsentStore\\microphone";
+    const long MaxBytes = ${WIN32_MAX_RECORDING_BYTES}L;
+    const string Consent ="SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\CapabilityAccessManager\\ConsentStore\\microphone";
 
     readonly string dir;
     bool ready;
@@ -242,6 +249,7 @@ public sealed class BliRecorder
             while (true)
             {
                 if (File.Exists(stopPath)) break;
+                if (total >= MaxBytes) { endedBy = "max_duration_reached"; break; }
                 if (clock.ElapsedMilliseconds - lastPrivacy >= 1000)
                 {
                     lastPrivacy = clock.ElapsedMilliseconds;
@@ -292,6 +300,7 @@ public sealed class BliRecorder
 
         Log("closed ended_by=" + endedBy + " buffers=" + buffers + " bytes=" + total);
         if (endedBy == "mic_denied") { Fail("mic_denied"); return 3; }
+        if (endedBy == "max_duration_reached") File.WriteAllText(Path.Combine(dir, "ended.txt"), endedBy);
         File.WriteAllText(Path.Combine(dir, "done"), "ok");
         return 0;
     }

package/dist/commands/notes-record.js

@@ -4,28 +4,33 @@
  * note with "Speaker N" lines.
  *
  *   start   opens the microphone and returns; the recorder keeps running.
- *   stop    closes it, trims the silence away on this machine, and uploads the
- *           trimmed audio through `cockpit notes upload` (the direct uploader),
- *           so Tower transcribes and labels the speakers exactly as it does
- *           for any other audio. `stop <session-id>` finishes a cancelled or
- *           crashed session the same way.
- *   cancel  closes the microphone and KEEPS the file (R37); nothing is uploaded.
- *   status  shows what is recording and what is recoverable, with time and size.
+ *   stop    closes it and uploads the ORIGINAL recording, untouched (only a
+ *           killed recorder's WAV header is repaired), through `cockpit notes
+ *           upload` (the direct uploader), so Tower transcribes and labels the
+ *           speakers exactly as it does for any other audio. Silence is
+ *           uploaded too; Tower names a recording with no speech. `stop
+ *           <session-id>` finishes a cancelled, crashed, auto-stopped or
+ *           failed-upload session the same way.
+ *   cancel  closes the microphone and KEEPS the file (R37); nothing is uploaded
+ *           yet. The BLI Notetaker app uploads it by itself (BLI-23382).
+ *   status  shows what is recording and every session waiting for upload
+ *           (`needs_upload: true`), with time and size.
  *
- * Nothing leaves the machine while recording, and there is no auto-stop. The
- * original file is never deleted or changed by the trim. Apple Silicon macOS
- * and Windows (BLI-23208) record; any other platform refuses by name. Both
- * platforms share one session directory, marker files, JSON answers and WAV
- * format, so the trim, upload and recovery below are the same code.
+ * Nothing leaves the machine while recording. The recorder stops by itself at
+ * `MAX_RECORDING_SECONDS` (8 hours) so the file stays under the 1 GB upload
+ * limit. Apple Silicon macOS and Windows (BLI-23208) record; any other platform
+ * refuses by name. Both platforms share one session directory, marker files,
+ * JSON answers and WAV format, so the upload and recovery below are one code path.
  *
  * Capture is `notes-record-capture.ts` (macOS) and
- * `notes-record-capture-win32.ts` (Windows); the speech trim is `notes-record-wav.ts`.
+ * `notes-record-capture-win32.ts` (Windows); the header repair is `notes-record-wav.ts`.
  */
+import { link, rm } from "node:fs/promises";
 import path from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { writeLine } from "./cli-io.js";
-import { audioPath, fileExists, fileSize, launchRecorder, listSessions, newSessionId, prepareSessionDir, processAlive, readReason, recordingsRoot, requestStop, sessionDir, trimmedPath, writeSession, RECORDING_SAMPLE_RATE, } from "./notes-record-capture.js";
-import { repairWavHeader, trimToSpeech } from "./notes-record-wav.js";
+import { audioPath, fileExists, fileSize, launchRecorder, listSessions, newSessionId, prepareSessionDir, processAlive, readEndedReason, readReason, recordingsRoot, requestStop, sessionDir, uploadPath, writeSession, MAX_RECORDING_SECONDS, RECORDING_SAMPLE_RATE, } from "./notes-record-capture.js";
+import { repairWavHeader } from "./notes-record-wav.js";
 const TAG = "[notes record]";
 const READY_DEADLINE_MS = 150_000;
 const STOP_DEADLINE_MS = 10_000;
@@ -44,11 +49,28 @@ export function defaultRecordDeps(io, upload) {
         upload,
     };
 }
-const stateOf = (session, deps) => {
-    if (!session.endedAt)
-        return deps.alive(session.pid) ? "recording" : "crashed";
-    return session.endedBy === "cancel" ? "cancelled" : "stopped";
-};
+/**
+ * Where a session stands. Order matters: an end the CLI wrote, then an end the recorder wrote (`ended.txt`
+ * at the 8-hour cap, or `done`), then a live process. A marker outranks the pid, so a pid the system reused
+ * never pins a finished recorder as "recording". `endedReason` is the recorder's closed label, if it wrote one.
+ */
+async function viewOf(root, session, deps) {
+    if (session.endedAt)
+        return { state: session.endedBy === "cancel" ? "cancelled" : "stopped", endedReason: null };
+    const ended = await readEndedReason(root, session.id);
+    if (ended)
+        return { state: "stopped", endedReason: ended };
+    if (await fileExists(path.join(sessionDir(root, session.id), "done")))
+        return { state: "stopped", endedReason: null };
+    return { state: deps.alive(session.pid) ? "recording" : "crashed", endedReason: null };
+}
+async function findRecording(root, sessions, deps) {
+    for (const session of sessions) {
+        if ((await viewOf(root, session, deps)).state === "recording")
+            return session;
+    }
+    return undefined;
+}
 const MIC_DENIED_DARWIN = "The microphone is blocked for this terminal. Open System Settings > Privacy & Security > Microphone, switch your terminal app on, then run `cockpit notes record start` again.";
 const MIC_DENIED_WIN32 = "The microphone is blocked. Open Settings > Privacy & security > Microphone, turn on Microphone access and Let desktop apps access your microphone, then run `cockpit notes record start` again.";
 /** The sentence for a recorder reason, per platform: the macOS and Windows microphone switches live in different places. */
@@ -98,7 +120,7 @@ export async function runNotesRecord(command, io, deps) {
 }
 async function startRecording(command, io, deps, root) {
     const sessions = await listSessions(root);
-    const running = sessions.find((s) => stateOf(s, deps) === "recording");
+    const running = await findRecording(root, sessions, deps);
     if (running) {
         return refuse(io, command, "already_recording", `A recording is already running (started ${running.startedAt}). Run \`cockpit notes record stop\` to finish it or \`cockpit notes record cancel\` to keep the file and stop.`);
     }
@@ -120,7 +142,7 @@ async function startRecording(command, io, deps, root) {
         }
         if (await fileExists(`${sessionDir(root, id)}/ready`)) {
             writeLine(io.stderr, `${TAG} recording ${JSON.stringify({ session: id, reason: "mic_open" })}`);
-            return say(io, command, `Recording. Nothing leaves this machine until you run \`cockpit notes record stop\`.\nFile: ${audioPath(root, id)}`, { session: id, state: "recording", file: audioPath(root, id) });
+            return say(io, command, `Recording. Nothing leaves this machine until you run \`cockpit notes record stop\`. It stops by itself after ${MAX_RECORDING_SECONDS / 3600} hours.\nFile: ${audioPath(root, id)}`, { session: id, state: "recording", file: audioPath(root, id) });
         }
         if (!deps.alive(pid)) {
             await writeSession(root, { ...session, endedAt: deps.now().toISOString(), endedBy: "cancel" });
@@ -140,85 +162,123 @@ async function closeRecorder(root, session, deps) {
         deps.kill(session.pid);
 }
 async function cancelRecording(command, io, deps, root) {
-    const running = (await listSessions(root)).find((s) => stateOf(s, deps) === "recording");
+    const running = await findRecording(root, await listSessions(root), deps);
     if (!running)
         return refuse(io, command, "not_recording", "No recording is running.");
     await closeRecorder(root, running, deps);
-    await repairWavHeader(audioPath(root, running.id));
+    if (await fileExists(audioPath(root, running.id)))
+        await repairWavHeader(audioPath(root, running.id));
     await writeSession(root, { ...running, endedAt: deps.now().toISOString(), endedBy: "cancel" });
     const bytes = await fileSize(audioPath(root, running.id));
     writeLine(io.stderr, `${TAG} cancelled ${JSON.stringify({ session: running.id, bytes })}`);
-    return say(io, command, `Stopped. Nothing was uploaded and the file is kept (${megabytes(bytes)}): ${audioPath(root, running.id)}\nFinish it later with \`cockpit notes record stop ${running.id}\`.`, { session: running.id, state: "cancelled", file: audioPath(root, running.id), bytes });
+    return say(io, command, `Stopped. Nothing was uploaded yet and the file is kept (${megabytes(bytes)}): ${audioPath(root, running.id)}\nThe BLI Notetaker app uploads it by itself; or run \`cockpit notes record stop ${running.id}\`.`, { session: running.id, state: "cancelled", file: audioPath(root, running.id), bytes });
+}
+/**
+ * Why a session's audio cannot be sent, or null when it can. Records the reason on the session, so `status`
+ * stops listing it and nothing (the app's timer included) retries it forever. The file is never deleted.
+ */
+async function unsendable(root, session, deps) {
+    const audio = audioPath(root, session.id);
+    let reason = null;
+    if (!(await fileExists(audio)))
+        reason = "no_file";
+    else {
+        const repaired = await repairWavHeader(audio);
+        if (!repaired.ok)
+            reason = repaired.reason;
+    }
+    if (reason)
+        await writeSession(root, { ...session, nothingToUpload: { at: deps.now().toISOString(), reason } });
+    return reason;
+}
+/**
+ * The file handed to the uploader: `meeting-<stamp>.wav`, a hard link to `audio.wav` (the same bytes, so the
+ * note is named after the meeting's time rather than "audio"). Whatever sat at that name is removed first
+ * (CLIs before BLI-23382 wrote a trimmed copy there). If this disk cannot link, `audio.wav` itself is sent.
+ */
+async function fileToSend(root, id, io) {
+    const audio = audioPath(root, id);
+    const named = uploadPath(root, id);
+    try {
+        await rm(named, { force: true });
+        await link(audio, named);
+        return named;
+    }
+    catch (error) {
+        writeLine(io.stderr, `${TAG} upload name not linked ${JSON.stringify({ session: id, reason: error.code ?? "link_failed" })}`);
+        return audio;
+    }
 }
 async function stopRecording(command, io, deps, root) {
     const sessions = await listSessions(root);
     const target = command.sessionId
         ? sessions.find((s) => s.id === command.sessionId)
-        : sessions.find((s) => stateOf(s, deps) === "recording");
+        : await findRecording(root, sessions, deps);
     if (!target) {
-        const waiting = sessions.filter((s) => !s.submittedAt);
-        const hint = waiting.length ? ` Recoverable: ${waiting.map((s) => s.id).join(", ")} (\`cockpit notes record stop <id>\`).` : "";
+        const waiting = sessions.filter((s) => !s.submittedAt && !s.nothingToUpload);
+        const hint = waiting.length ? ` Waiting for upload: ${waiting.map((s) => s.id).join(", ")} (\`cockpit notes record stop <id>\`).` : "";
         return refuse(io, command, command.sessionId ? "unknown_session" : "not_recording", command.sessionId ? `No recording called ${command.sessionId}.${hint}` : `No recording is running.${hint}`);
     }
     if (target.submittedAt) {
         return refuse(io, command, "already_submitted", `Recording ${target.id} was already submitted at ${target.submittedAt}.`);
     }
     let session = target;
-    if (stateOf(target, deps) === "recording") {
+    const view = await viewOf(root, target, deps);
+    if (view.state === "recording") {
         await closeRecorder(root, target, deps);
         session = { ...target, endedAt: deps.now().toISOString(), endedBy: "stop" };
         await writeSession(root, session);
     }
     const audio = audioPath(root, session.id);
-    const repaired = await repairWavHeader(audio);
-    if (!repaired.ok) {
-        return refuse(io, command, `audio_${repaired.reason}`, `The recording could not be read (${repaired.reason}). The file is kept at ${audio}; nothing was uploaded.`);
-    }
-    const trimmed = trimmedPath(root, session.id);
-    const result = await trimToSpeech(audio, trimmed);
-    if (!result.ok) {
-        return refuse(io, command, `audio_${result.reason}`, `The recording could not be trimmed (${result.reason}). The file is kept at ${audio}; nothing was uploaded.`);
-    }
-    if (!result.speech) {
-        writeLine(io.stderr, `${TAG} no speech ${JSON.stringify({ session: session.id, total_s: Math.round(result.totalSeconds), speech_s: Number(result.speechSeconds.toFixed(2)) })}`);
-        return say(io, command, `No speech was found in ${clock(result.totalSeconds)} of audio, so nothing was submitted. The recording is kept: ${audio}`, { session: session.id, state: "no_speech", submitted: false, total_seconds: Math.round(result.totalSeconds), file: audio });
+    const reason = await unsendable(root, session, deps);
+    if (reason) {
+        writeLine(io.stderr, `${TAG} nothing to upload ${JSON.stringify({ session: session.id, reason })}`);
+        return refuse(io, command, `audio_${reason}`, `The recording has no audio that can be sent (${reason}). Nothing was uploaded; it will not be tried again. Any file is kept in ${sessionDir(root, session.id)}.`);
     }
-    writeLine(io.stderr, `${TAG} trimmed ${JSON.stringify({ session: session.id, total_s: Math.round(result.totalSeconds), kept_s: Math.round(result.keptSeconds), spans: result.spans, bytes: result.bytes })}`);
-    if (!command.json) {
-        writeLine(io.stderr, `Kept ${clock(result.keptSeconds)} of speech from ${clock(result.totalSeconds)}. Uploading...`);
-    }
-    const code = await deps.upload({ ...command, action: "upload", paths: [trimmed] }, trimmed);
+    const bytes = await fileSize(audio);
+    const sent = await fileToSend(root, session.id, io);
+    writeLine(io.stderr, `${TAG} uploading original ${JSON.stringify({ session: session.id, bytes, seconds: Math.round(audioSeconds(bytes)), ended_reason: view.endedReason })}`);
+    if (!command.json)
+        writeLine(io.stderr, `Uploading the whole recording (${clock(audioSeconds(bytes))}, ${megabytes(bytes)})...`);
+    const code = await deps.upload({ ...command, action: "upload", paths: [sent] }, sent);
     if (code !== 0) {
         writeLine(io.stderr, `${TAG} upload failed ${JSON.stringify({ session: session.id, exit: code })}`);
-        writeLine(io.stderr, `The upload did not finish. Both files are kept; run \`cockpit notes record stop ${session.id}\` to try again.`);
+        writeLine(io.stderr, `The upload did not finish. The recording is kept; the BLI Notetaker app tries again by itself, or run \`cockpit notes record stop ${session.id}\`.`);
         return code;
     }
     await writeSession(root, { ...session, submittedAt: deps.now().toISOString() });
-    writeLine(io.stderr, `${TAG} submitted ${JSON.stringify({ session: session.id, kept_s: Math.round(result.keptSeconds) })}`);
-    writeLine(io.stderr, `The original recording stays on this machine: ${audio}`);
+    writeLine(io.stderr, `${TAG} submitted ${JSON.stringify({ session: session.id, bytes })}`);
+    writeLine(io.stderr, `The recording also stays on this machine: ${audio}`);
     return 0;
 }
+const NOTE = {
+    recording: "recording now",
+    crashed: "the recorder died; the audio so far is kept",
+    cancelled: "cancelled; file kept",
+    stopped: "stopped, not yet uploaded",
+};
 async function recordingStatus(command, io, deps, root) {
-    const sessions = (await listSessions(root)).filter((s) => !s.submittedAt);
+    const sessions = (await listSessions(root)).filter((s) => !s.submittedAt && !s.nothingToUpload);
     const rows = [];
     for (const session of sessions) {
-        const state = stateOf(session, deps);
+        const { state, endedReason } = await viewOf(root, session, deps);
         const bytes = await fileSize(audioPath(root, session.id));
         if (state !== "recording" && bytes === null)
             continue;
         const elapsed = state === "recording" ? (deps.now().getTime() - Date.parse(session.startedAt)) / 1000 : audioSeconds(bytes);
-        rows.push({ session: session.id, state, started_at: session.startedAt, elapsed_seconds: Math.round(elapsed), bytes, file: audioPath(root, session.id) });
+        rows.push({
+            session: session.id, state, needs_upload: state !== "recording", ended_reason: endedReason,
+            started_at: session.startedAt, elapsed_seconds: Math.round(elapsed), bytes, file: audioPath(root, session.id),
+        });
     }
-    writeLine(io.stderr, `${TAG} status ${JSON.stringify({ sessions: rows.length })}`);
+    writeLine(io.stderr, `${TAG} status ${JSON.stringify({ sessions: rows.length, needs_upload: rows.filter((row) => row.needs_upload).length })}`);
     if (command.json)
         return say(io, command, "", { sessions: rows });
     if (rows.length === 0)
-        return say(io, command, "No recording is running and none is waiting to be finished.", {});
+        return say(io, command, "No recording is running and none is waiting for upload.", {});
     const lines = rows.map((row) => {
-        const note = row.state === "recording" ? "recording now"
-            : row.state === "crashed" ? "the recorder died; the audio so far is kept"
-                : row.state === "cancelled" ? "cancelled; file kept" : "stopped, not yet uploaded";
-        const next = row.state === "recording" ? "" : `  finish with: cockpit notes record stop ${row.session}`;
+        const note = row.ended_reason === "max_duration_reached" ? `stopped by itself at ${MAX_RECORDING_SECONDS / 3600} hours, not yet uploaded` : NOTE[row.state];
+        const next = row.needs_upload ? `  waiting for upload (the BLI Notetaker app sends it by itself), or: cockpit notes record stop ${row.session}` : "";
         return `${row.session}  ${row.state}  ${clock(row.elapsed_seconds)}  ${megabytes(row.bytes)}  (${note})${next ? `\n${next}` : ""}`;
     });
     return say(io, command, lines.join("\n"), {});

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.275");
+    writeLine(io?.stdout ?? process.stdout, "0.2.276");
     return 0;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.275",
+  "version": "0.2.276",
   "private": false,
   "type": "module",
   "bin": {