guard by feature flag

* chore: developer experience - pre-commit hook, ai instructions, yaml formatting for prettier

* no prettierrc, editorconfig instead

* fixes from copilot suggestions

---------

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

.editorconfig

@@ -0,0 +1,24 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+charset = utf-8
+
+[*.rs]
+indent_style = space
+indent_size = 4
+max_line_length = 100
+
+[*.{yml,yaml}]
+indent_style = space
+indent_size = 2
+
+[*.toml]
+indent_style = space
+indent_size = 4
+
+[*.nix]
+indent_style = space
+indent_size = 2

.githooks/pre-commit

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Ensure we're at the repo root
+cd "$(git rev-parse --show-toplevel)" || exit 1
+
+echo "Running cargo fmt (auto-format)..."
+# Run formatter to apply fixes but do not stage them. If formatting changed,
+# fail the commit so the user can review and stage the changes manually.
+cargo fmt --all
+if ! git diff --quiet --exit-code; then
+  echo "" >&2
+  echo "ERROR: cargo fmt modified files. Review changes, stage them, and commit again." >&2
+  git --no-pager diff --name-only
+  exit 1
+fi
+
+echo "Running cargo clippy..."
+# Matches CI: deny warnings to keep code health strict
+if ! cargo clippy --workspace --all-targets --all-features -- -D warnings; then
+  echo "" >&2
+  echo "ERROR: clippy found warnings/errors. Fix them before committing." >&2
+  exit 1
+fi
+
+echo "Running cargo test..."
+if ! cargo test --workspace --all-features; then
+  echo "" >&2
+  echo "ERROR: Some tests failed. Fix tests before committing." >&2
+  exit 1
+fi
+
+echo "All pre-commit checks passed."
+exit 0

.github/workflows/cachix.yml

@@ -1,6 +1,16 @@
-name: Binary Cache
+name: Nix Binary Cache
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
 
-on: [push, pull_request, workflow_dispatch]
 jobs:
   nix:
     strategy:
@@ -8,23 +18,24 @@ jobs:
         os:
           - ubuntu-latest
           - macos-15-intel
-        - macos-14
+          - macos-latest
     name: "Build"
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout
-      uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           submodules: recursive
 
-    - uses: DeterminateSystems/nix-installer-action@main
+      # - uses: DeterminateSystems/nix-installer-action@main
-      with:
+      #   with:
-        logger: pretty
+      #     logger: pretty
-    - uses: DeterminateSystems/magic-nix-cache-action@main
+      # - uses: DeterminateSystems/magic-nix-cache-action@main
-    - uses: cachix/cachix-action@v14
+      - uses: cachix/install-nix-action@v31
+      - uses: cachix/cachix-action@v16
         with:
           name: lan-mouse
-        authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
+          authToken: "${{ secrets.CACHIX_AUTH_TOKEN }}"
 
       - name: Build lan-mouse (x86_64-linux)
         if: matrix.os == 'ubuntu-latest'
@@ -35,6 +46,5 @@ jobs:
         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'
+        if: matrix.os == 'macos-latest'
         run: nix build --print-build-logs --show-trace .#packages.aarch64-darwin.lan-mouse
-

.github/workflows/release.yml

@@ -1,31 +1,59 @@
-name: "pre-release"
+name: "Release"
+run-name: "Release - ${{ startsWith(github.ref, 'refs/tags/') && github.ref_name || github.event.inputs.name || github.ref_name }}"
 
 on:
   push:
     branches: [ "main" ]
-
+    tags:
-
+      - v**
+  workflow_dispatch:
+    inputs:
+      name:
+        description: 'Development release name'
+        required: false
+        default: ''
 
 env:
   CARGO_TERM_COLOR: always
 
 jobs:
   linux-release-build:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: install dependencies
       run: |
         sudo apt-get update
         sudo apt-get install libx11-dev libxtst-dev
         sudo apt-get install libadwaita-1-dev libgtk-4-dev
     - name: Release Build
-      run: cargo build --release
+      run: |
+        cargo build --release
+        cp target/release/lan-mouse lan-mouse-linux-x86_64
     - name: Upload build artifact
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v6
       with:
-        name: lan-mouse-linux
+        name: lan-mouse-linux-x86_64
-        path: target/release/lan-mouse
+        path: lan-mouse-linux-x86_64
+
+  linux-arm64-release-build:
+    runs-on: ubuntu-22.04-arm
+    steps:
+    - uses: actions/checkout@v6
+    - name: install dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install libx11-dev libxtst-dev
+        sudo apt-get install libadwaita-1-dev libgtk-4-dev
+    - name: Release Build
+      run: |
+        cargo build --release
+        cp target/release/lan-mouse lan-mouse-linux-arm64
+    - name: Upload build artifact
+      uses: actions/upload-artifact@v6
+      with:
+        name: lan-mouse-linux-arm64
+        path: lan-mouse-linux-arm64
 
   windows-release-build:
     runs-on: windows-latest
@@ -64,7 +92,7 @@ jobs:
         gvsbuild build --msys-dir=C:\msys64 gtk4 libadwaita librsvg
         Move-Item "C:\Program Files\Git\usr\notbin" "C:\Program Files\Git\usr\bin"
         Move-Item "C:\Program Files\Git\notbin" "C:\Program Files\Git\bin"
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Release Build
       run: cargo build --release
     - name: Create Archive
@@ -72,19 +100,21 @@ jobs:
         mkdir "lan-mouse-windows"
         Get-Childitem -Path "C:\\gtk-build\\gtk\\x64\\release\\bin\\*.dll" -File -Recurse | Copy-Item -Destination "lan-mouse-windows"
         Copy-Item -Path "target\release\lan-mouse.exe" -Destination "lan-mouse-windows"
-        Compress-Archive -Path "lan-mouse-windows\*" -DestinationPath lan-mouse-windows.zip
+        Compress-Archive -Path "lan-mouse-windows\*" -DestinationPath lan-mouse-windows-x86_64.zip
     - name: Upload build artifact
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v6
       with:
-        name: lan-mouse-windows
+        name: lan-mouse-windows-x86_64
-        path: lan-mouse-windows.zip
+        path: lan-mouse-windows-x86_64.zip
 
   macos-release-build:
     runs-on: macos-15-intel
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: install dependencies
-      run: brew install gtk4 libadwaita imagemagick
+      run: |
+        brew install --cask inkscape
+        brew install gtk4 libadwaita imagemagick librsvg
     - name: Release Build
       run: |
         cargo build --release
@@ -102,21 +132,23 @@ jobs:
         cd target/release/bundle/osx
         zip -r "lan-mouse-macos-intel.zip" "Lan Mouse.app"
     - name: Upload build artifact
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v6
       with:
         name: lan-mouse-macos-intel
         path: target/release/bundle/osx/lan-mouse-macos-intel.zip
 
-  macos-aarch64-release-build:
+  macos-arm64-release-build:
-    runs-on: macos-14
+    runs-on: macos-15
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: install dependencies
-      run: brew install gtk4 libadwaita imagemagick
+      run: |
+        brew install --cask inkscape
+        brew install gtk4 libadwaita imagemagick librsvg
     - name: Release Build
       run: |
         cargo build --release
-        cp target/release/lan-mouse lan-mouse-macos-aarch64
+        cp target/release/lan-mouse lan-mouse-macos-arm64
     - name: Make icns
       run: scripts/makeicns.sh
     - name: Install cargo bundle
@@ -128,29 +160,45 @@ jobs:
     - name: Zip bundle
       run: |
         cd target/release/bundle/osx
-        zip -r "lan-mouse-macos-aarch64.zip" "Lan Mouse.app"
+        zip -r "lan-mouse-macos-arm64.zip" "Lan Mouse.app"
     - name: Upload build artifact
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v6
       with:
-        name: lan-mouse-macos-aarch64
+        name: lan-mouse-macos-arm64
-        path: target/release/bundle/osx/lan-mouse-macos-aarch64.zip
+        path: target/release/bundle/osx/lan-mouse-macos-arm64.zip
 
-  pre-release:
+  release:
-    name: "Pre Release"
+    name: "Release"
-    needs: [windows-release-build, linux-release-build, macos-release-build, macos-aarch64-release-build]
+    needs: [windows-release-build, linux-release-build, linux-arm64-release-build, macos-release-build, macos-arm64-release-build]
     runs-on: "ubuntu-latest"
     steps:
     - name: Download build artifacts
       uses: actions/download-artifact@v4
-    - name: Create Release
+    - name: Create Pre-Release
-      uses: "marvinpinto/action-automatic-releases@latest"
+      if: ${{ !startsWith(github.ref, 'refs/tags/') }}
+      uses: softprops/action-gh-release@v2
       with:
-        repo_token: "${{ secrets.GITHUB_TOKEN }}"
+        token: ${{ secrets.GITHUB_TOKEN }}
-        automatic_release_tag: "latest"
+        tag_name: ${{ github.event.inputs.name || github.ref_name }}
+        name: ${{ github.event.inputs.name || github.ref_name }}
         prerelease: true
-        title: "Development Build"
+        generate_release_notes: true
         files: |
-          lan-mouse-linux/lan-mouse
+          lan-mouse-linux-x86_64/lan-mouse-linux-x86_64
+          lan-mouse-linux-arm64/lan-mouse-linux-arm64
           lan-mouse-macos-intel/lan-mouse-macos-intel.zip
-          lan-mouse-macos-aarch64/lan-mouse-macos-aarch64.zip
+          lan-mouse-macos-arm64/lan-mouse-macos-arm64.zip
-          lan-mouse-windows/lan-mouse-windows.zip
+          lan-mouse-windows-x86_64/lan-mouse-windows-x86_64.zip
+    - name: Create Tagged Release
+      if: startsWith(github.ref, 'refs/tags/')
+      uses: softprops/action-gh-release@v2
+      with:
+        token: ${{ secrets.GITHUB_TOKEN }}
+        name: ${{ github.ref_name }}
+        generate_release_notes: true
+        files: |
+          lan-mouse-linux-x86_64/lan-mouse-linux-x86_64
+          lan-mouse-linux-arm64/lan-mouse-linux-arm64
+          lan-mouse-macos-intel/lan-mouse-macos-intel.zip
+          lan-mouse-macos-arm64/lan-mouse-macos-arm64.zip
+          lan-mouse-windows-x86_64/lan-mouse-windows-x86_64.zip

.github/workflows/rust.yml

@@ -9,59 +9,67 @@ on:
 env:
   CARGO_TERM_COLOR: always
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
 jobs:
-  build-linux:
+  fmt:
-
+    name: Formatting
     runs-on: ubuntu-latest
-
     steps:
-    - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
-    - name: install dependencies
+      - name: cargo fmt
+        run: cargo fmt --check
+
+  ci:
+    name: ${{ matrix.job }} ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+          - ubuntu-latest
+          - windows-latest
+          - macos-latest
+          - macos-15-intel
+        job:
+          - build
+          - check
+          - clippy
+          - test
+    steps:
+      - uses: actions/checkout@v6
+      - uses: Swatinem/rust-cache@v2
+      - name: Install Linux deps
+        if: runner.os == 'Linux'
         run: |
           sudo apt-get update
-        sudo apt-get install libx11-dev libxtst-dev
+          sudo apt-get install libx11-dev libxtst-dev libadwaita-1-dev libgtk-4-dev
-        sudo apt-get install libadwaita-1-dev libgtk-4-dev
+      - name: Install macOS dependencies
-    - name: Build
+        if: runner.os == 'macOS'
-      run: cargo build --verbose
+        run: brew install gtk4 libadwaita imagemagick
-    - name: Run tests
+      - name: Install Windows Dependencies - create gtk dir
-      run: cargo test --verbose
+        if: runner.os == 'Windows'
-    - name: Check Formatting
-      run: cargo fmt --check
-    - name: Clippy
-      run: cargo clippy --all-features --all-targets -- --deny warnings
-    - name: Upload build artifact
-      uses: actions/upload-artifact@v4
-      with:
-        name: lan-mouse
-        path: target/debug/lan-mouse
-
-  build-windows:
-
-    runs-on: windows-latest
-
-    steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-python@v5
-      with:
-        python-version: '3.11'
-    # needed for cache restore
-    - name: create gtk dir
         run: mkdir C:\gtk-build\gtk\x64\release
-    - uses: actions/cache@v3
+      - name: Install Windows Dependencies - install gtk from cache
+        uses: actions/cache@v3
+        if: runner.os == 'Windows'
         id: cache
         with:
           path: c:/gtk-build/gtk/x64/release/**
           key: gtk-windows-build
           restore-keys: gtk-windows-build
-    - name: Update path
+      - name: Install Windows Dependencies - update PATH
+        if: runner.os == 'Windows'
         run: |
           echo "PKG_CONFIG=C:\gtk-build\gtk\x64\release\bin\pkgconf.exe" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
           echo "C:\pkg-config-lite-0.28-1\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
           echo "C:\gtk-build\gtk\x64\release\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
           echo $env:GITHUB_PATH
           echo $env:PATH
-    - name: Install dependencies
+      - name: Install Windows dependencies - build gtk
-      if: steps.cache.outputs.cache-hit != 'true'
+        if: runner.os == 'Windows' && steps.cache.outputs.cache-hit != 'true'
         run: |
           # choco install msys2
           # choco install visualstudio2022-workload-vctools
@@ -69,90 +77,24 @@ jobs:
           py -m venv .venv
           .venv\Scripts\activate.ps1
           py -m pip install gvsbuild
-        # see https://github.com/wingtk/gvsbuild/pull/1004
-        Move-Item "C:\Program Files\Git\usr\bin" "C:\Program Files\Git\usr\notbin"
-        Move-Item "C:\Program Files\Git\bin" "C:\Program Files\Git\notbin"
           gvsbuild build --msys-dir=C:\msys64 gtk4 libadwaita librsvg
-        Move-Item "C:\Program Files\Git\usr\notbin" "C:\Program Files\Git\usr\bin"
+      - name: cargo build
-        Move-Item "C:\Program Files\Git\notbin" "C:\Program Files\Git\bin"
+        if: matrix.job == 'build'
-    - name: Build
+        run: cargo build
-      run: cargo build --verbose
-    - name: Run tests
-      run: cargo test --verbose
-    - name: Check Formatting
-      run: cargo fmt --check
-    - name: Clippy
-      run: cargo clippy --all-features --all-targets -- --deny warnings
-    - name: Copy Gtk Dlls
-      run: Get-Childitem -Path "C:\\gtk-build\\gtk\\x64\\release\\bin\\*.dll" -File -Recurse | Copy-Item -Destination "target\\debug"
-    - name: Upload build artifact
-      uses: actions/upload-artifact@v4
-      with:
-        name: lan-mouse-windows
-        path: |
-          target/debug/lan-mouse.exe
-          target/debug/*.dll
 
-  build-macos:
+      - name: cargo check
-    runs-on: macos-15-intel
+        if: matrix.job == 'check'
-    steps:
+        run: cargo check --workspace --all-targets --all-features
-    - uses: actions/checkout@v4
-    - name: install dependencies
-      run: brew install gtk4 libadwaita imagemagick
-    - name: Build
-      run: cargo build --verbose
-    - name: Run tests
-      run: cargo test --verbose
-    - name: Check Formatting
-      run: cargo fmt --check
-    - name: Clippy
-      run: cargo clippy --all-features --all-targets -- --deny warnings
-    - name: Make icns
-      run: scripts/makeicns.sh
-    - name: Install cargo bundle
-      run: cargo install cargo-bundle
-    - name: Bundle
-      run: |
-        cargo bundle
-        scripts/copy-macos-dylib.sh
-    - name: Zip bundle
-      run: |
-        cd target/debug/bundle/osx
-        zip -r "Lan Mouse macOS (Intel).zip" "Lan Mouse.app"
-    - name: Upload build artifact
-      uses: actions/upload-artifact@v4
-      with:
-        name: Lan Mouse macOS (Intel)
-        path: target/debug/bundle/osx/Lan Mouse macOS (Intel).zip
 
-  build-macos-aarch64:
+      - name: cargo test
-    runs-on: macos-14
+        if: matrix.job == 'test'
-    steps:
+        run: cargo test --workspace --all-features
-    - uses: actions/checkout@v4
+
-    - name: install dependencies
+      - name: cargo clippy
-      run: brew install gtk4 libadwaita imagemagick
+        if: matrix.job == 'clippy'
-    - name: Build
+        run: cargo clippy --workspace --all-targets --all-features -- -D warnings
-      run: cargo build --verbose
+
-    - name: Run tests
+      - uses: clechasseur/rs-clippy-check@v4
-      run: cargo test --verbose
+        if: matrix.job == 'clippy'
-    - name: Check Formatting
-      run: cargo fmt --check
-    - name: Clippy
-      run: cargo clippy --all-features --all-targets -- --deny warnings
-    - name: Make icns
-      run: scripts/makeicns.sh
-    - name: Install cargo bundle
-      run: cargo install cargo-bundle
-    - name: Bundle
-      run: |
-        cargo bundle
-        scripts/copy-macos-dylib.sh
-    - name: Zip bundle
-      run: |
-        cd target/debug/bundle/osx
-        zip -r "Lan Mouse macOS (ARM).zip" "Lan Mouse.app"
-    - name: Upload build artifact
-      uses: actions/upload-artifact@v4
         with:
-        name: Lan Mouse macOS (ARM)
+          args: --workspace --all-targets --all-features
-        path: target/debug/bundle/osx/Lan Mouse macOS (ARM).zip

.github/workflows/tagged-release.yml

@@ -1,150 +0,0 @@
-name: "Tagged Release"
-
-on:
-  push:
-    tags:
-      - v**
-
-jobs:
-  linux-release-build:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - name: install dependencies
-      run: |
-        sudo apt-get update
-        sudo apt-get install libx11-dev libxtst-dev
-        sudo apt-get install libadwaita-1-dev libgtk-4-dev
-    - name: Release Build
-      run: cargo build --release
-    - name: Upload build artifact
-      uses: actions/upload-artifact@v4
-      with:
-        name: lan-mouse-linux
-        path: target/release/lan-mouse
-
-  windows-release-build:
-    runs-on: windows-latest
-    steps:
-    - uses: actions/setup-python@v5
-      with:
-        python-version: '3.11'
-    # needed for cache restore
-    - name: create gtk dir
-      run: mkdir C:\gtk-build\gtk\x64\release
-    - uses: actions/cache@v3
-      id: cache
-      with:
-        path: c:/gtk-build/gtk/x64/release/**
-        key: gtk-windows-build
-        restore-keys: gtk-windows-build
-    - name: Update path
-      run: |
-        echo "PKG_CONFIG=C:\gtk-build\gtk\x64\release\bin\pkgconf.exe" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
-        echo "C:\pkg-config-lite-0.28-1\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-        echo "C:\gtk-build\gtk\x64\release\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-        echo $env:GITHUB_PATH
-        echo $env:PATH
-    - name: Install dependencies
-      if: steps.cache.outputs.cache-hit != 'true'
-      run: |
-        # choco install msys2
-        # choco install visualstudio2022-workload-vctools
-        # choco install pkgconfiglite
-        py -m venv .venv
-        .venv\Scripts\activate.ps1
-        py -m pip install gvsbuild
-        # see https://github.com/wingtk/gvsbuild/pull/1004
-        Move-Item "C:\Program Files\Git\usr\bin" "C:\Program Files\Git\usr\notbin"
-        Move-Item "C:\Program Files\Git\bin" "C:\Program Files\Git\notbin"
-        gvsbuild build --msys-dir=C:\msys64 gtk4 libadwaita librsvg
-        Move-Item "C:\Program Files\Git\usr\notbin" "C:\Program Files\Git\usr\bin"
-        Move-Item "C:\Program Files\Git\notbin" "C:\Program Files\Git\bin"
-    - uses: actions/checkout@v4
-    - name: Release Build
-      run: cargo build --release
-    - name: Create Archive
-      run: |
-        mkdir "lan-mouse-windows"
-        Get-Childitem -Path "C:\\gtk-build\\gtk\\x64\\release\\bin\\*.dll" -File -Recurse | Copy-Item -Destination "lan-mouse-windows"
-        Copy-Item -Path "target\release\lan-mouse.exe" -Destination "lan-mouse-windows"
-        Compress-Archive -Path "lan-mouse-windows\*" -DestinationPath lan-mouse-windows.zip
-    - name: Upload build artifact
-      uses: actions/upload-artifact@v4
-      with:
-        name: lan-mouse-windows
-        path: lan-mouse-windows.zip
-
-  macos-release-build:
-    runs-on: macos-15-intel
-    steps:
-    - uses: actions/checkout@v4
-    - name: install dependencies
-      run: brew install gtk4 libadwaita imagemagick
-    - name: Release Build
-      run: |
-        cargo build --release
-        cp target/release/lan-mouse lan-mouse-macos-intel
-    - name: Make icns
-      run: scripts/makeicns.sh
-    - name: Install cargo bundle
-      run: cargo install cargo-bundle
-    - name: Bundle
-      run: |
-        cargo bundle --release
-        scripts/copy-macos-dylib.sh "target/release/bundle/osx/Lan Mouse.app/Contents/MacOS/lan-mouse"
-    - name: Zip bundle
-      run: |
-        cd target/release/bundle/osx
-        zip -r "lan-mouse-macos-intel.zip" "Lan Mouse.app"
-    - name: Upload build artifact
-      uses: actions/upload-artifact@v4
-      with:
-        name: lan-mouse-macos-intel.zip
-        path: target/release/bundle/osx/lan-mouse-macos-intel.zip
-
-  macos-aarch64-release-build:
-    runs-on: macos-14
-    steps:
-    - uses: actions/checkout@v4
-    - name: install dependencies
-      run: brew install gtk4 libadwaita imagemagick
-    - name: Release Build
-      run: |
-        cargo build --release
-        cp target/release/lan-mouse lan-mouse-macos-aarch64
-    - name: Make icns
-      run: scripts/makeicns.sh
-    - name: Install cargo bundle
-      run: cargo install cargo-bundle
-    - name: Bundle
-      run: |
-        cargo bundle --release
-        scripts/copy-macos-dylib.sh "target/release/bundle/osx/Lan Mouse.app/Contents/MacOS/lan-mouse"
-    - name: Zip bundle
-      run: |
-        cd target/release/bundle/osx
-        zip -r "lan-mouse-macos-aarch64.zip" "Lan Mouse.app"
-    - name: Upload build artifact
-      uses: actions/upload-artifact@v4
-      with:
-        name: lan-mouse-macos-aarch64.zip
-        path: target/release/bundle/osx/lan-mouse-macos-aarch64.zip
-
-  tagged-release:
-    name: "Tagged Release"
-    needs: [windows-release-build, linux-release-build, macos-release-build, macos-aarch64-release-build]
-    runs-on: "ubuntu-latest"
-    steps:
-    - name: Download build artifacts
-      uses: actions/download-artifact@v4
-    - name: Create Release
-      uses: "marvinpinto/action-automatic-releases@latest"
-      with:
-        repo_token: "${{ secrets.GITHUB_TOKEN }}"
-        prerelease: false
-        files: |
-          lan-mouse-linux/lan-mouse
-          lan-mouse-macos-intel/lan-mouse-macos-intel.zip
-          lan-mouse-macos-aarch64/lan-mouse-macos-aarch64.zip
-          lan-mouse-windows/lan-mouse-windows.zip

AGENTS.md

@@ -0,0 +1,65 @@
+# Lan Mouse Agent Instructions
+
+## Overview
+
+Lan Mouse is an open-source Software KVM sharing mouse/keyboard input across local networks. The Rust workspace combines a GTK frontend, CLI/daemon mode, and multi-OS capture/emulation backends for Linux, Windows, and macOS.
+
+## Core principles
+
+- **Scope discipline.** Only implement what was requested; describe follow-up work instead of absorbing it.
+- **Clarify OS behavior.** Ask when requirements touch OS-specific capture/emulation (they differ significantly).
+- **Docs stay current.** Update [README.md](README.md) or [DOC.md](DOC.md) when touching public APIs or platform support.
+- **Rust idioms.** Use `Result`/`Option`, `thiserror` for errors, descriptive logs, and concise comments for non-obvious invariants.
+
+## Terminology
+
+- **Client:** A remote machine that can receive or send input events. Each client is either _active_ (receiving events) or _inactive_ (can send events back). This mutual exclusion prevents feedback loops.
+- **Backend:** OS-specific implementation for capture or emulation (e.g., libei, layer-shell, wlroots, X11, Windows, macOS).
+- **Handle:** A per-client identifier used to route events and track state (pressed keys, position).
+
+## Architecture
+
+**Pipeline:** `input-capture` → `lan-mouse-ipc` → `input-emulation`
+
+- **input-capture:** Reads OS events into a `Stream<CaptureEvent>`. Backends tried in priority order (libei → layer-shell → X11 → fallback). Tracks `pressed_keys` to avoid stuck modifiers. `position_map` queues events when multiple clients share a screen edge.
+- **input-emulation:** Replays events via the `Emulation` trait (`consume`, `create`, `destroy`, `terminate`). Maintains `pressed_keys` and releases them on disconnect.
+- **lan-mouse-ipc / lan-mouse-proto:** Protocol glue and serialization. Events are UDP; connection requests are TCP on the same port. Version bumps required when serialization changes.
+- **input-event:** Shared scancode enums and abstract event types—extend here, don't duplicate translations.
+
+## Feature & cfg discipline
+
+- Feature flags live in root `Cargo.toml`. Gate OS-specific modules with tight cfgs (e.g., `cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))`).
+- Prefer module-level gating over per-function cfgs to avoid empty stubs.
+- New backends: add feature in `Cargo.toml`, create gated module, log backend selection.
+
+## Async patterns
+
+- Tokio runtime with `futures` streams and `async_trait`. Model new flows as streams or async methods.
+- Avoid blocking; use `spawn_blocking` if needed. Prefer existing single-threaded stream handling.
+- `InputCapture` implements `Stream` and manually pumps backends—don't short-circuit this logic.
+
+## Commands
+
+```sh
+cargo build --workspace                                    # full build
+cargo build -p <crate>                                     # single crate
+cargo test --workspace                                     # all tests
+cargo fmt && cargo clippy --workspace --all-targets --all-features  # lint
+RUST_LOG=lan_mouse=debug cargo run                         # debug logging
+```
+
+Run from repo root—no `cd` in scripts.
+
+## Testing
+
+- Unit tests for utilities; integration tests for protocol behavior.
+- OS-specific backends: test via GTK/CLI on target OS or document manual verification.
+- Dummy backend exercises pipeline without real dependencies.
+- Verify `terminate()` releases keys on unexpected disconnect.
+
+## Workflow
+
+1. Clarify ambiguous requirements, especially OS-specific behavior.
+2. Implement minimal change; flag follow-up work.
+3. Add proportional tests; run `cargo test` on affected crates.
+4. Run `cargo fmt` and `cargo clippy --workspace --all-targets --all-features`.

Cargo.toml

@@ -38,6 +38,7 @@ shadow-rs = { version = "1.2.0", features = ["metadata"] }
 
 hickory-resolver = "0.25.2"
 toml = "0.8"
+toml_edit = { version = "0.22", features = ["serde"] }
 serde = { version = "1.0", features = ["derive"] }
 log = "0.4.20"
 env_logger = "0.11.3"

README.md

@@ -1,4 +1,9 @@
 # Lan Mouse
+
+[![CI](https://github.com/feschber/lan-mouse/actions/workflows/rust.yml/badge.svg)](https://github.com/feschber/lan-mouse/actions/workflows/rust.yml) [![Cachix](https://github.com/feschber/lan-mouse/actions/workflows/cachix.yml/badge.svg)](https://github.com/feschber/lan-mouse/actions/workflows/cachix.yml) [![Release](https://github.com/feschber/lan-mouse/actions/workflows/release.yml/badge.svg)](https://github.com/feschber/lan-mouse/actions/workflows/release.yml)
+
+[![crates.io](https://img.shields.io/crates/v/lan-mouse.svg)](https://crates.io/crates/lan-mouse)  [![license](https://img.shields.io/crates/l/lan-mouse.svg)](https://github.com/feschber/lan-mouse/blob/main/Cargo.toml)
+
 Lan Mouse is a *cross-platform* mouse and keyboard sharing software similar to universal-control on Apple devices.
 It allows for using multiple PCs via a single set of mouse and keyboard.
 This is also known as a Software KVM switch.
@@ -177,8 +182,27 @@ For a detailed list of available features, checkout the [Cargo.toml](./Cargo.tom
 
 
 
+## Development
 
-## Installing Dependencies for Development / Compiling from Source
+### Git pre-commit hook
+
+This repository includes a local git hooks directory `.githooks/` with a `pre-commit` script that enforces formatting, lints, and tests before allowing a commit.  It is optional to enable it, but it will prevent you from committing code with failing unit tests or that needs clippy/fmt fixes. To enable the hook locally:
+
+1. Make the hook executable:
+
+```sh
+chmod +x .githooks/pre-commit
+```
+
+2. Point git to the hooks directory (one-time per clone):
+
+```sh
+git config core.hooksPath .githooks
+```
+
+The `pre-commit` script runs `cargo fmt --all` (and fails if files were modified), `cargo clippy --workspace --all-targets --all-features -- -D warnings`, and `cargo test --workspace --all-features`.
+
+### Dependencies & Compiling from Source
 <details>
     <summary>MacOS</summary>
 
@@ -321,6 +345,9 @@ To do so, use the `daemon` subcommand:
 ```sh
 lan-mouse daemon
 ```
+</details>
+
+## Systemd Service
 
 In order to start lan-mouse with a graphical session automatically,
 the [systemd-service](service/lan-mouse.service) can be used:
@@ -332,7 +359,9 @@ cp service/lan-mouse.service ~/.config/systemd/user
 systemctl --user daemon-reload
 systemctl --user enable --now lan-mouse.service
 ```
-</details>
+> [!Important]
+> Make sure to point `ExecStart=/usr/bin/lan-mouse daemon` to the actual `lan-mouse` binary (in case it is not under `/usr/bin`, e.g. when installed manually.
+
 
 ## Configuration
 To automatically load clients on startup, the file `$XDG_CONFIG_HOME/lan-mouse/config.toml` is parsed.

flake.lock

@@ -2,11 +2,11 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1752687322,
+        "lastModified": 1772963539,
-        "narHash": "sha256-RKwfXA4OZROjBTQAl9WOZQFm7L8Bo93FQwSJpAiSRvo=",
+        "narHash": "sha256-9jVDGZnvCckTGdYT53d/EfznygLskyLQXYwJLKMPsZs=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "6e987485eb2c77e5dcc5af4e3c70843711ef9251",
+        "rev": "9dcb002ca1690658be4a04645215baea8b95f31d",
         "type": "github"
       },
       "original": {
@@ -29,11 +29,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1752806774,
+        "lastModified": 1773025773,
-        "narHash": "sha256-4cHeoR2roN7d/3J6gT+l6o7J2hTrBIUiCwVdDNMeXzE=",
+        "narHash": "sha256-Wik8+xApNfldpUFjPmJkPdg0RrvUPSWGIZis+A/0N1w=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "3c90219b3ba1c9790c45a078eae121de48a39c55",
+        "rev": "3c06fdbbd36ff60386a1e590ee0cd52dcd1892bf",
         "type": "github"
       },
       "original": {

flake.nix

@@ -7,60 +7,87 @@
       inputs.nixpkgs.follows = "nixpkgs";
     };
   };
-  outputs = {
+  outputs =
-    self,
+    {
       nixpkgs,
       rust-overlay,
+      self,
       ...
-  }: let
+    }:
+    let
       inherit (nixpkgs) lib;
-    genSystems = lib.genAttrs [
+      forEachPkgs =
+        f:
+        lib.genAttrs
+          [
             "aarch64-darwin"
             "aarch64-linux"
             "x86_64-darwin"
             "x86_64-linux"
-    ];
+          ]
-    pkgsFor = system:
+          (
-      import nixpkgs {
+            system:
+            let
+              pkgs = import nixpkgs {
                 inherit system;
-
+                overlays = [ rust-overlay.overlays.default ];
-        overlays = [
+              };
-          rust-overlay.overlays.default
+              # Default toolchain for devshell
+              rustToolchain = pkgs.rust-bin.stable.latest.default.override {
+                extensions = [
+                  # includes already:
+                  # rustc
+                  # cargo
+                  # rust-std
+                  # rust-docs
+                  # rustfmt-preview
+                  # clippy-preview
+                  "rust-analyzer"
+                  "rust-src"
                 ];
               };
-    mkRustToolchain = pkgs:
+              # Minimal toolchain for builds (rustc + cargo + rust-std only)
-      pkgs.rust-bin.stable.latest.default.override {
+              rustToolchainForBuild = pkgs.rust-bin.stable.latest.minimal;
-        extensions = ["rust-src"];
+            in
+            f { inherit pkgs rustToolchain rustToolchainForBuild; }
+          );
+    in
+    {
+      packages = forEachPkgs (
+        { pkgs, rustToolchainForBuild, ... }:
+        let
+          customRustPlatform = pkgs.makeRustPlatform {
+            cargo = rustToolchainForBuild;
+            rustc = rustToolchainForBuild;
           };
-    pkgs = genSystems (system: import nixpkgs {inherit system;});
+          lan-mouse = pkgs.callPackage ./nix { rustPlatform = customRustPlatform; };
-  in {
+        in
-    packages = genSystems (system: rec {
+        {
-      default = pkgs.${system}.callPackage ./nix {};
+          default = lan-mouse;
-      lan-mouse = default;
+          inherit lan-mouse;
-    });
+        }
-    homeManagerModules.default = import ./nix/hm-module.nix self;
+      );
-    devShells = genSystems (system: let
+      devShells = forEachPkgs (
-      pkgs = pkgsFor system;
+        { pkgs, rustToolchain, ... }:
-      rust = mkRustToolchain pkgs;
+        {
-    in {
           default = pkgs.mkShell {
-        packages = with pkgs; [
+            packages =
-          rust
+              with pkgs;
-          rust-analyzer-unwrapped
+              [
+                rustToolchain
                 pkg-config
-          xorg.libX11
                 gtk4
                 libadwaita
                 librsvg
-          xorg.libXtst
+              ]
-        ] ++ lib.optionals stdenv.isDarwin
+              ++ lib.optionals pkgs.stdenv.isLinux [
-        (with darwin.apple_sdk_11_0.frameworks; [
+                libX11
-          CoreGraphics
+                libXtst
-          ApplicationServices
+              ];
-        ]);
+            env.RUST_SRC_PATH = "${rustToolchain}/lib/rustlib/src/rust/library";
-
-        RUST_SRC_PATH = "${rust}/lib/rustlib/src/rust/library";
           };
-    });
+        }
+      );
+      homeManagerModules.default = import ./nix/hm-module.nix self;
     };
 }

input-capture/Cargo.toml

@@ -12,7 +12,7 @@ futures-core = "0.3.30"
 log = "0.4.22"
 input-event = { path = "../input-event", version = "0.3.0" }
 memmap = "0.7"
-tempfile = "3.8"
+tempfile = "3.25.0"
 thiserror = "2.0.0"
 tokio = { version = "1.32.0", features = [
     "io-util",
@@ -23,6 +23,7 @@ tokio = { version = "1.32.0", features = [
     "rt",
     "sync",
     "signal",
+    "time",
 ] }
 once_cell = "1.19.0"
 async-trait = "0.1.81"
@@ -40,7 +41,8 @@ wayland-protocols-wlr = { version = "0.3.1", features = [
     "client",
 ], optional = true }
 x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.11.0", default-features = false, features = [
+ashpd = { version = "0.13.9", default-features = false, features = [
+    "input_capture",
     "tokio",
 ], optional = true }
 reis = { version = "0.5.0", features = ["tokio"], optional = true }

input-capture/src/lib.rs

@@ -2,6 +2,7 @@ use std::{
     collections::{HashMap, HashSet, VecDeque},
     fmt::Display,
     mem::swap,
+    sync::{Arc, Mutex},
     task::{Poll, ready},
 };
 
@@ -129,6 +130,24 @@ pub struct InputCapture {
     pending: VecDeque<(CaptureHandle, CaptureEvent)>,
 }
 
+#[derive(Clone, Debug)]
+pub enum WindowIdentifier {
+    Wayland(String),
+    X11(u32),
+}
+
+#[cfg(all(unix, feature = "libei"))]
+impl Into<ashpd::WindowIdentifier> for WindowIdentifier {
+    fn into(self) -> ashpd::WindowIdentifier {
+        match self {
+            WindowIdentifier::Wayland(handle) => {
+                ashpd::WindowIdentifier::from_xdg_foreign_exported(handle)
+            }
+            WindowIdentifier::X11(_) => todo!(),
+        }
+    }
+}
+
 impl InputCapture {
     /// create a new client with the given id
     pub async fn create(&mut self, id: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
@@ -177,8 +196,11 @@ impl InputCapture {
     }
 
     /// creates a new [`InputCapture`]
-    pub async fn new(backend: Option<Backend>) -> Result<Self, CaptureCreationError> {
+    pub async fn new(
-        let capture = create(backend).await?;
+        backend: Option<Backend>,
+        window_identifier: Arc<Mutex<Option<WindowIdentifier>>>,
+    ) -> Result<Self, CaptureCreationError> {
+        let capture = create(backend, window_identifier).await?;
         Ok(Self {
             capture,
             id_map: Default::default(),
@@ -280,13 +302,16 @@ trait Capture: Stream<Item = Result<(Position, CaptureEvent), CaptureError>> + U
 
 async fn create_backend(
     backend: Backend,
+    window_identifier: Arc<Mutex<Option<WindowIdentifier>>>,
 ) -> Result<
     Box<dyn Capture<Item = Result<(Position, CaptureEvent), CaptureError>>>,
     CaptureCreationError,
 > {
     match backend {
         #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-        Backend::InputCapturePortal => Ok(Box::new(libei::LibeiInputCapture::new().await?)),
+        Backend::InputCapturePortal => Ok(Box::new(
+            libei::LibeiInputCapture::new(window_identifier).await?,
+        )),
         #[cfg(all(unix, feature = "layer_shell", not(target_os = "macos")))]
         Backend::LayerShell => Ok(Box::new(layer_shell::LayerShellInputCapture::new()?)),
         #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
@@ -301,12 +326,13 @@ async fn create_backend(
 
 async fn create(
     backend: Option<Backend>,
+    window_identifier: Arc<Mutex<Option<WindowIdentifier>>>,
 ) -> Result<
     Box<dyn Capture<Item = Result<(Position, CaptureEvent), CaptureError>>>,
     CaptureCreationError,
 > {
     if let Some(backend) = backend {
-        let b = create_backend(backend).await;
+        let b = create_backend(backend, window_identifier).await;
         if b.is_ok() {
             log::info!("using capture backend: {backend}");
         }
@@ -325,7 +351,7 @@ async fn create(
         #[cfg(target_os = "macos")]
         Backend::MacOs,
     ] {
-        match create_backend(backend).await {
+        match create_backend(backend, window_identifier.clone()).await {
             Ok(b) => {
                 log::info!("using capture backend: {backend}");
                 return Ok(b);

input-capture/src/libei.rs

@@ -2,8 +2,8 @@ use ashpd::{
     desktop::{
         Session,
         input_capture::{
-            Activated, ActivatedBarrier, Barrier, BarrierID, Capabilities, InputCapture, Region,
+            Activated, ActivatedBarrier, Barrier, BarrierID, Capabilities, CreateSessionOptions,
-            Zones,
+            InputCapture, Region, ReleaseOptions, Zones,
         },
     },
     enumflags2::BitFlags,
@@ -23,7 +23,7 @@ use std::{
     os::unix::net::UnixStream,
     pin::Pin,
     rc::Rc,
-    sync::Arc,
+    sync::{Arc, Mutex},
     task::{Context, Poll},
 };
 use tokio::{
@@ -39,7 +39,7 @@ use futures_core::Stream;
 
 use input_event::Event;
 
-use crate::CaptureEvent;
+use crate::{CaptureEvent, WindowIdentifier};
 
 use super::{
     Capture as LanMouseInputCapture, Position,
@@ -58,8 +58,8 @@ enum LibeiNotifyEvent {
 }
 
 #[allow(dead_code)]
-pub struct LibeiInputCapture<'a> {
+pub struct LibeiInputCapture {
-    input_capture: Pin<Box<InputCapture<'a>>>,
+    input_capture: Pin<Box<InputCapture>>,
     capture_task: JoinHandle<Result<(), CaptureError>>,
     event_rx: Receiver<(Position, CaptureEvent)>,
     notify_capture: Sender<LibeiNotifyEvent>,
@@ -130,12 +130,15 @@ fn select_barriers(
 }
 
 async fn update_barriers(
-    input_capture: &InputCapture<'_>,
+    input_capture: &InputCapture,
-    session: &Session<'_, InputCapture<'_>>,
+    session: &Session<InputCapture>,
     active_clients: &[Position],
     next_barrier_id: &mut NonZeroU32,
 ) -> Result<(Vec<ICBarrier>, HashMap<BarrierID, Position>), ashpd::Error> {
-    let zones = input_capture.zones(session).await?.response()?;
+    let zones = input_capture
+        .zones(session, Default::default())
+        .await?
+        .response()?;
     log::debug!("zones: {zones:?}");
 
     let (barriers, id_map) = select_barriers(&zones, active_clients, next_barrier_id);
@@ -144,31 +147,42 @@ async fn update_barriers(
 
     let ashpd_barriers: Vec<Barrier> = barriers.iter().copied().map(|b| b.into()).collect();
     let response = input_capture
-        .set_pointer_barriers(session, &ashpd_barriers, zones.zone_set())
+        .set_pointer_barriers(
+            session,
+            &ashpd_barriers,
+            zones.zone_set(),
+            Default::default(),
+        )
         .await?;
     let response = response.response()?;
     log::debug!("{response:?}");
     Ok((barriers, id_map))
 }
 
-async fn create_session<'a>(
+async fn create_session(
-    input_capture: &'a InputCapture<'a>,
+    input_capture: &InputCapture,
-) -> std::result::Result<(Session<'a, InputCapture<'a>>, BitFlags<Capabilities>), ashpd::Error> {
+    window_identifier: Arc<Mutex<Option<WindowIdentifier>>>,
-    log::debug!("creating input capture session");
+) -> std::result::Result<(Session<InputCapture>, BitFlags<Capabilities>), ashpd::Error> {
-    input_capture
+    log::debug!("creating input capture session: {window_identifier:?}");
-        .create_session(
+    let window_identifier = window_identifier.lock().unwrap().clone();
-            None,
+    let create_session_options = CreateSessionOptions::default().set_capabilities(
         Capabilities::Keyboard | Capabilities::Pointer | Capabilities::Touchscreen,
-        )
+    );
+    let ashpd_window_identifier: Option<ashpd::WindowIdentifier> =
+        window_identifier.map(|i| i.into());
+    input_capture
+        .create_session(ashpd_window_identifier.as_ref(), create_session_options)
         .await
 }
 
 async fn connect_to_eis(
-    input_capture: &InputCapture<'_>,
+    input_capture: &InputCapture,
-    session: &Session<'_, InputCapture<'_>>,
+    session: &Session<InputCapture>,
 ) -> Result<(ei::Context, Connection, EiConvertEventStream), CaptureError> {
     log::debug!("connect_to_eis");
-    let fd = input_capture.connect_to_eis(session).await?;
+    let fd = input_capture
+        .connect_to_eis(session, Default::default())
+        .await?;
 
     // create unix stream from fd
     let stream = UnixStream::from(fd);
@@ -201,11 +215,16 @@ async fn libei_event_handler(
     }
 }
 
-impl LibeiInputCapture<'_> {
+impl LibeiInputCapture {
-    pub async fn new() -> std::result::Result<Self, LibeiCaptureCreationError> {
+    /// creates a new libei input capture
+    /// `window_id` is a window identifier for user prompts
+    pub async fn new(
+        window_identifier: Arc<Mutex<Option<WindowIdentifier>>>,
+    ) -> std::result::Result<Self, LibeiCaptureCreationError> {
         let input_capture = Box::pin(InputCapture::new().await?);
-        let input_capture_ptr = input_capture.as_ref().get_ref() as *const InputCapture<'static>;
+        let input_capture_ptr = input_capture.as_ref().get_ref() as *const InputCapture;
-        let first_session = Some(create_session(unsafe { &*input_capture_ptr }).await?);
+        let first_session =
+            Some(create_session(unsafe { &*input_capture_ptr }, window_identifier.clone()).await?);
 
         let (event_tx, event_rx) = mpsc::channel(1);
         let (notify_capture, notify_rx) = mpsc::channel(1);
@@ -220,6 +239,7 @@ impl LibeiInputCapture<'_> {
             first_session,
             event_tx,
             cancellation_token.clone(),
+            window_identifier,
         );
         let capture_task = tokio::task::spawn_local(capture);
 
@@ -238,12 +258,13 @@ impl LibeiInputCapture<'_> {
 }
 
 async fn do_capture(
-    input_capture: *const InputCapture<'static>,
+    input_capture: *const InputCapture,
     mut capture_event: Receiver<LibeiNotifyEvent>,
     notify_release: Arc<Notify>,
-    session: Option<(Session<'_, InputCapture<'_>>, BitFlags<Capabilities>)>,
+    session: Option<(Session<InputCapture>, BitFlags<Capabilities>)>,
     event_tx: Sender<(Position, CaptureEvent)>,
     cancellation_token: CancellationToken,
+    window_identifier: Arc<Mutex<Option<WindowIdentifier>>>,
 ) -> Result<(), CaptureError> {
     let mut session = session.map(|s| s.0);
 
@@ -289,7 +310,11 @@ async fn do_capture(
             // create session
             let mut session = match session.take() {
                 Some(s) => s,
-                None => create_session(input_capture).await?.0,
+                None => {
+                    create_session(input_capture, window_identifier.clone())
+                        .await?
+                        .0
+                }
             };
 
             let capture_session = do_capture_session(
@@ -307,7 +332,7 @@ async fn do_capture(
 
             // disable capture
             log::debug!("disabling input capture");
-            if let Err(e) = input_capture.disable(&session).await {
+            if let Err(e) = input_capture.disable(&session, Default::default()).await {
                 log::warn!("input_capture.disable(&session) {e}");
             }
             if let Err(e) = session.close().await {
@@ -336,8 +361,8 @@ async fn do_capture(
 }
 
 async fn do_capture_session(
-    input_capture: &InputCapture<'_>,
+    input_capture: &InputCapture,
-    session: &mut Session<'_, InputCapture<'_>>,
+    session: &mut Session<InputCapture>,
     event_tx: &Sender<(Position, CaptureEvent)>,
     active_clients: &[Position],
     next_barrier_id: &mut NonZeroU32,
@@ -356,7 +381,7 @@ async fn do_capture_session(
         update_barriers(input_capture, session, active_clients, next_barrier_id).await?;
 
     log::debug!("enabling session");
-    input_capture.enable(session).await?;
+    input_capture.enable(session, Default::default()).await?;
 
     // cancellation token to release session
     let release_session = Arc::new(Notify::new());
@@ -462,9 +487,9 @@ async fn do_capture_session(
     Ok(())
 }
 
-async fn release_capture<'a>(
+async fn release_capture(
-    input_capture: &InputCapture<'a>,
+    input_capture: &InputCapture,
-    session: &Session<'a, InputCapture<'a>>,
+    session: &Session<InputCapture>,
     activated: Activated,
     current_pos: Position,
 ) -> Result<(), CaptureError> {
@@ -484,9 +509,10 @@ async fn release_capture<'a>(
     };
     // release 1px to the right of the entered zone
     let cursor_position = (x as f64 + dx, y as f64 + dy);
-    input_capture
+    let release_options = ReleaseOptions::default()
-        .release(session, activated.activation_id(), Some(cursor_position))
+        .set_activation_id(activated.activation_id())
-        .await?;
+        .set_cursor_position(Some(cursor_position));
+    input_capture.release(session, release_options).await?;
     Ok(())
 }
 
@@ -561,7 +587,7 @@ async fn handle_ei_event(
 }
 
 #[async_trait]
-impl LanMouseInputCapture for LibeiInputCapture<'_> {
+impl LanMouseInputCapture for LibeiInputCapture {
     async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {
         let _ = self
             .notify_capture
@@ -598,7 +624,7 @@ impl LanMouseInputCapture for LibeiInputCapture<'_> {
     }
 }
 
-impl Drop for LibeiInputCapture<'_> {
+impl Drop for LibeiInputCapture {
     fn drop(&mut self) {
         if !self.terminated {
             /* this workaround is needed until async drop is stabilized */
@@ -607,10 +633,10 @@ impl Drop for LibeiInputCapture<'_> {
     }
 }
 
-impl Stream for LibeiInputCapture<'_> {
+impl Stream for LibeiInputCapture {
     type Item = Result<(Position, CaptureEvent), CaptureError>;
 
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
         match self.capture_task.poll_unpin(cx) {
             Poll::Ready(r) => match r.expect("failed to join") {
                 Ok(()) => Poll::Ready(None),

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,
             })))
         }
@@ -646,6 +660,7 @@ unsafe fn configure_cf_settings() -> Result<(), MacosCaptureCreationError> {
     let event_source = CGEventSource::new(CGEventSourceStateID::CombinedSessionState)
         .map_err(|_| MacosCaptureCreationError::EventSourceCreation)?;
     CGEventSourceSetLocalEventsSuppressionInterval(event_source, 0.05);
+    // FIXME Memory Leak
 
     // This is a private settings that allows the cursor to be hidden while in the background.
     // It is used by Barrier and other apps.

input-emulation/Cargo.toml

@@ -40,7 +40,9 @@ wayland-protocols-misc = { version = "0.3.1", features = [
     "client",
 ], optional = true }
 x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.11.0", default-features = false, features = [
+ashpd = { version = "0.13.9", default-features = false, features = [
+    "remote_desktop",
+    "screencast",
     "tokio",
 ], optional = true }
 reis = { version = "0.5.0", features = ["tokio"], optional = true }

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},
@@ -12,7 +13,7 @@ use tokio::task::JoinHandle;
 
 use ashpd::desktop::{
     PersistMode, Session,
-    remote_desktop::{DeviceType, RemoteDesktop},
+    remote_desktop::{DeviceType, RemoteDesktop, SelectDevicesOptions},
 };
 use async_trait::async_trait;
 
@@ -39,42 +40,85 @@ struct Devices {
     keyboard: Arc<RwLock<Option<(ei::Device, ei::Keyboard)>>>,
 }
 
-pub(crate) struct LibeiEmulation<'a> {
+pub(crate) struct LibeiEmulation {
     context: ei::Context,
     conn: event::Connection,
     devices: Devices,
     ei_task: JoinHandle<()>,
     error: Arc<Mutex<Option<EmulationError>>>,
     libei_error: Arc<AtomicBool>,
-    _remote_desktop: RemoteDesktop<'a>,
+    _remote_desktop: RemoteDesktop,
-    session: Session<'a, RemoteDesktop<'a>>,
+    session: Session<RemoteDesktop>,
 }
 
-async fn get_ei_fd<'a>()
+/// Get the path to the RemoteDesktop token file
--> Result<(RemoteDesktop<'a>, Session<'a, RemoteDesktop<'a>>, OwnedFd), ashpd::Error> {
+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() -> Result<(RemoteDesktop, Session<RemoteDesktop>, 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?;
+    let session = remote_desktop.create_session(Default::default()).await?;
 
     log::debug!("selecting devices ...");
-    remote_desktop
+    let options = SelectDevicesOptions::default()
-        .select_devices(
+        .set_devices(DeviceType::Keyboard | DeviceType::Pointer)
-            &session,
+        .set_persist_mode(PersistMode::ExplicitlyRevoked)
-            DeviceType::Keyboard | DeviceType::Pointer,
+        .set_restore_token(restore_token.as_deref());
-            None,
+    remote_desktop.select_devices(&session, options).await?;
-            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, Default::default())
+        .await?
+        .response()?;
 
-    let fd = remote_desktop.connect_to_eis(&session).await?;
+    // 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, Default::default())
+        .await?;
     Ok((remote_desktop, session, fd))
 }
 
-impl LibeiEmulation<'_> {
+impl LibeiEmulation {
     pub(crate) async fn new() -> Result<Self, LibeiEmulationCreationError> {
         let (_remote_desktop, session, eifd) = get_ei_fd().await?;
         let stream = UnixStream::from(eifd);
@@ -109,14 +153,14 @@ impl LibeiEmulation<'_> {
     }
 }
 
-impl Drop for LibeiEmulation<'_> {
+impl Drop for LibeiEmulation {
     fn drop(&mut self) {
         self.ei_task.abort();
     }
 }
 
 #[async_trait]
-impl Emulation for LibeiEmulation<'_> {
+impl Emulation for LibeiEmulation {
     async fn consume(
         &mut self,
         event: Event,

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
+    /// current state of the mouse buttons (tracked by evdev button code)
-    button_state: ButtonState,
+    pressed_buttons: HashSet<u32>,
-    /// button previously pressed
+    /// button previously pressed (evdev button code)
-    previous_button: Option<CGMouseButton>,
+    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 {
+/// Maps an evdev button code to the CGEventType used for drag events.
-    left: bool,
+fn drag_event_type(button: u32) -> CGEventType {
-    right: bool,
+    match button {
-    center: bool,
+        BTN_LEFT => CGEventType::LeftMouseDragged,
-}
+        BTN_RIGHT => CGEventType::RightMouseDragged,
-
+        // middle, back, forward, and any other button all use OtherMouseDragged
-impl Index<CGMouseButton> for ButtonState {
+        _ => CGEventType::OtherMouseDragged,
-    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,
-        }
     }
 }
 
@@ -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 any button is held, emit a drag event for it;
-                        if self.button_state.left {
+                        // otherwise emit a normal mouse-moved event.
-                            event_type = CGEventType::LeftMouseDragged
+                        let event_type = self
-                        } else if self.button_state.right {
+                            .pressed_buttons
-                            event_type = CGEventType::RightMouseDragged
+                            .iter()
-                        } else if self.button_state.center {
+                            .next()
-                            event_type = CGEventType::OtherMouseDragged
+                            .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
+                        // store button state using the evdev button code so
-                        self.button_state[mouse_button] = state == 1;
+                        // back, forward, and middle are tracked independently
-
-                        // update previous button state
                         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 {

input-emulation/src/xdg_desktop_portal.rs

@@ -1,7 +1,10 @@
 use ashpd::{
     desktop::{
         PersistMode, Session,
-        remote_desktop::{Axis, DeviceType, KeyState, RemoteDesktop},
+        remote_desktop::{
+            Axis, DeviceType, KeyState, NotifyPointerAxisOptions, RemoteDesktop,
+            SelectDevicesOptions,
+        },
     },
     zbus::AsyncDrop,
 };
@@ -17,32 +20,31 @@ use crate::error::EmulationError;
 
 use super::{Emulation, EmulationHandle, error::XdpEmulationCreationError};
 
-pub(crate) struct DesktopPortalEmulation<'a> {
+pub(crate) struct DesktopPortalEmulation {
-    proxy: RemoteDesktop<'a>,
+    proxy: RemoteDesktop,
-    session: Session<'a, RemoteDesktop<'a>>,
+    session: Session<RemoteDesktop>,
 }
 
-impl<'a> DesktopPortalEmulation<'a> {
+impl DesktopPortalEmulation {
-    pub(crate) async fn new() -> Result<DesktopPortalEmulation<'a>, XdpEmulationCreationError> {
+    pub(crate) async fn new() -> Result<DesktopPortalEmulation, XdpEmulationCreationError> {
         log::debug!("connecting to org.freedesktop.portal.RemoteDesktop portal ...");
         let proxy = RemoteDesktop::new().await?;
 
         // retry when user presses the cancel button
         log::debug!("creating session ...");
-        let session = proxy.create_session().await?;
+        let session = proxy.create_session(Default::default()).await?;
 
         log::debug!("selecting devices ...");
-        proxy
+        let options = SelectDevicesOptions::default()
-            .select_devices(
+            .set_devices(DeviceType::Keyboard | DeviceType::Pointer)
-                &session,
+            .set_persist_mode(PersistMode::ExplicitlyRevoked);
-                DeviceType::Keyboard | DeviceType::Pointer,
+        proxy.select_devices(&session, options).await?;
-                None,
-                PersistMode::ExplicitlyRevoked,
-            )
-            .await?;
 
         log::info!("requesting permission for input emulation");
-        let _devices = proxy.start(&session, None).await?.response()?;
+        let _devices = proxy
+            .start(&session, None, Default::default())
+            .await?
+            .response()?;
 
         log::debug!("started session");
         let session = session;
@@ -52,7 +54,7 @@ impl<'a> DesktopPortalEmulation<'a> {
 }
 
 #[async_trait]
-impl Emulation for DesktopPortalEmulation<'_> {
+impl Emulation for DesktopPortalEmulation {
     async fn consume(
         &mut self,
         event: input_event::Event,
@@ -62,7 +64,7 @@ impl Emulation for DesktopPortalEmulation<'_> {
             Pointer(p) => match p {
                 PointerEvent::Motion { time: _, dx, dy } => {
                     self.proxy
-                        .notify_pointer_motion(&self.session, dx, dy)
+                        .notify_pointer_motion(&self.session, dx, dy, Default::default())
                         .await?;
                 }
                 PointerEvent::Button {
@@ -75,7 +77,12 @@ impl Emulation for DesktopPortalEmulation<'_> {
                         _ => KeyState::Pressed,
                     };
                     self.proxy
-                        .notify_pointer_button(&self.session, button as i32, state)
+                        .notify_pointer_button(
+                            &self.session,
+                            button as i32,
+                            state,
+                            Default::default(),
+                        )
                         .await?;
                 }
                 PointerEvent::AxisDiscrete120 { axis, value } => {
@@ -84,7 +91,12 @@ impl Emulation for DesktopPortalEmulation<'_> {
                         _ => Axis::Horizontal,
                     };
                     self.proxy
-                        .notify_pointer_axis_discrete(&self.session, axis, value / 120)
+                        .notify_pointer_axis_discrete(
+                            &self.session,
+                            axis,
+                            value / 120,
+                            Default::default(),
+                        )
                         .await?;
                 }
                 PointerEvent::Axis {
@@ -101,7 +113,12 @@ impl Emulation for DesktopPortalEmulation<'_> {
                         Axis::Horizontal => (value, 0.),
                     };
                     self.proxy
-                        .notify_pointer_axis(&self.session, dx, dy, true)
+                        .notify_pointer_axis(
+                            &self.session,
+                            dx,
+                            dy,
+                            NotifyPointerAxisOptions::default().set_finish(true),
+                        )
                         .await?;
                 }
             },
@@ -117,7 +134,12 @@ impl Emulation for DesktopPortalEmulation<'_> {
                             _ => KeyState::Pressed,
                         };
                         self.proxy
-                            .notify_keyboard_keycode(&self.session, key as i32, state)
+                            .notify_keyboard_keycode(
+                                &self.session,
+                                key as i32,
+                                state,
+                                Default::default(),
+                            )
                             .await?;
                     }
                     KeyboardEvent::Modifiers { .. } => {
@@ -141,7 +163,7 @@ impl Emulation for DesktopPortalEmulation<'_> {
     }
 }
 
-impl AsyncDrop for DesktopPortalEmulation<'_> {
+impl AsyncDrop for DesktopPortalEmulation {
     #[doc = r" Perform the async cleanup."]
     #[allow(clippy::type_complexity, clippy::type_repetition_in_bounds)]
     fn async_drop<'async_trait>(

lan-mouse-cli/src/lib.rs

@@ -71,6 +71,8 @@ enum CliSubcommand {
     },
     /// deauthorize a public key
     RemoveAuthorizedKey { sha256_fingerprint: String },
+    /// save configuration to file
+    SaveConfig,
 }
 
 pub async fn run(args: CliArgs) -> Result<(), CliError> {
@@ -162,6 +164,7 @@ async fn execute(cmd: CliSubcommand) -> Result<(), CliError> {
             tx.request(FrontendRequest::RemoveAuthorizedKey(sha256_fingerprint))
                 .await?
         }
+        CliSubcommand::SaveConfig => tx.request(FrontendRequest::SaveConfiguration).await?,
     }
     Ok(())
 }

lan-mouse-gtk/Cargo.toml

@@ -15,5 +15,13 @@ log = "0.4.20"
 lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.2.0" }
 thiserror = "2.0.0"
 
+[target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
+gdk4_wayland = { package = "gdk4-wayland", version="0.9.6", optional=true }
+
 [build-dependencies]
 glib-build-tools = { version = "0.20.0" }
+
+
+[features]
+default = ["wayland_window_identifier"]
+wayland_window_identifier = ["dep:gdk4_wayland"]

lan-mouse-gtk/src/lib.rs

@@ -10,7 +10,7 @@ use std::{env, process, str};
 
 use window::Window;
 
-use lan_mouse_ipc::FrontendEvent;
+use lan_mouse_ipc::{FrontendEvent, FrontendRequest, WindowIdentifier};
 
 use adw::Application;
 use gtk::{IconTheme, gdk::Display, glib::clone, prelude::*};
@@ -19,6 +19,9 @@ use gtk::{gio, glib, prelude::ApplicationExt};
 use self::client_object::ClientObject;
 use self::key_object::KeyObject;
 
+#[cfg(all(unix, feature = "wayland_window_identifier", not(target_os = "macos")))]
+use gdk4_wayland::WaylandToplevel;
+
 use thiserror::Error;
 
 #[derive(Error, Debug)]
@@ -124,6 +127,28 @@ fn build_ui(app: &Application) {
 
     let window = Window::new(app, frontend_tx);
 
+    // export TopLevel handle and send it to the service so that it can put the InpuCapture / RemoteDesktop
+    // windows on top of it using xdg-foreign.
+    #[cfg(all(unix, feature = "wayland_window_identifier", not(target_os = "macos")))]
+    window.connect_show(|window| {
+        // needs the surface so we have to present first!
+        if let Some(surface) = window.surface() {
+            if surface.display().backend().is_wayland() {
+                // let surface = surface.downcast::<WaylandSurface>();
+                let toplevel = surface.downcast::<WaylandToplevel>().expect("xdg-toplevel");
+                let window = window.clone();
+                toplevel.export_handle(move |_toplevel, handle| {
+                    if let Ok(handle) = handle {
+                        let handle = handle.to_string();
+                        window.request(FrontendRequest::WindowIdentifier(
+                            WindowIdentifier::Wayland(handle),
+                        ));
+                    }
+                });
+            }
+        }
+    });
+
     glib::spawn_future_local(clone!(
         #[weak]
         window,

lan-mouse-gtk/src/window.rs

@@ -422,7 +422,7 @@ impl Window {
         self.request(FrontendRequest::RemoveAuthorizedKey(fp));
     }
 
-    fn request(&self, request: FrontendRequest) {
+    pub(crate) fn request(&self, request: FrontendRequest) {
         let mut requester = self.imp().frontend_request_writer.borrow_mut();
         let requester = requester.as_mut().unwrap();
         if let Err(e) = requester.request(request) {

lan-mouse-ipc/Cargo.toml

@@ -12,5 +12,5 @@ log = "0.4.22"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.107"
 thiserror = "2.0.0"
-tokio = { version = "1.32.0", features = ["net", "io-util", "time"] }
+tokio = { version = "1.32.0", features = ["macros", "net", "io-util", "time"] }
 tokio-stream = { version = "0.1.15", features = ["io-util"] }

lan-mouse-ipc/src/lib.rs

@@ -253,6 +253,16 @@ pub enum FrontendRequest {
     RemoveAuthorizedKey(String),
     /// change the hook command
     UpdateEnterHook(u64, Option<String>),
+    /// save config file
+    SaveConfiguration,
+    /// window identifier used to present input-capture / remote-desktop prompts
+    WindowIdentifier(WindowIdentifier),
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub enum WindowIdentifier {
+    Wayland(String),
+    X11(u32),
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug, Default, Serialize, Deserialize)]

nix/default.nix

@@ -1,34 +1,40 @@
 {
+  stdenv,
   rustPlatform,
   lib,
-  pkgs,
+  pkg-config,
-}: let
+  libX11,
-  cargoToml = builtins.fromTOML (builtins.readFile ../Cargo.toml);
+  gtk4,
+  libadwaita,
+  libXtst,
+  wrapGAppsHook4,
+  librsvg,
+  git,
+}:
+let
+  cargoToml = fromTOML (builtins.readFile ../Cargo.toml);
   pname = cargoToml.package.name;
   version = cargoToml.package.version;
 in
 rustPlatform.buildRustPackage {
-  pname = pname;
+  inherit pname;
-  version = version;
+  inherit version;
 
-  nativeBuildInputs = with pkgs; [
+  nativeBuildInputs = [
-    git
     pkg-config
-    cmake
+    wrapGAppsHook4
-    makeWrapper
+    git
-    buildPackages.gtk4
   ];
 
-  buildInputs = with pkgs; [
+  buildInputs = [
-    xorg.libX11
     gtk4
     libadwaita
-    xorg.libXtst
+    librsvg
-  ] ++ lib.optionals stdenv.isDarwin
+  ]
-  (with darwin.apple_sdk_11_0.frameworks; [
+  ++ lib.optionals stdenv.isLinux [
-    CoreGraphics
+    libX11
-    ApplicationServices
+    libXtst
-  ]);
+  ];
 
   src = builtins.path {
     name = pname;
@@ -40,11 +46,7 @@ rustPlatform.buildRustPackage {
   # Set Environment Variables
   RUST_BACKTRACE = "full";
 
-  # Needed to enable support for SVG icons in GTK
   postInstall = ''
-    wrapProgram "$out/bin/lan-mouse" \
-      --set GDK_PIXBUF_MODULE_FILE ${pkgs.librsvg.out}/lib/gdk-pixbuf-2.0/2.10.0/loaders.cache
-
     install -Dm444 *.desktop -t $out/share/applications
     install -Dm444 lan-mouse-gtk/resources/*.svg -t $out/share/icons/hicolor/scalable/apps
   '';

scripts/makeicns.sh

@@ -29,13 +29,13 @@ iconset="${3:-./target/icon.iconset}"
 set -u
 
 mkdir -p "$iconset"
-magick convert -background none -resize 1024x1024 "$svg" "$iconset"/icon_512x512@2x.png
+magick "$svg" -background none -resize 1024x1024 "$iconset"/icon_512x512@2x.png
-magick convert -background none -resize 512x512 "$svg" "$iconset"/icon_512x512.png
+magick "$svg" -background none -resize 512x512 "$iconset"/icon_512x512.png
-magick convert -background none -resize 256x256 "$svg" "$iconset"/icon_256x256.png
+magick "$svg" -background none -resize 256x256 "$iconset"/icon_256x256.png
-magick convert -background none -resize 128x128 "$svg" "$iconset"/icon_128x128.png
+magick "$svg" -background none -resize 128x128 "$iconset"/icon_128x128.png
-magick convert -background none -resize 64x64 "$svg" "$iconset"/icon_32x32@2x.png
+magick "$svg" -background none -resize 64x64 "$iconset"/icon_32x32@2x.png
-magick convert -background none -resize 32x32 "$svg" "$iconset"/icon_32x32.png
+magick "$svg" -background none -resize 32x32 "$iconset"/icon_32x32.png
-magick convert -background none -resize 16x16 "$svg" "$iconset"/icon_16x16.png
+magick "$svg" -background none -resize 16x16 "$iconset"/icon_16x16.png
 cp "$iconset"/icon_512x512.png "$iconset"/icon_256x256@2x.png
 cp "$iconset"/icon_256x256.png "$iconset"/icon_128x128@2x.png
 cp "$iconset"/icon_32x32.png "$iconset"/icon_16x16@2x.png

src/capture.rs

@@ -1,12 +1,14 @@
 use std::{
     cell::{Cell, RefCell},
     rc::Rc,
+    sync::{Arc, Mutex},
     time::{Duration, Instant},
 };
 
 use futures::StreamExt;
 use input_capture::{
     CaptureError, CaptureEvent, CaptureHandle, InputCapture, InputCaptureError, Position,
+    WindowIdentifier,
 };
 use input_event::scancode;
 use lan_mouse_proto::ProtoEvent;
@@ -49,7 +51,7 @@ pub(crate) enum CaptureType {
     EnterOnly,
 }
 
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Debug)]
 enum CaptureRequest {
     /// capture must release the mouse
     Release,
@@ -66,6 +68,7 @@ impl Capture {
         backend: Option<input_capture::Backend>,
         conn: LanMouseConnection,
         release_bind: Vec<scancode::Linux>,
+        window_identifier: Arc<Mutex<Option<WindowIdentifier>>>,
     ) -> Self {
         let (request_tx, request_rx) = channel();
         let (event_tx, event_rx) = channel();
@@ -80,6 +83,7 @@ impl Capture {
             request_rx,
             release_bind: Rc::new(RefCell::new(release_bind)),
             state: Default::default(),
+            window_identifier,
         };
         let task = spawn_local(capture_task.run());
         Self {
@@ -160,6 +164,7 @@ struct CaptureTask {
     release_bind: Rc<RefCell<Vec<scancode::Linux>>>,
     request_rx: Receiver<CaptureRequest>,
     state: State,
+    window_identifier: Arc<Mutex<Option<WindowIdentifier>>>,
 }
 
 impl CaptureTask {
@@ -194,6 +199,7 @@ impl CaptureTask {
     }
 
     async fn run(mut self) {
+        tokio::time::sleep(Duration::from_secs(1)).await;
         loop {
             if let Err(e) = self.do_capture().await {
                 log::warn!("input capture exited: {e}");
@@ -201,10 +207,10 @@ impl CaptureTask {
             loop {
                 tokio::select! {
                     r = self.request_rx.recv() => match r.expect("channel closed") {
-                        CaptureRequest::Reenable => break,
+                        CaptureRequest::Reenable=>break,
-                        CaptureRequest::Create(h, p, t) => self.add_capture(h, p, t),
+                        CaptureRequest::Create(h,p,t)=>self.add_capture(h,p,t),
-                        CaptureRequest::Destroy(h) => self.remove_capture(h),
+                        CaptureRequest::Destroy(h)=>self.remove_capture(h),
-                        CaptureRequest::Release => { /* nothing to do */ }
+                        CaptureRequest::Release=>{}
                     },
                     _ = self.cancellation_token.cancelled() => return,
                 }
@@ -215,7 +221,7 @@ impl CaptureTask {
     async fn do_capture(&mut self) -> Result<(), InputCaptureError> {
         /* allow cancelling capture request */
         let mut capture = tokio::select! {
-            r = InputCapture::new(self.backend) => r?,
+            r = InputCapture::new(self.backend, self.window_identifier.clone()) => r?,
             _ = self.cancellation_token.cancelled() => return Ok(()),
         };
 
@@ -285,16 +291,10 @@ impl CaptureTask {
                     }
                 },
                 e = self.request_rx.recv() => match e.expect("channel closed") {
-                    CaptureRequest::Reenable => { /* already active */ },
+                    CaptureRequest::Reenable=>{},
-                    CaptureRequest::Release => self.release_capture(capture).await?,
+                    CaptureRequest::Release=>self.release_capture(capture).await?,
-                    CaptureRequest::Create(h, p, t) => {
+                    CaptureRequest::Create(h,p,t)=>{self.add_capture(h,p,t);capture.create(h,p).await?;}
-                        self.add_capture(h, p, t);
+                    CaptureRequest::Destroy(h)=>{self.remove_capture(h);capture.destroy(h).await?;}
-                        capture.create(h, p).await?;
-                    }
-                    CaptureRequest::Destroy(h) => {
-                        self.remove_capture(h);
-                        capture.destroy(h).await?;
-                    }
                 },
                 _ = self.cancellation_token.cancelled() => break,
             }

src/capture_test.rs

@@ -1,3 +1,5 @@
+use std::sync::{Arc, Mutex};
+
 use crate::config::Config;
 use clap::Args;
 use futures::StreamExt;
@@ -12,7 +14,7 @@ pub async fn run(config: Config, _args: TestCaptureArgs) -> Result<(), InputCapt
     log::info!("creating input capture");
     let backend = config.capture_backend().map(|b| b.into());
     loop {
-        let mut input_capture = InputCapture::new(backend).await?;
+        let mut input_capture = InputCapture::new(backend, Arc::new(Mutex::new(None))).await?;
         log::info!("creating clients");
         input_capture.create(0, Position::Left).await?;
         input_capture.create(4, Position::Left).await?;

src/client.rs

@@ -15,6 +15,15 @@ pub struct ClientManager {
 }
 
 impl ClientManager {
+    /// get all clients
+    pub fn clients(&self) -> Vec<(ClientConfig, ClientState)> {
+        self.clients
+            .borrow()
+            .iter()
+            .map(|(_, c)| c.clone())
+            .collect::<Vec<_>>()
+    }
+
     /// add a new client to this manager
     pub fn add_client(&self) -> ClientHandle {
         self.clients.borrow_mut().insert(Default::default()) as ClientHandle

src/config.rs

@@ -5,12 +5,14 @@ use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::env::{self, VarError};
 use std::fmt::Display;
-use std::fs;
+use std::fs::{self, File};
+use std::io::Write;
 use std::net::IpAddr;
 use std::path::{Path, PathBuf};
 use std::{collections::HashSet, io};
 use thiserror::Error;
 use toml;
+use toml_edit::{self, DocumentMut};
 
 use lan_mouse_cli::CliArgs;
 use lan_mouse_ipc::{DEFAULT_PORT, Position};
@@ -44,7 +46,7 @@ fn default_path() -> Result<PathBuf, VarError> {
     Ok(PathBuf::from(default_path))
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Clone, Debug, Default)]
 struct ConfigToml {
     capture_backend: Option<CaptureBackend>,
     emulation_backend: Option<EmulationBackend>,
@@ -274,6 +276,33 @@ impl From<TomlClient> for ConfigClient {
     }
 }
 
+impl From<ConfigClient> for TomlClient {
+    fn from(client: ConfigClient) -> Self {
+        let hostname = client.hostname;
+        let host_name = None;
+        let mut ips = client.ips.into_iter().collect::<Vec<_>>();
+        ips.sort();
+        let ips = Some(ips);
+        let port = if client.port == DEFAULT_PORT {
+            None
+        } else {
+            Some(client.port)
+        };
+        let position = Some(client.pos);
+        let activate_on_startup = if client.active { Some(true) } else { None };
+        let enter_hook = client.enter_hook;
+        Self {
+            hostname,
+            host_name,
+            ips,
+            port,
+            position,
+            activate_on_startup,
+            enter_hook,
+        }
+    }
+}
+
 #[derive(Debug, Error)]
 pub enum ConfigError {
     #[error(transparent)]
@@ -384,4 +413,66 @@ impl Config {
             .and_then(|c| c.release_bind.clone())
             .unwrap_or(Vec::from_iter(DEFAULT_RELEASE_KEYS.iter().cloned()))
     }
+
+    /// set configured clients
+    pub fn set_clients(&mut self, clients: Vec<ConfigClient>) {
+        if clients.is_empty() {
+            return;
+        }
+        if self.config_toml.is_none() {
+            self.config_toml = Some(Default::default());
+        }
+        self.config_toml.as_mut().expect("config").clients =
+            Some(clients.into_iter().map(|c| c.into()).collect::<Vec<_>>());
+    }
+
+    /// set authorized keys
+    pub fn set_authorized_keys(&mut self, fingerprints: HashMap<String, String>) {
+        if fingerprints.is_empty() {
+            return;
+        }
+        if self.config_toml.is_none() {
+            self.config_toml = Some(Default::default());
+        }
+        self.config_toml
+            .as_mut()
+            .expect("config")
+            .authorized_fingerprints = Some(fingerprints);
+    }
+
+    pub fn write_back(&self) -> Result<(), io::Error> {
+        log::info!("writing config to {:?}", &self.config_path);
+        /* load the current configuration file */
+        let current_config = match fs::read_to_string(&self.config_path) {
+            Ok(c) => c.parse::<DocumentMut>().unwrap_or_default(),
+            Err(e) => {
+                log::info!("{:?} {e} => creating new config", self.config_path());
+                Default::default()
+            }
+        };
+        let _current_config =
+            toml_edit::de::from_document::<ConfigToml>(current_config).unwrap_or_default();
+
+        /* the new config */
+        let new_config = self.config_toml.clone().unwrap_or_default();
+        // let new_config = toml_edit::ser::to_document::<ConfigToml>(&new_config).expect("fixme");
+        let new_config = toml_edit::ser::to_string_pretty(&new_config).expect("config");
+
+        /*
+         * TODO merge documents => eventually we might want to split this up into clients configured
+         * via the config file and clients managed through the GUI / frontend.
+         * The latter should be saved to $XDG_DATA_HOME instead of $XDG_CONFIG_HOME,
+         * and clients configured through .config could be made permanent.
+         * For now we just override the config file.
+         */
+
+        /* write new config to file */
+        if let Some(p) = self.config_path().parent() {
+            fs::create_dir_all(p)?;
+        }
+        let mut f = File::create(self.config_path())?;
+        f.write_all(new_config.as_bytes())?;
+
+        Ok(())
+    }
 }

src/service.rs

@@ -1,7 +1,7 @@
 use crate::{
     capture::{Capture, CaptureType, ICaptureEvent},
     client::ClientManager,
-    config::Config,
+    config::{Config, ConfigClient},
     connect::LanMouseConnection,
     crypto,
     dns::{DnsEvent, DnsResolver},
@@ -19,7 +19,7 @@ use std::{
     collections::{HashMap, HashSet, VecDeque},
     io,
     net::{IpAddr, SocketAddr},
-    sync::{Arc, RwLock},
+    sync::{Arc, Mutex, RwLock},
 };
 use thiserror::Error;
 use tokio::{process::Command, signal, sync::Notify};
@@ -39,6 +39,8 @@ pub enum ServiceError {
 }
 
 pub struct Service {
+    /// configuration
+    config: Config,
     /// input capture
     capture: Capture,
     /// input emulation
@@ -68,6 +70,7 @@ pub struct Service {
     /// map from capture handle to connection info
     incoming_conn_info: HashMap<ClientHandle, Incoming>,
     next_trigger_handle: u64,
+    window_identifier: Arc<Mutex<Option<input_capture::WindowIdentifier>>>,
 }
 
 #[derive(Debug)]
@@ -113,7 +116,13 @@ impl Service {
 
         // input capture + emulation
         let capture_backend = config.capture_backend().map(|b| b.into());
-        let capture = Capture::new(capture_backend, conn, config.release_bind());
+        let window_identifier = Arc::new(Mutex::new(None));
+        let capture = Capture::new(
+            capture_backend,
+            conn,
+            config.release_bind(),
+            window_identifier.clone(),
+        );
         let emulation_backend = config.emulation_backend().map(|b| b.into());
         let emulation = Emulation::new(emulation_backend, listener);
 
@@ -122,6 +131,7 @@ impl Service {
 
         let port = config.port();
         let service = Self {
+            config,
             capture,
             emulation,
             frontend_listener,
@@ -137,6 +147,7 @@ impl Service {
             incoming_conn_info: Default::default(),
             incoming_conns: Default::default(),
             next_trigger_handle: 0,
+            window_identifier,
         };
         Ok(service)
     }
@@ -182,24 +193,87 @@ impl Service {
             Err(e) => return log::error!("error receiving request: {e}"),
         };
         match request {
-            FrontendRequest::Activate(handle, active) => self.set_client_active(handle, active),
+            FrontendRequest::Activate(handle, active) => {
-            FrontendRequest::AuthorizeKey(desc, fp) => self.add_authorized_key(desc, fp),
+                self.set_client_active(handle, active);
+                self.save_config();
+            }
+            FrontendRequest::AuthorizeKey(desc, fp) => {
+                self.add_authorized_key(desc, fp);
+                self.save_config();
+            }
             FrontendRequest::ChangePort(port) => self.change_port(port),
-            FrontendRequest::Create => self.add_client(),
+            FrontendRequest::Create => {
-            FrontendRequest::Delete(handle) => self.remove_client(handle),
+                self.add_client();
+                self.save_config();
+            }
+            FrontendRequest::Delete(handle) => {
+                self.remove_client(handle);
+                self.save_config();
+            }
             FrontendRequest::EnableCapture => self.capture.reenable(),
             FrontendRequest::EnableEmulation => self.emulation.reenable(),
             FrontendRequest::Enumerate() => self.enumerate(),
-            FrontendRequest::UpdateFixIps(handle, fix_ips) => self.update_fix_ips(handle, fix_ips),
+            FrontendRequest::UpdateFixIps(handle, fix_ips) => {
-            FrontendRequest::UpdateHostname(handle, host) => self.update_hostname(handle, host),
+                self.update_fix_ips(handle, fix_ips);
-            FrontendRequest::UpdatePort(handle, port) => self.update_port(handle, port),
+                self.save_config();
-            FrontendRequest::UpdatePosition(handle, pos) => self.update_pos(handle, pos),
+            }
+            FrontendRequest::UpdateHostname(handle, host) => {
+                self.update_hostname(handle, host);
+                self.save_config();
+            }
+            FrontendRequest::UpdatePort(handle, port) => {
+                self.update_port(handle, port);
+                self.save_config();
+            }
+            FrontendRequest::UpdatePosition(handle, pos) => {
+                self.update_pos(handle, pos);
+                self.save_config();
+            }
             FrontendRequest::ResolveDns(handle) => self.resolve(handle),
             FrontendRequest::Sync => self.sync_frontend(),
-            FrontendRequest::RemoveAuthorizedKey(key) => self.remove_authorized_key(key),
+            FrontendRequest::RemoveAuthorizedKey(key) => {
+                self.remove_authorized_key(key);
+                self.save_config();
+            }
             FrontendRequest::UpdateEnterHook(handle, enter_hook) => {
                 self.update_enter_hook(handle, enter_hook)
             }
+            FrontendRequest::SaveConfiguration => self.save_config(),
+            FrontendRequest::WindowIdentifier(handle) => {
+                log::info!("xdg-foreign handle: {handle:?}");
+                self.window_identifier
+                    .lock()
+                    .unwrap()
+                    .replace(match handle {
+                        lan_mouse_ipc::WindowIdentifier::Wayland(handle) => {
+                            input_capture::WindowIdentifier::Wayland(handle)
+                        }
+                        lan_mouse_ipc::WindowIdentifier::X11(xid) => {
+                            input_capture::WindowIdentifier::X11(xid)
+                        }
+                    });
+            }
+        }
+    }
+
+    fn save_config(&mut self) {
+        let clients = self.client_manager.clients();
+        let clients = clients
+            .into_iter()
+            .map(|(c, s)| ConfigClient {
+                ips: HashSet::from_iter(c.fix_ips),
+                hostname: c.hostname,
+                port: c.port,
+                pos: c.pos,
+                active: s.active,
+                enter_hook: c.cmd,
+            })
+            .collect();
+        self.config.set_clients(clients);
+        let authorized_keys = self.authorized_keys.read().expect("lock").clone();
+        self.config.set_authorized_keys(authorized_keys);
+        if let Err(e) = self.config.write_back() {
+            log::warn!("failed to write config: {e}");
         }
     }