Files
pipelines/internal/server/chat_activity.go
T
alan 45c933c176 Chat list: spinner and background-task badge from server activity on every row
The list applies chat_activity pushes and each row's activity by seq, so
every listed chat shows a running turn, not only the chat open here. An
idle chat with running background tasks wears a quiet badge with tooltip and
semantics "Background tasks running (N)". Older servers keep the old
behaviour. List rows that never changed carry the server's current seq so
they order after snapshots kept from an earlier server process.
2026-11-03 19:53:52 +00:00

125 lines
4.5 KiB
Go

package server
import (
"time"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// Chat list activity: every listed chat shows whether its turn is running and
// whether background tasks (shells, background commands, subagents) are still
// running after the turn. Room frames reach only the connections that opened
// that chat, so the hub keeps a small per-session summary and pushes each
// change to every connection as chat_activity, and chat_sessions carries the
// current summary on each row.
//
// The summary is derived from the hub's own state only (no broker call, no
// I/O), under the hub mutex, at the points where that state changes: a turn
// admitted or finished, a step announcing or ending a turn, a shell starting
// or exiting, a shell readback reconciling the set, and a room released.
// Anything else, including every text or tool chunk, never touches it.
//
// A session's background tasks are counted only while it has a room, i.e.
// while the hub observes its stream (a viewer, or unattended observation, see
// chat_unattended.go). Once the room is released its shell exits are no
// longer seen, so the count drops to zero rather than going stale.
// chatActivityLocked computes the session's current summary. Callers hold h.mu.
func (h *chatHub) chatActivityLocked(sessionID string) protocol.ChatActivity {
activity := protocol.ChatActivity{SessionID: sessionID}
room := h.rooms[sessionID]
if room == nil {
return activity
}
activity.TurnRunning = room.running || room.observedTurn
activity.BackgroundTasks = h.backgroundTasksLocked(sessionID)
return activity
}
// backgroundTasksLocked counts the session's retained running shells. Callers
// hold h.mu.
func (h *chatHub) backgroundTasksLocked(sessionID string) int {
if turn := h.turns[sessionID]; turn != nil {
return len(turn.shells)
}
return 0
}
// noteActivityLocked recomputes the session's summary and, only when the turn
// state or the background-task count changed, records it under a new sequence
// number and pushes it to every connection. Callers hold h.mu; the push itself
// never blocks (chatSessionChanges writes on its own goroutines).
func (h *chatHub) noteActivityLocked(sessionID string) {
if sessionID == "" {
return
}
next := h.chatActivityLocked(sessionID)
previous := h.activity[sessionID]
if previous.TurnRunning == next.TurnRunning && previous.BackgroundTasks == next.BackgroundTasks {
return
}
if h.activity == nil {
h.activity = map[string]protocol.ChatActivity{}
}
next.Seq = h.nextActivitySeqLocked()
// The record keeps the last sequence of an idle session too, so a list
// row's Seq never moves backwards behind a push a client already applied.
// It holds one small entry per session that was ever active.
h.activity[sessionID] = next
h.sessionChanges.broadcastActivity(next)
}
// nextActivitySeqLocked returns a strictly increasing sequence. It starts from
// the wall clock in microseconds (exact in a JavaScript number) so snapshots
// after a server restart still order after the ones a client held before.
func (h *chatHub) nextActivitySeqLocked() int64 {
if h.activitySeq == 0 {
h.activitySeq = time.Now().UnixMicro()
}
h.activitySeq++
return h.activitySeq
}
// activitySnapshot returns the current summary of each session in ids, each
// with the sequence of its last recorded change. A session that has not
// changed since this server started carries the current sequence instead, so
// it still orders after anything a client kept from a previous server process
// and before any later push.
func (h *chatHub) activitySnapshot(ids []string) map[string]protocol.ChatActivity {
out := make(map[string]protocol.ChatActivity, len(ids))
if h == nil {
return out
}
h.mu.Lock()
defer h.mu.Unlock()
if h.activitySeq == 0 {
h.activitySeq = time.Now().UnixMicro()
}
for _, id := range ids {
activity := h.chatActivityLocked(id)
activity.Seq = h.activitySeq
if recorded, ok := h.activity[id]; ok {
activity.Seq = recorded.Seq
}
out[id] = activity
}
return out
}
// broadcastActivity pushes one session's activity to every connection,
// including the one whose action caused it (it has no reply carrying it).
func (c *chatSessionChanges) broadcastActivity(activity protocol.ChatActivity) {
c.mu.Lock()
targets := make([]func(protocol.Message) error, 0, len(c.clients))
for _, write := range c.clients {
targets = append(targets, write)
}
c.mu.Unlock()
for _, write := range targets {
body := activity
go func() {
_ = write(protocol.Message{Type: protocol.ChatActivityChanged, ChatActivity: &body})
}()
}
}