5946f1abc8
Use an explicit chat_create operation_id as the durable bootstrap key while retaining envelope IDs for reply correlation. Legacy requests receive fresh server-scoped identities, so independent cli-1/android-1 requests do not collide; clients that retry retain one operation_id. Update Android creation state and repository calls to preserve an operation identity across retries, and cover durable reconnect retries, duplicate barriers, changed input, legacy correlation reuse, and protocol serialization. Checked packaged templates: none describe chat_create. Checked packaged authoring-skill references: the existing description is stale, but shared references and README must not be edited by an item; docs/notes/bootstrap-create-identity.md records the required docs-fold update and rollout compatibility.
134 lines
6.4 KiB
Go
134 lines
6.4 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"strconv"
|
|
"sync/atomic"
|
|
|
|
"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, cursor string) (protocol.ChatHistoryPage, 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)
|
|
// ActivateSkill explicitly attaches a registered OpenCode skill before a chat can receive its first prompt.
|
|
ActivateSkill(ctx context.Context, sessionID, skill string) 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)
|
|
// Shells returns only shell operations whose ownership is authoritatively
|
|
// verified for sessionID. It is the reconnect/readback source.
|
|
Shells(ctx context.Context, sessionID string) ([]protocol.ChatShell, error)
|
|
Reply(ctx context.Context, request protocol.ChatReplyRequest) error
|
|
}
|
|
|
|
// chatShellReleaser is implemented by brokers that retain verified shell ids for
|
|
// attributing exit events. The hub calls it only after the last observer leaves
|
|
// a room; a later attach obtains a fresh authoritative snapshot.
|
|
// This is a bounded local-cache operation: it must not perform I/O or call the
|
|
// hub, which serializes it with room replacement under its mutex.
|
|
type chatShellReleaser interface {
|
|
ReleaseShells(sessionID string)
|
|
}
|
|
|
|
// 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 {
|
|
BeginChatCreate(ctx context.Context, requestID, title, directory string) (pipeline.ChatCreateBootstrap, error)
|
|
SetChatCreateSession(ctx context.Context, requestID, sessionID string) error
|
|
AdvanceChatCreate(ctx context.Context, requestID, from, to string) error
|
|
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)
|
|
// OperatorSession returns one recorded operator session by id (found false
|
|
// when the id is not an operator session), so chat_close/chat_reopen can echo
|
|
// the updated row and refuse a session that is not theirs.
|
|
OperatorSession(ctx context.Context, sessionID string) (pipeline.OperatorSession, bool, error)
|
|
// CloseOperatorSession records the closed state; ReopenOperatorSession clears
|
|
// it. Neither deletes anything, and neither touches a pipeline-owned run
|
|
// session (which has no operator_sessions row).
|
|
CloseOperatorSession(ctx context.Context, sessionID string) error
|
|
ReopenOperatorSession(ctx context.Context, sessionID string) error
|
|
}
|
|
|
|
var chatTokenSequence atomic.Uint64
|
|
|
|
// chatClientToken returns an unguessable per-connection identity. Its only role
|
|
// is to key a connection's chat-room subscriptions and to exclude the sender from
|
|
// its own fan-out; it carries no ownership. A fresh token per connection means a
|
|
// reconnected client is a new identity and simply reattaches.
|
|
func chatClientToken() string {
|
|
var b [8]byte
|
|
if _, err := rand.Read(b[:]); err != nil {
|
|
return "conn-fallback-" + strconv.FormatUint(chatTokenSequence.Add(1), 10)
|
|
}
|
|
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.ChatSubscribe:
|
|
handleChatSubscribe(request, broker, hub, 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, 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
|
|
case protocol.ChatClose:
|
|
handleChatClose(ctx, request, broker, hub, registry, write)
|
|
return true
|
|
case protocol.ChatReopen:
|
|
handleChatReopen(ctx, request, registry, write)
|
|
return true
|
|
}
|
|
return false
|
|
}
|