@infilectai/aira 0.0.0-stage → 0.1.0

package/native/AiraCapture.swift

@@ -0,0 +1,1142 @@
+import Foundation
+import AppKit
+import ApplicationServices
+import CoreGraphics
+import CoreAudio
+import AudioToolbox
+import AVFoundation
+import CoreMedia
+import ScreenCaptureKit
+
+// MARK: - Core Wire Types
+
+public struct MeetingTarget: Codable, Sendable, Equatable {
+    public let pid: Int32
+    public let browser: String
+    public let platform: String
+    public let url: String
+    public let title: String
+
+    public init(pid: Int32, browser: String, platform: String, url: String, title: String) {
+        self.pid = pid
+        self.browser = browser
+        self.platform = platform
+        self.url = url
+        self.title = title
+    }
+
+    public static func == (lhs: MeetingTarget, rhs: MeetingTarget) -> Bool {
+        lhs.pid == rhs.pid && lhs.url == rhs.url
+    }
+}
+
+public struct Participant: Codable, Sendable, Hashable {
+    public let id: String
+    public let name: String
+
+    public init(id: String, name: String) {
+        self.id = id
+        self.name = name
+    }
+}
+
+public struct ChromeParticipant: Codable, Sendable {
+    public let pid: String
+    public let name: String
+    public let muted: Bool?
+}
+
+public struct ChromeEvent: Codable, Sendable {
+    public let type: String
+    public let speaker: String?
+    public let method: String?
+    public let participants: [ChromeParticipant]?
+}
+
+// MARK: - Stdio Protocol Framing (`aira_capture|<json>`)
+
+private let stdoutLock = NSLock()
+
+private func sendProtocolJSON<T: Encodable>(_ payload: T) {
+    guard let data = try? JSONEncoder().encode(payload),
+          let str = String(data: data, encoding: .utf8) else { return }
+    stdoutLock.lock()
+    defer { stdoutLock.unlock() }
+    if let lineData = ("aira_capture|" + str + "\n").data(using: .utf8) {
+        FileHandle.standardOutput.write(lineData)
+    }
+}
+
+private struct RPCResponse<R: Encodable>: Encodable {
+    let type = "response"
+    let id: String
+    let status: String
+    let result: R?
+    let error: String?
+}
+
+private struct RPCEvent<P: Encodable>: Encodable {
+    let type = "event"
+    let event: String
+    let payload: P
+}
+
+private func sendResponse<R: Encodable>(id: String, result: R) {
+    sendProtocolJSON(RPCResponse(id: id, status: "success", result: result, error: nil))
+}
+
+private func sendErrorResponse(id: String, message: String) {
+    sendProtocolJSON(RPCResponse<String>(id: id, status: "error", result: nil, error: message))
+}
+
+private func emitEvent<P: Encodable>(_ name: String, payload: P) {
+    sendProtocolJSON(RPCEvent(event: name, payload: payload))
+}
+
+// MARK: - Permission Manager
+
+enum EyesPermissionManager {
+    static func checkAll(prompt: Bool) async -> [String: String] {
+        let axOpts = ["AXTrustedCheckOptionPrompt": prompt] as CFDictionary
+        let axGranted = AXIsProcessTrustedWithOptions(axOpts)
+        let screenGranted = prompt ? CGRequestScreenCaptureAccess() : CGPreflightScreenCaptureAccess()
+
+        let micStatus = AVCaptureDevice.authorizationStatus(for: .audio)
+        let micGranted: Bool
+        switch micStatus {
+        case .authorized:
+            micGranted = true
+        case .notDetermined where prompt:
+            micGranted = await AVCaptureDevice.requestAccess(for: .audio)
+        default:
+            micGranted = false
+        }
+
+        let sysAudioGranted: Bool
+        if #available(macOS 14.2, *) {
+            sysAudioGranted = true
+        } else {
+            sysAudioGranted = screenGranted
+        }
+
+        return [
+            "accessibility": axGranted ? "granted" : "denied",
+            "screen-capture": screenGranted ? "granted" : "denied",
+            "microphone": micGranted ? "granted" : "denied",
+            "system-audio": sysAudioGranted ? "granted" : "denied",
+        ]
+    }
+}
+
+// MARK: - Meeting Detector
+
+actor MeetingDetector {
+    static let shared = MeetingDetector()
+
+    private var isPolling = false
+    private var pollTask: Task<Void, Never>?
+    private var currentMeetings: [MeetingTarget] = []
+
+    func start() async {
+        if !isPolling {
+            isPolling = true
+            await poll(forceEmit: true)
+            pollTask = Task {
+                while !Task.isCancelled && isPolling {
+                    try? await Task.sleep(nanoseconds: 2_500_000_000)
+                    guard !Task.isCancelled && isPolling else { break }
+                    await poll(forceEmit: false)
+                }
+            }
+        } else {
+            emitEvent("meetings", payload: currentMeetings)
+        }
+    }
+
+    func stop() {
+        isPolling = false
+        pollTask?.cancel()
+        pollTask = nil
+    }
+
+    private func poll(forceEmit: Bool) async {
+        var foundMeetings: [MeetingTarget] = []
+        let targetBundleIds: Set<String> = [
+            "com.google.Chrome",
+            "company.thebrowser.Browser",
+            "com.brave.Browser",
+            "com.microsoft.edgemac",
+            "com.vivaldi.Vivaldi",
+            "com.apple.Safari",
+            "us.zoom.xos",
+            "com.microsoft.teams",
+            "com.microsoft.teams2"
+        ]
+
+        let apps = NSWorkspace.shared.runningApplications
+        for app in apps {
+            guard app.activationPolicy == .regular,
+                  let bundleId = app.bundleIdentifier,
+                  targetBundleIds.contains(bundleId) else { continue }
+
+            let detected = NativeMeetingScraper.shared.detectMeetings(in: app)
+            for mt in detected {
+                if !foundMeetings.contains(where: { $0.url == mt.url && $0.pid == mt.pid }) {
+                    foundMeetings.append(mt)
+                }
+            }
+        }
+
+        if let content = try? await SCShareableContent.excludingDesktopWindows(false, onScreenWindowsOnly: false) {
+            for window in content.windows {
+                guard let app = window.owningApplication else { continue }
+                let bundleId = app.bundleIdentifier
+                guard targetBundleIds.contains(bundleId) else { continue }
+                let pid = app.processID
+                let title = window.title ?? ""
+
+                if window.frame.height < 120 && (title.contains("sharing your screen") || title.contains("is sharing")) {
+                    continue
+                }
+
+                if let mt = parseMeetingTarget(title: title, bundleId: bundleId, pid: pid, appName: app.applicationName) {
+                    if !foundMeetings.contains(where: { $0.pid == mt.pid && ($0.url == mt.url || $0.platform == mt.platform) }) {
+                        foundMeetings.append(mt)
+                    }
+                }
+            }
+        }
+
+        let changed = currentMeetings != foundMeetings
+        currentMeetings = foundMeetings
+
+        if changed || forceEmit {
+            emitEvent("meetings", payload: currentMeetings)
+        }
+    }
+
+    private func parseMeetingTarget(title: String, bundleId: String, pid: pid_t, appName: String) -> MeetingTarget? {
+        let browserBundles: Set<String> = [
+            "com.google.Chrome", "company.thebrowser.Browser", "com.brave.Browser",
+            "com.microsoft.edgemac", "com.vivaldi.Vivaldi", "com.apple.Safari"
+        ]
+        if browserBundles.contains(bundleId) {
+            if title.starts(with: "Meet - ") || title.starts(with: "Meet – ") {
+                let cleanTitle = NativeMeetingScraper.shared.sanitizeMeetingTitle(title, fallbackCode: nil)
+                let suffix = cleanTitle.replacingOccurrences(of: #"^Meet\s*[-–]\s*"#, with: "", options: .regularExpression)
+                let codePattern = #"([a-z]{3}-[a-z]{4}-[a-z]{3})"#
+                let range = NSRange(suffix.startIndex..<suffix.endIndex, in: suffix)
+                let slug: String
+                if let regex = try? NSRegularExpression(pattern: codePattern, options: [.caseInsensitive]),
+                   let match = regex.firstMatch(in: suffix, options: [], range: range),
+                   let r = Range(match.range(at: 1), in: suffix) {
+                    slug = String(suffix[r]).lowercased()
+                } else {
+                    slug = "active"
+                }
+                let browserSlug = NativeMeetingScraper.shared.normalizeBrowserName(bundleId: bundleId, appName: appName)
+                return MeetingTarget(pid: pid, browser: browserSlug, platform: "google-meet", url: "https://meet.google.com/\(slug)", title: cleanTitle)
+            }
+        } else if bundleId == "us.zoom.xos" {
+            if title.contains("Zoom Meeting") || title.contains("Zoom Webinar") || title.hasPrefix("Talking:") {
+                return MeetingTarget(pid: pid, browser: "Zoom", platform: "zoom", url: "zoom://meeting/\(pid)", title: title)
+            }
+        } else if bundleId == "com.microsoft.teams" || bundleId == "com.microsoft.teams2" {
+            let lower = title.lowercased()
+            let isMainChat = lower.hasPrefix("chat |") || lower.hasPrefix("activity |") || lower.hasPrefix("calendar |") || lower.hasPrefix("teams |")
+            if (lower.contains("meeting") || lower.contains("call with")) && !isMainChat {
+                return MeetingTarget(pid: pid, browser: appName, platform: "teams", url: "teams://meeting/\(pid)", title: title)
+            }
+        }
+        return nil
+    }
+}
+
+// MARK: - Microphone Activity & 16 kHz Resampler
+
+enum MicActivity {
+    typealias PCMHandler = @Sendable ([Float]) -> Void
+
+    private static let engine = AVAudioEngine()
+    private static var isRunning = false
+    private static var rms: Float = 0
+    private static var onResampledPCM: PCMHandler?
+    private static var converter: AVAudioConverter?
+    private static let targetFormat = AVAudioFormat(
+        commonFormat: .pcmFormatFloat32,
+        sampleRate: 16_000,
+        channels: 1,
+        interleaved: false
+    )!
+    private static let lock = NSLock()
+    private static let queue = DispatchQueue(label: "aira.mic.activity", qos: .userInitiated)
+
+    static func start(onPCM: PCMHandler? = nil) {
+        lock.lock()
+        if let onPCM {
+            onResampledPCM = onPCM
+        }
+        if isRunning {
+            lock.unlock()
+            return
+        }
+        lock.unlock()
+
+        let status = AVCaptureDevice.authorizationStatus(for: .audio)
+        switch status {
+        case .authorized:
+            queue.async { startEngineIfAuthorized() }
+        case .notDetermined:
+            AVCaptureDevice.requestAccess(for: .audio) { granted in
+                if granted {
+                    queue.async { startEngineIfAuthorized() }
+                }
+            }
+        default:
+            return
+        }
+    }
+
+    private static func startEngineIfAuthorized() {
+        lock.lock()
+        guard !isRunning else {
+            lock.unlock()
+            return
+        }
+        lock.unlock()
+
+        let input = engine.inputNode
+        let fmt = input.inputFormat(forBus: 0)
+        guard fmt.sampleRate > 0 && fmt.channelCount > 0 else { return }
+        let conv = AVAudioConverter(from: fmt, to: targetFormat)
+        lock.lock()
+        converter = conv
+        lock.unlock()
+
+        input.removeTap(onBus: 0)
+        input.installTap(onBus: 0, bufferSize: 1024, format: fmt) { buffer, _ in
+            let data = buffer.floatChannelData?[0]
+            let count = Int(buffer.frameLength)
+            guard let data, count > 0 else { return }
+            var sum: Float = 0
+            for i in 0..<count { sum += data[i] * data[i] }
+            let level = sqrt(sum / Float(count))
+
+            var callback: PCMHandler?
+            var localConv: AVAudioConverter?
+            lock.lock()
+            rms = level
+            callback = onResampledPCM
+            localConv = converter
+            lock.unlock()
+
+            if let callback, let localConv {
+                let ratio = targetFormat.sampleRate / buffer.format.sampleRate
+                let outFrames = AVAudioFrameCount(Double(buffer.frameLength) * ratio + 16)
+                if let outBuf = AVAudioPCMBuffer(pcmFormat: targetFormat, frameCapacity: outFrames) {
+                    var err: NSError?
+                    var consumed = false
+                    let status = localConv.convert(to: outBuf, error: &err) { _, statusOut in
+                        if consumed {
+                            statusOut.pointee = .noDataNow
+                            return nil
+                        }
+                        consumed = true
+                        statusOut.pointee = .haveData
+                        return buffer
+                    }
+                    if status != .error, err == nil, let ch = outBuf.floatChannelData {
+                        let n = Int(outBuf.frameLength)
+                        if n > 0 {
+                            let samples = Array(UnsafeBufferPointer(start: ch[0], count: n))
+                            callback(samples)
+                        }
+                    }
+                }
+            }
+        }
+        engine.prepare()
+        do {
+            try engine.start()
+            lock.lock()
+            isRunning = true
+            lock.unlock()
+        } catch {
+            input.removeTap(onBus: 0)
+        }
+    }
+
+    static func currentRMS() -> Float {
+        lock.lock()
+        defer { lock.unlock() }
+        return rms
+    }
+
+    static func stop() {
+        lock.lock()
+        defer { lock.unlock() }
+        onResampledPCM = nil
+        guard isRunning else { return }
+        engine.inputNode.removeTap(onBus: 0)
+        engine.stop()
+        converter = nil
+        isRunning = false
+    }
+}
+
+// MARK: - CoreAudio Process Tap + ScreenCaptureKit Audio Capture
+
+final class ProcessAudioCapture: NSObject, @unchecked Sendable {
+    typealias FrameHandler = @Sendable ([Float]) -> Void
+
+    private let pid: pid_t
+    private let onFrames: FrameHandler
+
+    private var tapID: AudioObjectID = AudioObjectID(kAudioObjectUnknown)
+    private var aggregateDeviceID: AudioObjectID = AudioObjectID(kAudioObjectUnknown)
+    private var ioProcID: AudioDeviceIOProcID?
+    private let audioTapQueue = DispatchQueue(label: "aira.audio.tap", qos: .userInitiated)
+
+    private var stream: SCStream?
+    private var streamOutput: AudioStreamOutput?
+    private var converter: AVAudioConverter?
+    private var sourceFormat: AVAudioFormat?
+    private let targetFormat = AVAudioFormat(
+        commonFormat: .pcmFormatFloat32,
+        sampleRate: 16_000,
+        channels: 1,
+        interleaved: false
+    )!
+
+    init(pid: pid_t, onFrames: @escaping FrameHandler) {
+        self.pid = pid
+        self.onFrames = onFrames
+    }
+
+    func start() async throws {
+        if startCoreAudioProcessTap() {
+            return
+        }
+
+        let content = try await SCShareableContent.excludingDesktopWindows(false, onScreenWindowsOnly: false)
+        guard let display = content.displays.first else {
+            throw NSError(domain: "AiraCapture", code: 1, userInfo: [NSLocalizedDescriptionKey: "No display available"])
+        }
+
+        let filter = SCContentFilter(display: display, excludingApplications: [], exceptingWindows: [])
+        let config = SCStreamConfiguration()
+        config.capturesAudio = true
+        config.excludesCurrentProcessAudio = true
+        config.sampleRate = 48_000
+        config.channelCount = 2
+        config.width = 2
+        config.height = 2
+        config.minimumFrameInterval = CMTime(value: 1, timescale: 1)
+        config.queueDepth = 6
+
+        let stream = SCStream(filter: filter, configuration: config, delegate: nil)
+        let output = AudioStreamOutput { [weak self] buffer in
+            self?.handle(buffer: buffer)
+        }
+        try stream.addStreamOutput(output, type: .audio, sampleHandlerQueue: .global(qos: .userInitiated))
+        try await stream.startCapture()
+        self.stream = stream
+        self.streamOutput = output
+    }
+
+    func stop() async {
+        stopCoreAudioProcessTap()
+        guard let stream else { return }
+        try? await stream.stopCapture()
+        self.stream = nil
+        self.streamOutput = nil
+        self.converter = nil
+        self.sourceFormat = nil
+    }
+
+    private func startCoreAudioProcessTap() -> Bool {
+        guard #available(macOS 14.2, *) else { return false }
+
+        let currentPid = ProcessInfo.processInfo.processIdentifier
+        let excludedProcessIDs = resolveAudioObjectIDs(forPIDs: [currentPid])
+
+        let tapDesc = CATapDescription(stereoGlobalTapButExcludeProcesses: excludedProcessIDs)
+        let tapUUID = UUID()
+        tapDesc.name = "AiraSystemAudioTap-\(tapUUID.uuidString)"
+        tapDesc.uuid = tapUUID
+        tapDesc.isPrivate = true
+        tapDesc.muteBehavior = .unmuted
+
+        var createdTapID: AudioObjectID = AudioObjectID(kAudioObjectUnknown)
+        guard AudioHardwareCreateProcessTap(tapDesc, &createdTapID) == noErr,
+              createdTapID != kAudioObjectUnknown else {
+            return false
+        }
+        self.tapID = createdTapID
+
+        let aggUID = "AiraSystemAudioAggregateDevice-\(UUID().uuidString)"
+        let tapEntry: [String: Any] = [
+            kAudioSubTapUIDKey as String: tapUUID.uuidString,
+            kAudioSubTapDriftCompensationKey as String: true
+        ]
+        let aggDesc: [String: Any] = [
+            kAudioAggregateDeviceNameKey as String: "AiraSystemAudioAggregateDevice",
+            kAudioAggregateDeviceUIDKey as String: aggUID,
+            kAudioAggregateDeviceIsPrivateKey as String: true,
+            kAudioAggregateDeviceIsStackedKey as String: false,
+            kAudioAggregateDeviceTapAutoStartKey as String: true,
+            kAudioAggregateDeviceTapListKey as String: [tapEntry]
+        ]
+
+        var createdAggID: AudioObjectID = AudioObjectID(kAudioObjectUnknown)
+        guard AudioHardwareCreateAggregateDevice(aggDesc as CFDictionary, &createdAggID) == noErr,
+              createdAggID != kAudioObjectUnknown else {
+            AudioHardwareDestroyProcessTap(createdTapID)
+            self.tapID = AudioObjectID(kAudioObjectUnknown)
+            return false
+        }
+        self.aggregateDeviceID = createdAggID
+
+        let tapFormat = getFirstTapInputStreamFormat(for: createdAggID)
+        let sampleRate = (tapFormat?.mSampleRate).flatMap { $0 > 0 ? $0 : nil }
+            ?? getNominalSampleRate(deviceId: createdAggID)
+            ?? 48_000.0
+        let handler = self.onFrames
+
+        var createdProcID: AudioDeviceIOProcID?
+        let ioStatus = AudioDeviceCreateIOProcIDWithBlock(&createdProcID, createdAggID, audioTapQueue) { _, inInputData, _, _, _ in
+            let bufferList = UnsafeMutableAudioBufferListPointer(UnsafeMutablePointer(mutating: inInputData))
+            guard bufferList.count > 0 else { return }
+
+            let firstBuf = bufferList[0]
+            guard let rawData = firstBuf.mData, firstBuf.mDataByteSize > 0 else { return }
+            let channelCount = max(1, Int(firstBuf.mNumberChannels))
+            let totalFloats = Int(firstBuf.mDataByteSize) / MemoryLayout<Float>.size
+            let frameCount = totalFloats / channelCount
+            guard frameCount > 0 else { return }
+
+            let floatPtr = rawData.assumingMemoryBound(to: Float.self)
+            var mono = [Float](repeating: 0, count: frameCount)
+
+            if bufferList.count == 1 && channelCount >= 2 {
+                for i in 0..<frameCount {
+                    var sum: Float = 0
+                    for c in 0..<channelCount {
+                        sum += floatPtr[i * channelCount + c]
+                    }
+                    mono[i] = sum / Float(channelCount)
+                }
+            } else if bufferList.count >= 2 {
+                let ch0 = bufferList[0].mData?.assumingMemoryBound(to: Float.self)
+                let ch1 = bufferList[1].mData?.assumingMemoryBound(to: Float.self)
+                for i in 0..<frameCount {
+                    mono[i] = 0.5 * ((ch0?[i] ?? 0) + (ch1?[i] ?? 0))
+                }
+            } else {
+                for i in 0..<frameCount {
+                    mono[i] = floatPtr[i]
+                }
+            }
+
+            let resampled = Self.resampleLinearTo16kHz(mono, fromRate: sampleRate)
+            if !resampled.isEmpty {
+                handler(resampled)
+            }
+        }
+
+        guard ioStatus == noErr, let procID = createdProcID else {
+            stopCoreAudioProcessTap()
+            return false
+        }
+        self.ioProcID = procID
+
+        guard AudioDeviceStart(createdAggID, procID) == noErr else {
+            stopCoreAudioProcessTap()
+            return false
+        }
+        return true
+    }
+
+    private func stopCoreAudioProcessTap() {
+        if let procID = ioProcID, aggregateDeviceID != kAudioObjectUnknown {
+            AudioDeviceStop(aggregateDeviceID, procID)
+            AudioDeviceDestroyIOProcID(aggregateDeviceID, procID)
+        }
+        ioProcID = nil
+        if aggregateDeviceID != kAudioObjectUnknown {
+            AudioHardwareDestroyAggregateDevice(aggregateDeviceID)
+            aggregateDeviceID = AudioObjectID(kAudioObjectUnknown)
+        }
+        if tapID != kAudioObjectUnknown {
+            if #available(macOS 14.2, *) {
+                AudioHardwareDestroyProcessTap(tapID)
+            }
+            tapID = AudioObjectID(kAudioObjectUnknown)
+        }
+    }
+
+    private func getFirstTapInputStreamFormat(for aggDeviceId: AudioObjectID) -> AudioStreamBasicDescription? {
+        var streamsAddr = AudioObjectPropertyAddress(
+            mSelector: kAudioDevicePropertyStreams,
+            mScope: kAudioObjectPropertyScopeInput,
+            mElement: kAudioObjectPropertyElementMain
+        )
+        var dataSize: UInt32 = 0
+        guard AudioObjectGetPropertyDataSize(aggDeviceId, &streamsAddr, 0, nil, &dataSize) == noErr,
+              dataSize >= UInt32(MemoryLayout<AudioStreamID>.size) else {
+            return nil
+        }
+        let streamCount = Int(dataSize) / MemoryLayout<AudioStreamID>.size
+        var streams = [AudioStreamID](repeating: 0, count: streamCount)
+        guard AudioObjectGetPropertyData(aggDeviceId, &streamsAddr, 0, nil, &dataSize, &streams) == noErr,
+              let firstStream = streams.first else {
+            return nil
+        }
+        var formatAddr = AudioObjectPropertyAddress(
+            mSelector: kAudioStreamPropertyVirtualFormat,
+            mScope: kAudioObjectPropertyScopeGlobal,
+            mElement: kAudioObjectPropertyElementMain
+        )
+        var asbd = AudioStreamBasicDescription()
+        var asbdSize = UInt32(MemoryLayout<AudioStreamBasicDescription>.size)
+        guard AudioObjectGetPropertyData(firstStream, &formatAddr, 0, nil, &asbdSize, &asbd) == noErr else {
+            return nil
+        }
+        return asbd
+    }
+
+    private func getNominalSampleRate(deviceId: AudioObjectID) -> Double? {
+        var addr = AudioObjectPropertyAddress(
+            mSelector: kAudioDevicePropertyNominalSampleRate,
+            mScope: kAudioObjectPropertyScopeGlobal,
+            mElement: kAudioObjectPropertyElementMain
+        )
+        var rate: Float64 = 0
+        var size = UInt32(MemoryLayout<Float64>.size)
+        guard AudioObjectGetPropertyData(deviceId, &addr, 0, nil, &size, &rate) == noErr, rate > 0 else {
+            return nil
+        }
+        return rate
+    }
+
+    private func resolveAudioObjectIDs(forPIDs pids: [pid_t]) -> [AudioObjectID] {
+        var result: [AudioObjectID] = []
+        var addr = AudioObjectPropertyAddress(
+            mSelector: kAudioHardwarePropertyTranslatePIDToProcessObject,
+            mScope: kAudioObjectPropertyScopeGlobal,
+            mElement: kAudioObjectPropertyElementMain
+        )
+        for var p in pids {
+            var objID: AudioObjectID = AudioObjectID(kAudioObjectUnknown)
+            var size = UInt32(MemoryLayout<AudioObjectID>.size)
+            let status = AudioObjectGetPropertyData(
+                AudioObjectID(kAudioObjectSystemObject),
+                &addr,
+                UInt32(MemoryLayout<pid_t>.size),
+                &p,
+                &size,
+                &objID
+            )
+            if status == noErr && objID != kAudioObjectUnknown {
+                result.append(objID)
+            }
+        }
+        return result
+    }
+
+    private static func resampleLinearTo16kHz(_ input: [Float], fromRate: Double) -> [Float] {
+        guard !input.isEmpty, fromRate > 0 else { return [] }
+        let targetRate = 16_000.0
+        if abs(fromRate - targetRate) < 1.0 { return input }
+        let ratio = fromRate / targetRate
+        let outLength = max(1, Int(Double(input.count) / ratio))
+        var output = [Float](repeating: 0, count: outLength)
+        for i in 0..<outLength {
+            let srcPos = Double(i) * ratio
+            let idx = Int(srcPos)
+            let frac = Float(srcPos - Double(idx))
+            let s0 = input[min(idx, input.count - 1)]
+            let s1 = input[min(idx + 1, input.count - 1)]
+            output[i] = s0 + frac * (s1 - s0)
+        }
+        return output
+    }
+
+    private func handle(buffer: CMSampleBuffer) {
+        guard CMSampleBufferDataIsReady(buffer),
+              let pcm = pcmBuffer(from: buffer),
+              let resampled = resample(pcm),
+              let chData = resampled.floatChannelData else { return }
+        let count = Int(resampled.frameLength)
+        guard count > 0 else { return }
+        let samples = Array(UnsafeBufferPointer(start: chData[0], count: count))
+        onFrames(samples)
+    }
+
+    private func pcmBuffer(from sampleBuffer: CMSampleBuffer) -> AVAudioPCMBuffer? {
+        guard let formatDesc = CMSampleBufferGetFormatDescription(sampleBuffer),
+              let asbd = CMAudioFormatDescriptionGetStreamBasicDescription(formatDesc),
+              let format = AVAudioFormat(streamDescription: asbd) else { return nil }
+        if sourceFormat != format {
+            sourceFormat = format
+            converter = AVAudioConverter(from: format, to: targetFormat)
+        }
+        let nFrames = AVAudioFrameCount(CMSampleBufferGetNumSamples(sampleBuffer))
+        guard let pcm = AVAudioPCMBuffer(pcmFormat: format, frameCapacity: nFrames) else { return nil }
+        pcm.frameLength = nFrames
+        let status = CMSampleBufferCopyPCMDataIntoAudioBufferList(
+            sampleBuffer, at: 0, frameCount: Int32(nFrames), into: pcm.mutableAudioBufferList
+        )
+        guard status == noErr else { return nil }
+        return pcm
+    }
+
+    private func resample(_ input: AVAudioPCMBuffer) -> AVAudioPCMBuffer? {
+        guard let converter else { return nil }
+        let ratio = targetFormat.sampleRate / input.format.sampleRate
+        let outFrames = AVAudioFrameCount(Double(input.frameLength) * ratio + 16)
+        guard let output = AVAudioPCMBuffer(pcmFormat: targetFormat, frameCapacity: outFrames) else { return nil }
+        var error: NSError?
+        var consumed = false
+        let status = converter.convert(to: output, error: &error) { _, statusOut in
+            if consumed {
+                statusOut.pointee = .noDataNow
+                return nil
+            }
+            consumed = true
+            statusOut.pointee = .haveData
+            return input
+        }
+        if status == .error || error != nil { return nil }
+        return output
+    }
+}
+
+private final class AudioStreamOutput: NSObject, SCStreamOutput {
+    private let handler: (CMSampleBuffer) -> Void
+    init(handler: @escaping (CMSampleBuffer) -> Void) { self.handler = handler }
+    func stream(_ stream: SCStream, didOutputSampleBuffer buffer: CMSampleBuffer, of type: SCStreamOutputType) {
+        guard type == .audio else { return }
+        handler(buffer)
+    }
+}
+
+// MARK: - Live Meeting Capture Session (Streams Audio + Speaker Spans + Roster to SDK)
+
+struct RosterPayload: Encodable {
+    let participants: [Participant]
+    let localUserId: String
+    let localUserName: String
+}
+
+struct SpeakerChangePayload: Encodable {
+    let participantId: String
+    let name: String
+    let t: Double
+    let source: String
+}
+
+struct AudioChunkPayload: Encodable {
+    let pcmBase64: String
+    let t0: Double
+    let t1: Double
+    let sysRMS: Float
+    let micRMS: Float
+    let micActive: Bool
+}
+
+actor CaptureSessionManager {
+    static let shared = CaptureSessionManager()
+
+    private var capture: ProcessAudioCapture?
+    private var nativeScrapeLoop: Task<Void, Never>?
+    private var roster: [Participant] = []
+    private var localUserId: String = "local"
+    private var localUserName: String = ""
+    private var currentSpeakerId: String = ""
+    private var totalAudioSamples: Int = 0
+    private var sessionStart: Double = ProcessInfo.processInfo.systemUptime
+    private var audioStartUptime: Double = 0
+    private var lastSystemAudioUptime: Double = 0
+    private var systemOnlyRMS: Float = 0
+    private var micPendingSamples: [Float] = []
+    private var pcmChunkBuffer: [Float] = []
+    private var pcmChunkStartSample: Int = 0
+
+    func start(target: MeetingTarget) async throws {
+        await stop()
+        roster = []
+        localUserId = "local"
+        localUserName = ""
+        currentSpeakerId = ""
+        totalAudioSamples = 0
+        sessionStart = ProcessInfo.processInfo.systemUptime
+        audioStartUptime = 0
+        lastSystemAudioUptime = 0
+        systemOnlyRMS = 0
+        micPendingSamples.removeAll()
+        pcmChunkBuffer.removeAll()
+        pcmChunkStartSample = 0
+
+        identifyLocalUser(target: target, explicitLocalName: nil)
+        emitEvent("roster", payload: RosterPayload(
+            participants: roster,
+            localUserId: localUserId,
+            localUserName: resolvedLocalUserName()
+        ))
+
+        startNativeScraper(target: target)
+
+        MicActivity.start { micSamples in
+            Task { await CaptureSessionManager.shared.receiveLocalMic(micSamples) }
+        }
+
+        let cap = ProcessAudioCapture(pid: target.pid) { floats in
+            Task { await CaptureSessionManager.shared.feedSystemAudio(floats) }
+        }
+        try await cap.start()
+        self.capture = cap
+    }
+
+    func stop() async {
+        nativeScrapeLoop?.cancel()
+        nativeScrapeLoop = nil
+        if !pcmChunkBuffer.isEmpty {
+            flushPCMChunk()
+        }
+        await capture?.stop()
+        capture = nil
+        MicActivity.stop()
+        micPendingSamples.removeAll()
+        pcmChunkBuffer.removeAll()
+    }
+
+    func handleChromeEvent(_ event: ChromeEvent) async {
+        if let participants = event.participants {
+            let incoming = participants.map { Participant(id: $0.pid, name: $0.name) }
+            mergeRoster(incoming, explicitLocalName: nil)
+        }
+        if let speakerName = event.speaker, !speakerName.isEmpty {
+            let audioNow = currentAudioSeconds()
+            if let match = roster.first(where: { $0.name == speakerName || $0.id == speakerName }) {
+                emitSpeakerActivity(id: match.id, name: match.name, audioTime: audioNow, source: "chrome_ext")
+            } else {
+                emitSpeakerActivity(id: speakerName, name: speakerName, audioTime: audioNow, source: "chrome_ext")
+            }
+        }
+    }
+
+    private func startNativeScraper(target: MeetingTarget) {
+        nativeScrapeLoop?.cancel()
+        nativeScrapeLoop = Task.detached(priority: .utility) {
+            while !Task.isCancelled {
+                if let snap = NativeMeetingScraper.shared.scrape(target: target) {
+                    await CaptureSessionManager.shared.applyScrapeSnapshot(snap)
+                }
+                try? await Task.sleep(nanoseconds: 250_000_000)
+            }
+        }
+    }
+
+    private func applyScrapeSnapshot(_ snap: NativeMeetingScraper.ScrapeSnapshot) {
+        if !snap.participants.isEmpty || (snap.localUserName != nil && !(snap.localUserName?.isEmpty ?? true)) {
+            mergeRoster(snap.participants, explicitLocalName: snap.localUserName)
+        }
+        if let activeName = snap.activeSpeakerName, !activeName.isEmpty {
+            let activeId = snap.activeSpeakerId ?? activeName
+            emitSpeakerActivity(id: activeId, name: activeName, audioTime: currentAudioSeconds(), source: "native_ax")
+        }
+    }
+
+    private func mergeRoster(_ incoming: [Participant], explicitLocalName: String?) {
+        var updatedLocal = false
+        if let explicitLocalName, !explicitLocalName.isEmpty, localUserName != explicitLocalName {
+            localUserName = explicitLocalName
+            updatedLocal = true
+        }
+        var combined = roster
+        var changed = false
+        for p in incoming {
+            if let idx = combined.firstIndex(where: { $0.id == p.id || $0.name.localizedCaseInsensitiveCompare(p.name) == .orderedSame }) {
+                if combined[idx] != p {
+                    combined[idx] = p
+                    changed = true
+                }
+            } else {
+                combined.append(p)
+                changed = true
+            }
+        }
+        if changed || updatedLocal || roster.isEmpty {
+            roster = combined
+            refreshLocalUserMapping()
+            emitEvent("roster", payload: RosterPayload(
+                participants: roster,
+                localUserId: localUserId,
+                localUserName: resolvedLocalUserName()
+            ))
+        }
+    }
+
+    private func emitSpeakerActivity(id: String, name: String, audioTime: Double, source: String) {
+        emitEvent("speaker_activity", payload: SpeakerChangePayload(
+            participantId: id,
+            name: name,
+            t: audioTime,
+            source: source
+        ))
+        if currentSpeakerId != id {
+            currentSpeakerId = id
+            emitEvent("speaker_change", payload: SpeakerChangePayload(
+                participantId: id,
+                name: name,
+                t: audioTime,
+                source: source
+            ))
+        }
+    }
+
+    private func currentAudioSeconds() -> Double {
+        if totalAudioSamples > 0 {
+            return Double(totalAudioSamples) / 16000.0
+        }
+        let ref = audioStartUptime > 0 ? audioStartUptime : sessionStart
+        return max(0, ProcessInfo.processInfo.systemUptime - ref)
+    }
+
+    private func feedSystemAudio(_ sysFloats: [Float]) {
+        guard !sysFloats.isEmpty else { return }
+        let now = ProcessInfo.processInfo.systemUptime
+        lastSystemAudioUptime = now
+
+        var sum: Float = 0
+        for s in sysFloats { sum += s * s }
+        let rms = sqrt(sum / Float(sysFloats.count))
+        systemOnlyRMS = rms
+
+        var mixed = sysFloats
+        if !micPendingSamples.isEmpty {
+            let mixCount = min(mixed.count, micPendingSamples.count)
+            if rms < 0.018 && MicActivity.currentRMS() >= 0.022 {
+                for i in 0..<mixCount {
+                    let v = mixed[i] + micPendingSamples[i]
+                    mixed[i] = max(-1.0, min(1.0, v))
+                }
+            }
+            micPendingSamples.removeFirst(mixCount)
+        }
+
+        appendSamples(mixed)
+    }
+
+    private func receiveLocalMic(_ micFloats: [Float]) {
+        guard !micFloats.isEmpty else { return }
+        var sum: Float = 0
+        for s in micFloats { sum += s * s }
+        let micRMS = sqrt(sum / Float(micFloats.count))
+
+        let now = ProcessInfo.processInfo.systemUptime
+        let sysIdle = lastSystemAudioUptime == 0 || (now - lastSystemAudioUptime) > 0.20
+
+        if sysIdle {
+            if !micPendingSamples.isEmpty {
+                micPendingSamples.removeAll(keepingCapacity: true)
+            }
+            if micRMS >= 0.022 {
+                appendSamples(micFloats)
+            }
+        } else if micRMS >= 0.022 {
+            micPendingSamples.append(contentsOf: micFloats)
+            if micPendingSamples.count > 16_000 {
+                micPendingSamples.removeFirst(micPendingSamples.count - 16_000)
+            }
+        } else {
+            micPendingSamples.removeAll(keepingCapacity: true)
+        }
+
+        if micRMS > 0.022 && (systemOnlyRMS < 0.012 || micRMS > systemOnlyRMS * 1.8) {
+            let id = localUserId.isEmpty ? "local" : localUserId
+            emitSpeakerActivity(id: id, name: resolvedLocalUserName(), audioTime: currentAudioSeconds(), source: "mic")
+        }
+    }
+
+    private func appendSamples(_ floats: [Float]) {
+        guard !floats.isEmpty else { return }
+        if audioStartUptime == 0 {
+            audioStartUptime = ProcessInfo.processInfo.systemUptime
+        }
+        if pcmChunkBuffer.isEmpty {
+            pcmChunkStartSample = totalAudioSamples
+        }
+        pcmChunkBuffer.append(contentsOf: floats)
+        totalAudioSamples += floats.count
+
+        // Emit in ~100ms chunks (1600 samples @ 16 kHz)
+        if pcmChunkBuffer.count >= 1600 {
+            flushPCMChunk()
+        }
+    }
+
+    private func flushPCMChunk() {
+        guard !pcmChunkBuffer.isEmpty else { return }
+        let count = pcmChunkBuffer.count
+        let t0 = Double(pcmChunkStartSample) / 16000.0
+        let t1 = Double(pcmChunkStartSample + count) / 16000.0
+
+        var int16Samples = [Int16](repeating: 0, count: count)
+        for i in 0..<count {
+            let clamped = max(-1.0, min(1.0, pcmChunkBuffer[i]))
+            int16Samples[i] = Int16(clamped * 32767.0)
+        }
+        let data = int16Samples.withUnsafeBufferPointer { Data(buffer: $0) }
+        let b64 = data.base64EncodedString()
+        let micRMS = MicActivity.currentRMS()
+        let micActive = micRMS > 0.022 && (systemOnlyRMS < 0.015 || micRMS > systemOnlyRMS * 1.8)
+
+        pcmChunkBuffer.removeAll(keepingCapacity: true)
+        pcmChunkStartSample = totalAudioSamples
+
+        emitEvent("audio", payload: AudioChunkPayload(
+            pcmBase64: b64,
+            t0: t0,
+            t1: t1,
+            sysRMS: systemOnlyRMS,
+            micRMS: micRMS,
+            micActive: micActive
+        ))
+    }
+
+    private func identifyLocalUser(target: MeetingTarget, explicitLocalName: String?) {
+        let extracted = explicitLocalName ?? extractLocalUserName(from: target.title)
+        if !extracted.isEmpty {
+            localUserName = extracted
+        }
+        refreshLocalUserMapping()
+    }
+
+    private func refreshLocalUserMapping() {
+        if !localUserName.isEmpty {
+            if let match = roster.first(where: {
+                $0.name.localizedCaseInsensitiveCompare(localUserName) == .orderedSame ||
+                $0.name.lowercased().hasPrefix(localUserName.lowercased() + " ")
+            }) {
+                localUserId = match.id
+                localUserName = match.name
+            }
+        }
+        if localUserId.isEmpty {
+            localUserId = "local"
+        }
+    }
+
+    private func resolvedLocalUserName() -> String {
+        if let match = roster.first(where: { $0.id == localUserId }) {
+            return match.name
+        }
+        return localUserName.isEmpty ? "You" : localUserName
+    }
+
+    private func extractLocalUserName(from title: String) -> String {
+        let cleaned = NativeMeetingScraper.shared.sanitizeMeetingTitle(title, fallbackCode: nil)
+        let parts = cleaned.components(separatedBy: " - ").map { $0.trimmingCharacters(in: .whitespaces) }.filter { !$0.isEmpty }
+        guard parts.count >= 3, let candidate = parts.last else { return "" }
+        let ignored: Set<String> = [
+            "google chrome", "chrome", "brave", "brave browser", "microsoft edge", "edge",
+            "arc", "vivaldi", "safari", "zoom", "zoom meeting", "microsoft teams", "teams",
+            "microphone recording", "camera recording", "camera and microphone recording",
+            "tab content shared", "audio playing"
+        ]
+        if ignored.contains(candidate.lowercased()) { return "" }
+        return candidate
+    }
+}
+
+// MARK: - Main Entrypoint & Stdio Command Loop
+
+private struct IncomingCommand: Decodable {
+    let id: String
+    let command: String
+    let prompt: Bool?
+    let target: MeetingTarget?
+    let event: ChromeEvent?
+}
+
+@main
+struct AiraCaptureMain {
+    static func main() {
+        // Announce ready on stdout
+        emitEvent("ready", payload: ["status": "ok"])
+
+        // Read newline-delimited JSON commands on background thread
+        DispatchQueue.global(qos: .userInitiated).async {
+            while let line = readLine(strippingNewline: true) {
+                let trimmed = line.trimmingCharacters(in: .whitespacesAndNewlines)
+                if trimmed.isEmpty { continue }
+                guard let data = trimmed.data(using: .utf8),
+                      let cmd = try? JSONDecoder().decode(IncomingCommand.self, from: data) else {
+                    continue
+                }
+                Task {
+                    await handleCommand(cmd)
+                }
+            }
+            // EOF on stdin -> clean shutdown
+            Task {
+                await CaptureSessionManager.shared.stop()
+                await MeetingDetector.shared.stop()
+                _exit(0)
+            }
+        }
+
+        RunLoop.main.run()
+    }
+
+    private static func handleCommand(_ cmd: IncomingCommand) async {
+        switch cmd.command {
+        case "checkPermissions":
+            let perms = await EyesPermissionManager.checkAll(prompt: cmd.prompt ?? false)
+            sendResponse(id: cmd.id, result: perms)
+
+        case "watchMeetings":
+            await MeetingDetector.shared.start()
+            sendResponse(id: cmd.id, result: ["watching": true])
+
+        case "stopWatchingMeetings":
+            await MeetingDetector.shared.stop()
+            sendResponse(id: cmd.id, result: ["watching": false])
+
+        case "startCapture":
+            guard let target = cmd.target else {
+                sendErrorResponse(id: cmd.id, message: "missing target")
+                return
+            }
+            do {
+                try await CaptureSessionManager.shared.start(target: target)
+                sendResponse(id: cmd.id, result: ["started": true])
+            } catch {
+                sendErrorResponse(id: cmd.id, message: error.localizedDescription)
+            }
+
+        case "stopCapture":
+            await CaptureSessionManager.shared.stop()
+            sendResponse(id: cmd.id, result: ["stopped": true])
+
+        case "pushChromeEvent":
+            guard let ev = cmd.event else {
+                sendErrorResponse(id: cmd.id, message: "missing event")
+                return
+            }
+            await CaptureSessionManager.shared.handleChromeEvent(ev)
+            sendResponse(id: cmd.id, result: ["ok": true])
+
+        case "shutdown":
+            await CaptureSessionManager.shared.stop()
+            await MeetingDetector.shared.stop()
+            sendResponse(id: cmd.id, result: ["shutdown": true])
+            _exit(0)
+
+        default:
+            sendErrorResponse(id: cmd.id, message: "unknown command: \(cmd.command)")
+        }
+    }
+}