fixed ci with release fixes

.gitea/workflows/ci.yml

@@ -19,6 +19,8 @@ jobs:
           toolchain: stable
           components: rustfmt, clippy
           cache: false
+      - name: Install packaging tools
+        run: apt-get update && apt-get install -y dpkg-dev pkg-config libdbus-1-dev protobuf-compiler libpulse-dev
 
       - name: Check formatting
         run: cargo fmt --check

.gitea/workflows/release.yml

@@ -22,7 +22,7 @@ jobs:
           cache: false
 
       - name: Install packaging tools
-        run: apt-get update && apt-get install -y dpkg-dev
+        run: apt-get update && apt-get install -y dpkg-dev pkg-config libdbus-1-dev protobuf-compiler libpulse-dev
 
       - name: Get Version
         id: get_version

Cargo.toml

@@ -1,19 +1,28 @@
 [package]
 name = "fluxo-rs"
-version = "0.2.0"
+version = "0.3.1"
 edition = "2024"
 
 [dependencies]
 anyhow = "1.0.102"
 clap = { version = "4.6.0", features = ["derive"] }
 ctrlc = "3"
-regex = "1.10"
+regex = "1.12"
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.149"
 sysinfo = "0.38.4"
-toml = "1.0.6"
+thiserror = "2.0"
+toml = "1.1.1"
 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-util = { version = "0.7", features = ["codec"] }
+futures = "0.3"
+libpulse-binding = "2.30"
+nix = { version = "0.31", features = ["net"] }
 
 [dev-dependencies]
+
 tempfile = "3"

README.md

@@ -32,8 +32,7 @@ This approach eliminates process spawning overhead and temporary file locking, r
 | `pool` | Aggregate storage (btrfs) | `{used}`, `{total}` |
 | `vol` | Audio output volume | `{name}`, `{volume}`, `{icon}` |
 | `mic` | Audio input volume | `{name}`, `{volume}`, `{icon}` |
-| `bt` | Bluetooth status | `{alias}` |
-| `buds` | Pixel Buds Pro control | `{left}`, `{right}`, `{anc}` |
+| `bt` | Bluetooth status & plugins | `{alias}`, `{mac}`, `{left}`, `{right}`, `{anc}` |
 | `power` | Battery and AC status | `{percentage}`, `{icon}` |
 | `game` | Hyprland gamemode status | active/inactive icon strings |
 

example.config.toml

@@ -0,0 +1,46 @@
+# Fluxo configuration example
+
+[general]
+menu_command = "fuzzel --dmenu --prompt '{prompt}'"
+
+[network]
+format = "{interface} ({ip}):  {rx:>5.2} MB/s   {tx:>5.2} MB/s"
+
+[cpu]
+format = "CPU: {usage:>4.1}% {temp:>4.1}C"
+
+[memory]
+format = "{used:>5.2}/{total:>5.2}GB"
+
+[gpu]
+format_amd = "AMD: {usage:>3.0}% {vram_used:>4.1}/{vram_total:>4.1}GB {temp:>4.1}C"
+format_intel = "iGPU: {usage:>3.0}%"
+format_nvidia = "NV: {usage:>3.0}% {vram_used:>4.1}/{vram_total:>4.1}GB {temp:>4.1}C"
+
+[sys]
+format = "UP: {uptime} | LOAD: {load1:>4.2} {load5:>4.2} {load15:>4.2}"
+
+[disk]
+format = "{mount} {used:>5.1}/{total:>5.1}G"
+
+[pool]
+format = "{used:>4.0}G / {total:>4.0}G"
+
+[power]
+format = "{percentage:>3}%  {icon}"
+
+[bt]
+format_connected = "{alias} 󰂰"
+format_plugin = "{alias} [{left}|{right}] {anc} 󰂰"
+format_disconnected = "󰂯"
+format_disabled = "󰂲 Off"
+
+[audio]
+format_sink_unmuted = "{name} {volume:>3}% {icon}"
+format_sink_muted = "{name} {icon}"
+format_source_unmuted = "{name} {volume:>3}% {icon}"
+format_source_muted = "{name} {icon}"
+
+[game]
+format_active = "<span size='large'>󰊖</span>"
+format_inactive = "<span size='large'></span>"

src/config.rs

@@ -26,8 +26,6 @@ pub struct Config {
     #[serde(default)]
     pub power: PowerConfig,
     #[serde(default)]
-    pub buds: BudsConfig,
-    #[serde(default)]
     pub audio: AudioConfig,
     #[serde(default)]
     pub bt: BtConfig,
@@ -158,23 +156,6 @@ impl Default for PowerConfig {
     }
 }
 
-#[derive(Deserialize)]
-pub struct BudsConfig {
-    pub mac: String,
-    pub format: String,
-    pub format_disconnected: String,
-}
-
-impl Default for BudsConfig {
-    fn default() -> Self {
-        Self {
-            mac: "B4:23:A2:09:D3:53".to_string(),
-            format: "{left} | {right} | {anc}".to_string(),
-            format_disconnected: "<span size='large'></span>".to_string(),
-        }
-    }
-}
-
 #[derive(Deserialize)]
 pub struct AudioConfig {
     pub format_sink_unmuted: String,
@@ -197,6 +178,7 @@ impl Default for AudioConfig {
 #[derive(Deserialize)]
 pub struct BtConfig {
     pub format_connected: String,
+    pub format_plugin: String,
     pub format_disconnected: String,
     pub format_disabled: String,
 }
@@ -205,6 +187,7 @@ impl Default for BtConfig {
     fn default() -> Self {
         Self {
             format_connected: "{alias} 󰂰".to_string(),
+            format_plugin: "{alias} [{left}|{right}] {anc} 󰂰".to_string(),
             format_disconnected: "󰂯".to_string(),
             format_disabled: "󰂲 Off".to_string(),
         }
@@ -275,7 +258,6 @@ impl Config {
         validate_format("disk", &self.disk.format, &["mount", "used", "total"]);
         validate_format("pool", &self.pool.format, &["used", "total"]);
         validate_format("power", &self.power.format, &["percentage", "icon"]);
-        validate_format("buds", &self.buds.format, &["left", "right", "anc"]);
         validate_format(
             "audio.sink_unmuted",
             &self.audio.format_sink_unmuted,
@@ -297,6 +279,11 @@ impl Config {
             &["name", "icon"],
         );
         validate_format("bt.connected", &self.bt.format_connected, &["alias"]);
+        validate_format(
+            "bt.plugin",
+            &self.bt.format_plugin,
+            &["alias", "left", "right", "anc", "mac"],
+        );
     }
 }
 

src/daemon.rs

@@ -1,19 +1,20 @@
 use crate::config::Config;
+use crate::error::FluxoError;
 use crate::ipc::socket_path;
 use crate::modules::WaybarModule;
+use crate::modules::audio::AudioDaemon;
+use crate::modules::bt::BtDaemon;
 use crate::modules::hardware::HardwareDaemon;
 use crate::modules::network::NetworkDaemon;
 use crate::state::{AppState, SharedState};
 use anyhow::Result;
 use std::fs;
-use std::io::{BufRead, BufReader, Write};
-use std::net::Shutdown;
-use std::os::unix::net::UnixListener;
 use std::path::PathBuf;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, RwLock};
-use std::thread;
-use std::time::Duration;
+use std::sync::Arc;
+use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
+use tokio::net::UnixListener;
+use tokio::sync::RwLock;
+use tokio::time::{Duration, Instant, sleep};
 use tracing::{debug, error, info, warn};
 
 struct SocketGuard {
@@ -27,7 +28,7 @@ impl Drop for SocketGuard {
     }
 }
 
-pub fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
+pub async fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
     let sock_path = socket_path();
 
     if fs::metadata(&sock_path).is_ok() {
@@ -41,86 +42,126 @@ pub fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
         path: sock_path.clone(),
     };
 
-    // Signal handling: set flag so main loop exits cleanly
-    let running = Arc::new(AtomicBool::new(true));
-    let running_clone = Arc::clone(&running);
-    ctrlc::set_handler(move || {
+    // Signal handling for graceful shutdown in async context
+    let running = Arc::new(tokio::sync::Notify::new());
+    let r_clone = Arc::clone(&running);
+    tokio::spawn(async move {
+        tokio::signal::ctrl_c().await.unwrap();
         info!("Received shutdown signal, exiting...");
-        running_clone.store(false, Ordering::SeqCst);
-    })?;
+        r_clone.notify_waiters();
+    });
 
-    // We store the original config_path to allow proper reloading later
     let config_path_clone = config_path.clone();
     let config = Arc::new(RwLock::new(crate::config::load_config(config_path)));
 
+    // 1. Network Task
     let poll_state = Arc::clone(&state);
-    let poll_running = Arc::clone(&running);
-    thread::spawn(move || {
-        info!("Starting background polling thread");
-        let mut network_daemon = NetworkDaemon::new();
-        let mut hardware_daemon = HardwareDaemon::new();
-        while poll_running.load(Ordering::SeqCst) {
-            network_daemon.poll(Arc::clone(&poll_state));
-            hardware_daemon.poll(Arc::clone(&poll_state));
-            thread::sleep(Duration::from_secs(1));
+    tokio::spawn(async move {
+        info!("Starting Network polling task");
+        let mut daemon = NetworkDaemon::new();
+        loop {
+            daemon.poll(Arc::clone(&poll_state)).await;
+            sleep(Duration::from_secs(1)).await;
         }
     });
 
+    // 2. Fast Hardware Task (CPU, Mem, Load)
+    let poll_state = Arc::clone(&state);
+    tokio::spawn(async move {
+        info!("Starting Fast Hardware polling task");
+        let mut daemon = HardwareDaemon::new();
+        loop {
+            daemon.poll_fast(Arc::clone(&poll_state)).await;
+            sleep(Duration::from_secs(1)).await;
+        }
+    });
+
+    // 3. Slow Hardware Task (GPU, Disks)
+    let poll_state = Arc::clone(&state);
+    tokio::spawn(async move {
+        info!("Starting Slow Hardware polling task");
+        let mut daemon = HardwareDaemon::new();
+        loop {
+            daemon.poll_slow(Arc::clone(&poll_state)).await;
+            sleep(Duration::from_secs(1)).await;
+        }
+    });
+
+    // 4. Bluetooth Task
+    let poll_state = Arc::clone(&state);
+    tokio::spawn(async move {
+        info!("Starting Bluetooth polling task");
+        let mut daemon = BtDaemon::new();
+        loop {
+            daemon.poll(Arc::clone(&poll_state)).await;
+            sleep(Duration::from_secs(1)).await;
+        }
+    });
+
+    // 5. Audio Thread (Event driven - pulse usually needs its own thread)
+    let audio_daemon = AudioDaemon::new();
+    audio_daemon.start(Arc::clone(&state));
+
     info!("Fluxo daemon successfully bound to socket: {}", sock_path);
 
-    // Use non-blocking accept so we can check the running flag
-    listener.set_nonblocking(true)?;
-
-    while running.load(Ordering::SeqCst) {
-        match listener.accept() {
-            Ok((mut stream, _)) => {
-                let state_clone = Arc::clone(&state);
-                let config_clone = Arc::clone(&config);
-                let cp_clone = config_path_clone.clone();
-                thread::spawn(move || {
-                    let mut reader = BufReader::new(&stream);
-                    let mut request = String::new();
-                    if let Err(e) = reader.read_line(&mut request) {
-                        error!("Failed to read from IPC stream: {}", e);
-                        return;
-                    }
-                    drop(reader);
-
-                    let request = request.trim();
-                    if request.is_empty() {
-                        return;
-                    }
-
-                    let parts: Vec<&str> = request.split_whitespace().collect();
-                    if let Some(module_name) = parts.first() {
-                        if *module_name == "reload" {
-                            info!("Reloading configuration...");
-                            let new_config = crate::config::load_config(cp_clone);
-                            if let Ok(mut config_lock) = config_clone.write() {
-                                *config_lock = new_config;
-                                let _ = stream.write_all(b"{\"text\":\"ok\"}");
-                                info!("Configuration reloaded successfully.");
-                            } else {
-                                error!("Failed to acquire write lock for configuration reload.");
+    loop {
+        tokio::select! {
+            _ = running.notified() => {
+                break;
+            }
+            res = listener.accept() => {
+                match res {
+                    Ok((mut stream, _)) => {
+                        let state_clone = Arc::clone(&state);
+                        let config_clone = Arc::clone(&config);
+                        let cp_clone = config_path_clone.clone();
+                        tokio::spawn(async move {
+                            let (reader, mut writer) = stream.split();
+                            let mut reader = BufReader::new(reader);
+                            let mut request = String::new();
+                            if let Err(e) = reader.read_line(&mut request).await {
+                                error!("Failed to read from IPC stream: {}", e);
+                                return;
                             }
-                            let _ = stream.shutdown(Shutdown::Write);
-                            return;
-                        }
 
-                        debug!(module = module_name, args = ?&parts[1..], "Handling IPC request");
-                        let response =
-                            handle_request(module_name, &parts[1..], &state_clone, &config_clone);
-                        if let Err(e) = stream.write_all(response.as_bytes()) {
-                            error!("Failed to write IPC response: {}", e);
-                        }
-                        let _ = stream.shutdown(Shutdown::Write);
+                            let request = request.trim();
+                            if request.is_empty() {
+                                return;
+                            }
+
+                            let parts: Vec<&str> = request.split_whitespace().collect();
+                            if let Some(module_name) = parts.first() {
+                                if *module_name == "reload" {
+                                    info!("Reloading configuration...");
+                                    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;
+                                }
+
+                                debug!(module = module_name, args = ?&parts[1..], "Handling IPC request");
+                                let response =
+                                    handle_request(module_name, &parts[1..], &state_clone, &config_clone).await;
+                                if let Err(e) = writer.write_all(response.as_bytes()).await {
+                                    if e.kind() == std::io::ErrorKind::BrokenPipe
+                                        || e.kind() == std::io::ErrorKind::ConnectionReset
+                                    {
+                                        debug!(
+                                            "IPC client disconnected before response could be sent: {}",
+                                            e
+                                        );
+                                    } else {
+                                        error!("Failed to write IPC response: {}", e);
+                                    }
+                                }
+                            }
+                        });
                     }
-                });
+                    Err(e) => error!("Failed to accept incoming connection: {}", e),
+                }
             }
-            Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
-                thread::sleep(Duration::from_millis(50));
-            }
-            Err(e) => error!("Failed to accept incoming connection: {}", e),
         }
     }
 
@@ -128,54 +169,127 @@ pub fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
     Ok(())
 }
 
-fn handle_request(
+async fn handle_request(
     module_name: &str,
     args: &[&str],
     state: &SharedState,
     config_lock: &Arc<RwLock<Config>>,
 ) -> String {
-    let config = if let Ok(c) = config_lock.read() {
-        c
-    } else {
-        error!("Failed to acquire read lock for configuration.");
-        return "{\"text\":\"error: config lock failed\"}".to_string();
-    };
-
-    let result = match module_name {
-        "net" | "network" => crate::modules::network::NetworkModule.run(&config, state, args),
-        "cpu" => crate::modules::cpu::CpuModule.run(&config, state, args),
-        "mem" | "memory" => crate::modules::memory::MemoryModule.run(&config, state, args),
-        "disk" => crate::modules::disk::DiskModule.run(&config, state, args),
-        "pool" | "btrfs" => crate::modules::btrfs::BtrfsModule.run(&config, state, args),
-        "vol" => crate::modules::audio::AudioModule.run(
-            &config,
-            state,
-            &["sink", args.first().unwrap_or(&"show")],
-        ),
-        "mic" => crate::modules::audio::AudioModule.run(
-            &config,
-            state,
-            &["source", args.first().unwrap_or(&"show")],
-        ),
-        "gpu" => crate::modules::gpu::GpuModule.run(&config, state, args),
-        "sys" => crate::modules::sys::SysModule.run(&config, state, args),
-        "bt" | "bluetooth" => crate::modules::bt::BtModule.run(&config, state, args),
-        "buds" => crate::modules::buds::BudsModule.run(&config, state, args),
-        "power" => crate::modules::power::PowerModule.run(&config, state, args),
-        "game" => crate::modules::game::GameModule.run(&config, state, args),
-        _ => {
-            warn!("Received request for unknown module: '{}'", module_name);
-            Err(anyhow::anyhow!("Unknown module: {}", module_name))
+    // 1. Check Circuit Breaker status
+    let is_in_backoff = {
+        let lock = state.read().await;
+        if let Some(health) = lock.health.get(module_name) {
+            if let Some(until) = health.backoff_until {
+                Instant::now() < until
+            } else {
+                false
+            }
+        } else {
+            false
         }
     };
 
+    if is_in_backoff {
+        return format!(
+            "{{\"text\":\"\u{200B}Cooling down ({})\u{200B}\",\"class\":\"error\"}}",
+            module_name
+        );
+    }
+
+    let config = config_lock.read().await;
+
+    let result = match module_name {
+        "net" | "network" => {
+            crate::modules::network::NetworkModule
+                .run(&config, state, args)
+                .await
+        }
+        "cpu" => {
+            crate::modules::cpu::CpuModule
+                .run(&config, state, args)
+                .await
+        }
+        "mem" | "memory" => {
+            crate::modules::memory::MemoryModule
+                .run(&config, state, args)
+                .await
+        }
+        "disk" => {
+            crate::modules::disk::DiskModule
+                .run(&config, state, args)
+                .await
+        }
+        "pool" | "btrfs" => {
+            crate::modules::btrfs::BtrfsModule
+                .run(&config, state, args)
+                .await
+        }
+        "vol" => {
+            crate::modules::audio::AudioModule
+                .run(&config, state, &["sink", args.first().unwrap_or(&"show")])
+                .await
+        }
+        "mic" => {
+            crate::modules::audio::AudioModule
+                .run(&config, state, &["source", args.first().unwrap_or(&"show")])
+                .await
+        }
+        "gpu" => {
+            crate::modules::gpu::GpuModule
+                .run(&config, state, args)
+                .await
+        }
+        "sys" => {
+            crate::modules::sys::SysModule
+                .run(&config, state, args)
+                .await
+        }
+        "bt" | "bluetooth" => crate::modules::bt::BtModule.run(&config, state, args).await,
+        "power" => {
+            crate::modules::power::PowerModule
+                .run(&config, state, args)
+                .await
+        }
+        "game" => {
+            crate::modules::game::GameModule
+                .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
+    {
+        let mut lock = state.write().await;
+        let health = lock.health.entry(module_name.to_string()).or_default();
+        match &result {
+            Ok(_) => {
+                health.consecutive_failures = 0;
+                health.backoff_until = None;
+            }
+            Err(e) => {
+                health.consecutive_failures += 1;
+                health.last_failure = Some(Instant::now());
+                if health.consecutive_failures >= 3 {
+                    // Backoff for 30 seconds after 3 failures
+                    health.backoff_until = Some(Instant::now() + Duration::from_secs(30));
+                    warn!(module = module_name, error = %e, "Module entered backoff state due to repeated failures");
+                }
+            }
+        }
+    }
+
     match result {
         Ok(output) => serde_json::to_string(&output).unwrap_or_else(|_| "{}".to_string()),
         Err(e) => {
-            error!(module = module_name, error = %e, "Module execution failed");
+            let error_msg = e.to_string();
+            error!(module = module_name, error = %error_msg, "Module execution failed");
             let err_out = crate::output::WaybarOutput {
                 text: "\u{200B}Error\u{200B}".to_string(),
-                tooltip: Some(e.to_string()),
+                tooltip: Some(error_msg),
                 class: Some("error".to_string()),
                 percentage: None,
             };

src/error.rs

@@ -0,0 +1,31 @@
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+#[allow(dead_code)]
+pub enum FluxoError {
+    #[error("Configuration error: {0}")]
+    Config(String),
+
+    #[error("Module error ({module}): {message}")]
+    Module {
+        module: &'static str,
+        message: String,
+    },
+
+    #[error("Daemon IPC error: {0}")]
+    Ipc(String),
+
+    #[error("External system error: {0}")]
+    System(String),
+
+    #[error("IO error: {0}")]
+    Io(#[from] std::io::Error),
+
+    #[error("Serialization error: {0}")]
+    Serialization(#[from] serde_json::Error),
+
+    #[error("Other error: {0}")]
+    Other(#[from] anyhow::Error),
+}
+
+pub type Result<T> = std::result::Result<T, FluxoError>;

src/main.rs

@@ -1,5 +1,6 @@
 mod config;
 mod daemon;
+mod error;
 mod ipc;
 mod modules;
 mod output;
@@ -71,11 +72,6 @@ enum Commands {
         #[arg(default_value = "show")]
         action: String,
     },
-    /// Pixel Buds Pro ANC and Battery
-    Buds {
-        #[arg(default_value = "show")]
-        action: String,
-    },
     /// System power and battery status
     Power,
     /// Hyprland gamemode status
@@ -93,7 +89,12 @@ fn main() {
     match &cli.command {
         Commands::Daemon { config } => {
             info!("Starting Fluxo daemon...");
-            if let Err(e) = daemon::run_daemon(config.clone()) {
+            let rt = tokio::runtime::Builder::new_multi_thread()
+                .enable_all()
+                .build()
+                .unwrap();
+
+            if let Err(e) = rt.block_on(daemon::run_daemon(config.clone())) {
                 error!("Daemon failed: {}", e);
                 process::exit(1);
             }
@@ -125,6 +126,25 @@ fn main() {
                 // Client-side execution of the menu
                 let config = config::load_config(None);
 
+                let mut items = Vec::new();
+
+                // If connected, show plugin modes and disconnect
+                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));
+                    }
+                }
+
+                if !items.is_empty() {
+                    items.push("Disconnect".to_string());
+                }
+
+                items.push("--- Connect Device ---".to_string());
+
                 let devices_out = match std::process::Command::new("bluetoothctl")
                     .args(["devices"])
                     .output()
@@ -137,7 +157,6 @@ fn main() {
                 };
                 let stdout = String::from_utf8_lossy(&devices_out.stdout);
 
-                let mut items = Vec::new();
                 for line in stdout.lines() {
                     if line.starts_with("Device ") {
                         let parts: Vec<&str> = line.splitn(3, ' ').collect();
@@ -149,23 +168,30 @@ fn main() {
 
                 if !items.is_empty() {
                     if let Ok(selected) =
-                        utils::show_menu("Connect BT: ", &items, &config.general.menu_command)
-                        && let Some(mac_start) = selected.rfind('(')
-                        && let Some(mac_end) = selected.rfind(')')
+                        utils::show_menu("BT Menu: ", &items, &config.general.menu_command)
                     {
-                        let mac = &selected[mac_start + 1..mac_end];
-                        let _ = std::process::Command::new("bluetoothctl")
-                            .args(["connect", mac])
-                            .status();
+                        if let Some(mode) = selected.strip_prefix("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 ---" {
+                            // 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 paired Bluetooth devices found.");
+                    info!("No Bluetooth options found.");
                 }
                 return;
             }
             handle_ipc_response(ipc::request_data("bt", &[action]));
         }
-        Commands::Buds { action } => handle_ipc_response(ipc::request_data("buds", &[action])),
         Commands::Power => handle_ipc_response(ipc::request_data("power", &[])),
         Commands::Game => handle_ipc_response(ipc::request_data("game", &[])),
     }

src/modules/audio.rs

@@ -1,56 +1,236 @@
 use crate::config::Config;
+use crate::error::{FluxoError, Result};
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
 use crate::state::SharedState;
-use crate::utils::{TokenValue, format_template, run_command};
-use anyhow::{Result, anyhow};
+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 std::sync::{Arc, LazyLock};
+use tracing::error;
+
+static RUNTIME: LazyLock<tokio::runtime::Runtime> = LazyLock::new(|| {
+    tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .expect("Failed to create Audio tokio runtime")
+});
+
+pub struct AudioDaemon;
+
+impl AudioDaemon {
+    pub fn new() -> Self {
+        Self
+    }
+
+    pub fn start(&self, state: SharedState) {
+        let state_arc = Arc::clone(&state);
+
+        std::thread::spawn(move || {
+            let mut mainloop =
+                ThreadedMainloop::new().expect("Failed to create pulse threaded mainloop");
+
+            let mut context =
+                Context::new(&mainloop, "fluxo-rs").expect("Failed to create pulse context");
+
+            context
+                .connect(None, ContextFlag::NOFLAGS, None)
+                .expect("Failed to connect pulse context");
+
+            mainloop.start().expect("Failed to start pulse mainloop");
+
+            mainloop.lock();
+
+            // Wait for context to be ready
+            loop {
+                match context.get_state() {
+                    libpulse_binding::context::State::Ready => break,
+                    libpulse_binding::context::State::Failed
+                    | libpulse_binding::context::State::Terminated => {
+                        error!("Pulse context failed or terminated");
+                        mainloop.unlock();
+                        return;
+                    }
+                    _ => {
+                        mainloop.unlock();
+                        std::thread::sleep(Duration::from_millis(50));
+                        mainloop.lock();
+                    }
+                }
+            }
+
+            // Initial fetch
+            let _ = fetch_audio_data_sync(&mut context, &state_arc);
+
+            // Subscribe to events
+            let interest =
+                InterestMaskSet::SINK | InterestMaskSet::SOURCE | InterestMaskSet::SERVER;
+            context.subscribe(interest, |_| {});
+
+            let (tx, rx) = std::sync::mpsc::channel();
+
+            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(());
+                    }
+                    _ => {}
+                }
+            })));
+
+            mainloop.unlock();
+
+            // Background polling loop driven by events or a 2s fallback timeout
+            loop {
+                let _ = rx.recv_timeout(Duration::from_secs(2));
+                {
+                    mainloop.lock();
+                    let _ = fetch_audio_data_sync(&mut context, &state_arc);
+                    mainloop.unlock();
+                }
+            }
+        });
+    }
+}
+
+use std::time::Duration;
+
+fn fetch_audio_data_sync(context: &mut Context, state: &SharedState) -> Result<()> {
+    let state_inner = Arc::clone(state);
+
+    // 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);
+    context.introspect().get_server_info(move |info| {
+        let mut lock = RUNTIME.block_on(st_server.write());
+        lock.audio.sink.name = info
+            .default_sink_name
+            .as_ref()
+            .map(|s| s.to_string())
+            .unwrap_or_default();
+        lock.audio.source.name = info
+            .default_source_name
+            .as_ref()
+            .map(|s| s.to_string())
+            .unwrap_or_default();
+    });
+
+    let st_sink = Arc::clone(&state_inner);
+    context.introspect().get_sink_info_list(move |res| {
+        if let ListResult::Item(item) = res {
+            let mut lock = RUNTIME.block_on(st_sink.write());
+            // If this matches our default sink name, or if we don't have details for any yet
+            let is_default = item
+                .name
+                .as_ref()
+                .map(|s| s.as_ref() == lock.audio.sink.name)
+                .unwrap_or(false);
+            if is_default {
+                lock.audio.sink.description = item
+                    .description
+                    .as_ref()
+                    .map(|s| s.to_string())
+                    .unwrap_or_default();
+                lock.audio.sink.volume =
+                    ((item.volume.avg().0 as f64 / Volume::NORMAL.0 as f64) * 100.0).round() as u8;
+                lock.audio.sink.muted = item.mute;
+            }
+        }
+    });
+
+    let st_source = Arc::clone(&state_inner);
+    context.introspect().get_source_info_list(move |res| {
+        if let ListResult::Item(item) = res {
+            let mut lock = RUNTIME.block_on(st_source.write());
+            let is_default = item
+                .name
+                .as_ref()
+                .map(|s| s.as_ref() == lock.audio.source.name)
+                .unwrap_or(false);
+            if is_default {
+                lock.audio.source.description = item
+                    .description
+                    .as_ref()
+                    .map(|s| s.to_string())
+                    .unwrap_or_default();
+                lock.audio.source.volume =
+                    ((item.volume.avg().0 as f64 / Volume::NORMAL.0 as f64) * 100.0).round() as u8;
+                lock.audio.source.muted = item.mute;
+            }
+        }
+    });
+
+    Ok(())
+}
 
 pub struct AudioModule;
 
 impl WaybarModule for AudioModule {
-    fn run(&self, config: &Config, _state: &SharedState, args: &[&str]) -> Result<WaybarOutput> {
+    async fn run(
+        &self,
+        config: &Config,
+        state: &SharedState,
+        args: &[&str],
+    ) -> Result<WaybarOutput> {
         let target_type = args.first().unwrap_or(&"sink");
         let action = args.get(1).unwrap_or(&"show");
 
         match *action {
             "cycle" => {
                 self.cycle_device(target_type)?;
-                Ok(WaybarOutput {
-                    text: String::new(),
-                    tooltip: None,
-                    class: None,
-                    percentage: None,
-                })
+                Ok(WaybarOutput::default())
             }
-            "show" => self.get_status(config, target_type),
-            other => Err(anyhow!("Unknown audio action: '{}'", other)),
+            "show" => self.get_status(config, state, target_type).await,
+            other => Err(FluxoError::Module {
+                module: "audio",
+                message: format!("Unknown audio action: '{}'", other),
+            }),
         }
     }
 }
 
 impl AudioModule {
-    fn get_status(&self, config: &Config, target_type: &str) -> Result<WaybarOutput> {
-        let target = if target_type == "sink" {
-            "@DEFAULT_AUDIO_SINK@"
-        } else {
-            "@DEFAULT_AUDIO_SOURCE@"
+    async fn get_status(
+        &self,
+        config: &Config,
+        state: &SharedState,
+        target_type: &str,
+    ) -> Result<WaybarOutput> {
+        let audio_state = {
+            let lock = state.read().await;
+            lock.audio.clone()
         };
 
-        let stdout = run_command("wpctl", &["get-volume", target])?;
+        let (name, description, volume, muted) = if target_type == "sink" {
+            (
+                audio_state.sink.name,
+                audio_state.sink.description,
+                audio_state.sink.volume,
+                audio_state.sink.muted,
+            )
+        } else {
+            (
+                audio_state.source.name,
+                audio_state.source.description,
+                audio_state.source.volume,
+                audio_state.source.muted,
+            )
+        };
 
-        let parts: Vec<&str> = stdout.split_whitespace().collect();
-        if parts.len() < 2 {
-            return Err(anyhow!("Could not parse wpctl output: {}", stdout));
+        if name.is_empty() {
+            // Fallback if daemon hasn't populated state yet
+            return Ok(WaybarOutput {
+                text: "Audio Loading...".to_string(),
+                ..Default::default()
+            });
         }
 
-        let vol_val: f64 = parts[1].parse().unwrap_or(0.0);
-        let vol = (vol_val * 100.0).round() as u8;
-        let display_vol = std::cmp::min(vol, 100);
-        let muted = stdout.contains("[MUTED]");
-
-        let description = self.get_description(target_type)?;
-        let name = if description.len() > 20 {
+        let display_name = if description.len() > 20 {
             format!("{}...", &description[..17])
         } else {
             description.clone()
@@ -66,16 +246,16 @@ impl AudioModule {
             let t = format_template(
                 format_str,
                 &[
-                    ("name", TokenValue::String(&name)),
-                    ("icon", TokenValue::String(icon)),
+                    ("name", TokenValue::String(display_name)),
+                    ("icon", TokenValue::String(icon.to_string())),
                 ],
             );
             (t, "muted")
         } else {
             let icon = if target_type == "sink" {
-                if display_vol <= 30 {
+                if volume <= 30 {
                     ""
-                } else if display_vol <= 60 {
+                } else if volume <= 60 {
                     ""
                 } else {
                     ""
@@ -91,9 +271,9 @@ impl AudioModule {
             let t = format_template(
                 format_str,
                 &[
-                    ("name", TokenValue::String(&name)),
-                    ("icon", TokenValue::String(icon)),
-                    ("volume", TokenValue::Int(display_vol as i64)),
+                    ("name", TokenValue::String(display_name)),
+                    ("icon", TokenValue::String(icon.to_string())),
+                    ("volume", TokenValue::Int(volume as i64)),
                 ],
             );
             (t, "unmuted")
@@ -103,52 +283,32 @@ impl AudioModule {
             text,
             tooltip: Some(description),
             class: Some(class.to_string()),
-            percentage: Some(display_vol),
+            percentage: Some(volume),
         })
     }
 
-    fn get_description(&self, target_type: &str) -> Result<String> {
-        let info_stdout = run_command("pactl", &["info"])?;
-        let search_key = if target_type == "sink" {
-            "Default Sink:"
-        } else {
-            "Default Source:"
-        };
-
-        let default_dev = info_stdout
-            .lines()
-            .find(|l| l.contains(search_key))
-            .and_then(|l| l.split(':').nth(1))
-            .map(|s| s.trim())
-            .ok_or_else(|| anyhow!("Default {} not found", target_type))?;
-
-        let list_cmd = if target_type == "sink" {
-            "sinks"
-        } else {
-            "sources"
-        };
-        let list_stdout = run_command("pactl", &["list", list_cmd])?;
-
-        let mut current_name = String::new();
-        for line in list_stdout.lines() {
-            if line.trim().starts_with("Name: ") {
-                current_name = line.split(':').nth(1).unwrap_or("").trim().to_string();
-            }
-            if current_name == default_dev && line.trim().starts_with("Description: ") {
-                return Ok(line.split(':').nth(1).unwrap_or("").trim().to_string());
-            }
-        }
-
-        Ok(default_dev.to_string())
-    }
-
     fn cycle_device(&self, target_type: &str) -> Result<()> {
+        // Keep using pactl for cycling for now as it's a rare action
+        // but we could also implement it natively later.
+        let set_cmd = if target_type == "sink" {
+            "set-default-sink"
+        } else {
+            "set-default-source"
+        };
+
+        // We need to find the "next" device.
+        // For simplicity, let's keep the CLI version for now or refactor later.
+        // The user asked for "step by step".
+
         let list_cmd = if target_type == "sink" {
             "sinks"
         } else {
             "sources"
         };
-        let stdout = run_command("pactl", &["list", "short", list_cmd])?;
+        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()
@@ -171,13 +331,13 @@ impl AudioModule {
             return Ok(());
         }
 
-        let info_stdout = run_command("pactl", &["info"])?;
+        let info_output = Command::new("pactl").args(["info"]).output()?;
+        let info_stdout = String::from_utf8_lossy(&info_output.stdout);
         let search_key = if target_type == "sink" {
             "Default Sink:"
         } else {
             "Default Source:"
         };
-
         let current_dev = info_stdout
             .lines()
             .find(|l| l.contains(search_key))
@@ -189,13 +349,7 @@ impl AudioModule {
         let next_index = (current_index + 1) % devices.len();
         let next_dev = &devices[next_index];
 
-        let set_cmd = if target_type == "sink" {
-            "set-default-sink"
-        } else {
-            "set-default-source"
-        };
         Command::new("pactl").args([set_cmd, next_dev]).status()?;
-
         Ok(())
     }
 }

src/modules/bt.rs

@@ -1,34 +1,542 @@
 use crate::config::Config;
+use crate::error::Result as FluxoResult;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
-use crate::utils::{TokenValue, format_template, run_command};
-use anyhow::Result;
+use crate::state::{BtState, SharedState};
+use crate::utils::{TokenValue, format_template};
+use anyhow::{Context, Result};
+use futures::StreamExt;
+use std::collections::HashMap;
 use std::process::Command;
+use std::sync::{Arc, LazyLock, Mutex};
+use tokio::sync::mpsc;
+use tokio::time::{Duration, Instant};
+use tracing::{debug, error, info, warn};
+
+// Maestro imports
+#[allow(unused_imports)]
+use maestro::protocol::codec::Codec;
+#[allow(unused_imports)]
+use maestro::pwrpc::client::{Client, ClientHandle};
+#[allow(unused_imports)]
+use maestro::service::MaestroService;
+#[allow(unused_imports)]
+use maestro::service::settings::{self, Setting, SettingValue};
+
+#[derive(Clone, Default)]
+struct BudsStatus {
+    left_battery: Option<u8>,
+    right_battery: Option<u8>,
+    case_battery: Option<u8>,
+    anc_state: String,
+    #[allow(dead_code)]
+    last_update: Option<Instant>,
+    error: Option<String>,
+}
+
+enum BudsCommand {
+    SetAnc(String),
+}
+
+enum ManagerCommand {
+    EnsureTask(String),
+    SendCommand(String, BudsCommand),
+}
+
+struct MaestroManager {
+    statuses: Arc<Mutex<HashMap<String, BudsStatus>>>,
+    management_tx: mpsc::UnboundedSender<ManagerCommand>,
+}
+
+impl MaestroManager {
+    fn new() -> Self {
+        let (tx, mut rx) = mpsc::unbounded_channel::<ManagerCommand>();
+        let statuses = Arc::new(Mutex::new(HashMap::new()));
+        let statuses_clone = Arc::clone(&statuses);
+
+        // Start dedicated BT management thread
+        std::thread::spawn(move || {
+            let rt = tokio::runtime::Builder::new_current_thread()
+                .enable_all()
+                .build()
+                .unwrap();
+
+            let local = tokio::task::LocalSet::new();
+
+            local.block_on(&rt, async move {
+                let mut command_txs: HashMap<String, mpsc::Sender<BudsCommand>> = HashMap::new();
+
+                loop {
+                    tokio::select! {
+                        Some(cmd) = rx.recv() => {
+                            match cmd {
+                                ManagerCommand::EnsureTask(mac) => {
+                                    if !command_txs.contains_key(&mac) {
+                                        let (tx, buds_rx) = mpsc::channel::<BudsCommand>(10);
+                                        command_txs.insert(mac.clone(), tx);
+
+                                        let mac_clone = mac.clone();
+                                        let st_clone = Arc::clone(&statuses_clone);
+
+                                        tokio::task::spawn_local(async move {
+                                            if let Err(e) = buds_task(&mac_clone, st_clone, buds_rx).await {
+                                                error!("Buds task for {} failed: {}", mac_clone, e);
+                                            }
+                                        });
+                                    }
+                                }
+                                ManagerCommand::SendCommand(mac, buds_cmd) => {
+                                    if let Some(tx) = command_txs.get(&mac) {
+                                        let _ = tx.try_send(buds_cmd);
+                                    }
+                                }
+                            }
+                        }
+                        _ = tokio::time::sleep(Duration::from_millis(100)) => {
+                            // Cleanup dropped tasks if needed
+                        }
+                    }
+                }
+            });
+        });
+
+        Self {
+            statuses,
+            management_tx: tx,
+        }
+    }
+
+    fn get_status(&self, mac: &str) -> BudsStatus {
+        let statuses = self.statuses.lock().unwrap();
+        statuses.get(mac).cloned().unwrap_or_default()
+    }
+
+    fn ensure_task(&self, mac: &str) {
+        let _ = self
+            .management_tx
+            .send(ManagerCommand::EnsureTask(mac.to_string()));
+    }
+
+    fn send_command(&self, mac: &str, cmd: BudsCommand) -> Result<()> {
+        self.ensure_task(mac);
+        let _ = self
+            .management_tx
+            .send(ManagerCommand::SendCommand(mac.to_string(), cmd));
+        Ok(())
+    }
+}
+
+async fn buds_task(
+    mac: &str,
+    statuses: Arc<Mutex<HashMap<String, BudsStatus>>>,
+    mut rx: mpsc::Receiver<BudsCommand>,
+) -> Result<()> {
+    info!("Starting native Maestro connection task for {}", mac);
+
+    loop {
+        let addr: bluer::Address = mac.parse().context("Failed to parse MAC address")?;
+        let session = bluer::Session::new()
+            .await
+            .context("Failed to create bluer session")?;
+        let adapter = session
+            .default_adapter()
+            .await
+            .context("Failed to get default adapter")?;
+        let device = adapter
+            .device(addr)
+            .context("Failed to get device handle")?;
+
+        if !device.is_connected().await.unwrap_or(false) {
+            debug!("Device {} not connected to BT, stopping maestro task", mac);
+            break;
+        }
+
+        // Connect to Maestro RFCOMM service
+        // We try channel 1 then 2, which covers most Pixel Buds variants.
+        let mut stream = None;
+        for channel in [1, 2] {
+            let socket = match bluer::rfcomm::Socket::new() {
+                Ok(s) => s,
+                Err(e) => {
+                    error!("Failed to create RFCOMM socket: {}", e);
+                    return Err(e.into());
+                }
+            };
+            let target = bluer::rfcomm::SocketAddr::new(addr, channel);
+            debug!(
+                "Trying to connect RFCOMM to {} on channel {}...",
+                mac, channel
+            );
+            match socket.connect(target).await {
+                Ok(s) => {
+                    stream = Some(s);
+                    break;
+                }
+                Err(e) => {
+                    debug!("Failed to connect to channel {}: {}", channel, e);
+                }
+            }
+        }
+
+        let stream = match stream {
+            Some(s) => s,
+            None => {
+                warn!(
+                    "Failed to connect RFCOMM to {} on any common channel. Retrying in 15s...",
+                    mac
+                );
+                tokio::time::sleep(Duration::from_secs(15)).await;
+                continue;
+            }
+        };
+
+        info!("Connected Maestro RFCOMM to {} on channel", mac);
+
+        // Initialize Maestro communication stack
+        let codec = Codec::new();
+        let stream = codec.wrap(stream);
+        let mut client = Client::new(stream);
+        let handle = client.handle();
+
+        // Resolve Maestro channel (typically 1 or 2)
+        let channel = match maestro::protocol::utils::resolve_channel(&mut client).await {
+            Ok(c) => c,
+            Err(e) => {
+                error!("Failed to resolve Maestro channel for {}: {}", mac, e);
+                continue;
+            }
+        };
+
+        // Run client in background to handle RPC packets
+        tokio::spawn(async move {
+            if let Err(e) = client.run().await {
+                error!("Maestro client loop error: {}", e);
+            }
+        });
+
+        let mut service = MaestroService::new(handle, channel);
+
+        // Query initial ANC state
+        if let Ok(val) = service
+            .read_setting_var(settings::SettingId::CurrentAncrState)
+            .await
+            && let SettingValue::CurrentAncrState(anc_state) = val
+        {
+            let mut status = MAESTRO.get_status(mac);
+            status.anc_state = anc_state_to_string(&anc_state);
+            statuses.lock().unwrap().insert(mac.to_string(), status);
+        }
+
+        // Subscribe to real-time status updates (battery, ANC, wear)
+        let mut call = match service.subscribe_to_runtime_info() {
+            Ok(c) => c,
+            Err(e) => {
+                error!("Failed to subscribe to runtime info for {}: {}", mac, e);
+                continue;
+            }
+        };
+
+        let mut runtime_info = call.stream();
+
+        debug!("Subscribed to runtime info for {}", mac);
+
+        loop {
+            tokio::select! {
+                cmd = rx.recv() => {
+                    match cmd {
+                        Some(BudsCommand::SetAnc(mode)) => {
+                            debug!("Setting ANC mode to {} for {}", mode, mac);
+                            let state = mode_to_anc_state(&mode);
+                            let val = SettingValue::CurrentAncrState(state);
+                            if let Err(e) = service.write_setting(val).await {
+                                error!("Failed to write ANC setting for {}: {}", mac, e);
+                            }
+                        }
+                        None => return Ok(()),
+                    }
+                }
+                Some(Ok(info)) = runtime_info.next() => {
+                    let mut status = MAESTRO.get_status(mac);
+                    status.last_update = Some(Instant::now());
+
+                    if let Some(bat) = info.battery_info {
+                        status.left_battery = bat.left.map(|b| b.level as u8);
+                        status.right_battery = bat.right.map(|b| b.level as u8);
+                        status.case_battery = bat.case.map(|b| b.level as u8);
+                    }
+
+                    statuses.lock().unwrap().insert(mac.to_string(), status);
+                }
+                _ = tokio::time::sleep(Duration::from_secs(30)) => {
+                    // Check if still connected to BT
+                    if !device.is_connected().await.unwrap_or(false) {
+                        break;
+                    }
+                }
+            }
+        }
+
+        if !device.is_connected().await.unwrap_or(false) {
+            break;
+        }
+    }
+
+    Ok(())
+}
+
+fn mode_to_anc_state(mode: &str) -> settings::AncState {
+    match mode {
+        "active" => settings::AncState::Active,
+        "aware" => settings::AncState::Aware,
+        "off" => settings::AncState::Off,
+        _ => settings::AncState::Off,
+    }
+}
+
+fn anc_state_to_string(state: &settings::AncState) -> String {
+    match state {
+        settings::AncState::Active => "active".to_string(),
+        settings::AncState::Aware => "aware".to_string(),
+        settings::AncState::Off => "off".to_string(),
+        _ => "unknown".to_string(),
+    }
+}
+
+static MAESTRO: LazyLock<MaestroManager> = LazyLock::new(MaestroManager::new);
+
+pub struct BtDaemon {
+    session: Option<bluer::Session>,
+}
+
+impl BtDaemon {
+    pub fn new() -> Self {
+        Self { session: None }
+    }
+
+    pub async fn poll(&mut self, state: SharedState) {
+        if let Err(e) = self.poll_async(state).await {
+            error!("BT daemon error: {}", e);
+        }
+    }
+
+    async fn poll_async(&mut self, state: SharedState) -> Result<()> {
+        if self.session.is_none() {
+            self.session = Some(bluer::Session::new().await?);
+        }
+        let session = self.session.as_ref().unwrap();
+        let adapter = session.default_adapter().await?;
+        let adapter_powered = adapter.is_powered().await.unwrap_or(false);
+
+        let mut bt_state = BtState {
+            adapter_powered,
+            ..Default::default()
+        };
+
+        if adapter_powered {
+            let devices = adapter.device_addresses().await?;
+            for addr in devices {
+                let device = adapter.device(addr)?;
+                if device.is_connected().await.unwrap_or(false) {
+                    let uuids = device.uuids().await?.unwrap_or_default();
+                    // Audio sink UUID (0x110b)
+                    let audio_sink_uuid =
+                        bluer::Uuid::from_u128(0x0000110b_0000_1000_8000_00805f9b34fb);
+                    if uuids.contains(&audio_sink_uuid) {
+                        bt_state.connected = true;
+                        bt_state.device_address = addr.to_string();
+                        bt_state.device_alias =
+                            device.alias().await.unwrap_or_else(|_| addr.to_string());
+                        bt_state.battery_percentage =
+                            device.battery_percentage().await.unwrap_or(None);
+
+                        // Plugin detection
+                        for p in PLUGINS.iter() {
+                            if p.can_handle(&bt_state.device_alias, &bt_state.device_address) {
+                                match p.get_data(&bt_state.device_address) {
+                                    Ok(data) => {
+                                        bt_state.plugin_data = data
+                                            .into_iter()
+                                            .map(|(k, v)| {
+                                                let val_str = match v {
+                                                    TokenValue::String(s) => s,
+                                                    TokenValue::Int(i) => i.to_string(),
+                                                    TokenValue::Float(f) => format!("{:.1}", f),
+                                                };
+                                                (k, val_str)
+                                            })
+                                            .collect();
+                                    }
+                                    Err(e) => {
+                                        warn!("Plugin {} failed for {}: {}", p.name(), addr, e);
+                                        bt_state
+                                            .plugin_data
+                                            .push(("plugin_error".to_string(), e.to_string()));
+                                    }
+                                }
+                                break;
+                            }
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+
+        let mut lock = state.write().await;
+        lock.bluetooth = bt_state;
+
+        Ok(())
+    }
+}
+
+pub trait BtPlugin: Send + Sync {
+    fn name(&self) -> &str;
+    fn can_handle(&self, alias: &str, mac: &str) -> bool;
+    fn get_data(&self, mac: &str) -> Result<Vec<(String, TokenValue)>>;
+    fn get_modes(&self, _mac: &str) -> Result<Vec<String>> {
+        Ok(vec![])
+    }
+    fn set_mode(&self, _mode: &str, _mac: &str) -> Result<()> {
+        Ok(())
+    }
+    fn cycle_mode(&self, _mac: &str) -> Result<()> {
+        Ok(())
+    }
+}
+
+pub struct PixelBudsPlugin;
+
+impl BtPlugin for PixelBudsPlugin {
+    fn name(&self) -> &str {
+        "Pixel Buds Pro"
+    }
+
+    fn can_handle(&self, alias: &str, _mac: &str) -> bool {
+        alias.contains("Pixel Buds Pro")
+    }
+
+    fn get_data(&self, mac: &str) -> Result<Vec<(String, TokenValue)>> {
+        MAESTRO.ensure_task(mac);
+        let status = MAESTRO.get_status(mac);
+
+        if let Some(err) = status.error {
+            return Err(anyhow::anyhow!(err));
+        }
+
+        let left_display = status
+            .left_battery
+            .map(|b| format!("{}%", b))
+            .unwrap_or_else(|| "---".to_string());
+        let right_display = status
+            .right_battery
+            .map(|b| format!("{}%", b))
+            .unwrap_or_else(|| "---".to_string());
+
+        let (anc_icon, class) = match status.anc_state.as_str() {
+            "active" => ("ANC", "anc-active"),
+            "aware" => ("Aware", "anc-aware"),
+            "off" => ("Off", "anc-off"),
+            _ => ("?", "anc-unknown"),
+        };
+
+        Ok(vec![
+            ("left".to_string(), TokenValue::String(left_display)),
+            ("right".to_string(), TokenValue::String(right_display)),
+            ("anc".to_string(), TokenValue::String(anc_icon.to_string())),
+            (
+                "plugin_class".to_string(),
+                TokenValue::String(class.to_string()),
+            ),
+        ])
+    }
+
+    fn get_modes(&self, _mac: &str) -> Result<Vec<String>> {
+        Ok(vec![
+            "active".to_string(),
+            "aware".to_string(),
+            "off".to_string(),
+        ])
+    }
+
+    fn set_mode(&self, mode: &str, mac: &str) -> Result<()> {
+        MAESTRO.send_command(mac, BudsCommand::SetAnc(mode.to_string()))
+    }
+
+    fn cycle_mode(&self, mac: &str) -> Result<()> {
+        let status = MAESTRO.get_status(mac);
+        let next_mode = match status.anc_state.as_str() {
+            "active" => "aware",
+            "aware" => "off",
+            _ => "active",
+        };
+        self.set_mode(next_mode, mac)
+    }
+}
+
+static PLUGINS: LazyLock<Vec<Box<dyn BtPlugin>>> =
+    LazyLock::new(|| vec![Box::new(PixelBudsPlugin)]);
 
 pub struct BtModule;
 
 impl WaybarModule for BtModule {
-    fn run(&self, config: &Config, _state: &SharedState, args: &[&str]) -> Result<WaybarOutput> {
+    async fn run(
+        &self,
+        config: &Config,
+        state: &SharedState,
+        args: &[&str],
+    ) -> FluxoResult<WaybarOutput> {
         let action = args.first().unwrap_or(&"show");
+        let bt_state = {
+            let lock = state.read().await;
+            lock.bluetooth.clone()
+        };
 
-        if *action == "disconnect" {
-            if let Some(mac) = find_audio_device() {
+        match *action {
+            "disconnect" if bt_state.connected => {
                 let _ = Command::new("bluetoothctl")
-                    .args(["disconnect", &mac])
+                    .args(["disconnect", &bt_state.device_address])
                     .output();
+                return Ok(WaybarOutput::default());
             }
-            return Ok(WaybarOutput {
-                text: String::new(),
-                tooltip: None,
-                class: None,
-                percentage: None,
-            });
+            "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)?;
+                }
+                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)?
+                } 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)?;
+                    }
+                }
+                return Ok(WaybarOutput::default());
+            }
+            "show" => {}
+            _ => {}
         }
 
-        if let Ok(stdout) = run_command("bluetoothctl", &["show"])
-            && stdout.contains("Powered: no")
-        {
+        if !bt_state.adapter_powered {
             return Ok(WaybarOutput {
                 text: config.bt.format_disabled.clone(),
                 tooltip: Some("Bluetooth Disabled".to_string()),
@@ -37,46 +545,54 @@ impl WaybarModule for BtModule {
             });
         }
 
-        if let Some(mac) = find_audio_device() {
-            let info = run_command("bluetoothctl", &["info", &mac])?;
+        if bt_state.connected {
+            let mut tokens: Vec<(String, TokenValue)> = vec![
+                (
+                    "alias".to_string(),
+                    TokenValue::String(bt_state.device_alias.clone()),
+                ),
+                (
+                    "mac".to_string(),
+                    TokenValue::String(bt_state.device_address.clone()),
+                ),
+            ];
 
-            let mut alias = mac.clone();
-            let mut battery = None;
-            let mut trusted = "no";
+            let mut class = vec!["connected".to_string()];
+            let mut has_plugin = false;
 
-            for line in info.lines() {
-                if line.contains("Alias:") {
-                    alias = line.split("Alias:").nth(1).unwrap_or("").trim().to_string();
-                } else if line.contains("Battery Percentage:") {
-                    if let Some(bat_str) = line.split('(').nth(1).and_then(|s| s.split(')').next())
-                    {
-                        battery = bat_str.parse::<u8>().ok();
-                    }
-                } else if line.contains("Trusted: yes") {
-                    trusted = "yes";
+            for (k, v) in &bt_state.plugin_data {
+                if k == "plugin_class" {
+                    class.push(v.clone());
+                    has_plugin = true;
+                } else if k == "plugin_error" {
+                    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
+            };
+
+            let text = format_template(format, &tokens);
             let tooltip = format!(
-                "{} | MAC: {}\nTrusted: {} | Bat: {}",
-                alias,
-                mac,
-                trusted,
-                battery
+                "{} | 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())
             );
 
-            let text = format_template(
-                &config.bt.format_connected,
-                &[("alias", TokenValue::String(&alias))],
-            );
-
             Ok(WaybarOutput {
                 text,
                 tooltip: Some(tooltip),
-                class: Some("connected".to_string()),
-                percentage: battery,
+                class: Some(class.join(" ")),
+                percentage: bt_state.battery_percentage,
             })
         } else {
             Ok(WaybarOutput {
@@ -88,32 +604,3 @@ impl WaybarModule for BtModule {
         }
     }
 }
-
-fn find_audio_device() -> Option<String> {
-    if let Ok(sink) = run_command("pactl", &["get-default-sink"])
-        && sink.starts_with("bluez_output.")
-    {
-        let parts: Vec<&str> = sink.split('.').collect();
-        if parts.len() >= 2 {
-            return Some(parts[1].replace('_', ":"));
-        }
-    }
-
-    if let Ok(stdout) = run_command("bluetoothctl", &["devices", "Connected"]) {
-        for line in stdout.lines() {
-            if line.starts_with("Device ") {
-                let parts: Vec<&str> = line.split_whitespace().collect();
-                if parts.len() >= 2 {
-                    let mac = parts[1];
-                    if let Ok(info_str) = run_command("bluetoothctl", &["info", mac])
-                        && info_str.contains("0000110b-0000-1000-8000-00805f9b34fb")
-                    {
-                        return Some(mac.to_string());
-                    }
-                }
-            }
-        }
-    }
-
-    None
-}

src/modules/btrfs.rs

@@ -1,18 +1,22 @@
 use crate::config::Config;
+use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
 use crate::state::SharedState;
 use crate::utils::{TokenValue, format_template};
-use anyhow::Result;
 
 pub struct BtrfsModule;
 
 impl WaybarModule for BtrfsModule {
-    fn run(&self, config: &Config, state: &SharedState, _args: &[&str]) -> Result<WaybarOutput> {
-        let disks = if let Ok(s) = state.read() {
+    async fn run(
+        &self,
+        config: &Config,
+        state: &SharedState,
+        _args: &[&str],
+    ) -> Result<WaybarOutput> {
+        let disks = {
+            let s = state.read().await;
             s.disks.clone()
-        } else {
-            return Err(anyhow::anyhow!("Failed to read state"));
         };
 
         let mut total_used: f64 = 0.0;

src/modules/buds.rs

@@ -1,136 +0,0 @@
-use crate::config::Config;
-use crate::modules::WaybarModule;
-use crate::output::WaybarOutput;
-use crate::state::SharedState;
-use crate::utils::{TokenValue, format_template, run_command};
-use anyhow::Result;
-
-pub struct BudsModule;
-
-impl WaybarModule for BudsModule {
-    fn run(&self, config: &Config, _state: &SharedState, args: &[&str]) -> Result<WaybarOutput> {
-        let action = args.first().unwrap_or(&"show");
-        let mac = &config.buds.mac;
-
-        match *action {
-            "cycle_anc" => {
-                let current_mode = run_command("pbpctrl", &["get", "anc"])?;
-
-                let next_mode = match current_mode.as_str() {
-                    "active" => "aware",
-                    "aware" => "off",
-                    _ => "active",
-                };
-
-                let _ = run_command("pbpctrl", &["set", "anc", next_mode]);
-                return Ok(WaybarOutput {
-                    text: String::new(),
-                    tooltip: None,
-                    class: None,
-                    percentage: None,
-                });
-            }
-            "connect" => {
-                let _ = run_command("bluetoothctl", &["connect", mac]);
-                return Ok(WaybarOutput {
-                    text: String::new(),
-                    tooltip: None,
-                    class: None,
-                    percentage: None,
-                });
-            }
-            "disconnect" => {
-                let _ = run_command("bluetoothctl", &["disconnect", mac]);
-                return Ok(WaybarOutput {
-                    text: String::new(),
-                    tooltip: None,
-                    class: None,
-                    percentage: None,
-                });
-            }
-            "show" => {}
-            other => {
-                return Err(anyhow::anyhow!("Unknown buds action: '{}'", other));
-            }
-        }
-
-        let bt_str = run_command("bluetoothctl", &["info", mac])?;
-
-        if !bt_str.contains("Connected: yes") {
-            return Ok(WaybarOutput {
-                text: config.buds.format_disconnected.clone(),
-                tooltip: Some("Pixel Buds Pro 2 not connected".to_string()),
-                class: Some("disconnected".to_string()),
-                percentage: None,
-            });
-        }
-
-        let bat_output = match run_command("pbpctrl", &["show", "battery"]) {
-            Ok(output) => output,
-            Err(_) => {
-                return Ok(WaybarOutput {
-                    text: config.buds.format_disconnected.clone(),
-                    tooltip: Some("Pixel Buds Pro 2 connected (No Data)".to_string()),
-                    class: Some("disconnected".to_string()),
-                    percentage: None,
-                });
-            }
-        };
-
-        let mut left_bud = "unknown";
-        let mut right_bud = "unknown";
-
-        for line in bat_output.lines() {
-            if line.contains("left bud:") {
-                left_bud = line.split_whitespace().nth(2).unwrap_or("unknown");
-            } else if line.contains("right bud:") {
-                right_bud = line.split_whitespace().nth(2).unwrap_or("unknown");
-            }
-        }
-
-        if left_bud == "unknown" && right_bud == "unknown" {
-            return Ok(WaybarOutput {
-                text: "{}".to_string(),
-                tooltip: None,
-                class: None,
-                percentage: None,
-            });
-        }
-
-        let left_display = if left_bud == "unknown" {
-            "---".to_string()
-        } else {
-            format!("{}%", left_bud)
-        };
-        let right_display = if right_bud == "unknown" {
-            "---".to_string()
-        } else {
-            format!("{}%", right_bud)
-        };
-
-        let current_mode = run_command("pbpctrl", &["get", "anc"]).unwrap_or_default();
-
-        let (anc_icon, class) = match current_mode.as_str() {
-            "active" => ("ANC", "anc-active"),
-            "aware" => ("Aware", "anc-aware"),
-            "off" => ("Off", "anc-off"),
-            _ => ("?", "anc-unknown"),
-        };
-
-        let text = format_template(
-            &config.buds.format,
-            &[
-                ("left", TokenValue::String(&left_display)),
-                ("right", TokenValue::String(&right_display)),
-                ("anc", TokenValue::String(anc_icon)),
-            ],
-        );
-
-        Ok(WaybarOutput {
-            text,
-            tooltip: Some("Pixel Buds Pro 2".to_string()),
-            class: Some(class.to_string()),
-            percentage: None,
-        })
-    }
-}

src/modules/cpu.rs

@@ -1,24 +1,26 @@
 use crate::config::Config;
+use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
 use crate::state::SharedState;
 use crate::utils::{TokenValue, format_template};
-use anyhow::Result;
 
 pub struct CpuModule;
 
 impl WaybarModule for CpuModule {
-    fn run(&self, config: &Config, state: &SharedState, _args: &[&str]) -> Result<WaybarOutput> {
+    async fn run(
+        &self,
+        config: &Config,
+        state: &SharedState,
+        _args: &[&str],
+    ) -> Result<WaybarOutput> {
         let (usage, temp, model) = {
-            if let Ok(state_lock) = state.read() {
-                (
-                    state_lock.cpu.usage,
-                    state_lock.cpu.temp,
-                    state_lock.cpu.model.clone(),
-                )
-            } else {
-                (0.0, 0.0, String::from("Unknown"))
-            }
+            let state_lock = state.read().await;
+            (
+                state_lock.cpu.usage,
+                state_lock.cpu.temp,
+                state_lock.cpu.model.clone(),
+            )
         };
 
         let text = format_template(
@@ -51,8 +53,8 @@ mod tests {
     use super::*;
     use crate::state::{AppState, CpuState, mock_state};
 
-    #[test]
-    fn test_cpu_normal() {
+    #[tokio::test]
+    async fn test_cpu_normal() {
         let state = mock_state(AppState {
             cpu: CpuState {
                 usage: 25.0,
@@ -62,7 +64,7 @@ mod tests {
             ..Default::default()
         });
         let config = Config::default();
-        let output = CpuModule.run(&config, &state, &[]).unwrap();
+        let output = CpuModule.run(&config, &state, &[]).await.unwrap();
         assert!(output.text.contains("25.0"));
         assert!(output.text.contains("45.0"));
         assert_eq!(output.class.as_deref(), Some("normal"));
@@ -70,8 +72,8 @@ mod tests {
         assert_eq!(output.tooltip.as_deref(), Some("Test CPU"));
     }
 
-    #[test]
-    fn test_cpu_high() {
+    #[tokio::test]
+    async fn test_cpu_high() {
         let state = mock_state(AppState {
             cpu: CpuState {
                 usage: 80.0,
@@ -81,12 +83,12 @@ mod tests {
             ..Default::default()
         });
         let config = Config::default();
-        let output = CpuModule.run(&config, &state, &[]).unwrap();
+        let output = CpuModule.run(&config, &state, &[]).await.unwrap();
         assert_eq!(output.class.as_deref(), Some("high"));
     }
 
-    #[test]
-    fn test_cpu_max() {
+    #[tokio::test]
+    async fn test_cpu_max() {
         let state = mock_state(AppState {
             cpu: CpuState {
                 usage: 99.0,
@@ -96,7 +98,7 @@ mod tests {
             ..Default::default()
         });
         let config = Config::default();
-        let output = CpuModule.run(&config, &state, &[]).unwrap();
+        let output = CpuModule.run(&config, &state, &[]).await.unwrap();
         assert_eq!(output.class.as_deref(), Some("max"));
     }
 }

src/modules/disk.rs

@@ -1,20 +1,24 @@
 use crate::config::Config;
+use crate::error::{FluxoError, Result};
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
 use crate::state::SharedState;
 use crate::utils::{TokenValue, format_template};
-use anyhow::Result;
 
 pub struct DiskModule;
 
 impl WaybarModule for DiskModule {
-    fn run(&self, config: &Config, state: &SharedState, args: &[&str]) -> Result<WaybarOutput> {
+    async fn run(
+        &self,
+        config: &Config,
+        state: &SharedState,
+        args: &[&str],
+    ) -> Result<WaybarOutput> {
         let mountpoint = args.first().unwrap_or(&"/");
 
-        let disks = if let Ok(s) = state.read() {
+        let disks = {
+            let s = state.read().await;
             s.disks.clone()
-        } else {
-            return Err(anyhow::anyhow!("Failed to read state"));
         };
 
         for disk in &disks {
@@ -44,7 +48,7 @@ impl WaybarModule for DiskModule {
                 let text = format_template(
                     &config.disk.format,
                     &[
-                        ("mount", TokenValue::String(mountpoint)),
+                        ("mount", TokenValue::String(mountpoint.to_string())),
                         ("used", TokenValue::Float(used_gb)),
                         ("total", TokenValue::Float(total_gb)),
                     ],
@@ -62,7 +66,10 @@ impl WaybarModule for DiskModule {
             }
         }
 
-        Err(anyhow::anyhow!("Mountpoint {} not found", mountpoint))
+        Err(FluxoError::Module {
+            module: "disk",
+            message: format!("Mountpoint {} not found", mountpoint),
+        })
     }
 }
 
@@ -83,30 +90,30 @@ mod tests {
         })
     }
 
-    #[test]
-    fn test_disk_found() {
+    #[tokio::test]
+    async fn test_disk_found() {
         let gb = 1024 * 1024 * 1024;
         let state = state_with_disk("/", 100 * gb, 60 * gb);
         let config = Config::default();
-        let output = DiskModule.run(&config, &state, &["/"]).unwrap();
+        let output = DiskModule.run(&config, &state, &["/"]).await.unwrap();
         assert_eq!(output.class.as_deref(), Some("normal"));
         assert_eq!(output.percentage, Some(40)); // 40% used
     }
 
-    #[test]
-    fn test_disk_high() {
+    #[tokio::test]
+    async fn test_disk_high() {
         let gb = 1024 * 1024 * 1024;
         let state = state_with_disk("/", 100 * gb, 15 * gb);
         let config = Config::default();
-        let output = DiskModule.run(&config, &state, &["/"]).unwrap();
+        let output = DiskModule.run(&config, &state, &["/"]).await.unwrap();
         assert_eq!(output.class.as_deref(), Some("high")); // 85% used
     }
 
-    #[test]
-    fn test_disk_not_found() {
+    #[tokio::test]
+    async fn test_disk_not_found() {
         let state = mock_state(AppState::default());
         let config = Config::default();
-        let result = DiskModule.run(&config, &state, &["/nonexistent"]);
+        let result = DiskModule.run(&config, &state, &["/nonexistent"]).await;
         assert!(result.is_err());
     }
 }

src/modules/game.rs

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

src/modules/gpu.rs

@@ -1,36 +1,30 @@
 use crate::config::Config;
+use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
 use crate::state::SharedState;
 use crate::utils::{TokenValue, format_template};
-use anyhow::Result;
 
 pub struct GpuModule;
 
 impl WaybarModule for GpuModule {
-    fn run(&self, config: &Config, state: &SharedState, _args: &[&str]) -> Result<WaybarOutput> {
+    async fn run(
+        &self,
+        config: &Config,
+        state: &SharedState,
+        _args: &[&str],
+    ) -> Result<WaybarOutput> {
         let (active, vendor, usage, vram_used, vram_total, temp, model) = {
-            if let Ok(state_lock) = state.read() {
-                (
-                    state_lock.gpu.active,
-                    state_lock.gpu.vendor.clone(),
-                    state_lock.gpu.usage,
-                    state_lock.gpu.vram_used,
-                    state_lock.gpu.vram_total,
-                    state_lock.gpu.temp,
-                    state_lock.gpu.model.clone(),
-                )
-            } else {
-                (
-                    false,
-                    String::from("Unknown"),
-                    0.0,
-                    0.0,
-                    0.0,
-                    0.0,
-                    String::from("Unknown"),
-                )
-            }
+            let state_lock = state.read().await;
+            (
+                state_lock.gpu.active,
+                state_lock.gpu.vendor.clone(),
+                state_lock.gpu.usage,
+                state_lock.gpu.vram_used,
+                state_lock.gpu.vram_total,
+                state_lock.gpu.temp,
+                state_lock.gpu.model.clone(),
+            )
         };
 
         if !active {

src/modules/hardware.rs

@@ -20,11 +20,11 @@ impl HardwareDaemon {
             components,
             gpu_vendor: None,
             gpu_poll_counter: 0,
-            disk_poll_counter: 0,
+            disk_poll_counter: 9, // Start at 9 to poll on the first tick
         }
     }
 
-    pub fn poll(&mut self, state: SharedState) {
+    pub async fn poll_fast(&mut self, state: SharedState) {
         self.sys.refresh_cpu_usage();
         self.sys.refresh_memory();
         self.components.refresh(true);
@@ -70,30 +70,36 @@ impl HardwareDaemon {
             }
         }
 
-        if let Ok(mut state_lock) = state.write() {
-            state_lock.cpu.usage = cpu_usage as f64;
-            state_lock.cpu.temp = cpu_temp;
-            state_lock.cpu.model = cpu_model;
+        let mut state_lock = state.write().await;
+        state_lock.cpu.usage = cpu_usage as f64;
+        state_lock.cpu.temp = cpu_temp;
+        state_lock.cpu.model = cpu_model;
 
-            state_lock.memory.total_gb = total_mem;
-            state_lock.memory.used_gb = used_mem;
+        state_lock.memory.total_gb = total_mem;
+        state_lock.memory.used_gb = used_mem;
 
-            state_lock.sys.load_1 = load_avg.one;
-            state_lock.sys.load_5 = load_avg.five;
-            state_lock.sys.load_15 = load_avg.fifteen;
-            state_lock.sys.uptime = uptime;
-            state_lock.sys.process_count = process_count;
+        state_lock.sys.load_1 = load_avg.one;
+        state_lock.sys.load_5 = load_avg.five;
+        state_lock.sys.load_15 = load_avg.fifteen;
+        state_lock.sys.uptime = uptime;
+        state_lock.sys.process_count = process_count;
+    }
 
-            // Poll GPU every 5 seconds to avoid expensive nvidia-smi calls
-            self.gpu_poll_counter = (self.gpu_poll_counter + 1) % 5;
-            if self.gpu_poll_counter == 0 {
-                self.poll_gpu(&mut state_lock.gpu);
-            }
+    pub async fn poll_slow(&mut self, state: SharedState) {
+        // 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);
+        }
 
-            // Poll disks every 10 seconds
-            self.disk_poll_counter = (self.disk_poll_counter + 1) % 10;
-            if self.disk_poll_counter == 0 {
-                state_lock.disks = Disks::new_with_refreshed_list()
+        // 2. Gather Disk data outside of lock
+        let mut disks_data = None;
+        self.disk_poll_counter = (self.disk_poll_counter + 1) % 10;
+        if self.disk_poll_counter == 0 {
+            disks_data = Some(
+                Disks::new_with_refreshed_list()
                     .iter()
                     .map(|d| DiskInfo {
                         mount_point: d.mount_point().to_string_lossy().into_owned(),
@@ -101,8 +107,18 @@ impl HardwareDaemon {
                         total_bytes: d.total_space(),
                         available_bytes: d.available_space(),
                     })
-                    .collect();
-            }
+                    .collect::<Vec<DiskInfo>>(),
+            );
+        }
+
+        // 3. Apply to state
+        let mut state_lock = state.write().await;
+        if should_poll_gpu {
+            state_lock.gpu = gpu_state;
+        }
+
+        if let Some(d) = disks_data {
+            state_lock.disks = d;
         }
     }
 

src/modules/memory.rs

@@ -1,20 +1,22 @@
 use crate::config::Config;
+use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
 use crate::state::SharedState;
 use crate::utils::{TokenValue, format_template};
-use anyhow::Result;
 
 pub struct MemoryModule;
 
 impl WaybarModule for MemoryModule {
-    fn run(&self, config: &Config, state: &SharedState, _args: &[&str]) -> Result<WaybarOutput> {
+    async fn run(
+        &self,
+        config: &Config,
+        state: &SharedState,
+        _args: &[&str],
+    ) -> Result<WaybarOutput> {
         let (used_gb, total_gb) = {
-            if let Ok(state_lock) = state.read() {
-                (state_lock.memory.used_gb, state_lock.memory.total_gb)
-            } else {
-                (0.0, 0.0)
-            }
+            let state_lock = state.read().await;
+            (state_lock.memory.used_gb, state_lock.memory.total_gb)
         };
 
         let ratio = if total_gb > 0.0 {
@@ -53,8 +55,8 @@ mod tests {
     use super::*;
     use crate::state::{AppState, MemoryState, mock_state};
 
-    #[test]
-    fn test_memory_normal() {
+    #[tokio::test]
+    async fn test_memory_normal() {
         let state = mock_state(AppState {
             memory: MemoryState {
                 used_gb: 8.0,
@@ -63,15 +65,15 @@ mod tests {
             ..Default::default()
         });
         let config = Config::default();
-        let output = MemoryModule.run(&config, &state, &[]).unwrap();
+        let output = MemoryModule.run(&config, &state, &[]).await.unwrap();
         assert!(output.text.contains("8.00"));
         assert!(output.text.contains("32.00"));
         assert_eq!(output.class.as_deref(), Some("normal"));
         assert_eq!(output.percentage, Some(25)); // 8/32 = 25%
     }
 
-    #[test]
-    fn test_memory_high() {
+    #[tokio::test]
+    async fn test_memory_high() {
         let state = mock_state(AppState {
             memory: MemoryState {
                 used_gb: 26.0,
@@ -80,12 +82,12 @@ mod tests {
             ..Default::default()
         });
         let config = Config::default();
-        let output = MemoryModule.run(&config, &state, &[]).unwrap();
+        let output = MemoryModule.run(&config, &state, &[]).await.unwrap();
         assert_eq!(output.class.as_deref(), Some("high")); // 81%
     }
 
-    #[test]
-    fn test_memory_zero_total() {
+    #[tokio::test]
+    async fn test_memory_zero_total() {
         let state = mock_state(AppState {
             memory: MemoryState {
                 used_gb: 0.0,
@@ -94,7 +96,7 @@ mod tests {
             ..Default::default()
         });
         let config = Config::default();
-        let output = MemoryModule.run(&config, &state, &[]).unwrap();
+        let output = MemoryModule.run(&config, &state, &[]).await.unwrap();
         assert_eq!(output.class.as_deref(), Some("normal"));
         assert_eq!(output.percentage, Some(0));
     }

src/modules/mod.rs

@@ -1,7 +1,6 @@
 pub mod audio;
 pub mod bt;
 pub mod btrfs;
-pub mod buds;
 pub mod cpu;
 pub mod disk;
 pub mod game;
@@ -13,10 +12,15 @@ pub mod power;
 pub mod sys;
 
 use crate::config::Config;
+use crate::error::Result as FluxoResult;
 use crate::output::WaybarOutput;
 use crate::state::SharedState;
-use anyhow::Result;
 
 pub trait WaybarModule {
-    fn run(&self, config: &Config, state: &SharedState, args: &[&str]) -> Result<WaybarOutput>;
+    fn run(
+        &self,
+        config: &Config,
+        state: &SharedState,
+        args: &[&str],
+    ) -> impl std::future::Future<Output = FluxoResult<WaybarOutput>> + Send;
 }

src/modules/network.rs

@@ -1,9 +1,10 @@
 use crate::config::Config;
+use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
 use crate::state::SharedState;
-use crate::utils::{TokenValue, format_template, run_command};
-use anyhow::Result;
+use crate::utils::{TokenValue, format_template};
+use nix::ifaddrs::getifaddrs;
 use std::fs;
 use std::time::{SystemTime, UNIX_EPOCH};
 
@@ -28,22 +29,19 @@ impl NetworkDaemon {
         }
     }
 
-    pub fn poll(&mut self, state: SharedState) {
-        // Cache invalidation: if the interface directory doesn't exist, clear cache
-        if let Some(ref iface) = self.cached_interface
-            && !std::path::Path::new(&format!("/sys/class/net/{}", iface)).exists()
-        {
-            self.cached_interface = None;
-            self.cached_ip = None;
-        }
-
-        // Re-detect interface if needed
-        if self.cached_interface.is_none()
-            && let Ok(iface) = get_primary_interface()
+    pub async fn poll(&mut self, state: SharedState) {
+        // Re-detect interface on every poll to catch VPNs or route changes immediately
+        if let Ok(iface) = get_primary_interface()
             && !iface.is_empty()
         {
-            self.cached_ip = get_ip_address(&iface);
-            self.cached_interface = Some(iface);
+            // If the interface changed, or we don't have an IP yet, update the IP
+            if self.cached_interface.as_ref() != Some(&iface) || self.cached_ip.is_none() {
+                self.cached_ip = get_ip_address(&iface);
+                self.cached_interface = Some(iface);
+            }
+        } else {
+            self.cached_interface = None;
+            self.cached_ip = None;
         }
 
         if let Some(ref interface) = self.cached_interface {
@@ -64,14 +62,14 @@ impl NetworkDaemon {
                         / 1024.0
                         / 1024.0;
 
-                    if let Ok(mut state_lock) = state.write() {
-                        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 if let Ok(mut state_lock) = state.write() {
+                    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();
                 }
@@ -83,8 +81,9 @@ impl NetworkDaemon {
                 // Read failed, might be down
                 self.cached_interface = None;
             }
-        } else if let Ok(mut state_lock) = state.write() {
+        } else {
             // No interface detected
+            let mut state_lock = state.write().await;
             state_lock.network.interface.clear();
             state_lock.network.ip.clear();
         }
@@ -92,21 +91,20 @@ impl NetworkDaemon {
 }
 
 impl WaybarModule for NetworkModule {
-    fn run(&self, config: &Config, state: &SharedState, _args: &[&str]) -> Result<WaybarOutput> {
-        let (interface, ip, rx_mbps, tx_mbps) = if let Ok(s) = state.read() {
+    async fn run(
+        &self,
+        config: &Config,
+        state: &SharedState,
+        _args: &[&str],
+    ) -> Result<WaybarOutput> {
+        let (interface, ip, rx_mbps, tx_mbps) = {
+            let s = state.read().await;
             (
                 s.network.interface.clone(),
                 s.network.ip.clone(),
                 s.network.rx_mbps,
                 s.network.tx_mbps,
             )
-        } else {
-            return Ok(WaybarOutput {
-                text: "No connection".to_string(),
-                tooltip: None,
-                class: None,
-                percentage: None,
-            });
         };
 
         if interface.is_empty() {
@@ -123,8 +121,8 @@ impl WaybarModule for NetworkModule {
         let mut output_text = format_template(
             &config.network.format,
             &[
-                ("interface", TokenValue::String(&interface)),
-                ("ip", TokenValue::String(ip_display)),
+                ("interface", TokenValue::String(interface.clone())),
+                ("ip", TokenValue::String(ip_display.to_string())),
                 ("rx", TokenValue::Float(rx_mbps)),
                 ("tx", TokenValue::Float(tx_mbps)),
             ],
@@ -134,6 +132,8 @@ impl WaybarModule for NetworkModule {
             || interface.starts_with("wg")
             || interface.starts_with("ppp")
             || interface.starts_with("pvpn")
+            || interface.starts_with("proton")
+            || interface.starts_with("ipsec")
         {
             output_text = format!("  {}", output_text);
         }
@@ -148,24 +148,18 @@ impl WaybarModule for NetworkModule {
 }
 
 fn get_primary_interface() -> Result<String> {
-    let stdout = run_command("ip", &["route", "list"])?;
+    let content = fs::read_to_string("/proc/net/route")?;
 
     let mut defaults = Vec::new();
-    for line in stdout.lines() {
-        if line.starts_with("default") {
-            let parts: Vec<&str> = line.split_whitespace().collect();
-            let mut dev = "";
-            let mut metric = 0;
-            for i in 0..parts.len() {
-                if parts[i] == "dev" && i + 1 < parts.len() {
-                    dev = parts[i + 1];
-                }
-                if parts[i] == "metric" && i + 1 < parts.len() {
-                    metric = parts[i + 1].parse::<i32>().unwrap_or(0);
-                }
-            }
-            if !dev.is_empty() {
-                defaults.push((metric, dev.to_string()));
+    for line in content.lines().skip(1) {
+        let parts: Vec<&str> = line.split_whitespace().collect();
+        if parts.len() >= 7 {
+            let iface = parts[0];
+            let dest = parts[1];
+            let metric = parts[6].parse::<i32>().unwrap_or(0);
+
+            if dest == "00000000" {
+                defaults.push((metric, iface.to_string()));
             }
         }
     }
@@ -179,15 +173,13 @@ fn get_primary_interface() -> Result<String> {
 }
 
 fn get_ip_address(interface: &str) -> Option<String> {
-    let stdout = run_command("ip", &["-4", "addr", "show", interface]).ok()?;
-    for line in stdout.lines() {
-        if line.trim().starts_with("inet ") {
-            let parts: Vec<&str> = line.split_whitespace().collect();
-            if parts.len() > 1 {
-                let ip_cidr = parts[1];
-                let ip = ip_cidr.split('/').next().unwrap_or(ip_cidr);
-                return Some(ip.to_string());
-            }
+    let addrs = getifaddrs().ok()?;
+    for ifaddr in addrs {
+        if ifaddr.interface_name == interface
+            && let Some(address) = ifaddr.address
+            && let Some(sockaddr) = address.as_sockaddr_in()
+        {
+            return Some(sockaddr.ip().to_string());
         }
     }
     None
@@ -216,16 +208,16 @@ mod tests {
     use super::*;
     use crate::state::{AppState, NetworkState, mock_state};
 
-    #[test]
-    fn test_network_no_connection() {
+    #[tokio::test]
+    async fn test_network_no_connection() {
         let state = mock_state(AppState::default());
         let config = Config::default();
-        let output = NetworkModule.run(&config, &state, &[]).unwrap();
+        let output = NetworkModule.run(&config, &state, &[]).await.unwrap();
         assert_eq!(output.text, "No connection");
     }
 
-    #[test]
-    fn test_network_connected() {
+    #[tokio::test]
+    async fn test_network_connected() {
         let state = mock_state(AppState {
             network: NetworkState {
                 rx_mbps: 1.5,
@@ -236,15 +228,15 @@ mod tests {
             ..Default::default()
         });
         let config = Config::default();
-        let output = NetworkModule.run(&config, &state, &[]).unwrap();
+        let output = NetworkModule.run(&config, &state, &[]).await.unwrap();
         assert!(output.text.contains("eth0"));
         assert!(output.text.contains("192.168.1.100"));
         assert!(output.text.contains("1.50"));
         assert_eq!(output.class.as_deref(), Some("eth0"));
     }
 
-    #[test]
-    fn test_network_vpn_prefix() {
+    #[tokio::test]
+    async fn test_network_vpn_prefix() {
         let state = mock_state(AppState {
             network: NetworkState {
                 rx_mbps: 0.0,
@@ -255,12 +247,12 @@ mod tests {
             ..Default::default()
         });
         let config = Config::default();
-        let output = NetworkModule.run(&config, &state, &[]).unwrap();
+        let output = NetworkModule.run(&config, &state, &[]).await.unwrap();
         assert!(output.text.starts_with("  "));
     }
 
-    #[test]
-    fn test_network_no_ip() {
+    #[tokio::test]
+    async fn test_network_no_ip() {
         let state = mock_state(AppState {
             network: NetworkState {
                 rx_mbps: 0.0,
@@ -271,7 +263,7 @@ mod tests {
             ..Default::default()
         });
         let config = Config::default();
-        let output = NetworkModule.run(&config, &state, &[]).unwrap();
+        let output = NetworkModule.run(&config, &state, &[]).await.unwrap();
         assert!(output.text.contains("No IP"));
     }
 }

src/modules/power.rs

@@ -1,15 +1,20 @@
 use crate::config::Config;
+use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
 use crate::state::SharedState;
 use crate::utils::{TokenValue, format_template};
-use anyhow::Result;
 use std::fs;
 
 pub struct PowerModule;
 
 impl WaybarModule for PowerModule {
-    fn run(&self, config: &Config, _state: &SharedState, _args: &[&str]) -> Result<WaybarOutput> {
+    async fn run(
+        &self,
+        config: &Config,
+        _state: &SharedState,
+        _args: &[&str],
+    ) -> Result<WaybarOutput> {
         let critical_threshold = 15;
         let warning_threshold = 50;
 
@@ -96,7 +101,7 @@ impl WaybarModule for PowerModule {
             &config.power.format,
             &[
                 ("percentage", TokenValue::Int(percentage as i64)),
-                ("icon", TokenValue::String(icon)),
+                ("icon", TokenValue::String(icon.to_string())),
             ],
         );
 

src/modules/sys.rs

@@ -1,26 +1,28 @@
 use crate::config::Config;
+use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
 use crate::state::SharedState;
 use crate::utils::{TokenValue, format_template};
-use anyhow::Result;
 
 pub struct SysModule;
 
 impl WaybarModule for SysModule {
-    fn run(&self, config: &Config, state: &SharedState, _args: &[&str]) -> Result<WaybarOutput> {
+    async fn run(
+        &self,
+        config: &Config,
+        state: &SharedState,
+        _args: &[&str],
+    ) -> Result<WaybarOutput> {
         let (load1, load5, load15, uptime_secs, process_count) = {
-            if let Ok(state_lock) = state.read() {
-                (
-                    state_lock.sys.load_1,
-                    state_lock.sys.load_5,
-                    state_lock.sys.load_15,
-                    state_lock.sys.uptime,
-                    state_lock.sys.process_count,
-                )
-            } else {
-                (0.0, 0.0, 0.0, 0, 0)
-            }
+            let state_lock = state.read().await;
+            (
+                state_lock.sys.load_1,
+                state_lock.sys.load_5,
+                state_lock.sys.load_15,
+                state_lock.sys.uptime,
+                state_lock.sys.process_count,
+            )
         };
 
         let hours = uptime_secs / 3600;
@@ -34,7 +36,7 @@ impl WaybarModule for SysModule {
         let text = format_template(
             &config.sys.format,
             &[
-                ("uptime", TokenValue::String(&uptime_str)),
+                ("uptime", TokenValue::String(uptime_str.clone())),
                 ("load1", TokenValue::Float(load1)),
                 ("load5", TokenValue::Float(load5)),
                 ("load15", TokenValue::Float(load15)),

src/output.rs

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

src/state.rs

@@ -1,4 +1,7 @@
-use std::sync::{Arc, RwLock};
+use std::collections::HashMap;
+use std::sync::Arc;
+use tokio::sync::RwLock;
+use tokio::time::Instant;
 
 #[derive(Default, Clone)]
 pub struct AppState {
@@ -8,6 +11,48 @@ pub struct AppState {
     pub sys: SysState,
     pub gpu: GpuState,
     pub disks: Vec<DiskInfo>,
+    pub bluetooth: BtState,
+    pub audio: AudioState,
+    pub health: HashMap<String, ModuleHealth>,
+}
+
+#[derive(Clone, Default)]
+pub struct ModuleHealth {
+    pub consecutive_failures: u32,
+    pub last_failure: Option<Instant>,
+    pub backoff_until: Option<Instant>,
+}
+
+#[derive(Default, Clone)]
+pub struct AudioState {
+    pub sink: AudioDeviceInfo,
+    pub source: AudioSourceInfo,
+}
+
+#[derive(Default, Clone)]
+pub struct AudioDeviceInfo {
+    pub name: String,
+    pub description: String,
+    pub volume: u8,
+    pub muted: bool,
+}
+
+#[derive(Default, Clone)]
+pub struct AudioSourceInfo {
+    pub name: String,
+    pub description: String,
+    pub volume: u8,
+    pub muted: bool,
+}
+
+#[derive(Default, Clone)]
+pub struct BtState {
+    pub connected: bool,
+    pub adapter_powered: bool,
+    pub device_alias: String,
+    pub device_address: String,
+    pub battery_percentage: Option<u8>,
+    pub plugin_data: Vec<(String, String)>,
 }
 
 #[derive(Default, Clone)]

src/utils.rs

@@ -2,20 +2,6 @@ use anyhow::{Context, Result};
 use std::io::Write;
 use std::process::{Command, Stdio};
 
-/// Run an external command and return its stdout as a trimmed String.
-/// Provides clear error messages when the command is not found or fails.
-pub fn run_command(cmd: &str, args: &[&str]) -> Result<String> {
-    let output = Command::new(cmd)
-        .args(args)
-        .output()
-        .with_context(|| format!("'{}' not found or failed to execute. Is it installed?", cmd))?;
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        anyhow::bail!("'{}' exited with {}: {}", cmd, output.status, stderr.trim());
-    }
-    Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
-}
-
 pub fn show_menu(prompt: &str, items: &[String], menu_cmd: &str) -> Result<String> {
     let cmd_str = menu_cmd.replace("{prompt}", prompt);
     let mut child = Command::new("sh")
@@ -50,20 +36,23 @@ pub fn show_menu(prompt: &str, items: &[String], menu_cmd: &str) -> Result<Strin
 use regex::Regex;
 use std::sync::LazyLock;
 
-pub enum TokenValue<'a> {
+pub enum TokenValue {
     Float(f64),
     Int(i64),
-    String(&'a str),
+    String(String),
 }
 
-pub fn format_template(template: &str, values: &[(&str, TokenValue)]) -> String {
+pub fn format_template<K>(template: &str, values: &[(K, TokenValue)]) -> String
+where
+    K: AsRef<str>,
+{
     static RE: LazyLock<Regex> = LazyLock::new(|| {
         Regex::new(r"\{([a-zA-Z0-9_]+)(?::([<>\^])?(\d+)?(?:\.(\d+))?)?\}").unwrap()
     });
 
     RE.replace_all(template, |caps: &regex::Captures| {
         let name = &caps[1];
-        if let Some((_, val)) = values.iter().find(|(k, _)| *k == name) {
+        if let Some((_, val)) = values.iter().find(|(k, _)| k.as_ref() == name) {
             let align = caps.get(2).map(|m| m.as_str()).unwrap_or(">");
             let width = caps
                 .get(3)
@@ -121,7 +110,10 @@ mod tests {
 
     #[test]
     fn test_simple_string_token() {
-        let result = format_template("{name}", &[("name", TokenValue::String("hello"))]);
+        let result = format_template(
+            "{name}",
+            &[("name", TokenValue::String("hello".to_string()))],
+        );
         assert_eq!(result, "hello");
     }
 
@@ -166,14 +158,20 @@ mod tests {
 
     #[test]
     fn test_string_left_align() {
-        let result = format_template("{val:<10}", &[("val", TokenValue::String("hi"))]);
+        let result = format_template(
+            "{val:<10}",
+            &[("val", TokenValue::String("hi".to_string()))],
+        );
         assert_eq!(result, "hi        ");
         assert_eq!(result.len(), 10);
     }
 
     #[test]
     fn test_unknown_token_preserved() {
-        let result = format_template("{unknown}", &[("name", TokenValue::String("test"))]);
+        let result = format_template(
+            "{unknown}",
+            &[("name", TokenValue::String("test".to_string()))],
+        );
         assert_eq!(result, "{unknown}");
     }
 
@@ -191,7 +189,7 @@ mod tests {
 
     #[test]
     fn test_no_tokens() {
-        let result = format_template("plain text", &[]);
+        let result = format_template::<&'static str>("plain text", &[]);
         assert_eq!(result, "plain text");
     }
 
@@ -206,8 +204,8 @@ mod tests {
         let result = format_template(
             "{name} ({ip}): {rx:>5.2} MB/s",
             &[
-                ("name", TokenValue::String("eth0")),
-                ("ip", TokenValue::String("10.0.0.1")),
+                ("name", TokenValue::String("eth0".to_string())),
+                ("ip", TokenValue::String("10.0.0.1".to_string())),
                 ("rx", TokenValue::Float(1.5)),
             ],
         );