6cb61578de
A session was owned by one connection: the claim map in chat_claims.go let the
first client hold it, every other client saw the session Busy and read-only, and
a second client's prompt was rejected. Replace the claim with a per-session
"room" so the operator's phone, tablet and terminal all watch and write the same
conversation, and a pending approval is a shared, exactly-once object.
Server (internal/server, internal/protocol):
- New chat_room.go: one room per session holding the session's single broker
stream, its one bounded prompt queue (8) and the fan-out to every attached
client. A chat_subscribe frame attaches a connection to a session's shared
stream and replays the still-unresolved approval requests the room holds.
- chat_stream.go: handleChatPrompt accepts a prompt from any client. It attaches
the sender, either starts a turn or queues the prompt behind the in-flight turn
and acknowledges it with chat_queued:true ("queued" is the chosen behaviour,
stated on the wire and in docs/cli.md), and echoes the user turn to every other
client attributed to the sender's label. The prompt handler no longer owns the
stream; one turn runner per room drains the queue, so two turns never
interleave. Per-connection write serialisation is unchanged (each chatSub has
its own writer goroutine and bounded buffer).
- chat_permissions.go / chat_commands.go: an approval is reserved by the first
answer and confirmed once delivered; the first answer wins, is recorded with
the answering client's label, and the resolution is pushed to every watching
client as chat_permission with resolved/decision/resolved_by so their cards
clear. A later answer is refused with an error naming the client that answered,
and never reaches the agent twice; a reservation whose reply failed is
released.
- chat_hub.go / chat_sessions.go / chat.go: the hub now owns rooms and the
user-turn id sequence; the resulting user turns are retained (role and client
carried) so a reconnect re-syncs who said what. chat_sessions no longer marks a
session Busy and its clientID parameter is gone; the protocol keeps the Busy
field for wire compatibility only. websocket.go detaches a connection's chat
subscriptions when the read loop ends.
- chat_claims.go is removed, not left vestigial: the only exclusive thing left is
a turn, and the room's queue is that.
App (android):
- PipelinesRepository carries a stable per-device client label (Build.MODEL, with
a fallback) on prompts and replies, and adds chatSubscribe; AppViewModel
subscribes on opening a chat (best-effort, an older server's error frame does
not stop history loading) and records the queued ack.
- ChatStore folds a user frame from another client into the transcript once,
attributed by the sender's label, and never receives its own prompt back, so
the sender's own message is never duplicated. ChatThread.readOnly is gone:
canSend no longer depends on another client, the composer says "Queued - it
will send when the current turn finishes." instead of disabling input, and the
status label is Running/Idle only. Scroll/follow behaviour is untouched.
- Tests: ChatProtocolTest round-trips the new wire fields, ChatFormatTest asserts
the stale Busy flag cannot produce a read-only label, MultiChatStateTest asserts
a session another client watches stays writable.
Reflected where it belongs: no packaged template changes (no bundled starter
embeds the chat protocol). Checked the packaged authoring skill references: none
of them describes the chat wire beyond operations.md, and
internal/author/skill/references/operations.md is now stale - its "Brokered
OpenCode chat" section still says chat_sessions marks "busy" when another client
holds the session and that a second client's chat_prompt is rejected, and it does
not mention chat_subscribe, the per-session prompt queue/chat_queued, the
per-client label or the shared exactly-once approval (it also still describes the
per-subscription permission poller, which the room's single poller replaced). The
supported semantics are the ones in docs/cli.md, updated in this commit; the
operations.md section needs a rewrite to match. No README or other shared
document was edited here.
Checks run on the committed tree: gofmt -l internal cmd examples (nothing), go
build ./..., go vet ./internal/... ./cmd/..., go test ./internal/server
./internal/protocol ./internal/stage ./internal/pipeline.
123 lines
5.5 KiB
Go
123 lines
5.5 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
|
|
}
|
|
_ = write(protocol.Message{Type: protocol.ChatSubscribe, ID: request.ID})
|
|
// 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})
|
|
}
|
|
}
|