2fe63012f9
The operator's chat list showed ~99 stray "New chat" entries. The listing was already fail-closed (registry-only); the fault was what got recorded: an automated UI check drives the real page, so its throwaway chat was recorded as an operator chat exactly like a manually created one and stayed in the list for ever (each run added one). Server: chat_create takes an optional ephemeral flag. The session is created, bootstrapped, usable, closable and reopenable exactly like any other, but its registry row is hidden, so chat_sessions never lists it. operator_sessions gains an ephemeral column (idempotent migration, existing rows default to listed) and the list query filters it; the single-row lookup does not, so close/reopen keep working. RecordVerificationSession is the hidden recorder. Web: the page marks a create ephemeral only when automation asks for it (__pipelinesEphemeralChat, set by the UI smoke for its throwaway chat), so the smoke's own runs stop polluting while a manual create is unchanged. Tests: a hidden row is never listed yet is still looked up and closable; a normal re-record of the same id lists it again; a pre-ephemeral database migrates with every existing chat still listed. Live data pruned separately (107 -> 8 registry rows, backed up).
151 lines
7.1 KiB
Go
151 lines
7.1 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
|
|
}
|
|
|
|
type chatPromptWithMessageID interface {
|
|
PromptWithMessageID(context.Context, string, string, string) error
|
|
}
|
|
|
|
type chatShellOutputReader interface {
|
|
ShellOutput(ctx context.Context, query protocol.ChatShellOutputQuery) (protocol.ChatShellOutputPage, 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
|
|
// RecordVerificationSession records a chat created for automated verification:
|
|
// a real, closable row that OperatorSessions never lists.
|
|
RecordVerificationSession(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
|
|
case protocol.ChatShells:
|
|
handleChatShells(ctx, request, broker, registry, write)
|
|
return true
|
|
case protocol.ChatShellOutput:
|
|
handleChatShellOutput(ctx, request, broker, registry, write)
|
|
return true
|
|
}
|
|
return false
|
|
}
|