@hasna/recordings 0.1.10 → 0.1.11

package/src/native/Recordings/Recordings/FnKeyMonitor.swift

@@ -1,8 +1,8 @@
 import Cocoa
 
 /// Monitors the fn/Globe key using CGEventTap.
-/// Based on the proven pattern from CustomWispr (open-source WisprFlow alternative).
-/// User must set System Settings > Keyboard > "Press fn key to: Do Nothing" for this to work.
+/// Fn is exposed as a modifier flag, so we watch flagsChanged events and
+/// check CGEventFlags.maskSecondaryFn rather than relying on a raw bit mask.
 final class FnKeyMonitor: @unchecked Sendable {
     var onFnKeyDown: (() -> Void)?
     var onFnKeyUp: (() -> Void)?
@@ -13,7 +13,6 @@ final class FnKeyMonitor: @unchecked Sendable {
     private var fnIsDown = false
 
     private static let fnKeyCode: UInt16 = 63
-    private static let fnFlagMask: UInt64 = 0x800000
 
     /// Start monitoring. Returns true if successful.
     func start() -> Bool {
@@ -22,46 +21,54 @@ final class FnKeyMonitor: @unchecked Sendable {
             return true
         }
 
-        fputs("[FnKeyMonitor] Creating event tap...\n", stderr)
-        let eventMask: CGEventMask = (1 << CGEventType.flagsChanged.rawValue)
-
-        // passRetained so the callback reference stays alive
-        let selfPtr = Unmanaged.passRetained(self).toOpaque()
-
-        guard let tap = CGEvent.tapCreate(
-            tap: .cgSessionEventTap,
-            place: .headInsertEventTap,
-            options: .defaultTap,
-            eventsOfInterest: eventMask,
-            callback: { (proxy, type, event, refcon) -> Unmanaged<CGEvent>? in
-                guard let refcon = refcon else { return Unmanaged.passRetained(event) }
-                let monitor = Unmanaged<FnKeyMonitor>.fromOpaque(refcon).takeUnretainedValue()
-                return monitor.handleEvent(type: type, event: event)
-            },
-            userInfo: selfPtr
-        ) else {
-            Unmanaged<FnKeyMonitor>.fromOpaque(selfPtr).release()
-            return false
-        }
-
-        self.eventTap = tap
-
-        let source = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, tap, 0)
-        self.runLoopSource = source
-        CFRunLoopAddSource(CFRunLoopGetCurrent(), source, .commonModes)
-        CGEvent.tapEnable(tap: tap, enable: true)
-        fputs("[FnKeyMonitor] Event tap created and enabled OK\n", stderr)
+        let eventMask: CGEventMask = 1 << CGEventType.flagsChanged.rawValue
+        let selfPtr = Unmanaged.passUnretained(self).toOpaque()
+        let candidates: [(CGEventTapLocation, CGEventTapPlacement, String)] = [
+            (.cgAnnotatedSessionEventTap, .tailAppendEventTap, "annotated-session/tail"),
+            (.cgSessionEventTap, .tailAppendEventTap, "session/tail"),
+            (.cghidEventTap, .headInsertEventTap, "hid/head"),
+        ]
+
+        for (tapLocation, tapPlacement, label) in candidates {
+            fputs("[FnKeyMonitor] Trying event tap: \(label)\n", stderr)
+
+            guard let tap = CGEvent.tapCreate(
+                tap: tapLocation,
+                place: tapPlacement,
+                options: .defaultTap,
+                eventsOfInterest: eventMask,
+                callback: { _, type, event, refcon -> Unmanaged<CGEvent>? in
+                    guard let refcon else { return Unmanaged.passRetained(event) }
+                    let monitor = Unmanaged<FnKeyMonitor>.fromOpaque(refcon).takeUnretainedValue()
+                    return monitor.handleEvent(type: type, event: event)
+                },
+                userInfo: selfPtr
+            ) else {
+                continue
+            }
 
-        // Health check: macOS silently disables taps — re-enable every 3 seconds
-        healthCheckTimer = Timer.scheduledTimer(withTimeInterval: 3.0, repeats: true) { [weak self] _ in
-            guard let self = self, let tap = self.eventTap else { return }
-            if !CGEvent.tapIsEnabled(tap: tap) {
-                fputs("[FnKeyMonitor] Tap was disabled, re-enabling\n", stderr)
-                CGEvent.tapEnable(tap: tap, enable: true)
+            eventTap = tap
+            runLoopSource = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, tap, 0)
+            if let runLoopSource {
+                CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource, .commonModes)
+            }
+            CGEvent.tapEnable(tap: tap, enable: true)
+            fputs("[FnKeyMonitor] Event tap ready: \(label)\n", stderr)
+
+            // Health check: macOS can silently disable taps — re-enable every 3 seconds.
+            healthCheckTimer = Timer.scheduledTimer(withTimeInterval: 3.0, repeats: true) { [weak self] _ in
+                guard let self, let tap = self.eventTap else { return }
+                if !CGEvent.tapIsEnabled(tap: tap) {
+                    fputs("[FnKeyMonitor] Tap was disabled, re-enabling\n", stderr)
+                    CGEvent.tapEnable(tap: tap, enable: true)
+                }
             }
+
+            return true
         }
 
-        return true
+        fputs("[FnKeyMonitor] Failed to create any event tap\n", stderr)
+        return false
     }
 
     func stop() {
@@ -80,7 +87,6 @@ final class FnKeyMonitor: @unchecked Sendable {
     }
 
     private func handleEvent(type: CGEventType, event: CGEvent) -> Unmanaged<CGEvent>? {
-        // Re-enable if macOS disabled the tap
         if type == .tapDisabledByTimeout || type == .tapDisabledByUserInput {
             if let tap = eventTap {
                 CGEvent.tapEnable(tap: tap, enable: true)
@@ -88,33 +94,36 @@ final class FnKeyMonitor: @unchecked Sendable {
             return Unmanaged.passRetained(event)
         }
 
+        guard type == .flagsChanged else {
+            return Unmanaged.passRetained(event)
+        }
+
         let keyCode = UInt16(event.getIntegerValueField(.keyboardEventKeycode))
+        let fnPressed = event.flags.contains(.maskSecondaryFn)
+        let isFnTransition = keyCode == FnKeyMonitor.fnKeyCode || fnPressed || fnIsDown
 
-        // Only handle fn key (keyCode 63)
-        guard keyCode == FnKeyMonitor.fnKeyCode else {
+        guard isFnTransition else {
             return Unmanaged.passRetained(event)
         }
 
         let flags = event.flags.rawValue
-        let fnPressed = (flags & FnKeyMonitor.fnFlagMask) != 0
-
         fputs("[FnKeyMonitor] flagsChanged keyCode=\(keyCode) flags=0x\(String(flags, radix: 16)) fnPressed=\(fnPressed) fnIsDown=\(fnIsDown)\n", stderr)
 
         if fnPressed && !fnIsDown {
-            // fn just pressed
             fnIsDown = true
             fputs("[FnKeyMonitor] fn DOWN — starting recording\n", stderr)
             DispatchQueue.main.async { [weak self] in
                 self?.onFnKeyDown?()
             }
-            return nil // Swallow — prevents emoji picker / language switch
-        } else if !fnPressed && fnIsDown {
-            // fn released
+            return nil
+        }
+
+        if !fnPressed && fnIsDown {
             fnIsDown = false
             DispatchQueue.main.async { [weak self] in
                 self?.onFnKeyUp?()
             }
-            return nil // Swallow release too
+            return nil
         }
 
         return Unmanaged.passRetained(event)

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

@@ -4,89 +4,81 @@ import KeyboardShortcuts
 struct MenuBarPopover: View {
     @ObservedObject var engine: RecordingEngine
     @ObservedObject var shortcuts: VoiceShortcuts
+    @ObservedObject var projectStore: ProjectStore
+    @State private var copiedIndex: Int?
+    @State private var filterProjectId: String?
+
+    private var filteredTranscriptions: [TranscriptionResult] {
+        guard let filter = filterProjectId else {
+            return engine.recentTranscriptions
+        }
+        if filter == "__none__" {
+            return engine.recentTranscriptions.filter { $0.projectId == nil }
+        }
+        return engine.recentTranscriptions.filter { $0.projectId == filter }
+    }
 
     var body: some View {
         VStack(spacing: 0) {
-            header.padding(.horizontal, 16).padding(.top, 12).padding(.bottom, 8)
-            Divider()
-            modeSelector.padding(.horizontal, 16).padding(.vertical, 10)
-            shortcutRow.padding(.horizontal, 16).padding(.bottom, 8)
+            header
+                .padding(.horizontal, 16).padding(.top, 12).padding(.bottom, 8)
             Divider()
-            recordingArea.padding(.horizontal, 16).padding(.vertical, 12)
+            recordingArea
+                .padding(.horizontal, 16).padding(.vertical, 12)
             Divider()
-            recentList.frame(maxHeight: 180)
+            if !engine.recentTranscriptions.isEmpty {
+                filterBar
+                    .padding(.horizontal, 16).padding(.vertical, 6)
+                Divider()
+            }
+            recentList
+                .frame(maxHeight: 200)
             Divider()
-            footer.padding(.horizontal, 16).padding(.vertical, 8)
+            footerMenu
         }
     }
 
     // MARK: - Header
 
     private var header: some View {
-        HStack {
-            Image(systemName: "mic.fill").font(.title3).foregroundStyle(.tint)
-            Text("Recordings").font(.headline)
-            Spacer()
-            Toggle(isOn: $engine.isWhisperMode) {
-                Label("Whisper", systemImage: "speaker.wave.1.fill").font(.caption)
-            }
-            .toggleStyle(.button).buttonStyle(.bordered).controlSize(.small)
-        }
-    }
-
-    // MARK: - Mode Selector
-
-    private var modeSelector: some View {
-        HStack(spacing: 8) {
-            modeBtn(.pushToTalk)
-            modeBtn(.dictation)
-            modeBtn(.command)
-        }
-    }
-
-    @ViewBuilder
-    private func modeBtn(_ m: RecordingMode) -> some View {
-        if engine.mode == m {
-            Button { engine.mode = m } label: {
-                Label(m.rawValue, systemImage: m.icon).font(.caption)
-                    .foregroundStyle(.white).frame(maxWidth: .infinity)
-            }.buttonStyle(.borderedProminent).controlSize(.small)
-        } else {
-            Button { engine.mode = m } label: {
-                Label(m.rawValue, systemImage: m.icon).font(.caption)
-                    .frame(maxWidth: .infinity)
-            }.buttonStyle(.bordered).controlSize(.small)
-        }
-    }
-
-    // MARK: - Shortcut Row
-
-    private var shortcutRow: some View {
-        VStack(spacing: 6) {
-            // fn key toggle
+        VStack(alignment: .leading, spacing: 4) {
             HStack {
-                Toggle(isOn: $engine.useFnKey) {
-                    HStack(spacing: 4) {
-                        Text("fn").font(.system(.caption, design: .monospaced)).bold()
-                        Text("Globe key").font(.caption).foregroundStyle(.secondary)
-                    }
+                Image(systemName: "mic.fill")
+                    .foregroundStyle(.tint)
+                Text("Hasna Recordings")
+                Spacer()
+                if let shortcut = KeyboardShortcuts.getShortcut(for: .toggleRecording) {
+                    Text(shortcut.description)
+                        .foregroundStyle(.secondary)
                 }
-                .toggleStyle(.switch).controlSize(.small)
             }
-
-            // Custom shortcut
-            HStack(spacing: 8) {
-                Text("Custom").font(.caption).foregroundStyle(.secondary)
-                Spacer()
-                let current = KeyboardShortcuts.getShortcut(for: .toggleRecording)
-                Text(current?.description ?? "None")
-                    .font(.system(.caption, design: .monospaced))
-                    .padding(.horizontal, 8).padding(.vertical, 3)
-                    .background(.quaternary, in: RoundedRectangle(cornerRadius: 5))
-
-                SettingsLink {
-                    Text("Set").font(.caption2)
-                }.buttonStyle(.bordered).controlSize(.mini)
+            if !projectStore.settings.projects.isEmpty {
+                HStack(spacing: 4) {
+                    Image(systemName: "folder.fill")
+                        .foregroundColor(projectStore.activeProject != nil ? .accentColor : .secondary)
+                    Menu {
+                        Button("None") { projectStore.setActive(nil) }
+                        Divider()
+                        ForEach(projectStore.settings.projects) { project in
+                            Button {
+                                projectStore.setActive(project.id)
+                            } label: {
+                                HStack {
+                                    Text(project.name)
+                                    if project.id == projectStore.settings.activeProjectId {
+                                        Image(systemName: "checkmark")
+                                    }
+                                }
+                            }
+                        }
+                    } label: {
+                        Text(projectStore.activeProject?.name ?? "No project")
+                            .foregroundStyle(projectStore.activeProject == nil ? .secondary : .primary)
+                    }
+                    .menuStyle(.borderlessButton)
+                    .fixedSize()
+                    Spacer()
+                }
             }
         }
     }
@@ -94,41 +86,94 @@ struct MenuBarPopover: View {
     // MARK: - Recording Area
 
     private var recordingArea: some View {
-        VStack(spacing: 8) {
+        Group {
             if engine.isRecording {
-                HStack(spacing: 12) {
-                    Circle().fill(.red).frame(width: 10, height: 10)
-                    Text(fmt(engine.recordingDuration))
-                        .font(.system(.title2, design: .monospaced))
-                    Spacer()
-                    Button("Stop") { engine.stopAndTranscribe() }
-                        .buttonStyle(.borderedProminent).tint(.red).controlSize(.small)
+                VStack(spacing: 6) {
+                    HStack {
+                        Circle().fill(.red).frame(width: 8, height: 8)
+                        Text(fmt(engine.recordingDuration))
+                            .monospacedDigit()
+                        Spacer()
+                        Button("Stop") { engine.stopAndTranscribe() }
+                            .controlSize(.small)
+                    }
+                    if let project = projectStore.activeProject {
+                        HStack(spacing: 4) {
+                            Image(systemName: "folder.fill").foregroundStyle(.tint)
+                            Text(project.name).foregroundStyle(.secondary)
+                            Spacer()
+                        }
+                    }
                 }
-                .padding(12).glassEffect(.regular.tint(.red))
+                .padding(10)
+                .glassEffect(.regular)
             } else if engine.isTranscribing {
-                HStack(spacing: 8) {
-                    ProgressView().controlSize(.small)
-                    Text("Transcribing...").font(.subheadline).foregroundStyle(.secondary)
+                VStack(spacing: 6) {
+                    HStack(spacing: 8) {
+                        ProgressView().controlSize(.small)
+                        Text("Transcribing...")
+                            .foregroundStyle(.secondary)
+                        Spacer()
+                    }
+                    if let project = projectStore.activeProject {
+                        HStack(spacing: 4) {
+                            Image(systemName: "folder.fill").foregroundStyle(.tint)
+                            Text(project.name).foregroundStyle(.secondary)
+                            Spacer()
+                        }
+                    }
                 }
-                .frame(maxWidth: .infinity).padding(12).glassEffect(.regular)
+                .frame(maxWidth: .infinity)
+                .padding(10)
+                .glassEffect(.regular)
             } else {
-                VStack(spacing: 10) {
+                VStack(spacing: 6) {
                     Button { engine.startRecording() } label: {
-                        Label("Record", systemImage: "mic.circle.fill").font(.title3)
-                    }.buttonStyle(.borderedProminent).controlSize(.large)
+                        Label("Record", systemImage: "mic.circle.fill")
+                    }
+                    .controlSize(.regular)
 
-                    Text(engine.mode.hint)
-                        .font(.callout).foregroundStyle(.primary.opacity(0.7))
-                        .multilineTextAlignment(.center)
-                        .fixedSize(horizontal: false, vertical: true)
+                    if let shortcut = KeyboardShortcuts.getShortcut(for: .toggleRecording) {
+                        Text("or hold \(shortcut.description)")
+                            .foregroundStyle(.tertiary)
+                    }
                 }
-                .frame(maxWidth: .infinity).padding(14).glassEffect(.clear)
+                .frame(maxWidth: .infinity)
+                .padding(10)
+                .glassEffect(.regular)
             }
+        }
+    }
 
-            Text(engine.statusMessage)
-                .font(.caption2).foregroundStyle(.secondary)
-                .lineLimit(2).truncationMode(.tail)
-                .frame(maxWidth: .infinity, alignment: .leading)
+    // MARK: - Filter Bar
+
+    private var filterBar: some View {
+        ScrollView(.horizontal, showsIndicators: false) {
+            HStack(spacing: 6) {
+                FilterChip(label: "All", isActive: filterProjectId == nil) {
+                    filterProjectId = nil
+                }
+                ForEach(projectStore.settings.projects) { project in
+                    let count = engine.recentTranscriptions.filter { $0.projectId == project.id }.count
+                    if count > 0 {
+                        FilterChip(
+                            label: "\(project.name) (\(count))",
+                            isActive: filterProjectId == project.id
+                        ) {
+                            filterProjectId = filterProjectId == project.id ? nil : project.id
+                        }
+                    }
+                }
+                let noProjectCount = engine.recentTranscriptions.filter { $0.projectId == nil }.count
+                if noProjectCount > 0 {
+                    FilterChip(
+                        label: "No project (\(noProjectCount))",
+                        isActive: filterProjectId == "__none__"
+                    ) {
+                        filterProjectId = filterProjectId == "__none__" ? nil : "__none__"
+                    }
+                }
+            }
         }
     }
 
@@ -136,18 +181,30 @@ struct MenuBarPopover: View {
 
     private var recentList: some View {
         Group {
-            if engine.recentTranscriptions.isEmpty {
-                VStack { Spacer()
-                    Text("No recent transcriptions").font(.caption).foregroundStyle(.quaternary)
-                    Spacer()
-                }.frame(maxWidth: .infinity)
+            if filteredTranscriptions.isEmpty {
+                Spacer()
             } else {
                 ScrollView {
-                    LazyVStack(alignment: .leading, spacing: 4) {
-                        ForEach(engine.recentTranscriptions.indices, id: \.self) { i in
-                            TranscriptionRow(item: engine.recentTranscriptions[i])
+                    LazyVStack(alignment: .leading, spacing: 2) {
+                        ForEach(filteredTranscriptions.indices, id: \.self) { i in
+                            let item = filteredTranscriptions[i]
+                            TranscriptionRow(
+                                item: item,
+                                showProject: filterProjectId == nil,
+                                isCopied: copiedIndex == i
+                            ) {
+                                NSPasteboard.general.clearContents()
+                                NSPasteboard.general.setString(item.displayText, forType: .string)
+                                withAnimation(.easeInOut(duration: 0.15)) {
+                                    copiedIndex = i
+                                }
+                                DispatchQueue.main.asyncAfter(deadline: .now() + 1.2) {
+                                    withAnimation { if copiedIndex == i { copiedIndex = nil } }
+                                }
+                            }
                         }
-                    }.padding(.horizontal, 16).padding(.vertical, 6)
+                    }
+                    .padding(.horizontal, 16).padding(.vertical, 6)
                 }
             }
         }
@@ -155,12 +212,33 @@ struct MenuBarPopover: View {
 
     // MARK: - Footer
 
-    private var footer: some View {
-        HStack {
-            SettingsLink { Image(systemName: "gear") }.buttonStyle(.borderless)
-            Spacer()
-            Button("Quit") { NSApplication.shared.terminate(nil) }
-                .buttonStyle(.borderless).foregroundStyle(.secondary)
+    private var footerMenu: some View {
+        VStack(spacing: 0) {
+            SettingsLink {
+                HStack {
+                    Text("Settings...")
+                    Spacer()
+                    Text("⌘,").foregroundStyle(.tertiary)
+                }
+                .contentShape(Rectangle())
+                .padding(.horizontal, 16).padding(.vertical, 6)
+            }
+            .buttonStyle(.plain)
+
+            Divider()
+
+            Button {
+                NSApplication.shared.terminate(nil)
+            } label: {
+                HStack {
+                    Text("Quit Hasna Recordings")
+                    Spacer()
+                    Text("⌘Q").foregroundStyle(.tertiary)
+                }
+                .contentShape(Rectangle())
+                .padding(.horizontal, 16).padding(.vertical, 6)
+            }
+            .buttonStyle(.plain)
         }
     }
 
@@ -169,20 +247,71 @@ struct MenuBarPopover: View {
     }
 }
 
+// MARK: - Filter Chip
+
+struct FilterChip: View {
+    let label: String
+    let isActive: Bool
+    let action: () -> Void
+
+    var body: some View {
+        Button(action: action) {
+            Text(label)
+                .padding(.horizontal, 8)
+                .padding(.vertical, 3)
+                .background(isActive ? Color.accentColor.opacity(0.15) : Color.clear)
+                .clipShape(RoundedRectangle(cornerRadius: 6))
+        }
+        .buttonStyle(.plain)
+        .foregroundStyle(isActive ? .primary : .secondary)
+    }
+}
+
+// MARK: - Transcription Row
+
 struct TranscriptionRow: View {
     let item: TranscriptionResult
+    let showProject: Bool
+    let isCopied: Bool
+    let onCopy: () -> Void
+
     var body: some View {
-        HStack(alignment: .top, spacing: 8) {
-            Text(item.displayText).font(.caption).lineLimit(2)
-                .frame(maxWidth: .infinity, alignment: .leading)
-            Text({ let s = Date().timeIntervalSince(item.timestamp)
-                return s < 60 ? "now" : s < 3600 ? "\(Int(s/60))m" : "\(Int(s/3600))h"
-            }()).font(.caption2).foregroundStyle(.tertiary)
+        VStack(alignment: .leading, spacing: 2) {
+            HStack(alignment: .top, spacing: 8) {
+                Text(item.displayText)
+                    .lineLimit(2)
+                    .frame(maxWidth: .infinity, alignment: .leading)
+
+                if isCopied {
+                    Image(systemName: "checkmark")
+                        .foregroundStyle(.green)
+                        .transition(.scale.combined(with: .opacity))
+                } else {
+                    Text(relativeTime(item.timestamp))
+                        .foregroundStyle(.tertiary)
+                }
+            }
+            if showProject, let name = item.projectName {
+                HStack(spacing: 3) {
+                    Image(systemName: "folder")
+                    Text(name)
+                }
+                .foregroundStyle(.tertiary)
+            }
         }
-        .padding(.vertical, 4).contentShape(Rectangle())
-        .onTapGesture {
-            NSPasteboard.general.clearContents()
-            NSPasteboard.general.setString(item.displayText, forType: .string)
+        .padding(.vertical, 4)
+        .padding(.horizontal, 6)
+        .contentShape(Rectangle())
+        .onTapGesture { onCopy() }
+        .onHover { hovering in
+            if hovering { NSCursor.pointingHand.push() } else { NSCursor.pop() }
         }
     }
+
+    private func relativeTime(_ date: Date) -> String {
+        let s = Date().timeIntervalSince(date)
+        if s < 60 { return "now" }
+        if s < 3600 { return "\(Int(s / 60))m" }
+        return "\(Int(s / 3600))h"
+    }
 }