Fix focus status fallback for unknown layers

Author: neko-kai

src/daemon/integration_tests.rs

@@ -2206,8 +2206,10 @@ async fn test_handle_focus_event_ignored_when_paused() {
             &status_broadcaster,
             &pause_broadcaster,
             &win,
+            &kanata,
             "default",
-        );
+        )
+        .await;
         assert!(actions.is_none(), "Expected no actions while paused");
         let msg = mock_server.recv_timeout(Duration::from_millis(500));
         assert!(msg.is_none(), "Expected no Kanata messages while paused");
@@ -2218,8 +2220,10 @@ async fn test_handle_focus_event_ignored_when_paused() {
             &status_broadcaster,
             &pause_broadcaster,
             &win,
+            &kanata,
             "default",
-        );
+        )
+        .await;
         assert!(actions.is_some(), "Expected actions after unpause");
         if let Some(actions) = actions {
             execute_focus_actions(&kanata, actions).await;
@@ -2292,8 +2296,10 @@ async fn test_unfocus_ignored_when_paused() {
             &status_broadcaster,
             &pause_broadcaster,
             &unfocus,
+            &kanata,
             "default",
-        );
+        )
+        .await;
         assert!(actions.is_none(), "Expected no actions while paused");
         let msg = mock_server.recv_timeout(Duration::from_millis(500));
         assert!(msg.is_none(), "Expected no Kanata messages while paused");

src/daemon/main.rs

@@ -1676,10 +1676,11 @@ fn extract_focus_layer(actions: &FocusActions) -> Option<String> {
     })
 }
 
-fn update_status_for_focus(
+async fn update_status_for_focus(
     handler: &Arc<Mutex<FocusHandler>>,
     status_broadcaster: &StatusBroadcaster,
     win: &WindowInfo,
+    kanata: &KanataClient,
     default_layer: &str,
 ) -> Option<FocusActions> {
     let (actions, virtual_keys, focus_layer) = {
@@ -1694,23 +1695,26 @@ fn update_status_for_focus(
 
     status_broadcaster.update_virtual_keys(virtual_keys);
     if let Some(layer) = focus_layer {
-        status_broadcaster.update_focus_layer(layer);
+        if let Some(resolved_layer) = kanata.resolve_layer_name(&layer, false).await {
+            status_broadcaster.update_focus_layer(resolved_layer);
+        }
     }
 
     actions
 }
 
-fn handle_focus_event(
+async fn handle_focus_event(
     handler: &Arc<Mutex<FocusHandler>>,
     status_broadcaster: &StatusBroadcaster,
     pause_broadcaster: &PauseBroadcaster,
     win: &WindowInfo,
+    kanata: &KanataClient,
     default_layer: &str,
 ) -> Option<FocusActions> {
     if pause_broadcaster.is_paused() {
         return None;
     }
-    update_status_for_focus(handler, status_broadcaster, win, default_layer)
+    update_status_for_focus(handler, status_broadcaster, win, kanata, default_layer).await
 }
 
 fn native_terminal_window() -> WindowInfo {
@@ -2001,8 +2005,11 @@ async fn apply_focus_for_env(
         status_broadcaster,
         pause_broadcaster,
         &win,
+        kanata,
         &default_layer,
-    ) {
+    )
+    .await
+    {
         execute_focus_actions(kanata, actions).await;
     }
     Ok(())
@@ -2037,8 +2044,11 @@ async fn apply_session_focus(
         status_broadcaster,
         pause_broadcaster,
         &win,
+        kanata,
         &default_layer,
-    ) {
+    )
+    .await
+    {
         execute_focus_actions(kanata, actions).await;
     }
 
@@ -2537,6 +2547,33 @@ impl KanataClient {
         }
     }
 
+    fn resolve_layer_name_from_inner(
+        inner: &KanataClientInner,
+        layer_name: &str,
+        warn_unknown: bool,
+    ) -> Option<String> {
+        if !inner.known_layers.is_empty()
+            && !inner.known_layers.iter().any(|layer| layer == layer_name)
+        {
+            if warn_unknown && !inner.quiet {
+                eprintln!(
+                    "[Kanata] Warning: Unknown layer \"{}\", switching to default instead",
+                    layer_name
+                );
+            }
+            return inner
+                .config_default_layer
+                .clone()
+                .or_else(|| inner.auto_default_layer.clone());
+        }
+        Some(layer_name.to_string())
+    }
+
+    async fn resolve_layer_name(&self, layer_name: &str, warn_unknown: bool) -> Option<String> {
+        let inner = self.inner.lock().await;
+        Self::resolve_layer_name_from_inner(&inner, layer_name, warn_unknown)
+    }
+
     pub async fn connect_with_retry(&self) {
         let delays = [0, 1000, 2000, 5000];
         let mut attempt = 0;
@@ -2744,28 +2781,11 @@ impl KanataClient {
     pub async fn change_layer(&self, layer_name: &str) -> bool {
         let mut inner = self.inner.lock().await;
 
-        // Validate layer exists if we have known layers
-        let target_layer = if !inner.known_layers.is_empty()
-            && !inner.known_layers.iter().any(|l| l == layer_name)
-        {
-            // Unknown layer - warn and fall back to default
-            if !inner.quiet {
-                eprintln!(
-                    "[Kanata] Warning: Unknown layer \"{}\", switching to default instead",
-                    layer_name
-                );
-            }
-            let default = inner
-                .config_default_layer
-                .clone()
-                .or_else(|| inner.auto_default_layer.clone());
-            match default {
-                Some(d) => d,
+        let target_layer =
+            match Self::resolve_layer_name_from_inner(&inner, layer_name, true) {
+                Some(layer) => layer,
                 None => return false,
-            }
-        } else {
-            layer_name.to_string()
-        };
+            };
 
         let current = inner.current_layer.clone();
         if current.as_deref() == Some(&target_layer) {
@@ -3303,8 +3323,11 @@ async fn run_wayland(
                 &status_broadcaster,
                 &pause_broadcaster,
                 &win,
+                &kanata,
                 &default_layer,
-            ) {
+            )
+            .await
+            {
                 execute_focus_actions(&kanata, actions).await;
             }
             continue;
@@ -3344,8 +3367,11 @@ async fn run_wayland(
             &status_broadcaster,
             &pause_broadcaster,
             &win,
+            &kanata,
             &default_layer,
-        ) {
+        )
+        .await
+        {
             execute_focus_actions(&kanata, actions).await;
         }
     }
@@ -3533,8 +3559,11 @@ async fn run_x11(
                         &status_broadcaster,
                         &pause_broadcaster,
                         &win,
+                        &kanata,
                         &default_layer,
-                    ) {
+                    )
+                    .await
+                    {
                         execute_focus_actions(&kanata, actions).await;
                     }
                 }
@@ -4276,12 +4305,16 @@ impl DbusWindowFocusService {
             .block_on(async { self.kanata.default_layer().await })
             .unwrap_or_default();
 
-        let actions = update_status_for_focus(
-            &self.handler,
-            &self.status_broadcaster,
-            &win,
-            &default_layer,
-        );
+        let actions = self.runtime_handle.block_on(async {
+            update_status_for_focus(
+                &self.handler,
+                &self.status_broadcaster,
+                &win,
+                &self.kanata,
+                &default_layer,
+            )
+            .await
+        });
 
         if let Some(actions) = actions {
             let kanata = self.kanata.clone();

src/daemon/tests.rs

@@ -717,27 +717,73 @@ fn test_sni_tooltip_includes_virtual_keys() {
     assert!(tooltip.contains("vk_media"));
 }
 
-#[test]
-fn test_update_status_for_focus_updates_snapshot() {
+#[tokio::test]
+async fn test_update_status_for_focus_updates_snapshot() {
     let rules = vec![rule(Some("firefox"), None, Some("browser"))];
     let handler = Arc::new(Mutex::new(FocusHandler::new(rules, None, true)));
     let status_broadcaster = StatusBroadcaster::new();
+    let kanata = KanataClient::new("127.0.0.1", 10000, None, true, status_broadcaster.clone());
 
     let win = win("firefox", "");
-    let actions = update_status_for_focus(&handler, &status_broadcaster, &win, "default");
+    let actions = update_status_for_focus(
+        &handler,
+        &status_broadcaster,
+        &win,
+        &kanata,
+        "default",
+    )
+    .await;
     assert!(actions.is_some());
 
     let snapshot = status_broadcaster.snapshot();
     assert_eq!(snapshot.layer, "browser");
     assert_eq!(snapshot.layer_source, LayerSource::Focus);
 }
 
-#[test]
-fn test_handle_focus_event_ignored_when_paused_no_status_change() {
+#[tokio::test]
+async fn test_update_status_for_focus_unknown_layer_uses_default() {
+    let rules = vec![rule(Some("firefox"), None, Some("browser"))];
+    let handler = Arc::new(Mutex::new(FocusHandler::new(rules, None, true)));
+    let status_broadcaster = StatusBroadcaster::new();
+    let kanata = KanataClient::new(
+        "127.0.0.1",
+        10000,
+        Some("default".to_string()),
+        true,
+        status_broadcaster.clone(),
+    );
+
+    {
+        let mut inner = kanata
+            .inner
+            .try_lock()
+            .expect("Expected KanataClient lock");
+        inner.known_layers = vec!["default".to_string()];
+    }
+
+    let win = win("firefox", "");
+    let actions = update_status_for_focus(
+        &handler,
+        &status_broadcaster,
+        &win,
+        &kanata,
+        "default",
+    )
+    .await;
+    assert!(actions.is_some());
+
+    let snapshot = status_broadcaster.snapshot();
+    assert_eq!(snapshot.layer, "default");
+    assert_eq!(snapshot.layer_source, LayerSource::Focus);
+}
+
+#[tokio::test]
+async fn test_handle_focus_event_ignored_when_paused_no_status_change() {
     let rules = vec![rule(Some("firefox"), None, Some("browser"))];
     let handler = Arc::new(Mutex::new(FocusHandler::new(rules, None, true)));
     let status_broadcaster = StatusBroadcaster::new();
     let pause_broadcaster = PauseBroadcaster::new();
+    let kanata = KanataClient::new("127.0.0.1", 10000, None, true, status_broadcaster.clone());
 
     pause_broadcaster.set_paused(true);
     let win = win("firefox", "");
@@ -746,8 +792,10 @@ fn test_handle_focus_event_ignored_when_paused_no_status_change() {
         &status_broadcaster,
         &pause_broadcaster,
         &win,
+        &kanata,
         "default",
-    );
+    )
+    .await;
     assert!(actions.is_none());
     let snapshot = status_broadcaster.snapshot();
     assert!(snapshot.layer.is_empty());
@@ -758,20 +806,23 @@ fn test_handle_focus_event_ignored_when_paused_no_status_change() {
         &status_broadcaster,
         &pause_broadcaster,
         &win,
+        &kanata,
         "default",
-    );
+    )
+    .await;
     assert!(actions.is_some());
     let snapshot = status_broadcaster.snapshot();
     assert_eq!(snapshot.layer, "browser");
     assert_eq!(snapshot.layer_source, LayerSource::Focus);
 }
 
-#[test]
-fn test_handle_focus_event_unfocus_paused_does_not_switch_layer() {
+#[tokio::test]
+async fn test_handle_focus_event_unfocus_paused_does_not_switch_layer() {
     let rules = vec![rule(Some("firefox"), None, Some("browser"))];
     let handler = Arc::new(Mutex::new(FocusHandler::new(rules, None, true)));
     let status_broadcaster = StatusBroadcaster::new();
     let pause_broadcaster = PauseBroadcaster::new();
+    let kanata = KanataClient::new("127.0.0.1", 10000, None, true, status_broadcaster.clone());
 
     status_broadcaster.update_layer("current".to_string(), LayerSource::External);
     pause_broadcaster.set_paused(true);
@@ -781,8 +832,10 @@ fn test_handle_focus_event_unfocus_paused_does_not_switch_layer() {
         &status_broadcaster,
         &pause_broadcaster,
         &WindowInfo::default(),
+        &kanata,
         "default",
-    );
+    )
+    .await;
     assert!(actions.is_none());
     let snapshot = status_broadcaster.snapshot();
     assert_eq!(snapshot.layer, "current");