Skip to content

Fastest and only macOS Dictation app with on-device STT and custom trained AI enhancement model. Windows, iOS testflight! Android, Linux waitlist open! A local Wispr Flow alternative. Follow https://x.com/fluidvoiceapp for more

Honor restored Edit settings and screen privacy

altic-devc19e567a590e
diff --git a/Sources/Fluid/ContentView.swift b/Sources/Fluid/ContentView.swift
index bf86f6d1..245b8485 100644
--- a/Sources/Fluid/ContentView.swift
+++ b/Sources/Fluid/ContentView.swift
@@ -590,6 +590,9 @@ struct ContentView: View {
.onChange(of: self.settings.dictationScreenContextEnabled) { _, enabled in
if !enabled { self.cancelDictationContextCapture() }
}
+ .onChange(of: self.settings.editModeScreenContextRevision) { _, _ in
+ self.rewriteModeService.cancelOutdatedWindowCapture()
+ }
.onDisappear {
Task { await self.asr.stopWithoutTranscription() }
self.cancelPrewarmDictationIfNeeded()
diff --git a/Sources/Fluid/Persistence/SettingsStore.swift b/Sources/Fluid/Persistence/SettingsStore.swift
index 5d627f14..b48fbff0 100644
--- a/Sources/Fluid/Persistence/SettingsStore.swift
+++ b/Sources/Fluid/Persistence/SettingsStore.swift
@@ -3458,12 +3458,17 @@ final class SettingsStore: ObservableObject {
}
}
+ /// Invalidates old captures even when the switch changes off and back on.
+ private(set) var editModeScreenContextRevision: UInt64 = 0
+
/// Lets on-device Edit Mode use the text in the front window. On until turned off.
var editModeReadsScreen: Bool {
get { self.defaults.object(forKey: Keys.editModeReadsScreen) as? Bool ?? true }
set {
+ guard newValue != self.editModeReadsScreen else { return }
objectWillChange.send()
self.defaults.set(newValue, forKey: Keys.editModeReadsScreen)
+ self.editModeScreenContextRevision &+= 1
}
}
@@ -3881,7 +3886,6 @@ final class SettingsStore: ObservableObject {
self.rewriteModeSelectedModel = payload.rewriteModeSelectedModel
self.rewriteModeSelectedProviderID = payload.rewriteModeSelectedProviderID
self.rewriteModeLinkedToGlobal = payload.rewriteModeLinkedToGlobal
- self.makeEditModeIndependentIfNeeded()
if let enabled = payload.meetingRecordingShortcutEnabled {
self.meetingRecordingHotkeyShortcut = enabled ? payload.meetingRecordingHotkeyShortcut : nil
}
@@ -4061,6 +4065,7 @@ final class SettingsStore: ObservableObject {
self.normalizeDictationPromptConfigurationsIfNeeded()
}
self.purgeRetiredAppleIntelligenceState()
+ self.makeEditModeIndependentIfNeeded()
}
// MARK: - Private Methods
diff --git a/Sources/Fluid/Services/RewriteModeService.swift b/Sources/Fluid/Services/RewriteModeService.swift
index f6797eda..dd8e6ad9 100644
--- a/Sources/Fluid/Services/RewriteModeService.swift
+++ b/Sources/Fluid/Services/RewriteModeService.swift
@@ -17,6 +17,14 @@ final class RewriteModeService: ObservableObject {
private var promptAppBundleID: String?
/// The front window as read when the shortcut was pressed.
private var windowCapture: DictationContextCapture?
+ private var windowCaptureRevision: UInt64?
+ private let captureWindow: @MainActor (TypingService.RecordingTargetContext) -> DictationContextCapture?
+
+ init(captureWindow: @escaping @MainActor (TypingService.RecordingTargetContext) -> DictationContextCapture? = {
+ DictationContextCapture.startForEditMode(target: $0)
+ }) {
+ self.captureWindow = captureWindow
+ }
private let textSelectionService = TextSelectionService.shared
private let typingService = TypingService()
@@ -199,13 +207,34 @@ final class RewriteModeService: ObservableObject {
/// Starts reading the window while it is still in front, so the answer can use
/// what the user is looking at. Replaces the reading of any earlier press.
func startReadingWindow(target: TypingService.RecordingTargetContext) {
- self.windowCapture?.cancel()
- self.windowCapture = DictationContextCapture.startForEditMode(target: target)
+ self.stopReadingWindow()
+ guard SettingsStore.shared.editModeReadsScreen else { return }
+ self.windowCaptureRevision = SettingsStore.shared.editModeScreenContextRevision
+ self.windowCapture = self.captureWindow(target)
+ }
+
+ func windowContextForRewrite() async -> DictationTypingContext? {
+ self.cancelOutdatedWindowCapture()
+ guard let capture = self.windowCapture, let revision = self.windowCaptureRevision else { return nil }
+ let context = await capture.result(timeout: .seconds(2))
+ // The switch or target may change while the window reader is pending.
+ guard !Task.isCancelled, SettingsStore.shared.editModeReadsScreen,
+ revision == SettingsStore.shared.editModeScreenContextRevision,
+ self.windowCapture === capture
+ else { return nil }
+ return context
+ }
+
+ func cancelOutdatedWindowCapture() {
+ if !SettingsStore.shared.editModeReadsScreen || self.windowCaptureRevision != SettingsStore.shared.editModeScreenContextRevision {
+ self.stopReadingWindow()
+ }
}
func stopReadingWindow() {
self.windowCapture?.cancel()
self.windowCapture = nil
+ self.windowCaptureRevision = nil
}
func setPromptAppBundleID(_ bundleID: String?) {
@@ -318,7 +347,7 @@ final class RewriteModeService: ObservableObject {
if usesPrivateAIProvider || PrivateAIIntegrationService.shouldHandleDictation(model: model) {
// A follow-up applies to the last result, not to the original selection.
let textToEdit = self.rewrittenText.isEmpty ? self.selectedContextText : self.rewrittenText
- let window = await self.windowCapture?.result(timeout: .seconds(2))
+ let window = await self.windowContextForRewrite()
// Counts only: what was read is never logged.
DebugLogger.shared.info(
"Edit Mode read the window | lines=\(window?.windowLines?.count ?? 0) | hasSelection=\(!textToEdit.isEmpty)",
diff --git a/Tests/FluidDictationIntegrationTests/DictationContextCaptureTests.swift b/Tests/FluidDictationIntegrationTests/DictationContextCaptureTests.swift
index 1e1d5bcc..e6283ed1 100644
--- a/Tests/FluidDictationIntegrationTests/DictationContextCaptureTests.swift
+++ b/Tests/FluidDictationIntegrationTests/DictationContextCaptureTests.swift
@@ -498,6 +498,78 @@ final class DictationContextCaptureTests: XCTestCase {
semaphore.wait(timeout: .now() + 2) == .success
}
+ func testEditWindowContextIsDroppedWhenDisabled() async {
+ let settings = SettingsStore.shared
+ let old = settings.editModeReadsScreen
+ defer { settings.editModeReadsScreen = old }
+ settings.editModeReadsScreen = true
+ let expected = DictationTypingContext(textBeforeCursor: nil, screenText: ["captured window"])
+ let capture = DictationContextCapture(target: self.target(), task: Task { expected })
+ let service = RewriteModeService(captureWindow: { _ in capture })
+ service.selectedContextText = "explicit selection"
+ service.startReadingWindow(target: self.target())
+ settings.editModeReadsScreen = false
+ let result = await service.windowContextForRewrite()
+ XCTAssertNil(result)
+ XCTAssertEqual(service.selectedContextText, "explicit selection")
+ }
+
+ func testEditWindowContextIsNotReusedAfterOffThenOn() async {
+ let settings = SettingsStore.shared
+ let old = settings.editModeReadsScreen
+ defer { settings.editModeReadsScreen = old }
+ settings.editModeReadsScreen = true
+ let capture = DictationContextCapture(target: self.target(), task: Task {
+ DictationTypingContext(textBeforeCursor: nil, screenText: ["stale window"])
+ })
+ let service = RewriteModeService(captureWindow: { _ in capture })
+ service.startReadingWindow(target: self.target())
+ settings.editModeReadsScreen = false
+ settings.editModeReadsScreen = true
+ let result = await service.windowContextForRewrite()
+ XCTAssertNil(result)
+ }
+
+ func testDisablingEditScreenContextCancelsItsTaskWithoutChangingDictation() async {
+ let settings = SettingsStore.shared
+ let old = settings.editModeReadsScreen
+ let dictation = settings.dictationScreenContextEnabled
+ defer { settings.editModeReadsScreen = old }
+ settings.editModeReadsScreen = true
+ let task = self.delayedRead()
+ let capture = DictationContextCapture(target: self.target(), task: task)
+ let service = RewriteModeService(captureWindow: { _ in capture })
+ service.startReadingWindow(target: self.target())
+ settings.editModeReadsScreen = false
+ service.cancelOutdatedWindowCapture()
+ XCTAssertTrue(task.isCancelled)
+ XCTAssertEqual(settings.dictationScreenContextEnabled, dictation)
+ let context = await service.windowContextForRewrite()
+ XCTAssertNil(context)
+ }
+
+ func testEditWindowCaptureDoesNotStartWhileDisabledAndCanRestartFresh() async {
+ let settings = SettingsStore.shared
+ let old = settings.editModeReadsScreen
+ defer { settings.editModeReadsScreen = old }
+ settings.editModeReadsScreen = false
+ let expected = DictationTypingContext(textBeforeCursor: nil, screenText: ["fresh window"])
+ var starts = 0
+ let service = RewriteModeService(captureWindow: { target in
+ starts += 1
+ return DictationContextCapture(target: target, task: Task { expected })
+ })
+ service.startReadingWindow(target: self.target())
+ XCTAssertEqual(starts, 0)
+ settings.editModeReadsScreen = true
+ service.startReadingWindow(target: self.target())
+ // A delayed preference observer must not cancel this new capture.
+ service.cancelOutdatedWindowCapture()
+ let context = await service.windowContextForRewrite()
+ XCTAssertEqual(context, expected)
+ XCTAssertEqual(starts, 1)
+ }
+
private func target(pid: pid_t = 1, window: AXUIElement? = nil, element: AXUIElement? = nil) -> TypingService.RecordingTargetContext {
.init(id: UUID(), pid: pid, bundleIdentifier: "test.context", window: window, element: element)
}
diff --git a/Tests/FluidDictationIntegrationTests/SettingsBackupRoundTripTests.swift b/Tests/FluidDictationIntegrationTests/SettingsBackupRoundTripTests.swift
index e48dad68..e3905a03 100644
--- a/Tests/FluidDictationIntegrationTests/SettingsBackupRoundTripTests.swift
+++ b/Tests/FluidDictationIntegrationTests/SettingsBackupRoundTripTests.swift
@@ -108,6 +108,41 @@ final class SettingsBackupRoundTripTests: XCTestCase {
}
}
+ func testLegacyLinkedEditUsesRestoredPromptProvider() throws {
+ try self.withSavedDefaults {
+ let settings = SettingsStore.shared
+ settings.selectedProviderID = "openai"
+ settings.rewriteModeLinkedToGlobal = true
+ settings.setDictationPromptSelection(.default, for: .primary)
+ settings.dictationPromptConfigurations = ["__default__": .init(providerID: "openai", modelName: "gpt-4o-mini")]
+ let payload = settings.makeBackupPayload()
+ settings.dictationPromptConfigurations = ["__default__": .init(providerID: "anthropic", modelName: "claude-haiku")]
+
+ settings.restore(from: payload, promptProfiles: [], appPromptBindings: [])
+
+ XCTAssertEqual(settings.rewriteModeSelectedProviderID, "openai")
+ XCTAssertFalse(settings.rewriteModeLinkedToGlobal)
+ XCTAssertEqual(settings.dictationPromptSelection(for: .primary), .default)
+ XCTAssertEqual(settings.selectedProviderID, payload.selectedProviderID)
+ XCTAssertEqual(settings.primaryDictationShortcuts, payload.primaryDictationShortcuts)
+ }
+ }
+
+ func testIndependentEditBackupKeepsItsOwnProvider() throws {
+ try self.withSavedDefaults {
+ let settings = SettingsStore.shared
+ settings.rewriteModeLinkedToGlobal = false
+ settings.rewriteModeSelectedProviderID = "anthropic"
+ settings.rewriteModeSelectedModel = "saved-edit-model"
+ let payload = settings.makeBackupPayload()
+ settings.rewriteModeSelectedProviderID = "openai"
+ settings.restore(from: payload, promptProfiles: [], appPromptBindings: [])
+ XCTAssertEqual(settings.rewriteModeSelectedProviderID, "anthropic")
+ XCTAssertEqual(settings.rewriteModeSelectedModel, "saved-edit-model")
+ XCTAssertFalse(settings.rewriteModeLinkedToGlobal)
+ }
+ }
+
private func payload(removing keys: [String]) throws -> SettingsBackupPayload {
var json = try XCTUnwrap(JSONSerialization.jsonObject(with: JSONEncoder().encode(SettingsStore.shared.makeBackupPayload())) as? [String: Any])
for key in keys {