feat: add Dangerous Read Everything Mode with AX tree traversal

Hatoko/Accessibility/AccessibilityPermission.swift

@@ -0,0 +1,14 @@
+import ApplicationServices
+
+enum AccessibilityPermission {
+
+    static var isTrusted: Bool {
+        AXIsProcessTrusted()
+    }
+
+    static func requestTrust() {
+        // Use the raw string to avoid concurrency-safety warnings with the global CFString constant
+        let options = ["AXTrustedCheckOptionPrompt": true] as CFDictionary
+        AXIsProcessTrustedWithOptions(options)
+    }
+}

Hatoko/Accessibility/DangerousReadModeController.swift

@@ -0,0 +1,161 @@
+import Cocoa
+
+/// Manages the lifecycle of the Dangerous Read Mode session.
+///
+/// Marked `@preconcurrency @MainActor` because all state mutations and UI operations
+/// require the main thread. `nonisolated` accessors use `MainActor.assumeIsolated`
+/// because they are called from IMKInputController (always main thread) but cannot
+/// be statically proven to be MainActor-isolated.
+@preconcurrency @MainActor
+final class DangerousReadModeController {
+
+    private var activeState = false
+    private var latestScreenContext: ScreenContext?
+    private var sessionStartTime: Date?
+    private var sessionDuration = 0
+    private var captureTask: Task<Void, Never>?
+    private var countdownTask: Task<Void, Never>?
+    private let indicatorWindow = DangerousReadIndicatorWindow()
+
+    static let enabledKey = "dangerous_read_enabled"
+    static let maxDurationKey = "dangerous_read_max_duration"
+    static let captureIntervalKey = "dangerous_read_capture_interval"
+    static let defaultMaxDuration = 300
+    static let defaultCaptureInterval = 3
+
+    nonisolated var isActive: Bool {
+        MainActor.assumeIsolated { activeState }
+    }
+
+    nonisolated func activeScreenContext() -> ScreenContext? {
+        MainActor.assumeIsolated {
+            guard activeState else { return nil }
+            return latestScreenContext
+        }
+    }
+
+    var isEnabledInSettings: Bool {
+        UserDefaults.standard.bool(forKey: Self.enabledKey)
+    }
+
+    static func storedMaxDuration() -> Int {
+        let stored = UserDefaults.standard.integer(forKey: maxDurationKey)
+        return stored > 0 ? stored : defaultMaxDuration
+    }
+
+    static func storedCaptureInterval() -> Int {
+        let stored = UserDefaults.standard.integer(forKey: captureIntervalKey)
+        return stored > 0 ? stored : defaultCaptureInterval
+    }
+
+    var maxSessionDuration: Int { Self.storedMaxDuration() }
+    var captureInterval: Int { Self.storedCaptureInterval() }
+
+    nonisolated func toggleSession() {
+        MainActor.assumeIsolated {
+            if activeState {
+                stopSession()
+            } else {
+                startSession()
+            }
+        }
+    }
+
+    func startSession() {
+        guard !activeState else { return }
+        guard isEnabledInSettings else {
+            NSSound.beep()
+            return
+        }
+
+        guard AccessibilityPermission.isTrusted else {
+            AccessibilityPermission.requestTrust()
+            return
+        }
+
+        guard showConsentAlert() else { return }
+
+        activeState = true
+        sessionStartTime = Date()
+        latestScreenContext = nil
+        sessionDuration = maxSessionDuration
+
+        let duration = sessionDuration
+        indicatorWindow.show(remainingSeconds: duration)
+        startCaptureLoop()
+        startCountdown()
+    }
+
+    func stopSession() {
+        activeState = false
+        captureTask?.cancel()
+        captureTask = nil
+        countdownTask?.cancel()
+        countdownTask = nil
+        sessionStartTime = nil
+        sessionDuration = 0
+        latestScreenContext = nil
+        indicatorWindow.hide()
+    }
+
+    var remainingSeconds: Int {
+        guard let start = sessionStartTime else { return 0 }
+        let elapsed = Int(Date().timeIntervalSince(start))
+        return max(0, sessionDuration - elapsed)
+    }
+
+    // MARK: - Private
+
+    private func startCaptureLoop() {
+        let interval = captureInterval
+        captureTask = Task { [weak self] in
+            defer { self?.indicatorWindow.setScanning(false) }
+            let reader = ScreenReader()
+            while !Task.isCancelled {
+                guard let self else { return }
+                self.indicatorWindow.setScanning(true)
+                let context = await reader.captureFullWindowContext()
+                self.indicatorWindow.setScanning(false)
+                guard !Task.isCancelled, self.activeState else { return }
+                if let context {
+                    self.latestScreenContext = context
+                }
+                do {
+                    try await Task.sleep(for: .seconds(interval))
+                } catch {
+                    return
+                }
+            }
+        }
+    }
+
+    private func startCountdown() {
+        countdownTask = Task { [weak self] in
+            while !Task.isCancelled {
+                guard let self else { return }
+                let remaining = self.remainingSeconds
+                guard remaining > 0 else { break }
+                self.indicatorWindow.updateRemainingTime(remaining)
+                do {
+                    try await Task.sleep(for: .seconds(1))
+                } catch {
+                    return
+                }
+            }
+            guard !Task.isCancelled, let self else { return }
+            NSSound.beep()
+            self.stopSession()
+        }
+    }
+
+    private func showConsentAlert() -> Bool {
+        NSApp.activate()
+        let alert = NSAlert()
+        alert.messageText = L10n.DangerousRead.Consent.title
+        alert.informativeText = L10n.DangerousRead.Consent.message
+        alert.alertStyle = .critical
+        alert.addButton(withTitle: L10n.DangerousRead.Consent.start)
+        alert.addButton(withTitle: L10n.DangerousRead.Consent.cancel)
+        return alert.runModal() == .alertFirstButtonReturn
+    }
+}

Hatoko/Accessibility/ScreenContext.swift

@@ -0,0 +1,61 @@
+import Foundation
+
+struct ScreenContext: Sendable, Equatable {
+
+    let appName: String?
+    let windowTitle: String?
+    let focusedText: String?
+    let selectedText: String?
+    let visibleText: String?
+    let capturedAt: Date
+
+    init(
+        appName: String?,
+        windowTitle: String?,
+        focusedText: String?,
+        selectedText: String?,
+        visibleText: String? = nil,
+        capturedAt: Date = Date()
+    ) {
+        self.appName = Self.truncateShort(appName)
+        self.windowTitle = Self.truncateShort(windowTitle)
+        self.focusedText = Self.truncate(focusedText)
+        self.selectedText = Self.truncate(selectedText)
+        self.visibleText = Self.truncate(visibleText)
+        self.capturedAt = capturedAt
+    }
+
+    func formatted() -> String {
+        var lines: [String] = []
+        if let appName {
+            lines.append("Application: \(appName)")
+        }
+        if let windowTitle {
+            lines.append("Window: \(windowTitle)")
+        }
+        if let selectedText {
+            lines.append("Selected text: \(selectedText)")
+        }
+        // Prefer visibleText (full window) over focusedText (single element)
+        if let visibleText {
+            lines.append("Visible text:\n\(visibleText)")
+        } else if let focusedText {
+            lines.append("Focused text: \(focusedText)")
+        }
+        guard !lines.isEmpty else { return "" }
+        let body = lines.joined(separator: "\n")
+        return "<screen_context>\n\(body)\n</screen_context>"
+    }
+
+    private static let maxShortFieldLength = 500
+
+    private static func truncate(_ text: String?) -> String? {
+        guard let text, !text.isEmpty else { return nil }
+        return String(text.prefix(PromptGuard.maxScreenContextLength))
+    }
+
+    private static func truncateShort(_ text: String?) -> String? {
+        guard let text, !text.isEmpty else { return nil }
+        return String(text.prefix(maxShortFieldLength))
+    }
+}