refactor(#1456): extract dashboard approval + diff endpoints into dashboard/approvals.rs

hive-c0re/src/dashboard/approvals.rs

@@ -0,0 +1,229 @@
+//! Approval endpoints + diff machinery for the dashboard.
+//!
+//! Approve/deny actions, the orphan-approval GC sweep used by the
+//! `/api/state` builder, and the unified-diff endpoints (on-demand
+//! `/api/approval-diff/{id}` against a chosen base, plus the `pub(crate)`
+//! `approval_diff` the manager-socket handler pre-computes at submit time).
+
+use std::path::Path;
+
+use anyhow::{Context, Result};
+use axum::{
+    extract::{Form, Path as AxumPath, State},
+    http::StatusCode,
+    response::{IntoResponse, Response},
+};
+use hive_sh4re::Approval;
+use serde::Deserialize;
+
+use super::{AppState, error_response};
+use crate::actions;
+use crate::coordinator::Coordinator;
+use crate::lifecycle;
+
+pub(super) async fn post_approve(
+    State(state): State<AppState>,
+    AxumPath(id): AxumPath<i64>,
+) -> Response {
+    match actions::approve(state.coord.clone(), id).await {
+        // 200 instead of 303 — `actions::approve` fires
+        // `ApprovalResolved` (success path) or the eventual failure
+        // event, both of which the dashboard's derived store applies
+        // live. The matching form carries `data-no-refresh`.
+        Ok(()) => (StatusCode::OK, "ok").into_response(),
+        Err(e) => error_response(&format!("approve {id} failed: {e:#}")),
+    }
+}
+
+#[derive(Deserialize, Default)]
+pub(super) struct DenyForm {
+    #[serde(default)]
+    note: Option<String>,
+}
+
+pub(super) async fn post_deny(
+    State(state): State<AppState>,
+    AxumPath(id): AxumPath<i64>,
+    Form(form): Form<DenyForm>,
+) -> Response {
+    let note = form
+        .note
+        .as_deref()
+        .map(str::trim)
+        .filter(|s| !s.is_empty());
+    match actions::deny(&state.coord, id, note).await {
+        Ok(()) => (StatusCode::OK, "ok").into_response(),
+        Err(e) => error_response(&format!("deny {id} failed: {e:#}")),
+    }
+}
+
+/// Filter out approvals whose agent state dir was wiped out from under us
+/// (e.g. by a test script's cleanup). Marks them failed so they fall out of
+/// `pending` on next render.
+pub(super) fn gc_orphans(coord: &Coordinator, approvals: Vec<Approval>) -> Vec<Approval> {
+    approvals
+        .into_iter()
+        .filter(|a| {
+            // Spawn and InitConfig approvals are for not-yet-existent agents;
+            // the proposed dir is supposed to be missing.
+            if matches!(
+                a.kind,
+                hive_sh4re::ApprovalKind::Spawn | hive_sh4re::ApprovalKind::InitConfig
+            ) {
+                return true;
+            }
+            if Coordinator::agent_proposed_dir(&a.agent).exists() {
+                true
+            } else {
+                let note = "agent state dir missing";
+                let _ = coord.approvals.mark_failed(a.id, note);
+                tracing::info!(id = a.id, agent = %a.agent, "auto-failed orphan approval");
+                let sha_short = a
+                    .fetched_sha
+                    .as_deref()
+                    .map(|s| s[..s.len().min(12)].to_owned());
+                coord.emit_approval_resolved(
+                    a.id,
+                    &a.agent,
+                    "apply_commit",
+                    sha_short,
+                    "failed",
+                    Some(note.to_owned()),
+                    a.description.clone(),
+                );
+                false
+            }
+        })
+        .collect()
+}
+
+/// Multi-file unified diff between the currently-deployed tree and
+/// the proposal for this approval. Runs against the applied repo
+/// since the canonical proposal commit lives there (manager-side
+/// amendments don't move it). Empty output means proposal == main —
+/// a no-op approval.
+///
+/// `pub(crate)` so the manager-socket handler can pre-compute the
+/// diff once at submission time and embed it in the `ApprovalAdded`
+/// dashboard event (instead of forcing the dashboard to wait a
+/// `/api/state` cycle to see the diff for newly-queued approvals).
+pub(crate) async fn approval_diff(agent: &str, approval_id: i64) -> String {
+    let applied = Coordinator::agent_applied_dir(agent);
+    if !applied.join(".git").exists() {
+        return format!("(no applied git repo at {})", applied.display());
+    }
+    let proposal_ref = format!("refs/tags/proposal/{approval_id}");
+    match git_diff_refs(&applied, "refs/heads/main", &proposal_ref).await {
+        Ok(s) if s.is_empty() => "(proposal matches currently-deployed tree)".to_owned(),
+        Ok(s) => s,
+        Err(e) => format!("(error: {e:#})"),
+    }
+}
+
+async fn git_diff_refs(applied_dir: &Path, base_ref: &str, target_ref: &str) -> Result<String> {
+    let out = lifecycle::git_command()
+        .current_dir(applied_dir)
+        .args(["diff", &format!("{base_ref}..{target_ref}")])
+        .output()
+        .await
+        .with_context(|| format!("spawn `git diff` in {}", applied_dir.display()))?;
+    if !out.status.success() {
+        anyhow::bail!(
+            "git diff {base_ref}..{target_ref} failed: {}",
+            String::from_utf8_lossy(&out.stderr).trim()
+        );
+    }
+    Ok(String::from_utf8_lossy(&out.stdout).into_owned())
+}
+
+/// Numeric ids of `<prefix>/<n>` tags in the applied repo (e.g.
+/// `proposal/3` → `3`). Unparseable suffixes are skipped. Used to
+/// resolve the `approved` / `previous` diff bases for an approval.
+async fn tag_ids(applied_dir: &Path, prefix: &str) -> Vec<i64> {
+    let Ok(out) = lifecycle::git_command()
+        .current_dir(applied_dir)
+        .args(["tag", "-l", &format!("{prefix}/*")])
+        .output()
+        .await
+    else {
+        return Vec::new();
+    };
+    if !out.status.success() {
+        return Vec::new();
+    }
+    let strip = format!("{prefix}/");
+    String::from_utf8_lossy(&out.stdout)
+        .lines()
+        .filter_map(|l| l.trim().strip_prefix(&strip))
+        .filter_map(|s| s.parse::<i64>().ok())
+        .collect()
+}
+
+#[derive(Deserialize)]
+pub(super) struct DiffBaseQuery {
+    /// `applied` (running tree — default), `approved` (most recent
+    /// earlier approved proposal), or `previous` (the prior queued
+    /// proposal for this agent).
+    base: Option<String>,
+}
+
+/// On-demand unified diff for one `ApplyCommit` approval against a
+/// chosen base. `applied` = `applied/main` (what's running);
+/// `approved` = the most recent earlier `approved/<n>` tag (the last
+/// proposal the operator OK'd, even if its build then failed);
+/// `previous` = the prior queued `proposal/<n>` (the incremental
+/// delta when the manager chains proposals). Returns the raw diff
+/// text — the dashboard classifies lines client-side.
+pub(super) async fn get_approval_diff(
+    State(state): State<AppState>,
+    AxumPath(id): AxumPath<i64>,
+    axum::extract::Query(q): axum::extract::Query<DiffBaseQuery>,
+) -> Response {
+    let base = q.base.as_deref().unwrap_or("applied");
+    let approval = match state.coord.approvals.get(id) {
+        Ok(Some(a)) => a,
+        Ok(None) => return error_response(&format!("approval {id} not found")),
+        Err(e) => return error_response(&format!("approval {id}: {e:#}")),
+    };
+    if !matches!(approval.kind, hive_sh4re::ApprovalKind::ApplyCommit) {
+        return error_response("spawn approvals carry no commit to diff");
+    }
+    let applied = Coordinator::agent_applied_dir(&approval.agent);
+    if !applied.join(".git").exists() {
+        return plain_text(format!("(no applied git repo at {})", applied.display()));
+    }
+    let target = format!("refs/tags/proposal/{id}");
+    let base_ref = match base {
+        "applied" => Some("refs/heads/main".to_owned()),
+        "approved" => {
+            let ids = tag_ids(&applied, "approved").await;
+            ids.into_iter()
+                .filter(|&n| n != id)
+                .max()
+                .map(|n| format!("refs/tags/approved/{n}"))
+        }
+        "previous" => {
+            let ids = tag_ids(&applied, "proposal").await;
+            ids.into_iter()
+                .filter(|&n| n < id)
+                .max()
+                .map(|n| format!("refs/tags/proposal/{n}"))
+        }
+        other => return error_response(&format!("unknown diff base {other:?}")),
+    };
+    let Some(base_ref) = base_ref else {
+        return plain_text(match base {
+            "approved" => "(no earlier approved proposal to diff against)".to_owned(),
+            _ => "(no previous proposal to diff against)".to_owned(),
+        });
+    };
+    match git_diff_refs(&applied, &base_ref, &target).await {
+        Ok(s) if s.is_empty() => plain_text("(identical — no changes vs this base)".to_owned()),
+        Ok(s) => plain_text(s),
+        Err(e) => error_response(&format!("git diff: {e:#}")),
+    }
+}
+
+fn plain_text(body: String) -> Response {
+    (StatusCode::OK, body).into_response()
+}