Merge branch 'feat/mx-master-4-firmware-runtime' into docs/mx-master-4-firmware-first

Author: hughesyadaddy

core/engine.py

@@ -778,8 +778,15 @@ def _battery_poll_loop(self, stop_event):
                         except Exception:
                             pass
 
+                # Read ``_replay_inflight`` under the same lock that the
+                # replay thread uses to flip it, otherwise the battery
+                # loop can issue a Smart Shift poll partway through a
+                # replay round-trip and the firmware queues conflicting
+                # HID++ writes.
+                with self._replay_lock:
+                    replay_inflight = self._replay_inflight
                 if (
-                    not self._replay_inflight
+                    not replay_inflight
                     and now - _last_ss >= _ss_poll_interval
                     and hg.smart_shift_supported
                 ):
@@ -928,3 +935,15 @@ def stop(self):
             self._battery_poll_thread = None
         self._app_detector.stop()
         self.hook.stop()
+        # Cancel any pending safety auto-release timers. Without this the
+        # threading.Timer scheduled by execute_action can still fire after
+        # ``stop()`` returns and call ``inject_mouse_up`` against a hook
+        # that has already been torn down -- one of the timers fires a
+        # phantom release every time Mouser quits during a long press.
+        timers = list(self._mouse_release_timers.values())
+        self._mouse_release_timers.clear()
+        for timer in timers:
+            try:
+                timer.cancel()
+            except Exception as exc:  # noqa: BLE001 - shutdown must complete
+                print(f"[Engine] stop: failed to cancel release timer: {exc!r}")

core/logi_devices.py

@@ -442,9 +442,32 @@ def iter_known_devices() -> Iterable[LogiDeviceSpec]:
 
 
 def clamp_dpi(value, device=None) -> int:
+    """Clamp ``value`` into the device's DPI range, defaulting to the safe
+    floor on malformed input.
+
+    ``value`` may arrive from a JSON config file, a QML binding, or a HID
+    report -- so the raw ``int(value)`` cast that was here before could
+    raise on a stringified hex value, on ``None``, or on a partial HID
+    read. Crashing the engine's DPI path because the user edited
+    ``config.json`` by hand is the wrong failure mode; we coerce
+    defensively and return the device minimum so the cursor never freezes.
+    """
     dpi_min = getattr(device, "dpi_min", DEFAULT_DPI_MIN) or DEFAULT_DPI_MIN
     dpi_max = getattr(device, "dpi_max", DEFAULT_DPI_MAX) or DEFAULT_DPI_MAX
-    dpi = int(value)
+    if isinstance(value, bool):
+        # ``bool`` is a subclass of ``int`` -- reject it explicitly so a
+        # leaked truthy flag never silently resolves to 0 or 1 DPI.
+        return dpi_min
+    if isinstance(value, str):
+        try:
+            dpi = int(value, 0)
+        except (TypeError, ValueError):
+            return dpi_min
+    else:
+        try:
+            dpi = int(value)
+        except (TypeError, ValueError):
+            return dpi_min
     return max(dpi_min, min(dpi_max, dpi))
 
 

core/mouse_hook_base.py

@@ -197,8 +197,11 @@ def _set_device_connected(self, connected):
         if self._connection_change_cb:
             try:
                 self._connection_change_cb(connected)
-            except Exception:
-                pass
+            except Exception as exc:  # noqa: BLE001 - callback boundary
+                print(
+                    f"[MouseHook] connection_change_cb raised on "
+                    f"{state.lower()}: {exc!r}"
+                )
 
     def set_debug_callback(self, callback):
         self._debug_callback = callback
@@ -213,22 +216,24 @@ def _emit_debug(self, message):
         if self.debug_mode and self._debug_callback:
             try:
                 self._debug_callback(message)
-            except Exception:
-                pass
+            except Exception as exc:  # noqa: BLE001 - callback boundary
+                # ``_emit_debug`` is itself the diagnostic channel, so the
+                # failure goes straight to print() rather than recursing.
+                print(f"[MouseHook] debug_callback raised: {exc!r}")
 
     def _emit_status(self, message):
         if self._status_callback:
             try:
                 self._status_callback(message)
-            except Exception:
-                pass
+            except Exception as exc:  # noqa: BLE001 - callback boundary
+                print(f"[MouseHook] status_callback raised: {exc!r}")
 
     def _emit_gesture_event(self, event):
         if self.debug_mode and self._gesture_callback:
             try:
                 self._gesture_callback(event)
-            except Exception:
-                pass
+            except Exception as exc:  # noqa: BLE001 - callback boundary
+                print(f"[MouseHook] gesture_callback raised: {exc!r}")
 
     def _dispatch(self, event):
         callbacks = self._callbacks.get(event.event_type, [])

core/mouse_hook_macos.py

@@ -229,6 +229,14 @@ def _dispatch_worker(self):
 
     @_autoreleased
     def _event_tap_callback(self, proxy, event_type, cg_event, refcon):
+        # The CGEventTap continues to fire briefly after ``stop()`` sets
+        # ``_running = False`` -- macOS does not synchronously drain
+        # in-flight callbacks before disabling the tap. Drop the event
+        # untouched so we never enqueue into a torn-down dispatch worker,
+        # mutate shared state, or apply scroll inversion after the device
+        # connection has already been released.
+        if not self._running:
+            return cg_event
         try:
             if event_type in (
                 _kCGEventTapDisabledByTimeout,
@@ -254,8 +262,13 @@ def _event_tap_callback(self, proxy, event_type, cg_event, refcon):
                     == _INJECTED_EVENT_MARKER
                 ):
                     return cg_event
-            except Exception:
-                pass
+            except Exception as exc:  # noqa: BLE001 - Quartz boundary
+                # Surface failures so a borked Quartz binding cannot make
+                # the injected-event marker silently misfire on every
+                # event for the rest of the session.
+                self._emit_debug(
+                    f"CGEventGetIntegerValueField(kCGEventSourceUserData) failed: {exc!r}"
+                )
             mouse_event = None
             should_block = False
 

core/mouse_hook_windows.py

@@ -241,6 +241,12 @@ def __init__(self):
         self._startup_ok = False
         self._prev_raw_buttons = {}
         self._last_rehook_time = 0
+        # Serializes gesture begin/end transitions across the LL hook
+        # thread (XBUTTON), the Raw Input window proc thread, and the HID
+        # listener thread. Held only around the `_gesture_active` /
+        # `_gesture_triggered` flips -- dispatch happens outside so an
+        # engine callback that re-enters the hook never deadlocks.
+        self._gesture_lock = threading.Lock()
         self._init_dispatch_queue(maxsize=512)
         self._dispatch_worker_thread = None
 
@@ -562,15 +568,20 @@ def _check_raw_mouse_gesture(self, hDevice, buffer):
         if extra_now == extra_prev:
             return
         if extra_now and not extra_prev:
-            if not self._gesture_active:
+            with self._gesture_lock:
+                if self._gesture_active:
+                    return
                 self._gesture_active = True
                 self._gesture_triggered = False
-                print(f"[MouseHook] Gesture DOWN (rawBtns extra: 0x{extra_now:X})")
-        elif not extra_now and extra_prev:
-            if self._gesture_active:
+            print(f"[MouseHook] Gesture DOWN (rawBtns extra: 0x{extra_now:X})")
+            return
+        if not extra_now and extra_prev:
+            with self._gesture_lock:
+                if not self._gesture_active:
+                    return
                 self._gesture_active = False
-                print("[MouseHook] Gesture UP")
-                self._dispatch(MouseEvent(MouseEvent.GESTURE_CLICK))
+            print("[MouseHook] Gesture UP")
+            self._dispatch(MouseEvent(MouseEvent.GESTURE_CLICK))
 
     def _setup_raw_input(self):
         instance = GetModuleHandleW(None)
@@ -709,34 +720,42 @@ def _reinstall_hook(self):
             print("[MouseHook] Failed to reinstall hook!")
 
     def _on_hid_gesture_down(self):
-        if not self._gesture_active:
+        with self._gesture_lock:
+            if self._gesture_active:
+                return
             self._gesture_active = True
             self._gesture_triggered = False
-            self._emit_debug("HID gesture button down")
-            self._emit_gesture_event({"type": "button_down"})
-            if self._gesture_direction_enabled and not self._gesture_cooldown_active():
+            tracking = (
+                self._gesture_direction_enabled
+                and not self._gesture_cooldown_active()
+            )
+            if tracking:
                 self._start_gesture_tracking()
             else:
                 self._gesture_tracking = False
-                self._gesture_triggered = False
+        self._emit_debug("HID gesture button down")
+        self._emit_gesture_event({"type": "button_down"})
 
     def _on_hid_gesture_up(self):
-        if self._gesture_active:
+        should_click = False
+        with self._gesture_lock:
+            if not self._gesture_active:
+                return
             should_click = not self._gesture_triggered
             self._gesture_active = False
             self._finish_gesture_tracking()
             self._gesture_triggered = False
-            self._emit_debug(
-                f"HID gesture button up click_candidate={str(should_click).lower()}"
-            )
-            self._emit_gesture_event(
-                {
-                    "type": "button_up",
-                    "click_candidate": should_click,
-                }
-            )
-            if should_click:
-                self._dispatch(MouseEvent(MouseEvent.GESTURE_CLICK))
+        self._emit_debug(
+            f"HID gesture button up click_candidate={str(should_click).lower()}"
+        )
+        self._emit_gesture_event(
+            {
+                "type": "button_up",
+                "click_candidate": should_click,
+            }
+        )
+        if should_click:
+            self._dispatch(MouseEvent(MouseEvent.GESTURE_CLICK))
 
     def _on_hid_mode_shift_down(self):
         self._emit_debug("HID mode shift button down")

tests/test_logi_devices.py

@@ -233,6 +233,31 @@ def test_clamp_dpi_defaults_without_device(self):
         self.assertEqual(clamp_dpi(100, None), 200)
         self.assertEqual(clamp_dpi(9000, None), 8000)
 
+    def test_clamp_dpi_accepts_string_int(self):
+        """Hand-edited config files can persist DPI as a JSON string when
+        users copy values around. Coerce instead of throwing."""
+        self.assertEqual(clamp_dpi("1500", None), 1500)
+
+    def test_clamp_dpi_accepts_hex_string(self):
+        self.assertEqual(clamp_dpi("0x5DC", None), 1500)
+
+    def test_clamp_dpi_falls_back_to_min_on_garbage_string(self):
+        self.assertEqual(clamp_dpi("not-a-number", None), 200)
+
+    def test_clamp_dpi_falls_back_to_min_on_none(self):
+        self.assertEqual(clamp_dpi(None, None), 200)
+
+    def test_clamp_dpi_rejects_bool(self):
+        """``bool`` is a subclass of ``int`` -- without the explicit check
+        ``True``/``False`` would silently clamp to ``dpi_min``/``dpi_min``
+        because ``int(True) == 1`` and ``min(200, 1) == 1`` becomes 200 via
+        the floor, which masks the upstream bug."""
+        self.assertEqual(clamp_dpi(True, None), 200)
+        self.assertEqual(clamp_dpi(False, None), 200)
+
+    def test_clamp_dpi_accepts_float(self):
+        self.assertEqual(clamp_dpi(1500.7, None), 1500)
+
     def test_mx_anywhere_2s_supported_buttons_include_middle_and_hscroll(self):
         device = resolve_device(product_id=0xB01A)