import AppKit import ApplicationServices import Darwin import Foundation @MainActor final class InputEventTap { typealias Handler = @MainActor (CGEventType, CGEvent) -> Bool private(set) var port: CFMachPort? private var source: CFRunLoopSource? private var permissionMonitor: InputPermissionMonitor? private let handler: Handler private let onFailure: @MainActor (InputError) -> Void init( mask: CGEventMask, trustObserver: AccessibilityTrustObserver = .shared, readTrust: @escaping @MainActor () -> Bool = { AXIsProcessTrusted() }, handler: @escaping Handler, onFailure: @escaping @MainActor (InputError) -> Void ) throws { self.handler = handler self.onFailure = onFailure guard readTrust() else { throw InputError.accessibilityRequired } guard let port = CGEvent.tapCreate( tap: .cgSessionEventTap, place: .headInsertEventTap, options: .defaultTap, eventsOfInterest: mask, callback: { _, type, event, context in guard let context else { return Unmanaged.passUnretained(event) } // This source is attached only to the main run loop; delivery never hops threads. let consumed = MainActor.assumeIsolated { let owner = Unmanaged.fromOpaque(context).takeUnretainedValue() return owner.receive(type, event) } return consumed ? nil : Unmanaged.passUnretained(event) }, userInfo: Unmanaged.passUnretained(self).toOpaque()) else { throw InputError.tapCreationFailed } self.port = port guard let source = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, port, 0) else { CFMachPortInvalidate(port) self.port = nil throw InputError.tapRunLoopSourceFailed } self.source = source CFRunLoopAddSource(CFRunLoopGetMain(), source, .commonModes) CGEvent.tapEnable(tap: port, enable: true) guard CGEvent.tapIsEnabled(tap: port) else { stop() throw InputError.tapEnableFailed } permissionMonitor = InputPermissionMonitor( appCenter: .default, workspaceCenter: NSWorkspace.shared.notificationCenter, trustObserver: trustObserver, readTrust: readTrust, onRevoked: { [weak self] in guard let self else { return } self.stop() self.onFailure(.accessibilityRequired) }) } isolated deinit { stop() } func stop() { permissionMonitor?.stop() permissionMonitor = nil if let port { CGEvent.tapEnable(tap: port, enable: false) CFMachPortInvalidate(port) } if let source { CFRunLoopRemoveSource(CFRunLoopGetMain(), source, .commonModes) } source = nil port = nil } static func dispatch( _ type: CGEventType, _ event: CGEvent, trace: any ParcelTraceSink = SignpostTraceSink.shared, handler: Handler ) -> Bool { let interval = trace.beginIfEnabled(.tapCallback, value: UInt64(type.rawValue), detail: event.timestamp) var consumed = false defer { trace.endIfStarted(.tapCallback, interval, value: consumed ? 1 : 0) } if event.timestamp != 0, trace.emits(.inputLatency) { let now = clock_gettime_nsec_np(CLOCK_UPTIME_RAW) if now >= event.timestamp { // Signposts start when emitted; the event clock preserves the queueing latency separately. trace.event(.inputLatency, value: event.timestamp, detail: now - event.timestamp) } } consumed = handler(type, event) return consumed } func receive(_ type: CGEventType, _ event: CGEvent) -> Bool { Self.dispatch(type, event) { type, event in handle(type, event) } } private func handle(_ type: CGEventType, _ event: CGEvent) -> Bool { guard port != nil, permissionMonitor?.isTrusted == true else { return false } if type == .tapDisabledByTimeout || type == .tapDisabledByUserInput { guard permissionMonitor?.checkPermission() == true else { return false } _ = handler(type, event) if let port { CGEvent.tapEnable(tap: port, enable: true) if !CGEvent.tapIsEnabled(tap: port) { stop() onFailure(.tapEnableFailed) } } return false } return handler(type, event) } } @MainActor final class InputPermissionMonitor { private(set) var isTrusted = true private let readTrust: @MainActor () -> Bool private let trustObserver: AccessibilityTrustObserver private let onRevoked: @MainActor () -> Void private var observers: [(NotificationCenter, any NSObjectProtocol)] = [] private var trustObservation: AccessibilityTrustObservation? private var isStopped = false init( appCenter: NotificationCenter, workspaceCenter: NotificationCenter, trustObserver: AccessibilityTrustObserver = .shared, readTrust: @escaping @MainActor () -> Bool, onRevoked: @escaping @MainActor () -> Void ) { self.readTrust = readTrust self.trustObserver = trustObserver self.onRevoked = onRevoked observe(NSApplication.didBecomeActiveNotification, in: appCenter) observe(NSWorkspace.didActivateApplicationNotification, in: workspaceCenter) observe(NSWorkspace.didWakeNotification, in: workspaceCenter) observe(NSWorkspace.screensDidWakeNotification, in: workspaceCenter) trustObservation = trustObserver.observe { [weak self] in _ = self?.checkPermission() } } isolated deinit { stop() } @discardableResult func checkPermission() -> Bool { guard !isStopped else { return false } isTrusted = readTrust() guard isTrusted else { stop() onRevoked() return false } return true } func stop() { guard !isStopped else { return } isStopped = true isTrusted = false trustObservation?.cancel() trustObservation = nil for (center, token) in observers { center.removeObserver(token) } observers.removeAll() } private func observe(_ name: Notification.Name, in center: NotificationCenter) { let token = center.addObserver(forName: name, object: nil, queue: .main) { [weak self] _ in MainActor.assumeIsolated { _ = self?.checkPermission() } } observers.append((center, token)) } }