Move Network section below RAM in system widget

Reordered display sections in system widget:
- Network section now appears after RAM and tmpfs mounts
- Improves logical grouping by placing network info between memory and storage
- Updated to version 0.1.168

.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|version = \"v[^\"]*\"|version = \"$VERSION\"|" services/cm-dashboard.nix
-          sed -i "s|sha256 = \"sha256-[^\"]*\"|sha256 = \"$NIX_HASH\"|" hosts/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.160"
+version = "0.1.168"
 dependencies = [
  "anyhow",
  "chrono",
@@ -301,7 +301,7 @@ dependencies = [
 
 [[package]]
 name = "cm-dashboard-agent"
-version = "0.1.160"
+version = "0.1.168"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -324,7 +324,7 @@ dependencies = [
 
 [[package]]
 name = "cm-dashboard-shared"
-version = "0.1.160"
+version = "0.1.168"
 dependencies = [
  "chrono",
  "serde",

agent/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard-agent"
-version = "0.1.160"
+version = "0.1.168"
 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,143 @@
+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());
+                                                    }
+                                                }
+                                                _ => {}
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+
+                            // 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() {
+                                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
+                            };
+
+                            interfaces.push(NetworkInterfaceData {
+                                name,
+                                ipv4_addresses,
+                                ipv6_addresses,
+                                is_physical,
+                                link_status,
+                                parent_interface: None,
+                            });
+                        }
+                    }
+                }
+            }
+            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(())
+    }
+}

dashboard/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard"
-version = "0.1.160"
+version = "0.1.168"
 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  
+    /// Compress IPv4 addresses from same subnet
-    pub fn render(&mut self, frame: &mut Frame, area: Rect, hostname: &str, config: Option<&crate::config::DashboardConfig>) {
+    /// 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,30 +714,19 @@ 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())
-                ]));
-            }
-        }
-        
 
         // 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()),
@@ -625,7 +737,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(),
@@ -637,16 +749,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()),
             ];
@@ -657,6 +769,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.160"
+version = "0.1.168"
 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,