package dashboard import ( "context" "fmt" "net/http" "time" "github.com/danielgtaylor/huma/v2" "github.com/samcharles93/archie-core/internal/platform/httpapi" "github.com/samcharles93/archie-core/internal/platform/hub" chatpkg "github.com/samcharles93/archie-core/modules/chat" "github.com/samcharles93/archie-core/modules/governance" ) // keepalive is how often an idle stream writes a comment, so proxies keep // the connection open and the browser notices one that died. const keepalive = 25 * time.Second // chatOutcome is the frame the dashboard re-reads the open conversation on. const chatOutcome = `data: {"topic":"tasks","data":{"kind":"chat_outcome"}}` + "\n\n" // Register adds the dashboard's live stream: the one EventSource the SPA // keeps open, framing each update as `data: {"topic":…,"data":…}`. A settled // chat action is the only update with a dashboard reader; a turn's own reply // streams from the chat API. Keepalives tell the connection indicator the // server is up, and a reconnect makes every mounted page re-read. func Register(api huma.API, h *hub.Hub) { httpapi.Register(api, httpapi.Authorized(governance.ActionRead, governance.KindDashboard), huma.Operation{ OperationID: "stream-dashboard", Method: http.MethodGet, Path: "/api/stream", Summary: "Stream live dashboard updates", Tags: []string{"Dashboard"}, Responses: map[string]*huma.Response{"200": { Description: "Server-sent events: one data frame of {\"topic\", \"data\"} per update, and a keepalive comment while idle", Content: map[string]*huma.MediaType{"text/event-stream": {Schema: &huma.Schema{Type: huma.TypeString}}}, }}, }, func(ctx context.Context, _ *struct{}) (*huma.StreamResponse, error) { // A conversation is its owner's; nobody else hears that it changed. var chat <-chan hub.Note stop := func() {} if p, ok := governance.PrincipalFromContext(ctx); ok && p.IdentityID != "" { chat, stop = h.Subscribe(chatpkg.OwnerTopic(string(p.IdentityID))) } return &huma.StreamResponse{Body: func(hc huma.Context) { defer stop() serve(hc, chat) }}, nil }) } func serve(hc huma.Context, chat <-chan hub.Note) { w := hc.BodyWriter() flusher, ok := w.(http.Flusher) if !ok { hc.SetStatus(http.StatusInternalServerError) return } hc.SetHeader("Content-Type", "text/event-stream") hc.SetHeader("Cache-Control", "no-store") hc.SetStatus(http.StatusOK) flusher.Flush() tick := time.NewTicker(keepalive) defer tick.Stop() for { frame := ": keepalive\n\n" select { case <-hc.Context().Done(): return case <-tick.C: case _, ok := <-chat: if !ok { // The hub dropped a reader that fell behind; it reconnects // and re-reads. return } frame = chatOutcome } if _, err := fmt.Fprint(w, frame); err != nil { return } flusher.Flush() } }