Bump version to v0.1.204

Complete removal of service resource metrics:

Agent:
- Remove memory_mb and disk_gb fields from ServiceData struct
- Remove get_service_memory_usage() method
- Remove get_service_disk_usage() method
- Remove get_directory_size() method
- Remove unused warn import

Dashboard:
- Remove memory_mb and disk_gb from ServiceInfo struct
- Remove memory/disk display from format_parent_service_line
- Remove memory/disk parsing in legacy metric path
- Remove unused format_disk_size() function

Service resource metrics were slow, unreliable, and never worked
properly since structured data migration. Will be handled differently
in the future.

Cargo.lock

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

agent/Cargo.toml

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

agent/src/agent.rs

@@ -4,7 +4,7 @@ use std::time::Duration;
 use tokio::time::interval;
 use tracing::{debug, error, info};
 
-use crate::communication::{AgentCommand, ZmqHandler};
+use crate::communication::ZmqHandler;
 use crate::config::AgentConfig;
 use crate::collectors::{
     Collector,
@@ -134,12 +134,6 @@ impl Agent {
                     // NOTE: With structured data, we might need to implement status tracking differently
                     // For now, we skip this until status evaluation is migrated
                 }
-                // Handle incoming commands (check periodically)
-                _ = tokio::time::sleep(Duration::from_millis(100)) => {
-                    if let Err(e) = self.handle_commands().await {
-                        error!("Error handling commands: {}", e);
-                    }
-                }
                 _ = &mut shutdown_rx => {
                     info!("Shutdown signal received, stopping agent loop");
                     break;
@@ -259,36 +253,4 @@ impl Agent {
         Ok(())
     }
 
-    /// Handle incoming commands from dashboard
-    async fn handle_commands(&mut self) -> Result<()> {
-        // Try to receive a command (non-blocking)
-        if let Ok(Some(command)) = self.zmq_handler.try_receive_command() {
-            info!("Received command: {:?}", command);
-
-            match command {
-                AgentCommand::CollectNow => {
-                    info!("Received immediate collection request");
-                    if let Err(e) = self.collect_and_broadcast().await {
-                        error!("Failed to collect on demand: {}", e);
-                    }
-                }
-                AgentCommand::SetInterval { seconds } => {
-                    info!("Received interval change request: {}s", seconds);
-                    // Note: This would require more complex handling to update the interval
-                    // For now, just acknowledge
-                }
-                AgentCommand::ToggleCollector { name, enabled } => {
-                    info!("Received collector toggle request: {} -> {}", name, enabled);
-                    // Note: This would require more complex handling to enable/disable collectors
-                    // For now, just acknowledge
-                }
-                AgentCommand::Ping => {
-                    info!("Received ping command");
-                    // Maybe send back a pong or status
-                }
-            }
-        }
-        Ok(())
-    }
-
 }

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, warn};
+use tracing::debug;
 
 use super::{Collector, CollectorError};
 use crate::config::SystemdConfig;
@@ -87,9 +87,6 @@ impl SystemdCollector {
         for service_name in &monitored_services {
             match self.get_service_status(service_name) {
                 Ok((active_status, _detailed_info)) => {
-                    let memory_mb = self.get_service_memory_usage(service_name).await.unwrap_or(0.0);
-                    let disk_gb = self.get_service_disk_usage(service_name).await.unwrap_or(0.0);
-                    
                     let mut sub_services = Vec::new();
 
                     // Sub-service metrics for specific services (always include cached results)
@@ -113,6 +110,7 @@ impl SystemdCollector {
                                 name: site_name.clone(),
                                 service_status: self.calculate_service_status(&site_name, &site_status),
                                 metrics,
+                                service_type: "nginx_site".to_string(),
                             });
                         }
                     }
@@ -128,12 +126,13 @@ impl SystemdCollector {
                                 name: container_name.clone(),
                                 service_status: self.calculate_service_status(&container_name, &container_status),
                                 metrics,
+                                service_type: "container".to_string(),
                             });
                         }
 
                         // Add Docker images
                         let docker_images = self.get_docker_images();
-                        for (image_name, image_status, image_size_str, image_size_mb) in docker_images {
+                        for (image_name, image_status, image_size_mb) in docker_images {
                             let mut metrics = Vec::new();
                             metrics.push(SubServiceMetric {
                                 label: "size".to_string(),
@@ -142,9 +141,10 @@ impl SystemdCollector {
                             });
 
                             sub_services.push(SubServiceData {
-                                name: format!("{} ({})", image_name, image_size_str),
+                                name: image_name.to_string(),
                                 service_status: self.calculate_service_status(&image_name, &image_status),
                                 metrics,
+                                service_type: "image".to_string(),
                             });
                         }
                     }
@@ -152,8 +152,6 @@ impl SystemdCollector {
                     // Create complete service data
                     let service_data = ServiceData {
                         name: service_name.clone(),
-                        memory_mb,
-                        disk_gb,
                         user_stopped: false, // TODO: Integrate with service tracker
                         service_status: self.calculate_service_status(service_name, &active_status),
                         sub_services,
@@ -413,80 +411,6 @@ impl SystemdCollector {
         true
     }
 
-    /// Get disk usage for a specific service
-    async fn get_service_disk_usage(&self, service_name: &str) -> Result<f32, CollectorError> {
-        // Check if this service has configured directory paths
-        if let Some(dirs) = self.config.service_directories.get(service_name) {
-            // Service has configured paths - use the first accessible one
-            for dir in dirs {
-                if let Some(size) = self.get_directory_size(dir).await {
-                    return Ok(size);
-                }
-            }
-            // If configured paths failed, return 0
-            return Ok(0.0);
-        }
-
-        // No configured path - try to get WorkingDirectory from systemctl (with 2 second timeout)
-        let output = Command::new("timeout")
-            .args(&["2", "systemctl", "show", &format!("{}.service", service_name), "--property=WorkingDirectory"])
-            .output()
-            .map_err(|e| CollectorError::SystemRead {
-                path: format!("WorkingDirectory for {}", service_name),
-                error: e.to_string(),
-            })?;
-
-        let output_str = String::from_utf8_lossy(&output.stdout);
-        for line in output_str.lines() {
-            if line.starts_with("WorkingDirectory=") && !line.contains("[not set]") {
-                let dir = line.strip_prefix("WorkingDirectory=").unwrap_or("");
-                if !dir.is_empty() && dir != "/" {
-                    return Ok(self.get_directory_size(dir).await.unwrap_or(0.0));
-                }
-            }
-        }
-
-        Ok(0.0)
-    }
-    
-    /// Get size of a directory in GB (with 2 second timeout)
-    async fn get_directory_size(&self, path: &str) -> Option<f32> {
-        use super::run_command_with_timeout;
-
-        // Use -s (summary) and --apparent-size for speed, 2 second timeout
-        let mut cmd = Command::new("sudo");
-        cmd.args(&["du", "-s", "--apparent-size", "--block-size=1", path]);
-
-        let output = run_command_with_timeout(cmd, 2).await.ok()?;
-
-        if !output.status.success() {
-            // Log permission errors for debugging but don't spam logs
-            let stderr = String::from_utf8_lossy(&output.stderr);
-            if stderr.contains("Permission denied") {
-                debug!("Permission denied accessing directory: {}", path);
-            } else if stderr.contains("timed out") {
-                warn!("Directory size check timed out for {}", path);
-            } else {
-                debug!("Failed to get size for directory {}: {}", path, stderr);
-            }
-            return None;
-        }
-
-        let output_str = String::from_utf8(output.stdout).ok()?;
-        let size_str = output_str.split_whitespace().next()?;
-        if let Ok(size_bytes) = size_str.parse::<u64>() {
-            let size_gb = size_bytes as f32 / (1024.0 * 1024.0 * 1024.0);
-            // Return size even if very small (minimum 0.001 GB = 1MB for visibility)
-            if size_gb > 0.0 {
-                Some(size_gb.max(0.001))
-            } else {
-                None
-            }
-        } else {
-            None
-        }
-    }
-
     /// Calculate service status, taking user-stopped services into account
     fn calculate_service_status(&self, service_name: &str, active_status: &str) -> Status {
         match active_status.to_lowercase().as_str() {
@@ -504,33 +428,6 @@ impl SystemdCollector {
         }
     }
 
-    /// Get memory usage for a specific service
-    async fn get_service_memory_usage(&self, service_name: &str) -> Result<f32, CollectorError> {
-        let output = Command::new("systemctl")
-            .args(&["show", &format!("{}.service", service_name), "--property=MemoryCurrent"])
-            .output()
-            .map_err(|e| CollectorError::SystemRead {
-                path: format!("memory usage for {}", service_name),
-                error: e.to_string(),
-            })?;
-
-        let output_str = String::from_utf8_lossy(&output.stdout);
-        
-        for line in output_str.lines() {
-            if line.starts_with("MemoryCurrent=") {
-                if let Some(mem_str) = line.strip_prefix("MemoryCurrent=") {
-                    if mem_str != "[not set]" {
-                        if let Ok(memory_bytes) = mem_str.parse::<u64>() {
-                            return Ok(memory_bytes as f32 / (1024.0 * 1024.0)); // Convert to MB
-                        }
-                    }
-                }
-            }
-        }
-
-        Ok(0.0)
-    }
-
     /// Check if service collection cache should be updated
     fn should_update_cache(&self) -> bool {
         let state = self.state.read().unwrap();
@@ -824,7 +721,7 @@ impl SystemdCollector {
     }
 
     /// Get docker images as sub-services
-    fn get_docker_images(&self) -> Vec<(String, String, String, f32)> {
+    fn get_docker_images(&self) -> Vec<(String, String, f32)> {
         let mut images = Vec::new();
         // Check if docker is available (cm-agent user is in docker group) with 3 second timeout
         let output = Command::new("timeout")
@@ -865,9 +762,8 @@ impl SystemdCollector {
                 let size_mb = self.parse_docker_size(size_str);
 
                 images.push((
-                    format!("I {}", image_name),
+                    image_name.to_string(),
                     "inactive".to_string(), // Images are informational - use inactive for neutral display
-                    size_str.to_string(),
                     size_mb
                 ));
             }

agent/src/communication/mod.rs

@@ -5,10 +5,9 @@ use zmq::{Context, Socket, SocketType};
 
 use crate::config::ZmqConfig;
 
-/// ZMQ communication handler for publishing metrics and receiving commands
+/// ZMQ communication handler for publishing metrics
 pub struct ZmqHandler {
     publisher: Socket,
-    command_receiver: Socket,
 }
 
 impl ZmqHandler {
@@ -26,20 +25,8 @@ impl ZmqHandler {
         publisher.set_sndhwm(1000)?; // High water mark for outbound messages
         publisher.set_linger(1000)?; // Linger time on close
 
-        // Create command receiver socket (PULL socket to receive commands from dashboard)
-        let command_receiver = context.socket(SocketType::PULL)?;
-        let cmd_bind_address = format!("tcp://{}:{}", config.bind_address, config.command_port);
-        command_receiver.bind(&cmd_bind_address)?;
-
-        info!("ZMQ command receiver bound to {}", cmd_bind_address);
-
-        // Set non-blocking mode for command receiver
-        command_receiver.set_rcvtimeo(0)?; // Non-blocking receive
-        command_receiver.set_linger(1000)?;
-
         Ok(Self {
             publisher,
-            command_receiver,
         })
     }
 
@@ -65,36 +52,4 @@ impl ZmqHandler {
         Ok(())
     }
 
-    /// Try to receive a command (non-blocking)
-    pub fn try_receive_command(&self) -> Result<Option<AgentCommand>> {
-        match self.command_receiver.recv_bytes(zmq::DONTWAIT) {
-            Ok(bytes) => {
-                debug!("Received command message ({} bytes)", bytes.len());
-
-                let command: AgentCommand = serde_json::from_slice(&bytes)
-                    .map_err(|e| anyhow::anyhow!("Failed to deserialize command: {}", e))?;
-
-                debug!("Parsed command: {:?}", command);
-                Ok(Some(command))
-            }
-            Err(zmq::Error::EAGAIN) => {
-                // No message available (non-blocking)
-                Ok(None)
-            }
-            Err(e) => Err(anyhow::anyhow!("ZMQ receive error: {}", e)),
-        }
-    }
-}
-
-/// Commands that can be sent to the agent
-#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
-pub enum AgentCommand {
-    /// Request immediate metric collection
-    CollectNow,
-    /// Change collection interval
-    SetInterval { seconds: u64 },
-    /// Enable/disable a collector
-    ToggleCollector { name: String, enabled: bool },
-    /// Request status/health check
-    Ping,
 }

agent/src/config/mod.rs

@@ -20,7 +20,6 @@ pub struct AgentConfig {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ZmqConfig {
     pub publisher_port: u16,
-    pub command_port: u16,
     pub bind_address: String,
     pub transmission_interval_seconds: u64,
     /// Heartbeat transmission interval in seconds for host connectivity detection

agent/src/config/validation.rs

@@ -7,14 +7,6 @@ pub fn validate_config(config: &AgentConfig) -> Result<()> {
         bail!("ZMQ publisher port cannot be 0");
     }
 
-    if config.zmq.command_port == 0 {
-        bail!("ZMQ command port cannot be 0");
-    }
-
-    if config.zmq.publisher_port == config.zmq.command_port {
-        bail!("ZMQ publisher and command ports cannot be the same");
-    }
-
     if config.zmq.bind_address.is_empty() {
         bail!("ZMQ bind address cannot be empty");
     }

dashboard/Cargo.toml

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

dashboard/src/ui/widgets/services.rs

@@ -28,10 +28,9 @@ pub struct ServicesWidget {
 
 #[derive(Clone)]
 struct ServiceInfo {
-    memory_mb: Option<f32>,
-    disk_gb: Option<f32>,
     metrics: Vec<(String, f32, Option<String>)>, // (label, value, unit)
     widget_status: Status,
+    service_type: String, // "nginx_site", "container", "image", or empty for parent services
 }
 
 impl ServicesWidget {
@@ -51,8 +50,6 @@ impl ServicesWidget {
         if metric_name.starts_with("service_") {
             if let Some(end_pos) = metric_name
                 .rfind("_status")
-                .or_else(|| metric_name.rfind("_memory_mb"))
-                .or_else(|| metric_name.rfind("_disk_gb"))
                 .or_else(|| metric_name.rfind("_latency_ms"))
             {
                 let service_part = &metric_name[8..end_pos]; // Remove "service_" prefix
@@ -75,36 +72,8 @@ impl ServicesWidget {
         None
     }
 
-    /// Format disk size with appropriate units (kB/MB/GB)
-    fn format_disk_size(size_gb: f32) -> String {
-        let size_mb = size_gb * 1024.0; // Convert GB to MB
-
-        if size_mb >= 1024.0 {
-            // Show as GB
-            format!("{:.1}GB", size_gb)
-        } else if size_mb >= 1.0 {
-            // Show as MB
-            format!("{:.0}MB", size_mb)
-        } else if size_mb >= 0.001 {
-            // Convert to kB
-            let size_kb = size_mb * 1024.0;
-            format!("{:.0}kB", size_kb)
-        } else {
-            // Show very small sizes as bytes
-            let size_bytes = size_mb * 1024.0 * 1024.0;
-            format!("{:.0}B", size_bytes)
-        }
-    }
-
     /// Format parent service line - returns text without icon for span formatting
     fn format_parent_service_line(&self, name: &str, info: &ServiceInfo) -> String {
-        let memory_str = info
-            .memory_mb
-            .map_or("0M".to_string(), |m| format!("{:.0}M", m));
-        let disk_str = info
-            .disk_gb
-            .map_or("0".to_string(), |d| Self::format_disk_size(d));
-
         // Truncate long service names to fit layout (account for icon space)
         let short_name = if name.len() > 22 {
             format!("{}...", &name[..19])
@@ -124,8 +93,8 @@ impl ServicesWidget {
         };
 
         format!(
-            "{:<23} {:<10} {:<8} {:<8}",
-            short_name, status_str, memory_str, disk_str
+            "{:<23} {:<10}",
+            short_name, status_str
         )
     }
 
@@ -179,6 +148,35 @@ impl ServicesWidget {
         };
         let tree_symbol = if is_last { "└─" } else { "├─" };
 
+        // Docker images use docker whale icon
+        if info.service_type == "image" {
+            vec![
+                // Indentation and tree prefix
+                ratatui::text::Span::styled(
+                    format!("  {} ", tree_symbol),
+                    Typography::tree(),
+                ),
+                // Docker icon (simple character for performance)
+                ratatui::text::Span::styled(
+                    "D ".to_string(),
+                    Style::default().fg(Theme::highlight()).bg(Theme::background()),
+                ),
+                // Service name
+                ratatui::text::Span::styled(
+                    format!("{:<18} ", short_name),
+                    Style::default()
+                        .fg(Theme::secondary_text())
+                        .bg(Theme::background()),
+                ),
+                // Status/metrics text
+                ratatui::text::Span::styled(
+                    status_str,
+                    Style::default()
+                        .fg(Theme::secondary_text())
+                        .bg(Theme::background()),
+                ),
+            ]
+        } else {
             vec![
                 // Indentation and tree prefix
                 ratatui::text::Span::styled(
@@ -206,6 +204,7 @@ impl ServicesWidget {
                 ),
             ]
         }
+    }
 
     /// Move selection up
     pub fn select_previous(&mut self) {
@@ -278,10 +277,9 @@ impl Widget for ServicesWidget {
         for service in &agent_data.services {
             // Store parent service
             let parent_info = ServiceInfo {
-                memory_mb: Some(service.memory_mb),
-                disk_gb: Some(service.disk_gb),
                 metrics: Vec::new(), // Parent services don't have custom metrics
                 widget_status: service.service_status,
+                service_type: String::new(), // Parent services have no type
             };
             self.parent_services.insert(service.name.clone(), parent_info);
 
@@ -295,10 +293,9 @@ impl Widget for ServicesWidget {
                         .collect();
 
                     let sub_info = ServiceInfo {
-                        memory_mb: None, // Not used for sub-services
-                        disk_gb: None,   // Not used for sub-services
                         metrics,
                         widget_status: sub_service.service_status,
+                        service_type: sub_service.service_type.clone(),
                     };
                     sub_list.push((sub_service.name.clone(), sub_info));
                 }
@@ -338,22 +335,13 @@ impl ServicesWidget {
                             self.parent_services
                                 .entry(parent_service)
                                 .or_insert(ServiceInfo {
-                                    memory_mb: None,
-                                    disk_gb: None,
                                     metrics: Vec::new(),
                                     widget_status: Status::Unknown,
+                                    service_type: String::new(),
                                 });
 
                         if metric.name.ends_with("_status") {
                             service_info.widget_status = metric.status;
-                        } else if metric.name.ends_with("_memory_mb") {
-                            if let Some(memory) = metric.value.as_f32() {
-                                service_info.memory_mb = Some(memory);
-                            }
-                        } else if metric.name.ends_with("_disk_gb") {
-                            if let Some(disk) = metric.value.as_f32() {
-                                service_info.disk_gb = Some(disk);
-                            }
                         }
                     }
                     Some(sub_name) => {
@@ -373,10 +361,9 @@ impl ServicesWidget {
                             sub_service_list.push((
                                 sub_name.clone(),
                                 ServiceInfo {
-                                    memory_mb: None,
-                                    disk_gb: None,
                                     metrics: Vec::new(),
                                     widget_status: Status::Unknown,
+                                    service_type: String::new(), // Unknown type in legacy path
                                 },
                             ));
                             &mut sub_service_list.last_mut().unwrap().1
@@ -384,14 +371,6 @@ impl ServicesWidget {
 
                         if metric.name.ends_with("_status") {
                             sub_service_info.widget_status = metric.status;
-                        } else if metric.name.ends_with("_memory_mb") {
-                            if let Some(memory) = metric.value.as_f32() {
-                                sub_service_info.memory_mb = Some(memory);
-                            }
-                        } else if metric.name.ends_with("_disk_gb") {
-                            if let Some(disk) = metric.value.as_f32() {
-                                sub_service_info.disk_gb = Some(disk);
-                            }
                         }
                     }
                 }

shared/Cargo.toml

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

shared/src/agent_data.rs

@@ -136,8 +136,6 @@ pub struct PoolDriveData {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ServiceData {
     pub name: String,
-    pub memory_mb: f32,
-    pub disk_gb: f32,
     pub user_stopped: bool,
     pub service_status: Status,
     pub sub_services: Vec<SubServiceData>,
@@ -149,6 +147,9 @@ pub struct SubServiceData {
     pub name: String,
     pub service_status: Status,
     pub metrics: Vec<SubServiceMetric>,
+    /// Type of sub-service: "nginx_site", "container", "image"
+    #[serde(default)]
+    pub service_type: String,
 }
 
 /// Individual metric for a sub-service