cuecard 0.2.13__py3-none-any.whl

cuecard/__init__.py

@@ -0,0 +1,3 @@
+"""Cuecard: real-time meeting copilot."""
+
+__version__ = "0.2.13"

cuecard/__main__.py

@@ -0,0 +1,4 @@
+from cuecard.cli import main
+
+if __name__ == "__main__":
+    main()

cuecard/_swift/listen/Package.swift

@@ -0,0 +1,18 @@
+// swift-tools-version:6.0
+import PackageDescription
+
+let package = Package(
+    name: "cuecard-listen",
+    platforms: [.macOS("26.0")],
+    targets: [
+        .executableTarget(
+            name: "cuecard-listen",
+            path: "Sources/cuecard-listen",
+            linkerSettings: [
+                .unsafeFlags(["-Xlinker", "-sectcreate", "-Xlinker", "__TEXT", "-Xlinker", "__info_plist",
+                              "-Xlinker", "Sources/cuecard-listen/Info.plist"])
+            ]
+        )
+    ],
+    swiftLanguageModes: [.v5]
+)

cuecard/_swift/listen/Sources/cuecard-listen/Capture.swift

@@ -0,0 +1,276 @@
+import AudioToolbox
+import AVFoundation
+import CoreAudio
+import Foundation
+
+private func getProp<T>(_ obj: AudioObjectID, _ selector: AudioObjectPropertySelector, _ value: inout T) -> OSStatus {
+    var addr = AudioObjectPropertyAddress(mSelector: selector, mScope: kAudioObjectPropertyScopeGlobal, mElement: kAudioObjectPropertyElementMain)
+    var size = UInt32(MemoryLayout<T>.size)
+    return AudioObjectGetPropertyData(obj, &addr, 0, nil, &size, &value)
+}
+
+/// Captures all system output audio (except our own process) via a Core Audio process tap.
+final class SystemTap: @unchecked Sendable {
+    private let pipeline: SourcePipeline
+    private var tapID = AudioObjectID(kAudioObjectUnknown)
+    private var aggID = AudioObjectID(kAudioObjectUnknown)
+    private var procID: AudioDeviceIOProcID?
+    private var format: AVAudioFormat?
+    private var excludePIDs: [pid_t]
+    private var listenerBlock: AudioObjectPropertyListenerBlock?
+    private let lock = NSLock()
+
+    init(pipeline: SourcePipeline, excludePIDs: [pid_t]) {
+        self.pipeline = pipeline
+        self.excludePIDs = excludePIDs
+    }
+
+    static func processObject(for pid: pid_t) -> AudioObjectID? {
+        var addr = AudioObjectPropertyAddress(mSelector: kAudioHardwarePropertyTranslatePIDToProcessObject, mScope: kAudioObjectPropertyScopeGlobal, mElement: kAudioObjectPropertyElementMain)
+        var p = pid
+        var obj = AudioObjectID(kAudioObjectUnknown)
+        var size = UInt32(MemoryLayout<AudioObjectID>.size)
+        let err = AudioObjectGetPropertyData(AudioObjectID(kAudioObjectSystemObject), &addr, UInt32(MemoryLayout<pid_t>.size), &p, &size, &obj)
+        return (err == noErr && obj != kAudioObjectUnknown) ? obj : nil
+    }
+
+    func start() throws {
+        lock.lock(); defer { lock.unlock() }
+        try build()
+        installDeviceListener()
+    }
+
+    private func build() throws {
+        let excluded = excludePIDs.compactMap { SystemTap.processObject(for: $0) }
+        let desc = CATapDescription(stereoGlobalTapButExcludeProcesses: excluded)
+        desc.uuid = UUID()
+        desc.muteBehavior = .unmuted
+        desc.isPrivate = true
+        desc.name = "cuecard-tap"
+        var err = AudioHardwareCreateProcessTap(desc, &tapID)
+        guard err == noErr else { throw NSError(domain: "cuecard.tap", code: Int(err), userInfo: [NSLocalizedDescriptionKey: "AudioHardwareCreateProcessTap failed (\(err)); grant System Audio Recording permission"]) }
+
+        var asbd = AudioStreamBasicDescription()
+        err = getProp(tapID, kAudioTapPropertyFormat, &asbd)
+        guard err == noErr, let fmt = AVAudioFormat(streamDescription: &asbd) else {
+            throw NSError(domain: "cuecard.tap", code: Int(err), userInfo: [NSLocalizedDescriptionKey: "cannot read tap format"])
+        }
+        format = fmt
+
+        var outDev = AudioObjectID(0)
+        _ = getProp(AudioObjectID(kAudioObjectSystemObject), kAudioHardwarePropertyDefaultSystemOutputDevice, &outDev)
+        var uid: CFString = "" as CFString
+        _ = getProp(outDev, kAudioDevicePropertyDeviceUID, &uid)
+        let outUID = uid as String
+
+        let agg: [String: Any] = [
+            kAudioAggregateDeviceNameKey: "Cuecard Tap",
+            kAudioAggregateDeviceUIDKey: UUID().uuidString,
+            kAudioAggregateDeviceMainSubDeviceKey: outUID,
+            kAudioAggregateDeviceIsPrivateKey: true,
+            kAudioAggregateDeviceIsStackedKey: false,
+            kAudioAggregateDeviceTapAutoStartKey: true,
+            kAudioAggregateDeviceSubDeviceListKey: [[kAudioSubDeviceUIDKey: outUID]],
+            kAudioAggregateDeviceTapListKey: [[kAudioSubTapDriftCompensationKey: true, kAudioSubTapUIDKey: desc.uuid.uuidString]],
+        ]
+        err = AudioHardwareCreateAggregateDevice(agg as CFDictionary, &aggID)
+        guard err == noErr else { throw NSError(domain: "cuecard.tap", code: Int(err), userInfo: [NSLocalizedDescriptionKey: "aggregate device failed (\(err))"]) }
+
+        let pipeline = self.pipeline
+        err = AudioDeviceCreateIOProcIDWithBlock(&procID, aggID, nil) { _, inData, _, _, _ in
+            guard let src = AVAudioPCMBuffer(pcmFormat: fmt, bufferListNoCopy: inData, deallocator: nil),
+                  src.frameLength > 0,
+                  let copy = AVAudioPCMBuffer(pcmFormat: fmt, frameCapacity: src.frameLength) else { return }
+            copy.frameLength = src.frameLength
+            let srcList = UnsafeMutableAudioBufferListPointer(UnsafeMutablePointer(mutating: src.audioBufferList))
+            let dstList = UnsafeMutableAudioBufferListPointer(copy.mutableAudioBufferList)
+            for i in 0..<min(srcList.count, dstList.count) {
+                if let s = srcList[i].mData, let d = dstList[i].mData {
+                    memcpy(d, s, Int(min(srcList[i].mDataByteSize, dstList[i].mDataByteSize)))
+                }
+            }
+            pipeline.push(copy)
+        }
+        guard err == noErr else { throw NSError(domain: "cuecard.tap", code: Int(err), userInfo: [NSLocalizedDescriptionKey: "IOProc failed (\(err))"]) }
+        err = AudioDeviceStart(aggID, procID)
+        guard err == noErr else { throw NSError(domain: "cuecard.tap", code: Int(err), userInfo: [NSLocalizedDescriptionKey: "device start failed (\(err))"]) }
+        Out.log("system tap started fmt=\(fmt) output=\(outUID) excluded=\(excluded)")
+    }
+
+    private func teardown() {
+        if aggID != kAudioObjectUnknown {
+            if let procID { AudioDeviceStop(aggID, procID); AudioDeviceDestroyIOProcID(aggID, procID) }
+            AudioHardwareDestroyAggregateDevice(aggID)
+        }
+        if tapID != kAudioObjectUnknown { AudioHardwareDestroyProcessTap(tapID) }
+        procID = nil
+        aggID = AudioObjectID(kAudioObjectUnknown)
+        tapID = AudioObjectID(kAudioObjectUnknown)
+    }
+
+    /// Rebuild when the default output device changes (headphones plugged, Bluetooth, etc).
+    private func installDeviceListener() {
+        var addr = AudioObjectPropertyAddress(mSelector: kAudioHardwarePropertyDefaultSystemOutputDevice, mScope: kAudioObjectPropertyScopeGlobal, mElement: kAudioObjectPropertyElementMain)
+        let block: AudioObjectPropertyListenerBlock = { [weak self] _, _ in
+            guard let self else { return }
+            DispatchQueue.global().asyncAfter(deadline: .now() + 0.3) {
+                self.lock.lock(); defer { self.lock.unlock() }
+                self.teardown()
+                do {
+                    try self.build()
+                    Out.emit("status", ["src": "them", "message": "output device changed; capture rebuilt"])
+                } catch {
+                    Out.error("them", "device", "\(error.localizedDescription)")
+                }
+            }
+        }
+        listenerBlock = block
+        AudioObjectAddPropertyListenerBlock(AudioObjectID(kAudioObjectSystemObject), &addr, DispatchQueue.global(), block)
+    }
+
+    func stop() {
+        lock.lock(); defer { lock.unlock() }
+        teardown()
+    }
+}
+
+/// Microphone capture via AVAudioEngine.
+final class MicCapture: @unchecked Sendable {
+    private let engine = AVAudioEngine()
+    private let pipeline: SourcePipeline
+    private let aec: Bool
+    private let ctl = DispatchQueue(label: "cuecard.mic")  // start / pause / resume / device changes, one at a time
+    private var paused = false
+    private var observer: NSObjectProtocol?
+
+    init(pipeline: SourcePipeline, aec: Bool) {
+        self.pipeline = pipeline
+        self.aec = aec
+    }
+
+    /// `open: false` sets everything up but leaves the microphone closed (ME turned it off): `resume()` opens it.
+    func start(open: Bool = true) throws {
+        let status = AVCaptureDevice.authorizationStatus(for: .audio)
+        if status == .denied || status == .restricted {
+            throw NSError(domain: "cuecard.mic", code: 1, userInfo: [NSLocalizedDescriptionKey: "microphone permission denied"])
+        }
+        if aec {
+            do {
+                try engine.inputNode.setVoiceProcessingEnabled(true)
+                engine.inputNode.voiceProcessingOtherAudioDuckingConfiguration = .init(enableAdvancedDucking: false, duckingLevel: .min)
+            } catch { Out.log("voice processing unavailable: \(error)") }
+        }
+        try ctl.sync {
+            if open { try installAndStart() } else { paused = true }
+        }
+        // A new input device (AirPods, a USB headset, unplugging one) stops the engine and may change the format:
+        // re-install the tap with the new format and start again, or the mic silently goes dead.
+        observer = NotificationCenter.default.addObserver(forName: .AVAudioEngineConfigurationChange, object: engine,
+                                                          queue: nil) { [weak self] _ in
+            guard let self else { return }
+            self.ctl.async {
+                if self.paused { return }  // resume() re-installs with whatever device is current then
+                do {
+                    try self.installAndStart()
+                    Out.log("mic restarted after an audio device change")
+                } catch {
+                    Out.error(self.pipeline.src, "device", "microphone stopped after an audio device change: \(error.localizedDescription)")
+                }
+            }
+        }
+    }
+
+    /// On `ctl`: (re-)install the tap with the input's current format and start the engine.
+    private func installAndStart() throws {
+        let input = engine.inputNode
+        input.removeTap(onBus: 0)
+        let fmt = input.outputFormat(forBus: 0)
+        guard fmt.sampleRate > 0 else {
+            throw NSError(domain: "cuecard.mic", code: 2, userInfo: [NSLocalizedDescriptionKey: "no microphone input device"])
+        }
+        let pipeline = self.pipeline
+        input.installTap(onBus: 0, bufferSize: 1024, format: fmt) { buf, _ in
+            guard let copy = AVAudioPCMBuffer(pcmFormat: buf.format, frameCapacity: buf.frameLength) else { return }
+            copy.frameLength = buf.frameLength
+            let s = UnsafeMutableAudioBufferListPointer(UnsafeMutablePointer(mutating: buf.audioBufferList))
+            let d = UnsafeMutableAudioBufferListPointer(copy.mutableAudioBufferList)
+            for i in 0..<min(s.count, d.count) {
+                if let sp = s[i].mData, let dp = d[i].mData { memcpy(dp, sp, Int(min(s[i].mDataByteSize, d[i].mDataByteSize))) }
+            }
+            pipeline.push(copy)
+        }
+        engine.prepare()
+        try engine.start()
+        Out.log("mic started fmt=\(fmt) aec=\(aec)")
+    }
+
+    func stop() {
+        ctl.sync {
+            if let observer { NotificationCenter.default.removeObserver(observer) }
+            observer = nil
+            engine.inputNode.removeTap(onBus: 0)
+            engine.stop()
+        }
+    }
+
+    /// Paused = the microphone is really closed (the macOS mic indicator goes off).
+    func pause() {
+        ctl.sync {
+            paused = true
+            engine.stop()
+        }
+    }
+
+    func resume() {
+        ctl.sync {
+            paused = false
+            do { try installAndStart() } catch {
+                Out.error(pipeline.src, "mic", "resume failed: \(error.localizedDescription)")
+            }
+        }
+    }
+}
+
+/// Replays an audio file into a pipeline, paced at real time when requested.
+final class FileSource: @unchecked Sendable {
+    let path: String
+    let pipeline: SourcePipeline
+    let realtime: Bool
+
+    init(path: String, pipeline: SourcePipeline, realtime: Bool) {
+        self.path = path
+        self.pipeline = pipeline
+        self.realtime = realtime
+    }
+
+    /// Blocks until the file is fully fed. `anchor` is the shared wall-clock start.
+    func run(anchor: Date, tailSilence: Double) throws {
+        let file = try AVAudioFile(forReading: URL(fileURLWithPath: path))
+        let fmt = file.processingFormat
+        let chunk = AVAudioFrameCount(fmt.sampleRate * 0.02)
+        var fed = 0.0
+        while true {
+            let remain = AVAudioFrameCount(max(0, file.length - file.framePosition))
+            if remain == 0 { break }
+            guard let buf = AVAudioPCMBuffer(pcmFormat: fmt, frameCapacity: chunk) else { break }
+            try file.read(into: buf, frameCount: min(chunk, remain))
+            if buf.frameLength == 0 { break }
+            pipeline.push(buf)
+            fed += Double(buf.frameLength) / fmt.sampleRate
+            if realtime {
+                let wait = fed - Date().timeIntervalSince(anchor)
+                if wait > 0 { Thread.sleep(forTimeInterval: wait) }
+            }
+        }
+        // Trailing silence so VAD/ASR can close the last turn, paced as well.
+        let steps = Int(tailSilence / 0.1)
+        for _ in 0..<steps {
+            pipeline.pushSilence(seconds: 0.1)
+            fed += 0.1
+            if realtime {
+                let wait = fed - Date().timeIntervalSince(anchor)
+                if wait > 0 { Thread.sleep(forTimeInterval: wait) }
+            }
+        }
+    }
+}

cuecard/_swift/listen/Sources/cuecard-listen/Info.plist

@@ -0,0 +1,16 @@
+<?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>CFBundleIdentifier</key>
+	<string>dev.cuecard.listen</string>
+	<key>CFBundleName</key>
+	<string>cuecard-listen</string>
+	<key>NSMicrophoneUsageDescription</key>
+	<string>Cuecard transcribes your microphone for meeting context.</string>
+	<key>NSAudioCaptureUsageDescription</key>
+	<string>Cuecard records system audio to transcribe what the other side says.</string>
+	<key>NSSpeechRecognitionUsageDescription</key>
+	<string>Cuecard uses on-device speech recognition for live captions.</string>
+</dict>
+</plist>

cuecard/_swift/listen/Sources/cuecard-listen/Output.swift

@@ -0,0 +1,26 @@
+import Foundation
+
+/// Thread-safe NDJSON writer on stdout. Every event gets a wall-clock timestamp.
+enum Out {
+    private static let lock = NSLock()
+
+    static func emit(_ type: String, _ fields: [String: Any] = [:]) {
+        var obj = fields
+        obj["type"] = type
+        obj["wall"] = Date().timeIntervalSince1970
+        guard let data = try? JSONSerialization.data(withJSONObject: obj, options: [.withoutEscapingSlashes]) else { return }
+        lock.lock()
+        FileHandle.standardOutput.write(data)
+        FileHandle.standardOutput.write("\n".data(using: .utf8)!)
+        lock.unlock()
+    }
+
+    static func log(_ msg: String) {
+        FileHandle.standardError.write("[listen] \(msg)\n".data(using: .utf8)!)
+    }
+
+    static func error(_ src: String, _ code: String, _ message: String) {
+        emit("error", ["src": src, "code": code, "message": message])
+        log("error \(src) \(code): \(message)")
+    }
+}