Add responsive column visibility to service panel

Service panel now dynamically shows/hides columns based on terminal width:
- ≥80 chars: All columns (Name, Status, RAM, Uptime, Restarts)
- ≥60 chars: Hide Restarts only
- ≥45 chars: Hide Uptime and Restarts
- <45 chars: Minimal (Name and Status only)

Improves dashboard usability on smaller terminal sizes.

Cargo.lock

@@ -279,7 +279,7 @@ checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
 
 [[package]]
 name = "cm-dashboard"
-version = "0.1.213"
+version = "0.1.226"
 dependencies = [
  "anyhow",
  "chrono",
@@ -301,7 +301,7 @@ dependencies = [
 
 [[package]]
 name = "cm-dashboard-agent"
-version = "0.1.213"
+version = "0.1.226"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -309,6 +309,7 @@ dependencies = [
  "chrono-tz",
  "clap",
  "cm-dashboard-shared",
+ "futures",
  "gethostname",
  "lettre",
  "reqwest",
@@ -324,7 +325,7 @@ dependencies = [
 
 [[package]]
 name = "cm-dashboard-shared"
-version = "0.1.213"
+version = "0.1.226"
 dependencies = [
  "chrono",
  "serde",
@@ -552,6 +553,21 @@ dependencies = [
  "percent-encoding",
 ]
 
+[[package]]
+name = "futures"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
 [[package]]
 name = "futures-channel"
 version = "0.3.31"
@@ -559,6 +575,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
 dependencies = [
  "futures-core",
+ "futures-sink",
 ]
 
 [[package]]
@@ -567,12 +584,34 @@ version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
 
+[[package]]
+name = "futures-executor"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
 [[package]]
 name = "futures-io"
 version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
 
+[[package]]
+name = "futures-macro"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "futures-sink"
 version = "0.3.31"
@@ -591,8 +630,11 @@ version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
 dependencies = [
+ "futures-channel",
  "futures-core",
  "futures-io",
+ "futures-macro",
+ "futures-sink",
  "futures-task",
  "memchr",
  "pin-project-lite",

agent/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard-agent"
-version = "0.1.214"
+version = "0.1.227"
 edition = "2021"
 
 [dependencies]
@@ -20,4 +20,5 @@ gethostname = { workspace = true }
 chrono-tz = "0.8"
 toml = { workspace = true }
 async-trait = "0.1"
-reqwest = { version = "0.11", features = ["json", "blocking"] }
+reqwest = { version = "0.11", features = ["json", "blocking"] }
+futures = "0.3"

agent/src/collectors/backup.rs

@@ -142,6 +142,17 @@ impl BackupCollector {
                     // Build service list for this disk
                     let services: Vec<String> = backup_status.services.keys().cloned().collect();
 
+                    // Get min and max archive counts to detect inconsistencies
+                    let archives_min: i64 = backup_status.services.values()
+                        .map(|service| service.archive_count)
+                        .min()
+                        .unwrap_or(0);
+
+                    let archives_max: i64 = backup_status.services.values()
+                        .map(|service| service.archive_count)
+                        .max()
+                        .unwrap_or(0);
+
                     // Create disk data
                     let disk_data = BackupDiskData {
                         serial: backup_status.disk_serial_number.unwrap_or_else(|| "Unknown".to_string()),
@@ -155,6 +166,8 @@ impl BackupCollector {
                         disk_total_gb: total_gb,
                         usage_status,
                         services,
+                        archives_min,
+                        archives_max,
                     };
 
                     disks.push(disk_data);

agent/src/collectors/disk.rs

@@ -3,10 +3,9 @@ use async_trait::async_trait;
 use cm_dashboard_shared::{AgentData, DriveData, FilesystemData, PoolData, HysteresisThresholds, Status};
 
 use crate::config::DiskConfig;
-use std::process::Command;
-use std::time::Instant;
+use tokio::process::Command as TokioCommand;
+use std::process::Command as StdCommand;
 use std::collections::HashMap;
-use tracing::debug;
 
 use super::{Collector, CollectorError};
 
@@ -67,9 +66,6 @@ impl DiskCollector {
 
     /// Collect all storage data and populate AgentData
     async fn collect_storage_data(&self, agent_data: &mut AgentData) -> Result<(), CollectorError> {
-        let start_time = Instant::now();
-        debug!("Starting clean storage collection");
-
         // Step 1: Get mount points and their backing devices
         let mount_devices = self.get_mount_devices().await?;
         
@@ -104,9 +100,6 @@ impl DiskCollector {
         self.populate_drives_data(&physical_drives, &smart_data, agent_data)?;
         self.populate_pools_data(&mergerfs_pools, &smart_data, agent_data)?;
 
-        let elapsed = start_time.elapsed();
-        debug!("Storage collection completed in {:?}", elapsed);
-
         Ok(())
     }
 
@@ -114,7 +107,7 @@ impl DiskCollector {
     async fn get_mount_devices(&self) -> Result<HashMap<String, String>, CollectorError> {
         use super::run_command_with_timeout;
 
-        let mut cmd = Command::new("lsblk");
+        let mut cmd = TokioCommand::new("lsblk");
         cmd.args(&["-rn", "-o", "NAME,MOUNTPOINT"]);
 
         let output = run_command_with_timeout(cmd, 2).await
@@ -141,7 +134,6 @@ impl DiskCollector {
             }
         }
 
-        debug!("Found {} mounted block devices", mount_devices.len());
         Ok(mount_devices)
     }
 
@@ -154,8 +146,8 @@ impl DiskCollector {
                 Ok((total, used)) => {
                     filesystem_usage.insert(mount_point.clone(), (total, used));
                 }
-                Err(e) => {
-                    debug!("Failed to get filesystem info for {}: {}", mount_point, e);
+                Err(_e) => {
+                    // Silently skip filesystems we can't read
                 }
             }
         }
@@ -176,8 +168,6 @@ impl DiskCollector {
                 // 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));
                     }
                 }
@@ -189,7 +179,7 @@ impl DiskCollector {
 
     /// Get filesystem info for a single mount point
     fn get_filesystem_info(&self, mount_point: &str) -> Result<(u64, u64), CollectorError> {
-        let output = std::process::Command::new("timeout")
+        let output = StdCommand::new("timeout")
             .args(&["2", "df", "--block-size=1", mount_point])
             .output()
             .map_err(|e| CollectorError::SystemRead {
@@ -252,9 +242,8 @@ impl DiskCollector {
                 } else {
                     mount_point.trim_start_matches('/').replace('/', "_")
                 };
-                
+
                 if pool_name.is_empty() {
-                    debug!("Skipping mergerfs pool with empty name: {}", mount_point);
                     continue;
                 }
                 
@@ -282,8 +271,7 @@ impl DiskCollector {
                 // Categorize as data vs parity drives
                 let (data_drives, parity_drives) = match self.categorize_pool_drives(&all_member_paths) {
                     Ok(drives) => drives,
-                    Err(e) => {
-                        debug!("Failed to categorize drives for pool {}: {}. Skipping.", mount_point, e);
+                    Err(_e) => {
                         continue;
                     }
                 };
@@ -298,8 +286,7 @@ impl DiskCollector {
                 });
             }
         }
-        
-        debug!("Found {} mergerfs pools", pools.len());
+
         Ok(pools)
     }
 
@@ -386,9 +373,9 @@ impl DiskCollector {
         device.to_string()
     }
 
-    /// Get SMART data for drives
+    /// Get SMART data for drives in parallel
     async fn get_smart_data_for_drives(&self, physical_drives: &[PhysicalDrive], mergerfs_pools: &[MergerfsPool]) -> HashMap<String, SmartData> {
-        let mut smart_data = HashMap::new();
+        use futures::future::join_all;
 
         // Collect all drive names
         let mut all_drives = std::collections::HashSet::new();
@@ -404,9 +391,24 @@ impl DiskCollector {
             }
         }
 
-        // Get SMART data for each drive
-        for drive_name in all_drives {
-            if let Ok(data) = self.get_smart_data(&drive_name).await {
+        // Collect SMART data for all drives in parallel
+        let futures: Vec<_> = all_drives
+            .iter()
+            .map(|drive_name| {
+                let drive = drive_name.clone();
+                async move {
+                    let result = self.get_smart_data(&drive).await;
+                    (drive, result)
+                }
+            })
+            .collect();
+
+        let results = join_all(futures).await;
+
+        // Build HashMap from results
+        let mut smart_data = HashMap::new();
+        for (drive_name, result) in results {
+            if let Ok(data) = result {
                 smart_data.insert(drive_name, data);
             }
         }
@@ -420,7 +422,7 @@ impl DiskCollector {
 
         // Use direct smartctl (no sudo) - service has CAP_SYS_RAWIO and CAP_SYS_ADMIN capabilities
         // For NVMe drives, specify device type explicitly
-        let mut cmd = Command::new("smartctl");
+        let mut cmd = TokioCommand::new("smartctl");
         if drive_name.starts_with("nvme") {
             cmd.args(&["-d", "nvme", "-a", &format!("/dev/{}", drive_name)]);
         } else {
@@ -435,8 +437,10 @@ impl DiskCollector {
 
         let output_str = String::from_utf8_lossy(&output.stdout);
 
-        if !output.status.success() {
-            // Return unknown data rather than failing completely
+        // Note: smartctl returns non-zero exit codes for warnings (like exit code 32
+        // for "temperature was high in the past"), but the output data is still valid.
+        // Only check if we got any output at all, don't reject based on exit code.
+        if output_str.is_empty() {
             return Ok(SmartData {
                 health: "UNKNOWN".to_string(),
                 serial_number: None,
@@ -444,7 +448,7 @@ impl DiskCollector {
                 wear_percent: None,
             });
         }
-        
+
         let mut health = "UNKNOWN".to_string();
         let mut serial_number = None;
         let mut temperature = None;
@@ -763,7 +767,7 @@ impl DiskCollector {
     /// Get drive information for a mount path
     fn get_drive_info_for_path(&self, path: &str) -> anyhow::Result<PoolDrive> {
         // Use lsblk to find the backing device with timeout
-        let output = Command::new("timeout")
+        let output = StdCommand::new("timeout")
             .args(&["2", "lsblk", "-rn", "-o", "NAME,MOUNTPOINT"])
             .output()
             .map_err(|e| anyhow::anyhow!("Failed to run lsblk: {}", e))?;
@@ -785,20 +789,13 @@ impl DiskCollector {
         
         // Extract base device name (e.g., "sda1" -> "sda")
         let base_device = self.extract_base_device(&format!("/dev/{}", device));
-        
-        // Get temperature from SMART data if available
-        let temperature = if let Ok(smart_data) = tokio::task::block_in_place(|| {
-            tokio::runtime::Handle::current().block_on(self.get_smart_data(&base_device))
-        }) {
-            smart_data.temperature_celsius
-        } else {
-            None
-        };
-        
+
+        // Temperature will be filled in later from parallel SMART collection
+        // Don't collect it here to avoid sequential blocking with problematic async nesting
         Ok(PoolDrive {
             name: base_device,
             mount_point: path.to_string(),
-            temperature_celsius: temperature,
+            temperature_celsius: None,
         })
     }
 

agent/src/collectors/mod.rs

@@ -1,8 +1,7 @@
 use async_trait::async_trait;
 use cm_dashboard_shared::{AgentData};
-use std::process::{Command, Output};
+use std::process::Output;
 use std::time::Duration;
-use tokio::time::timeout;
 
 pub mod backup;
 pub mod cpu;
@@ -16,16 +15,34 @@ pub mod systemd;
 pub use error::CollectorError;
 
 /// Run a command with a timeout to prevent blocking
-pub async fn run_command_with_timeout(mut cmd: Command, timeout_secs: u64) -> std::io::Result<Output> {
+/// Properly kills the process if timeout is exceeded
+pub async fn run_command_with_timeout(mut cmd: tokio::process::Command, timeout_secs: u64) -> std::io::Result<Output> {
+    use tokio::time::timeout;
+    use std::process::Stdio;
     let timeout_duration = Duration::from_secs(timeout_secs);
 
-    match timeout(timeout_duration, tokio::task::spawn_blocking(move || cmd.output())).await {
-        Ok(Ok(result)) => result,
-        Ok(Err(e)) => Err(std::io::Error::new(std::io::ErrorKind::Other, e)),
-        Err(_) => Err(std::io::Error::new(
-            std::io::ErrorKind::TimedOut,
-            format!("Command timed out after {} seconds", timeout_secs)
-        )),
+    // Configure stdio to capture output
+    cmd.stdout(Stdio::piped());
+    cmd.stderr(Stdio::piped());
+
+    let child = cmd.spawn()?;
+    let pid = child.id();
+
+    match timeout(timeout_duration, child.wait_with_output()).await {
+        Ok(result) => result,
+        Err(_) => {
+            // Timeout - force kill the process using system kill command
+            if let Some(process_id) = pid {
+                let _ = tokio::process::Command::new("kill")
+                    .args(&["-9", &process_id.to_string()])
+                    .output()
+                    .await;
+            }
+            Err(std::io::Error::new(
+                std::io::ErrorKind::TimedOut,
+                format!("Command timed out after {} seconds", timeout_secs)
+            ))
+        }
     }
 }
 

dashboard/Cargo.toml

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

dashboard/src/ui/widgets/services.rs

@@ -11,6 +11,59 @@ use tracing::debug;
 use crate::ui::theme::{Components, StatusIcons, Theme, Typography};
 use ratatui::style::Style;
 
+/// Column visibility configuration based on terminal width
+#[derive(Debug, Clone, Copy)]
+struct ColumnVisibility {
+    show_name: bool,
+    show_status: bool,
+    show_ram: bool,
+    show_uptime: bool,
+    show_restarts: bool,
+}
+
+impl ColumnVisibility {
+    /// Determine which columns to show based on available width
+    fn from_width(width: u16) -> Self {
+        if width >= 80 {
+            // Full layout: Name (25) + Status (10) + RAM (8) + Uptime (8) + Restarts (5) = 56 chars
+            Self {
+                show_name: true,
+                show_status: true,
+                show_ram: true,
+                show_uptime: true,
+                show_restarts: true,
+            }
+        } else if width >= 60 {
+            // Hide restarts: Name (25) + Status (10) + RAM (8) + Uptime (8) = 51 chars
+            Self {
+                show_name: true,
+                show_status: true,
+                show_ram: true,
+                show_uptime: true,
+                show_restarts: false,
+            }
+        } else if width >= 45 {
+            // Hide uptime and restarts: Name (25) + Status (10) + RAM (8) = 43 chars
+            Self {
+                show_name: true,
+                show_status: true,
+                show_ram: true,
+                show_uptime: false,
+                show_restarts: false,
+            }
+        } else {
+            // Minimal: Name (25) + Status (10) = 35 chars
+            Self {
+                show_name: true,
+                show_status: true,
+                show_ram: false,
+                show_uptime: false,
+                show_restarts: false,
+            }
+        }
+    }
+}
+
 /// Services widget displaying hierarchical systemd service statuses
 #[derive(Clone)]
 pub struct ServicesWidget {
@@ -76,7 +129,7 @@ impl ServicesWidget {
     }
 
     /// Format parent service line - returns text without icon for span formatting
-    fn format_parent_service_line(&self, name: &str, info: &ServiceInfo) -> String {
+    fn format_parent_service_line(&self, name: &str, info: &ServiceInfo, columns: ColumnVisibility) -> String {
         // Truncate long service names to fit layout (account for icon space)
         let short_name = if name.len() > 22 {
             format!("{}...", &name[..19])
@@ -129,10 +182,25 @@ impl ServicesWidget {
             }
         });
 
-        format!(
-            "{:<23} {:<10} {:<8} {:<8} {:<5}",
-            short_name, status_str, memory_str, uptime_str, restart_str
-        )
+        // Build format string based on column visibility
+        let mut parts = Vec::new();
+        if columns.show_name {
+            parts.push(format!("{:<23}", short_name));
+        }
+        if columns.show_status {
+            parts.push(format!("{:<10}", status_str));
+        }
+        if columns.show_ram {
+            parts.push(format!("{:<8}", memory_str));
+        }
+        if columns.show_uptime {
+            parts.push(format!("{:<8}", uptime_str));
+        }
+        if columns.show_restarts {
+            parts.push(format!("{:<5}", restart_str));
+        }
+
+        parts.join(" ")
     }
 
 
@@ -476,11 +544,28 @@ impl ServicesWidget {
             .constraints([Constraint::Length(1), Constraint::Min(0)])
             .split(inner_area);
 
-        // Header
-        let header = format!(
-            "{:<25} {:<10} {:<8} {:<8} {:<5}",
-            "Service:", "Status:", "RAM:", "Uptime:", "↻:"
-        );
+        // Determine which columns to show based on available width
+        let columns = ColumnVisibility::from_width(inner_area.width);
+
+        // Build header based on visible columns
+        let mut header_parts = Vec::new();
+        if columns.show_name {
+            header_parts.push(format!("{:<25}", "Service:"));
+        }
+        if columns.show_status {
+            header_parts.push(format!("{:<10}", "Status:"));
+        }
+        if columns.show_ram {
+            header_parts.push(format!("{:<8}", "RAM:"));
+        }
+        if columns.show_uptime {
+            header_parts.push(format!("{:<8}", "Uptime:"));
+        }
+        if columns.show_restarts {
+            header_parts.push(format!("{:<5}", "↻:"));
+        }
+        let header = header_parts.join(" ");
+
         let header_para = Paragraph::new(header).style(Typography::muted());
         frame.render_widget(header_para, content_chunks[0]);
 
@@ -492,11 +577,11 @@ impl ServicesWidget {
         }
 
         // Render the services list
-        self.render_services(frame, content_chunks[1], is_focused);
+        self.render_services(frame, content_chunks[1], is_focused, columns);
     }
 
     /// Render services list
-    fn render_services(&mut self, frame: &mut Frame, area: Rect, is_focused: bool) {
+    fn render_services(&mut self, frame: &mut Frame, area: Rect, is_focused: bool, columns: ColumnVisibility) {
         // Build hierarchical service list for display
         let mut display_lines: Vec<(String, Status, bool, Option<(ServiceInfo, bool)>)> = Vec::new();
 
@@ -506,7 +591,7 @@ impl ServicesWidget {
 
         for (parent_name, parent_info) in parent_services {
             // Add parent service line
-            let parent_line = self.format_parent_service_line(parent_name, parent_info);
+            let parent_line = self.format_parent_service_line(parent_name, parent_info, columns);
             display_lines.push((parent_line, parent_info.widget_status, false, None));
 
             // Add sub-services for this parent (if any)

dashboard/src/ui/widgets/system.rs

@@ -565,9 +565,16 @@ impl SystemWidget {
                 lines.push(Line::from(time_spans));
             }
 
-            // Show usage with status
+            // Show usage with status and archive count
+            let archive_display = if disk.archives_min == disk.archives_max {
+                format!("{}", disk.archives_min)
+            } else {
+                format!("{}-{}", disk.archives_min, disk.archives_max)
+            };
+
             let usage_text = format!(
-                "Usage: {:.0}% {:.0}GB/{:.0}GB",
+                "Usage: ({}) {:.0}% {:.0}GB/{:.0}GB",
+                archive_display,
                 disk.disk_usage_percent,
                 disk.disk_used_gb,
                 disk.disk_total_gb

shared/Cargo.toml

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

shared/src/agent_data.rs

@@ -195,6 +195,8 @@ pub struct BackupDiskData {
     pub disk_total_gb: f32,
     pub usage_status: Status,
     pub services: Vec<String>,
+    pub archives_min: i64,
+    pub archives_max: i64,
 }
 
 impl AgentData {