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::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
49pub 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");
59const APP_JS: &str = include_str!(env!("ORCH_WEB_JS"));
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'";
63
64#[derive(Clone)]
65struct App {
66 store: Arc<TaskStore>,
67 events: broadcast::Sender<TaskEvent>,
68 token: Arc<str>,
69 host: Arc<str>,
70 codes: Arc<Mutex<HashMap<String, Instant>>>,
72}
73
74#[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 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 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#[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
322struct 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
379async 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
398pub 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
411pub 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
491pub 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
504fn 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
524fn 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
553async 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 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
637fn 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
684async 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 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
712async 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
726fn 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
735async 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
771async 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 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
840async 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
867async 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
937fn 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
946fn version_of(text: &str) -> String {
948 let mut hasher = DefaultHasher::new();
949 text.hash(&mut hasher);
950 format!("{:016x}", hasher.finish())
951}
952
953fn 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
987fn 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 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
1005fn 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
1030async 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(¤t) != 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, ¤t, &req.text, &state.join("config-backups")));
1061 if let Err(e) = saved {
1062 return internal(&e);
1063 }
1064
1065 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
1084async 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 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
1122async 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
1175async 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
1221async 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
1301async 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 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 followed.retain(|id, _| live.contains(id));
1382 first = false;
1383 time::sleep(TAIL_POLL).await;
1384 }
1385}
1386
1387#[cfg(test)]
1388mod tests;