@hasna/recordings 0.3.13 → 0.5.0

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

@@ -4,29 +4,31 @@ import SwiftUI
 public struct SettingsView: View {
     @ObservedObject public var engine: RecordingEngine
     @ObservedObject public var shortcuts: VoiceShortcuts
-    @ObservedObject public var projectStore: ProjectStore
-    @AppStorage("openAIAPIKey") private var openAIAPIKey = ""
+    @ObservedObject public var preferences: ProjectStore
+    @State private var openAIAPIKey = ""
+    @State private var providerStatus = ""
 
-    public init(engine: RecordingEngine, shortcuts: VoiceShortcuts, projectStore: ProjectStore) {
+    public init(engine: RecordingEngine, shortcuts: VoiceShortcuts, preferences: ProjectStore) {
         self.engine = engine
         self.shortcuts = shortcuts
-        self.projectStore = projectStore
+        self.preferences = preferences
     }
 
     public var body: some View {
         TabView {
             generalTab.tabItem { Label("General", systemImage: "gear") }
-            projectsTab.tabItem { Label("Projects", systemImage: "folder") }
             shortcutsTab.tabItem { Label("Voice Shortcuts", systemImage: "text.badge.star") }
         }
-        .frame(width: 520, height: 500)
-        .alert("Project Settings Error", isPresented: Binding(
-            get: { projectStore.persistenceError != nil },
-            set: { if !$0 { projectStore.clearPersistenceError() } }
+        .font(.system(size: 13))
+        .controlSize(.small)
+        .frame(width: 520, height: 460)
+        .alert("Settings Error", isPresented: Binding(
+            get: { preferences.persistenceError != nil },
+            set: { if !$0 { preferences.clearPersistenceError() } }
         )) {
             Button("OK", role: .cancel) {}
         } message: {
-            Text(projectStore.persistenceError ?? "The project settings could not be saved.")
+            Text(preferences.persistenceError ?? "The settings could not be saved.")
         }
     }
 
@@ -34,18 +36,38 @@ public struct SettingsView: View {
 
     private var generalTab: some View {
         Form {
+            ServiceConnectionView(home: engine.home)
             Section("OpenAI") {
                 SecureField("API key", text: $openAIAPIKey)
                     .textFieldStyle(.roundedBorder)
-                    .onChange(of: openAIAPIKey) {
-                        // Keep the CLI config in sync — final transcription shells out to it.
-                        try? OpenAIAPIKeyStore.save(key: openAIAPIKey, homePath: engine.home)
+                Button("Save OpenAI Key") {
+                    do {
+                        try OpenAIAPIKeyStore.save(key: openAIAPIKey, homePath: engine.home)
+                        openAIAPIKey = ""
+                        providerStatus = "OpenAI key saved in Keychain."
+                    } catch {
+                        providerStatus = error.localizedDescription
+                    }
+                }
+                .disabled(openAIAPIKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty)
+                Button("Connect Saved Key") {
+                    do {
+                        providerStatus = (try OpenAIAPIKeyStore.loadKeychain(allowInteraction: true))?.isEmpty == false
+                            ? "OpenAI key available from Keychain."
+                            : "No saved OpenAI key found in Keychain."
+                    } catch { providerStatus = error.localizedDescription }
+                }
+                Text(providerStatus).foregroundStyle(.secondary)
+                    .onAppear {
+                        providerStatus = OpenAIAPIKeyStore.load(homePath: engine.home).isEmpty
+                            ? "Add an OpenAI key for transcription."
+                            : "OpenAI key available for transcription."
                     }
                 Picker("Language", selection: $engine.transcriptionLanguage) {
                     Text("English").tag("en")
                     Text("Auto Detect").tag("auto")
                 }
-                Text("Used for live transcription and the final paste. Stored in ~/.hasna/recordings/config.json.")
+                Text("Used for live transcription and the final paste. New keys are stored in macOS Keychain.")
                     .foregroundStyle(.secondary)
             }
 
@@ -143,82 +165,26 @@ public struct SettingsView: View {
             }
 
             Section("Transcription Cleanup") {
-                Picker("Mode", selection: $projectStore.settings.postProcessingMode) {
+                Picker("Mode", selection: $preferences.settings.postProcessingMode) {
                     ForEach(PostProcessingMode.allCases) { mode in
                         Text(mode.label).tag(mode.rawValue)
                     }
                 }
                 .pickerStyle(.segmented)
-                .onChange(of: projectStore.settings.postProcessingMode) {
-                    try? projectStore.save()
+                .onChange(of: preferences.settings.postProcessingMode) {
+                    try? preferences.save()
                 }
-                TextEditor(text: $projectStore.settings.globalSystemPrompt)
-                    .frame(height: 80)
-                    .onChange(of: projectStore.settings.globalSystemPrompt) {
-                        try? projectStore.save()
+                TextEditor(text: $preferences.settings.globalSystemPrompt)
+                    .frame(height: 80).scrollContentBackground(.hidden)
+                    .onChange(of: preferences.settings.globalSystemPrompt) {
+                        try? preferences.save()
                     }
                 Text("Instructions for post-transcription cleanup and formatting.")
                     .foregroundStyle(.secondary)
             }
-            .disabled(!projectStore.canMutateProjects)
-        }
-        .formStyle(.grouped).padding()
-    }
-
-    // MARK: - Projects
-
-    @State private var newProjectName = ""
-    @State private var editingProject: RecProject?
-
-    private var projectsTab: some View {
-        VStack(spacing: 0) {
-            HStack(spacing: 8) {
-                TextField("New project name", text: $newProjectName)
-                    .textFieldStyle(.roundedBorder)
-                Button("Add") {
-                    guard !newProjectName.isEmpty else { return }
-                    let name = newProjectName
-                    Task {
-                        do {
-                            try await projectStore.addProject(name: name)
-                            newProjectName = ""
-                        } catch {}
-                    }
-                }
-                .disabled(newProjectName.isEmpty)
-            }
-            .padding()
-
-            Divider()
-
-            if projectStore.settings.projects.isEmpty {
-                Spacer()
-                VStack(spacing: 8) {
-                    Image(systemName: "folder").font(.largeTitle).foregroundStyle(.quaternary)
-                    Text("No projects yet").foregroundStyle(.secondary)
-                }
-                Spacer()
-            } else {
-                List {
-                    ForEach(projectStore.settings.projects) { project in
-                        ProjectRow(project: project) {
-                            editingProject = project
-                        }
-                    }
-                    .onDelete { indexSet in
-                        for i in indexSet {
-                            try? projectStore.removeProject(id: projectStore.settings.projects[i].id)
-                        }
-                    }
-                }
-            }
-        }
-        .disabled(!projectStore.canMutateProjects)
-        .sheet(item: $editingProject) { project in
-            ProjectEditView(project: project, store: projectStore) {
-                editingProject = nil
-            }
+            .disabled(!preferences.canMutateProjects)
         }
+        .formStyle(.grouped).scrollContentBackground(.hidden).padding(8)
     }
 
     // MARK: - Voice Shortcuts
@@ -263,73 +229,3 @@ public struct SettingsView: View {
         }
     }
 }
-
-// MARK: - Project Row
-
-struct ProjectRow: View {
-    let project: RecProject
-    let onEdit: () -> Void
-
-    var body: some View {
-        HStack {
-            VStack(alignment: .leading, spacing: 2) {
-                Text(project.name)
-                if let path = project.path, !path.isEmpty {
-                    Text(path).foregroundStyle(.secondary).lineLimit(1)
-                }
-            }
-            Spacer()
-            Button("Edit") { onEdit() }
-                .controlSize(.small)
-        }
-    }
-}
-
-// MARK: - Project Edit
-
-struct ProjectEditView: View {
-    @State var project: RecProject
-    let store: ProjectStore
-    let onDismiss: () -> Void
-
-    var body: some View {
-        VStack(spacing: 0) {
-            Form {
-                Section("Project") {
-                    TextField("Name", text: $project.name)
-                    TextField("Path", text: Binding(
-                        get: { project.path ?? "" },
-                        set: { project.path = $0.isEmpty ? nil : $0 }
-                    ))
-                    .textFieldStyle(.roundedBorder)
-                }
-
-                Section("Transcriber Instructions") {
-                    TextEditor(text: Binding(
-                        get: { project.systemPrompt ?? "" },
-                        set: { project.systemPrompt = $0.isEmpty ? nil : $0 }
-                    ))
-                    .frame(height: 100)
-                    Text("Project-specific cleanup and formatting instructions.")
-                        .foregroundStyle(.secondary)
-                }
-            }
-            .formStyle(.grouped)
-            .disabled(!store.canMutateProjects)
-
-            HStack {
-                Spacer()
-                Button("Cancel") { onDismiss() }
-                Button("Save") {
-                    do {
-                        try store.updateProject(project)
-                        onDismiss()
-                    } catch {}
-                }
-                .disabled(!store.canMutateProjects)
-            }
-            .padding()
-        }
-        .frame(width: 420, height: 340)
-    }
-}

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

@@ -0,0 +1,48 @@
+import AppKit
+import SwiftUI
+
+/// Settings must also open from an accessory app with no SwiftUI workspace scene.
+/// Retain the window so repeated menu actions and closing/reopening preserve its state.
+@MainActor
+public final class SettingsWindowController {
+    private var window: NSWindow?
+    private let makeContent: @MainActor () -> NSView
+
+    public init(content: @escaping @MainActor () -> NSView) {
+        makeContent = content
+    }
+
+    @discardableResult
+    public func show() -> NSWindow {
+        let settings: NSWindow
+        if let window {
+            settings = window
+        } else {
+            settings = NSWindow(
+                contentRect: NSRect(x: 0, y: 0, width: 520, height: 500),
+                styleMask: [.titled, .closable],
+                backing: .buffered,
+                defer: false
+            )
+            settings.title = "Hasna Recordings Settings"
+            settings.isReleasedWhenClosed = false
+            settings.isOpaque = false
+            settings.backgroundColor = .clear
+            settings.titlebarAppearsTransparent = true
+            let content = makeContent()
+            let backdrop = NSHostingView(rootView: RecordingGlassBackground())
+            backdrop.frame = content.bounds
+            backdrop.autoresizingMask = [.width, .height]
+            content.addSubview(backdrop, positioned: .below, relativeTo: nil)
+            settings.contentView = content
+            settings.center()
+            window = settings
+        }
+        // Activation is needed when invoked from a menu-bar popover. Preserve the
+        // activation policy so a bar-only app stays out of the Dock and app switcher.
+        NSApplication.shared.activate()
+        NSRunningApplication.current.activate(options: [.activateAllWindows])
+        settings.makeKeyAndOrderFront(nil)
+        return settings
+    }
+}

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

@@ -0,0 +1,85 @@
+import Dispatch
+import Foundation
+import Testing
+@testable import RecordingsLib
+
+@Suite("Blocking operation scheduling")
+struct BlockingOperationTests {
+    private final class Observation: @unchecked Sendable {
+        let entered = DispatchSemaphore(value: 0)
+        let release = DispatchSemaphore(value: 0)
+        let peer = DispatchSemaphore(value: 0)
+        private let lock = NSLock()
+        private var result = (entered: false, peerBeforeRelease: false)
+
+        func record(entered: Bool, peerBeforeRelease: Bool) {
+            lock.lock()
+            result = (entered, peerBeforeRelease)
+            lock.unlock()
+        }
+
+        func snapshot() -> (entered: Bool, peerBeforeRelease: Bool) {
+            lock.lock()
+            defer { lock.unlock() }
+            return result
+        }
+    }
+
+    @Test("blocking work leaves executor progress available and drains after cancellation", arguments: [false, true], [false, true])
+    func peerProgressWhileBlocked(cancel: Bool, delayedSubmission: Bool) async {
+        let observation = Observation()
+        // A single buffered handoff gives the operation its already-created Task handle
+        // without blocking a cooperative worker or capturing an uninitialized variable.
+        let handoff = AsyncStream<Task<(Int, Bool), Never>>.makeStream(bufferingPolicy: .bufferingNewest(1))
+        let work = Task.detached {
+            var handles = handoff.stream.makeAsyncIterator()
+            guard let ownTask = await handles.next() else {
+                preconditionFailure("Fixture task handle was not supplied")
+            }
+            // Admission is deliberately slower than the former two-second entry timer.
+            // Only progress while the synchronous operation is held is under observation.
+            if delayedSubmission { try? await Task.sleep(for: .seconds(3)) }
+            let value = await BlockingOperation.run {
+                observation.entered.signal()
+                // Start the observation inside the operation, after entry. This independent
+                // thread always releases the gate, even when the peer misses its deadline.
+                Thread.detachNewThread {
+                    defer { observation.release.signal() }
+                    let entered = observation.entered.wait(timeout: .now()) == .success
+                    if cancel { ownTask.cancel() }
+                    if entered {
+                        Task.detached { observation.peer.signal() }
+                    }
+                    let progressed = entered && observation.peer.wait(timeout: .now() + .seconds(1)) == .success
+                    observation.record(entered: entered, peerBeforeRelease: progressed)
+                }
+                observation.release.wait()
+                return 7
+            }
+            return (value, Task.isCancelled)
+        }
+        handoff.continuation.yield(work)
+        handoff.continuation.finish()
+        let (value, wasCancelled) = await work.value
+        let observed = observation.snapshot()
+        #expect(observed.entered)
+        #expect(observed.peerBeforeRelease)
+        #expect(value == 7)
+        #expect(wasCancelled == cancel)
+    }
+
+    private enum FixtureFailure: Error { case expected }
+
+    @Test("throwing blocking work preserves its exact error")
+    func preservesError() async {
+        do {
+            let _: Int = try await BlockingOperation.runThrowing(qos: .utility) {
+                throw FixtureFailure.expected
+            }
+            Issue.record("Blocking operation discarded its error")
+        } catch FixtureFailure.expected {
+        } catch {
+            Issue.record("Blocking operation replaced its error: \(error)")
+        }
+    }
+}