Switch key stroke observation to use defaultTap

Author: intitni

Core/Sources/CGEventObserver/CGEventObserver.swift

@@ -6,39 +6,50 @@ public protocol CGEventObserverType {
     @discardableResult
     func activateIfPossible() -> Bool
     func deactivate()
-    var stream: AsyncStream<CGEvent> { get }
+    func createStream() -> AsyncStream<CGEvent>
     var isEnabled: Bool { get }
 }
 
 public final class CGEventObserver: CGEventObserverType {
-    public let stream: AsyncStream<CGEvent>
     public var isEnabled: Bool { port != nil }
 
-    private var continuation: AsyncStream<CGEvent>.Continuation
+    private var continuations: [UUID: AsyncStream<CGEvent>.Continuation] = [:]
     private var port: CFMachPort?
     private let eventsOfInterest: Set<CGEventType>
     private let tapLocation: CGEventTapLocation = .cghidEventTap
     private let tapPlacement: CGEventTapPlacement = .tailAppendEventTap
-    private let tapOptions: CGEventTapOptions = .listenOnly
-    private var retryTask: Task<Void, Error>?
+    private let tapOptions: CGEventTapOptions = .defaultTap
 
     deinit {
-        continuation.finish()
+        for continuation in continuations {
+            continuation.value.finish()
+        }
         CFMachPortInvalidate(port)
     }
 
     public init(eventsOfInterest: Set<CGEventType>) {
         self.eventsOfInterest = eventsOfInterest
-        var continuation: AsyncStream<CGEvent>.Continuation!
-        stream = AsyncStream { c in
-            continuation = c
+    }
+
+    public func createStream() -> AsyncStream<CGEvent> {
+        .init { continuation in
+            let id = UUID()
+            addContinuation(continuation, id: id)
+            continuation.onTermination = { [weak self] _ in
+                self?.removeContinuation(id: id)
+            }
         }
-        self.continuation = continuation
+    }
+
+    private func addContinuation(_ continuation: AsyncStream<CGEvent>.Continuation, id: UUID) {
+        continuations[id] = continuation
+    }
+
+    private func removeContinuation(id: UUID) {
+        continuations[id] = nil
     }
 
     public func deactivate() {
-        retryTask?.cancel()
-        retryTask = nil
         guard let port else { return }
         os_log(.info, "CGEventObserver deactivated.")
         CFMachPortInvalidate(port)
@@ -56,7 +67,7 @@ public final class CGEventObserver: CGEventObserverType {
             tapProxy _: CGEventTapProxy,
             eventType: CGEventType,
             event: CGEvent,
-            continuationPointer: UnsafeMutableRawPointer?
+            continuationsPointer: UnsafeMutableRawPointer?
         ) -> Unmanaged<CGEvent>? {
             guard AXIsProcessTrusted() else {
                 return .passRetained(event)
@@ -66,10 +77,12 @@ public final class CGEventObserver: CGEventObserverType {
                 return .passRetained(event)
             }
 
-            if let continuation = continuationPointer?
-                .assumingMemoryBound(to: AsyncStream<CGEvent>.Continuation.self)
+            if let continuations = continuationsPointer?
+                .assumingMemoryBound(to: [UUID: AsyncStream<CGEvent>.Continuation].self)
             {
-                continuation.pointee.yield(event)
+                for continuation in continuations.pointee {
+                    continuation.value.yield(event)
+                }
             }
 
             return .passRetained(event)
@@ -79,7 +92,7 @@ public final class CGEventObserver: CGEventObserverType {
         let tapPlacement = tapPlacement
         let tapOptions = tapOptions
 
-        guard let port = withUnsafeMutablePointer(to: &continuation, { pointer in
+        guard let port = withUnsafeMutablePointer(to: &continuations, { pointer in
             CGEvent.tapCreate(
                 tap: tapLocation,
                 place: tapPlacement,
@@ -89,11 +102,6 @@ public final class CGEventObserver: CGEventObserverType {
                 userInfo: pointer
             )
         }) else {
-            retryTask = Task {
-                try? await Task.sleep(nanoseconds: 2_000_000_000)
-                try Task.checkCancellation()
-                activateIfPossible()
-            }
             return false
         }
         self.port = port

Core/Sources/Service/RealtimeSuggestionController.swift

@@ -66,8 +66,9 @@ public class RealtimeSuggestionController {
         os_log(.info, "Add auto trigger listener: %@.", listener as CVarArg)
 
         if task == nil {
-            task = Task { [stream = eventObserver.stream] in
-                for await event in stream {
+            task = Task { [weak self, eventObserver] in
+                for await event in eventObserver.createStream() {
+                    guard let self else { return }
                     await self.handleHIDEvent(event: event)
                 }
             }

DEVELOPMENT.md

@@ -4,37 +4,44 @@
 
 ### Copilot for Xcode
 
-Copilot for Xcode is the app containing both the XPCService and the editor extension.
+Copilot for Xcode is the host app containing both the XPCService and the editor extension.
 
 ### EditorExtension
 
-As its name suggests, the editor extension. Since an editor extension must be sandboxed, it will need to talk to a trusted non-sandboxed XPCService to break out the limitations. The identifier of the XPCService must be listed under `com.apple.security.temporary-exception.mach-lookup.global-name` in entitlements.
+As its name suggests, the editor extension. Its sole purpose is to forward editor content to the XPCService for processing, and update the editor with the returned content. Due to the sandboxing requirements for editor extensions, it has to communicate with a trusted, non-sandboxed XPCService to bypass the limitations. The XPCService identifier must be included in the `com.apple.security.temporary-exception.mach-lookup.global-name` entitlements.
 
 ### ExtensionService
 
-The ExtensionService is a program that runs in the background and does basically everything. It redirects the requests from EditorExtension to `CopilotService` and returns the updated code back to the extension.
+The `ExtensionService` is a program that operates in the background and performs a wide range of tasks. It redirects requests from the `EditorExtension` to the `CopilotService` and returns the updated code back to the extension, or presents it in a GUI outside of Xcode.
 
-Since the Xcode source editor extension only allows its commands to be triggered manually, the ExtensionService has to use Apple Scripts to trigger the menu items to generate real-time suggestions.
+### Core
 
-The ExtensionService is also using a lot of Apple Script tricks to get the file paths and project/workspace paths of the active Xcode window because Xcode is not providing this information.
+Most of the logics are implemented inside the package `Core`.
+
+- The `CopilotService` is responsible for communicating with the GitHub Copilot LSP.
+- The `Service` is responsible for handling the requests from the `EditorExtension`, communicating with the `CopilotService`, update the code blocks and present the GUI.
+- The `Client` is basically just a wrapper around the XPCService
+- The `SuggestionInjector` is responsible for injecting the suggestions into the code. Used in comment mode to present the suggestions, and all modes to accept suggestions.
+- The `Environment` contains some swappable global functions. It is used to make testing easier.
+- The `SuggestionWidget` is responsible for presenting the suggestions in floating widget mode.
 
 ## Building and Archiving the App
 
-Firstly, create a `Secrets.xcconfig` next to the others. You can provide a `GITHUB_TOKEN` here if you want to check for updates.
+To get started, create a `Secrets.xcconfig` file at the root directory. You can use the `Secrets.sample.xcconfig` as a reference.
 
-This project contains a Git submodule `copilot.vim`, so you will have to initialize the submodule or download it from [copilot.vim](https://github.com/github/copilot.vim).
+This project includes a Git submodule, `copilot.vim`, so you will need to either initialize the submodule or download it from the [copilot.vim](https://github.com/github/copilot.vim) repository.
 
-Then archive the target Copilot for Xcode.
+Finally, archive the Copilot for Xcode target.
 
 ## Testing Extension
 
-### Testing Real-time Suggestions Commands
+Just run both the `ExtensionService` and the `EditorExtension` Target.
 
-Testing Real-time Suggestions is a little bit different because the Apple Script can't find the commands when debugging the extension in Xcode. Instead, you will have to archive the debug version of the app, run the XPCService target simultaneously and use them against each other.
+## Unit Tests
 
-### Testing Other Commands
+To run unit tests, just run test from the `Copilot for Xcode` target.
 
-Just run both the XPCService and the EditorExtension Target. 
+For new tests, they should be added to the `TestPlan.xctestplan`.
 
 ## Code Style
 

README.md

@@ -22,7 +22,9 @@ Thanks to [LSP-copilot](https://github.com/TerminalFi/LSP-copilot) for showing t
 - [Limitations](#limitations)
 - [FAQ](#faq)
 - [License](#license)
-- [Development](DEVELOPMENT.md)
+
+
+For development instruction, check [Development.md](DEVELOPMENT.md).
 
 ## Prerequisites
 
@@ -32,15 +34,10 @@ Thanks to [LSP-copilot](https://github.com/TerminalFi/LSP-copilot) for showing t
 
 ## Permissions Required
 
-- Accessibility API
 - Folder Access
-- Input Monitoring (for real-time suggestions cancellation by pressing esc, arrow keys or clicking the mouse)
+- Accessibility API
 
-> You no longer require Input Monitoring to utilize real-time suggestions with version 0.8.1+. If you do not need the cancellation feature, you can simply ignore this permission.
-> 
-> However, to be frank, the Accessibility API is more dangerous than Input Monitoring. To remove the need for Input Monitoring, we can simply change the `CGEventTapOptions` from `listenOnly` to `defaultTap`, which allows for input manipulation.
->
-> If you are concerned about key logging and cannot trust the binary, we recommend examining the code and building it yourself. To address any concerns, you can specifically search for `CGEvent.tapCreate`, `AXObserver`, `AX___` within the code.
+> If you are concerned about key logging and cannot trust the binary, we recommend examining the code and [building it yourself](DEVELOPMENT.md). To address any concerns, you can specifically search for `CGEvent.tapCreate`, `AXObserver`, `AX___` within the code.
 
 ## Installation and Setup
 
@@ -72,18 +69,14 @@ Then set it up with the following steps:
 
 ### Granting Permissions to the App
 
-The first time the app is open and command run, the extension will ask for the necessary permissions. (except Input Monitoring, you have to enable it manually) 
+The first time the app is open and command run, the extension will ask for the necessary permissions.
 
 Alternatively, you may manually grant the required permissions by navigating to the `Privacy & Security` tab in the `System Settings.app`.
 
 - To grant permissions for the Accessibility API, click `Accessibility`, and drag `CopilotForXcodeExtensionService.app` to the list. You can locate the extension app by clicking `Reveal Extension App in Finder` in the host app.
 
 <img alt="Accessibility API" src="/accessibility_api_permission.png" width="500px">
 
-- To enable Input Monitoring (for real-time suggestions cancellation by pressing esc, arrow keys or clicking the mouse), click `Input Monitoring`, and drag `CopilotForXcodeExtensionService.app` to the list. You can locate the extension app by clicking `Reveal Extension App in Finder` in the host app.
-
-<img alt="Input Monitoring" src="/input_monitoring_permission.png" width="500px">
-
 If you encounter an alert requesting permission that you have previously granted, please remove the permission from the list and add it again to re-grant the necessary permissions.
 
 ### Managing `CopilotForXcodeExtensionService.app`