pi-meta-oauth 0.1.1 → 0.2.0

package/README.md

@@ -1,19 +1,22 @@
+<img width="3840" height="2160" alt="Meta-Symbol" src="https://github.com/user-attachments/assets/a3074df9-ad80-40ca-b9b9-944b96dda192" />
+
 # pi-meta-oauth
 
-Meta Model API OAuth provider for [pi](https://pi.dev) — use **Muse Spark** (`muse-spark-1.2`, `muse-spark-1.2-contributor`, `muse-spark-1.1`) via `openai-responses` inside pi.
+Meta Model API OAuth and Muse-style voice input for [pi](https://pi.dev).
 
-- Device authorization (same client as Muse Code) against `https://auth.meta.com`
-- Mints a Model API key via `POST https://api.meta.ai/muse-code/key`
-- Stores OAuth `refresh = identity token` + `access = Model API key` in `~/.pi/agent/auth.json` under provider `meta`
-- Refresh re-mints the Model API key daily
-- Model catalog from `GET https://api.meta.ai/v1/models` with thinking levels `minimal/low/medium/high/xhigh`
+- Use Muse Spark models through Pi's `openai-responses` provider
+- 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
 
 ## Install
 
 ```bash
-# local path (no publish needed)
-pi install ./pi-meta-provider
-# or npm (after publish)
+# Local checkout
+pi install /absolute/path/to/pi-meta-oauth
+
+# npm
 pi install npm:pi-meta-oauth
 
 pi --list-models meta
@@ -21,29 +24,51 @@ pi --list-models meta
 
 ## Login
 
-```bash
-pi
+```text
 /login meta
-# shows device code -> approve in browser -> mints Model API key automatically
 ```
 
-Stored credential shape:
+Pi displays a device code, opens the Meta authorization flow, and mints a Model API key. Credentials are stored by Pi in `~/.pi/agent/auth.json` under provider `meta`:
 
 ```json
 { "meta": { "type": "oauth", "refresh": "<identity>", "access": "<MODEL_API_KEY>", "expires": 123 } }
 ```
 
+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.
+
+1. Press **Alt+V** once to start recording.
+2. Speak while the green microphone meter is visible in Pi's status bar.
+3. Press **Alt+V** again to stop.
+4. The transcript is inserted into Pi's editor for review before submission.
+
+Commands:
+
+- `/voice` — show voice status and privacy behavior
+- `/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.
+
+Optional overrides:
+
+- `PI_META_VOICE_ASR_ENDPOINT`
+- `PI_META_VOICE_ASR_MODEL`
+
 ## Models
 
-All three share 1,048,576 context, 256K output, `supportsReasoningEffort: true`, and `input: ["text","image"]`:
+Fallback models use a 1,048,576-token context window, up to 256K output tokens, image input, and reasoning levels `minimal`, `low`, `medium`, `high`, and `xhigh`.
 
 | id | pricing (input/output/cached) $/M |
-|---|---|
+| --- | --- |
 | `muse-spark-1.2` | 1.25 / 4.25 / 0.15 |
 | `muse-spark-1.2-contributor` | 0.10 / 0.20 / 0.002 |
 | `muse-spark-1.1` | 1.25 / 4.25 / 0.15 |
 
-Add to `enabledModels` in `~/.pi/agent/settings.json`:
+To scope Pi's model picker to Meta models:
 
 ```json
 { "enabledModels": ["meta/*"] }
@@ -54,16 +79,20 @@ Add to `enabledModels` in `~/.pi/agent/settings.json`:
 ```bash
 pi --list-models meta
 pi -p --provider meta --model muse-spark-1.2 "Reply exactly: META_OK"
-bun test extensions/meta.test.ts
+bun run typecheck
+bun test
 ```
 
 ## Publish to pi.dev
 
-`pi-package` keyword makes it appear at https://pi.dev/packages
+The `pi-package` keyword makes the package discoverable at <https://pi.dev/packages>.
 
 ```bash
 npm publish --access public
-# users then run: pi install npm:pi-meta-oauth
 ```
 
-See `extensions/meta.ts` for the `registerProvider` / `refreshModels` / `oauth` implementation reused from Muse Code's launcher flow.
+Users can then update with:
+
+```bash
+pi update npm:pi-meta-oauth
+```

package/extensions/voice/Entitlements.plist

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>com.apple.security.device.audio-input</key>
+	<true/>
+</dict>
+</plist>

package/extensions/voice/Info.plist

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>en</string>
+	<key>CFBundleDisplayName</key>
+	<string>Pi Meta OAuth Voice</string>
+	<key>CFBundleExecutable</key>
+	<string>pi-meta-oauth-voice-v1</string>
+	<key>CFBundleIdentifier</key>
+	<string>dev.pi.metaoauth.voice</string>
+	<key>CFBundleName</key>
+	<string>Pi Meta OAuth Voice</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>2.0</string>
+	<key>NSMicrophoneUsageDescription</key>
+	<string>Pi records audio after Alt+V starts voice input and stops when Alt+V is pressed again, then sends it to Meta ASR for transcription.</string>
+</dict>
+</plist>

package/extensions/voice/macos-audio.swift

@@ -0,0 +1,182 @@
+import AVFoundation
+import Foundation
+
+private let outputQueue = DispatchQueue(label: "com.pi.muse.meta-voice.output")
+
+private func emitNow(_ type: String, _ fields: [String: Any] = [:]) {
+    var payload = fields
+    payload["type"] = type
+    guard let data = try? JSONSerialization.data(withJSONObject: payload),
+          var line = String(data: data, encoding: .utf8) else {
+        return
+    }
+    line.append("\n")
+    FileHandle.standardOutput.write(Data(line.utf8))
+}
+
+private func emit(_ type: String, _ fields: [String: Any] = [:]) {
+    outputQueue.async {
+        emitNow(type, fields)
+    }
+}
+
+private final class MicrophoneSession {
+    private let audioEngine = AVAudioEngine()
+    private var converter: AVAudioConverter?
+    private var stopping = false
+    private var finished = false
+
+    func start() {
+        requestMicrophoneAccess()
+    }
+
+    private func requestMicrophoneAccess() {
+        switch AVCaptureDevice.authorizationStatus(for: .audio) {
+        case .authorized:
+            beginCapture()
+        case .notDetermined:
+            AVCaptureDevice.requestAccess(for: .audio) { [weak self] granted in
+                DispatchQueue.main.async {
+                    guard let self else { return }
+                    if granted {
+                        self.beginCapture()
+                    } else {
+                        self.fail("Microphone permission was not granted. Enable it in System Settings → Privacy & Security → Microphone.", exitCode: 2)
+                    }
+                }
+            }
+        default:
+            fail("Microphone permission is disabled. Enable it in System Settings → Privacy & Security → Microphone.", exitCode: 2)
+        }
+    }
+
+    private func beginCapture() {
+        let inputNode = audioEngine.inputNode
+        let inputFormat = inputNode.outputFormat(forBus: 0)
+        guard inputFormat.sampleRate > 0, inputFormat.channelCount > 0 else {
+            fail("The selected microphone returned an invalid audio format.", exitCode: 3)
+            return
+        }
+        guard let outputFormat = AVAudioFormat(
+            commonFormat: .pcmFormatInt16,
+            sampleRate: 16_000,
+            channels: 1,
+            interleaved: false
+        ), let converter = AVAudioConverter(from: inputFormat, to: outputFormat) else {
+            fail("Could not initialize 16 kHz microphone conversion.", exitCode: 3)
+            return
+        }
+        self.converter = converter
+
+        let tap: AVAudioNodeTapBlock = { [weak self] buffer, _ in
+            self?.convertAndEmit(buffer, outputFormat: outputFormat)
+        }
+        let tapBufferSize = AVAudioFrameCount(inputFormat.sampleRate * 0.1)
+        do {
+            if #available(macOS 27.0, *) {
+                try inputNode.__installTap(
+                    onBus: 0,
+                    bufferSize: tapBufferSize,
+                    format: inputFormat,
+                    error: (),
+                    block: tap
+                )
+            } else {
+                inputNode.installTap(
+                    onBus: 0,
+                    bufferSize: tapBufferSize,
+                    format: inputFormat,
+                    block: tap
+                )
+            }
+            audioEngine.prepare()
+            try audioEngine.start()
+        } catch {
+            inputNode.removeTap(onBus: 0)
+            fail("Could not start microphone capture: \(error.localizedDescription)", exitCode: 4)
+            return
+        }
+
+        emit("ready", [
+            "sampleRate": 16_000,
+            "channels": 1,
+            "encoding": "pcm_s16le"
+        ])
+
+        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            _ = readLine()
+            DispatchQueue.main.async {
+                self?.stop()
+            }
+        }
+    }
+
+    private func convertAndEmit(_ input: AVAudioPCMBuffer, outputFormat: AVAudioFormat) {
+        guard !stopping, !finished, let converter else { return }
+        let ratio = outputFormat.sampleRate / input.format.sampleRate
+        let capacity = AVAudioFrameCount(ceil(Double(input.frameLength) * ratio)) + 32
+        guard let output = AVAudioPCMBuffer(pcmFormat: outputFormat, frameCapacity: capacity) else {
+            return
+        }
+
+        var suppliedInput = false
+        var conversionError: NSError?
+        let status = converter.convert(to: output, error: &conversionError) { _, inputStatus in
+            if suppliedInput {
+                inputStatus.pointee = .noDataNow
+                return nil
+            }
+            suppliedInput = true
+            inputStatus.pointee = .haveData
+            return input
+        }
+
+        if let conversionError {
+            emit("error", ["message": "Microphone conversion failed: \(conversionError.localizedDescription)"])
+            return
+        }
+        guard status != .error,
+              output.frameLength > 0,
+              let samples = output.int16ChannelData?[0] else {
+            return
+        }
+
+        let byteCount = Int(output.frameLength) * MemoryLayout<Int16>.size
+        let audio = Data(bytes: samples, count: byteCount)
+        emit("audio", ["data": audio.base64EncodedString()])
+    }
+
+    func stop() {
+        guard !stopping, !finished else { return }
+        stopping = true
+        if audioEngine.isRunning {
+            audioEngine.stop()
+        }
+        audioEngine.inputNode.removeTap(onBus: 0)
+        converter = nil
+        finished = true
+        outputQueue.async {
+            emitNow("stopped")
+            fflush(stdout)
+            exit(0)
+        }
+    }
+
+    private func fail(_ message: String, exitCode: Int32) {
+        guard !finished else { return }
+        finished = true
+        if audioEngine.isRunning {
+            audioEngine.stop()
+            audioEngine.inputNode.removeTap(onBus: 0)
+        }
+        outputQueue.async {
+            emitNow("error", ["message": message])
+            fflush(stdout)
+            exit(exitCode)
+        }
+    }
+}
+
+private let session = MicrophoneSession()
+session.start()
+RunLoop.main.run()