Files
archie/modules/dashboard/stream.go
T
samandCopilot cf6108ad14 feat(chat): conversations belong to their person and act with their access (#2065)
Sessions carry an owner; every chat route serves only the caller's own
conversations (others are 404). Each turn and each approved held action
acts as its owner's principal, checked against the access rules before
judgement, so an operator's chat can't do what the operator can't. Chat is
open to any signed-in person, and the stream sends chat updates only to
the owner.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-11-20 19:05:20 +11:00

84 lines
2.7 KiB
Go

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) {
huma.Register(api, httpapi.SignedIn(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()
}
}