1mod 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
48pub 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");
58const APP_JS: &str = include_str!(env!("ORCH_WEB_JS"));
60const 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 codes: Arc<Mutex<HashMap<String, Instant>>>,
71}
72
73#[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 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 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#[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
321struct 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
378async 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
397pub 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
410pub 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
490pub 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
503fn 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
523fn 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
552async 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 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
636fn 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
683async 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 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
711async 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
725fn 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
734async 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
770async 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 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
839async 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
866async 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
936fn 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
945fn 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
974fn 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 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
992fn 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
1017async 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(¤t) != 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, ¤t, &req.text, &state.join("config-backups")));
1045 if let Err(e) = saved {
1046 return internal(&e);
1047 }
1048
1049 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
1068async 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 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
1106async 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
1159async 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
1205async 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
1285async 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 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 followed.retain(|id, _| live.contains(id));
1366 first = false;
1367 time::sleep(TAIL_POLL).await;
1368 }
1369}
1370
1371#[cfg(test)]
1372mod tests;