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