@hasna/recordings 0.2.11 → 0.2.13

package/src/native/Recordings/RecordingsTests/RecordingStartControlPresentationTests.swift

@@ -0,0 +1,42 @@
+import Testing
+@testable import RecordingsLib
+
+struct RecordingStartControlPresentationTests {
+    @Test(
+        "every recording start control follows the engine start gate",
+        arguments: RecordingStartControlPresentation.Kind.allCases
+    )
+    func startControlsFollowEngineGate(kind: RecordingStartControlPresentation.Kind) {
+        let settling = RecordingStartControlPresentation(
+            kind: kind,
+            canStartRecording: false
+        )
+        let available = RecordingStartControlPresentation(
+            kind: kind,
+            canStartRecording: true
+        )
+
+        #expect(!settling.isEnabled)
+        #expect(available.isEnabled)
+        #expect(!settling.accessibilityLabel.isEmpty)
+    }
+
+    @Test("ready and error controls keep their accessible action names")
+    func retryControlLabels() {
+        let ready = RecordingStartControlPresentation(
+            kind: .recordAgain,
+            canStartRecording: false
+        )
+        let failed = RecordingStartControlPresentation(
+            kind: .tryAgain,
+            canStartRecording: false
+        )
+
+        #expect(ready.title == "Record Again")
+        #expect(ready.accessibilityLabel == "Start a new recording")
+        #expect(!ready.isEnabled)
+        #expect(failed.title == "Try Again")
+        #expect(failed.accessibilityLabel == "Try recording again")
+        #expect(!failed.isEnabled)
+    }
+}

package/src/native/Recordings/RecordingsTests/RecordingStartGateTests.swift

@@ -1,12 +1,276 @@
+import Foundation
 import Testing
 @testable import RecordingsLib
 
 struct RecordingStartGateTests {
+    @Test("permission-only launch skips global handlers and terminates after handling")
+    func permissionHelperLaunchPlan() {
+        let plan = PermissionRequestLaunchPlan(arguments: [
+            "/Applications/Recordings.app/Contents/MacOS/Recordings",
+            "--request-permissions",
+            "--open-permission-settings",
+        ])
+
+        #expect(plan.isHelper)
+        #expect(plan.opensPermissionSettings)
+        #expect(!plan.installsGlobalHandlers)
+        #expect(!plan.declaresMainWindow)
+        #expect(!plan.declaresMenuBar)
+        #expect(plan.terminatesAfterHandling)
+        #expect(plan.requestsAccessibilityPrompt)
+    }
+
+    @Test("regular launch retains global handlers and never self-terminates")
+    func regularLaunchPlan() {
+        let plan = PermissionRequestLaunchPlan(arguments: ["Recordings"])
+
+        #expect(!plan.isHelper)
+        #expect(plan.installsGlobalHandlers)
+        #expect(plan.declaresMainWindow)
+        #expect(plan.declaresMenuBar)
+        #expect(!plan.terminatesAfterHandling)
+        #expect(!plan.requestsAccessibilityPrompt)
+    }
+
+    @Test("runtime smoke plans install no handlers and never request permissions")
+    func runtimeSmokeLaunchPlans() {
+        let normal = PermissionRequestLaunchPlan(arguments: [
+            "Recordings", "--runtime-smoke", "normal", "--runtime-smoke-output", "/tmp/result.json",
+            "--runtime-smoke-ack", "/tmp/result.ack",
+            "--runtime-smoke-completion", "/tmp/result.completion.json",
+        ])
+        #expect(normal.isRuntimeSmoke)
+        #expect(!normal.installsGlobalHandlers)
+        #expect(normal.declaresMenuBar)
+        #expect(normal.runtimeSmokeOutputPath == "/tmp/result.json")
+        #expect(normal.runtimeSmokeAcknowledgementPath == "/tmp/result.ack")
+        #expect(normal.runtimeSmokeCompletionPath == "/tmp/result.completion.json")
+        #expect(!normal.requestsAccessibilityPrompt)
+
+        let helper = PermissionRequestLaunchPlan(arguments: [
+            "Recordings", "--request-permissions", "--runtime-smoke", "permission-helper",
+            "--runtime-smoke-output", "/tmp/result.json",
+        ])
+        #expect(helper.isRuntimeSmoke)
+        #expect(!helper.installsGlobalHandlers)
+        #expect(!helper.declaresMenuBar)
+        #expect(helper.isHelper)
+        #expect(!helper.requestsAccessibilityPrompt)
+    }
+
+    @Test("first untrusted protected operation prompts once per process")
+    func firstProtectedOperationPromptsOnce() {
+        let gate = AccessibilityPromptGate()
+        var trustChecks = 0
+        var prompts = 0
+
+        let first = gate.trustForProtectedOperation(
+            isTrusted: {
+                trustChecks += 1
+                return false
+            },
+            requestPrompt: {
+                prompts += 1
+                return false
+            }
+        )
+        let second = gate.trustForProtectedOperation(
+            isTrusted: {
+                trustChecks += 1
+                return false
+            },
+            requestPrompt: {
+                prompts += 1
+                return false
+            }
+        )
+
+        #expect(!first.trusted)
+        #expect(first.didPrompt)
+        #expect(!second.trusted)
+        #expect(!second.didPrompt)
+        #expect(trustChecks == 2)
+        #expect(prompts == 1)
+        #expect(gate.promptRequestCount == 1)
+    }
+
+    @Test("explicit Accessibility action may prompt after the automatic attempt")
+    func explicitAccessibilityActionMayPromptAgain() {
+        let gate = AccessibilityPromptGate()
+        var prompts = 0
+        var trusted = false
+
+        _ = gate.trustForProtectedOperation(
+            isTrusted: { false },
+            requestPrompt: {
+                prompts += 1
+                return false
+            }
+        )
+        let explicit = gate.requestExplicitly(
+            isTrusted: { trusted },
+            requestPrompt: {
+                prompts += 1
+                trusted = true
+                return false
+            }
+        )
+
+        #expect(explicit.trusted)
+        #expect(explicit.didPrompt)
+        #expect(prompts == 2)
+        #expect(gate.promptRequestCount == 2)
+    }
+
+    @Test("permission helper rechecks Accessibility at completion after a delayed grant")
+    func permissionHelperRechecksDelayedAccessibilityGrant() {
+        let gate = AccessibilityPromptGate()
+        var checks = 0
+        let promptResult = AccessibilityTrustResult(trusted: false, didPrompt: true)
+
+        let completion = gate.waitForExplicitRequestCompletion(
+            promptResult,
+            attempts: 3,
+            waitBetweenAttempts: {},
+            isTrusted: {
+                checks += 1
+                return checks == 3
+            }
+        )
+
+        #expect(completion.trusted)
+        #expect(completion.didPrompt)
+        #expect(checks == 3)
+    }
+
+    @Test("permission helper remains denied when Accessibility is still untrusted")
+    func permissionHelperReportsStillDenied() {
+        let gate = AccessibilityPromptGate()
+        var waits = 0
+        let completion = gate.waitForExplicitRequestCompletion(
+            AccessibilityTrustResult(trusted: true, didPrompt: true),
+            attempts: 3,
+            waitBetweenAttempts: { waits += 1 },
+            isTrusted: { false }
+        )
+
+        #expect(!completion.trusted)
+        #expect(completion.didPrompt)
+        #expect(waits == 2)
+    }
+
+    @Test("trusted protected operation never invokes the prompt API")
+    func trustedProtectedOperationDoesNotPrompt() {
+        let gate = AccessibilityPromptGate()
+        var prompts = 0
+
+        let result = gate.trustForProtectedOperation(
+            isTrusted: { true },
+            requestPrompt: {
+                prompts += 1
+                return true
+            }
+        )
+
+        #expect(result.trusted)
+        #expect(!result.didPrompt)
+        #expect(prompts == 0)
+        #expect(gate.promptRequestCount == 0)
+    }
+
+    @Test("explicit prompt consumes the automatic allowance for later protected operations")
+    func explicitPromptPreventsUnexpectedAutomaticReprompt() {
+        let gate = AccessibilityPromptGate()
+        var prompts = 0
+
+        _ = gate.requestExplicitly {
+            prompts += 1
+            return false
+        }
+        let protectedOperation = gate.trustForProtectedOperation(
+            isTrusted: { false },
+            requestPrompt: {
+                prompts += 1
+                return false
+            }
+        )
+
+        #expect(!protectedOperation.trusted)
+        #expect(!protectedOperation.didPrompt)
+        #expect(prompts == 1)
+        #expect(gate.promptRequestCount == 1)
+    }
+
+    @Test("permission helper outcome reports both permission results truthfully")
+    func permissionHelperOutcome() {
+        #expect(PermissionRequestOutcome(
+            microphoneGranted: true,
+            accessibilityTrusted: true
+        ).succeeded)
+        #expect(!PermissionRequestOutcome(
+            microphoneGranted: false,
+            accessibilityTrusted: true
+        ).succeeded)
+        #expect(!PermissionRequestOutcome(
+            microphoneGranted: true,
+            accessibilityTrusted: false
+        ).succeeded)
+    }
+
     @Test("recording cannot begin while already recording or transcribing")
     func cannotBeginWhenBusy() {
         #expect(RecordingEngine.canBeginRecording(isRecording: false, isTranscribing: false) == true)
         #expect(RecordingEngine.canBeginRecording(isRecording: true, isTranscribing: false) == false)
         #expect(RecordingEngine.canBeginRecording(isRecording: false, isTranscribing: true) == false)
+        #expect(RecordingEngine.canBeginRecording(
+            isRecording: false,
+            isTranscribing: false,
+            isAwaitingMicrophonePermission: true
+        ) == false)
+        #expect(RecordingEngine.canBeginRecording(
+            isRecording: false,
+            isTranscribing: false,
+            isDeliveryPending: true
+        ) == false)
+    }
+
+    @Test("recording status is derived from the trigger")
+    func statusUsesTrigger() {
+        #expect(RecordingEngine.recordingStatus(
+            trigger: .keyboardShortcut
+        ) == "Recording — release to stop")
+        #expect(RecordingEngine.recordingStatus(
+            trigger: .fnKey
+        ) == "Recording — release to stop")
+        #expect(RecordingEngine.recordingStatus(
+            trigger: .manual
+        ) == "Recording — click Stop when finished")
+    }
+
+    @Test("microphone permission start gate admits one current continuation")
+    func permissionStartGateRejectsDuplicateAndStaleContinuations() {
+        let firstRequestID = UUID()
+        let currentRequestID = UUID()
+        var gate = MicrophonePermissionStartGate()
+
+        let firstReservation = gate.reserve(requestID: firstRequestID)
+        #expect(firstReservation == firstRequestID)
+        #expect(gate.isAwaitingResponse)
+        let duplicateReservation = gate.reserve(requestID: currentRequestID)
+        #expect(duplicateReservation == nil)
+        #expect(gate.activeRequestID == firstRequestID)
+
+        gate.cancel()
+        let currentReservation = gate.reserve(requestID: currentRequestID)
+        #expect(currentReservation == currentRequestID)
+        let staleResponseConsumed = gate.consumeResponse(for: firstRequestID)
+        #expect(!staleResponseConsumed)
+        #expect(gate.activeRequestID == currentRequestID)
+        let currentResponseConsumed = gate.consumeResponse(for: currentRequestID)
+        #expect(currentResponseConsumed)
+        #expect(!gate.isAwaitingResponse)
+        let repeatedResponseConsumed = gate.consumeResponse(for: currentRequestID)
+        #expect(!repeatedResponseConsumed)
     }
 
     @Test("manual recording can continue after permission grant")

package/src/native/Recordings/RecordingsTests/RecordingStartTimingTests.swift

@@ -0,0 +1,129 @@
+import AVFoundation
+import Foundation
+import Testing
+@testable import RecordingsLib
+
+/// A recorder that starts instantly and records when it was asked to. Lets the production
+/// `startRecording` path run without microphone hardware or TCC grants.
+private final class FakePCMRecorder: PCMRecordingSource, @unchecked Sendable {
+    private let lock = NSLock()
+    private var startedFlag = false
+
+    var started: Bool {
+        lock.withLock { startedFlag }
+    }
+
+    func start() throws {
+        lock.withLock { startedFlag = true }
+    }
+
+    func stop() {}
+}
+
+@MainActor
+private func makeStartableEngine(
+    recorder: FakePCMRecorder,
+    selectionCapture: @escaping @Sendable (pid_t) -> AccessibilitySelectionToken?
+) -> RecordingEngine {
+    let engine = RecordingEngine()
+    engine.openAIAPIKeyProvider = { "" }
+    engine.microphoneAuthorization = { .authorized }
+    engine.accessibilityTrustCheck = { true }
+    engine.protectedOperationTrust = { AccessibilityTrustResult(trusted: true, didPrompt: false) }
+    engine.frontmostAppSnapshot = {
+        FrontmostAppSnapshot(pid: 99_999, bundleIdentifier: "com.example.editor", launchDate: Date())
+    }
+    engine.recorderFactory = { _ in recorder }
+    engine.selectionCapture = selectionCapture
+    engine.focusedWindowTitleLookup = { _ in nil }
+    engine.pasteInterceptorForTesting = { _, _, _ in }
+    return engine
+}
+
+@MainActor
+private func waitUntil(
+    timeout: TimeInterval = 5,
+    _ condition: @MainActor () -> Bool
+) async -> Bool {
+    let deadline = Date().addingTimeInterval(timeout)
+    while Date() < deadline {
+        if condition() { return true }
+        try? await Task.sleep(for: .milliseconds(20))
+    }
+    return condition()
+}
+
+@MainActor
+struct RecordingStartTimingTests {
+    @Test("the recorder starts on keydown even while the AX selection capture is blocked")
+    func recorderStartDoesNotWaitOnSelectionCapture() {
+        let captureGate = DispatchSemaphore(value: 0)
+        let recorder = FakePCMRecorder()
+        let engine = makeStartableEngine(recorder: recorder) { _ in
+            // Simulates a beachballing target app: the capture IPC hangs far longer than
+            // any acceptable start budget.
+            captureGate.wait()
+            return nil
+        }
+
+        // `startRecording` runs synchronously on the MainActor through recorder start.
+        // With the pre-fix ordering (capture before recorder start, on the MainActor) this
+        // call would block on the semaphore and the test would time out; with the fixed
+        // ordering the recorder is live before the capture has produced anything.
+        engine.startRecording(trigger: .manual)
+        #expect(recorder.started, "recorder must start while AX capture is still pending")
+        #expect(engine.isRecording)
+        #expect(engine.flowPhase == .listening)
+
+        captureGate.signal()
+        engine.cancelRecording()
+        #expect(engine.flowPhase == .idle)
+    }
+
+    @Test("stopping waits for the generation-bound start context instead of dropping the frozen target")
+    func stopAwaitsFrozenStartContext() async {
+        let captureGate = DispatchSemaphore(value: 0)
+        let recorder = FakePCMRecorder()
+        let engine = makeStartableEngine(recorder: recorder) { _ in
+            captureGate.wait()
+            return AccessibilitySelectionToken.unsafeTestToken(selectedText: "frozen words")
+        }
+
+        engine.startRecording(trigger: .manual)
+        #expect(engine.isRecording)
+        engine.stopAndTranscribe()
+        #expect(engine.isTranscribing)
+
+        // The pipeline must hold in finalizing while the frozen context is unresolved —
+        // it may not deliver without the selection frozen at start.
+        try? await Task.sleep(for: .milliseconds(150))
+        #expect(engine.flowPhase == .finalizing)
+
+        captureGate.signal()
+        // No audio was produced by the fake recorder, so the pipeline ends in the
+        // fail-closed no-audio state — importantly, only after the context resolved.
+        #expect(await waitUntil {
+            if case .failed = engine.flowPhase { return true }
+            return false
+        })
+        #expect(engine.statusMessage == "No audio captured")
+        #expect(engine.canStartRecording)
+    }
+
+    @Test("a released key before the capture resolves still cancels cleanly")
+    func cancelDuringPendingCapture() {
+        let captureGate = DispatchSemaphore(value: 0)
+        let recorder = FakePCMRecorder()
+        let engine = makeStartableEngine(recorder: recorder) { _ in
+            captureGate.wait()
+            return nil
+        }
+        engine.startRecording(trigger: .manual)
+        #expect(engine.isRecording)
+        engine.cancelRecording()
+        #expect(!engine.isRecording)
+        #expect(engine.flowPhase == .idle)
+        captureGate.signal()
+        #expect(engine.canStartRecording)
+    }
+}