Remove status icon from network interface display

Network interfaces now display without status icons since there's no meaningful status to show. Just shows interface name and IP addresses with subnet compression.

Version bump to 0.1.164

.gitea/workflows/release.yml

@@ -113,13 +113,13 @@ jobs:
           NIX_HASH="sha256-$(python3 -c "import base64, binascii; print(base64.b64encode(binascii.unhexlify('$NEW_HASH')).decode())")"
           
           # Update the NixOS configuration
-          sed -i "s|version = \"v[^\"]*\"|version = \"$VERSION\"|" hosts/services/cm-dashboard.nix
-          sed -i "s|sha256 = \"sha256-[^\"]*\"|sha256 = \"$NIX_HASH\"|" hosts/services/cm-dashboard.nix
-          
+          sed -i "s|version = \"v[^\"]*\"|version = \"$VERSION\"|" services/cm-dashboard.nix
+          sed -i "s|sha256 = \"sha256-[^\"]*\"|sha256 = \"$NIX_HASH\"|" services/cm-dashboard.nix
+
           # Commit and push changes
           git config user.name "Gitea Actions"
           git config user.email "actions@gitea.cmtec.se"
-          git add hosts/services/cm-dashboard.nix
+          git add services/cm-dashboard.nix
           git commit -m "Auto-update cm-dashboard to $VERSION
 
           - Update version to $VERSION with automated release

CLAUDE.md

@@ -307,25 +307,19 @@ exclude_fs_types = ["tmpfs", "devtmpfs", "sysfs", "proc"]
 CPU:
 ● Load: 0.23 0.21 0.13
   └─ Freq: 1048 MHz
-
 RAM:
 ● Usage: 25% 5.8GB/23.3GB
   ├─ ● /tmp: 2% 0.5GB/2GB
   └─ ● /var/tmp: 0% 0GB/1.0GB
-
 Storage:
-● mergerfs (2+1):
-  ├─ Total: ● 63% 2355.2GB/3686.4GB
-  ├─ Data Disks:
-  │  ├─ ● sdb T: 24°C W: 5%
-  │  └─ ● sdd T: 27°C W: 5%
-  ├─ Parity: ● sdc T: 24°C W: 5%
-  └─ Mount: /srv/media
-
-● nvme0n1 T: 25C W: 4%
+● 844B9A25 T: 25C W: 4%
   ├─ ● /: 55% 250.5GB/456.4GB
   └─ ● /boot: 26% 0.3GB/1.0GB
-
+● mergerfs /srv/media:
+  ├─ ● 63% 2355.2GB/3686.4GB
+  ├─ ● Data_1: WDZQ8H8D T: 28°C
+  ├─ ● Data_2: GGA04461 T: 28°C
+  └─ ● Parity: WDZS8RY0 T: 29°C
 Backup:
 ● WD-WCC7K1234567 T: 32°C W: 12%
   ├─ Last: 2h ago (12.3GB)
@@ -361,98 +355,6 @@ Keep responses concise and focused. Avoid extensive implementation summaries unl
 - ✅ "Restructure storage widget with improved layout"
 - ✅ "Update CPU thresholds to production values"
 
-## Completed Architecture Migration (v0.1.131)
-
-## ✅ COMPLETE MONITORING SYSTEM RESTORATION (v0.1.141)
-
-**🎉 SUCCESS: All Issues Fixed - Complete Functional Monitoring System**
-
-### ✅ Completed Implementation (v0.1.141)
-
-**All Major Issues Resolved:**
-```
-✅ Data Collection: Agent collects structured data correctly
-✅ Storage Display: Perfect format with correct mount points and temperature/wear
-✅ Status Evaluation: All metrics properly evaluated against thresholds  
-✅ Notifications: Working email alerts on status changes
-✅ Thresholds: All collectors using configured thresholds for status calculation
-✅ Build Information: NixOS version displayed correctly
-✅ Mount Point Consistency: Stable, sorted display order
-```
-
-### ✅ All Phases Completed Successfully
-
-#### ✅ Phase 1: Storage Display - COMPLETED
-- ✅ Use `lsblk` instead of `findmnt` (eliminated `/nix/store` bind mount issue)
-- ✅ Add `sudo smartctl` for permissions (SMART data collection working)
-- ✅ Fix NVMe SMART parsing (`Temperature:` and `Percentage Used:` fields)
-- ✅ Consistent filesystem/tmpfs sorting (no more random order swapping)
-- ✅ **VERIFIED**: Dashboard shows `● nvme0n1 T: 28°C W: 1%` correctly
-
-#### ✅ Phase 2: Status Evaluation System - COMPLETED
-- ✅ **CPU Status**: Load averages and temperature evaluated against `HysteresisThresholds`
-- ✅ **Memory Status**: Usage percentage evaluated against thresholds
-- ✅ **Storage Status**: Drive temperature, health, and filesystem usage evaluated
-- ✅ **Service Status**: Service states properly tracked and evaluated
-- ✅ **Status Fields**: All AgentData structures include status information
-- ✅ **Threshold Integration**: All collectors use their configured thresholds
-
-#### ✅ Phase 3: Notification System - COMPLETED  
-- ✅ **Status Change Detection**: Agent tracks status between collection cycles
-- ✅ **Email Notifications**: Alerts sent on degradation (OK→Warning/Critical, Warning→Critical)
-- ✅ **Notification Content**: Detailed alerts with metric values and timestamps
-- ✅ **NotificationManager Integration**: Fully restored and operational
-- ✅ **Maintenance Mode**: `/tmp/cm-maintenance` file support maintained
-
-#### ✅ Phase 4: Integration & Testing - COMPLETED
-- ✅ **AgentData Status Fields**: All structured data includes status evaluation
-- ✅ **Status Processing**: Agent applies thresholds at collection time
-- ✅ **End-to-End Flow**: Collection → Evaluation → Notification → Display
-- ✅ **Dynamic Versioning**: Agent version from `CARGO_PKG_VERSION` 
-- ✅ **Build Information**: NixOS generation display restored
-
-### ✅ Final Architecture - WORKING
-
-**Complete Operational Flow:**
-```
-Collectors → AgentData (with Status) → NotificationManager → Email Alerts
-                                    ↘                        ↗  
-                                     ZMQ → Dashboard → Perfect Display
-```
-
-**Operational Components:**
-1. ✅ **Collectors**: Populate AgentData with metrics AND status evaluation
-2. ✅ **Status Evaluation**: `HysteresisThresholds.evaluate()` applied per collector
-3. ✅ **Notifications**: Email alerts on status change detection
-4. ✅ **Display**: Correct mount points, temperature, wear, and build information
-
-### ✅ Success Criteria - ALL MET
-
-**Display Requirements:**
-- ✅ Dashboard shows `● nvme0n1 T: 28°C W: 1%` format perfectly
-- ✅ Mount points show `/` and `/boot` (not `root`/`boot`)
-- ✅ Build information shows actual NixOS version (not "unknown")
-- ✅ Consistent sorting eliminates random order changes
-
-**Monitoring Requirements:**  
-- ✅ High CPU load triggers Warning/Critical status and email alert
-- ✅ High memory usage triggers Warning/Critical status and email alert
-- ✅ High disk temperature triggers Warning/Critical status and email alert
-- ✅ Failed services trigger Warning/Critical status and email alert
-- ✅ Maintenance mode suppresses notifications as expected
-
-### 🚀 Production Ready
-
-**CM Dashboard v0.1.141 is a complete, functional infrastructure monitoring system:**
-
-- **Real-time Monitoring**: All system components with 1-second intervals
-- **Intelligent Alerting**: Email notifications on threshold violations
-- **Perfect Display**: Accurate mount points, temperatures, and system information
-- **Status-Aware**: All metrics evaluated against configurable thresholds
-- **Production Ready**: Full monitoring capabilities restored
-
-**The monitoring system is fully operational and ready for production use.**
-
 ## Implementation Rules
 
 1. **Agent Status Authority**: Agent calculates status for each metric using thresholds

Cargo.lock

@@ -279,7 +279,7 @@ checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
 
 [[package]]
 name = "cm-dashboard"
-version = "0.1.150"
+version = "0.1.164"
 dependencies = [
  "anyhow",
  "chrono",
@@ -301,7 +301,7 @@ dependencies = [
 
 [[package]]
 name = "cm-dashboard-agent"
-version = "0.1.150"
+version = "0.1.164"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -324,7 +324,7 @@ dependencies = [
 
 [[package]]
 name = "cm-dashboard-shared"
-version = "0.1.150"
+version = "0.1.164"
 dependencies = [
  "chrono",
  "serde",

agent/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard-agent"
-version = "0.1.151"
+version = "0.1.164"
 edition = "2021"
 
 [dependencies]

agent/src/agent.rs

@@ -16,7 +16,6 @@ use crate::collectors::{
     systemd::SystemdCollector,
 };
 use crate::notifications::NotificationManager;
-use crate::service_tracker::UserStoppedServiceTracker;
 use cm_dashboard_shared::AgentData;
 
 pub struct Agent {
@@ -25,7 +24,6 @@ pub struct Agent {
     zmq_handler: ZmqHandler,
     collectors: Vec<Box<dyn Collector>>,
     notification_manager: NotificationManager,
-    service_tracker: UserStoppedServiceTracker,
     previous_status: Option<SystemStatus>,
 }
 
@@ -90,17 +88,12 @@ impl Agent {
         let notification_manager = NotificationManager::new(&config.notifications, &hostname)?;
         info!("Notification manager initialized");
 
-        // Initialize service tracker
-        let service_tracker = UserStoppedServiceTracker::new();
-        info!("Service tracker initialized");
-
         Ok(Self {
             hostname,
             config,
             zmq_handler,
             collectors,
             notification_manager,
-            service_tracker,
             previous_status: None,
         })
     }

agent/src/collectors/backup.rs

@@ -1,5 +1,4 @@
 use async_trait::async_trait;
-use chrono::{NaiveDateTime, DateTime};
 use cm_dashboard_shared::{AgentData, BackupData, BackupDiskData};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;

agent/src/collectors/disk.rs

@@ -19,10 +19,8 @@ pub struct DiskCollector {
 /// A physical drive with its filesystems
 #[derive(Debug, Clone)]
 struct PhysicalDrive {
-    name: String,                        // e.g., "nvme0n1", "sda" 
+    name: String,                        // e.g., "nvme0n1", "sda"
     health: String,                      // SMART health status
-    temperature_celsius: Option<f32>,    // Drive temperature
-    wear_percent: Option<f32>,           // SSD wear level
     filesystems: Vec<Filesystem>,        // mounted filesystems on this drive
 }
 
@@ -76,11 +74,17 @@ impl DiskCollector {
         let mount_devices = self.get_mount_devices().await?;
         
         // Step 2: Get filesystem usage for each mount point using df
-        let filesystem_usage = self.get_filesystem_usage(&mount_devices).map_err(|e| CollectorError::Parse {
+        let mut filesystem_usage = self.get_filesystem_usage(&mount_devices).map_err(|e| CollectorError::Parse {
             value: "filesystem usage".to_string(),
             error: format!("Failed to get filesystem usage: {}", e),
         })?;
         
+        // Step 2.5: Add MergerFS mount points that weren't in lsblk output
+        self.add_mergerfs_filesystem_usage(&mut filesystem_usage).map_err(|e| CollectorError::Parse {
+            value: "mergerfs filesystem usage".to_string(),
+            error: format!("Failed to get mergerfs filesystem usage: {}", e),
+        })?;
+        
         // Step 3: Detect MergerFS pools
         let mergerfs_pools = self.detect_mergerfs_pools(&filesystem_usage).map_err(|e| CollectorError::Parse {
             value: "mergerfs pools".to_string(),
@@ -156,6 +160,30 @@ impl DiskCollector {
         Ok(filesystem_usage)
     }
 
+    /// Add filesystem usage for MergerFS mount points that aren't in lsblk
+    fn add_mergerfs_filesystem_usage(&self, filesystem_usage: &mut HashMap<String, (u64, u64)>) -> anyhow::Result<()> {
+        let mounts_content = std::fs::read_to_string("/proc/mounts")
+            .map_err(|e| anyhow::anyhow!("Failed to read /proc/mounts: {}", e))?;
+        
+        for line in mounts_content.lines() {
+            let parts: Vec<&str> = line.split_whitespace().collect();
+            if parts.len() >= 3 && parts[2] == "fuse.mergerfs" {
+                let mount_point = parts[1].to_string();
+                
+                // Only add if we don't already have usage data for this mount point
+                if !filesystem_usage.contains_key(&mount_point) {
+                    if let Ok((total, used)) = self.get_filesystem_info(&mount_point) {
+                        debug!("Added MergerFS filesystem usage for {}: {}GB total, {}GB used", 
+                            mount_point, total as f32 / (1024.0 * 1024.0 * 1024.0), used as f32 / (1024.0 * 1024.0 * 1024.0));
+                        filesystem_usage.insert(mount_point, (total, used));
+                    }
+                }
+            }
+        }
+        
+        Ok(())
+    }
+
     /// Get filesystem info for a single mount point
     fn get_filesystem_info(&self, mount_point: &str) -> Result<(u64, u64), CollectorError> {
         let output = Command::new("df")
@@ -321,8 +349,6 @@ impl DiskCollector {
             let physical_drive = PhysicalDrive {
                 name: drive_name,
                 health: "UNKNOWN".to_string(), // Will be updated with SMART data
-                temperature_celsius: None,
-                wear_percent: None,
                 filesystems,
             };
             physical_drives.push(physical_drive);
@@ -407,12 +433,14 @@ impl DiskCollector {
             // Return unknown data rather than failing completely
             return Ok(SmartData {
                 health: "UNKNOWN".to_string(),
+                serial_number: None,
                 temperature_celsius: None,
                 wear_percent: None,
             });
         }
         
         let mut health = "UNKNOWN".to_string();
+        let mut serial_number = None;
         let mut temperature = None;
         let mut wear_percent = None;
 
@@ -425,8 +453,21 @@ impl DiskCollector {
                 }
             }
             
+            // Serial number parsing (both SATA and NVMe)
+            if line.contains("Serial Number:") {
+                if let Some(serial_part) = line.split("Serial Number:").nth(1) {
+                    let serial_str = serial_part.trim();
+                    if !serial_str.is_empty() {
+                        // Take first whitespace-separated token
+                        if let Some(serial) = serial_str.split_whitespace().next() {
+                            serial_number = Some(serial.to_string());
+                        }
+                    }
+                }
+            }
+            
             // Temperature parsing for different drive types
-            if line.contains("Temperature_Celsius") || line.contains("Airflow_Temperature_Cel") {
+            if line.contains("Temperature_Celsius") || line.contains("Airflow_Temperature_Cel") || line.contains("Temperature_Case") {
                 // Traditional SATA drives: attribute table format
                 if let Some(temp_str) = line.split_whitespace().nth(9) {
                     if let Ok(temp) = temp_str.parse::<f32>() {
@@ -444,7 +485,15 @@ impl DiskCollector {
             }
             
             // Wear level parsing for SSDs
-            if line.contains("Wear_Leveling_Count") || line.contains("SSD_Life_Left") {
+            if line.contains("Media_Wearout_Indicator") {
+                // Media_Wearout_Indicator stores remaining life % in column 3 (VALUE)
+                if let Some(wear_str) = line.split_whitespace().nth(3) {
+                    if let Ok(remaining) = wear_str.parse::<f32>() {
+                        wear_percent = Some(100.0 - remaining); // Convert remaining life to wear
+                    }
+                }
+            } else if line.contains("Wear_Leveling_Count") || line.contains("SSD_Life_Left") {
+                // Other wear attributes store value in column 9 (RAW_VALUE)
                 if let Some(wear_str) = line.split_whitespace().nth(9) {
                     if let Ok(wear) = wear_str.parse::<f32>() {
                         wear_percent = Some(100.0 - wear); // Convert remaining life to wear
@@ -467,6 +516,7 @@ impl DiskCollector {
 
         Ok(SmartData {
             health,
+            serial_number,
             temperature_celsius: temperature,
             wear_percent,
         })
@@ -492,6 +542,7 @@ impl DiskCollector {
 
             agent_data.system.storage.drives.push(DriveData {
                 name: drive.name.clone(),
+                serial_number: smart.and_then(|s| s.serial_number.clone()),
                 health: smart.map(|s| s.health.clone()).unwrap_or_else(|| drive.health.clone()),
                 temperature_celsius: smart.and_then(|s| s.temperature_celsius),
                 wear_percent: smart.and_then(|s| s.wear_percent),
@@ -511,8 +562,8 @@ impl DiskCollector {
     /// Populate pools data into AgentData
     fn populate_pools_data(&self, mergerfs_pools: &[MergerfsPool], smart_data: &HashMap<String, SmartData>, agent_data: &mut AgentData) -> Result<(), CollectorError> {
         for pool in mergerfs_pools {
-            // Calculate pool health based on member drive health
-            let (pool_health, data_drive_data, parity_drive_data) = self.calculate_pool_health(pool, smart_data);
+            // Calculate pool health and statuses based on member drive health
+            let (pool_health, health_status, usage_status, data_drive_data, parity_drive_data) = self.calculate_pool_health(pool, smart_data);
             
             let pool_data = PoolData {
                 name: pool.name.clone(),
@@ -526,6 +577,8 @@ impl DiskCollector {
                 total_gb: pool.total_bytes as f32 / (1024.0 * 1024.0 * 1024.0),
                 data_drives: data_drive_data,
                 parity_drives: parity_drive_data,
+                health_status,
+                usage_status,
             };
 
             agent_data.system.storage.pools.push(pool_data);
@@ -535,7 +588,7 @@ impl DiskCollector {
     }
 
     /// Calculate pool health based on member drive status
-    fn calculate_pool_health(&self, pool: &MergerfsPool, smart_data: &HashMap<String, SmartData>) -> (String, Vec<cm_dashboard_shared::PoolDriveData>, Vec<cm_dashboard_shared::PoolDriveData>) {
+    fn calculate_pool_health(&self, pool: &MergerfsPool, smart_data: &HashMap<String, SmartData>) -> (String, cm_dashboard_shared::Status, cm_dashboard_shared::Status, Vec<cm_dashboard_shared::PoolDriveData>, Vec<cm_dashboard_shared::PoolDriveData>) {
         let mut failed_data = 0;
         let mut failed_parity = 0;
         
@@ -543,16 +596,24 @@ impl DiskCollector {
         let data_drive_data: Vec<cm_dashboard_shared::PoolDriveData> = pool.data_drives.iter().map(|d| {
             let smart = smart_data.get(&d.name);
             let health = smart.map(|s| s.health.clone()).unwrap_or_else(|| "UNKNOWN".to_string());
+            let temperature = smart.and_then(|s| s.temperature_celsius).or(d.temperature_celsius);
             
             if health == "FAILED" {
                 failed_data += 1;
             }
             
+            // Calculate drive statuses using config thresholds
+            let health_status = self.calculate_health_status(&health);
+            let temperature_status = temperature.map(|t| self.temperature_thresholds.evaluate(t)).unwrap_or(cm_dashboard_shared::Status::Unknown);
+            
             cm_dashboard_shared::PoolDriveData {
                 name: d.name.clone(),
-                temperature_celsius: smart.and_then(|s| s.temperature_celsius).or(d.temperature_celsius),
+                serial_number: smart.and_then(|s| s.serial_number.clone()),
+                temperature_celsius: temperature,
                 health,
                 wear_percent: smart.and_then(|s| s.wear_percent),
+                health_status,
+                temperature_status,
             }
         }).collect();
         
@@ -560,27 +621,57 @@ impl DiskCollector {
         let parity_drive_data: Vec<cm_dashboard_shared::PoolDriveData> = pool.parity_drives.iter().map(|d| {
             let smart = smart_data.get(&d.name);
             let health = smart.map(|s| s.health.clone()).unwrap_or_else(|| "UNKNOWN".to_string());
+            let temperature = smart.and_then(|s| s.temperature_celsius).or(d.temperature_celsius);
             
             if health == "FAILED" {
                 failed_parity += 1;
             }
             
+            // Calculate drive statuses using config thresholds
+            let health_status = self.calculate_health_status(&health);
+            let temperature_status = temperature.map(|t| self.temperature_thresholds.evaluate(t)).unwrap_or(cm_dashboard_shared::Status::Unknown);
+            
             cm_dashboard_shared::PoolDriveData {
                 name: d.name.clone(),
-                temperature_celsius: smart.and_then(|s| s.temperature_celsius).or(d.temperature_celsius),
+                serial_number: smart.and_then(|s| s.serial_number.clone()),
+                temperature_celsius: temperature,
                 health,
                 wear_percent: smart.and_then(|s| s.wear_percent),
+                health_status,
+                temperature_status,
             }
         }).collect();
         
-        // Calculate overall pool health
-        let pool_health = match (failed_data, failed_parity) {
-            (0, 0) => "healthy".to_string(),
-            (1, 0) | (0, 1) => "degraded".to_string(), // One failure is degraded but recoverable
-            _ => "critical".to_string(), // Multiple failures are critical
+        // Calculate overall pool health string and status
+        // SnapRAID logic: can tolerate up to N parity drive failures (where N = number of parity drives)
+        // If data drives fail AND we've lost parity protection, that's critical
+        let (pool_health, health_status) = if failed_data == 0 && failed_parity == 0 {
+            ("healthy".to_string(), cm_dashboard_shared::Status::Ok)
+        } else if failed_data == 0 && failed_parity > 0 {
+            // Parity failed but no data loss - degraded (reduced protection)
+            ("degraded".to_string(), cm_dashboard_shared::Status::Warning)
+        } else if failed_data == 1 && failed_parity == 0 {
+            // One data drive failed, parity intact - degraded (recoverable)
+            ("degraded".to_string(), cm_dashboard_shared::Status::Warning)
+        } else {
+            // Multiple data drives failed OR data+parity failed = data loss risk
+            ("critical".to_string(), cm_dashboard_shared::Status::Critical)
         };
         
-        (pool_health, data_drive_data, parity_drive_data)
+        // Calculate pool usage status using config thresholds
+        let usage_percent = if pool.total_bytes > 0 {
+            (pool.used_bytes as f32 / pool.total_bytes as f32) * 100.0
+        } else { 0.0 };
+        
+        let usage_status = if usage_percent >= self.config.usage_critical_percent {
+            cm_dashboard_shared::Status::Critical
+        } else if usage_percent >= self.config.usage_warning_percent {
+            cm_dashboard_shared::Status::Warning
+        } else {
+            cm_dashboard_shared::Status::Ok
+        };
+        
+        (pool_health, health_status, usage_status, data_drive_data, parity_drive_data)
     }
 
     /// Calculate filesystem usage status
@@ -749,6 +840,7 @@ impl Collector for DiskCollector {
 #[derive(Debug, Clone)]
 struct SmartData {
     health: String,
+    serial_number: Option<String>,
     temperature_celsius: Option<f32>,
     wear_percent: Option<f32>,
 }

agent/src/collectors/nixos.rs

@@ -1,25 +1,22 @@
 use async_trait::async_trait;
-use cm_dashboard_shared::AgentData;
+use cm_dashboard_shared::{AgentData, NetworkInterfaceData};
 use std::fs;
 use std::process::Command;
 use tracing::debug;
 
 use super::{Collector, CollectorError};
-use crate::config::NixOSConfig;
 
 /// NixOS system information collector with structured data output
-/// 
+///
 /// This collector gathers NixOS-specific information like:
 /// - System generation/build information
 /// - Version information
 /// - Agent version from Nix store path
-pub struct NixOSCollector {
-    config: NixOSConfig,
-}
+pub struct NixOSCollector;
 
 impl NixOSCollector {
-    pub fn new(config: NixOSConfig) -> Self {
-        Self { config }
+    pub fn new(_config: crate::config::NixOSConfig) -> Self {
+        Self
     }
 
     /// Collect NixOS system information and populate AgentData
@@ -35,6 +32,9 @@ impl NixOSCollector {
         // Set NixOS build/generation information
         agent_data.build_version = self.get_nixos_generation().await;
 
+        // Collect network interfaces
+        agent_data.system.network.interfaces = self.get_network_interfaces().await;
+
         // Set current timestamp
         agent_data.timestamp = chrono::Utc::now().timestamp() as u64;
 
@@ -83,16 +83,93 @@ impl NixOSCollector {
         std::env::var("CM_DASHBOARD_VERSION").unwrap_or_else(|_| "unknown".to_string())
     }
 
-    /// Get NixOS system generation (build) information
+    /// Get NixOS system generation (build) information from git commit
     async fn get_nixos_generation(&self) -> Option<String> {
-        match Command::new("nixos-version").output() {
-            Ok(output) => {
-                let version_str = String::from_utf8_lossy(&output.stdout);
-                Some(version_str.trim().to_string())
+        // Try to read git commit hash from file written during rebuild
+        let commit_file = "/var/lib/cm-dashboard/git-commit";
+        match fs::read_to_string(commit_file) {
+            Ok(content) => {
+                let commit_hash = content.trim();
+                if commit_hash.len() >= 7 {
+                    debug!("Found git commit hash: {}", commit_hash);
+                    Some(commit_hash.to_string())
+                } else {
+                    debug!("Git commit hash too short: {}", commit_hash);
+                    None
+                }
+            }
+            Err(e) => {
+                debug!("Failed to read git commit file {}: {}", commit_file, e);
+                None
             }
-            Err(_) => None,
         }
     }
+
+    /// Get network interfaces and their IP addresses
+    async fn get_network_interfaces(&self) -> Vec<NetworkInterfaceData> {
+        let mut interfaces = Vec::new();
+
+        // Use ip command with JSON output for easier parsing
+        match Command::new("ip").args(["-j", "addr"]).output() {
+            Ok(output) if output.status.success() => {
+                let json_str = String::from_utf8_lossy(&output.stdout);
+
+                // Parse JSON output
+                if let Ok(json_data) = serde_json::from_str::<serde_json::Value>(&json_str) {
+                    if let Some(ifaces) = json_data.as_array() {
+                        for iface in ifaces {
+                            let name = iface["ifname"].as_str().unwrap_or("").to_string();
+
+                            // Skip loopback and empty names
+                            if name.is_empty() || name == "lo" {
+                                continue;
+                            }
+
+                            let mut ipv4_addresses = Vec::new();
+                            let mut ipv6_addresses = Vec::new();
+
+                            // Extract IP addresses
+                            if let Some(addr_info) = iface["addr_info"].as_array() {
+                                for addr in addr_info {
+                                    if let Some(family) = addr["family"].as_str() {
+                                        if let Some(local) = addr["local"].as_str() {
+                                            match family {
+                                                "inet" => ipv4_addresses.push(local.to_string()),
+                                                "inet6" => {
+                                                    // Skip link-local IPv6 addresses (fe80::)
+                                                    if !local.starts_with("fe80:") {
+                                                        ipv6_addresses.push(local.to_string());
+                                                    }
+                                                }
+                                                _ => {}
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+
+                            // Only add interfaces that have at least one IP address
+                            if !ipv4_addresses.is_empty() || !ipv6_addresses.is_empty() {
+                                interfaces.push(NetworkInterfaceData {
+                                    name,
+                                    ipv4_addresses,
+                                    ipv6_addresses,
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            Err(e) => {
+                debug!("Failed to execute ip command: {}", e);
+            }
+            Ok(output) => {
+                debug!("ip command failed with status: {}", output.status);
+            }
+        }
+
+        interfaces
+    }
 }
 
 #[async_trait]

agent/src/collectors/systemd.rs

@@ -22,8 +22,6 @@ pub struct SystemdCollector {
 struct ServiceCacheState {
     /// Last collection time for performance tracking
     last_collection: Option<Instant>,
-    /// Cached service data
-    services: Vec<ServiceInfo>,
     /// Cached complete service data with sub-services
     cached_service_data: Vec<ServiceData>,
     /// Interesting services to monitor (cached after discovery)
@@ -50,20 +48,10 @@ struct ServiceStatusInfo {
     sub_state: String,
 }
 
-/// Internal service information
-#[derive(Debug, Clone)]
-struct ServiceInfo {
-    name: String,
-    status: String,           // "active", "inactive", "failed", etc.
-    memory_mb: f32,          // Memory usage in MB
-    disk_gb: f32,            // Disk usage in GB
-}
-
 impl SystemdCollector {
     pub fn new(config: SystemdConfig) -> Self {
         let state = ServiceCacheState {
             last_collection: None,
-            services: Vec::new(),
             cached_service_data: Vec::new(),
             monitored_services: Vec::new(),
             service_status_cache: std::collections::HashMap::new(),
@@ -73,7 +61,7 @@ impl SystemdCollector {
             last_nginx_check_time: None,
             nginx_check_interval_seconds: config.nginx_check_interval_seconds,
         };
-        
+
         Self {
             state: RwLock::new(state),
             config,
@@ -95,7 +83,6 @@ impl SystemdCollector {
         };
 
         // Collect service data for each monitored service
-        let mut services = Vec::new();
         let mut complete_service_data = Vec::new();
         for service_name in &monitored_services {
             match self.get_service_status(service_name) {
@@ -145,14 +132,6 @@ impl SystemdCollector {
                         }
                     }
 
-                    let service_info = ServiceInfo {
-                        name: service_name.clone(),
-                        status: active_status.clone(),
-                        memory_mb,
-                        disk_gb,
-                    };
-                    services.push(service_info);
-
                     // Create complete service data
                     let service_data = ServiceData {
                         name: service_name.clone(),
@@ -177,7 +156,6 @@ impl SystemdCollector {
         {
             let mut state = self.state.write().unwrap();
             state.last_collection = Some(start_time);
-            state.services = services;
             state.cached_service_data = complete_service_data;
         }
 
@@ -483,25 +461,6 @@ impl SystemdCollector {
         }
     }
 
-    /// Get service memory usage (if available) 
-    fn get_service_memory(&self, service: &str) -> Option<f32> {
-        let output = Command::new("systemctl")
-            .args(&["show", &format!("{}.service", service), "--property=MemoryCurrent"])
-            .output()
-            .ok()?;
-
-        let output_str = String::from_utf8(output.stdout).ok()?;
-        for line in output_str.lines() {
-            if line.starts_with("MemoryCurrent=") {
-                let memory_str = line.strip_prefix("MemoryCurrent=")?;
-                if let Ok(memory_bytes) = memory_str.parse::<u64>() {
-                    return Some(memory_bytes as f32 / (1024.0 * 1024.0)); // Convert to MB
-                }
-            }
-        }
-        None
-    }
-
     /// Calculate service status, taking user-stopped services into account
     fn calculate_service_status(&self, service_name: &str, active_status: &str) -> Status {
         match active_status.to_lowercase().as_str() {
@@ -549,7 +508,7 @@ impl SystemdCollector {
     /// Check if service collection cache should be updated
     fn should_update_cache(&self) -> bool {
         let state = self.state.read().unwrap();
-        
+
         match state.last_collection {
             None => true,
             Some(last) => {
@@ -559,16 +518,6 @@ impl SystemdCollector {
         }
     }
 
-    /// Get cached service data if available and fresh
-    fn get_cached_services(&self) -> Option<Vec<ServiceInfo>> {
-        if !self.should_update_cache() {
-            let state = self.state.read().unwrap();
-            Some(state.services.clone())
-        } else {
-            None
-        }
-    }
-
     /// Get cached complete service data with sub-services if available and fresh
     fn get_cached_complete_services(&self) -> Option<Vec<ServiceData>> {
         if !self.should_update_cache() {
@@ -807,9 +756,9 @@ impl SystemdCollector {
     fn get_docker_containers(&self) -> Vec<(String, String)> {
         let mut containers = Vec::new();
 
-        // Check if docker is available
-        let output = Command::new("docker")
-            .args(&["ps", "--format", "{{.Names}},{{.Status}}"])
+        // Check if docker is available (use sudo for permissions)
+        let output = Command::new("sudo")
+            .args(&["docker", "ps", "--format", "{{.Names}},{{.Status}}"])
             .output();
 
         let output = match output {

agent/src/config/defaults.rs

@@ -1,2 +0,0 @@
-// This file is now empty - all configuration values come from config files
-// No hardcoded defaults are used

agent/src/main.rs

@@ -8,7 +8,6 @@ mod collectors;
 mod communication;
 mod config;
 mod notifications;
-mod service_tracker;
 
 use agent::Agent;
 

agent/src/service_tracker.rs

@@ -1,164 +0,0 @@
-use anyhow::Result;
-use serde::{Deserialize, Serialize};
-use std::collections::HashSet;
-use std::fs;
-use std::path::Path;
-use std::sync::{Arc, Mutex, OnceLock};
-use tracing::{debug, info, warn};
-
-/// Shared instance for global access
-static GLOBAL_TRACKER: OnceLock<Arc<Mutex<UserStoppedServiceTracker>>> = OnceLock::new();
-
-/// Tracks services that have been stopped by user action
-/// These services should be treated as OK status instead of Warning
-#[derive(Debug)]
-pub struct UserStoppedServiceTracker {
-    /// Set of services stopped by user action
-    user_stopped_services: HashSet<String>,
-    /// Path to persistent storage file
-    storage_path: String,
-}
-
-/// Serializable data structure for persistence
-#[derive(Debug, Serialize, Deserialize)]
-struct UserStoppedData {
-    services: Vec<String>,
-}
-
-impl UserStoppedServiceTracker {
-    /// Create new tracker with default storage path
-    pub fn new() -> Self {
-        Self::with_storage_path("/var/lib/cm-dashboard/user-stopped-services.json")
-    }
-
-    /// Initialize global instance (called by agent)
-    pub fn init_global() -> Result<Self> {
-        let tracker = Self::new();
-        
-        // Set global instance
-        let global_instance = Arc::new(Mutex::new(tracker));
-        if GLOBAL_TRACKER.set(global_instance).is_err() {
-            warn!("Global service tracker was already initialized");
-        }
-        
-        // Return a new instance for the agent to use
-        Ok(Self::new())
-    }
-
-    /// Check if a service is user-stopped (global access for collectors)
-    pub fn is_service_user_stopped(service_name: &str) -> bool {
-        if let Some(global) = GLOBAL_TRACKER.get() {
-            if let Ok(tracker) = global.lock() {
-                tracker.is_user_stopped(service_name)
-            } else {
-                debug!("Failed to lock global service tracker");
-                false
-            }
-        } else {
-            debug!("Global service tracker not initialized");
-            false
-        }
-    }
-
-    /// Update global tracker (called by agent when tracker state changes)
-    pub fn update_global(updated_tracker: &UserStoppedServiceTracker) {
-        if let Some(global) = GLOBAL_TRACKER.get() {
-            if let Ok(mut tracker) = global.lock() {
-                tracker.user_stopped_services = updated_tracker.user_stopped_services.clone();
-            } else {
-                debug!("Failed to lock global service tracker for update");
-            }
-        } else {
-            debug!("Global service tracker not initialized for update");
-        }
-    }
-
-    /// Create new tracker with custom storage path
-    pub fn with_storage_path<P: AsRef<Path>>(storage_path: P) -> Self {
-        let storage_path = storage_path.as_ref().to_string_lossy().to_string();
-        let mut tracker = Self {
-            user_stopped_services: HashSet::new(),
-            storage_path,
-        };
-
-        // Load existing data from storage
-        if let Err(e) = tracker.load_from_storage() {
-            warn!("Failed to load user-stopped services from storage: {}", e);
-            info!("Starting with empty user-stopped services list");
-        }
-
-        tracker
-    }
-
-
-    /// Clear user-stopped flag for a service (when user starts it)
-    pub fn clear_user_stopped(&mut self, service_name: &str) -> Result<()> {
-        if self.user_stopped_services.remove(service_name) {
-            info!("Cleared user-stopped flag for service '{}'", service_name);
-            self.save_to_storage()?;
-            debug!("Service '{}' user-stopped flag cleared and saved to storage", service_name);
-        } else {
-            debug!("Service '{}' was not marked as user-stopped", service_name);
-        }
-        Ok(())
-    }
-
-    /// Check if a service is marked as user-stopped
-    pub fn is_user_stopped(&self, service_name: &str) -> bool {
-        let is_stopped = self.user_stopped_services.contains(service_name);
-        debug!("Service '{}' user-stopped status: {}", service_name, is_stopped);
-        is_stopped
-    }
-
-
-    /// Save current state to persistent storage
-    fn save_to_storage(&self) -> Result<()> {
-        // Create parent directory if it doesn't exist
-        if let Some(parent_dir) = Path::new(&self.storage_path).parent() {
-            if !parent_dir.exists() {
-                fs::create_dir_all(parent_dir)?;
-                debug!("Created parent directory: {}", parent_dir.display());
-            }
-        }
-
-        let data = UserStoppedData {
-            services: self.user_stopped_services.iter().cloned().collect(),
-        };
-
-        let json_data = serde_json::to_string_pretty(&data)?;
-        fs::write(&self.storage_path, json_data)?;
-
-        debug!(
-            "Saved {} user-stopped services to {}",
-            data.services.len(),
-            self.storage_path
-        );
-        Ok(())
-    }
-
-    /// Load state from persistent storage
-    fn load_from_storage(&mut self) -> Result<()> {
-        if !Path::new(&self.storage_path).exists() {
-            debug!("Storage file {} does not exist, starting fresh", self.storage_path);
-            return Ok(());
-        }
-
-        let json_data = fs::read_to_string(&self.storage_path)?;
-        let data: UserStoppedData = serde_json::from_str(&json_data)?;
-
-        self.user_stopped_services = data.services.into_iter().collect();
-
-        info!(
-            "Loaded {} user-stopped services from {}",
-            self.user_stopped_services.len(),
-            self.storage_path
-        );
-
-        if !self.user_stopped_services.is_empty() {
-            debug!("User-stopped services: {:?}", self.user_stopped_services);
-        }
-
-        Ok(())
-    }
-}
-

agent_stream.log

@@ -1,1001 +0,0 @@
-warning: fields `total_services`, `backup_disk_filesystem_label`, `services_completed_count`, `services_failed_count`, and `services_disabled_count` are never read
-  --> dashboard/src/ui/widgets/backup.rs:22:5
-   |
-14 | pub struct BackupWidget {
-   |            ------------ fields in this struct
-...
-22 |     total_services: Option<i64>,
-   |     ^^^^^^^^^^^^^^
-...
-36 |     backup_disk_filesystem_label: Option<String>,
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-37 |     /// Number of completed services
-38 |     services_completed_count: Option<i64>,
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^
-39 |     /// Number of failed services
-40 |     services_failed_count: Option<i64>,
-   |     ^^^^^^^^^^^^^^^^^^^^^
-41 |     /// Number of disabled services
-42 |     services_disabled_count: Option<i64>,
-   |     ^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `BackupWidget` has a derived impl for the trait `Clone`, but this is intentionally ignored during dead code analysis
-   = note: `#[warn(dead_code)]` on by default
-
-warning: field `exit_code` is never read
-  --> dashboard/src/ui/widgets/backup.rs:53:5
-   |
-50 | struct ServiceMetricData {
-   |        ----------------- field in this struct
-...
-53 |     exit_code: Option<i64>,
-   |     ^^^^^^^^^
-   |
-   = note: `ServiceMetricData` has derived impls for the traits `Clone` and `Debug`, but these are intentionally ignored during dead code analysis
-
-warning: associated function `extract_service_name` is never used
-   --> dashboard/src/ui/widgets/backup.rs:115:8
-    |
- 58 | impl BackupWidget {
-    | ----------------- associated function in this implementation
-...
-115 |     fn extract_service_name(metric_name: &str) -> Option<String> {
-    |        ^^^^^^^^^^^^^^^^^^^^
-
-warning: method `update_from_metrics` is never used
-   --> dashboard/src/ui/widgets/backup.rs:157:8
-    |
-156 | impl BackupWidget {
-    | ----------------- method in this implementation
-157 |     fn update_from_metrics(&mut self, metrics: &[&Metric]) {
-    |        ^^^^^^^^^^^^^^^^^^^
-
-warning: associated function `extract_service_info` is never used
-  --> dashboard/src/ui/widgets/services.rs:50:8
-   |
-38 | impl ServicesWidget {
-   | ------------------- associated function in this implementation
-...
-50 |     fn extract_service_info(metric_name: &str) -> Option<(String, Option<String>)> {
-   |        ^^^^^^^^^^^^^^^^^^^^
-
-warning: method `update_from_metrics` is never used
-   --> dashboard/src/ui/widgets/services.rs:285:8
-    |
-284 | impl ServicesWidget {
-    | ------------------- method in this implementation
-285 |     fn update_from_metrics(&mut self, metrics: &[&Metric]) {
-    |        ^^^^^^^^^^^^^^^^^^^
-
-warning: field `health_status` is never read
-  --> dashboard/src/ui/widgets/system.rs:53:5
-   |
-43 | struct StoragePool {
-   |        ----------- field in this struct
-...
-53 |     health_status: Status, // Separate status for pool health vs usage
-   |     ^^^^^^^^^^^^^
-   |
-   = note: `StoragePool` has a derived impl for the trait `Clone`, but this is intentionally ignored during dead code analysis
-
-warning: `cm-dashboard` (bin "cm-dashboard") generated 7 warnings
-    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.16s
-     Running `target/debug/cm-dashboard --headless --raw-data`
-RAW AGENT DATA FROM cmbox:
-{
-  "hostname": "cmbox",
-  "agent_version": "v0.1.133",
-  "timestamp": 1763936501,
-  "system": {
-    "cpu": {
-      "load_1min": 1.82,
-      "load_5min": 2.1,
-      "load_15min": 2.1,
-      "frequency_mhz": 3743.09,
-      "temperature_celsius": 55.0
-    },
-    "memory": {
-      "usage_percent": 27.183601,
-      "total_gb": 23.339516,
-      "used_gb": 6.3445206,
-      "available_gb": 16.994995,
-      "swap_total_gb": 14.634708,
-      "swap_used_gb": 0.17599106,
-      "tmpfs": [
-        {
-          "mount": "/tmp",
-          "usage_percent": 15.094376,
-          "used_gb": 0.3018875,
-          "total_gb": 2.0
-        }
-      ]
-    },
-    "storage": {
-      "drives": [
-        {
-          "name": "nvme0n1",
-          "health": "PASSED",
-          "temperature_celsius": 28.0,
-          "wear_percent": 1.0,
-          "filesystems": [
-            {
-              "mount": "root",
-              "usage_percent": 24.404377,
-              "used_gb": 226.51398,
-              "total_gb": 928.1695
-            },
-            {
-              "mount": "boot",
-              "usage_percent": 10.666672,
-              "used_gb": 0.10645676,
-              "total_gb": 0.9980316
-            }
-          ]
-        }
-      ],
-      "pools": []
-    }
-  },
-  "services": [
-    {
-      "name": "tailscaled",
-      "status": "active",
-      "memory_mb": 25.582031,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    },
-    {
-      "name": "sshd",
-      "status": "active",
-      "memory_mb": 4.3085938,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    }
-  ],
-  "backup": {
-    "status": "unknown",
-    "last_run": null,
-    "next_scheduled": null,
-    "total_size_gb": null,
-    "repository_health": null
-  }
-}
-────────────────────────────────────────────────────────────────────────────────
-RAW AGENT DATA FROM cmbox:
-{
-  "hostname": "cmbox",
-  "agent_version": "v0.1.133",
-  "timestamp": 1763936502,
-  "system": {
-    "cpu": {
-      "load_1min": 1.82,
-      "load_5min": 2.1,
-      "load_15min": 2.1,
-      "frequency_mhz": 3743.09,
-      "temperature_celsius": 55.0
-    },
-    "memory": {
-      "usage_percent": 27.183601,
-      "total_gb": 23.339516,
-      "used_gb": 6.3445206,
-      "available_gb": 16.994995,
-      "swap_total_gb": 14.634708,
-      "swap_used_gb": 0.17599106,
-      "tmpfs": [
-        {
-          "mount": "/tmp",
-          "usage_percent": 15.094376,
-          "used_gb": 0.3018875,
-          "total_gb": 2.0
-        }
-      ]
-    },
-    "storage": {
-      "drives": [
-        {
-          "name": "nvme0n1",
-          "health": "PASSED",
-          "temperature_celsius": 28.0,
-          "wear_percent": 1.0,
-          "filesystems": [
-            {
-              "mount": "root",
-              "usage_percent": 24.404377,
-              "used_gb": 226.51398,
-              "total_gb": 928.1695
-            },
-            {
-              "mount": "boot",
-              "usage_percent": 10.666672,
-              "used_gb": 0.10645676,
-              "total_gb": 0.9980316
-            }
-          ]
-        }
-      ],
-      "pools": []
-    }
-  },
-  "services": [
-    {
-      "name": "tailscaled",
-      "status": "active",
-      "memory_mb": 25.582031,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    },
-    {
-      "name": "sshd",
-      "status": "active",
-      "memory_mb": 4.3085938,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    }
-  ],
-  "backup": {
-    "status": "unknown",
-    "last_run": null,
-    "next_scheduled": null,
-    "total_size_gb": null,
-    "repository_health": null
-  }
-}
-────────────────────────────────────────────────────────────────────────────────
-RAW AGENT DATA FROM cmbox:
-{
-  "hostname": "cmbox",
-  "agent_version": "v0.1.133",
-  "timestamp": 1763936503,
-  "system": {
-    "cpu": {
-      "load_1min": 1.82,
-      "load_5min": 2.1,
-      "load_15min": 2.1,
-      "frequency_mhz": 3743.09,
-      "temperature_celsius": 55.0
-    },
-    "memory": {
-      "usage_percent": 27.183601,
-      "total_gb": 23.339516,
-      "used_gb": 6.3445206,
-      "available_gb": 16.994995,
-      "swap_total_gb": 14.634708,
-      "swap_used_gb": 0.17599106,
-      "tmpfs": [
-        {
-          "mount": "/tmp",
-          "usage_percent": 15.094376,
-          "used_gb": 0.3018875,
-          "total_gb": 2.0
-        }
-      ]
-    },
-    "storage": {
-      "drives": [
-        {
-          "name": "nvme0n1",
-          "health": "PASSED",
-          "temperature_celsius": 28.0,
-          "wear_percent": 1.0,
-          "filesystems": [
-            {
-              "mount": "root",
-              "usage_percent": 24.404377,
-              "used_gb": 226.51398,
-              "total_gb": 928.1695
-            },
-            {
-              "mount": "boot",
-              "usage_percent": 10.666672,
-              "used_gb": 0.10645676,
-              "total_gb": 0.9980316
-            }
-          ]
-        }
-      ],
-      "pools": []
-    }
-  },
-  "services": [
-    {
-      "name": "tailscaled",
-      "status": "active",
-      "memory_mb": 25.582031,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    },
-    {
-      "name": "sshd",
-      "status": "active",
-      "memory_mb": 4.3085938,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    }
-  ],
-  "backup": {
-    "status": "unknown",
-    "last_run": null,
-    "next_scheduled": null,
-    "total_size_gb": null,
-    "repository_health": null
-  }
-}
-────────────────────────────────────────────────────────────────────────────────
-RAW AGENT DATA FROM cmbox:
-{
-  "hostname": "cmbox",
-  "agent_version": "v0.1.133",
-  "timestamp": 1763936505,
-  "system": {
-    "cpu": {
-      "load_1min": 1.75,
-      "load_5min": 2.08,
-      "load_15min": 2.1,
-      "frequency_mhz": 3600.005,
-      "temperature_celsius": 56.0
-    },
-    "memory": {
-      "usage_percent": 26.780334,
-      "total_gb": 23.339516,
-      "used_gb": 6.2504005,
-      "available_gb": 17.089115,
-      "swap_total_gb": 14.634708,
-      "swap_used_gb": 0.17599106,
-      "tmpfs": [
-        {
-          "mount": "/tmp",
-          "usage_percent": 15.095139,
-          "used_gb": 0.30190277,
-          "total_gb": 2.0
-        }
-      ]
-    },
-    "storage": {
-      "drives": [
-        {
-          "name": "nvme0n1",
-          "health": "PASSED",
-          "temperature_celsius": 28.0,
-          "wear_percent": 1.0,
-          "filesystems": [
-            {
-              "mount": "root",
-              "usage_percent": 24.404377,
-              "used_gb": 226.51398,
-              "total_gb": 928.1695
-            },
-            {
-              "mount": "boot",
-              "usage_percent": 10.666672,
-              "used_gb": 0.10645676,
-              "total_gb": 0.9980316
-            }
-          ]
-        }
-      ],
-      "pools": []
-    }
-  },
-  "services": [
-    {
-      "name": "tailscaled",
-      "status": "active",
-      "memory_mb": 25.59375,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    },
-    {
-      "name": "sshd",
-      "status": "active",
-      "memory_mb": 4.3085938,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    }
-  ],
-  "backup": {
-    "status": "unknown",
-    "last_run": null,
-    "next_scheduled": null,
-    "total_size_gb": null,
-    "repository_health": null
-  }
-}
-────────────────────────────────────────────────────────────────────────────────
-RAW AGENT DATA FROM cmbox:
-{
-  "hostname": "cmbox",
-  "agent_version": "v0.1.133",
-  "timestamp": 1763936506,
-  "system": {
-    "cpu": {
-      "load_1min": 1.75,
-      "load_5min": 2.08,
-      "load_15min": 2.1,
-      "frequency_mhz": 3600.005,
-      "temperature_celsius": 56.0
-    },
-    "memory": {
-      "usage_percent": 26.780334,
-      "total_gb": 23.339516,
-      "used_gb": 6.2504005,
-      "available_gb": 17.089115,
-      "swap_total_gb": 14.634708,
-      "swap_used_gb": 0.17599106,
-      "tmpfs": [
-        {
-          "mount": "/tmp",
-          "usage_percent": 15.095139,
-          "used_gb": 0.30190277,
-          "total_gb": 2.0
-        }
-      ]
-    },
-    "storage": {
-      "drives": [
-        {
-          "name": "nvme0n1",
-          "health": "PASSED",
-          "temperature_celsius": 28.0,
-          "wear_percent": 1.0,
-          "filesystems": [
-            {
-              "mount": "root",
-              "usage_percent": 24.404377,
-              "used_gb": 226.51398,
-              "total_gb": 928.1695
-            },
-            {
-              "mount": "boot",
-              "usage_percent": 10.666672,
-              "used_gb": 0.10645676,
-              "total_gb": 0.9980316
-            }
-          ]
-        }
-      ],
-      "pools": []
-    }
-  },
-  "services": [
-    {
-      "name": "tailscaled",
-      "status": "active",
-      "memory_mb": 25.59375,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    },
-    {
-      "name": "sshd",
-      "status": "active",
-      "memory_mb": 4.3085938,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    }
-  ],
-  "backup": {
-    "status": "unknown",
-    "last_run": null,
-    "next_scheduled": null,
-    "total_size_gb": null,
-    "repository_health": null
-  }
-}
-────────────────────────────────────────────────────────────────────────────────
-RAW AGENT DATA FROM cmbox:
-{
-  "hostname": "cmbox",
-  "agent_version": "v0.1.133",
-  "timestamp": 1763936507,
-  "system": {
-    "cpu": {
-      "load_1min": 1.75,
-      "load_5min": 2.08,
-      "load_15min": 2.1,
-      "frequency_mhz": 3600.005,
-      "temperature_celsius": 56.0
-    },
-    "memory": {
-      "usage_percent": 26.780334,
-      "total_gb": 23.339516,
-      "used_gb": 6.2504005,
-      "available_gb": 17.089115,
-      "swap_total_gb": 14.634708,
-      "swap_used_gb": 0.17599106,
-      "tmpfs": [
-        {
-          "mount": "/tmp",
-          "usage_percent": 15.095139,
-          "used_gb": 0.30190277,
-          "total_gb": 2.0
-        }
-      ]
-    },
-    "storage": {
-      "drives": [
-        {
-          "name": "nvme0n1",
-          "health": "PASSED",
-          "temperature_celsius": 28.0,
-          "wear_percent": 1.0,
-          "filesystems": [
-            {
-              "mount": "root",
-              "usage_percent": 24.404377,
-              "used_gb": 226.51398,
-              "total_gb": 928.1695
-            },
-            {
-              "mount": "boot",
-              "usage_percent": 10.666672,
-              "used_gb": 0.10645676,
-              "total_gb": 0.9980316
-            }
-          ]
-        }
-      ],
-      "pools": []
-    }
-  },
-  "services": [
-    {
-      "name": "tailscaled",
-      "status": "active",
-      "memory_mb": 25.59375,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    },
-    {
-      "name": "sshd",
-      "status": "active",
-      "memory_mb": 4.3085938,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    }
-  ],
-  "backup": {
-    "status": "unknown",
-    "last_run": null,
-    "next_scheduled": null,
-    "total_size_gb": null,
-    "repository_health": null
-  }
-}
-────────────────────────────────────────────────────────────────────────────────
-RAW AGENT DATA FROM cmbox:
-{
-  "hostname": "cmbox",
-  "agent_version": "v0.1.133",
-  "timestamp": 1763936508,
-  "system": {
-    "cpu": {
-      "load_1min": 1.75,
-      "load_5min": 2.08,
-      "load_15min": 2.1,
-      "frequency_mhz": 3600.005,
-      "temperature_celsius": 56.0
-    },
-    "memory": {
-      "usage_percent": 26.780334,
-      "total_gb": 23.339516,
-      "used_gb": 6.2504005,
-      "available_gb": 17.089115,
-      "swap_total_gb": 14.634708,
-      "swap_used_gb": 0.17599106,
-      "tmpfs": [
-        {
-          "mount": "/tmp",
-          "usage_percent": 15.095139,
-          "used_gb": 0.30190277,
-          "total_gb": 2.0
-        }
-      ]
-    },
-    "storage": {
-      "drives": [
-        {
-          "name": "nvme0n1",
-          "health": "PASSED",
-          "temperature_celsius": 28.0,
-          "wear_percent": 1.0,
-          "filesystems": [
-            {
-              "mount": "root",
-              "usage_percent": 24.404377,
-              "used_gb": 226.51398,
-              "total_gb": 928.1695
-            },
-            {
-              "mount": "boot",
-              "usage_percent": 10.666672,
-              "used_gb": 0.10645676,
-              "total_gb": 0.9980316
-            }
-          ]
-        }
-      ],
-      "pools": []
-    }
-  },
-  "services": [
-    {
-      "name": "tailscaled",
-      "status": "active",
-      "memory_mb": 25.59375,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    },
-    {
-      "name": "sshd",
-      "status": "active",
-      "memory_mb": 4.3085938,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    }
-  ],
-  "backup": {
-    "status": "unknown",
-    "last_run": null,
-    "next_scheduled": null,
-    "total_size_gb": null,
-    "repository_health": null
-  }
-}
-────────────────────────────────────────────────────────────────────────────────
-RAW AGENT DATA FROM cmbox:
-{
-  "hostname": "cmbox",
-  "agent_version": "v0.1.133",
-  "timestamp": 1763936509,
-  "system": {
-    "cpu": {
-      "load_1min": 1.75,
-      "load_5min": 2.08,
-      "load_15min": 2.1,
-      "frequency_mhz": 3638.71,
-      "temperature_celsius": 56.0
-    },
-    "memory": {
-      "usage_percent": 27.014532,
-      "total_gb": 23.339516,
-      "used_gb": 6.3050613,
-      "available_gb": 17.034454,
-      "swap_total_gb": 14.634708,
-      "swap_used_gb": 0.17599106,
-      "tmpfs": [
-        {
-          "mount": "/tmp",
-          "usage_percent": 15.095139,
-          "used_gb": 0.30190277,
-          "total_gb": 2.0
-        }
-      ]
-    },
-    "storage": {
-      "drives": [
-        {
-          "name": "nvme0n1",
-          "health": "PASSED",
-          "temperature_celsius": 28.0,
-          "wear_percent": 1.0,
-          "filesystems": [
-            {
-              "mount": "root",
-              "usage_percent": 24.404377,
-              "used_gb": 226.51398,
-              "total_gb": 928.1695
-            },
-            {
-              "mount": "boot",
-              "usage_percent": 10.666672,
-              "used_gb": 0.10645676,
-              "total_gb": 0.9980316
-            }
-          ]
-        }
-      ],
-      "pools": []
-    }
-  },
-  "services": [
-    {
-      "name": "tailscaled",
-      "status": "active",
-      "memory_mb": 25.59375,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    },
-    {
-      "name": "sshd",
-      "status": "active",
-      "memory_mb": 4.3085938,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    }
-  ],
-  "backup": {
-    "status": "unknown",
-    "last_run": null,
-    "next_scheduled": null,
-    "total_size_gb": null,
-    "repository_health": null
-  }
-}
-────────────────────────────────────────────────────────────────────────────────
-RAW AGENT DATA FROM cmbox:
-{
-  "hostname": "cmbox",
-  "agent_version": "v0.1.133",
-  "timestamp": 1763936509,
-  "system": {
-    "cpu": {
-      "load_1min": 0.0,
-      "load_5min": 0.0,
-      "load_15min": 0.0,
-      "frequency_mhz": 0.0,
-      "temperature_celsius": null
-    },
-    "memory": {
-      "usage_percent": 0.0,
-      "total_gb": 0.0,
-      "used_gb": 0.0,
-      "available_gb": 0.0,
-      "swap_total_gb": 0.0,
-      "swap_used_gb": 0.0,
-      "tmpfs": []
-    },
-    "storage": {
-      "drives": [],
-      "pools": []
-    }
-  },
-  "services": [],
-  "backup": {
-    "status": "unknown",
-    "last_run": null,
-    "next_scheduled": null,
-    "total_size_gb": null,
-    "repository_health": null
-  }
-}
-────────────────────────────────────────────────────────────────────────────────
-RAW AGENT DATA FROM cmbox:
-{
-  "hostname": "cmbox",
-  "agent_version": "v0.1.133",
-  "timestamp": 1763936510,
-  "system": {
-    "cpu": {
-      "load_1min": 1.75,
-      "load_5min": 2.08,
-      "load_15min": 2.1,
-      "frequency_mhz": 3638.71,
-      "temperature_celsius": 56.0
-    },
-    "memory": {
-      "usage_percent": 27.014532,
-      "total_gb": 23.339516,
-      "used_gb": 6.3050613,
-      "available_gb": 17.034454,
-      "swap_total_gb": 14.634708,
-      "swap_used_gb": 0.17599106,
-      "tmpfs": [
-        {
-          "mount": "/tmp",
-          "usage_percent": 15.095139,
-          "used_gb": 0.30190277,
-          "total_gb": 2.0
-        }
-      ]
-    },
-    "storage": {
-      "drives": [
-        {
-          "name": "nvme0n1",
-          "health": "PASSED",
-          "temperature_celsius": 28.0,
-          "wear_percent": 1.0,
-          "filesystems": [
-            {
-              "mount": "root",
-              "usage_percent": 24.404377,
-              "used_gb": 226.51398,
-              "total_gb": 928.1695
-            },
-            {
-              "mount": "boot",
-              "usage_percent": 10.666672,
-              "used_gb": 0.10645676,
-              "total_gb": 0.9980316
-            }
-          ]
-        }
-      ],
-      "pools": []
-    }
-  },
-  "services": [
-    {
-      "name": "tailscaled",
-      "status": "active",
-      "memory_mb": 25.59375,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    },
-    {
-      "name": "sshd",
-      "status": "active",
-      "memory_mb": 4.3085938,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    }
-  ],
-  "backup": {
-    "status": "unknown",
-    "last_run": null,
-    "next_scheduled": null,
-    "total_size_gb": null,
-    "repository_health": null
-  }
-}
-────────────────────────────────────────────────────────────────────────────────
-RAW AGENT DATA FROM cmbox:
-{
-  "hostname": "cmbox",
-  "agent_version": "v0.1.133",
-  "timestamp": 1763936511,
-  "system": {
-    "cpu": {
-      "load_1min": 1.75,
-      "load_5min": 2.08,
-      "load_15min": 2.1,
-      "frequency_mhz": 3638.71,
-      "temperature_celsius": 56.0
-    },
-    "memory": {
-      "usage_percent": 27.014532,
-      "total_gb": 23.339516,
-      "used_gb": 6.3050613,
-      "available_gb": 17.034454,
-      "swap_total_gb": 14.634708,
-      "swap_used_gb": 0.17599106,
-      "tmpfs": [
-        {
-          "mount": "/tmp",
-          "usage_percent": 15.095139,
-          "used_gb": 0.30190277,
-          "total_gb": 2.0
-        }
-      ]
-    },
-    "storage": {
-      "drives": [
-        {
-          "name": "nvme0n1",
-          "health": "PASSED",
-          "temperature_celsius": 28.0,
-          "wear_percent": 1.0,
-          "filesystems": [
-            {
-              "mount": "root",
-              "usage_percent": 24.404377,
-              "used_gb": 226.51398,
-              "total_gb": 928.1695
-            },
-            {
-              "mount": "boot",
-              "usage_percent": 10.666672,
-              "used_gb": 0.10645676,
-              "total_gb": 0.9980316
-            }
-          ]
-        }
-      ],
-      "pools": []
-    }
-  },
-  "services": [
-    {
-      "name": "tailscaled",
-      "status": "active",
-      "memory_mb": 25.59375,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    },
-    {
-      "name": "sshd",
-      "status": "active",
-      "memory_mb": 4.3085938,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    }
-  ],
-  "backup": {
-    "status": "unknown",
-    "last_run": null,
-    "next_scheduled": null,
-    "total_size_gb": null,
-    "repository_health": null
-  }
-}
-────────────────────────────────────────────────────────────────────────────────
-RAW AGENT DATA FROM cmbox:
-{
-  "hostname": "cmbox",
-  "agent_version": "v0.1.133",
-  "timestamp": 1763936512,
-  "system": {
-    "cpu": {
-      "load_1min": 1.75,
-      "load_5min": 2.08,
-      "load_15min": 2.1,
-      "frequency_mhz": 3638.71,
-      "temperature_celsius": 56.0
-    },
-    "memory": {
-      "usage_percent": 27.014532,
-      "total_gb": 23.339516,
-      "used_gb": 6.3050613,
-      "available_gb": 17.034454,
-      "swap_total_gb": 14.634708,
-      "swap_used_gb": 0.17599106,
-      "tmpfs": [
-        {
-          "mount": "/tmp",
-          "usage_percent": 15.095139,
-          "used_gb": 0.30190277,
-          "total_gb": 2.0
-        }
-      ]
-    },
-    "storage": {
-      "drives": [
-        {
-          "name": "nvme0n1",
-          "health": "PASSED",
-          "temperature_celsius": 28.0,
-          "wear_percent": 1.0,
-          "filesystems": [
-            {
-              "mount": "root",
-              "usage_percent": 24.404377,
-              "used_gb": 226.51398,
-              "total_gb": 928.1695
-            },
-            {
-              "mount": "boot",
-              "usage_percent": 10.666672,
-              "used_gb": 0.10645676,
-              "total_gb": 0.9980316
-            }
-          ]
-        }
-      ],
-      "pools": []
-    }
-  },
-  "services": [
-    {
-      "name": "tailscaled",
-      "status": "active",
-      "memory_mb": 25.59375,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    },
-    {
-      "name": "sshd",
-      "status": "active",
-      "memory_mb": 4.3085938,
-      "disk_gb": 0.0,
-      "user_stopped": false
-    }
-  ],
-  "backup": {
-    "status": "unknown",
-    "last_run": null,
-    "next_scheduled": null,
-    "total_size_gb": null,
-    "repository_health": null
-  }
-}
-────────────────────────────────────────────────────────────────────────────────
-Terminated

dashboard/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard"
-version = "0.1.151"
+version = "0.1.164"
 edition = "2021"
 
 [dependencies]

dashboard/src/app.rs

@@ -20,13 +20,12 @@ pub struct Dashboard {
     tui_app: Option<TuiApp>,
     terminal: Option<Terminal<CrosstermBackend<io::Stdout>>>,
     headless: bool,
-    raw_data: bool,
     initial_commands_sent: std::collections::HashSet<String>,
     config: DashboardConfig,
 }
 
 impl Dashboard {
-    pub async fn new(config_path: Option<String>, headless: bool, raw_data: bool) -> Result<Self> {
+    pub async fn new(config_path: Option<String>, headless: bool) -> Result<Self> {
         info!("Initializing dashboard");
 
         // Load configuration - try default path if not specified
@@ -120,7 +119,6 @@ impl Dashboard {
             tui_app,
             terminal,
             headless,
-            raw_data,
             initial_commands_sent: std::collections::HashSet::new(),
             config,
         })
@@ -205,13 +203,6 @@ impl Dashboard {
                             .insert(agent_data.hostname.clone());
                     }
 
-                    // Show raw data if requested (before processing)
-                    if self.raw_data {
-                        println!("RAW AGENT DATA FROM {}:", agent_data.hostname);
-                        println!("{}", serde_json::to_string_pretty(&agent_data).unwrap_or_else(|e| format!("Serialization error: {}", e)));
-                        println!("{}", "─".repeat(80));
-                    }
-
                     // Store structured data directly
                     self.metric_store.store_agent_data(agent_data);
 

dashboard/src/main.rs

@@ -51,10 +51,6 @@ struct Cli {
     /// Run in headless mode (no TUI, just logging)
     #[arg(long)]
     headless: bool,
-
-    /// Show raw agent data in headless mode
-    #[arg(long)]
-    raw_data: bool,
 }
 
 #[tokio::main]
@@ -90,7 +86,7 @@ async fn main() -> Result<()> {
     }
 
     // Create and run dashboard
-    let mut dashboard = Dashboard::new(cli.config, cli.headless, cli.raw_data).await?;
+    let mut dashboard = Dashboard::new(cli.config, cli.headless).await?;
 
     // Setup graceful shutdown
     let ctrl_c = async {

dashboard/src/ui/theme.rs

@@ -225,9 +225,6 @@ impl Layout {
     pub const LEFT_PANEL_WIDTH: u16 = 45;
     /// Right panel percentage (services)
     pub const RIGHT_PANEL_WIDTH: u16 = 55;
-    /// System vs backup split (equal)
-    pub const SYSTEM_PANEL_HEIGHT: u16 = 50;
-    pub const BACKUP_PANEL_HEIGHT: u16 = 50;
 }
 
 /// Typography system

dashboard/src/ui/widgets/cpu.rs

@@ -1 +0,0 @@
-// This file is intentionally left minimal - CPU functionality is handled by the SystemWidget

dashboard/src/ui/widgets/memory.rs

@@ -1 +0,0 @@
-// This file is intentionally left minimal - Memory functionality is handled by the SystemWidget

dashboard/src/ui/widgets/mod.rs

@@ -1,7 +1,5 @@
 use cm_dashboard_shared::AgentData;
 
-pub mod cpu;
-pub mod memory;
 pub mod services;
 pub mod system;
 

dashboard/src/ui/widgets/system.rs

@@ -8,13 +8,16 @@ use ratatui::{
 
 use crate::ui::theme::{StatusIcons, Typography};
 
-/// System widget displaying NixOS info, CPU, RAM, and Storage in unified layout
+/// System widget displaying NixOS info, Network, CPU, RAM, and Storage in unified layout
 #[derive(Clone)]
 pub struct SystemWidget {
     // NixOS information
     nixos_build: Option<String>,
     agent_hash: Option<String>,
-    
+
+    // Network interfaces
+    network_interfaces: Vec<cm_dashboard_shared::NetworkInterfaceData>,
+
     // CPU metrics
     cpu_load_1min: Option<f32>,
     cpu_load_5min: Option<f32>,
@@ -57,7 +60,9 @@ struct StoragePool {
     name: String,
     mount_point: String,
     pool_type: String, // "single", "mergerfs (2+1)", "RAID5 (3+1)", etc.
-    drives: Vec<StorageDrive>,
+    drives: Vec<StorageDrive>, // For physical drives
+    data_drives: Vec<StorageDrive>, // For MergerFS pools
+    parity_drives: Vec<StorageDrive>, // For MergerFS pools
     filesystems: Vec<FileSystem>, // For physical drive pools: individual filesystem children
     usage_percent: Option<f32>,
     used_gb: Option<f32>,
@@ -87,6 +92,7 @@ impl SystemWidget {
         Self {
             nixos_build: None,
             agent_hash: None,
+            network_interfaces: Vec::new(),
             cpu_load_1min: None,
             cpu_load_5min: None,
             cpu_load_15min: None,
@@ -162,6 +168,9 @@ impl Widget for SystemWidget {
         // Extract build version
         self.nixos_build = agent_data.build_version.clone();
 
+        // Extract network interfaces
+        self.network_interfaces = agent_data.system.network.interfaces.clone();
+
         // Extract CPU data directly
         let cpu = &agent_data.system.cpu;
         self.cpu_load_1min = Some(cpu.load_1min);
@@ -227,6 +236,8 @@ impl SystemWidget {
                 mount_point: drive.name.clone(),
                 pool_type: "drive".to_string(),
                 drives: Vec::new(),
+                data_drives: Vec::new(),
+                parity_drives: Vec::new(),
                 filesystems: Vec::new(),
                 usage_percent: None,
                 used_gb: None,
@@ -235,8 +246,11 @@ impl SystemWidget {
             };
 
             // Add drive info
+            let display_name = drive.serial_number.as_ref()
+                .map(|s| truncate_serial(s))
+                .unwrap_or(drive.name.clone());
             let storage_drive = StorageDrive {
-                name: drive.name.clone(),
+                name: display_name,
                 temperature: drive.temperature_celsius,
                 wear_percent: drive.wear_percent,
                 status: Status::Ok,
@@ -267,7 +281,85 @@ impl SystemWidget {
             pools.insert(drive.name.clone(), pool);
         }
 
-        // Convert pools
+        // Convert pools (MergerFS, RAID, etc.)
+        for pool in &agent_data.system.storage.pools {
+            // Use agent-calculated status (combined health and usage status)
+            let pool_status = if pool.health_status == Status::Critical || pool.usage_status == Status::Critical {
+                Status::Critical
+            } else if pool.health_status == Status::Warning || pool.usage_status == Status::Warning {
+                Status::Warning
+            } else if pool.health_status == Status::Ok && pool.usage_status == Status::Ok {
+                Status::Ok
+            } else {
+                Status::Unknown
+            };
+            
+            let mut storage_pool = StoragePool {
+                name: pool.name.clone(),
+                mount_point: pool.mount.clone(),
+                pool_type: pool.pool_type.clone(),
+                drives: Vec::new(),
+                data_drives: Vec::new(),
+                parity_drives: Vec::new(),
+                filesystems: Vec::new(),
+                usage_percent: Some(pool.usage_percent),
+                used_gb: Some(pool.used_gb),
+                total_gb: Some(pool.total_gb),
+                status: pool_status,
+            };
+
+            // Add data drives - use agent-calculated status
+            for drive in &pool.data_drives {
+                // Use combined health and temperature status
+                let drive_status = if drive.health_status == Status::Critical || drive.temperature_status == Status::Critical {
+                    Status::Critical
+                } else if drive.health_status == Status::Warning || drive.temperature_status == Status::Warning {
+                    Status::Warning
+                } else if drive.health_status == Status::Ok && drive.temperature_status == Status::Ok {
+                    Status::Ok
+                } else {
+                    Status::Unknown
+                };
+
+                let display_name = drive.serial_number.as_ref()
+                    .map(|s| truncate_serial(s))
+                    .unwrap_or(drive.name.clone());
+                let storage_drive = StorageDrive {
+                    name: display_name,
+                    temperature: drive.temperature_celsius,
+                    wear_percent: drive.wear_percent,
+                    status: drive_status,
+                };
+                storage_pool.data_drives.push(storage_drive);
+            }
+
+            // Add parity drives - use agent-calculated status
+            for drive in &pool.parity_drives {
+                // Use combined health and temperature status
+                let drive_status = if drive.health_status == Status::Critical || drive.temperature_status == Status::Critical {
+                    Status::Critical
+                } else if drive.health_status == Status::Warning || drive.temperature_status == Status::Warning {
+                    Status::Warning
+                } else if drive.health_status == Status::Ok && drive.temperature_status == Status::Ok {
+                    Status::Ok
+                } else {
+                    Status::Unknown
+                };
+
+                let display_name = drive.serial_number.as_ref()
+                    .map(|s| truncate_serial(s))
+                    .unwrap_or(drive.name.clone());
+                let storage_drive = StorageDrive {
+                    name: display_name,
+                    temperature: drive.temperature_celsius,
+                    wear_percent: drive.wear_percent,
+                    status: drive_status,
+                };
+                storage_pool.parity_drives.push(storage_drive);
+            }
+
+            pools.insert(pool.name.clone(), storage_pool);
+        }
 
         // Store pools
         let mut pool_list: Vec<StoragePool> = pools.into_values().collect();
@@ -283,12 +375,8 @@ impl SystemWidget {
             // Pool header line with type and health
             let pool_label = if pool.pool_type == "drive" {
                 // For physical drives, show the drive name with temperature and wear percentage if available
-                // Look for any drive with temp/wear data (physical drives may have drives named after the pool)
-                let drive_info = pool.drives.iter()
-                    .find(|d| d.name == pool.name)
-                    .or_else(|| pool.drives.first());
-
-                if let Some(drive) = drive_info {
+                // Physical drives only have one drive entry
+                if let Some(drive) = pool.drives.first() {
                     let mut drive_details = Vec::new();
                     if let Some(temp) = drive.temperature {
                         drive_details.push(format!("T: {}°C", temp as i32));
@@ -296,18 +384,18 @@ impl SystemWidget {
                     if let Some(wear) = drive.wear_percent {
                         drive_details.push(format!("W: {}%", wear as i32));
                     }
-                    
+
                     if !drive_details.is_empty() {
-                        format!("{} {}", pool.name, drive_details.join(" "))
+                        format!("{} {}", drive.name, drive_details.join(" "))
                     } else {
-                        pool.name.clone()
+                        drive.name.clone()
                     }
                 } else {
                     pool.name.clone()
                 }
             } else {
-                // For mergerfs pools, show pool name with format
-                format!("{} ({})", pool.mount_point, pool.pool_type)
+                // For mergerfs pools, show pool type with mount point
+                format!("mergerfs {}:", pool.mount_point)
             };
 
             let pool_spans = StatusIcons::create_status_spans(pool.status.clone(), &pool_label);
@@ -336,28 +424,78 @@ impl SystemWidget {
                     lines.push(Line::from(fs_spans));
                 }
             } else {
-                // For mergerfs pools, show data drives and parity drives in tree structure
-                if !pool.drives.is_empty() {
-                    // Group drives by type based on naming conventions or show all as data drives
-                    let (data_drives, parity_drives): (Vec<_>, Vec<_>) = pool.drives.iter()
-                        .partition(|d| !d.name.contains("parity") && !d.name.starts_with("sdc"));
+                // For mergerfs pools, show structure matching CLAUDE.md format:
+                // ● mergerfs (2+1):
+                //   ├─ Total: ● 63% 2355.2GB/3686.4GB
+                //   ├─ Data Disks:
+                //   │  ├─ ● sdb T: 24°C W: 5%
+                //   │  └─ ● sdd T: 27°C W: 5%
+                //   ├─ Parity: ● sdc T: 24°C W: 5%
+                //   └─ Mount: /srv/media
+                
+                // Pool total usage
+                let total_text = format!("{:.0}% {:.1}GB/{:.1}GB",
+                    pool.usage_percent.unwrap_or(0.0),
+                    pool.used_gb.unwrap_or(0.0),
+                    pool.total_gb.unwrap_or(0.0)
+                );
+                let mut total_spans = vec![
+                    Span::styled("  ├─ ", Typography::tree()),
+                ];
+                total_spans.extend(StatusIcons::create_status_spans(Status::Ok, &total_text));
+                lines.push(Line::from(total_spans));
 
-                    if !data_drives.is_empty() {
-                        lines.push(Line::from(vec![
-                            Span::styled("  ├─ Data Disks:", Typography::secondary())
-                        ]));
-                        for (i, drive) in data_drives.iter().enumerate() {
-                            render_pool_drive(drive, i == data_drives.len() - 1 && parity_drives.is_empty(), &mut lines);
-                        }
+                // Data drives - at same level as parity
+                let has_parity = !pool.parity_drives.is_empty();
+                for (i, drive) in pool.data_drives.iter().enumerate() {
+                    let is_last_data = i == pool.data_drives.len() - 1;
+                    let mut drive_details = Vec::new();
+                    if let Some(temp) = drive.temperature {
+                        drive_details.push(format!("T: {}°C", temp as i32));
+                    }
+                    if let Some(wear) = drive.wear_percent {
+                        drive_details.push(format!("W: {}%", wear as i32));
                     }
 
-                    if !parity_drives.is_empty() {
-                        lines.push(Line::from(vec![
-                            Span::styled("  └─ Parity:", Typography::secondary())
-                        ]));
-                        for (i, drive) in parity_drives.iter().enumerate() {
-                            render_pool_drive(drive, i == parity_drives.len() - 1, &mut lines);
+                    let drive_text = if !drive_details.is_empty() {
+                        format!("Data_{}: {} {}", i + 1, drive.name, drive_details.join(" "))
+                    } else {
+                        format!("Data_{}: {}", i + 1, drive.name)
+                    };
+
+                    // Last data drive uses └─ if there's no parity, otherwise ├─
+                    let tree_symbol = if is_last_data && !has_parity { "  └─ " } else { "  ├─ " };
+                    let mut data_spans = vec![
+                        Span::styled(tree_symbol, Typography::tree()),
+                    ];
+                    data_spans.extend(StatusIcons::create_status_spans(drive.status.clone(), &drive_text));
+                    lines.push(Line::from(data_spans));
+                }
+
+                // Parity drives - last item(s)
+                if !pool.parity_drives.is_empty() {
+                    for (i, drive) in pool.parity_drives.iter().enumerate() {
+                        let is_last = i == pool.parity_drives.len() - 1;
+                        let mut drive_details = Vec::new();
+                        if let Some(temp) = drive.temperature {
+                            drive_details.push(format!("T: {}°C", temp as i32));
                         }
+                        if let Some(wear) = drive.wear_percent {
+                            drive_details.push(format!("W: {}%", wear as i32));
+                        }
+
+                        let drive_text = if !drive_details.is_empty() {
+                            format!("Parity: {} {}", drive.name, drive_details.join(" "))
+                        } else {
+                            format!("Parity: {}", drive.name)
+                        };
+
+                        let tree_symbol = if is_last { "  └─ " } else { "  ├─ " };
+                        let mut parity_spans = vec![
+                            Span::styled(tree_symbol, Typography::tree()),
+                        ];
+                        parity_spans.extend(StatusIcons::create_status_spans(drive.status.clone(), &drive_text));
+                        lines.push(Line::from(parity_spans));
                     }
                 }
             }
@@ -367,30 +505,14 @@ impl SystemWidget {
     }
 }
 
-/// Helper function to render a drive in a storage pool
-fn render_pool_drive(drive: &StorageDrive, is_last: bool, lines: &mut Vec<Line<'_>>) {
-    let tree_symbol = if is_last { "    └─" } else { "    ├─" };
-    
-    let mut drive_details = Vec::new();
-    if let Some(temp) = drive.temperature {
-        drive_details.push(format!("T: {}°C", temp as i32));
-    }
-    if let Some(wear) = drive.wear_percent {
-        drive_details.push(format!("W: {}%", wear as i32));
-    }
-    
-    let drive_text = if !drive_details.is_empty() {
-        format!("● {} {}", drive.name, drive_details.join(" "))
+/// Truncate serial number to last 8 characters
+fn truncate_serial(serial: &str) -> String {
+    let len = serial.len();
+    if len > 8 {
+        serial[len - 8..].to_string()
     } else {
-        format!("● {}", drive.name)
-    };
-    
-    let mut drive_spans = vec![
-        Span::styled(tree_symbol, Typography::tree()),
-        Span::raw(" "),
-    ];
-    drive_spans.extend(StatusIcons::create_status_spans(drive.status.clone(), &drive_text));
-    lines.push(Line::from(drive_spans));
+        serial.to_string()
+    }
 }
 
 impl SystemWidget {
@@ -400,6 +522,7 @@ impl SystemWidget {
 
         // First line: serial number with temperature and wear
         if let Some(serial) = &self.backup_disk_serial {
+            let truncated_serial = truncate_serial(serial);
             let mut details = Vec::new();
             if let Some(temp) = self.backup_disk_temperature {
                 details.push(format!("T: {}°C", temp as i32));
@@ -409,9 +532,9 @@ impl SystemWidget {
             }
 
             let disk_text = if !details.is_empty() {
-                format!("{} {}", serial, details.join(" "))
+                format!("{} {}", truncated_serial, details.join(" "))
             } else {
-                serial.clone()
+                truncated_serial
             };
 
             let backup_status = match self.backup_status.as_str() {
@@ -457,45 +580,81 @@ impl SystemWidget {
         lines
     }
 
-    /// Format time ago from timestamp
-    fn format_time_ago(&self, timestamp: u64) -> String {
-        let now = chrono::Utc::now().timestamp() as u64;
-        let seconds_ago = now.saturating_sub(timestamp);
-        
-        let hours = seconds_ago / 3600;
-        let minutes = (seconds_ago % 3600) / 60;
-        
-        if hours > 0 {
-            format!("{}h ago", hours)
-        } else if minutes > 0 {
-            format!("{}m ago", minutes)
-        } else {
-            "now".to_string()
+    /// Compress IPv4 addresses from same subnet
+    /// Example: "192.168.30.1, 192.168.30.100" -> "192.168.30.1, 100"
+    fn compress_ipv4_addresses(addresses: &[String]) -> String {
+        if addresses.is_empty() {
+            return String::new();
         }
+
+        if addresses.len() == 1 {
+            return addresses[0].clone();
+        }
+
+        let mut result = Vec::new();
+        let mut last_prefix = String::new();
+
+        for addr in addresses {
+            let parts: Vec<&str> = addr.split('.').collect();
+            if parts.len() == 4 {
+                let prefix = format!("{}.{}.{}", parts[0], parts[1], parts[2]);
+
+                if prefix == last_prefix {
+                    // Same subnet, show only last octet
+                    result.push(parts[3].to_string());
+                } else {
+                    // Different subnet, show full IP
+                    result.push(addr.clone());
+                    last_prefix = prefix;
+                }
+            } else {
+                // Invalid IP format, show as-is
+                result.push(addr.clone());
+            }
+        }
+
+        result.join(", ")
     }
 
-    /// Format time until from future timestamp  
-    fn format_time_until(&self, timestamp: u64) -> String {
-        let now = chrono::Utc::now().timestamp() as u64;
-        if timestamp <= now {
-            return "overdue".to_string();
+    /// Render network section for display
+    fn render_network(&self) -> Vec<Line<'_>> {
+        let mut lines = Vec::new();
+
+        if self.network_interfaces.is_empty() {
+            return lines;
         }
-        
-        let seconds_until = timestamp - now;
-        let hours = seconds_until / 3600;
-        let minutes = (seconds_until % 3600) / 60;
-        
-        if hours > 0 {
-            format!("in {}h", hours)
-        } else if minutes > 0 {
-            format!("in {}m", minutes)
-        } else {
-            "soon".to_string()
+
+        for (i, interface) in self.network_interfaces.iter().enumerate() {
+            let is_last = i == self.network_interfaces.len() - 1;
+            let tree_symbol = if is_last { "  └─ " } else { "  ├─ " };
+
+            // Show interface name
+            let mut interface_text = format!("{}: ", interface.name);
+
+            // Add compressed IPv4 addresses
+            if !interface.ipv4_addresses.is_empty() {
+                interface_text.push_str(&Self::compress_ipv4_addresses(&interface.ipv4_addresses));
+            }
+
+            // Add IPv6 addresses (no compression for now)
+            if !interface.ipv6_addresses.is_empty() {
+                if !interface.ipv4_addresses.is_empty() {
+                    interface_text.push_str(", ");
+                }
+                interface_text.push_str(&interface.ipv6_addresses.join(", "));
+            }
+
+            lines.push(Line::from(vec![
+                Span::styled(tree_symbol, Typography::tree()),
+                Span::styled(interface_text, Typography::secondary()),
+            ]));
         }
+
+        lines
     }
 
-    /// Render system widget  
-    pub fn render(&mut self, frame: &mut Frame, area: Rect, hostname: &str, config: Option<&crate::config::DashboardConfig>) {
+    /// Render system widget
+    pub fn render(&mut self, frame: &mut Frame, area: Rect, hostname: &str, _config: Option<&crate::config::DashboardConfig>) {
         let mut lines = Vec::new();
 
         // NixOS section
@@ -512,17 +671,16 @@ impl SystemWidget {
         lines.push(Line::from(vec![
             Span::styled(format!("Agent: {}", agent_version_text), Typography::secondary())
         ]));
-        
-        // Display detected connection IP
-        if let Some(config) = config {
-            if let Some(host_details) = config.hosts.get(hostname) {
-                let detected_ip = host_details.get_connection_ip(hostname);
-                lines.push(Line::from(vec![
-                    Span::styled(format!("IP: {}", detected_ip), Typography::secondary())
-                ]));
-            }
+
+        // Network section
+        if !self.network_interfaces.is_empty() {
+            lines.push(Line::from(vec![
+                Span::styled("Network:", Typography::widget_title())
+            ]));
+
+            let network_lines = self.render_network();
+            lines.extend(network_lines);
         }
-        
 
         // CPU section
         lines.push(Line::from(vec![

shared/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard-shared"
-version = "0.1.151"
+version = "0.1.164"
 edition = "2021"
 
 [dependencies]

shared/src/agent_data.rs

@@ -16,11 +16,26 @@ pub struct AgentData {
 /// System-level monitoring data
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SystemData {
+    pub network: NetworkData,
     pub cpu: CpuData,
     pub memory: MemoryData,
     pub storage: StorageData,
 }
 
+/// Network interface monitoring data
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct NetworkData {
+    pub interfaces: Vec<NetworkInterfaceData>,
+}
+
+/// Individual network interface data
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct NetworkInterfaceData {
+    pub name: String,
+    pub ipv4_addresses: Vec<String>,
+    pub ipv6_addresses: Vec<String>,
+}
+
 /// CPU monitoring data
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct CpuData {
@@ -66,6 +81,7 @@ pub struct StorageData {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct DriveData {
     pub name: String,
+    pub serial_number: Option<String>,
     pub health: String,
     pub temperature_celsius: Option<f32>,
     pub wear_percent: Option<f32>,
@@ -96,15 +112,20 @@ pub struct PoolData {
     pub total_gb: f32,
     pub data_drives: Vec<PoolDriveData>,
     pub parity_drives: Vec<PoolDriveData>,
+    pub health_status: Status,
+    pub usage_status: Status,
 }
 
 /// Drive in a storage pool
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct PoolDriveData {
     pub name: String,
+    pub serial_number: Option<String>,
     pub temperature_celsius: Option<f32>,
     pub wear_percent: Option<f32>,
     pub health: String,
+    pub health_status: Status,
+    pub temperature_status: Status,
 }
 
 /// Service monitoring data
@@ -165,6 +186,9 @@ impl AgentData {
             build_version: None,
             timestamp: chrono::Utc::now().timestamp() as u64,
             system: SystemData {
+                network: NetworkData {
+                    interfaces: Vec::new(),
+                },
                 cpu: CpuData {
                     load_1min: 0.0,
                     load_5min: 0.0,