import CoreGraphics import Foundation import ParcelAnimation import ParcelCore public import ParcelIPC public import ParcelPlatform @MainActor public enum EngineDiagnostics { public static func collect(engine: ParcelEngine?, accessibility: AccessibilityStatus) async throws -> IPCDiagnostics { try await collect(engine: engine, accessibility: accessibility, permissions: .live, capabilities: .live) } struct PermissionReader: Sendable { let inputMonitoring: @Sendable () -> Bool let screenRecording: @Sendable () -> Bool static let live = Self( inputMonitoring: { Permissions.inputMonitoringIsGranted() }, screenRecording: { CGPreflightScreenCaptureAccess() }) } struct CapabilityReader: Sendable { let available: WindowServer.Capabilities let displaySpaces: @Sendable () throws -> [WindowServer.DisplaySpaces] let currentSpace: @Sendable (String) throws -> UInt64 static var live: Self { let server = WindowServer() return Self( available: server.capabilities, displaySpaces: { try server.displaySpaces() }, currentSpace: { try server.currentSpace(displayID: $0) }) } } static func collect( engine: ParcelEngine?, accessibility: AccessibilityStatus, permissions: PermissionReader, capabilities: CapabilityReader ) async throws -> IPCDiagnostics { try Task.checkCancellation() let running = engine?.isRunning == true let applications = applications(engine) let accessibilityState: IPCDiagnostics.PermissionState = switch accessibility { case .granted: .granted case .notGranted: .notGranted case .possiblyStale: .staleGrant } let platform = await Task.detached { ( permissions: IPCDiagnostics.Permissions( accessibility: accessibilityState, inputMonitoring: permissions.inputMonitoring() ? .granted : .notGranted, screenRecording: permissions.screenRecording() ? .granted : .notGranted), capabilities: inspectCapabilities(capabilities) ) }.value try Task.checkCancellation() return IPCDiagnostics( running: running, applications: applications, permissions: platform.permissions, capabilities: platform.capabilities, suspendedDisplays: (engine?.displaySuspensions ?? []).map { IPCDiagnostics.SuspendedDisplay( display: $0.display.rawValue, reason: $0.reason.rawValue, detail: $0.reason.detail, sinceUnixSeconds: $0.since.timeIntervalSince1970) }) } private static func applications(_ engine: ParcelEngine?) -> [IPCDiagnostics.Application] { guard let engine else { return [] } let metrics = engine.writeMetrics let apps = Set(engine.snapshot.state.windows.values.map(\.app)).union(engine.wedgedApps) let pids = Set(apps.map(\.pid)).union(metrics.keys.map(\.rawValue)) let wedgedPIDs = Set(engine.wedgedApps.map(\.pid)) let now = engine.animationTime return pids.sorted().map { pid in let metric = metrics[MotionAppID(rawValue: pid)] let bundleID = apps.first { $0.pid == pid && !$0.bundleID.isEmpty }?.bundleID return IPCDiagnostics.Application( pid: pid, bundleID: bundleID, slow: metric?.isSlow(at: now) == true, wedged: wedgedPIDs.contains(pid), sampleCount: metric?.sampleCount ?? 0, retainedSampleCount: metric?.retainedSampleCount ?? 0, p50Milliseconds: metric?.p50WriteDuration.map { $0 * 1000 }, p95Milliseconds: metric?.p95WriteDuration.map { $0 * 1000 }) } } nonisolated static func inspectCapabilities(_ reader: CapabilityReader) -> [IPCDiagnostics.Capability] { let available = reader.available let brightnessDetail = String( localized: "Not verified because diagnostics do not write window brightness.", bundle: .module) return inspectSpaceCapabilities(reader) + [ IPCDiagnostics.Capability( symbol: "SLSMainConnectionID / CGSMainConnectionID", available: available.brightnessConnection, verification: .unverified, detail: brightnessDetail), IPCDiagnostics.Capability( symbol: "CGSSetWindowListBrightness", available: available.windowListBrightness, verification: .unverified, detail: brightnessDetail), IPCDiagnostics.Capability( symbol: "_AXUIElementGetWindow", available: available.axWindowID, verification: .unverified, detail: String( localized: "Not verified because diagnostics do not make Accessibility calls.", bundle: .module)), ] } nonisolated private static func inspectSpaceCapabilities(_ reader: CapabilityReader) -> [IPCDiagnostics.Capability] { func result( main: IPCDiagnostics.Verification, displays: IPCDiagnostics.Verification, current: IPCDiagnostics.Verification, detail: String? = nil ) -> [IPCDiagnostics.Capability] { func capability(_ symbol: String, available: Bool, verification: IPCDiagnostics.Verification) -> IPCDiagnostics.Capability { IPCDiagnostics.Capability( symbol: symbol, available: available, verification: available ? verification : .unverified, detail: !available ? WindowServer.ReadError.symbolUnavailable(symbol).description : verification == .verified ? nil : detail) } return [ capability("SLSMainConnectionID", available: reader.available.mainConnection, verification: main), capability( "SLSCopyManagedDisplaySpaces", available: reader.available.managedDisplaySpaces, verification: displays), capability( "SLSManagedDisplayGetCurrentSpace", available: reader.available.currentSpace, verification: current), ] } guard reader.available.canReadDisplaySpaces else { let missing = reader.available.mainConnection ? "SLSCopyManagedDisplaySpaces" : "SLSMainConnectionID" return result( main: .unverified, displays: .unverified, current: .unverified, detail: WindowServer.ReadError.symbolUnavailable(missing).description) } let displays: [WindowServer.DisplaySpaces] do { displays = try reader.displaySpaces() } catch { return result(main: .unverified, displays: .failed, current: .unverified, detail: String(describing: error)) } guard !displays.isEmpty else { return result( main: .unverified, displays: .failed, current: .unverified, detail: String(localized: "The window server returned no display spaces to verify.", bundle: .module)) } var failures: [String] = [] for (index, display) in displays.enumerated() { if display.displayID.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty { failures.append( WindowServer.ReadError.invalidDisplaySpaces( index: index, field: "Display Identifier", problem: .malformed ).description) } if display.spaces.isEmpty { failures.append( String( format: String(localized: "Display %@ has no spaces to verify.", bundle: .module), display.displayID)) } else if !display.spaces.allSatisfy({ $0 != 0 }) { failures.append( WindowServer.ReadError.invalidDisplaySpaces(index: index, field: "Spaces", problem: .malformed) .description) } } guard failures.isEmpty else { return result( main: .unverified, displays: .failed, current: .unverified, detail: failures.joined(separator: "\n")) } guard reader.available.canReadCurrentSpace else { return result( main: .verified, displays: .verified, current: .unverified, detail: WindowServer.ReadError.symbolUnavailable("SLSManagedDisplayGetCurrentSpace").description) } for display in displays { do { let current = try reader.currentSpace(display.displayID) guard current != 0 else { failures.append( WindowServer.ReadError.currentSpaceUnavailable(displayID: display.displayID).description) continue } if !display.spaces.contains(current) { failures.append( String( format: String( localized: "Current space %@ is not listed for display %@.", bundle: .module), String(current), display.displayID)) } } catch { failures.append(String(describing: error)) } } return result( main: .verified, displays: .verified, current: failures.isEmpty ? .verified : .failed, detail: failures.isEmpty ? nil : failures.joined(separator: "\n")) } }