fix bug: listen for pause/unpause commands on DBus for wlroots & X11 backends.

Author: neko-kai

llm-docs/LLM-TODO.md

@@ -45,3 +45,4 @@ The project daemon is located at `src/daemon/` (Rust).
 - 2026-01-23: Legacy kanata support - versions without `RequestFakeKeyNames` API are detected via error response, reconnect skips the request. VK validation is bypassed for legacy kanata (all VKs pass through).
 - 2026-01-23: Config Rule struct uses `#[serde(deny_unknown_fields)]` to reject typos like `native_terminal` (should be `on_native_terminal`).
 - 2026-01-23: Rules without class/title matchers require `fallthrough: true` (otherwise would match everything and stop further matching).
+- 2026-01-27: DBus control service starts on Wayland/X11 regardless of SNI status so Pause/Unpause/Restart commands still work if SNI fails.

qa/desktop-backends-checklist.md

@@ -1,7 +1,7 @@
 # Desktop Backends Checklist
 
-Last tested: 2026-01-22
-Environment: NixOS, KDE, Wayland
+Last tested: 2026-01-27
+Environment: NixOS, Hyprland, Wayland
 
 ## KDE Plasma
 - [x] KWin script loads automatically
@@ -11,14 +11,14 @@ Environment: NixOS, KDE, Wayland
 - [x] DBus backend stays connected
 
 ## wlroots (Sway/Hyprland/Niri)
-- [ ] wlr-foreign-toplevel events received
-- [ ] Focus changes trigger expected actions
-- [ ] Daemon start applies current focused window without extra focus change
-- [ ] Pause/unpause re-queries current focus (no cached focus)
+- [x] wlr-foreign-toplevel events received
+- [x] Focus changes trigger expected actions
+- [x] Daemon start applies current focused window without extra focus change
+- [x] Pause/unpause re-queries current focus (no cached focus)
 
 ## COSMIC
-- [ ] cosmic-toplevel-info events received
-- [ ] Focus changes trigger expected actions
+- [x] cosmic-toplevel-info events received
+- [x] Focus changes trigger expected actions
 - [ ] Daemon start applies current focused window without extra focus change
 - [ ] Pause/unpause re-queries current focus (no cached focus)
 

qa/installation-checklist.md

@@ -1,11 +1,11 @@
 # Installation Checklist
 
-Last tested: 2026-01-22
-Environment: NixOS, KDE, Wayland
+Last tested: 2026-01-27
+Environment: NixOS, Hyprland, Wayland
 
 ## Cargo install
-- [ ] `cargo install --path .` succeeds
-- [ ] Binary is on PATH (or invoked directly)
+- [x] `cargo install --path .` succeeds
+- [x] Binary is on PATH (or invoked directly)
 - [x] `kanata-switcher --help` shows CLI options
 
 ## Nix install
@@ -23,5 +23,5 @@ Environment: NixOS, KDE, Wayland
 
 ## Config discovery
 - [x] Default config path `~/.config/kanata/kanata-switcher.json` is used
-- [ ] Missing config errors show example config
-- [ ] Explicit `--config` path is honored
+- [x] Missing config errors show example config
+- [x] Explicit `--config` path is honored

qa/sni-indicator-checklist.md

@@ -1,19 +1,20 @@
 # SNI Indicator Checklist (Non-GNOME)
 
-Last tested: 2026-01-22
-Environment: KDE, KDE Panel, Wayland
+Last tested: 2026-01-29
+Environment: Hyprland, No Panel, Wayland
 
 ## Indicator lifecycle
 - [x] SNI indicator appears by default on non-GNOME
 - [x] `--no-indicator` suppresses it
 - [x] Logs show SNI startup and watcher online/offline
-- [ ] Logs show SNI watcher offline
+- [x] Logs show SNI watcher offline
 
 ## Visual behavior
 - [x] Layer glyph updates on focus changes
 - [x] VK glyph updates (single key / count / overflow)
 - [x] Layer glyph is white and VK glyph is cyan (matches GNOME indicator)
-- [ ] Glyphs use Noto Sans Mono bitmap (size 32) and VK overflow shows "9+"
+- [x] Glyphs use Noto Sans Mono bitmap (size 32)
+- [ ] VK overflow shows "9+"
 - [x] Tooltip shows layer and virtual keys
 
 ## Menu actions
@@ -28,4 +29,4 @@ Environment: KDE, KDE Panel, Wayland
 - [x] `--indicator-focus-only true|false` overrides startup value without locking the toggle
 
 ## Failure behavior
-- [ ] If SNI cannot be started, daemon keeps running and logs error
+- [x] If SNI cannot be started, daemon keeps running and logs error

src/daemon/integration_tests.rs

@@ -2297,6 +2297,110 @@ async fn test_handle_focus_event_ignored_when_paused() {
     .await;
 }
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn test_dbus_pause_wayland_env() {
+    with_test_timeout(async {
+        use zbus::connection::Builder;
+
+        let dbus = DbusSessionGuard::start()
+            .expect("Failed to start dbus-daemon. Run `nix run .#test` or install dbus.");
+
+        let mock_server = MockKanataServer::start();
+
+        let rules = vec![Rule {
+            class: Some("test-app".to_string()),
+            title: None,
+            on_native_terminal: None,
+            layer: Some("browser".to_string()),
+            virtual_key: None,
+            raw_vk_action: None,
+            fallthrough: false,
+        }];
+
+        let address: zbus::Address = dbus.address().parse().expect("Invalid bus address");
+
+        let status_broadcaster = StatusBroadcaster::new();
+        let pause_broadcaster = PauseBroadcaster::new();
+        let pause_state = pause_broadcaster.clone();
+        let handler = Arc::new(Mutex::new(FocusHandler::new(rules, None, true)));
+        let kanata = KanataClient::new(
+            "127.0.0.1",
+            mock_server.port(),
+            Some("default".to_string()),
+            true,
+            status_broadcaster.clone(),
+        );
+        kanata.connect_with_retry().await;
+
+        drain_kanata_messages(&mock_server, Duration::from_millis(100));
+
+        let service_connection = Builder::address(address.clone())
+            .expect("Failed to create connection builder")
+            .build()
+            .await
+            .expect("Failed to connect to private bus");
+        let focus_query_connection = Builder::address(address.clone())
+            .expect("Failed to create focus query builder")
+            .build()
+            .await
+            .expect("Failed to connect focus query bus");
+
+        let restart_handle = RestartHandle::new();
+        register_dbus_service(
+            &service_connection,
+            focus_query_connection,
+            Environment::Wayland,
+            false,
+            kanata,
+            handler,
+            status_broadcaster,
+            restart_handle,
+            pause_broadcaster,
+        )
+        .await
+        .expect("Failed to register service");
+
+        let client = Builder::address(address)
+            .expect("Failed to create client builder")
+            .build()
+            .await
+            .expect("Failed to connect client");
+
+        let dbus_proxy = zbus::fdo::DBusProxy::new(&client)
+            .await
+            .expect("Failed to create DBus proxy");
+        wait_for_async(|| {
+            let proxy = dbus_proxy.clone();
+            async move {
+                proxy
+                    .name_has_owner("com.github.kanata.Switcher".try_into().unwrap())
+                    .await
+                    .ok()
+                    .filter(|&has_owner| has_owner)
+            }
+        })
+        .await
+        .expect("Timeout waiting for service registration");
+
+        let pause_result = client
+            .call_method(
+                Some("com.github.kanata.Switcher"),
+                "/com/github/kanata/Switcher",
+                Some("com.github.kanata.Switcher"),
+                "Pause",
+                &(),
+            )
+            .await;
+        assert!(
+            pause_result.is_ok(),
+            "DBus Pause failed: {:?}",
+            pause_result.err()
+        );
+        assert!(pause_state.is_paused(), "Expected daemon to be paused");
+    })
+    .await;
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
 async fn test_control_command_returns_error_without_service() {
     with_test_timeout(async {

src/daemon/main.rs

@@ -3867,6 +3867,18 @@ impl Drop for SniGuard {
     }
 }
 
+struct DbusControlGuard {
+    _connection: Connection,
+}
+
+impl DbusControlGuard {
+    fn new(connection: Connection) -> Self {
+        Self {
+            _connection: connection,
+        }
+    }
+}
+
 fn dconf_get_bool(key: &str) -> Result<bool, String> {
     let output = Command::new("dconf")
         .args(["read", key])
@@ -5008,6 +5020,30 @@ async fn run_once() -> Result<RunOutcome, Box<dyn std::error::Error + Send + Syn
         .await;
     }
 
+    let dbus_control_guard = if matches!(env, Environment::Wayland | Environment::X11) {
+        let handler = focus_handler
+            .clone()
+            .expect("Focus handler missing for DBus control service");
+        let connection = Connection::session().await?;
+        let focus_query_connection = Connection::session().await?;
+        register_dbus_service(
+            &connection,
+            focus_query_connection,
+            env,
+            false,
+            kanata.clone(),
+            handler,
+            status_broadcaster.clone(),
+            restart_handle.clone(),
+            pause_broadcaster.clone(),
+        )
+        .await?;
+        Some(DbusControlGuard::new(connection))
+    } else {
+        None
+    };
+    let _dbus_control_guard = dbus_control_guard;
+
     // Create shutdown guard - will switch to default layer when dropped
     let _shutdown_guard = ShutdownGuard::new(kanata.clone());