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: prompt.NativeMessageID, Kind: protocol.ChatEventUser, Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "usr", Text: prompt.Text}, Client: sub.label, OperationID: prompt.OperationID, } if userFrame.MessageID == "" { userFrame.MessageID = hub.nextUserMessageID() } queued, refused := hub.submitPrompt(sessionID, &chatQueuedPrompt{ text: prompt.Text, operationID: prompt.OperationID, nativeID: userFrame.MessageID, 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) }