Add BLE reconnect detection, code review cleanup

IOHIDManager watcher detects Logitech HID device arrival/removal
via CFRunLoop, triggering reconnect to re-divert buttons after BLE
drops. Keepalive checks diversion state every 5 minutes as a safety
net for silent BLE reconnects where the HID handle stays valid but
firmware state resets.

Code review fixes:
- Extract connect_device(), execute_and_notify(), format_hex(),
  classify_error(), action_description() to eliminate duplication
- ActionOutcome enum replaces ambiguous bool return from execute()
- Move SAMPLE_CONFIG to config.rs, add ACCESSIBILITY_ERROR const
- Fix run_listen_only with proper backoff and error deduplication
- Deduplicate FFI declarations in platform.rs, fix c-string literals
- Collapse permission error handling in main.rs
- Fix service.rs plist label to match bundle ID (com.jlevere.hidpp)
- Fix RESPONSE_TIMEOUT_MS type from i32 to u64

Author: jlevere

crates/hidpp-daemon/src/action.rs

@@ -5,6 +5,17 @@ use tracing::{error, info, warn};
 
 use crate::config::{Action, ExplicitAction};
 
+/// Outcome of executing an action.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ActionOutcome {
+    /// Action executed successfully.
+    Executed,
+    /// Accessibility permission not granted — caller should show error.
+    PermissionDenied,
+    /// Action failed (bad keystroke, key error, etc.) — already logged.
+    Failed,
+}
+
 /// Global enigo instance. Initialized lazily on first use.
 static ENIGO: Mutex<Option<Enigo>> = Mutex::new(None);
 
@@ -51,56 +62,56 @@ pub fn retry_init() {
 }
 
 /// Execute an action. Initializes enigo lazily if needed.
-/// Returns false if Accessibility permission is missing.
-pub fn execute(action: &Action) -> bool {
+pub fn execute(action: &Action) -> ActionOutcome {
     match action {
         Action::Keystroke(keys) => execute_keystroke(keys),
         Action::Explicit(ExplicitAction::Keystroke { keys }) => execute_keystroke(keys),
         Action::Explicit(ExplicitAction::Command { run }) => {
             execute_command(run);
-            true
+            ActionOutcome::Executed
         }
     }
 }
 
 /// Parse and execute a keystroke string like "ctrl+shift+left".
-/// Returns false if Accessibility permission is missing.
-fn execute_keystroke(keystroke: &str) -> bool {
+fn execute_keystroke(keystroke: &str) -> ActionOutcome {
     let parts: Vec<&str> = keystroke.split('+').map(str::trim).collect();
     if parts.is_empty() {
-        return true;
+        return ActionOutcome::Failed;
     }
 
     let (modifier_strs, main_str) = parts.split_at(parts.len() - 1);
     let modifiers: Vec<Key> = modifier_strs.iter().filter_map(|s| parse_key(s)).collect();
 
     let Some(main_key) = main_str.first().and_then(|s| parse_key(s)) else {
         error!("unknown key in keystroke: {keystroke}");
-        return true;
+        return ActionOutcome::Failed;
     };
 
     if !ensure_init() {
-        error!(
-            "grant Accessibility permission: System Settings → Privacy & Security → Accessibility"
-        );
-        return false;
+        return ActionOutcome::PermissionDenied;
     }
 
     let mut guard = ENIGO.lock().unwrap();
     let Some(enigo) = guard.as_mut() else {
-        return true;
+        return ActionOutcome::Failed;
     };
 
     // Press modifiers, click main key, release modifiers in reverse.
     for m in &modifiers {
         if let Err(e) = enigo.key(*m, Direction::Press) {
             error!("key press failed: {e}");
-            return true;
+            return ActionOutcome::Failed;
         }
     }
 
     if let Err(e) = enigo.key(main_key, Direction::Click) {
         error!("key click failed: {e}");
+        // Still release pressed modifiers before returning.
+        for m in modifiers.iter().rev() {
+            let _ = enigo.key(*m, Direction::Release);
+        }
+        return ActionOutcome::Failed;
     }
 
     for m in modifiers.iter().rev() {
@@ -109,14 +120,11 @@ fn execute_keystroke(keystroke: &str) -> bool {
         }
     }
 
-    info!("keystroke: {keystroke}");
-    true
+    ActionOutcome::Executed
 }
 
 /// Run a shell command in the background. Reaps the child on a separate thread.
 fn execute_command(cmd: &str) {
-    info!("command: {cmd}");
-
     #[cfg(unix)]
     let result = std::process::Command::new("sh").args(["-c", cmd]).spawn();
 

crates/hidpp-daemon/src/config.rs

@@ -3,6 +3,49 @@ use std::path::{Path, PathBuf};
 
 use serde::Deserialize;
 
+pub const SAMPLE_CONFIG: &str = r#"# hidppd config — maps diverted buttons and gestures to actions.
+#
+# Button CIDs for MX Master 3S:
+#   82  = Middle Click
+#   83  = Back
+#   86  = Forward
+#   195 = Gesture Button (thumb)
+#   196 = Mode Shift (scroll wheel click)
+#
+# Keystroke format: "modifier+modifier+key"
+#   Modifiers: ctrl, alt, shift, cmd (or meta/super/win)
+#   Keys: a-z, 0-9, f1-f20, left/right/up/down, tab, return,
+#         space, escape, home, end, pageup, pagedown, delete,
+#         playpause, next, prev, volumeup, volumedown, mute
+#
+# Simple button → keystroke:
+#   [buttons]
+#   83 = "alt+left"          # Back button → browser back
+#   86 = "alt+right"         # Forward → browser forward
+#
+# Gesture button — hold + swipe for directional actions:
+#   [gestures.195]
+#   up = "ctrl+up"           # Swipe up → Mission Control
+#   down = "ctrl+down"       # Swipe down → App Exposé
+#   left = "ctrl+left"       # Swipe left → prev desktop
+#   right = "ctrl+right"     # Swipe right → next desktop
+#   tap = "playpause"        # Quick tap → play/pause
+#   threshold = 50           # Min displacement (default: 50)
+#
+# Command actions:
+#   83 = { type = "command", run = "open -a Safari" }
+
+[buttons]
+83 = "alt+left"
+86 = "alt+right"
+
+[gestures.195]
+up = "ctrl+up"
+down = "ctrl+down"
+left = "ctrl+left"
+right = "ctrl+right"
+"#;
+
 /// Raw config as deserialized from TOML (string keys).
 #[derive(Debug, Deserialize, Default)]
 struct RawConfig {