Remove 'Repo' prefix from backup header display

Simplify backup section header by removing the 'Repo' prefix and
displaying only the timestamp with status icon. Repository details
are still shown as sub-items below the timestamp.

Cargo.lock

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

agent/Cargo.toml

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

agent/src/collectors/backup.rs

@@ -1,7 +1,7 @@
 use async_trait::async_trait;
-use cm_dashboard_shared::{AgentData, BackupData, BackupDiskData, Status};
+use cm_dashboard_shared::{AgentData, BackupData, BackupRepositoryData, Status};
 use serde::{Deserialize, Serialize};
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::fs;
 use std::path::{Path, PathBuf};
 use tracing::{debug, warn};
@@ -21,7 +21,7 @@ impl BackupCollector {
         }
     }
 
-    /// Scan directory for all backup status files
+    /// Scan directory for backup status file (nfs-backup.toml)
     async fn scan_status_files(&self) -> Result<Vec<PathBuf>, CollectorError> {
         let status_path = Path::new(&self.status_dir);
 
@@ -30,30 +30,15 @@ impl BackupCollector {
             return Ok(Vec::new());
         }
 
-        let mut status_files = Vec::new();
+        // Look for nfs-backup.toml (new NFS-based backup)
-
+        let nfs_backup_file = status_path.join("nfs-backup.toml");
-        match fs::read_dir(status_path) {
+        if nfs_backup_file.exists() {
-            Ok(entries) => {
+            return Ok(vec![nfs_backup_file]);
-                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());
-            }
         }
 
-        Ok(status_files)
+        // No backup status file found
+        debug!("No nfs-backup.toml found in {}", self.status_dir);
+        Ok(Vec::new())
     }
 
     /// Read a single backup status file
@@ -76,24 +61,13 @@ 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" => Status::Ok,
+            "success" | "completed" => 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?;
@@ -101,76 +75,47 @@ 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(());
         }
 
-        let mut all_repositories = HashSet::new();
+        // Aggregate repository data across all backup status files
-        let mut disks = Vec::new();
+        let mut repo_map: HashMap<String, BackupRepositoryData> = HashMap::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);
 
-                    // Calculate usage status from disk space
+                    // Track latest backup time
-                    let (usage_percent, used_gb, total_gb, usage_status) = if let Some(disk_space) = &backup_status.disk_space {
+                    if latest_backup_time.is_none() || Some(&backup_status.start_time) > latest_backup_time.as_ref() {
-                        let usage_pct = disk_space.usage_percent as f32;
+                        latest_backup_time = Some(backup_status.start_time.clone());
-                        (
+                    }
-                            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)
-                    };
 
-                    // Update worst status
+                    // Process each service in this backup
-                    worst_status = worst_status.max(backup_status_enum).max(usage_status);
+                    for (service_name, service_status) in backup_status.services {
+                        // Convert bytes to GB
+                        let repo_size_gb = service_status.repo_size_bytes as f32 / 1_073_741_824.0;
 
-                    // Build service list for this disk
+                        // Calculate service status
-                    let services: Vec<String> = backup_status.services.keys().cloned().collect();
+                        let service_status_enum = Self::calculate_backup_status(&service_status.status);
+                        worst_status = worst_status.max(service_status_enum);
 
-                    // Get min and max archive counts to detect inconsistencies
+                        // Update or insert repository data
-                    let archives_min: i64 = backup_status.services.values()
+                        repo_map.insert(service_name.clone(), BackupRepositoryData {
-                        .map(|service| service.archive_count)
+                            name: service_name,
-                        .min()
+                            archive_count: service_status.archive_count,
-                        .unwrap_or(0);
+                            repo_size_gb,
-
+                            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);
@@ -178,12 +123,14 @@ impl BackupCollector {
             }
         }
 
-        let repositories: Vec<String> = all_repositories.into_iter().collect();
+        // Convert HashMap to sorted Vec
+        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/network.rs

@@ -181,6 +181,7 @@ impl NetworkCollector {
                                 link_status,
                                 parent_interface,
                                 vlan_id,
+                                connection_method: None,
                             });
                         }
                     }

agent/src/collectors/systemd.rs

@@ -178,6 +178,18 @@ impl SystemdCollector {
                                 service_type: "torrent_stats".to_string(),
                             });
                         }
+
+                        // Add active torrent copy status for each copy operation
+                        for torrent_name in self.get_active_torrent_copies() {
+                            let metrics = Vec::new();
+
+                            sub_services.push(SubServiceData {
+                                name: format!("Copy: {}", torrent_name),
+                                service_status: Status::Info,
+                                metrics,
+                                service_type: "torrent_copy".to_string(),
+                            });
+                        }
                     }
 
                     if service_name == "nftables" && status_info.active_state == "active" {
@@ -186,7 +198,7 @@ impl SystemdCollector {
                         if !tcp_ports.is_empty() {
                             let metrics = Vec::new();
                             sub_services.push(SubServiceData {
-                                name: format!("TCP: {}", tcp_ports),
+                                name: format!("wan tcp: {}", tcp_ports),
                                 service_status: Status::Info,
                                 metrics,
                                 service_type: "firewall_port".to_string(),
@@ -196,7 +208,7 @@ impl SystemdCollector {
                         if !udp_ports.is_empty() {
                             let metrics = Vec::new();
                             sub_services.push(SubServiceData {
-                                name: format!("UDP: {}", udp_ports),
+                                name: format!("wan udp: {}", udp_ports),
                                 service_status: Status::Info,
                                 metrics,
                                 service_type: "firewall_port".to_string(),
@@ -204,6 +216,20 @@ impl SystemdCollector {
                         }
                     }
 
+                    if service_name == "tailscaled" && status_info.active_state == "active" {
+                        // Add Tailscale peers with their connection methods as sub-services
+                        let peers = self.get_tailscale_peers();
+                        for (peer_name, conn_method) in peers {
+                            let metrics = Vec::new();
+                            sub_services.push(SubServiceData {
+                                name: format!("{}: {}", peer_name, conn_method),
+                                service_status: Status::Info,
+                                metrics,
+                                service_type: "tailscale_peer".to_string(),
+                            });
+                        }
+                    }
+
                     // Create complete service data
                     let service_data = ServiceData {
                         name: service_name.clone(),
@@ -911,6 +937,80 @@ impl SystemdCollector {
         None
     }
 
+    /// Get Tailscale connected peers with their connection methods
+    /// Returns a list of (device_name, connection_method) tuples
+    fn get_tailscale_peers(&self) -> Vec<(String, String)> {
+        match Command::new("timeout")
+            .args(["2", "tailscale", "status"])
+            .output()
+        {
+            Ok(output) if output.status.success() => {
+                let status_output = String::from_utf8_lossy(&output.stdout);
+                let mut peers = Vec::new();
+
+                // Get current hostname to filter it out
+                let current_hostname = gethostname::gethostname()
+                    .to_string_lossy()
+                    .to_string();
+
+                // Parse tailscale status output
+                // Format: IP  hostname  user  os  status
+                // Example: 100.110.98.3    wslbox               cm@          linux   active; direct 192.168.30.227:53757
+                // Note: First line is always the current host, skip it
+                for (idx, line) in status_output.lines().enumerate() {
+                    if idx == 0 {
+                        continue; // Skip first line (current host)
+                    }
+
+                    let parts: Vec<&str> = line.split_whitespace().collect();
+                    if parts.len() < 5 {
+                        continue; // Skip invalid lines
+                    }
+
+                    // parts[0] = IP
+                    // parts[1] = hostname
+                    // parts[2] = user
+                    // parts[3] = OS
+                    // parts[4+] = status (e.g., "active;", "direct", "192.168.30.227:53757" or "idle;" or "offline")
+
+                    let hostname = parts[1];
+
+                    // Skip if this is the current host (double-check in case format changes)
+                    if hostname == current_hostname {
+                        continue;
+                    }
+
+                    let status_parts = &parts[4..];
+
+                    // Determine connection method from status
+                    let connection_method = if status_parts.is_empty() {
+                        continue; // Skip if no status
+                    } else {
+                        let status_str = status_parts.join(" ");
+                        if status_str.contains("offline") {
+                            continue; // Skip offline peers
+                        } else if status_str.contains("direct") {
+                            "direct"
+                        } else if status_str.contains("relay") {
+                            "relay"
+                        } else if status_str.contains("idle") {
+                            "idle"
+                        } else if status_str.contains("active") {
+                            "active"
+                        } else {
+                            continue; // Skip unknown status
+                        }
+                    };
+
+                    peers.push((hostname.to_string(), connection_method.to_string()));
+                }
+
+                peers
+            }
+            _ => Vec::new(),
+        }
+    }
+
     /// Get nftables open ports grouped by protocol
     /// Returns: (tcp_ports_string, udp_ports_string)
     fn get_nftables_open_ports(&self) -> (String, String) {
@@ -1088,6 +1188,31 @@ impl SystemdCollector {
 
         Some((active_count, download_mbps, upload_mbps))
     }
+
+    /// Check for active torrent copy operations
+    /// Returns: Vec of filenames currently being copied
+    fn get_active_torrent_copies(&self) -> Vec<String> {
+        let marker_dir = "/tmp/torrent-copy";
+        let mut active_copies = Vec::new();
+
+        // Read all marker files from directory
+        if let Ok(entries) = std::fs::read_dir(marker_dir) {
+            for entry in entries.flatten() {
+                if let Ok(file_type) = entry.file_type() {
+                    if file_type.is_file() {
+                        // Filename is the marker (sanitized torrent name)
+                        if let Some(filename) = entry.file_name().to_str() {
+                            // Convert sanitized name back (replace _ with /)
+                            let display_name = filename.replace('_', "/");
+                            active_copies.push(display_name);
+                        }
+                    }
+                }
+            }
+        }
+
+        active_copies
+    }
 }
 
 #[async_trait]

dashboard/Cargo.toml

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

dashboard/src/app.rs

@@ -1,10 +1,10 @@
 use anyhow::Result;
 use crossterm::{
-    event::{self},
+    event::{self, EnableMouseCapture, DisableMouseCapture, Event, MouseEvent, MouseEventKind, MouseButton},
     execute,
     terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
 };
-use ratatui::{backend::CrosstermBackend, Terminal};
+use ratatui::{backend::CrosstermBackend, Terminal, layout::Rect};
 use std::io;
 use std::time::{Duration, Instant};
 use tracing::{debug, error, info, warn};
@@ -22,6 +22,9 @@ 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
 }
 
 impl Dashboard {
@@ -92,7 +95,7 @@ impl Dashboard {
             }
 
             let mut stdout = io::stdout();
-            if let Err(e) = execute!(stdout, EnterAlternateScreen) {
+            if let Err(e) = execute!(stdout, EnterAlternateScreen, EnableMouseCapture) {
                 error!("Failed to enter alternate screen: {}", e);
                 let _ = disable_raw_mode();
                 return Err(e.into());
@@ -121,6 +124,9 @@ impl Dashboard {
             headless,
             initial_commands_sent: std::collections::HashSet::new(),
             config,
+            title_area: Rect::default(),
+            system_area: Rect::default(),
+            services_area: Rect::default(),
         })
     }
 
@@ -132,27 +138,45 @@ impl Dashboard {
         let metrics_check_interval = Duration::from_millis(100); // Check for metrics every 100ms
         let mut last_heartbeat_check = Instant::now();
         let heartbeat_check_interval = Duration::from_secs(1); // Check for host connectivity every 1 second
+        let mut needs_render = true; // Track if we need to render
 
         loop {
-            // Handle terminal events (keyboard input) only if not headless
+            // Handle terminal events (keyboard and mouse input) only if not headless
             if !self.headless {
-                match event::poll(Duration::from_millis(50)) {
+                match event::poll(Duration::from_millis(200)) {
                     Ok(true) => {
                         match event::read() {
                             Ok(event) => {
                                 if let Some(ref mut tui_app) = self.tui_app {
-                                    // Handle input
+                                    match event {
-                                    match tui_app.handle_input(event) {
+                                        Event::Key(_) => {
-                                        Ok(_) => {
+                                            // Handle keyboard input
-                                            // Check if we should quit
+                                            match tui_app.handle_input(event) {
-                                            if tui_app.should_quit() {
+                                                Ok(_) => {
-                                                info!("Quit requested, exiting dashboard");
+                                                    needs_render = true;
-                                                break;
+                                                    // Check if we should quit
+                                                    if tui_app.should_quit() {
+                                                        info!("Quit requested, exiting dashboard");
+                                                        break;
+                                                    }
+                                                }
+                                                Err(e) => {
+                                                    error!("Error handling input: {}", e);
+                                                }
                                             }
                                         }
-                                        Err(e) => {
+                                        Event::Mouse(mouse_event) => {
-                                            error!("Error handling input: {}", e);
+                                            // Handle mouse events
+                                            if let Err(e) = self.handle_mouse_event(mouse_event) {
+                                                error!("Error handling mouse event: {}", e);
+                                            }
+                                            needs_render = true;
                                         }
+                                        Event::Resize(_width, _height) => {
+                                            // Terminal was resized - mark for re-render
+                                            needs_render = true;
+                                        }
+                                        _ => {}
                                     }
                                 }
                             }
@@ -168,17 +192,6 @@ impl Dashboard {
                         break;
                     }
                 }
-
-                // Render UI immediately after handling input for responsive feedback
-                if let Some(ref mut terminal) = self.terminal {
-                    if let Some(ref mut tui_app) = self.tui_app {
-                        if let Err(e) = terminal.draw(|frame| {
-                            tui_app.render(frame, &self.metric_store);
-                        }) {
-                            error!("Error rendering TUI after input: {}", e);
-                        }
-                    }
-                }
             }
 
             // Check for new metrics
@@ -217,6 +230,8 @@ impl Dashboard {
                     if let Some(ref mut tui_app) = self.tui_app {
                         tui_app.update_metrics(&mut self.metric_store);
                     }
+
+                    needs_render = true; // New metrics received, need to render
                 }
 
                 // Also check for command output messages
@@ -245,31 +260,416 @@ impl Dashboard {
                     tui_app.update_hosts(connected_hosts);
                 }
                 last_heartbeat_check = Instant::now();
+                needs_render = true; // Heartbeat check happened, may have changed hosts
             }
 
-            // Render TUI (only if not headless)
+            // Render TUI only when needed (not headless and something changed)
-            if !self.headless {
+            if !self.headless && needs_render {
                 if let Some(ref mut terminal) = self.terminal {
                     if let Some(ref mut tui_app) = self.tui_app {
-                        if let Err(e) = terminal.draw(|frame| {
+                        // Clear and autoresize terminal to handle any resize events
-                            tui_app.render(frame, &self.metric_store);
+                        if let Err(e) = terminal.autoresize() {
+                            warn!("Error autoresizing terminal: {}", e);
+                        }
+
+                        // Check minimum terminal size to prevent panics
+                        let size = terminal.size().unwrap_or_default();
+                        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;
                         }) {
                             error!("Error rendering TUI: {}", e);
                             break;
                         }
                     }
                 }
+                needs_render = false; // Reset flag after rendering
             }
-
-            // Small sleep to prevent excessive CPU usage
-            tokio::time::sleep(Duration::from_millis(10)).await;
         }
 
         info!("Dashboard main loop ended");
         Ok(())
     }
 
+    /// Handle mouse events
+    fn handle_mouse_event(&mut self, mouse: MouseEvent) -> Result<()> {
+        let x = mouse.column;
+        let y = mouse.row;
 
+        // Handle popup menu if open
+        let popup_info = if let Some(ref tui_app) = self.tui_app {
+            tui_app.popup_menu.clone().map(|popup| {
+                let hostname = tui_app.current_host.clone();
+                (popup, hostname)
+            })
+        } else {
+            None
+        };
+
+        if let Some((popup, hostname)) = popup_info {
+            // Calculate popup bounds using screen coordinates
+            let popup_width = 20;
+            let popup_height = 5; // 3 items + 2 borders
+
+            // Get terminal size
+            let (screen_width, screen_height) = if let Some(ref terminal) = self.terminal {
+                let size = terminal.size().unwrap_or_default();
+                (size.width, size.height)
+            } else {
+                (80, 24) // fallback
+            };
+
+            let popup_x = if popup.x + popup_width < screen_width {
+                popup.x
+            } else {
+                screen_width.saturating_sub(popup_width)
+            };
+
+            let popup_y = if popup.y + popup_height < screen_height {
+                popup.y
+            } else {
+                screen_height.saturating_sub(popup_height)
+            };
+
+            let popup_area = Rect {
+                x: popup_x,
+                y: popup_y,
+                width: popup_width,
+                height: popup_height,
+            };
+
+            // Update selected index on mouse move
+            if matches!(mouse.kind, MouseEventKind::Moved) {
+                if is_in_area(x, y, &popup_area) {
+                    let relative_y = y.saturating_sub(popup_y + 1) as usize; // +1 for top border
+                    if relative_y < 3 {
+                        if let Some(ref mut tui_app) = self.tui_app {
+                            if let Some(ref mut popup) = tui_app.popup_menu {
+                                popup.selected_index = relative_y;
+                            }
+                        }
+                    }
+                }
+                return Ok(());
+            }
+
+            if matches!(mouse.kind, MouseEventKind::Down(MouseButton::Left)) {
+                if is_in_area(x, y, &popup_area) {
+                    // Click inside popup - execute action
+                    let relative_y = y.saturating_sub(popup_y + 1) as usize; // +1 for top border
+                    if relative_y < 3 {
+                        // Execute the selected action
+                        self.execute_service_action(relative_y, &popup.service_name, hostname.as_deref())?;
+                    }
+                    // Close popup after action
+                    if let Some(ref mut tui_app) = self.tui_app {
+                        tui_app.popup_menu = None;
+                    }
+                    return Ok(());
+                } else {
+                    // Click outside popup - close it
+                    if let Some(ref mut tui_app) = self.tui_app {
+                        tui_app.popup_menu = None;
+                    }
+                    return Ok(());
+                }
+            }
+
+            // Any other event while popup is open - don't process panels
+            return Ok(());
+        }
+
+        // Check for title bar clicks (host selection)
+        if matches!(mouse.kind, MouseEventKind::Down(MouseButton::Left)) {
+            if is_in_area(x, y, &self.title_area) {
+                // Click in title bar - check if it's on a hostname
+                // The title bar has "cm-dashboard vX.X.X" on the left (22 chars)
+                // Then hostnames start at position 22
+                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(());
+            }
+        }
+
+        // Determine which panel the mouse is over
+        let in_system_area = is_in_area(x, y, &self.system_area);
+        let in_services_area = is_in_area(x, y, &self.services_area);
+
+        if !in_system_area && !in_services_area {
+            return Ok(());
+        }
+
+        // Handle mouse events
+        match mouse.kind {
+            MouseEventKind::ScrollDown => {
+                if in_system_area {
+                    // Scroll down in system panel
+                    if let Some(ref mut tui_app) = self.tui_app {
+                        if let Some(hostname) = tui_app.current_host.clone() {
+                            let host_widgets = tui_app.get_or_create_host_widgets(&hostname);
+                            let visible_height = self.system_area.height as usize;
+                            let total_lines = host_widgets.system_widget.get_total_lines();
+                            host_widgets.system_widget.scroll_down(visible_height, total_lines);
+                        }
+                    }
+                } else if in_services_area {
+                    // Scroll down in services panel
+                    if let Some(ref mut tui_app) = self.tui_app {
+                        if let Some(hostname) = tui_app.current_host.clone() {
+                            let host_widgets = tui_app.get_or_create_host_widgets(&hostname);
+                            // Calculate visible height (panel height - borders and header)
+                            let visible_height = self.services_area.height.saturating_sub(3) as usize;
+                            host_widgets.services_widget.scroll_down(visible_height);
+                        }
+                    }
+                }
+            }
+            MouseEventKind::ScrollUp => {
+                if in_system_area {
+                    // Scroll up in system panel
+                    if let Some(ref mut tui_app) = self.tui_app {
+                        if let Some(hostname) = tui_app.current_host.clone() {
+                            let host_widgets = tui_app.get_or_create_host_widgets(&hostname);
+                            host_widgets.system_widget.scroll_up();
+                        }
+                    }
+                } else if in_services_area {
+                    // Scroll up in services panel
+                    if let Some(ref mut tui_app) = self.tui_app {
+                        if let Some(hostname) = tui_app.current_host.clone() {
+                            let host_widgets = tui_app.get_or_create_host_widgets(&hostname);
+                            host_widgets.services_widget.scroll_up();
+                        }
+                    }
+                }
+            }
+            MouseEventKind::Down(button) => {
+                // Only handle clicks in services area (not system area)
+                if !in_services_area {
+                    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 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,
+                                        });
+                                    }
+                                }
+                                _ => {}
+                            }
+                        }
+                    }
+                }
+            }
+            _ => {}
+        }
+
+        Ok(())
+    }
+
+    /// Execute service action from popup menu
+    fn execute_service_action(&self, action_index: usize, service_name: &str, hostname: Option<&str>) -> Result<()> {
+        let Some(hostname) = hostname else {
+            return Ok(());
+        };
+
+        let connection_ip = self.get_connection_ip(hostname);
+
+        match action_index {
+            0 => {
+                // Start Service
+                let service_start_command = format!(
+                    "echo 'Starting service: {} on {}' && ssh -tt {}@{} \"bash -ic '{} start {}'\"",
+                    service_name,
+                    hostname,
+                    self.config.ssh.rebuild_user,
+                    connection_ip,
+                    self.config.ssh.service_manage_cmd,
+                    service_name
+                );
+
+                std::process::Command::new("tmux")
+                    .arg("split-window")
+                    .arg("-v")
+                    .arg("-p")
+                    .arg("30")
+                    .arg(&service_start_command)
+                    .spawn()
+                    .ok();
+            }
+            1 => {
+                // Stop Service
+                let service_stop_command = format!(
+                    "echo 'Stopping service: {} on {}' && ssh -tt {}@{} \"bash -ic '{} stop {}'\"",
+                    service_name,
+                    hostname,
+                    self.config.ssh.rebuild_user,
+                    connection_ip,
+                    self.config.ssh.service_manage_cmd,
+                    service_name
+                );
+
+                std::process::Command::new("tmux")
+                    .arg("split-window")
+                    .arg("-v")
+                    .arg("-p")
+                    .arg("30")
+                    .arg(&service_stop_command)
+                    .spawn()
+                    .ok();
+            }
+            2 => {
+                // View Logs
+                let logs_command = format!(
+                    "ssh -tt {}@{} '{} logs {}'",
+                    self.config.ssh.rebuild_user,
+                    connection_ip,
+                    self.config.ssh.service_manage_cmd,
+                    service_name
+                );
+
+                std::process::Command::new("tmux")
+                    .arg("split-window")
+                    .arg("-v")
+                    .arg("-p")
+                    .arg("30")
+                    .arg(&logs_command)
+                    .spawn()
+                    .ok();
+            }
+            _ => {}
+        }
+
+        Ok(())
+    }
+
+    /// Get connection IP for a host
+    fn get_connection_ip(&self, hostname: &str) -> String {
+        self.config
+            .hosts
+            .get(hostname)
+            .and_then(|h| h.ip.clone())
+            .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 + area.width
+        && y >= area.y && y < area.y + area.height
 }
 
 impl Drop for Dashboard {
@@ -278,7 +678,7 @@ impl Drop for Dashboard {
         if !self.headless {
             let _ = disable_raw_mode();
             if let Some(ref mut terminal) = self.terminal {
-                let _ = execute!(terminal.backend_mut(), LeaveAlternateScreen);
+                let _ = execute!(terminal.backend_mut(), LeaveAlternateScreen, DisableMouseCapture);
                 let _ = terminal.show_cursor();
             }
         }

dashboard/src/metrics/store.rs

@@ -86,16 +86,6 @@ impl MetricStore {
         self.current_agent_data.get(hostname)
     }
 
-    /// Get ZMQ communication statistics for a host
-    pub fn get_zmq_stats(&mut self, hostname: &str) -> Option<ZmqStats> {
-        let now = Instant::now();
-        self.zmq_stats.get_mut(hostname).map(|stats| {
-            // Update packet age
-            stats.last_packet_age_secs = now.duration_since(stats.last_packet_time).as_secs_f64();
-            stats.clone()
-        })
-    }
-
     /// Get connected hosts (hosts with recent heartbeats)
     pub fn get_connected_hosts(&self, timeout: Duration) -> Vec<String> {
         let now = Instant::now();

dashboard/src/ui/mod.rs

@@ -17,7 +17,7 @@ pub mod widgets;
 use crate::config::DashboardConfig;
 use crate::metrics::MetricStore;
 use cm_dashboard_shared::Status;
-use theme::{Components, Layout as ThemeLayout, Theme, Typography};
+use theme::{Components, Layout as ThemeLayout, Theme};
 use widgets::{ServicesWidget, SystemWidget, Widget};
 
 
@@ -47,12 +47,21 @@ impl HostWidgets {
 }
 
 
+/// Popup menu state
+#[derive(Clone)]
+pub struct PopupMenu {
+    pub service_name: String,
+    pub x: u16,
+    pub y: u16,
+    pub selected_index: usize,
+}
+
 /// Main TUI application
 pub struct TuiApp {
     /// Widget states per host (hostname -> HostWidgets)
     host_widgets: HashMap<String, HostWidgets>,
     /// Current active host
-    current_host: Option<String>,
+    pub current_host: Option<String>,
     /// Available hosts
     available_hosts: Vec<String>,
     /// Host index for navigation
@@ -65,6 +74,8 @@ pub struct TuiApp {
     config: DashboardConfig,
     /// Cached localhost hostname to avoid repeated system calls
     localhost: String,
+    /// Active popup menu (if any)
+    pub popup_menu: Option<PopupMenu>,
 }
 
 impl TuiApp {
@@ -79,6 +90,7 @@ impl TuiApp {
             user_navigated_away: false,
             config,
             localhost,
+            popup_menu: None,
         };
         
         // Sort predefined hosts
@@ -93,7 +105,7 @@ impl TuiApp {
     }
 
     /// Get or create host widgets for the given hostname
-    fn get_or_create_host_widgets(&mut self, hostname: &str) -> &mut HostWidgets {
+    pub fn get_or_create_host_widgets(&mut self, hostname: &str) -> &mut HostWidgets {
         self.host_widgets
             .entry(hostname.to_string())
             .or_insert_with(HostWidgets::new)
@@ -159,6 +171,14 @@ impl TuiApp {
     /// Handle keyboard input
     pub fn handle_input(&mut self, event: Event) -> Result<()> {
         if let Event::Key(key) = event {
+            // Close popup on Escape
+            if matches!(key.code, KeyCode::Esc) {
+                if self.popup_menu.is_some() {
+                    self.popup_menu = None;
+                    return Ok(());
+                }
+            }
+
             match key.code {
                 KeyCode::Char('q') => {
                     self.should_quit = true;
@@ -363,6 +383,23 @@ impl TuiApp {
         Ok(())
     }
 
+    /// 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) {
+            self.host_index = index;
+            self.current_host = Some(hostname.to_string());
+
+            // Check if user navigated away from localhost
+            if hostname != &self.localhost {
+                self.user_navigated_away = true;
+            } else {
+                self.user_navigated_away = false; // User navigated back to localhost
+            }
+
+            info!("Switched to host: {}", hostname);
+        }
+    }
+
     /// Navigate between hosts
     fn navigate_host(&mut self, direction: i32) {
         if self.available_hosts.is_empty() {
@@ -408,6 +445,10 @@ impl TuiApp {
         None
     }
 
+    /// Get the list of available hosts
+    pub fn get_available_hosts(&self) -> &Vec<String> {
+        &self.available_hosts
+    }
 
     /// Should quit application
     pub fn should_quit(&self) -> bool {
@@ -421,7 +462,7 @@ impl TuiApp {
 
 
     /// Render the dashboard (real btop-style multi-panel layout)
-    pub fn render(&mut self, frame: &mut Frame, metric_store: &MetricStore) {
+    pub fn render(&mut self, frame: &mut Frame, metric_store: &MetricStore) -> (Rect, Rect, Rect) {
         let size = frame.size();
 
         // Clear background to true black like btop
@@ -461,8 +502,8 @@ impl TuiApp {
         if current_host_offline {
             self.render_offline_host_message(frame, main_chunks[1]);
             self.render_btop_title(frame, main_chunks[0], metric_store);
-            self.render_statusbar(frame, main_chunks[2]);
+            self.render_statusbar(frame, main_chunks[2], metric_store);
-            return;
+            return (main_chunks[0], Rect::default(), Rect::default()); // Return title area and empty areas when offline
         }
 
         // Left side: system panel only (full height)
@@ -475,20 +516,29 @@ impl TuiApp {
         self.render_btop_title(frame, main_chunks[0], metric_store);
 
         // Render system panel
-        self.render_system_panel(frame, left_chunks[0], metric_store);
+        let system_area = left_chunks[0];
+        self.render_system_panel(frame, system_area, metric_store);
 
         // Render services widget for current host
+        let services_area = content_chunks[1];
         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, content_chunks[1], is_focused); // Services takes full right side
+                .render(frame, services_area, is_focused); // Services takes full right side
         }
 
         // Render statusbar at the bottom
-        self.render_statusbar(frame, main_chunks[2]); // main_chunks[2] is the statusbar area
+        self.render_statusbar(frame, main_chunks[2], metric_store);
 
+        // Render popup menu on top of everything if active
+        if let Some(ref popup) = self.popup_menu {
+            self.render_popup_menu(frame, popup);
+        }
+
+        // Return all areas for mouse event handling
+        (main_chunks[0], system_area, services_area)
     }
 
     /// Render btop-style minimal title with host status colors
@@ -556,7 +606,14 @@ impl TuiApp {
             ));
 
             if Some(host) == self.current_host.as_ref() {
-                // Selected host in bold background color against status background
+                // 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()
@@ -564,6 +621,13 @@ impl TuiApp {
                         .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(
@@ -597,36 +661,137 @@ impl TuiApp {
         }
     }
 
-    /// Render dynamic statusbar with context-aware shortcuts
+    /// Render popup menu for service actions
-    fn render_statusbar(&self, frame: &mut Frame, area: Rect) {
+    fn render_popup_menu(&self, frame: &mut Frame, popup: &PopupMenu) {
-        let shortcuts = self.get_context_shortcuts();
+        use ratatui::widgets::{Block, Borders, Clear, List, ListItem};
-        let statusbar_text = shortcuts.join(" • ");
+        use ratatui::style::{Color, Modifier};
 
-        let statusbar = Paragraph::new(statusbar_text)
+        // Menu items
-            .style(Typography::secondary())
+        let items = vec![
-            .alignment(ratatui::layout::Alignment::Center);
+            "Start Service",
+            "Stop Service",
+            "View Logs",
+        ];
 
+        // Calculate popup size
+        let width = 20;
+        let height = items.len() as u16 + 2; // +2 for borders
+
+        // Position popup near click location, but keep it on screen
+        let screen_width = frame.size().width;
+        let screen_height = frame.size().height;
+
+        let x = if popup.x + width < screen_width {
+            popup.x
+        } else {
+            screen_width.saturating_sub(width)
+        };
+
+        let y = if popup.y + height < screen_height {
+            popup.y
+        } else {
+            screen_height.saturating_sub(height)
+        };
+
+        let popup_area = Rect {
+            x,
+            y,
+            width,
+            height,
+        };
+
+        // Create menu items with selection highlight
+        let menu_items: Vec<ListItem> = items
+            .iter()
+            .enumerate()
+            .map(|(i, item)| {
+                let style = if i == popup.selected_index {
+                    Style::default()
+                        .fg(Color::Black)
+                        .bg(Color::White)
+                        .add_modifier(Modifier::BOLD)
+                } else {
+                    Style::default().fg(Theme::primary_text())
+                };
+                ListItem::new(*item).style(style)
+            })
+            .collect();
+
+        let menu_list = List::new(menu_items)
+            .block(
+                Block::default()
+                    .borders(Borders::ALL)
+                    .style(Style::default().bg(Theme::background()).fg(Theme::primary_text()))
+            );
+
+        // Clear the area and render menu
+        frame.render_widget(Clear, popup_area);
+        frame.render_widget(menu_list, popup_area);
+    }
+
+    /// Render statusbar with host and client IPs
+    fn render_statusbar(&self, frame: &mut Frame, area: Rect, _metric_store: &MetricStore) {
+        use ratatui::text::{Line, Span};
+        use ratatui::widgets::Paragraph;
+
+        // Get current host info
+        let (hostname_str, host_ip, build_version, agent_version) = if let Some(hostname) = &self.current_host {
+            // Get the connection IP (the IP dashboard uses to connect to the agent)
+            let ip = if let Some(host_details) = self.config.hosts.get(hostname) {
+                host_details.get_connection_ip(hostname)
+            } else {
+                hostname.clone()
+            };
+
+            // Get build and agent versions from system widget
+            let (build, agent) = if let Some(host_widgets) = self.host_widgets.get(hostname) {
+                let build = host_widgets.system_widget.get_build_version().unwrap_or("N/A".to_string());
+                let agent = host_widgets.system_widget.get_agent_version().unwrap_or("N/A".to_string());
+                (build, agent)
+            } else {
+                ("N/A".to_string(), "N/A".to_string())
+            };
+
+            (hostname.clone(), ip, build, agent)
+        } else {
+            ("None".to_string(), "N/A".to_string(), "N/A".to_string(), "N/A".to_string())
+        };
+
+        let left_text = format!("Host: {} | {} | Build:{} | Agent:{}", hostname_str, host_ip, build_version, agent_version);
+
+        // Get dashboard local IP
+        let dashboard_ip = Self::get_local_ip();
+        let right_text = format!("Dashboard: {}", dashboard_ip);
+
+        // 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())),
+        ]);
+
+        let statusbar = Paragraph::new(line);
         frame.render_widget(statusbar, area);
     }
 
-    /// Get context-aware shortcuts based on focused panel
+    /// Get local IP address of the dashboard
-    fn get_context_shortcuts(&self) -> Vec<String> {
+    fn get_local_ip() -> String {
-        let mut shortcuts = Vec::new();
+        use std::net::UdpSocket;
 
-        // Global shortcuts
+        // Try to get local IP by creating a UDP socket
-        shortcuts.push("Tab: Host".to_string());
+        // This doesn't actually send data, just determines routing
-        shortcuts.push("↑↓/jk: Select".to_string());
+        if let Ok(socket) = UdpSocket::bind("0.0.0.0:0") {
-        shortcuts.push("r: Rebuild".to_string());
+            if socket.connect("8.8.8.8:80").is_ok() {
-        shortcuts.push("B: Backup".to_string());
+                if let Ok(addr) = socket.local_addr() {
-        shortcuts.push("s/S: Start/Stop".to_string());
+                    return addr.ip().to_string();
-        shortcuts.push("L: Logs".to_string());
+                }
-        shortcuts.push("t: Terminal".to_string());
+            }
-        shortcuts.push("w: Wake".to_string());
+        }
-        
+        "N/A".to_string()
-        // Always show quit
-        shortcuts.push("q: Quit".to_string());
-        
-        shortcuts
     }
 
     fn render_system_panel(&mut self, frame: &mut Frame, area: Rect, _metric_store: &MetricStore) {

dashboard/src/ui/widgets/services.rs

@@ -91,14 +91,17 @@ pub struct ServicesWidget {
     /// Last update indicator
     has_data: bool,
     /// Currently selected service index (for navigation cursor)
-    selected_index: usize,
+    pub selected_index: usize,
+    /// Scroll offset for viewport (which display line is at the top)
+    pub scroll_offset: usize,
+    /// Last rendered viewport height (for accurate scroll bounds)
+    last_viewport_height: usize,
 }
 
 #[derive(Clone)]
 struct ServiceInfo {
     metrics: Vec<(String, f32, Option<String>)>, // (label, value, unit)
     widget_status: Status,
-    service_type: String, // "nginx_site", "container", "image", or empty for parent services
     memory_bytes: Option<u64>,
     restart_count: Option<u32>,
     uptime_seconds: Option<u64>,
@@ -112,6 +115,8 @@ impl ServicesWidget {
             status: Status::Unknown,
             has_data: false,
             selected_index: 0,
+            scroll_offset: 0,
+            last_viewport_height: 0,
         }
     }
 
@@ -338,6 +343,7 @@ impl ServicesWidget {
     pub fn select_previous(&mut self) {
         if self.selected_index > 0 {
             self.selected_index -= 1;
+            self.ensure_selected_visible();
         }
         debug!("Service selection moved up to: {}", self.selected_index);
     }
@@ -346,10 +352,77 @@ impl ServicesWidget {
     pub fn select_next(&mut self, total_services: usize) {
         if total_services > 0 && self.selected_index < total_services.saturating_sub(1) {
             self.selected_index += 1;
+            self.ensure_selected_visible();
         }
         debug!("Service selection: {}/{}", self.selected_index, total_services);
     }
 
+    /// Convert parent service index to display line index
+    fn parent_index_to_display_line(&self, parent_index: usize) -> usize {
+        let mut parent_services: Vec<_> = self.parent_services.iter().collect();
+        parent_services.sort_by(|(a, _), (b, _)| a.cmp(b));
+
+        let mut display_line = 0;
+        for (idx, (parent_name, _)) in parent_services.iter().enumerate() {
+            if idx == parent_index {
+                return display_line;
+            }
+            display_line += 1; // Parent service line
+
+            // Add sub-service lines
+            if let Some(sub_list) = self.sub_services.get(*parent_name) {
+                display_line += sub_list.len();
+            }
+        }
+        display_line
+    }
+
+    /// Ensure the currently selected service is visible in the viewport
+    fn ensure_selected_visible(&mut self) {
+        if self.last_viewport_height == 0 {
+            return; // Can't adjust without knowing viewport size
+        }
+
+        let display_line = self.parent_index_to_display_line(self.selected_index);
+        let total_display_lines = self.get_total_display_lines();
+        let viewport_height = self.last_viewport_height;
+
+        // Check if selected line is above visible area
+        if display_line < self.scroll_offset {
+            self.scroll_offset = display_line;
+            return;
+        }
+
+        // Calculate current effective viewport (accounting for "more below" if present)
+        let current_remaining = total_display_lines.saturating_sub(self.scroll_offset);
+        let current_has_more = current_remaining > viewport_height;
+        let current_effective = if current_has_more {
+            viewport_height.saturating_sub(1)
+        } else {
+            viewport_height
+        };
+
+        // Check if selected line is below current visible area
+        if display_line >= self.scroll_offset + current_effective {
+            // Need to scroll down. Position selected line so there's room for "more below" if needed
+            // Strategy: if there are lines below the selected line, don't put it at the very bottom
+            let has_content_below = display_line < total_display_lines - 1;
+
+            if has_content_below {
+                // Leave room for "... X more below" message by positioning selected line
+                // one position higher than the last line
+                let target_position = viewport_height.saturating_sub(2);
+                self.scroll_offset = display_line.saturating_sub(target_position);
+            } else {
+                // This is the last line, can put it at the bottom
+                self.scroll_offset = display_line.saturating_sub(viewport_height - 1);
+            }
+        }
+
+        debug!("Auto-scroll: selected={}, display_line={}, scroll_offset={}, viewport={}, total={}",
+            self.selected_index, display_line, self.scroll_offset, viewport_height, total_display_lines);
+    }
+
     /// Get currently selected service name (for actions)
     /// Only returns parent service names since only parent services can be selected
     pub fn get_selected_service(&self) -> Option<String> {
@@ -366,6 +439,81 @@ impl ServicesWidget {
         self.parent_services.len()
     }
 
+    /// Get total display lines (parent services + sub-services)
+    pub fn get_total_display_lines(&self) -> usize {
+        let mut total = self.parent_services.len();
+        for sub_list in self.sub_services.values() {
+            total += sub_list.len();
+        }
+        total
+    }
+
+    /// Scroll down by one line
+    pub fn scroll_down(&mut self, _visible_height: usize) {
+        let total_lines = self.get_total_display_lines();
+
+        // Use last_viewport_height if available (more accurate), otherwise can't scroll
+        let viewport_height = if self.last_viewport_height > 0 {
+            self.last_viewport_height
+        } else {
+            return; // Can't scroll without knowing viewport size
+        };
+
+        // Calculate exact max scroll to match render logic
+        // Stop scrolling when all remaining content fits in viewport
+        // At scroll_offset N: remaining = total_lines - N
+        // We can show all when: remaining <= viewport_height
+        // So max_scroll is when: total_lines - max_scroll = viewport_height
+        // Therefore: max_scroll = total_lines - viewport_height (but at least 0)
+        let max_scroll = total_lines.saturating_sub(viewport_height);
+
+        debug!("Scroll down: total={}, viewport={}, offset={}, max={}", total_lines, viewport_height, self.scroll_offset, max_scroll);
+
+        if self.scroll_offset < max_scroll {
+            self.scroll_offset += 1;
+        }
+    }
+
+    /// Scroll up by one line
+    pub fn scroll_up(&mut self) {
+        if self.scroll_offset > 0 {
+            self.scroll_offset -= 1;
+        }
+    }
+
+
+    /// Map a display line index to a parent service index (returns None if clicked on sub-service)
+    pub fn display_line_to_parent_index(&self, display_line_index: usize) -> Option<usize> {
+        // Build the same display list to map line index to parent service index
+        let mut parent_index = 0;
+        let mut line_index = 0;
+
+        let mut parent_services: Vec<_> = self.parent_services.iter().collect();
+        parent_services.sort_by(|(a, _), (b, _)| a.cmp(b));
+
+        for (parent_name, _) in parent_services {
+            // Check if this line index matches a parent service
+            if line_index == display_line_index {
+                return Some(parent_index);
+            }
+            line_index += 1;
+
+            // Add sub-services for this parent (if any)
+            if let Some(sub_list) = self.sub_services.get(parent_name) {
+                for _ in sub_list {
+                    if line_index == display_line_index {
+                        // Clicked on a sub-service - return None (can't select sub-services)
+                        return None;
+                    }
+                    line_index += 1;
+                }
+            }
+
+            parent_index += 1;
+        }
+
+        None
+    }
 
     /// Calculate which parent service index corresponds to a display line index
     fn calculate_parent_service_index(&self, display_line_index: &usize) -> usize {
@@ -407,7 +555,6 @@ impl Widget for ServicesWidget {
             let parent_info = ServiceInfo {
                 metrics: Vec::new(), // Parent services don't have custom metrics
                 widget_status: service.service_status,
-                service_type: String::new(), // Parent services have no type
                 memory_bytes: service.memory_bytes,
                 restart_count: service.restart_count,
                 uptime_seconds: service.uptime_seconds,
@@ -426,7 +573,6 @@ impl Widget for ServicesWidget {
                     let sub_info = ServiceInfo {
                         metrics,
                         widget_status: sub_service.service_status,
-                        service_type: sub_service.service_type.clone(),
                         memory_bytes: None, // Sub-services don't have individual metrics yet
                         restart_count: None,
                         uptime_seconds: None,
@@ -471,7 +617,6 @@ impl ServicesWidget {
                                 .or_insert(ServiceInfo {
                                     metrics: Vec::new(),
                                     widget_status: Status::Unknown,
-                                    service_type: String::new(),
                                     memory_bytes: None,
                                     restart_count: None,
                                     uptime_seconds: None,
@@ -500,7 +645,6 @@ impl ServicesWidget {
                                 ServiceInfo {
                                     metrics: Vec::new(),
                                     widget_status: Status::Unknown,
-                                    service_type: String::new(), // Unknown type in legacy path
                                     memory_bytes: None,
                                     restart_count: None,
                                     uptime_seconds: None,
@@ -542,12 +686,23 @@ impl ServicesWidget {
             self.selected_index = total_count - 1;
         }
 
+        // Clamp scroll offset to valid range after update
+        // This prevents scroll issues when switching between hosts or when service count changes
+        let total_display_lines = self.get_total_display_lines();
+        if total_display_lines == 0 {
+            self.scroll_offset = 0;
+        } else if self.scroll_offset >= total_display_lines {
+            // Clamp to max valid value, not reset to 0
+            self.scroll_offset = total_display_lines.saturating_sub(1);
+        }
+
         debug!(
-            "Services widget updated: {} parent services, {} sub-service groups, total={}, selected={}, status={:?}",
+            "Services widget updated: {} parent services, {} sub-service groups, total={}, selected={}, scroll={}, status={:?}",
             self.parent_services.len(),
             self.sub_services.len(),
             total_count,
             self.selected_index,
+            self.scroll_offset,
             self.status
         );
     }
@@ -640,19 +795,45 @@ impl ServicesWidget {
         let available_lines = area.height as usize;
         let total_lines = display_lines.len();
 
-        // Reserve one line for "X more below" if needed
+        // Store viewport height for accurate scroll calculations
-        let lines_for_content = if total_lines > available_lines {
+        self.last_viewport_height = available_lines;
+
+        // Clamp scroll_offset to valid range based on current viewport and content
+        // This handles dynamic viewport size changes
+        let max_valid_scroll = total_lines.saturating_sub(available_lines);
+        if self.scroll_offset > max_valid_scroll {
+            self.scroll_offset = max_valid_scroll;
+        }
+
+        // Calculate how many lines remain after scroll offset
+        let remaining_lines = total_lines.saturating_sub(self.scroll_offset);
+
+        debug!("Render: total={}, viewport={}, offset={}, max={}, remaining={}",
+            total_lines, available_lines, self.scroll_offset, max_valid_scroll, remaining_lines);
+
+        // Check if all remaining content fits in viewport
+        let will_show_more_below = remaining_lines > available_lines;
+
+        // Reserve one line for "X more below" only if we can't fit everything
+        let lines_for_content = if will_show_more_below {
             available_lines.saturating_sub(1)
         } else {
-            available_lines
+            available_lines.min(remaining_lines)
         };
 
+        // Apply scroll offset
         let visible_lines: Vec<_> = display_lines
             .iter()
+            .skip(self.scroll_offset)
             .take(lines_for_content)
             .collect();
 
-        let hidden_below = total_lines.saturating_sub(lines_for_content);
+        // Only calculate hidden_below if we actually reserved space for the message
+        let hidden_below = if will_show_more_below {
+            remaining_lines.saturating_sub(lines_for_content)
+        } else {
+            0
+        };
         
         let lines_to_show = visible_lines.len();
 
@@ -666,7 +847,7 @@ impl ServicesWidget {
 
             for (i, (line_text, line_status, is_sub, sub_info)) in visible_lines.iter().enumerate()
             {
-                let actual_index = i; // Simple index since we're not scrolling
+                let actual_index = self.scroll_offset + i; // Account for scroll offset
 
                 // Only parent services can be selected - calculate parent service index
                 let is_selected = if !*is_sub {
@@ -712,7 +893,7 @@ impl ServicesWidget {
             // Show "X more below" message if content was truncated
             if hidden_below > 0 {
                 let more_text = format!("... {} more below", hidden_below);
-                let more_para = Paragraph::new(more_text).style(Typography::muted());
+                let more_para = Paragraph::new(more_text).style(Style::default().fg(Theme::border()));
                 frame.render_widget(more_para, service_chunks[lines_to_show]);
             }
         }

dashboard/src/ui/widgets/system.rs

@@ -1,12 +1,13 @@
 use cm_dashboard_shared::Status;
 use ratatui::{
     layout::Rect,
+    style::Style,
     text::{Line, Span, Text},
     widgets::Paragraph,
     Frame,
 };
 
-use crate::ui::theme::{StatusIcons, Typography};
+use crate::ui::theme::{StatusIcons, Theme, Typography};
 
 /// System widget displaying NixOS info, Network, CPU, RAM, and Storage in unified layout
 #[derive(Clone)]
@@ -43,12 +44,17 @@ pub struct SystemWidget {
     storage_pools: Vec<StoragePool>,
     
     // Backup metrics
-    backup_repositories: Vec<String>,
+    backup_last_time: Option<String>,
-    backup_repository_status: Status,
+    backup_status: Status,
-    backup_disks: Vec<cm_dashboard_shared::BackupDiskData>,
+    backup_repositories: Vec<cm_dashboard_shared::BackupRepositoryData>,
     
     // Overall status
     has_data: bool,
+
+    // Scroll offset for viewport
+    pub scroll_offset: usize,
+    /// Last rendered viewport height (for accurate scroll bounds)
+    last_viewport_height: usize,
 }
 
 #[derive(Clone)]
@@ -106,10 +112,12 @@ 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,
         }
     }
 
@@ -153,6 +161,16 @@ impl SystemWidget {
     pub fn _get_agent_hash(&self) -> Option<&String> {
         self.agent_hash.as_ref()
     }
+
+    /// Get the build version
+    pub fn get_build_version(&self) -> Option<String> {
+        self.nixos_build.clone()
+    }
+
+    /// Get the agent version
+    pub fn get_agent_version(&self) -> Option<String> {
+        self.agent_hash.clone()
+    }
 }
 
 use super::Widget;
@@ -203,9 +221,19 @@ 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
+        let total_lines = self.get_total_lines();
+        if total_lines == 0 {
+            self.scroll_offset = 0;
+        } else if self.scroll_offset >= total_lines {
+            // Clamp to max valid value, not reset to 0
+            self.scroll_offset = total_lines.saturating_sub(1);
+        }
     }
 }
 
@@ -505,79 +533,42 @@ impl SystemWidget {
     fn render_backup(&self) -> Vec<Line<'_>> {
         let mut lines = Vec::new();
 
-        // First section: Repository status and list
+        if self.backup_repositories.is_empty() {
-        if !self.backup_repositories.is_empty() {
+            return lines;
-            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()),
-                ]));
-            }
         }
 
-        // Second section: Per-disk backup information (sorted by serial for consistent display)
+        // Format backup time (use complete timestamp)
-        let mut sorted_disks = self.backup_disks.clone();
+        let time_display = if let Some(ref time_str) = self.backup_last_time {
-        sorted_disks.sort_by(|a, b| a.serial.cmp(&b.serial));
+            time_str.clone()
-        for disk in &sorted_disks {
+        } else {
-            let truncated_serial = truncate_serial(&disk.serial);
+            "unknown".to_string()
-            let mut details = Vec::new();
+        };
 
-            if let Some(temp) = disk.temperature_celsius {
+        // Header: just the timestamp
-                details.push(format!("T: {}°C", temp as i32));
+        let repo_spans = StatusIcons::create_status_spans(self.backup_status, &time_display);
-            }
+        lines.push(Line::from(repo_spans));
-            if let Some(wear) = disk.wear_percent {
-                details.push(format!("W: {}%", wear as i32));
-            }
 
-            let disk_text = if !details.is_empty() {
+        // List all repositories with archive count and size
-                format!("{} {}", truncated_serial, details.join(" "))
+        let repo_count = self.backup_repositories.len();
+        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 {
-                truncated_serial
+                format!("{:.1}GB", repo.repo_size_gb)
             };
 
-            // Overall disk status (worst of backup and usage)
+            let repo_text = format!("{} ({}) {}", repo.name, repo.archive_count, size_display);
-            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));
 
-            // Show backup time with status
+            let mut repo_spans = vec![
-            if let Some(backup_time) = &disk.last_backup_time {
+                Span::styled(format!("  {} ", tree_char), Typography::tree()),
-                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()),
             ];
-            usage_spans.extend(StatusIcons::create_status_spans(disk.usage_status, &usage_text));
+            repo_spans.extend(StatusIcons::create_status_spans(repo.status, &repo_text));
-            lines.push(Line::from(usage_spans));
+            lines.push(Line::from(repo_spans));
         }
 
         lines
@@ -781,24 +772,88 @@ impl SystemWidget {
     }
 
     /// Render system widget
-    pub fn render(&mut self, frame: &mut Frame, area: Rect, hostname: &str, _config: Option<&crate::config::DashboardConfig>) {
+    /// Scroll down by one line
+    pub fn scroll_down(&mut self, _visible_height: usize, _total_lines: usize) {
+        let total_lines = self.get_total_lines();
+
+        // Use last_viewport_height if available (more accurate), otherwise can't scroll
+        let viewport_height = if self.last_viewport_height > 0 {
+            self.last_viewport_height
+        } else {
+            return; // Can't scroll without knowing viewport size
+        };
+
+        // Max scroll should allow us to see all remaining content
+        // When scroll_offset + viewport_height >= total_lines, we can see everything
+        let max_scroll = if total_lines > viewport_height {
+            total_lines - viewport_height
+        } else {
+            0
+        };
+
+        if self.scroll_offset < max_scroll {
+            self.scroll_offset += 1;
+        }
+    }
+
+    /// Scroll up by one line
+    pub fn scroll_up(&mut self) {
+        if self.scroll_offset > 0 {
+            self.scroll_offset -= 1;
+        }
+    }
+
+    /// Get total line count (needs to be calculated before rendering)
+    pub fn get_total_lines(&self) -> usize {
+        let mut count = 0;
+
+        // CPU section (2+ lines for load/cstate, +1 if has model/cores)
+        count += 2;
+        if self.cpu_model_name.is_some() || self.cpu_core_count.is_some() {
+            count += 1;
+        }
+
+        // RAM section (1 + tmpfs mounts)
+        count += 2;
+        count += self.tmpfs_mounts.len();
+
+        // Network section
+        if !self.network_interfaces.is_empty() {
+            count += 1; // Header
+            // Count network lines (would need to mirror render_network logic)
+            for iface in &self.network_interfaces {
+                count += 1; // Interface name
+                count += iface.ipv4_addresses.len();
+                count += iface.ipv6_addresses.len();
+            }
+        }
+
+        // Storage section
+        count += 1; // Header
+        for pool in &self.storage_pools {
+            count += 1; // Pool header
+            count += pool.drives.len();
+            count += pool.data_drives.len();
+            count += pool.parity_drives.len();
+            count += pool.filesystems.len();
+        }
+
+        // Backup section
+        if !self.backup_repositories.is_empty() {
+            count += 1; // Header: "Backup:"
+            count += 1; // Repo count and timestamp header
+            count += self.backup_repositories.len(); // Individual repos
+        }
+
+        count
+    }
+
+    pub fn render(&mut self, frame: &mut Frame, area: Rect, _hostname: &str, _config: Option<&crate::config::DashboardConfig>) {
+        // Store viewport height for accurate scroll calculations
+        self.last_viewport_height = area.height as usize;
+
         let mut lines = Vec::new();
 
-        // NixOS section
-        lines.push(Line::from(vec![
-            Span::styled(format!("NixOS {}:", hostname), Typography::widget_title())
-        ]));
-        
-        let build_text = self.nixos_build.as_deref().unwrap_or("unknown");
-        lines.push(Line::from(vec![
-            Span::styled(format!("Build: {}", build_text), Typography::secondary())
-        ]));
-        
-        let agent_version_text = self.agent_hash.as_deref().unwrap_or("unknown");
-        lines.push(Line::from(vec![
-            Span::styled(format!("Agent: {}", agent_version_text), Typography::secondary())
-        ]));
-
         // CPU section
         lines.push(Line::from(vec![
             Span::styled("CPU:", Typography::widget_title())
@@ -893,7 +948,7 @@ impl SystemWidget {
         lines.extend(storage_lines);
 
         // Backup section (if available)
-        if !self.backup_repositories.is_empty() || !self.backup_disks.is_empty() {
+        if !self.backup_repositories.is_empty() {
             lines.push(Line::from(vec![
                 Span::styled("Backup:", Typography::widget_title())
             ]));
@@ -906,28 +961,50 @@ impl SystemWidget {
         let total_lines = lines.len();
         let available_height = area.height as usize;
 
-        // Show only what fits, with "X more below" if needed
+        // Clamp scroll_offset to valid range based on current viewport and content
-        if total_lines > available_height {
+        // This handles dynamic viewport size changes
-            let lines_for_content = available_height.saturating_sub(1); // Reserve one line for "more below"
+        let max_valid_scroll = total_lines.saturating_sub(available_height);
-            let mut visible_lines: Vec<Line> = lines
+        let clamped_scroll = self.scroll_offset.min(max_valid_scroll);
-                .into_iter()
-                .take(lines_for_content)
-                .collect();
 
-            let hidden_below = total_lines.saturating_sub(lines_for_content);
+        // Calculate how many lines remain after scroll offset
-            if hidden_below > 0 {
+        let remaining_lines = total_lines.saturating_sub(clamped_scroll);
-                let more_line = Line::from(vec![
-                    Span::styled(format!("... {} more below", hidden_below), Typography::muted())
-                ]);
-                visible_lines.push(more_line);
-            }
 
-            let paragraph = Paragraph::new(Text::from(visible_lines));
+        // Check if all remaining content fits in viewport
-            frame.render_widget(paragraph, area);
+        let will_show_more_below = remaining_lines > available_height;
+
+        // Reserve one line for "X more below" only if we can't fit everything
+        let lines_for_content = if will_show_more_below {
+            available_height.saturating_sub(1)
         } else {
-            // All content fits and no scroll offset, render normally
+            available_height.min(remaining_lines)
-            let paragraph = Paragraph::new(Text::from(lines));
+        };
-            frame.render_widget(paragraph, area);
+
+        // Apply clamped scroll offset and take only what fits
+        let mut visible_lines: Vec<Line> = lines
+            .into_iter()
+            .skip(clamped_scroll)
+            .take(lines_for_content)
+            .collect();
+
+        // Note: we don't update self.scroll_offset here due to borrow checker constraints
+        // It will be clamped on next render if still out of bounds
+
+        // Only calculate hidden_below if we actually reserved space for the message
+        let hidden_below = if will_show_more_below {
+            remaining_lines.saturating_sub(lines_for_content)
+        } else {
+            0
+        };
+
+        // Add "more below" message if needed
+        if hidden_below > 0 {
+            let more_line = Line::from(vec![
+                Span::styled(format!("... {} more below", hidden_below), Style::default().fg(Theme::border()))
+            ]);
+            visible_lines.push(more_line);
         }
+
+        let paragraph = Paragraph::new(Text::from(visible_lines));
+        frame.render_widget(paragraph, area);
     }
 }

shared/Cargo.toml

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

shared/src/agent_data.rs

@@ -38,6 +38,7 @@ pub struct NetworkInterfaceData {
     pub link_status: Status,
     pub parent_interface: Option<String>,
     pub vlan_id: Option<u16>,
+    pub connection_method: Option<String>, // For Tailscale: "direct", "relay", or "proxy"
 }
 
 /// CPU C-state usage information
@@ -181,27 +182,18 @@ pub struct SubServiceMetric {
 /// Backup system data
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct BackupData {
-    pub repositories: Vec<String>,
-    pub repository_status: Status,
-    pub disks: Vec<BackupDiskData>,
-}
-
-/// Backup repository disk information
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct BackupDiskData {
-    pub serial: String,
-    pub product_name: Option<String>,
-    pub wear_percent: Option<f32>,
-    pub temperature_celsius: Option<f32>,
     pub last_backup_time: Option<String>,
     pub backup_status: Status,
-    pub disk_usage_percent: f32,
+    pub repositories: Vec<BackupRepositoryData>,
-    pub disk_used_gb: f32,
+}
-    pub disk_total_gb: f32,
+
-    pub usage_status: Status,
+/// Individual backup repository information
-    pub services: Vec<String>,
+#[derive(Debug, Clone, Serialize, Deserialize)]
-    pub archives_min: i64,
+pub struct BackupRepositoryData {
-    pub archives_max: i64,
+    pub name: String,
+    pub archive_count: i64,
+    pub repo_size_gb: f32,
+    pub status: Status,
 }
 
 impl AgentData {
@@ -244,9 +236,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(),
             },
         }
     }