@hasna/recordings 0.2.10 → 0.2.13

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

@@ -0,0 +1,130 @@
+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 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)
+            }
+        }
+        .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)
+            }
+        } 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)
+                }
+            }
+        } 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) }
+                            }
+                        Divider().opacity(0.35).padding(.leading, 16)
+                    }
+                }
+            }
+        }
+    }
+
+    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
+
+    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) } }
+    }
+}

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

@@ -0,0 +1,206 @@
+import Foundation
+import SwiftUI
+import Combine
+import RecordingsLib
+
+/// Which main pane the canvas shows.
+enum Pane: Equatable {
+    case record       // the recording workspace (default / first screen)
+    case library      // browse past recordings
+}
+
+/// Sidebar filter selection for the library.
+enum LibraryFilter: Hashable {
+    case all
+    case project(String)     // project id
+    case noProject
+    case mode(String)        // "raw" | "enhanced"
+    case thisMachine
+    case machine(String)
+}
+
+/// Observable application state for the full macOS app. Bridges the live `RecordingEngine`,
+/// the `ProjectStore` / `VoiceShortcuts`, and the `recordings` CLI Store.
+@MainActor
+final class RecordingsStore: ObservableObject {
+    let engine: RecordingEngine
+    let projectStore: ProjectStore
+    let voiceShortcuts: VoiceShortcuts
+
+    @Published var pane: Pane = .record
+    @Published var library: [Recording] = []
+    @Published var selection: String?
+    @Published var filter: LibraryFilter = .all
+    @Published var searchText: String = ""
+    @Published var isLoadingLibrary = false
+    @Published var loadError: String?
+    @Published var operationError: String?
+
+    @Published var stats: RecordingStats?
+    let localMachineID: String
+    private let home: String
+    private var cancellables = Set<AnyCancellable>()
+
+    init(engine: RecordingEngine = RecordingEngine(),
+         projectStore: ProjectStore = ProjectStore(),
+         voiceShortcuts: VoiceShortcuts = VoiceShortcuts()) {
+        self.engine = engine
+        self.projectStore = projectStore
+        self.voiceShortcuts = voiceShortcuts
+        self.home = FileManager.default.homeDirectoryForCurrentUser.path
+        self.localMachineID = NativeMachineIdentity.current()
+        engine.projectStore = projectStore
+        engine.voiceShortcuts = voiceShortcuts
+
+        // Re-publish the wrapped ObservableObjects so views that observe only this store
+        // refresh on live recording changes (timer, live text) and project edits.
+        engine.objectWillChange
+            .sink { [weak self] in self?.objectWillChange.send() }
+            .store(in: &cancellables)
+        engine.$persistedRecordingRevision
+            .dropFirst()
+            .sink { [weak self] _ in self?.loadLibrary() }
+            .store(in: &cancellables)
+        projectStore.objectWillChange
+            .sink { [weak self] in self?.objectWillChange.send() }
+            .store(in: &cancellables)
+        voiceShortcuts.objectWillChange
+            .sink { [weak self] in self?.objectWillChange.send() }
+            .store(in: &cancellables)
+
+        reconcileProjects()
+    }
+
+    func reconcileProjects() {
+        let home = self.home
+        Task { [weak self] in
+            guard let self else { return }
+            do {
+                try await projectStore.reconcileWithCanonicalStore(home: home)
+                self.operationError = nil
+            } catch {
+                self.operationError = projectStore.persistenceError
+                    ?? (error as? RecordingsCLI.Failure)?.message
+                    ?? error.localizedDescription
+            }
+        }
+    }
+
+    // MARK: - Derived collections
+
+    var projects: [RecProject] { projectStore.settings.projects }
+
+    var machines: [String] {
+        Set(library.compactMap { $0.machineId }.filter { !$0.isEmpty })
+            .sorted { $0.localizedCaseInsensitiveCompare($1) == .orderedAscending }
+    }
+
+    var lastUpdated: Date? { library.compactMap(\.createdDate).max() }
+
+    var visibleRecordings: [Recording] {
+        library.filter { matchesFilter($0) && matchesSearch($0) }
+    }
+
+    private func matchesFilter(_ r: Recording) -> Bool {
+        switch filter {
+        case .all: return true
+        case .project(let id): return r.projectId == id
+        case .noProject: return r.projectId == nil
+        case .mode(let m): return r.processingMode == m
+        case .thisMachine: return r.machineId == localMachineID
+        case .machine(let m): return r.machineId == m
+        }
+    }
+
+    private func matchesSearch(_ r: Recording) -> Bool {
+        let q = searchText.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !q.isEmpty else { return true }
+        if r.displayText.localizedCaseInsensitiveContains(q) { return true }
+        if r.tags.contains(where: { $0.localizedCaseInsensitiveContains(q) }) { return true }
+        return false
+    }
+
+    func count(for filter: LibraryFilter) -> Int {
+        library.filter {
+            switch filter {
+            case .all: return true
+            case .project(let id): return $0.projectId == id
+            case .noProject: return $0.projectId == nil
+            case .mode(let m): return $0.processingMode == m
+            case .thisMachine: return $0.machineId == localMachineID
+            case .machine(let m): return $0.machineId == m
+            }
+        }.count
+    }
+
+    var selectedRecording: Recording? {
+        guard let id = selection else { return nil }
+        return library.first { $0.id == id }
+    }
+
+    func projectName(_ id: String?) -> String? {
+        guard let id else { return nil }
+        return projects.first { $0.id == id }?.name
+    }
+
+    // MARK: - Library loading
+
+    private var reloadRequestedDuringLoad = false
+
+    func loadLibrary() {
+        guard !isLoadingLibrary else { reloadRequestedDuringLoad = true; return }
+        isLoadingLibrary = true
+        let home = home
+        Task.detached(priority: .userInitiated) {
+            let result: Result<([Recording], RecordingStats?), Error>
+            do {
+                let recs = try RecordingsCLI.listAll(home: home)
+                let stats = try? RecordingsCLI.stats(home: home)
+                result = .success((recs, stats))
+            } catch {
+                result = .failure(error)
+            }
+            await MainActor.run {
+                self.isLoadingLibrary = false
+                switch result {
+                case .success(let (recs, stats)):
+                    self.library = recs
+                    self.stats = stats
+                    self.loadError = nil
+                    if self.selection == nil || !recs.contains(where: { $0.id == self.selection }) {
+                        self.selection = self.visibleRecordings.first?.id
+                    }
+                case .failure(let error):
+                    self.loadError = (error as? RecordingsCLI.Failure)?.message ?? error.localizedDescription
+                }
+                if self.reloadRequestedDuringLoad {
+                    self.reloadRequestedDuringLoad = false
+                    self.loadLibrary()
+                }
+            }
+        }
+    }
+
+    func delete(id: String) {
+        let home = home
+        Task.detached(priority: .userInitiated) {
+            let result: Result<Void, Error>
+            do {
+                try RecordingsCLI.delete(id: id, home: home)
+                result = .success(())
+            } catch {
+                result = .failure(error)
+            }
+            await MainActor.run {
+                switch result {
+                case .success:
+                    self.library.removeAll { $0.id == id }
+                    if self.selection == id { self.selection = self.visibleRecordings.first?.id }
+                case .failure(let error):
+                    self.operationError = (error as? RecordingsCLI.Failure)?.message ?? error.localizedDescription
+                }
+            }
+        }
+    }
+
+}

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

@@ -0,0 +1,158 @@
+@preconcurrency import Cocoa
+import SwiftUI
+import RecordingsLib
+
+@MainActor
+final class RuntimeSmokeProbe: ObservableObject {
+    enum Phase: Int, CaseIterable {
+        case idle
+        case recording
+        case transcribing
+    }
+
+    @Published private(set) var phase: Phase = .idle
+    private(set) var surfaceAppearances = 0
+    private(set) var renderedLabels: [String] = []
+    private var completionScheduled = false
+    var completed: (() -> Void)? {
+        didSet { finishIfReady() }
+    }
+
+    var presentation: MenuBarPresentation {
+        MenuBarPresentation(
+            isRecording: phase == .recording,
+            canStartRecording: phase == .idle,
+            statusMessage: phase == .transcribing ? "Transcribing" : "Ready"
+        )
+    }
+
+    func surfaceAppeared() {
+        surfaceAppearances += 1
+        observeCurrentPresentation()
+    }
+
+    func presentationChanged() {
+        observeCurrentPresentation()
+    }
+
+    private func observeCurrentPresentation() {
+        let label = presentation.accessibilityLabel
+        if renderedLabels.last != label {
+            renderedLabels.append(label)
+        }
+        switch phase {
+        case .idle:
+            DispatchQueue.main.async { self.phase = .recording }
+        case .recording:
+            DispatchQueue.main.async { self.phase = .transcribing }
+        case .transcribing:
+            finishIfReady()
+        }
+    }
+
+    private func finishIfReady() {
+        guard phase == .transcribing,
+              renderedLabels.count == Phase.allCases.count,
+              !completionScheduled,
+              completed != nil else { return }
+        completionScheduled = true
+        DispatchQueue.main.async { self.completed?() }
+    }
+}
+
+struct RuntimeSmokeMenuBarLabel: View {
+    @ObservedObject var probe: RuntimeSmokeProbe
+
+    var body: some View {
+        Image(systemName: probe.presentation.iconName)
+            .accessibilityLabel(probe.presentation.accessibilityLabel)
+            .onAppear { probe.surfaceAppeared() }
+            .onChange(of: probe.phase) { _, _ in
+                probe.presentationChanged()
+            }
+    }
+}
+
+struct RuntimeSmokeResult: Codable {
+    let mode: String
+    let processIdentifier: Int32
+    let menuBarSurfaceCount: Int
+    let renderedStatusLabels: [String]
+    let accessibilityObservationStatus: String
+    let accessibilityMenuBarItemCount: Int
+    let accessibilityMenuBarLabels: [String]
+    let globalHandlersInstalled: Bool
+    let permissionRequestsStarted: Int
+    let windowCreationCount: Int
+    let windowActivationCount: Int
+    let retainedWindowReused: Bool
+    let applicationActivationPolicy: Int
+    let applicationIsActive: Bool
+    let mainWindowIsVisible: Bool
+    let mainWindowCanBecomeKey: Bool
+    let mainWindowIsKey: Bool
+    let resolvedCompanionPath: String?
+    let companionCapabilitiesPassed: Bool
+}
+
+enum RuntimeSmokeAccessibilityObservationStatus: String {
+    case available
+    case absent
+    case unavailable
+}
+
+struct RuntimeSmokeAccessibilitySnapshot {
+    let status: RuntimeSmokeAccessibilityObservationStatus
+    let itemCount: Int
+    let labels: [String]
+
+    static func processMenuBarExtras(processIdentifier: pid_t = getpid()) -> Self {
+        let application = AXUIElementCreateApplication(processIdentifier)
+        var menuBarValue: CFTypeRef?
+        let menuBarError = AXUIElementCopyAttributeValue(
+            application,
+            kAXExtrasMenuBarAttribute as CFString,
+            &menuBarValue
+        )
+        if menuBarError == .noValue || menuBarError == .attributeUnsupported {
+            return Self(status: .absent, itemCount: 0, labels: [])
+        }
+        guard menuBarError == .success,
+              let menuBarValue,
+              CFGetTypeID(menuBarValue) == AXUIElementGetTypeID() else {
+            return Self(status: .unavailable, itemCount: -1, labels: [])
+        }
+
+        let menuBar = menuBarValue as! AXUIElement
+        var childrenValue: CFTypeRef?
+        let childrenError = AXUIElementCopyAttributeValue(
+            menuBar,
+            kAXChildrenAttribute as CFString,
+            &childrenValue
+        )
+        if childrenError == .noValue || childrenError == .attributeUnsupported {
+            return Self(status: .unavailable, itemCount: -1, labels: [])
+        }
+        guard childrenError == .success,
+              let children = childrenValue as? [AXUIElement] else {
+            return Self(status: .unavailable, itemCount: -1, labels: [])
+        }
+
+        let labels = children.compactMap { child -> String? in
+            for attribute in [kAXDescriptionAttribute, kAXTitleAttribute, kAXHelpAttribute] {
+                var value: CFTypeRef?
+                if AXUIElementCopyAttributeValue(child, attribute as CFString, &value) == .success,
+                   let label = value as? String,
+                   !label.isEmpty {
+                    return label
+                }
+            }
+            return nil
+        }
+        return Self(
+            status: children.isEmpty ? .absent : .available,
+            itemCount: children.count,
+            labels: labels
+        )
+    }
+}