Update network display format to match CLAUDE.md specification

Nest IP addresses under physical interface names. Show physical interfaces with status icon on header line. Virtual interfaces show inline with compressed IPs.

Format:
● eno1:
  ├─ ip: 192.168.30.105
  └─ tailscale0: 100.125.108.16

Version bump to 0.1.166

.gitea/workflows/release.yml

@@ -113,13 +113,13 @@ jobs:
           NIX_HASH="sha256-$(python3 -c "import base64, binascii; print(base64.b64encode(binascii.unhexlify('$NEW_HASH')).decode())")"
           
           # Update the NixOS configuration
-          sed -i "s|version = \"v[^\"]*\"|version = \"$VERSION\"|" hosts/services/cm-dashboard.nix
-          sed -i "s|sha256 = \"sha256-[^\"]*\"|sha256 = \"$NIX_HASH\"|" hosts/services/cm-dashboard.nix
-          
+          sed -i "s|version = \"v[^\"]*\"|version = \"$VERSION\"|" services/cm-dashboard.nix
+          sed -i "s|sha256 = \"sha256-[^\"]*\"|sha256 = \"$NIX_HASH\"|" services/cm-dashboard.nix
+
           # Commit and push changes
           git config user.name "Gitea Actions"
           git config user.email "actions@gitea.cmtec.se"
-          git add hosts/services/cm-dashboard.nix
+          git add services/cm-dashboard.nix
           git commit -m "Auto-update cm-dashboard to $VERSION
 
           - Update version to $VERSION with automated release

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.159"
+version = "0.1.166"
 dependencies = [
  "anyhow",
  "chrono",
@@ -301,7 +301,7 @@ dependencies = [
 
 [[package]]
 name = "cm-dashboard-agent"
-version = "0.1.159"
+version = "0.1.166"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -324,7 +324,7 @@ dependencies = [
 
 [[package]]
 name = "cm-dashboard-shared"
-version = "0.1.159"
+version = "0.1.166"
 dependencies = [
  "chrono",
  "serde",

agent/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard-agent"
-version = "0.1.159"
+version = "0.1.166"
 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,137 @@
+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,
+        }
+    }
+
+    /// Collect network interfaces using ip command
+    async fn collect_interfaces(&self) -> Vec<NetworkInterfaceData> {
+        let mut interfaces = Vec::new();
+
+        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 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());
+                                                    }
+                                                }
+                                                _ => {}
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+
+                            // 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
+                            };
+
+                            interfaces.push(NetworkInterfaceData {
+                                name,
+                                ipv4_addresses,
+                                ipv6_addresses,
+                                is_physical,
+                                link_status,
+                                parent_interface: None,  // TODO: Implement virtual interface parent detection
+                            });
+                        }
+                    }
+                }
+            }
+            Err(e) => {
+                debug!("Failed to execute ip command: {}", e);
+            }
+            Ok(output) => {
+                debug!("ip command failed with status: {}", output.status);
+            }
+        }
+
+        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/systemd.rs

@@ -756,9 +756,9 @@ impl SystemdCollector {
     fn get_docker_containers(&self) -> Vec<(String, String)> {
         let mut containers = Vec::new();
 
-        // Check if docker is available
-        let output = Command::new("docker")
-            .args(&["ps", "--format", "{{.Names}},{{.Status}}"])
+        // Check if docker is available (use sudo for permissions)
+        let output = Command::new("sudo")
+            .args(&["docker", "ps", "--format", "{{.Names}},{{.Status}}"])
             .output();
 
         let output = match output {

dashboard/Cargo.toml

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

dashboard/src/ui/widgets/system.rs

@@ -8,13 +8,16 @@ use ratatui::{
 
 use crate::ui::theme::{StatusIcons, Typography};
 
-/// System widget displaying NixOS info, CPU, RAM, and Storage in unified layout
+/// System widget displaying NixOS info, Network, CPU, RAM, and Storage in unified layout
 #[derive(Clone)]
 pub struct SystemWidget {
     // NixOS information
     nixos_build: Option<String>,
     agent_hash: Option<String>,
-    
+
+    // Network interfaces
+    network_interfaces: Vec<cm_dashboard_shared::NetworkInterfaceData>,
+
     // CPU metrics
     cpu_load_1min: Option<f32>,
     cpu_load_5min: Option<f32>,
@@ -89,6 +92,7 @@ impl SystemWidget {
         Self {
             nixos_build: None,
             agent_hash: None,
+            network_interfaces: Vec::new(),
             cpu_load_1min: None,
             cpu_load_5min: None,
             cpu_load_15min: None,
@@ -164,6 +168,9 @@ impl Widget for SystemWidget {
         // Extract build version
         self.nixos_build = agent_data.build_version.clone();
 
+        // Extract network interfaces
+        self.network_interfaces = agent_data.system.network.interfaces.clone();
+
         // Extract CPU data directly
         let cpu = &agent_data.system.cpu;
         self.cpu_load_1min = Some(cpu.load_1min);
@@ -573,8 +580,124 @@ impl SystemWidget {
         lines
     }
 
-    /// Render system widget  
-    pub fn render(&mut self, frame: &mut Frame, area: Rect, hostname: &str, config: Option<&crate::config::DashboardConfig>) {
+    /// 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();
+
+        if self.network_interfaces.is_empty() {
+            return lines;
+        }
+
+        // Separate physical and virtual interfaces
+        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
+        for (phy_idx, interface) in physical.iter().enumerate() {
+            let is_last_physical = phy_idx == physical.len() - 1 && virtual_interfaces.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));
+
+            // Show IPs nested under the interface
+            let ip_count = interface.ipv4_addresses.len() + interface.ipv6_addresses.len();
+            let mut ip_index = 0;
+
+            // IPv4 addresses
+            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 { "  ├─ " };
+                lines.push(Line::from(vec![
+                    Span::styled(tree_symbol, Typography::tree()),
+                    Span::styled(format!("ip: {}", ipv4), Typography::secondary()),
+                ]));
+            }
+
+            // IPv6 addresses
+            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 { "  ├─ " };
+                lines.push(Line::from(vec![
+                    Span::styled(tree_symbol, Typography::tree()),
+                    Span::styled(format!("ip: {}", ipv6), 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;
+            let tree_symbol = if is_last { "  └─ " } else { "  ├─ " };
+
+            // Virtual interface with IPs
+            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()
+            };
+
+            let interface_text = if !ip_text.is_empty() {
+                format!("{}: {}", interface.name, ip_text)
+            } else {
+                format!("{}:", interface.name)
+            };
+
+            lines.push(Line::from(vec![
+                Span::styled(tree_symbol, Typography::tree()),
+                Span::styled(interface_text, Typography::secondary()),
+            ]));
+        }
+
+        lines
+    }
+
+    /// Render system widget
+    pub fn render(&mut self, frame: &mut Frame, area: Rect, hostname: &str, _config: Option<&crate::config::DashboardConfig>) {
         let mut lines = Vec::new();
 
         // NixOS section
@@ -591,17 +714,16 @@ impl SystemWidget {
         lines.push(Line::from(vec![
             Span::styled(format!("Agent: {}", agent_version_text), Typography::secondary())
         ]));
-        
-        // Display detected connection IP
-        if let Some(config) = config {
-            if let Some(host_details) = config.hosts.get(hostname) {
-                let detected_ip = host_details.get_connection_ip(hostname);
-                lines.push(Line::from(vec![
-                    Span::styled(format!("IP: {}", detected_ip), 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![

shared/Cargo.toml

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

shared/src/agent_data.rs

@@ -16,11 +16,29 @@ pub struct AgentData {
 /// System-level monitoring data
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SystemData {
+    pub network: NetworkData,
     pub cpu: CpuData,
     pub memory: MemoryData,
     pub storage: StorageData,
 }
 
+/// Network interface monitoring data
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct NetworkData {
+    pub interfaces: Vec<NetworkInterfaceData>,
+}
+
+/// Individual network interface data
+#[derive(Debug, Clone, Serialize, Deserialize)]
+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>,
+}
+
 /// CPU monitoring data
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct CpuData {
@@ -171,6 +189,9 @@ impl AgentData {
             build_version: None,
             timestamp: chrono::Utc::now().timestamp() as u64,
             system: SystemData {
+                network: NetworkData {
+                    interfaces: Vec::new(),
+                },
                 cpu: CpuData {
                     load_1min: 0.0,
                     load_5min: 0.0,