Improve NVMe serial parsing and restructure MergerFS display

- Fix NVMe serial number parsing to handle whitespace variations
- Move mount point to MergerFS header, remove drive count
- Restructure data drives to same level as parity with Data_1, Data_2 labels
- Remove "Total:" label from pool usage line
- Update parity to use closing tree symbol as last item

Cargo.lock

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

agent/Cargo.toml

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

agent/src/collectors/disk.rs

@@ -76,11 +76,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 +162,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")
@@ -407,12 +437,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,6 +457,19 @@ 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") {
                 // Traditional SATA drives: attribute table format
@@ -467,6 +512,7 @@ impl DiskCollector {
 
         Ok(SmartData {
             health,
+            serial_number,
             temperature_celsius: temperature,
             wear_percent,
         })
@@ -492,6 +538,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 +558,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 +573,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 +584,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 +592,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 +617,48 @@ 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
+        let (pool_health, health_status) = match (failed_data, failed_parity) {
+            (0, 0) => ("healthy".to_string(), cm_dashboard_shared::Status::Ok),
+            (1, 0) | (0, 1) => ("degraded".to_string(), cm_dashboard_shared::Status::Warning),
+            _ => ("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 +827,7 @@ impl Collector for DiskCollector {
 #[derive(Debug, Clone)]
 struct SmartData {
     health: String,
+    serial_number: Option<String>,
     temperature_celsius: Option<f32>,
     wear_percent: Option<f32>,
 }

dashboard/Cargo.toml

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

dashboard/src/ui/widgets/system.rs

@@ -57,7 +57,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>,
@@ -227,6 +229,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 +239,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 +274,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();
@@ -306,8 +391,8 @@ impl SystemWidget {
                     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 +421,72 @@ 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
+                for (i, drive) in pool.data_drives.iter().enumerate() {
+                    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)
+                    };
+
+                    let mut data_spans = vec![
+                        Span::styled("  ├─ ", Typography::tree()),
+                    ];
+                    data_spans.extend(StatusIcons::create_status_spans(drive.status.clone(), &drive_text));
+                    lines.push(Line::from(data_spans));
+                }
+
+                // Parity drives - last item
+                if !pool.parity_drives.is_empty() {
+                    for drive in &pool.parity_drives {
+                        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 mut parity_spans = vec![
+                            Span::styled("  └─ ", Typography::tree()),
+                        ];
+                        parity_spans.extend(StatusIcons::create_status_spans(drive.status.clone(), &drive_text));
+                        lines.push(Line::from(parity_spans));
                     }
                 }
             }
@@ -367,6 +496,39 @@ impl SystemWidget {
     }
 }
 
+/// 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 {
+        serial.to_string()
+    }
+}
+
+/// Helper function to render a drive in a MergerFS pool
+fn render_mergerfs_drive<'a>(drive: &StorageDrive, tree_symbol: &'a str, lines: &mut Vec<Line<'a>>) {
+    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(" "))
+    } else {
+        drive.name.clone()
+    };
+    
+    let mut drive_spans = vec![
+        Span::styled(tree_symbol, Typography::tree()),
+    ];
+    drive_spans.extend(StatusIcons::create_status_spans(drive.status.clone(), &drive_text));
+    lines.push(Line::from(drive_spans));
+}
+
 /// 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 { "    ├─" };
@@ -400,6 +562,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 +572,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() {

shared/Cargo.toml

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

shared/src/agent_data.rs

@@ -66,6 +66,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 +97,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