@hasna/recordings 0.1.20 → 0.1.21

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.1.11";
+export declare const VERSION = "0.1.21";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@hasna/recordings",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "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": {

package/scripts/install_macos_app.sh

@@ -73,4 +73,36 @@ rm -rf "$APP_DEST"
 mkdir -p "$DATA_DIR"
 cp -R "$APP_SOURCE" "$APP_DEST" || warn_or_fail "failed to copy app bundle"
 
+current_cdhash() {
+  codesign -d --verbose=4 "$1" 2>&1 | awk -F= '/^CDHash=/ { print toupper($2); exit }'
+}
+
+tcc_csreq_hex() {
+  local db_path="$1"
+  local service="$2"
+  if [ ! -r "$db_path" ] || ! command -v sqlite3 >/dev/null 2>&1; then
+    return 0
+  fi
+  sqlite3 "$db_path" \
+    "SELECT hex(csreq) FROM access WHERE service = '${service}' AND client = 'com.hasna.recordings' ORDER BY last_modified DESC LIMIT 1;" \
+    2>/dev/null || true
+}
+
+reset_stale_permission() {
+  local service="$1"
+  local tcc_service="$2"
+  local db_path="$3"
+  local cdhash="$4"
+  local csreq_hex
+  csreq_hex="$(tcc_csreq_hex "$db_path" "$tcc_service" | tr '[:lower:]' '[:upper:]')"
+  if [ -n "$cdhash" ] && [ -n "$csreq_hex" ] && [[ "$csreq_hex" != *"$cdhash"* ]]; then
+    tccutil reset "$service" com.hasna.recordings >/dev/null 2>&1 || true
+    echo "Reset stale ${service} permission for the newly installed Recordings.app."
+  fi
+}
+
+APP_CDHASH="$(current_cdhash "$APP_DEST" || true)"
+reset_stale_permission "Microphone" "kTCCServiceMicrophone" "${HOME}/Library/Application Support/com.apple.TCC/TCC.db" "$APP_CDHASH"
+reset_stale_permission "Accessibility" "kTCCServiceAccessibility" "/Library/Application Support/com.apple.TCC/TCC.db" "$APP_CDHASH"
+
 echo "Installed Recordings.app from package: ${APP_DEST}"

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

@@ -1,5 +1,5 @@
 import SwiftUI
-import KeyboardShortcuts
+@preconcurrency import KeyboardShortcuts
 
 public struct MenuBarPopover: View {
     @ObservedObject public var engine: RecordingEngine
@@ -237,11 +237,10 @@ public struct MenuBarPopover: View {
                                 showProject: filterProjectId == nil,
                                 isCopied: copiedIndex == i
                             ) {
-                                NSPasteboard.general.clearContents()
-                                NSPasteboard.general.setString(item.displayText, forType: .string)
                                 withAnimation(.easeInOut(duration: 0.15)) {
                                     copiedIndex = i
                                 }
+                                engine.pasteIntoFrontApp(item.displayText)
                                 DispatchQueue.main.asyncAfter(deadline: .now() + 1.2) {
                                     withAnimation { if copiedIndex == i { copiedIndex = nil } }
                                 }

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

@@ -16,12 +16,20 @@ public final class RealtimeTranscriptionClient: ObservableObject, @unchecked Sen
 
     private var ws: URLSessionWebSocketTask?
     private var receiveTask: Task<Void, Never>?
+    private var outboundEventTask: Task<Void, Never>?
     private var isConfigured = false
     private var pendingAudioChunks: [Data] = []
     private var itemOrder: [String] = []
     private var deltaTextByItem: [String: String] = [:]
     private var completedTextByItem: [String: String] = [:]
+    private var committedItemIDs = Set<String>()
+    private var completedItemIDs = Set<String>()
     private var completedEventCount = 0
+    private var queuedCommitCount = 0
+    private var uncommittedAudioBytes = 0
+    private var lastRealtimeEventAt = Date.distantPast
+
+    private nonisolated static let minimumManualCommitBytes = 5_760
 
     private let apiKey: String
     private let homePath: String
@@ -52,7 +60,12 @@ public final class RealtimeTranscriptionClient: ObservableObject, @unchecked Sen
         itemOrder.removeAll(keepingCapacity: true)
         deltaTextByItem.removeAll(keepingCapacity: true)
         completedTextByItem.removeAll(keepingCapacity: true)
+        committedItemIDs.removeAll(keepingCapacity: true)
+        completedItemIDs.removeAll(keepingCapacity: true)
         completedEventCount = 0
+        queuedCommitCount = 0
+        uncommittedAudioBytes = 0
+        lastRealtimeEventAt = Date()
         error = nil
 
         var request = URLRequest(url: Self.transcriptionURL)
@@ -98,33 +111,51 @@ public final class RealtimeTranscriptionClient: ObservableObject, @unchecked Sen
             return
         }
         let base64 = data.base64EncodedString()
+        uncommittedAudioBytes += data.count
         let msg: [String: Any] = [
             "type": "input_audio_buffer.append",
             "audio": base64,
         ]
-        Task { [weak self] in
-            try? await self?.sendEvent(msg)
-        }
+        enqueueOutboundEvent(msg)
     }
 
     /// Signal end of input — triggers final transcription completion.
-    public func commitInput() async {
-        guard isStreaming, ws != nil else { return }
+    @discardableResult
+    public func commitInput(reason: String = "final") async -> Bool {
+        guard isStreaming, ws != nil else { return false }
         flushPendingAudio()
+        let bytesToCommit = uncommittedAudioBytes
+        guard Self.shouldManuallyCommit(uncommittedAudioBytes: bytesToCommit) else {
+            return false
+        }
         let msg: [String: Any] = [
             "type": "input_audio_buffer.commit",
         ]
-        try? await sendEvent(msg)
+        uncommittedAudioBytes = 0
+        queuedCommitCount += 1
+        lastRealtimeEventAt = Date()
+        NativeAppLog.write("realtime commit queued reason=\(reason) bytes=\(bytesToCommit)", homePath: homePath)
+        let commitTask = enqueueOutboundEvent(msg)
+        await commitTask?.value
+        return true
     }
 
     /// Commit buffered input, wait briefly for a final completed event, then close.
-    public func finish(timeoutMilliseconds: UInt64 = 1_800) async -> String {
+    public func finish(timeoutMilliseconds: UInt64 = 2_800) async -> String {
         guard isStreaming else { return accumulatedText }
-        let initialCompletedCount = completedEventCount
-        await commitInput()
+        let completedCountBeforeCommit = completedEventCount
+        let didManualCommit = await commitInput()
+        let expectedCommitCount = queuedCommitCount
 
         let deadline = Date().addingTimeInterval(TimeInterval(timeoutMilliseconds) / 1_000)
-        while Date() < deadline, isStreaming, completedEventCount == initialCompletedCount {
+        while Date() < deadline, isStreaming {
+            let hasIncompleteCommittedItems = !committedItemIDs.subtracting(completedItemIDs).isEmpty
+            let hasManualCommitCompletion = !didManualCommit || completedEventCount > completedCountBeforeCommit
+            let hasQueuedCommitCompletion = completedEventCount >= expectedCommitCount
+            let quietLongEnough = Date().timeIntervalSince(lastRealtimeEventAt) >= 0.35
+            if !hasIncompleteCommittedItems, hasManualCommitCompletion, hasQueuedCommitCompletion, quietLongEnough {
+                break
+            }
             try? await Task.sleep(for: .milliseconds(50))
         }
 
@@ -139,8 +170,10 @@ public final class RealtimeTranscriptionClient: ObservableObject, @unchecked Sen
         isConfigured = false
         receiveTask?.cancel()
         ws?.cancel(with: .normalClosure, reason: nil)
+        outboundEventTask?.cancel()
         ws = nil
         receiveTask = nil
+        outboundEventTask = nil
         pendingAudioChunks.removeAll(keepingCapacity: true)
         let text = accumulatedText
         return text
@@ -180,11 +213,14 @@ public final class RealtimeTranscriptionClient: ObservableObject, @unchecked Sen
 
         switch type {
         case "input_audio_buffer.committed":
+            lastRealtimeEventAt = Date()
             if let itemID = json["item_id"] as? String {
                 registerItem(itemID, previousItemID: json["previous_item_id"] as? String)
+                committedItemIDs.insert(itemID)
             }
 
         case "conversation.item.input_audio_transcription.delta":
+            lastRealtimeEventAt = Date()
             let itemID = json["item_id"] as? String ?? "__default__"
             registerItem(itemID, previousItemID: nil)
             if let delta = json["delta"] as? String {
@@ -194,21 +230,29 @@ public final class RealtimeTranscriptionClient: ObservableObject, @unchecked Sen
 
         case "conversation.item.input_audio_transcription.completed":
             // The server may send the complete transcript here
+            lastRealtimeEventAt = Date()
             let itemID = json["item_id"] as? String ?? "__default__"
             registerItem(itemID, previousItemID: nil)
+            completedItemIDs.insert(itemID)
+            completedEventCount += 1
             if let text = json["transcript"] as? String, !text.isEmpty {
                 completedTextByItem[itemID] = text
-                completedEventCount += 1
-                rebuildAccumulatedText()
             }
+            rebuildAccumulatedText()
 
         case "conversation.item.input_audio_transcription.failed":
+            lastRealtimeEventAt = Date()
+            if let itemID = json["item_id"] as? String {
+                completedItemIDs.insert(itemID)
+                completedEventCount += 1
+            }
             if let msg = json["error"] as? [String: Any],
                let message = msg["message"] as? String {
                 self.error = message
             }
 
         case "error":
+            lastRealtimeEventAt = Date()
             if let detail = json["error"] as? [String: Any],
                let msg = detail["message"] as? String {
                 fputs("[RealtimeClient] Error: \(msg)\n", stderr)
@@ -220,6 +264,18 @@ public final class RealtimeTranscriptionClient: ObservableObject, @unchecked Sen
         }
     }
 
+    @discardableResult
+    private func enqueueOutboundEvent(_ obj: [String: Any]) -> Task<Void, Never>? {
+        guard ws != nil else { return nil }
+        let previousTask = outboundEventTask
+        let task = Task { [weak self] in
+            await previousTask?.value
+            try? await self?.sendEvent(obj)
+        }
+        outboundEventTask = task
+        return task
+    }
+
     private func registerItem(_ itemID: String, previousItemID: String?) {
         guard !itemOrder.contains(itemID) else { return }
         if let previousItemID, let previousIndex = itemOrder.firstIndex(of: previousItemID) {
@@ -295,6 +351,10 @@ public final class RealtimeTranscriptionClient: ObservableObject, @unchecked Sen
         return output
     }
 
+    private nonisolated static func shouldManuallyCommit(uncommittedAudioBytes: Int) -> Bool {
+        uncommittedAudioBytes >= minimumManualCommitBytes
+    }
+
     private nonisolated static func transcriptionSessionUpdateEvent(transcription: [String: Any]) -> [String: Any] {
         [
             "type": "session.update",
@@ -363,6 +423,10 @@ extension RealtimeTranscriptionClient {
         joinTranscriptParts(parts)
     }
 
+    public nonisolated static func shouldManuallyCommitTestHelper(uncommittedAudioBytes: Int) -> Bool {
+        shouldManuallyCommit(uncommittedAudioBytes: uncommittedAudioBytes)
+    }
+
     public nonisolated static func sessionUpdateTestHelper(prompt: String, language: String = "") -> [String: Any] {
         var transcription: [String: Any] = [
             "model": modelID,

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

@@ -1,5 +1,5 @@
 import SwiftUI
-import KeyboardShortcuts
+@preconcurrency import KeyboardShortcuts
 
 public struct SettingsView: View {
     @ObservedObject public var engine: RecordingEngine
@@ -45,6 +45,32 @@ public struct SettingsView: View {
                     .foregroundStyle(.secondary)
             }
 
+            Section("Permissions") {
+                HStack {
+                    Text("Microphone")
+                    Spacer()
+                    Text(engine.microphonePermissionLabel)
+                        .foregroundStyle(.secondary)
+                }
+                Button("Request Microphone") {
+                    engine.requestMicrophonePermission()
+                }
+                HStack {
+                    Text("Accessibility")
+                    Spacer()
+                    Text(engine.accessibilityPermissionLabel)
+                        .foregroundStyle(.secondary)
+                }
+                HStack {
+                    Button("Request Accessibility") {
+                        engine.requestAccessibilityPermission()
+                    }
+                    Button("Open Accessibility Settings") {
+                        engine.openAccessibilitySettings()
+                    }
+                }
+            }
+
             Section("System Prompt") {
                 TextEditor(text: $projectStore.settings.globalSystemPrompt)
                     .frame(height: 80)

package/src/native/Recordings/RecordingsTests/NativeAppDiagnosticsTests.swift

@@ -0,0 +1,23 @@
+import Foundation
+import Testing
+@testable import RecordingsLib
+
+struct NativeAppDiagnosticsTests {
+    @Test("Native app log writes to recordings log file")
+    func logWritesFile() throws {
+        let home = try makeHome()
+
+        NativeAppLog.write("diagnostic-test", homePath: home)
+
+        let path = "\(home)/.hasna/recordings/Recordings.log"
+        let text = try String(contentsOfFile: path, encoding: .utf8)
+        #expect(text.contains("diagnostic-test"))
+    }
+
+    private func makeHome() throws -> String {
+        let url = FileManager.default.temporaryDirectory
+            .appendingPathComponent("recordings-diagnostics-tests-\(UUID().uuidString)")
+        try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true)
+        return url.path
+    }
+}

package/src/native/Recordings/RecordingsTests/RealtimeTranscriptionTests.swift

@@ -110,4 +110,17 @@ struct RealtimeTranscriptionTests {
         let text = RealtimeTranscriptionClient.joinTranscriptPartsTestHelper(["Hello", "world.", " Next"])
         #expect(text == "Hello world. Next")
     }
+
+    @Test("Manual commit waits for enough buffered PCM audio")
+    func manualCommitThreshold() {
+        #expect(RealtimeTranscriptionClient.shouldManuallyCommitTestHelper(uncommittedAudioBytes: 4_799) == false)
+        #expect(RealtimeTranscriptionClient.shouldManuallyCommitTestHelper(uncommittedAudioBytes: 5_760) == true)
+    }
+
+    @Test("Partial realtime text falls back for longer recordings")
+    func partialRealtimeFallback() {
+        #expect(RecordingEngine.shouldFallbackFromPartialRealtime(text: "Hi", pcmByteCount: 96_000) == true)
+        #expect(RecordingEngine.shouldFallbackFromPartialRealtime(text: "This is a complete sentence.", pcmByteCount: 96_000) == false)
+        #expect(RecordingEngine.shouldFallbackFromPartialRealtime(text: "Hi", pcmByteCount: 12_000) == false)
+    }
 }