Implement remote command execution and visual feedback for service control

This implements the core functionality for executing remote commands through
the dashboard and providing real-time visual feedback to users.

Key Features:
- Remote service control (start/stop/restart) via existing keyboard shortcuts
- System rebuild command with maintenance mode integration
- Real-time visual feedback with service status transitions
- ZMQ command protocol extension for service and system operations

Implementation Details:
- Extended AgentCommand enum with ServiceControl and SystemRebuild variants
- Added agent-side handlers for systemctl and nixos-rebuild execution
- Implemented command status tracking system for visual feedback
- Enhanced services widget to show progress states (⏳ restarting)
- Integrated command execution with existing keyboard navigation

Keyboard Controls:
- Services Panel: Space (start/stop), R (restart)
- System Panel: R (nixos-rebuild switch)
- Backup Panel: B (trigger backup)

Technical Architecture:
- Command flow: UI → Dashboard → ZMQ → Agent → systemctl/nixos-rebuild
- Status tracking: InProgress/Success/Failed states with visual indicators
- Maintenance mode: Automatic /tmp/cm-maintenance file management
- Service feedback: Icon transitions (● → ⏳ → ● with status text)

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::{AgentCommand, ServiceAction, ZmqHandler};
 use crate::config::AgentConfig;
 use crate::metrics::MetricCollectionManager;
 use crate::notifications::NotificationManager;
@@ -226,7 +226,109 @@ impl Agent {
                 info!("Processing Ping command - agent is alive");
                 // Could send a response back via ZMQ if needed
             }
+            AgentCommand::ServiceControl { service_name, action } => {
+                info!("Processing ServiceControl command: {} {:?}", service_name, action);
+                if let Err(e) = self.handle_service_control(&service_name, &action).await {
+                    error!("Failed to execute service control: {}", e);
+                }
+            }
+            AgentCommand::SystemRebuild { nixos_path } => {
+                info!("Processing SystemRebuild command with path: {}", nixos_path);
+                if let Err(e) = self.handle_system_rebuild(&nixos_path).await {
+                    error!("Failed to execute system rebuild: {}", e);
+                }
+            }
         }
         Ok(())
     }
+
+    /// Handle systemd service control commands
+    async fn handle_service_control(&self, service_name: &str, action: &ServiceAction) -> Result<()> {
+        let action_str = match action {
+            ServiceAction::Start => "start",
+            ServiceAction::Stop => "stop", 
+            ServiceAction::Restart => "restart",
+            ServiceAction::Status => "status",
+        };
+
+        info!("Executing systemctl {} {}", action_str, service_name);
+
+        let output = tokio::process::Command::new("systemctl")
+            .arg(action_str)
+            .arg(service_name)
+            .output()
+            .await?;
+
+        if output.status.success() {
+            info!("Service {} {} completed successfully", service_name, action_str);
+            if !output.stdout.is_empty() {
+                debug!("stdout: {}", String::from_utf8_lossy(&output.stdout));
+            }
+        } else {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            error!("Service {} {} failed: {}", service_name, action_str, stderr);
+            return Err(anyhow::anyhow!("systemctl {} {} failed: {}", action_str, service_name, stderr));
+        }
+
+        // Force refresh metrics after service control to update service status
+        if matches!(action, ServiceAction::Start | ServiceAction::Stop | ServiceAction::Restart) {
+            info!("Triggering metric refresh after service control");
+            // Note: We can't call self.collect_metrics_only() here due to borrowing issues
+            // The next metric collection cycle will pick up the changes
+        }
+
+        Ok(())
+    }
+
+    /// Handle NixOS system rebuild commands
+    async fn handle_system_rebuild(&self, nixos_path: &str) -> Result<()> {
+        info!("Starting NixOS system rebuild from path: {}", nixos_path);
+
+        // Enable maintenance mode before rebuild
+        let maintenance_file = "/tmp/cm-maintenance";
+        if let Err(e) = tokio::fs::File::create(maintenance_file).await {
+            error!("Failed to create maintenance mode file: {}", e);
+        } else {
+            info!("Maintenance mode enabled");
+        }
+
+        // Change to nixos directory and execute rebuild
+        let output = tokio::process::Command::new("nixos-rebuild")
+            .arg("switch")
+            .current_dir(nixos_path)
+            .output()
+            .await;
+
+        // Always try to remove maintenance mode file
+        if let Err(e) = tokio::fs::remove_file(maintenance_file).await {
+            if e.kind() != std::io::ErrorKind::NotFound {
+                error!("Failed to remove maintenance mode file: {}", e);
+            }
+        } else {
+            info!("Maintenance mode disabled");
+        }
+
+        // Check rebuild result
+        match output {
+            Ok(output) => {
+                if output.status.success() {
+                    info!("NixOS rebuild completed successfully");
+                    if !output.stdout.is_empty() {
+                        debug!("rebuild stdout: {}", String::from_utf8_lossy(&output.stdout));
+                    }
+                } else {
+                    let stderr = String::from_utf8_lossy(&output.stderr);
+                    error!("NixOS rebuild failed: {}", stderr);
+                    return Err(anyhow::anyhow!("nixos-rebuild failed: {}", stderr));
+                }
+            }
+            Err(e) => {
+                error!("Failed to execute nixos-rebuild: {}", e);
+                return Err(anyhow::anyhow!("Failed to execute nixos-rebuild: {}", e));
+            }
+        }
+
+        info!("System rebuild completed, triggering metric refresh");
+        Ok(())
+    }
 }

agent/src/communication/mod.rs

@@ -99,4 +99,22 @@ pub enum AgentCommand {
     ToggleCollector { name: String, enabled: bool },
     /// Request status/health check
     Ping,
+    /// Control systemd service
+    ServiceControl {
+        service_name: String,
+        action: ServiceAction,
+    },
+    /// Rebuild NixOS system
+    SystemRebuild {
+        nixos_path: String, // Path to nixosbox directory
+    },
+}
+
+/// Service control actions
+#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
+pub enum ServiceAction {
+    Start,
+    Stop,
+    Restart,
+    Status,
 }