@bli-cockpit/cli 0.2.259 → 0.2.261

package/dist/commands/notes-app.js

@@ -15,50 +15,30 @@
  *   status     what is installed, whether it is running, and whether a newer
  *              release exists.
  *
- * Apple Silicon macOS only; Windows and Linux are refused by name. The app is
- * a shell over `cockpit notes record`; it captures nothing itself. Its layout
- * and LaunchAgent are `notes-app-plist.ts`.
+ * Apple Silicon macOS and 64-bit Windows (BLI-23208); Linux and Windows on Arm are
+ * refused by name. The app is a shell over `cockpit notes record`; it captures
+ * nothing itself. The Mac layout and LaunchAgent are `notes-app-plist.ts`; the
+ * Windows half (Run key instead of a LaunchAgent) is `notes-app-windows.ts`;
+ * what both share (deps, release question, checked download) is
+ * `notes-app-shared.ts`.
  */
-import { createHash, randomBytes } from "node:crypto";
-import { createWriteStream } from "node:fs";
-import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { randomBytes } from "node:crypto";
+import { mkdir, rename, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { Readable, Transform } from "node:stream";
-import { pipeline } from "node:stream/promises";
 import { launchdUserDomain, reregisterDarwinAgent } from "../autostart-darwin.js";
 import { writeLine } from "./cli-io.js";
-import { ask } from "./notes-door.js";
 import { NOTETAKER_APP_EXECUTABLE, NOTETAKER_APP_LABEL, NOTETAKER_APP_NAME, notetakerAppPaths, renderNotetakerAppPlist, } from "./notes-app-plist.js";
-const TAG = "[notes app]";
-const RELEASE_DEADLINE_MS = 30_000;
-const DOWNLOAD_DEADLINE_MS = 10 * 60_000;
-function say(io, command, human, json) {
-    writeLine(io.stdout, command.json ? JSON.stringify({ ok: true, ...json }) : human);
-    return 0;
-}
-function refuse(io, command, reason, sentence, fields = {}) {
-    writeLine(io.stderr, `${TAG} refused ${JSON.stringify({ reason, ...fields })}`);
-    if (command.json)
-        writeLine(io.stdout, JSON.stringify({ ok: false, reason, detail: sentence }));
-    else
-        writeLine(io.stderr, sentence);
-    return 1;
-}
-const exists = async (file) => stat(file).then(() => true, () => false);
-async function readReceipt(file) {
-    try {
-        const parsed = JSON.parse(await readFile(file, "utf8"));
-        return typeof parsed.tag === "string" && typeof parsed.version === "string" ? parsed : null;
-    }
-    catch {
-        return null;
-    }
-}
+import { TAG, downloadToFile, exists, newestRelease, readReceipt, refuse, say, } from "./notes-app-shared.js";
+import { runNotesAppWindows } from "./notes-app-windows.js";
+export { downloadToFile };
+const MAC = "darwin-arm64";
 export async function runNotesApp(command, io, deps) {
     const verb = command.appAction ?? "status";
+    if (deps.platform === "win32" && (deps.arch ?? "x64") === "x64")
+        return await runNotesAppWindows(command, io, deps);
     if (deps.platform !== "darwin") {
-        const where = deps.platform === "win32" ? "Windows" : deps.platform === "linux" ? "Linux" : deps.platform;
-        return refuse(io, command, "platform_not_supported", `The BLI Notetaker app is not available on ${where} yet. It runs in the menu bar on Apple Silicon Macs; Windows is a follow-up. \`cockpit notes record\` is the terminal way to record.`, { platform: deps.platform });
+        const where = deps.platform === "win32" ? `Windows on ${deps.arch ?? "this processor"}` : deps.platform === "linux" ? "Linux" : deps.platform;
+        return refuse(io, command, "platform_not_supported", `The BLI Notetaker app is not available on ${where} yet. It runs in the menu bar on Apple Silicon Macs and in the notification area on 64-bit (x64) Windows. \`cockpit notes record\` is the terminal way to record.`, { platform: deps.platform, arch: deps.arch ?? null });
     }
     const paths = notetakerAppPaths(deps.homeDir);
     if (verb === "uninstall")
@@ -67,49 +47,6 @@ export async function runNotesApp(command, io, deps) {
         return await install(command, io, deps, paths);
     return await status(command, io, deps, paths);
 }
-/** Ask the paired Tower for the newest release; a refusal comes back as reason + sentence. */
-async function newestRelease(deps) {
-    const door = await deps.door();
-    if (!("deviceToken" in door))
-        return { ok: false, reason: door.reason, detail: door.detail };
-    const answer = await ask(door, { path: "/api/notes/app/release", method: "GET", label: "notes app release", timeoutMs: RELEASE_DEADLINE_MS });
-    if (!answer.ok)
-        return answer;
-    const body = answer.body;
-    const sha = typeof body.sha256 === "string" ? body.sha256.toLowerCase() : "";
-    if (!body.tag || !body.version || !/^[0-9a-f]{64}$/.test(sha) || !body.zip?.url?.startsWith("https://")) {
-        return { ok: false, reason: "release_answer_unreadable", detail: "Tower answered without a release this command can install." };
-    }
-    return { ok: true, release: { tag: body.tag, version: body.version, sha256: sha, zip: body.zip }, door };
-}
-/** Stream `url` to `dest`, hashing as it goes. No credential is sent: the link is GitHub's own signed one. */
-export async function downloadToFile(fetchImpl, url, dest) {
-    let response;
-    try {
-        response = await fetchImpl(url, { signal: AbortSignal.timeout(DOWNLOAD_DEADLINE_MS) });
-    }
-    catch {
-        return { ok: false, reason: "download_unreachable" };
-    }
-    if (!response.ok || !response.body)
-        return { ok: false, reason: `download_http_${response.status}` };
-    const hash = createHash("sha256");
-    let bytes = 0;
-    const meter = new Transform({
-        transform(chunk, _encoding, done) {
-            hash.update(chunk);
-            bytes += chunk.length;
-            done(null, chunk);
-        },
-    });
-    try {
-        await pipeline(Readable.fromWeb(response.body), meter, createWriteStream(dest, { mode: 0o600 }));
-    }
-    catch {
-        return { ok: false, reason: "download_interrupted" };
-    }
-    return { ok: true, bytes, sha256: hash.digest("hex") };
-}
 async function appleSilicon(deps) {
     const answer = await deps.exec("sysctl", ["-n", "hw.optional.arm64"]).catch(() => ({ code: 1, stdout: "", stderr: "" }));
     return answer.code === 0 && answer.stdout.trim() === "1";
@@ -118,7 +55,7 @@ async function install(command, io, deps, paths) {
     if (!(await appleSilicon(deps))) {
         return refuse(io, command, "apple_silicon_only", "The BLI Notetaker app is built for Apple Silicon Macs (M1 and later); this Mac is not one. `cockpit notes record` works here from a terminal.");
     }
-    const found = await newestRelease(deps);
+    const found = await newestRelease(deps, MAC);
     if (!found.ok)
         return refuse(io, command, found.reason, found.detail);
     const { release, door } = found;
@@ -200,7 +137,7 @@ async function status(command, io, deps, paths) {
     const running = loaded && /\bstate = running\b/.test(printed.stdout);
     const pid = Number(/\bpid = (\d+)/.exec(printed.stdout)?.[1] ?? NaN);
     // The newest release is best effort: a status line without it is still an answer.
-    const newest = await newestRelease(deps);
+    const newest = await newestRelease(deps, MAC);
     const newestTag = newest.ok ? newest.release.tag : null;
     const update = Boolean(installed && newestTag && receipt?.tag !== newestTag);
     writeLine(io.stderr, `${TAG} status ${JSON.stringify({ installed, tag: receipt?.tag ?? null, plist, loaded, running, newest: newestTag, newest_reason: newest.ok ? null : newest.reason })}`);

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

@@ -0,0 +1,170 @@
+/**
+ * BLI-23208: the Windows microphone half of `cockpit notes record`.
+ *
+ * Capture mechanism: `record.ps1` in the session directory, run by Windows
+ * PowerShell 5.1, which `Add-Type`s a small C# class that records through the
+ * legacy winmm `waveIn` API (16 kHz, mono, 16-bit PCM, `WAVE_MAPPER`). Why this
+ * one: nothing is downloaded or shipped as a binary (the npm package copier
+ * reads files as UTF-8), `winmm.dll` and the .NET C# compiler ship with every
+ * Windows, and `waveIn` hands us raw buffers, so WE decide when bytes reach the
+ * disk. WinRT `MediaCapture` was rejected: PowerShell 7 has no WinRT projection
+ * and the Media Foundation sink only guarantees a readable file when it is
+ * finalized, which a killed recorder never does.
+ *
+ * Crash safety is the contract `repairWavHeader` relies on: the recorder writes
+ * a 44-byte header with the size fields at 36 / 0, then appends and flushes
+ * every completed 100 ms buffer. A `TerminateProcess` leaves header plus audio
+ * up to the last ~100 ms; a clean stop rewrites the real sizes.
+ *
+ * Same session contract as macOS (`notes-record-capture.ts`): `audio.wav`,
+ * `ready` (after the first buffer really arrived), a `stop` marker polled every
+ * buffer, `done`, and `failed.txt` holding a closed reason label.
+ *
+ * With Settings > Privacy & security > Microphone off, waveIn still opens and
+ * delivers SILENCE. So the recorder reads the consent store before opening and
+ * about once a second while recording; any `Deny` is `mic_denied`.
+ *
+ * The recorder must outlive `record start` and a tray Job Object kill, so it is
+ * started through WMI (`Win32_Process.Create`: its parent is the WMI provider,
+ * not the CLI) with a `Start-Process` fallback (never a Node child: it would inherit the CLI's pipes).
+ *
+ * This file imports nothing from `notes-record-capture.ts` (that file imports
+ * this one).
+ */
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+const TAG = "[notes record]";
+const WMI_TIMEOUT_MS = 15_000;
+/** Same quoting as `powershellLiteral` in `autostart-windows-scripts.ts`; not imported so this module stays free of that file's workspace imports. */
+export const powershellLiteral = (value) => `'${value.replace(/'/gu, "''")}'`;
+/** Windows PowerShell 5.1 by absolute path (same answer as `windowsPowerShellPath` in `autostart-windows-scripts.ts`); PATH is never consulted. */
+export function windowsPowerShellPath(env = process.env) {
+    const windowsRoot = env.SystemRoot ?? env.WINDIR ?? "C:\\Windows";
+    return path.win32.join(windowsRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+}
+/** Set to `start_process` to skip WMI (a diagnostic knob for comparing the two launch paths on a machine). */
+export const LAUNCH_OVERRIDE_ENV = "BLI_NOTES_RECORD_LAUNCH";
+export { RECORDER_SCRIPT_WIN32 } from "./notes-record-win32-script.js";
+const POWERSHELL_FLAGS = ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-WindowStyle", "Hidden"];
+const encodeCommand = (script) => Buffer.from(script, "utf16le").toString("base64");
+/**
+ * The PowerShell that runs `record.ps1` for `dir`. The directory is one
+ * single-quoted literal and the script is read and compiled in-process, so
+ * execution policy, spaces, apostrophes and non-ASCII in the path cannot bite
+ * (no `-File`).
+ */
+export function recorderBootstrap(dir) {
+    return [
+        "$ErrorActionPreference = 'Stop'",
+        `$dir = ${powershellLiteral(dir)}`,
+        "try {",
+        "  & ([scriptblock]::Create([IO.File]::ReadAllText((Join-Path $dir 'record.ps1')))) $dir",
+        "} catch {",
+        "  try { [IO.File]::AppendAllText((Join-Path $dir 'recorder.log'), 'bootstrap_failed type=' + $_.Exception.GetType().Name + [Environment]::NewLine) } catch { <# best effort: a log line that cannot be written must not stop the recorder #> }",
+        "  if (-not [IO.File]::Exists((Join-Path $dir 'failed.txt'))) { 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 #> } }",
+        "}",
+        "",
+    ].join("\r\n");
+}
+/** The recorder's argument list (also what the Start-Process fallback passes). */
+export function recorderArgs(dir) {
+    return [...POWERSHELL_FLAGS, "-EncodedCommand", encodeCommand(recorderBootstrap(dir))];
+}
+/** The recorder as one Windows command line, for `Win32_Process.Create`. */
+export function recorderCommandLine(powershell, dir) {
+    return [`"${powershell}"`, ...recorderArgs(dir)].join(" ");
+}
+/** The short PowerShell that starts `commandLine` through WMI and prints `ok <pid>` or `fail <code>`. */
+export function wmiLaunchScript(commandLine) {
+    return [
+        "$ErrorActionPreference = 'Stop'",
+        "try { [Console]::OutputEncoding = [Text.Encoding]::ASCII } catch { <# an older host refuses; parseWmiLaunchOutput also reads UTF-16 and BOMs #> }",
+        "try {",
+        "  $startup = New-CimInstance -ClassName Win32_ProcessStartup -ClientOnly -Property @{ ShowWindow = [uint16]0 }",
+        `  $result = Invoke-CimMethod -ClassName Win32_Process -MethodName Create -Arguments @{ CommandLine = ${powershellLiteral(commandLine)}; ProcessStartupInformation = $startup }`,
+        "  if ([int]$result.ReturnValue -eq 0) { Write-Output ('ok ' + [int]$result.ProcessId) } else { Write-Output ('fail ' + [int]$result.ReturnValue) }",
+        "} catch {",
+        "  Write-Output 'fail exception'",
+        "}",
+        "",
+    ].join("\r\n");
+}
+/** A hidden PowerShell that starts `file args` through Start-Process (no handle inheritance) and prints `ok <pid>`. */
+export function startProcessScript(file, args) {
+    return [
+        "$ErrorActionPreference = 'Stop'",
+        "try { [Console]::OutputEncoding = [Text.Encoding]::ASCII } catch { <# an older host refuses; parseWmiLaunchOutput also reads UTF-16 and BOMs #> }",
+        "try {",
+        `  $p = Start-Process -FilePath ${powershellLiteral(file)} -ArgumentList @(${args.map(powershellLiteral).join(", ")}) -WindowStyle Hidden -PassThru`,
+        "  Write-Output ('ok ' + [int]$p.Id)",
+        "} catch {",
+        "  Write-Output 'fail exception'",
+        "}",
+        "",
+    ].join("\r\n");
+}
+/** Decode what the WMI helper printed: ASCII, UTF-8 with a BOM, or UTF-16LE (Windows PowerShell may emit any), CRLF or LF. */
+export function parseWmiLaunchOutput(output) {
+    let text;
+    if (typeof output === "string")
+        text = output;
+    else if (output.length >= 2 && output[0] === 0xff && output[1] === 0xfe)
+        text = output.subarray(2).toString("utf16le");
+    else if (output.includes(0))
+        text = output.toString("latin1");
+    else
+        text = output.toString("utf8");
+    const lines = text.split("\0").join("").split("\uFEFF").join("").split(/\r?\n/u).map((line) => line.trim());
+    for (const line of lines.reverse()) {
+        const ok = /^ok (\d+)$/u.exec(line);
+        if (ok) {
+            const pid = Number(ok[1]);
+            return pid > 0 ? { ok: true, pid } : { ok: false, code: "no_pid" };
+        }
+        const fail = /^fail (\S+)$/u.exec(line);
+        if (fail)
+            return { ok: false, code: fail[1].slice(0, 32) };
+    }
+    return { ok: false, code: "unparsed" };
+}
+const defaultWinLaunchDeps = () => ({
+    powershell: windowsPowerShellPath(),
+    env: process.env,
+    run: (file, args) => {
+        const result = spawnSync(file, args, { windowsHide: true, timeout: WMI_TIMEOUT_MS, stdio: ["ignore", "pipe", "ignore"] });
+        return { status: result.status, stdout: Buffer.isBuffer(result.stdout) ? result.stdout : Buffer.alloc(0), error: result.error };
+    },
+    start: (file, args) => {
+        // Not a Node child: libuv creates children with handle inheritance on, so a recorder spawned here would hold
+        // the CLI's stdout pipe open for as long as it records (the tray reads `record start`'s answer from that pipe).
+        // Start-Process goes through ShellExecute, which inherits nothing; the short PowerShell in between exits at once.
+        const result = spawnSync(file, [...POWERSHELL_FLAGS, "-EncodedCommand", encodeCommand(startProcessScript(file, args))], {
+            windowsHide: true, timeout: WMI_TIMEOUT_MS, stdio: ["ignore", "pipe", "ignore"],
+        });
+        if (result.error || !Buffer.isBuffer(result.stdout))
+            return null;
+        const answer = parseWmiLaunchOutput(result.stdout);
+        return answer.ok ? answer.pid : null;
+    },
+    log: (message, fields) => console.error(`${TAG} ${message}`, JSON.stringify(fields)),
+});
+/** Start the recorder for the session in `dir`, detached from this process. Returns its pid, or null. */
+export function launchRecorderWin32(dir, overrides = {}) {
+    const deps = { ...defaultWinLaunchDeps(), ...overrides };
+    const session = dir.split(/[\\/]/u).filter(Boolean).pop() ?? "unknown";
+    let wmiReturn = "skipped";
+    if (deps.env[LAUNCH_OVERRIDE_ENV] !== "start_process") {
+        const script = wmiLaunchScript(recorderCommandLine(deps.powershell, dir));
+        const ran = deps.run(deps.powershell, [...POWERSHELL_FLAGS, "-EncodedCommand", encodeCommand(script)]);
+        const answer = ran.error ? { ok: false, code: "run_error" } : parseWmiLaunchOutput(ran.stdout);
+        if (answer.ok) {
+            deps.log("recorder launch", { session, pid: answer.pid, launch: "wmi", wmi_return: "0" });
+            return answer.pid;
+        }
+        wmiReturn = answer.code;
+        deps.log("recorder launch wmi refused, falling back to start_process", { session, wmi_return: wmiReturn, exit: ran.status });
+    }
+    const pid = deps.start(deps.powershell, recorderArgs(dir));
+    deps.log(pid === null ? "recorder launch failed" : "recorder launch", { session, pid, launch: "start_process", wmi_return: wmiReturn });
+    return pid;
+}

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

@@ -1,5 +1,7 @@
 /**
- * BLI-22979: the microphone half of `cockpit notes record` (Apple Silicon macOS).
+ * BLI-22979: the microphone half of `cockpit notes record` (Apple Silicon macOS;
+ * the Windows backend is `notes-record-capture-win32.ts`, BLI-23208, behind the
+ * same session directory, marker files and WAV format).
  *
  * Capture mechanism: `osascript -l JavaScript` driving AVFoundation's
  * AVAudioRecorder. Why this one: `osascript` ships with every Mac, so nothing
@@ -24,6 +26,7 @@ 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";
+import { launchRecorderWin32, RECORDER_SCRIPT_WIN32 } from "./notes-record-capture-win32.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');
@@ -119,8 +122,15 @@ export async function readReason(root, id) {
 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) {
+/**
+ * Start the detached recorder in `dir`. Returns its pid, or null when it could not be launched.
+ * `platform` picks the backend: osascript on macOS, Windows PowerShell on Windows (BLI-23208).
+ */
+export function launchRecorder(dir, platform = process.platform) {
+    if (platform === "win32")
+        return launchRecorderWin32(dir);
+    if (platform !== "darwin")
+        return null;
     try {
         const child = spawn("/usr/bin/osascript", ["-l", "JavaScript", path.join(dir, "record.js"), dir], {
             windowsHide: true,
@@ -144,9 +154,13 @@ export function processAlive(pid) {
         return error.code === "EPERM";
     }
 }
-export async function prepareSessionDir(root, id) {
+/** Create the session directory and write the platform's recorder script into it: `record.js` (macOS) or `record.ps1` (Windows). */
+export async function prepareSessionDir(root, id, platform = process.platform) {
     const dir = sessionDir(root, id);
     await mkdir(dir, { recursive: true, mode: 0o700 });
-    await writeFile(path.join(dir, "record.js"), RECORDER_SCRIPT, { mode: 0o600 });
+    if (platform === "win32")
+        await writeFile(path.join(dir, "record.ps1"), RECORDER_SCRIPT_WIN32, { mode: 0o600 });
+    else
+        await writeFile(path.join(dir, "record.js"), RECORDER_SCRIPT, { mode: 0o600 });
     return dir;
 }