omniterm 0.1.3

Web-based tmux terminal manager with AI agent monitoring
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use axum::{
    extract::{Path, State},
    http::StatusCode,
    response::IntoResponse,
    routing::{get, post},
    Json, Router,
};
use serde_json::json;
use tracing::error;

use crate::tmux;
use crate::AppState;

pub fn routes() -> Router<AppState> {
    Router::new()
        .route("/sessions/{id}/hook-status", get(hook_status))
        .route("/sessions/{id}/hook-enable", post(hook_enable))
        .route("/sessions/{id}/hook-disable", post(hook_disable))
}

async fn hook_status(
    State(state): State<AppState>,
    Path(id): Path<String>,
) -> impl IntoResponse {
    let session: Option<(String, bool)> =
        sqlx::query_as("SELECT tmux_session_name, hook_enabled FROM sessions WHERE id = ?")
            .bind(&id)
            .fetch_optional(&state.db)
            .await
            .ok()
            .flatten();

    let Some((tmux_name, hook_enabled)) = session else {
        return (StatusCode::NOT_FOUND, Json(json!({ "error": "session not found" })));
    };

    if !hook_enabled {
        return (
            StatusCode::OK,
            Json(json!({
                "enabled": false,
                "state": "idle",
            })),
        );
    }

    // First, try to read agent state from the tmux session option
    match tmux::get_session_agent_option(&tmux_name).await {
        Ok(Some(snapshot)) => {
            return (
                StatusCode::OK,
                Json(json!({
                    "enabled": true,
                    "state": snapshot.agent_state.as_str(),
                    "agent_kind": snapshot.agent_kind.as_str(),
                    "attention_reason": snapshot.attention_reason.map(|r| r.as_str()),
                    "agent_event": snapshot.agent_event,
                    "agent_nonce": snapshot.agent_nonce,
                })),
            );
        }
        Ok(None) => {
            // Option not set — hooks may not have been injected yet
        }
        Err(e) => {
            tracing::warn!("failed to read agent option for {}: {}", tmux_name, e);
        }
    }

    // No structured agent state available — hooks not yet injected or session is bare shell
    (
        StatusCode::OK,
        Json(json!({
            "enabled": true,
            "state": "unknown",
            "detail": "agent hooks not injected yet",
        })),
    )
}

async fn hook_enable(
    State(state): State<AppState>,
    Path(id): Path<String>,
) -> (StatusCode, Json<serde_json::Value>) {
    let result = sqlx::query("UPDATE sessions SET hook_enabled = 1 WHERE id = ?")
        .bind(&id)
        .execute(&state.db)
        .await;

    match result {
        Ok(r) if r.rows_affected() > 0 => {
            // Try to detect agent CLI and inject hooks if possible
            // (Best effort — the session might not have a running agent process,
            // in which case hook-status will fall back to heuristic scanning.)
            (StatusCode::OK, Json(json!({ "ok": true, "hook_enabled": true })))
        }
        Ok(_) => {
            (StatusCode::NOT_FOUND, Json(json!({ "error": "session not found" })))
        }
        Err(e) => {
            error!("failed to enable hook: {}", e);
            (StatusCode::INTERNAL_SERVER_ERROR, Json(json!({ "error": "db error" })))
        }
    }
}

async fn hook_disable(
    State(state): State<AppState>,
    Path(id): Path<String>,
) -> (StatusCode, Json<serde_json::Value>) {
    let result = sqlx::query("UPDATE sessions SET hook_enabled = 0, hook_status = NULL WHERE id = ?")
        .bind(&id)
        .execute(&state.db)
        .await;

    match result {
        Ok(r) if r.rows_affected() > 0 => {
            (StatusCode::OK, Json(json!({ "ok": true, "hook_enabled": false })))
        }
        Ok(_) => {
            (StatusCode::NOT_FOUND, Json(json!({ "error": "session not found" })))
        }
        Err(e) => {
            error!("failed to disable hook: {}", e);
            (StatusCode::INTERNAL_SERVER_ERROR, Json(json!({ "error": "db error" })))
        }
    }
}