Merge pull request 'feature/events' (#2) from feature/events into main

Reviewed-on: #2

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fluxo-rs"
-version = "0.3.1"
+version = "0.3.3"
 edition = "2024"
 
 [dependencies]
@@ -12,16 +12,18 @@ serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.149"
 sysinfo = "0.38.4"
 thiserror = "2.0"
-toml = "1.1.1"
+toml = "1.1.2"
 tracing = "0.1.44"
 tracing-subscriber = { version = "0.3.23", features = ["env-filter"] }
 maestro = { git = "https://github.com/qzed/pbpctrl", package = "maestro" }
 bluer = { version = "0.17", features = ["bluetoothd", "rfcomm", "id"] }
-tokio = { version = "1", features = ["rt", "rt-multi-thread", "sync", "time", "macros", "signal"] }
+tokio = { version = "1", features = ["rt", "rt-multi-thread", "sync", "time", "macros", "signal", "process"] }
-tokio-util = { version = "0.7", features = ["codec"] }
+tokio-util = { version = "0.7", features = ["codec", "time"] }
 futures = "0.3"
 libpulse-binding = "2.30"
 nix = { version = "0.31", features = ["net"] }
+notify = "8.2.0"
+zbus = "4"
 
 [dev-dependencies]
 

example.config.toml

@@ -1,7 +1,7 @@
 # Fluxo configuration example
 
 [general]
-menu_command = "fuzzel --dmenu --prompt '{prompt}'"
+menu_command = "fuzzel --dmenu --prompt \"$FLUXO_PROMPT\""
 
 [network]
 format = "{interface} ({ip}):  {rx:>5.2} MB/s   {tx:>5.2} MB/s"

src/config.rs

@@ -10,6 +10,8 @@ pub struct Config {
     #[serde(default)]
     pub general: GeneralConfig,
     #[serde(default)]
+    pub signals: SignalsConfig,
+    #[serde(default)]
     pub network: NetworkConfig,
     #[serde(default)]
     pub cpu: CpuConfig,
@@ -31,6 +33,14 @@ pub struct Config {
     pub bt: BtConfig,
     #[serde(default)]
     pub game: GameConfig,
+    #[serde(default)]
+    pub mpris: MprisConfig,
+    #[serde(default)]
+    pub backlight: BacklightConfig,
+    #[serde(default)]
+    pub keyboard: KeyboardConfig,
+    #[serde(default)]
+    pub dnd: DndConfig,
 }
 
 #[derive(Deserialize, Clone)]
@@ -41,11 +51,31 @@ pub struct GeneralConfig {
 impl Default for GeneralConfig {
     fn default() -> Self {
         Self {
-            menu_command: "fuzzel --dmenu --prompt '{prompt}'".to_string(),
+            menu_command: "fuzzel --dmenu --prompt \"$FLUXO_PROMPT\"".to_string(),
         }
     }
 }
 
+#[allow(dead_code)]
+#[derive(Deserialize, Default, Clone)]
+pub struct SignalsConfig {
+    pub network: Option<i32>,
+    pub cpu: Option<i32>,
+    pub memory: Option<i32>,
+    pub gpu: Option<i32>,
+    pub sys: Option<i32>,
+    pub disk: Option<i32>,
+    pub pool: Option<i32>,
+    pub power: Option<i32>,
+    pub audio: Option<i32>,
+    pub bt: Option<i32>,
+    pub game: Option<i32>,
+    pub mpris: Option<i32>,
+    pub backlight: Option<i32>,
+    pub keyboard: Option<i32>,
+    pub dnd: Option<i32>,
+}
+
 #[derive(Deserialize, Clone)]
 pub struct NetworkConfig {
     pub format: String,
@@ -209,6 +239,60 @@ impl Default for GameConfig {
     }
 }
 
+#[derive(Deserialize, Clone)]
+pub struct MprisConfig {
+    pub format: String,
+}
+
+impl Default for MprisConfig {
+    fn default() -> Self {
+        Self {
+            format: "{status_icon} {artist} - {title}".to_string(),
+        }
+    }
+}
+
+#[derive(Deserialize, Clone)]
+pub struct BacklightConfig {
+    pub format: String,
+}
+
+impl Default for BacklightConfig {
+    fn default() -> Self {
+        Self {
+            format: "{percentage:>3}% {icon}".to_string(),
+        }
+    }
+}
+
+#[derive(Deserialize, Clone)]
+pub struct KeyboardConfig {
+    pub format: String,
+}
+
+impl Default for KeyboardConfig {
+    fn default() -> Self {
+        Self {
+            format: "{layout}".to_string(),
+        }
+    }
+}
+
+#[derive(Deserialize, Clone)]
+pub struct DndConfig {
+    pub format_dnd: String,
+    pub format_normal: String,
+}
+
+impl Default for DndConfig {
+    fn default() -> Self {
+        Self {
+            format_dnd: "<span size='large'>󰂛</span>".to_string(),
+            format_normal: "<span size='large'>󰂚</span>".to_string(),
+        }
+    }
+}
+
 static TOKEN_RE: LazyLock<Regex> =
     LazyLock::new(|| Regex::new(r"\{([a-zA-Z0-9_]+)(?::([<>\^])?(\d+)?(?:\.(\d+))?)?\}").unwrap());
 
@@ -284,6 +368,13 @@ impl Config {
             &self.bt.format_plugin,
             &["alias", "left", "right", "anc", "mac"],
         );
+        validate_format(
+            "mpris",
+            &self.mpris.format,
+            &["artist", "title", "album", "status_icon"],
+        );
+        validate_format("backlight", &self.backlight.format, &["percentage", "icon"]);
+        validate_format("keyboard", &self.keyboard.format, &["layout"]);
     }
 }
 
@@ -330,7 +421,7 @@ mod tests {
         let config = Config::default();
         assert_eq!(
             config.general.menu_command,
-            "fuzzel --dmenu --prompt '{prompt}'"
+            "fuzzel --dmenu --prompt \"$FLUXO_PROMPT\""
         );
         assert!(config.cpu.format.contains("usage"));
         assert!(config.cpu.format.contains("temp"));
@@ -344,7 +435,7 @@ mod tests {
         // Should fallback to defaults without panicking
         assert_eq!(
             config.general.menu_command,
-            "fuzzel --dmenu --prompt '{prompt}'"
+            "fuzzel --dmenu --prompt \"$FLUXO_PROMPT\""
         );
     }
 
@@ -371,7 +462,7 @@ mod tests {
         // Should fallback to defaults
         assert_eq!(
             config.general.menu_command,
-            "fuzzel --dmenu --prompt '{prompt}'"
+            "fuzzel --dmenu --prompt \"$FLUXO_PROMPT\""
         );
     }
 
@@ -383,7 +474,7 @@ mod tests {
         let config = load_config(Some(tmpfile.path().to_path_buf()));
         assert_eq!(
             config.general.menu_command,
-            "fuzzel --dmenu --prompt '{prompt}'"
+            "fuzzel --dmenu --prompt \"$FLUXO_PROMPT\""
         );
         assert!(config.cpu.format.contains("usage"));
     }

src/daemon.rs

@@ -3,18 +3,26 @@ use crate::error::FluxoError;
 use crate::ipc::socket_path;
 use crate::modules::WaybarModule;
 use crate::modules::audio::AudioDaemon;
+use crate::modules::backlight::BacklightDaemon;
 use crate::modules::bt::BtDaemon;
+use crate::modules::dnd::DndDaemon;
 use crate::modules::hardware::HardwareDaemon;
+use crate::modules::keyboard::KeyboardDaemon;
+use crate::modules::mpris::MprisDaemon;
 use crate::modules::network::NetworkDaemon;
-use crate::state::{AppState, SharedState};
+use crate::signaler::WaybarSignaler;
+use crate::state::AppReceivers;
 use anyhow::Result;
+use notify::{Config as NotifyConfig, Event, RecommendedWatcher, RecursiveMode, Watcher};
+use std::collections::HashMap;
 use std::fs;
 use std::path::PathBuf;
 use std::sync::Arc;
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 use tokio::net::UnixListener;
-use tokio::sync::RwLock;
+use tokio::sync::{RwLock, mpsc, watch};
 use tokio::time::{Duration, Instant, sleep};
+use tokio_util::sync::CancellationToken;
 use tracing::{debug, error, info, warn};
 
 struct SocketGuard {
@@ -28,6 +36,18 @@ impl Drop for SocketGuard {
     }
 }
 
+fn get_config_path(custom_path: Option<PathBuf>) -> PathBuf {
+    custom_path.unwrap_or_else(|| {
+        let config_dir = std::env::var("XDG_CONFIG_HOME")
+            .map(PathBuf::from)
+            .unwrap_or_else(|_| {
+                let home = std::env::var("HOME").unwrap_or_else(|_| String::from("/"));
+                PathBuf::from(home).join(".config")
+            });
+        config_dir.join("fluxo/config.toml")
+    })
+}
+
 pub async fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
     let sock_path = socket_path();
 
@@ -36,87 +56,224 @@ pub async fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
         fs::remove_file(&sock_path)?;
     }
 
-    let state: SharedState = Arc::new(RwLock::new(AppState::default()));
+    let (net_tx, net_rx) = watch::channel(Default::default());
+    let (cpu_tx, cpu_rx) = watch::channel(Default::default());
+    let (mem_tx, mem_rx) = watch::channel(Default::default());
+    let (sys_tx, sys_rx) = watch::channel(Default::default());
+    let (gpu_tx, gpu_rx) = watch::channel(Default::default());
+    let (disks_tx, disks_rx) = watch::channel(Default::default());
+    let (bt_tx, bt_rx) = watch::channel(Default::default());
+    let (audio_tx, audio_rx) = watch::channel(Default::default());
+    let (mpris_tx, mpris_rx) = watch::channel(Default::default());
+    let (backlight_tx, backlight_rx) = watch::channel(Default::default());
+    let (keyboard_tx, keyboard_rx) = watch::channel(Default::default());
+    let (dnd_tx, dnd_rx) = watch::channel(Default::default());
+    let health = Arc::new(RwLock::new(HashMap::new()));
+    let (bt_force_tx, mut bt_force_rx) = mpsc::channel(1);
+    let (audio_cmd_tx, audio_cmd_rx) = mpsc::channel(8);
+
+    let receivers = AppReceivers {
+        network: net_rx,
+        cpu: cpu_rx,
+        memory: mem_rx,
+        sys: sys_rx,
+        gpu: gpu_rx,
+        disks: disks_rx,
+        bluetooth: bt_rx,
+        audio: audio_rx,
+        mpris: mpris_rx,
+        backlight: backlight_rx,
+        keyboard: keyboard_rx,
+        dnd: dnd_rx,
+        health: Arc::clone(&health),
+        bt_force_poll: bt_force_tx,
+        audio_cmd_tx,
+    };
+
     let listener = UnixListener::bind(&sock_path)?;
     let _guard = SocketGuard {
         path: sock_path.clone(),
     };
 
-    // Signal handling for graceful shutdown in async context
+    // Signal handling for graceful shutdown
-    let running = Arc::new(tokio::sync::Notify::new());
+    let cancel_token = CancellationToken::new();
-    let r_clone = Arc::clone(&running);
+    let token_clone = cancel_token.clone();
     tokio::spawn(async move {
         tokio::signal::ctrl_c().await.unwrap();
         info!("Received shutdown signal, exiting...");
-        r_clone.notify_waiters();
+        token_clone.cancel();
     });
 
-    let config_path_clone = config_path.clone();
+    let resolved_config_path = get_config_path(config_path.clone());
-    let config = Arc::new(RwLock::new(crate::config::load_config(config_path)));
+    let config = Arc::new(RwLock::new(crate::config::load_config(config_path.clone())));
+
+    // 0. Config Watcher (Hot Reload)
+    let watcher_config = Arc::clone(&config);
+    let watcher_path = resolved_config_path.clone();
+    tokio::spawn(async move {
+        let (ev_tx, mut ev_rx) = mpsc::channel(1);
+        let mut watcher = RecommendedWatcher::new(
+            move |res: notify::Result<Event>| {
+                if let Ok(event) = res
+                    && (event.kind.is_modify() || event.kind.is_create())
+                {
+                    let _ = ev_tx.blocking_send(());
+                }
+            },
+            NotifyConfig::default(),
+        )
+        .unwrap();
+
+        if let Some(parent) = watcher_path.parent() {
+            let _ = watcher.watch(parent, RecursiveMode::NonRecursive);
+        }
+
+        info!("Config watcher started on {:?}", watcher_path);
+
+        loop {
+            tokio::select! {
+                _ = ev_rx.recv() => {
+                    // Debounce reloads
+                    sleep(Duration::from_millis(100)).await;
+                    while ev_rx.try_recv().is_ok() {}
+                    reload_config(&watcher_config, Some(watcher_path.clone())).await;
+                }
+            }
+        }
+    });
+
+    // 0.1 SIGHUP Handler
+    let hup_config = Arc::clone(&config);
+    let hup_path = resolved_config_path.clone();
+    tokio::spawn(async move {
+        use tokio::signal::unix::{SignalKind, signal};
+        let mut stream = signal(SignalKind::hangup()).unwrap();
+        loop {
+            stream.recv().await;
+            info!("Received SIGHUP, reloading config...");
+            reload_config(&hup_config, Some(hup_path.clone())).await;
+        }
+    });
 
     // 1. Network Task
-    let poll_state = Arc::clone(&state);
+    let token = cancel_token.clone();
+    let net_health = Arc::clone(&health);
     tokio::spawn(async move {
         info!("Starting Network polling task");
         let mut daemon = NetworkDaemon::new();
         loop {
-            daemon.poll(Arc::clone(&poll_state)).await;
+            if !is_in_backoff("net", &net_health).await {
-            sleep(Duration::from_secs(1)).await;
+                let res = daemon.poll(&net_tx).await;
+                handle_poll_result("net", res, &net_health).await;
+            }
+            tokio::select! {
+                _ = token.cancelled() => break,
+                _ = sleep(Duration::from_secs(1)) => {}
+            }
         }
+        info!("Network task shut down.");
     });
 
     // 2. Fast Hardware Task (CPU, Mem, Load)
-    let poll_state = Arc::clone(&state);
+    let token = cancel_token.clone();
+    let hw_health = Arc::clone(&health);
     tokio::spawn(async move {
         info!("Starting Fast Hardware polling task");
         let mut daemon = HardwareDaemon::new();
         loop {
-            daemon.poll_fast(Arc::clone(&poll_state)).await;
+            if !is_in_backoff("cpu", &hw_health).await {
-            sleep(Duration::from_secs(1)).await;
+                daemon.poll_fast(&cpu_tx, &mem_tx, &sys_tx).await;
+            }
+            tokio::select! {
+                _ = token.cancelled() => break,
+                _ = sleep(Duration::from_secs(1)) => {}
+            }
         }
+        info!("Fast Hardware task shut down.");
     });
 
     // 3. Slow Hardware Task (GPU, Disks)
-    let poll_state = Arc::clone(&state);
+    let token = cancel_token.clone();
+    let slow_health = Arc::clone(&health);
     tokio::spawn(async move {
         info!("Starting Slow Hardware polling task");
         let mut daemon = HardwareDaemon::new();
         loop {
-            daemon.poll_slow(Arc::clone(&poll_state)).await;
+            if !is_in_backoff("gpu", &slow_health).await {
-            sleep(Duration::from_secs(1)).await;
+                daemon.poll_slow(&gpu_tx, &disks_tx).await;
+            }
+            tokio::select! {
+                _ = token.cancelled() => break,
+                _ = sleep(Duration::from_secs(5)) => {}
+            }
         }
+        info!("Slow Hardware task shut down.");
     });
 
     // 4. Bluetooth Task
-    let poll_state = Arc::clone(&state);
+    let token = cancel_token.clone();
+    let bt_health = Arc::clone(&health);
     let poll_config = Arc::clone(&config);
+    let poll_receivers = receivers.clone();
     tokio::spawn(async move {
         info!("Starting Bluetooth polling task");
         let mut daemon = BtDaemon::new();
         loop {
-            let config = poll_config.read().await;
+            if !is_in_backoff("bt", &bt_health).await {
-            daemon.poll(Arc::clone(&poll_state), &config).await;
+                let config = poll_config.read().await;
-            sleep(Duration::from_secs(1)).await;
+                daemon.poll(&bt_tx, &poll_receivers, &config).await;
+            }
+            tokio::select! {
+                _ = token.cancelled() => break,
+                _ = bt_force_rx.recv() => {},
+                _ = sleep(Duration::from_secs(2)) => {}
+            }
         }
+        info!("Bluetooth task shut down.");
     });
 
-    // 5. Audio Thread (Event driven - pulse usually needs its own thread)
+    // 5. Audio Thread (Event driven)
     let audio_daemon = AudioDaemon::new();
-    audio_daemon.start(Arc::clone(&state));
+    audio_daemon.start(&audio_tx, audio_cmd_rx);
+
+    // 5.1 Backlight Thread (Event driven)
+    let backlight_daemon = BacklightDaemon::new();
+    backlight_daemon.start(backlight_tx);
+
+    // 5.2 Keyboard Thread (Event driven)
+    let keyboard_daemon = KeyboardDaemon::new();
+    keyboard_daemon.start(keyboard_tx);
+
+    // 5.3 DND Thread (Event driven)
+    let dnd_daemon = DndDaemon::new();
+    dnd_daemon.start(dnd_tx);
+
+    // 5.4 MPRIS Thread
+    let mpris_daemon = MprisDaemon::new();
+    mpris_daemon.start(mpris_tx);
+
+    // 6. Waybar Signaler Task
+    let signaler = WaybarSignaler::new();
+    let sig_config = Arc::clone(&config);
+    let sig_receivers = receivers.clone();
+    tokio::spawn(async move {
+        info!("Starting Waybar Signaler task");
+        signaler.run(sig_config, sig_receivers).await;
+    });
 
     info!("Fluxo daemon successfully bound to socket: {}", sock_path);
 
     loop {
         tokio::select! {
-            _ = running.notified() => {
+            _ = cancel_token.cancelled() => {
                 break;
             }
             res = listener.accept() => {
                 match res {
                     Ok((mut stream, _)) => {
-                        let state_clone = Arc::clone(&state);
+                        let state_clone = receivers.clone();
                         let config_clone = Arc::clone(&config);
-                        let cp_clone = config_path_clone.clone();
+                        let cp_clone = config_path.clone();
                         tokio::spawn(async move {
                             let (reader, mut writer) = stream.split();
                             let mut reader = BufReader::new(reader);
@@ -134,12 +291,8 @@ pub async fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
                             let parts: Vec<&str> = request.split_whitespace().collect();
                             if let Some(module_name) = parts.first() {
                                 if *module_name == "reload" {
-                                    info!("Reloading configuration...");
+                                    reload_config(&config_clone, cp_clone).await;
-                                    let new_config = crate::config::load_config(cp_clone);
-                                    let mut config_lock = config_clone.write().await;
-                                    *config_lock = new_config;
                                     let _ = writer.write_all(b"{\"text\":\"ok\"}").await;
-                                    info!("Configuration reloaded successfully.");
                                     return;
                                 }
 
@@ -171,27 +324,170 @@ pub async fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
     Ok(())
 }
 
+async fn handle_poll_result(
+    module_name: &str,
+    result: crate::error::Result<()>,
+    health_lock: &Arc<RwLock<HashMap<String, crate::state::ModuleHealth>>>,
+) {
+    let mut lock = health_lock.write().await;
+    let health = lock.entry(module_name.to_string()).or_default();
+
+    match result {
+        Ok(_) => {
+            if health.consecutive_failures > 0 {
+                info!(
+                    module = module_name,
+                    "Module recovered after {} failures", health.consecutive_failures
+                );
+            }
+            health.consecutive_failures = 0;
+            health.backoff_until = None;
+        }
+        Err(e) => {
+            health.consecutive_failures += 1;
+            health.last_failure = Some(Instant::now());
+
+            if !e.is_transient() {
+                // Fatal errors trigger immediate long backoff
+                health.backoff_until = Some(Instant::now() + Duration::from_secs(60));
+                error!(module = module_name, error = %e, "Fatal module error, entering long cooldown");
+            } else if health.consecutive_failures >= 3 {
+                // Exponential backoff for transient errors: 30s, 60s, 120s...
+                let backoff_secs = 30 * (2u64.pow(health.consecutive_failures.saturating_sub(3)));
+                let backoff_secs = backoff_secs.min(3600); // Cap at 1 hour
+                health.backoff_until = Some(Instant::now() + Duration::from_secs(backoff_secs));
+                warn!(module = module_name, error = %e, backoff = backoff_secs, "Repeated transient failures, entering backoff");
+            } else {
+                debug!(module = module_name, error = %e, "Transient module failure (attempt {})", health.consecutive_failures);
+            }
+        }
+    }
+}
+
+async fn is_in_backoff(
+    module_name: &str,
+    health_lock: &Arc<RwLock<HashMap<String, crate::state::ModuleHealth>>>,
+) -> bool {
+    let lock = health_lock.read().await;
+    if let Some(health) = lock.get(module_name)
+        && let Some(until) = health.backoff_until
+    {
+        return Instant::now() < until;
+    }
+    false
+}
+
+pub async fn reload_config(config_lock: &Arc<RwLock<Config>>, path: Option<PathBuf>) {
+    info!("Reloading configuration...");
+    let new_config = crate::config::load_config(path);
+    let mut lock = config_lock.write().await;
+    *lock = new_config;
+    info!("Configuration reloaded successfully.");
+}
+
+pub async fn evaluate_module_for_signaler(
+    module_name: &str,
+    state: &AppReceivers,
+    config: &Config,
+) -> Option<String> {
+    let result = match module_name {
+        "net" | "network" => {
+            crate::modules::network::NetworkModule
+                .run(config, state, &[])
+                .await
+        }
+        "cpu" => crate::modules::cpu::CpuModule.run(config, state, &[]).await,
+        "mem" | "memory" => {
+            crate::modules::memory::MemoryModule
+                .run(config, state, &[])
+                .await
+        }
+        "disk" => {
+            crate::modules::disk::DiskModule
+                .run(config, state, &["/"])
+                .await
+        }
+        "pool" | "btrfs" => {
+            crate::modules::btrfs::BtrfsModule
+                .run(config, state, &["btrfs"])
+                .await
+        }
+        "vol" | "audio" => {
+            crate::modules::audio::AudioModule
+                .run(config, state, &["sink", "show"])
+                .await
+        }
+        "mic" => {
+            crate::modules::audio::AudioModule
+                .run(config, state, &["source", "show"])
+                .await
+        }
+        "gpu" => crate::modules::gpu::GpuModule.run(config, state, &[]).await,
+        "sys" => crate::modules::sys::SysModule.run(config, state, &[]).await,
+        "bt" | "bluetooth" => {
+            crate::modules::bt::BtModule
+                .run(config, state, &["show"])
+                .await
+        }
+        "power" => {
+            crate::modules::power::PowerModule
+                .run(config, state, &[])
+                .await
+        }
+        "game" => {
+            crate::modules::game::GameModule
+                .run(config, state, &[])
+                .await
+        }
+        "backlight" => {
+            crate::modules::backlight::BacklightModule
+                .run(config, state, &[])
+                .await
+        }
+        "kbd" | "keyboard" => {
+            crate::modules::keyboard::KeyboardModule
+                .run(config, state, &[])
+                .await
+        }
+        "dnd" => crate::modules::dnd::DndModule.run(config, state, &[]).await,
+        "mpris" => {
+            crate::modules::mpris::MprisModule
+                .run(config, state, &[])
+                .await
+        }
+        _ => return None,
+    };
+    result.ok().and_then(|out| serde_json::to_string(&out).ok())
+}
+
 async fn handle_request(
     module_name: &str,
     args: &[&str],
-    state: &SharedState,
+    state: &AppReceivers,
     config_lock: &Arc<RwLock<Config>>,
 ) -> String {
     // 1. Check Circuit Breaker status
-    let is_in_backoff = {
+    let (is_in_backoff, cached_output) = {
-        let lock = state.read().await;
+        let lock = state.health.read().await;
-        if let Some(health) = lock.health.get(module_name) {
+        if let Some(health) = lock.get(module_name) {
-            if let Some(until) = health.backoff_until {
+            let in_backoff = if let Some(until) = health.backoff_until {
                 Instant::now() < until
             } else {
                 false
-            }
+            };
+            (in_backoff, health.last_successful_output.clone())
         } else {
-            false
+            (false, None)
         }
     };
 
     if is_in_backoff {
+        if let Some(mut cached) = cached_output {
+            // Add a "warning" class to indicate stale data
+            let class = cached.class.unwrap_or_default();
+            cached.class = Some(format!("{} warning", class).trim().to_string());
+            return serde_json::to_string(&cached).unwrap_or_else(|_| "{}".to_string());
+        }
         return format!(
             "{{\"text\":\"\u{200B}Cooling down ({})\u{200B}\",\"class\":\"error\"}}",
             module_name
@@ -226,14 +522,14 @@ async fn handle_request(
                 .run(&config, state, args)
                 .await
         }
-        "vol" => {
+        "vol" | "audio" => {
             crate::modules::audio::AudioModule
-                .run(&config, state, &["sink", args.first().unwrap_or(&"show")])
+                .run(&config, state, args)
                 .await
         }
         "mic" => {
             crate::modules::audio::AudioModule
-                .run(&config, state, &["source", args.first().unwrap_or(&"show")])
+                .run(&config, state, args)
                 .await
         }
         "gpu" => {
@@ -257,20 +553,41 @@ async fn handle_request(
                 .run(&config, state, args)
                 .await
         }
+        "backlight" => {
+            crate::modules::backlight::BacklightModule
+                .run(&config, state, args)
+                .await
+        }
+        "kbd" | "keyboard" => {
+            crate::modules::keyboard::KeyboardModule
+                .run(&config, state, args)
+                .await
+        }
+        "dnd" => {
+            crate::modules::dnd::DndModule
+                .run(&config, state, args)
+                .await
+        }
+        "mpris" => {
+            crate::modules::mpris::MprisModule
+                .run(&config, state, args)
+                .await
+        }
         _ => {
             warn!("Received request for unknown module: '{}'", module_name);
             Err(FluxoError::Ipc(format!("Unknown module: {}", module_name)))
         }
     };
 
-    // 2. Update Health based on result
+    // 2. Update Health and Cache based on result
     {
-        let mut lock = state.write().await;
+        let mut lock = state.health.write().await;
-        let health = lock.health.entry(module_name.to_string()).or_default();
+        let health = lock.entry(module_name.to_string()).or_default();
         match &result {
-            Ok(_) => {
+            Ok(output) => {
                 health.consecutive_failures = 0;
                 health.backoff_until = None;
+                health.last_successful_output = Some(output.clone());
             }
             Err(e) => {
                 health.consecutive_failures += 1;
@@ -287,6 +604,13 @@ async fn handle_request(
     match result {
         Ok(output) => serde_json::to_string(&output).unwrap_or_else(|_| "{}".to_string()),
         Err(e) => {
+            // If we have a cached output, return it as fallback even on immediate error
+            if let Some(mut cached) = cached_output {
+                let class = cached.class.unwrap_or_default();
+                cached.class = Some(format!("{} warning", class).trim().to_string());
+                return serde_json::to_string(&cached).unwrap_or_else(|_| "{}".to_string());
+            }
+
             let error_msg = e.to_string();
             error!(module = module_name, error = %error_msg, "Module execution failed");
             let err_out = crate::output::WaybarOutput {

src/error.rs

@@ -18,6 +18,15 @@ pub enum FluxoError {
     #[error("External system error: {0}")]
     System(String),
 
+    #[error("Bluetooth error: {0}")]
+    Bluetooth(String),
+
+    #[error("Network error: {0}")]
+    Network(String),
+
+    #[error("Hardware error: {0}")]
+    Hardware(String),
+
     #[error("IO error: {0}")]
     Io(#[from] std::io::Error),
 
@@ -28,4 +37,18 @@ pub enum FluxoError {
     Other(#[from] anyhow::Error),
 }
 
+impl FluxoError {
+    pub fn is_transient(&self) -> bool {
+        matches!(
+            self,
+            Self::Io(_)
+                | Self::System(_)
+                | Self::Bluetooth(_)
+                | Self::Network(_)
+                | Self::Hardware(_)
+                | Self::Module { .. }
+        )
+    }
+}
+
 pub type Result<T> = std::result::Result<T, FluxoError>;

src/main.rs

@@ -4,6 +4,7 @@ mod error;
 mod ipc;
 mod modules;
 mod output;
+mod signaler;
 mod state;
 mod utils;
 
@@ -18,7 +19,14 @@ use tracing_subscriber::{EnvFilter, fmt, prelude::*};
 #[command(about = "A high-performance daemon/client for Waybar custom modules", long_about = None)]
 struct Cli {
     #[command(subcommand)]
-    command: Commands,
+    command: Option<Commands>,
+
+    /// Module name to query or interact with
+    module: Option<String>,
+
+    /// Arguments to pass to the module
+    #[arg(trailing_var_arg = true)]
+    args: Vec<String>,
 }
 
 #[derive(Subcommand)]
@@ -31,51 +39,6 @@ enum Commands {
     },
     /// Reload the daemon configuration
     Reload,
-    /// Network speed module
-    #[command(alias = "network")]
-    Net,
-    /// CPU usage and temp module
-    Cpu,
-    /// Memory usage module
-    #[command(alias = "memory")]
-    Mem,
-    /// Disk usage module (path defaults to /)
-    Disk {
-        #[arg(default_value = "/")]
-        path: String,
-    },
-    /// Storage pool aggregate module (e.g., btrfs)
-    #[command(alias = "btrfs")]
-    Pool {
-        #[arg(default_value = "btrfs")]
-        kind: String,
-    },
-    /// Audio volume (sink) control
-    Vol {
-        /// Cycle to the next available output device
-        #[arg(short, long)]
-        cycle: bool,
-    },
-    /// Microphone (source) control
-    Mic {
-        /// Cycle to the next available input device
-        #[arg(short, long)]
-        cycle: bool,
-    },
-    /// GPU usage, VRAM, and temp module
-    Gpu,
-    /// System load average and uptime
-    Sys,
-    /// Bluetooth audio device status
-    #[command(alias = "bluetooth")]
-    Bt {
-        #[arg(default_value = "show")]
-        action: String,
-    },
-    /// System power and battery status
-    Power,
-    /// Hyprland gamemode status
-    Game,
 }
 
 fn main() {
@@ -86,114 +49,108 @@ fn main() {
 
     let cli = Cli::parse();
 
-    match &cli.command {
+    if let Some(command) = &cli.command {
-        Commands::Daemon { config } => {
+        match command {
-            info!("Starting Fluxo daemon...");
+            Commands::Daemon { config } => {
-            let rt = tokio::runtime::Builder::new_multi_thread()
+                info!("Starting Fluxo daemon...");
-                .enable_all()
+                let rt = tokio::runtime::Builder::new_multi_thread()
-                .build()
+                    .enable_all()
-                .unwrap();
+                    .build()
+                    .unwrap();
 
-            if let Err(e) = rt.block_on(daemon::run_daemon(config.clone())) {
+                if let Err(e) = rt.block_on(daemon::run_daemon(config.clone())) {
-                error!("Daemon failed: {}", e);
+                    error!("Daemon failed: {}", e);
-                process::exit(1);
+                    process::exit(1);
+                }
             }
+            Commands::Reload => match ipc::request_data("reload", &[]) {
+                Ok(_) => info!("Reload signal sent to daemon"),
+                Err(e) => {
+                    error!("Failed to send reload signal: {}", e);
+                    process::exit(1);
+                }
+            },
         }
-        Commands::Reload => match ipc::request_data("reload", &[]) {
+        return;
-            Ok(_) => info!("Reload signal sent to daemon"),
+    }
-            Err(e) => {
+
-                error!("Failed to send reload signal: {}", e);
+    if let Some(module) = &cli.module {
-                process::exit(1);
+        // Special case for client-side Bluetooth menu which requires UI
+        if module == "bt" && cli.args.first().map(|s| s.as_str()) == Some("menu") {
+            let config = config::load_config(None);
+            let mut items = Vec::new();
+
+            if let Ok(json_str) = ipc::request_data("bt", &["get_modes"])
+                && let Ok(val) = serde_json::from_str::<serde_json::Value>(&json_str)
+                && let Some(modes_str) = val.get("text").and_then(|t| t.as_str())
+                && !modes_str.is_empty()
+            {
+                for mode in modes_str.lines() {
+                    items.push(format!("Mode: {}", mode));
+                }
             }
-        },
-        Commands::Net => handle_ipc_response(ipc::request_data("net", &[])),
-        Commands::Cpu => handle_ipc_response(ipc::request_data("cpu", &[])),
-        Commands::Mem => handle_ipc_response(ipc::request_data("mem", &[])),
-        Commands::Disk { path } => handle_ipc_response(ipc::request_data("disk", &[path])),
-        Commands::Pool { kind } => handle_ipc_response(ipc::request_data("pool", &[kind])),
-        Commands::Vol { cycle } => {
-            let action = if *cycle { "cycle" } else { "show" };
-            handle_ipc_response(ipc::request_data("vol", &[action]));
-        }
-        Commands::Mic { cycle } => {
-            let action = if *cycle { "cycle" } else { "show" };
-            handle_ipc_response(ipc::request_data("mic", &[action]));
-        }
-        Commands::Gpu => handle_ipc_response(ipc::request_data("gpu", &[])),
-        Commands::Sys => handle_ipc_response(ipc::request_data("sys", &[])),
-        Commands::Bt { action } => {
-            if action == "menu" {
-                // Client-side execution of the menu
-                let config = config::load_config(None);
 
-                let mut items = Vec::new();
+            if !items.is_empty() {
+                items.push("Disconnect".to_string());
+            }
 
-                // If connected, show plugin modes and disconnect
+            items.push("--- Connect Device ---".to_string());
-                if let Ok(json_str) = ipc::request_data("bt", &["get_modes"])
+
-                    && let Ok(val) = serde_json::from_str::<serde_json::Value>(&json_str)
+            if let Ok(json_str) = ipc::request_data("bt", &["menu_data"])
-                    && let Some(modes_str) = val.get("text").and_then(|t| t.as_str())
+                && let Ok(val) = serde_json::from_str::<serde_json::Value>(&json_str)
-                    && !modes_str.is_empty()
+                && let Some(devices_str) = val.get("text").and_then(|t| t.as_str())
+            {
+                for line in devices_str.lines() {
+                    if !line.is_empty() {
+                        items.push(line.to_string());
+                    }
+                }
+            }
+
+            if !items.is_empty() {
+                if let Ok(selected) =
+                    utils::show_menu("BT Menu: ", &items, &config.general.menu_command)
                 {
-                    for mode in modes_str.lines() {
+                    if let Some(mode) = selected.strip_prefix("Mode: ") {
-                        items.push(format!("Mode: {}", mode));
+                        handle_ipc_response(ipc::request_data("bt", &["set_mode", mode]));
-                    }
+                    } else if selected == "Disconnect" {
-                }
+                        handle_ipc_response(ipc::request_data("bt", &["disconnect"]));
-
+                    } else if selected == "--- Connect Device ---" {
-                if !items.is_empty() {
+                        // Do nothing
-                    items.push("Disconnect".to_string());
+                    } else if let Some(mac_start) = selected.rfind('(')
-                }
+                        && let Some(mac_end) = selected.rfind(')')
-
-                items.push("--- Connect Device ---".to_string());
-
-                let devices_out = match std::process::Command::new("bluetoothctl")
-                    .args(["devices"])
-                    .output()
-                {
-                    Ok(out) => out,
-                    Err(e) => {
-                        error!("bluetoothctl not found or failed: {}", e);
-                        return;
-                    }
-                };
-                let stdout = String::from_utf8_lossy(&devices_out.stdout);
-
-                for line in stdout.lines() {
-                    if line.starts_with("Device ") {
-                        let parts: Vec<&str> = line.splitn(3, ' ').collect();
-                        if parts.len() == 3 {
-                            items.push(format!("{} ({})", parts[2], parts[1]));
-                        }
-                    }
-                }
-
-                if !items.is_empty() {
-                    if let Ok(selected) =
-                        utils::show_menu("BT Menu: ", &items, &config.general.menu_command)
                     {
-                        if let Some(mode) = selected.strip_prefix("Mode: ") {
+                        let mac = &selected[mac_start + 1..mac_end];
-                            handle_ipc_response(ipc::request_data("bt", &["set_mode", mode]));
+                        handle_ipc_response(ipc::request_data("bt", &["connect", mac]));
-                        } else if selected == "Disconnect" {
-                            handle_ipc_response(ipc::request_data("bt", &["disconnect"]));
-                        } else if selected == "--- Connect Device ---" {
-                            // Do nothing
-                        } else if let Some(mac_start) = selected.rfind('(')
-                            && let Some(mac_end) = selected.rfind(')')
-                        {
-                            let mac = &selected[mac_start + 1..mac_end];
-                            let _ = std::process::Command::new("bluetoothctl")
-                                .args(["connect", mac])
-                                .status();
-                        }
                     }
-                } else {
-                    info!("No Bluetooth options found.");
                 }
-                return;
+            } else {
+                info!("No Bluetooth options found.");
             }
-            handle_ipc_response(ipc::request_data("bt", &[action]));
+            return;
         }
-        Commands::Power => handle_ipc_response(ipc::request_data("power", &[])),
+
-        Commands::Game => handle_ipc_response(ipc::request_data("game", &[])),
+        // Generic module dispatch
+        // To handle module-specific default targets like "vol up" -> "vol sink up" or "mic up" -> "vol source up"
+        // Wait, `daemon.rs` `evaluate_module_for_signaler` defaults `vol` to `sink show`.
+        // If we map `mic` to `["vol", "source"]` in `main.rs` instead of keeping `mic` in daemon:
+        let (actual_module, actual_args) = if module == "vol" {
+            let mut new_args = vec!["sink".to_string()];
+            new_args.extend(cli.args.clone());
+            ("vol".to_string(), new_args)
+        } else if module == "mic" {
+            let mut new_args = vec!["source".to_string()];
+            new_args.extend(cli.args.clone());
+            ("vol".to_string(), new_args)
+        } else {
+            (module.clone(), cli.args.clone())
+        };
+
+        let args_ref: Vec<&str> = actual_args.iter().map(|s| s.as_str()).collect();
+        handle_ipc_response(ipc::request_data(&actual_module, &args_ref));
+    } else {
+        println!("Please specify a module or command. See --help.");
+        process::exit(1);
     }
 }
 

src/modules/audio.rs

@@ -2,23 +2,29 @@ use crate::config::Config;
 use crate::error::{FluxoError, Result};
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
+use crate::state::{AppReceivers, AudioState};
 use crate::utils::{TokenValue, format_template};
 use libpulse_binding::callbacks::ListResult;
 use libpulse_binding::context::subscribe::{Facility, InterestMaskSet};
 use libpulse_binding::context::{Context, FlagSet as ContextFlag};
 use libpulse_binding::mainloop::threaded::Mainloop as ThreadedMainloop;
 use libpulse_binding::volume::Volume;
-use std::process::Command;
+use tokio::sync::{mpsc, watch};
-use std::sync::{Arc, LazyLock};
 use tracing::error;
 
-static RUNTIME: LazyLock<tokio::runtime::Runtime> = LazyLock::new(|| {
+pub enum AudioCommand {
-    tokio::runtime::Builder::new_current_thread()
+    ChangeVolume {
-        .enable_all()
+        is_sink: bool,
-        .build()
+        step_val: u32,
-        .expect("Failed to create Audio tokio runtime")
+        is_up: bool,
-});
+    },
+    ToggleMute {
+        is_sink: bool,
+    },
+    CycleDevice {
+        is_sink: bool,
+    },
+}
 
 pub struct AudioDaemon;
 
@@ -27,8 +33,12 @@ impl AudioDaemon {
         Self
     }
 
-    pub fn start(&self, state: SharedState) {
+    pub fn start(
-        let state_arc = Arc::clone(&state);
+        &self,
+        state_tx: &watch::Sender<AudioState>,
+        mut cmd_rx: mpsc::Receiver<AudioCommand>,
+    ) {
+        let state_tx = state_tx.clone();
 
         std::thread::spawn(move || {
             let mut mainloop =
@@ -64,7 +74,7 @@ impl AudioDaemon {
             }
 
             // Initial fetch
-            let _ = fetch_audio_data_sync(&mut context, &state_arc);
+            let _ = fetch_audio_data_sync(&mut context, &state_tx);
 
             // Subscribe to events
             let interest =
@@ -72,11 +82,12 @@ impl AudioDaemon {
             context.subscribe(interest, |_| {});
 
             let (tx, rx) = std::sync::mpsc::channel();
+            let tx_cb = tx.clone();
 
             context.set_subscribe_callback(Some(Box::new(move |facility, _operation, _index| {
                 match facility {
                     Some(Facility::Sink) | Some(Facility::Source) | Some(Facility::Server) => {
-                        let _ = tx.send(());
+                        let _ = tx_cb.send(());
                     }
                     _ => {}
                 }
@@ -84,14 +95,110 @@ impl AudioDaemon {
 
             mainloop.unlock();
 
-            // Background polling loop driven by events or a 2s fallback timeout
             loop {
-                let _ = rx.recv_timeout(Duration::from_secs(2));
+                if let Ok(cmd) = cmd_rx.try_recv() {
-                {
                     mainloop.lock();
-                    let _ = fetch_audio_data_sync(&mut context, &state_arc);
+                    match cmd {
+                        AudioCommand::ChangeVolume {
+                            is_sink,
+                            step_val,
+                            is_up,
+                        } => {
+                            let current = state_tx.borrow().clone();
+                            let (name, mut vol, channels) = if is_sink {
+                                (
+                                    current.sink.name.clone(),
+                                    current.sink.volume,
+                                    current.sink.channels,
+                                )
+                            } else {
+                                (
+                                    current.source.name.clone(),
+                                    current.source.volume,
+                                    current.source.channels,
+                                )
+                            };
+
+                            if is_up {
+                                vol = vol.saturating_add(step_val as u8).min(150);
+                            } else {
+                                vol = vol.saturating_sub(step_val as u8);
+                            }
+
+                            let pulse_vol = Volume(
+                                (vol as f64 / 100.0 * Volume::NORMAL.0 as f64).round() as u32,
+                            );
+                            let mut cvol = libpulse_binding::volume::ChannelVolumes::default();
+                            cvol.set(channels.max(1), pulse_vol);
+
+                            if is_sink {
+                                context
+                                    .introspect()
+                                    .set_sink_volume_by_name(&name, &cvol, None);
+                            } else {
+                                context
+                                    .introspect()
+                                    .set_source_volume_by_name(&name, &cvol, None);
+                            }
+                        }
+                        AudioCommand::ToggleMute { is_sink } => {
+                            let current = state_tx.borrow().clone();
+                            let (name, muted) = if is_sink {
+                                (current.sink.name.clone(), current.sink.muted)
+                            } else {
+                                (current.source.name.clone(), current.source.muted)
+                            };
+
+                            if is_sink {
+                                context
+                                    .introspect()
+                                    .set_sink_mute_by_name(&name, !muted, None);
+                            } else {
+                                context
+                                    .introspect()
+                                    .set_source_mute_by_name(&name, !muted, None);
+                            }
+                        }
+                        AudioCommand::CycleDevice { is_sink } => {
+                            let current = state_tx.borrow().clone();
+                            let current_name = if is_sink {
+                                current.sink.name.clone()
+                            } else {
+                                current.source.name.clone()
+                            };
+
+                            let devices = if is_sink {
+                                &current.available_sinks
+                            } else {
+                                &current.available_sources
+                            };
+                            if !devices.is_empty() {
+                                let current_idx =
+                                    devices.iter().position(|d| d == &current_name).unwrap_or(0);
+                                let next_idx = (current_idx + 1) % devices.len();
+                                let next_dev = &devices[next_idx];
+
+                                if is_sink {
+                                    context.set_default_sink(next_dev, |_| {});
+                                } else {
+                                    context.set_default_source(next_dev, |_| {});
+                                }
+                            }
+                        }
+                    }
                     mainloop.unlock();
+                    let _ = tx.send(());
                 }
+
+                let _ = rx.recv_timeout(Duration::from_millis(50));
+                while rx.try_recv().is_ok() {}
+
+                mainloop.lock();
+
+                // Fetch data and update available sinks/sources
+                let _ = fetch_audio_data_sync(&mut context, &state_tx);
+
+                mainloop.unlock();
             }
         });
     }
@@ -99,69 +206,109 @@ impl AudioDaemon {
 
 use std::time::Duration;
 
-fn fetch_audio_data_sync(context: &mut Context, state: &SharedState) -> Result<()> {
+fn fetch_audio_data_sync(
-    let state_inner = Arc::clone(state);
+    context: &mut Context,
-
+    state_tx: &watch::Sender<AudioState>,
+) -> Result<()> {
     // We fetch all sinks and sources, and also server info to know defaults.
     // The order doesn't strictly matter as long as we update correctly.
 
-    let st_server = Arc::clone(&state_inner);
+    let tx_server = state_tx.clone();
     context.introspect().get_server_info(move |info| {
-        let mut lock = RUNTIME.block_on(st_server.write());
+        let mut current = tx_server.borrow().clone();
-        lock.audio.sink.name = info
+        current.sink.name = info
             .default_sink_name
             .as_ref()
             .map(|s| s.to_string())
             .unwrap_or_default();
-        lock.audio.source.name = info
+        current.source.name = info
             .default_source_name
             .as_ref()
             .map(|s| s.to_string())
             .unwrap_or_default();
+        let _ = tx_server.send(current);
     });
 
-    let st_sink = Arc::clone(&state_inner);
+    let tx_sink = state_tx.clone();
     context.introspect().get_sink_info_list(move |res| {
-        if let ListResult::Item(item) = res {
+        let mut current = tx_sink.borrow().clone();
-            let mut lock = RUNTIME.block_on(st_sink.write());
+        match res {
-            // If this matches our default sink name, or if we don't have details for any yet
+            ListResult::Item(item) => {
-            let is_default = item
+                if let Some(name) = item.name.as_ref() {
-                .name
+                    let name_str = name.to_string();
-                .as_ref()
+                    if !current.available_sinks.contains(&name_str) {
-                .map(|s| s.as_ref() == lock.audio.sink.name)
+                        current.available_sinks.push(name_str);
-                .unwrap_or(false);
+                    }
-            if is_default {
+                }
-                lock.audio.sink.description = item
+
-                    .description
+                let is_default = item
+                    .name
                     .as_ref()
-                    .map(|s| s.to_string())
+                    .map(|s| s.as_ref() == current.sink.name)
-                    .unwrap_or_default();
+                    .unwrap_or(false);
-                lock.audio.sink.volume =
+                if is_default {
-                    ((item.volume.avg().0 as f64 / Volume::NORMAL.0 as f64) * 100.0).round() as u8;
+                    current.sink.description = item
-                lock.audio.sink.muted = item.mute;
+                        .description
+                        .as_ref()
+                        .map(|s| s.to_string())
+                        .unwrap_or_default();
+                    current.sink.volume = ((item.volume.avg().0 as f64 / Volume::NORMAL.0 as f64)
+                        * 100.0)
+                        .round() as u8;
+                    current.sink.muted = item.mute;
+                    current.sink.channels = item.volume.len();
+                }
+                let _ = tx_sink.send(current);
             }
+            ListResult::End => {
+                // Clear the list on End so it rebuilds fresh next time
+                current.available_sinks.clear();
+                let _ = tx_sink.send(current);
+            }
+            ListResult::Error => {}
         }
     });
 
-    let st_source = Arc::clone(&state_inner);
+    let tx_source = state_tx.clone();
     context.introspect().get_source_info_list(move |res| {
-        if let ListResult::Item(item) = res {
+        let mut current = tx_source.borrow().clone();
-            let mut lock = RUNTIME.block_on(st_source.write());
+        match res {
-            let is_default = item
+            ListResult::Item(item) => {
-                .name
+                if let Some(name) = item.name.as_ref() {
-                .as_ref()
+                    let name_str = name.to_string();
-                .map(|s| s.as_ref() == lock.audio.source.name)
+                    // PulseAudio includes monitor sources, ignore them if we want to
-                .unwrap_or(false);
+                    if !name_str.contains(".monitor")
-            if is_default {
+                        && !current.available_sources.contains(&name_str)
-                lock.audio.source.description = item
+                    {
-                    .description
+                        current.available_sources.push(name_str);
+                    }
+                }
+
+                let is_default = item
+                    .name
                     .as_ref()
-                    .map(|s| s.to_string())
+                    .map(|s| s.as_ref() == current.source.name)
-                    .unwrap_or_default();
+                    .unwrap_or(false);
-                lock.audio.source.volume =
+                if is_default {
-                    ((item.volume.avg().0 as f64 / Volume::NORMAL.0 as f64) * 100.0).round() as u8;
+                    current.source.description = item
-                lock.audio.source.muted = item.mute;
+                        .description
+                        .as_ref()
+                        .map(|s| s.to_string())
+                        .unwrap_or_default();
+                    current.source.volume = ((item.volume.avg().0 as f64 / Volume::NORMAL.0 as f64)
+                        * 100.0)
+                        .round() as u8;
+                    current.source.muted = item.mute;
+                    current.source.channels = item.volume.len();
+                }
+                let _ = tx_source.send(current);
             }
+            ListResult::End => {
+                // Clear the list on End so it rebuilds fresh next time
+                current.available_sources.clear();
+                let _ = tx_source.send(current);
+            }
+            ListResult::Error => {}
         }
     });
 
@@ -174,15 +321,28 @@ impl WaybarModule for AudioModule {
     async fn run(
         &self,
         config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
         args: &[&str],
     ) -> Result<WaybarOutput> {
         let target_type = args.first().unwrap_or(&"sink");
         let action = args.get(1).unwrap_or(&"show");
+        let step = args.get(2).unwrap_or(&"5");
 
         match *action {
+            "up" => {
+                self.change_volume(state, target_type, step, true).await?;
+                Ok(WaybarOutput::default())
+            }
+            "down" => {
+                self.change_volume(state, target_type, step, false).await?;
+                Ok(WaybarOutput::default())
+            }
+            "mute" => {
+                self.toggle_mute(state, target_type).await?;
+                Ok(WaybarOutput::default())
+            }
             "cycle" => {
-                self.cycle_device(target_type)?;
+                self.cycle_device(state, target_type).await?;
                 Ok(WaybarOutput::default())
             }
             "show" => self.get_status(config, state, target_type).await,
@@ -198,13 +358,10 @@ impl AudioModule {
     async fn get_status(
         &self,
         config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
         target_type: &str,
     ) -> Result<WaybarOutput> {
-        let audio_state = {
+        let audio_state = state.audio.borrow().clone();
-            let lock = state.read().await;
-            lock.audio.clone()
-        };
 
         let (name, description, volume, muted) = if target_type == "sink" {
             (
@@ -287,69 +444,41 @@ impl AudioModule {
         })
     }
 
-    fn cycle_device(&self, target_type: &str) -> Result<()> {
+    async fn change_volume(
-        // Keep using pactl for cycling for now as it's a rare action
+        &self,
-        // but we could also implement it natively later.
+        state: &AppReceivers,
-        let set_cmd = if target_type == "sink" {
+        target_type: &str,
-            "set-default-sink"
+        step: &str,
-        } else {
+        is_up: bool,
-            "set-default-source"
+    ) -> Result<()> {
-        };
+        let is_sink = target_type == "sink";
-
+        let step_val: u32 = step.parse().unwrap_or(5);
-        // We need to find the "next" device.
+        let _ = state
-        // For simplicity, let's keep the CLI version for now or refactor later.
+            .audio_cmd_tx
-        // The user asked for "step by step".
+            .send(AudioCommand::ChangeVolume {
-
+                is_sink,
-        let list_cmd = if target_type == "sink" {
+                step_val,
-            "sinks"
+                is_up,
-        } else {
-            "sources"
-        };
-        let output = Command::new("pactl")
-            .args(["list", "short", list_cmd])
-            .output()?;
-        let stdout = String::from_utf8_lossy(&output.stdout);
-
-        let devices: Vec<String> = stdout
-            .lines()
-            .filter_map(|l| {
-                let parts: Vec<&str> = l.split_whitespace().collect();
-                if parts.len() >= 2 {
-                    let name = parts[1].to_string();
-                    if target_type == "source" && name.contains(".monitor") {
-                        None
-                    } else {
-                        Some(name)
-                    }
-                } else {
-                    None
-                }
             })
-            .collect();
+            .await;
+        Ok(())
+    }
 
-        if devices.is_empty() {
+    async fn toggle_mute(&self, state: &AppReceivers, target_type: &str) -> Result<()> {
-            return Ok(());
+        let is_sink = target_type == "sink";
-        }
+        let _ = state
+            .audio_cmd_tx
+            .send(AudioCommand::ToggleMute { is_sink })
+            .await;
+        Ok(())
+    }
 
-        let info_output = Command::new("pactl").args(["info"]).output()?;
+    async fn cycle_device(&self, state: &AppReceivers, target_type: &str) -> Result<()> {
-        let info_stdout = String::from_utf8_lossy(&info_output.stdout);
+        let is_sink = target_type == "sink";
-        let search_key = if target_type == "sink" {
+        let _ = state
-            "Default Sink:"
+            .audio_cmd_tx
-        } else {
+            .send(AudioCommand::CycleDevice { is_sink })
-            "Default Source:"
+            .await;
-        };
-        let current_dev = info_stdout
-            .lines()
-            .find(|l| l.contains(search_key))
-            .and_then(|l| l.split(':').nth(1))
-            .map(|s| s.trim())
-            .unwrap_or("");
-
-        let current_index = devices.iter().position(|d| d == current_dev).unwrap_or(0);
-        let next_index = (current_index + 1) % devices.len();
-        let next_dev = &devices[next_index];
-
-        Command::new("pactl").args([set_cmd, next_dev]).status()?;
         Ok(())
     }
 }

src/modules/backlight.rs

@@ -0,0 +1,154 @@
+use crate::config::Config;
+use crate::error::Result;
+use crate::modules::WaybarModule;
+use crate::output::WaybarOutput;
+use crate::state::{AppReceivers, BacklightState};
+use crate::utils::{TokenValue, format_template};
+use notify::{Config as NotifyConfig, Event, RecommendedWatcher, RecursiveMode, Watcher};
+use std::path::PathBuf;
+use std::sync::mpsc;
+use std::time::Duration;
+use tokio::sync::watch;
+use tracing::{error, info};
+
+pub struct BacklightModule;
+
+impl WaybarModule for BacklightModule {
+    async fn run(
+        &self,
+        config: &Config,
+        state: &AppReceivers,
+        _args: &[&str],
+    ) -> Result<WaybarOutput> {
+        let percentage = state.backlight.borrow().percentage;
+
+        let icon = if percentage < 30 {
+            "󰃞"
+        } else if percentage < 70 {
+            "󰃟"
+        } else {
+            "󰃠"
+        };
+
+        let text = format_template(
+            &config.backlight.format,
+            &[
+                ("percentage", TokenValue::Int(percentage as i64)),
+                ("icon", TokenValue::String(icon.to_string())),
+            ],
+        );
+
+        Ok(WaybarOutput {
+            text,
+            tooltip: Some(format!("Brightness: {}%", percentage)),
+            class: Some("normal".to_string()),
+            percentage: Some(percentage),
+        })
+    }
+}
+
+pub struct BacklightDaemon;
+
+impl BacklightDaemon {
+    pub fn new() -> Self {
+        Self
+    }
+
+    pub fn start(&self, tx: watch::Sender<BacklightState>) {
+        std::thread::spawn(move || {
+            let base_dir = PathBuf::from("/sys/class/backlight");
+            let mut device_dir = None;
+
+            if let Ok(entries) = std::fs::read_dir(&base_dir) {
+                for entry in entries.flatten() {
+                    let path = entry.path();
+                    if path.is_dir() {
+                        device_dir = Some(path);
+                        break;
+                    }
+                }
+            }
+
+            let Some(dir) = device_dir else {
+                error!("No backlight device found in /sys/class/backlight");
+                return;
+            };
+
+            info!("Monitoring backlight device: {:?}", dir);
+
+            let max_brightness_path = dir.join("max_brightness");
+            let brightness_path = dir.join("actual_brightness");
+            let brightness_path_fallback = dir.join("brightness");
+
+            let target_file = if brightness_path.exists() {
+                brightness_path
+            } else {
+                brightness_path_fallback
+            };
+
+            let get_percentage = || -> u8 {
+                let max: f64 = std::fs::read_to_string(&max_brightness_path)
+                    .unwrap_or_default()
+                    .trim()
+                    .parse()
+                    .unwrap_or(100.0);
+                let current: f64 = std::fs::read_to_string(&target_file)
+                    .unwrap_or_default()
+                    .trim()
+                    .parse()
+                    .unwrap_or(0.0);
+
+                if max > 0.0 {
+                    ((current / max) * 100.0).round() as u8
+                } else {
+                    0
+                }
+            };
+
+            // Initial poll
+            let _ = tx.send(BacklightState {
+                percentage: get_percentage(),
+            });
+
+            // Set up notify watcher
+            let (ev_tx, ev_rx) = mpsc::channel();
+            let mut watcher = RecommendedWatcher::new(
+                move |res: notify::Result<Event>| {
+                    if let Ok(event) = res
+                        && event.kind.is_modify()
+                    {
+                        let _ = ev_tx.send(());
+                    }
+                },
+                NotifyConfig::default(),
+            )
+            .unwrap();
+
+            if let Err(e) = watcher.watch(&target_file, RecursiveMode::NonRecursive) {
+                error!("Failed to watch backlight file: {}", e);
+                return;
+            }
+
+            loop {
+                // Block until an event occurs or a timeout to catch missed events
+                if ev_rx.recv_timeout(Duration::from_secs(5)).is_ok() {
+                    // Debounce rapid events
+                    std::thread::sleep(Duration::from_millis(50));
+                    while ev_rx.try_recv().is_ok() {}
+
+                    let _ = tx.send(BacklightState {
+                        percentage: get_percentage(),
+                    });
+                } else {
+                    // Timeout hit, poll just in case
+                    let current = get_percentage();
+                    if tx.borrow().percentage != current {
+                        let _ = tx.send(BacklightState {
+                            percentage: current,
+                        });
+                    }
+                }
+            }
+        });
+    }
+}

src/modules/bt/buds.rs

@@ -1,10 +1,9 @@
 use crate::config::Config;
 use crate::error::{FluxoError, Result as FluxoResult};
-use crate::modules::bt::maestro::{BudsCommand, get_maestro};
+use crate::modules::bt::maestro::BudsCommand;
-use crate::state::SharedState;
+use crate::state::AppReceivers;
 use crate::utils::TokenValue;
 use futures::future::BoxFuture;
-use std::sync::Arc;
 
 pub trait BtPlugin: Send + Sync {
     fn name(&self) -> &str;
@@ -12,21 +11,21 @@ pub trait BtPlugin: Send + Sync {
     fn get_data(
         &self,
         config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
         mac: &str,
     ) -> BoxFuture<'static, FluxoResult<Vec<(String, TokenValue)>>>;
     fn get_modes(
         &self,
         mac: &str,
-        state: &SharedState,
+        state: &AppReceivers,
     ) -> BoxFuture<'static, FluxoResult<Vec<String>>>;
     fn set_mode(
         &self,
         mode: &str,
         mac: &str,
-        state: &SharedState,
+        state: &AppReceivers,
     ) -> BoxFuture<'static, FluxoResult<()>>;
-    fn cycle_mode(&self, mac: &str, state: &SharedState) -> BoxFuture<'static, FluxoResult<()>>;
+    fn cycle_mode(&self, mac: &str, state: &AppReceivers) -> BoxFuture<'static, FluxoResult<()>>;
 }
 
 pub struct PixelBudsPlugin;
@@ -43,13 +42,13 @@ impl BtPlugin for PixelBudsPlugin {
     fn get_data(
         &self,
         _config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
         mac: &str,
     ) -> BoxFuture<'static, FluxoResult<Vec<(String, TokenValue)>>> {
         let mac = mac.to_string();
-        let state = Arc::clone(state);
+        let state = state.clone();
         Box::pin(async move {
-            let maestro = get_maestro(&state);
+            let maestro = crate::modules::bt::maestro::get_maestro(&state);
             maestro.ensure_task(&mac);
             let status = maestro.get_status(&mac);
 
@@ -91,7 +90,7 @@ impl BtPlugin for PixelBudsPlugin {
     fn get_modes(
         &self,
         _mac: &str,
-        _state: &SharedState,
+        _state: &AppReceivers,
     ) -> BoxFuture<'static, FluxoResult<Vec<String>>> {
         Box::pin(async move {
             Ok(vec![
@@ -106,13 +105,13 @@ impl BtPlugin for PixelBudsPlugin {
         &self,
         mode: &str,
         mac: &str,
-        state: &SharedState,
+        state: &AppReceivers,
     ) -> BoxFuture<'static, FluxoResult<()>> {
         let mode = mode.to_string();
         let mac = mac.to_string();
-        let state = Arc::clone(state);
+        let state = state.clone();
         Box::pin(async move {
-            get_maestro(&state)
+            crate::modules::bt::maestro::get_maestro(&state)
                 .send_command(&mac, BudsCommand::SetAnc(mode))
                 .map_err(|e: anyhow::Error| FluxoError::Module {
                     module: "bt.buds",
@@ -121,17 +120,17 @@ impl BtPlugin for PixelBudsPlugin {
         })
     }
 
-    fn cycle_mode(&self, mac: &str, state: &SharedState) -> BoxFuture<'static, FluxoResult<()>> {
+    fn cycle_mode(&self, mac: &str, state: &AppReceivers) -> BoxFuture<'static, FluxoResult<()>> {
         let mac = mac.to_string();
-        let state = Arc::clone(state);
+        let state = state.clone();
         Box::pin(async move {
-            let status = get_maestro(&state).get_status(&mac);
+            let status = crate::modules::bt::maestro::get_maestro(&state).get_status(&mac);
             let next_mode = match status.anc_state.as_str() {
                 "active" => "aware",
                 "aware" => "off",
                 _ => "active",
             };
-            get_maestro(&state)
+            crate::modules::bt::maestro::get_maestro(&state)
                 .send_command(&mac, BudsCommand::SetAnc(next_mode.to_string()))
                 .map_err(|e: anyhow::Error| FluxoError::Module {
                     module: "bt.buds",

src/modules/bt/maestro.rs

@@ -1,4 +1,4 @@
-use crate::state::SharedState;
+use crate::state::AppReceivers;
 use anyhow::{Context, Result};
 use futures::StreamExt;
 use std::collections::HashMap;
@@ -39,11 +39,11 @@ pub struct MaestroManager {
 }
 
 impl MaestroManager {
-    pub fn new(state: SharedState) -> Self {
+    pub fn new(state: AppReceivers) -> Self {
         let (tx, mut rx) = mpsc::unbounded_channel::<ManagerCommand>();
         let statuses = Arc::new(Mutex::new(HashMap::new()));
         let statuses_clone = Arc::clone(&statuses);
-        let state_clone = Arc::clone(&state);
+        let state_clone = state.clone();
 
         // Start dedicated BT management thread
         std::thread::spawn(move || {
@@ -68,7 +68,7 @@ impl MaestroManager {
 
                                         let mac_clone = mac.clone();
                                         let st_clone = Arc::clone(&statuses_clone);
-                                        let state_inner = Arc::clone(&state_clone);
+                                        let state_inner = state_clone.clone();
 
                                         tokio::task::spawn_local(async move {
                                             if let Err(e) = buds_task(&mac_clone, st_clone, buds_rx, state_inner).await {
@@ -122,7 +122,7 @@ async fn buds_task(
     mac: &str,
     statuses: Arc<Mutex<HashMap<String, BudsStatus>>>,
     mut rx: mpsc::Receiver<BudsCommand>,
-    state: SharedState,
+    state: AppReceivers,
 ) -> Result<()> {
     info!("Starting native Maestro connection task for {}", mac);
 
@@ -215,8 +215,8 @@ async fn buds_task(
 
         // Update health
         {
-            let mut lock = state.write().await;
+            let mut lock = state.health.write().await;
-            let health = lock.health.entry("bt.buds".to_string()).or_default();
+            let health = lock.entry("bt.buds".to_string()).or_default();
             health.consecutive_failures = 0;
             health.backoff_until = None;
         }
@@ -357,6 +357,6 @@ pub fn anc_state_to_string(state: &settings::AncState) -> String {
 
 static MAESTRO: OnceLock<MaestroManager> = OnceLock::new();
 
-pub fn get_maestro(state: &SharedState) -> &MaestroManager {
+pub fn get_maestro(state: &AppReceivers) -> &MaestroManager {
-    MAESTRO.get_or_init(|| MaestroManager::new(Arc::clone(state)))
+    MAESTRO.get_or_init(|| MaestroManager::new(state.clone()))
 }

src/modules/bt/mod.rs

@@ -5,11 +5,11 @@ use crate::config::Config;
 use crate::error::Result as FluxoResult;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::{BtState, SharedState};
+use crate::state::{AppReceivers, BtState};
 use crate::utils::{TokenValue, format_template};
 use anyhow::Result;
-use std::process::Command;
+use std::sync::LazyLock;
-use std::sync::{Arc, LazyLock};
+use tokio::sync::watch;
 use tracing::{error, warn};
 
 use self::buds::{BtPlugin, PixelBudsPlugin};
@@ -23,13 +23,23 @@ impl BtDaemon {
         Self { session: None }
     }
 
-    pub async fn poll(&mut self, state: SharedState, config: &Config) {
+    pub async fn poll(
-        if let Err(e) = self.poll_async(state, config).await {
+        &mut self,
+        tx: &watch::Sender<BtState>,
+        state: &AppReceivers,
+        config: &Config,
+    ) {
+        if let Err(e) = self.poll_async(tx, state, config).await {
             error!("BT daemon error: {}", e);
         }
     }
 
-    async fn poll_async(&mut self, state: SharedState, config: &Config) -> Result<()> {
+    async fn poll_async(
+        &mut self,
+        tx: &watch::Sender<BtState>,
+        state: &AppReceivers,
+        config: &Config,
+    ) -> Result<()> {
         if self.session.is_none() {
             self.session = Some(bluer::Session::new().await?);
         }
@@ -60,7 +70,7 @@ impl BtDaemon {
 
                         for p in PLUGINS.iter() {
                             if p.can_handle(&bt_state.device_alias, &bt_state.device_address) {
-                                match p.get_data(config, &state, &bt_state.device_address).await {
+                                match p.get_data(config, state, &bt_state.device_address).await {
                                     Ok(data) => {
                                         bt_state.plugin_data = data
                                             .into_iter()
@@ -90,8 +100,7 @@ impl BtDaemon {
             }
         }
 
-        let mut lock = state.write().await;
+        let _ = tx.send(bt_state);
-        lock.bluetooth = bt_state;
 
         Ok(())
     }
@@ -100,137 +109,181 @@ impl BtDaemon {
 static PLUGINS: LazyLock<Vec<Box<dyn BtPlugin>>> =
     LazyLock::new(|| vec![Box::new(PixelBudsPlugin)]);
 
+fn trigger_robust_poll(state: AppReceivers) {
+    tokio::spawn(async move {
+        // Poll immediately and then a few times over the next few seconds
+        // to catch slow state changes in bluez or plugins.
+        for delay in [200, 500, 1000, 2000, 3000] {
+            tokio::time::sleep(std::time::Duration::from_millis(delay)).await;
+            let _ = state.bt_force_poll.try_send(());
+        }
+    });
+}
+
 pub struct BtModule;
 
 impl WaybarModule for BtModule {
-    fn run(
+    async fn run(
         &self,
         config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
         args: &[&str],
-    ) -> impl std::future::Future<Output = FluxoResult<WaybarOutput>> + Send {
+    ) -> FluxoResult<WaybarOutput> {
         let action = args.first().cloned().unwrap_or("show").to_string();
         let args = args.iter().map(|s| s.to_string()).collect::<Vec<_>>();
-        let state = Arc::clone(state);
-        let config = config.clone();
 
-        async move {
+        let bt_state = state.bluetooth.borrow().clone();
-            let bt_state = {
-                let lock = state.read().await;
-                lock.bluetooth.clone()
-            };
 
-            match action.as_str() {
+        match action.as_str() {
-                "disconnect" if bt_state.connected => {
+            "connect" => {
-                    let _ = Command::new("bluetoothctl")
+                if let Some(mac) = args.get(1) {
-                        .args(["disconnect", &bt_state.device_address])
+                    if let Ok(session) = bluer::Session::new().await
-                        .output();
+                        && let Ok(adapter) = session.default_adapter().await
-                    return Ok(WaybarOutput::default());
+                        && let Ok(addr) = mac.parse::<bluer::Address>()
+                        && let Ok(device) = adapter.device(addr)
+                    {
+                        let _ = device.connect().await;
+                    }
+                    trigger_robust_poll(state.clone());
                 }
-                "cycle_mode" if bt_state.connected => {
+                return Ok(WaybarOutput::default());
+            }
+            "disconnect" if bt_state.connected => {
+                if let Ok(session) = bluer::Session::new().await
+                    && let Ok(adapter) = session.default_adapter().await
+                    && let Ok(addr) = bt_state.device_address.parse::<bluer::Address>()
+                    && let Ok(device) = adapter.device(addr)
+                {
+                    let _ = device.disconnect().await;
+                }
+                trigger_robust_poll(state.clone());
+                return Ok(WaybarOutput::default());
+            }
+            "menu_data" => {
+                let mut devs = Vec::new();
+                if let Ok(session) = bluer::Session::new().await
+                    && let Ok(adapter) = session.default_adapter().await
+                    && let Ok(addresses) = adapter.device_addresses().await
+                {
+                    for addr in addresses {
+                        if let Ok(device) = adapter.device(addr)
+                            && device.is_paired().await.unwrap_or(false)
+                        {
+                            let alias = device.alias().await.unwrap_or_else(|_| addr.to_string());
+                            devs.push(format!("{} ({})", alias, addr));
+                        }
+                    }
+                }
+                return Ok(WaybarOutput {
+                    text: devs.join("\n"),
+                    ..Default::default()
+                });
+            }
+            "cycle_mode" if bt_state.connected => {
+                let plugin = PLUGINS
+                    .iter()
+                    .find(|p| p.can_handle(&bt_state.device_alias, &bt_state.device_address));
+                if let Some(p) = plugin {
+                    p.cycle_mode(&bt_state.device_address, state).await?;
+                    trigger_robust_poll(state.clone());
+                }
+                return Ok(WaybarOutput::default());
+            }
+            "get_modes" if bt_state.connected => {
+                let plugin = PLUGINS
+                    .iter()
+                    .find(|p| p.can_handle(&bt_state.device_alias, &bt_state.device_address));
+                let modes = if let Some(p) = plugin {
+                    p.get_modes(&bt_state.device_address, state).await?
+                } else {
+                    vec![]
+                };
+                return Ok(WaybarOutput {
+                    text: modes.join("\n"),
+                    ..Default::default()
+                });
+            }
+            "set_mode" if bt_state.connected => {
+                if let Some(mode) = args.get(1) {
                     let plugin = PLUGINS
                         .iter()
                         .find(|p| p.can_handle(&bt_state.device_alias, &bt_state.device_address));
                     if let Some(p) = plugin {
-                        p.cycle_mode(&bt_state.device_address, &state).await?;
+                        p.set_mode(mode, &bt_state.device_address, state).await?;
+                        trigger_robust_poll(state.clone());
                     }
-                    return Ok(WaybarOutput::default());
                 }
-                "get_modes" if bt_state.connected => {
+                return Ok(WaybarOutput::default());
-                    let plugin = PLUGINS
-                        .iter()
-                        .find(|p| p.can_handle(&bt_state.device_alias, &bt_state.device_address));
-                    let modes = if let Some(p) = plugin {
-                        p.get_modes(&bt_state.device_address, &state).await?
-                    } else {
-                        vec![]
-                    };
-                    return Ok(WaybarOutput {
-                        text: modes.join("\n"),
-                        ..Default::default()
-                    });
-                }
-                "set_mode" if bt_state.connected => {
-                    if let Some(mode) = args.get(1) {
-                        let plugin = PLUGINS.iter().find(|p| {
-                            p.can_handle(&bt_state.device_alias, &bt_state.device_address)
-                        });
-                        if let Some(p) = plugin {
-                            p.set_mode(mode, &bt_state.device_address, &state).await?;
-                        }
-                    }
-                    return Ok(WaybarOutput::default());
-                }
-                "show" => {}
-                _ => {}
             }
+            "show" => {}
+            _ => {}
+        }
 
-            if !bt_state.adapter_powered {
+        if !bt_state.adapter_powered {
-                return Ok(WaybarOutput {
+            return Ok(WaybarOutput {
-                    text: config.bt.format_disabled.clone(),
+                text: config.bt.format_disabled.clone(),
-                    tooltip: Some("Bluetooth Disabled".to_string()),
+                tooltip: Some("Bluetooth Disabled".to_string()),
-                    class: Some("disabled".to_string()),
+                class: Some("disabled".to_string()),
-                    percentage: None,
+                percentage: None,
-                });
+            });
-            }
+        }
 
-            if bt_state.connected {
+        if bt_state.connected {
-                let mut tokens: Vec<(String, TokenValue)> = vec![
+            let mut tokens: Vec<(String, TokenValue)> = vec![
-                    (
+                (
-                        "alias".to_string(),
+                    "alias".to_string(),
-                        TokenValue::String(bt_state.device_alias.clone()),
+                    TokenValue::String(bt_state.device_alias.clone()),
-                    ),
+                ),
-                    (
+                (
-                        "mac".to_string(),
+                    "mac".to_string(),
-                        TokenValue::String(bt_state.device_address.clone()),
+                    TokenValue::String(bt_state.device_address.clone()),
-                    ),
+                ),
-                ];
+            ];
 
-                let mut class = vec!["connected".to_string()];
+            let mut class = vec!["connected".to_string()];
-                let mut has_plugin = false;
+            let mut has_plugin = false;
 
-                for (k, v) in &bt_state.plugin_data {
+            for (k, v) in &bt_state.plugin_data {
-                    if k == "plugin_class" {
+                if k == "plugin_class" {
-                        class.push(v.clone());
+                    class.push(v.clone());
-                        has_plugin = true;
+                    has_plugin = true;
-                    } else if k == "plugin_error" {
+                } else if k == "plugin_error" {
-                        class.push("plugin-error".to_string());
+                    class.push("plugin-error".to_string());
-                    } else {
-                        tokens.push((k.clone(), TokenValue::String(v.clone())));
-                    }
-                }
-
-                let format = if has_plugin {
-                    &config.bt.format_plugin
                 } else {
-                    &config.bt.format_connected
+                    tokens.push((k.clone(), TokenValue::String(v.clone())));
-                };
+                }
-
-                let text = format_template(format, &tokens);
-                let tooltip = format!(
-                    "{} | MAC: {}\nBattery: {}",
-                    bt_state.device_alias,
-                    bt_state.device_address,
-                    bt_state
-                        .battery_percentage
-                        .map(|b| format!("{}%", b))
-                        .unwrap_or_else(|| "N/A".to_string())
-                );
-
-                Ok(WaybarOutput {
-                    text,
-                    tooltip: Some(tooltip),
-                    class: Some(class.join(" ")),
-                    percentage: bt_state.battery_percentage,
-                })
-            } else {
-                Ok(WaybarOutput {
-                    text: config.bt.format_disconnected.clone(),
-                    tooltip: Some("Bluetooth On (Disconnected)".to_string()),
-                    class: Some("disconnected".to_string()),
-                    percentage: None,
-                })
             }
+
+            let format = if has_plugin {
+                &config.bt.format_plugin
+            } else {
+                &config.bt.format_connected
+            };
+
+            let text = format_template(format, &tokens);
+            let tooltip = format!(
+                "{} | MAC: {}\nBattery: {}",
+                bt_state.device_alias,
+                bt_state.device_address,
+                bt_state
+                    .battery_percentage
+                    .map(|b| format!("{}%", b))
+                    .unwrap_or_else(|| "N/A".to_string())
+            );
+
+            Ok(WaybarOutput {
+                text,
+                tooltip: Some(tooltip),
+                class: Some(class.join(" ")),
+                percentage: bt_state.battery_percentage,
+            })
+        } else {
+            Ok(WaybarOutput {
+                text: config.bt.format_disconnected.clone(),
+                tooltip: Some("Bluetooth On (Disconnected)".to_string()),
+                class: Some("disconnected".to_string()),
+                percentage: None,
+            })
         }
     }
 }

src/modules/btrfs.rs

@@ -2,7 +2,7 @@ use crate::config::Config;
 use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
+use crate::state::AppReceivers;
 use crate::utils::{TokenValue, format_template};
 
 pub struct BtrfsModule;
@@ -11,12 +11,12 @@ impl WaybarModule for BtrfsModule {
     async fn run(
         &self,
         config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
         _args: &[&str],
     ) -> Result<WaybarOutput> {
         let disks = {
-            let s = state.read().await;
+            let s = state.disks.borrow();
-            s.disks.clone()
+            s.clone()
         };
 
         let mut total_used: f64 = 0.0;

src/modules/cpu.rs

@@ -2,7 +2,7 @@ use crate::config::Config;
 use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
+use crate::state::AppReceivers;
 use crate::utils::{TokenValue, format_template};
 
 pub struct CpuModule;
@@ -11,16 +11,12 @@ impl WaybarModule for CpuModule {
     async fn run(
         &self,
         config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
         _args: &[&str],
     ) -> Result<WaybarOutput> {
         let (usage, temp, model) = {
-            let state_lock = state.read().await;
+            let s = state.cpu.borrow();
-            (
+            (s.usage, s.temp, s.model.clone())
-                state_lock.cpu.usage,
-                state_lock.cpu.temp,
-                state_lock.cpu.model.clone(),
-            )
         };
 
         let text = format_template(
@@ -64,7 +60,7 @@ mod tests {
             ..Default::default()
         });
         let config = Config::default();
-        let output = CpuModule.run(&config, &state, &[]).await.unwrap();
+        let output = CpuModule.run(&config, &state.receivers, &[]).await.unwrap();
         assert!(output.text.contains("25.0"));
         assert!(output.text.contains("45.0"));
         assert_eq!(output.class.as_deref(), Some("normal"));
@@ -83,7 +79,7 @@ mod tests {
             ..Default::default()
         });
         let config = Config::default();
-        let output = CpuModule.run(&config, &state, &[]).await.unwrap();
+        let output = CpuModule.run(&config, &state.receivers, &[]).await.unwrap();
         assert_eq!(output.class.as_deref(), Some("high"));
     }
 
@@ -98,7 +94,7 @@ mod tests {
             ..Default::default()
         });
         let config = Config::default();
-        let output = CpuModule.run(&config, &state, &[]).await.unwrap();
+        let output = CpuModule.run(&config, &state.receivers, &[]).await.unwrap();
         assert_eq!(output.class.as_deref(), Some("max"));
     }
 }

src/modules/disk.rs

@@ -2,7 +2,7 @@ use crate::config::Config;
 use crate::error::{FluxoError, Result};
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
+use crate::state::AppReceivers;
 use crate::utils::{TokenValue, format_template};
 
 pub struct DiskModule;
@@ -11,15 +11,19 @@ impl WaybarModule for DiskModule {
     async fn run(
         &self,
         config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
         args: &[&str],
     ) -> Result<WaybarOutput> {
         let mountpoint = args.first().unwrap_or(&"/");
 
-        let disks = {
+        let disks = state.disks.borrow().clone();
-            let s = state.read().await;
+
-            s.disks.clone()
+        if disks.is_empty() {
-        };
+            return Ok(WaybarOutput {
+                text: "Disk Loading...".to_string(),
+                ..Default::default()
+            });
+        }
 
         for disk in &disks {
             if disk.mount_point == *mountpoint {
@@ -76,9 +80,9 @@ impl WaybarModule for DiskModule {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::state::{AppState, DiskInfo, mock_state};
+    use crate::state::{AppState, DiskInfo, MockState, mock_state};
 
-    fn state_with_disk(mount: &str, total: u64, available: u64) -> crate::state::SharedState {
+    fn state_with_disk(mount: &str, total: u64, available: u64) -> MockState {
         mock_state(AppState {
             disks: vec![DiskInfo {
                 mount_point: mount.to_string(),
@@ -95,7 +99,10 @@ mod tests {
         let gb = 1024 * 1024 * 1024;
         let state = state_with_disk("/", 100 * gb, 60 * gb);
         let config = Config::default();
-        let output = DiskModule.run(&config, &state, &["/"]).await.unwrap();
+        let output = DiskModule
+            .run(&config, &state.receivers, &["/"])
+            .await
+            .unwrap();
         assert_eq!(output.class.as_deref(), Some("normal"));
         assert_eq!(output.percentage, Some(40)); // 40% used
     }
@@ -105,7 +112,10 @@ mod tests {
         let gb = 1024 * 1024 * 1024;
         let state = state_with_disk("/", 100 * gb, 15 * gb);
         let config = Config::default();
-        let output = DiskModule.run(&config, &state, &["/"]).await.unwrap();
+        let output = DiskModule
+            .run(&config, &state.receivers, &["/"])
+            .await
+            .unwrap();
         assert_eq!(output.class.as_deref(), Some("high")); // 85% used
     }
 
@@ -113,7 +123,9 @@ mod tests {
     async fn test_disk_not_found() {
         let state = mock_state(AppState::default());
         let config = Config::default();
-        let result = DiskModule.run(&config, &state, &["/nonexistent"]).await;
+        let result = DiskModule
+            .run(&config, &state.receivers, &["/nonexistent"])
+            .await;
         assert!(result.is_err());
     }
 }

src/modules/dnd.rs

@@ -0,0 +1,104 @@
+use crate::config::Config;
+use crate::error::Result;
+use crate::modules::WaybarModule;
+use crate::output::WaybarOutput;
+use crate::state::{AppReceivers, DndState};
+use futures::StreamExt;
+use tokio::sync::watch;
+use tracing::{debug, error, info};
+use zbus::{Connection, fdo::PropertiesProxy, proxy};
+
+pub struct DndModule;
+
+impl WaybarModule for DndModule {
+    async fn run(
+        &self,
+        config: &Config,
+        state: &AppReceivers,
+        _args: &[&str],
+    ) -> Result<WaybarOutput> {
+        let is_dnd = state.dnd.borrow().is_dnd;
+
+        if is_dnd {
+            Ok(WaybarOutput {
+                text: config.dnd.format_dnd.clone(),
+                tooltip: Some("Do Not Disturb: On".to_string()),
+                class: Some("dnd".to_string()),
+                percentage: None,
+            })
+        } else {
+            Ok(WaybarOutput {
+                text: config.dnd.format_normal.clone(),
+                tooltip: Some("Do Not Disturb: Off".to_string()),
+                class: Some("normal".to_string()),
+                percentage: None,
+            })
+        }
+    }
+}
+
+pub struct DndDaemon;
+
+#[proxy(
+    interface = "org.erikreider.swaync.control",
+    default_service = "org.erikreider.swaync.control",
+    default_path = "/org/erikreider/swaync/control"
+)]
+trait SwayncControl {
+    #[zbus(property)]
+    fn dnd(&self) -> zbus::Result<bool>;
+}
+
+impl DndDaemon {
+    pub fn new() -> Self {
+        Self
+    }
+
+    pub fn start(&self, tx: watch::Sender<DndState>) {
+        tokio::spawn(async move {
+            loop {
+                if let Err(e) = Self::listen_loop(&tx).await {
+                    error!("DND listener error: {}", e);
+                    tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
+                }
+            }
+        });
+    }
+
+    async fn listen_loop(tx: &watch::Sender<DndState>) -> anyhow::Result<()> {
+        let connection = Connection::session().await?;
+
+        info!("Connected to D-Bus for DND monitoring");
+
+        // Try SwayNC first
+        if let Ok(proxy) = SwayncControlProxy::new(&connection).await {
+            debug!("Found SwayNC, using it for DND state.");
+
+            // Get initial state
+            if let Ok(is_dnd) = proxy.dnd().await {
+                let _ = tx.send(DndState { is_dnd });
+            }
+
+            // Monitor properties changed
+            if let Ok(props_proxy) = PropertiesProxy::builder(&connection)
+                .destination("org.erikreider.swaync.control")?
+                .path("/org/erikreider/swaync/control")?
+                .build()
+                .await
+            {
+                let mut stream = props_proxy.receive_properties_changed().await?;
+                while let Some(signal) = stream.next().await {
+                    let args = signal.args()?;
+                    if args.interface_name == "org.erikreider.swaync.control"
+                        && let Some(val) = args.changed_properties.get("dnd")
+                        && let Ok(is_dnd) = bool::try_from(val)
+                    {
+                        let _ = tx.send(DndState { is_dnd });
+                    }
+                }
+            }
+        }
+
+        Err(anyhow::anyhow!("DND stream ended or daemon not found"))
+    }
+}

src/modules/game.rs

@@ -2,11 +2,9 @@ use crate::config::Config;
 use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
+use crate::state::AppReceivers;
-use anyhow::anyhow;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
-use std::env;
+use tokio::net::UnixStream;
-use std::io::{Read, Write};
-use std::os::unix::net::UnixStream;
 
 pub struct GameModule;
 
@@ -14,10 +12,11 @@ impl WaybarModule for GameModule {
     async fn run(
         &self,
         config: &Config,
-        _state: &SharedState,
+        _state: &AppReceivers,
         _args: &[&str],
     ) -> Result<WaybarOutput> {
         let is_gamemode = hyprland_ipc("j/getoption animations:enabled")
+            .await
             .map(|stdout| stdout.contains("\"int\": 0"))
             .unwrap_or(false);
 
@@ -39,16 +38,14 @@ impl WaybarModule for GameModule {
     }
 }
 
-fn hyprland_ipc(cmd: &str) -> Result<String> {
+async fn hyprland_ipc(cmd: &str) -> Result<String> {
-    let signature = env::var("HYPRLAND_INSTANCE_SIGNATURE")
+    let path = crate::utils::get_hyprland_socket(".socket.sock")?;
-        .map_err(|_| anyhow!("HYPRLAND_INSTANCE_SIGNATURE not set"))?;
-    let path = format!("/tmp/hypr/{}/.socket.sock", signature);
 
-    let mut stream = UnixStream::connect(path)?;
+    let mut stream = UnixStream::connect(path).await?;
-    stream.write_all(cmd.as_bytes())?;
+    stream.write_all(cmd.as_bytes()).await?;
 
     let mut response = String::new();
-    stream.read_to_string(&mut response)?;
+    stream.read_to_string(&mut response).await?;
 
     Ok(response)
 }

src/modules/gpu.rs

@@ -2,7 +2,7 @@ use crate::config::Config;
 use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
+use crate::state::AppReceivers;
 use crate::utils::{TokenValue, format_template};
 
 pub struct GpuModule;
@@ -11,19 +11,19 @@ impl WaybarModule for GpuModule {
     async fn run(
         &self,
         config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
         _args: &[&str],
     ) -> Result<WaybarOutput> {
         let (active, vendor, usage, vram_used, vram_total, temp, model) = {
-            let state_lock = state.read().await;
+            let s = state.gpu.borrow();
             (
-                state_lock.gpu.active,
+                s.active,
-                state_lock.gpu.vendor.clone(),
+                s.vendor.clone(),
-                state_lock.gpu.usage,
+                s.usage,
-                state_lock.gpu.vram_used,
+                s.vram_used,
-                state_lock.gpu.vram_total,
+                s.vram_total,
-                state_lock.gpu.temp,
+                s.temp,
-                state_lock.gpu.model.clone(),
+                s.model.clone(),
             )
         };
 

src/modules/hardware.rs

@@ -1,5 +1,6 @@
-use crate::state::{DiskInfo, SharedState};
+use crate::state::{CpuState, DiskInfo, GpuState, MemoryState, SysState};
 use sysinfo::{Components, Disks, System};
+use tokio::sync::watch;
 
 pub struct HardwareDaemon {
     sys: System,
@@ -24,7 +25,12 @@ impl HardwareDaemon {
         }
     }
 
-    pub async fn poll_fast(&mut self, state: SharedState) {
+    pub async fn poll_fast(
+        &mut self,
+        cpu_tx: &watch::Sender<CpuState>,
+        mem_tx: &watch::Sender<MemoryState>,
+        sys_tx: &watch::Sender<SysState>,
+    ) {
         self.sys.refresh_cpu_usage();
         self.sys.refresh_memory();
         self.components.refresh(true);
@@ -70,28 +76,37 @@ impl HardwareDaemon {
             }
         }
 
-        let mut state_lock = state.write().await;
+        let mut cpu = cpu_tx.borrow().clone();
-        state_lock.cpu.usage = cpu_usage as f64;
+        cpu.usage = cpu_usage as f64;
-        state_lock.cpu.temp = cpu_temp;
+        cpu.temp = cpu_temp;
-        state_lock.cpu.model = cpu_model;
+        cpu.model = cpu_model;
+        let _ = cpu_tx.send(cpu);
 
-        state_lock.memory.total_gb = total_mem;
+        let mut mem = mem_tx.borrow().clone();
-        state_lock.memory.used_gb = used_mem;
+        mem.total_gb = total_mem;
+        mem.used_gb = used_mem;
+        let _ = mem_tx.send(mem);
 
-        state_lock.sys.load_1 = load_avg.one;
+        let mut sys = sys_tx.borrow().clone();
-        state_lock.sys.load_5 = load_avg.five;
+        sys.load_1 = load_avg.one;
-        state_lock.sys.load_15 = load_avg.fifteen;
+        sys.load_5 = load_avg.five;
-        state_lock.sys.uptime = uptime;
+        sys.load_15 = load_avg.fifteen;
-        state_lock.sys.process_count = process_count;
+        sys.uptime = uptime;
+        sys.process_count = process_count;
+        let _ = sys_tx.send(sys);
     }
 
-    pub async fn poll_slow(&mut self, state: SharedState) {
+    pub async fn poll_slow(
+        &mut self,
+        gpu_tx: &watch::Sender<GpuState>,
+        disks_tx: &watch::Sender<Vec<DiskInfo>>,
+    ) {
         // 1. Gather GPU data outside of lock
         let mut gpu_state = crate::state::GpuState::default();
         self.gpu_poll_counter = (self.gpu_poll_counter + 1) % 5;
         let should_poll_gpu = self.gpu_poll_counter == 0;
         if should_poll_gpu {
-            self.poll_gpu(&mut gpu_state);
+            self.poll_gpu(&mut gpu_state).await;
         }
 
         // 2. Gather Disk data outside of lock
@@ -99,39 +114,43 @@ impl HardwareDaemon {
         self.disk_poll_counter = (self.disk_poll_counter + 1) % 10;
         if self.disk_poll_counter == 0 {
             disks_data = Some(
-                Disks::new_with_refreshed_list()
+                tokio::task::spawn_blocking(|| {
-                    .iter()
+                    Disks::new_with_refreshed_list()
-                    .map(|d| DiskInfo {
+                        .iter()
-                        mount_point: d.mount_point().to_string_lossy().into_owned(),
+                        .map(|d| DiskInfo {
-                        filesystem: d.file_system().to_string_lossy().to_lowercase(),
+                            mount_point: d.mount_point().to_string_lossy().into_owned(),
-                        total_bytes: d.total_space(),
+                            filesystem: d.file_system().to_string_lossy().to_lowercase(),
-                        available_bytes: d.available_space(),
+                            total_bytes: d.total_space(),
-                    })
+                            available_bytes: d.available_space(),
-                    .collect::<Vec<DiskInfo>>(),
+                        })
+                        .collect::<Vec<DiskInfo>>()
+                })
+                .await
+                .unwrap_or_default(),
             );
         }
 
         // 3. Apply to state
-        let mut state_lock = state.write().await;
         if should_poll_gpu {
-            state_lock.gpu = gpu_state;
+            let _ = gpu_tx.send(gpu_state);
         }
 
         if let Some(d) = disks_data {
-            state_lock.disks = d;
+            let _ = disks_tx.send(d);
         }
     }
 
-    fn poll_gpu(&mut self, gpu: &mut crate::state::GpuState) {
+    async fn poll_gpu(&mut self, gpu: &mut crate::state::GpuState) {
         gpu.active = false;
 
         if (self.gpu_vendor.as_deref() == Some("NVIDIA") || self.gpu_vendor.is_none())
-            && let Ok(output) = std::process::Command::new("nvidia-smi")
+            && let Ok(output) = tokio::process::Command::new("nvidia-smi")
                 .args([
                     "--query-gpu=utilization.gpu,memory.used,memory.total,temperature.gpu,name",
                     "--format=csv,noheader,nounits",
                 ])
                 .output()
+                .await
             && output.status.success()
         {
             let stdout = String::from_utf8_lossy(&output.stdout);

src/modules/keyboard.rs

@@ -0,0 +1,104 @@
+use crate::config::Config;
+use crate::error::Result;
+use crate::modules::WaybarModule;
+use crate::output::WaybarOutput;
+use crate::state::{AppReceivers, KeyboardState};
+use crate::utils::{TokenValue, format_template};
+use anyhow::anyhow;
+use tokio::io::{AsyncBufReadExt, BufReader};
+use tokio::net::UnixStream;
+use tokio::sync::watch;
+use tracing::{error, info};
+
+pub struct KeyboardModule;
+
+impl WaybarModule for KeyboardModule {
+    async fn run(
+        &self,
+        config: &Config,
+        state: &AppReceivers,
+        _args: &[&str],
+    ) -> Result<WaybarOutput> {
+        let layout = state.keyboard.borrow().layout.clone();
+
+        if layout.is_empty() {
+            return Ok(WaybarOutput {
+                text: "Layout Loading...".to_string(),
+                tooltip: None,
+                class: Some("loading".to_string()),
+                percentage: None,
+            });
+        }
+
+        let text = format_template(
+            &config.keyboard.format,
+            &[("layout", TokenValue::String(layout.clone()))],
+        );
+
+        Ok(WaybarOutput {
+            text,
+            tooltip: Some(format!("Keyboard Layout: {}", layout)),
+            class: Some("normal".to_string()),
+            percentage: None,
+        })
+    }
+}
+
+pub struct KeyboardDaemon;
+
+impl KeyboardDaemon {
+    pub fn new() -> Self {
+        Self
+    }
+
+    pub fn start(&self, tx: watch::Sender<KeyboardState>) {
+        tokio::spawn(async move {
+            loop {
+                if let Err(e) = Self::listen_loop(&tx).await {
+                    error!("Keyboard layout listener error: {}", e);
+                    // Fallback to waiting before reconnecting to prevent tight loop
+                    tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
+                }
+            }
+        });
+    }
+
+    async fn listen_loop(tx: &watch::Sender<KeyboardState>) -> anyhow::Result<()> {
+        let path = crate::utils::get_hyprland_socket(".socket2.sock")?;
+
+        info!("Connecting to Hyprland event socket: {:?}", path);
+        let stream = UnixStream::connect(path).await?;
+        let reader = BufReader::new(stream);
+        let mut lines = reader.lines();
+
+        // Fetch initial layout natively via hyprctl
+        if let Ok(output) = tokio::process::Command::new("hyprctl")
+            .args(["devices", "-j"])
+            .output()
+            .await
+            && let Ok(json) = serde_json::from_slice::<serde_json::Value>(&output.stdout)
+            && let Some(keyboards) = json.get("keyboards").and_then(|v| v.as_array())
+            && let Some(main_kb) = keyboards.last()
+        {
+            // The last active one is usually the main one
+            if let Some(layout) = main_kb.get("active_keymap").and_then(|v| v.as_str()) {
+                let _ = tx.send(KeyboardState {
+                    layout: layout.to_string(),
+                });
+            }
+        }
+
+        while let Ok(Some(line)) = lines.next_line().await {
+            if let Some(payload) = line.strip_prefix("activelayout>>") {
+                // payload format: keyboard_name,layout_name
+                let parts: Vec<&str> = payload.splitn(2, ',').collect();
+                if parts.len() == 2 {
+                    let layout = parts[1].to_string();
+                    let _ = tx.send(KeyboardState { layout });
+                }
+            }
+        }
+
+        Err(anyhow!("Hyprland socket closed or read error"))
+    }
+}

src/modules/memory.rs

@@ -2,7 +2,7 @@ use crate::config::Config;
 use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
+use crate::state::AppReceivers;
 use crate::utils::{TokenValue, format_template};
 
 pub struct MemoryModule;
@@ -11,12 +11,12 @@ impl WaybarModule for MemoryModule {
     async fn run(
         &self,
         config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
         _args: &[&str],
     ) -> Result<WaybarOutput> {
         let (used_gb, total_gb) = {
-            let state_lock = state.read().await;
+            let s = state.memory.borrow();
-            (state_lock.memory.used_gb, state_lock.memory.total_gb)
+            (s.used_gb, s.total_gb)
         };
 
         let ratio = if total_gb > 0.0 {
@@ -65,7 +65,10 @@ mod tests {
             ..Default::default()
         });
         let config = Config::default();
-        let output = MemoryModule.run(&config, &state, &[]).await.unwrap();
+        let output = MemoryModule
+            .run(&config, &state.receivers, &[])
+            .await
+            .unwrap();
         assert!(output.text.contains("8.00"));
         assert!(output.text.contains("32.00"));
         assert_eq!(output.class.as_deref(), Some("normal"));
@@ -82,7 +85,10 @@ mod tests {
             ..Default::default()
         });
         let config = Config::default();
-        let output = MemoryModule.run(&config, &state, &[]).await.unwrap();
+        let output = MemoryModule
+            .run(&config, &state.receivers, &[])
+            .await
+            .unwrap();
         assert_eq!(output.class.as_deref(), Some("high")); // 81%
     }
 
@@ -96,7 +102,10 @@ mod tests {
             ..Default::default()
         });
         let config = Config::default();
-        let output = MemoryModule.run(&config, &state, &[]).await.unwrap();
+        let output = MemoryModule
+            .run(&config, &state.receivers, &[])
+            .await
+            .unwrap();
         assert_eq!(output.class.as_deref(), Some("normal"));
         assert_eq!(output.percentage, Some(0));
     }

src/modules/mod.rs

@@ -1,12 +1,16 @@
 pub mod audio;
+pub mod backlight;
 pub mod bt;
 pub mod btrfs;
 pub mod cpu;
 pub mod disk;
+pub mod dnd;
 pub mod game;
 pub mod gpu;
 pub mod hardware;
+pub mod keyboard;
 pub mod memory;
+pub mod mpris;
 pub mod network;
 pub mod power;
 pub mod sys;
@@ -14,13 +18,13 @@ pub mod sys;
 use crate::config::Config;
 use crate::error::Result as FluxoResult;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
+use crate::state::AppReceivers;
 
 pub trait WaybarModule {
     fn run(
         &self,
         config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
         args: &[&str],
     ) -> impl std::future::Future<Output = FluxoResult<WaybarOutput>> + Send;
 }

src/modules/mpris.rs

@@ -0,0 +1,208 @@
+use crate::config::Config;
+use crate::error::Result;
+use crate::modules::WaybarModule;
+use crate::output::WaybarOutput;
+use crate::state::{AppReceivers, MprisState};
+use crate::utils::{TokenValue, format_template};
+use tokio::sync::watch;
+use tracing::{debug, info};
+use zbus::{Connection, proxy};
+
+pub struct MprisModule;
+
+impl WaybarModule for MprisModule {
+    async fn run(
+        &self,
+        config: &Config,
+        state: &AppReceivers,
+        _args: &[&str],
+    ) -> Result<WaybarOutput> {
+        let mpris = state.mpris.borrow().clone();
+
+        if mpris.is_stopped && mpris.title.is_empty() {
+            return Ok(WaybarOutput {
+                text: String::new(),
+                tooltip: None,
+                class: Some("stopped".to_string()),
+                percentage: None,
+            });
+        }
+
+        let status_icon = if mpris.is_playing {
+            "󰏤"
+        } else if mpris.is_paused {
+            "󰐊"
+        } else {
+            "󰓛"
+        };
+
+        let class = if mpris.is_playing {
+            "playing"
+        } else if mpris.is_paused {
+            "paused"
+        } else {
+            "stopped"
+        };
+
+        let text = format_template(
+            &config.mpris.format,
+            &[
+                ("artist", TokenValue::String(mpris.artist.clone())),
+                ("title", TokenValue::String(mpris.title.clone())),
+                ("album", TokenValue::String(mpris.album.clone())),
+                ("status_icon", TokenValue::String(status_icon.to_string())),
+            ],
+        );
+
+        Ok(WaybarOutput {
+            text,
+            tooltip: Some(format!("{} - {}", mpris.artist, mpris.title)),
+            class: Some(class.to_string()),
+            percentage: None,
+        })
+    }
+}
+
+pub struct MprisDaemon;
+
+#[proxy(
+    interface = "org.freedesktop.DBus",
+    default_service = "org.freedesktop.DBus",
+    default_path = "/org/freedesktop/DBus"
+)]
+trait DBus {
+    fn list_names(&self) -> zbus::Result<Vec<String>>;
+}
+
+#[proxy(
+    interface = "org.mpris.MediaPlayer2.Player",
+    default_path = "/org/mpris/MediaPlayer2"
+)]
+trait MprisPlayer {
+    #[zbus(property)]
+    fn playback_status(&self) -> zbus::Result<String>;
+
+    #[zbus(property)]
+    fn metadata(
+        &self,
+    ) -> zbus::Result<std::collections::HashMap<String, zbus::zvariant::Value<'_>>>;
+}
+
+impl MprisDaemon {
+    pub fn new() -> Self {
+        Self
+    }
+
+    pub fn start(&self, tx: watch::Sender<MprisState>) {
+        tokio::spawn(async move {
+            loop {
+                if let Err(e) = Self::listen_loop(&tx).await {
+                    debug!("MPRIS listener ended or error: {}", e);
+                    tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
+                }
+            }
+        });
+    }
+
+    async fn listen_loop(tx: &watch::Sender<MprisState>) -> anyhow::Result<()> {
+        let connection = Connection::session().await?;
+
+        info!("Connected to D-Bus for MPRIS monitoring");
+
+        // Simple poll loop for MPRIS since players can come and go, and tracking dynamically
+        // with pure signals across multiple dynamically spawned DBus names is complex.
+        // A robust hybrid approach: poll every 2s for active players, and update state.
+
+        let dbus_proxy = DBusProxy::new(&connection).await?;
+
+        loop {
+            let names = dbus_proxy.list_names().await?;
+            let mut active_player = None;
+
+            for name in names {
+                if name.starts_with("org.mpris.MediaPlayer2.") {
+                    active_player = Some(name);
+                    break; // Just grab the first active player for now
+                }
+            }
+
+            if let Some(player_name) = active_player {
+                if let Ok(player_proxy) = MprisPlayerProxy::builder(&connection)
+                    .destination(player_name.clone())?
+                    .build()
+                    .await
+                {
+                    let status = player_proxy.playback_status().await.unwrap_or_default();
+                    let metadata = player_proxy.metadata().await.unwrap_or_default();
+
+                    let is_playing = status == "Playing";
+                    let is_paused = status == "Paused";
+                    let is_stopped = status == "Stopped";
+
+                    let mut artist = String::new();
+                    let mut title = String::new();
+                    let mut album = String::new();
+
+                    if let Some(v) = metadata.get("xesam:artist") {
+                        if let Ok(arr) = zbus::zvariant::Array::try_from(v) {
+                            let mut artists = Vec::new();
+                            for i in 0..arr.len() {
+                                if let Ok(Some(s)) = arr.get::<&str>(i) {
+                                    artists.push(s.to_string());
+                                }
+                            }
+                            artist = artists.join(", ");
+                        } else if let Ok(a) = <&str>::try_from(v) {
+                            artist = a.to_string();
+                        }
+                    }
+                    if let Some(v) = metadata.get("xesam:title")
+                        && let Ok(t) = <&str>::try_from(v)
+                    {
+                        title = t.to_string();
+                    }
+                    if let Some(v) = metadata.get("xesam:album")
+                        && let Ok(a) = <&str>::try_from(v)
+                    {
+                        album = a.to_string();
+                    }
+
+                    // Only send if changed
+                    let current = tx.borrow();
+                    if current.is_playing != is_playing
+                        || current.is_paused != is_paused
+                        || current.is_stopped != is_stopped
+                        || current.title != title
+                        || current.artist != artist
+                        || current.album != album
+                    {
+                        drop(current); // Drop borrow before send
+                        let _ = tx.send(MprisState {
+                            is_playing,
+                            is_paused,
+                            is_stopped,
+                            artist,
+                            title,
+                            album,
+                        });
+                    }
+                }
+            } else {
+                let current = tx.borrow();
+                if !current.is_stopped || !current.title.is_empty() {
+                    drop(current);
+                    let _ = tx.send(MprisState {
+                        is_playing: false,
+                        is_paused: false,
+                        is_stopped: true,
+                        artist: String::new(),
+                        title: String::new(),
+                        album: String::new(),
+                    });
+                }
+            }
+
+            tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
+        }
+    }
+}

src/modules/network.rs

@@ -2,11 +2,12 @@ use crate::config::Config;
 use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
+use crate::state::{AppReceivers, NetworkState};
 use crate::utils::{TokenValue, format_template};
 use nix::ifaddrs::getifaddrs;
 use std::fs;
 use std::time::{SystemTime, UNIX_EPOCH};
+use tokio::sync::watch;
 
 pub struct NetworkModule;
 
@@ -18,6 +19,8 @@ pub struct NetworkDaemon {
     cached_ip: Option<String>,
 }
 
+type PollResult = crate::error::Result<(String, Option<String>, Option<(u64, u64)>)>;
+
 impl NetworkDaemon {
     pub fn new() -> Self {
         Self {
@@ -29,64 +32,101 @@ impl NetworkDaemon {
         }
     }
 
-    pub async fn poll(&mut self, state: SharedState) {
+    pub async fn poll(
-        // Re-detect interface on every poll to catch VPNs or route changes immediately
+        &mut self,
-        if let Ok(iface) = get_primary_interface()
+        state_tx: &watch::Sender<NetworkState>,
-            && !iface.is_empty()
+    ) -> crate::error::Result<()> {
-        {
+        let (iface, ip_opt, bytes_opt) = tokio::task::spawn_blocking(|| -> PollResult {
-            // If the interface changed, or we don't have an IP yet, update the IP
+            let iface = get_primary_interface()?;
+            if iface.is_empty() {
+                return Ok((String::new(), None, None));
+            }
+            let ip = get_ip_address(&iface);
+            let bytes = get_bytes(&iface).ok();
+            Ok((iface, ip, bytes))
+        })
+        .await
+        .map_err(|e| crate::error::FluxoError::System(e.to_string()))??;
+
+        if !iface.is_empty() {
             if self.cached_interface.as_ref() != Some(&iface) || self.cached_ip.is_none() {
-                self.cached_ip = get_ip_address(&iface);
+                self.cached_ip = ip_opt;
-                self.cached_interface = Some(iface);
+                self.cached_interface = Some(iface.clone());
             }
         } else {
             self.cached_interface = None;
             self.cached_ip = None;
+            // Provide a default state for "No connection"
+            let mut network = state_tx.borrow().clone();
+            network.interface.clear();
+            network.ip.clear();
+            network.rx_mbps = 0.0;
+            network.tx_mbps = 0.0;
+            let _ = state_tx.send(network);
+            return Err(crate::error::FluxoError::Network(
+                "No primary interface found".into(),
+            ));
         }
 
-        if let Some(ref interface) = self.cached_interface {
+        let interface = if let Some(ref interface) = self.cached_interface {
-            let time_now = SystemTime::now()
+            interface.clone()
-                .duration_since(UNIX_EPOCH)
-                .unwrap_or_default()
-                .as_secs();
-
-            if let Ok((rx_bytes_now, tx_bytes_now)) = get_bytes(interface) {
-                if self.last_time > 0 && time_now > self.last_time {
-                    let time_diff = (time_now - self.last_time) as f64;
-                    let rx_mbps = (rx_bytes_now.saturating_sub(self.last_rx_bytes)) as f64
-                        / time_diff
-                        / 1024.0
-                        / 1024.0;
-                    let tx_mbps = (tx_bytes_now.saturating_sub(self.last_tx_bytes)) as f64
-                        / time_diff
-                        / 1024.0
-                        / 1024.0;
-
-                    let mut state_lock = state.write().await;
-                    state_lock.network.rx_mbps = rx_mbps;
-                    state_lock.network.tx_mbps = tx_mbps;
-                    state_lock.network.interface = interface.clone();
-                    state_lock.network.ip = self.cached_ip.clone().unwrap_or_default();
-                } else {
-                    // First poll: no speed data yet, but update interface/ip
-                    let mut state_lock = state.write().await;
-                    state_lock.network.interface = interface.clone();
-                    state_lock.network.ip = self.cached_ip.clone().unwrap_or_default();
-                }
-
-                self.last_time = time_now;
-                self.last_rx_bytes = rx_bytes_now;
-                self.last_tx_bytes = tx_bytes_now;
-            } else {
-                // Read failed, might be down
-                self.cached_interface = None;
-            }
         } else {
             // No interface detected
-            let mut state_lock = state.write().await;
+            let mut network = state_tx.borrow().clone();
-            state_lock.network.interface.clear();
+            network.interface.clear();
-            state_lock.network.ip.clear();
+            network.ip.clear();
+            network.rx_mbps = 0.0;
+            network.tx_mbps = 0.0;
+            let _ = state_tx.send(network);
+            return Err(crate::error::FluxoError::Network(
+                "Interface disappeared during poll".into(),
+            ));
+        };
+
+        let time_now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_secs();
+
+        if let Some((rx_bytes_now, tx_bytes_now)) = bytes_opt {
+            if self.last_time > 0 && time_now > self.last_time {
+                let time_diff = (time_now - self.last_time) as f64;
+                let rx_mbps = (rx_bytes_now.saturating_sub(self.last_rx_bytes)) as f64
+                    / time_diff
+                    / 1024.0
+                    / 1024.0;
+                let tx_mbps = (tx_bytes_now.saturating_sub(self.last_tx_bytes)) as f64
+                    / time_diff
+                    / 1024.0
+                    / 1024.0;
+
+                let mut network = state_tx.borrow().clone();
+                network.rx_mbps = rx_mbps;
+                network.tx_mbps = tx_mbps;
+                network.interface = interface.clone();
+                network.ip = self.cached_ip.clone().unwrap_or_default();
+                let _ = state_tx.send(network);
+            } else {
+                // First poll: no speed data yet, but update interface/ip
+                let mut network = state_tx.borrow().clone();
+                network.interface = interface.clone();
+                network.ip = self.cached_ip.clone().unwrap_or_default();
+                let _ = state_tx.send(network);
+            }
+
+            self.last_time = time_now;
+            self.last_rx_bytes = rx_bytes_now;
+            self.last_tx_bytes = tx_bytes_now;
+        } else {
+            // Read failed, might be down
+            self.cached_interface = None;
+            return Err(crate::error::FluxoError::Network(format!(
+                "Failed to read bytes for {}",
+                interface
+            )));
         }
+
+        Ok(())
     }
 }
 
@@ -94,17 +134,12 @@ impl WaybarModule for NetworkModule {
     async fn run(
         &self,
         config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
         _args: &[&str],
     ) -> Result<WaybarOutput> {
         let (interface, ip, rx_mbps, tx_mbps) = {
-            let s = state.read().await;
+            let s = state.network.borrow();
-            (
+            (s.interface.clone(), s.ip.clone(), s.rx_mbps, s.tx_mbps)
-                s.network.interface.clone(),
-                s.network.ip.clone(),
-                s.network.rx_mbps,
-                s.network.tx_mbps,
-            )
         };
 
         if interface.is_empty() {
@@ -148,24 +183,26 @@ impl WaybarModule for NetworkModule {
 }
 
 fn get_primary_interface() -> Result<String> {
-    let content = fs::read_to_string("/proc/net/route")?;
+    let content = std::fs::read_to_string("/proc/net/route")?;
 
     let mut defaults = Vec::new();
     for line in content.lines().skip(1) {
         let parts: Vec<&str> = line.split_whitespace().collect();
-        if parts.len() >= 7 {
+        if parts.len() >= 8 {
             let iface = parts[0];
             let dest = parts[1];
             let metric = parts[6].parse::<i32>().unwrap_or(0);
+            let mask = u32::from_str_radix(parts[7], 16).unwrap_or(0);
 
             if dest == "00000000" {
-                defaults.push((metric, iface.to_string()));
+                defaults.push((mask, metric, iface.to_string()));
             }
         }
     }
 
-    defaults.sort_by_key(|k| k.0);
+    // Sort by mask descending (longest prefix match first), then by metric ascending
-    if let Some((_, dev)) = defaults.first() {
+    defaults.sort_by(|a, b| b.0.cmp(&a.0).then(a.1.cmp(&b.1)));
+    if let Some((_, _, dev)) = defaults.first() {
         Ok(dev.clone())
     } else {
         Ok(String::new())
@@ -212,7 +249,10 @@ mod tests {
     async fn test_network_no_connection() {
         let state = mock_state(AppState::default());
         let config = Config::default();
-        let output = NetworkModule.run(&config, &state, &[]).await.unwrap();
+        let output = NetworkModule
+            .run(&config, &state.receivers, &[])
+            .await
+            .unwrap();
         assert_eq!(output.text, "No connection");
     }
 
@@ -228,7 +268,10 @@ mod tests {
             ..Default::default()
         });
         let config = Config::default();
-        let output = NetworkModule.run(&config, &state, &[]).await.unwrap();
+        let output = NetworkModule
+            .run(&config, &state.receivers, &[])
+            .await
+            .unwrap();
         assert!(output.text.contains("eth0"));
         assert!(output.text.contains("192.168.1.100"));
         assert!(output.text.contains("1.50"));
@@ -247,7 +290,10 @@ mod tests {
             ..Default::default()
         });
         let config = Config::default();
-        let output = NetworkModule.run(&config, &state, &[]).await.unwrap();
+        let output = NetworkModule
+            .run(&config, &state.receivers, &[])
+            .await
+            .unwrap();
         assert!(output.text.starts_with("  "));
     }
 
@@ -263,7 +309,10 @@ mod tests {
             ..Default::default()
         });
         let config = Config::default();
-        let output = NetworkModule.run(&config, &state, &[]).await.unwrap();
+        let output = NetworkModule
+            .run(&config, &state.receivers, &[])
+            .await
+            .unwrap();
         assert!(output.text.contains("No IP"));
     }
 }

src/modules/power.rs

@@ -2,7 +2,7 @@ use crate::config::Config;
 use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
+use crate::state::AppReceivers;
 use crate::utils::{TokenValue, format_template};
 use std::fs;
 
@@ -12,7 +12,7 @@ impl WaybarModule for PowerModule {
     async fn run(
         &self,
         config: &Config,
-        _state: &SharedState,
+        _state: &AppReceivers,
         _args: &[&str],
     ) -> Result<WaybarOutput> {
         let critical_threshold = 15;

src/modules/sys.rs

@@ -2,7 +2,7 @@ use crate::config::Config;
 use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
+use crate::state::AppReceivers;
 use crate::utils::{TokenValue, format_template};
 
 pub struct SysModule;
@@ -11,17 +11,17 @@ impl WaybarModule for SysModule {
     async fn run(
         &self,
         config: &Config,
-        state: &SharedState,
+        state: &AppReceivers,
         _args: &[&str],
     ) -> Result<WaybarOutput> {
         let (load1, load5, load15, uptime_secs, process_count) = {
-            let state_lock = state.read().await;
+            let state_lock = state.sys.borrow();
             (
-                state_lock.sys.load_1,
+                state_lock.load_1,
-                state_lock.sys.load_5,
+                state_lock.load_5,
-                state_lock.sys.load_15,
+                state_lock.load_15,
-                state_lock.sys.uptime,
+                state_lock.uptime,
-                state_lock.sys.process_count,
+                state_lock.process_count,
             )
         };
 

src/output.rs

@@ -1,6 +1,6 @@
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Default)]
+#[derive(Serialize, Deserialize, Clone, Debug, Default)]
 pub struct WaybarOutput {
     pub text: String,
     #[serde(skip_serializing_if = "Option::is_none")]

src/signaler.rs

@@ -0,0 +1,156 @@
+use crate::config::Config;
+use crate::state::AppReceivers;
+use nix::libc;
+use nix::sys::signal::{Signal, kill};
+use nix::unistd::Pid;
+use std::collections::HashMap;
+use std::sync::Arc;
+use sysinfo::{ProcessesToUpdate, System};
+use tokio::sync::RwLock;
+use tokio::time::{Duration, Instant, sleep};
+use tracing::{debug, warn};
+
+pub struct WaybarSignaler {
+    cached_pid: Option<Pid>,
+    sys: System,
+    last_signal_sent: HashMap<i32, Instant>,
+}
+
+impl WaybarSignaler {
+    pub fn new() -> Self {
+        Self {
+            cached_pid: None,
+            sys: System::new(),
+            last_signal_sent: HashMap::new(),
+        }
+    }
+
+    fn find_waybar_pid(&mut self) -> Option<Pid> {
+        self.sys.refresh_processes(ProcessesToUpdate::All, true);
+        for (pid, process) in self.sys.processes() {
+            if process.name() == "waybar" {
+                return Some(Pid::from_raw(pid.as_u32() as i32));
+            }
+        }
+        None
+    }
+
+    fn send_signal(&mut self, signal_num: i32) {
+        if let Some(last) = self.last_signal_sent.get(&signal_num)
+            && last.elapsed() < Duration::from_millis(50)
+        {
+            return;
+        }
+
+        let mut valid_pid = false;
+        if let Some(pid) = self.cached_pid
+            && kill(pid, None).is_ok()
+        {
+            valid_pid = true;
+        }
+
+        if !valid_pid {
+            self.cached_pid = self.find_waybar_pid();
+        }
+
+        if let Some(pid) = self.cached_pid {
+            let rt_sig = match Signal::try_from(libc::SIGRTMIN() + signal_num) {
+                Ok(sig) => sig,
+                Err(_) => {
+                    unsafe {
+                        if libc::kill(pid.as_raw(), libc::SIGRTMIN() + signal_num) == 0 {
+                            debug!("Sent raw SIGRTMIN+{} to waybar (PID: {})", signal_num, pid);
+                            self.last_signal_sent.insert(signal_num, Instant::now());
+                        } else {
+                            warn!("Failed to send raw SIGRTMIN+{} to waybar", signal_num);
+                        }
+                    }
+                    return;
+                }
+            };
+
+            if let Err(e) = kill(pid, rt_sig) {
+                warn!("Failed to signal waybar: {}", e);
+                self.cached_pid = None;
+            } else {
+                debug!("Sent SIGRTMIN+{} to waybar (PID: {})", signal_num, pid);
+                self.last_signal_sent.insert(signal_num, Instant::now());
+            }
+        } else {
+            debug!("Waybar process not found, skipping signal.");
+        }
+    }
+
+    pub async fn run(mut self, config_lock: Arc<RwLock<Config>>, mut receivers: AppReceivers) {
+        let mut last_outputs: HashMap<&'static str, String> = HashMap::new();
+
+        loop {
+            let signals = config_lock.read().await.signals.clone();
+
+            macro_rules! check_and_signal {
+                ($module_name:expr, $signal_opt:expr) => {
+                    if let Some(sig) = $signal_opt {
+                        let config = config_lock.read().await;
+                        if let Some(out) = crate::daemon::evaluate_module_for_signaler(
+                            $module_name,
+                            &receivers,
+                            &config,
+                        )
+                        .await
+                        {
+                            if last_outputs.get($module_name) != Some(&out) {
+                                last_outputs.insert($module_name, out);
+                                self.send_signal(sig);
+                            }
+                        }
+                    }
+                };
+            }
+
+            tokio::select! {
+                res = receivers.network.changed(), if signals.network.is_some() => {
+                    if res.is_ok() { check_and_signal!("net", signals.network); }
+                }
+                res = receivers.cpu.changed(), if signals.cpu.is_some() => {
+                    if res.is_ok() { check_and_signal!("cpu", signals.cpu); }
+                }
+                res = receivers.memory.changed(), if signals.memory.is_some() => {
+                    if res.is_ok() { check_and_signal!("mem", signals.memory); }
+                }
+                res = receivers.sys.changed(), if signals.sys.is_some() => {
+                    if res.is_ok() { check_and_signal!("sys", signals.sys); }
+                }
+                res = receivers.gpu.changed(), if signals.gpu.is_some() => {
+                    if res.is_ok() { check_and_signal!("gpu", signals.gpu); }
+                }
+                res = receivers.disks.changed(), if signals.disk.is_some() => {
+                    if res.is_ok() { check_and_signal!("disk", signals.disk); }
+                }
+                res = receivers.bluetooth.changed(), if signals.bt.is_some() => {
+                    if res.is_ok() { check_and_signal!("bt", signals.bt); }
+                }
+                res = receivers.audio.changed(), if signals.audio.is_some() => {
+                    if res.is_ok() {
+                        check_and_signal!("vol", signals.audio);
+                        check_and_signal!("mic", signals.audio);
+                    }
+                }
+                res = receivers.backlight.changed(), if signals.backlight.is_some() => {
+                    if res.is_ok() { check_and_signal!("backlight", signals.backlight); }
+                }
+                res = receivers.keyboard.changed(), if signals.keyboard.is_some() => {
+                    if res.is_ok() { check_and_signal!("keyboard", signals.keyboard); }
+                }
+                res = receivers.dnd.changed(), if signals.dnd.is_some() => {
+                    if res.is_ok() { check_and_signal!("dnd", signals.dnd); }
+                }
+                res = receivers.mpris.changed(), if signals.mpris.is_some() => {
+                    if res.is_ok() { check_and_signal!("mpris", signals.mpris); }
+                }
+                _ = sleep(Duration::from_secs(5)) => {
+                    // loop and refresh config
+                }
+            }
+        }
+    }
+}

src/state.rs

@@ -1,19 +1,26 @@
+use crate::output::WaybarOutput;
 use std::collections::HashMap;
 use std::sync::Arc;
-use tokio::sync::RwLock;
+use tokio::sync::{RwLock, mpsc, watch};
 use tokio::time::Instant;
 
-#[derive(Default, Clone)]
+#[derive(Clone)]
-pub struct AppState {
+pub struct AppReceivers {
-    pub network: NetworkState,
+    pub network: watch::Receiver<NetworkState>,
-    pub cpu: CpuState,
+    pub cpu: watch::Receiver<CpuState>,
-    pub memory: MemoryState,
+    pub memory: watch::Receiver<MemoryState>,
-    pub sys: SysState,
+    pub sys: watch::Receiver<SysState>,
-    pub gpu: GpuState,
+    pub gpu: watch::Receiver<GpuState>,
-    pub disks: Vec<DiskInfo>,
+    pub disks: watch::Receiver<Vec<DiskInfo>>,
-    pub bluetooth: BtState,
+    pub bluetooth: watch::Receiver<BtState>,
-    pub audio: AudioState,
+    pub audio: watch::Receiver<AudioState>,
-    pub health: HashMap<String, ModuleHealth>,
+    pub mpris: watch::Receiver<MprisState>,
+    pub backlight: watch::Receiver<BacklightState>,
+    pub keyboard: watch::Receiver<KeyboardState>,
+    pub dnd: watch::Receiver<DndState>,
+    pub health: Arc<RwLock<HashMap<String, ModuleHealth>>>,
+    pub bt_force_poll: mpsc::Sender<()>,
+    pub audio_cmd_tx: mpsc::Sender<crate::modules::audio::AudioCommand>,
 }
 
 #[derive(Clone, Default)]
@@ -21,12 +28,15 @@ pub struct ModuleHealth {
     pub consecutive_failures: u32,
     pub last_failure: Option<Instant>,
     pub backoff_until: Option<Instant>,
+    pub last_successful_output: Option<WaybarOutput>,
 }
 
 #[derive(Default, Clone)]
 pub struct AudioState {
     pub sink: AudioDeviceInfo,
     pub source: AudioSourceInfo,
+    pub available_sinks: Vec<String>,
+    pub available_sources: Vec<String>,
 }
 
 #[derive(Default, Clone)]
@@ -35,6 +45,7 @@ pub struct AudioDeviceInfo {
     pub description: String,
     pub volume: u8,
     pub muted: bool,
+    pub channels: u8,
 }
 
 #[derive(Default, Clone)]
@@ -43,6 +54,7 @@ pub struct AudioSourceInfo {
     pub description: String,
     pub volume: u8,
     pub muted: bool,
+    pub channels: u8,
 }
 
 #[derive(Default, Clone)]
@@ -128,9 +140,113 @@ impl Default for GpuState {
     }
 }
 
-pub type SharedState = Arc<RwLock<AppState>>;
+#[derive(Default, Clone)]
+pub struct DndState {
+    pub is_dnd: bool,
+}
+
+#[derive(Default, Clone)]
+pub struct KeyboardState {
+    pub layout: String,
+}
+
+#[derive(Default, Clone)]
+pub struct BacklightState {
+    pub percentage: u8,
+}
+
+#[derive(Default, Clone)]
+pub struct MprisState {
+    pub is_playing: bool,
+    pub is_paused: bool,
+    pub is_stopped: bool,
+    pub artist: String,
+    pub title: String,
+    pub album: String,
+}
 
 #[cfg(test)]
-pub fn mock_state(state: AppState) -> SharedState {
+pub struct MockState {
-    Arc::new(RwLock::new(state))
+    pub receivers: AppReceivers,
+    // Keep senders alive so receivers don't return Closed errors
+    _net_tx: watch::Sender<NetworkState>,
+    _cpu_tx: watch::Sender<CpuState>,
+    _mem_tx: watch::Sender<MemoryState>,
+    _sys_tx: watch::Sender<SysState>,
+    _gpu_tx: watch::Sender<GpuState>,
+    _disks_tx: watch::Sender<Vec<DiskInfo>>,
+    _bt_tx: watch::Sender<BtState>,
+    _audio_tx: watch::Sender<AudioState>,
+    _mpris_tx: watch::Sender<MprisState>,
+    _backlight_tx: watch::Sender<BacklightState>,
+    _keyboard_tx: watch::Sender<KeyboardState>,
+    _dnd_tx: watch::Sender<DndState>,
+}
+
+#[cfg(test)]
+#[derive(Default, Clone)]
+pub struct AppState {
+    pub network: NetworkState,
+    pub cpu: CpuState,
+    pub memory: MemoryState,
+    pub sys: SysState,
+    pub gpu: GpuState,
+    pub disks: Vec<DiskInfo>,
+    pub bluetooth: BtState,
+    pub audio: AudioState,
+    pub mpris: MprisState,
+    pub backlight: BacklightState,
+    pub keyboard: KeyboardState,
+    pub dnd: DndState,
+    pub health: HashMap<String, ModuleHealth>,
+}
+
+#[cfg(test)]
+pub fn mock_state(state: AppState) -> MockState {
+    let (net_tx, net_rx) = watch::channel(state.network);
+    let (cpu_tx, cpu_rx) = watch::channel(state.cpu);
+    let (mem_tx, mem_rx) = watch::channel(state.memory);
+    let (sys_tx, sys_rx) = watch::channel(state.sys);
+    let (gpu_tx, gpu_rx) = watch::channel(state.gpu);
+    let (disks_tx, disks_rx) = watch::channel(state.disks);
+    let (bt_tx, bt_rx) = watch::channel(state.bluetooth);
+    let (audio_tx, audio_rx) = watch::channel(state.audio);
+    let (mpris_tx, mpris_rx) = watch::channel(state.mpris);
+    let (backlight_tx, backlight_rx) = watch::channel(state.backlight);
+    let (keyboard_tx, keyboard_rx) = watch::channel(state.keyboard);
+    let (dnd_tx, dnd_rx) = watch::channel(state.dnd);
+    let (bt_force_tx, _) = mpsc::channel(1);
+    let (audio_cmd_tx, _) = mpsc::channel(1);
+
+    MockState {
+        receivers: AppReceivers {
+            network: net_rx,
+            cpu: cpu_rx,
+            memory: mem_rx,
+            sys: sys_rx,
+            gpu: gpu_rx,
+            disks: disks_rx,
+            bluetooth: bt_rx,
+            audio: audio_rx,
+            mpris: mpris_rx,
+            backlight: backlight_rx,
+            keyboard: keyboard_rx,
+            dnd: dnd_rx,
+            health: Arc::new(RwLock::new(state.health)),
+            bt_force_poll: bt_force_tx,
+            audio_cmd_tx,
+        },
+        _net_tx: net_tx,
+        _cpu_tx: cpu_tx,
+        _mem_tx: mem_tx,
+        _sys_tx: sys_tx,
+        _gpu_tx: gpu_tx,
+        _disks_tx: disks_tx,
+        _bt_tx: bt_tx,
+        _audio_tx: audio_tx,
+        _mpris_tx: mpris_tx,
+        _backlight_tx: backlight_tx,
+        _keyboard_tx: keyboard_tx,
+        _dnd_tx: dnd_tx,
+    }
 }

src/utils.rs

@@ -3,17 +3,21 @@ use std::io::Write;
 use std::process::{Command, Stdio};
 
 pub fn show_menu(prompt: &str, items: &[String], menu_cmd: &str) -> Result<String> {
+    // Backward compatibility for {prompt}, but environment variable is safer
     let cmd_str = menu_cmd.replace("{prompt}", prompt);
     let mut child = Command::new("sh")
         .arg("-c")
         .arg(&cmd_str)
+        .env("FLUXO_PROMPT", prompt) // Safer shell injection
         .stdin(Stdio::piped())
         .stdout(Stdio::piped())
+        .stderr(Stdio::null()) // Suppress GTK/Wayland warnings from tools like wofi
         .spawn()
         .context("Failed to spawn menu command")?;
 
     if let Some(mut stdin) = child.stdin.take() {
-        let input = items.join("\n");
+        let mut input = items.join("\n");
+        input.push('\n'); // Ensure trailing newline for wofi/rofi
         stdin
             .write_all(input.as_bytes())
             .context("Failed to write to menu stdin")?;
@@ -33,6 +37,36 @@ pub fn show_menu(prompt: &str, items: &[String], menu_cmd: &str) -> Result<Strin
     Ok(selected)
 }
 
+pub fn get_hyprland_socket(socket_name: &str) -> Result<std::path::PathBuf> {
+    let signature = std::env::var("HYPRLAND_INSTANCE_SIGNATURE")
+        .context("HYPRLAND_INSTANCE_SIGNATURE not set")?;
+
+    // Try XDG_RUNTIME_DIR first (usually /run/user/1000)
+    if let Ok(runtime_dir) = std::env::var("XDG_RUNTIME_DIR") {
+        let path = std::path::PathBuf::from(runtime_dir)
+            .join("hypr")
+            .join(&signature)
+            .join(socket_name);
+        if path.exists() {
+            return Ok(path);
+        }
+    }
+
+    // Fallback to /tmp
+    let path = std::path::PathBuf::from("/tmp/hypr")
+        .join(&signature)
+        .join(socket_name);
+
+    if path.exists() {
+        Ok(path)
+    } else {
+        Err(anyhow::anyhow!(
+            "Hyprland socket {} not found in runtime dir or /tmp",
+            socket_name
+        ))
+    }
+}
+
 use regex::Regex;
 use std::sync::LazyLock;