package server import ( "context" "crypto/rand" "encoding/hex" "git.a-wan.net/alan/pipelines/internal/pipeline" "git.a-wan.net/alan/pipelines/internal/protocol" ) // chatBroker is the server-side OpenCode chat seam. *opencode.Chat implements // it; tests substitute a scripted broker. Keeping it an interface means the // /connect handler never builds a second OpenCode transport. type chatBroker interface { Prompt(ctx context.Context, sessionID, text string) error // Stream subscribes to the session's OpenCode event stream. ready is called // once the subscription is attached, before any frame is read, so the caller // can order the prompt after the subscription. Stream(ctx context.Context, sessionID string, ready func(), emit func(protocol.ChatEventFrame) error) error Interrupt(ctx context.Context, sessionID string) error Messages(ctx context.Context, sessionID string, limit int) ([]protocol.ChatMessage, error) // Sessions lists the endpoint's OpenCode sessions so the handler can // restrict them to the operator's own recorded sessions. Sessions(ctx context.Context) ([]protocol.ChatSession, error) // Create creates one OpenCode session in the given directory and returns it. Create(ctx context.Context, title, directory string) (protocol.ChatSession, error) // Session returns the endpoint's own record of one existing session so an // adopted session carries the endpoint's directory and title; found is false // when the endpoint does not list sessionID. Session(ctx context.Context, sessionID string) (protocol.ChatSession, bool, error) // Permissions lists the session's pending OpenCode approval requests so the // handler can push chat_permission frames. Permissions(ctx context.Context, sessionID string) ([]protocol.ChatPermissionFrame, error) Reply(ctx context.Context, request protocol.ChatReplyRequest) error } // operatorRegistry is the server-side operator-session seam. *pipeline.Store // satisfies it. It is a table of its own, separate from the pipeline stage // ownership (SessionOwner/run_session_owners) that settles a run: chat_sessions // lists operator sessions only and never consults stage ownership. type operatorRegistry interface { RecordOperatorSession(ctx context.Context, sessionID, directory, title, tag string) error TouchOperatorSession(ctx context.Context, sessionID string) error OperatorSessions(ctx context.Context) ([]pipeline.OperatorSession, error) OperatorDirectories(ctx context.Context, limit int) ([]string, error) } // chatClientToken returns an unguessable per-connection identity. It attributes // a session claim so two clients on the same server cannot silently write the // same conversation; a fresh token per connection means a reconnected client is // a new writer and must re-claim. func chatClientToken() string { var b [8]byte if _, err := rand.Read(b[:]); err != nil { return "conn-unknown" } return "conn-" + hex.EncodeToString(b[:]) } // handleChat dispatches one chat_* request. It returns true when the request was // a chat type and has been fully answered (the caller must not fall through to // the generic response). Frames are pushed after the ack, each through the // connection-scoped write function so the read loop and the stream goroutine // never interleave partial websocket writes. func handleChat(ctx context.Context, request protocol.Message, broker chatBroker, hub *chatHub, registry operatorRegistry, clientID string, write func(protocol.Message) error) bool { switch request.Type { case protocol.ChatPrompt: handleChatPrompt(ctx, request, broker, hub, registry, clientID, write) return true case protocol.ChatMessages: handleChatMessages(ctx, request, broker, hub, write) return true case protocol.ChatInterrupt: handleChatSimple(ctx, request, broker, hub, write) return true case protocol.ChatReply: handleChatSimple(ctx, request, broker, hub, write) return true case protocol.ChatSessions: handleChatSessions(ctx, request, broker, hub, registry, clientID, write) return true case protocol.ChatCreate: handleChatCreate(ctx, request, broker, registry, write) return true case protocol.ChatAdopt: handleChatAdopt(ctx, request, broker, registry, write) return true case protocol.ChatDirectories: handleChatDirectories(ctx, request, registry, write) return true } return false }