pi-meta-oauth 0.3.0 → 0.4.0

package/README.md

@@ -11,7 +11,7 @@ Meta Model API OAuth and Muse-style voice input for [pi](https://pi.dev).
 - Device authorization against `https://auth.meta.com`
 - Model API-key minting through `POST https://api.meta.ai/muse-code/key`
 - Dynamic Muse model catalog from `GET https://api.meta.ai/v1/models`
-- Toggle-based Meta voice dictation on macOS with a live green input meter
+- Toggle-based Meta voice dictation on macOS and Windows with a live green input meter
 
 ## Install
 
@@ -41,7 +41,7 @@ The access key is re-minted daily.
 
 ## Voice input
 
-Voice mode currently requires macOS. It uses the same Meta credential managed by this provider; a separate Muse login is not required.
+Voice mode runs on **macOS and Windows** (Linux is not yet supported). It uses the same Meta credential managed by this provider; a separate Muse login is not required.
 
 1. Press **Alt+V** once to start recording.
 2. Speak while the green microphone meter is visible in Pi's status bar.
@@ -54,7 +54,11 @@ Commands:
 - `/voice-on` — enable the Alt+V shortcut
 - `/voice-off` — disable voice input
 
-The first recording may trigger the macOS microphone permission prompt. Audio is captured only between the two Alt+V presses and streamed as 16 kHz mono PCM to Muse Code's internal Meta ASR endpoint. No local speech-recognition model is downloaded. The endpoint is undocumented and may change in a future Muse release.
+Audio is captured only between the two Alt+V presses and streamed as 16 kHz mono PCM to Muse Code's internal Meta ASR endpoint. No local speech-recognition model is downloaded. The endpoint is undocumented and may change in a future Muse release.
+
+**macOS:** uses `AVFoundation` via a Swift helper compiled with `xcrun swiftc` (first recording triggers the system microphone permission prompt).
+
+**Windows:** uses `winmm.dll` `waveIn*` via a C# helper. On first run pi tries to compile `extensions/voice/windows-audio.cs` with `csc.exe` (in-box .NET Framework) to `~/.pi/agent/bin/pi-meta-oauth-voice-v1.exe` for best performance. If no compiler is found it falls back to `extensions/voice/windows-audio.ps1` executed with `powershell.exe -ExecutionPolicy Bypass` (PowerShell 5.1 inbox, or `pwsh` 7 if present) which compiles the same capture code at runtime via `Add-Type`. No extra install is required. If recording fails, check **Settings → Privacy & security → Microphone** that access is allowed for desktop apps.
 
 Optional overrides:
 

package/extensions/voice/windows-audio.cs

@@ -0,0 +1,281 @@
+// Windows microphone helper for pi-meta-oauth voice.
+// Captures 16 kHz mono PCM via winmm.dll waveIn* and streams base64 JSON lines
+// Protocol mirrors macos-audio.swift:
+//   -> stdout: {"type":"ready","sampleRate":16000,"channels":1,"encoding":"pcm_s16le"}
+//   -> stdout: {"type":"audio","data":"<base64 s16le>"} per captured chunk
+//   -> stdout: {"type":"stopped"}
+//   -> stdout: {"type":"error","message":"..."}
+//   <- stdin: "stop\n" to end capture.
+// Built with: csc.exe /nologo /target:exe /out:pi-meta-oauth-voice-v1.exe windows-audio.cs
+//        or: dotnet build via csc.dll
+// No external dependencies beyond winmm.dll and System.dll.
+
+using System;
+using System.Text;
+using System.Threading;
+using System.Runtime.InteropServices;
+
+class WinVoice
+{
+    // ----- winmm interop -----
+    [StructLayout(LayoutKind.Sequential)]
+    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)]
+    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;
+    }
+
+    delegate void WaveInProc(IntPtr hwi, uint uMsg, IntPtr dwInstance, IntPtr dwParam1, IntPtr dwParam2);
+
+    [DllImport("winmm.dll")]
+    static extern int waveInGetNumDevs();
+
+    [DllImport("winmm.dll", CharSet = CharSet.Auto)]
+    static extern int waveInGetErrorText(int mmrError, StringBuilder pszText, int cchText);
+
+    [DllImport("winmm.dll")]
+    static extern int waveInOpen(out IntPtr phwi, int uDeviceID, ref WAVEFORMATEX pwfx, WaveInProc dwCallback, IntPtr dwInstance, uint fdwOpen);
+
+    [DllImport("winmm.dll")]
+    static extern int waveInPrepareHeader(IntPtr hwi, IntPtr pwh, int cbwh);
+
+    [DllImport("winmm.dll")]
+    static extern int waveInUnprepareHeader(IntPtr hwi, IntPtr pwh, int cbwh);
+
+    [DllImport("winmm.dll")]
+    static extern int waveInAddBuffer(IntPtr hwi, IntPtr pwh, int cbwh);
+
+    [DllImport("winmm.dll")]
+    static extern int waveInStart(IntPtr hwi);
+
+    [DllImport("winmm.dll")]
+    static extern int waveInStop(IntPtr hwi);
+
+    [DllImport("winmm.dll")]
+    static extern int waveInReset(IntPtr hwi);
+
+    [DllImport("winmm.dll")]
+    static extern int waveInClose(IntPtr hwi);
+
+    const uint CALLBACK_FUNCTION = 0x00030000;
+    const int WAVE_MAPPER = -1;
+    const ushort WAVE_FORMAT_PCM = 1;
+    const uint WIM_DATA = 0x3C0;
+
+    const int BUFFER_BYTES = 3200; // 100 ms @ 16 kHz mono s16le
+    const int BUFFER_COUNT = 3;
+
+    static readonly object emitLock = new object();
+    static WaveInProc callbackDelegate; // keep alive
+    static IntPtr hWaveIn = IntPtr.Zero;
+    static IntPtr[] headerPtrs = new IntPtr[BUFFER_COUNT];
+    static IntPtr[] bufferPtrs = new IntPtr[BUFFER_COUNT];
+    static volatile bool stopping = false;
+    static volatile bool finished = false;
+    static ManualResetEvent done = new ManualResetEvent(false);
+
+    static void Emit(string type, string extraJson = null)
+    {
+        string line;
+        if (extraJson == null) line = "{\"type\":\"" + type + "\"}";
+        else line = "{\"type\":\"" + type + "\"," + extraJson + "}";
+        lock (emitLock)
+        {
+            Console.WriteLine(line);
+            Console.Out.Flush();
+        }
+    }
+
+    static void EmitError(string msg)
+    {
+        string esc = msg.Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\r", "\\r").Replace("\n", "\\n");
+        Emit("error", "\"message\":\"" + esc + "\"");
+    }
+
+    static string ErrorText(int code)
+    {
+        var sb = new StringBuilder(256);
+        if (waveInGetErrorText(code, sb, sb.Capacity) == 0 && sb.Length > 0) return sb.ToString();
+        return "winmm error " + code;
+    }
+
+    static void WaveCallback(IntPtr hwi, uint uMsg, IntPtr dwInstance, IntPtr dwParam1, IntPtr dwParam2)
+    {
+        if (uMsg != WIM_DATA) return;
+        if (stopping || finished) return;
+        try
+        {
+            WAVEHDR hdr = (WAVEHDR)Marshal.PtrToStructure(dwParam1, typeof(WAVEHDR));
+            uint recorded = hdr.dwBytesRecorded;
+            if (recorded > 0 && recorded <= hdr.dwBufferLength)
+            {
+                byte[] data = new byte[recorded];
+                Marshal.Copy(hdr.lpData, data, 0, (int)recorded);
+                string b64 = Convert.ToBase64String(data);
+                Emit("audio", "\"data\":\"" + b64 + "\"");
+            }
+            if (!stopping && !finished)
+            {
+                // requeue same header (dwBytesRecorded will be reset by driver)
+                // Need to reset flags? waveInAddBuffer will reuse.
+                int r = waveInAddBuffer(hWaveIn, dwParam1, Marshal.SizeOf(typeof(WAVEHDR)));
+                if (r != 0)
+                {
+                    // If requeue fails, surface error but don't crash callback
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            // Don't emit from callback if already finishing
+            if (!finished) EmitError("wave callback failed: " + ex.Message);
+        }
+    }
+
+    static void Cleanup()
+    {
+        if (hWaveIn != IntPtr.Zero)
+        {
+            try { waveInReset(hWaveIn); } catch { }
+            for (int i = 0; i < BUFFER_COUNT; i++)
+            {
+                if (headerPtrs[i] != IntPtr.Zero)
+                {
+                    try { waveInUnprepareHeader(hWaveIn, headerPtrs[i], Marshal.SizeOf(typeof(WAVEHDR))); } catch { }
+                }
+            }
+            try { waveInClose(hWaveIn); } catch { }
+            hWaveIn = IntPtr.Zero;
+        }
+        for (int i = 0; i < BUFFER_COUNT; i++)
+        {
+            if (bufferPtrs[i] != IntPtr.Zero) { Marshal.FreeHGlobal(bufferPtrs[i]); bufferPtrs[i] = IntPtr.Zero; }
+            if (headerPtrs[i] != IntPtr.Zero) { Marshal.FreeHGlobal(headerPtrs[i]); headerPtrs[i] = IntPtr.Zero; }
+        }
+    }
+
+    static void StopAndExit(int code)
+    {
+        if (finished) return;
+        finished = true;
+        stopping = true;
+        Cleanup();
+        if (code == 0) Emit("stopped");
+        try { Console.Out.Flush(); } catch { }
+        done.Set();
+        Environment.Exit(code);
+    }
+
+    static int Main(string[] args)
+    {
+        // Ctrl+C should produce error rather than silent exit
+        Console.CancelKeyPress += (s, e) => { e.Cancel = true; StopAndExit(0); };
+
+        if (waveInGetNumDevs() == 0)
+        {
+            EmitError("No microphone was found. Check Settings \u2192 Privacy & security \u2192 Microphone and ensure access is allowed.");
+            return 2;
+        }
+
+        var fmt = new WAVEFORMATEX
+        {
+            wFormatTag = WAVE_FORMAT_PCM,
+            nChannels = 1,
+            nSamplesPerSec = 16000,
+            wBitsPerSample = 16,
+            nBlockAlign = 2,
+            nAvgBytesPerSec = 32000,
+            cbSize = 0
+        };
+
+        callbackDelegate = new WaveInProc(WaveCallback);
+
+        int res = waveInOpen(out hWaveIn, WAVE_MAPPER, ref fmt, callbackDelegate, IntPtr.Zero, CALLBACK_FUNCTION);
+        if (res != 0)
+        {
+            string detail = ErrorText(res);
+            if (res == 32) detail += " — Microphone is in use by another app.";
+            // 5 = MMSYSERR_NODRIVER etc hints
+            EmitError("Could not open microphone: " + detail + " Check microphone privacy settings.");
+            return 2;
+        }
+
+        for (int i = 0; i < BUFFER_COUNT; i++)
+        {
+            bufferPtrs[i] = Marshal.AllocHGlobal(BUFFER_BYTES);
+            headerPtrs[i] = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(WAVEHDR)));
+            var hdr = new WAVEHDR
+            {
+                lpData = bufferPtrs[i],
+                dwBufferLength = (uint)BUFFER_BYTES,
+                dwBytesRecorded = 0,
+                dwFlags = 0
+            };
+            Marshal.StructureToPtr(hdr, headerPtrs[i], false);
+            res = waveInPrepareHeader(hWaveIn, headerPtrs[i], Marshal.SizeOf(typeof(WAVEHDR)));
+            if (res != 0) { EmitError("Could not prepare audio buffer: " + ErrorText(res)); Cleanup(); return 3; }
+            res = waveInAddBuffer(hWaveIn, headerPtrs[i], Marshal.SizeOf(typeof(WAVEHDR)));
+            if (res != 0) { EmitError("Could not queue audio buffer: " + ErrorText(res)); Cleanup(); return 3; }
+        }
+
+        res = waveInStart(hWaveIn);
+        if (res != 0) { EmitError("Could not start microphone capture: " + ErrorText(res)); Cleanup(); return 4; }
+
+        Emit("ready", "\"sampleRate\":16000,\"channels\":1,\"encoding\":\"pcm_s16le\"");
+
+        // Wait for "stop" on stdin in background (Console.ReadLine blocks)
+        var stdinThread = new Thread(() =>
+        {
+            try
+            {
+                string line;
+                while ((line = Console.ReadLine()) != null)
+                {
+                    if (line.Trim() == "stop")
+                    {
+                        stopping = true;
+                        try { waveInStop(hWaveIn); } catch { }
+                        // Give a brief window for final WIM_DATA to be delivered,
+                        // then reset and exit. 150 ms is enough for trailing 100 ms buffer.
+                        Thread.Sleep(180);
+                        StopAndExit(0);
+                        break;
+                    }
+                }
+                // stdin closed (parent died) -> stop as well
+                if (!finished)
+                {
+                    stopping = true;
+                    try { waveInStop(hWaveIn); } catch { }
+                    Thread.Sleep(120);
+                    StopAndExit(0);
+                }
+            }
+            catch { StopAndExit(0); }
+        });
+        stdinThread.IsBackground = true;
+        stdinThread.Start();
+
+        // Block main thread until done signal
+        done.WaitOne();
+        return 0;
+    }
+}

package/extensions/voice/windows-audio.ps1

@@ -0,0 +1,195 @@
+#Requires -Version 5.1
+# Windows microphone helper for pi-meta-oauth voice (PowerShell fallback).
+# Mirrors windows-audio.cs protocol when a compiled exe is not available.
+# Uses winmm.dll waveIn* via Add-Type compiled C# — no NAudio / ffmpeg required.
+# Protocol:
+#   stdout: {"type":"ready",...}
+#   stdout: {"type":"audio","data":"<base64>"}
+#   stdout: {"type":"stopped"}
+#   stdout: {"type":"error","message":"..."}
+#   stdin:  "stop\n"
+# Run: powershell -NoProfile -ExecutionPolicy Bypass -File windows-audio.ps1
+
+$ErrorActionPreference = "Stop"
+
+$csCode = @"
+using System;
+using System.Text;
+using System.Threading;
+using System.Runtime.InteropServices;
+
+public class PsWinVoice
+{
+    [StructLayout(LayoutKind.Sequential)]
+    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)]
+    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;
+    }
+
+    delegate void WaveInProc(IntPtr hwi, uint uMsg, IntPtr dwInstance, IntPtr dwParam1, IntPtr dwParam2);
+
+    [DllImport("winmm.dll")]
+    static extern int waveInGetNumDevs();
+    [DllImport("winmm.dll", CharSet = CharSet.Auto)]
+    static extern int waveInGetErrorText(int mmrError, StringBuilder pszText, int cchText);
+    [DllImport("winmm.dll")]
+    static extern int waveInOpen(out IntPtr phwi, int uDeviceID, ref WAVEFORMATEX pwfx, WaveInProc dwCallback, IntPtr dwInstance, uint fdwOpen);
+    [DllImport("winmm.dll")]
+    static extern int waveInPrepareHeader(IntPtr hwi, IntPtr pwh, int cbwh);
+    [DllImport("winmm.dll")]
+    static extern int waveInUnprepareHeader(IntPtr hwi, IntPtr pwh, int cbwh);
+    [DllImport("winmm.dll")]
+    static extern int waveInAddBuffer(IntPtr hwi, IntPtr pwh, int cbwh);
+    [DllImport("winmm.dll")]
+    static extern int waveInStart(IntPtr hwi);
+    [DllImport("winmm.dll")]
+    static extern int waveInStop(IntPtr hwi);
+    [DllImport("winmm.dll")]
+    static extern int waveInReset(IntPtr hwi);
+    [DllImport("winmm.dll")]
+    static extern int waveInClose(IntPtr hwi);
+
+    const uint CALLBACK_FUNCTION = 0x00030000;
+    const int WAVE_MAPPER = -1;
+    const int BUFFER_BYTES = 3200;
+    const int BUFFER_COUNT = 3;
+
+    static object emitLock = new object();
+    static WaveInProc cb;
+    static IntPtr hWaveIn = IntPtr.Zero;
+    static IntPtr[] hdrs = new IntPtr[BUFFER_COUNT];
+    static IntPtr[] bufs = new IntPtr[BUFFER_COUNT];
+    static volatile bool stopping = false;
+    static volatile bool finished = false;
+    static ManualResetEvent done = new ManualResetEvent(false);
+
+    static void Emit(string t, string extra = null)
+    {
+        string line = extra == null ? "{\"type\":\"" + t + "\"}" : "{\"type\":\"" + t + "\"," + extra + "}";
+        lock (emitLock) { Console.WriteLine(line); Console.Out.Flush(); }
+    }
+    static void EmitErr(string m)
+    {
+        string e = m.Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\r", "\\r").Replace("\n", "\\n");
+        Emit("error", "\"message\":\"" + e + "\"");
+    }
+    static string ErrTxt(int c)
+    {
+        var sb = new StringBuilder(256);
+        if (waveInGetErrorText(c, sb, sb.Capacity) == 0 && sb.Length > 0) return sb.ToString();
+        return "winmm error " + c;
+    }
+    static void Callback(IntPtr hwi, uint uMsg, IntPtr a, IntPtr pHdr, IntPtr b)
+    {
+        if (uMsg != 0x3C0) return;
+        if (stopping || finished) return;
+        try
+        {
+            WAVEHDR h = (WAVEHDR)Marshal.PtrToStructure(pHdr, typeof(WAVEHDR));
+            uint n = h.dwBytesRecorded;
+            if (n > 0 && n <= h.dwBufferLength)
+            {
+                byte[] d = new byte[n];
+                Marshal.Copy(h.lpData, d, 0, (int)n);
+                Emit("audio", "\"data\":\"" + Convert.ToBase64String(d) + "\"");
+            }
+            if (!stopping && !finished) waveInAddBuffer(hWaveIn, pHdr, Marshal.SizeOf(typeof(WAVEHDR)));
+        }
+        catch (Exception ex) { if (!finished) EmitErr("wave callback failed: " + ex.Message); }
+    }
+    static void Cleanup()
+    {
+        if (hWaveIn != IntPtr.Zero)
+        {
+            try { waveInReset(hWaveIn); } catch {}
+            for (int i = 0; i < BUFFER_COUNT; i++) if (hdrs[i] != IntPtr.Zero) try { waveInUnprepareHeader(hWaveIn, hdrs[i], Marshal.SizeOf(typeof(WAVEHDR))); } catch {}
+            try { waveInClose(hWaveIn); } catch {}
+            hWaveIn = IntPtr.Zero;
+        }
+        for (int i = 0; i < BUFFER_COUNT; i++)
+        {
+            if (bufs[i] != IntPtr.Zero) { Marshal.FreeHGlobal(bufs[i]); bufs[i]=IntPtr.Zero; }
+            if (hdrs[i] != IntPtr.Zero) { Marshal.FreeHGlobal(hdrs[i]); hdrs[i]=IntPtr.Zero; }
+        }
+    }
+    static void StopOk(int code)
+    {
+        if (finished) return;
+        finished = true; stopping = true;
+        Cleanup();
+        if (code == 0) Emit("stopped");
+        try { Console.Out.Flush(); } catch {}
+        done.Set();
+        Environment.Exit(code);
+    }
+
+    public static int Run()
+    {
+        if (waveInGetNumDevs() == 0) { EmitErr("No microphone was found. Check Settings \u2192 Privacy & security \u2192 Microphone."); return 2; }
+        var fmt = new WAVEFORMATEX { wFormatTag = 1, nChannels = 1, nSamplesPerSec = 16000, wBitsPerSample = 16, nBlockAlign = 2, nAvgBytesPerSec = 32000, cbSize = 0 };
+        cb = new WaveInProc(Callback);
+        int r = waveInOpen(out hWaveIn, WAVE_MAPPER, ref fmt, cb, IntPtr.Zero, CALLBACK_FUNCTION);
+        if (r != 0) { EmitErr("Could not open microphone: " + ErrTxt(r) + ". Check microphone privacy settings."); return 2; }
+        for (int i=0;i<BUFFER_COUNT;i++)
+        {
+            bufs[i] = Marshal.AllocHGlobal(BUFFER_BYTES);
+            hdrs[i] = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(WAVEHDR)));
+            var h = new WAVEHDR { lpData = bufs[i], dwBufferLength = (uint)BUFFER_BYTES };
+            Marshal.StructureToPtr(h, hdrs[i], false);
+            r = waveInPrepareHeader(hWaveIn, hdrs[i], Marshal.SizeOf(typeof(WAVEHDR)));
+            if (r!=0){ EmitErr("Could not prepare buffer: "+ErrTxt(r)); Cleanup(); return 3; }
+            r = waveInAddBuffer(hWaveIn, hdrs[i], Marshal.SizeOf(typeof(WAVEHDR)));
+            if (r!=0){ EmitErr("Could not queue buffer: "+ErrTxt(r)); Cleanup(); return 3; }
+        }
+        r = waveInStart(hWaveIn);
+        if (r!=0){ EmitErr("Could not start capture: "+ErrTxt(r)); Cleanup(); return 4; }
+        Emit("ready", "\"sampleRate\":16000,\"channels\":1,\"encoding\":\"pcm_s16le\"");
+        var t = new Thread(() => {
+            try {
+                string l;
+                while ((l = Console.ReadLine()) != null) {
+                    if (l.Trim() == "stop") { stopping=true; try{ waveInStop(hWaveIn);}catch{} Thread.Sleep(180); StopOk(0); break; }
+                }
+                if (!finished) { stopping=true; try{ waveInStop(hWaveIn);}catch{} Thread.Sleep(120); StopOk(0); }
+            } catch { StopOk(0); }
+        });
+        t.IsBackground=true; t.Start();
+        done.WaitOne();
+        return 0;
+    }
+}
+"@
+
+try {
+    Add-Type -TypeDefinition $csCode -Language CSharp -ErrorAction Stop | Out-Null
+} catch {
+    # Emit JSON error expected by TypeScript fail path
+    $msg = $_.Exception.Message.Replace('\','\\').Replace('"','\"')
+    Write-Output ('{"type":"error","message":"Failed to initialize Windows audio capture: ' + $msg + '"}')
+    exit 3
+}
+
+# Ensure Console uses UTF8 without BOM for JSON lines
+[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
+
+$code = [PsWinVoice]::Run()
+exit $code

package/extensions/voice.ts

@@ -25,6 +25,10 @@ const HELPER_SOURCE = join(HELPER_DIR, "macos-audio.swift");
 const HELPER_PLIST = join(HELPER_DIR, "Info.plist");
 const HELPER_ENTITLEMENTS = join(HELPER_DIR, "Entitlements.plist");
 const HELPER_BINARY = join(AGENT_DIR, "bin/pi-meta-oauth-voice-v1");
+// Windows helpers
+const WINDOWS_HELPER_SOURCE = join(HELPER_DIR, "windows-audio.cs");
+const WINDOWS_HELPER_PS1 = join(HELPER_DIR, "windows-audio.ps1");
+const WINDOWS_HELPER_BINARY = join(AGENT_DIR, "bin/pi-meta-oauth-voice-v1.exe");
 
 const DEFAULT_ASR_ENDPOINT =
 	"wss://shortwave.facebook.com/voyager/v1/asr/duplex";
@@ -45,6 +49,24 @@ type AsrTranscript = {
 	final?: unknown;
 };
 
+function isMacOS(): boolean {
+	return platform() === "darwin";
+}
+
+function isWindows(): boolean {
+	return platform() === "win32";
+}
+
+function isSupportedPlatform(): boolean {
+	return isMacOS() || isWindows();
+}
+
+function supportedPlatformLabel(): string {
+	if (isMacOS()) return "macOS";
+	if (isWindows()) return "Windows";
+	return `${platform()}`;
+}
+
 function loadSettings(): Settings {
 	if (existsSync(SETTINGS_FILE)) {
 		try {
@@ -56,7 +78,7 @@ function loadSettings(): Settings {
 			// Fall through to the platform default.
 		}
 	}
-	return { enabled: platform() === "darwin" };
+	return { enabled: isSupportedPlatform() };
 }
 
 function saveSettings(settings: Settings): void {
@@ -206,10 +228,17 @@ function helperNeedsBuild(): boolean {
 	);
 }
 
+function windowsHelperNeedsBuild(): boolean {
+	if (!existsSync(WINDOWS_HELPER_BINARY)) return true;
+	if (!existsSync(WINDOWS_HELPER_SOURCE)) return false;
+	const binaryTime = statSync(WINDOWS_HELPER_BINARY).mtimeMs;
+	return statSync(WINDOWS_HELPER_SOURCE).mtimeMs > binaryTime;
+}
+
 async function ensureMacOSHelper(): Promise<string> {
-	if (platform() !== "darwin") {
+	if (!isMacOS()) {
 		throw new Error(
-			"Muse-style voice input is currently available only on macOS",
+			"Muse-style voice input is currently available only on macOS and Windows",
 		);
 	}
 	if (
@@ -249,6 +278,109 @@ async function ensureMacOSHelper(): Promise<string> {
 	return HELPER_BINARY;
 }
 
+async function tryCompileWindowsHelper(): Promise<boolean> {
+	if (!existsSync(WINDOWS_HELPER_SOURCE)) return false;
+	mkdirSync(join(AGENT_DIR, "bin"), { recursive: true });
+
+	const candidates: string[] = [
+		"csc",
+		"csc.exe",
+		"C:\\Windows\\Microsoft.NET\\Framework\\v4.0.30319\\csc.exe",
+		"C:\\Windows\\Microsoft.NET\\Framework64\\v4.0.30319\\csc.exe",
+	];
+	// Also try where-found csc via PATH expansion if on Windows
+	for (const c of candidates) {
+		try {
+			await runProcess(c, [
+				"/nologo",
+				"/target:exe",
+				`/out:${WINDOWS_HELPER_BINARY}`,
+				WINDOWS_HELPER_SOURCE,
+			]);
+			if (existsSync(WINDOWS_HELPER_BINARY)) return true;
+		} catch {
+			// try next candidate
+		}
+	}
+	return false;
+}
+
+function findPowerShellCommand(): string {
+	// Prefer pwsh (PowerShell 7) if present, otherwise Windows PowerShell
+	// We check filesystem first to avoid spawning during hot path
+	if (existsSync("C:\\Program Files\\PowerShell\\7\\pwsh.exe"))
+		return "C:\\Program Files\\PowerShell\\7\\pwsh.exe";
+	if (existsSync("C:\\Program Files\\PowerShell\\7\\pwsh")) return "pwsh";
+	// Windows PowerShell is inbox in System32
+	if (
+		existsSync("C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe")
+	)
+		return "C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe";
+	return "powershell.exe";
+}
+
+async function ensureWindowsHelper(): Promise<{
+	command: string;
+	args: string[];
+}> {
+	if (!isWindows()) {
+		throw new Error(
+			"Muse-style voice input is currently available only on macOS and Windows",
+		);
+	}
+	if (!existsSync(WINDOWS_HELPER_SOURCE) && !existsSync(WINDOWS_HELPER_PS1)) {
+		throw new Error("The Windows microphone helper sources are incomplete");
+	}
+
+	// If compiled exe exists and is fresh, use it
+	if (existsSync(WINDOWS_HELPER_BINARY) && !windowsHelperNeedsBuild()) {
+		return { command: WINDOWS_HELPER_BINARY, args: [] };
+	}
+
+	// Try to compile exe for better performance
+	if (existsSync(WINDOWS_HELPER_SOURCE)) {
+		if (!windowsHelperNeedsBuild() && existsSync(WINDOWS_HELPER_BINARY)) {
+			return { command: WINDOWS_HELPER_BINARY, args: [] };
+		}
+		const compiled = await tryCompileWindowsHelper();
+		if (compiled && existsSync(WINDOWS_HELPER_BINARY)) {
+			return { command: WINDOWS_HELPER_BINARY, args: [] };
+		}
+	}
+
+	// Fallback to PowerShell script (no compilation needed)
+	if (existsSync(WINDOWS_HELPER_PS1)) {
+		const ps = findPowerShellCommand();
+		return {
+			command: ps,
+			args: [
+				"-NoProfile",
+				"-ExecutionPolicy",
+				"Bypass",
+				"-File",
+				WINDOWS_HELPER_PS1,
+			],
+		};
+	}
+
+	throw new Error(
+		"Windows voice helper could not be prepared — no compiled binary and no PowerShell fallback found",
+	);
+}
+
+async function ensureHelper(): Promise<{ command: string; args: string[] }> {
+	if (isMacOS()) {
+		const bin = await ensureMacOSHelper();
+		return { command: bin, args: [] };
+	}
+	if (isWindows()) {
+		return ensureWindowsHelper();
+	}
+	throw new Error(
+		`Muse-style voice input is currently available only on macOS and Windows (current: ${supportedPlatformLabel()})`,
+	);
+}
+
 class MetaVoiceController {
 	private readonly pi: ExtensionAPI;
 	private readonly settings = loadSettings();
@@ -339,9 +471,9 @@ class MetaVoiceController {
 	}
 
 	private enable(ctx: ExtensionContext): void {
-		if (platform() !== "darwin") {
+		if (!isSupportedPlatform()) {
 			ctx.ui.notify(
-				"Meta voice input is currently available only on macOS",
+				`Meta voice input is currently available only on macOS and Windows (current: ${supportedPlatformLabel()})`,
 				"error",
 			);
 			return;
@@ -407,8 +539,8 @@ class MetaVoiceController {
 		this.renderTranscript(ctx);
 
 		try {
-			const [binary, apiKey] = await Promise.all([
-				ensureMacOSHelper(),
+			const [helperInfo, apiKey] = await Promise.all([
+				ensureHelper(),
 				ctx.modelRegistry.getApiKeyForProvider(META_PROVIDER_ID),
 			]);
 			if (currentGeneration !== this.generation) return;
@@ -421,7 +553,12 @@ class MetaVoiceController {
 			}
 
 			this.connectSocket(ctx, apiKey, currentGeneration);
-			this.spawnHelper(ctx, binary, currentGeneration);
+			this.spawnHelper(
+				ctx,
+				helperInfo.command,
+				helperInfo.args,
+				currentGeneration,
+			);
 			this.renderInterval = setInterval(() => {
 				this.renderTranscript(ctx);
 				this.renderRecordingStatus(ctx);
@@ -558,10 +695,14 @@ class MetaVoiceController {
 
 	private spawnHelper(
 		ctx: ExtensionContext,
-		binary: string,
+		command: string,
+		args: string[],
 		currentGeneration: number,
 	): void {
-		const helper = spawn(binary, [], { stdio: ["pipe", "pipe", "pipe"] });
+		const helper = spawn(command, args, {
+			stdio: ["pipe", "pipe", "pipe"],
+			windowsHide: true,
+		});
 		this.helper = helper;
 		helper.stdout?.on("data", (chunk: Buffer) =>
 			this.parseHelperOutput(ctx, chunk, currentGeneration),
@@ -603,7 +744,7 @@ class MetaVoiceController {
 			try {
 				this.handleHelperEvent(ctx, JSON.parse(line) as HelperEvent);
 			} catch {
-				// Ignore non-protocol output from macOS audio frameworks.
+				// Ignore non-protocol output from audio frameworks.
 			}
 		}
 	}
@@ -636,7 +777,7 @@ class MetaVoiceController {
 					new Error(
 						typeof event.message === "string"
 							? event.message
-							: "macOS microphone capture failed",
+							: "microphone capture failed",
 					),
 				);
 				return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-meta-oauth",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Meta Model API OAuth provider and Muse-style voice dictation for pi",
   "keywords": [
     "pi-package",