Skip to main content

orch/ui/
mod.rs

1//! The web UI the daemon serves on 127.0.0.1: projects, a board of their tasks, live agent output,
2//! the service log and a chat per project
3
4mod chat;
5mod compose;
6mod plan;
7mod setup;
8
9use std::collections::HashMap;
10use std::convert::Infallible;
11use std::fs;
12use std::hash::{DefaultHasher, Hash, Hasher};
13use std::path::{Path, PathBuf};
14use std::process;
15use std::sync::Arc;
16use std::time::Duration;
17
18use axum::extract::{Query, State};
19use axum::http::{HeaderMap, StatusCode, header};
20use axum::response::sse::{Event, KeepAlive, Sse};
21use axum::response::{IntoResponse, Redirect, Response};
22use axum::routing::{get, post};
23use axum::{Json, Router};
24use futures::Stream;
25use futures::stream;
26use serde::{Deserialize, Serialize};
27use subtle::ConstantTimeEq;
28use tokio::fs as tokio_fs;
29use tokio::net::TcpListener;
30use tokio::sync::{Mutex, broadcast, mpsc};
31use tokio::task;
32use tokio::time;
33use tokio::time::Instant;
34
35use crate::cli::ndjson::Formatter;
36use crate::cli::stream::{Tail, newest_output};
37use crate::cli::task_ref;
38use crate::cluster::local::write_private;
39use crate::config;
40use crate::engine::cooldown;
41use crate::engine::events::TaskEvent;
42use crate::github::http::GhHttp;
43use crate::home;
44use crate::plan::{HUMAN_LABEL, NO_AGENT_LABEL};
45use crate::security;
46use crate::store::{StatsEvents, StatusChange, Task, TaskRun, TaskStatus, TaskStore};
47
48/// Fixed so a bookmark keeps working, and below the ephemeral range so no outgoing socket takes it
49pub const PORT: u16 = 43917;
50const COOKIE: &str = "orch_ui";
51const LOGIN_CODE_TTL: Duration = Duration::from_secs(60);
52const DONE_ON_BOARD: i64 = 20;
53const ERROR_CHARS: usize = 400;
54const TAIL_POLL: Duration = Duration::from_secs(1);
55
56const INDEX_HTML: &str = include_str!("../../web/index.html");
57const APP_CSS: &str = include_str!("../../web/app.css");
58// Built by Bun into web/dist on release, build.rs points at it or at a page saying how to build it
59const APP_JS: &str = include_str!(env!("ORCH_WEB_JS"));
60// The page loads only its own script and style, so injected markup cannot reach another host
61const CSP: &str = "default-src 'none'; script-src 'self'; style-src 'self'; connect-src 'self'; img-src 'self' data:; base-uri 'none'; form-action 'none'; frame-ancestors 'none'";
62
63#[derive(Clone)]
64struct App {
65    store: Arc<TaskStore>,
66    events: broadcast::Sender<TaskEvent>,
67    token: Arc<str>,
68    host: Arc<str>,
69    /// One-time sign-in codes and when each stops working
70    codes: Arc<Mutex<HashMap<String, Instant>>>,
71}
72
73/// Where `orch ui` finds the running UI
74#[derive(Debug, Clone)]
75pub struct Endpoint {
76    pub port: u16,
77    pub token: String,
78}
79
80#[derive(Deserialize)]
81pub(super) struct RepoQuery {
82    repo: String,
83}
84
85#[derive(Deserialize)]
86struct DayQuery {
87    from: String,
88    to: String,
89    #[serde(default)]
90    repo: String,
91}
92
93#[derive(Serialize)]
94struct Inbox {
95    blocked: Vec<Card>,
96    human: Vec<Card>,
97}
98
99#[derive(Serialize)]
100struct Landed {
101    at: String,
102    card: Card,
103}
104
105#[derive(Serialize)]
106struct Day {
107    landed: Vec<Landed>,
108    blocked: Vec<Landed>,
109}
110
111#[derive(Deserialize)]
112struct ConfigQuery {
113    #[serde(default)]
114    repo: String,
115}
116
117#[derive(Deserialize)]
118struct ConfigWrite {
119    #[serde(default)]
120    repo: String,
121    text: String,
122    version: String,
123}
124
125#[derive(Serialize)]
126struct ConfigFile {
127    repo: String,
128    path: String,
129    text: String,
130    version: String,
131}
132
133#[derive(Deserialize)]
134struct FeedQuery {
135    #[serde(default)]
136    repo: String,
137}
138
139#[derive(Deserialize)]
140struct IdQuery {
141    id: i64,
142}
143
144#[derive(Deserialize)]
145struct CodeQuery {
146    code: Option<String>,
147}
148
149#[derive(Serialize)]
150struct LoginCode {
151    code: String,
152}
153
154#[derive(Serialize)]
155struct Project {
156    repo: String,
157    counts: Vec<(String, i64)>,
158}
159
160#[derive(Serialize)]
161struct Card {
162    id: i64,
163    repo: String,
164    number: Option<String>,
165    title: String,
166    status: String,
167    agent: Option<String>,
168    model: Option<String>,
169    complexity: String,
170    url: String,
171    pr_number: Option<i32>,
172    pr_url: Option<String>,
173    labels: Vec<String>,
174    block_reason: Option<String>,
175    last_error: String,
176    attempts: i32,
177    review_cycles: i32,
178    created_at: String,
179    updated_at: String,
180    /// When the task entered its status, filled in where a page shows how long it waited
181    since: Option<String>,
182}
183
184#[derive(Serialize)]
185struct Detail {
186    card: Card,
187    body: String,
188    summary: String,
189    branch: String,
190    activity: Vec<Activity>,
191    runs: Vec<RunRow>,
192}
193
194#[derive(Serialize)]
195struct RunRow {
196    attempt: i32,
197    run_type: String,
198    agent: String,
199    model: String,
200    outcome: String,
201    error: String,
202    duration_secs: f64,
203    started_at: String,
204    completed_at: Option<String>,
205    input_tokens: i64,
206    output_tokens: i64,
207}
208
209impl RunRow {
210    // The prompt, environment and output stay out, they are large and can hold secrets
211    fn from_run(r: TaskRun) -> Self {
212        Self {
213            attempt: r.attempt,
214            run_type: r.run_type,
215            agent: r.agent,
216            model: r.model,
217            outcome: r.outcome,
218            error: security::redact(&r.error)
219                .chars()
220                .take(ERROR_CHARS)
221                .collect(),
222            duration_secs: r.duration_secs,
223            started_at: r.started_at,
224            completed_at: r.completed_at,
225            input_tokens: r.input_tokens,
226            output_tokens: r.output_tokens,
227        }
228    }
229}
230
231#[derive(Serialize)]
232struct PrCheck {
233    name: String,
234    status: String,
235    conclusion: Option<String>,
236}
237
238#[derive(Serialize)]
239struct PrReview {
240    login: String,
241    state: String,
242    submitted_at: String,
243}
244
245#[derive(Serialize)]
246struct PrState {
247    number: u64,
248    title: String,
249    state: String,
250    merged: bool,
251    mergeable: Option<bool>,
252    mergeable_state: Option<String>,
253    html_url: String,
254    head: String,
255    base: String,
256    checks: Vec<PrCheck>,
257    reviews: Vec<PrReview>,
258}
259
260#[derive(Serialize)]
261struct QuotaWindow {
262    agent: String,
263    window: String,
264    status: String,
265    utilization: Option<f64>,
266    resets_at: Option<i64>,
267}
268
269#[derive(Serialize)]
270struct Cooldown {
271    key: String,
272    until: i64,
273    reason: String,
274}
275
276#[derive(Serialize)]
277struct Usage {
278    windows: Vec<QuotaWindow>,
279    cooldowns: Vec<Cooldown>,
280}
281
282#[derive(Deserialize)]
283struct StatsQuery {
284    days: u32,
285}
286
287#[derive(Serialize)]
288struct Activity {
289    timestamp: String,
290    event_type: String,
291    from_status: Option<String>,
292    to_status: Option<String>,
293    agent: Option<String>,
294    model: Option<String>,
295}
296
297#[derive(Serialize)]
298pub(super) struct ChatMessage {
299    role: String,
300    content: String,
301    agent: Option<String>,
302    model: Option<String>,
303    created_at: String,
304}
305
306/// One line of an activity feed: a task changed status, or an agent wrote output
307#[derive(Serialize)]
308struct FeedItem {
309    kind: &'static str,
310    timestamp: String,
311    repo: String,
312    task: Option<i64>,
313    number: Option<String>,
314    title: String,
315    from: Option<String>,
316    to: Option<String>,
317    agent: Option<String>,
318    text: String,
319}
320
321/// An agent being followed by a feed, and the output file it writes now
322struct Followed {
323    task: Task,
324    dirs: Vec<PathBuf>,
325    tail: Option<(PathBuf, Tail, Formatter)>,
326}
327
328impl FeedItem {
329    fn from_change(c: StatusChange) -> Self {
330        Self {
331            kind: "status",
332            timestamp: c.timestamp,
333            repo: c.repo,
334            task: Some(c.task_id),
335            number: c.external_id.filter(|n| !n.starts_with("internal:")),
336            title: c.title,
337            from: c.from_status,
338            to: c.to_status,
339            agent: c.agent,
340            text: String::new(),
341        }
342    }
343}
344
345impl Card {
346    fn from_task(t: Task) -> Self {
347        let pr_url = t
348            .pr_number
349            .map(|n| format!("https://github.com/{}/pull/{n}", t.repo));
350        let last_error: String = security::redact(&t.last_error)
351            .chars()
352            .take(ERROR_CHARS)
353            .collect();
354        Self {
355            id: t.id,
356            repo: t.repo,
357            number: t.external_id.filter(|n| !n.starts_with("internal:")),
358            title: t.title,
359            status: t.status.as_str().to_string(),
360            agent: t.agent,
361            model: t.model,
362            complexity: t.complexity,
363            url: t.url,
364            pr_number: t.pr_number,
365            pr_url,
366            labels: t.labels,
367            block_reason: t.block_reason.map(|r| security::redact(&r)),
368            last_error,
369            attempts: t.attempts,
370            review_cycles: t.review_cycles,
371            created_at: t.created_at,
372            updated_at: t.updated_at,
373            since: None,
374        }
375    }
376}
377
378/// Cards for tasks, each with when it entered its status
379async fn cards(store: &TaskStore, tasks: Vec<Task>) -> Vec<Card> {
380    let ids: Vec<i64> = tasks.iter().map(|t| t.id).collect();
381    let mut since = store.entered_status(&ids).await.unwrap_or_default();
382    tasks
383        .into_iter()
384        .map(|t| {
385            let entered = since.remove(&t.id);
386            let mut card = Card::from_task(t);
387            card.since = entered;
388            card
389        })
390        .collect()
391}
392
393fn port_path() -> anyhow::Result<PathBuf> {
394    Ok(home::state_dir()?.join("ui.port"))
395}
396
397/// Serve the UI on 127.0.0.1 and record the port, a fresh token and the pid for `orch ui`
398pub async fn serve(
399    store: Arc<TaskStore>,
400    events: broadcast::Sender<TaskEvent>,
401) -> anyhow::Result<u16> {
402    let endpoint = serve_on(store, events).await?;
403    write_private(
404        &port_path()?,
405        &format!("{} {} {}", endpoint.port, endpoint.token, process::id()),
406    )?;
407    Ok(endpoint.port)
408}
409
410/// Serve the UI without recording it, for `orch ui --dev`
411pub async fn serve_on(
412    store: Arc<TaskStore>,
413    events: broadcast::Sender<TaskEvent>,
414) -> anyhow::Result<Endpoint> {
415    let listener = match TcpListener::bind(("127.0.0.1", PORT)).await {
416        Ok(l) => l,
417        Err(e) => {
418            tracing::warn!(port = PORT, err = %e, "web UI port taken, using a free one");
419            TcpListener::bind("127.0.0.1:0").await?
420        }
421    };
422    let port = listener.local_addr()?.port();
423    let token = format!(
424        "{}{}",
425        uuid::Uuid::new_v4().simple(),
426        uuid::Uuid::new_v4().simple()
427    );
428    let app = router(App {
429        store,
430        events,
431        token: Arc::from(token.as_str()),
432        host: Arc::from(format!("127.0.0.1:{port}")),
433        codes: Arc::default(),
434    });
435    tokio::spawn(async move {
436        if let Err(e) = axum::serve(listener, app).await {
437            tracing::warn!(err = %e, "web UI stopped");
438        }
439    });
440    tracing::info!(port, "web UI started on 127.0.0.1");
441    Ok(Endpoint { port, token })
442}
443
444fn router(app: App) -> Router {
445    Router::new()
446        .route("/", get(index))
447        .route("/login-code", post(login_code))
448        .route("/app.css", get(css))
449        .route("/app.js", get(js))
450        .route("/api/projects", get(projects))
451        .route("/api/tasks", get(tasks))
452        .route("/api/running", get(running))
453        .route("/api/inbox", get(inbox))
454        .route("/api/agents", get(compose::agents))
455        .route("/api/plan", get(plan::state))
456        .route("/api/plan/message", post(plan::message))
457        .route("/api/plan/preview", post(plan::preview))
458        .route("/api/plan/import", post(plan::import))
459        .route("/api/plan/clear", post(plan::clear))
460        .route("/api/tasks/new", post(compose::create))
461        .route("/api/setup", get(setup::status))
462        .route(
463            "/api/setup/login",
464            get(setup::login_state).post(setup::login_start),
465        )
466        .route("/api/setup/repos", get(setup::repos))
467        .route("/api/setup/owners", get(setup::owners))
468        .route("/api/setup/dirs", get(setup::dirs))
469        .route("/api/projects/add", post(setup::add))
470        .route("/api/pr", get(pr_state))
471        .route("/api/usage", get(usage))
472        .route("/api/stats", get(stats))
473        .route("/api/day", get(day))
474        .route("/api/task", get(task_detail))
475        .route("/api/config", get(config_read).put(config_write))
476        .route("/api/chat", get(chat::history).post(chat::send))
477        .route("/api/events", get(events))
478        .route("/api/output", get(output))
479        .route("/api/logs", get(logs))
480        .route("/api/activity", get(activity))
481        .with_state(app)
482}
483
484pub async fn cleanup() {
485    if let Ok(path) = port_path() {
486        let _ = tokio_fs::remove_file(path).await;
487    }
488}
489
490/// The running daemon's UI. A file left by a daemon that is gone names nothing
491pub async fn endpoint() -> Option<Endpoint> {
492    let body = tokio_fs::read_to_string(port_path().ok()?).await.ok()?;
493    let mut parts = body.split_whitespace();
494    let port: u16 = parts.next()?.parse().ok()?;
495    let token = parts.next()?.to_string();
496    let pid: u32 = parts.next()?.parse().ok()?;
497    let alive = task::spawn_blocking(move || home::pid_is_orch_serve(pid))
498        .await
499        .ok()?;
500    alive.then_some(Endpoint { port, token })
501}
502
503// A rebound DNS name sends its own Host, so only the literal address passes
504fn host_ok(app: &App, headers: &HeaderMap) -> bool {
505    headers
506        .get(header::HOST)
507        .is_some_and(|h| h.as_bytes() == app.host.as_bytes())
508}
509
510fn token_ok(app: &App, given: &str) -> bool {
511    given.as_bytes().ct_eq(app.token.as_bytes()).into()
512}
513
514fn cookie_token(headers: &HeaderMap) -> Option<&str> {
515    headers
516        .get_all(header::COOKIE)
517        .iter()
518        .filter_map(|v| v.to_str().ok())
519        .flat_map(|v| v.split(';'))
520        .find_map(|pair| pair.trim().strip_prefix("orch_ui="))
521}
522
523/**
524 * Whether the request comes from the UI's own page or a direct visit. A cookie reaches every port of
525 * 127.0.0.1, so a page another local server serves would carry it too. Browsers say where a request
526 * started in `Sec-Fetch-Site` and `Origin`, and a tool that sends neither, such as curl, is the owner
527 **/
528fn same_origin(app: &App, headers: &HeaderMap) -> bool {
529    let site_ok = headers
530        .get("sec-fetch-site")
531        .is_none_or(|v| matches!(v.as_bytes(), b"same-origin" | b"none"));
532    let origin_ok = headers
533        .get(header::ORIGIN)
534        .is_none_or(|o| o.as_bytes() == format!("http://{}", app.host).as_bytes());
535    site_ok && origin_ok
536}
537
538fn authorized(app: &App, headers: &HeaderMap) -> bool {
539    host_ok(app, headers)
540        && same_origin(app, headers)
541        && cookie_token(headers).is_some_and(|t| token_ok(app, t))
542}
543
544fn unauthorized() -> Response {
545    (
546        StatusCode::UNAUTHORIZED,
547        "Run `orch ui` to open the web UI\n",
548    )
549        .into_response()
550}
551
552/// `orch ui` opens `/?token=…` once, which trades the token for a cookie and drops it from the URL
553/**
554 * A sign-in code for `orch ui`, which proves it can read the token file with a Bearer header. The
555 * browser opens `/?code=…`, so its history keeps a code that is spent within a minute, never the
556 * token itself
557 **/
558async fn login_code(State(app): State<App>, headers: HeaderMap) -> Response {
559    let bearer = headers
560        .get(header::AUTHORIZATION)
561        .and_then(|v| v.to_str().ok())
562        .and_then(|v| v.strip_prefix("Bearer "));
563    if !host_ok(&app, &headers) || !bearer.is_some_and(|t| token_ok(&app, t)) {
564        return unauthorized();
565    }
566
567    let code = uuid::Uuid::new_v4().simple().to_string();
568    let mut codes = app.codes.lock().await;
569    let now = Instant::now();
570    codes.retain(|_, until| *until > now);
571    codes.insert(code.clone(), now + LOGIN_CODE_TTL);
572    Json(LoginCode { code }).into_response()
573}
574
575async fn index(State(app): State<App>, headers: HeaderMap, Query(q): Query<CodeQuery>) -> Response {
576    if !host_ok(&app, &headers) || !same_origin(&app, &headers) {
577        return unauthorized();
578    }
579
580    // A code works once, then the cookie carries the token
581    if let Some(code) = q.code {
582        let fresh = app
583            .codes
584            .lock()
585            .await
586            .remove(&code)
587            .is_some_and(|until| until > Instant::now());
588        if !fresh {
589            return unauthorized();
590        }
591
592        let cookie = format!("{COOKIE}={}; HttpOnly; SameSite=Strict; Path=/", app.token);
593        return ([(header::SET_COOKIE, cookie)], Redirect::to("/")).into_response();
594    }
595
596    if !authorized(&app, &headers) {
597        return unauthorized();
598    }
599
600    (
601        [
602            (header::CONTENT_TYPE, "text/html; charset=utf-8"),
603            (header::CONTENT_SECURITY_POLICY, CSP),
604            (header::CACHE_CONTROL, "no-store"),
605        ],
606        INDEX_HTML,
607    )
608        .into_response()
609}
610
611async fn css(State(app): State<App>, headers: HeaderMap) -> Response {
612    if !authorized(&app, &headers) {
613        return unauthorized();
614    }
615
616    ([(header::CONTENT_TYPE, "text/css; charset=utf-8")], APP_CSS).into_response()
617}
618
619async fn js(State(app): State<App>, headers: HeaderMap) -> Response {
620    if !authorized(&app, &headers) {
621        return unauthorized();
622    }
623
624    (
625        [(header::CONTENT_TYPE, "text/javascript; charset=utf-8")],
626        APP_JS,
627    )
628        .into_response()
629}
630
631fn internal(e: &anyhow::Error) -> Response {
632    tracing::warn!(err = %e, "web UI request failed");
633    (StatusCode::INTERNAL_SERVER_ERROR, format!("{e:#}")).into_response()
634}
635
636/// The project's directory, or None when the repo is not one orch runs
637fn project_dir(repo: &str) -> Option<PathBuf> {
638    config::get_projects_with_paths()
639        .ok()?
640        .into_iter()
641        .find_map(|(r, path)| (r == repo).then_some(path))
642}
643
644async fn projects(State(app): State<App>, headers: HeaderMap) -> Response {
645    if !authorized(&app, &headers) {
646        return unauthorized();
647    }
648
649    let repos = match config::get_projects_with_paths() {
650        Ok(p) => p,
651        Err(e) => return internal(&e),
652    };
653    let mut out = Vec::new();
654    for (repo, _) in repos {
655        let counts = app.store.count_by_status(&repo).await.unwrap_or_default();
656        out.push(Project { repo, counts });
657    }
658    Json(out).into_response()
659}
660
661async fn tasks(State(app): State<App>, headers: HeaderMap, Query(q): Query<RepoQuery>) -> Response {
662    if !authorized(&app, &headers) {
663        return unauthorized();
664    }
665
666    match app.store.list_for_board(&q.repo, DONE_ON_BOARD).await {
667        Ok(tasks) => Json(cards(&app.store, tasks).await).into_response(),
668        Err(e) => internal(&e),
669    }
670}
671
672async fn running(State(app): State<App>, headers: HeaderMap) -> Response {
673    if !authorized(&app, &headers) {
674        return unauthorized();
675    }
676
677    match app.store.list_running().await {
678        Ok(tasks) => Json(cards(&app.store, tasks).await).into_response(),
679        Err(e) => internal(&e),
680    }
681}
682
683/// What waits on a person: blocked tasks, and tasks kept from agents for a person to do
684async fn inbox(State(app): State<App>, headers: HeaderMap, Query(q): Query<FeedQuery>) -> Response {
685    if !authorized(&app, &headers) {
686        return unauthorized();
687    }
688
689    let repo = (!q.repo.is_empty()).then_some(q.repo.as_str());
690    let open = match app.store.list_open(repo).await {
691        Ok(t) => t,
692        Err(e) => return internal(&e),
693    };
694    let mut out = Inbox {
695        blocked: Vec::new(),
696        human: Vec::new(),
697    };
698    for task in cards_waiting(&app.store, open).await {
699        if task.status == TaskStatus::Blocked.as_str() {
700            out.blocked.push(task);
701        } else {
702            out.human.push(task);
703        }
704    }
705    // The longest wait first, which is the one to look at
706    out.blocked.sort_by(|a, b| a.since.cmp(&b.since));
707    out.human.sort_by(|a, b| a.since.cmp(&b.since));
708    Json(out).into_response()
709}
710
711/// Open tasks that wait on a person, so only those pay for the status lookup
712async fn cards_waiting(store: &TaskStore, open: Vec<Task>) -> Vec<Card> {
713    let waiting = open
714        .into_iter()
715        .filter(|t| {
716            t.status == TaskStatus::Blocked
717                || t.labels
718                    .iter()
719                    .any(|l| l == HUMAN_LABEL || l == NO_AGENT_LABEL)
720        })
721        .collect();
722    cards(store, waiting).await
723}
724
725/// RFC 3339 in the store's own format, so text comparison orders it
726fn store_instant(value: &str) -> Option<String> {
727    chrono::DateTime::parse_from_rfc3339(value).ok().map(|t| {
728        t.with_timezone(&chrono::Utc)
729            .format("%Y-%m-%dT%H:%M:%SZ")
730            .to_string()
731    })
732}
733
734/// Tasks that merged between two instants, which the page picks as the user's local day
735async fn day(State(app): State<App>, headers: HeaderMap, Query(q): Query<DayQuery>) -> Response {
736    if !authorized(&app, &headers) {
737        return unauthorized();
738    }
739
740    let (Some(from), Some(to)) = (store_instant(&q.from), store_instant(&q.to)) else {
741        return (StatusCode::BAD_REQUEST, "from and to must be RFC 3339").into_response();
742    };
743    let repo = (!q.repo.is_empty()).then_some(q.repo.as_str());
744    let landed = |rows: Vec<(String, Task)>| -> Vec<Landed> {
745        rows.into_iter()
746            .map(|(at, task)| Landed {
747                at,
748                card: Card::from_task(task),
749            })
750            .collect()
751    };
752    let done = app
753        .store
754        .entered_between(TaskStatus::Done, &from, &to, repo)
755        .await;
756    let blocked = app
757        .store
758        .entered_between(TaskStatus::Blocked, &from, &to, repo)
759        .await;
760    match (done, blocked) {
761        (Ok(done), Ok(blocked)) => Json(Day {
762            landed: landed(done),
763            blocked: landed(blocked),
764        })
765        .into_response(),
766        (Err(e), _) | (_, Err(e)) => internal(&e),
767    }
768}
769
770/// The task's PR as GitHub has it now: state, mergeability, each check and each reviewer's latest say
771async fn pr_state(
772    State(app): State<App>,
773    headers: HeaderMap,
774    Query(q): Query<IdQuery>,
775) -> Response {
776    if !authorized(&app, &headers) {
777        return unauthorized();
778    }
779
780    let Ok(task) = app.store.get(q.id).await else {
781        return StatusCode::NOT_FOUND.into_response();
782    };
783    let Some(number) = task.pr_number.and_then(|n| u64::try_from(n).ok()) else {
784        return StatusCode::NO_CONTENT.into_response();
785    };
786    match read_pr(&task.repo, number).await {
787        Ok(pr) => Json(pr).into_response(),
788        Err(e) => (StatusCode::BAD_GATEWAY, format!("{e:#}")).into_response(),
789    }
790}
791
792async fn read_pr(repo: &str, number: u64) -> anyhow::Result<PrState> {
793    let gh = GhHttp::new()?;
794    let pr = gh.get_pr(repo, number).await?;
795    let (checks, reviews) = tokio::join!(
796        gh.get_check_runs(repo, &pr.head.sha),
797        gh.get_pr_reviews(repo, number)
798    );
799    let mut latest: HashMap<String, PrReview> = HashMap::new();
800    // A comment does not change a reviewer's verdict, so only these count
801    for r in reviews.unwrap_or_default() {
802        if matches!(
803            r.state.as_str(),
804            "APPROVED" | "CHANGES_REQUESTED" | "DISMISSED"
805        ) {
806            latest.insert(
807                r.user.login.clone(),
808                PrReview {
809                    login: r.user.login,
810                    state: r.state,
811                    submitted_at: r.submitted_at,
812                },
813            );
814        }
815    }
816    Ok(PrState {
817        number: pr.number,
818        title: pr.title,
819        state: pr.state,
820        merged: pr.merged.unwrap_or(false),
821        mergeable: pr.mergeable,
822        mergeable_state: pr.mergeable_state,
823        html_url: pr.html_url,
824        head: pr.head.ref_,
825        base: pr.base.ref_,
826        checks: checks
827            .unwrap_or_default()
828            .into_iter()
829            .map(|c| PrCheck {
830                name: c.name,
831                status: c.status,
832                conclusion: c.conclusion,
833            })
834            .collect(),
835        reviews: latest.into_values().collect(),
836    })
837}
838
839/// Each agent's plan windows as the vendor last reported them, and every active cooldown
840async fn usage(State(app): State<App>, headers: HeaderMap) -> Response {
841    if !authorized(&app, &headers) {
842        return unauthorized();
843    }
844
845    let windows = cooldown::list_rate_limit_windows(&app.store)
846        .await
847        .into_iter()
848        .map(|(agent, w)| QuotaWindow {
849            agent,
850            window: w.window_type,
851            status: w.status,
852            utilization: w.utilization,
853            resets_at: w.resets_at,
854        })
855        .collect();
856    let cooldowns = cooldown::list_persisted_cooldowns(&app.store)
857        .await
858        .into_iter()
859        .map(|(key, until, reason)| Cooldown { key, until, reason })
860        .collect();
861    Json(Usage { windows, cooldowns }).into_response()
862}
863
864const STATS_MAX_DAYS: u32 = 90;
865
866/// Merges, blocks and runs over the last `days`, counted by the page
867async fn stats(
868    State(app): State<App>,
869    headers: HeaderMap,
870    Query(q): Query<StatsQuery>,
871) -> Response {
872    if !authorized(&app, &headers) {
873        return unauthorized();
874    }
875
876    let days = i64::from(q.days.clamp(1, STATS_MAX_DAYS));
877    let since = (chrono::Utc::now() - chrono::Duration::days(days))
878        .format("%Y-%m-%dT%H:%M:%SZ")
879        .to_string();
880    let events: anyhow::Result<StatsEvents> = app.store.stats_since(&since).await;
881    match events {
882        Ok(e) => Json::<StatsEvents>(e).into_response(),
883        Err(e) => internal(&e),
884    }
885}
886
887async fn task_detail(
888    State(app): State<App>,
889    headers: HeaderMap,
890    Query(q): Query<IdQuery>,
891) -> Response {
892    if !authorized(&app, &headers) {
893        return unauthorized();
894    }
895
896    let Ok(task) = app.store.get(q.id).await else {
897        return StatusCode::NOT_FOUND.into_response();
898    };
899    let activity = app
900        .store
901        .get_activity(q.id, Some(200))
902        .await
903        .unwrap_or_default()
904        .into_iter()
905        .map(|a| Activity {
906            timestamp: a.timestamp,
907            event_type: a.event_type,
908            from_status: a.from_status,
909            to_status: a.to_status,
910            agent: a.agent,
911            model: a.model,
912        })
913        .collect();
914    let runs = app
915        .store
916        .get_runs(q.id)
917        .await
918        .unwrap_or_default()
919        .into_iter()
920        .map(RunRow::from_run)
921        .collect();
922    let body = security::redact(&task.body);
923    let summary = security::redact(&task.summary);
924    let branch = task.branch.clone();
925    Json(Detail {
926        card: Card::from_task(task),
927        body,
928        summary,
929        branch,
930        activity,
931        runs,
932    })
933    .into_response()
934}
935
936/// The global config with no repo, else that project's `.orch.yml`
937fn config_file(repo: &str) -> Option<PathBuf> {
938    if repo.is_empty() {
939        return home::config_path().ok();
940    }
941
942    project_dir(repo).map(|dir| dir.join(".orch.yml"))
943}
944
945/// Changes when the file does, so a save over someone else's edit is refused
946fn version_of(text: &str) -> String {
947    let mut hasher = DefaultHasher::new();
948    text.hash(&mut hasher);
949    format!("{:016x}", hasher.finish())
950}
951
952async fn config_read(
953    State(app): State<App>,
954    headers: HeaderMap,
955    Query(q): Query<ConfigQuery>,
956) -> Response {
957    if !authorized(&app, &headers) {
958        return unauthorized();
959    }
960
961    let Some(path) = config_file(&q.repo) else {
962        return StatusCode::NOT_FOUND.into_response();
963    };
964    let text = fs::read_to_string(&path).unwrap_or_default();
965    Json(ConfigFile {
966        repo: q.repo,
967        path: path.display().to_string(),
968        version: version_of(&text),
969        text,
970    })
971    .into_response()
972}
973
974/// Why `text` cannot replace the config file for `repo`, if it cannot
975fn config_problem(repo: &str, text: &str) -> Option<String> {
976    let doc = match serde_norway::from_str::<serde_norway::Value>(text) {
977        Ok(doc) => doc,
978        Err(e) => return Some(format!("not valid YAML: {e}")),
979    };
980    if repo.is_empty() {
981        return None;
982    }
983
984    // The engine finds a project by this key, so a save without it would drop the project
985    let named = doc
986        .get("gh")
987        .and_then(|gh| gh.get("repo"))
988        .and_then(|r| r.as_str());
989    (named != Some(repo)).then(|| format!("gh.repo must stay {repo}"))
990}
991
992/**
993 * Write `text` over a config file. A symlinked config, as in a dotfiles repo, is written at its
994 * target so the link stays. The old text goes to orch's state dir, never beside the file, where a
995 * project checkout would show it as untracked
996 **/
997fn save_config(path: &Path, current: &str, text: &str, backups: &Path) -> anyhow::Result<()> {
998    let target = fs::canonicalize(path).unwrap_or_else(|_| path.to_path_buf());
999    if !current.is_empty() {
1000        let name: String = target
1001            .to_string_lossy()
1002            .chars()
1003            .map(|c| {
1004                if c.is_ascii_alphanumeric() || c == '.' {
1005                    c
1006                } else {
1007                    '_'
1008                }
1009            })
1010            .collect();
1011        write_private(&backups.join(format!("{name}.bak")), current)?;
1012    }
1013
1014    write_private(&target, text)
1015}
1016
1017/// Replace a config file as the owner edited it, keeping the old one in the state dir
1018async fn config_write(
1019    State(app): State<App>,
1020    headers: HeaderMap,
1021    Json(req): Json<ConfigWrite>,
1022) -> Response {
1023    if !authorized(&app, &headers) {
1024        return unauthorized();
1025    }
1026
1027    let Some(path) = config_file(&req.repo) else {
1028        return StatusCode::NOT_FOUND.into_response();
1029    };
1030    let current = fs::read_to_string(&path).unwrap_or_default();
1031    if version_of(&current) != req.version {
1032        return (
1033            StatusCode::CONFLICT,
1034            "the file changed since you opened it, reload it first",
1035        )
1036            .into_response();
1037    }
1038
1039    if let Some(problem) = config_problem(&req.repo, &req.text) {
1040        return (StatusCode::UNPROCESSABLE_ENTITY, problem).into_response();
1041    }
1042
1043    let saved = home::state_dir()
1044        .and_then(|state| save_config(&path, &current, &req.text, &state.join("config-backups")));
1045    if let Err(e) = saved {
1046        return internal(&e);
1047    }
1048
1049    // A save replaces the file, which can end a watch on its old inode, so it reloads here
1050    config::reloaded(&path);
1051    tracing::info!(path = %path.display(), "config saved from the web UI");
1052    Json(ConfigFile {
1053        repo: req.repo,
1054        path: path.display().to_string(),
1055        version: version_of(&req.text),
1056        text: req.text,
1057    })
1058    .into_response()
1059}
1060
1061fn sse(rx: mpsc::Receiver<Event>) -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
1062    let stream = stream::unfold(rx, |mut rx| async move {
1063        rx.recv().await.map(|event| (Ok(event), rx))
1064    });
1065    Sse::new(stream).keep_alive(KeepAlive::default())
1066}
1067
1068/// Task status changes as they happen. `lagged` tells the page to fetch the board again
1069async fn events(
1070    State(app): State<App>,
1071    headers: HeaderMap,
1072    Query(q): Query<RepoQuery>,
1073) -> Response {
1074    if !authorized(&app, &headers) {
1075        return unauthorized();
1076    }
1077
1078    let mut events = app.events.subscribe();
1079    let (tx, rx) = mpsc::channel(64);
1080    tokio::spawn(async move {
1081        loop {
1082            let event = match events.recv().await {
1083                Ok(mut e) if q.repo.is_empty() || e.repo == q.repo => {
1084                    // Agent text can hold a secret, the activity feed redacts the same fields
1085                    e.error = e.error.map(|t| security::redact(&t));
1086                    e.summary = e.summary.map(|t| security::redact(&t));
1087                    e.review_context = e.review_context.map(|t| security::redact(&t));
1088                    Event::default().event("task").json_data(&e).ok()
1089                }
1090                Ok(_) => None,
1091                Err(broadcast::error::RecvError::Lagged(_)) => {
1092                    Some(Event::default().event("lagged").data(""))
1093                }
1094                Err(broadcast::error::RecvError::Closed) => break,
1095            };
1096            if let Some(event) = event
1097                && tx.send(event).await.is_err()
1098            {
1099                break;
1100            }
1101        }
1102    });
1103    sse(rx).into_response()
1104}
1105
1106/// The newest agent output of a task and its review, formatted the way `orch stream` prints it
1107async fn output(State(app): State<App>, headers: HeaderMap, Query(q): Query<IdQuery>) -> Response {
1108    if !authorized(&app, &headers) {
1109        return unauthorized();
1110    }
1111
1112    let Ok(dirs) = task_ref::resolve(&app.store, &q.id.to_string())
1113        .await
1114        .and_then(|t| task_ref::state_dirs(&t))
1115    else {
1116        return StatusCode::NOT_FOUND.into_response();
1117    };
1118    let (tx, rx) = mpsc::channel(256);
1119    tokio::spawn(async move {
1120        let mut current: Option<(PathBuf, Tail, Formatter)> = None;
1121        loop {
1122            if let Some(path) = newest_output(&dirs)
1123                && current.as_ref().is_none_or(|(p, _, _)| *p != path)
1124            {
1125                let tail = Tail::open(path.clone(), false);
1126                current = Some((path, tail, Formatter::new(false)));
1127                if tx
1128                    .send(Event::default().event("attempt").data(""))
1129                    .await
1130                    .is_err()
1131                {
1132                    break;
1133                }
1134            }
1135
1136            if let Some((_, tail, formatter)) = current.as_mut() {
1137                for line in tail.read_lines() {
1138                    for entry in formatter.format(&line) {
1139                        let event = Event::default()
1140                            .event("line")
1141                            .data(security::redact(&entry));
1142                        if tx.send(event).await.is_err() {
1143                            return;
1144                        }
1145                    }
1146                }
1147            }
1148
1149            if tx.is_closed() {
1150                break;
1151            }
1152
1153            time::sleep(TAIL_POLL).await;
1154        }
1155    });
1156    sse(rx).into_response()
1157}
1158
1159/// The service log as it grows
1160async fn logs(State(app): State<App>, headers: HeaderMap) -> Response {
1161    if !authorized(&app, &headers) {
1162        return unauthorized();
1163    }
1164
1165    let path = match home::state_dir() {
1166        Ok(dir) => dir.join("orch.log"),
1167        Err(e) => return internal(&e),
1168    };
1169    let (tx, rx) = mpsc::channel(256);
1170    tokio::spawn(async move {
1171        let mut tail = Tail::open(path.clone(), false);
1172        loop {
1173            if tail.shrank() {
1174                tail = Tail::open(path.clone(), false);
1175            }
1176
1177            for line in tail.read_lines() {
1178                let event = Event::default().event("line").data(security::redact(&line));
1179                if tx.send(event).await.is_err() {
1180                    return;
1181                }
1182            }
1183
1184            if tx.is_closed() {
1185                break;
1186            }
1187
1188            time::sleep(TAIL_POLL).await;
1189        }
1190    });
1191    sse(rx).into_response()
1192}
1193
1194const FEED_BACKLOG: i64 = 60;
1195const FEED_LINE_CHARS: usize = 240;
1196
1197fn now() -> String {
1198    chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string()
1199}
1200
1201fn feed_event(item: &FeedItem) -> Option<Event> {
1202    Event::default().event("item").json_data(item).ok()
1203}
1204
1205/// Status changes and agent output, for one project or every one
1206async fn activity(
1207    State(app): State<App>,
1208    headers: HeaderMap,
1209    Query(q): Query<FeedQuery>,
1210) -> Response {
1211    if !authorized(&app, &headers) {
1212        return unauthorized();
1213    }
1214
1215    let repo = (!q.repo.is_empty()).then_some(q.repo);
1216    let backlog = app
1217        .store
1218        .recent_status_changes(repo.as_deref(), FEED_BACKLOG)
1219        .await
1220        .unwrap_or_default();
1221    let (tx, rx) = mpsc::channel(512);
1222    for change in backlog {
1223        if let Some(event) = feed_event(&FeedItem::from_change(change)) {
1224            let _ = tx.try_send(event);
1225        }
1226    }
1227
1228    tokio::spawn(feed_status(
1229        Arc::clone(&app.store),
1230        app.events.subscribe(),
1231        repo.clone(),
1232        tx.clone(),
1233    ));
1234    tokio::spawn(feed_output(app.store, repo, tx));
1235    sse(rx).into_response()
1236}
1237
1238async fn feed_status(
1239    store: Arc<TaskStore>,
1240    mut events: broadcast::Receiver<TaskEvent>,
1241    repo: Option<String>,
1242    tx: mpsc::Sender<Event>,
1243) {
1244    loop {
1245        let e = match events.recv().await {
1246            Ok(e) => e,
1247            Err(broadcast::error::RecvError::Lagged(_)) => continue,
1248            Err(broadcast::error::RecvError::Closed) => break,
1249        };
1250        if repo.as_ref().is_some_and(|r| *r != e.repo) || e.old_status == e.new_status {
1251            continue;
1252        }
1253
1254        let task = store
1255            .get_by_external_id(&e.repo, &e.task_id)
1256            .await
1257            .ok()
1258            .flatten();
1259        let item = FeedItem {
1260            kind: "status",
1261            timestamp: e.timestamp,
1262            task: task.as_ref().map(|t| t.id),
1263            number: (!e.task_id.starts_with("internal:")).then_some(e.task_id),
1264            title: e
1265                .title
1266                .or_else(|| task.map(|t| t.title))
1267                .unwrap_or_default(),
1268            repo: e.repo,
1269            from: Some(e.old_status).filter(|s| !s.is_empty()),
1270            to: Some(e.new_status),
1271            agent: e.agent,
1272            text: e
1273                .error
1274                .map(|err| security::redact(&err))
1275                .unwrap_or_default(),
1276        };
1277        if let Some(event) = feed_event(&item)
1278            && tx.send(event).await.is_err()
1279        {
1280            break;
1281        }
1282    }
1283}
1284
1285/// Follow every running agent's output, the way `orch stream` does with no task named
1286async fn feed_output(store: Arc<TaskStore>, repo: Option<String>, tx: mpsc::Sender<Event>) {
1287    let mut followed: HashMap<i64, Followed> = HashMap::new();
1288    let mut first = true;
1289    while !tx.is_closed() {
1290        let running = store.list_running().await.unwrap_or_default();
1291        let live: Vec<i64> = running.iter().map(|t| t.id).collect();
1292        for task in running {
1293            if repo.as_ref().is_some_and(|r| *r != task.repo) || followed.contains_key(&task.id) {
1294                continue;
1295            }
1296
1297            let Ok(dirs) = task_ref::resolve(&store, &task.id.to_string())
1298                .await
1299                .and_then(|t| task_ref::state_dirs(&t))
1300            else {
1301                continue;
1302            };
1303            followed.insert(
1304                task.id,
1305                Followed {
1306                    task,
1307                    dirs,
1308                    tail: None,
1309                },
1310            );
1311        }
1312
1313        for f in followed.values_mut() {
1314            if let Some(path) = newest_output(&f.dirs)
1315                && f.tail.as_ref().is_none_or(|(p, _, _)| *p != path)
1316            {
1317                // A feed opened mid-run starts at the end, a new attempt starts at its beginning
1318                let tail = if first {
1319                    Tail::open_at_end(path.clone())
1320                } else {
1321                    Tail::open(path.clone(), false)
1322                };
1323                f.tail = Some((path, tail, Formatter::new(false)));
1324            }
1325
1326            let Some((_, tail, formatter)) = f.tail.as_mut() else {
1327                continue;
1328            };
1329            for line in tail.read_lines() {
1330                for entry in formatter.format(&line) {
1331                    let text: String = security::redact(entry.lines().next().unwrap_or(""))
1332                        .chars()
1333                        .take(FEED_LINE_CHARS)
1334                        .collect();
1335                    if text.trim().is_empty() {
1336                        continue;
1337                    }
1338
1339                    let item = FeedItem {
1340                        kind: "output",
1341                        timestamp: now(),
1342                        repo: f.task.repo.clone(),
1343                        task: Some(f.task.id),
1344                        number: f
1345                            .task
1346                            .external_id
1347                            .clone()
1348                            .filter(|n| !n.starts_with("internal:")),
1349                        title: f.task.title.clone(),
1350                        from: None,
1351                        to: None,
1352                        agent: f.task.agent.clone(),
1353                        text,
1354                    };
1355                    if let Some(event) = feed_event(&item)
1356                        && tx.send(event).await.is_err()
1357                    {
1358                        return;
1359                    }
1360                }
1361            }
1362        }
1363
1364        // A finished task got its last read above
1365        followed.retain(|id, _| live.contains(id));
1366        first = false;
1367        time::sleep(TAIL_POLL).await;
1368    }
1369}
1370
1371#[cfg(test)]
1372mod tests;