refactor(#2464): rename hive-ag3nt crate to hive-agent, collapse lib into main

hive-agent/src/web_ui/stream.rs

@@ -0,0 +1,77 @@
+//! Live SSE event stream + history endpoints.
+
+use std::convert::Infallible;
+
+use axum::Json;
+use axum::extract::{Query, State};
+use axum::response::sse::{Event, KeepAlive, Sse};
+use serde::Deserialize;
+use tokio_stream::{Stream, StreamExt, wrappers::BroadcastStream};
+
+use super::AppState;
+
+/// Query params for the paginated history endpoint.
+#[derive(Debug, Deserialize)]
+pub(super) struct HistoryParams {
+    /// Cursor: only return events with sqlite row id < `before`.
+    /// Omit for the initial (most-recent) page.
+    before: Option<i64>,
+    /// Page size (default 100, capped at `HISTORY_CAPACITY`).
+    limit: Option<usize>,
+}
+
+pub(super) async fn events_history(
+    State(state): State<AppState>,
+    Query(params): Query<HistoryParams>,
+) -> Json<serde_json::Value> {
+    use crate::events::HISTORY_CAPACITY;
+    let limit = params.limit.unwrap_or(100).min(HISTORY_CAPACITY);
+    let before = params.before;
+    let is_initial = before.is_none();
+
+    // Capture seq *before* the read on initial loads so the SSE dedupe
+    // window is "drop buffered events you've already seen in history",
+    // never "lose an event that fired between the read and the seq."
+    // On paginated loads (`before` is set) seq is not needed.
+    let seq = if is_initial {
+        Some(state.bus.current_seq())
+    } else {
+        None
+    };
+
+    let (events, min_id, has_more) = state.bus.history_page(before, limit);
+    let mut resp = serde_json::json!({
+        "events": events,
+        "min_id": min_id,
+        "has_more": has_more,
+    });
+    if let Some(s) = seq {
+        resp["seq"] = serde_json::json!(s);
+    }
+    Json(resp)
+}
+
+pub(super) async fn events_stream(
+    State(state): State<AppState>,
+) -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
+    tracing::info!("sse: client subscribed");
+    let rx = state.bus.subscribe();
+    // Prime THIS connection with a one-off "hello" so it can clear the
+    // connecting placeholder immediately. Injected into this subscriber's own
+    // stream rather than emitted to the bus — a bus emit would spam every
+    // already-connected client with a spurious note each time anyone opens
+    // the stream.
+    let hello = Event::default().data(
+        serde_json::to_string(&crate::events::LiveEvent::Note {
+            text: "live stream attached".into(),
+        })
+        .unwrap_or_default(),
+    );
+    let live = BroadcastStream::new(rx).filter_map(|res| {
+        let ev = res.ok()?;
+        let json = serde_json::to_string(&ev).ok()?;
+        Some(Ok(Event::default().data(json)))
+    });
+    let stream = tokio_stream::once(Ok(hello)).chain(live);
+    Sse::new(stream).keep_alive(KeepAlive::default())
+}