version bump

Reviewed-on: #2

.gitea/workflows/ci.yml

@@ -0,0 +1,62 @@
+name: CI
+
+on:
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  check:
+    name: Lint and Test
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install Rust
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          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
+
+      - name: Clippy
+        run: cargo clippy --tests -- -D warnings
+
+      - name: Test
+        run: cargo test
+
+      - name: Build
+        run: cargo build --release
+
+  version-check:
+    name: Version Check
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Compare versions
+        shell: bash
+        run: |
+          NEW_VERSION=$(grep -m1 '^version =' Cargo.toml | cut -d '"' -f 2)
+
+          git fetch origin ${{ github.base_ref }}
+          OLD_VERSION=$(git show origin/${{ github.base_ref }}:Cargo.toml | grep -m1 '^version =' | cut -d '"' -f 2)
+
+          echo "Old version (main): $OLD_VERSION"
+          echo "New version (PR): $NEW_VERSION"
+
+          if [ "$NEW_VERSION" = "$OLD_VERSION" ]; then
+            echo "Error: Cargo.toml version has not been updated in this PR!"
+            exit 1
+          else
+            echo "Success: Version updated from $OLD_VERSION to $NEW_VERSION"
+          fi

.gitea/workflows/release.yml

@@ -0,0 +1,109 @@
+name: Release
+
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - 'v*'
+
+jobs:
+  build:
+    name: Build and Release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install Rust
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: stable
+          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: Get Version
+        id: get_version
+        run: |
+          VERSION=$(grep -m1 '^version =' Cargo.toml | cut -d '"' -f 2)
+          echo "VERSION=$VERSION" >> $GITHUB_OUTPUT
+          if [[ "${{ github.ref }}" == refs/tags/v* ]]; then
+            echo "TAG=${{ github.ref_name }}" >> $GITHUB_OUTPUT
+          else
+            echo "TAG=v$VERSION" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Check if Release Exists
+        id: check_release
+        shell: bash
+        run: |
+          HTTP_STATUS=$(curl -s -o /dev/null -w "%{http_code}" \
+            -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
+            "${{ github.server_url }}/api/v1/repos/${{ github.repository }}/releases/tags/${{ steps.get_version.outputs.TAG }}")
+
+          if [ "$HTTP_STATUS" = "200" ]; then
+            echo "EXISTS=true" >> $GITHUB_OUTPUT
+            echo "Release already exists for tag ${{ steps.get_version.outputs.TAG }}. Skipping."
+          else
+            echo "EXISTS=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Build
+        if: steps.check_release.outputs.EXISTS == 'false'
+        run: cargo build --release
+
+      - name: Test
+        if: steps.check_release.outputs.EXISTS == 'false'
+        run: cargo test
+
+      - name: Package .deb
+        if: steps.check_release.outputs.EXISTS == 'false'
+        env:
+          VERSION: ${{ steps.get_version.outputs.VERSION }}
+          TAG: ${{ steps.get_version.outputs.TAG }}
+        run: |
+          PKG="fluxo-rs_${VERSION}_amd64"
+
+          mkdir -p "${PKG}/DEBIAN"
+          mkdir -p "${PKG}/usr/bin"
+
+          cp target/release/fluxo-rs "${PKG}/usr/bin/"
+          strip "${PKG}/usr/bin/fluxo-rs"
+
+          printf '%s\n' \
+            "Package: fluxo-rs" \
+            "Version: ${VERSION}" \
+            "Section: utils" \
+            "Priority: optional" \
+            "Architecture: amd64" \
+            "Maintainer: fluxo-rs contributors" \
+            "Description: High-performance daemon/client for Waybar custom modules" \
+            " fluxo-rs is a compiled Rust daemon that polls system metrics and" \
+            " serves formatted JSON output to Waybar custom modules over a Unix" \
+            " domain socket. Replaces shell scripts with a single binary." \
+            > "${PKG}/DEBIAN/control"
+
+          dpkg-deb --build "${PKG}"
+
+          mv "${PKG}.deb" "fluxo-rs-${TAG}-amd64.deb"
+          echo "Built: fluxo-rs-${TAG}-amd64.deb"
+
+      - name: Create Release and Upload Assets
+        if: steps.check_release.outputs.EXISTS == 'false'
+        uses: https://github.com/softprops/action-gh-release@v1
+        with:
+          tag_name: ${{ steps.get_version.outputs.TAG }}
+          name: Release ${{ steps.get_version.outputs.TAG }}
+          body: |
+            Automated release for version ${{ steps.get_version.outputs.VERSION }}
+            Commit: ${{ github.sha }}
+            Branch: ${{ github.ref_name }}
+          files: |
+            fluxo-rs-${{ steps.get_version.outputs.TAG }}-amd64.deb
+            target/release/fluxo-rs
+          draft: false
+          prerelease: false
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Cargo.toml

@@ -1,16 +1,40 @@
 [package]
 name = "fluxo-rs"
-version = "0.1.0"
+version = "0.4.1"
 edition = "2024"
 
+[features]
+default = ["mod-audio", "mod-bt", "mod-network", "mod-hardware", "mod-dbus"]
+mod-audio = ["dep:libpulse-binding"]
+mod-bt = ["dep:bluer", "dep:maestro"]
+mod-network = ["dep:nix"]
+mod-hardware = []
+mod-dbus = ["dep:zbus", "dep:futures"]
+
 [dependencies]
 anyhow = "1.0.102"
 clap = { version = "4.6.0", features = ["derive"] }
-fs4 = "0.13.1"
-regex = "1.10"
+ctrlc = "3"
+libc = "0.2"
+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.2"
 tracing = "0.1.44"
 tracing-subscriber = { version = "0.3.23", features = ["env-filter"] }
+tokio = { version = "1", features = ["rt", "rt-multi-thread", "sync", "time", "macros", "signal", "process", "io-util", "net"] }
+tokio-util = { version = "0.7", features = ["codec", "time"] }
+notify = "8.2.0"
+
+# Optional module dependencies
+maestro = { git = "https://github.com/qzed/pbpctrl", package = "maestro", optional = true }
+bluer = { version = "0.17", features = ["bluetoothd", "rfcomm", "id"], optional = true }
+futures = { version = "0.3", optional = true }
+libpulse-binding = { version = "2.30", optional = true }
+nix = { version = "0.31", features = ["net"], optional = true }
+zbus = { version = "5", optional = true }
+
+[dev-dependencies]
+tempfile = "3"

README.md

@@ -1,96 +1,74 @@
 # fluxo-rs
 
-fluxo-rs is a high-performance system metrics daemon and client designed specifically for waybar. It replaces standard shell scripts with a compiled rust binary that collects data via a background polling loop and serves it over a unix domain socket (`/tmp/fluxo.sock`).
+`fluxo-rs` is a high-performance system metrics daemon and client designed specifically for Waybar. It entirely replaces standard shell scripts with a compiled Rust binary that collects data via a background polling loop and serves it over a Unix socket. 
 
-## Description
+With its **100% Native, Content-Based Event-Driven Architecture**, it consumes effectively 0% CPU while idle and signals Waybar to redraw *only* when the rendered UI text or icons physically change.
 
-The project follows a client-server architecture:
-- **Daemon**: Handles heavy lifting (polling cpu, memory, network, gpu) and stores state in memory.
-- **Client**: A thin cli wrapper that connects to the daemon's socket to retrieve formatted json for waybar.
+## Key Features
 
-This approach eliminates process spawning overhead and temporary file locking, resulting in near-zero cpu usage for custom modules.
-
-## Features
-
-- **Ultra-lightweight**: Background polling is highly optimized (e.g., O(1) process counting).
-- **Jitter-free**: Uses zero-width sentinels and figure spaces to prevent waybar from trimming padding.
-- **Configurable**: Fully customizable output formats via toml config.
-- **Interactive Menus**: Integrated support for selecting items (like Bluetooth devices) via external menus (e.g., Rofi, Wofi, Fuzzel).
-- **Live Reload**: Configuration can be reloaded without restarting the daemon.
-- **Multi-vendor GPU**: Native support for intel (igpu), amd, and nvidia.
+- **100% Native Architecture**: Zero shell-outs or subprocesses. Uses `bluer` for Bluetooth, `libpulse-binding` for audio, `zbus` for MPRIS/DND, and `notify` for backlight.
+- **Content-Based Event Signaling**: `fluxo-rs` evaluates your custom configuration formats internally. It only sends a `SIGRTMIN+X` signal to Waybar if the resulting string or CSS class has actually changed, eliminating pointless re-renders from raw polling fluctuations.
+- **Zero-Latency Interactions**: Direct library bindings mean that when you change your volume or connect a Bluetooth device via the CLI, the daemon updates instantly.
+- **Circuit Breaker (Failsafe)**: Automatically detects failing modules and enters a "Cool down" state, preventing resource waste and log spam. Fallback caching keeps your bar looking clean even during brief failures.
+- **Multi-threaded Polling**: Decoupled Tokio subsystem threads ensure that a hang in one system (e.g., a slow GPU probe) never freezes your Waybar.
 
 ## Modules
 
 | Command | Description | Tokens |
 | :--- | :--- | :--- |
-| `net` | Network speed (rx/tx) | `{interface}`, `{ip}`, `{rx}`, `{tx}` |
-| `cpu` | CPU usage and temp | `{usage}`, `{temp}` |
+| `cpu` | CPU usage and temperature | `{usage}`, `{temp}`, `{model}` |
 | `mem` | Memory usage | `{used}`, `{total}` |
-| `gpu` | GPU utilization | `{usage}`, `{vram_used}`, `{vram_total}`, `{temp}` |
-| `sys` | System load and uptime | `{uptime}`, `{load1}`, `{load5}`, `{load15}` |
-| `disk` | Disk usage (default: /) | `{mount}`, `{used}`, `{total}` |
-| `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}` |
+| `net` | Network status & speeds | `{interface}`, `{ip}`, `{rx}`, `{tx}` |
+| `sys` | System load and uptime | `{uptime}`, `{load1}`, `{load5}`, `{load15}`, `{procs}` |
+| `disk` | Disk usage | `{mount}`, `{used}`, `{total}` |
+| `pool` | Btrfs aggregate storage | `{used}`, `{total}` |
+| `gpu` | GPU usage & thermals | `{usage}`, `{vram_used}`, `{vram_total}`, `{temp}` |
+| `vol` | Audio output (sink) | `{name}`, `{volume}`, `{icon}` |
+| `mic` | Audio input (source) | `{name}`, `{volume}`, `{icon}` |
+| `bt` | Bluetooth status & plugins | `{alias}`, `{mac}`, `{left}`, `{right}`, `{anc}` |
 | `power` | Battery and AC status | `{percentage}`, `{icon}` |
-| `game` | Hyprland gamemode status | active/inactive icon strings |
+| `game` | Hyprland Gamemode status | active/inactive strings |
+| `mpris` | Media Player status | `{artist}`, `{title}`, `{album}`, `{status_icon}` |
+| `backlight` | Display Brightness | `{percentage}`, `{icon}` |
+| `kbd` | Keyboard Layout | `{layout}` |
+| `dnd` | Do Not Disturb (SwayNC) | active/inactive strings |
 
 ## Setup
 
-1. Build the project:
-   ```bash
-   cd fluxo-rs
-   cargo build --release
-   ```
+1. **Build**: `cargo build --release`
+2. **Configure**: Create `~/.config/fluxo/config.toml` (see `example.config.toml`). Ensure you map your `[signals]`.
+3. **Daemon**: Start `fluxo-rs daemon`. It is highly recommended to run this as a systemd user service.
 
-2. Start the daemon:
-   ```bash
-   # Starts the daemon using the default config path (~/.config/fluxo/config.toml)
-   ./target/release/fluxo-rs daemon &
+## Waybar Configuration
 
-   # Or provide a custom path
-   ./target/release/fluxo-rs daemon --config /path/to/your/config.toml &
-   ```
+To achieve zero-latency updates and zero-polling CPU usage, set `interval: 0` on your modules and rely entirely on **Waybar Signals** mapped in your `config.toml`:
 
-3. Configuration:
-   Create `~/.config/fluxo/config.toml` (see `example.config.toml` for all default options).
-
-4. Waybar configuration (`config.jsonc`):
-   ```json
-   "custom/cpu": {
-       "exec": "~/path/to/fluxo-rs cpu",
-       "return-type": "json"
-   }
-   ```
-
-## Development
-
-### Architecture
-- `src/main.rs`: Entry point, CLI parsing, interactive GUI spawns (menus), and client-side formatting logic.
-- `src/daemon.rs`: UDS listener, configuration management, and polling orchestration.
-- `src/ipc.rs`: Unix domain socket communication logic.
-- `src/utils.rs`: Generic GUI utilities (like the menu spawner).
-- `src/modules/`: Individual metric implementations.
-- `src/state.rs`: Shared thread-safe data structures.
-
-### Adding a Module
-1. Add the required config block to `src/config.rs`.
-2. Add the required state fields to `src/state.rs`.
-3. Implement the `WaybarModule` trait in a new file in `src/modules/`.
-4. Add polling logic to `src/modules/hardware.rs` or `src/daemon.rs`.
-5. Register the new subcommand in `src/main.rs` and the router in `src/daemon.rs`.
-
-### Configuration Reload
-The daemon can reload its configuration live:
-```bash
-fluxo-rs reload
+```jsonc
+"custom/volume": {
+    "exec": "fluxo-rs vol",
+    "return-type": "json",
+    "interval": 0,
+    "signal": 8, // Must match the value in config.toml [signals]
+    "on-click": "fluxo-rs vol mute",
+    "on-scroll-up": "fluxo-rs vol up 1",
+    "on-scroll-down": "fluxo-rs vol down 1",
+    "on-click-right": "fluxo-rs vol cycle"
+},
+"custom/bluetooth-audio": {
+    "format": "{}",
+    "return-type": "json",
+    "exec": "fluxo-rs bt",
+    "on-click": "fluxo-rs bt menu",
+    "on-click-right": "fluxo-rs bt cycle_mode",
+    "signal": 9,
+    "interval": 0,
+    "tooltip": true
+}
 ```
 
-### Logging & Debugging
-`fluxo-rs` uses the `tracing` ecosystem. If a module isn't behaving properly or your configuration isn't applying, start the daemon with debug logging enabled in the foreground:
+## Debugging
+
+Start the daemon with `RUST_LOG=debug` to see detailed logs of library interactions and circuit breaker status:
 ```bash
 RUST_LOG=debug fluxo-rs daemon
 ```
-This will print verbose information regarding config parsing errors, subprocess failures, and IPC requests.

example.config.toml

@@ -0,0 +1,97 @@
+# Fluxo configuration example
+# Place this at ~/.config/fluxo/config.toml
+
+# Note: All tokens support standard alignment, padding, and precision specifiers dynamically.
+# For example, you can change {rx:>5.2} to {rx:<8.1} or {used} to {used:^4.0} directly here.
+
+[general]
+# command used for interactive menus (e.g., bluetooth device selection)
+# $FLUXO_PROMPT is securely injected to prevent shell escaping issues
+menu_command = "fuzzel --dmenu --prompt \"$FLUXO_PROMPT\""
+# For Wofi use: menu_command = "wofi --show dmenu --prompt \"$FLUXO_PROMPT\""
+
+# Map modules to specific Waybar signals for zero-latency, event-driven UI updates.
+# These MUST match the `signal` configuration in your waybar config.jsonc
+[signals]
+network = 1
+cpu = 2
+memory = 3
+gpu = 4
+sys = 5
+disk = 6
+game = 7
+audio = 8
+bt = 9
+power = 10
+keyboard = 11
+mpris = 12
+backlight = 13
+dnd = 14
+
+[network]
+# tokens: {interface}, {ip}, {rx}, {tx}
+format = "{interface} ({ip}):  {rx:^4.1} MB/s   {tx:^4.1} MB/s"
+
+[cpu]
+# tokens: {usage}, {temp}, {model}
+format = "CPU: {usage:^4.1}% {temp:^4.1}C"
+
+[memory]
+# tokens: {used}, {total}
+format = "MEM: {used:^4.1}/{total:^4.1}GB"
+
+[gpu]
+# tokens: {usage}, {vram_used}, {vram_total}, {temp}
+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]
+# tokens: {uptime}, {load1}, {load5}, {load15}, {procs}
+format = "UP: {uptime} LOAD: {load1:^3.1} "
+
+[disk]
+# tokens: {mount}, {used}, {total}
+format = "{mount} {used:^3.0}/{total:^3.0}G"
+
+[pool]
+# tokens: {used}, {total}
+format = "{used:>4.0}G / {total:>4.0}G"
+
+[power]
+# tokens: {percentage}, {icon}
+format = "{percentage:>3}%  {icon}"
+
+[audio]
+# tokens: {name}, {volume}, {icon}
+format_sink_unmuted = "{name} {volume:>3}% {icon}"
+format_sink_muted = "{name} {icon}"
+format_source_unmuted = "{name} {volume:>3}% {icon}"
+format_source_muted = "{name} {icon}"
+
+[bt]
+# tokens: {alias}, {mac}, {left}, {right}, {anc}
+format_plugin = "{alias} [{left}|{right}] {anc} 󰂰"
+format_connected = "󰂰 {alias}"
+format_disconnected = "󰂯 Disconnected"
+format_disabled = "󰂲 Off"
+
+[game]
+format_active = "<span size='large'>󰊖</span>"
+format_inactive = "<span size='large'></span>"
+
+[mpris]
+# tokens: {artist}, {title}, {album}, {status_icon}
+format = "{status_icon} {artist} - {title}"
+
+[backlight]
+# tokens: {percentage}, {icon}
+format = "{percentage:>3}% {icon}"
+
+[keyboard]
+# tokens: {layout}
+format = "{layout}"
+
+[dnd]
+format_dnd = "<span size='large'>󰂛</span>"
+format_normal = "<span size='large'>󰂚</span>"

src/config.rs

@@ -3,37 +3,60 @@ use std::fs;
 use std::path::PathBuf;
 use tracing::{debug, info, warn};
 
-#[derive(Deserialize, Default)]
+#[derive(Deserialize, Default, Clone)]
 pub struct Config {
     #[serde(default)]
     pub general: GeneralConfig,
     #[serde(default)]
+    pub signals: SignalsConfig,
+    #[cfg(feature = "mod-network")]
+    #[serde(default)]
     pub network: NetworkConfig,
+    #[cfg(feature = "mod-hardware")]
     #[serde(default)]
     pub cpu: CpuConfig,
+    #[cfg(feature = "mod-hardware")]
     #[serde(default)]
     pub memory: MemoryConfig,
+    #[cfg(feature = "mod-hardware")]
     #[serde(default)]
     pub gpu: GpuConfig,
+    #[cfg(feature = "mod-hardware")]
     #[serde(default)]
     pub sys: SysConfig,
+    #[cfg(feature = "mod-hardware")]
     #[serde(default)]
     pub disk: DiskConfig,
+    #[cfg(feature = "mod-hardware")]
     #[serde(default)]
     pub pool: PoolConfig,
+    #[cfg(feature = "mod-hardware")]
     #[serde(default)]
     pub power: PowerConfig,
-    #[serde(default)]
-    pub buds: BudsConfig,
+    #[cfg(feature = "mod-audio")]
     #[serde(default)]
     pub audio: AudioConfig,
+    #[cfg(feature = "mod-bt")]
     #[serde(default)]
     pub bt: BtConfig,
+    #[cfg(feature = "mod-hardware")]
     #[serde(default)]
     pub game: GameConfig,
+    #[cfg(feature = "mod-dbus")]
+    #[serde(default)]
+    pub mpris: MprisConfig,
+    #[cfg(feature = "mod-dbus")]
+    #[serde(default)]
+    pub backlight: BacklightConfig,
+    #[cfg(feature = "mod-dbus")]
+    #[serde(default)]
+    pub keyboard: KeyboardConfig,
+    #[cfg(feature = "mod-dbus")]
+    #[serde(default)]
+    pub dnd: DndConfig,
 }
 
-#[derive(Deserialize)]
+#[derive(Deserialize, Clone)]
 pub struct GeneralConfig {
     pub menu_command: String,
 }
@@ -41,12 +64,32 @@ pub struct GeneralConfig {
 impl Default for GeneralConfig {
     fn default() -> Self {
         Self {
-            menu_command: "fuzzel --dmenu --prompt '{prompt}'".to_string(),
+            menu_command: "fuzzel --dmenu --prompt \"$FLUXO_PROMPT\"".to_string(),
         }
     }
 }
 
-#[derive(Deserialize)]
+#[allow(dead_code)]
+#[derive(Deserialize, Default, Clone)]
+pub struct SignalsConfig {
+    pub network: Option<i32>,
+    pub cpu: Option<i32>,
+    pub memory: Option<i32>,
+    pub gpu: Option<i32>,
+    pub sys: Option<i32>,
+    pub disk: Option<i32>,
+    pub pool: Option<i32>,
+    pub power: Option<i32>,
+    pub audio: Option<i32>,
+    pub bt: Option<i32>,
+    pub game: Option<i32>,
+    pub mpris: Option<i32>,
+    pub backlight: Option<i32>,
+    pub keyboard: Option<i32>,
+    pub dnd: Option<i32>,
+}
+
+#[derive(Deserialize, Clone)]
 pub struct NetworkConfig {
     pub format: String,
 }
@@ -59,7 +102,7 @@ impl Default for NetworkConfig {
     }
 }
 
-#[derive(Deserialize)]
+#[derive(Deserialize, Clone)]
 pub struct CpuConfig {
     pub format: String,
 }
@@ -72,7 +115,7 @@ impl Default for CpuConfig {
     }
 }
 
-#[derive(Deserialize)]
+#[derive(Deserialize, Clone)]
 pub struct MemoryConfig {
     pub format: String,
 }
@@ -85,7 +128,7 @@ impl Default for MemoryConfig {
     }
 }
 
-#[derive(Deserialize)]
+#[derive(Deserialize, Clone)]
 pub struct GpuConfig {
     pub format_amd: String,
     pub format_intel: String,
@@ -95,14 +138,16 @@ pub struct GpuConfig {
 impl Default for GpuConfig {
     fn default() -> Self {
         Self {
-            format_amd: "AMD: {usage:>3.0}% {vram_used:>4.1}/{vram_total:>4.1}GB {temp:>4.1}C".to_string(),
+            format_amd: "AMD: {usage:>3.0}% {vram_used:>4.1}/{vram_total:>4.1}GB {temp:>4.1}C"
+                .to_string(),
             format_intel: "iGPU: {usage:>3.0}%".to_string(),
-            format_nvidia: "NV: {usage:>3.0}% {vram_used:>4.1}/{vram_total:>4.1}GB {temp:>4.1}C".to_string(),
+            format_nvidia: "NV: {usage:>3.0}% {vram_used:>4.1}/{vram_total:>4.1}GB {temp:>4.1}C"
+                .to_string(),
         }
     }
 }
 
-#[derive(Deserialize)]
+#[derive(Deserialize, Clone)]
 pub struct SysConfig {
     pub format: String,
 }
@@ -115,7 +160,7 @@ impl Default for SysConfig {
     }
 }
 
-#[derive(Deserialize)]
+#[derive(Deserialize, Clone)]
 pub struct DiskConfig {
     pub format: String,
 }
@@ -128,7 +173,7 @@ impl Default for DiskConfig {
     }
 }
 
-#[derive(Deserialize)]
+#[derive(Deserialize, Clone)]
 pub struct PoolConfig {
     pub format: String,
 }
@@ -141,7 +186,7 @@ impl Default for PoolConfig {
     }
 }
 
-#[derive(Deserialize)]
+#[derive(Deserialize, Clone)]
 pub struct PowerConfig {
     pub format: String,
 }
@@ -154,24 +199,7 @@ 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)]
+#[derive(Deserialize, Clone)]
 pub struct AudioConfig {
     pub format_sink_unmuted: String,
     pub format_sink_muted: String,
@@ -190,9 +218,10 @@ impl Default for AudioConfig {
     }
 }
 
-#[derive(Deserialize)]
+#[derive(Deserialize, Clone)]
 pub struct BtConfig {
     pub format_connected: String,
+    pub format_plugin: String,
     pub format_disconnected: String,
     pub format_disabled: String,
 }
@@ -201,13 +230,14 @@ 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(),
         }
     }
 }
 
-#[derive(Deserialize)]
+#[derive(Deserialize, Clone)]
 pub struct GameConfig {
     pub format_active: String,
     pub format_inactive: String,
@@ -222,8 +252,156 @@ impl Default for GameConfig {
     }
 }
 
-pub fn load_config(custom_path: Option<PathBuf>) -> Config {
-    let config_path = custom_path.unwrap_or_else(|| {
+#[derive(Deserialize, Clone)]
+pub struct MprisConfig {
+    pub format: String,
+}
+
+impl Default for MprisConfig {
+    fn default() -> Self {
+        Self {
+            format: "{status_icon} {artist} - {title}".to_string(),
+        }
+    }
+}
+
+#[derive(Deserialize, Clone)]
+pub struct BacklightConfig {
+    pub format: String,
+}
+
+impl Default for BacklightConfig {
+    fn default() -> Self {
+        Self {
+            format: "{percentage:>3}% {icon}".to_string(),
+        }
+    }
+}
+
+#[derive(Deserialize, Clone)]
+pub struct KeyboardConfig {
+    pub format: String,
+}
+
+impl Default for KeyboardConfig {
+    fn default() -> Self {
+        Self {
+            format: "{layout}".to_string(),
+        }
+    }
+}
+
+#[derive(Deserialize, Clone)]
+pub struct DndConfig {
+    pub format_dnd: String,
+    pub format_normal: String,
+}
+
+impl Default for DndConfig {
+    fn default() -> Self {
+        Self {
+            format_dnd: "<span size='large'>󰂛</span>".to_string(),
+            format_normal: "<span size='large'>󰂚</span>".to_string(),
+        }
+    }
+}
+
+fn extract_tokens(format_str: &str) -> Vec<String> {
+    crate::utils::TOKEN_RE
+        .captures_iter(format_str)
+        .map(|cap| cap[1].to_string())
+        .collect()
+}
+
+fn validate_format(label: &str, format_str: &str, known_tokens: &[&str]) {
+    for token in extract_tokens(format_str) {
+        if !known_tokens.contains(&token.as_str()) {
+            warn!(
+                "Config [{}]: unknown token '{{{}}}' in format string. Known tokens: {:?}",
+                label, token, known_tokens
+            );
+        }
+    }
+}
+
+impl Config {
+    pub fn validate(&self) {
+        #[cfg(feature = "mod-network")]
+        validate_format(
+            "network",
+            &self.network.format,
+            &["interface", "ip", "rx", "tx"],
+        );
+        #[cfg(feature = "mod-hardware")]
+        {
+            validate_format("cpu", &self.cpu.format, &["usage", "temp"]);
+            validate_format("memory", &self.memory.format, &["used", "total"]);
+            validate_format(
+                "gpu.amd",
+                &self.gpu.format_amd,
+                &["usage", "vram_used", "vram_total", "temp"],
+            );
+            validate_format("gpu.intel", &self.gpu.format_intel, &["usage", "freq"]);
+            validate_format(
+                "gpu.nvidia",
+                &self.gpu.format_nvidia,
+                &["usage", "vram_used", "vram_total", "temp"],
+            );
+            validate_format(
+                "sys",
+                &self.sys.format,
+                &["uptime", "load1", "load5", "load15", "procs"],
+            );
+            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"]);
+        }
+        #[cfg(feature = "mod-audio")]
+        {
+            validate_format(
+                "audio.sink_unmuted",
+                &self.audio.format_sink_unmuted,
+                &["name", "icon", "volume"],
+            );
+            validate_format(
+                "audio.sink_muted",
+                &self.audio.format_sink_muted,
+                &["name", "icon"],
+            );
+            validate_format(
+                "audio.source_unmuted",
+                &self.audio.format_source_unmuted,
+                &["name", "icon", "volume"],
+            );
+            validate_format(
+                "audio.source_muted",
+                &self.audio.format_source_muted,
+                &["name", "icon"],
+            );
+        }
+        #[cfg(feature = "mod-bt")]
+        {
+            validate_format("bt.connected", &self.bt.format_connected, &["alias"]);
+            validate_format(
+                "bt.plugin",
+                &self.bt.format_plugin,
+                &["alias", "left", "right", "anc", "mac"],
+            );
+        }
+        #[cfg(feature = "mod-dbus")]
+        {
+            validate_format(
+                "mpris",
+                &self.mpris.format,
+                &["artist", "title", "album", "status_icon"],
+            );
+            validate_format("backlight", &self.backlight.format, &["percentage", "icon"]);
+            validate_format("keyboard", &self.keyboard.format, &["layout"]);
+        }
+    }
+}
+
+pub fn default_config_path() -> PathBuf {
     let config_dir = std::env::var("XDG_CONFIG_HOME")
         .map(PathBuf::from)
         .unwrap_or_else(|_| {
@@ -231,12 +409,16 @@ pub fn load_config(custom_path: Option<PathBuf>) -> Config {
             PathBuf::from(home).join(".config")
         });
     config_dir.join("fluxo/config.toml")
-    });
+}
+
+pub fn load_config(custom_path: Option<PathBuf>) -> Config {
+    let config_path = custom_path.unwrap_or_else(default_config_path);
 
     if let Ok(content) = fs::read_to_string(&config_path) {
-        match toml::from_str(&content) {
+        match toml::from_str::<Config>(&content) {
             Ok(cfg) => {
                 info!("Successfully loaded configuration from {:?}", config_path);
+                cfg.validate();
                 cfg
             }
             Err(e) => {
@@ -246,7 +428,79 @@ pub fn load_config(custom_path: Option<PathBuf>) -> Config {
             }
         }
     } else {
-        debug!("No config file found at {:?}, using default settings.", config_path);
+        debug!(
+            "No config file found at {:?}, using default settings.",
+            config_path
+        );
         Config::default()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Write;
+
+    #[test]
+    fn test_default_config() {
+        let config = Config::default();
+        assert_eq!(
+            config.general.menu_command,
+            "fuzzel --dmenu --prompt \"$FLUXO_PROMPT\""
+        );
+        assert!(config.cpu.format.contains("usage"));
+        assert!(config.cpu.format.contains("temp"));
+        assert!(config.memory.format.contains("used"));
+        assert!(config.memory.format.contains("total"));
+    }
+
+    #[test]
+    fn test_load_missing_config() {
+        let config = load_config(Some(PathBuf::from("/nonexistent/config.toml")));
+        // Should fallback to defaults without panicking
+        assert_eq!(
+            config.general.menu_command,
+            "fuzzel --dmenu --prompt \"$FLUXO_PROMPT\""
+        );
+    }
+
+    #[test]
+    fn test_load_valid_partial_config() {
+        let mut tmpfile = tempfile::NamedTempFile::new().unwrap();
+        // In TOML, braces have no special meaning in strings
+        writeln!(tmpfile, "[cpu]").unwrap();
+        writeln!(tmpfile, "format = \"custom: {{usage}}\"").unwrap();
+
+        let config = load_config(Some(tmpfile.path().to_path_buf()));
+        // TOML treats {{ as literal {{ (no escape), so the value is "custom: {{usage}}"
+        assert!(config.cpu.format.contains("usage"));
+        // Other sections still have defaults
+        assert!(config.memory.format.contains("used"));
+    }
+
+    #[test]
+    fn test_load_invalid_toml() {
+        let mut tmpfile = tempfile::NamedTempFile::new().unwrap();
+        write!(tmpfile, "this is not valid toml {{{{").unwrap();
+
+        let config = load_config(Some(tmpfile.path().to_path_buf()));
+        // Should fallback to defaults
+        assert_eq!(
+            config.general.menu_command,
+            "fuzzel --dmenu --prompt \"$FLUXO_PROMPT\""
+        );
+    }
+
+    #[test]
+    fn test_load_empty_config() {
+        let tmpfile = tempfile::NamedTempFile::new().unwrap();
+        // Empty file is valid TOML, all sections default
+
+        let config = load_config(Some(tmpfile.path().to_path_buf()));
+        assert_eq!(
+            config.general.menu_command,
+            "fuzzel --dmenu --prompt \"$FLUXO_PROMPT\""
+        );
+        assert!(config.cpu.format.contains("usage"));
+    }
+}

src/daemon.rs

@@ -1,132 +1,421 @@
 use crate::config::Config;
-use crate::ipc::SOCKET_PATH;
-use crate::modules::network::NetworkDaemon;
+use crate::ipc::socket_path;
+#[cfg(feature = "mod-audio")]
+use crate::modules::audio::AudioDaemon;
+#[cfg(feature = "mod-dbus")]
+use crate::modules::backlight::BacklightDaemon;
+#[cfg(feature = "mod-bt")]
+use crate::modules::bt::BtDaemon;
+#[cfg(feature = "mod-dbus")]
+use crate::modules::dnd::DndDaemon;
+#[cfg(feature = "mod-hardware")]
 use crate::modules::hardware::HardwareDaemon;
-use crate::modules::WaybarModule;
-use crate::state::{AppState, SharedState};
+#[cfg(feature = "mod-dbus")]
+use crate::modules::keyboard::KeyboardDaemon;
+#[cfg(feature = "mod-dbus")]
+use crate::modules::mpris::MprisDaemon;
+#[cfg(feature = "mod-network")]
+use crate::modules::network::NetworkDaemon;
+use crate::signaler::WaybarSignaler;
+use crate::state::AppReceivers;
 use anyhow::Result;
+use notify::{Config as NotifyConfig, Event, RecommendedWatcher, RecursiveMode, Watcher};
+use std::collections::HashMap;
 use std::fs;
-use std::io::{BufRead, BufReader, Write};
-use std::os::unix::net::UnixListener;
-use std::sync::{Arc, RwLock};
-use std::thread;
-use std::time::Duration;
-use tracing::{info, warn, error, debug};
 use std::path::PathBuf;
+use std::sync::Arc;
+use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
+use tokio::net::UnixListener;
+use tokio::sync::{RwLock, mpsc, watch};
+use tokio::time::{Duration, sleep};
+use tokio_util::sync::CancellationToken;
+use tracing::{debug, error, info};
 
-pub fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
-    if fs::metadata(SOCKET_PATH).is_ok() {
-        debug!("Removing stale socket file: {}", SOCKET_PATH);
-        fs::remove_file(SOCKET_PATH)?;
+struct SocketGuard {
+    path: String,
+}
+
+impl Drop for SocketGuard {
+    fn drop(&mut self) {
+        debug!("Cleaning up socket file: {}", self.path);
+        let _ = fs::remove_file(&self.path);
+    }
+}
+
+fn get_config_path(custom_path: Option<PathBuf>) -> PathBuf {
+    custom_path.unwrap_or_else(crate::config::default_config_path)
+}
+
+pub async fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
+    let sock_path = socket_path();
+
+    if fs::metadata(&sock_path).is_ok() {
+        debug!("Removing stale socket file: {}", sock_path);
+        fs::remove_file(&sock_path)?;
     }
 
-    let state: SharedState = Arc::new(RwLock::new(AppState::default()));
-    let listener = UnixListener::bind(SOCKET_PATH)?;
+    #[cfg(feature = "mod-network")]
+    let (net_tx, net_rx) = watch::channel(Default::default());
+    #[cfg(feature = "mod-hardware")]
+    let (cpu_tx, cpu_rx) = watch::channel(Default::default());
+    #[cfg(feature = "mod-hardware")]
+    let (mem_tx, mem_rx) = watch::channel(Default::default());
+    #[cfg(feature = "mod-hardware")]
+    let (sys_tx, sys_rx) = watch::channel(Default::default());
+    #[cfg(feature = "mod-hardware")]
+    let (gpu_tx, gpu_rx) = watch::channel(Default::default());
+    #[cfg(feature = "mod-hardware")]
+    let (disks_tx, disks_rx) = watch::channel(Default::default());
+    #[cfg(feature = "mod-bt")]
+    let (bt_tx, bt_rx) = watch::channel(Default::default());
+    #[cfg(feature = "mod-audio")]
+    let (audio_tx, audio_rx) = watch::channel(Default::default());
+    #[cfg(feature = "mod-dbus")]
+    let (mpris_tx, mpris_rx) = watch::channel(Default::default());
+    #[cfg(feature = "mod-dbus")]
+    let (backlight_tx, backlight_rx) = watch::channel(Default::default());
+    #[cfg(feature = "mod-dbus")]
+    let (keyboard_tx, keyboard_rx) = watch::channel(Default::default());
+    #[cfg(feature = "mod-dbus")]
+    let (dnd_tx, dnd_rx) = watch::channel(Default::default());
+    let health = Arc::new(RwLock::new(HashMap::new()));
+    #[cfg(feature = "mod-bt")]
+    let (bt_force_tx, mut bt_force_rx) = mpsc::channel(1);
+    #[cfg(feature = "mod-audio")]
+    let (audio_cmd_tx, audio_cmd_rx) = mpsc::channel(8);
 
-    // 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)));
+    let receivers = AppReceivers {
+        #[cfg(feature = "mod-network")]
+        network: net_rx,
+        #[cfg(feature = "mod-hardware")]
+        cpu: cpu_rx,
+        #[cfg(feature = "mod-hardware")]
+        memory: mem_rx,
+        #[cfg(feature = "mod-hardware")]
+        sys: sys_rx,
+        #[cfg(feature = "mod-hardware")]
+        gpu: gpu_rx,
+        #[cfg(feature = "mod-hardware")]
+        disks: disks_rx,
+        #[cfg(feature = "mod-bt")]
+        bluetooth: bt_rx,
+        #[cfg(feature = "mod-audio")]
+        audio: audio_rx,
+        #[cfg(feature = "mod-dbus")]
+        mpris: mpris_rx,
+        #[cfg(feature = "mod-dbus")]
+        backlight: backlight_rx,
+        #[cfg(feature = "mod-dbus")]
+        keyboard: keyboard_rx,
+        #[cfg(feature = "mod-dbus")]
+        dnd: dnd_rx,
+        health: Arc::clone(&health),
+        #[cfg(feature = "mod-bt")]
+        bt_force_poll: bt_force_tx,
+        #[cfg(feature = "mod-audio")]
+        audio_cmd_tx,
+    };
+
+    let listener = UnixListener::bind(&sock_path)?;
+    let _guard = SocketGuard {
+        path: sock_path.clone(),
+    };
+
+    // Signal handling for graceful shutdown
+    let cancel_token = CancellationToken::new();
+    let token_clone = cancel_token.clone();
+    tokio::spawn(async move {
+        tokio::signal::ctrl_c().await.unwrap();
+        info!("Received shutdown signal, exiting...");
+        token_clone.cancel();
+    });
+
+    let resolved_config_path = get_config_path(config_path.clone());
+    let config = Arc::new(RwLock::new(crate::config::load_config(config_path.clone())));
+
+    // 0. Config Watcher (Hot Reload)
+    let watcher_config = Arc::clone(&config);
+    let watcher_path = resolved_config_path.clone();
+    tokio::spawn(async move {
+        let (ev_tx, mut ev_rx) = mpsc::channel(1);
+        let mut watcher = RecommendedWatcher::new(
+            move |res: notify::Result<Event>| {
+                if let Ok(event) = res
+                    && (event.kind.is_modify() || event.kind.is_create())
+                {
+                    let _ = ev_tx.blocking_send(());
+                }
+            },
+            NotifyConfig::default(),
+        )
+        .unwrap();
+
+        if let Some(parent) = watcher_path.parent() {
+            let _ = watcher.watch(parent, RecursiveMode::NonRecursive);
+        }
+
+        info!("Config watcher started on {:?}", watcher_path);
 
-    let poll_state = Arc::clone(&state);
-    thread::spawn(move || {
-        info!("Starting background polling thread");
-        let mut network_daemon = NetworkDaemon::new();
-        let mut hardware_daemon = HardwareDaemon::new();
         loop {
-            network_daemon.poll(Arc::clone(&poll_state));
-            hardware_daemon.poll(Arc::clone(&poll_state));
-            thread::sleep(Duration::from_secs(1));
+            tokio::select! {
+                _ = ev_rx.recv() => {
+                    // Debounce reloads
+                    sleep(Duration::from_millis(100)).await;
+                    while ev_rx.try_recv().is_ok() {}
+                    reload_config(&watcher_config, Some(watcher_path.clone())).await;
+                }
+            }
         }
     });
 
-    info!("Fluxo daemon successfully bound to socket: {}", SOCKET_PATH);
+    // 0.1 SIGHUP Handler
+    let hup_config = Arc::clone(&config);
+    let hup_path = resolved_config_path.clone();
+    tokio::spawn(async move {
+        use tokio::signal::unix::{SignalKind, signal};
+        let mut stream = signal(SignalKind::hangup()).unwrap();
+        loop {
+            stream.recv().await;
+            info!("Received SIGHUP, reloading config...");
+            reload_config(&hup_config, Some(hup_path.clone())).await;
+        }
+    });
 
-    for stream in listener.incoming() {
-        match stream {
-            Ok(mut stream) => {
-                let state_clone = Arc::clone(&state);
+    // 1. Network Task
+    #[cfg(feature = "mod-network")]
+    {
+        let token = cancel_token.clone();
+        let net_health = Arc::clone(&health);
+        tokio::spawn(async move {
+            info!("Starting Network polling task");
+            let mut daemon = NetworkDaemon::new();
+            loop {
+                if !crate::health::is_poll_in_backoff("net", &net_health).await {
+                    let res = daemon.poll(&net_tx).await;
+                    crate::health::handle_poll_result("net", res, &net_health).await;
+                }
+                tokio::select! {
+                    _ = token.cancelled() => break,
+                    _ = sleep(Duration::from_secs(1)) => {}
+                }
+            }
+            info!("Network task shut down.");
+        });
+    }
+
+    // 2. Fast Hardware Task (CPU, Mem, Load)
+    #[cfg(feature = "mod-hardware")]
+    {
+        let token = cancel_token.clone();
+        let hw_health = Arc::clone(&health);
+        tokio::spawn(async move {
+            info!("Starting Fast Hardware polling task");
+            let mut daemon = HardwareDaemon::new();
+            loop {
+                if !crate::health::is_poll_in_backoff("cpu", &hw_health).await {
+                    daemon.poll_fast(&cpu_tx, &mem_tx, &sys_tx).await;
+                }
+                tokio::select! {
+                    _ = token.cancelled() => break,
+                    _ = sleep(Duration::from_secs(1)) => {}
+                }
+            }
+            info!("Fast Hardware task shut down.");
+        });
+    }
+
+    // 3. Slow Hardware Task (GPU, Disks)
+    #[cfg(feature = "mod-hardware")]
+    {
+        let token = cancel_token.clone();
+        let slow_health = Arc::clone(&health);
+        tokio::spawn(async move {
+            info!("Starting Slow Hardware polling task");
+            let mut daemon = HardwareDaemon::new();
+            loop {
+                if !crate::health::is_poll_in_backoff("gpu", &slow_health).await {
+                    daemon.poll_slow(&gpu_tx, &disks_tx).await;
+                }
+                tokio::select! {
+                    _ = token.cancelled() => break,
+                    _ = sleep(Duration::from_secs(5)) => {}
+                }
+            }
+            info!("Slow Hardware task shut down.");
+        });
+    }
+
+    // 4. Bluetooth Task
+    #[cfg(feature = "mod-bt")]
+    {
+        let token = cancel_token.clone();
+        let bt_health = Arc::clone(&health);
+        let poll_config = Arc::clone(&config);
+        let poll_receivers = receivers.clone();
+        tokio::spawn(async move {
+            info!("Starting Bluetooth polling task");
+            let mut daemon = BtDaemon::new();
+            loop {
+                if !crate::health::is_poll_in_backoff("bt", &bt_health).await {
+                    let config = poll_config.read().await;
+                    daemon.poll(&bt_tx, &poll_receivers, &config).await;
+                }
+                tokio::select! {
+                    _ = token.cancelled() => break,
+                    _ = bt_force_rx.recv() => {},
+                    _ = sleep(Duration::from_secs(2)) => {}
+                }
+            }
+            info!("Bluetooth task shut down.");
+        });
+    }
+
+    // 5. Audio Thread (Event driven)
+    #[cfg(feature = "mod-audio")]
+    {
+        let audio_daemon = AudioDaemon::new();
+        audio_daemon.start(&audio_tx, audio_cmd_rx);
+    }
+
+    // 5.1 Backlight Thread (Event driven)
+    #[cfg(feature = "mod-dbus")]
+    {
+        let backlight_daemon = BacklightDaemon::new();
+        backlight_daemon.start(backlight_tx);
+    }
+
+    // 5.2 Keyboard Thread (Event driven)
+    #[cfg(feature = "mod-dbus")]
+    {
+        let keyboard_daemon = KeyboardDaemon::new();
+        keyboard_daemon.start(keyboard_tx);
+    }
+
+    // 5.3 DND Thread (Event driven)
+    #[cfg(feature = "mod-dbus")]
+    {
+        let dnd_daemon = DndDaemon::new();
+        dnd_daemon.start(dnd_tx);
+    }
+
+    // 5.4 MPRIS Thread
+    #[cfg(feature = "mod-dbus")]
+    {
+        let mpris_daemon = MprisDaemon::new();
+        mpris_daemon.start(mpris_tx);
+    }
+
+    // 6. Waybar Signaler Task
+    let signaler = WaybarSignaler::new();
+    let sig_config = Arc::clone(&config);
+    let sig_receivers = receivers.clone();
+    tokio::spawn(async move {
+        info!("Starting Waybar Signaler task");
+        signaler.run(sig_config, sig_receivers).await;
+    });
+
+    info!("Fluxo daemon successfully bound to socket: {}", sock_path);
+
+    loop {
+        tokio::select! {
+            _ = cancel_token.cancelled() => {
+                break;
+            }
+            res = listener.accept() => {
+                match res {
+                    Ok((mut stream, _)) => {
+                        let state_clone = receivers.clone();
                         let config_clone = Arc::clone(&config);
-                let cp_clone = config_path_clone.clone();
-                thread::spawn(move || {
-                    let mut reader = BufReader::new(stream.try_clone().unwrap());
+                        let cp_clone = config_path.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) {
+                            if let Err(e) = reader.read_line(&mut request).await {
                                 error!("Failed to read from IPC stream: {}", e);
                                 return;
                             }
 
                             let request = request.trim();
-                    if request.is_empty() { return; }
+                            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.");
-                            }
+                                    reload_config(&config_clone, cp_clone).await;
+                                    let _ = writer.write_all(b"{\"text\":\"ok\"}").await;
                                     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()) {
+                                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),
                 }
             }
+        }
+    }
 
+    info!("Daemon shutting down gracefully.");
     Ok(())
 }
 
-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();
-    };
+pub async fn reload_config(config_lock: &Arc<RwLock<Config>>, path: Option<PathBuf>) {
+    info!("Reloading configuration...");
+    let new_config = crate::config::load_config(path);
+    let mut lock = config_lock.write().await;
+    *lock = new_config;
+    info!("Configuration reloaded successfully.");
+}
 
-    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.get(0).unwrap_or(&"show")]),
-        "mic" => crate::modules::audio::AudioModule.run(&config, state, &["source", args.get(0).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))
-        },
-    };
+pub async fn evaluate_module_for_signaler(
+    module_name: &str,
+    state: &AppReceivers,
+    config: &Config,
+) -> Option<String> {
+    let args = crate::registry::signaler_default_args(module_name);
+    crate::registry::dispatch(module_name, config, state, args)
+        .await
+        .ok()
+        .and_then(|out| serde_json::to_string(&out).ok())
+}
+
+async fn handle_request(
+    module_name: &str,
+    args: &[&str],
+    state: &AppReceivers,
+    config_lock: &Arc<RwLock<Config>>,
+) -> String {
+    let (is_in_backoff, cached_output) = crate::health::check_backoff(module_name, state).await;
+
+    if is_in_backoff {
+        return crate::health::backoff_response(module_name, cached_output);
+    }
+
+    let config = config_lock.read().await;
+    let result = crate::registry::dispatch(module_name, &config, state, args).await;
+
+    crate::health::update_health(module_name, &result, state).await;
 
     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 err_out = crate::output::WaybarOutput {
-                text: format!("\u{200B}Error\u{200B}"),
-                tooltip: Some(e.to_string()),
-                class: Some("error".to_string()),
-                percentage: None,
-            };
-            serde_json::to_string(&err_out).unwrap_or_else(|_| "{}".to_string())
-        }
+        Err(e) => crate::health::error_response(module_name, &e, cached_output),
     }
 }

src/error.rs

@@ -0,0 +1,54 @@
+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("Bluetooth error: {0}")]
+    Bluetooth(String),
+
+    #[error("Network error: {0}")]
+    Network(String),
+
+    #[error("Hardware error: {0}")]
+    Hardware(String),
+
+    #[error("IO error: {0}")]
+    Io(#[from] std::io::Error),
+
+    #[error("Serialization error: {0}")]
+    Serialization(#[from] serde_json::Error),
+
+    #[error("Other error: {0}")]
+    Other(#[from] anyhow::Error),
+}
+
+impl FluxoError {
+    pub fn is_transient(&self) -> bool {
+        matches!(
+            self,
+            Self::Io(_)
+                | Self::System(_)
+                | Self::Bluetooth(_)
+                | Self::Network(_)
+                | Self::Hardware(_)
+                | Self::Module { .. }
+        )
+    }
+}
+
+pub type Result<T> = std::result::Result<T, FluxoError>;

src/health.rs

@@ -0,0 +1,135 @@
+use crate::output::WaybarOutput;
+use crate::state::{AppReceivers, ModuleHealth};
+use std::collections::HashMap;
+use std::sync::Arc;
+use tokio::sync::RwLock;
+use tokio::time::{Duration, Instant};
+use tracing::{debug, error, info, warn};
+
+/// Check if a module is in backoff (used by request handler).
+pub async fn check_backoff(
+    module_name: &str,
+    state: &AppReceivers,
+) -> (bool, Option<WaybarOutput>) {
+    let lock = state.health.read().await;
+    if let Some(health) = lock.get(module_name) {
+        let in_backoff = health
+            .backoff_until
+            .is_some_and(|until| Instant::now() < until);
+        (in_backoff, health.last_successful_output.clone())
+    } else {
+        (false, None)
+    }
+}
+
+/// Update health after a request dispatch (used by request handler).
+pub async fn update_health(
+    module_name: &str,
+    result: &Result<WaybarOutput, crate::error::FluxoError>,
+    state: &AppReceivers,
+) {
+    let mut lock = state.health.write().await;
+    let health = lock.entry(module_name.to_string()).or_default();
+    match result {
+        Ok(output) => {
+            health.consecutive_failures = 0;
+            health.backoff_until = None;
+            health.last_successful_output = Some(output.clone());
+        }
+        Err(e) => {
+            health.consecutive_failures += 1;
+            health.last_failure = Some(Instant::now());
+            if health.consecutive_failures >= 3 {
+                health.backoff_until = Some(Instant::now() + Duration::from_secs(30));
+                warn!(module = module_name, error = %e, "Module entered backoff state due to repeated failures");
+            }
+        }
+    }
+}
+
+/// Check if a polling daemon module is in backoff.
+pub async fn is_poll_in_backoff(
+    module_name: &str,
+    health_lock: &Arc<RwLock<HashMap<String, ModuleHealth>>>,
+) -> bool {
+    let lock = health_lock.read().await;
+    if let Some(health) = lock.get(module_name)
+        && let Some(until) = health.backoff_until
+    {
+        return Instant::now() < until;
+    }
+    false
+}
+
+/// Update health after a polling daemon result.
+pub async fn handle_poll_result(
+    module_name: &str,
+    result: crate::error::Result<()>,
+    health_lock: &Arc<RwLock<HashMap<String, ModuleHealth>>>,
+) {
+    let mut lock = health_lock.write().await;
+    let health = lock.entry(module_name.to_string()).or_default();
+
+    match result {
+        Ok(_) => {
+            if health.consecutive_failures > 0 {
+                info!(
+                    module = module_name,
+                    "Module recovered after {} failures", health.consecutive_failures
+                );
+            }
+            health.consecutive_failures = 0;
+            health.backoff_until = None;
+        }
+        Err(e) => {
+            health.consecutive_failures += 1;
+            health.last_failure = Some(Instant::now());
+
+            if !e.is_transient() {
+                health.backoff_until = Some(Instant::now() + Duration::from_secs(60));
+                error!(module = module_name, error = %e, "Fatal module error, entering long cooldown");
+            } else if health.consecutive_failures >= 3 {
+                let backoff_secs = 30 * (2u64.pow(health.consecutive_failures.saturating_sub(3)));
+                let backoff_secs = backoff_secs.min(3600);
+                health.backoff_until = Some(Instant::now() + Duration::from_secs(backoff_secs));
+                warn!(module = module_name, error = %e, backoff = backoff_secs, "Repeated transient failures, entering backoff");
+            } else {
+                debug!(module = module_name, error = %e, "Transient module failure (attempt {})", health.consecutive_failures);
+            }
+        }
+    }
+}
+
+pub fn backoff_response(module_name: &str, cached: Option<WaybarOutput>) -> String {
+    if let Some(mut cached) = cached {
+        let class = cached.class.unwrap_or_default();
+        cached.class = Some(format!("{} warning", class).trim().to_string());
+        return serde_json::to_string(&cached).unwrap_or_else(|_| "{}".to_string());
+    }
+    format!(
+        "{{\"text\":\"\u{200B}Cooling down ({})\u{200B}\",\"class\":\"error\"}}",
+        module_name
+    )
+}
+
+pub fn error_response(
+    module_name: &str,
+    e: &crate::error::FluxoError,
+    cached: Option<WaybarOutput>,
+) -> String {
+    if let Some(mut cached) = cached {
+        let class = cached.class.unwrap_or_default();
+        cached.class = Some(format!("{} warning", class).trim().to_string());
+        return serde_json::to_string(&cached).unwrap_or_else(|_| "{}".to_string());
+    }
+
+    let error_msg = e.to_string();
+    error!(module = module_name, error = %error_msg, "Module execution failed");
+    let err_out = WaybarOutput {
+        text: "\u{200B}Error\u{200B}".to_string(),
+        tooltip: Some(error_msg),
+        class: Some("error".to_string()),
+        percentage: None,
+    };
+    serde_json::to_string(&err_out).unwrap_or_else(|_| "{}".to_string())
+}

src/ipc.rs

@@ -1,12 +1,21 @@
 use std::io::{Read, Write};
 use std::os::unix::net::UnixStream;
+use std::time::Duration;
 use tracing::debug;
 
-pub const SOCKET_PATH: &str = "/tmp/fluxo.sock";
+pub fn socket_path() -> String {
+    if let Ok(dir) = std::env::var("XDG_RUNTIME_DIR") {
+        format!("{}/fluxo.sock", dir)
+    } else {
+        "/tmp/fluxo.sock".to_string()
+    }
+}
 
-pub fn request_data(module: &str, args: &[String]) -> anyhow::Result<String> {
-    debug!(module, ?args, "Connecting to daemon socket: {}", SOCKET_PATH);
-    let mut stream = UnixStream::connect(SOCKET_PATH)?;
+pub fn request_data(module: &str, args: &[&str]) -> anyhow::Result<String> {
+    let sock = socket_path();
+    debug!(module, ?args, "Connecting to daemon socket: {}", sock);
+    let mut stream = UnixStream::connect(&sock)?;
+    stream.set_read_timeout(Some(Duration::from_secs(5)))?;
 
     // Send module and args
     let mut request = module.to_string();

src/main.rs

@@ -1,8 +1,12 @@
 mod config;
 mod daemon;
+mod error;
+mod health;
 mod ipc;
 mod modules;
 mod output;
+mod registry;
+mod signaler;
 mod state;
 mod utils;
 
@@ -10,14 +14,21 @@ use clap::{Parser, Subcommand};
 use std::path::PathBuf;
 use std::process;
 use tracing::{error, info};
-use tracing_subscriber::{fmt, prelude::*, EnvFilter};
+use tracing_subscriber::{EnvFilter, fmt, prelude::*};
 
 #[derive(Parser)]
 #[command(name = "fluxo")]
 #[command(about = "A high-performance daemon/client for Waybar custom modules", long_about = None)]
 struct Cli {
     #[command(subcommand)]
-    command: Commands,
+    command: Option<Commands>,
+
+    /// Module name to query or interact with
+    module: Option<String>,
+
+    /// Arguments to pass to the module
+    #[arg(trailing_var_arg = true)]
+    args: Vec<String>,
 }
 
 #[derive(Subcommand)]
@@ -30,56 +41,6 @@ enum Commands {
     },
     /// Reload the daemon configuration
     Reload,
-    /// Network speed module
-    #[command(alias = "network")]
-    Net,
-    /// CPU usage and temp module
-    Cpu,
-    /// Memory usage module
-    #[command(alias = "memory")]
-    Mem,
-    /// Disk usage module (path defaults to /)
-    Disk {
-        #[arg(default_value = "/")]
-        path: String,
-    },
-    /// Storage pool aggregate module (e.g., btrfs)
-    #[command(alias = "btrfs")]
-    Pool {
-        #[arg(default_value = "btrfs")]
-        kind: String,
-    },
-    /// Audio volume (sink) control
-    Vol {
-        /// Cycle to the next available output device
-        #[arg(short, long)]
-        cycle: bool,
-    },
-    /// Microphone (source) control
-    Mic {
-        /// Cycle to the next available input device
-        #[arg(short, long)]
-        cycle: bool,
-    },
-    /// GPU usage, VRAM, and temp module
-    Gpu,
-    /// System load average and uptime
-    Sys,
-    /// Bluetooth audio device status
-    #[command(alias = "bluetooth")]
-    Bt {
-        #[arg(default_value = "show")]
-        action: String,
-    },
-    /// Pixel Buds Pro ANC and Battery
-    Buds {
-        #[arg(default_value = "show")]
-        action: String,
-    },
-    /// System power and battery status
-    Power,
-    /// Hyprland gamemode status
-    Game,
 }
 
 fn main() {
@@ -90,87 +51,113 @@ fn main() {
 
     let cli = Cli::parse();
 
-    match &cli.command {
+    if let Some(command) = &cli.command {
+        match 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);
                 }
             }
-        Commands::Reload => {
-            match ipc::request_data("reload", &[]) {
+            Commands::Reload => match ipc::request_data("reload", &[]) {
                 Ok(_) => info!("Reload signal sent to daemon"),
                 Err(e) => {
                     error!("Failed to send reload signal: {}", e);
                     process::exit(1);
                 }
+            },
         }
+        return;
     }
-        Commands::Net => handle_ipc_response(ipc::request_data("net", &[])),
-        Commands::Cpu => handle_ipc_response(ipc::request_data("cpu", &[])),
-        Commands::Mem => handle_ipc_response(ipc::request_data("mem", &[])),
-        Commands::Disk { path } => handle_ipc_response(ipc::request_data("disk", &[path.clone()])),
-        Commands::Pool { kind } => handle_ipc_response(ipc::request_data("pool", &[kind.clone()])),
-        Commands::Vol { cycle } => {
-            let action = if *cycle { "cycle" } else { "show" };
-            handle_ipc_response(ipc::request_data("vol", &[action.to_string()]));
-        }
-        Commands::Mic { cycle } => {
-            let action = if *cycle { "cycle" } else { "show" };
-            handle_ipc_response(ipc::request_data("mic", &[action.to_string()]));
-        }
-        Commands::Gpu => handle_ipc_response(ipc::request_data("gpu", &[])),
-        Commands::Sys => handle_ipc_response(ipc::request_data("sys", &[])),
-        Commands::Bt { action } => {
-            if action == "menu" {
-                // Client-side execution of the menu
+
+    if let Some(module) = &cli.module {
+        // Special case for client-side Bluetooth menu which requires UI
+        #[cfg(feature = "mod-bt")]
+        if module == "bt" && cli.args.first().map(|s| s.as_str()) == Some("menu") {
             let config = config::load_config(None);
-                
-                let devices_out = std::process::Command::new("bluetoothctl")
-                    .args(["devices"])
-                    .output()
-                    .expect("Failed to run bluetoothctl");
-                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();
-                        if parts.len() == 3 {
-                            items.push(format!("{} ({})", parts[2], parts[1]));
+
+            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());
+
+            if let Ok(json_str) = ipc::request_data("bt", &["menu_data"])
+                && let Ok(val) = serde_json::from_str::<serde_json::Value>(&json_str)
+                && let Some(devices_str) = val.get("text").and_then(|t| t.as_str())
+            {
+                for line in devices_str.lines() {
+                    if !line.is_empty() {
+                        items.push(line.to_string());
                     }
                 }
             }
 
             if !items.is_empty() {
-                    if let Ok(selected) = utils::show_menu("Connect BT: ", &items, &config.general.menu_command) {
-                        if let Some(mac_start) = selected.rfind('(') {
-                            if let Some(mac_end) = selected.rfind(')') {
+                if let Ok(selected) =
+                    utils::show_menu("BT Menu: ", &items, &config.general.menu_command)
+                {
+                    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();
-                            }
+                        handle_ipc_response(ipc::request_data("bt", &["connect", mac]));
                     }
                 }
             } else {
-                    info!("No paired Bluetooth devices found.");
+                info!("No Bluetooth options found.");
             }
             return;
         }
-            handle_ipc_response(ipc::request_data("bt", &[action.clone()]));
-        }
-        Commands::Buds { action } => handle_ipc_response(ipc::request_data("buds", &[action.clone()])),
-        Commands::Power => handle_ipc_response(ipc::request_data("power", &[])),
-        Commands::Game => handle_ipc_response(ipc::request_data("game", &[])),
+
+        // Generic module dispatch
+        // Translate module-specific shorthand targets
+        let (actual_module, actual_args) = if module == "vol" {
+            let mut new_args = vec!["sink".to_string()];
+            new_args.extend(cli.args.clone());
+            ("vol".to_string(), new_args)
+        } else if module == "mic" {
+            let mut new_args = vec!["source".to_string()];
+            new_args.extend(cli.args.clone());
+            ("vol".to_string(), new_args)
+        } else {
+            (module.clone(), cli.args.clone())
+        };
+
+        let args_ref: Vec<&str> = actual_args.iter().map(|s| s.as_str()).collect();
+        handle_ipc_response(ipc::request_data(&actual_module, &args_ref));
+    } else {
+        println!("Please specify a module or command. See --help.");
+        process::exit(1);
     }
 }
 
 fn handle_ipc_response(response: anyhow::Result<String>) {
     match response {
-        Ok(json_str) => {
-            match serde_json::from_str::<serde_json::Value>(&json_str) {
+        Ok(json_str) => match serde_json::from_str::<serde_json::Value>(&json_str) {
             Ok(mut val) => {
                 if let Some(text) = val.get_mut("text").and_then(|t| t.as_str()) {
                     let processed_text = if text.contains('<') {
@@ -185,8 +172,7 @@ fn handle_ipc_response(response: anyhow::Result<String>) {
                 println!("{}", serde_json::to_string(&val).unwrap());
             }
             Err(_) => println!("{}", json_str),
-            }
-        }
+        },
         Err(e) => {
             let err_out = output::WaybarOutput {
                 text: format!("\u{200B}Daemon offline ({})\u{200B}", e),

src/modules/audio.rs

@@ -1,56 +1,393 @@
 use crate::config::Config;
+use crate::error::{FluxoError, Result};
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
-use crate::utils::{format_template, TokenValue};
-use anyhow::{Result, anyhow};
-use std::process::Command;
+use crate::state::{AppReceivers, AudioState};
+use crate::utils::{TokenValue, format_template};
+use libpulse_binding::callbacks::ListResult;
+use libpulse_binding::context::subscribe::{Facility, InterestMaskSet};
+use libpulse_binding::context::{Context, FlagSet as ContextFlag};
+use libpulse_binding::mainloop::threaded::Mainloop as ThreadedMainloop;
+use libpulse_binding::volume::Volume;
+use tokio::sync::{mpsc, watch};
+use tracing::error;
+
+pub enum AudioCommand {
+    ChangeVolume {
+        is_sink: bool,
+        step_val: u32,
+        is_up: bool,
+    },
+    ToggleMute {
+        is_sink: bool,
+    },
+    CycleDevice {
+        is_sink: bool,
+    },
+}
+
+pub struct AudioDaemon;
+
+impl AudioDaemon {
+    pub fn new() -> Self {
+        Self
+    }
+
+    pub fn start(
+        &self,
+        state_tx: &watch::Sender<AudioState>,
+        mut cmd_rx: mpsc::Receiver<AudioCommand>,
+    ) {
+        let state_tx = state_tx.clone();
+
+        std::thread::spawn(move || {
+            let mut mainloop =
+                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_tx);
+
+            // Subscribe to events
+            let interest =
+                InterestMaskSet::SINK | InterestMaskSet::SOURCE | InterestMaskSet::SERVER;
+            context.subscribe(interest, |_| {});
+
+            let (tx, rx) = std::sync::mpsc::channel();
+            let tx_cb = tx.clone();
+
+            context.set_subscribe_callback(Some(Box::new(move |facility, _operation, _index| {
+                match facility {
+                    Some(Facility::Sink) | Some(Facility::Source) | Some(Facility::Server) => {
+                        let _ = tx_cb.send(());
+                    }
+                    _ => {}
+                }
+            })));
+
+            mainloop.unlock();
+
+            loop {
+                if let Ok(cmd) = cmd_rx.try_recv() {
+                    mainloop.lock();
+                    match cmd {
+                        AudioCommand::ChangeVolume {
+                            is_sink,
+                            step_val,
+                            is_up,
+                        } => {
+                            let current = state_tx.borrow().clone();
+                            let (name, mut vol, channels) = if is_sink {
+                                (
+                                    current.sink.name.clone(),
+                                    current.sink.volume,
+                                    current.sink.channels,
+                                )
+                            } else {
+                                (
+                                    current.source.name.clone(),
+                                    current.source.volume,
+                                    current.source.channels,
+                                )
+                            };
+
+                            if is_up {
+                                vol = vol.saturating_add(step_val as u8).min(150);
+                            } else {
+                                vol = vol.saturating_sub(step_val as u8);
+                            }
+
+                            let pulse_vol = Volume(
+                                (vol as f64 / 100.0 * Volume::NORMAL.0 as f64).round() as u32,
+                            );
+                            let mut cvol = libpulse_binding::volume::ChannelVolumes::default();
+                            cvol.set(channels.max(1), pulse_vol);
+
+                            if is_sink {
+                                context
+                                    .introspect()
+                                    .set_sink_volume_by_name(&name, &cvol, None);
+                            } else {
+                                context
+                                    .introspect()
+                                    .set_source_volume_by_name(&name, &cvol, None);
+                            }
+                        }
+                        AudioCommand::ToggleMute { is_sink } => {
+                            let current = state_tx.borrow().clone();
+                            let (name, muted) = if is_sink {
+                                (current.sink.name.clone(), current.sink.muted)
+                            } else {
+                                (current.source.name.clone(), current.source.muted)
+                            };
+
+                            if is_sink {
+                                context
+                                    .introspect()
+                                    .set_sink_mute_by_name(&name, !muted, None);
+                            } else {
+                                context
+                                    .introspect()
+                                    .set_source_mute_by_name(&name, !muted, None);
+                            }
+                        }
+                        AudioCommand::CycleDevice { is_sink } => {
+                            let current = state_tx.borrow().clone();
+                            let current_name = if is_sink {
+                                current.sink.name.clone()
+                            } else {
+                                current.source.name.clone()
+                            };
+
+                            let devices = if is_sink {
+                                &current.available_sinks
+                            } else {
+                                &current.available_sources
+                            };
+                            if !devices.is_empty() {
+                                let current_idx =
+                                    devices.iter().position(|d| d == &current_name).unwrap_or(0);
+                                let next_idx = (current_idx + 1) % devices.len();
+                                let next_dev = &devices[next_idx];
+
+                                if is_sink {
+                                    context.set_default_sink(next_dev, |_| {});
+                                } else {
+                                    context.set_default_source(next_dev, |_| {});
+                                }
+                            }
+                        }
+                    }
+                    mainloop.unlock();
+                    let _ = tx.send(());
+                }
+
+                let _ = rx.recv_timeout(Duration::from_millis(50));
+                while rx.try_recv().is_ok() {}
+
+                mainloop.lock();
+
+                // Fetch data and update available sinks/sources
+                let _ = fetch_audio_data_sync(&mut context, &state_tx);
+
+                mainloop.unlock();
+            }
+        });
+    }
+}
+
+use std::time::Duration;
+
+fn fetch_audio_data_sync(
+    context: &mut Context,
+    state_tx: &watch::Sender<AudioState>,
+) -> Result<()> {
+    // We fetch all sinks and sources, and also server info to know defaults.
+    // The order doesn't strictly matter as long as we update correctly.
+
+    let tx_server = state_tx.clone();
+    context.introspect().get_server_info(move |info| {
+        let mut current = tx_server.borrow().clone();
+        current.sink.name = info
+            .default_sink_name
+            .as_ref()
+            .map(|s| s.to_string())
+            .unwrap_or_default();
+        current.source.name = info
+            .default_source_name
+            .as_ref()
+            .map(|s| s.to_string())
+            .unwrap_or_default();
+        let _ = tx_server.send(current);
+    });
+
+    let tx_sink = state_tx.clone();
+    context.introspect().get_sink_info_list(move |res| {
+        let mut current = tx_sink.borrow().clone();
+        match res {
+            ListResult::Item(item) => {
+                if let Some(name) = item.name.as_ref() {
+                    let name_str = name.to_string();
+                    if !current.available_sinks.contains(&name_str) {
+                        current.available_sinks.push(name_str);
+                    }
+                }
+
+                let is_default = item
+                    .name
+                    .as_ref()
+                    .map(|s| s.as_ref() == current.sink.name)
+                    .unwrap_or(false);
+                if is_default {
+                    current.sink.description = item
+                        .description
+                        .as_ref()
+                        .map(|s| s.to_string())
+                        .unwrap_or_default();
+                    current.sink.volume = ((item.volume.avg().0 as f64 / Volume::NORMAL.0 as f64)
+                        * 100.0)
+                        .round() as u8;
+                    current.sink.muted = item.mute;
+                    current.sink.channels = item.volume.len();
+                }
+                let _ = tx_sink.send(current);
+            }
+            ListResult::End => {
+                // Clear the list on End so it rebuilds fresh next time
+                current.available_sinks.clear();
+                let _ = tx_sink.send(current);
+            }
+            ListResult::Error => {}
+        }
+    });
+
+    let tx_source = state_tx.clone();
+    context.introspect().get_source_info_list(move |res| {
+        let mut current = tx_source.borrow().clone();
+        match res {
+            ListResult::Item(item) => {
+                if let Some(name) = item.name.as_ref() {
+                    let name_str = name.to_string();
+                    // PulseAudio includes monitor sources, ignore them if we want to
+                    if !name_str.contains(".monitor")
+                        && !current.available_sources.contains(&name_str)
+                    {
+                        current.available_sources.push(name_str);
+                    }
+                }
+
+                let is_default = item
+                    .name
+                    .as_ref()
+                    .map(|s| s.as_ref() == current.source.name)
+                    .unwrap_or(false);
+                if is_default {
+                    current.source.description = item
+                        .description
+                        .as_ref()
+                        .map(|s| s.to_string())
+                        .unwrap_or_default();
+                    current.source.volume = ((item.volume.avg().0 as f64 / Volume::NORMAL.0 as f64)
+                        * 100.0)
+                        .round() as u8;
+                    current.source.muted = item.mute;
+                    current.source.channels = item.volume.len();
+                }
+                let _ = tx_source.send(current);
+            }
+            ListResult::End => {
+                // Clear the list on End so it rebuilds fresh next time
+                current.available_sources.clear();
+                let _ = tx_source.send(current);
+            }
+            ListResult::Error => {}
+        }
+    });
+
+    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: &AppReceivers,
+        args: &[&str],
+    ) -> Result<WaybarOutput> {
         let target_type = args.first().unwrap_or(&"sink");
         let action = args.get(1).unwrap_or(&"show");
+        let step = args.get(2).unwrap_or(&"5");
 
         match *action {
+            "up" => {
+                self.change_volume(state, target_type, step, true).await?;
+                Ok(WaybarOutput::default())
+            }
+            "down" => {
+                self.change_volume(state, target_type, step, false).await?;
+                Ok(WaybarOutput::default())
+            }
+            "mute" => {
+                self.toggle_mute(state, target_type).await?;
+                Ok(WaybarOutput::default())
+            }
             "cycle" => {
-                self.cycle_device(target_type)?;
-                return Ok(WaybarOutput {
-                    text: String::new(),
-                    tooltip: None,
-                    class: None,
-                    percentage: None,
-                });
-            }
-            "show" | _ => {
-                self.get_status(config, target_type)
+                self.cycle_device(state, target_type).await?;
+                Ok(WaybarOutput::default())
             }
+            "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: &AppReceivers,
+        target_type: &str,
+    ) -> Result<WaybarOutput> {
+        let audio_state = state.audio.borrow().clone();
 
-        let output = Command::new("wpctl")
-            .args(["get-volume", target])
-            .output()?;
-        let stdout = String::from_utf8_lossy(&output.stdout);
+        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.trim().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()
@@ -58,31 +395,43 @@ impl AudioModule {
 
         let (text, class) = if muted {
             let icon = if target_type == "sink" { "" } else { "" };
-            let format_str = if target_type == "sink" { &config.audio.format_sink_muted } else { &config.audio.format_source_muted };
+            let format_str = if target_type == "sink" {
+                &config.audio.format_sink_muted
+            } else {
+                &config.audio.format_source_muted
+            };
             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 { "" }
-                else if display_vol <= 60 { "" }
-                else { "" }
+                if volume <= 30 {
+                    ""
+                } else if volume <= 60 {
+                    ""
+                } else {
+                    ""
+                }
             } else {
                 ""
             };
-            let format_str = if target_type == "sink" { &config.audio.format_sink_unmuted } else { &config.audio.format_source_unmuted };
+            let format_str = if target_type == "sink" {
+                &config.audio.format_sink_unmuted
+            } else {
+                &config.audio.format_source_unmuted
+            };
             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")
         };
@@ -91,78 +440,45 @@ 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_output = Command::new("pactl").arg("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 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_output = Command::new("pactl").args(["list", list_cmd]).output()?;
-        let list_stdout = String::from_utf8_lossy(&list_output.stdout);
-
-        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<()> {
-        let list_cmd = if target_type == "sink" { "sinks" } else { "sources" };
-        let output = Command::new("pactl").args(["list", "short", list_cmd]).output()?;
-        let stdout = String::from_utf8_lossy(&output.stdout);
-
-        let devices: Vec<String> = stdout.lines()
-            .filter_map(|l| {
-                let parts: Vec<&str> = l.split_whitespace().collect();
-                if parts.len() >= 2 {
-                    let name = parts[1].to_string();
-                    if target_type == "source" && name.contains(".monitor") {
-                        None
-                    } else {
-                        Some(name)
-                    }
-                } else {
-                    None
-                }
+    async fn change_volume(
+        &self,
+        state: &AppReceivers,
+        target_type: &str,
+        step: &str,
+        is_up: bool,
+    ) -> Result<()> {
+        let is_sink = target_type == "sink";
+        let step_val: u32 = step.parse().unwrap_or(5);
+        let _ = state
+            .audio_cmd_tx
+            .send(AudioCommand::ChangeVolume {
+                is_sink,
+                step_val,
+                is_up,
             })
-            .collect();
+            .await;
+        Ok(())
+    }
 
-        if devices.is_empty() { return Ok(()); }
-
-        let info_output = Command::new("pactl").arg("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))
-            .and_then(|l| l.split(':').nth(1))
-            .map(|s| s.trim())
-            .unwrap_or("");
-
-        let current_index = devices.iter().position(|d| d == current_dev).unwrap_or(0);
-        let next_index = (current_index + 1) % devices.len();
-        let next_dev = &devices[next_index];
-
-        let set_cmd = if target_type == "sink" { "set-default-sink" } else { "set-default-source" };
-        Command::new("pactl").args([set_cmd, next_dev]).status()?;
+    async fn toggle_mute(&self, state: &AppReceivers, target_type: &str) -> Result<()> {
+        let is_sink = target_type == "sink";
+        let _ = state
+            .audio_cmd_tx
+            .send(AudioCommand::ToggleMute { is_sink })
+            .await;
+        Ok(())
+    }
 
+    async fn cycle_device(&self, state: &AppReceivers, target_type: &str) -> Result<()> {
+        let is_sink = target_type == "sink";
+        let _ = state
+            .audio_cmd_tx
+            .send(AudioCommand::CycleDevice { is_sink })
+            .await;
         Ok(())
     }
 }

src/modules/backlight.rs

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

src/modules/bt.rs

@@ -1,119 +0,0 @@
-use crate::config::Config;
-use crate::modules::WaybarModule;
-use crate::output::WaybarOutput;
-use crate::state::SharedState;
-use crate::utils::{format_template, TokenValue};
-use anyhow::Result;
-use std::process::Command;
-
-pub struct BtModule;
-
-impl WaybarModule for BtModule {
-    fn run(&self, config: &Config, _state: &SharedState, args: &[&str]) -> Result<WaybarOutput> {
-        let action = args.first().unwrap_or(&"show");
-
-        if *action == "disconnect" {
-            if let Some(mac) = find_audio_device() {
-                let _ = Command::new("bluetoothctl").args(["disconnect", &mac]).output();
-            }
-            return Ok(WaybarOutput {
-                text: String::new(),
-                tooltip: None,
-                class: None,
-                percentage: None,
-            });
-        }
-
-        if let Ok(output) = Command::new("bluetoothctl").arg("show").output() {
-            let stdout = String::from_utf8_lossy(&output.stdout);
-            if stdout.contains("Powered: no") {
-                return Ok(WaybarOutput {
-                    text: config.bt.format_disabled.clone(),
-                    tooltip: Some("Bluetooth Disabled".to_string()),
-                    class: Some("disabled".to_string()),
-                    percentage: None,
-                });
-            }
-        }
-
-        if let Some(mac) = find_audio_device() {
-            let info_output = Command::new("bluetoothctl").args(["info", &mac]).output()?;
-            let info = String::from_utf8_lossy(&info_output.stdout);
-
-            let mut alias = mac.clone();
-            let mut battery = None;
-            let mut trusted = "no";
-
-            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";
-                }
-            }
-
-            let tooltip = format!(
-                "{} | MAC: {}\nTrusted: {} | Bat: {}",
-                alias,
-                mac,
-                trusted,
-                battery.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,
-            })
-        } else {
-            Ok(WaybarOutput {
-                text: config.bt.format_disconnected.clone(),
-                tooltip: Some("Bluetooth On (Disconnected)".to_string()),
-                class: Some("disconnected".to_string()),
-                percentage: None,
-            })
-        }
-    }
-}
-
-fn find_audio_device() -> Option<String> {
-    if let Ok(output) = Command::new("pactl").arg("get-default-sink").output() {
-        let sink = String::from_utf8_lossy(&output.stdout).trim().to_string();
-        if sink.starts_with("bluez_output.") {
-            let parts: Vec<&str> = sink.split('.').collect();
-            if parts.len() >= 2 {
-                return Some(parts[1].replace('_', ":"));
-            }
-        }
-    }
-
-    if let Ok(output) = Command::new("bluetoothctl").args(["devices", "Connected"]).output() {
-        let stdout = String::from_utf8_lossy(&output.stdout);
-        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) = Command::new("bluetoothctl").args(["info", mac]).output() {
-                        let info_str = String::from_utf8_lossy(&info.stdout);
-                        if info_str.contains("0000110b-0000-1000-8000-00805f9b34fb") {
-                            return Some(mac.to_string());
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    None
-}

src/modules/bt/buds.rs

@@ -0,0 +1,141 @@
+use crate::config::Config;
+use crate::error::{FluxoError, Result as FluxoResult};
+use crate::modules::bt::maestro::BudsCommand;
+use crate::state::AppReceivers;
+use crate::utils::TokenValue;
+use futures::future::BoxFuture;
+
+pub trait BtPlugin: Send + Sync {
+    fn name(&self) -> &str;
+    fn can_handle(&self, alias: &str, mac: &str) -> bool;
+    fn get_data(
+        &self,
+        config: &Config,
+        state: &AppReceivers,
+        mac: &str,
+    ) -> BoxFuture<'static, FluxoResult<Vec<(String, TokenValue)>>>;
+    fn get_modes(
+        &self,
+        mac: &str,
+        state: &AppReceivers,
+    ) -> BoxFuture<'static, FluxoResult<Vec<String>>>;
+    fn set_mode(
+        &self,
+        mode: &str,
+        mac: &str,
+        state: &AppReceivers,
+    ) -> BoxFuture<'static, FluxoResult<()>>;
+    fn cycle_mode(&self, mac: &str, state: &AppReceivers) -> BoxFuture<'static, FluxoResult<()>>;
+}
+
+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,
+        _config: &Config,
+        state: &AppReceivers,
+        mac: &str,
+    ) -> BoxFuture<'static, FluxoResult<Vec<(String, TokenValue)>>> {
+        let mac = mac.to_string();
+        let state = state.clone();
+        Box::pin(async move {
+            let maestro = crate::modules::bt::maestro::get_maestro(&state);
+            maestro.ensure_task(&mac);
+            let status = maestro.get_status(&mac);
+
+            if let Some(err) = status.error {
+                return Err(FluxoError::Module {
+                    module: "bt.buds",
+                    message: 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,
+        _state: &AppReceivers,
+    ) -> BoxFuture<'static, FluxoResult<Vec<String>>> {
+        Box::pin(async move {
+            Ok(vec![
+                "active".to_string(),
+                "aware".to_string(),
+                "off".to_string(),
+            ])
+        })
+    }
+
+    fn set_mode(
+        &self,
+        mode: &str,
+        mac: &str,
+        state: &AppReceivers,
+    ) -> BoxFuture<'static, FluxoResult<()>> {
+        let mode = mode.to_string();
+        let mac = mac.to_string();
+        let state = state.clone();
+        Box::pin(async move {
+            crate::modules::bt::maestro::get_maestro(&state)
+                .send_command(&mac, BudsCommand::SetAnc(mode))
+                .map_err(|e: anyhow::Error| FluxoError::Module {
+                    module: "bt.buds",
+                    message: e.to_string(),
+                })
+        })
+    }
+
+    fn cycle_mode(&self, mac: &str, state: &AppReceivers) -> BoxFuture<'static, FluxoResult<()>> {
+        let mac = mac.to_string();
+        let state = state.clone();
+        Box::pin(async move {
+            let status = crate::modules::bt::maestro::get_maestro(&state).get_status(&mac);
+            let next_mode = match status.anc_state.as_str() {
+                "active" => "aware",
+                "aware" => "off",
+                _ => "active",
+            };
+            crate::modules::bt::maestro::get_maestro(&state)
+                .send_command(&mac, BudsCommand::SetAnc(next_mode.to_string()))
+                .map_err(|e: anyhow::Error| FluxoError::Module {
+                    module: "bt.buds",
+                    message: e.to_string(),
+                })
+        })
+    }
+}

src/modules/bt/maestro.rs

@@ -0,0 +1,362 @@
+use crate::state::AppReceivers;
+use anyhow::{Context, Result};
+use futures::StreamExt;
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex, OnceLock};
+use std::time::{Duration, Instant};
+use tokio::sync::mpsc;
+use tracing::{debug, error, info, warn};
+
+// Maestro imports
+use maestro::protocol::codec::Codec;
+use maestro::pwrpc::client::Client;
+use maestro::service::MaestroService;
+use maestro::service::settings::{self, SettingValue};
+
+#[derive(Clone, Default)]
+pub struct BudsStatus {
+    pub left_battery: Option<u8>,
+    pub right_battery: Option<u8>,
+    pub case_battery: Option<u8>,
+    pub anc_state: String,
+    #[allow(dead_code)]
+    pub last_update: Option<Instant>,
+    pub error: Option<String>,
+}
+
+pub enum BudsCommand {
+    SetAnc(String),
+}
+
+pub enum ManagerCommand {
+    EnsureTask(String),
+    SendCommand(String, BudsCommand),
+}
+
+pub struct MaestroManager {
+    statuses: Arc<Mutex<HashMap<String, BudsStatus>>>,
+    management_tx: mpsc::UnboundedSender<ManagerCommand>,
+}
+
+impl MaestroManager {
+    pub fn new(state: AppReceivers) -> Self {
+        let (tx, mut rx) = mpsc::unbounded_channel::<ManagerCommand>();
+        let statuses = Arc::new(Mutex::new(HashMap::new()));
+        let statuses_clone = Arc::clone(&statuses);
+        let state_clone = state.clone();
+
+        // 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);
+                                        let state_inner = state_clone.clone();
+
+                                        tokio::task::spawn_local(async move {
+                                            if let Err(e) = buds_task(&mac_clone, st_clone, buds_rx, state_inner).await {
+                                                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,
+        }
+    }
+
+    pub fn get_status(&self, mac: &str) -> BudsStatus {
+        let statuses = self.statuses.lock().unwrap();
+        statuses.get(mac).cloned().unwrap_or_default()
+    }
+
+    pub fn ensure_task(&self, mac: &str) {
+        let _ = self
+            .management_tx
+            .send(ManagerCommand::EnsureTask(mac.to_string()));
+    }
+
+    pub 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>,
+    state: AppReceivers,
+) -> Result<()> {
+    info!("Starting native Maestro connection task for {}", mac);
+
+    loop {
+        let addr: bluer::Address = match mac.parse() {
+            Ok(a) => a,
+            Err(e) => {
+                error!("Failed to parse MAC address {}: {}", mac, e);
+                return Err(e.into());
+            }
+        };
+        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
+        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
+        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;
+            }
+        };
+
+        tokio::spawn(async move {
+            if let Err(e) = client.run().await {
+                error!("Maestro client loop error: {}", e);
+            }
+        });
+
+        let mut service = MaestroService::new(handle, channel);
+
+        // Update health
+        {
+            let mut lock = state.health.write().await;
+            let health = lock.entry("bt.buds".to_string()).or_default();
+            health.consecutive_failures = 0;
+            health.backoff_until = None;
+        }
+
+        // Query initial ANC state
+        if let Ok(val) = service
+            .read_setting_var(settings::SettingId::CurrentAncrState)
+            .await
+            && let SettingValue::CurrentAncrState(anc_state) = val
+        {
+            let mut lock = statuses.lock().unwrap();
+            let status = lock.entry(mac.to_string()).or_default();
+            status.anc_state = anc_state_to_string(&anc_state);
+            status.last_update = Some(Instant::now());
+        }
+
+        let mut runtime_info_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 = runtime_info_call.stream();
+
+        let mut settings_changes_call = match service.subscribe_to_settings_changes() {
+            Ok(s) => s,
+            Err(e) => {
+                error!("Failed to subscribe to settings changes for {}: {}", mac, e);
+                continue;
+            }
+        };
+
+        let mut settings_changes = settings_changes_call.stream();
+
+        debug!("Subscribed to status and settings 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);
+
+                            {
+                                let mut lock = statuses.lock().unwrap();
+                                let status = lock.entry(mac.to_string()).or_default();
+                                status.anc_state = mode.clone();
+                                status.last_update = Some(Instant::now());
+                            }
+
+                            if let Err(e) = service.write_setting(val).await {
+                                error!("Failed to write ANC setting for {}: {}", mac, e);
+                            }
+                        }
+                        None => return Ok(()),
+                    }
+                }
+                Some(res) = runtime_info.next() => {
+                    match res {
+                        Ok(info) => {
+                            let mut lock = statuses.lock().unwrap();
+                            let status = lock.entry(mac.to_string()).or_default();
+                            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);
+                            }
+                        }
+                        Err(e) => {
+                            warn!("Runtime info stream error for {}: {}", mac, e);
+                            break;
+                        }
+                    }
+                }
+                Some(res) = settings_changes.next() => {
+                    if let Ok(change) = res {
+                        use maestro::protocol::types::settings_rsp::ValueOneof as RspOneof;
+                        use maestro::protocol::types::setting_value::ValueOneof as ValOneof;
+
+                        if let Some(RspOneof::Value(setting_val)) = change.value_oneof
+                            && let Some(ValOneof::CurrentAncrState(anc_state_raw)) = setting_val.value_oneof {
+                                let mut lock = statuses.lock().unwrap();
+                                let status = lock.entry(mac.to_string()).or_default();
+
+                                let anc_state = match anc_state_raw {
+                                    1 => settings::AncState::Off,
+                                    2 => settings::AncState::Active,
+                                    3 => settings::AncState::Aware,
+                                    4 => settings::AncState::Adaptive,
+                                    _ => settings::AncState::Unknown(anc_state_raw),
+                                };
+
+                                status.anc_state = anc_state_to_string(&anc_state);
+                                status.last_update = Some(Instant::now());
+                                debug!(mode = %status.anc_state, "Caught physical ANC toggle");
+                        }
+                    }
+                }
+                _ = tokio::time::sleep(Duration::from_secs(30)) => {
+                    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,
+    }
+}
+
+pub 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: OnceLock<MaestroManager> = OnceLock::new();
+
+pub fn get_maestro(state: &AppReceivers) -> &MaestroManager {
+    MAESTRO.get_or_init(|| MaestroManager::new(state.clone()))
+}

src/modules/bt/mod.rs

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

src/modules/btrfs.rs

@@ -1,23 +1,31 @@
 use crate::config::Config;
+use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
-use crate::utils::{format_template, TokenValue};
-use anyhow::Result;
-use sysinfo::Disks;
+use crate::state::AppReceivers;
+use crate::utils::{TokenValue, classify_usage, format_template};
 
 pub struct BtrfsModule;
 
 impl WaybarModule for BtrfsModule {
-    fn run(&self, config: &Config, _state: &SharedState, _args: &[&str]) -> Result<WaybarOutput> {
-        let disks = Disks::new_with_refreshed_list();
+    async fn run(
+        &self,
+        config: &Config,
+        state: &AppReceivers,
+        _args: &[&str],
+    ) -> Result<WaybarOutput> {
+        let disks = {
+            let s = state.disks.borrow();
+            s.clone()
+        };
+
         let mut total_used: f64 = 0.0;
         let mut total_size: f64 = 0.0;
 
         for disk in &disks {
-            if disk.file_system().to_string_lossy().to_lowercase().contains("btrfs") {
-                let size = disk.total_space() as f64;
-                let available = disk.available_space() as f64;
+            if disk.filesystem.contains("btrfs") {
+                let size = disk.total_bytes as f64;
+                let available = disk.available_bytes as f64;
                 total_size += size;
                 total_used += size - available;
             }
@@ -36,20 +44,14 @@ impl WaybarModule for BtrfsModule {
         let size_gb = total_size / 1024.0 / 1024.0 / 1024.0;
         let percentage = (total_used / total_size) * 100.0;
 
-        let class = if percentage > 95.0 {
-            "max"
-        } else if percentage > 80.0 {
-            "high"
-        } else {
-            "normal"
-        };
+        let class = classify_usage(percentage, 80.0, 95.0);
 
         let text = format_template(
             &config.pool.format,
             &[
                 ("used", TokenValue::Float(used_gb)),
                 ("total", TokenValue::Float(size_gb)),
-            ]
+            ],
         );
 
         Ok(WaybarOutput {

src/modules/buds.rs

@@ -1,121 +0,0 @@
-use crate::config::Config;
-use crate::modules::WaybarModule;
-use crate::output::WaybarOutput;
-use crate::state::SharedState;
-use crate::utils::{format_template, TokenValue};
-use anyhow::Result;
-use std::process::Command;
-
-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 output = Command::new("pbpctrl").args(["get", "anc"]).output()?;
-                let current_mode = String::from_utf8_lossy(&output.stdout).trim().to_string();
-                
-                let next_mode = match current_mode.as_str() {
-                    "active" => "aware",
-                    "aware" => "off",
-                    _ => "active",
-                };
-                
-                Command::new("pbpctrl").args(["set", "anc", next_mode]).status()?;
-                return Ok(WaybarOutput {
-                    text: String::new(),
-                    tooltip: None, class: None, percentage: None,
-                });
-            }
-            "connect" => {
-                Command::new("bluetoothctl").args(["connect", mac]).status()?;
-                return Ok(WaybarOutput {
-                    text: String::new(),
-                    tooltip: None, class: None, percentage: None,
-                });
-            }
-            "disconnect" => {
-                Command::new("bluetoothctl").args(["disconnect", mac]).status()?;
-                return Ok(WaybarOutput {
-                    text: String::new(),
-                    tooltip: None, class: None, percentage: None,
-                });
-            }
-            "show" | _ => {}
-        }
-
-        let bt_info = Command::new("bluetoothctl").args(["info", mac]).output()?;
-        let bt_str = String::from_utf8_lossy(&bt_info.stdout);
-        
-        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_cmd = Command::new("pbpctrl").args(["show", "battery"]).output();
-        if bat_cmd.is_err() || !bat_cmd.as_ref().unwrap().status.success() {
-            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 bat_result = bat_cmd.unwrap();
-        let bat_output = String::from_utf8_lossy(&bat_result.stdout);
-        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 anc_cmd = Command::new("pbpctrl").args(["get", "anc"]).output()?;
-        let current_mode = String::from_utf8_lossy(&anc_cmd.stdout).trim().to_string();
-
-        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,22 @@
 use crate::config::Config;
+use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
-use crate::utils::{format_template, TokenValue};
-use anyhow::Result;
+use crate::state::AppReceivers;
+use crate::utils::{TokenValue, classify_usage, format_template};
 
 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: &AppReceivers,
+        _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 s = state.cpu.borrow();
+            (s.usage, s.temp, s.model.clone())
         };
 
         let text = format_template(
@@ -26,16 +24,10 @@ impl WaybarModule for CpuModule {
             &[
                 ("usage", TokenValue::Float(usage)),
                 ("temp", TokenValue::Float(temp)),
-            ]
+            ],
         );
 
-        let class = if usage > 95.0 {
-            "max"
-        } else if usage > 75.0 {
-            "high"
-        } else {
-            "normal"
-        };
+        let class = classify_usage(usage, 75.0, 95.0);
 
         Ok(WaybarOutput {
             text,
@@ -45,3 +37,58 @@ impl WaybarModule for CpuModule {
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::state::{AppState, CpuState, mock_state};
+
+    #[tokio::test]
+    async fn test_cpu_normal() {
+        let state = mock_state(AppState {
+            cpu: CpuState {
+                usage: 25.0,
+                temp: 45.0,
+                model: "Test CPU".into(),
+            },
+            ..Default::default()
+        });
+        let config = Config::default();
+        let output = CpuModule.run(&config, &state.receivers, &[]).await.unwrap();
+        assert!(output.text.contains("25.0"));
+        assert!(output.text.contains("45.0"));
+        assert_eq!(output.class.as_deref(), Some("normal"));
+        assert_eq!(output.percentage, Some(25));
+        assert_eq!(output.tooltip.as_deref(), Some("Test CPU"));
+    }
+
+    #[tokio::test]
+    async fn test_cpu_high() {
+        let state = mock_state(AppState {
+            cpu: CpuState {
+                usage: 80.0,
+                temp: 70.0,
+                model: "Test".into(),
+            },
+            ..Default::default()
+        });
+        let config = Config::default();
+        let output = CpuModule.run(&config, &state.receivers, &[]).await.unwrap();
+        assert_eq!(output.class.as_deref(), Some("high"));
+    }
+
+    #[tokio::test]
+    async fn test_cpu_max() {
+        let state = mock_state(AppState {
+            cpu: CpuState {
+                usage: 99.0,
+                temp: 95.0,
+                model: "Test".into(),
+            },
+            ..Default::default()
+        });
+        let config = Config::default();
+        let output = CpuModule.run(&config, &state.receivers, &[]).await.unwrap();
+        assert_eq!(output.class.as_deref(), Some("max"));
+    }
+}

src/modules/disk.rs

@@ -1,56 +1,125 @@
 use crate::config::Config;
+use crate::error::{FluxoError, Result};
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
-use crate::utils::{format_template, TokenValue};
-use anyhow::Result;
-use sysinfo::Disks;
+use crate::state::AppReceivers;
+use crate::utils::{TokenValue, classify_usage, format_template};
 
 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: &AppReceivers,
+        args: &[&str],
+    ) -> Result<WaybarOutput> {
         let mountpoint = args.first().unwrap_or(&"/");
 
-        let disks = Disks::new_with_refreshed_list();
+        let disks = state.disks.borrow().clone();
+
+        if disks.is_empty() {
+            return Ok(WaybarOutput {
+                text: "Disk Loading...".to_string(),
+                ..Default::default()
+            });
+        }
+
         for disk in &disks {
-            if disk.mount_point().to_string_lossy() == *mountpoint {
-                let total = disk.total_space() as f64;
-                let available = disk.available_space() as f64;
+            if disk.mount_point == *mountpoint {
+                let total = disk.total_bytes as f64;
+                let available = disk.available_bytes as f64;
                 let used = total - available;
 
                 let used_gb = used / 1024.0 / 1024.0 / 1024.0;
                 let total_gb = total / 1024.0 / 1024.0 / 1024.0;
                 let free_gb = available / 1024.0 / 1024.0 / 1024.0;
 
-                let percentage = if total > 0.0 { (used / total) * 100.0 } else { 0.0 };
-
-                let class = if percentage > 95.0 {
-                    "max"
-                } else if percentage > 80.0 {
-                    "high"
+                let percentage = if total > 0.0 {
+                    (used / total) * 100.0
                 } else {
-                    "normal"
+                    0.0
                 };
 
+                let class = classify_usage(percentage, 80.0, 95.0);
+
                 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)),
-                    ]
+                    ],
                 );
 
                 return Ok(WaybarOutput {
                     text,
-                    tooltip: Some(format!("Used: {:.1}G\nTotal: {:.1}G\nFree: {:.1}G", used_gb, total_gb, free_gb)),
+                    tooltip: Some(format!(
+                        "Used: {:.1}G\nTotal: {:.1}G\nFree: {:.1}G",
+                        used_gb, total_gb, free_gb
+                    )),
                     class: Some(class.to_string()),
                     percentage: Some(percentage as u8),
                 });
             }
         }
 
-        Err(anyhow::anyhow!("Mountpoint {} not found", mountpoint))
+        Err(FluxoError::Module {
+            module: "disk",
+            message: format!("Mountpoint {} not found", mountpoint),
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::state::{AppState, DiskInfo, MockState, mock_state};
+
+    fn state_with_disk(mount: &str, total: u64, available: u64) -> MockState {
+        mock_state(AppState {
+            disks: vec![DiskInfo {
+                mount_point: mount.to_string(),
+                filesystem: "ext4".to_string(),
+                total_bytes: total,
+                available_bytes: available,
+            }],
+            ..Default::default()
+        })
+    }
+
+    #[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.receivers, &["/"])
+            .await
+            .unwrap();
+        assert_eq!(output.class.as_deref(), Some("normal"));
+        assert_eq!(output.percentage, Some(40)); // 40% used
+    }
+
+    #[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.receivers, &["/"])
+            .await
+            .unwrap();
+        assert_eq!(output.class.as_deref(), Some("high")); // 85% used
+    }
+
+    #[tokio::test]
+    async fn test_disk_not_found() {
+        let state = state_with_disk("/", 100, 50);
+        let config = Config::default();
+        let result = DiskModule
+            .run(&config, &state.receivers, &["/nonexistent"])
+            .await;
+        assert!(result.is_err());
     }
 }

src/modules/dnd.rs

@@ -0,0 +1,174 @@
+use crate::config::Config;
+use crate::error::Result;
+use crate::modules::WaybarModule;
+use crate::output::WaybarOutput;
+use crate::state::{AppReceivers, DndState};
+use futures::StreamExt;
+use tokio::sync::watch;
+use tracing::{debug, error, info};
+use zbus::{Connection, fdo::PropertiesProxy, proxy};
+
+pub struct DndModule;
+
+impl WaybarModule for DndModule {
+    async fn run(
+        &self,
+        config: &Config,
+        state: &AppReceivers,
+        args: &[&str],
+    ) -> Result<WaybarOutput> {
+        let action = args.first().unwrap_or(&"show");
+
+        if *action == "toggle" {
+            let connection =
+                Connection::session()
+                    .await
+                    .map_err(|e| crate::error::FluxoError::Module {
+                        module: "dnd",
+                        message: format!("DBus connection failed: {}", e),
+                    })?;
+
+            // Try toggling SwayNC
+            if let Ok(proxy) = SwayncControlProxy::new(&connection).await {
+                if let Ok(is_dnd) = proxy.dnd().await {
+                    let _ = proxy.set_dnd(!is_dnd).await;
+                    return Ok(WaybarOutput::default());
+                }
+            }
+
+            // Try toggling Dunst
+            if let Ok(proxy) = DunstControlProxy::new(&connection).await {
+                if let Ok(is_paused) = proxy.paused().await {
+                    let _ = proxy.set_paused(!is_paused).await;
+                    return Ok(WaybarOutput::default());
+                }
+            }
+
+            return Err(crate::error::FluxoError::Module {
+                module: "dnd",
+                message: "No supported notification daemon found to toggle".to_string(),
+            });
+        }
+
+        let is_dnd = state.dnd.borrow().is_dnd;
+
+        if is_dnd {
+            Ok(WaybarOutput {
+                text: config.dnd.format_dnd.clone(),
+                tooltip: Some("Do Not Disturb: On".to_string()),
+                class: Some("dnd".to_string()),
+                percentage: None,
+            })
+        } else {
+            Ok(WaybarOutput {
+                text: config.dnd.format_normal.clone(),
+                tooltip: Some("Do Not Disturb: Off".to_string()),
+                class: Some("normal".to_string()),
+                percentage: None,
+            })
+        }
+    }
+}
+
+pub struct DndDaemon;
+
+#[proxy(
+    interface = "org.erikreider.swaync.control",
+    default_service = "org.erikreider.swaync.control",
+    default_path = "/org/erikreider/swaync/control"
+)]
+trait SwayncControl {
+    #[zbus(property)]
+    fn dnd(&self) -> zbus::Result<bool>;
+    #[zbus(property)]
+    fn set_dnd(&self, value: bool) -> zbus::Result<()>;
+}
+
+#[proxy(
+    interface = "org.dunstproject.cmd0",
+    default_service = "org.freedesktop.Notifications",
+    default_path = "/org/freedesktop/Notifications"
+)]
+trait DunstControl {
+    #[zbus(property)]
+    fn paused(&self) -> zbus::Result<bool>;
+    #[zbus(property)]
+    fn set_paused(&self, value: bool) -> zbus::Result<()>;
+}
+
+impl DndDaemon {
+    pub fn new() -> Self {
+        Self
+    }
+
+    pub fn start(&self, tx: watch::Sender<DndState>) {
+        tokio::spawn(async move {
+            loop {
+                if let Err(e) = Self::listen_loop(&tx).await {
+                    error!("DND listener error: {}", e);
+                    tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
+                }
+            }
+        });
+    }
+
+    async fn listen_loop(tx: &watch::Sender<DndState>) -> anyhow::Result<()> {
+        let connection = Connection::session().await?;
+
+        info!("Connected to D-Bus for DND monitoring");
+
+        // Try SwayNC
+        if let Ok(proxy) = SwayncControlProxy::new(&connection).await {
+            if let Ok(is_dnd) = proxy.dnd().await {
+                debug!("Found SwayNC, using it for DND state.");
+                let _ = tx.send(DndState { is_dnd });
+
+                if let Ok(props_proxy) = PropertiesProxy::builder(&connection)
+                    .destination("org.erikreider.swaync.control")?
+                    .path("/org/erikreider/swaync/control")?
+                    .build()
+                    .await
+                {
+                    let mut stream = props_proxy.receive_properties_changed().await?;
+                    while let Some(signal) = stream.next().await {
+                        let args = signal.args()?;
+                        if args.interface_name == "org.erikreider.swaync.control"
+                            && let Some(val) = args.changed_properties.get("dnd")
+                            && let Ok(is_dnd) = bool::try_from(val)
+                        {
+                            let _ = tx.send(DndState { is_dnd });
+                        }
+                    }
+                }
+            }
+        }
+
+        // Try Dunst
+        if let Ok(proxy) = DunstControlProxy::new(&connection).await {
+            if let Ok(is_dnd) = proxy.paused().await {
+                debug!("Found Dunst, using it for DND state.");
+                let _ = tx.send(DndState { is_dnd });
+
+                if let Ok(props_proxy) = PropertiesProxy::builder(&connection)
+                    .destination("org.freedesktop.Notifications")?
+                    .path("/org/freedesktop/Notifications")?
+                    .build()
+                    .await
+                {
+                    let mut stream = props_proxy.receive_properties_changed().await?;
+                    while let Some(signal) = stream.next().await {
+                        let args = signal.args()?;
+                        if args.interface_name == "org.dunstproject.cmd0"
+                            && let Some(val) = args.changed_properties.get("paused")
+                            && let Ok(is_dnd) = bool::try_from(val)
+                        {
+                            let _ = tx.send(DndState { is_dnd });
+                        }
+                    }
+                }
+            }
+        }
+
+        Err(anyhow::anyhow!("DND stream ended or daemon not found"))
+    }
+}

src/modules/game.rs

@@ -1,26 +1,24 @@
 use crate::config::Config;
+use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
-use anyhow::Result;
-use std::process::Command;
+use crate::state::AppReceivers;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::UnixStream;
 
 pub struct GameModule;
 
 impl WaybarModule for GameModule {
-    fn run(&self, config: &Config, _state: &SharedState, _args: &[&str]) -> Result<WaybarOutput> {
-        let output = Command::new("hyprctl")
-            .args(["getoption", "animations:enabled", "-j"])
-            .output();
-
-        let mut is_gamemode = false;
-
-        if let Ok(out) = output {
-            let stdout = String::from_utf8_lossy(&out.stdout);
-            if stdout.contains("\"int\": 0") {
-                is_gamemode = true;
-            }
-        }
+    async fn run(
+        &self,
+        config: &Config,
+        _state: &AppReceivers,
+        _args: &[&str],
+    ) -> Result<WaybarOutput> {
+        let is_gamemode = hyprland_ipc("j/getoption animations:enabled")
+            .await
+            .map(|stdout| stdout.contains("\"int\": 0"))
+            .unwrap_or(false);
 
         if is_gamemode {
             Ok(WaybarOutput {
@@ -39,3 +37,15 @@ impl WaybarModule for GameModule {
         }
     }
 }
+
+async fn hyprland_ipc(cmd: &str) -> Result<String> {
+    let path = crate::utils::get_hyprland_socket(".socket.sock")?;
+
+    let mut stream = UnixStream::connect(path).await?;
+    stream.write_all(cmd.as_bytes()).await?;
+
+    let mut response = String::new();
+    stream.read_to_string(&mut response).await?;
+
+    Ok(response)
+}

src/modules/gpu.rs

@@ -1,28 +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::{format_template, TokenValue};
-use anyhow::Result;
+use crate::state::AppReceivers;
+use crate::utils::{TokenValue, classify_usage, format_template};
 
 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: &AppReceivers,
+        _args: &[&str],
+    ) -> Result<WaybarOutput> {
         let (active, vendor, usage, vram_used, vram_total, temp, model) = {
-            if let Ok(state_lock) = state.read() {
+            let s = state.gpu.borrow();
             (
-                    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(),
+                s.active,
+                s.vendor.clone(),
+                s.usage,
+                s.vram_used,
+                s.vram_total,
+                s.temp,
+                s.model.clone(),
             )
-            } else {
-                (false, String::from("Unknown"), 0.0, 0.0, 0.0, 0.0, String::from("Unknown"))
-            }
         };
 
         if !active {
@@ -34,13 +36,7 @@ impl WaybarModule for GpuModule {
             });
         }
 
-        let class = if usage > 95.0 {
-            "max"
-        } else if usage > 75.0 {
-            "high"
-        } else {
-            "normal"
-        };
+        let class = classify_usage(usage, 75.0, 95.0);
 
         let format_str = match vendor.as_str() {
             "Intel" => &config.gpu.format_intel,
@@ -55,13 +51,16 @@ impl WaybarModule for GpuModule {
                 ("vram_used", TokenValue::Float(vram_used)),
                 ("vram_total", TokenValue::Float(vram_total)),
                 ("temp", TokenValue::Float(temp)),
-            ]
+            ],
         );
 
         let tooltip = if vendor == "Intel" {
             format!("Model: {}\nApprox Usage: {:.0}%", model, usage)
         } else {
-            format!("Model: {}\nUsage: {:.0}%\nVRAM: {:.1}/{:.1}GB\nTemp: {:.1}°C", model, usage, vram_used, vram_total, temp)
+            format!(
+                "Model: {}\nUsage: {:.0}%\nVRAM: {:.1}/{:.1}GB\nTemp: {:.1}°C",
+                model, usage, vram_used, vram_total, temp
+            )
         };
 
         Ok(WaybarOutput {

src/modules/hardware.rs

@@ -1,35 +1,60 @@
-use crate::state::SharedState;
-use sysinfo::{Components, System};
+use crate::state::{CpuState, DiskInfo, GpuState, MemoryState, SysState};
+use sysinfo::{Components, Disks, System};
+use tokio::sync::watch;
 
 pub struct HardwareDaemon {
     sys: System,
     components: Components,
     gpu_vendor: Option<String>,
+    gpu_poll_counter: u8,
+    disk_poll_counter: u8,
 }
 
 impl HardwareDaemon {
     pub fn new() -> Self {
-        let mut sys = System::new_all();
-        sys.refresh_all();
+        let mut sys = System::new();
+        sys.refresh_cpu_usage();
+        sys.refresh_memory();
         let components = Components::new_with_refreshed_list();
-        Self { sys, components, gpu_vendor: None }
+        Self {
+            sys,
+            components,
+            gpu_vendor: None,
+            gpu_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,
+        cpu_tx: &watch::Sender<CpuState>,
+        mem_tx: &watch::Sender<MemoryState>,
+        sys_tx: &watch::Sender<SysState>,
+    ) {
         self.sys.refresh_cpu_usage();
         self.sys.refresh_memory();
         self.components.refresh(true);
 
         let cpu_usage = self.sys.global_cpu_usage();
-        let cpu_model = self.sys.cpus().first().map(|c| c.brand().to_string()).unwrap_or_else(|| "Unknown".to_string());
+        let cpu_model = self
+            .sys
+            .cpus()
+            .first()
+            .map(|c| c.brand().to_string())
+            .unwrap_or_else(|| "Unknown".to_string());
 
         let mut cpu_temp = 0.0;
         for component in &self.components {
             let label = component.label().to_lowercase();
-            if label.contains("tctl") || label.contains("cpu") || label.contains("package") || label.contains("temp1") {
-                if let Some(temp) = component.temperature() {
+            if (label.contains("tctl")
+                || label.contains("cpu")
+                || label.contains("package")
+                || label.contains("temp1"))
+                && let Some(temp) = component.temperature()
+            {
                 cpu_temp = temp as f64;
-                    if cpu_temp > 0.0 { break; }
+                if cpu_temp > 0.0 {
+                    break;
                 }
             }
         }
@@ -44,40 +69,90 @@ impl HardwareDaemon {
         let mut process_count = 0;
         if let Ok(loadavg_str) = std::fs::read_to_string("/proc/loadavg") {
             let parts: Vec<&str> = loadavg_str.split_whitespace().collect();
-            if parts.len() >= 4 {
-                if let Some(total_procs) = parts[3].split('/').nth(1) {
+            if parts.len() >= 4
+                && let Some(total_procs) = parts[3].split('/').nth(1)
+            {
                 process_count = total_procs.parse().unwrap_or(0);
             }
         }
+
+        let mut cpu = cpu_tx.borrow().clone();
+        cpu.usage = cpu_usage as f64;
+        cpu.temp = cpu_temp;
+        cpu.model = cpu_model;
+        let _ = cpu_tx.send(cpu);
+
+        let mut mem = mem_tx.borrow().clone();
+        mem.total_gb = total_mem;
+        mem.used_gb = used_mem;
+        let _ = mem_tx.send(mem);
+
+        let mut sys = sys_tx.borrow().clone();
+        sys.load_1 = load_avg.one;
+        sys.load_5 = load_avg.five;
+        sys.load_15 = load_avg.fifteen;
+        sys.uptime = uptime;
+        sys.process_count = process_count;
+        let _ = sys_tx.send(sys);
     }
 
-        if let Ok(mut state_lock) = state.write() {
-            state_lock.cpu.usage = cpu_usage as f64;
-            state_lock.cpu.temp = cpu_temp as f64;
-            state_lock.cpu.model = cpu_model;
+    pub async fn poll_slow(
+        &mut self,
+        gpu_tx: &watch::Sender<GpuState>,
+        disks_tx: &watch::Sender<Vec<DiskInfo>>,
+    ) {
+        // 1. Gather GPU data outside of lock
+        let mut gpu_state = crate::state::GpuState::default();
+        self.gpu_poll_counter = (self.gpu_poll_counter + 1) % 5;
+        let should_poll_gpu = self.gpu_poll_counter == 0;
+        if should_poll_gpu {
+            self.poll_gpu(&mut gpu_state).await;
+        }
 
-            state_lock.memory.total_gb = total_mem;
-            state_lock.memory.used_gb = used_mem;
+        // 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(
+                tokio::task::spawn_blocking(|| {
+                    Disks::new_with_refreshed_list()
+                        .iter()
+                        .map(|d| DiskInfo {
+                            mount_point: d.mount_point().to_string_lossy().into_owned(),
+                            filesystem: d.file_system().to_string_lossy().to_lowercase(),
+                            total_bytes: d.total_space(),
+                            available_bytes: d.available_space(),
+                        })
+                        .collect::<Vec<DiskInfo>>()
+                })
+                .await
+                .unwrap_or_default(),
+            );
+        }
 
-            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;
+        // 3. Apply to state
+        if should_poll_gpu {
+            let _ = gpu_tx.send(gpu_state);
+        }
 
-            self.poll_gpu(&mut state_lock.gpu);
+        if let Some(d) = disks_data {
+            let _ = disks_tx.send(d);
         }
     }
 
-    fn poll_gpu(&mut self, gpu: &mut crate::state::GpuState) {
+    async fn poll_gpu(&mut self, gpu: &mut crate::state::GpuState) {
         gpu.active = false;
 
-        if self.gpu_vendor.as_deref() == Some("NVIDIA") || self.gpu_vendor.is_none() {
-            if let Ok(output) = std::process::Command::new("nvidia-smi")
-                .args(["--query-gpu=utilization.gpu,memory.used,memory.total,temperature.gpu,name", "--format=csv,noheader,nounits"])
+        if (self.gpu_vendor.as_deref() == Some("NVIDIA") || self.gpu_vendor.is_none())
+            && let Ok(output) = tokio::process::Command::new("nvidia-smi")
+                .args([
+                    "--query-gpu=utilization.gpu,memory.used,memory.total,temperature.gpu,name",
+                    "--format=csv,noheader,nounits",
+                ])
                 .output()
+                .await
+            && output.status.success()
         {
-                if output.status.success() {
             let stdout = String::from_utf8_lossy(&output.stdout);
             if let Some(line) = stdout.lines().next() {
                 let parts: Vec<&str> = line.split(',').collect();
@@ -94,24 +169,37 @@ impl HardwareDaemon {
                 }
             }
         }
-            }
-        }
 
-        if self.gpu_vendor.as_deref() == Some("AMD") || self.gpu_vendor.as_deref() == Some("Intel") || self.gpu_vendor.is_none() {
+        if self.gpu_vendor.as_deref() == Some("AMD")
+            || self.gpu_vendor.as_deref() == Some("Intel")
+            || self.gpu_vendor.is_none()
+        {
             for i in 0..=3 {
                 let base = format!("/sys/class/drm/card{}/device", i);
 
-                if self.gpu_vendor.as_deref() == Some("AMD") || self.gpu_vendor.is_none() {
-                    if let Ok(usage_str) = std::fs::read_to_string(format!("{}/gpu_busy_percent", base)) {
+                if (self.gpu_vendor.as_deref() == Some("AMD") || self.gpu_vendor.is_none())
+                    && let Ok(usage_str) =
+                        std::fs::read_to_string(format!("{}/gpu_busy_percent", base))
+                {
                     gpu.active = true;
                     gpu.vendor = "AMD".to_string();
                     gpu.usage = usage_str.trim().parse().unwrap_or(0.0);
 
-                        if let Ok(mem_used) = std::fs::read_to_string(format!("{}/mem_info_vram_used", base)) {
-                            gpu.vram_used = mem_used.trim().parse::<f64>().unwrap_or(0.0) / 1024.0 / 1024.0 / 1024.0;
+                    if let Ok(mem_used) =
+                        std::fs::read_to_string(format!("{}/mem_info_vram_used", base))
+                    {
+                        gpu.vram_used = mem_used.trim().parse::<f64>().unwrap_or(0.0)
+                            / 1024.0
+                            / 1024.0
+                            / 1024.0;
                     }
-                        if let Ok(mem_total) = std::fs::read_to_string(format!("{}/mem_info_vram_total", base)) {
-                            gpu.vram_total = mem_total.trim().parse::<f64>().unwrap_or(0.0) / 1024.0 / 1024.0 / 1024.0;
+                    if let Ok(mem_total) =
+                        std::fs::read_to_string(format!("{}/mem_info_vram_total", base))
+                    {
+                        gpu.vram_total = mem_total.trim().parse::<f64>().unwrap_or(0.0)
+                            / 1024.0
+                            / 1024.0
+                            / 1024.0;
                     }
 
                     if let Ok(entries) = std::fs::read_dir(format!("{}/hwmon", base)) {
@@ -127,19 +215,25 @@ impl HardwareDaemon {
                     self.gpu_vendor = Some("AMD".to_string());
                     return;
                 }
-                }
 
                 if self.gpu_vendor.as_deref() == Some("Intel") || self.gpu_vendor.is_none() {
-                    let freq_path = if std::path::Path::new(&format!("{}/gt_cur_freq_mhz", base)).exists() {
+                    let freq_path =
+                        if std::path::Path::new(&format!("{}/gt_cur_freq_mhz", base)).exists() {
                             Some(format!("{}/gt_cur_freq_mhz", base))
-                    } else if std::path::Path::new(&format!("/sys/class/drm/card{}/gt_cur_freq_mhz", i)).exists() {
+                        } else if std::path::Path::new(&format!(
+                            "/sys/class/drm/card{}/gt_cur_freq_mhz",
+                            i
+                        ))
+                        .exists()
+                        {
                             Some(format!("/sys/class/drm/card{}/gt_cur_freq_mhz", i))
                         } else {
                             None
                         };
 
-                    if let Some(path) = freq_path {
-                        if let Ok(freq_str) = std::fs::read_to_string(&path) {
+                    if let Some(path) = freq_path
+                        && let Ok(freq_str) = std::fs::read_to_string(&path)
+                    {
                         gpu.active = true;
                         gpu.vendor = "Intel".to_string();
 
@@ -151,7 +245,11 @@ impl HardwareDaemon {
                             max_freq = max_str.trim().parse::<f64>().unwrap_or(0.0);
                         }
 
-                            gpu.usage = if max_freq > 0.0 { (cur_freq / max_freq) * 100.0 } else { 0.0 };
+                        gpu.usage = if max_freq > 0.0 {
+                            (cur_freq / max_freq) * 100.0
+                        } else {
+                            0.0
+                        };
                         gpu.temp = 0.0;
                         gpu.vram_used = 0.0;
                         gpu.vram_total = 0.0;
@@ -163,5 +261,4 @@ impl HardwareDaemon {
             }
         }
     }
-    }
 }

src/modules/keyboard.rs

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

src/modules/memory.rs

@@ -1,42 +1,39 @@
 use crate::config::Config;
+use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
-use crate::utils::{format_template, TokenValue};
-use anyhow::Result;
+use crate::state::AppReceivers;
+use crate::utils::{TokenValue, classify_usage, format_template};
 
 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: &AppReceivers,
+        _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 s = state.memory.borrow();
+            (s.used_gb, s.total_gb)
         };
 
-        let ratio = if total_gb > 0.0 { (used_gb / total_gb) * 100.0 } else { 0.0 };
+        let ratio = if total_gb > 0.0 {
+            (used_gb / total_gb) * 100.0
+        } else {
+            0.0
+        };
 
         let text = format_template(
             &config.memory.format,
             &[
                 ("used", TokenValue::Float(used_gb)),
                 ("total", TokenValue::Float(total_gb)),
-            ]
+            ],
         );
 
-        let class = if ratio > 95.0 {
-            "max"
-        } else if ratio > 75.0 {
-            "high"
-        } else {
-            "normal"
-        };
+        let class = classify_usage(ratio, 75.0, 95.0);
 
         Ok(WaybarOutput {
             text,
@@ -46,3 +43,64 @@ impl WaybarModule for MemoryModule {
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::state::{AppState, MemoryState, mock_state};
+
+    #[tokio::test]
+    async fn test_memory_normal() {
+        let state = mock_state(AppState {
+            memory: MemoryState {
+                used_gb: 8.0,
+                total_gb: 32.0,
+            },
+            ..Default::default()
+        });
+        let config = Config::default();
+        let output = MemoryModule
+            .run(&config, &state.receivers, &[])
+            .await
+            .unwrap();
+        assert!(output.text.contains("8.00"));
+        assert!(output.text.contains("32.00"));
+        assert_eq!(output.class.as_deref(), Some("normal"));
+        assert_eq!(output.percentage, Some(25)); // 8/32 = 25%
+    }
+
+    #[tokio::test]
+    async fn test_memory_high() {
+        let state = mock_state(AppState {
+            memory: MemoryState {
+                used_gb: 26.0,
+                total_gb: 32.0,
+            },
+            ..Default::default()
+        });
+        let config = Config::default();
+        let output = MemoryModule
+            .run(&config, &state.receivers, &[])
+            .await
+            .unwrap();
+        assert_eq!(output.class.as_deref(), Some("high")); // 81%
+    }
+
+    #[tokio::test]
+    async fn test_memory_zero_total() {
+        let state = mock_state(AppState {
+            memory: MemoryState {
+                used_gb: 0.0,
+                total_gb: 0.0,
+            },
+            ..Default::default()
+        });
+        let config = Config::default();
+        let output = MemoryModule
+            .run(&config, &state.receivers, &[])
+            .await
+            .unwrap();
+        assert_eq!(output.class.as_deref(), Some("normal"));
+        assert_eq!(output.percentage, Some(0));
+    }
+}

src/modules/mod.rs

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

src/modules/mpris.rs

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

src/modules/network.rs

@@ -1,11 +1,13 @@
 use crate::config::Config;
+use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::SharedState;
-use crate::utils::{format_template, TokenValue};
-use anyhow::Result;
+use crate::state::{AppReceivers, NetworkState};
+use crate::utils::{TokenValue, format_template};
+use nix::ifaddrs::getifaddrs;
 use std::fs;
 use std::time::{SystemTime, UNIX_EPOCH};
+use tokio::sync::watch;
 
 pub struct NetworkModule;
 
@@ -17,6 +19,8 @@ pub struct NetworkDaemon {
     cached_ip: Option<String>,
 }
 
+type PollResult = crate::error::Result<(String, Option<String>, Option<(u64, u64)>)>;
+
 impl NetworkDaemon {
     pub fn new() -> Self {
         Self {
@@ -28,44 +32,86 @@ 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 {
-            if !std::path::Path::new(&format!("/sys/class/net/{}", iface)).exists() {
+    pub async fn poll(
+        &mut self,
+        state_tx: &watch::Sender<NetworkState>,
+    ) -> crate::error::Result<()> {
+        let (iface, ip_opt, bytes_opt) = tokio::task::spawn_blocking(|| -> PollResult {
+            let iface = get_primary_interface()?;
+            if iface.is_empty() {
+                return Ok((String::new(), None, None));
+            }
+            let ip = get_ip_address(&iface);
+            let bytes = get_bytes(&iface).ok();
+            Ok((iface, ip, bytes))
+        })
+        .await
+        .map_err(|e| crate::error::FluxoError::System(e.to_string()))??;
+
+        if !iface.is_empty() {
+            if self.cached_interface.as_ref() != Some(&iface) || self.cached_ip.is_none() {
+                self.cached_ip = ip_opt;
+                self.cached_interface = Some(iface.clone());
+            }
+        } else {
             self.cached_interface = None;
             self.cached_ip = None;
-            }
+            // Provide a default state for "No connection"
+            let mut network = state_tx.borrow().clone();
+            network.interface.clear();
+            network.ip.clear();
+            network.rx_mbps = 0.0;
+            network.tx_mbps = 0.0;
+            let _ = state_tx.send(network);
+            return Err(crate::error::FluxoError::Network(
+                "No primary interface found".into(),
+            ));
         }
 
-        // Re-detect interface if needed
-        if self.cached_interface.is_none() {
-            if let Ok(iface) = get_primary_interface() {
-                if !iface.is_empty() {
-                    self.cached_interface = Some(iface.clone());
-                    self.cached_ip = get_ip_address(&iface);
-                }
-            }
-        }
+        let interface = if let Some(ref interface) = self.cached_interface {
+            interface.clone()
+        } else {
+            // No interface detected
+            let mut network = state_tx.borrow().clone();
+            network.interface.clear();
+            network.ip.clear();
+            network.rx_mbps = 0.0;
+            network.tx_mbps = 0.0;
+            let _ = state_tx.send(network);
+            return Err(crate::error::FluxoError::Network(
+                "Interface disappeared during poll".into(),
+            ));
+        };
 
-        if let Some(ref interface) = self.cached_interface {
         let time_now = SystemTime::now()
             .duration_since(UNIX_EPOCH)
             .unwrap_or_default()
             .as_secs();
 
-            if let Ok((rx_bytes_now, tx_bytes_now)) = get_bytes(interface) {
+        if let Some((rx_bytes_now, tx_bytes_now)) = bytes_opt {
             if self.last_time > 0 && time_now > self.last_time {
-                    let time_diff = time_now - self.last_time;
-                    let rx_bps = (rx_bytes_now.saturating_sub(self.last_rx_bytes)) / time_diff;
-                    let tx_bps = (tx_bytes_now.saturating_sub(self.last_tx_bytes)) / time_diff;
+                let time_diff = (time_now - self.last_time) as f64;
+                let rx_mbps = (rx_bytes_now.saturating_sub(self.last_rx_bytes)) as f64
+                    / time_diff
+                    / 1024.0
+                    / 1024.0;
+                let tx_mbps = (tx_bytes_now.saturating_sub(self.last_tx_bytes)) as f64
+                    / time_diff
+                    / 1024.0
+                    / 1024.0;
 
-                    let rx_mbps = (rx_bps as f64) / 1024.0 / 1024.0;
-                    let tx_mbps = (tx_bps as f64) / 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;
-                    }
+                let mut network = state_tx.borrow().clone();
+                network.rx_mbps = rx_mbps;
+                network.tx_mbps = tx_mbps;
+                network.interface = interface.clone();
+                network.ip = self.cached_ip.clone().unwrap_or_default();
+                let _ = state_tx.send(network);
+            } else {
+                // First poll: no speed data yet, but update interface/ip
+                let mut network = state_tx.borrow().clone();
+                network.interface = interface.clone();
+                network.ip = self.cached_ip.clone().unwrap_or_default();
+                let _ = state_tx.send(network);
             }
 
             self.last_time = time_now;
@@ -74,14 +120,28 @@ impl NetworkDaemon {
         } else {
             // Read failed, might be down
             self.cached_interface = None;
+            return Err(crate::error::FluxoError::Network(format!(
+                "Failed to read bytes for {}",
+                interface
+            )));
         }
-        }
+
+        Ok(())
     }
 }
 
 impl WaybarModule for NetworkModule {
-    fn run(&self, config: &Config, state: &SharedState, _args: &[&str]) -> Result<WaybarOutput> {
-        let interface = get_primary_interface()?;
+    async fn run(
+        &self,
+        config: &Config,
+        state: &AppReceivers,
+        _args: &[&str],
+    ) -> Result<WaybarOutput> {
+        let (interface, ip, rx_mbps, tx_mbps) = {
+            let s = state.network.borrow();
+            (s.interface.clone(), s.ip.clone(), s.rx_mbps, s.tx_mbps)
+        };
+
         if interface.is_empty() {
             return Ok(WaybarOutput {
                 text: "No connection".to_string(),
@@ -91,37 +151,31 @@ impl WaybarModule for NetworkModule {
             });
         }
 
-        let ip = get_ip_address(&interface).unwrap_or_else(|| String::from("No IP"));
-        
-        let (rx_mbps, tx_mbps) = {
-            if let Ok(state_lock) = state.read() {
-                (state_lock.network.rx_mbps, state_lock.network.tx_mbps)
-            } else {
-                (0.0, 0.0)
-            }
-        };
+        let ip_display = if ip.is_empty() { "No IP" } else { &ip };
 
         let mut output_text = format_template(
             &config.network.format,
             &[
-                ("interface", TokenValue::String(&interface)),
-                ("ip", TokenValue::String(&ip)),
+                ("interface", TokenValue::String(interface.clone())),
+                ("ip", TokenValue::String(ip_display.to_string())),
                 ("rx", TokenValue::Float(rx_mbps)),
                 ("tx", TokenValue::Float(tx_mbps)),
-            ]
+            ],
         );
 
         if interface.starts_with("tun")
             || 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);
+            output_text = format!("  {}", output_text);
         }
 
         Ok(WaybarOutput {
             text: output_text,
-            tooltip: Some(format!("Interface: {}\nIP: {}", interface, ip)),
+            tooltip: Some(format!("Interface: {}\nIP: {}", interface, ip_display)),
             class: Some(interface),
             percentage: None,
         })
@@ -129,33 +183,26 @@ impl WaybarModule for NetworkModule {
 }
 
 fn get_primary_interface() -> Result<String> {
-    let output = std::process::Command::new("ip")
-        .args(["route", "list"])
-        .output()?;
-    let stdout = String::from_utf8_lossy(&output.stdout);
+    let content = std::fs::read_to_string("/proc/net/route")?;
 
     let mut defaults = Vec::new();
-    for line in stdout.lines() {
-        if line.starts_with("default") {
+    for line in content.lines().skip(1) {
         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()));
+        if parts.len() >= 8 {
+            let iface = parts[0];
+            let dest = parts[1];
+            let metric = parts[6].parse::<i32>().unwrap_or(0);
+            let mask = u32::from_str_radix(parts[7], 16).unwrap_or(0);
+
+            if dest == "00000000" {
+                defaults.push((mask, metric, iface.to_string()));
             }
         }
     }
 
-    defaults.sort_by_key(|k| k.0);
-    if let Some((_, dev)) = defaults.first() {
+    // Sort by mask descending (longest prefix match first), then by metric ascending
+    defaults.sort_by(|a, b| b.0.cmp(&a.0).then(a.1.cmp(&b.1)));
+    if let Some((_, _, dev)) = defaults.first() {
         Ok(dev.clone())
     } else {
         Ok(String::new())
@@ -163,19 +210,13 @@ fn get_primary_interface() -> Result<String> {
 }
 
 fn get_ip_address(interface: &str) -> Option<String> {
-    let output = std::process::Command::new("ip")
-        .args(["-4", "addr", "show", interface])
-        .output()
-        .ok()?;
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    for line in stdout.lines() {
-        if line.trim().starts_with("inet ") {
-            let parts: Vec<&str> = line.trim().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
@@ -198,3 +239,80 @@ fn get_bytes(interface: &str) -> Result<(u64, u64)> {
 
     Ok((rx, tx))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::state::{AppState, NetworkState, mock_state};
+
+    #[tokio::test]
+    async fn test_network_no_connection() {
+        let state = mock_state(AppState::default());
+        let config = Config::default();
+        let output = NetworkModule
+            .run(&config, &state.receivers, &[])
+            .await
+            .unwrap();
+        assert_eq!(output.text, "No connection");
+    }
+
+    #[tokio::test]
+    async fn test_network_connected() {
+        let state = mock_state(AppState {
+            network: NetworkState {
+                rx_mbps: 1.5,
+                tx_mbps: 0.3,
+                interface: "eth0".to_string(),
+                ip: "192.168.1.100".to_string(),
+            },
+            ..Default::default()
+        });
+        let config = Config::default();
+        let output = NetworkModule
+            .run(&config, &state.receivers, &[])
+            .await
+            .unwrap();
+        assert!(output.text.contains("eth0"));
+        assert!(output.text.contains("192.168.1.100"));
+        assert!(output.text.contains("1.50"));
+        assert_eq!(output.class.as_deref(), Some("eth0"));
+    }
+
+    #[tokio::test]
+    async fn test_network_vpn_prefix() {
+        let state = mock_state(AppState {
+            network: NetworkState {
+                rx_mbps: 0.0,
+                tx_mbps: 0.0,
+                interface: "wg0".to_string(),
+                ip: "10.0.0.1".to_string(),
+            },
+            ..Default::default()
+        });
+        let config = Config::default();
+        let output = NetworkModule
+            .run(&config, &state.receivers, &[])
+            .await
+            .unwrap();
+        assert!(output.text.starts_with("  "));
+    }
+
+    #[tokio::test]
+    async fn test_network_no_ip() {
+        let state = mock_state(AppState {
+            network: NetworkState {
+                rx_mbps: 0.0,
+                tx_mbps: 0.0,
+                interface: "eth0".to_string(),
+                ip: String::new(),
+            },
+            ..Default::default()
+        });
+        let config = Config::default();
+        let output = NetworkModule
+            .run(&config, &state.receivers, &[])
+            .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::{format_template, TokenValue};
-use anyhow::Result;
+use crate::state::AppReceivers;
+use crate::utils::{TokenValue, format_template};
 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: &AppReceivers,
+        _args: &[&str],
+    ) -> Result<WaybarOutput> {
         let critical_threshold = 15;
         let warning_threshold = 50;
 
@@ -32,15 +37,15 @@ impl WaybarModule for PowerModule {
                 let name = entry.file_name().to_string_lossy().to_string();
                 if name.starts_with("AC") || name.starts_with("ADP") {
                     let online_path = entry.path().join("online");
-                    if let Ok(online_str) = fs::read_to_string(online_path) {
-                        if online_str.trim() == "1" {
+                    if let Ok(online_str) = fs::read_to_string(online_path)
+                        && online_str.trim() == "1"
+                    {
                         ac_online = true;
                         break;
                     }
                 }
             }
         }
-        }
 
         let Some(bat_path) = battery_path else {
             if ac_online {
@@ -60,9 +65,11 @@ impl WaybarModule for PowerModule {
             }
         };
 
-        let capacity_str = fs::read_to_string(bat_path.join("capacity")).unwrap_or_else(|_| "0".to_string());
+        let capacity_str =
+            fs::read_to_string(bat_path.join("capacity")).unwrap_or_else(|_| "0".to_string());
         let percentage: u8 = capacity_str.trim().parse().unwrap_or(0);
-        let status_str = fs::read_to_string(bat_path.join("status")).unwrap_or_else(|_| "Unknown".to_string());
+        let status_str =
+            fs::read_to_string(bat_path.join("status")).unwrap_or_else(|_| "Unknown".to_string());
         let state = status_str.trim().to_lowercase();
 
         let (icon, class, tooltip) = if state == "charging" || ac_online {
@@ -94,8 +101,8 @@ impl WaybarModule for PowerModule {
             &config.power.format,
             &[
                 ("percentage", TokenValue::Int(percentage as i64)),
-                ("icon", TokenValue::String(icon)),
-            ]
+                ("icon", TokenValue::String(icon.to_string())),
+            ],
         );
 
         Ok(WaybarOutput {

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::{format_template, TokenValue};
-use anyhow::Result;
+use crate::state::AppReceivers;
+use crate::utils::{TokenValue, format_template};
 
 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: &AppReceivers,
+        _args: &[&str],
+    ) -> Result<WaybarOutput> {
         let (load1, load5, load15, uptime_secs, process_count) = {
-            if let Ok(state_lock) = state.read() {
+            let state_lock = state.sys.borrow();
             (
-                    state_lock.sys.load_1,
-                    state_lock.sys.load_5,
-                    state_lock.sys.load_15,
-                    state_lock.sys.uptime,
-                    state_lock.sys.process_count,
+                state_lock.load_1,
+                state_lock.load_5,
+                state_lock.load_15,
+                state_lock.uptime,
+                state_lock.process_count,
             )
-            } else {
-                (0.0, 0.0, 0.0, 0, 0)
-            }
         };
 
         let hours = uptime_secs / 3600;
@@ -34,11 +36,11 @@ 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)),
-            ]
+            ],
         );
 
         Ok(WaybarOutput {

src/output.rs

@@ -1,6 +1,6 @@
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 
-#[derive(Serialize)]
+#[derive(Serialize, Deserialize, Clone, Debug, Default)]
 pub struct WaybarOutput {
     pub text: String,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -10,3 +10,55 @@ pub struct WaybarOutput {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub percentage: Option<u8>,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_full_output_serialization() {
+        let output = WaybarOutput {
+            text: "CPU: 50%".to_string(),
+            tooltip: Some("Details".to_string()),
+            class: Some("normal".to_string()),
+            percentage: Some(50),
+        };
+        let json = serde_json::to_string(&output).unwrap();
+        let val: serde_json::Value = serde_json::from_str(&json).unwrap();
+        assert_eq!(val["text"], "CPU: 50%");
+        assert_eq!(val["tooltip"], "Details");
+        assert_eq!(val["class"], "normal");
+        assert_eq!(val["percentage"], 50);
+    }
+
+    #[test]
+    fn test_optional_fields_omitted() {
+        let output = WaybarOutput {
+            text: "test".to_string(),
+            tooltip: None,
+            class: None,
+            percentage: None,
+        };
+        let json = serde_json::to_string(&output).unwrap();
+        let val: serde_json::Value = serde_json::from_str(&json).unwrap();
+        assert_eq!(val["text"], "test");
+        assert!(val.get("tooltip").is_none());
+        assert!(val.get("class").is_none());
+        assert!(val.get("percentage").is_none());
+    }
+
+    #[test]
+    fn test_partial_optional_fields() {
+        let output = WaybarOutput {
+            text: "test".to_string(),
+            tooltip: Some("tip".to_string()),
+            class: None,
+            percentage: Some(75),
+        };
+        let json = serde_json::to_string(&output).unwrap();
+        let val: serde_json::Value = serde_json::from_str(&json).unwrap();
+        assert_eq!(val["tooltip"], "tip");
+        assert!(val.get("class").is_none());
+        assert_eq!(val["percentage"], 75);
+    }
+}

src/registry.rs

@@ -0,0 +1,121 @@
+use crate::config::Config;
+use crate::error::{FluxoError, Result as FluxoResult};
+use crate::output::WaybarOutput;
+use crate::state::AppReceivers;
+
+#[allow(unused_imports)]
+use crate::modules::WaybarModule;
+
+pub async fn dispatch(
+    module_name: &str,
+    #[allow(unused)] config: &Config,
+    #[allow(unused)] state: &AppReceivers,
+    #[allow(unused)] args: &[&str],
+) -> FluxoResult<WaybarOutput> {
+    match module_name {
+        #[cfg(feature = "mod-network")]
+        "net" | "network" => {
+            crate::modules::network::NetworkModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-hardware")]
+        "cpu" => {
+            crate::modules::cpu::CpuModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-hardware")]
+        "mem" | "memory" => {
+            crate::modules::memory::MemoryModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-hardware")]
+        "disk" => {
+            crate::modules::disk::DiskModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-hardware")]
+        "pool" | "btrfs" => {
+            crate::modules::btrfs::BtrfsModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-audio")]
+        "vol" | "audio" => {
+            crate::modules::audio::AudioModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-audio")]
+        "mic" => {
+            crate::modules::audio::AudioModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-hardware")]
+        "gpu" => {
+            crate::modules::gpu::GpuModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-hardware")]
+        "sys" => {
+            crate::modules::sys::SysModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-bt")]
+        "bt" | "bluetooth" => crate::modules::bt::BtModule.run(config, state, args).await,
+        #[cfg(feature = "mod-hardware")]
+        "power" => {
+            crate::modules::power::PowerModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-hardware")]
+        "game" => {
+            crate::modules::game::GameModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-dbus")]
+        "backlight" => {
+            crate::modules::backlight::BacklightModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-dbus")]
+        "kbd" | "keyboard" => {
+            crate::modules::keyboard::KeyboardModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-dbus")]
+        "dnd" => {
+            crate::modules::dnd::DndModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-dbus")]
+        "mpris" => {
+            crate::modules::mpris::MprisModule
+                .run(config, state, args)
+                .await
+        }
+        _ => Err(FluxoError::Ipc(format!("Unknown module: {}", module_name))),
+    }
+}
+
+/// Returns the default args used by the signaler when evaluating a module.
+pub fn signaler_default_args(module_name: &str) -> &'static [&'static str] {
+    match module_name {
+        "disk" => &["/"],
+        "vol" | "audio" => &["sink", "show"],
+        "mic" => &["source", "show"],
+        "bt" | "bluetooth" => &["show"],
+        _ => &[],
+    }
+}

src/signaler.rs

@@ -0,0 +1,224 @@
+use crate::config::Config;
+use crate::state::AppReceivers;
+use std::collections::HashMap;
+use std::sync::Arc;
+use sysinfo::{ProcessesToUpdate, System};
+use tokio::sync::RwLock;
+use tokio::time::{Duration, Instant, sleep};
+use tracing::{debug, warn};
+
+pub struct WaybarSignaler {
+    cached_pid: Option<i32>,
+    sys: System,
+    last_signal_sent: HashMap<i32, Instant>,
+}
+
+impl WaybarSignaler {
+    pub fn new() -> Self {
+        Self {
+            cached_pid: None,
+            sys: System::new(),
+            last_signal_sent: HashMap::new(),
+        }
+    }
+
+    fn find_waybar_pid(&mut self) -> Option<i32> {
+        self.sys.refresh_processes(ProcessesToUpdate::All, true);
+        for (pid, process) in self.sys.processes() {
+            if process.name() == "waybar" {
+                return Some(pid.as_u32() as i32);
+            }
+        }
+        None
+    }
+
+    fn send_signal(&mut self, signal_num: i32) {
+        if let Some(last) = self.last_signal_sent.get(&signal_num)
+            && last.elapsed() < Duration::from_millis(50)
+        {
+            return;
+        }
+
+        let mut valid_pid = false;
+        if let Some(pid) = self.cached_pid
+            && unsafe { libc::kill(pid, 0) } == 0
+        {
+            valid_pid = true;
+        }
+
+        if !valid_pid {
+            self.cached_pid = self.find_waybar_pid();
+        }
+
+        if let Some(pid) = self.cached_pid {
+            let sig = libc::SIGRTMIN() + signal_num;
+            if unsafe { libc::kill(pid, sig) } == 0 {
+                debug!("Sent SIGRTMIN+{} to waybar (PID: {})", signal_num, pid);
+                self.last_signal_sent.insert(signal_num, Instant::now());
+            } else {
+                warn!("Failed to send SIGRTMIN+{} to waybar", signal_num);
+                self.cached_pid = None;
+            }
+        } else {
+            debug!("Waybar process not found, skipping signal.");
+        }
+    }
+
+    pub async fn run(mut self, config_lock: Arc<RwLock<Config>>, mut receivers: AppReceivers) {
+        let mut last_outputs: HashMap<&'static str, String> = HashMap::new();
+
+        loop {
+            let signals = config_lock.read().await.signals.clone();
+
+            macro_rules! check_and_signal {
+                ($module_name:expr, $signal_opt:expr) => {
+                    if let Some(sig) = $signal_opt {
+                        let config = config_lock.read().await;
+                        if let Some(out) = crate::daemon::evaluate_module_for_signaler(
+                            $module_name,
+                            &receivers,
+                            &config,
+                        )
+                        .await
+                        {
+                            if last_outputs.get($module_name) != Some(&out) {
+                                last_outputs.insert($module_name, out);
+                                self.send_signal(sig);
+                            }
+                        }
+                    }
+                };
+            }
+
+            // For disabled features, create futures that never resolve
+            #[cfg(not(feature = "mod-network"))]
+            let net_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-network")]
+            let net_changed = receivers.network.changed();
+
+            #[cfg(not(feature = "mod-hardware"))]
+            let cpu_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-hardware")]
+            let cpu_changed = receivers.cpu.changed();
+
+            #[cfg(not(feature = "mod-hardware"))]
+            let mem_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-hardware")]
+            let mem_changed = receivers.memory.changed();
+
+            #[cfg(not(feature = "mod-hardware"))]
+            let sys_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-hardware")]
+            let sys_changed = receivers.sys.changed();
+
+            #[cfg(not(feature = "mod-hardware"))]
+            let gpu_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-hardware")]
+            let gpu_changed = receivers.gpu.changed();
+
+            #[cfg(not(feature = "mod-hardware"))]
+            let disks_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-hardware")]
+            let disks_changed = receivers.disks.changed();
+
+            #[cfg(not(feature = "mod-bt"))]
+            let bt_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-bt")]
+            let bt_changed = receivers.bluetooth.changed();
+
+            #[cfg(not(feature = "mod-audio"))]
+            let audio_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-audio")]
+            let audio_changed = receivers.audio.changed();
+
+            #[cfg(not(feature = "mod-dbus"))]
+            let backlight_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-dbus")]
+            let backlight_changed = receivers.backlight.changed();
+
+            #[cfg(not(feature = "mod-dbus"))]
+            let keyboard_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-dbus")]
+            let keyboard_changed = receivers.keyboard.changed();
+
+            #[cfg(not(feature = "mod-dbus"))]
+            let dnd_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-dbus")]
+            let dnd_changed = receivers.dnd.changed();
+
+            #[cfg(not(feature = "mod-dbus"))]
+            let mpris_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-dbus")]
+            let mpris_changed = receivers.mpris.changed();
+
+            tokio::select! {
+                res = net_changed, if signals.network.is_some() => {
+                    if res.is_ok() { check_and_signal!("net", signals.network); }
+                }
+                res = cpu_changed, if signals.cpu.is_some() => {
+                    if res.is_ok() { check_and_signal!("cpu", signals.cpu); }
+                }
+                res = mem_changed, if signals.memory.is_some() => {
+                    if res.is_ok() { check_and_signal!("mem", signals.memory); }
+                }
+                res = sys_changed, if signals.sys.is_some() => {
+                    if res.is_ok() { check_and_signal!("sys", signals.sys); }
+                }
+                res = gpu_changed, if signals.gpu.is_some() => {
+                    if res.is_ok() { check_and_signal!("gpu", signals.gpu); }
+                }
+                res = disks_changed, if signals.disk.is_some() => {
+                    if res.is_ok() { check_and_signal!("disk", signals.disk); }
+                }
+                res = bt_changed, if signals.bt.is_some() => {
+                    if res.is_ok() { check_and_signal!("bt", signals.bt); }
+                }
+                res = audio_changed, if signals.audio.is_some() => {
+                    if res.is_ok() {
+                        check_and_signal!("vol", signals.audio);
+                        check_and_signal!("mic", signals.audio);
+                    }
+                }
+                res = backlight_changed, if signals.backlight.is_some() => {
+                    if res.is_ok() { check_and_signal!("backlight", signals.backlight); }
+                }
+                res = keyboard_changed, if signals.keyboard.is_some() => {
+                    if res.is_ok() { check_and_signal!("keyboard", signals.keyboard); }
+                }
+                res = dnd_changed, if signals.dnd.is_some() => {
+                    if res.is_ok() { check_and_signal!("dnd", signals.dnd); }
+                }
+                res = mpris_changed, if signals.mpris.is_some() => {
+                    if res.is_ok() { check_and_signal!("mpris", signals.mpris); }
+                }
+                _ = sleep(Duration::from_secs(5)) => {
+                    // loop and refresh config
+                }
+            }
+        }
+    }
+}

src/state.rs

@@ -1,18 +1,100 @@
-use std::sync::{Arc, RwLock};
+use crate::output::WaybarOutput;
+use std::collections::HashMap;
+use std::sync::Arc;
+use tokio::sync::{RwLock, mpsc, watch};
+use tokio::time::Instant;
+
+#[derive(Clone)]
+pub struct AppReceivers {
+    #[cfg(feature = "mod-network")]
+    pub network: watch::Receiver<NetworkState>,
+    #[cfg(feature = "mod-hardware")]
+    pub cpu: watch::Receiver<CpuState>,
+    #[cfg(feature = "mod-hardware")]
+    pub memory: watch::Receiver<MemoryState>,
+    #[cfg(feature = "mod-hardware")]
+    pub sys: watch::Receiver<SysState>,
+    #[cfg(feature = "mod-hardware")]
+    pub gpu: watch::Receiver<GpuState>,
+    #[cfg(feature = "mod-hardware")]
+    pub disks: watch::Receiver<Vec<DiskInfo>>,
+    #[cfg(feature = "mod-bt")]
+    pub bluetooth: watch::Receiver<BtState>,
+    #[cfg(feature = "mod-audio")]
+    pub audio: watch::Receiver<AudioState>,
+    #[cfg(feature = "mod-dbus")]
+    pub mpris: watch::Receiver<MprisState>,
+    #[cfg(feature = "mod-dbus")]
+    pub backlight: watch::Receiver<BacklightState>,
+    #[cfg(feature = "mod-dbus")]
+    pub keyboard: watch::Receiver<KeyboardState>,
+    #[cfg(feature = "mod-dbus")]
+    pub dnd: watch::Receiver<DndState>,
+    pub health: Arc<RwLock<HashMap<String, ModuleHealth>>>,
+    #[cfg(feature = "mod-bt")]
+    pub bt_force_poll: mpsc::Sender<()>,
+    #[cfg(feature = "mod-audio")]
+    pub audio_cmd_tx: mpsc::Sender<crate::modules::audio::AudioCommand>,
+}
+
+#[derive(Clone, Default)]
+pub struct ModuleHealth {
+    pub consecutive_failures: u32,
+    pub last_failure: Option<Instant>,
+    pub backoff_until: Option<Instant>,
+    pub last_successful_output: Option<WaybarOutput>,
+}
 
 #[derive(Default, Clone)]
-pub struct AppState {
-    pub network: NetworkState,
-    pub cpu: CpuState,
-    pub memory: MemoryState,
-    pub sys: SysState,
-    pub gpu: GpuState,
+pub struct AudioState {
+    pub sink: AudioDeviceInfo,
+    pub source: AudioSourceInfo,
+    pub available_sinks: Vec<String>,
+    pub available_sources: Vec<String>,
+}
+
+#[derive(Default, Clone)]
+pub struct AudioDeviceInfo {
+    pub name: String,
+    pub description: String,
+    pub volume: u8,
+    pub muted: bool,
+    pub channels: u8,
+}
+
+#[derive(Default, Clone)]
+pub struct AudioSourceInfo {
+    pub name: String,
+    pub description: String,
+    pub volume: u8,
+    pub muted: bool,
+    pub channels: u8,
+}
+
+#[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)]
+pub struct DiskInfo {
+    pub mount_point: String,
+    pub filesystem: String,
+    pub total_bytes: u64,
+    pub available_bytes: u64,
 }
 
 #[derive(Default, Clone)]
 pub struct NetworkState {
     pub rx_mbps: f64,
     pub tx_mbps: f64,
+    pub interface: String,
+    pub ip: String,
 }
 
 #[derive(Clone)]
@@ -72,4 +154,176 @@ impl Default for GpuState {
     }
 }
 
-pub type SharedState = Arc<RwLock<AppState>>;
+#[derive(Default, Clone)]
+pub struct DndState {
+    pub is_dnd: bool,
+}
+
+#[derive(Default, Clone)]
+pub struct KeyboardState {
+    pub layout: String,
+}
+
+#[derive(Default, Clone)]
+pub struct BacklightState {
+    pub percentage: u8,
+}
+
+#[derive(Default, Clone)]
+pub struct MprisState {
+    pub is_playing: bool,
+    pub is_paused: bool,
+    pub is_stopped: bool,
+    pub artist: String,
+    pub title: String,
+    pub album: String,
+}
+
+#[cfg(test)]
+pub struct MockState {
+    pub receivers: AppReceivers,
+    #[cfg(feature = "mod-network")]
+    _net_tx: watch::Sender<NetworkState>,
+    #[cfg(feature = "mod-hardware")]
+    _cpu_tx: watch::Sender<CpuState>,
+    #[cfg(feature = "mod-hardware")]
+    _mem_tx: watch::Sender<MemoryState>,
+    #[cfg(feature = "mod-hardware")]
+    _sys_tx: watch::Sender<SysState>,
+    #[cfg(feature = "mod-hardware")]
+    _gpu_tx: watch::Sender<GpuState>,
+    #[cfg(feature = "mod-hardware")]
+    _disks_tx: watch::Sender<Vec<DiskInfo>>,
+    #[cfg(feature = "mod-bt")]
+    _bt_tx: watch::Sender<BtState>,
+    #[cfg(feature = "mod-audio")]
+    _audio_tx: watch::Sender<AudioState>,
+    #[cfg(feature = "mod-dbus")]
+    _mpris_tx: watch::Sender<MprisState>,
+    #[cfg(feature = "mod-dbus")]
+    _backlight_tx: watch::Sender<BacklightState>,
+    #[cfg(feature = "mod-dbus")]
+    _keyboard_tx: watch::Sender<KeyboardState>,
+    #[cfg(feature = "mod-dbus")]
+    _dnd_tx: watch::Sender<DndState>,
+}
+
+#[cfg(test)]
+#[derive(Default, Clone)]
+pub struct AppState {
+    #[cfg(feature = "mod-network")]
+    pub network: NetworkState,
+    #[cfg(feature = "mod-hardware")]
+    pub cpu: CpuState,
+    #[cfg(feature = "mod-hardware")]
+    pub memory: MemoryState,
+    #[cfg(feature = "mod-hardware")]
+    pub sys: SysState,
+    #[cfg(feature = "mod-hardware")]
+    pub gpu: GpuState,
+    #[cfg(feature = "mod-hardware")]
+    pub disks: Vec<DiskInfo>,
+    #[cfg(feature = "mod-bt")]
+    pub bluetooth: BtState,
+    #[cfg(feature = "mod-audio")]
+    pub audio: AudioState,
+    #[cfg(feature = "mod-dbus")]
+    pub mpris: MprisState,
+    #[cfg(feature = "mod-dbus")]
+    pub backlight: BacklightState,
+    #[cfg(feature = "mod-dbus")]
+    pub keyboard: KeyboardState,
+    #[cfg(feature = "mod-dbus")]
+    pub dnd: DndState,
+    pub health: HashMap<String, ModuleHealth>,
+}
+
+#[cfg(test)]
+pub fn mock_state(state: AppState) -> MockState {
+    #[cfg(feature = "mod-network")]
+    let (net_tx, net_rx) = watch::channel(state.network);
+    #[cfg(feature = "mod-hardware")]
+    let (cpu_tx, cpu_rx) = watch::channel(state.cpu);
+    #[cfg(feature = "mod-hardware")]
+    let (mem_tx, mem_rx) = watch::channel(state.memory);
+    #[cfg(feature = "mod-hardware")]
+    let (sys_tx, sys_rx) = watch::channel(state.sys);
+    #[cfg(feature = "mod-hardware")]
+    let (gpu_tx, gpu_rx) = watch::channel(state.gpu);
+    #[cfg(feature = "mod-hardware")]
+    let (disks_tx, disks_rx) = watch::channel(state.disks);
+    #[cfg(feature = "mod-bt")]
+    let (bt_tx, bt_rx) = watch::channel(state.bluetooth);
+    #[cfg(feature = "mod-audio")]
+    let (audio_tx, audio_rx) = watch::channel(state.audio);
+    #[cfg(feature = "mod-dbus")]
+    let (mpris_tx, mpris_rx) = watch::channel(state.mpris);
+    #[cfg(feature = "mod-dbus")]
+    let (backlight_tx, backlight_rx) = watch::channel(state.backlight);
+    #[cfg(feature = "mod-dbus")]
+    let (keyboard_tx, keyboard_rx) = watch::channel(state.keyboard);
+    #[cfg(feature = "mod-dbus")]
+    let (dnd_tx, dnd_rx) = watch::channel(state.dnd);
+    #[cfg(feature = "mod-bt")]
+    let (bt_force_tx, _) = mpsc::channel(1);
+    #[cfg(feature = "mod-audio")]
+    let (audio_cmd_tx, _) = mpsc::channel(1);
+
+    MockState {
+        receivers: AppReceivers {
+            #[cfg(feature = "mod-network")]
+            network: net_rx,
+            #[cfg(feature = "mod-hardware")]
+            cpu: cpu_rx,
+            #[cfg(feature = "mod-hardware")]
+            memory: mem_rx,
+            #[cfg(feature = "mod-hardware")]
+            sys: sys_rx,
+            #[cfg(feature = "mod-hardware")]
+            gpu: gpu_rx,
+            #[cfg(feature = "mod-hardware")]
+            disks: disks_rx,
+            #[cfg(feature = "mod-bt")]
+            bluetooth: bt_rx,
+            #[cfg(feature = "mod-audio")]
+            audio: audio_rx,
+            #[cfg(feature = "mod-dbus")]
+            mpris: mpris_rx,
+            #[cfg(feature = "mod-dbus")]
+            backlight: backlight_rx,
+            #[cfg(feature = "mod-dbus")]
+            keyboard: keyboard_rx,
+            #[cfg(feature = "mod-dbus")]
+            dnd: dnd_rx,
+            health: Arc::new(RwLock::new(state.health)),
+            #[cfg(feature = "mod-bt")]
+            bt_force_poll: bt_force_tx,
+            #[cfg(feature = "mod-audio")]
+            audio_cmd_tx,
+        },
+        #[cfg(feature = "mod-network")]
+        _net_tx: net_tx,
+        #[cfg(feature = "mod-hardware")]
+        _cpu_tx: cpu_tx,
+        #[cfg(feature = "mod-hardware")]
+        _mem_tx: mem_tx,
+        #[cfg(feature = "mod-hardware")]
+        _sys_tx: sys_tx,
+        #[cfg(feature = "mod-hardware")]
+        _gpu_tx: gpu_tx,
+        #[cfg(feature = "mod-hardware")]
+        _disks_tx: disks_tx,
+        #[cfg(feature = "mod-bt")]
+        _bt_tx: bt_tx,
+        #[cfg(feature = "mod-audio")]
+        _audio_tx: audio_tx,
+        #[cfg(feature = "mod-dbus")]
+        _mpris_tx: mpris_tx,
+        #[cfg(feature = "mod-dbus")]
+        _backlight_tx: backlight_tx,
+        #[cfg(feature = "mod-dbus")]
+        _keyboard_tx: keyboard_tx,
+        #[cfg(feature = "mod-dbus")]
+        _dnd_tx: dnd_tx,
+    }
+}

src/utils.rs

@@ -3,18 +3,24 @@ use std::io::Write;
 use std::process::{Command, Stdio};
 
 pub fn show_menu(prompt: &str, items: &[String], menu_cmd: &str) -> Result<String> {
+    // Backward compatibility for {prompt}, but environment variable is safer
     let cmd_str = menu_cmd.replace("{prompt}", prompt);
     let mut child = Command::new("sh")
         .arg("-c")
         .arg(&cmd_str)
+        .env("FLUXO_PROMPT", prompt) // Safer shell injection
         .stdin(Stdio::piped())
         .stdout(Stdio::piped())
+        .stderr(Stdio::null()) // Suppress GTK/Wayland warnings from tools like wofi
         .spawn()
         .context("Failed to spawn menu command")?;
 
     if let Some(mut stdin) = child.stdin.take() {
-        let input = items.join("\n");
-        stdin.write_all(input.as_bytes()).context("Failed to write to menu stdin")?;
+        let mut input = items.join("\n");
+        input.push('\n'); // Ensure trailing newline for wofi/rofi
+        stdin
+            .write_all(input.as_bytes())
+            .context("Failed to write to menu stdin")?;
     }
 
     let output = child.wait_with_output().context("Failed to wait on menu")?;
@@ -31,26 +37,74 @@ pub fn show_menu(prompt: &str, items: &[String], menu_cmd: &str) -> Result<Strin
     Ok(selected)
 }
 
+pub fn get_hyprland_socket(socket_name: &str) -> Result<std::path::PathBuf> {
+    let signature = std::env::var("HYPRLAND_INSTANCE_SIGNATURE")
+        .context("HYPRLAND_INSTANCE_SIGNATURE not set")?;
+
+    // Try XDG_RUNTIME_DIR first (usually /run/user/1000)
+    if let Ok(runtime_dir) = std::env::var("XDG_RUNTIME_DIR") {
+        let path = std::path::PathBuf::from(runtime_dir)
+            .join("hypr")
+            .join(&signature)
+            .join(socket_name);
+        if path.exists() {
+            return Ok(path);
+        }
+    }
+
+    // Fallback to /tmp
+    let path = std::path::PathBuf::from("/tmp/hypr")
+        .join(&signature)
+        .join(socket_name);
+
+    if path.exists() {
+        Ok(path)
+    } else {
+        Err(anyhow::anyhow!(
+            "Hyprland socket {} not found in runtime dir or /tmp",
+            socket_name
+        ))
+    }
+}
+
 use regex::Regex;
 use std::sync::LazyLock;
 
-pub enum TokenValue<'a> {
-    Float(f64),
-    Int(i64),
-    String(&'a str),
+pub fn classify_usage(value: f64, high: f64, max: f64) -> &'static str {
+    if value > max {
+        "max"
+    } else if value > high {
+        "high"
+    } else {
+        "normal"
+    }
 }
 
-pub fn format_template(template: &str, values: &[(&str, TokenValue)]) -> String {
-    static RE: LazyLock<Regex> = LazyLock::new(|| {
-        Regex::new(r"\{([a-zA-Z0-9_]+)(?::([<>\^])?(\d+)?(?:\.(\d+))?)?\}").unwrap()
-    });
+pub enum TokenValue {
+    Float(f64),
+    Int(i64),
+    String(String),
+}
 
-    RE.replace_all(template, |caps: &regex::Captures| {
+pub static TOKEN_RE: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"\{([a-zA-Z0-9_]+)(?::([<>\^])?(\d+)?(?:\.(\d+))?)?\}").unwrap());
+
+pub fn format_template<K>(template: &str, values: &[(K, TokenValue)]) -> String
+where
+    K: AsRef<str>,
+{
+    TOKEN_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).map(|m| m.as_str().parse::<usize>().unwrap_or(0)).unwrap_or(0);
-            let precision = caps.get(4).map(|m| m.as_str().parse::<usize>().unwrap_or(0));
+                let width = caps
+                    .get(3)
+                    .map(|m| m.as_str().parse::<usize>().unwrap_or(0))
+                    .unwrap_or(0);
+                let precision = caps
+                    .get(4)
+                    .map(|m| m.as_str().parse::<usize>().unwrap_or(0));
 
                 match val {
                     TokenValue::Float(f) => format_float(*f, align, width, precision),
@@ -60,35 +114,151 @@ pub fn format_template(template: &str, values: &[(&str, TokenValue)]) -> String
             } else {
                 caps[0].to_string()
             }
-    }).into_owned()
+        })
+        .into_owned()
 }
 
 fn format_float(f: f64, align: &str, width: usize, precision: Option<usize>) -> String {
     match (align, precision) {
-        ("<", Some(p)) => format!("{:<width$.p$}", f, width=width, p=p),
-        ("^", Some(p)) => format!("{:^width$.p$}", f, width=width, p=p),
-        (">", Some(p)) => format!("{:>width$.p$}", f, width=width, p=p),
-        ("<", None) => format!("{:<width$}", f, width=width),
-        ("^", None) => format!("{:^width$}", f, width=width),
-        (">", None) => format!("{:>width$}", f, width=width),
+        ("<", Some(p)) => format!("{:<width$.p$}", f, width = width, p = p),
+        ("^", Some(p)) => format!("{:^width$.p$}", f, width = width, p = p),
+        (">", Some(p)) => format!("{:>width$.p$}", f, width = width, p = p),
+        ("<", None) => format!("{:<width$}", f, width = width),
+        ("^", None) => format!("{:^width$}", f, width = width),
+        (">", None) => format!("{:>width$}", f, width = width),
         _ => format!("{}", f),
     }
 }
 
 fn format_int(i: i64, align: &str, width: usize) -> String {
     match align {
-        "<" => format!("{:<width$}", i, width=width),
-        "^" => format!("{:^width$}", i, width=width),
-        ">" => format!("{:>width$}", i, width=width),
+        "<" => format!("{:<width$}", i, width = width),
+        "^" => format!("{:^width$}", i, width = width),
+        ">" => format!("{:>width$}", i, width = width),
         _ => format!("{}", i),
     }
 }
 
 fn format_str(s: &str, align: &str, width: usize) -> String {
     match align {
-        "<" => format!("{:<width$}", s, width=width),
-        "^" => format!("{:^width$}", s, width=width),
-        ">" => format!("{:>width$}", s, width=width),
-        _ => format!("{}", s),
+        "<" => format!("{:<width$}", s, width = width),
+        "^" => format!("{:^width$}", s, width = width),
+        ">" => format!("{:>width$}", s, width = width),
+        _ => s.to_string(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_simple_string_token() {
+        let result = format_template(
+            "{name}",
+            &[("name", TokenValue::String("hello".to_string()))],
+        );
+        assert_eq!(result, "hello");
+    }
+
+    #[test]
+    fn test_simple_float_token() {
+        let result = format_template("{val}", &[("val", TokenValue::Float(3.15))]);
+        assert_eq!(result, "3.15");
+    }
+
+    #[test]
+    fn test_simple_int_token() {
+        let result = format_template("{count}", &[("count", TokenValue::Int(42))]);
+        assert_eq!(result, "42");
+    }
+
+    #[test]
+    fn test_float_right_align_with_precision() {
+        let result = format_template("{val:>8.2}", &[("val", TokenValue::Float(3.15))]);
+        assert_eq!(result, "    3.15");
+        assert_eq!(result.len(), 8);
+    }
+
+    #[test]
+    fn test_float_left_align_with_precision() {
+        let result = format_template("{val:<8.2}", &[("val", TokenValue::Float(3.15))]);
+        assert_eq!(result, "3.15    ");
+        assert_eq!(result.len(), 8);
+    }
+
+    #[test]
+    fn test_float_center_align_with_precision() {
+        let result = format_template("{val:^8.2}", &[("val", TokenValue::Float(3.15))]);
+        assert_eq!(result, "  3.15  ");
+        assert_eq!(result.len(), 8);
+    }
+
+    #[test]
+    fn test_int_right_align() {
+        let result = format_template("{val:>5}", &[("val", TokenValue::Int(42))]);
+        assert_eq!(result, "   42");
+    }
+
+    #[test]
+    fn test_string_left_align() {
+        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".to_string()))],
+        );
+        assert_eq!(result, "{unknown}");
+    }
+
+    #[test]
+    fn test_multiple_tokens() {
+        let result = format_template(
+            "CPU: {usage:>4.1}% {temp:>4.1}C",
+            &[
+                ("usage", TokenValue::Float(55.3)),
+                ("temp", TokenValue::Float(65.0)),
+            ],
+        );
+        assert_eq!(result, "CPU: 55.3% 65.0C");
+    }
+
+    #[test]
+    fn test_no_tokens() {
+        let result = format_template::<&'static str>("plain text", &[]);
+        assert_eq!(result, "plain text");
+    }
+
+    #[test]
+    fn test_empty_template() {
+        let result = format_template("", &[("x", TokenValue::Int(1))]);
+        assert_eq!(result, "");
+    }
+
+    #[test]
+    fn test_mixed_token_types() {
+        let result = format_template(
+            "{name} ({ip}): {rx:>5.2} MB/s",
+            &[
+                ("name", TokenValue::String("eth0".to_string())),
+                ("ip", TokenValue::String("10.0.0.1".to_string())),
+                ("rx", TokenValue::Float(1.5)),
+            ],
+        );
+        assert_eq!(result, "eth0 (10.0.0.1):  1.50 MB/s");
+    }
+
+    #[test]
+    fn test_float_precision_zero() {
+        let result = format_template("{val:>3.0}", &[("val", TokenValue::Float(99.7))]);
+        assert_eq!(result, "100");
     }
 }