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>
84 lines
2.7 KiB
Go
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()
|
|
}
|
|
}
|