@hasna/recordings 0.3.13 → 0.5.0

package/src/native/Recordings/App/RecordingsApp.swift

@@ -4,6 +4,12 @@ import Darwin
 import SwiftUI
 import KeyboardShortcuts
 import RecordingsLib
+import Combine
+
+private final class RecorderPanel: NSPanel {
+    override var canBecomeKey: Bool { true }
+    override var canBecomeMain: Bool { true }
+}
 
 private final class PermissionRequestResultBox: @unchecked Sendable {
     private let lock = NSLock()
@@ -63,7 +69,14 @@ final class RecordingsAppState: ObservableObject {
     private let runtimeSmokeOutputPath: String?
     private let runtimeSmokeAcknowledgementPath: String?
     private let runtimeSmokeCompletionPath: String?
+    @Published var page: RecorderPage = .recorder
     private var mainWindow: NSWindow?
+    private var settingsWindowController: SettingsWindowController?
+    private var historyWindow: NSWindow?
+    private var transcriptionBar: NSPanel?
+    private var recentPastesWindow: NSWindow?
+    private var subscriptions = Set<AnyCancellable>()
+    private var compactSettingsWindow: NSWindow?
     private(set) var windowCreationCount = 0
     private(set) var windowActivationCount = 0
 
@@ -77,8 +90,28 @@ final class RecordingsAppState: ObservableObject {
         runtimeSmokeCompletionPath = plan.runtimeSmokeCompletionPath
         runtimeSmokeProbe = plan.runtimeSmokeMode == "normal" ? RuntimeSmokeProbe() : nil
         if plan.installsGlobalHandlers {
-            let store = RecordingsStore()
+            let store: RecordingsStore
+            #if DEBUG
+            if CommandLine.arguments.contains("--visual-preview") {
+                let home = NSTemporaryDirectory() + "recordings-design-preview"
+                store = RecordingsStore(engine: RecordingEngine(homePath: home, installsGlobalHandlers: false),
+                    preferences: ProjectStore(filePath: home + "/projects.json"), voiceShortcuts: VoiceShortcuts(homePath: home))
+                store.isVisualPreview = true
+                let labels = ["Interview notes", "Project idea", "Quick thought", "Meeting recap", "Voice memo"]
+                let durations = [737000, 343000, 68000, 1691000, 156000]
+                store.library = labels.enumerated().map { i, name in
+                    Recording(id: "visual-preview-\(i)", audioPath: ProcessInfo.processInfo.environment["RECORDINGS_VISUAL_PREVIEW_AUDIO"], rawText: name, durationMs: durations[i],
+                              createdAt: ISO8601DateFormatter().string(from: Date().addingTimeInterval(Double(-i * 86400))))
+                }
+                if CommandLine.arguments.contains("--visual-preview-recording") {
+                    store.engine.configureVisualPreview()
+                }
+            } else { store = RecordingsStore() }
+            #else
+            store = RecordingsStore()
+            #endif
             self.store = store
+            store.$showMenuBar.sink { [weak self] _ in self?.objectWillChange.send() }.store(in: &subscriptions)
             if plan.declaresMainWindow {
                 Task { @MainActor [weak self] in
                     self?.openRecordings()
@@ -90,6 +123,8 @@ final class RecordingsAppState: ObservableObject {
     }
 
     func openRecordings() {
+        page = .recorder
+        resizeDesktop()
         // Bar launches never create the workspace window — on any path, including the
         // reopen handler and the runtime smoke. Keyed on declaresWindow (NOT on
         // declaresMainWindow, which excludes every runtime smoke): a full build's
@@ -99,12 +134,133 @@ final class RecordingsAppState: ObservableObject {
         // deterministically on every build.
         guard declaresWindow else { return }
         if let store {
-            showWindow(contentView: NSHostingView(rootView: ContentView(store: store)))
+            showWindow(contentView: NSHostingView(rootView: ContentView(store: store, state: self, windowAction: performWindowAction)))
         } else if runtimeSmokeMode == "normal" {
             showWindow(contentView: NSHostingView(rootView: Text("Recordings runtime smoke")))
         }
     }
 
+    private func showPage(_ destination: RecorderPage) {
+        if mainWindow == nil { openRecordings() }
+        page = destination
+        resizeDesktop()
+        activate(mainWindow)
+    }
+
+    private func resizeDesktop() {
+        guard let mainWindow else { return }
+        mainWindow.contentMinSize = page.size
+        mainWindow.contentMaxSize = page.size
+        mainWindow.setContentSize(page.size)
+    }
+
+    private func performWindowAction(_ kind: NSWindow.ButtonType) {
+        switch kind {
+        case .closeButton: mainWindow?.performClose(nil)
+        case .miniaturizeButton: mainWindow?.miniaturize(nil)
+        case .zoomButton: mainWindow?.toggleFullScreen(nil)
+        default: break
+        }
+    }
+
+    func openBar() {
+        guard let store else { return }
+        if transcriptionBar == nil {
+            let screen = NSScreen.main?.visibleFrame ?? NSRect(x: 0, y: 0, width: 1200, height: 800)
+            let width = min(820, screen.width - 48) + 16
+            let panel = RecorderPanel(contentRect: NSRect(x: screen.midX - width / 2, y: screen.maxY - 84, width: width, height: 76),
+                styleMask: [.borderless, .nonactivatingPanel], backing: .buffered, defer: false)
+            panel.title = "Hasna Recordings — Live Transcript"
+            panel.isOpaque = false; panel.backgroundColor = .clear
+            panel.level = .floating; panel.hasShadow = true
+            panel.isMovableByWindowBackground = true
+            panel.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary]
+            panel.isReleasedWhenClosed = false
+            panel.contentView = NSHostingView(rootView: MenuBarStatusView(store: store, openRecordings: openRecordings,
+                openSettings: openSettings, openHistory: openHistory, openRecent: openRecent,
+                closeBar: { [weak self] in self?.transcriptionBar?.orderOut(nil) }, barOnly: barOnly))
+            transcriptionBar = panel
+        }
+        transcriptionBar?.makeKeyAndOrderFront(nil)
+    }
+
+    func openRecent() {
+        guard let store else { return }
+        let screen = NSScreen.main?.visibleFrame ?? NSRect(x: 0, y: 0, width: 1200, height: 800)
+        let width = min(760, screen.width - 48)
+        if recentPastesWindow == nil {
+            recentPastesWindow = makePanel(title: "Recent pastes", width: width, height: 350,
+                content: NSHostingView(rootView: VStack(spacing: 0) {
+                    PanelPointer().fill(Color(red: 0.94, green: 0.95, blue: 0.97))
+                        .frame(width: 26, height: 12).offset(x: width * 0.34)
+                    RecentPastesView(store: store, close: { [weak self] in self?.recentPastesWindow?.close() })
+                        .frame(width: width, height: 338)
+                }))
+            recentPastesWindow?.level = .floating
+        }
+        let barBottom = transcriptionBar?.frame.minY ?? (screen.maxY - 84)
+        recentPastesWindow?.setFrameOrigin(NSPoint(x: screen.midX - width / 2, y: barBottom - 356))
+        activate(recentPastesWindow)
+    }
+
+    func openHistory() {
+        guard let store else { return }
+        store.selection = nil
+        store.searchText = ""
+        if !barOnly { showPage(.history); return }
+        store.searchText = ""
+        if historyWindow == nil {
+            historyWindow = makePanel(title: "Recordings", width: 500, height: 354,
+                content: NSHostingView(rootView: RecordingsListView(store: store, close: { [weak self] in self?.historyWindow?.close() }).background(FrostedBackground())))
+        }
+        store.loadLibrary()
+        activate(historyWindow)
+    }
+
+    func openSettings() {
+        guard let store else { return }
+        if !barOnly { showPage(.settings); return }
+        if compactSettingsWindow == nil {
+            compactSettingsWindow = makePanel(title: "Hasna Recordings Settings", width: 420, height: 314,
+                content: NSHostingView(rootView: RecorderSettingsView(store: store,
+                    close: { [weak self] in self?.compactSettingsWindow?.close() }, advanced: openAdvancedSettings).background(FrostedBackground())))
+        }
+        activate(compactSettingsWindow)
+    }
+
+    private func makePanel(title: String, width: CGFloat, height: CGFloat, content: NSView) -> NSWindow {
+        let panel = RecorderPanel(contentRect: NSRect(x: 0, y: 0, width: width, height: height),
+                            styleMask: [.borderless, .resizable], backing: .buffered, defer: false)
+        panel.title = title
+        panel.isReleasedWhenClosed = false
+        panel.isMovableByWindowBackground = true
+        panel.isOpaque = false; panel.backgroundColor = .clear; panel.hasShadow = true
+        panel.appearance = NSAppearance(named: .aqua)
+        panel.contentView = content
+        panel.center()
+        return panel
+    }
+
+    private func activate(_ window: NSWindow?) {
+        NSApplication.shared.activate()
+        window?.makeKeyAndOrderFront(nil)
+    }
+
+    func openAdvancedSettings() {
+        guard let store, !store.isVisualPreview else { return }
+        if !barOnly { showPage(.advanced); return }
+        if settingsWindowController == nil {
+            settingsWindowController = SettingsWindowController {
+                NSHostingView(rootView: SettingsView(
+                    engine: store.engine,
+                    shortcuts: store.voiceShortcuts,
+                    preferences: store.preferences
+                ))
+            }
+        }
+        settingsWindowController?.show()
+    }
+
     private func showWindow(contentView: NSView) {
         windowActivationCount += 1
         NSApplication.shared.setActivationPolicy(.regular)
@@ -116,22 +272,31 @@ final class RecordingsAppState: ObservableObject {
         }
 
         let window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 1180, height: 760),
+            contentRect: NSRect(x: 0, y: 0, width: 224, height: 244),
             styleMask: [.titled, .closable, .miniaturizable, .resizable, .fullSizeContentView],
             backing: .buffered,
             defer: false
         )
-        window.title = "Recordings"
+        window.title = "Hasna Recordings"
         window.titleVisibility = .hidden
         window.titlebarAppearsTransparent = true
+        window.isOpaque = false
+        window.backgroundColor = .clear
+        window.isMovableByWindowBackground = true
+        window.appearance = NSAppearance(named: .aqua)
         window.isReleasedWhenClosed = false
         window.contentView = contentView
+        window.contentMinSize = NSSize(width: 224, height: 244)
+        window.contentMaxSize = NSSize(width: 224, height: 244)
         window.center()
         mainWindow = window
         windowCreationCount += 1
         NSApplication.shared.activate()
         NSRunningApplication.current.activate(options: [.activateAllWindows])
         window.makeKeyAndOrderFront(nil)
+        for kind in [NSWindow.ButtonType.closeButton, .miniaturizeButton, .zoomButton] {
+            window.standardWindowButton(kind)?.isHidden = true
+        }
     }
 
     func startRuntimeSmokeIfNeeded() {
@@ -351,6 +516,10 @@ struct RecordingsApp: App {
                 MenuBarStatusView(
                     store: store,
                     openRecordings: state.openRecordings,
+                    openSettings: state.openSettings,
+                    openHistory: state.openHistory,
+                    openRecent: state.openRecent,
+                    openBar: state.openBar,
                     barOnly: state.barOnly
                 )
             } else if state.runtimeSmokeProbe != nil {
@@ -370,23 +539,30 @@ struct RecordingsApp: App {
 
         Settings {
             if let store = state.store {
-                SettingsView(engine: store.engine, shortcuts: store.voiceShortcuts, projectStore: store.projectStore)
+                SettingsView(engine: store.engine, shortcuts: store.voiceShortcuts, preferences: store.preferences)
             } else {
                 EmptyView()
             }
         }
         .commands {
             if let store = state.store {
+                CommandGroup(replacing: .appSettings) {
+                    Button("Settings…", action: state.openSettings)
+                        .keyboardShortcut(",", modifiers: .command)
+                }
                 CommandGroup(replacing: .newItem) {
                     Button("New Recording") {
-                        store.pane = .record
-                        store.engine.startRecording()
+                        self.state.openRecordings()
+                        store.beginRecording()
                     }
                     .keyboardShortcut("n", modifiers: .command)
+                    .disabled(!store.engine.canStartRecording)
                 }
                 CommandGroup(after: .toolbar) {
-                    Button("Recordings Library") { store.pane = .library }
+                    Button("Recordings") { state.openHistory() }
                         .keyboardShortcut("l", modifiers: .command)
+                    Button("Show Transcription Bar", action: state.openBar)
+                        .keyboardShortcut("b", modifiers: [.command, .shift])
                 }
             }
         }
@@ -394,7 +570,7 @@ struct RecordingsApp: App {
 
     private var menuBarInsertion: Binding<Bool> {
         Binding(
-            get: { state.declaresMenuBar && (state.store != nil || state.runtimeSmokeProbe != nil) },
+            get: { state.declaresMenuBar && (state.store?.showMenuBar == true || state.runtimeSmokeProbe != nil) },
             set: { _ in }
         )
     }

package/src/native/Recordings/App/RecordingsListView.swift

@@ -1,130 +1,78 @@
 import SwiftUI
 import RecordingsLib
 
-/// The recordings library list: a search field, then a flat list of transcripts on the white
-/// canvas, separated by hairline dividers. Selecting a row shows it in the detail pane.
 struct RecordingsListView: View {
     @ObservedObject var store: RecordingsStore
+    var close: () -> Void = {}
+    @State private var searching = false
 
     var body: some View {
-        VStack(spacing: 0) {
-            searchRow
-            Divider().opacity(0.5)
-            list
-        }
-    }
-
-    private var searchRow: some View {
-        HStack(spacing: 8) {
-            Image(systemName: "magnifyingglass").foregroundStyle(.secondary)
-            TextField("Search transcripts", text: $store.searchText)
-                .textFieldStyle(.plain)
-                .font(.system(.body, design: .rounded))
-            if !store.searchText.isEmpty {
-                Button { store.searchText = "" } label: {
-                    Image(systemName: "xmark.circle.fill").foregroundStyle(.tertiary)
-                }
-                .buttonStyle(.plain)
+        VStack(spacing: 10) {
+            HStack {
+                Button(action: close) { Image(systemName: "chevron.left") }.help("Back to recorder").accessibilityLabel("Back to recorder")
+                Text("Recordings").font(.system(size: 13, weight: .semibold))
+                Spacer()
+                Button { searching.toggle() } label: { Image(systemName: "magnifyingglass") }
+                    .help("Search transcripts").accessibilityLabel("Search transcripts")
+                Button { store.loadLibrary() } label: { Image(systemName: "arrow.clockwise") }
+                    .help("Refresh recordings").accessibilityLabel("Refresh recordings")
             }
-        }
-        .padding(.horizontal, 16).padding(.vertical, 10)
-    }
-
-    @ViewBuilder
-    private var list: some View {
-        if store.isLoadingLibrary && store.library.isEmpty {
-            centered { ProgressView() }
-        } else if let error = store.loadError, store.library.isEmpty {
-            centered {
-                VStack(spacing: 8) {
-                    Image(systemName: "exclamationmark.triangle").font(.largeTitle).foregroundStyle(.orange)
-                    Text(error).font(.callout).foregroundStyle(.secondary).multilineTextAlignment(.center)
-                    Button("Retry") { store.loadLibrary() }
-                }
-                .padding(24)
+            .buttonStyle(GlassButtonStyle()).foregroundStyle(Theme.accent)
+            .padding(.horizontal, 2)
+            if searching && store.selectedRecording == nil {
+                TextField("Search transcripts", text: $store.searchText).textFieldStyle(.plain).padding(7).background(GlassInset()).padding(.horizontal, 12)
             }
-        } else if store.visibleRecordings.isEmpty {
-            centered {
-                VStack(spacing: 8) {
-                    Image(systemName: "waveform").font(.largeTitle).foregroundStyle(.quaternary)
-                    Text(emptyMessage).foregroundStyle(.secondary).multilineTextAlignment(.center)
-                    Button("Record") { store.pane = .record }.buttonStyle(.borderless)
+            if store.selectedRecording != nil {
+                HStack {
+                    Button { store.selection = nil } label: { Label("All recordings", systemImage: "chevron.left") }.buttonStyle(GlassButtonStyle())
+                    Spacer()
                 }
-            }
-        } else {
-            ScrollView {
-                LazyVStack(spacing: 0) {
-                    ForEach(store.visibleRecordings) { rec in
-                        RecordingRow(rec: rec,
-                                     projectName: store.projectName(rec.projectId),
-                                     selected: store.selection == rec.id)
-                            .contentShape(Rectangle())
-                            .onTapGesture { store.selection = rec.id }
-                            .contextMenu {
-                                Button("Copy") {
-                                    let pb = NSPasteboard.general
-                                    pb.clearContents(); pb.setString(rec.displayText, forType: .string)
-                                }
-                                Button("Paste into front app") { store.engine.pasteIntoFrontApp(rec.displayText) }
-                                Divider()
-                                Button("Delete", role: .destructive) { store.delete(id: rec.id) }
+                RecordingDetailView(store: store)
+            } else if store.isLoadingLibrary && store.library.isEmpty {
+                Spacer(); ProgressView(); Spacer()
+            } else if let error = store.loadError, store.library.isEmpty {
+                Spacer()
+                Text(error.contains("HASNA_RECORDINGS") ? "Connect your Recordings API in Settings to see your history." : error)
+                    .font(.callout).foregroundStyle(.secondary).multilineTextAlignment(.center).padding()
+                Button("Retry") { store.loadLibrary() }; Spacer()
+            } else if store.visibleRecordings.isEmpty {
+                Spacer(); Text(store.searchText.isEmpty ? "No recordings yet" : "No matching recordings").foregroundStyle(.secondary); Spacer()
+            } else {
+                ScrollView {
+                    LazyVStack(spacing: 2) {
+                        ForEach(store.visibleRecordings) { rec in
+                            HStack(spacing: 12) {
+                                GlassIconButton(symbol: store.playbackRecordingID == rec.id && store.isPlaying ? "pause.fill" : "play.fill", label: "Play recording", size: 28) { store.play(rec) }
+                                    .disabled(!store.canPlay(rec) || store.engine.captureIsActive)
+                                    .help(store.canPlay(rec) ? "Play recording" : "Audio is not stored on this Mac")
+                                Button { store.selection = rec.id } label: {
+                                    VStack(alignment: .leading, spacing: 5) {
+                                        Text(rec.snippet).font(.system(size: 13)).lineLimit(1)
+                                        Text(rec.createdDate?.recordingDateLabel ?? "Recording").font(.system(size: 11)).foregroundStyle(.secondary)
+                                    }
+                                    .frame(maxWidth: .infinity, alignment: .leading).contentShape(Rectangle())
+                                }.buttonStyle(.plain)
+                                Text(Theme.clock(rec.durationSeconds)).font(.system(size: 12)).monospacedDigit().foregroundStyle(.secondary)
+                                Menu {
+                                    Button("Open transcript") { store.selection = rec.id }
+                                    Button("Copy transcript") { NSPasteboard.general.clearContents(); NSPasteboard.general.setString(rec.displayText, forType: .string) }
+                                    Button("Delete recording", role: .destructive) { store.delete(id: rec.id) }
+                                } label: { Image(systemName: "ellipsis").font(.system(size: 13)) }
+                                .menuStyle(.borderlessButton).menuIndicator(.hidden).frame(width: 28)
                             }
-                        Divider().opacity(0.35).padding(.leading, 16)
+                            .padding(.horizontal, 10).padding(.vertical, 8)
+                            .background(GlassInset(radius: 10))
+                        }
                     }
                 }
             }
         }
-    }
-
-    private var emptyMessage: String {
-        if !store.searchText.isEmpty { return "No matches for “\(store.searchText)”" }
-        switch store.filter {
-        case .project(let id):
-            return "No recordings in \(store.projectName(id) ?? "this project") yet"
-        case .noProject: return "No unassigned recordings"
-        case .mode(let m): return "No \(m) recordings yet"
-        case .thisMachine, .machine: return "No recordings from this machine"
-        case .all: return "No recordings yet"
-        }
-    }
-
-    @ViewBuilder
-    private func centered<Content: View>(@ViewBuilder _ content: () -> Content) -> some View {
-        VStack { Spacer(); content(); Spacer() }.frame(maxWidth: .infinity, maxHeight: .infinity)
-    }
-}
-
-private struct RecordingRow: View {
-    let rec: Recording
-    let projectName: String?
-    let selected: Bool
+        .padding(12)
 
-    var body: some View {
-        VStack(alignment: .leading, spacing: 5) {
-            Text(rec.snippet)
-                .font(.system(.headline, design: .rounded)).lineLimit(2)
-            HStack(spacing: 6) {
-                if let date = rec.createdDate {
-                    Text(date.relativeDescription).font(.caption2).foregroundStyle(.secondary)
-                }
-                if rec.durationMs > 0 {
-                    Text("·").font(.caption2).foregroundStyle(.secondary)
-                    Text(rec.durationLabel).font(.caption2).foregroundStyle(.secondary)
-                }
-                if rec.isEnhanced {
-                    Text("·").font(.caption2).foregroundStyle(.secondary)
-                    Label("Enhanced", systemImage: "wand.and.stars")
-                        .labelStyle(.titleAndIcon).font(.caption2).foregroundStyle(Theme.accent.opacity(0.9))
-                }
-                if let projectName {
-                    Text("·").font(.caption2).foregroundStyle(.secondary)
-                    Label(projectName, systemImage: "folder").labelStyle(.titleAndIcon)
-                        .font(.caption2).foregroundStyle(.secondary)
-                }
-            }
-        }
-        .padding(.horizontal, 16).padding(.vertical, 11)
-        .frame(maxWidth: .infinity, alignment: .leading)
-        .background { if selected { Theme.accent.opacity(0.12) } }
+        .frame(minWidth: 500, minHeight: 354)
+        .onAppear { store.loadLibrary() }
+        .alert("Recordings Error", isPresented: Binding(get: { store.operationError != nil }, set: { if !$0 { store.operationError = nil } })) {
+            Button("OK") { store.operationError = nil }
+        } message: { Text(store.operationError ?? "The operation failed.") }
     }
 }