@bli-cockpit/cli 0.2.259 → 0.2.261

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

@@ -0,0 +1,332 @@
+/**
+ * BLI-23208: the Windows recorder itself, `record.ps1` and the C# it compiles. Split from
+ * `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.
+ */
+/**
+ * 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
+ * denied, 4 recorder failed.
+ */
+const RECORDER_CSHARP = String.raw `using System;
+using System.Diagnostics;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+using Microsoft.Win32;
+
+public sealed class BliRecorder
+{
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct WaveFormatEx
+    {
+        public ushort wFormatTag;
+        public ushort nChannels;
+        public uint nSamplesPerSec;
+        public uint nAvgBytesPerSec;
+        public ushort nBlockAlign;
+        public ushort wBitsPerSample;
+        public ushort cbSize;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct WaveHdr
+    {
+        public IntPtr lpData;
+        public uint dwBufferLength;
+        public uint dwBytesRecorded;
+        public IntPtr dwUser;
+        public uint dwFlags;
+        public uint dwLoops;
+        public IntPtr lpNext;
+        public IntPtr reserved;
+    }
+
+    [DllImport("winmm.dll")] static extern uint waveInGetNumDevs();
+    [DllImport("winmm.dll")] static extern uint waveInOpen(out IntPtr hwi, uint deviceId, ref WaveFormatEx fmt, IntPtr callback, IntPtr instance, uint flags);
+    [DllImport("winmm.dll")] static extern uint waveInPrepareHeader(IntPtr hwi, IntPtr hdr, uint size);
+    [DllImport("winmm.dll")] static extern uint waveInUnprepareHeader(IntPtr hwi, IntPtr hdr, uint size);
+    [DllImport("winmm.dll")] static extern uint waveInAddBuffer(IntPtr hwi, IntPtr hdr, uint size);
+    [DllImport("winmm.dll")] static extern uint waveInStart(IntPtr hwi);
+    [DllImport("winmm.dll")] static extern uint waveInReset(IntPtr hwi);
+    [DllImport("winmm.dll")] static extern uint waveInClose(IntPtr hwi);
+
+    const uint WaveMapper = 0xFFFFFFFF;
+    const uint WhdrDone = 1;
+    const int BufferCount = 8;
+    const int BufferBytes = 3200;
+    const string Consent = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\CapabilityAccessManager\\ConsentStore\\microphone";
+
+    readonly string dir;
+    bool ready;
+    long total;
+    int buffers;
+    FileStream file;
+    byte[] scratch = new byte[BufferBytes];
+
+    BliRecorder(string sessionDir) { dir = sessionDir; }
+
+    public static int Run(string sessionDir, string host)
+    {
+        BliRecorder recorder = new BliRecorder(sessionDir);
+        try
+        {
+            recorder.Log("start host=" + host + " pid=" + Process.GetCurrentProcess().Id + " session_id=" + Process.GetCurrentProcess().SessionId);
+            return recorder.Record();
+        }
+        catch (Exception e)
+        {
+            recorder.Log("exception type=" + e.GetType().Name);
+            if (!recorder.ready) recorder.Fail("recorder_failed");
+            return 4;
+        }
+    }
+
+    void Log(string line)
+    {
+        try { File.AppendAllText(Path.Combine(dir, "recorder.log"), DateTime.UtcNow.ToString("o") + " " + line + "\r\n"); }
+        catch (Exception) { /* best effort: a log line that cannot be written must not stop the recording */ }
+    }
+
+    void Fail(string reason)
+    {
+        try { File.WriteAllText(Path.Combine(dir, "failed.txt"), reason); }
+        catch (Exception) { /* the CLI then reports recorder_exited; the Log line below still says why */ }
+        Log("failed reason=" + reason);
+    }
+
+    static string ReadConsent(RegistryHive hive, string subKey)
+    {
+        try
+        {
+            using (RegistryKey root = RegistryKey.OpenBaseKey(hive, RegistryView.Registry64))
+            using (RegistryKey key = root.OpenSubKey(subKey))
+            {
+                if (key == null) return "absent";
+                object value = key.GetValue("Value");
+                return value == null ? "absent" : value.ToString();
+            }
+        }
+        catch (Exception) { return "unreadable"; }
+    }
+
+    static bool Denied(out string summary)
+    {
+        string machine = ReadConsent(RegistryHive.LocalMachine, Consent);
+        string user = ReadConsent(RegistryHive.CurrentUser, Consent);
+        string desktop = ReadConsent(RegistryHive.CurrentUser, Consent + "\\NonPackaged");
+        summary = "machine=" + machine + " user=" + user + " desktop_apps=" + desktop;
+        return IsDeny(machine) || IsDeny(user) || IsDeny(desktop);
+    }
+
+    static bool IsDeny(string value) { return string.Equals(value, "Deny", StringComparison.OrdinalIgnoreCase); }
+
+    static byte[] Header(uint dataBytes)
+    {
+        using (MemoryStream memory = new MemoryStream())
+        using (BinaryWriter writer = new BinaryWriter(memory))
+        {
+            writer.Write(Encoding.ASCII.GetBytes("RIFF"));
+            writer.Write((uint)(36 + dataBytes));
+            writer.Write(Encoding.ASCII.GetBytes("WAVEfmt "));
+            writer.Write((uint)16);
+            writer.Write((ushort)1);
+            writer.Write((ushort)1);
+            writer.Write((uint)16000);
+            writer.Write((uint)32000);
+            writer.Write((ushort)2);
+            writer.Write((ushort)16);
+            writer.Write(Encoding.ASCII.GetBytes("data"));
+            writer.Write(dataBytes);
+            writer.Flush();
+            return memory.ToArray();
+        }
+    }
+
+    void Check(string what, uint rc)
+    {
+        if (rc == 0) return;
+        Log(what + " rc=" + rc);
+        throw new InvalidOperationException(what);
+    }
+
+    void Append(IntPtr hdr, IntPtr data, int bytesOffset)
+    {
+        int got = Marshal.ReadInt32(hdr, bytesOffset);
+        if (got > BufferBytes) got = BufferBytes;
+        if (got <= 0) return;
+        Marshal.Copy(data, scratch, 0, got);
+        file.Write(scratch, 0, got);
+        file.Flush();
+        total += got;
+        buffers++;
+        if (!ready)
+        {
+            File.WriteAllText(Path.Combine(dir, "ready"), "ok");
+            ready = true;
+            Log("ready first_buffer_bytes=" + got);
+        }
+        else if (buffers % 600 == 0)
+        {
+            Log("progress buffers=" + buffers + " bytes=" + total);
+        }
+    }
+
+    int Record()
+    {
+        string summary;
+        bool denied = Denied(out summary);
+        Log("privacy " + summary);
+        if (denied) { Fail("mic_denied"); return 3; }
+
+        uint devices = waveInGetNumDevs();
+        Log("devices=" + devices);
+        if (devices == 0) { Fail("no_microphone"); return 2; }
+
+        WaveFormatEx format = new WaveFormatEx();
+        format.wFormatTag = 1;
+        format.nChannels = 1;
+        format.nSamplesPerSec = 16000;
+        format.nAvgBytesPerSec = 32000;
+        format.nBlockAlign = 2;
+        format.wBitsPerSample = 16;
+        format.cbSize = 0;
+        IntPtr hwi;
+        uint rc = waveInOpen(out hwi, WaveMapper, ref format, IntPtr.Zero, IntPtr.Zero, 0);
+        Log("open rc=" + rc + " format=pcm,1ch,16000hz,16bit");
+        if (rc != 0)
+        {
+            bool none = rc == 2 || rc == 6;
+            Fail(none ? "no_microphone" : "recorder_failed");
+            return none ? 2 : 4;
+        }
+
+        int headerSize = Marshal.SizeOf(typeof(WaveHdr));
+        int flagsOffset = (int)Marshal.OffsetOf(typeof(WaveHdr), "dwFlags");
+        int bytesOffset = (int)Marshal.OffsetOf(typeof(WaveHdr), "dwBytesRecorded");
+        IntPtr[] headers = new IntPtr[BufferCount];
+        IntPtr[] data = new IntPtr[BufferCount];
+        bool[] prepared = new bool[BufferCount];
+        bool started = false;
+        string endedBy = "stop";
+        try
+        {
+            file = new FileStream(Path.Combine(dir, "audio.wav"), FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite, 4096);
+            byte[] head = Header(0);
+            file.Write(head, 0, head.Length);
+            file.Flush();
+
+            for (int i = 0; i < BufferCount; i++)
+            {
+                data[i] = Marshal.AllocHGlobal(BufferBytes);
+                headers[i] = Marshal.AllocHGlobal(headerSize);
+                WaveHdr hdr = new WaveHdr();
+                hdr.lpData = data[i];
+                hdr.dwBufferLength = BufferBytes;
+                Marshal.StructureToPtr(hdr, headers[i], false);
+                Check("prepare", waveInPrepareHeader(hwi, headers[i], (uint)headerSize));
+                prepared[i] = true;
+                Check("addbuffer", waveInAddBuffer(hwi, headers[i], (uint)headerSize));
+            }
+            Check("start", waveInStart(hwi));
+            started = true;
+            Log("recording buffers=" + BufferCount + " buffer_bytes=" + BufferBytes);
+
+            string stopPath = Path.Combine(dir, "stop");
+            Stopwatch clock = Stopwatch.StartNew();
+            long lastPrivacy = 0;
+            int next = 0;
+            while (true)
+            {
+                if (File.Exists(stopPath)) break;
+                if (clock.ElapsedMilliseconds - lastPrivacy >= 1000)
+                {
+                    lastPrivacy = clock.ElapsedMilliseconds;
+                    string now;
+                    if (Denied(out now)) { Log("privacy " + now); endedBy = "mic_denied"; break; }
+                }
+                uint flags = (uint)Marshal.ReadInt32(headers[next], flagsOffset);
+                if ((flags & WhdrDone) == 0) { Thread.Sleep(10); continue; }
+                Append(headers[next], data[next], bytesOffset);
+                Check("addbuffer", waveInAddBuffer(hwi, headers[next], (uint)headerSize));
+                next = (next + 1) % BufferCount;
+            }
+
+            // Reset hands every queued buffer back (the oldest partly filled): keep what they hold, oldest first.
+            waveInReset(hwi);
+            started = false;
+            for (int i = 0; i < BufferCount; i++)
+            {
+                int index = (next + i) % BufferCount;
+                uint flags = (uint)Marshal.ReadInt32(headers[index], flagsOffset);
+                if ((flags & WhdrDone) != 0) Append(headers[index], data[index], bytesOffset);
+            }
+        }
+        finally
+        {
+            if (started) waveInReset(hwi);
+            for (int i = 0; i < BufferCount; i++)
+            {
+                if (prepared[i]) waveInUnprepareHeader(hwi, headers[i], (uint)headerSize);
+                if (headers[i] != IntPtr.Zero) Marshal.FreeHGlobal(headers[i]);
+                if (data[i] != IntPtr.Zero) Marshal.FreeHGlobal(data[i]);
+            }
+            waveInClose(hwi);
+            if (file != null)
+            {
+                try
+                {
+                    uint size = total > 0xFFFFFFFFL - 36 ? 0xFFFFFFFFu - 36 : (uint)total;
+                    file.Seek(0, SeekOrigin.Begin);
+                    byte[] sized = Header(size);
+                    file.Write(sized, 0, sized.Length);
+                    file.Flush();
+                }
+                catch (Exception e) { Log("size_rewrite_failed type=" + e.GetType().Name); }
+                file.Close();
+            }
+        }
+
+        Log("closed ended_by=" + endedBy + " buffers=" + buffers + " bytes=" + total);
+        if (endedBy == "mic_denied") { Fail("mic_denied"); return 3; }
+        File.WriteAllText(Path.Combine(dir, "done"), "ok");
+        return 0;
+    }
+}
+`;
+/**
+ * The recorder script, `record.ps1`. PURE ASCII (asserted by a test): Windows
+ * PowerShell 5.1 reads a BOM-less file as ANSI. `$args[0]` is the session
+ * directory. Reasons it writes to `failed.txt`: mic_denied, no_microphone,
+ * recorder_failed. Everything is written through [IO.File], never Out-File.
+ */
+export const RECORDER_SCRIPT_WIN32 = `param([Parameter(Position = 0)][string]$Dir)
+$ErrorActionPreference = 'Stop'
+if (-not $Dir) { exit 4 }
+$source = @'
+${RECORDER_CSHARP.replace(/\r?\n$/u, "")}
+'@
+function Write-RecorderLog([string]$Line) {
+  try { [IO.File]::AppendAllText((Join-Path $Dir 'recorder.log'), $Line + [Environment]::NewLine) } catch { <# best effort: a log line that cannot be written must not stop the recorder #> }
+}
+try {
+  Add-Type -TypeDefinition $source -Language CSharp
+} catch {
+  Write-RecorderLog ('add_type_failed type=' + $_.Exception.GetType().Name)
+  try { [IO.File]::WriteAllText((Join-Path $Dir 'failed.txt'), 'recorder_failed') } catch { <# nothing else to tell: the CLI then reports recorder_exited, and recorder.log says why #> }
+  exit 4
+}
+$code = 4
+try {
+  $code = [BliRecorder]::Run($Dir, ('powershell-' + $PSVersionTable.PSVersion.ToString()))
+} catch {
+  Write-RecorderLog ('run_exception type=' + $_.Exception.GetType().Name)
+  if (-not [IO.File]::Exists((Join-Path $Dir 'ready'))) {
+    try { [IO.File]::WriteAllText((Join-Path $Dir 'failed.txt'), 'recorder_failed') } catch { <# nothing else to tell: the CLI then reports recorder_exited, and recorder.log says why #> }
+  }
+}
+exit $code
+`.replace(/\r?\n/gu, "\r\n");

package/dist/commands/notes-record.js

@@ -14,10 +14,14 @@
  *
  * 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).
+ * 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.
  *
- * Capture is `notes-record-capture.ts`; the speech trim is `notes-record-wav.ts`.
+ * Capture is `notes-record-capture.ts` (macOS) and
+ * `notes-record-capture-win32.ts` (Windows); the speech trim is `notes-record-wav.ts`.
  */
+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";
@@ -31,7 +35,7 @@ export function defaultRecordDeps(io, upload) {
         platform: process.platform,
         now: () => new Date(),
         sleep: io.sleep ?? ((ms) => delay(ms)),
-        launch: launchRecorder,
+        launch: (dir) => launchRecorder(dir, process.platform),
         alive: processAlive,
         kill: (pid) => { try {
             process.kill(pid, "SIGTERM");
@@ -45,12 +49,19 @@ const stateOf = (session, deps) => {
         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.",
-};
+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. */
+function refusalSentence(platform, reason) {
+    switch (reason) {
+        case "mic_denied": return platform === "win32" ? MIC_DENIED_WIN32 : MIC_DENIED_DARWIN;
+        case "mic_permission_unanswered": return "macOS asked for microphone access and nobody answered. Run `cockpit notes record start` again and choose Allow.";
+        case "no_microphone": return "No microphone was found. Connect or enable a microphone, then run `cockpit notes record start` again.";
+        case "recorder_failed": return "The recorder could not open the microphone. Check that a microphone is connected and not in use, then try again.";
+        default: return "The recorder stopped before it started.";
+    }
+}
+const RECORDER_NAME = { darwin: "macOS recorder (osascript)", win32: "Windows recorder (PowerShell)" };
 function say(io, command, human, json, ok = true) {
     writeLine(io.stdout, command.json ? JSON.stringify({ ok, ...json }) : human);
     return ok ? 0 : 1;
@@ -74,9 +85,8 @@ const megabytes = (bytes) => (bytes === null ? "no file yet" : `${(bytes / 1_000
 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.`);
+    if (deps.platform !== "darwin" && deps.platform !== "win32") {
+        return refuse(io, command, "platform_not_supported", `Recording a meeting is not supported on ${deps.platform}. It works on Apple Silicon Macs and on Windows.`);
     }
     const root = recordingsRoot(command.homeDir);
     switch (verb) {
@@ -93,10 +103,10 @@ async function startRecording(command, io, deps, root) {
         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 dir = await prepareSessionDir(root, id, deps.platform);
     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.");
+        return refuse(io, command, "recorder_not_launched", `Could not start the ${RECORDER_NAME[deps.platform] ?? "recorder"}. Nothing was recorded.`);
     }
     const session = { id, startedAt: deps.now().toISOString(), pid };
     await writeSession(root, session);
@@ -106,7 +116,7 @@ async function startRecording(command, io, deps, root) {
         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.");
+            return refuse(io, command, failed, refusalSentence(deps.platform, failed));
         }
         if (await fileExists(`${sessionDir(root, id)}/ready`)) {
             writeLine(io.stderr, `${TAG} recording ${JSON.stringify({ session: id, reason: "mic_open" })}`);
@@ -114,7 +124,8 @@ async function startRecording(command, io, deps, root) {
         }
         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.");
+            const log = deps.platform === "win32" ? ` Details: ${path.join(sessionDir(root, id), "recorder.log")}` : "";
+            return refuse(io, command, "recorder_exited", `The recorder exited before the microphone opened. Nothing was recorded.${log}`);
         }
         await deps.sleep(POLL_MS);
     }

package/dist/commands/notes.js

@@ -37,7 +37,7 @@
  *    (it runs on a shared server-side key, not a `notes_accounts` row), read
  *    off its `granola_sync_runs` ledger.
  *  - `notes-app.ts` — BLI-23207: `app install|uninstall|status`, the BLI
- *    Notetaker menu-bar app on this Mac (its LaunchAgent: `notes-app-plist.ts`).
+ *    Notetaker app on this Mac or Windows PC (Mac LaunchAgent: `notes-app-plist.ts`; Windows: `notes-app-windows.ts`).
  *  - `notes-transcription-stats.ts` — BLI-18003: what meeting transcription
  *    cost and did per provider for a month, and the spend against the cap.
  *
@@ -105,10 +105,12 @@ export async function runNotes(command, io) {
             });
         }));
     }
-    // BLI-23207: the menu-bar app is installed on this Mac; only install and status ask Tower (for the newest release).
+    // BLI-23207/23208: the menu-bar / notification-area app is installed on this Mac or Windows PC; only install and status ask Tower (for the newest release).
     if (command.action === "app") {
         return runNotesApp(command, io, {
             platform: process.platform,
+            arch: process.arch,
+            env: io.env,
             homeDir: command.homeDir ?? os.homedir(),
             uid: process.getuid?.() ?? 0,
             exec: io.exec ?? defaultExec(),

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.259",
+  "version": "0.2.261",
   "private": false,
   "type": "module",
   "bin": {
@@ -28,7 +28,7 @@
   },
   "dependencies": {
     "@bli-cockpit/memory-mcp": "0.1.77",
-    "@bli-cockpit/mcp": "0.1.159",
+    "@bli-cockpit/mcp": "0.1.160",
     "@bli-cockpit/telemetry-core": "0.1.84"
   },
   "repository": {