@hasna/recordings 0.2.11 → 0.2.13

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

@@ -0,0 +1,138 @@
+import SwiftUI
+import AVFoundation
+import RecordingsLib
+
+/// Detail pane for a selected recording: the full transcript on the white canvas, a slim
+/// action toolbar (copy / paste / play / delete), and a metadata strip. No boxed panels.
+struct RecordingDetailView: View {
+    @ObservedObject var store: RecordingsStore
+    @State private var player: AVAudioPlayer?
+    @State private var isPlaying = false
+    @State private var copied = false
+
+    var body: some View {
+        if let rec = store.selectedRecording {
+            detail(rec)
+        } else {
+            VStack(spacing: 10) {
+                Image(systemName: "waveform.and.mic").font(.system(size: 40)).foregroundStyle(.quaternary)
+                Text("Select a recording").foregroundStyle(.secondary)
+            }
+            .frame(maxWidth: .infinity, maxHeight: .infinity)
+        }
+    }
+
+    private func detail(_ rec: Recording) -> some View {
+        VStack(alignment: .leading, spacing: 0) {
+            HStack(spacing: 10) {
+                Text(rec.createdDate.map { dateLabel($0) } ?? "Recording")
+                    .font(.system(.title2, design: .rounded).weight(.semibold))
+                Spacer()
+                toolbar(rec)
+            }
+            .padding(.horizontal, 18).padding(.top, 16).padding(.bottom, 8)
+            Divider().opacity(0.4)
+
+            ScrollView {
+                Text(rec.displayText.isEmpty ? "No transcript" : rec.displayText)
+                    .font(.system(.title3, design: .rounded))
+                    .textSelection(.enabled)
+                    .frame(maxWidth: .infinity, alignment: .leading)
+                    .padding(.horizontal, 18).padding(.top, 14)
+
+                if rec.isEnhanced, !rec.rawText.isEmpty, rec.rawText != rec.displayText {
+                    VStack(alignment: .leading, spacing: 4) {
+                        Text("RAW TRANSCRIPT").font(.caption2.weight(.semibold)).foregroundStyle(.secondary)
+                        Text(rec.rawText).font(.callout).foregroundStyle(.secondary).textSelection(.enabled)
+                            .frame(maxWidth: .infinity, alignment: .leading)
+                    }
+                    .padding(.horizontal, 18).padding(.top, 18)
+                }
+            }
+
+            Divider().opacity(0.4)
+            metadata(rec).padding(.horizontal, 18).padding(.vertical, 10)
+        }
+        .onChange(of: store.selection) { _, _ in stopPlayback() }
+        .onDisappear { stopPlayback() }
+    }
+
+    private func toolbar(_ rec: Recording) -> some View {
+        HStack(spacing: 4) {
+            if hasAudio(rec) {
+                iconButton(isPlaying ? "stop.circle" : "play.circle", help: isPlaying ? "Stop" : "Play audio") {
+                    togglePlayback(rec)
+                }
+            }
+            iconButton(copied ? "checkmark" : "doc.on.doc", help: "Copy transcript") {
+                let pb = NSPasteboard.general
+                pb.clearContents(); pb.setString(rec.displayText, forType: .string)
+                withAnimation { copied = true }
+                DispatchQueue.main.asyncAfter(deadline: .now() + 1.2) { withAnimation { copied = false } }
+            }
+            iconButton("arrow.up.right.square", help: "Paste into front app") {
+                store.engine.pasteIntoFrontApp(rec.displayText)
+            }
+            iconButton("trash", help: "Delete") { store.delete(id: rec.id) }
+        }
+        .foregroundStyle(.secondary)
+    }
+
+    private func iconButton(_ name: String, help: String, action: @escaping () -> Void) -> some View {
+        Button(action: action) { Image(systemName: name).frame(width: 24, height: 24) }
+            .buttonStyle(.plain).help(help)
+    }
+
+    private func metadata(_ rec: Recording) -> some View {
+        HStack(spacing: 14) {
+            if rec.durationMs > 0 { metaItem("clock", rec.durationLabel) }
+            if let model = rec.modelUsed { metaItem("cpu", model) }
+            if let lang = rec.language, !lang.isEmpty { metaItem("globe", lang) }
+            if let name = store.projectName(rec.projectId) { metaItem("folder", name) }
+            if let machine = rec.machineId, !machine.isEmpty { metaItem("desktopcomputer", machine) }
+            if !rec.tags.isEmpty { metaItem("number", rec.tags.joined(separator: ", ")) }
+            Spacer()
+        }
+        .font(.caption2).foregroundStyle(.tertiary).lineLimit(1)
+    }
+
+    private func metaItem(_ icon: String, _ text: String) -> some View {
+        Label(text, systemImage: icon).labelStyle(.titleAndIcon)
+    }
+
+    private func dateLabel(_ date: Date) -> String {
+        let f = DateFormatter()
+        f.dateStyle = .medium; f.timeStyle = .short
+        return f.string(from: date)
+    }
+
+    // MARK: - Audio playback
+
+    private func hasAudio(_ rec: Recording) -> Bool {
+        guard let path = rec.audioPath, !path.isEmpty else { return false }
+        return FileManager.default.fileExists(atPath: path)
+    }
+
+    private func togglePlayback(_ rec: Recording) {
+        if isPlaying { stopPlayback(); return }
+        guard let path = rec.audioPath else { return }
+        do {
+            let p = try AVAudioPlayer(contentsOf: URL(fileURLWithPath: path))
+            p.play()
+            player = p
+            isPlaying = true
+            // Reset the button when playback ends.
+            DispatchQueue.main.asyncAfter(deadline: .now() + p.duration + 0.1) {
+                if player === p { stopPlayback() }
+            }
+        } catch {
+            isPlaying = false
+        }
+    }
+
+    private func stopPlayback() {
+        player?.stop()
+        player = nil
+        isPlaying = false
+    }
+}

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

@@ -1,79 +1,402 @@
 @preconcurrency import Cocoa
 import AVFoundation
+import Darwin
 import SwiftUI
 import KeyboardShortcuts
 import RecordingsLib
 
+private final class PermissionRequestResultBox: @unchecked Sendable {
+    private let lock = NSLock()
+    private var microphoneGranted = false
+
+    func setMicrophoneGranted(_ granted: Bool) {
+        lock.withLock { microphoneGranted = granted }
+    }
+
+    func outcome(accessibilityTrusted: Bool) -> PermissionRequestOutcome {
+        lock.withLock {
+            PermissionRequestOutcome(
+                microphoneGranted: microphoneGranted,
+                accessibilityTrusted: accessibilityTrusted
+            )
+        }
+    }
+}
+
+private struct RuntimeSmokeCompletionResponse: Encodable, Sendable {
+    let challenge: String
+    let mode: String
+    let processIdentifier: Int32
+}
+
+/// Recordings — a full native macOS app. The main window is the Recordings workspace
+/// (record + library); the menu-bar surface, global shortcuts, and the intent-routed
+/// recording flow keep working while the window is in the background.
+/// Keeps the app (and therefore the RecordingEngine + global shortcuts) alive after the
+/// last window is closed, so background recording shortcuts keep working.
+@MainActor
+final class RecordingsAppDelegate: NSObject, NSApplicationDelegate {
+    weak var state: RecordingsAppState?
+
+    func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool { false }
+
+    func applicationDidFinishLaunching(_ notification: Notification) {
+        state?.startRuntimeSmokeIfNeeded()
+    }
+
+    func applicationShouldHandleReopen(_ sender: NSApplication, hasVisibleWindows flag: Bool) -> Bool {
+        if !flag {
+            state?.openRecordings()
+        }
+        return true
+    }
+}
+
+@MainActor
+final class RecordingsAppState: ObservableObject {
+    let store: RecordingsStore?
+    let declaresMenuBar: Bool
+    let runtimeSmokeProbe: RuntimeSmokeProbe?
+    private let runtimeSmokeMode: String?
+    private let runtimeSmokeOutputPath: String?
+    private let runtimeSmokeAcknowledgementPath: String?
+    private let runtimeSmokeCompletionPath: String?
+    private var mainWindow: NSWindow?
+    private(set) var windowCreationCount = 0
+    private(set) var windowActivationCount = 0
+
+    init(plan: PermissionRequestLaunchPlan) {
+        declaresMenuBar = plan.declaresMenuBar
+        runtimeSmokeMode = plan.runtimeSmokeMode
+        runtimeSmokeOutputPath = plan.runtimeSmokeOutputPath
+        runtimeSmokeAcknowledgementPath = plan.runtimeSmokeAcknowledgementPath
+        runtimeSmokeCompletionPath = plan.runtimeSmokeCompletionPath
+        runtimeSmokeProbe = plan.runtimeSmokeMode == "normal" ? RuntimeSmokeProbe() : nil
+        if plan.installsGlobalHandlers {
+            let store = RecordingsStore()
+            self.store = store
+            if plan.declaresMainWindow {
+                Task { @MainActor [weak self] in
+                    self?.openRecordings()
+                }
+            }
+        } else {
+            store = nil
+        }
+    }
+
+    func openRecordings() {
+        if let store {
+            showWindow(contentView: NSHostingView(rootView: ContentView(store: store)))
+        } else if runtimeSmokeMode == "normal" {
+            showWindow(contentView: NSHostingView(rootView: Text("Recordings runtime smoke")))
+        }
+    }
+
+    private func showWindow(contentView: NSView) {
+        windowActivationCount += 1
+        NSApplication.shared.setActivationPolicy(.regular)
+        if let mainWindow {
+            NSApplication.shared.activate()
+            NSRunningApplication.current.activate(options: [.activateAllWindows])
+            mainWindow.makeKeyAndOrderFront(nil)
+            return
+        }
+
+        let window = NSWindow(
+            contentRect: NSRect(x: 0, y: 0, width: 1180, height: 760),
+            styleMask: [.titled, .closable, .miniaturizable, .resizable, .fullSizeContentView],
+            backing: .buffered,
+            defer: false
+        )
+        window.title = "Recordings"
+        window.titleVisibility = .hidden
+        window.titlebarAppearsTransparent = true
+        window.isReleasedWhenClosed = false
+        window.contentView = contentView
+        window.center()
+        mainWindow = window
+        windowCreationCount += 1
+        NSApplication.shared.activate()
+        NSRunningApplication.current.activate(options: [.activateAllWindows])
+        window.makeKeyAndOrderFront(nil)
+    }
+
+    func startRuntimeSmokeIfNeeded() {
+        guard let mode = runtimeSmokeMode, runtimeSmokeOutputPath != nil else { return }
+        DispatchQueue.global(qos: .utility).asyncAfter(deadline: .now() + 15) {
+            Darwin._exit(124)
+        }
+        if mode == "permission-helper" {
+            NSApplication.shared.setActivationPolicy(.accessory)
+            DispatchQueue.main.async { [weak self] in
+                DispatchQueue.main.async {
+                    self?.finishRuntimeSmoke(
+                        mode: mode,
+                        surfaceCount: 0,
+                        labels: [],
+                        accessibility: RuntimeSmokeAccessibilitySnapshot.processMenuBarExtras()
+                    )
+                }
+            }
+            return
+        }
+        if mode == "resolver" {
+            let probeHome = FileManager.default.temporaryDirectory
+                .appendingPathComponent("recordings-resolver-smoke-\(UUID().uuidString)")
+            do {
+                try FileManager.default.createDirectory(at: probeHome, withIntermediateDirectories: true)
+                let probe = try RecordingsCLI.probePackagedCompanion(home: probeHome.path)
+                try? FileManager.default.removeItem(at: probeHome)
+                finishRuntimeSmoke(
+                    mode: mode,
+                    surfaceCount: 0,
+                    labels: [],
+                    accessibility: RuntimeSmokeAccessibilitySnapshot.processMenuBarExtras(),
+                    resolvedCompanionPath: probe.executablePath,
+                    companionCapabilitiesPassed: true
+                )
+            } catch {
+                try? FileManager.default.removeItem(at: probeHome)
+                fputs("Packaged companion resolver smoke failed: \(error)\n", stderr)
+                finishRuntimeSmoke(
+                    mode: mode,
+                    surfaceCount: 0,
+                    labels: [],
+                    accessibility: RuntimeSmokeAccessibilitySnapshot.processMenuBarExtras(),
+                    companionCapabilitiesPassed: false
+                )
+            }
+            return
+        }
+        guard mode == "normal", let runtimeSmokeProbe else {
+            finishRuntimeSmoke(
+                mode: mode,
+                surfaceCount: 0,
+                labels: [],
+                accessibility: RuntimeSmokeAccessibilitySnapshot.processMenuBarExtras()
+            )
+            return
+        }
+        runtimeSmokeProbe.completed = { [weak self, weak runtimeSmokeProbe] in
+            guard let self, let runtimeSmokeProbe else { return }
+            let accessibility = RuntimeSmokeAccessibilitySnapshot.processMenuBarExtras()
+            self.openRecordings()
+            let firstWindow = self.mainWindow
+            self.openRecordings()
+            self.finishRuntimeSmokeWhenWindowSettles(
+                mode: mode,
+                surfaceCount: runtimeSmokeProbe.surfaceAppearances,
+                labels: runtimeSmokeProbe.renderedLabels,
+                accessibility: accessibility,
+                retainedWindowReused: firstWindow === self.mainWindow
+            )
+        }
+    }
+
+    private func finishRuntimeSmokeWhenWindowSettles(
+        mode: String,
+        surfaceCount: Int,
+        labels: [String],
+        accessibility: RuntimeSmokeAccessibilitySnapshot,
+        retainedWindowReused: Bool,
+        attempt: Int = 0
+    ) {
+        let windowSettled = NSApplication.shared.isActive && (mainWindow?.isKeyWindow ?? false)
+        guard windowSettled || attempt >= 60 else {
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) { [weak self] in
+                self?.finishRuntimeSmokeWhenWindowSettles(
+                    mode: mode,
+                    surfaceCount: surfaceCount,
+                    labels: labels,
+                    accessibility: accessibility,
+                    retainedWindowReused: retainedWindowReused,
+                    attempt: attempt + 1
+                )
+            }
+            return
+        }
+        finishRuntimeSmoke(
+            mode: mode,
+            surfaceCount: surfaceCount,
+            labels: labels,
+            accessibility: accessibility,
+            retainedWindowReused: retainedWindowReused
+        )
+    }
+
+    private func finishRuntimeSmoke(
+        mode: String,
+        surfaceCount: Int,
+        labels: [String],
+        accessibility: RuntimeSmokeAccessibilitySnapshot,
+        retainedWindowReused: Bool = false,
+        resolvedCompanionPath: String? = nil,
+        companionCapabilitiesPassed: Bool = false
+    ) {
+        guard let runtimeSmokeOutputPath else { return }
+        let result = RuntimeSmokeResult(
+            mode: mode,
+            processIdentifier: getpid(),
+            menuBarSurfaceCount: surfaceCount,
+            renderedStatusLabels: labels,
+            accessibilityObservationStatus: accessibility.status.rawValue,
+            accessibilityMenuBarItemCount: accessibility.itemCount,
+            accessibilityMenuBarLabels: accessibility.labels,
+            globalHandlersInstalled: store != nil,
+            permissionRequestsStarted: AccessibilityPromptGate.processShared.promptRequestCount,
+            windowCreationCount: windowCreationCount,
+            windowActivationCount: windowActivationCount,
+            retainedWindowReused: retainedWindowReused,
+            applicationActivationPolicy: NSApplication.shared.activationPolicy().rawValue,
+            applicationIsActive: NSApplication.shared.isActive,
+            mainWindowIsVisible: mainWindow?.isVisible ?? false,
+            mainWindowCanBecomeKey: mainWindow?.canBecomeKey ?? false,
+            mainWindowIsKey: mainWindow?.isKeyWindow ?? false,
+            resolvedCompanionPath: resolvedCompanionPath,
+            companionCapabilitiesPassed: companionCapabilitiesPassed
+        )
+        do {
+            let data = try JSONEncoder().encode(result)
+            try data.write(to: URL(fileURLWithPath: runtimeSmokeOutputPath), options: .atomic)
+            if let acknowledgementPath = runtimeSmokeAcknowledgementPath,
+               let completionPath = runtimeSmokeCompletionPath {
+                let processIdentifier = getpid()
+                DispatchQueue.global(qos: .utility).async {
+                    for _ in 0..<300 {
+                        if let challenge = try? String(
+                            contentsOfFile: acknowledgementPath,
+                            encoding: .utf8
+                        ).trimmingCharacters(in: .whitespacesAndNewlines),
+                           !challenge.isEmpty {
+                            do {
+                                let response = RuntimeSmokeCompletionResponse(
+                                    challenge: challenge,
+                                    mode: mode,
+                                    processIdentifier: processIdentifier
+                                )
+                                let responseData = try JSONEncoder().encode(response)
+                                try responseData.write(
+                                    to: URL(fileURLWithPath: completionPath),
+                                    options: .atomic
+                                )
+                            } catch {
+                                NativeAppLog.write("Runtime smoke completion failed: \(error)")
+                                return
+                            }
+                            Darwin._exit(0)
+                        }
+                        usleep(50_000)
+                    }
+                }
+            }
+        } catch {
+            fputs("Runtime smoke result failed: \(error)\n", stderr)
+        }
+    }
+}
+
 @main
 struct RecordingsApp: App {
-    @StateObject private var engine = RecordingEngine()
-    @StateObject private var shortcuts = VoiceShortcuts()
-    @StateObject private var projectStore = ProjectStore()
+    @NSApplicationDelegateAdaptor(RecordingsAppDelegate.self) private var appDelegate
+    @StateObject private var state: RecordingsAppState
 
     init() {
-        Self.terminateDuplicateInstances()
-        AXIsProcessTrustedWithOptions(
-            [kAXTrustedCheckOptionPrompt.takeUnretainedValue(): true] as CFDictionary
-        )
-        Self.handlePermissionRequestArguments()
+        let plan = PermissionRequestLaunchPlan(arguments: CommandLine.arguments)
+        let state = RecordingsAppState(plan: plan)
+        _state = StateObject(wrappedValue: state)
+        appDelegate.state = state
+        if plan.isRuntimeSmoke {
+            // Runtime smoke retains the real launch classification but never invokes TCC APIs.
+        } else if plan.requestsAccessibilityPrompt {
+            Self.handlePermissionRequest(plan)
+        }
     }
 
-    var body: some Scene {
-        MenuBarExtra {
-            MenuBarPopover(engine: engine, shortcuts: shortcuts, projectStore: projectStore)
-                .frame(width: 320, height: 420)
-                .onAppear {
-                    engine.projectStore = projectStore
-                    engine.voiceShortcuts = shortcuts
-                }
+    @SceneBuilder var body: some Scene {
+        MenuBarExtra(isInserted: menuBarInsertion) {
+            if let store = state.store {
+                MenuBarStatusView(store: store, openRecordings: state.openRecordings)
+            } else if state.runtimeSmokeProbe != nil {
+                EmptyView()
+            }
         } label: {
-            if engine.isRecording {
-                Image(systemName: "waveform")
-                    .symbolEffect(.variableColor.iterative, isActive: true)
-            } else if engine.isTranscribing {
-                Image(systemName: "ellipsis.circle")
-                    .symbolEffect(.pulse, isActive: true)
+            if let store = state.store {
+                MenuBarStatusLabel(store: store)
+            } else if let probe = state.runtimeSmokeProbe {
+                RuntimeSmokeMenuBarLabel(probe: probe)
             } else {
                 Image(systemName: "mic.fill")
+                    .accessibilityLabel("Recordings")
             }
         }
         .menuBarExtraStyle(.window)
 
         Settings {
-            SettingsView(engine: engine, shortcuts: shortcuts, projectStore: projectStore)
+            if let store = state.store {
+                SettingsView(engine: store.engine, shortcuts: store.voiceShortcuts, projectStore: store.projectStore)
+            } else {
+                EmptyView()
+            }
         }
-    }
-
-    private static func terminateDuplicateInstances() {
-        let currentPID = ProcessInfo.processInfo.processIdentifier
-        for app in NSRunningApplication.runningApplications(withBundleIdentifier: "com.hasna.recordings")
-            where app.processIdentifier != currentPID {
-            app.terminate()
+        .commands {
+            if let store = state.store {
+                CommandGroup(replacing: .newItem) {
+                    Button("New Recording") {
+                        store.pane = .record
+                        store.engine.startRecording()
+                    }
+                    .keyboardShortcut("n", modifiers: .command)
+                }
+                CommandGroup(after: .toolbar) {
+                    Button("Recordings Library") { store.pane = .library }
+                        .keyboardShortcut("l", modifiers: .command)
+                }
+            }
         }
     }
 
-    private static func handlePermissionRequestArguments() {
-        let arguments = CommandLine.arguments
-        guard arguments.contains("--request-permissions") else { return }
+    private var menuBarInsertion: Binding<Bool> {
+        Binding(
+            get: { state.declaresMenuBar && (state.store != nil || state.runtimeSmokeProbe != nil) },
+            set: { _ in }
+        )
+    }
 
+    private static func handlePermissionRequest(_ plan: PermissionRequestLaunchPlan) {
+        NSApplication.shared.setActivationPolicy(.accessory)
         NativeAppLog.write("request-permissions argument received")
+        let work = DispatchGroup()
+        let resultBox = PermissionRequestResultBox()
+        work.enter()
         AVCaptureDevice.requestAccess(for: .audio) { granted in
+            resultBox.setMicrophoneGranted(granted)
             NativeAppLog.write("request-permissions microphone granted=\(granted)")
+            work.leave()
         }
 
-        let trusted = AXIsProcessTrustedWithOptions(
-            [kAXTrustedCheckOptionPrompt.takeUnretainedValue(): true] as CFDictionary
-        )
-        NativeAppLog.write("request-permissions accessibility trusted=\(trusted)")
+        let accessibility = AccessibilityPromptGate.processShared.requestExplicitly()
+        NativeAppLog.write("request-permissions accessibility trusted=\(accessibility.trusted)")
 
-        guard arguments.contains("--open-permission-settings") else { return }
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.8) {
-            if let microphone = URL(string: "x-apple.systempreferences:com.apple.preference.security?Privacy_Microphone") {
-                NSWorkspace.shared.open(microphone)
-            }
-            if let accessibility = URL(string: "x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility") {
-                NSWorkspace.shared.open(accessibility)
+        if plan.opensPermissionSettings {
+            work.enter()
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.8) {
+                if let microphone = URL(string: "x-apple.systempreferences:com.apple.preference.security?Privacy_Microphone") {
+                    NSWorkspace.shared.open(microphone)
+                }
+                if let accessibility = URL(string: "x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility") {
+                    NSWorkspace.shared.open(accessibility)
+                }
+                work.leave()
             }
         }
+        work.notify(queue: .global(qos: .userInitiated)) {
+            let completedAccessibility = AccessibilityPromptGate.processShared.waitForExplicitRequestCompletion(
+                accessibility
+            )
+            let outcome = resultBox.outcome(accessibilityTrusted: completedAccessibility.trusted)
+            NativeAppLog.write("request-permissions helper completed success=\(outcome.succeeded)")
+            exit(outcome.succeeded ? EXIT_SUCCESS : EXIT_FAILURE)
+        }
     }
 }