Implement robust auto-update system for GuruConnect agent

Features:
- Agent checks for updates periodically (hourly) during idle
- Admin can trigger immediate updates via dashboard "Update Agent" button
- Silent updates with in-place binary replacement (no reboot required)
- SHA-256 checksum verification before installation
- Semantic version comparison

Server changes:
- New releases table for tracking available versions
- GET /api/version endpoint for agent polling (unauthenticated)
- POST /api/machines/:id/update endpoint for admin push updates
- Release management API (/api/releases CRUD)
- Track agent_version in machine status

Agent changes:
- New update.rs module with download/verify/install/restart logic
- Handle ADMIN_UPDATE WebSocket command for push updates
- --post-update flag for cleanup after successful update
- Periodic update check in idle loop (persistent agents only)
- agent_version included in AgentStatus messages

Dashboard changes:
- Version display in machine detail panel
- "Update Agent" button for each connected machine

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

agent/src/session/mod.rs

@@ -47,6 +47,8 @@ use std::time::{Duration, Instant};
 const HEARTBEAT_INTERVAL: Duration = Duration::from_secs(30);
 // Status report interval (60 seconds)
 const STATUS_INTERVAL: Duration = Duration::from_secs(60);
+// Update check interval (1 hour)
+const UPDATE_CHECK_INTERVAL: Duration = Duration::from_secs(3600);
 
 /// Session manager handles the remote control session
 pub struct SessionManager {
@@ -172,6 +174,7 @@ impl SessionManager {
             uptime_secs: self.start_time.elapsed().as_secs() as i64,
             display_count: self.get_display_count(),
             is_streaming: self.state == SessionState::Streaming,
+            agent_version: crate::build_info::short_version(),
         };
 
         let msg = Message {
@@ -215,6 +218,7 @@ impl SessionManager {
         let mut last_heartbeat = Instant::now();
         let mut last_status = Instant::now();
         let mut last_frame_time = Instant::now();
+        let mut last_update_check = Instant::now();
         let frame_interval = Duration::from_millis(1000 / self.config.capture.fps as u64);
 
         // Main loop
@@ -309,7 +313,7 @@ impl SessionManager {
                 }
 
                 // Handle other messages (input events, disconnect, etc.)
-                self.handle_message(msg)?;
+                self.handle_message(msg).await?;
             }
 
             // Check for outgoing chat messages
@@ -347,6 +351,26 @@ impl SessionManager {
                         }
                     }
 
+                    // Periodic update check (only for persistent agents, not support sessions)
+                    if self.config.support_code.is_none() && last_update_check.elapsed() >= UPDATE_CHECK_INTERVAL {
+                        last_update_check = Instant::now();
+                        let server_url = self.config.server_url.replace("/ws/agent", "").replace("wss://", "https://").replace("ws://", "http://");
+                        match crate::update::check_for_update(&server_url).await {
+                            Ok(Some(version_info)) => {
+                                tracing::info!("Update available: {} -> {}", crate::build_info::VERSION, version_info.latest_version);
+                                if let Err(e) = crate::update::perform_update(&version_info).await {
+                                    tracing::error!("Auto-update failed: {}", e);
+                                }
+                            }
+                            Ok(None) => {
+                                tracing::debug!("No update available");
+                            }
+                            Err(e) => {
+                                tracing::debug!("Update check failed: {}", e);
+                            }
+                        }
+                    }
+
                     // Longer sleep in idle mode to reduce CPU usage
                     tokio::time::sleep(Duration::from_millis(100)).await;
                 }
@@ -401,7 +425,7 @@ impl SessionManager {
     }
 
     /// Handle incoming message from server
-    fn handle_message(&mut self, msg: Message) -> Result<()> {
+    async fn handle_message(&mut self, msg: Message) -> Result<()> {
         match msg.payload {
             Some(message::Payload::MouseEvent(mouse)) => {
                 if let Some(input) = self.input.as_mut() {
@@ -468,7 +492,25 @@ impl SessionManager {
                         return Err(anyhow::anyhow!("ADMIN_RESTART: {}", cmd.reason));
                     }
                     Some(AdminCommandType::AdminUpdate) => {
-                        tracing::info!("Update command received (not implemented)");
+                        tracing::info!("Update command received from server: {}", cmd.reason);
+                        // Trigger update check and perform update if available
+                        // The server URL is derived from the config
+                        let server_url = self.config.server_url.replace("/ws/agent", "").replace("wss://", "https://").replace("ws://", "http://");
+                        match crate::update::check_for_update(&server_url).await {
+                            Ok(Some(version_info)) => {
+                                tracing::info!("Update available: {} -> {}", crate::build_info::VERSION, version_info.latest_version);
+                                if let Err(e) = crate::update::perform_update(&version_info).await {
+                                    tracing::error!("Update failed: {}", e);
+                                }
+                                // If we get here, the update failed (perform_update exits on success)
+                            }
+                            Ok(None) => {
+                                tracing::info!("Already running latest version");
+                            }
+                            Err(e) => {
+                                tracing::error!("Failed to check for updates: {}", e);
+                            }
+                        }
                     }
                     None => {
                         tracing::warn!("Unknown admin command: {}", cmd.command);