Cargo.lock

@@ -279,7 +279,7 @@ checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
 
 [[package]]
 name = "cm-dashboard"
-version = "0.1.276"
+version = "0.1.265"
 dependencies = [
  "anyhow",
  "chrono",
@@ -301,7 +301,7 @@ dependencies = [
 
 [[package]]
 name = "cm-dashboard-agent"
-version = "0.1.275"
+version = "0.1.265"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -325,7 +325,7 @@ dependencies = [
 
 [[package]]
 name = "cm-dashboard-shared"
-version = "0.1.275"
+version = "0.1.265"
 dependencies = [
  "chrono",
  "serde",

agent/Cargo.toml

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

agent/src/collectors/backup.rs

@@ -1,7 +1,7 @@
 use async_trait::async_trait;
-use cm_dashboard_shared::{AgentData, BackupData, BackupRepositoryData, Status};
+use cm_dashboard_shared::{AgentData, BackupData, BackupDiskData, Status};
 use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::fs;
 use std::path::{Path, PathBuf};
 use tracing::{debug, warn};
@@ -21,7 +21,7 @@ impl BackupCollector {
         }
     }
 
-    /// Scan directory for backup status file (nfs-backup.toml)
+    /// Scan directory for all backup status files
     async fn scan_status_files(&self) -> Result<Vec<PathBuf>, CollectorError> {
         let status_path = Path::new(&self.status_dir);
 
@@ -30,15 +30,30 @@ impl BackupCollector {
             return Ok(Vec::new());
         }
 
-        // Look for nfs-backup.toml (new NFS-based backup)
+        let mut status_files = Vec::new();
-        let nfs_backup_file = status_path.join("nfs-backup.toml");
+
-        if nfs_backup_file.exists() {
+        match fs::read_dir(status_path) {
-            return Ok(vec![nfs_backup_file]);
+            Ok(entries) => {
+                for entry in entries {
+                    if let Ok(entry) = entry {
+                        let path = entry.path();
+                        if path.is_file() {
+                            if let Some(filename) = path.file_name().and_then(|n| n.to_str()) {
+                                if filename.starts_with("backup-status-") && filename.ends_with(".toml") {
+                                    status_files.push(path);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            Err(e) => {
+                warn!("Failed to read backup status directory: {}", e);
+                return Ok(Vec::new());
+            }
         }
 
-        // No backup status file found
+        Ok(status_files)
-        debug!("No nfs-backup.toml found in {}", self.status_dir);
-        Ok(Vec::new())
     }
 
     /// Read a single backup status file
@@ -61,13 +76,24 @@ impl BackupCollector {
     /// Calculate backup status from TOML status field
     fn calculate_backup_status(status_str: &str) -> Status {
         match status_str.to_lowercase().as_str() {
-            "success" | "completed" => Status::Ok,
+            "success" => Status::Ok,
             "warning" => Status::Warning,
             "failed" | "error" => Status::Critical,
             _ => Status::Unknown,
         }
     }
 
+    /// Calculate usage status from disk usage percentage
+    fn calculate_usage_status(usage_percent: f32) -> Status {
+        if usage_percent < 80.0 {
+            Status::Ok
+        } else if usage_percent < 90.0 {
+            Status::Warning
+        } else {
+            Status::Critical
+        }
+    }
+
     /// Convert BackupStatusToml to BackupData and populate AgentData
     async fn populate_backup_data(&self, agent_data: &mut AgentData) -> Result<(), CollectorError> {
         let status_files = self.scan_status_files().await?;
@@ -75,47 +101,76 @@ impl BackupCollector {
         if status_files.is_empty() {
             debug!("No backup status files found");
             agent_data.backup = BackupData {
-                last_backup_time: None,
-                backup_status: Status::Unknown,
                 repositories: Vec::new(),
+                repository_status: Status::Unknown,
+                disks: Vec::new(),
             };
             return Ok(());
         }
 
-        // Aggregate repository data across all backup status files
+        let mut all_repositories = HashSet::new();
-        let mut repo_map: HashMap<String, BackupRepositoryData> = HashMap::new();
+        let mut disks = Vec::new();
         let mut worst_status = Status::Ok;
-        let mut latest_backup_time: Option<String> = None;
 
         for status_file in status_files {
             match self.read_status_file(&status_file).await {
                 Ok(backup_status) => {
+                    // Collect all service names
+                    for service_name in backup_status.services.keys() {
+                        all_repositories.insert(service_name.clone());
+                    }
+
                     // Calculate backup status
                     let backup_status_enum = Self::calculate_backup_status(&backup_status.status);
-                    worst_status = worst_status.max(backup_status_enum);
 
-                    // Track latest backup time
+                    // Calculate usage status from disk space
-                    if latest_backup_time.is_none() || Some(&backup_status.start_time) > latest_backup_time.as_ref() {
+                    let (usage_percent, used_gb, total_gb, usage_status) = if let Some(disk_space) = &backup_status.disk_space {
-                        latest_backup_time = Some(backup_status.start_time.clone());
+                        let usage_pct = disk_space.usage_percent as f32;
-                    }
+                        (
+                            usage_pct,
+                            disk_space.used_gb as f32,
+                            disk_space.total_gb as f32,
+                            Self::calculate_usage_status(usage_pct),
+                        )
+                    } else {
+                        (0.0, 0.0, 0.0, Status::Unknown)
+                    };
 
-                    // Process each service in this backup
+                    // Update worst status
-                    for (service_name, service_status) in backup_status.services {
+                    worst_status = worst_status.max(backup_status_enum).max(usage_status);
-                        // Convert bytes to GB
-                        let repo_size_gb = service_status.repo_size_bytes as f32 / 1_073_741_824.0;
 
-                        // Calculate service status
+                    // Build service list for this disk
-                        let service_status_enum = Self::calculate_backup_status(&service_status.status);
+                    let services: Vec<String> = backup_status.services.keys().cloned().collect();
-                        worst_status = worst_status.max(service_status_enum);
 
-                        // Update or insert repository data
+                    // Get min and max archive counts to detect inconsistencies
-                        repo_map.insert(service_name.clone(), BackupRepositoryData {
+                    let archives_min: i64 = backup_status.services.values()
-                            name: service_name,
+                        .map(|service| service.archive_count)
-                            archive_count: service_status.archive_count,
+                        .min()
-                            repo_size_gb,
+                        .unwrap_or(0);
-                            status: service_status_enum,
+
-                        });
+                    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()),
+                        product_name: backup_status.disk_product_name,
+                        wear_percent: backup_status.disk_wear_percent,
+                        temperature_celsius: None, // Not available in current TOML
+                        last_backup_time: Some(backup_status.start_time),
+                        backup_status: backup_status_enum,
+                        disk_usage_percent: usage_percent,
+                        disk_used_gb: used_gb,
+                        disk_total_gb: total_gb,
+                        usage_status,
+                        services,
+                        archives_min,
+                        archives_max,
+                    };
+
+                    disks.push(disk_data);
                 }
                 Err(e) => {
                     warn!("Failed to read backup status file {:?}: {}", status_file, e);
@@ -123,14 +178,12 @@ impl BackupCollector {
             }
         }
 
-        // Convert HashMap to sorted Vec
+        let repositories: Vec<String> = all_repositories.into_iter().collect();
-        let mut repositories: Vec<BackupRepositoryData> = repo_map.into_values().collect();
-        repositories.sort_by(|a, b| a.name.cmp(&b.name));
 
         agent_data.backup = BackupData {
-            last_backup_time: latest_backup_time,
-            backup_status: worst_status,
             repositories,
+            repository_status: worst_status,
+            disks,
         };
 
         Ok(())

agent/src/collectors/disk.rs

@@ -114,7 +114,7 @@ impl DiskCollector {
         let mut cmd = TokioCommand::new("lsblk");
         cmd.args(&["-rn", "-o", "NAME,MOUNTPOINT"]);
 
-        let output = run_command_with_timeout(cmd, 10).await
+        let output = run_command_with_timeout(cmd, 2).await
             .map_err(|e| CollectorError::SystemRead {
                 path: "block devices".to_string(),
                 error: e.to_string(),
@@ -184,7 +184,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 = StdCommand::new("timeout")
-            .args(&["10", "df", "--block-size=1", mount_point])
+            .args(&["2", "df", "--block-size=1", mount_point])
             .output()
             .map_err(|e| CollectorError::SystemRead {
                 path: format!("df {}", mount_point),
@@ -433,7 +433,7 @@ impl DiskCollector {
             cmd.args(&["-a", &format!("/dev/{}", drive_name)]);
         }
 
-        let output = run_command_with_timeout(cmd, 15).await
+        let output = run_command_with_timeout(cmd, 3).await
             .map_err(|e| CollectorError::SystemRead {
                 path: format!("SMART data for {}", drive_name),
                 error: e.to_string(),
@@ -772,7 +772,7 @@ impl DiskCollector {
     fn get_drive_info_for_path(&self, path: &str) -> anyhow::Result<PoolDrive> {
         // Use lsblk to find the backing device with timeout
         let output = StdCommand::new("timeout")
-            .args(&["10", "lsblk", "-rn", "-o", "NAME,MOUNTPOINT"])
+            .args(&["2", "lsblk", "-rn", "-o", "NAME,MOUNTPOINT"])
             .output()
             .map_err(|e| anyhow::anyhow!("Failed to run lsblk: {}", e))?;
             

agent/src/collectors/systemd.rs

@@ -230,37 +230,6 @@ impl SystemdCollector {
                         }
                     }
 
-                    if service_name == "nfs-server" && status_info.active_state == "active" {
-                        // Add NFS exports as sub-services
-                        let exports = self.get_nfs_exports();
-                        for (export_path, info) in exports {
-                            let display = if !info.is_empty() {
-                                format!("{} {}", export_path, info)
-                            } else {
-                                export_path
-                            };
-                            sub_services.push(SubServiceData {
-                                name: display,
-                                service_status: Status::Info,
-                                metrics: Vec::new(),
-                                service_type: "nfs_export".to_string(),
-                            });
-                        }
-                    }
-
-                    if (service_name == "smbd" || service_name == "samba-smbd") && status_info.active_state == "active" {
-                        // Add SMB shares as sub-services
-                        let shares = self.get_smb_shares();
-                        for (share_name, share_path, mode) in shares {
-                            sub_services.push(SubServiceData {
-                                name: format!("{}: {} {}", share_name, share_path, mode),
-                                service_status: Status::Info,
-                                metrics: Vec::new(),
-                                service_type: "smb_share".to_string(),
-                            });
-                        }
-                    }
-
                     // Create complete service data
                     let service_data = ServiceData {
                         name: service_name.clone(),
@@ -1042,164 +1011,6 @@ impl SystemdCollector {
         }
     }
 
-    /// Get NFS exports from exportfs
-    /// Returns a list of (export_path, info_string) tuples
-    fn get_nfs_exports(&self) -> Vec<(String, String)> {
-        let output = match Command::new("timeout")
-            .args(["2", "exportfs", "-v"])
-            .output()
-        {
-            Ok(output) if output.status.success() => output,
-            _ => return Vec::new(),
-        };
-
-        let exports_output = String::from_utf8_lossy(&output.stdout);
-        let mut exports_map: std::collections::HashMap<String, Vec<(String, String)>> =
-            std::collections::HashMap::new();
-        let mut current_path: Option<String> = None;
-
-        for line in exports_output.lines() {
-            let trimmed = line.trim();
-
-            if trimmed.is_empty() || trimmed.starts_with('#') {
-                continue;
-            }
-
-            if trimmed.starts_with('/') {
-                // Export path line - may have network on same line or continuation
-                let parts: Vec<&str> = trimmed.splitn(2, char::is_whitespace).collect();
-                let path = parts[0].to_string();
-                current_path = Some(path.clone());
-
-                // Check if network info is on the same line
-                if parts.len() > 1 {
-                    let rest = parts[1].trim();
-                    if let Some(paren_pos) = rest.find('(') {
-                        let network = rest[..paren_pos].trim();
-
-                        if let Some(end_paren) = rest.find(')') {
-                            let options = &rest[paren_pos+1..end_paren];
-                            let mode = if options.contains(",rw,") || options.ends_with(",rw") {
-                                "rw"
-                            } else {
-                                "ro"
-                            };
-
-                            exports_map.entry(path)
-                                .or_insert_with(Vec::new)
-                                .push((network.to_string(), mode.to_string()));
-                        }
-                    }
-                }
-            } else if let Some(ref path) = current_path {
-                // Continuation line with network and options
-                if let Some(paren_pos) = trimmed.find('(') {
-                    let network = trimmed[..paren_pos].trim();
-
-                    if let Some(end_paren) = trimmed.find(')') {
-                        let options = &trimmed[paren_pos+1..end_paren];
-                        let mode = if options.contains(",rw,") || options.ends_with(",rw") {
-                            "rw"
-                        } else {
-                            "ro"
-                        };
-
-                        exports_map.entry(path.clone())
-                            .or_insert_with(Vec::new)
-                            .push((network.to_string(), mode.to_string()));
-                    }
-                }
-            }
-        }
-
-        // Build display strings: "path: mode [networks]"
-        let mut exports: Vec<(String, String)> = exports_map
-            .into_iter()
-            .map(|(path, mut entries)| {
-                if entries.is_empty() {
-                    return (path, String::new());
-                }
-
-                let mode = entries[0].1.clone();
-                let networks: Vec<String> = entries.drain(..).map(|(n, _)| n).collect();
-                let info = format!("{} [{}]", mode, networks.join(", "));
-                (path, info)
-            })
-            .collect();
-
-        exports.sort_by(|a, b| a.0.cmp(&b.0));
-        exports
-    }
-
-    /// Get SMB shares from smb.conf
-    /// Returns a list of (share_name, share_path, mode) tuples
-    fn get_smb_shares(&self) -> Vec<(String, String, String)> {
-        match std::fs::read_to_string("/etc/samba/smb.conf") {
-            Ok(config) => {
-                let mut shares = Vec::new();
-                let mut current_share: Option<String> = None;
-                let mut current_path: Option<String> = None;
-                let mut current_mode: String = "ro".to_string(); // Default to read-only
-
-                for line in config.lines() {
-                    let line = line.trim();
-
-                    // Skip comments and empty lines
-                    if line.is_empty() || line.starts_with('#') || line.starts_with(';') {
-                        continue;
-                    }
-
-                    // Detect share section [sharename]
-                    if line.starts_with('[') && line.ends_with(']') {
-                        // Save previous share if we have both name and path
-                        if let (Some(name), Some(path)) = (current_share.take(), current_path.take()) {
-                            // Skip special sections
-                            if name != "global" && name != "homes" && name != "printers" {
-                                shares.push((name, path, current_mode.clone()));
-                            }
-                        }
-
-                        // Start new share
-                        let share_name = line[1..line.len()-1].trim().to_string();
-                        current_share = Some(share_name);
-                        current_path = None;
-                        current_mode = "ro".to_string(); // Reset to default
-                    }
-                    // Look for path = /some/path
-                    else if line.starts_with("path") && line.contains('=') {
-                        if let Some(path_value) = line.split('=').nth(1) {
-                            current_path = Some(path_value.trim().to_string());
-                        }
-                    }
-                    // Look for read only = yes/no
-                    else if line.to_lowercase().starts_with("read only") && line.contains('=') {
-                        if let Some(value) = line.split('=').nth(1) {
-                            let val = value.trim().to_lowercase();
-                            current_mode = if val == "no" || val == "false" { "rw" } else { "ro" }.to_string();
-                        }
-                    }
-                    // Look for writable = yes/no (opposite of read only)
-                    else if line.to_lowercase().starts_with("writable") && line.contains('=') {
-                        if let Some(value) = line.split('=').nth(1) {
-                            let val = value.trim().to_lowercase();
-                            current_mode = if val == "yes" || val == "true" { "rw" } else { "ro" }.to_string();
-                        }
-                    }
-                }
-
-                // Don't forget the last share
-                if let (Some(name), Some(path)) = (current_share, current_path) {
-                    if name != "global" && name != "homes" && name != "printers" {
-                        shares.push((name, path, current_mode));
-                    }
-                }
-
-                shares
-            }
-            _ => Vec::new(),
-        }
-    }
-
     /// Get nftables open ports grouped by protocol
     /// Returns: (tcp_ports_string, udp_ports_string)
     fn get_nftables_open_ports(&self) -> (String, String) {

dashboard/Cargo.toml

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

dashboard/src/app.rs

@@ -22,6 +22,7 @@ pub struct Dashboard {
     headless: bool,
     initial_commands_sent: std::collections::HashSet<String>,
     config: DashboardConfig,
+    title_area: Rect, // Store title area for mouse event handling
     system_area: Rect, // Store system area for mouse event handling
     services_area: Rect, // Store services area for mouse event handling
 }
@@ -123,6 +124,7 @@ impl Dashboard {
             headless,
             initial_commands_sent: std::collections::HashSet::new(),
             config,
+            title_area: Rect::default(),
             system_area: Rect::default(),
             services_area: Rect::default(),
         })
@@ -270,9 +272,22 @@ impl Dashboard {
                             warn!("Error autoresizing terminal: {}", e);
                         }
 
-                        // Render TUI regardless of terminal size
+                        // Check minimum terminal size to prevent panics
-                        if let Err(e) = terminal.draw(|frame| {
+                        let size = terminal.size().unwrap_or_default();
-                            let (_title_area, system_area, services_area) = tui_app.render(frame, &self.metric_store);
+                        if size.width < 90 || size.height < 15 {
+                            // Terminal too small, show error message
+                            let msg_text = format!("Terminal too small\n\nMinimum: 90x15\nCurrent: {}x{}", size.width, size.height);
+                            let _ = terminal.draw(|frame| {
+                                use ratatui::widgets::{Paragraph, Block, Borders};
+                                use ratatui::layout::Alignment;
+                                let msg = Paragraph::new(msg_text.clone())
+                                    .alignment(Alignment::Center)
+                                    .block(Block::default().borders(Borders::ALL));
+                                frame.render_widget(msg, frame.size());
+                            });
+                        } else if let Err(e) = terminal.draw(|frame| {
+                            let (title_area, system_area, services_area) = tui_app.render(frame, &self.metric_store);
+                            self.title_area = title_area;
                             self.system_area = system_area;
                             self.services_area = services_area;
                         }) {
@@ -377,13 +392,19 @@ impl Dashboard {
             return Ok(());
         }
 
-        // Check for tab clicks in right panel (hosts | services)
+        // Check for title bar clicks (host selection)
         if matches!(mouse.kind, MouseEventKind::Down(MouseButton::Left)) {
-            let services_end = self.services_area.x.saturating_add(self.services_area.width);
+            if is_in_area(x, y, &self.title_area) {
-            if y == self.services_area.y && x >= self.services_area.x && x < services_end {
+                // Click in title bar - check if it's on a hostname
-                // Click on top border of services area (where tabs are)
+                // The title bar has "cm-dashboard vX.X.X" on the left (22 chars)
-                if let Some(ref mut tui_app) = self.tui_app {
+                // Then hostnames start at position 22
-                    tui_app.handle_tab_click(x, &self.services_area);
+                if x >= 22 {
+                    let hostname = self.find_hostname_at_position(x);
+                    if let Some(host) = hostname {
+                        if let Some(ref mut tui_app) = self.tui_app {
+                            tui_app.switch_to_host(&host);
+                        }
+                    }
                 }
                 return Ok(());
             }
@@ -447,66 +468,44 @@ impl Dashboard {
                     return Ok(());
                 }
 
+                // Calculate which service was clicked
+                // The services area includes a border, so we need to account for that
+                let relative_y = y.saturating_sub(self.services_area.y + 2) as usize; // +2 for border and header
+
                 if let Some(ref mut tui_app) = self.tui_app {
-                    if tui_app.focus_hosts {
+                    if let Some(hostname) = tui_app.current_host.clone() {
-                        // Hosts tab is active - handle host click
+                        let host_widgets = tui_app.get_or_create_host_widgets(&hostname);
-                        // The services area includes a border and header, so account for that
-                        let relative_y = y.saturating_sub(self.services_area.y + 2) as usize; // +2 for border and header
 
-                        let total_hosts = tui_app.get_available_hosts().len();
+                        // Account for scroll offset - the clicked line is relative to viewport
-                        let clicked_index = tui_app.hosts_widget.y_to_host_index(relative_y);
+                        let display_line_index = host_widgets.services_widget.scroll_offset + relative_y;
+
+                        // Map display line to parent service index
+                        if let Some(parent_index) = host_widgets.services_widget.display_line_to_parent_index(display_line_index) {
+                            // Set the selected index to the clicked parent service
+                            host_widgets.services_widget.selected_index = parent_index;
 
-                        if clicked_index < total_hosts {
                             match button {
                                 MouseButton::Left => {
-                                    // Left click: set selector and switch to host immediately
+                                    // Left click just selects the service
-                                    tui_app.hosts_widget.set_selected_index(clicked_index, total_hosts);
+                                    debug!("Left-clicked service at display line {} (parent index: {})", display_line_index, parent_index);
-                                    let selected_host = tui_app.get_available_hosts()[clicked_index].clone();
+                                }
-                                    tui_app.switch_to_host(&selected_host);
+                                MouseButton::Right => {
-                                    debug!("Clicked host at index {}: {}", clicked_index, selected_host);
+                                    // Right click opens context menu
+                                    debug!("Right-clicked service at display line {} (parent index: {})", display_line_index, parent_index);
+
+                                    // Get the service name for the popup
+                                    if let Some(service_name) = host_widgets.services_widget.get_selected_service() {
+                                        tui_app.popup_menu = Some(crate::ui::PopupMenu {
+                                            service_name,
+                                            x,
+                                            y,
+                                            selected_index: 0,
+                                        });
+                                    }
                                 }
                                 _ => {}
                             }
                         }
-                    } else {
-                        // Services tab is active - handle service click
-                        // The services area includes a border, so we need to account for that
-                        let relative_y = y.saturating_sub(self.services_area.y + 2) as usize; // +2 for border and header
-
-                        if let Some(hostname) = tui_app.current_host.clone() {
-                            let host_widgets = tui_app.get_or_create_host_widgets(&hostname);
-
-                            // Account for scroll offset - the clicked line is relative to viewport
-                            let display_line_index = host_widgets.services_widget.scroll_offset + relative_y;
-
-                            // Map display line to parent service index
-                            if let Some(parent_index) = host_widgets.services_widget.display_line_to_parent_index(display_line_index) {
-                                // Set the selected index to the clicked parent service
-                                host_widgets.services_widget.selected_index = parent_index;
-
-                                match button {
-                                    MouseButton::Left => {
-                                        // Left click just selects the service
-                                        debug!("Left-clicked service at display line {} (parent index: {})", display_line_index, parent_index);
-                                    }
-                                    MouseButton::Right => {
-                                        // Right click opens context menu
-                                        debug!("Right-clicked service at display line {} (parent index: {})", display_line_index, parent_index);
-
-                                        // Get the service name for the popup
-                                        if let Some(service_name) = host_widgets.services_widget.get_selected_service() {
-                                            tui_app.popup_menu = Some(crate::ui::PopupMenu {
-                                                service_name,
-                                                x,
-                                                y,
-                                                selected_index: 0,
-                                            });
-                                        }
-                                    }
-                                    _ => {}
-                                }
-                            }
-                        }
                     }
                 }
             }
@@ -601,12 +600,76 @@ impl Dashboard {
             .unwrap_or_else(|| hostname.to_string())
     }
 
+    /// Find which hostname is at a given x position in the title bar
+    fn find_hostname_at_position(&self, x: u16) -> Option<String> {
+        if let Some(ref tui_app) = self.tui_app {
+            // The hosts are RIGHT-ALIGNED in chunks[1]!
+            // Need to calculate total width first, then right-align
+
+            // Get terminal width
+            let terminal_width = if let Some(ref terminal) = self.terminal {
+                terminal.size().unwrap_or_default().width
+            } else {
+                80
+            };
+
+            // Calculate total width of all host text
+            let mut total_width = 0_u16;
+            for (i, host) in tui_app.get_available_hosts().iter().enumerate() {
+                if i > 0 {
+                    total_width += 1; // space between hosts
+                }
+                total_width += 2; // icon + space
+                let is_selected = Some(host) == tui_app.current_host.as_ref();
+                if is_selected {
+                    total_width += 1 + host.len() as u16 + 1; // [hostname]
+                } else {
+                    total_width += host.len() as u16;
+                }
+            }
+            total_width += 1; // right padding
+
+            // chunks[1] starts at 22, has width of (terminal_width - 22)
+            let chunk_width = terminal_width - 22;
+
+            // Right-aligned position
+            let hosts_start_x = if total_width < chunk_width {
+                22 + (chunk_width - total_width)
+            } else {
+                22
+            };
+
+            // Now calculate positions starting from hosts_start_x
+            let mut pos = hosts_start_x;
+
+            for (i, host) in tui_app.get_available_hosts().iter().enumerate() {
+                if i > 0 {
+                    pos += 1; // " "
+                }
+
+                let host_start = pos;
+                pos += 2; // "● "
+
+                let is_selected = Some(host) == tui_app.current_host.as_ref();
+                if is_selected {
+                    pos += 1 + host.len() as u16 + 1; // [hostname]
+                } else {
+                    pos += host.len() as u16;
+                }
+
+                if x >= host_start && x < pos {
+                    return Some(host.clone());
+                }
+            }
+        }
+        None
+    }
 }
 
 /// Check if a point is within a rectangular area
 fn is_in_area(x: u16, y: u16, area: &Rect) -> bool {
-    x >= area.x && x < area.x.saturating_add(area.width)
+    x >= area.x && x < area.x + area.width
-        && y >= area.y && y < area.y.saturating_add(area.height)
+        && y >= area.y && y < area.y + area.height
 }
 
 impl Drop for Dashboard {

dashboard/src/ui/mod.rs

@@ -18,7 +18,7 @@ use crate::config::DashboardConfig;
 use crate::metrics::MetricStore;
 use cm_dashboard_shared::Status;
 use theme::{Components, Layout as ThemeLayout, Theme};
-use widgets::{HostsWidget, ServicesWidget, SystemWidget, Widget};
+use widgets::{ServicesWidget, SystemWidget, Widget};
 
 
 
@@ -64,6 +64,8 @@ pub struct TuiApp {
     pub current_host: Option<String>,
     /// Available hosts
     available_hosts: Vec<String>,
+    /// Host index for navigation
+    host_index: usize,
     /// Should quit application
     should_quit: bool,
     /// Track if user manually navigated away from localhost
@@ -74,10 +76,6 @@ pub struct TuiApp {
     localhost: String,
     /// Active popup menu (if any)
     pub popup_menu: Option<PopupMenu>,
-    /// Focus on hosts tab (false = Services, true = Hosts)
-    pub focus_hosts: bool,
-    /// Hosts widget for navigation and rendering
-    pub hosts_widget: HostsWidget,
 }
 
 impl TuiApp {
@@ -87,13 +85,12 @@ impl TuiApp {
             host_widgets: HashMap::new(),
             current_host: None,
             available_hosts: config.hosts.keys().cloned().collect(),
+            host_index: 0,
             should_quit: false,
             user_navigated_away: false,
             config,
             localhost,
             popup_menu: None,
-            focus_hosts: true, // Start with Hosts tab focused by default
-            hosts_widget: HostsWidget::new(),
         };
         
         // Sort predefined hosts
@@ -146,31 +143,26 @@ impl TuiApp {
         all_hosts.sort();
         self.available_hosts = all_hosts;
         
-        // Track if we had a host before this update
-        let had_host = self.current_host.is_some();
-
         // Get the current hostname (localhost) for auto-selection
         if !self.available_hosts.is_empty() {
             if self.available_hosts.contains(&self.localhost) && !self.user_navigated_away {
                 // Localhost is available and user hasn't navigated away - switch to it
                 self.current_host = Some(self.localhost.clone());
-                // Initialize selector bar on first host selection
+                // Find the actual index of localhost in the sorted list
-                if !had_host {
+                self.host_index = self.available_hosts.iter().position(|h| h == &self.localhost).unwrap_or(0);
-                    let index = self.available_hosts.iter().position(|h| h == &self.localhost).unwrap_or(0);
-                    self.hosts_widget.set_selected_index(index, self.available_hosts.len());
-                }
             } else if self.current_host.is_none() {
                 // No current host - select first available (which is localhost if available)
                 self.current_host = Some(self.available_hosts[0].clone());
-                // Initialize selector bar
+                self.host_index = 0;
-                self.hosts_widget.set_selected_index(0, self.available_hosts.len());
             } else if let Some(ref current) = self.current_host {
                 if !self.available_hosts.contains(current) {
-                    // Current host disconnected - FORCE switch to first available
+                    // Current host disconnected - select first available and reset navigation flag
                     self.current_host = Some(self.available_hosts[0].clone());
-                    // Reset selector bar since we're forcing a host change
+                    self.host_index = 0;
-                    self.hosts_widget.set_selected_index(0, self.available_hosts.len());
                     self.user_navigated_away = false; // Reset since we're forced to switch
+                } else if let Some(index) = self.available_hosts.iter().position(|h| h == current) {
+                    // Update index for current host
+                    self.host_index = index;
                 }
             }
         }
@@ -191,6 +183,12 @@ impl TuiApp {
                 KeyCode::Char('q') => {
                     self.should_quit = true;
                 }
+                KeyCode::Left => {
+                    self.navigate_host(-1);
+                }
+                KeyCode::Right => {
+                    self.navigate_host(1);
+                }
                 KeyCode::Char('r') => {
                     // System rebuild command - works on any panel for current host
                     if let Some(hostname) = self.current_host.clone() {
@@ -358,46 +356,25 @@ impl TuiApp {
                     }
                 }
                 KeyCode::Tab => {
-                    // Tab toggles between Services and Hosts tabs
+                    // Tab cycles to next host
-                    self.focus_hosts = !self.focus_hosts;
+                    self.navigate_host(1);
                 }
                 KeyCode::Up | KeyCode::Char('k') => {
-                    if self.focus_hosts {
+                    // Move service selection up
-                        // Move blue selector bar up when in Hosts tab
+                    if let Some(hostname) = self.current_host.clone() {
-                        self.hosts_widget.select_previous();
+                        let host_widgets = self.get_or_create_host_widgets(&hostname);
-                    } else {
+                        host_widgets.services_widget.select_previous();
-                        // Move service selection up when in Services tab
-                        if let Some(hostname) = self.current_host.clone() {
-                            let host_widgets = self.get_or_create_host_widgets(&hostname);
-                            host_widgets.services_widget.select_previous();
-                        }
                     }
                 }
                 KeyCode::Down | KeyCode::Char('j') => {
-                    if self.focus_hosts {
+                    // Move service selection down
-                        // Move blue selector bar down when in Hosts tab
+                    if let Some(hostname) = self.current_host.clone() {
-                        let total_hosts = self.available_hosts.len();
+                        let total_services = {
-                        self.hosts_widget.select_next(total_hosts);
-                    } else {
-                        // Move service selection down when in Services tab
-                        if let Some(hostname) = self.current_host.clone() {
-                            let total_services = {
-                                let host_widgets = self.get_or_create_host_widgets(&hostname);
-                                host_widgets.services_widget.get_total_services_count()
-                            };
                             let host_widgets = self.get_or_create_host_widgets(&hostname);
-                            host_widgets.services_widget.select_next(total_services);
+                            host_widgets.services_widget.get_total_services_count()
-                        }
+                        };
-                    }
+                        let host_widgets = self.get_or_create_host_widgets(&hostname);
-                }
+                        host_widgets.services_widget.select_next(total_services);
-                KeyCode::Enter => {
-                    if self.focus_hosts {
-                        // Enter key switches to the selected host
-                        let selected_idx = self.hosts_widget.get_selected_index();
-                        if selected_idx < self.available_hosts.len() {
-                            let selected_host = self.available_hosts[selected_idx].clone();
-                            self.switch_to_host(&selected_host);
-                        }
                     }
                 }
                 _ => {}
@@ -409,8 +386,7 @@ impl TuiApp {
     /// Switch to a specific host by name
     pub fn switch_to_host(&mut self, hostname: &str) {
         if let Some(index) = self.available_hosts.iter().position(|h| h == hostname) {
-            // Update selector bar position
+            self.host_index = index;
-            self.hosts_widget.set_selected_index(index, self.available_hosts.len());
             self.current_host = Some(hostname.to_string());
 
             // Check if user navigated away from localhost
@@ -424,28 +400,36 @@ impl TuiApp {
         }
     }
 
-    /// Handle mouse click on tab title area
+    /// Navigate between hosts
-    pub fn handle_tab_click(&mut self, x: u16, area: &Rect) {
+    fn navigate_host(&mut self, direction: i32) {
-        // Tab title format: "hosts | services"
+        if self.available_hosts.is_empty() {
-        // Calculate positions relative to area start
+            return;
-        let title_start_x = area.x + 1; // +1 for left border
-
-        // "hosts | services"
-        // 0123456789...
-        let hosts_start = title_start_x;
-        let hosts_end = hosts_start + 5; // "hosts" is 5 chars
-        let services_start = hosts_end + 3; // After " | "
-        let services_end = services_start + 8; // "services" is 8 chars
-
-        if x >= hosts_start && x < hosts_end {
-            // Clicked on "hosts"
-            self.focus_hosts = true;
-        } else if x >= services_start && x < services_end {
-            // Clicked on "services"
-            self.focus_hosts = false;
         }
-    }
 
+        let len = self.available_hosts.len();
+        if direction > 0 {
+            self.host_index = (self.host_index + 1) % len;
+        } else {
+            self.host_index = if self.host_index == 0 {
+                len - 1
+            } else {
+                self.host_index - 1
+            };
+        }
+
+        self.current_host = Some(self.available_hosts[self.host_index].clone());
+
+        // Check if user navigated away from localhost
+        if let Some(ref current) = self.current_host {
+            if current != &self.localhost {
+                self.user_navigated_away = true;
+            } else {
+                self.user_navigated_away = false; // User navigated back to localhost
+            }
+        }
+
+        info!("Switched to host: {}", self.current_host.as_ref().unwrap());
+    }
 
 
 
@@ -535,9 +519,15 @@ impl TuiApp {
         let system_area = left_chunks[0];
         self.render_system_panel(frame, system_area, metric_store);
 
-        // Render right panel with tabs (Services | Hosts)
+        // Render services widget for current host
         let services_area = content_chunks[1];
-        self.render_right_panel_with_tabs(frame, services_area, metric_store);
+        if let Some(hostname) = self.current_host.clone() {
+            let is_focused = true; // Always show service selection
+            let host_widgets = self.get_or_create_host_widgets(&hostname);
+            host_widgets
+                .services_widget
+                .render(frame, services_area, is_focused); // Services takes full right side
+        }
 
         // Render statusbar at the bottom
         self.render_statusbar(frame, main_chunks[2], metric_store);
@@ -555,6 +545,7 @@ impl TuiApp {
     fn render_btop_title(&self, frame: &mut Frame, area: Rect, metric_store: &MetricStore) {
         use ratatui::style::Modifier;
         use ratatui::text::{Line, Span};
+        use theme::StatusIcons;
 
         if self.available_hosts.is_empty() {
             let title_text = "cm-dashboard • no hosts discovered";
@@ -577,34 +568,86 @@ impl TuiApp {
         // Use the worst status color as background
         let background_color = Theme::status_color(worst_status);
 
-        // Single line title bar showing dashboard name (left) and dashboard IP (right)
+        // Split the title bar into left and right sections
-        let left_text = format!(" cm-dashboard v{}", env!("CARGO_PKG_VERSION"));
+        let chunks = Layout::default()
+            .direction(Direction::Horizontal)
+            .constraints([Constraint::Length(22), Constraint::Min(0)])
+            .split(area);
 
-        // Get dashboard local IP for right side
+        // Left side: "cm-dashboard" text with version
-        let dashboard_ip = Self::get_local_ip();
+        let title_text = format!(" cm-dashboard v{}", env!("CARGO_PKG_VERSION"));
-        let right_text = format!("{} ", dashboard_ip);
+        let left_span = Span::styled(
+            &title_text, 
+            Style::default().fg(Theme::background()).bg(background_color).add_modifier(Modifier::BOLD)
+        );
+        let left_title = Paragraph::new(Line::from(vec![left_span]))
+            .style(Style::default().bg(background_color));
+        frame.render_widget(left_title, chunks[0]);
 
-        // Calculate spacing to push right text to the right
+        // Right side: hosts with status indicators
-        let total_text_len = left_text.len() + right_text.len();
+        let mut host_spans = Vec::new();
-        let spacing = (area.width as usize).saturating_sub(total_text_len).max(1);
-        let spacing_str = " ".repeat(spacing);
         
-        let title = Paragraph::new(Line::from(vec![
+        for (i, host) in self.available_hosts.iter().enumerate() {
-            Span::styled(
+            if i > 0 {
-                left_text,
+                host_spans.push(Span::styled(
-                Style::default().fg(Theme::background()).bg(background_color).add_modifier(Modifier::BOLD)
+                    " ", 
-            ),
+                    Style::default().fg(Theme::background()).bg(background_color)
-            Span::styled(
+                ));
-                spacing_str,
+            }
-                Style::default().bg(background_color)
+
-            ),
+            // Always show normal status icon based on metrics (no command status at host level)
-            Span::styled(
+            let host_status = self.calculate_host_status(host, metric_store);
-                right_text,
+            let status_icon = StatusIcons::get_icon(host_status);
-                Style::default().fg(Theme::background()).bg(background_color)
+
-            ),
+            // Add status icon with background color as foreground against status background
-        ]))
+            host_spans.push(Span::styled(
-        .style(Style::default().bg(background_color));
+                format!("{} ", status_icon),
-        frame.render_widget(title, area);
+                Style::default().fg(Theme::background()).bg(background_color),
+            ));
+
+            if Some(host) == self.current_host.as_ref() {
+                // Selected host with brackets in bold background color against status background
+                host_spans.push(Span::styled(
+                    "[",
+                    Style::default()
+                        .fg(Theme::background())
+                        .bg(background_color)
+                        .add_modifier(Modifier::BOLD),
+                ));
+                host_spans.push(Span::styled(
+                    host.clone(),
+                    Style::default()
+                        .fg(Theme::background())
+                        .bg(background_color)
+                        .add_modifier(Modifier::BOLD),
+                ));
+                host_spans.push(Span::styled(
+                    "]",
+                    Style::default()
+                        .fg(Theme::background())
+                        .bg(background_color)
+                        .add_modifier(Modifier::BOLD),
+                ));
+            } else {
+                // Other hosts in normal background color against status background
+                host_spans.push(Span::styled(
+                    host.clone(),
+                    Style::default().fg(Theme::background()).bg(background_color),
+                ));
+            }
+        }
+
+        // Add right padding
+        host_spans.push(Span::styled(
+            " ", 
+            Style::default().fg(Theme::background()).bg(background_color)
+        ));
+
+        let host_line = Line::from(host_spans);
+        let host_title = Paragraph::new(vec![host_line])
+            .style(Style::default().bg(background_color))
+            .alignment(ratatui::layout::Alignment::Right);
+        frame.render_widget(host_title, chunks[1]);
     }
 
     /// Calculate overall status for a host based on its structured data
@@ -714,15 +757,18 @@ impl TuiApp {
             ("None".to_string(), "N/A".to_string(), "N/A".to_string(), "N/A".to_string())
         };
 
-        let left_text = format!(" Host: {} | {}", hostname_str, host_ip);
+        let left_text = format!("Host: {} | {} | Build:{} | Agent:{}", hostname_str, host_ip, build_version, agent_version);
-        let right_text = format!("Build:{} | Agent:{} ", build_version, agent_version);
 
-        // Calculate spacing to push right text to the right
+        // Get dashboard local IP
-        let total_text_len = left_text.len() + right_text.len();
+        let dashboard_ip = Self::get_local_ip();
-        let spacing = (area.width as usize).saturating_sub(total_text_len).max(1);
+        let right_text = format!("Dashboard: {}", dashboard_ip);
-        let spacing_str = " ".repeat(spacing);
+
+        // Calculate spacing to push right text to the right (accounting for 1 char left padding)
+        let spacing = area.width as usize - left_text.len() - right_text.len() - 2; // -2 for left padding
+        let spacing_str = " ".repeat(spacing.max(1));
 
         let line = Line::from(vec![
+            Span::raw(" "), // 1 char left padding
             Span::styled(left_text, Style::default().fg(Theme::border())),
             Span::raw(spacing_str),
             Span::styled(right_text, Style::default().fg(Theme::border())),
@@ -762,73 +808,6 @@ impl TuiApp {
     }
 
 
-    /// Render right panel with tabs (hosts | services)
-    fn render_right_panel_with_tabs(&mut self, frame: &mut Frame, area: Rect, metric_store: &MetricStore) {
-        use ratatui::style::Modifier;
-        use ratatui::text::{Line, Span};
-        use ratatui::widgets::{Block, Borders};
-
-        // Build tab title with bold styling for active tab (like cm-player)
-        let hosts_style = if self.focus_hosts {
-            Style::default().fg(Theme::border_title()).add_modifier(Modifier::BOLD)
-        } else {
-            Style::default().fg(Theme::border_title())
-        };
-
-        let services_style = if !self.focus_hosts {
-            Style::default().fg(Theme::border_title()).add_modifier(Modifier::BOLD)
-        } else {
-            Style::default().fg(Theme::border_title())
-        };
-
-        let title = Line::from(vec![
-            Span::styled("hosts", hosts_style),
-            Span::raw(" | "),
-            Span::styled("services", services_style),
-        ]);
-
-        // Create ONE block with tab title (like cm-player)
-        let main_block = Block::default()
-            .borders(Borders::ALL)
-            .title(title.clone())
-            .style(Style::default().fg(Theme::border()).bg(Theme::background()));
-
-        let inner_area = main_block.inner(area);
-        frame.render_widget(main_block, area);
-
-        // Render appropriate content based on active tab
-        if self.focus_hosts {
-            // Render hosts list (no additional borders)
-            let localhost = self.localhost.clone();
-            let current_host = self.current_host.as_deref();
-            self.hosts_widget.render(
-                frame,
-                inner_area,
-                &self.available_hosts,
-                &localhost,
-                current_host,
-                metric_store,
-                |hostname, store| {
-                    // Inline calculate_host_status logic
-                    if store.get_agent_data(hostname).is_some() {
-                        Status::Ok
-                    } else {
-                        Status::Offline
-                    }
-                },
-                true, // Always focused when visible
-            );
-        } else {
-            // Render services for current host (no additional borders - just content!)
-            if let Some(hostname) = self.current_host.clone() {
-                let is_focused = true;
-                let host_widgets = self.get_or_create_host_widgets(&hostname);
-                host_widgets.services_widget.render_content(frame, inner_area, is_focused);
-            }
-        }
-    }
-
-
     /// Render offline host message with wake-up option
     fn render_offline_host_message(&self, frame: &mut Frame, area: Rect) {
         use ratatui::layout::Alignment;

dashboard/src/ui/widgets/hosts.rs

@@ -1,229 +0,0 @@
-use ratatui::{
-    layout::Rect,
-    style::{Modifier, Style},
-    text::{Line, Span},
-    widgets::{List, ListItem},
-    Frame,
-};
-
-use crate::metrics::MetricStore;
-use crate::ui::theme::Theme;
-use cm_dashboard_shared::Status;
-
-/// Hosts widget displaying all available hosts with selector bar navigation
-#[derive(Clone)]
-pub struct HostsWidget {
-    /// Currently selected host index (for blue selector bar)
-    pub selected_index: usize,
-    /// Scroll offset for viewport
-    pub scroll_offset: usize,
-    /// Last rendered viewport height for scroll calculations
-    last_viewport_height: usize,
-}
-
-impl HostsWidget {
-    pub fn new() -> Self {
-        Self {
-            selected_index: 0,
-            scroll_offset: 0,
-            last_viewport_height: 0,
-        }
-    }
-
-    /// Move selection up
-    pub fn select_previous(&mut self) {
-        if self.selected_index > 0 {
-            self.selected_index -= 1;
-            self.ensure_selected_visible();
-        }
-    }
-
-    /// Move selection down
-    pub fn select_next(&mut self, total_hosts: usize) {
-        if total_hosts > 0 && self.selected_index < total_hosts.saturating_sub(1) {
-            self.selected_index += 1;
-            self.ensure_selected_visible();
-        }
-    }
-
-    /// Ensure selected item is visible in viewport (auto-scroll)
-    fn ensure_selected_visible(&mut self) {
-        if self.last_viewport_height == 0 {
-            return; // Can't calculate without viewport height
-        }
-
-        let viewport_height = self.last_viewport_height;
-
-        // If selection is above viewport, scroll up to show it
-        if self.selected_index < self.scroll_offset {
-            self.scroll_offset = self.selected_index;
-        }
-
-        // If selection is below viewport, scroll down to show it
-        if self.selected_index >= self.scroll_offset + viewport_height {
-            self.scroll_offset = self.selected_index.saturating_sub(viewport_height.saturating_sub(1));
-        }
-    }
-
-    /// Scroll down manually
-    pub fn scroll_down(&mut self, total_hosts: usize) {
-        if self.last_viewport_height == 0 {
-            return;
-        }
-
-        let viewport_height = self.last_viewport_height;
-        let max_scroll = total_hosts.saturating_sub(viewport_height);
-
-        if self.scroll_offset < max_scroll {
-            self.scroll_offset += 1;
-        }
-    }
-
-    /// Scroll up manually
-    pub fn scroll_up(&mut self) {
-        if self.scroll_offset > 0 {
-            self.scroll_offset -= 1;
-        }
-    }
-
-    /// Get the currently selected host index
-    pub fn get_selected_index(&self) -> usize {
-        self.selected_index
-    }
-
-    /// Set selected index (used when switching to host via mouse)
-    pub fn set_selected_index(&mut self, index: usize, total_hosts: usize) {
-        if index < total_hosts {
-            self.selected_index = index;
-            self.ensure_selected_visible();
-        }
-    }
-
-    /// Convert y coordinate to host index (accounting for scroll)
-    pub fn y_to_host_index(&self, relative_y: usize) -> usize {
-        self.scroll_offset + relative_y
-    }
-
-    /// Render hosts list with selector bar
-    pub fn render<F>(
-        &mut self,
-        frame: &mut Frame,
-        area: Rect,
-        available_hosts: &[String],
-        localhost: &str,
-        current_host: Option<&str>,
-        metric_store: &MetricStore,
-        mut calculate_host_status: F,
-        is_focused: bool,
-    ) where F: FnMut(&str, &MetricStore) -> Status {
-        use crate::ui::theme::{StatusIcons, Typography};
-        use ratatui::widgets::Paragraph;
-
-        // Split area for header and list
-        let chunks = ratatui::layout::Layout::default()
-            .direction(ratatui::layout::Direction::Vertical)
-            .constraints([
-                ratatui::layout::Constraint::Length(1), // Header
-                ratatui::layout::Constraint::Min(0),    // List
-            ])
-            .split(area);
-
-        // Render header
-        let header = Paragraph::new("Hosts:").style(Typography::muted());
-        frame.render_widget(header, chunks[0]);
-
-        // Store viewport height for scroll calculations (minus header)
-        self.last_viewport_height = chunks[1].height as usize;
-
-        // Validate scroll offset
-        if self.scroll_offset >= available_hosts.len() && !available_hosts.is_empty() {
-            self.scroll_offset = available_hosts.len().saturating_sub(1);
-        }
-
-        // Create list items for visible hosts
-        let items: Vec<ListItem> = available_hosts
-            .iter()
-            .enumerate()
-            .skip(self.scroll_offset)
-            .take(chunks[1].height as usize)
-            .map(|(idx, hostname)| {
-                let host_status = calculate_host_status(hostname, metric_store);
-                let status_icon = StatusIcons::get_icon(host_status);
-                let status_color = Theme::status_color(host_status);
-
-                // Check if this is the selected host (for blue selector bar)
-                let is_selected = is_focused && idx == self.selected_index;
-
-                // Check if this is the current (active) host
-                let is_current = current_host == Some(hostname.as_str());
-
-                // Check if this is localhost
-                let is_localhost = hostname == localhost;
-
-                // Build the line with icon and hostname
-                let mut spans = vec![Span::styled(
-                    format!("{} ", status_icon),
-                    if is_selected {
-                        Style::default()
-                            .fg(Theme::background())
-                            .add_modifier(Modifier::BOLD)
-                    } else {
-                        Style::default().fg(status_color)
-                    },
-                )];
-
-                // Add arrow indicator if this is the current host (like cm-player)
-                if is_current {
-                    spans.push(Span::styled(
-                        "▸ ",
-                        if is_selected {
-                            Style::default()
-                                .fg(Theme::background())
-                                .add_modifier(Modifier::BOLD)
-                        } else {
-                            Style::default()
-                                .fg(Theme::primary_text())
-                                .add_modifier(Modifier::BOLD)
-                        },
-                    ));
-                }
-
-                // Add hostname with appropriate styling
-                let hostname_text = if is_localhost {
-                    format!("{} (localhost)", hostname)
-                } else {
-                    hostname.clone()
-                };
-
-                spans.push(Span::styled(
-                    hostname_text,
-                    if is_selected {
-                        Style::default()
-                            .fg(Theme::background())
-                            .add_modifier(Modifier::BOLD)
-                    } else if is_current {
-                        Style::default()
-                            .fg(Theme::primary_text())
-                            .add_modifier(Modifier::BOLD)
-                    } else {
-                        Style::default().fg(Theme::primary_text())
-                    },
-                ));
-
-                let line = Line::from(spans);
-
-                // Apply blue background to selected row
-                let base_style = if is_selected {
-                    Style::default().bg(Theme::highlight()) // Blue background
-                } else {
-                    Style::default().bg(Theme::background())
-                };
-
-                ListItem::new(line).style(base_style)
-            })
-            .collect();
-
-        let hosts_list = List::new(items);
-        frame.render_widget(hosts_list, chunks[1]);
-    }
-}

dashboard/src/ui/widgets/mod.rs

@@ -1,10 +1,8 @@
 use cm_dashboard_shared::AgentData;
 
-pub mod hosts;
 pub mod services;
 pub mod system;
 
-pub use hosts::HostsWidget;
 pub use services::ServicesWidget;
 pub use system::SystemWidget;
 

dashboard/src/ui/widgets/services.rs

@@ -713,11 +713,7 @@ impl ServicesWidget {
 
     /// Render with focus
     pub fn render(&mut self, frame: &mut Frame, area: Rect, is_focused: bool) {
-        self.render_with_title(frame, area, is_focused, "services");
+        let services_block = Components::widget_block("services");
-    }
-
-    pub fn render_with_title(&mut self, frame: &mut Frame, area: Rect, is_focused: bool, title: &str) {
-        let services_block = Components::widget_block(title);
         let inner_area = services_block.inner(area);
         frame.render_widget(services_block, area);
 
@@ -762,49 +758,6 @@ impl ServicesWidget {
         self.render_services(frame, content_chunks[1], is_focused, columns);
     }
 
-    /// Render services content WITHOUT block (for tab mode like cm-player)
-    pub fn render_content(&mut self, frame: &mut Frame, area: Rect, is_focused: bool) {
-        let content_chunks = Layout::default()
-            .direction(Direction::Vertical)
-            .constraints([Constraint::Length(1), Constraint::Min(0)])
-            .split(area);
-
-        // Determine which columns to show based on available width
-        let columns = ColumnVisibility::from_width(area.width);
-
-        // Build header based on visible columns
-        let mut header_parts = Vec::new();
-        if columns.show_name {
-            header_parts.push(format!("{:<width$}", "Service:", width = ColumnVisibility::NAME_WIDTH as usize));
-        }
-        if columns.show_status {
-            header_parts.push(format!("{:<width$}", "Status:", width = ColumnVisibility::STATUS_WIDTH as usize));
-        }
-        if columns.show_ram {
-            header_parts.push(format!("{:<width$}", "RAM:", width = ColumnVisibility::RAM_WIDTH as usize));
-        }
-        if columns.show_uptime {
-            header_parts.push(format!("{:<width$}", "Uptime:", width = ColumnVisibility::UPTIME_WIDTH as usize));
-        }
-        if columns.show_restarts {
-            header_parts.push(format!("{:<width$}", "↻:", width = ColumnVisibility::RESTARTS_WIDTH as usize));
-        }
-        let header = header_parts.join(" ");
-
-        let header_para = Paragraph::new(header).style(Typography::muted());
-        frame.render_widget(header_para, content_chunks[0]);
-
-        // Check if we have any services to display
-        if self.parent_services.is_empty() && self.sub_services.is_empty() {
-            let empty_text = Paragraph::new("No process data").style(Typography::muted());
-            frame.render_widget(empty_text, content_chunks[1]);
-            return;
-        }
-
-        // Render the services list
-        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, columns: ColumnVisibility) {
         // Build hierarchical service list for display

dashboard/src/ui/widgets/system.rs

@@ -44,9 +44,9 @@ pub struct SystemWidget {
     storage_pools: Vec<StoragePool>,
     
     // Backup metrics
-    backup_last_time: Option<String>,
+    backup_repositories: Vec<String>,
-    backup_status: Status,
+    backup_repository_status: Status,
-    backup_repositories: Vec<cm_dashboard_shared::BackupRepositoryData>,
+    backup_disks: Vec<cm_dashboard_shared::BackupDiskData>,
     
     // Overall status
     has_data: bool,
@@ -112,9 +112,9 @@ impl SystemWidget {
             tmp_status: Status::Unknown,
             tmpfs_mounts: Vec::new(),
             storage_pools: Vec::new(),
-            backup_last_time: None,
-            backup_status: Status::Unknown,
             backup_repositories: Vec::new(),
+            backup_repository_status: Status::Unknown,
+            backup_disks: Vec::new(),
             has_data: false,
             scroll_offset: 0,
             last_viewport_height: 0,
@@ -221,9 +221,9 @@ impl Widget for SystemWidget {
 
         // Extract backup data
         let backup = &agent_data.backup;
-        self.backup_last_time = backup.last_backup_time.clone();
-        self.backup_status = backup.backup_status;
         self.backup_repositories = backup.repositories.clone();
+        self.backup_repository_status = backup.repository_status;
+        self.backup_disks = backup.disks.clone();
 
         // Clamp scroll offset to valid range after update
         // This prevents scroll issues when switching between hosts
@@ -533,42 +533,79 @@ impl SystemWidget {
     fn render_backup(&self) -> Vec<Line<'_>> {
         let mut lines = Vec::new();
 
-        if self.backup_repositories.is_empty() {
+        // First section: Repository status and list
-            return lines;
+        if !self.backup_repositories.is_empty() {
+            let repo_text = format!("Repo: {}", self.backup_repositories.len());
+            let repo_spans = StatusIcons::create_status_spans(self.backup_repository_status, &repo_text);
+            lines.push(Line::from(repo_spans));
+
+            // List all repositories (sorted for consistent display)
+            let mut sorted_repos = self.backup_repositories.clone();
+            sorted_repos.sort();
+            let repo_count = sorted_repos.len();
+            for (idx, repo) in sorted_repos.iter().enumerate() {
+                let tree_char = if idx == repo_count - 1 { "└─" } else { "├─" };
+                lines.push(Line::from(vec![
+                    Span::styled(format!("  {} ", tree_char), Typography::tree()),
+                    Span::styled(repo.clone(), Typography::secondary()),
+                ]));
+            }
         }
 
-        // Format backup time (use complete timestamp)
+        // Second section: Per-disk backup information (sorted by serial for consistent display)
-        let time_display = if let Some(ref time_str) = self.backup_last_time {
+        let mut sorted_disks = self.backup_disks.clone();
-            time_str.clone()
+        sorted_disks.sort_by(|a, b| a.serial.cmp(&b.serial));
-        } else {
+        for disk in &sorted_disks {
-            "unknown".to_string()
+            let truncated_serial = truncate_serial(&disk.serial);
-        };
+            let mut details = Vec::new();
 
-        // Header: just the timestamp
+            if let Some(temp) = disk.temperature_celsius {
-        let repo_spans = StatusIcons::create_status_spans(self.backup_status, &time_display);
+                details.push(format!("T: {}°C", temp as i32));
-        lines.push(Line::from(repo_spans));
+            }
+            if let Some(wear) = disk.wear_percent {
+                details.push(format!("W: {}%", wear as i32));
+            }
 
-        // List all repositories with archive count and size
+            let disk_text = if !details.is_empty() {
-        let repo_count = self.backup_repositories.len();
+                format!("{} {}", truncated_serial, details.join(" "))
-        for (idx, repo) in self.backup_repositories.iter().enumerate() {
-            let tree_char = if idx == repo_count - 1 { "└─" } else { "├─" };
-
-            // Format size: use kB for < 1MB, MB for < 1GB, otherwise GB
-            let size_display = if repo.repo_size_gb < 0.001 {
-                format!("{:.0}kB", repo.repo_size_gb * 1024.0 * 1024.0)
-            } else if repo.repo_size_gb < 1.0 {
-                format!("{:.0}MB", repo.repo_size_gb * 1024.0)
             } else {
-                format!("{:.1}GB", repo.repo_size_gb)
+                truncated_serial
             };
 
-            let repo_text = format!("{} ({}) {}", repo.name, repo.archive_count, size_display);
+            // Overall disk status (worst of backup and usage)
+            let disk_status = disk.backup_status.max(disk.usage_status);
+            let disk_spans = StatusIcons::create_status_spans(disk_status, &disk_text);
+            lines.push(Line::from(disk_spans));
 
-            let mut repo_spans = vec![
+            // Show backup time with status
-                Span::styled(format!("  {} ", tree_char), Typography::tree()),
+            if let Some(backup_time) = &disk.last_backup_time {
+                let time_text = format!("Backup: {}", backup_time);
+                let mut time_spans = vec![
+                    Span::styled("  ├─ ", Typography::tree()),
+                ];
+                time_spans.extend(StatusIcons::create_status_spans(disk.backup_status, &time_text));
+                lines.push(Line::from(time_spans));
+            }
+
+            // 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",
+                archive_display,
+                disk.disk_usage_percent,
+                disk.disk_used_gb,
+                disk.disk_total_gb
+            );
+            let mut usage_spans = vec![
+                Span::styled("  └─ ", Typography::tree()),
             ];
-            repo_spans.extend(StatusIcons::create_status_spans(repo.status, &repo_text));
+            usage_spans.extend(StatusIcons::create_status_spans(disk.usage_status, &usage_text));
-            lines.push(Line::from(repo_spans));
+            lines.push(Line::from(usage_spans));
         }
 
         lines
@@ -839,10 +876,13 @@ impl SystemWidget {
         }
 
         // Backup section
-        if !self.backup_repositories.is_empty() {
+        if !self.backup_repositories.is_empty() || !self.backup_disks.is_empty() {
-            count += 1; // Header: "Backup:"
+            count += 1; // Header
-            count += 1; // Repo count and timestamp header
+            if !self.backup_repositories.is_empty() {
-            count += self.backup_repositories.len(); // Individual repos
+                count += 1; // Repo header
+                count += self.backup_repositories.len();
+            }
+            count += self.backup_disks.len() * 3; // Each disk has 3 lines
         }
 
         count
@@ -948,7 +988,7 @@ impl SystemWidget {
         lines.extend(storage_lines);
 
         // Backup section (if available)
-        if !self.backup_repositories.is_empty() {
+        if !self.backup_repositories.is_empty() || !self.backup_disks.is_empty() {
             lines.push(Line::from(vec![
                 Span::styled("Backup:", Typography::widget_title())
             ]));

shared/Cargo.toml

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

shared/src/agent_data.rs

@@ -182,18 +182,27 @@ pub struct SubServiceMetric {
 /// Backup system data
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct BackupData {
-    pub last_backup_time: Option<String>,
+    pub repositories: Vec<String>,
-    pub backup_status: Status,
+    pub repository_status: Status,
-    pub repositories: Vec<BackupRepositoryData>,
+    pub disks: Vec<BackupDiskData>,
 }
 
-/// Individual backup repository information
+/// Backup repository disk information
 #[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct BackupRepositoryData {
+pub struct BackupDiskData {
-    pub name: String,
+    pub serial: String,
-    pub archive_count: i64,
+    pub product_name: Option<String>,
-    pub repo_size_gb: f32,
+    pub wear_percent: Option<f32>,
-    pub status: Status,
+    pub temperature_celsius: Option<f32>,
+    pub last_backup_time: Option<String>,
+    pub backup_status: Status,
+    pub disk_usage_percent: f32,
+    pub disk_used_gb: f32,
+    pub disk_total_gb: f32,
+    pub usage_status: Status,
+    pub services: Vec<String>,
+    pub archives_min: i64,
+    pub archives_max: i64,
 }
 
 impl AgentData {
@@ -236,9 +245,9 @@ impl AgentData {
             },
             services: Vec::new(),
             backup: BackupData {
-                last_backup_time: None,
-                backup_status: Status::Unknown,
                 repositories: Vec::new(),
+                repository_status: Status::Unknown,
+                disks: Vec::new(),
             },
         }
     }