Change Docker collection logging from debug to info level

Agent changes:
- Changed debug!() to info!() for Docker collection logs
- This allows logs to show with default RUST_LOG=info setting
- Added info import to tracing use statement

Now logs will be visible in journalctl without needing to change log level:
- "Collecting Docker sub-services for service: docker"
- "Found X Docker containers"
- "Found X Docker images"
- "Total Docker sub-services added: X"

Updated to version 0.1.176

CLAUDE.md

@@ -304,6 +304,12 @@ exclude_fs_types = ["tmpfs", "devtmpfs", "sysfs", "proc"]
 ### Display Format
 
 ```
+Network:
+● eno1:
+  ├─ ip: 192.168.30.105
+  └─ tailscale0: 100.125.108.16
+● eno2:
+  └─ ip: 192.168.32.105
 CPU:
 ● Load: 0.23 0.21 0.13
   └─ Freq: 1048 MHz

Cargo.lock

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

agent/Cargo.toml

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

agent/src/agent.rs

@@ -12,6 +12,7 @@ use crate::collectors::{
     cpu::CpuCollector,
     disk::DiskCollector,
     memory::MemoryCollector,
+    network::NetworkCollector,
     nixos::NixOSCollector,
     systemd::SystemdCollector,
 };
@@ -77,7 +78,11 @@ impl Agent {
         if config.collectors.backup.enabled {
             collectors.push(Box::new(BackupCollector::new()));
         }
-        
+
+        if config.collectors.network.enabled {
+            collectors.push(Box::new(NetworkCollector::new(config.collectors.network.clone())));
+        }
+
         if config.collectors.nixos.enabled {
             collectors.push(Box::new(NixOSCollector::new(config.collectors.nixos.clone())));
         }

agent/src/collectors/mod.rs

@@ -7,6 +7,7 @@ pub mod cpu;
 pub mod disk;
 pub mod error;
 pub mod memory;
+pub mod network;
 pub mod nixos;
 pub mod systemd;
 

agent/src/collectors/network.rs

@@ -0,0 +1,224 @@
+use async_trait::async_trait;
+use cm_dashboard_shared::{AgentData, NetworkInterfaceData, Status};
+use std::process::Command;
+use tracing::debug;
+
+use super::{Collector, CollectorError};
+use crate::config::NetworkConfig;
+
+/// Network interface collector with physical/virtual classification and link status
+pub struct NetworkCollector {
+    _config: NetworkConfig,
+}
+
+impl NetworkCollector {
+    pub fn new(config: NetworkConfig) -> Self {
+        Self { _config: config }
+    }
+
+    /// Check if interface is physical (not virtual)
+    fn is_physical_interface(name: &str) -> bool {
+        // Physical interface patterns
+        matches!(
+            &name[..],
+            s if s.starts_with("eth")
+                || s.starts_with("ens")
+                || s.starts_with("enp")
+                || s.starts_with("wlan")
+                || s.starts_with("wlp")
+                || s.starts_with("eno")
+                || s.starts_with("enx")
+        )
+    }
+
+    /// Get link status for an interface
+    fn get_link_status(interface: &str) -> Status {
+        let operstate_path = format!("/sys/class/net/{}/operstate", interface);
+
+        match std::fs::read_to_string(&operstate_path) {
+            Ok(state) => {
+                let state = state.trim();
+                match state {
+                    "up" => Status::Ok,
+                    "down" => Status::Inactive,
+                    "unknown" => Status::Warning,
+                    _ => Status::Unknown,
+                }
+            }
+            Err(_) => Status::Unknown,
+        }
+    }
+
+    /// 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);
+
+                if let Ok(json_data) = serde_json::from_str::<serde_json::Value>(&json_str) {
+                    if let Some(ifaces) = json_data.as_array() {
+                        for iface in ifaces {
+                            let name = iface["ifname"].as_str().unwrap_or("").to_string();
+
+                            // 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();
+
+                            // Extract IP addresses
+                            if let Some(addr_info) = iface["addr_info"].as_array() {
+                                for addr in addr_info {
+                                    if let Some(family) = addr["family"].as_str() {
+                                        if let Some(local) = addr["local"].as_str() {
+                                            match family {
+                                                "inet" => ipv4_addresses.push(local.to_string()),
+                                                "inet6" => {
+                                                    // Skip link-local IPv6 addresses (fe80::)
+                                                    if !local.starts_with("fe80:") {
+                                                        ipv6_addresses.push(local.to_string());
+                                                    }
+                                                }
+                                                _ => {}
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+
+                            // 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;
+                            }
+
+                            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: interface_name,
+                                ipv4_addresses,
+                                ipv6_addresses,
+                                is_physical,
+                                link_status,
+                                parent_interface,
+                                vlan_id,
+                            });
+                        }
+                    }
+                }
+            }
+            Err(e) => {
+                debug!("Failed to execute ip command: {}", e);
+            }
+            Ok(output) => {
+                debug!("ip command failed with status: {}", output.status);
+            }
+        }
+
+        // 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
+    }
+}
+
+#[async_trait]
+impl Collector for NetworkCollector {
+    async fn collect_structured(&self, agent_data: &mut AgentData) -> Result<(), CollectorError> {
+        debug!("Collecting network interface data");
+
+        // Collect all network interfaces
+        let interfaces = self.collect_interfaces().await;
+
+        agent_data.system.network.interfaces = interfaces;
+
+        Ok(())
+    }
+}

agent/src/collectors/nixos.rs

@@ -1,5 +1,5 @@
 use async_trait::async_trait;
-use cm_dashboard_shared::{AgentData, NetworkInterfaceData};
+use cm_dashboard_shared::AgentData;
 use std::fs;
 use std::process::Command;
 use tracing::debug;
@@ -32,9 +32,6 @@ impl NixOSCollector {
         // Set NixOS build/generation information
         agent_data.build_version = self.get_nixos_generation().await;
 
-        // Collect network interfaces
-        agent_data.system.network.interfaces = self.get_network_interfaces().await;
-
         // Set current timestamp
         agent_data.timestamp = chrono::Utc::now().timestamp() as u64;
 
@@ -104,72 +101,6 @@ impl NixOSCollector {
             }
         }
     }
-
-    /// Get network interfaces and their IP addresses
-    async fn get_network_interfaces(&self) -> Vec<NetworkInterfaceData> {
-        let mut interfaces = Vec::new();
-
-        // Use ip command with JSON output for easier parsing
-        match Command::new("ip").args(["-j", "addr"]).output() {
-            Ok(output) if output.status.success() => {
-                let json_str = String::from_utf8_lossy(&output.stdout);
-
-                // Parse JSON output
-                if let Ok(json_data) = serde_json::from_str::<serde_json::Value>(&json_str) {
-                    if let Some(ifaces) = json_data.as_array() {
-                        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" {
-                                continue;
-                            }
-
-                            let mut ipv4_addresses = Vec::new();
-                            let mut ipv6_addresses = Vec::new();
-
-                            // Extract IP addresses
-                            if let Some(addr_info) = iface["addr_info"].as_array() {
-                                for addr in addr_info {
-                                    if let Some(family) = addr["family"].as_str() {
-                                        if let Some(local) = addr["local"].as_str() {
-                                            match family {
-                                                "inet" => ipv4_addresses.push(local.to_string()),
-                                                "inet6" => {
-                                                    // Skip link-local IPv6 addresses (fe80::)
-                                                    if !local.starts_with("fe80:") {
-                                                        ipv6_addresses.push(local.to_string());
-                                                    }
-                                                }
-                                                _ => {}
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-
-                            // Only add interfaces that have at least one IP address
-                            if !ipv4_addresses.is_empty() || !ipv6_addresses.is_empty() {
-                                interfaces.push(NetworkInterfaceData {
-                                    name,
-                                    ipv4_addresses,
-                                    ipv6_addresses,
-                                });
-                            }
-                        }
-                    }
-                }
-            }
-            Err(e) => {
-                debug!("Failed to execute ip command: {}", e);
-            }
-            Ok(output) => {
-                debug!("ip command failed with status: {}", output.status);
-            }
-        }
-
-        interfaces
-    }
 }
 
 #[async_trait]

agent/src/collectors/systemd.rs

@@ -4,7 +4,7 @@ use cm_dashboard_shared::{AgentData, ServiceData, SubServiceData, SubServiceMetr
 use std::process::Command;
 use std::sync::RwLock;
 use std::time::Instant;
-use tracing::debug;
+use tracing::{debug, info};
 
 use super::{Collector, CollectorError};
 use crate::config::SystemdConfig;
@@ -118,18 +118,41 @@ impl SystemdCollector {
                     }
 
                     if service_name.contains("docker") && active_status == "active" {
+                        info!("Collecting Docker sub-services for service: {}", service_name);
+
                         let docker_containers = self.get_docker_containers();
+                        info!("Found {} Docker containers", docker_containers.len());
                         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,
                             });
                         }
+
+                        // Add Docker images
+                        let docker_images = self.get_docker_images();
+                        info!("Found {} Docker images", docker_images.len());
+                        for (image_name, image_status, image_size) in docker_images {
+                            let mut metrics = Vec::new();
+                            metrics.push(SubServiceMetric {
+                                label: "size".to_string(),
+                                value: 0.0, // Size as string in name instead
+                                unit: None,
+                            });
+
+                            sub_services.push(SubServiceData {
+                                name: format!("{} ({})", image_name, image_size),
+                                service_status: self.calculate_service_status(&image_name, &image_status),
+                                metrics,
+                            });
+                        }
+
+                        info!("Total Docker sub-services added: {}", sub_services.len());
                     }
 
                     // Create complete service data
@@ -151,7 +174,7 @@ impl SystemdCollector {
                 }
             }
         }
-        
+
         // Update cached state
         {
             let mut state = self.state.write().unwrap();
@@ -757,8 +780,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 +807,10 @@ impl SystemdCollector {
 
                 let container_status = if status_str.contains("Up") {
                     "active"
-                } else if status_str.contains("Exited") {
+                } else if status_str.contains("Exited") || status_str.contains("Created") {
-                    "warning" // Match original: Exited → Warning, not inactive
+                    "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()));
@@ -795,6 +819,60 @@ impl SystemdCollector {
 
         containers
     }
+
+    /// Get docker images as sub-services
+    fn get_docker_images(&self) -> Vec<(String, String, String)> {
+        let mut images = Vec::new();
+
+        info!("Collecting Docker images");
+
+        // Check if docker is available (use sudo for permissions)
+        let output = Command::new("sudo")
+            .args(&["docker", "images", "--format", "{{.Repository}}:{{.Tag}},{{.Size}}"])
+            .output();
+
+        let output = match output {
+            Ok(out) if out.status.success() => out,
+            Ok(out) => {
+                info!("Docker images command failed with status: {}", out.status);
+                return images;
+            }
+            Err(e) => {
+                info!("Docker images command error: {}", e);
+                return images;
+            }
+        };
+
+        let output_str = match String::from_utf8(output.stdout) {
+            Ok(s) => s,
+            Err(_) => return images,
+        };
+
+        for line in output_str.lines() {
+            if line.trim().is_empty() {
+                continue;
+            }
+
+            let parts: Vec<&str> = line.split(',').collect();
+            if parts.len() >= 2 {
+                let image_name = parts[0].trim();
+                let size = parts[1].trim();
+
+                // Skip <none>:<none> images (dangling images)
+                if image_name.contains("<none>") {
+                    continue;
+                }
+
+                images.push((
+                    format!("image_{}", image_name),
+                    "active".to_string(), // Images are always "active" (present)
+                    size.to_string()
+                ));
+            }
+        }
+
+        images
+    }
 }
 
 #[async_trait]

dashboard/Cargo.toml

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

dashboard/src/ui/widgets/system.rs

@@ -580,7 +580,43 @@ impl SystemWidget {
         lines
     }
 
-    /// Render network section for display
+    /// Compress IPv4 addresses from same subnet
+    /// Example: "192.168.30.1, 192.168.30.100" -> "192.168.30.1, 100"
+    fn compress_ipv4_addresses(addresses: &[String]) -> String {
+        if addresses.is_empty() {
+            return String::new();
+        }
+
+        if addresses.len() == 1 {
+            return addresses[0].clone();
+        }
+
+        let mut result = Vec::new();
+        let mut last_prefix = String::new();
+
+        for addr in addresses {
+            let parts: Vec<&str> = addr.split('.').collect();
+            if parts.len() == 4 {
+                let prefix = format!("{}.{}.{}", parts[0], parts[1], parts[2]);
+
+                if prefix == last_prefix {
+                    // Same subnet, show only last octet
+                    result.push(parts[3].to_string());
+                } else {
+                    // Different subnet, show full IP
+                    result.push(addr.clone());
+                    last_prefix = prefix;
+                }
+            } else {
+                // Invalid IP format, show as-is
+                result.push(addr.clone());
+            }
+        }
+
+        result.join(", ")
+    }
+
+    /// Render network section for display with physical/virtual grouping
     fn render_network(&self) -> Vec<Line<'_>> {
         let mut lines = Vec::new();
 
@@ -588,31 +624,154 @@ impl SystemWidget {
             return lines;
         }
 
-        for (i, interface) in self.network_interfaces.iter().enumerate() {
+        // Separate physical and virtual interfaces
-            let is_last = i == self.network_interfaces.len() - 1;
+        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();
+
+        // 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 && standalone_virtual.is_empty();
+
+            // Physical interface header with status icon
+            let mut header_spans = vec![];
+            header_spans.extend(StatusIcons::create_status_spans(
+                interface.link_status.clone(),
+                &format!("{}:", interface.name)
+            ));
+            lines.push(Line::from(header_spans));
+
+            // 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();
+
+            // 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 {
+                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 on the physical interface itself
+            for ipv6 in &interface.ipv6_addresses {
+                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 standalone_virtual.iter().enumerate() {
+            let is_last = virt_idx == standalone_virtual.len() - 1;
             let tree_symbol = if is_last { "  └─ " } else { "  ├─ " };
 
-            // Show interface name
+            // Virtual interface with IPs
-            let mut interface_text = format!("{}: ", interface.name);
+            let ip_text = if !interface.ipv4_addresses.is_empty() {
+                Self::compress_ipv4_addresses(&interface.ipv4_addresses)
+            } else if !interface.ipv6_addresses.is_empty() {
+                interface.ipv6_addresses.join(", ")
+            } else {
+                String::new()
+            };
 
-            // Add IPv4 addresses
+            // Format: "name (vlan X): IP" or "name: IP"
-            if !interface.ipv4_addresses.is_empty() {
+            let interface_text = if let Some(vlan_id) = interface.vlan_id {
-                interface_text.push_str(&interface.ipv4_addresses.join(", "));
+                if !ip_text.is_empty() {
-            }
+                    format!("{} (vlan {}): {}", interface.name, vlan_id, ip_text)
-
+                } else {
-            // Add IPv6 addresses
+                    format!("{} (vlan {}):", interface.name, vlan_id)
-            if !interface.ipv6_addresses.is_empty() {
-                if !interface.ipv4_addresses.is_empty() {
-                    interface_text.push_str(", ");
                 }
-                interface_text.push_str(&interface.ipv6_addresses.join(", "));
+            } else {
-            }
+                if !ip_text.is_empty() {
+                    format!("{}: {}", interface.name, ip_text)
+                } else {
+                    format!("{}:", interface.name)
+                }
+            };
 
-            let mut spans = vec![
+            lines.push(Line::from(vec![
                 Span::styled(tree_symbol, Typography::tree()),
-            ];
+                Span::styled(interface_text, Typography::secondary()),
-            spans.extend(StatusIcons::create_status_spans(Status::Ok, &interface_text));
+            ]));
-            lines.push(Line::from(spans));
         }
 
         lines
@@ -637,28 +796,18 @@ impl SystemWidget {
             Span::styled(format!("Agent: {}", agent_version_text), Typography::secondary())
         ]));
 
-        // Network section
-        if !self.network_interfaces.is_empty() {
-            lines.push(Line::from(vec![
-                Span::styled("Network:", Typography::widget_title())
-            ]));
-
-            let network_lines = self.render_network();
-            lines.extend(network_lines);
-        }
-
         // CPU section
         lines.push(Line::from(vec![
             Span::styled("CPU:", Typography::widget_title())
         ]));
-        
+
         let load_text = self.format_cpu_load();
         let cpu_spans = StatusIcons::create_status_spans(
             self.cpu_status.clone(),
             &format!("Load: {}", load_text)
         );
         lines.push(Line::from(cpu_spans));
-        
+
         let freq_text = self.format_cpu_frequency();
         lines.push(Line::from(vec![
             Span::styled("  └─ ", Typography::tree()),
@@ -669,7 +818,7 @@ impl SystemWidget {
         lines.push(Line::from(vec![
             Span::styled("RAM:", Typography::widget_title())
         ]));
-        
+
         let memory_text = self.format_memory_usage();
         let memory_spans = StatusIcons::create_status_spans(
             self.memory_status.clone(),
@@ -681,16 +830,16 @@ impl SystemWidget {
         for (i, tmpfs) in self.tmpfs_mounts.iter().enumerate() {
             let is_last = i == self.tmpfs_mounts.len() - 1;
             let tree_symbol = if is_last { "  └─ " } else { "  ├─ " };
-            
+
             let usage_text = if tmpfs.total_gb > 0.0 {
-                format!("{:.0}% {:.1}GB/{:.1}GB", 
+                format!("{:.0}% {:.1}GB/{:.1}GB",
-                    tmpfs.usage_percent, 
+                    tmpfs.usage_percent,
-                    tmpfs.used_gb, 
+                    tmpfs.used_gb,
                     tmpfs.total_gb)
             } else {
                 "— —/—".to_string()
             };
-            
+
             let mut tmpfs_spans = vec![
                 Span::styled(tree_symbol, Typography::tree()),
             ];
@@ -701,6 +850,16 @@ impl SystemWidget {
             lines.push(Line::from(tmpfs_spans));
         }
 
+        // Network section
+        if !self.network_interfaces.is_empty() {
+            lines.push(Line::from(vec![
+                Span::styled("Network:", Typography::widget_title())
+            ]));
+
+            let network_lines = self.render_network();
+            lines.extend(network_lines);
+        }
+
         // Storage section
         lines.push(Line::from(vec![
             Span::styled("Storage:", Typography::widget_title())

shared/Cargo.toml

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

shared/src/agent_data.rs

@@ -34,6 +34,10 @@ pub struct NetworkInterfaceData {
     pub name: String,
     pub ipv4_addresses: Vec<String>,
     pub ipv6_addresses: Vec<String>,
+    pub is_physical: bool,
+    pub link_status: Status,
+    pub parent_interface: Option<String>,
+    pub vlan_id: Option<u16>,
 }
 
 /// CPU monitoring data