@hasna/recordings 0.2.10 → 0.2.13

package/src/native/Recordings/RecordingsLib/NativeAppDiagnostics.swift

@@ -1,5 +1,34 @@
 import Foundation
 
+public enum NativeErrorSanitizer {
+    private static let replacements: [(pattern: String, template: String)] = [
+        (#"(?i)\b(?:sk|sess)-[A-Za-z0-9_-]{8,}\b"#, "[REDACTED]"),
+        (#"(?i)(\bBearer\s+)[^\s,;]+"#, "$1[REDACTED]"),
+        (#"(?i)(\bAuthorization\s*:\s*(?:Basic|Digest)\s+)[^;\n]+"#, "$1[REDACTED]"),
+        (#"(?i)(\b[A-Z0-9_]*(?:(?:API|SECRET|PRIVATE)[_-]?KEY|SECRET[_-]?ACCESS[_-]?KEY|ACCESS[_-]?TOKEN|AUTH[_-]?TOKEN|CLIENT[_-]?(?:SECRET|PASSWORD)|PASSWORD|PASSCODE|SECRET|PRIVATE)\s*=\s*)(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^,;\n}]+)"#, "$1[REDACTED]"),
+        (#"(?i)((?:[{,]\s*)"?(?:(?:api|secret|private)[_-]?key|access[_-]?token|auth[_-]?token|client[_-]?(?:secret|password)|password|passcode|token|secret|private)"?\s*:\s*)(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^\s,;}]+)"#, "$1[REDACTED]"),
+        (#"(?i)((?:[?&]|\b)(?:(?:api|secret|private)[_-]?key|access[_-]?token|auth[_-]?token|client[_-]?(?:secret|password)|password|passcode|token|secret|private)=)(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^&\s,;]+)"#, "$1[REDACTED]"),
+        (#"(?i)((?:api\s+key(?:\s+provided)?|client\s+(?:secret|password)|password|passcode|private\s+key|secret(?:\s+key)?)\s*[:=]\s*)(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^,;\n}]+)"#, "$1[REDACTED]"),
+        // Bare "private:" labels a value only at the start of a clause; mid-sentence uses
+        // like "resource is private: access denied" are ordinary error prose and stay.
+        (#"(?i)((?:^|[;,{\n])\s*)(private\s*[:=]\s*)(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^,;\n}]+)"#, "$1$2[REDACTED]"),
+    ]
+
+    public static func sanitize(_ message: String) -> String {
+        replacements.reduce(message) { result, replacement in
+            guard let expression = try? NSRegularExpression(pattern: replacement.pattern) else {
+                return result
+            }
+            let range = NSRange(result.startIndex..<result.endIndex, in: result)
+            return expression.stringByReplacingMatches(
+                in: result,
+                range: range,
+                withTemplate: replacement.template
+            )
+        }
+    }
+}
+
 public enum NativeAppLog {
     private static let lock = NSLock()
 
@@ -9,7 +38,7 @@ public enum NativeAppLog {
 
         let dir = "\(homePath)/.hasna/recordings"
         let path = "\(dir)/Recordings.log"
-        let line = "[\(Self.timestamp())] \(message)\n"
+        let line = "[\(Self.timestamp())] \(NativeErrorSanitizer.sanitize(message))\n"
 
         do {
             try FileManager.default.createDirectory(atPath: dir, withIntermediateDirectories: true)
@@ -24,7 +53,8 @@ public enum NativeAppLog {
                 try line.write(toFile: path, atomically: true, encoding: .utf8)
             }
         } catch {
-            fputs("[Recordings] log write failed: \(error.localizedDescription)\n", stderr)
+            let safeError = NativeErrorSanitizer.sanitize(error.localizedDescription)
+            fputs("[Recordings] log write failed: \(safeError)\n", stderr)
         }
     }
 

package/src/native/Recordings/RecordingsLib/NativeMachineIdentity.swift

@@ -0,0 +1,24 @@
+import Darwin
+import Foundation
+
+public enum NativeMachineIdentity {
+    public static func current(
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        hostName: String? = nil
+    ) -> String {
+        let configured = environment["HASNA_MACHINE_ID"]?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+        if !configured.isEmpty { return configured }
+        return (hostName ?? posixHostName()).trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+
+    static func posixHostName() -> String {
+        var buffer = [CChar](repeating: 0, count: 256)
+        let result = buffer.withUnsafeMutableBufferPointer { pointer -> String? in
+            guard let baseAddress = pointer.baseAddress,
+                  gethostname(baseAddress, pointer.count) == 0 else { return nil }
+            pointer[pointer.count - 1] = 0
+            return String(cString: baseAddress)
+        }
+        return result ?? ProcessInfo.processInfo.hostName
+    }
+}

package/src/native/Recordings/RecordingsLib/NativePCMRecorder.swift

@@ -2,6 +2,7 @@
 import Foundation
 
 enum NativePCMRecorderError: LocalizedError {
+    case alreadyActive
     case noInputDevice
     case unsupportedInputFormat
     case failedToCreateConverter
@@ -9,6 +10,8 @@ enum NativePCMRecorderError: LocalizedError {
 
     var errorDescription: String? {
         switch self {
+        case .alreadyActive:
+            return "Microphone capture is already starting, running, or stopping"
         case .noInputDevice:
             return "No microphone input device is available"
         case .unsupportedInputFormat:
@@ -22,86 +25,300 @@ enum NativePCMRecorderError: LocalizedError {
 }
 
 final class NativePCMRecorder: @unchecked Sendable {
+    private enum LifecycleState: Equatable {
+        case idle
+        case starting
+        case running
+        case stopping
+    }
+
     private let engine = AVAudioEngine()
     private let onPCM: @Sendable (Data) -> Void
+    private let lifecycle = NSCondition()
+    private let conversionLock = NSLock()
+    private let deliveryQueue = DispatchQueue(label: "com.hasna.recordings.native-pcm-delivery")
+    private let deliveryQueueKey = DispatchSpecificKey<UInt8>()
+    private let stopWorkQueue = DispatchQueue(label: "com.hasna.recordings.native-pcm-stop")
+    private let stopCaptureForTesting: (@Sendable () -> Void)?
+    private let startCaptureForTesting: (@Sendable () throws -> Void)?
+    private let onCallbackAdmittedForTesting: (@Sendable () -> Void)?
+    private let finalizeConverter: @Sendable (AVAudioConverter, AVAudioFormat) -> [Data]
     private var converter: AVAudioConverter?
     private var inputFormat: AVAudioFormat?
     private var outputFormat: AVAudioFormat?
-    private var started = false
+    private var state = LifecycleState.idle
+    private var acceptingCallbacks = false
+    private var inFlightCallbacks = 0
 
     init(onPCM: @escaping @Sendable (Data) -> Void) {
         self.onPCM = onPCM
+        self.stopCaptureForTesting = nil
+        self.startCaptureForTesting = nil
+        self.onCallbackAdmittedForTesting = nil
+        self.finalizeConverter = Self.finalizeConverterTail
+        deliveryQueue.setSpecific(key: deliveryQueueKey, value: 1)
+    }
+
+    init(
+        testingInputFormat: AVAudioFormat,
+        outputFormat: AVAudioFormat,
+        converter: AVAudioConverter,
+        stopCapture: @escaping @Sendable () -> Void,
+        startCapture: (@Sendable () throws -> Void)? = nil,
+        onCallbackAdmitted: @escaping @Sendable () -> Void,
+        finalizeConverter: @escaping @Sendable (AVAudioConverter, AVAudioFormat) -> [Data],
+        startsRunning: Bool = true,
+        onPCM: @escaping @Sendable (Data) -> Void
+    ) {
+        self.onPCM = onPCM
+        self.stopCaptureForTesting = stopCapture
+        self.startCaptureForTesting = startCapture
+        self.onCallbackAdmittedForTesting = onCallbackAdmitted
+        self.finalizeConverter = finalizeConverter
+        self.converter = converter
+        self.inputFormat = testingInputFormat
+        self.outputFormat = outputFormat
+        self.state = startsRunning ? .running : .idle
+        self.acceptingCallbacks = startsRunning
+        deliveryQueue.setSpecific(key: deliveryQueueKey, value: 1)
     }
 
     func start() throws {
-        guard !started else { return }
+        try reserveStart()
+
+        if let startCaptureForTesting {
+            do {
+                try startCaptureForTesting()
+                finishStart()
+            } catch {
+                resetAfterStartFailure()
+                throw NativePCMRecorderError.failedToStart(error.localizedDescription)
+            }
+            return
+        }
 
         let inputNode = engine.inputNode
         let inputFormat = inputNode.inputFormat(forBus: 0)
         guard inputFormat.channelCount > 0 else {
+            abandonStart()
             throw NativePCMRecorderError.noInputDevice
         }
         guard inputFormat.sampleRate > 0 else {
+            abandonStart()
             throw NativePCMRecorderError.unsupportedInputFormat
         }
         guard let outputFormat = Self.realtimeOutputFormat() else {
+            abandonStart()
             throw NativePCMRecorderError.unsupportedInputFormat
         }
         guard let converter = AVAudioConverter(from: inputFormat, to: outputFormat) else {
+            abandonStart()
             throw NativePCMRecorderError.failedToCreateConverter
         }
 
+        lifecycle.lock()
         self.converter = converter
         self.inputFormat = inputFormat
         self.outputFormat = outputFormat
+        lifecycle.unlock()
 
         inputNode.installTap(onBus: 0, bufferSize: 1_024, format: inputFormat) { [weak self] buffer, _ in
-            self?.convertAndEmit(buffer)
+            self?.processInputBuffer(buffer)
         }
 
         do {
             engine.prepare()
             try engine.start()
-            started = true
+            finishStart()
         } catch {
             inputNode.removeTap(onBus: 0)
-            self.converter = nil
-            self.inputFormat = nil
-            self.outputFormat = nil
+            resetAfterStartFailure()
             throw NativePCMRecorderError.failedToStart(error.localizedDescription)
         }
     }
 
-    func stop() {
-        guard started else {
-            converter = nil
-            inputFormat = nil
-            outputFormat = nil
-            return
+    private func reserveStart() throws {
+        lifecycle.lock()
+        guard state == .idle else {
+            lifecycle.unlock()
+            throw NativePCMRecorderError.alreadyActive
         }
+        state = .starting
+        lifecycle.unlock()
+    }
 
-        engine.inputNode.removeTap(onBus: 0)
-        engine.stop()
+    private func finishStart() {
+        lifecycle.lock()
+        acceptingCallbacks = true
+        state = .running
+        lifecycle.broadcast()
+        lifecycle.unlock()
+    }
+
+    private func resetAfterStartFailure() {
+        lifecycle.lock()
         converter = nil
         inputFormat = nil
         outputFormat = nil
-        started = false
+        state = .idle
+        acceptingCallbacks = false
+        lifecycle.broadcast()
+        lifecycle.unlock()
+    }
+
+    func stop() {
+        let isReentrantDelivery = DispatchQueue.getSpecific(key: deliveryQueueKey) != nil
+        lifecycle.lock()
+        while state == .starting || (state == .stopping && !isReentrantDelivery) {
+            lifecycle.wait()
+        }
+        guard state == .running else {
+            lifecycle.unlock()
+            return
+        }
+        acceptingCallbacks = false
+        state = .stopping
+        lifecycle.unlock()
+
+        if isReentrantDelivery {
+            stopWorkQueue.async { [self] in
+                stopCaptureAndFinish()
+            }
+        } else {
+            stopCaptureAndFinish()
+        }
+    }
+
+    private func stopCaptureAndFinish() {
+        if let stopCaptureForTesting {
+            stopCaptureForTesting()
+        } else {
+            engine.inputNode.removeTap(onBus: 0)
+            engine.stop()
+        }
+
+        lifecycle.lock()
+        while inFlightCallbacks > 0 {
+            lifecycle.wait()
+        }
+        let converter = converter
+        let outputFormat = outputFormat
+        lifecycle.unlock()
+
+        if let converter, let outputFormat {
+            conversionLock.lock()
+            let tailChunks = finalizeConverter(converter, outputFormat)
+            conversionLock.unlock()
+            for data in tailChunks where !data.isEmpty {
+                deliverPCM(data)
+            }
+        }
+
+        lifecycle.lock()
+        self.converter = nil
+        inputFormat = nil
+        self.outputFormat = nil
+        state = .idle
+        lifecycle.broadcast()
+        lifecycle.unlock()
     }
 
     deinit {
         stop()
     }
 
-    private func convertAndEmit(_ inputBuffer: AVAudioPCMBuffer) {
-        guard let converter, let inputFormat, let outputFormat else { return }
+    private func abandonStart() {
+        lifecycle.lock()
+        state = .idle
+        acceptingCallbacks = false
+        lifecycle.broadcast()
+        lifecycle.unlock()
+    }
 
+    func processInputBufferForTesting(_ inputBuffer: AVAudioPCMBuffer) {
+        processInputBuffer(inputBuffer)
+    }
+
+    func deliverPCMForTesting(_ data: Data) {
+        lifecycle.lock()
+        guard acceptingCallbacks else {
+            lifecycle.unlock()
+            return
+        }
+        inFlightCallbacks += 1
+        lifecycle.unlock()
+
+        defer { finishCallback() }
+        deliverPCM(data)
+    }
+
+    var isIdleForTesting: Bool {
+        lifecycle.lock()
+        defer { lifecycle.unlock() }
+        return state == .idle
+    }
+
+    private func processInputBuffer(_ inputBuffer: AVAudioPCMBuffer) {
+        lifecycle.lock()
+        guard acceptingCallbacks,
+              let converter,
+              let inputFormat,
+              let outputFormat else {
+            lifecycle.unlock()
+            return
+        }
+        inFlightCallbacks += 1
+        lifecycle.unlock()
+
+        onCallbackAdmittedForTesting?()
+
+        defer { finishCallback() }
+
+        conversionLock.lock()
+        let data = convert(
+            inputBuffer,
+            converter: converter,
+            inputFormat: inputFormat,
+            outputFormat: outputFormat
+        )
+        conversionLock.unlock()
+        if !data.isEmpty {
+            deliverPCM(data)
+        }
+    }
+
+    private func deliverPCM(_ data: Data) {
+        if DispatchQueue.getSpecific(key: deliveryQueueKey) != nil {
+            onPCM(data)
+        } else {
+            deliveryQueue.sync {
+                onPCM(data)
+            }
+        }
+    }
+
+    private func finishCallback() {
+        lifecycle.lock()
+        inFlightCallbacks -= 1
+        if inFlightCallbacks == 0 {
+            lifecycle.broadcast()
+        }
+        lifecycle.unlock()
+    }
+
+    private func convert(
+        _ inputBuffer: AVAudioPCMBuffer,
+        converter: AVAudioConverter,
+        inputFormat: AVAudioFormat,
+        outputFormat: AVAudioFormat
+    ) -> Data {
         let sampleRateRatio = outputFormat.sampleRate / inputFormat.sampleRate
         let estimatedFrames = AVAudioFrameCount(Double(inputBuffer.frameLength) * sampleRateRatio) + 512
         guard let outputBuffer = AVAudioPCMBuffer(
             pcmFormat: outputFormat,
             frameCapacity: max(estimatedFrames, 1)
         ) else {
-            return
+            return Data()
         }
 
         let inputSource = AudioConverterInputSource(buffer: inputBuffer)
@@ -110,11 +327,33 @@ final class NativePCMRecorder: @unchecked Sendable {
             inputSource.next(status: status)
         }
 
-        guard conversionError == nil else { return }
-        let data = Self.extractPCM16Data(from: outputBuffer)
-        if !data.isEmpty {
-            onPCM(data)
+        guard conversionError == nil else { return Data() }
+        return Self.extractPCM16Data(from: outputBuffer)
+    }
+
+    static func finalizeConverterTail(_ converter: AVAudioConverter, outputFormat: AVAudioFormat) -> [Data] {
+        var chunks: [Data] = []
+        while let outputBuffer = AVAudioPCMBuffer(pcmFormat: outputFormat, frameCapacity: 4_096) {
+            var conversionError: NSError?
+            let status = converter.convert(to: outputBuffer, error: &conversionError) { _, inputStatus in
+                inputStatus.pointee = .endOfStream
+                return nil
+            }
+            guard conversionError == nil else { break }
+            let data = extractPCM16Data(from: outputBuffer)
+            if !data.isEmpty {
+                chunks.append(data)
+            }
+            switch status {
+            case .haveData:
+                guard !data.isEmpty else { return chunks }
+            case .inputRanDry, .endOfStream, .error:
+                return chunks
+            @unknown default:
+                return chunks
+            }
         }
+        return chunks
     }
 
     static func realtimeOutputFormat() -> AVAudioFormat? {

package/src/native/Recordings/RecordingsLib/OpenAIAPIKeyStore.swift

@@ -1,5 +1,15 @@
 import Foundation
 
+struct ProcessingModelSelection: Equatable, Sendable {
+    let transcriptionPrompt: String
+    let transcriptionModel: String
+    let transcriberModel: String
+    let enhancementModel: String
+    let intentModel: String
+    let enhanceTriggersJSON: String
+    let keywordTransformsJSON: String
+}
+
 enum OpenAIAPIKeyStore {
     static let defaultLanguage = "en"
 
@@ -40,6 +50,52 @@ enum OpenAIAPIKeyStore {
         return defaultLanguage
     }
 
+    static func loadProcessingModelSelection(
+        homePath: String,
+        environment: [String: String] = ProcessInfo.processInfo.environment
+    ) -> ProcessingModelSelection {
+        let json = loadMutableConfig(homePath: homePath)
+        let enhancementModel = firstNonEmpty(
+            environment["RECORDINGS_ENHANCEMENT_MODEL"],
+            json["enhancement_model"] as? String
+        ) ?? "gpt-4o"
+        let transcriberModel = firstNonEmpty(
+            environment["RECORDINGS_TRANSCRIBER_MODEL"],
+            json["transcriber_model"] as? String,
+            enhancementModel
+        ) ?? enhancementModel
+        let transcriptionModel = firstNonEmpty(
+            environment["RECORDINGS_MODEL"],
+            json["transcription_model"] as? String
+        ) ?? "gpt-4o-transcribe"
+        let intentModel = firstNonEmpty(
+            environment["RECORDINGS_INTENT_MODEL"],
+            json["intent_model"] as? String
+        ) ?? "gpt-4o-mini"
+        let triggers = (json["enhance_triggers"] as? [String]) ?? [
+            "say it better", "rewrite this", "make it sound", "clean this up",
+            "fix this", "rephrase", "write it properly", "make it professional",
+            "improve this", "polish this",
+        ]
+        let triggerData = try? JSONSerialization.data(withJSONObject: triggers)
+        let triggerJSON = triggerData.flatMap { String(data: $0, encoding: .utf8) } ?? "[]"
+        let keywordTransforms = (json["keyword_transforms"] as? [String: String]) ?? [:]
+        let transformData = try? JSONSerialization.data(withJSONObject: keywordTransforms)
+        let transformJSON = transformData.flatMap { String(data: $0, encoding: .utf8) } ?? "{}"
+        return ProcessingModelSelection(
+            transcriptionPrompt: firstNonEmpty(
+                environment["RECORDINGS_TRANSCRIPTION_PROMPT"],
+                json["transcription_prompt"] as? String
+            ) ?? "",
+            transcriptionModel: transcriptionModel,
+            transcriberModel: transcriberModel,
+            enhancementModel: enhancementModel,
+            intentModel: intentModel,
+            enhanceTriggersJSON: triggerJSON,
+            keywordTransformsJSON: transformJSON
+        )
+    }
+
     /// Persist the key into ~/.hasna/recordings/config.json so the CLI (which the app
     /// shells out to for final transcription) uses the same key as the app itself.
     static func save(key: String, homePath: String) throws {

package/src/native/Recordings/RecordingsLib/PermissionRequestLaunchPlan.swift

@@ -0,0 +1,56 @@
+import Foundation
+
+public struct PermissionRequestLaunchPlan: Sendable, Equatable {
+    public let isHelper: Bool
+    public let opensPermissionSettings: Bool
+    public let runtimeSmokeMode: String?
+    public let runtimeSmokeOutputPath: String?
+    public let runtimeSmokeAcknowledgementPath: String?
+    public let runtimeSmokeCompletionPath: String?
+
+    public var isRuntimeSmoke: Bool { runtimeSmokeMode != nil }
+    public var installsGlobalHandlers: Bool { !isHelper && !isRuntimeSmoke }
+    public var declaresMainWindow: Bool { !isHelper && !isRuntimeSmoke }
+    public var declaresMenuBar: Bool {
+        if isRuntimeSmoke { return runtimeSmokeMode == "normal" }
+        return !isHelper
+    }
+    public var terminatesAfterHandling: Bool { isHelper }
+    public var requestsAccessibilityPrompt: Bool { isHelper && !isRuntimeSmoke }
+
+    public init(arguments: [String]) {
+        isHelper = arguments.contains("--request-permissions")
+        opensPermissionSettings = isHelper && arguments.contains("--open-permission-settings")
+        runtimeSmokeMode = Self.optionValue("--runtime-smoke", arguments: arguments)
+        runtimeSmokeOutputPath = Self.optionValue("--runtime-smoke-output", arguments: arguments)
+        runtimeSmokeAcknowledgementPath = Self.optionValue(
+            "--runtime-smoke-ack",
+            arguments: arguments
+        )
+        runtimeSmokeCompletionPath = Self.optionValue(
+            "--runtime-smoke-completion",
+            arguments: arguments
+        )
+    }
+
+    private static func optionValue(_ name: String, arguments: [String]) -> String? {
+        guard let index = arguments.firstIndex(of: name), arguments.indices.contains(index + 1) else {
+            return nil
+        }
+        return arguments[index + 1]
+    }
+}
+
+public struct PermissionRequestOutcome: Sendable, Equatable {
+    public let microphoneGranted: Bool
+    public let accessibilityTrusted: Bool
+
+    public init(microphoneGranted: Bool, accessibilityTrusted: Bool) {
+        self.microphoneGranted = microphoneGranted
+        self.accessibilityTrusted = accessibilityTrusted
+    }
+
+    public var succeeded: Bool {
+        microphoneGranted && accessibilityTrusted
+    }
+}