@hasna/recordings 0.1.11 → 0.1.12

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@hasna/recordings",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "type": "module",
   "description": "Speech-to-text recording tool with MCP and CLI — records, transcribes, and optionally enhances text using AI",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hasna/recordings.git"
+  },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
@@ -25,8 +29,21 @@
     "test:coverage": "bun test --coverage",
     "dev:cli": "bun run src/cli/index.ts",
     "dev:mcp": "bun run src/mcp/index.ts",
-    "postinstall": "mkdir -p $HOME/.hasna/recordings/audio 2>/dev/null || true"
+    "prepack": "bun run build",
+    "postinstall": "bash scripts/install_macos_app.sh --postinstall"
   },
+  "files": [
+    "dist/",
+    "scripts/",
+    "src/native/Recordings/App/",
+    "src/native/Recordings/RecordingsLib/",
+    "src/native/Recordings/RecordingsTests/",
+    "src/native/Recordings/Package.swift",
+    "src/native/Recordings/Package.resolved",
+    "src/native/Recordings/build.sh",
+    "README.md",
+    "LICENSE"
+  ],
   "dependencies": {
     "@hasna/cloud": "^0.1.24",
     "@modelcontextprotocol/sdk": "^1.12.1",
@@ -45,4 +62,4 @@
   },
   "license": "Apache-2.0",
   "author": "Hasna <andrei@hasna.com>"
-}
+}

package/scripts/install_macos_app.sh

@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+set -u
+
+MODE="release"
+POSTINSTALL=0
+
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --mode)
+      MODE="${2:-release}"
+      shift 2
+      ;;
+    --postinstall)
+      POSTINSTALL=1
+      shift
+      ;;
+    *)
+      echo "Unknown argument: $1" >&2
+      exit 2
+      ;;
+  esac
+done
+
+case "$MODE" in
+  debug|release) ;;
+  *)
+    echo "Mode must be debug or release" >&2
+    exit 2
+    ;;
+esac
+
+PACKAGE_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+DATA_DIR="${HOME}/.hasna/recordings"
+NATIVE_DIR="${PACKAGE_ROOT}/src/native/Recordings"
+APP_SOURCE="${NATIVE_DIR}/.build/${MODE}/Recordings.app"
+APP_DEST="${DATA_DIR}/Recordings.app"
+
+mkdir -p "${DATA_DIR}/audio"
+
+if [ "$(uname -s)" != "Darwin" ]; then
+  exit 0
+fi
+
+warn_or_fail() {
+  local message="$1"
+  if [ "$POSTINSTALL" -eq 1 ]; then
+    echo "Recordings.app was not installed: ${message}" >&2
+    echo "Run 'recordings app install' after fixing this machine." >&2
+    exit 0
+  fi
+  echo "${message}" >&2
+  exit 1
+}
+
+if ! command -v swift >/dev/null 2>&1; then
+  warn_or_fail "Swift toolchain not found"
+fi
+
+if [ ! -d "$NATIVE_DIR" ]; then
+  warn_or_fail "native app sources are missing from package: ${NATIVE_DIR}"
+fi
+
+(
+  cd "$NATIVE_DIR" || exit 1
+  ./build.sh "$MODE"
+) || warn_or_fail "native app build failed"
+
+if [ ! -d "$APP_SOURCE" ]; then
+  warn_or_fail "native build did not produce ${APP_SOURCE}"
+fi
+
+rm -rf "$APP_DEST"
+mkdir -p "$DATA_DIR"
+cp -R "$APP_SOURCE" "$APP_DEST" || warn_or_fail "failed to copy app bundle"
+
+echo "Installed Recordings.app from package: ${APP_DEST}"

package/src/native/Recordings/{Recordings → App}/RecordingsApp.swift

@@ -1,6 +1,7 @@
 @preconcurrency import Cocoa
 import SwiftUI
 import KeyboardShortcuts
+import RecordingsLib
 
 @main
 struct RecordingsApp: App {
@@ -18,7 +19,10 @@ struct RecordingsApp: App {
         MenuBarExtra {
             MenuBarPopover(engine: engine, shortcuts: shortcuts, projectStore: projectStore)
                 .frame(width: 320, height: 420)
-                .onAppear { engine.projectStore = projectStore }
+                .onAppear {
+                    engine.projectStore = projectStore
+                    engine.voiceShortcuts = shortcuts
+                }
         } label: {
             if engine.isRecording {
                 Image(systemName: "record.circle.fill")

package/src/native/Recordings/Package.resolved

@@ -1,5 +1,5 @@
 {
-  "originHash" : "a6c896b6f831f2130914352c7417e95b036b1f02a1ff70318f1f4e5aa8966e9b",
+  "originHash" : "99390ba8c7a8c4d4b60ff9bc6f60500c0cc28740d0a509ae347d8785b97022b5",
   "pins" : [
     {
       "identity" : "keyboardshortcuts",
@@ -9,6 +9,24 @@
         "revision" : "1aef85578fdd4f9eaeeb8d53b7b4fc31bf08fe27",
         "version" : "2.4.0"
       }
+    },
+    {
+      "identity" : "swift-syntax",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/swiftlang/swift-syntax.git",
+      "state" : {
+        "revision" : "0687f71944021d616d34d922343dcef086855920",
+        "version" : "600.0.1"
+      }
+    },
+    {
+      "identity" : "swift-testing",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-testing.git",
+      "state" : {
+        "revision" : "399f76dcd91e4c688ca2301fa24a8cc6d9927211",
+        "version" : "0.99.0"
+      }
     }
   ],
   "version" : 3

package/src/native/Recordings/Package.swift

@@ -8,14 +8,25 @@ let package = Package(
         .macOS(.v26)
     ],
     dependencies: [
-        .package(url: "https://github.com/sindresorhus/KeyboardShortcuts", from: "2.0.0")
+        .package(url: "https://github.com/sindresorhus/KeyboardShortcuts", from: "2.0.0"),
+        .package(url: "https://github.com/apple/swift-testing.git", .upToNextMinor(from: "0.99.0")),
     ],
     targets: [
-        .executableTarget(
-            name: "Recordings",
+        .target(
+            name: "RecordingsLib",
             dependencies: ["KeyboardShortcuts"],
-            path: "Recordings",
+            path: "RecordingsLib",
             exclude: ["Info.plist", "Recordings.entitlements"]
-        )
+        ),
+        .executableTarget(
+            name: "App",
+            dependencies: ["RecordingsLib"],
+            path: "App"
+        ),
+        .testTarget(
+            name: "RecordingsTests",
+            dependencies: ["RecordingsLib", .product(name: "Testing", package: "swift-testing")],
+            path: "RecordingsTests"
+        ),
     ]
 )

package/src/native/Recordings/{Recordings → RecordingsLib}/Info.plist

@@ -8,15 +8,21 @@
     <string>Recordings</string>
     <key>CFBundleDisplayName</key>
     <string>Recordings</string>
+    <key>CFBundleExecutable</key>
+    <string>Recordings</string>
     <key>CFBundleIdentifier</key>
     <string>com.hasna.recordings</string>
     <key>CFBundleVersion</key>
     <string>1</string>
+    <key>CFBundlePackageType</key>
+    <string>APPL</string>
     <key>CFBundleShortVersionString</key>
     <string>0.1.0</string>
     <key>LSMinimumSystemVersion</key>
     <string>26.0</string>
     <key>NSMicrophoneUsageDescription</key>
     <string>Recordings needs microphone access to record and transcribe your speech.</string>
+    <key>NSAppleEventsUsageDescription</key>
+    <string>Recordings needs Apple Events access to paste transcribed text into your active app.</string>
 </dict>
 </plist>

package/src/native/Recordings/{Recordings → RecordingsLib}/MenuBarPopover.swift

@@ -1,13 +1,19 @@
 import SwiftUI
 import KeyboardShortcuts
 
-struct MenuBarPopover: View {
-    @ObservedObject var engine: RecordingEngine
-    @ObservedObject var shortcuts: VoiceShortcuts
-    @ObservedObject var projectStore: ProjectStore
+public struct MenuBarPopover: View {
+    @ObservedObject public var engine: RecordingEngine
+    @ObservedObject public var shortcuts: VoiceShortcuts
+    @ObservedObject public var projectStore: ProjectStore
     @State private var copiedIndex: Int?
     @State private var filterProjectId: String?
 
+    public init(engine: RecordingEngine, shortcuts: VoiceShortcuts, projectStore: ProjectStore) {
+        self.engine = engine
+        self.shortcuts = shortcuts
+        self.projectStore = projectStore
+    }
+
     private var filteredTranscriptions: [TranscriptionResult] {
         guard let filter = filterProjectId else {
             return engine.recentTranscriptions
@@ -18,13 +24,15 @@ struct MenuBarPopover: View {
         return engine.recentTranscriptions.filter { $0.projectId == filter }
     }
 
-    var body: some View {
+    public var body: some View {
         VStack(spacing: 0) {
             header
                 .padding(.horizontal, 16).padding(.top, 12).padding(.bottom, 8)
             Divider()
+            modePicker
+                .padding(.horizontal, 16).padding(.top, 10)
             recordingArea
-                .padding(.horizontal, 16).padding(.vertical, 12)
+                .padding(.horizontal, 16).padding(.top, 8).padding(.bottom, 12)
             Divider()
             if !engine.recentTranscriptions.isEmpty {
                 filterBar
@@ -85,9 +93,20 @@ struct MenuBarPopover: View {
 
     // MARK: - Recording Area
 
+    private var modePicker: some View {
+        Picker("Mode", selection: $engine.mode) {
+            ForEach(RecordingMode.allCases) { mode in
+                Image(systemName: mode.icon)
+                    .tag(mode)
+                    .help(mode.rawValue)
+            }
+        }
+        .pickerStyle(.segmented)
+    }
+
+    @ViewBuilder
     private var recordingArea: some View {
-        Group {
-            if engine.isRecording {
+        if engine.isRecording {
                 VStack(spacing: 6) {
                     HStack {
                         Circle().fill(.red).frame(width: 8, height: 8)
@@ -97,6 +116,18 @@ struct MenuBarPopover: View {
                         Button("Stop") { engine.stopAndTranscribe() }
                             .controlSize(.small)
                     }
+                    // Live streaming transcription text
+                    if !engine.liveTranscriptionText.isEmpty {
+                        Text(engine.liveTranscriptionText)
+                            .font(.callout)
+                            .foregroundStyle(.primary)
+                            .multilineTextAlignment(.leading)
+                            .lineLimit(3)
+                            .padding(.vertical, 4)
+                        Text("Listening...")
+                            .font(.caption)
+                            .foregroundStyle(.green)
+                    }
                     if let project = projectStore.activeProject {
                         HStack(spacing: 4) {
                             Image(systemName: "folder.fill").foregroundStyle(.tint)
@@ -107,7 +138,7 @@ struct MenuBarPopover: View {
                 }
                 .padding(10)
                 .glassEffect(.regular)
-            } else if engine.isTranscribing {
+        } else if engine.isTranscribing {
                 VStack(spacing: 6) {
                     HStack(spacing: 8) {
                         ProgressView().controlSize(.small)
@@ -115,6 +146,15 @@ struct MenuBarPopover: View {
                             .foregroundStyle(.secondary)
                         Spacer()
                     }
+                    // Show accumulated text during transcribing
+                    if !engine.liveTranscriptionText.isEmpty {
+                        Text(engine.liveTranscriptionText)
+                            .font(.callout)
+                            .foregroundStyle(.primary)
+                            .multilineTextAlignment(.leading)
+                            .lineLimit(3)
+                            .padding(.vertical, 4)
+                    }
                     if let project = projectStore.activeProject {
                         HStack(spacing: 4) {
                             Image(systemName: "folder.fill").foregroundStyle(.tint)
@@ -126,7 +166,7 @@ struct MenuBarPopover: View {
                 .frame(maxWidth: .infinity)
                 .padding(10)
                 .glassEffect(.regular)
-            } else {
+        } else {
                 VStack(spacing: 6) {
                     Button { engine.startRecording() } label: {
                         Label("Record", systemImage: "mic.circle.fill")
@@ -137,11 +177,15 @@ struct MenuBarPopover: View {
                         Text("or hold \(shortcut.description)")
                             .foregroundStyle(.tertiary)
                     }
+                    Text(engine.statusMessage)
+                        .font(.caption)
+                        .foregroundStyle(engine.statusMessage == "Ready" ? Color.secondary : Color.orange)
+                        .multilineTextAlignment(.center)
+                        .lineLimit(2)
                 }
                 .frame(maxWidth: .infinity)
                 .padding(10)
                 .glassEffect(.regular)
-            }
         }
     }
 

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

@@ -0,0 +1,164 @@
+@preconcurrency import AVFoundation
+import Foundation
+
+enum NativePCMRecorderError: LocalizedError {
+    case noInputDevice
+    case unsupportedInputFormat
+    case failedToCreateConverter
+    case failedToStart(String)
+
+    var errorDescription: String? {
+        switch self {
+        case .noInputDevice:
+            return "No microphone input device is available"
+        case .unsupportedInputFormat:
+            return "The selected microphone format is not supported"
+        case .failedToCreateConverter:
+            return "Could not prepare microphone audio conversion"
+        case .failedToStart(let message):
+            return "Could not start microphone capture: \(message)"
+        }
+    }
+}
+
+final class NativePCMRecorder: @unchecked Sendable {
+    private let engine = AVAudioEngine()
+    private let onPCM: @Sendable (Data) -> Void
+    private var converter: AVAudioConverter?
+    private var inputFormat: AVAudioFormat?
+    private var outputFormat: AVAudioFormat?
+    private var started = false
+
+    init(onPCM: @escaping @Sendable (Data) -> Void) {
+        self.onPCM = onPCM
+    }
+
+    func start() throws {
+        guard !started else { return }
+
+        let inputNode = engine.inputNode
+        let inputFormat = inputNode.inputFormat(forBus: 0)
+        guard inputFormat.channelCount > 0 else {
+            throw NativePCMRecorderError.noInputDevice
+        }
+        guard inputFormat.sampleRate > 0 else {
+            throw NativePCMRecorderError.unsupportedInputFormat
+        }
+        guard let outputFormat = Self.realtimeOutputFormat() else {
+            throw NativePCMRecorderError.unsupportedInputFormat
+        }
+        guard let converter = AVAudioConverter(from: inputFormat, to: outputFormat) else {
+            throw NativePCMRecorderError.failedToCreateConverter
+        }
+
+        self.converter = converter
+        self.inputFormat = inputFormat
+        self.outputFormat = outputFormat
+
+        inputNode.installTap(onBus: 0, bufferSize: 1_024, format: inputFormat) { [weak self] buffer, _ in
+            self?.convertAndEmit(buffer)
+        }
+
+        do {
+            engine.prepare()
+            try engine.start()
+            started = true
+        } catch {
+            inputNode.removeTap(onBus: 0)
+            self.converter = nil
+            self.inputFormat = nil
+            self.outputFormat = nil
+            throw NativePCMRecorderError.failedToStart(error.localizedDescription)
+        }
+    }
+
+    func stop() {
+        guard started else {
+            converter = nil
+            inputFormat = nil
+            outputFormat = nil
+            return
+        }
+
+        engine.inputNode.removeTap(onBus: 0)
+        engine.stop()
+        converter = nil
+        inputFormat = nil
+        outputFormat = nil
+        started = false
+    }
+
+    deinit {
+        stop()
+    }
+
+    private func convertAndEmit(_ inputBuffer: AVAudioPCMBuffer) {
+        guard let converter, let inputFormat, let outputFormat else { return }
+
+        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
+        }
+
+        let inputSource = AudioConverterInputSource(buffer: inputBuffer)
+        var conversionError: NSError?
+        converter.convert(to: outputBuffer, error: &conversionError) { _, status in
+            inputSource.next(status: status)
+        }
+
+        guard conversionError == nil else { return }
+        let data = Self.extractPCM16Data(from: outputBuffer)
+        if !data.isEmpty {
+            onPCM(data)
+        }
+    }
+
+    static func realtimeOutputFormat() -> AVAudioFormat? {
+        AVAudioFormat(
+            commonFormat: .pcmFormatInt16,
+            sampleRate: 24_000,
+            channels: 1,
+            interleaved: true
+        )
+    }
+
+    static func extractPCM16Data(from buffer: AVAudioPCMBuffer) -> Data {
+        var data = Data()
+        for audioBuffer in UnsafeMutableAudioBufferListPointer(buffer.mutableAudioBufferList) {
+            guard let bytes = audioBuffer.mData?.assumingMemoryBound(to: UInt8.self),
+                  audioBuffer.mDataByteSize > 0 else {
+                continue
+            }
+            data.append(bytes, count: Int(audioBuffer.mDataByteSize))
+        }
+        return data
+    }
+}
+
+private final class AudioConverterInputSource: @unchecked Sendable {
+    private let buffer: AVAudioPCMBuffer
+    private let lock = NSLock()
+    private var consumed = false
+
+    init(buffer: AVAudioPCMBuffer) {
+        self.buffer = buffer
+    }
+
+    func next(status: UnsafeMutablePointer<AVAudioConverterInputStatus>) -> AVAudioBuffer? {
+        lock.lock()
+        defer { lock.unlock() }
+
+        if consumed {
+            status.pointee = .noDataNow
+            return nil
+        }
+
+        consumed = true
+        status.pointee = .haveData
+        return buffer
+    }
+}

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

@@ -0,0 +1,113 @@
+import Foundation
+
+enum OpenAIAPIKeyStore {
+    static func load(
+        homePath: String,
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        userDefaultKey: String? = UserDefaults.standard.string(forKey: "openAIAPIKey")
+    ) -> String {
+        if let key = firstNonEmpty(environment["OPENAI_API_KEY"], environment["RECORDINGS_API_KEY"]) {
+            return key
+        }
+        if let key = firstNonEmpty(userDefaultKey) {
+            return key
+        }
+        if let key = loadConfigKey(homePath: homePath, environment: environment) {
+            return key
+        }
+        if let key = loadSecretKey(homePath: homePath) {
+            return key
+        }
+        return ""
+    }
+
+    private static func loadConfigKey(homePath: String, environment: [String: String]) -> String? {
+        let url = URL(fileURLWithPath: homePath)
+            .appendingPathComponent(".hasna")
+            .appendingPathComponent("recordings")
+            .appendingPathComponent("config.json")
+
+        guard let data = try? Data(contentsOf: url),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else { return nil }
+
+        for key in ["openai_api_key", "api_key"] {
+            guard let value = json[key] as? String,
+                  let resolved = resolve(value: value, environment: environment)
+            else { continue }
+            return resolved
+        }
+        return nil
+    }
+
+    private static func loadSecretKey(homePath: String) -> String? {
+        let root = URL(fileURLWithPath: homePath).appendingPathComponent(".secrets")
+        let fileManager = FileManager.default
+        guard let enumerator = fileManager.enumerator(
+            at: root,
+            includingPropertiesForKeys: [.isRegularFileKey],
+            options: [.skipsHiddenFiles]
+        ) else { return nil }
+
+        for case let url as URL in enumerator {
+            guard url.pathExtension == "env",
+                  let values = try? parseEnvFile(url: url)
+            else { continue }
+
+            if let key = firstNonEmpty(values["RECORDINGS_API_KEY"], values["OPENAI_API_KEY"]) {
+                return key
+            }
+        }
+        return nil
+    }
+
+    private static func parseEnvFile(url: URL) throws -> [String: String] {
+        let content = try String(contentsOf: url, encoding: .utf8)
+        var values: [String: String] = [:]
+
+        for rawLine in content.split(whereSeparator: \.isNewline) {
+            var line = rawLine.trimmingCharacters(in: .whitespacesAndNewlines)
+            guard !line.isEmpty, !line.hasPrefix("#") else { continue }
+            if line.hasPrefix("export ") {
+                line.removeFirst("export ".count)
+            }
+
+            let parts = line.split(separator: "=", maxSplits: 1, omittingEmptySubsequences: false)
+            guard parts.count == 2 else { continue }
+
+            let key = parts[0].trimmingCharacters(in: .whitespacesAndNewlines)
+            let value = stripQuotes(String(parts[1]).trimmingCharacters(in: .whitespacesAndNewlines))
+            values[key] = value
+        }
+
+        return values
+    }
+
+    private static func resolve(value: String, environment: [String: String]) -> String? {
+        let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return nil }
+        if trimmed.hasPrefix("$"), trimmed.count > 1 {
+            return firstNonEmpty(environment[String(trimmed.dropFirst())])
+        }
+        return trimmed
+    }
+
+    private static func stripQuotes(_ value: String) -> String {
+        guard value.count >= 2 else { return value }
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'")) {
+            return String(value.dropFirst().dropLast())
+        }
+        return value
+    }
+
+    private static func firstNonEmpty(_ values: String?...) -> String? {
+        for value in values {
+            let trimmed = value?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+            if !trimmed.isEmpty {
+                return trimmed
+            }
+        }
+        return nil
+    }
+}