@bli-cockpit/cli 0.2.254 → 0.2.256

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

@@ -0,0 +1,152 @@
+/**
+ * BLI-22979: the microphone half of `cockpit notes record` (Apple Silicon macOS).
+ *
+ * Capture mechanism: `osascript -l JavaScript` driving AVFoundation's
+ * AVAudioRecorder. Why this one: `osascript` ships with every Mac, so nothing
+ * is downloaded, signed, notarized or copied as a binary into the npm package
+ * (the packed-CLI copier reads files as UTF-8 and would corrupt one); the
+ * microphone permission prompt is the normal macOS one, shown for the terminal
+ * the person ran `record start` in; and AVAudioRecorder writes linear PCM
+ * straight to disk as it records, so a killed session leaves audio on disk
+ * (`repairWavHeader` fixes the size fields). A native helper would be the
+ * heavier path and is the follow-up if this ever proves flaky.
+ *
+ * The recorder runs as a detached process that outlives `record start`. It is
+ * stopped by a marker file (`stop`) it polls for, not by a signal, so it
+ * 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.
+ *
+ * Everything in a session lives in one directory under the collector's state
+ * dir. Nothing here touches the network.
+ */
+import { spawn } from "node:child_process";
+import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { randomBytes } from "node:crypto";
+import { getCollectorRuntimePaths } from "../local-state-paths.js";
+export const RECORDING_SAMPLE_RATE = 16_000;
+/** 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');
+ObjC.import('stdlib');
+function writeText(file, text) {
+  $.NSString.alloc.initWithUTF8String(text).writeToFileAtomicallyEncodingError(file, true, $.NSUTF8StringEncoding, null);
+}
+function exists(file) { return $.NSFileManager.defaultManager.fileExistsAtPath(file); }
+function tick(seconds) { $.NSRunLoop.currentRunLoop.runUntilDate($.NSDate.dateWithTimeIntervalSinceNow(seconds)); }
+function run(argv) {
+  var dir = argv[0];
+  var auth = $.AVCaptureDevice.authorizationStatusForMediaType('soun');
+  if (auth === 1 || auth === 2) { writeText(dir + '/failed.txt', 'mic_denied'); $.exit(3); }
+  var settings = $.NSDictionary.dictionaryWithObjectsForKeys(
+    $([1819304813, ${RECORDING_SAMPLE_RATE}, 1, 16, 0, 0]),
+    $(['AVFormatIDKey', 'AVSampleRateKey', 'AVNumberOfChannelsKey', 'AVLinearPCMBitDepthKey', 'AVLinearPCMIsFloatKey', 'AVLinearPCMIsBigEndianKey']));
+  var recorder = $.AVAudioRecorder.alloc.initWithURLSettingsError($.NSURL.fileURLWithPath(dir + '/audio.wav'), settings, null);
+  if (!recorder || !recorder.prepareToRecord || !recorder.record) { writeText(dir + '/failed.txt', 'recorder_failed'); $.exit(4); }
+  var announced = false;
+  var waited = 0;
+  while (!exists(dir + '/stop')) {
+    tick(0.2);
+    waited += 0.2;
+    var now = $.AVCaptureDevice.authorizationStatusForMediaType('soun');
+    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); }
+  }
+  recorder.stop;
+  writeText(dir + '/done', 'ok');
+  $.exit(0);
+}
+`;
+export function recordingsRoot(homeDir) {
+    return path.join(getCollectorRuntimePaths(homeDir).state_dir, "notes-recordings");
+}
+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`);
+export function newSessionId(now) {
+    const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\..*$/, "").replace("T", "-");
+    return `${stamp}-${randomBytes(2).toString("hex")}`;
+}
+export async function writeSession(root, session) {
+    await writeFile(path.join(root, session.id, "session.json"), `${JSON.stringify(session)}\n`, { mode: 0o600 });
+}
+export async function readSession(root, id) {
+    try {
+        const parsed = JSON.parse(await readFile(path.join(root, id, "session.json"), "utf8"));
+        return typeof parsed.id === "string" && typeof parsed.startedAt === "string" && typeof parsed.pid === "number" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Every session on disk, newest first. */
+export async function listSessions(root) {
+    let names;
+    try {
+        names = await readdir(root);
+    }
+    catch {
+        return [];
+    }
+    const sessions = [];
+    for (const name of names) {
+        const session = await readSession(root, name);
+        if (session)
+            sessions.push(session);
+    }
+    return sessions.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+}
+export async function fileSize(file) {
+    try {
+        return (await stat(file)).size;
+    }
+    catch {
+        return null;
+    }
+}
+export async function fileExists(file) {
+    return (await fileSize(file)) !== null;
+}
+export async function readReason(root, id) {
+    try {
+        return (await readFile(path.join(root, id, "failed.txt"), "utf8")).trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function requestStop(root, id) {
+    await writeFile(path.join(root, id, "stop"), "stop\n", { mode: 0o600 });
+}
+/** Start the detached recorder in `dir`. Returns its pid, or null when it could not be launched. */
+export function launchRecorder(dir) {
+    try {
+        const child = spawn("/usr/bin/osascript", ["-l", "JavaScript", path.join(dir, "record.js"), dir], {
+            windowsHide: true,
+            detached: true,
+            stdio: "ignore",
+        });
+        child.on("error", () => undefined);
+        child.unref();
+        return child.pid ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+export async function prepareSessionDir(root, id) {
+    const dir = sessionDir(root, id);
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    await writeFile(path.join(dir, "record.js"), RECORDER_SCRIPT, { mode: 0o600 });
+    return dir;
+}

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

@@ -0,0 +1,244 @@
+/**
+ * BLI-22979: the WAV file `cockpit notes record` writes, and the speech trim
+ * that runs on it when a recording stops.
+ *
+ * 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.
+ */
+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");
+    try {
+        const { size } = await handle.stat();
+        const head = Buffer.alloc(Math.min(HEADER_SCAN_BYTES, size));
+        await handle.read(head, 0, head.length, 0);
+        if (head.length < 12 || head.toString("ascii", 0, 4) !== "RIFF" || head.toString("ascii", 8, 12) !== "WAVE") {
+            return { ok: false, reason: "not_wav" };
+        }
+        let offset = 12;
+        let fmt = null;
+        while (offset + 8 <= head.length) {
+            const id = head.toString("ascii", offset, offset + 4);
+            const chunkSize = head.readUInt32LE(offset + 4);
+            if (id === "fmt " && offset + 24 <= head.length) {
+                fmt = {
+                    format: head.readUInt16LE(offset + 8),
+                    channels: head.readUInt16LE(offset + 10),
+                    sampleRate: head.readUInt32LE(offset + 12),
+                    bitsPerSample: head.readUInt16LE(offset + 22),
+                };
+            }
+            if (id === "data") {
+                if (!fmt)
+                    return { ok: false, reason: "not_wav" };
+                if ((fmt.format !== 1 && fmt.format !== 0xfffe) || fmt.bitsPerSample !== 16)
+                    return { ok: false, reason: "not_pcm16" };
+                const dataOffset = offset + 8;
+                const dataBytes = Math.max(0, size - dataOffset);
+                if (dataBytes < 2)
+                    return { ok: false, reason: "no_data" };
+                return {
+                    ok: true,
+                    info: { sampleRate: fmt.sampleRate, channels: fmt.channels, bitsPerSample: 16, dataOffset, dataBytes, dataSizeFieldOffset: offset + 4 },
+                };
+            }
+            offset += 8 + chunkSize + (chunkSize % 2);
+        }
+        return { ok: false, reason: "not_wav" };
+    }
+    finally {
+        await handle.close();
+    }
+}
+/** Rewrite the RIFF and data sizes from the real file length. Idempotent. */
+export async function repairWavHeader(filePath) {
+    const read = await readWavInfo(filePath);
+    if (!read.ok)
+        return read;
+    const { size } = await stat(filePath);
+    const handle = await open(filePath, "r+");
+    try {
+        const riff = Buffer.alloc(4);
+        riff.writeUInt32LE(Math.min(size - 8, 0xffffffff));
+        await handle.write(riff, 0, 4, 4);
+        const data = Buffer.alloc(4);
+        // Whole sample frames only, so a torn last write does not leave half a sample.
+        const frameBytes = (read.info.bitsPerSample / 8) * read.info.channels;
+        const usable = read.info.dataBytes - (read.info.dataBytes % frameBytes);
+        data.writeUInt32LE(Math.min(usable, 0xffffffff));
+        await handle.write(data, 0, 4, read.info.dataSizeFieldOffset);
+    }
+    finally {
+        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.js

@@ -0,0 +1,214 @@
+/**
+ * `cockpit notes record start | stop | status | cancel` (BLI-22979): record a
+ * meeting in a room from this machine's microphone and turn it into a Tower
+ * 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.
+ *
+ * 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
+ * only for now: Windows says so by name (a follow-up ticket adds it).
+ *
+ * Capture is `notes-record-capture.ts`; the speech trim is `notes-record-wav.ts`.
+ */
+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";
+const TAG = "[notes record]";
+const READY_DEADLINE_MS = 150_000;
+const STOP_DEADLINE_MS = 10_000;
+const POLL_MS = 250;
+export function defaultRecordDeps(io, upload) {
+    return {
+        platform: process.platform,
+        now: () => new Date(),
+        sleep: io.sleep ?? ((ms) => delay(ms)),
+        launch: launchRecorder,
+        alive: processAlive,
+        kill: (pid) => { try {
+            process.kill(pid, "SIGTERM");
+        }
+        catch { /* already gone */ } },
+        upload,
+    };
+}
+const stateOf = (session, deps) => {
+    if (!session.endedAt)
+        return deps.alive(session.pid) ? "recording" : "crashed";
+    return session.endedBy === "cancel" ? "cancelled" : "stopped";
+};
+const MIC_DENIED = "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 REFUSALS = {
+    mic_denied: MIC_DENIED,
+    mic_permission_unanswered: "macOS asked for microphone access and nobody answered. Run `cockpit notes record start` again and choose Allow.",
+    recorder_failed: "The recorder could not open the microphone. Check that a microphone is connected and not in use, then try again.",
+};
+function say(io, command, human, json, ok = true) {
+    writeLine(io.stdout, command.json ? JSON.stringify({ ok, ...json }) : human);
+    return ok ? 0 : 1;
+}
+function refuse(io, command, reason, sentence) {
+    writeLine(io.stderr, `${TAG} refused ${JSON.stringify({ reason })}`);
+    if (command.json)
+        writeLine(io.stdout, JSON.stringify({ ok: false, reason, detail: sentence }));
+    else
+        writeLine(io.stderr, sentence);
+    return 1;
+}
+const clock = (seconds) => {
+    const s = Math.max(0, Math.round(seconds));
+    const h = Math.floor(s / 3600);
+    const m = Math.floor((s % 3600) / 60);
+    return `${h > 0 ? `${h}:${String(m).padStart(2, "0")}` : String(m)}:${String(s % 60).padStart(2, "0")}`;
+};
+const megabytes = (bytes) => (bytes === null ? "no file yet" : `${(bytes / 1_000_000).toFixed(1)} MB`);
+/** Seconds of 16 kHz mono 16-bit audio in a file of `bytes` (header included, close enough for a status line). */
+const audioSeconds = (bytes) => (bytes === null ? 0 : Math.max(0, bytes - 44) / (RECORDING_SAMPLE_RATE * 2));
+export async function runNotesRecord(command, io, deps) {
+    const verb = command.recordAction ?? "status";
+    if (deps.platform !== "darwin") {
+        const where = deps.platform === "win32" ? "Windows" : deps.platform;
+        return refuse(io, command, "platform_not_supported", `Recording a meeting is not supported yet on ${where}. It works on Apple Silicon Macs today; Windows is a follow-up.`);
+    }
+    const root = recordingsRoot(command.homeDir);
+    switch (verb) {
+        case "start": return await startRecording(command, io, deps, root);
+        case "stop": return await stopRecording(command, io, deps, root);
+        case "cancel": return await cancelRecording(command, io, deps, root);
+        default: return await recordingStatus(command, io, deps, root);
+    }
+}
+async function startRecording(command, io, deps, root) {
+    const sessions = await listSessions(root);
+    const running = sessions.find((s) => stateOf(s, deps) === "recording");
+    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.`);
+    }
+    const id = newSessionId(deps.now());
+    const dir = await prepareSessionDir(root, id);
+    const pid = deps.launch(dir);
+    if (pid === null) {
+        return refuse(io, command, "recorder_not_launched", "Could not start the macOS recorder (osascript). Nothing was recorded.");
+    }
+    const session = { id, startedAt: deps.now().toISOString(), pid };
+    await writeSession(root, session);
+    writeLine(io.stderr, `${TAG} launched ${JSON.stringify({ session: id, pid })}`);
+    // Wait until the microphone is really open (the person may be answering the macOS prompt) or the recorder says why not.
+    for (let waited = 0; waited < READY_DEADLINE_MS; waited += POLL_MS) {
+        const failed = await readReason(root, id);
+        if (failed) {
+            await writeSession(root, { ...session, endedAt: deps.now().toISOString(), endedBy: "cancel" });
+            return refuse(io, command, failed, REFUSALS[failed] ?? "The recorder stopped before it started.");
+        }
+        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) });
+        }
+        if (!deps.alive(pid)) {
+            await writeSession(root, { ...session, endedAt: deps.now().toISOString(), endedBy: "cancel" });
+            return refuse(io, command, "recorder_exited", "The recorder exited before the microphone opened. Nothing was recorded.");
+        }
+        await deps.sleep(POLL_MS);
+    }
+    return refuse(io, command, "recorder_not_ready", `The recorder is running but the microphone did not open within ${READY_DEADLINE_MS / 1000} seconds. Run \`cockpit notes record cancel\` and try again.`);
+}
+/** Ask the recorder to close its file and wait for it; kill it only if it will not. */
+async function closeRecorder(root, session, deps) {
+    await requestStop(root, session.id);
+    for (let waited = 0; waited < STOP_DEADLINE_MS && deps.alive(session.pid); waited += POLL_MS)
+        await deps.sleep(POLL_MS);
+    if (deps.alive(session.pid))
+        deps.kill(session.pid);
+}
+async function cancelRecording(command, io, deps, root) {
+    const running = (await listSessions(root)).find((s) => stateOf(s, deps) === "recording");
+    if (!running)
+        return refuse(io, command, "not_recording", "No recording is running.");
+    await closeRecorder(root, running, deps);
+    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 });
+}
+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");
+    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>\`).` : "";
+        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") {
+        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 });
+    }
+    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);
+    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.`);
+        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}`);
+    return 0;
+}
+async function recordingStatus(command, io, deps, root) {
+    const sessions = (await listSessions(root)).filter((s) => !s.submittedAt);
+    const rows = [];
+    for (const session of sessions) {
+        const state = stateOf(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) });
+    }
+    writeLine(io.stderr, `${TAG} status ${JSON.stringify({ sessions: rows.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.", {});
+    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}`;
+        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/notes.js

@@ -50,6 +50,7 @@ import { showBotUpcoming } from "./notes-bot-upcoming.js";
 import { showGranolaStatus } from "./notes-granola-status.js";
 import { showTranscriptionStats } from "./notes-transcription-stats.js";
 import { listRecordings, showRecording } from "./notes-recordings.js";
+import { defaultRecordDeps, runNotesRecord } from "./notes-record.js";
 export { listNotes, listShelves, showNote, showShelf } from "./notes-reads.js";
 export { uploadNotes, pasteNote, shareNote, summarizeNote, moveNote, placeNote } from "./notes-writes.js";
 export { armNotesWebhook, connectNotetaker, detachNotetaker, listNotesAccounts, showNotesWebhook, syncNotetaker, syncStatusNotetakers, } from "./notes-accounts.js";
@@ -90,6 +91,15 @@ const NOTES_VERBS = {
     "transcription-stats": showTranscriptionStats,
 };
 export async function runNotes(command, io) {
+    // BLI-22979: recording is local until `stop` uploads, so only the upload needs the paired session.
+    if (command.action === "record") {
+        return runNotesRecord(command, io, defaultRecordDeps(io, async (uploadCommand) => {
+            const session = await loadPairedSession("notes", command.homeDir);
+            return uploadNotes(uploadCommand, {
+                dashboardUrl: command.dashboardUrl ?? session.dashboard_url, deviceToken: session.device_token, io, json: command.json,
+            });
+        }));
+    }
     const session = await loadPairedSession("notes", command.homeDir);
     const door = {
         dashboardUrl: command.dashboardUrl ?? session.dashboard_url,

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