Add machine deletion API with uninstall command support

- Add AdminCommand message to protobuf (uninstall, restart, update)
- Add DELETE /api/machines/:agent_id endpoint with options:
  - ?uninstall=true - send uninstall command to online agent
  - ?export=true - return session history before deletion
- Add GET /api/machines/:agent_id/history endpoint for history export
- Add GET /api/machines endpoint to list all machines
- Handle AdminCommand in agent session handler
- Handle ADMIN_UNINSTALL error in agent main loop to trigger uninstall

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

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

server/src/main.rs

@@ -18,8 +18,8 @@ pub mod proto {
 use anyhow::Result;
 use axum::{
     Router,
-    routing::{get, post},
-    extract::{Path, State, Json},
+    routing::{get, post, delete},
+    extract::{Path, State, Json, Query},
     response::{Html, IntoResponse},
     http::StatusCode,
 };
@@ -122,7 +122,13 @@ async fn main() -> Result<()> {
         // REST API - Sessions
         .route("/api/sessions", get(list_sessions))
         .route("/api/sessions/:id", get(get_session))
-        .route("/api/sessions/:id", axum::routing::delete(disconnect_session))
+        .route("/api/sessions/:id", delete(disconnect_session))
+
+        // REST API - Machines
+        .route("/api/machines", get(list_machines))
+        .route("/api/machines/:agent_id", get(get_machine))
+        .route("/api/machines/:agent_id", delete(delete_machine))
+        .route("/api/machines/:agent_id/history", get(get_machine_history))
         
         // HTML page routes (clean URLs)
         .route("/login", get(serve_login))
@@ -237,6 +243,129 @@ async fn disconnect_session(
     }
 }
 
+// Machine API handlers
+
+async fn list_machines(
+    State(state): State<AppState>,
+) -> Result<Json<Vec<api::MachineInfo>>, (StatusCode, &'static str)> {
+    let db = state.db.as_ref()
+        .ok_or((StatusCode::SERVICE_UNAVAILABLE, "Database not available"))?;
+
+    let machines = db::machines::get_all_machines(db.pool()).await
+        .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, "Database error"))?;
+
+    Ok(Json(machines.into_iter().map(api::MachineInfo::from).collect()))
+}
+
+async fn get_machine(
+    State(state): State<AppState>,
+    Path(agent_id): Path<String>,
+) -> Result<Json<api::MachineInfo>, (StatusCode, &'static str)> {
+    let db = state.db.as_ref()
+        .ok_or((StatusCode::SERVICE_UNAVAILABLE, "Database not available"))?;
+
+    let machine = db::machines::get_machine_by_agent_id(db.pool(), &agent_id).await
+        .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, "Database error"))?
+        .ok_or((StatusCode::NOT_FOUND, "Machine not found"))?;
+
+    Ok(Json(api::MachineInfo::from(machine)))
+}
+
+async fn get_machine_history(
+    State(state): State<AppState>,
+    Path(agent_id): Path<String>,
+) -> Result<Json<api::MachineHistory>, (StatusCode, &'static str)> {
+    let db = state.db.as_ref()
+        .ok_or((StatusCode::SERVICE_UNAVAILABLE, "Database not available"))?;
+
+    // Get machine
+    let machine = db::machines::get_machine_by_agent_id(db.pool(), &agent_id).await
+        .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, "Database error"))?
+        .ok_or((StatusCode::NOT_FOUND, "Machine not found"))?;
+
+    // Get sessions for this machine
+    let sessions = db::sessions::get_sessions_for_machine(db.pool(), machine.id).await
+        .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, "Database error"))?;
+
+    // Get events for this machine
+    let events = db::events::get_events_for_machine(db.pool(), machine.id).await
+        .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, "Database error"))?;
+
+    let history = api::MachineHistory {
+        machine: api::MachineInfo::from(machine),
+        sessions: sessions.into_iter().map(api::SessionRecord::from).collect(),
+        events: events.into_iter().map(api::EventRecord::from).collect(),
+        exported_at: chrono::Utc::now().to_rfc3339(),
+    };
+
+    Ok(Json(history))
+}
+
+async fn delete_machine(
+    State(state): State<AppState>,
+    Path(agent_id): Path<String>,
+    Query(params): Query<api::DeleteMachineParams>,
+) -> Result<Json<api::DeleteMachineResponse>, (StatusCode, &'static str)> {
+    let db = state.db.as_ref()
+        .ok_or((StatusCode::SERVICE_UNAVAILABLE, "Database not available"))?;
+
+    // Get machine first
+    let machine = db::machines::get_machine_by_agent_id(db.pool(), &agent_id).await
+        .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, "Database error"))?
+        .ok_or((StatusCode::NOT_FOUND, "Machine not found"))?;
+
+    // Export history if requested
+    let history = if params.export {
+        let sessions = db::sessions::get_sessions_for_machine(db.pool(), machine.id).await
+            .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, "Database error"))?;
+        let events = db::events::get_events_for_machine(db.pool(), machine.id).await
+            .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, "Database error"))?;
+
+        Some(api::MachineHistory {
+            machine: api::MachineInfo::from(machine.clone()),
+            sessions: sessions.into_iter().map(api::SessionRecord::from).collect(),
+            events: events.into_iter().map(api::EventRecord::from).collect(),
+            exported_at: chrono::Utc::now().to_rfc3339(),
+        })
+    } else {
+        None
+    };
+
+    // Send uninstall command if requested and agent is online
+    let mut uninstall_sent = false;
+    if params.uninstall {
+        // Find session for this agent
+        if let Some(session) = state.sessions.get_session_by_agent(&agent_id).await {
+            if session.is_online {
+                uninstall_sent = state.sessions.send_admin_command(
+                    session.id,
+                    proto::AdminCommandType::AdminUninstall,
+                    "Deleted by administrator",
+                ).await;
+                if uninstall_sent {
+                    info!("Sent uninstall command to agent {}", agent_id);
+                }
+            }
+        }
+    }
+
+    // Remove from session manager
+    state.sessions.remove_agent(&agent_id).await;
+
+    // Delete from database (cascades to sessions and events)
+    db::machines::delete_machine(db.pool(), &agent_id).await
+        .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, "Failed to delete machine"))?;
+
+    info!("Deleted machine {} (uninstall_sent: {})", agent_id, uninstall_sent);
+
+    Ok(Json(api::DeleteMachineResponse {
+        success: true,
+        message: format!("Machine {} deleted", machine.hostname),
+        uninstall_sent,
+        history,
+    }))
+}
+
 // Static page handlers
 async fn serve_login() -> impl IntoResponse {
     match tokio::fs::read_to_string("static/login.html").await {