Show all Docker containers as top-level services with active/inactive status

Agent changes:
- Changed docker ps to docker ps -a to show ALL containers (running and stopped)
- Map container status: Up -> active, Exited/Created -> inactive, other -> failed
- Display Docker containers as individual top-level services instead of sub-services
- Each container shown as "docker_{container_name}" in service list

This provides better visibility of all containers and their status directly in the
services panel, making it easier to see stopped containers at a glance.

Updated to version 0.1.172

Cargo.lock

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

agent/Cargo.toml

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

agent/src/collectors/network.rs

@@ -49,10 +49,67 @@ impl NetworkCollector {
         }
     }
 
+    /// Get the primary physical interface (the one with default route)
+    fn get_primary_physical_interface() -> Option<String> {
+        match Command::new("ip").args(["route", "show", "default"]).output() {
+            Ok(output) if output.status.success() => {
+                let output_str = String::from_utf8_lossy(&output.stdout);
+                // Parse: "default via 192.168.1.1 dev eno1 ..."
+                for line in output_str.lines() {
+                    if line.starts_with("default") {
+                        if let Some(dev_pos) = line.find(" dev ") {
+                            let after_dev = &line[dev_pos + 5..];
+                            if let Some(space_pos) = after_dev.find(' ') {
+                                let interface = &after_dev[..space_pos];
+                                // Only return if it's a physical interface
+                                if Self::is_physical_interface(interface) {
+                                    return Some(interface.to_string());
+                                }
+                            } else {
+                                // No space after interface name (end of line)
+                                let interface = after_dev.trim();
+                                if Self::is_physical_interface(interface) {
+                                    return Some(interface.to_string());
+                                }
+                            }
+                        }
+                    }
+                }
+                None
+            }
+            _ => None,
+        }
+    }
+
+    /// Parse VLAN configuration from /proc/net/vlan/config
+    /// Returns a map of interface name -> VLAN ID
+    fn parse_vlan_config() -> std::collections::HashMap<String, u16> {
+        let mut vlan_map = std::collections::HashMap::new();
+
+        if let Ok(contents) = std::fs::read_to_string("/proc/net/vlan/config") {
+            for line in contents.lines().skip(2) {  // Skip header lines
+                let parts: Vec<&str> = line.split('|').collect();
+                if parts.len() >= 2 {
+                    let interface_name = parts[0].trim();
+                    let vlan_id_str = parts[1].trim();
+
+                    if let Ok(vlan_id) = vlan_id_str.parse::<u16>() {
+                        vlan_map.insert(interface_name.to_string(), vlan_id);
+                    }
+                }
+            }
+        }
+
+        vlan_map
+    }
+
     /// Collect network interfaces using ip command
     async fn collect_interfaces(&self) -> Vec<NetworkInterfaceData> {
         let mut interfaces = Vec::new();
 
+        // Parse VLAN configuration
+        let vlan_map = Self::parse_vlan_config();
+
         match Command::new("ip").args(["-j", "addr"]).output() {
             Ok(output) if output.status.success() => {
                 let json_str = String::from_utf8_lossy(&output.stdout);
@@ -62,11 +119,19 @@ impl NetworkCollector {
                         for iface in ifaces {
                             let name = iface["ifname"].as_str().unwrap_or("").to_string();
 
-                            // Skip loopback and empty names
-                            if name.is_empty() || name == "lo" {
+                            // Skip loopback, empty names, and ifb* interfaces
+                            if name.is_empty() || name == "lo" || name.starts_with("ifb") {
                                 continue;
                             }
 
+                            // Parse parent interface from @parent notation (e.g., lan@enp0s31f6)
+                            let (interface_name, parent_interface) = if let Some(at_pos) = name.find('@') {
+                                let (child, parent) = name.split_at(at_pos);
+                                (child.to_string(), Some(parent[1..].to_string()))
+                            } else {
+                                (name.clone(), None)
+                            };
+
                             let mut ipv4_addresses = Vec::new();
                             let mut ipv6_addresses = Vec::new();
 
@@ -90,27 +155,32 @@ impl NetworkCollector {
                                 }
                             }
 
-                            // Only add interfaces that have at least one IP address
-                            // This filters out ifb*, dummy interfaces, etc. that have no IPs
-                            if ipv4_addresses.is_empty() && ipv6_addresses.is_empty() {
+                            // Determine if physical and get status
+                            let is_physical = Self::is_physical_interface(&interface_name);
+
+                            // Only filter out virtual interfaces without IPs
+                            // Physical interfaces should always be shown even if down/no IPs
+                            if !is_physical && ipv4_addresses.is_empty() && ipv6_addresses.is_empty() {
                                 continue;
                             }
 
-                            // Determine if physical and get status
-                            let is_physical = Self::is_physical_interface(&name);
                             let link_status = if is_physical {
                                 Self::get_link_status(&name)
                             } else {
                                 Status::Unknown  // Virtual interfaces don't have meaningful link status
                             };
 
+                            // Look up VLAN ID from the map (use original name before @ parsing)
+                            let vlan_id = vlan_map.get(&name).copied();
+
                             interfaces.push(NetworkInterfaceData {
-                                name,
+                                name: interface_name,
                                 ipv4_addresses,
                                 ipv6_addresses,
                                 is_physical,
                                 link_status,
-                                parent_interface: None,
+                                parent_interface,
+                                vlan_id,
                             });
                         }
                     }
@@ -124,6 +194,17 @@ impl NetworkCollector {
             }
         }
 
+        // Assign primary physical interface as parent to virtual interfaces without explicit parent
+        let primary_interface = Self::get_primary_physical_interface();
+        if let Some(primary) = primary_interface {
+            for interface in interfaces.iter_mut() {
+                // Only assign parent to virtual interfaces that don't already have one
+                if !interface.is_physical && interface.parent_interface.is_none() {
+                    interface.parent_interface = Some(primary.clone());
+                }
+            }
+        }
+
         interfaces
     }
 }

agent/src/collectors/systemd.rs

@@ -117,20 +117,8 @@ impl SystemdCollector {
                         }
                     }
 
-                    if service_name.contains("docker") && active_status == "active" {
-                        let docker_containers = self.get_docker_containers();
-                        for (container_name, container_status) in docker_containers {
-                            // For now, docker containers have no additional metrics
-                            // Future: could add memory_mb, cpu_percent, restart_count, etc.
-                            let metrics = Vec::new();
-                            
-                            sub_services.push(SubServiceData {
-                                name: container_name.clone(),
-                                service_status: self.calculate_service_status(&container_name, &container_status),
-                                metrics,
-                            });
-                        }
-                    }
+                    // Docker containers are now collected as top-level services below
+                    // Keeping nginx as sub-services for now
 
                     // Create complete service data
                     let service_data = ServiceData {
@@ -152,6 +140,21 @@ impl SystemdCollector {
             }
         }
 
+        // Collect Docker containers as top-level services
+        let docker_containers = self.get_docker_containers();
+        for (container_name, container_status) in docker_containers {
+            let service_data = ServiceData {
+                name: container_name.clone(),
+                memory_mb: 0.0, // TODO: Could add container memory via docker stats
+                disk_gb: 0.0,   // TODO: Could add container disk usage
+                user_stopped: false,
+                service_status: self.calculate_service_status(&container_name, &container_status),
+                sub_services: Vec::new(),
+            };
+            agent_data.services.push(service_data.clone());
+            complete_service_data.push(service_data);
+        }
+
         // Update cached state
         {
             let mut state = self.state.write().unwrap();
@@ -757,8 +760,9 @@ impl SystemdCollector {
         let mut containers = Vec::new();
 
         // Check if docker is available (use sudo for permissions)
+        // Use -a to show ALL containers (running and stopped)
         let output = Command::new("sudo")
-            .args(&["docker", "ps", "--format", "{{.Names}},{{.Status}}"])
+            .args(&["docker", "ps", "-a", "--format", "{{.Names}},{{.Status}}"])
             .output();
 
         let output = match output {
@@ -783,10 +787,10 @@ impl SystemdCollector {
 
                 let container_status = if status_str.contains("Up") {
                     "active"
-                } else if status_str.contains("Exited") {
-                    "warning" // Match original: Exited → Warning, not inactive
+                } else if status_str.contains("Exited") || status_str.contains("Created") {
+                    "inactive" // Stopped/created containers are inactive
                 } else {
-                    "failed" // Other states → failed
+                    "failed" // Other states (restarting, paused, dead) → failed
                 };
                 
                 containers.push((format!("docker_{}", container_name), container_status.to_string()));

dashboard/Cargo.toml

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

dashboard/src/ui/widgets/system.rs

@@ -628,9 +628,24 @@ impl SystemWidget {
         let physical: Vec<_> = self.network_interfaces.iter().filter(|i| i.is_physical).collect();
         let virtual_interfaces: Vec<_> = self.network_interfaces.iter().filter(|i| !i.is_physical).collect();
 
-        // Render physical interfaces
+        // Find standalone virtual interfaces (those without a parent)
+        let mut standalone_virtual: Vec<_> = virtual_interfaces.iter()
+            .filter(|i| i.parent_interface.is_none())
+            .collect();
+
+        // Sort standalone virtual: VLANs first (by VLAN ID), then others alphabetically
+        standalone_virtual.sort_by(|a, b| {
+            match (a.vlan_id, b.vlan_id) {
+                (Some(vlan_a), Some(vlan_b)) => vlan_a.cmp(&vlan_b),
+                (Some(_), None) => std::cmp::Ordering::Less,
+                (None, Some(_)) => std::cmp::Ordering::Greater,
+                (None, None) => a.name.cmp(&b.name),
+            }
+        });
+
+        // Render physical interfaces with their children
         for (phy_idx, interface) in physical.iter().enumerate() {
-            let is_last_physical = phy_idx == physical.len() - 1 && virtual_interfaces.is_empty();
+            let is_last_physical = phy_idx == physical.len() - 1 && standalone_virtual.is_empty();
 
             // Physical interface header with status icon
             let mut header_spans = vec![];
@@ -640,36 +655,93 @@ impl SystemWidget {
             ));
             lines.push(Line::from(header_spans));
 
-            // Show IPs nested under the interface
-            let ip_count = interface.ipv4_addresses.len() + interface.ipv6_addresses.len();
-            let mut ip_index = 0;
+            // Find child interfaces for this physical interface
+            let mut children: Vec<_> = virtual_interfaces.iter()
+                .filter(|vi| {
+                    if let Some(parent) = &vi.parent_interface {
+                        parent == &interface.name
+                    } else {
+                        false
+                    }
+                })
+                .collect();
 
-            // IPv4 addresses
+            // Sort children: VLANs first (by VLAN ID), then others alphabetically
+            children.sort_by(|a, b| {
+                match (a.vlan_id, b.vlan_id) {
+                    (Some(vlan_a), Some(vlan_b)) => vlan_a.cmp(&vlan_b),
+                    (Some(_), None) => std::cmp::Ordering::Less,
+                    (None, Some(_)) => std::cmp::Ordering::Greater,
+                    (None, None) => a.name.cmp(&b.name),
+                }
+            });
+
+            // Count total items under this physical interface (IPs + children)
+            let ip_count = interface.ipv4_addresses.len() + interface.ipv6_addresses.len();
+            let total_children = ip_count + children.len();
+            let mut child_index = 0;
+
+            // IPv4 addresses on the physical interface itself
             for ipv4 in &interface.ipv4_addresses {
-                ip_index += 1;
-                let is_last_ip = ip_index == ip_count && is_last_physical;
-                let tree_symbol = if is_last_ip { "  └─ " } else { "  ├─ " };
+                child_index += 1;
+                let is_last = child_index == total_children && is_last_physical;
+                let tree_symbol = if is_last { "  └─ " } else { "  ├─ " };
                 lines.push(Line::from(vec![
                     Span::styled(tree_symbol, Typography::tree()),
                     Span::styled(format!("ip: {}", ipv4), Typography::secondary()),
                 ]));
             }
 
-            // IPv6 addresses
+            // IPv6 addresses on the physical interface itself
             for ipv6 in &interface.ipv6_addresses {
-                ip_index += 1;
-                let is_last_ip = ip_index == ip_count && is_last_physical;
-                let tree_symbol = if is_last_ip { "  └─ " } else { "  ├─ " };
+                child_index += 1;
+                let is_last = child_index == total_children && is_last_physical;
+                let tree_symbol = if is_last { "  └─ " } else { "  ├─ " };
                 lines.push(Line::from(vec![
                     Span::styled(tree_symbol, Typography::tree()),
                     Span::styled(format!("ip: {}", ipv6), Typography::secondary()),
                 ]));
             }
+
+            // Child virtual interfaces (VLANs, etc.)
+            for child in children {
+                child_index += 1;
+                let is_last = child_index == total_children && is_last_physical;
+                let tree_symbol = if is_last { "  └─ " } else { "  ├─ " };
+
+                let ip_text = if !child.ipv4_addresses.is_empty() {
+                    Self::compress_ipv4_addresses(&child.ipv4_addresses)
+                } else if !child.ipv6_addresses.is_empty() {
+                    child.ipv6_addresses.join(", ")
+                } else {
+                    String::new()
+                };
+
+                // Format: "name (vlan X): IP" or "name: IP"
+                let child_text = if let Some(vlan_id) = child.vlan_id {
+                    if !ip_text.is_empty() {
+                        format!("{} (vlan {}): {}", child.name, vlan_id, ip_text)
+                    } else {
+                        format!("{} (vlan {}):", child.name, vlan_id)
+                    }
+                } else {
+                    if !ip_text.is_empty() {
+                        format!("{}: {}", child.name, ip_text)
+                    } else {
+                        format!("{}:", child.name)
+                    }
+                };
+
+                lines.push(Line::from(vec![
+                    Span::styled(tree_symbol, Typography::tree()),
+                    Span::styled(child_text, Typography::secondary()),
+                ]));
+            }
         }
 
         // Render standalone virtual interfaces (those without a parent)
-        for (virt_idx, interface) in virtual_interfaces.iter().enumerate() {
-            let is_last = virt_idx == virtual_interfaces.len() - 1;
+        for (virt_idx, interface) in standalone_virtual.iter().enumerate() {
+            let is_last = virt_idx == standalone_virtual.len() - 1;
             let tree_symbol = if is_last { "  └─ " } else { "  ├─ " };
 
             // Virtual interface with IPs
@@ -681,10 +753,19 @@ impl SystemWidget {
                 String::new()
             };
 
-            let interface_text = if !ip_text.is_empty() {
+            // Format: "name (vlan X): IP" or "name: IP"
+            let interface_text = if let Some(vlan_id) = interface.vlan_id {
+                if !ip_text.is_empty() {
+                    format!("{} (vlan {}): {}", interface.name, vlan_id, ip_text)
+                } else {
+                    format!("{} (vlan {}):", interface.name, vlan_id)
+                }
+            } else {
+                if !ip_text.is_empty() {
                     format!("{}: {}", interface.name, ip_text)
                 } else {
                     format!("{}:", interface.name)
+                }
             };
 
             lines.push(Line::from(vec![

shared/Cargo.toml

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

shared/src/agent_data.rs

@@ -37,6 +37,7 @@ pub struct NetworkInterfaceData {
     pub is_physical: bool,
     pub link_status: Status,
     pub parent_interface: Option<String>,
+    pub vlan_id: Option<u16>,
 }
 
 /// CPU monitoring data