e9d902213e
Reconcile authoritative shell snapshots with bounded lifecycle journals so concurrent exits and creates cannot be overwritten, coalesce observation setup, and retain verified ownership across reconnects. Add deterministic reconciliation and cancellation regressions plus stable limited-visibility handling.\n\nChecked packaged templates and authoring skill references: none need updating. The task-owned docs note records the stale shared chat documentation for docs-fold; shared documentation was not edited.
136 lines
6.2 KiB
Go
136 lines
6.2 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
"time"
|
|
|
|
"git.a-wan.net/alan/pipelines/internal/opencode"
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
)
|
|
|
|
// chatPermissionPollInterval is the fixed interval between permission polls: one
|
|
// GET per poll through the shared Connection bounds, never a busy loop. The first
|
|
// poll runs immediately so a request pending when a turn starts is surfaced
|
|
// without waiting a full interval.
|
|
const chatPermissionPollInterval = 2 * time.Second
|
|
|
|
// handleChatPrompt accepts a prompt from any client. It never rejects a prompt
|
|
// because another client is watching the session: the client attaches to the
|
|
// session's shared room and the prompt either starts a turn or is queued behind
|
|
// the one in flight, with the ack saying which. The prompt is echoed live to
|
|
// every other client, attributed to the sending device's label, and the turn's
|
|
// output is fanned out to all of them.
|
|
func handleChatPrompt(ctx context.Context, request protocol.Message, broker chatBroker, hub *chatHub, registry operatorRegistry, clientID string, write func(protocol.Message) error) {
|
|
if broker == nil {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "chat is not configured on this server"})
|
|
return
|
|
}
|
|
prompt := request.ChatPrompt
|
|
if prompt == nil {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a chat prompt payload is required"})
|
|
return
|
|
}
|
|
if !opencode.ValidSessionID(prompt.SessionID) {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a valid OpenCode session id is required"})
|
|
return
|
|
}
|
|
if strings.TrimSpace(prompt.Text) == "" {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a nonempty chat prompt is required"})
|
|
return
|
|
}
|
|
// Reject an oversized prompt before any OpenCode call; the bound matches the
|
|
// OpenCode request limit.
|
|
if len(prompt.Text) > opencode.MaxRequest {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "chat prompt exceeds 64 KiB"})
|
|
return
|
|
}
|
|
sessionID := prompt.SessionID
|
|
sub := hub.attach(sessionID, clientID, sanitizeChatClientLabel(prompt.Client), broker, write)
|
|
if sub == nil {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "could not attach to session " + sessionID})
|
|
return
|
|
}
|
|
// The user turn every *other* client sees, carrying the sender's label. The
|
|
// sender's own client appended it locally, so it is excluded below.
|
|
userFrame := protocol.ChatEventFrame{
|
|
SessionID: sessionID,
|
|
MessageID: hub.nextUserMessageID(),
|
|
Kind: protocol.ChatEventUser,
|
|
Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "usr", Text: prompt.Text},
|
|
Client: sub.label,
|
|
}
|
|
queued, refused := hub.submitPrompt(sessionID, &chatQueuedPrompt{
|
|
text: prompt.Text,
|
|
requestID: request.ID,
|
|
write: write,
|
|
})
|
|
if refused {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "session " + sessionID + " already has the maximum number of prompts queued"})
|
|
return
|
|
}
|
|
// Publish the user turn to every other client; the sender already has it.
|
|
hub.broadcastUser(userFrame, clientID)
|
|
if queued {
|
|
// The client that sent it is told the prompt is waiting for the in-flight
|
|
// turn, so it shows queued/steering instead of blocking or silently
|
|
// dropping the message. The turn runner acknowledges it once it runs, so
|
|
// clear the ack on the queued entry to avoid a second ack for the same id.
|
|
_ = write(protocol.Message{Type: protocol.ChatPrompt, ID: request.ID, ChatQueued: true})
|
|
}
|
|
if registry != nil {
|
|
// Recency is one UPDATE: it moves the operator session to the front of
|
|
// chat_sessions. A session id that is not an operator session updates no
|
|
// row and is not an error, so pipeline stage prompts are unaffected.
|
|
if err := registry.TouchOperatorSession(ctx, sessionID); err != nil {
|
|
// Best-effort; the turn runner also touches on delivery.
|
|
_ = err
|
|
}
|
|
}
|
|
}
|
|
|
|
// handleChatSubscribe attaches one connection to a session's shared stream so it
|
|
// receives every frame any client's turn produces, its own or another device's.
|
|
// It replays the session's still-pending approval requests, if the room holds
|
|
// any, so a device that joins late still shows the cards.
|
|
func handleChatSubscribe(request protocol.Message, broker chatBroker, hub *chatHub, clientID string, write func(protocol.Message) error) {
|
|
// The wire body of chat_subscribe is the chat_subscribe field (the app's
|
|
// subscribeRequest and docs/cli.md both use it), not the chat_query body the
|
|
// other session-scoped commands carry.
|
|
query := request.ChatSubscribe
|
|
if query == nil || !opencode.ValidSessionID(query.SessionID) {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a valid OpenCode session id is required"})
|
|
return
|
|
}
|
|
if broker == nil {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "chat is not configured on this server"})
|
|
return
|
|
}
|
|
sub := hub.attach(query.SessionID, clientID, "", broker, write)
|
|
if sub == nil {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "could not attach to session " + query.SessionID})
|
|
return
|
|
}
|
|
// Acknowledge before the stream is allowed to fan out: otherwise an immediately
|
|
// available retained shell can overtake the subscribe reply on this connection.
|
|
_ = write(protocol.Message{Type: protocol.ChatSubscribe, ID: request.ID})
|
|
if err := hub.ensureObserving(sub.room, broker); err != nil {
|
|
sub.close()
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "could not observe session " + query.SessionID})
|
|
return
|
|
}
|
|
// Replay every still-unresolved approval request the room holds, not only the
|
|
// most recent one, so a client that attaches after two requests were raised
|
|
// still sees both cards.
|
|
for _, pending := range hub.pendingFrames(query.SessionID) {
|
|
frame := pending
|
|
sub.send(protocol.Message{Type: protocol.ChatPermission, ChatPermission: &frame})
|
|
}
|
|
// Replay the background processes still running, so a device that attaches
|
|
// after they started (a reconnect, or a chat opened from another device)
|
|
// shows them rather than nothing until they exit. The message snapshot cannot
|
|
// carry a shell — a shell outlives the turn and is not a turn — so this is the
|
|
// shell half of the resume.
|
|
hub.replayShells(sub)
|
|
}
|