omniterm 0.2.29

use axum::{
    Json, Router,
    extract::{ConnectInfo, Path, Query, State},
    http::StatusCode,
    response::IntoResponse,
    routing::{delete, get, post},
};
use serde_json::json;
use std::net::SocketAddr;
use std::time::Duration;
use uuid::Uuid;

use crate::AppState;
use crate::acp::AcpClient;
use crate::models::agent::{Agent, AgentEnvVar, CreateAgent, UpdateAgent};
use tracing;

pub fn routes() -> Router<AppState> {
    Router::new()
        .route("/agents", get(list_agents).post(create_agent))
        .route("/agents/test-raw", post(test_agent_raw))
        .route("/agents/{id}", get(get_agent).put(update_agent).delete(delete_agent))
        .route("/agents/{id}/test", post(test_agent))
        .route("/agents/{id}/acp-sessions/{acp_session_id}", delete(purge_agent_acp_session))
}

/// `DELETE /agents/{id}/acp-sessions/{acp_session_id}` 的查询参数：会话的
/// `workspace_path`（agent 侧按 cwd 组织会话历史，必须与原会话一致）。
#[derive(Debug, serde::Deserialize)]
struct PurgeAcpSessionQuery {
    cwd: String,
}

/// 请求 agent 删除**它自己那份**会话记录（ACP `session/delete`）：临时拉起一个
/// 短命 agent 进程（不注册 supervisor，spawn / RPC 各 15s 预算），现场 gate
/// 能力位后补发，随后立即收尾。
///
/// 「删除会话」两段式的第二段：`DELETE /sessions/{id}?delete_agent_side=true` 在
/// 进程不驻留时立即返回 `agent_side:"pending"`，由客户端带着会话行的
/// `agent_id` / `acp_session_id` / `workspace_path` 补发本请求——用户先拿到
/// 「已删除」，agent 侧结果稍后如实补报；无服务端状态（不做 job 表 / 轮询）。
///
/// best-effort 语义与删会话路径一致：能力未声明 / 拉起失败 / RPC 失败都回
/// `agent_side:"skipped"` + 200（不报错码），由前端如实告知「未能删除」；
/// agent 配置不存在 / cwd 不是目录属请求错误，回 404 / 400。
async fn purge_agent_acp_session(
    State(state): State<AppState>,
    Path((id, acp_session_id)): Path<(String, String)>,
    Query(query): Query<PurgeAcpSessionQuery>,
) -> impl IntoResponse {
    let Some(agent) = load_agent(&state.db, &id).await else {
        return (StatusCode::NOT_FOUND, Json(json!({ "error": "agent not found" })));
    };
    let cwd = std::path::PathBuf::from(&query.cwd);
    if !cwd.is_dir() {
        return (
            StatusCode::BAD_REQUEST,
            Json(json!({ "error": format!("cwd is not an existing directory: {}", query.cwd) })),
        );
    }

    let agent_side = crate::api::sessions::delete_agent_side_record_via_ephemeral_spawn(
        &state,
        agent,
        cwd,
        &acp_session_id,
    )
    .await;
    (StatusCode::OK, Json(json!({ "ok": true, "agent_side": agent_side.as_str() })))
}

#[derive(sqlx::FromRow)]
struct AgentRow {
    id: String,
    display_name: String,
    command: String,
    args: String,
    env: String,
    npm_package: Option<String>,
    created_at: String,
    updated_at: String,
}

impl AgentRow {
    fn into_agent(self) -> Agent {
        let args: Vec<String> = serde_json::from_str(&self.args).unwrap_or_default();
        let env: Vec<AgentEnvVar> = serde_json::from_str(&self.env).unwrap_or_default();
        Agent {
            id: self.id,
            display_name: self.display_name,
            command: self.command,
            args,
            env,
            npm_package: self.npm_package,
            created_at: self.created_at,
            updated_at: self.updated_at,
        }
    }
}

async fn list_agents(State(state): State<AppState>) -> impl IntoResponse {
    let rows: Vec<AgentRow> = sqlx::query_as("SELECT * FROM agents ORDER BY created_at DESC")
        .fetch_all(&state.db)
        .await
        .unwrap_or_default();

    let agents: Vec<Agent> = rows.into_iter().map(AgentRow::into_agent).collect();
    Json(json!(agents))
}

async fn get_agent(State(state): State<AppState>, Path(id): Path<String>) -> impl IntoResponse {
    let row: Option<AgentRow> = sqlx::query_as("SELECT * FROM agents WHERE id = ?")
        .bind(&id)
        .fetch_optional(&state.db)
        .await
        .unwrap();

    match row {
        Some(r) => (StatusCode::OK, Json(json!(r.into_agent()))),
        None => (StatusCode::NOT_FOUND, Json(json!({ "error": "not found" }))),
    }
}

async fn create_agent(
    State(state): State<AppState>,
    ConnectInfo(addr): ConnectInfo<SocketAddr>,
    Json(req): Json<CreateAgent>,
) -> impl IntoResponse {
    let id = req.id.unwrap_or_else(|| Uuid::new_v4().to_string());
    let now = chrono::Utc::now().to_rfc3339();
    let args_json = serde_json::to_string(&req.args).unwrap_or_else(|_| "[]".into());
    let env_json = serde_json::to_string(&req.env).unwrap_or_else(|_| "[]".into());

    let result = sqlx::query(
        "INSERT INTO agents (id, display_name, command, args, env, npm_package, created_at, updated_at) \
         VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
    )
    .bind(&id)
    .bind(&req.display_name)
    .bind(&req.command)
    .bind(&args_json)
    .bind(&env_json)
    .bind(&req.npm_package)
    .bind(&now)
    .bind(&now)
    .execute(&state.db)
    .await;

    if let Err(e) = result {
        return (StatusCode::BAD_REQUEST, Json(json!({ "error": e.to_string() })));
    }

    // 审计（S5）：agent 配置决定后续每条会话会 spawn 什么进程、注入什么
    // 环境变量（可能含密钥名），改动它是「未来所有会话的行为」变更，必留痕。
    // detail 记命令与 env 的**键名**（不含值——§S3 敏感数据不落库）。
    // 注意边界：command 是自由文本、原样落库，`--token=sk-…` 这类形态会把
    // 凭据写进 detail。单人工具自选自输，不做通用 flag 掩码（过度设计）；
    // 若将来 agent 配置可共享/导入，必须补。
    let ctx = crate::api::audit::AuditContext::from_ip(Some(addr.ip()), Some("agents".into()));
    let detail = json!({
        "command": req.command.clone(),
        "env_keys": req.env.iter().map(|e| e.key.clone()).collect::<Vec<_>>(),
    })
    .to_string();
    crate::api::audit::record(
        &state.db,
        &ctx,
        crate::api::audit::AuditAction::AgentCreate,
        &id,
        Some(&detail),
    )
    .await;

    let agent = Agent {
        id,
        display_name: req.display_name,
        command: req.command,
        args: req.args,
        env: req.env,
        npm_package: req.npm_package,
        created_at: now.clone(),
        updated_at: now,
    };

    (StatusCode::CREATED, Json(json!(agent)))
}

async fn update_agent(
    State(state): State<AppState>,
    ConnectInfo(addr): ConnectInfo<SocketAddr>,
    Path(id): Path<String>,
    Json(req): Json<UpdateAgent>,
) -> impl IntoResponse {
    let existing: Option<AgentRow> = sqlx::query_as("SELECT * FROM agents WHERE id = ?")
        .bind(&id)
        .fetch_optional(&state.db)
        .await
        .unwrap();

    let Some(existing) = existing else {
        return (StatusCode::NOT_FOUND, Json(json!({ "error": "not found" })));
    };
    let mut current = existing.into_agent();

    // 被这次请求实际改动的字段名（None 的字段不动）——审计要答的是
    // 「改了什么」，不是「最终值是什么」，后者可从当前 agents 行反推。
    let mut changed: Vec<&str> = Vec::new();

    if let Some(v) = req.display_name {
        current.display_name = v;
        changed.push("display_name");
    }
    if let Some(v) = req.command {
        current.command = v;
        changed.push("command");
    }
    if let Some(v) = req.args {
        current.args = v;
        changed.push("args");
    }
    if let Some(v) = req.env {
        current.env = v;
        changed.push("env");
    }
    if let Some(v) = req.npm_package {
        current.npm_package = v;
        changed.push("npm_package");
    }
    current.updated_at = chrono::Utc::now().to_rfc3339();

    let args_json = serde_json::to_string(&current.args).unwrap_or_else(|_| "[]".into());
    let env_json = serde_json::to_string(&current.env).unwrap_or_else(|_| "[]".into());

    sqlx::query(
        "UPDATE agents SET display_name = ?, command = ?, args = ?, env = ?, npm_package = ?, updated_at = ? WHERE id = ?",
    )
    .bind(&current.display_name)
    .bind(&current.command)
    .bind(&args_json)
    .bind(&env_json)
    .bind(&current.npm_package)
    .bind(&current.updated_at)
    .bind(&id)
    .execute(&state.db)
    .await
    .unwrap();

    // 审计（S5）：同上，agent 配置变更是「未来所有会话的行为」变更。
    // detail 只记字段名与 env 键名，不记值（§S3）。
    let ctx = crate::api::audit::AuditContext::from_ip(Some(addr.ip()), Some("agents".into()));
    let detail = json!({
        "changed": changed,
        "env_keys": current.env.iter().map(|e| e.key.clone()).collect::<Vec<_>>(),
    })
    .to_string();
    crate::api::audit::record(
        &state.db,
        &ctx,
        crate::api::audit::AuditAction::AgentUpdate,
        &id,
        Some(&detail),
    )
    .await;

    (StatusCode::OK, Json(json!(current)))
}

async fn delete_agent(
    State(state): State<AppState>,
    ConnectInfo(addr): ConnectInfo<SocketAddr>,
    Path(id): Path<String>,
) -> impl IntoResponse {
    // Check if any sessions reference this agent
    let session_count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM sessions WHERE agent_id = ?")
        .bind(&id)
        .fetch_one(&state.db)
        .await
        .unwrap_or(0);

    if session_count > 0 {
        return (
            StatusCode::CONFLICT,
            Json(
                json!({ "error": format!("Cannot delete agent: {} session(s) still reference it", session_count) }),
            ),
        );
    }

    let result =
        sqlx::query("DELETE FROM agents WHERE id = ?").bind(&id).execute(&state.db).await.unwrap();

    if result.rows_affected() == 0 {
        return (StatusCode::NOT_FOUND, Json(json!({ "error": "not found" })));
    }

    // 清理该 agent 的全局配置偏好行（foreign_keys 级联本会覆盖，这里显式清理兜底）。
    let _ = crate::acp::config_prefs::clear_agent_prefs(&state.db, &id).await;

    // 审计（S5）：删除 agent 配置会让所有引用它的会话失去 spawn 依据。
    // 上面 session_count>0 的 409 守卫挡住了在用时删除，故能走到这里的
    // 都是「已无会话引用」的删除——这条边界本身也值得留痕。
    let ctx = crate::api::audit::AuditContext::from_ip(Some(addr.ip()), Some("agents".into()));
    crate::api::audit::record(
        &state.db,
        &ctx,
        crate::api::audit::AuditAction::AgentDelete,
        &id,
        None,
    )
    .await;

    (StatusCode::OK, Json(json!({ "ok": true })))
}

/// Load an agent for internal use (e.g. spawning).
pub async fn load_agent(db: &sqlx::SqlitePool, id: &str) -> Option<Agent> {
    let row: Option<AgentRow> = sqlx::query_as("SELECT * FROM agents WHERE id = ?")
        .bind(id)
        .fetch_optional(db)
        .await
        .ok()
        .flatten();
    row.map(AgentRow::into_agent)
}

async fn test_agent(State(state): State<AppState>, Path(id): Path<String>) -> impl IntoResponse {
    let agent = match load_agent(&state.db, &id).await {
        Some(a) => a,
        None => {
            return (StatusCode::NOT_FOUND, Json(json!({ "error": "agent not found" })));
        }
    };

    let cwd = std::env::temp_dir();
    match tokio::time::timeout(
        Duration::from_secs(15),
        AcpClient::spawn_and_connect(agent, cwd, &state.api_keys),
    )
    .await
    {
        Ok(Ok(client)) => {
            client.disconnect().await;
            (StatusCode::OK, Json(json!({ "ok": true })))
        }
        Ok(Err(e)) => {
            (StatusCode::BAD_GATEWAY, Json(json!({ "error": format!("connection failed: {}", e) })))
        }
        Err(_) => {
            // 超时即握手未完成：外层 spawn future 被 drop → abort_tx 释放 →
            // crash watcher abort 连接任务 → crate 的 ChildGuard::drop killpg
            // 进程组（Phase 1 D4 兜底，P2-3；此时无 AcpClient 句柄，omniterm
            // 侧 killpg 够不着，由 crate teardown 收尾）。pid 自报文件由任务内
            // 的 PidFileCleanup 守卫清理。此处 WARN 留痕便于关联现场。
            tracing::warn!(
                agent_id = %id,
                "agent 连接测试超时（15s）：agent 未完成 ACP 握手，已回收其进程组（crate teardown）"
            );
            (StatusCode::GATEWAY_TIMEOUT, Json(json!({ "error": "connection timed out (15s)" })))
        }
    }
}

/// Test an agent configuration without saving it to the database.
/// Accepts a `CreateAgent` body and attempts to spawn + connect.
async fn test_agent_raw(Json(req): Json<CreateAgent>) -> impl IntoResponse {
    let agent = Agent {
        id: "test-raw".to_string(),
        display_name: req.display_name,
        command: req.command,
        args: req.args,
        env: req.env,
        npm_package: req.npm_package,
        created_at: String::new(),
        updated_at: String::new(),
    };

    let cwd = std::env::temp_dir();
    // 超时 WARN 留痕用：agent 随后被 move 进 spawn_and_connect。
    let agent_label = agent.command.clone();
    match tokio::time::timeout(
        Duration::from_secs(15),
        AcpClient::spawn_and_connect(agent, cwd, &std::collections::HashMap::new()),
    )
    .await
    {
        Ok(Ok(client)) => {
            client.disconnect().await;
            (StatusCode::OK, Json(json!({ "ok": true })))
        }
        Ok(Err(e)) => {
            (StatusCode::BAD_GATEWAY, Json(json!({ "error": format!("connection failed: {}", e) })))
        }
        Err(_) => {
            // 同 test_agent：握手超时 → abort_tx 释放 → watcher abort → crate
            // ChildGuard::drop killpg 进程组（P2-3）。留痕。
            tracing::warn!(
                agent_command = %agent_label,
                "agent 连接测试（raw）超时（15s）：agent 未完成 ACP 握手，已回收其进程组（crate teardown）"
            );
            (StatusCode::GATEWAY_TIMEOUT, Json(json!({ "error": "connection timed out (15s)" })))
        }
    }
}

/// `DELETE /agents/{id}/acp-sessions/{acp_session_id}` 的前置校验（成功路径由
/// `api::sessions::ephemeral_agent_delete_tests` 的 fake agent 链路覆盖）。
#[cfg(test)]
mod purge_acp_session_tests {
    use super::*;

    fn cwd_query(path: &str) -> Query<PurgeAcpSessionQuery> {
        Query(PurgeAcpSessionQuery { cwd: path.to_string() })
    }

    async fn insert_agent(state: &AppState, id: &str) {
        let now = chrono::Utc::now().to_rfc3339();
        sqlx::query(
            "INSERT INTO agents (id, display_name, command, args, env, created_at, updated_at) \
             VALUES (?, 'Test', '/bin/true', '[]', '[]', ?, ?)",
        )
        .bind(id)
        .bind(&now)
        .bind(&now)
        .execute(&state.db)
        .await
        .expect("agent row");
    }

    #[tokio::test]
    async fn missing_agent_is_404() {
        let state = crate::test_utils::test_state().await;
        let resp = purge_agent_acp_session(
            State(state),
            Path(("no-such-agent".to_string(), "sess-1".to_string())),
            cwd_query(&std::env::temp_dir().to_string_lossy()),
        )
        .await
        .into_response();
        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
    }

    #[tokio::test]
    async fn cwd_that_is_not_a_directory_is_400() {
        let state = crate::test_utils::test_state().await;
        insert_agent(&state, "a1").await;
        let missing = std::env::temp_dir().join("omniterm-purge-nonexistent-cwd");
        let resp = purge_agent_acp_session(
            State(state),
            Path(("a1".to_string(), "sess-1".to_string())),
            cwd_query(&missing.to_string_lossy()),
        )
        .await
        .into_response();
        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
    }
}