c1652e2bc6
Pure move: split the three multi-feature server files into per-concern files, with no behaviour change - same package, same exported and unexported identifiers, same call graph, same tests. - internal/server/chat.go -> chat.go (broker seam, client token, dispatcher), chat_hub.go, chat_claims.go, chat_permissions.go, chat_sessions.go, chat_stream.go, chat_commands.go - internal/stage/model.go -> model.go, model_run.go, model_failure.go, model_validation.go - internal/pipeline/runs.go -> runs.go (read side), runs_schema.go, runs_create.go, runs_mutate.go, runs_sessions.go Checked before committing: - Packaged templates and internal/author/skill/references: neither refers to internal/server/chat.go, internal/stage/model.go or internal/pipeline/runs.go, so nothing there needed updating (the change is a move with no behaviour change). - gofmt -l on the three packages: clean. go build ./..., go vet ./... and go test ./... pass. go.mod/go.sum unchanged. - No test, docs, android/, install or Docker files touched. Known stale path pointers deliberately left to the single docs writer (shared docs) and out of scope (android/): docs/chat-verification.md and android/README.md name the old file paths.
95 lines
4.3 KiB
Go
95 lines
4.3 KiB
Go
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
|
|
}
|