Merge branch 'feature/accessibility-api-malfunction-recovery' into develop

Author: intitni

Core/Sources/HostApp/DebugView.swift

@@ -19,6 +19,12 @@ final class DebugSettings: ObservableObject {
     @AppStorage(\.disableGitIgnoreCheck) var disableGitIgnoreCheck
     @AppStorage(\.disableFileContentManipulationByCheatsheet)
     var disableFileContentManipulationByCheatsheet
+    @AppStorage(\.restartXcodeInspectorIfAccessibilityAPIIsMalfunctioning)
+    var restartXcodeInspectorIfAccessibilityAPIIsMalfunctioning
+    @AppStorage(\.restartXcodeInspectorIfAccessibilityAPIIsMalfunctioningNoTimer)
+    var restartXcodeInspectorIfAccessibilityAPIIsMalfunctioningNoTimer
+    @AppStorage(\.toastForTheReasonWhyXcodeInspectorNeedsToBeRestarted)
+    var toastForTheReasonWhyXcodeInspectorNeedsToBeRestarted
     init() {}
 }
 
@@ -75,6 +81,31 @@ struct DebugSettingsView: View {
                         Text("Disable file content manipulation by cheatsheet")
                     }
 
+                    Group {
+                        Toggle(
+                            isOn: $settings
+                                .restartXcodeInspectorIfAccessibilityAPIIsMalfunctioning
+                        ) {
+                            Text(
+                                "Re-activate Xcode Inspector when Accessibility API malfunctioning detected"
+                            )
+                        }
+
+                        Toggle(
+                            isOn: $settings
+                                .restartXcodeInspectorIfAccessibilityAPIIsMalfunctioningNoTimer
+                        ) {
+                            Text("Trigger malfunctioning detection only with events")
+                        }
+
+                        Toggle(
+                            isOn: $settings
+                                .toastForTheReasonWhyXcodeInspectorNeedsToBeRestarted
+                        ) {
+                            Text("Toast for the reason of re-activation of Xcode Inspector")
+                        }
+                    }
+
                     Button("Reset migration version to 0") {
                         UserDefaults.shared.set(nil, forKey: "OldMigrationVersion")
                     }

Core/Sources/Service/RealtimeSuggestionController.swift

@@ -71,12 +71,10 @@ public actor RealtimeSuggestionController {
 
                 switch notification.kind {
                 case .valueChanged:
-                    Logger.service.debug("Receive valueChanged from editor")
                     await cancelInFlightTasks()
                     await self.triggerPrefetchDebounced()
                     await self.notifyEditingFileChange(editor: sourceEditor.element)
                 case .selectedTextChanged:
-                    Logger.service.debug("Receive selectedTextChanged from editor")
                     guard let fileURL = XcodeInspector.shared.activeDocumentURL
                     else { break }
                     await PseudoCommandHandler().invalidateRealtimeSuggestionsIfNeeded(
@@ -96,7 +94,7 @@ public actor RealtimeSuggestionController {
                 .fetchOrCreateWorkspaceAndFilespace(fileURL: fileURL)
 
             if filespace.codeMetadata.uti == nil {
-                Logger.service.info("Generate cache for file.")
+                Logger.service.info("Generate cache for file.") 
                 // avoid the command get called twice
                 filespace.codeMetadata.uti = ""
                 do {

Core/Sources/SuggestionWidget/FeatureReducers/WidgetFeature.swift

@@ -356,8 +356,6 @@ public struct WidgetFeature: ReducerProtocol {
                     await send(.panel(.switchToAnotherEditorAndUpdateContent))
 
                     for await notification in notifications {
-                        Logger.service.debug("Receive \(notification.kind) from Xcode")
-
                         try Task.checkCancellation()
 
                         // Hide the widgets before switching to another window/editor
@@ -402,11 +400,10 @@ public struct WidgetFeature: ReducerProtocol {
 
                 return .run { send in
                     if #available(macOS 13.0, *) {
-                        for await notification in merge(
+                        for await _ in merge(
                             selectionRangeChange.debounce(for: Duration.milliseconds(500)),
                             scroll
                         ) {
-                            Logger.service.debug("Receive \(notification.kind) from editor")
                             guard xcodeInspector.latestActiveXcode != nil else { return }
                             try Task.checkCancellation()
                             await send(.updateWindowLocation(animated: false))

ExtensionService/AppDelegate+Menu.swift

@@ -126,15 +126,15 @@ extension AppDelegate: NSMenuDelegate {
                 .append(.text("Active Workspace: \(inspector.activeWorkspaceURL?.path ?? "N/A")"))
             menu.items
                 .append(.text("Active Document: \(inspector.activeDocumentURL?.path ?? "N/A")"))
-            
+
             if let focusedWindow = inspector.focusedWindow {
                 menu.items.append(.text(
                     "Active Window: \(focusedWindow.uiElement.identifier)"
                 ))
             } else {
                 menu.items.append(.text("Active Window: N/A"))
             }
-            
+
             if let focusedElement = inspector.focusedElement {
                 menu.items.append(.text(
                     "Focused Element: \(focusedElement.description)"
@@ -144,9 +144,9 @@ extension AppDelegate: NSMenuDelegate {
             }
 
             if let sourceEditor = inspector.focusedEditor {
-                menu.items.append(.text(
-                    "Active Source Editor: \(sourceEditor.element.isSourceEditor ? "Found" : "Error")"
-                ))
+                let label = sourceEditor.element.description
+                menu.items
+                    .append(.text("Active Source Editor: \(label.isEmpty ? "Unknown" : label)"))
             } else {
                 menu.items.append(.text("Active Source Editor: N/A"))
             }

Pro

@@ -168,6 +168,8 @@ let package = Package(
                 "SuggestionModel",
                 "AXNotificationStream",
                 "Logger",
+                "Toast",
+                "Preferences",
                 .product(name: "AsyncExtensions", package: "AsyncExtensions"),
                 .product(name: "AsyncAlgorithms", package: "swift-async-algorithms"),
             ]

Tool/Package.swift

@@ -569,5 +569,26 @@ public extension UserDefaultPreferenceKeys {
             key: "FeatureFlag-DisableEnhancedWorkspace"
         )
     }
+    
+    var restartXcodeInspectorIfAccessibilityAPIIsMalfunctioning: FeatureFlag {
+        .init(
+            defaultValue: true,
+            key: "FeatureFlag-RestartXcodeInspectorIfAccessibilityAPIIsMalfunctioning"
+        )
+    }
+    
+    var restartXcodeInspectorIfAccessibilityAPIIsMalfunctioningNoTimer: FeatureFlag {
+        .init(
+            defaultValue: true,
+            key: "FeatureFlag-RestartXcodeInspectorIfAccessibilityAPIIsMalfunctioningNoTimer"
+        )
+    }
+    
+    var toastForTheReasonWhyXcodeInspectorNeedsToBeRestarted: FeatureFlag {
+        .init(
+            defaultValue: false,
+            key: "FeatureFlag-ToastForTheReasonWhyXcodeInspectorNeedsToBeRestarted"
+        )
+    }
 }
 

Tool/Sources/Preferences/Keys.swift

@@ -135,7 +135,7 @@ public final class XcodeAppInstanceInspector: AppInstanceInspector {
             observeAXNotifications()
 
             try await Task.sleep(nanoseconds: 3_000_000_000)
-            // Sometimes the focused window may not be rea?dy on app launch.
+            // Sometimes the focused window may not be ready on app launch.
             if !(focusedWindow is WorkspaceXcodeWindowInspector) {
                 observeFocusedWindow()
             }
@@ -200,7 +200,7 @@ public final class XcodeAppInstanceInspector: AppInstanceInspector {
     }
 
     @MainActor
-    private func observeAXNotifications() {
+    func observeAXNotifications() {
         longRunningTasks.forEach { $0.cancel() }
         longRunningTasks = []
 

Tool/Sources/XcodeInspector/Apps/XcodeAppInstanceInspector.swift

@@ -6,10 +6,17 @@ import Foundation
 import Logger
 import Preferences
 import SuggestionModel
+import Toast
+
+public extension Notification.Name {
+    static let accessibilityAPIMalfunctioning = Notification.Name("accessibilityAPIMalfunctioning")
+}
 
 public final class XcodeInspector: ObservableObject {
     public static let shared = XcodeInspector()
 
+    private var toast: ToastController { ToastControllerDependencyKey.liveValue }
+
     private var cancellable = Set<AnyCancellable>()
     private var activeXcodeObservations = Set<Task<Void, Error>>()
     private var appChangeObservations = Set<Task<Void, Never>>()
@@ -182,6 +189,36 @@ public final class XcodeInspector: ObservableObject {
                         }
                     }
                 }
+
+                if UserDefaults.shared
+                    .value(for: \.restartXcodeInspectorIfAccessibilityAPIIsMalfunctioning)
+                {
+                    group.addTask { [weak self] in
+                        while true {
+                            guard let self else { return }
+                            if UserDefaults.shared.value(
+                                for: \.restartXcodeInspectorIfAccessibilityAPIIsMalfunctioningNoTimer
+                            ) {
+                                return
+                            }
+
+                            try await Task.sleep(nanoseconds: 10_000_000_000)
+                            await MainActor.run {
+                                self.checkForAccessibilityMalfunction("Timer")
+                            }
+                        }
+                    }
+                }
+
+                group.addTask { [weak self] in // malfunctioning
+                    let sequence = NSWorkspace.shared.notificationCenter
+                        .notifications(named: .accessibilityAPIMalfunctioning)
+                    for await notification in sequence {
+                        guard let self else { return }
+                        await self
+                            .recoverFromAccessibilityMalfunctioning(notification.object as? String)
+                    }
+                }
             }
         }
 
@@ -207,7 +244,7 @@ public final class XcodeInspector: ObservableObject {
         activeWorkspaceURL = xcode.workspaceURL
         focusedWindow = xcode.focusedWindow
 
-        let setFocusedElement = { [weak self] in
+        let setFocusedElement = { @MainActor [weak self] in
             guard let self else { return }
             focusedElement = xcode.appElement.focusedElement
             if let editorElement = focusedElement, editorElement.isSourceEditor {
@@ -218,27 +255,51 @@ public final class XcodeInspector: ObservableObject {
             } else if let element = focusedElement,
                       let editorElement = element.firstParent(where: \.isSourceEditor)
             {
+                Logger.service.debug("Focused on child of source editor.")
                 focusedEditor = .init(
                     runningApplication: xcode.runningApplication,
                     element: editorElement
                 )
             } else {
+                Logger.service.debug("No source editor found.")
                 focusedEditor = nil
             }
         }
 
         setFocusedElement()
         let focusedElementChanged = Task { @MainActor in
             for await notification in xcode.axNotifications {
-                guard notification.kind == .focusedUIElementChanged else { continue }
-                Logger.service.debug("Update focused element")
-                try Task.checkCancellation()
-                setFocusedElement()
+                if notification.kind == .focusedUIElementChanged {
+                    Logger.service.debug("Update focused element")
+                    try Task.checkCancellation()
+                    setFocusedElement()
+                }
             }
         }
 
         activeXcodeObservations.insert(focusedElementChanged)
 
+        if UserDefaults.shared
+            .value(for: \.restartXcodeInspectorIfAccessibilityAPIIsMalfunctioning)
+        {
+            let malfunctionCheck = Task { @MainActor [weak self] in
+                if #available(macOS 13.0, *) {
+                    let notifications = xcode.axNotifications.filter {
+                        $0.kind == .uiElementDestroyed
+                    }.debounce(for: .milliseconds(1000))
+                    for await _ in notifications {
+                        guard let self else { return }
+                        try Task.checkCancellation()
+                        self.checkForAccessibilityMalfunction("Element Destroyed")
+                    }
+                }
+            }
+
+            activeXcodeObservations.insert(malfunctionCheck)
+    
+            checkForAccessibilityMalfunction("Reactivate Xcode")
+        }
+        
         xcode.$completionPanel.receive(on: DispatchQueue.main).sink { [weak self] element in
             self?.completionPanel = element
         }.store(in: &activeXcodeCancellable)
@@ -259,5 +320,81 @@ public final class XcodeInspector: ObservableObject {
             self?.focusedWindow = window
         }.store(in: &activeXcodeCancellable)
     }
+    
+    private var lastRecoveryFromAccessibilityMalfunctioningTimeStamp = Date()
+
+    @MainActor
+    private func checkForAccessibilityMalfunction(_ source: String) {
+        guard Date().timeIntervalSince(lastRecoveryFromAccessibilityMalfunctioningTimeStamp) > 5
+        else { return }
+        
+        Logger.service.debug("""
+        Check for Accessibility Malfunctioning:
+        Source Editor: \({
+            if let editor = self.focusedEditor {
+                return editor.element.description
+            }
+            return "Not Found"
+        }())
+        Focused Element: \({
+            if let element = self.focusedElement {
+                return "\(element.description), \(element.identifier), \(element.role)"
+            }
+            return "Not Found"
+        }())
+
+        Accessibility API Permission: \(
+            AXIsProcessTrusted() ? "Granted" :
+                "Not Granted"
+        )
+        App: \(
+            activeApplication?.runningApplication
+                .bundleIdentifier ?? ""
+        )
+        Focused Element: \({
+            guard let element = self.activeApplication?.appElement
+                .focusedElement
+            else {
+                return "Not Found"
+            }
+            return "\(element.description), \(element.identifier), \(element.role)"
+        }())
+        """)
+
+        if let editor = focusedEditor, !editor.element.isSourceEditor {
+            NSWorkspace.shared.notificationCenter.post(
+                name: .accessibilityAPIMalfunctioning,
+                object: "Source Editor Element Corrupted: \(source)"
+            )
+        } else if let element = activeXcode?.appElement.focusedElement {
+            if element.description != focusedElement?.description ||
+                element.role != focusedElement?.role
+            {
+                NSWorkspace.shared.notificationCenter.post(
+                    name: .accessibilityAPIMalfunctioning,
+                    object: "Element Inconsistency:  \(source)"
+                )
+            }
+        }
+    }
+    
+    @MainActor
+    private func recoverFromAccessibilityMalfunctioning(_ source: String?) {
+        if UserDefaults.shared.value(for: \.toastForTheReasonWhyXcodeInspectorNeedsToBeRestarted) {
+            toast.toast(
+                content: """
+                Accessibility API malfunction detected: \
+                \(source ?? "").
+                Resetting active Xcode.
+                """,
+                type: .warning
+            )
+        }
+        if let activeXcode {
+            lastRecoveryFromAccessibilityMalfunctioningTimeStamp = Date()
+            setActiveXcode(activeXcode)
+            activeXcode.observeAXNotifications()
+        }
+    }
 }
 

Tool/Sources/XcodeInspector/XcodeInspector.swift

@@ -54,7 +54,6 @@ public final class WorkspaceXcodeWindowInspector: XcodeWindowInspector {
                     for await notification in axNotifications {
                         guard notification.kind == .focusedUIElementChanged else { continue }
                         guard let self else { return }
-                        Logger.service.debug("Workspace refresh")
                         try Task.checkCancellation()
                         await self.updateURLs()
                     }