Add Screen and Mouse Coordinate Modes (#15)

* Add Screen Coordinates and Live Mouse modes to ClickIt Lite

Implements two coordinate modes for the Lite version:
- Screen Coordinates Mode: Clicks at a static, user-defined position
- Live Mouse Mode: Clicks follow cursor position, triggered by right-click

Changes:
- SimpleViewModel: Added CoordinateMode enum and mode switching logic
- SimpleHotkeyManager: Extended with right-click monitoring and debouncing
- SimpleClickEngine: Added dynamic point provider support for cursor-following
- SimplifiedMainView: Added mode selector UI with context-aware controls

Both modes continue to use ESC/SPACEBAR for emergency stop.

* Fix Swift concurrency actor isolation issues

- Mark stopMonitoring() and stopMouseMonitoring() as nonisolated
  to allow calling from deinit without actor context
- Wrap checkPermissions() call in Task { @mainactor in } block
  to properly handle async call from notification observer

Resolves build errors in ClickIt Lite.

* Mark event monitor properties as nonisolated(unsafe)

The event monitor properties need to be accessible from nonisolated
stop methods that are called from deinit. Marking them as
nonisolated(unsafe) is safe because:
- They are opaque tokens from NSEvent.addMonitorForEvents
- NSEvent.removeMonitor is thread-safe
- We only read them to pass to removeMonitor

This resolves the MainActor isolation compilation errors.

* Fix coordinate conversion for Live Mouse Mode

The previous implementation used NSScreen.main for coordinate conversion,
which caused clicks to drift towards the top of the screen, especially
in multi-monitor setups.

Changes:
- Find the screen that contains the mouse cursor location
- Use that specific screen's frame for accurate coordinate conversion
- Add fallback logic for edge cases using the full desktop bounds

This ensures clicks happen exactly where the cursor is positioned.

* Fix coordinate conversion and resource leaks from code review

Coordinate conversion (SimpleViewModel.swift):
- Fixed multi-monitor coordinate conversion to use global maxY
- Previous per-screen logic was incorrect and caused wrong Y positions
- Now properly accounts for entire virtual screen space

Resource management (SimpleHotkeyManager.swift):
- Restored stopMonitoring() to MainActor with proper cleanup
- Fixed stopMouseMonitoring() to dispatch cleanup to MainActor
- Both methods now properly nil out monitor properties and callbacks
- Prevents memory leaks from retained closures in singleton
- Removed nonisolated(unsafe) annotations (no longer needed)

These fixes address all issues identified in code review.

---------

Co-authored-by: Claude <[email protected]>

Author: jsonify

Sources/ClickIt/Lite/SimpleClickEngine.swift

@@ -33,6 +33,21 @@ final class SimpleClickEngine {
         interval: TimeInterval,
         clickType: ClickType,
         onUpdate: @escaping (Int) -> Void
+    ) {
+        startClicking(
+            pointProvider: { point },
+            interval: interval,
+            clickType: clickType,
+            onUpdate: onUpdate
+        )
+    }
+
+    /// Start clicking with dynamic point generation
+    func startClicking(
+        pointProvider: @escaping () -> CGPoint,
+        interval: TimeInterval,
+        clickType: ClickType,
+        onUpdate: @escaping (Int) -> Void
     ) {
         guard !isRunning else { return }
 
@@ -43,6 +58,9 @@ final class SimpleClickEngine {
             guard let self = self else { return }
 
             while !Task.isCancelled && self.isRunning {
+                // Get current point (can be static or dynamic)
+                let point = pointProvider()
+
                 // Perform click
                 await self.performClick(at: point, type: clickType)
                 self.clickCount += 1

Sources/ClickIt/Lite/SimpleHotkeyManager.swift

@@ -19,6 +19,12 @@ final class SimpleHotkeyManager {
     private var localMonitor: Any?
     private var onEmergencyStop: (() -> Void)?
 
+    private var globalMouseMonitor: Any?
+    private var localMouseMonitor: Any?
+    private var onRightMouseClick: (() -> Void)?
+    private var lastClickTime: TimeInterval = 0
+    private let clickDebounceInterval: TimeInterval = 0.1
+
     // MARK: - Singleton
 
     static let shared = SimpleHotkeyManager()
@@ -66,6 +72,42 @@ final class SimpleHotkeyManager {
         onEmergencyStop = nil
     }
 
+    /// Start monitoring for right mouse clicks (Live Mouse Mode)
+    func startMouseMonitoring(onRightClick: @escaping () -> Void) {
+        self.onRightMouseClick = onRightClick
+
+        // Monitor globally (when app is inactive)
+        globalMouseMonitor = NSEvent.addGlobalMonitorForEvents(matching: .rightMouseDown) { [weak self] event in
+            // Dispatch to MainActor since global monitor runs on background thread
+            Task { @MainActor in
+                self?.handleRightMouseClick()
+            }
+        }
+
+        // Monitor locally (when app is active)
+        localMouseMonitor = NSEvent.addLocalMonitorForEvents(matching: .rightMouseDown) { [weak self] event in
+            // Already on MainActor
+            self?.handleRightMouseClick()
+            return event // Pass through the event
+        }
+    }
+
+    /// Stop mouse monitoring
+    nonisolated func stopMouseMonitoring() {
+        // Dispatch cleanup to the main actor to safely access and nil out properties.
+        Task { @MainActor in
+            if let monitor = self.globalMouseMonitor {
+                NSEvent.removeMonitor(monitor)
+                self.globalMouseMonitor = nil
+            }
+            if let monitor = self.localMouseMonitor {
+                NSEvent.removeMonitor(monitor)
+                self.localMouseMonitor = nil
+            }
+            self.onRightMouseClick = nil
+        }
+    }
+
     // MARK: - Private Methods
 
     /// Check if the event is an emergency stop key (ESC or SPACEBAR)
@@ -76,4 +118,14 @@ final class SimpleHotkeyManager {
     private func handleEmergencyStop() {
         onEmergencyStop?()
     }
+
+    /// Handle right mouse click with debouncing
+    private func handleRightMouseClick() {
+        let currentTime = CFAbsoluteTimeGetCurrent()
+        if currentTime - lastClickTime < clickDebounceInterval {
+            return
+        }
+        lastClickTime = currentTime
+        onRightMouseClick?()
+    }
 }

Sources/ClickIt/Lite/SimplePermissionManager.swift

@@ -45,7 +45,9 @@ final class SimplePermissionManager: ObservableObject {
             queue: .main
         ) { [weak self] _ in
             // Re-check permissions when app becomes active (e.g., returning from System Settings)
-            self?.checkPermissions()
+            Task { @MainActor in
+                self?.checkPermissions()
+            }
         }
     }
 

Sources/ClickIt/Lite/SimpleViewModel.swift

@@ -12,6 +12,14 @@ import SwiftUI
 @MainActor
 final class SimpleViewModel: ObservableObject {
 
+    // MARK: - Types
+
+    /// Coordinate mode for clicking
+    enum CoordinateMode {
+        case screenCoordinates  // Static position
+        case liveMouse          // Follow cursor
+    }
+
     // MARK: - Published Properties
 
     @Published var clickLocation: CGPoint = CGPoint(x: 500, y: 300)
@@ -20,6 +28,7 @@ final class SimpleViewModel: ObservableObject {
     @Published var isRunning = false
     @Published var clickCount = 0
     @Published var statusMessage = "Stopped"
+    @Published var coordinateMode: CoordinateMode = .screenCoordinates
 
     // MARK: - Private Properties
 
@@ -36,8 +45,29 @@ final class SimpleViewModel: ObservableObject {
         }
     }
 
+    deinit {
+        hotkeyManager.stopMouseMonitoring()
+    }
+
     // MARK: - Public Methods
 
+    /// Set coordinate mode
+    func setCoordinateMode(_ mode: CoordinateMode) {
+        coordinateMode = mode
+
+        // Set up or tear down mouse monitoring based on mode
+        switch mode {
+        case .screenCoordinates:
+            hotkeyManager.stopMouseMonitoring()
+            statusMessage = "Screen Coordinates Mode"
+        case .liveMouse:
+            hotkeyManager.startMouseMonitoring { [weak self] in
+                self?.startClicking()
+            }
+            statusMessage = "Live Mouse Mode - Right-click to trigger"
+        }
+    }
+
     /// Start clicking
     func startClicking() {
         // Check permissions first
@@ -50,8 +80,21 @@ final class SimpleViewModel: ObservableObject {
         clickCount = 0
         statusMessage = "Running: 0 clicks"
 
+        // Use appropriate point provider based on mode
+        let pointProvider: () -> CGPoint
+        switch coordinateMode {
+        case .screenCoordinates:
+            pointProvider = { [weak self] in
+                self?.clickLocation ?? CGPoint(x: 500, y: 300)
+            }
+        case .liveMouse:
+            pointProvider = {
+                NSEvent.mouseLocation.asCGPoint()
+            }
+        }
+
         clickEngine.startClicking(
-            at: clickLocation,
+            pointProvider: pointProvider,
             interval: clickInterval,
             clickType: clickType
         ) { [weak self] count in
@@ -84,9 +127,22 @@ final class SimpleViewModel: ObservableObject {
 
 private extension NSPoint {
     func asCGPoint() -> CGPoint {
-        // Convert from AppKit coordinates (bottom-left origin) to CG coordinates (top-left origin)
-        guard let screen = NSScreen.main else { return CGPoint(x: x, y: y) }
-        let screenHeight = screen.frame.height
-        return CGPoint(x: x, y: screenHeight - y)
+        // Convert from AppKit coordinates (bottom-left origin) to CG coordinates (top-left origin).
+        // This must account for the entire virtual screen space in multi-monitor setups.
+
+        // The total height of the virtual screen space is the max Y coordinate across all screens.
+        // The conversion is then to subtract the AppKit Y from this total height.
+        if let globalMaxY = NSScreen.screens.map({ $0.frame.maxY }).max() {
+            return CGPoint(x: x, y: globalMaxY - y)
+        }
+
+        // As a fallback, use the main screen's height, which works for single-monitor setups.
+        if let mainScreen = NSScreen.main {
+            let screenHeight = mainScreen.frame.height
+            return CGPoint(x: x, y: screenHeight - y)
+        }
+
+        // Ultimate fallback if no screen information is available.
+        return CGPoint(x: x, y: y)
     }
 }