@hasna/recordings 0.1.10 → 0.1.12

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

@@ -1,15 +1,28 @@
+@preconcurrency import Cocoa
 import SwiftUI
 import KeyboardShortcuts
+import RecordingsLib
 
 @main
 struct RecordingsApp: App {
     @StateObject private var engine = RecordingEngine()
     @StateObject private var shortcuts = VoiceShortcuts()
+    @StateObject private var projectStore = ProjectStore()
+
+    init() {
+        AXIsProcessTrustedWithOptions(
+            [kAXTrustedCheckOptionPrompt.takeUnretainedValue(): true] as CFDictionary
+        )
+    }
 
     var body: some Scene {
         MenuBarExtra {
-            MenuBarPopover(engine: engine, shortcuts: shortcuts)
-                .frame(width: 320, height: 440)
+            MenuBarPopover(engine: engine, shortcuts: shortcuts, projectStore: projectStore)
+                .frame(width: 320, height: 420)
+                .onAppear {
+                    engine.projectStore = projectStore
+                    engine.voiceShortcuts = shortcuts
+                }
         } label: {
             if engine.isRecording {
                 Image(systemName: "record.circle.fill")
@@ -22,9 +35,8 @@ struct RecordingsApp: App {
         }
         .menuBarExtraStyle(.window)
 
-        // Settings window — opened via SettingsLink
         Settings {
-            SettingsView(engine: engine, shortcuts: shortcuts)
+            SettingsView(engine: engine, shortcuts: shortcuts, projectStore: projectStore)
         }
     }
 }

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/RecordingsLib/FnKeyMonitor.swift

@@ -0,0 +1,131 @@
+import Cocoa
+
+/// Monitors the fn/Globe key using CGEventTap.
+/// 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)?
+
+    private var eventTap: CFMachPort?
+    private var runLoopSource: CFRunLoopSource?
+    private var healthCheckTimer: Timer?
+    private var fnIsDown = false
+
+    private static let fnKeyCode: UInt16 = 63
+
+    /// Start monitoring. Returns true if successful.
+    func start() -> Bool {
+        guard eventTap == nil else {
+            fputs("[FnKeyMonitor] Already running\n", stderr)
+            return true
+        }
+
+        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
+            }
+
+            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
+        }
+
+        fputs("[FnKeyMonitor] Failed to create any event tap\n", stderr)
+        return false
+    }
+
+    func stop() {
+        healthCheckTimer?.invalidate()
+        healthCheckTimer = nil
+
+        if let tap = eventTap {
+            CGEvent.tapEnable(tap: tap, enable: false)
+        }
+        if let source = runLoopSource {
+            CFRunLoopRemoveSource(CFRunLoopGetCurrent(), source, .commonModes)
+        }
+        eventTap = nil
+        runLoopSource = nil
+        fnIsDown = false
+    }
+
+    private func handleEvent(type: CGEventType, event: CGEvent) -> Unmanaged<CGEvent>? {
+        if type == .tapDisabledByTimeout || type == .tapDisabledByUserInput {
+            if let tap = eventTap {
+                CGEvent.tapEnable(tap: tap, enable: true)
+            }
+            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
+
+        guard isFnTransition else {
+            return Unmanaged.passRetained(event)
+        }
+
+        let flags = event.flags.rawValue
+        fputs("[FnKeyMonitor] flagsChanged keyCode=\(keyCode) flags=0x\(String(flags, radix: 16)) fnPressed=\(fnPressed) fnIsDown=\(fnIsDown)\n", stderr)
+
+        if fnPressed && !fnIsDown {
+            fnIsDown = true
+            fputs("[FnKeyMonitor] fn DOWN — starting recording\n", stderr)
+            DispatchQueue.main.async { [weak self] in
+                self?.onFnKeyDown?()
+            }
+            return nil
+        }
+
+        if !fnPressed && fnIsDown {
+            fnIsDown = false
+            DispatchQueue.main.async { [weak self] in
+                self?.onFnKeyUp?()
+            }
+            return nil
+        }
+
+        return Unmanaged.passRetained(event)
+    }
+}

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/RecordingsLib/MenuBarPopover.swift

@@ -0,0 +1,361 @@
+import SwiftUI
+import KeyboardShortcuts
+
+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
+        }
+        if filter == "__none__" {
+            return engine.recentTranscriptions.filter { $0.projectId == nil }
+        }
+        return engine.recentTranscriptions.filter { $0.projectId == filter }
+    }
+
+    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(.top, 8).padding(.bottom, 12)
+            Divider()
+            if !engine.recentTranscriptions.isEmpty {
+                filterBar
+                    .padding(.horizontal, 16).padding(.vertical, 6)
+                Divider()
+            }
+            recentList
+                .frame(maxHeight: 200)
+            Divider()
+            footerMenu
+        }
+    }
+
+    // MARK: - Header
+
+    private var header: some View {
+        VStack(alignment: .leading, spacing: 4) {
+            HStack {
+                Image(systemName: "mic.fill")
+                    .foregroundStyle(.tint)
+                Text("Hasna Recordings")
+                Spacer()
+                if let shortcut = KeyboardShortcuts.getShortcut(for: .toggleRecording) {
+                    Text(shortcut.description)
+                        .foregroundStyle(.secondary)
+                }
+            }
+            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()
+                }
+            }
+        }
+    }
+
+    // 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 {
+        if engine.isRecording {
+                VStack(spacing: 6) {
+                    HStack {
+                        Circle().fill(.red).frame(width: 8, height: 8)
+                        Text(fmt(engine.recordingDuration))
+                            .monospacedDigit()
+                        Spacer()
+                        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)
+                            Text(project.name).foregroundStyle(.secondary)
+                            Spacer()
+                        }
+                    }
+                }
+                .padding(10)
+                .glassEffect(.regular)
+        } else if engine.isTranscribing {
+                VStack(spacing: 6) {
+                    HStack(spacing: 8) {
+                        ProgressView().controlSize(.small)
+                        Text("Transcribing...")
+                            .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)
+                            Text(project.name).foregroundStyle(.secondary)
+                            Spacer()
+                        }
+                    }
+                }
+                .frame(maxWidth: .infinity)
+                .padding(10)
+                .glassEffect(.regular)
+        } else {
+                VStack(spacing: 6) {
+                    Button { engine.startRecording() } label: {
+                        Label("Record", systemImage: "mic.circle.fill")
+                    }
+                    .controlSize(.regular)
+
+                    if let shortcut = KeyboardShortcuts.getShortcut(for: .toggleRecording) {
+                        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)
+        }
+    }
+
+    // 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__"
+                    }
+                }
+            }
+        }
+    }
+
+    // MARK: - Recent
+
+    private var recentList: some View {
+        Group {
+            if filteredTranscriptions.isEmpty {
+                Spacer()
+            } else {
+                ScrollView {
+                    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)
+                }
+            }
+        }
+    }
+
+    // MARK: - Footer
+
+    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)
+        }
+    }
+
+    private func fmt(_ t: TimeInterval) -> String {
+        String(format: "%d:%02d", Int(t) / 60, Int(t) % 60)
+    }
+}
+
+// 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 {
+        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)
+        .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"
+    }
+}