guard by feature flag

.editorconfig

@@ -1,24 +0,0 @@
-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

@@ -1,34 +0,0 @@
-#!/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

@@ -7,10 +7,6 @@ on:
     branches: ["main"]
   workflow_dispatch:
 
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
 jobs:
   nix:
     strategy:
@@ -23,7 +19,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           submodules: recursive
 

.github/workflows/pre-release.yml

@@ -1,17 +1,10 @@
-name: "Release"
+name: "pre-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
@@ -20,40 +13,19 @@ jobs:
   linux-release-build:
     runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v6
+    - 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: |
+      run: cargo build --release
-        cargo build --release
-        cp target/release/lan-mouse lan-mouse-linux-x86_64
     - name: Upload build artifact
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v4
       with:
-        name: lan-mouse-linux-x86_64
+        name: lan-mouse-linux
-        path: lan-mouse-linux-x86_64
+        path: target/release/lan-mouse
-
-  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
@@ -92,7 +64,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@v6
+    - uses: actions/checkout@v4
     - name: Release Build
       run: cargo build --release
     - name: Create Archive
@@ -100,21 +72,19 @@ 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-x86_64.zip
+        Compress-Archive -Path "lan-mouse-windows\*" -DestinationPath lan-mouse-windows.zip
     - name: Upload build artifact
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v4
       with:
-        name: lan-mouse-windows-x86_64
+        name: lan-mouse-windows
-        path: lan-mouse-windows-x86_64.zip
+        path: lan-mouse-windows.zip
 
   macos-release-build:
     runs-on: macos-15-intel
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v4
     - name: install dependencies
-      run: |
+      run: brew install gtk4 libadwaita imagemagick
-        brew install --cask inkscape
-        brew install gtk4 libadwaita imagemagick librsvg
     - name: Release Build
       run: |
         cargo build --release
@@ -132,23 +102,21 @@ jobs:
         cd target/release/bundle/osx
         zip -r "lan-mouse-macos-intel.zip" "Lan Mouse.app"
     - name: Upload build artifact
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v4
       with:
         name: lan-mouse-macos-intel
         path: target/release/bundle/osx/lan-mouse-macos-intel.zip
 
-  macos-arm64-release-build:
+  macos-aarch64-release-build:
-    runs-on: macos-15
+    runs-on: macos-14
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v4
     - name: install dependencies
-      run: |
+      run: brew install gtk4 libadwaita imagemagick
-        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-arm64
+        cp target/release/lan-mouse lan-mouse-macos-aarch64
     - name: Make icns
       run: scripts/makeicns.sh
     - name: Install cargo bundle
@@ -160,45 +128,29 @@ jobs:
     - name: Zip bundle
       run: |
         cd target/release/bundle/osx
-        zip -r "lan-mouse-macos-arm64.zip" "Lan Mouse.app"
+        zip -r "lan-mouse-macos-aarch64.zip" "Lan Mouse.app"
     - name: Upload build artifact
-      uses: actions/upload-artifact@v6
+      uses: actions/upload-artifact@v4
       with:
-        name: lan-mouse-macos-arm64
+        name: lan-mouse-macos-aarch64
-        path: target/release/bundle/osx/lan-mouse-macos-arm64.zip
+        path: target/release/bundle/osx/lan-mouse-macos-aarch64.zip
 
-  release:
+  pre-release:
-    name: "Release"
+    name: "Pre Release"
-    needs: [windows-release-build, linux-release-build, linux-arm64-release-build, macos-release-build, macos-arm64-release-build]
+    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 Pre-Release
+    - name: Create Release
-      if: ${{ !startsWith(github.ref, 'refs/tags/') }}
+      uses: "marvinpinto/action-automatic-releases@latest"
-      uses: softprops/action-gh-release@v2
       with:
-        token: ${{ secrets.GITHUB_TOKEN }}
+        repo_token: "${{ secrets.GITHUB_TOKEN }}"
-        tag_name: ${{ github.event.inputs.name || github.ref_name }}
+        automatic_release_tag: "latest"
-        name: ${{ github.event.inputs.name || github.ref_name }}
         prerelease: true
-        generate_release_notes: true
+        title: "Development Build"
         files: |
-          lan-mouse-linux-x86_64/lan-mouse-linux-x86_64
+          lan-mouse-linux/lan-mouse
-          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-macos-aarch64/lan-mouse-macos-aarch64.zip
-          lan-mouse-windows-x86_64/lan-mouse-windows-x86_64.zip
+          lan-mouse-windows/lan-mouse-windows.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,16 +9,12 @@ on:
 env:
   CARGO_TERM_COLOR: always
 
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
 jobs:
   fmt:
     name: Formatting
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
       - name: cargo fmt
         run: cargo fmt --check
 
@@ -39,7 +35,7 @@ jobs:
           - clippy
           - test
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
       - uses: Swatinem/rust-cache@v2
       - name: Install Linux deps
         if: runner.os == 'Linux'

.github/workflows/tagged-release.yml

@@ -0,0 +1,150 @@
+name: "Tagged Release"
+
+on:
+  push:
+    tags:
+      - v**
+
+jobs:
+  linux-release-build:
+    runs-on: ubuntu-22.04
+    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

@@ -1,65 +0,0 @@
-# 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

@@ -67,7 +67,6 @@ rustls = { version = "0.23.12", default-features = false, features = [
 ] }
 rcgen = "0.13.1"
 sha2 = "0.10.8"
-notify = "8.2.0"
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2.148"

README.md

@@ -1,9 +1,4 @@
 # 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.
@@ -182,27 +177,8 @@ For a detailed list of available features, checkout the [Cargo.toml](./Cargo.tom
 
 
 
-## Development
 
-### Git pre-commit hook
+## Installing Dependencies for Development / Compiling from Source
-
-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>
 
@@ -475,4 +451,4 @@ The following sections detail the emulation and capture backends provided by lan
 - `libei`: This backend uses [libei](https://gitlab.freedesktop.org/libinput/libei) and is supported by GNOME >= 45 or KDE Plasma >= 6.1.
 - `windows`: Backend for input capture on Windows.
 - `macos`: Backend for input capture on MacOS.
-- `x11`: TODO (not yet supported)
+- `x11`: TODO (not yet supported)

flake.lock

@@ -2,11 +2,11 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1772963539,
+        "lastModified": 1770841267,
-        "narHash": "sha256-9jVDGZnvCckTGdYT53d/EfznygLskyLQXYwJLKMPsZs=",
+        "narHash": "sha256-9xejG0KoqsoKEGp2kVbXRlEYtFFcDTHjidiuX8hGO44=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "9dcb002ca1690658be4a04645215baea8b95f31d",
+        "rev": "ec7c70d12ce2fc37cb92aff673dcdca89d187bae",
         "type": "github"
       },
       "original": {
@@ -29,11 +29,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1773025773,
+        "lastModified": 1770952264,
-        "narHash": "sha256-Wik8+xApNfldpUFjPmJkPdg0RrvUPSWGIZis+A/0N1w=",
+        "narHash": "sha256-CjymNrJZWBtpavyuTkfPVPaZkwzIzGaf0E/3WgcwM14=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "3c06fdbbd36ff60386a1e590ee0cd52dcd1892bf",
+        "rev": "ec6a3d5cdf14bb5a1dd03652bd3f6351004d2188",
         "type": "github"
       },
       "original": {

flake.nix

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

input-capture/Cargo.toml

@@ -41,7 +41,7 @@ wayland-protocols-wlr = { version = "0.3.1", features = [
     "client",
 ], optional = true }
 x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.13.9", default-features = false, features = [
+ashpd = { version = "0.13.0", default-features = false, features = [
     "input_capture",
     "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

@@ -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,
@@ -161,13 +161,17 @@ async fn update_barriers(
 
 async fn create_session(
     input_capture: &InputCapture,
+    window_identifier: Arc<Mutex<Option<WindowIdentifier>>>,
 ) -> std::result::Result<(Session<InputCapture>, BitFlags<Capabilities>), ashpd::Error> {
-    log::debug!("creating input capture session");
+    log::debug!("creating input capture session: {window_identifier:?}");
+    let window_identifier = window_identifier.lock().unwrap().clone();
     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(None, create_session_options)
+        .create_session(ashpd_window_identifier.as_ref(), create_session_options)
         .await
 }
 
@@ -212,10 +216,15 @@ async fn libei_event_handler(
 }
 
 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;
-        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);
@@ -230,6 +239,7 @@ impl LibeiInputCapture {
             first_session,
             event_tx,
             cancellation_token.clone(),
+            window_identifier,
         );
         let capture_task = tokio::task::spawn_local(capture);
 
@@ -254,6 +264,7 @@ async fn do_capture(
     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);
 
@@ -299,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(

input-emulation/Cargo.toml

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

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/src/lib.rs

@@ -255,6 +255,14 @@ pub enum FrontendRequest {
     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,40 +1,34 @@
 {
-  stdenv,
   rustPlatform,
   lib,
-  pkg-config,
+  pkgs,
-  libX11,
+}: let
-  gtk4,
+  cargoToml = builtins.fromTOML (builtins.readFile ../Cargo.toml);
-  libadwaita,
-  libXtst,
-  wrapGAppsHook4,
-  librsvg,
-  git,
-}:
-let
-  cargoToml = fromTOML (builtins.readFile ../Cargo.toml);
   pname = cargoToml.package.name;
   version = cargoToml.package.version;
 in
 rustPlatform.buildRustPackage {
-  inherit pname;
+  pname = pname;
-  inherit version;
+  version = version;
 
-  nativeBuildInputs = [
+  nativeBuildInputs = with pkgs; [
-    pkg-config
-    wrapGAppsHook4
     git
+    pkg-config
+    cmake
+    makeWrapper
+    buildPackages.gtk4
   ];
 
-  buildInputs = [
+  buildInputs = with pkgs; [
+    xorg.libX11
     gtk4
     libadwaita
-    librsvg
+    xorg.libXtst
-  ]
+  ] ++ lib.optionals stdenv.isDarwin
-  ++ lib.optionals stdenv.isLinux [
+  (with darwin.apple_sdk_11_0.frameworks; [
-    libX11
+    CoreGraphics
-    libXtst
+    ApplicationServices
-  ];
+  ]);
 
   src = builtins.path {
     name = pname;
@@ -46,7 +40,11 @@ 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 "$svg" -background none -resize 1024x1024 "$iconset"/icon_512x512@2x.png
+magick convert -background none -resize 1024x1024 "$svg" "$iconset"/icon_512x512@2x.png
-magick "$svg" -background none -resize 512x512 "$iconset"/icon_512x512.png
+magick convert -background none -resize 512x512 "$svg" "$iconset"/icon_512x512.png
-magick "$svg" -background none -resize 256x256 "$iconset"/icon_256x256.png
+magick convert -background none -resize 256x256 "$svg" "$iconset"/icon_256x256.png
-magick "$svg" -background none -resize 128x128 "$iconset"/icon_128x128.png
+magick convert -background none -resize 128x128 "$svg" "$iconset"/icon_128x128.png
-magick "$svg" -background none -resize 64x64 "$iconset"/icon_32x32@2x.png
+magick convert -background none -resize 64x64 "$svg" "$iconset"/icon_32x32@2x.png
-magick "$svg" -background none -resize 32x32 "$iconset"/icon_32x32.png
+magick convert -background none -resize 32x32 "$svg" "$iconset"/icon_32x32.png
-magick "$svg" -background none -resize 16x16 "$iconset"/icon_16x16.png
+magick convert -background none -resize 16x16 "$svg" "$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;
@@ -59,8 +61,6 @@ enum CaptureRequest {
     Destroy(CaptureHandle),
     /// reenable input capture
     Reenable,
-    /// set release bind
-    SetReleaseBind(Vec<scancode::Linux>),
 }
 
 impl Capture {
@@ -68,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();
@@ -82,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 {
@@ -133,10 +135,6 @@ impl Capture {
     pub(crate) async fn event(&mut self) -> ICaptureEvent {
         self.event_rx.recv().await.expect("channel closed")
     }
-
-    pub(crate) fn set_release_bind(&mut self, bind: Vec<scancode::Linux>) {
-        let _ = self.request_tx.send(CaptureRequest::SetReleaseBind(bind));
-    }
 }
 
 /// debounce a statement `$st`, i.e. the statement is executed only if the
@@ -166,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 {
@@ -200,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}");
@@ -207,13 +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=>{}
-                        CaptureRequest::SetReleaseBind(bind) => {
-                            self.release_bind.borrow_mut().clone_from(&bind);
-                        }
                     },
                     _ = self.cancellation_token.cancelled() => return,
                 }
@@ -224,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(()),
         };
 
@@ -294,19 +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?;
-                    }
-                    CaptureRequest::SetReleaseBind(bind) => {
-                        self.release_bind.borrow_mut().clone_from(&bind);
-                    }
                 },
                 _ = 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

@@ -9,8 +9,6 @@ use slab::Slab;
 
 use lan_mouse_ipc::{ClientConfig, ClientHandle, ClientState, Position};
 
-use crate::config::ConfigClient;
-
 #[derive(Clone, Default)]
 pub struct ClientManager {
     clients: Rc<RefCell<Slab<(ClientConfig, ClientState)>>>,
@@ -26,25 +24,6 @@ impl ClientManager {
             .collect::<Vec<_>>()
     }
 
-    pub fn add_with_config(&self, config_client: ConfigClient) -> ClientHandle {
-        let config = ClientConfig {
-            hostname: config_client.hostname,
-            fix_ips: config_client.ips.into_iter().collect(),
-            port: config_client.port,
-            pos: config_client.pos,
-            cmd: config_client.enter_hook,
-        };
-        let state = ClientState {
-            active: config_client.active,
-            ips: HashSet::from_iter(config.fix_ips.iter().cloned()),
-            ..Default::default()
-        };
-        let handle = self.add_client();
-        self.set_config(handle, config);
-        self.set_state(handle, state);
-        handle
-    }
-
     /// add a new client to this manager
     pub fn add_client(&self) -> ClientHandle {
         self.clients.borrow_mut().insert(Default::default()) as ClientHandle
@@ -251,15 +230,6 @@ impl ClientManager {
             .and_then(|(c, _)| c.cmd.clone())
     }
 
-    /// returns all clients that are currently registered
-    pub(crate) fn registered_clients(&self) -> Vec<ClientHandle> {
-        self.clients
-            .borrow()
-            .iter()
-            .map(|(h, _)| h as ClientHandle)
-            .collect()
-    }
-
     /// returns all clients that are currently active
     pub(crate) fn active_clients(&self) -> Vec<ClientHandle> {
         self.clients

src/config.rs

@@ -1,7 +1,6 @@
 use crate::capture_test::TestCaptureArgs;
 use crate::emulation_test::TestEmulationArgs;
 use clap::{Parser, Subcommand, ValueEnum};
-use notify::{EventKind, RecommendedWatcher, Watcher};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::env::{self, VarError};
@@ -47,7 +46,7 @@ fn default_path() -> Result<PathBuf, VarError> {
     Ok(PathBuf::from(default_path))
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
+#[derive(Serialize, Deserialize, Clone, Debug, Default)]
 struct ConfigToml {
     capture_backend: Option<CaptureBackend>,
     emulation_backend: Option<EmulationBackend>,
@@ -245,14 +244,8 @@ pub struct Config {
     cert_path: PathBuf,
     /// path to the config file used
     config_path: PathBuf,
-    /// path to config directory (parent of above)
-    config_dir: PathBuf,
     /// the (optional) toml config and it's path
     config_toml: Option<ConfigToml>,
-    // filesystem watcher
-    watcher: notify::RecommendedWatcher,
-    // channel for filesystem events
-    watch_rx: tokio::sync::mpsc::Receiver<Result<notify::Event, notify::Error>>,
 }
 
 pub struct ConfigClient {
@@ -318,8 +311,6 @@ pub enum ConfigError {
     Io(#[from] io::Error),
     #[error(transparent)]
     Var(#[from] VarError),
-    #[error(transparent)]
-    Watcher(#[from] notify::Error),
 }
 
 const DEFAULT_RELEASE_KEYS: [scancode::Linux; 4] =
@@ -351,55 +342,12 @@ impl Config {
             .or(config_toml.as_ref().and_then(|c| c.cert_path.clone()))
             .unwrap_or(default_path()?.join(CERT_FILE_NAME));
 
-        let (tx, watch_rx) = tokio::sync::mpsc::channel(16);
+        Ok(Config {
-        let watcher = RecommendedWatcher::new(
-            move |res| {
-                let _ = tx.blocking_send(res);
-            },
-            notify::Config::default(),
-        )?;
-        let config_dir = config_path
-            .parent()
-            .expect("config directory")
-            .to_path_buf();
-        let mut config = Config {
             args,
             cert_path,
             config_path,
-            config_dir,
             config_toml,
-            watcher,
+        })
-            watch_rx,
-        };
-        config.watch()?;
-        Ok(config)
-    }
-
-    fn watch(&mut self) -> Result<(), notify::Error> {
-        self.watcher
-            .watch(&self.config_dir, notify::RecursiveMode::NonRecursive)?;
-        Ok(())
-    }
-
-    fn unwatch(&mut self) -> Result<(), notify::Error> {
-        self.watcher.unwatch(&self.config_dir)?;
-        Ok(())
-    }
-
-    pub async fn changed(&mut self) -> Result<(), notify::Error> {
-        loop {
-            let event = self.watch_rx.recv().await.expect("channel closed");
-            let event = event.expect("filesystem event");
-            if event.paths.contains(&self.config_path)
-                && matches!(
-                    event.kind,
-                    EventKind::Create(_) | EventKind::Modify(_) | EventKind::Remove(_)
-                )
-                && self.read_from_disk()?
-            {
-                return Ok(());
-            }
-        }
     }
 
     /// the command to run
@@ -480,8 +428,11 @@ impl Config {
 
     /// 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 = Default::default();
         }
         self.config_toml
             .as_mut()
@@ -489,58 +440,38 @@ impl Config {
             .authorized_fingerprints = Some(fingerprints);
     }
 
-    pub fn read_from_disk(&mut self) -> Result<bool, io::Error> {
+    pub fn write_back(&self) -> Result<(), io::Error> {
-        log::info!("reading config from {:?}", &self.config_path);
-
-        let current_config = fs::read_to_string(&self.config_path)?;
-        let current_config = match current_config.parse::<DocumentMut>() {
-            Ok(c) => c,
-            Err(e) => {
-                log::warn!("{:?} {e}", self.config_path());
-                return Ok(false);
-            }
-        };
-        let mut changed = false;
-        match toml_edit::de::from_document::<ConfigToml>(current_config) {
-            Ok(current_config) => {
-                changed = self
-                    .config_toml
-                    .as_ref()
-                    .is_none_or(|c| c != &current_config);
-                self.config_toml.replace(current_config);
-            }
-            Err(e) => log::warn!("{:?} {e}", self.config_path()),
-        };
-        Ok(changed)
-    }
-
-    pub fn write_back(&mut 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 with current config file to preserve comments
+         * TODO merge documents => eventually we might want to split this up into clients configured
-         * => 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.
          */
 
-        let _ = self.unwatch();
         /* 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())?;
-            let mut f = File::create(self.config_path())?;
+        f.write_all(new_config.as_bytes())?;
-            f.write_all(new_config.as_bytes())?;
-            f.sync_all()?;
-        }
-
-        let _ = self.watch();
 
         Ok(())
     }

src/service.rs

@@ -11,15 +11,15 @@ use crate::{
 use futures::StreamExt;
 use hickory_resolver::ResolveError;
 use lan_mouse_ipc::{
-    AsyncFrontendListener, ClientHandle, FrontendEvent, FrontendRequest, IpcError,
+    AsyncFrontendListener, ClientConfig, ClientHandle, ClientState, FrontendEvent, FrontendRequest,
-    IpcListenerCreationError, Position, Status,
+    IpcError, IpcListenerCreationError, Position, Status,
 };
 use log;
 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};
@@ -70,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)]
@@ -83,7 +84,21 @@ impl Service {
     pub async fn new(config: Config) -> Result<Self, ServiceError> {
         let client_manager = ClientManager::default();
         for client in config.clients() {
-            client_manager.add_with_config(client);
+            let config = ClientConfig {
+                hostname: client.hostname,
+                fix_ips: client.ips.into_iter().collect(),
+                port: client.port,
+                pos: client.pos,
+                cmd: client.enter_hook,
+            };
+            let state = ClientState {
+                active: client.active,
+                ips: HashSet::from_iter(config.fix_ips.iter().cloned()),
+                ..Default::default()
+            };
+            let handle = client_manager.add_client();
+            client_manager.set_config(handle, config);
+            client_manager.set_state(handle, state);
         }
 
         // load certificate
@@ -101,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);
 
@@ -126,6 +147,7 @@ impl Service {
             incoming_conn_info: Default::default(),
             incoming_conns: Default::default(),
             next_trigger_handle: 0,
+            window_identifier,
         };
         Ok(service)
     }
@@ -150,7 +172,6 @@ impl Service {
                 event = self.emulation.event() => self.handle_emulation_event(event),
                 event = self.capture.event() => self.handle_capture_event(event),
                 event = self.resolver.event() => self.handle_resolver_event(event),
-                _ = self.config.changed() => self.handle_config_change(),
                 r = signal::ctrl_c() => break r.expect("failed to wait for CTRL+C"),
             }
         }
@@ -218,6 +239,20 @@ impl Service {
                 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)
+                        }
+                    });
+            }
         }
     }
 
@@ -242,30 +277,6 @@ impl Service {
         }
     }
 
-    fn handle_config_change(&mut self) {
-        for h in self.client_manager.registered_clients() {
-            self.remove_client(h);
-        }
-        for c in self.config.clients() {
-            let handle = self.client_manager.add_with_config(c);
-            log::info!("added client {handle}");
-            let (c, s) = self.client_manager.get_state(handle).unwrap();
-            if s.active {
-                self.client_manager.deactivate_client(handle);
-                self.activate_client(handle);
-            }
-            self.notify_frontend(FrontendEvent::Created(handle, c, s));
-        }
-        let release_bind = self.config.release_bind();
-        self.capture.set_release_bind(release_bind);
-        let authorized_keys = self.config.authorized_fingerprints();
-        self.authorized_keys
-            .write()
-            .unwrap()
-            .clone_from(&authorized_keys);
-        self.sync_frontend();
-    }
-
     async fn handle_frontend_pending(&mut self) {
         while let Some(event) = self.pending_frontend_events.pop_front() {
             self.frontend_listener.broadcast(event).await;
@@ -488,7 +499,7 @@ impl Service {
     }
 
     fn activate_client(&mut self, handle: ClientHandle) {
-        log::debug!("activating client {handle}");
+        log::debug!("activating client");
 
         /* resolve dns on activate */
         self.resolve(handle);