fix(macos): forward back/forward mouse buttons in capture and emulation (#392)

* fix(macos): forward back/forward mouse buttons in capture and emulation

OtherMouseDown/Up events on macOS carry a button number field that
distinguishes middle (2), back (3), and forward (4) buttons. The
capture backend was unconditionally mapping all OtherMouse events to
BTN_MIDDLE, silently dropping back/forward. The emulation backend had
no match arms for BTN_BACK/BTN_FORWARD, causing them to be dropped
with a warning.

Fix capture by reading MOUSE_EVENT_BUTTON_NUMBER and mapping 3->BTN_BACK,
4->BTN_FORWARD. Fix emulation by adding match arms for BTN_BACK/BTN_FORWARD
and setting MOUSE_EVENT_BUTTON_NUMBER on the emitted CGEvent so macOS
apps receive the correct button identity.

* fix(macos): track button state and double-clicks by evdev code instead of CGMouseButton

Back, forward, and middle buttons all map to CGMouseButton::Center on
macOS, which caused them to share a single pressed-state boolean and
alias in double-click detection. Replace the ButtonState struct with a
HashSet<u32> keyed by evdev button code so each button is tracked
independently.

---------

Co-authored-by: Ferdinand Schober <ferdinandschober20@gmail.com>

.github/workflows/cachix.yml

@@ -1,40 +1,46 @@
-name: Binary Cache
+name: Nix Binary Cache
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+  workflow_dispatch:
 
-on: [push, pull_request, workflow_dispatch]
 jobs:
   nix:
     strategy:
       matrix:
-       os: 
-        - ubuntu-latest
-        - macos-15-intel
-        - macos-14
+        os:
+          - ubuntu-latest
+          - macos-15-intel
+          - macos-latest
     name: "Build"
-    runs-on: ${{ matrix.os }} 
+    runs-on: ${{ matrix.os }}
     steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-      with:
-        submodules: recursive
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
 
-    - uses: DeterminateSystems/nix-installer-action@main
-      with:
-        logger: pretty
-    - uses: DeterminateSystems/magic-nix-cache-action@main
-    - uses: cachix/cachix-action@v14
-      with:
-        name: lan-mouse
-        authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
+      # - uses: DeterminateSystems/nix-installer-action@main
+      #   with:
+      #     logger: pretty
+      # - uses: DeterminateSystems/magic-nix-cache-action@main
+      - uses: cachix/install-nix-action@v31
+      - uses: cachix/cachix-action@v16
+        with:
+          name: lan-mouse
+          authToken: "${{ secrets.CACHIX_AUTH_TOKEN }}"
 
-    - name: Build lan-mouse (x86_64-linux)
-      if: matrix.os == 'ubuntu-latest'
-      run: nix build --print-build-logs --show-trace .#packages.x86_64-linux.lan-mouse
+      - name: Build lan-mouse (x86_64-linux)
+        if: matrix.os == 'ubuntu-latest'
+        run: nix build --print-build-logs --show-trace .#packages.x86_64-linux.lan-mouse
 
-    - name: Build lan-mouse (x86_64-darwin)
-      if: matrix.os == 'macos-15-intel'
-      run: nix build --print-build-logs --show-trace .#packages.x86_64-darwin.lan-mouse
-
-    - name: Build lan-mouse (aarch64-darwin)
-      if: matrix.os == 'macos-14'
-      run: nix build --print-build-logs --show-trace .#packages.aarch64-darwin.lan-mouse
+      - name: Build lan-mouse (x86_64-darwin)
+        if: matrix.os == 'macos-15-intel'
+        run: nix build --print-build-logs --show-trace .#packages.x86_64-darwin.lan-mouse
 
+      - name: Build lan-mouse (aarch64-darwin)
+        if: matrix.os == 'macos-latest'
+        run: nix build --print-build-logs --show-trace .#packages.aarch64-darwin.lan-mouse

.github/workflows/rust.yml

@@ -76,7 +76,7 @@ jobs:
           gvsbuild build --msys-dir=C:\msys64 gtk4 libadwaita librsvg
       - name: cargo build
         if: matrix.job == 'build'
-        run: cargo check --workspace --all-targets --all-features
+        run: cargo build
 
       - name: cargo check
         if: matrix.job == 'check'

input-capture/src/macos.rs

@@ -18,7 +18,9 @@ use core_graphics::{
     event_source::{CGEventSource, CGEventSourceStateID},
 };
 use futures_core::Stream;
-use input_event::{BTN_LEFT, BTN_MIDDLE, BTN_RIGHT, Event, KeyboardEvent, PointerEvent};
+use input_event::{
+    BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT, Event, KeyboardEvent, PointerEvent,
+};
 use keycode::{KeyMap, KeyMapping};
 use libc::c_void;
 use once_cell::unsync::Lazy;
@@ -304,16 +306,28 @@ fn get_events(
             })))
         }
         CGEventType::OtherMouseDown => {
+            let btn_num = ev.get_integer_value_field(EventField::MOUSE_EVENT_BUTTON_NUMBER);
+            let button = match btn_num {
+                3 => BTN_BACK,
+                4 => BTN_FORWARD,
+                _ => BTN_MIDDLE,
+            };
             result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Button {
                 time: 0,
-                button: BTN_MIDDLE,
+                button,
                 state: 1,
             })))
         }
         CGEventType::OtherMouseUp => {
+            let btn_num = ev.get_integer_value_field(EventField::MOUSE_EVENT_BUTTON_NUMBER);
+            let button = match btn_num {
+                3 => BTN_BACK,
+                4 => BTN_FORWARD,
+                _ => BTN_MIDDLE,
+            };
             result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Button {
                 time: 0,
-                button: BTN_MIDDLE,
+                button,
                 state: 0,
             })))
         }

input-emulation/src/libei.rs

@@ -1,7 +1,8 @@
 use futures::{StreamExt, future};
 use std::{
-    io,
+    env, fs, io,
     os::{fd::OwnedFd, unix::net::UnixStream},
+    path::PathBuf,
     sync::{
         Arc, Mutex, RwLock,
         atomic::{AtomicBool, Ordering},
@@ -50,10 +51,45 @@ pub(crate) struct LibeiEmulation<'a> {
     session: Session<'a, RemoteDesktop<'a>>,
 }
 
+/// Get the path to the RemoteDesktop token file
+fn get_token_file_path() -> PathBuf {
+    let cache_dir = env::var("XDG_CACHE_HOME")
+        .ok()
+        .map(PathBuf::from)
+        .unwrap_or_else(|| {
+            let home = env::var("HOME").expect("HOME not set");
+            PathBuf::from(home).join(".cache")
+        });
+
+    cache_dir.join("lan-mouse").join("remote-desktop.token")
+}
+
+/// Read the RemoteDesktop token from file
+fn read_token() -> Option<String> {
+    let token_path = get_token_file_path();
+    match fs::read_to_string(&token_path) {
+        Ok(token) => Some(token.trim().to_string()),
+        Err(_) => None,
+    }
+}
+
+/// Write the RemoteDesktop token to file
+fn write_token(token: &str) -> io::Result<()> {
+    let token_path = get_token_file_path();
+    if let Some(parent) = token_path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+
+    fs::write(&token_path, token)?;
+    Ok(())
+}
+
 async fn get_ei_fd<'a>()
 -> Result<(RemoteDesktop<'a>, Session<'a, RemoteDesktop<'a>>, OwnedFd), ashpd::Error> {
     let remote_desktop = RemoteDesktop::new().await?;
 
+    let restore_token = read_token();
+
     log::debug!("creating session ...");
     let session = remote_desktop.create_session().await?;
 
@@ -62,13 +98,20 @@ async fn get_ei_fd<'a>()
         .select_devices(
             &session,
             DeviceType::Keyboard | DeviceType::Pointer,
-            None,
+            restore_token.as_deref(),
             PersistMode::ExplicitlyRevoked,
         )
         .await?;
 
     log::info!("requesting permission for input emulation");
-    let _devices = remote_desktop.start(&session, None).await?.response()?;
+    let start_response = remote_desktop.start(&session, None).await?.response()?;
+
+    // The restore token is only valid once, we need to re-save it each time
+    if let Some(token_str) = start_response.restore_token() {
+        if let Err(e) = write_token(token_str) {
+            log::warn!("failed to save RemoteDesktop token: {}", e);
+        }
+    }
 
     let fd = remote_desktop.connect_to_eis(&session).await?;
     Ok((remote_desktop, session, fd))

input-emulation/src/macos.rs

@@ -10,10 +10,13 @@ use core_graphics::event::{
     ScrollEventUnit,
 };
 use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
-use input_event::{BTN_LEFT, BTN_MIDDLE, BTN_RIGHT, Event, KeyboardEvent, PointerEvent, scancode};
+use input_event::{
+    BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT, Event, KeyboardEvent, PointerEvent,
+    scancode,
+};
 use keycode::{KeyMap, KeyMapping};
 use std::cell::Cell;
-use std::ops::{Index, IndexMut};
+use std::collections::HashSet;
 use std::rc::Rc;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
@@ -30,10 +33,10 @@ pub(crate) struct MacOSEmulation {
     event_source: CGEventSource,
     /// task handle for key repeats
     repeat_task: Option<JoinHandle<()>>,
-    /// current state of the mouse buttons
-    button_state: ButtonState,
-    /// button previously pressed
-    previous_button: Option<CGMouseButton>,
+    /// current state of the mouse buttons (tracked by evdev button code)
+    pressed_buttons: HashSet<u32>,
+    /// button previously pressed (evdev button code)
+    previous_button: Option<u32>,
     /// timestamp of previous click (button down)
     previous_button_click: Option<Instant>,
     /// click state, i.e. number of clicks in quick succession
@@ -44,31 +47,13 @@ pub(crate) struct MacOSEmulation {
     notify_repeat_task: Arc<Notify>,
 }
 
-struct ButtonState {
-    left: bool,
-    right: bool,
-    center: bool,
-}
-
-impl Index<CGMouseButton> for ButtonState {
-    type Output = bool;
-
-    fn index(&self, index: CGMouseButton) -> &Self::Output {
-        match index {
-            CGMouseButton::Left => &self.left,
-            CGMouseButton::Right => &self.right,
-            CGMouseButton::Center => &self.center,
-        }
-    }
-}
-
-impl IndexMut<CGMouseButton> for ButtonState {
-    fn index_mut(&mut self, index: CGMouseButton) -> &mut Self::Output {
-        match index {
-            CGMouseButton::Left => &mut self.left,
-            CGMouseButton::Right => &mut self.right,
-            CGMouseButton::Center => &mut self.center,
-        }
+/// Maps an evdev button code to the CGEventType used for drag events.
+fn drag_event_type(button: u32) -> CGEventType {
+    match button {
+        BTN_LEFT => CGEventType::LeftMouseDragged,
+        BTN_RIGHT => CGEventType::RightMouseDragged,
+        // middle, back, forward, and any other button all use OtherMouseDragged
+        _ => CGEventType::OtherMouseDragged,
     }
 }
 
@@ -78,14 +63,9 @@ impl MacOSEmulation {
     pub(crate) fn new() -> Result<Self, MacOSEmulationCreationError> {
         let event_source = CGEventSource::new(CGEventSourceStateID::CombinedSessionState)
             .map_err(|_| MacOSEmulationCreationError::EventSourceCreation)?;
-        let button_state = ButtonState {
-            left: false,
-            right: false,
-            center: false,
-        };
         Ok(Self {
             event_source,
-            button_state,
+            pressed_buttons: HashSet::new(),
             previous_button: None,
             previous_button_click: None,
             button_click_state: 0,
@@ -261,14 +241,14 @@ impl Emulation for MacOSEmulation {
                         mouse_location.x = new_mouse_x;
                         mouse_location.y = new_mouse_y;
 
-                        let mut event_type = CGEventType::MouseMoved;
-                        if self.button_state.left {
-                            event_type = CGEventType::LeftMouseDragged
-                        } else if self.button_state.right {
-                            event_type = CGEventType::RightMouseDragged
-                        } else if self.button_state.center {
-                            event_type = CGEventType::OtherMouseDragged
-                        };
+                        // If any button is held, emit a drag event for it;
+                        // otherwise emit a normal mouse-moved event.
+                        let event_type = self
+                            .pressed_buttons
+                            .iter()
+                            .next()
+                            .map(|&btn| drag_event_type(btn))
+                            .unwrap_or(CGEventType::MouseMoved);
                         let event = match CGEvent::new_mouse_event(
                             self.event_source.clone(),
                             event_type,
@@ -290,6 +270,12 @@ impl Emulation for MacOSEmulation {
                         button,
                         state,
                     } => {
+                        // button number for OtherMouse events (3 = back, 4 = forward, etc.)
+                        let cg_button_number: Option<i64> = match button {
+                            BTN_BACK => Some(3),
+                            BTN_FORWARD => Some(4),
+                            _ => None,
+                        };
                         let (event_type, mouse_button) = match (button, state) {
                             (BTN_LEFT, 1) => (CGEventType::LeftMouseDown, CGMouseButton::Left),
                             (BTN_LEFT, 0) => (CGEventType::LeftMouseUp, CGMouseButton::Left),
@@ -297,17 +283,29 @@ impl Emulation for MacOSEmulation {
                             (BTN_RIGHT, 0) => (CGEventType::RightMouseUp, CGMouseButton::Right),
                             (BTN_MIDDLE, 1) => (CGEventType::OtherMouseDown, CGMouseButton::Center),
                             (BTN_MIDDLE, 0) => (CGEventType::OtherMouseUp, CGMouseButton::Center),
+                            (BTN_BACK, 1) | (BTN_FORWARD, 1) => {
+                                (CGEventType::OtherMouseDown, CGMouseButton::Center)
+                            }
+                            (BTN_BACK, 0) | (BTN_FORWARD, 0) => {
+                                (CGEventType::OtherMouseUp, CGMouseButton::Center)
+                            }
                             _ => {
                                 log::warn!("invalid button event: {button},{state}");
                                 return Ok(());
                             }
                         };
-                        // store button state
-                        self.button_state[mouse_button] = state == 1;
-
-                        // update previous button state
+                        // store button state using the evdev button code so
+                        // back, forward, and middle are tracked independently
                         if state == 1 {
-                            if self.previous_button.is_some_and(|b| b.eq(&mouse_button))
+                            self.pressed_buttons.insert(button);
+                        } else {
+                            self.pressed_buttons.remove(&button);
+                        }
+
+                        // update double-click tracking using the evdev button
+                        // code so that back/forward don't alias with middle
+                        if state == 1 {
+                            if self.previous_button == Some(button)
                                 && self
                                     .previous_button_click
                                     .is_some_and(|i| i.elapsed() < DOUBLE_CLICK_INTERVAL)
@@ -316,7 +314,7 @@ impl Emulation for MacOSEmulation {
                             } else {
                                 self.button_click_state = 1;
                             }
-                            self.previous_button = Some(mouse_button);
+                            self.previous_button = Some(button);
                             self.previous_button_click = Some(Instant::now());
                         }
 
@@ -338,6 +336,13 @@ impl Emulation for MacOSEmulation {
                             EventField::MOUSE_EVENT_CLICK_STATE,
                             self.button_click_state,
                         );
+                        // Set the button number for extra buttons (back=3, forward=4)
+                        if let Some(btn_num) = cg_button_number {
+                            event.set_integer_value_field(
+                                EventField::MOUSE_EVENT_BUTTON_NUMBER,
+                                btn_num,
+                            );
+                        }
                         event.post(CGEventTapLocation::HID);
                     }
                     PointerEvent::Axis {
@@ -416,7 +421,10 @@ impl Emulation for MacOSEmulation {
                             return Ok(());
                         }
                     };
-                    update_modifiers(&self.modifier_state, key, state);
+                    let is_modifier = update_modifiers(&self.modifier_state, key, state);
+                    if is_modifier {
+                        modifier_event(self.event_source.clone(), self.modifier_state.get());
+                    }
                     match state {
                         // pressed
                         1 => self.spawn_repeat_task(code).await,
@@ -445,21 +453,6 @@ impl Emulation for MacOSEmulation {
     async fn terminate(&mut self) {}
 }
 
-trait ButtonEq {
-    fn eq(&self, other: &Self) -> bool;
-}
-
-impl ButtonEq for CGMouseButton {
-    fn eq(&self, other: &Self) -> bool {
-        matches!(
-            (self, other),
-            (CGMouseButton::Left, CGMouseButton::Left)
-                | (CGMouseButton::Right, CGMouseButton::Right)
-                | (CGMouseButton::Center, CGMouseButton::Center)
-        )
-    }
-}
-
 fn update_modifiers(modifiers: &Cell<XMods>, key: u32, state: u8) -> bool {
     if let Ok(key) = scancode::Linux::try_from(key) {
         let mask = match key {