18398dfa5b
chat_sessions used to list exactly the OpenCode sessions the pipelines own,
filtered through pipeline.SessionOwner (run_steps/run_session_owners), so an
operator-created chat was an accident of the run-ownership table and the
operator's working sessions were mixed with the internals of running pipelines.
Add a first-class operator session:
- internal/pipeline/operator_sessions.go: a dedicated operator_sessions table
(session_id PK, directory, title, tag, created_at, last_used_at) with
RecordOperatorSession (upsert preserving created_at), a one-statement
TouchOperatorSession (no-op for a non-operator id), OperatorSessions bounded to
128 rows most-recently-used first, and OperatorDirectories (bounded MRU,
deduped). run_steps/run_session_owners and SessionOwner/OwnedSessions are
untouched.
- internal/server/chat.go: chat_sessions returns operator sessions only - it
reads the registry once, intersects it with one broker session-list call, fills
directory/tag/created/updated from the registry, sets busy for a session held
by another connection, keeps MRU order, and stays fail-closed (empty list, never
the endpoint's whole list). A pipeline stage session and an untagged row can
never be listed. chat_create resolves the directory (empty/'~'/'~/...' ->
operator home; relative or missing rejected before any OpenCode call), calls
broker.Create(title, resolved) and records the row with the operator tag.
chat_directories returns home first then bounded (8) deduped recents. A
successful prompt touches the operator session without affecting pipeline
prompts.
- internal/opencode, internal/protocol, internal/server/websocket.go and
message.go: unscoped session list, Create posts {"title":...,
"location":{"directory":...}} to POST /api/session, additive protocol fields
(omitempty) and the ChatDirectories request/response, plus the OperatorRegistry
option defaulting to the first store. One OpenCode transport per server is
unchanged.
Docs and references: docs/cli.md gains a "Chat sessions" section documenting the
operator-only fail-closed list, directory defaulting/rejection, chat_directories
(home first, deduped, bounded 8) and why a dedicated request was chosen.
internal/author/skill/references/operations.md's stale "Brokered OpenCode chat"
text (chat_create unbrokered, run_steps filtering, "listed the owned scratch
session" evidence) is rewritten to the operator-session registry, the fail-closed
filter, directory defaulting and the corrected live-test wording. No new
reference file, so internal/author/install.go's inventory is unchanged.
Checked for staleness elsewhere: README.md, the docs/ topic pages and the
packaged server/TUI templates carry no chat-session ownership claims, so none
needed updating.
Verified: gofmt -l clean; go vet and go build ./... clean; go test -count=1
./internal/pipeline/... ./internal/protocol/... ./internal/opencode/...
./internal/server/... and the full go test -count=1 ./... pass.
318 lines
12 KiB
Go
318 lines
12 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"log"
|
|
"net/http"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/coder/websocket"
|
|
"github.com/coder/websocket/wsjson"
|
|
|
|
"git.a-wan.net/alan/pipelines/examples"
|
|
"git.a-wan.net/alan/pipelines/internal/buildinfo"
|
|
"git.a-wan.net/alan/pipelines/internal/pipeline"
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
"git.a-wan.net/alan/pipelines/internal/summarise"
|
|
)
|
|
|
|
// Options configures the HTTP handler.
|
|
type Options struct {
|
|
// ArtifactsRoot overrides where stage artifacts live. Empty uses the store's
|
|
// directory (the database's parent), matching the data-directory default.
|
|
ArtifactsRoot string
|
|
// Chat brokers OpenCode chat traffic over /connect. Nil answers every
|
|
// chat_* request with a protocol error; a configured server passes an
|
|
// *opencode.Chat bound to the owned endpoint.
|
|
Chat chatBroker
|
|
// OperatorRegistry is the operator-session registry chat_sessions lists and
|
|
// chat_create/chat_directories read. When nil, HandlerWithOptions derives it
|
|
// from the first store; when neither is available chat_sessions returns an
|
|
// empty list (never the endpoint's whole session list) and chat_create is
|
|
// refused. Purely pipeline stage ownership is unaffected.
|
|
OperatorRegistry operatorRegistry
|
|
// RunTitles generates the operator-facing title stored with each new run.
|
|
// When nil, run creation stores the prompt-derived fallback without a model
|
|
// call, which keeps tests and unconfigured servers deterministic.
|
|
RunTitles func(context.Context, string) summarise.Title
|
|
// StepVerdicts generates the bounded one-line reason stored with each
|
|
// completed stage visit. When nil, the store derives the verdict's reason at
|
|
// read time with no model call, which keeps tests and unconfigured servers
|
|
// deterministic.
|
|
StepVerdicts func(context.Context, map[string]any) string
|
|
}
|
|
|
|
// Handler serves the persistent connection with default options. Canceling ctx
|
|
// stops active clients.
|
|
func Handler(ctx context.Context, stores ...*pipeline.Store) http.Handler {
|
|
return HandlerWithOptions(ctx, Options{}, stores...)
|
|
}
|
|
|
|
// HandlerWithOptions serves the persistent connection and the stage-artifact
|
|
// endpoint. Canceling ctx stops active clients.
|
|
func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipeline.Store) http.Handler {
|
|
build := buildinfo.Current()
|
|
started := time.Now()
|
|
hub := newChatHub()
|
|
events := newRunEventHub()
|
|
mux := http.NewServeMux()
|
|
var runs *runner
|
|
var runErr error
|
|
if len(stores) > 0 {
|
|
runs, runErr = newRunner(ctx, stores[0])
|
|
if runErr == nil {
|
|
runs.events = events
|
|
}
|
|
if runErr == nil && options.ArtifactsRoot != "" {
|
|
runs.artifactsRoot = options.ArtifactsRoot
|
|
}
|
|
if runErr == nil && options.RunTitles != nil {
|
|
runs.title = options.RunTitles
|
|
}
|
|
if runErr == nil && options.StepVerdicts != nil {
|
|
runs.verdict = options.StepVerdicts
|
|
}
|
|
if runErr == nil {
|
|
runs.schedulerWG.Add(1)
|
|
go runs.scheduleLoop()
|
|
}
|
|
}
|
|
// chat_sessions lists the operator's own recorded sessions. Prefer an
|
|
// injected registry; otherwise derive it from the store. With neither, the
|
|
// handler fails closed to an empty list.
|
|
registry := options.OperatorRegistry
|
|
if registry == nil && len(stores) > 0 {
|
|
registry = stores[0]
|
|
}
|
|
mux.HandleFunc("GET /artifacts/{run}/{step}/{name...}", func(w http.ResponseWriter, r *http.Request) {
|
|
if runs == nil {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
runs.serveArtifact(w, r)
|
|
})
|
|
mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if runErr != nil {
|
|
w.WriteHeader(http.StatusServiceUnavailable)
|
|
_, _ = w.Write([]byte(`{"healthy":false}`))
|
|
return
|
|
}
|
|
_, _ = w.Write([]byte(`{"healthy":true}`))
|
|
})
|
|
mux.HandleFunc("GET /connect", func(w http.ResponseWriter, r *http.Request) {
|
|
conn, err := websocket.Accept(w, r, nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
defer conn.CloseNow()
|
|
conn.SetReadLimit(2 << 20)
|
|
// connCtx is canceled when this connection's read loop returns, so a
|
|
// chat subscription started for the client stops on disconnect. A single
|
|
// write mutex serializes the read loop's responses and the chat stream
|
|
// goroutine, which must never interleave partial websocket writes.
|
|
connCtx, connCancel := context.WithCancel(ctx)
|
|
defer connCancel()
|
|
var writeMu sync.Mutex
|
|
write := func(message protocol.Message) error {
|
|
// Every server frame (responses, the welcome and chat events) carries
|
|
// the build identity and protocol so an older client fails fast or
|
|
// warns once instead of silently misreading a field. build is
|
|
// computed once per handler.
|
|
if message.Build == nil {
|
|
message.Build = &build
|
|
}
|
|
if message.Protocol == 0 {
|
|
message.Protocol = protocol.ProtocolVersion
|
|
}
|
|
writeMu.Lock()
|
|
defer writeMu.Unlock()
|
|
writeCtx, cancel := context.WithTimeout(connCtx, 5*time.Second)
|
|
defer cancel()
|
|
return wsjson.Write(writeCtx, conn, message)
|
|
}
|
|
// clientID is this connection's identity for chat session claims: a
|
|
// second client is refused a session another connection holds.
|
|
clientID := chatClientToken()
|
|
// Drop every run subscription this connection holds when the read loop
|
|
// returns, so no subscriber, goroutine or timer outlives the connection.
|
|
defer events.unsubscribeClient(clientID)
|
|
if len(stores) > 0 {
|
|
items, err := stores[0].List(ctx)
|
|
if err != nil {
|
|
log.Printf("list pipelines: %v", err)
|
|
return
|
|
}
|
|
if err := write(protocol.Message{Type: protocol.PipelineList, Pipelines: items, NotificationEndpoints: notificationEndpoints()}); err != nil {
|
|
return
|
|
}
|
|
}
|
|
for {
|
|
var request protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &request); err != nil {
|
|
return
|
|
}
|
|
log.Printf("command received: client=%s type=%q id=%q pipeline=%d version=%d", r.RemoteAddr, request.Type, request.ID, request.PipelineID, request.Version)
|
|
if handleChat(connCtx, request, options.Chat, hub, registry, clientID, write) {
|
|
continue
|
|
}
|
|
if handleRunEvents(request, events, runs, clientID, write) {
|
|
continue
|
|
}
|
|
response := protocol.Message{Type: protocol.Pong, ID: request.ID}
|
|
if request.Type == protocol.List || request.Type == protocol.Submit {
|
|
response.NotificationEndpoints = notificationEndpoints()
|
|
}
|
|
if request.Type == protocol.GetStatus {
|
|
response.Type = protocol.Status
|
|
response.Status = systemStatus(r, started, runErr)
|
|
} else if request.Type == protocol.Ping {
|
|
response.Time = time.Now().UTC().Format(time.RFC3339)
|
|
} else if request.Type == protocol.ListTemplates {
|
|
response.Type = protocol.Templates
|
|
response.Templates = examples.Catalog()
|
|
model, backend := starterDefaults()
|
|
for i := range response.Templates {
|
|
response.Templates[i].Source = pipeline.WithDefaults(response.Templates[i].Source, model, backend)
|
|
}
|
|
} else if request.Type == protocol.Validate {
|
|
graph, err := pipeline.Parse(request.Source)
|
|
response.Type = protocol.Validated
|
|
if err != nil {
|
|
response.Type = protocol.Error
|
|
response.Error = err.Error()
|
|
} else {
|
|
response.Graph = &graph
|
|
}
|
|
} else if request.Type == protocol.Submit && len(stores) > 0 {
|
|
response.Type = protocol.Submitted
|
|
response.Name = strings.TrimSpace(request.Name)
|
|
version, err := stores[0].SubmitChecked(ctx, request.Name, request.Source, request.CreateOnly, request.ExpectedVersion)
|
|
if err != nil {
|
|
response.Type = protocol.Error
|
|
response.Error = err.Error()
|
|
} else {
|
|
response.Version = version
|
|
response.Pipelines, err = stores[0].List(ctx)
|
|
if err != nil {
|
|
log.Printf("list pipelines after submission: %v", err)
|
|
}
|
|
for _, item := range response.Pipelines {
|
|
if item.Name == response.Name {
|
|
response.Detail, err = stores[0].Get(ctx, item.ID, version)
|
|
if err != nil {
|
|
log.Printf("load submitted pipeline: %v", err)
|
|
}
|
|
break
|
|
}
|
|
}
|
|
}
|
|
} else if request.Type == protocol.GetPipeline && len(stores) > 0 {
|
|
response.Type = protocol.Pipeline
|
|
detail, err := stores[0].Get(ctx, request.PipelineID, request.Version)
|
|
if err != nil {
|
|
response.Type = protocol.Error
|
|
response.Error = err.Error()
|
|
} else {
|
|
response.Detail = detail
|
|
}
|
|
} else if request.Type == protocol.List && len(stores) > 0 {
|
|
response.Type = protocol.PipelineList
|
|
response.DefaultModel, response.DefaultHarness = starterDefaults()
|
|
items, err := stores[0].List(ctx)
|
|
if err != nil {
|
|
response.Type = protocol.Error
|
|
response.Error = err.Error()
|
|
} else {
|
|
response.Pipelines = items
|
|
}
|
|
} else if request.Type == protocol.Search {
|
|
if len(stores) == 0 {
|
|
response.Type = protocol.Error
|
|
response.Error = "search unavailable: no store"
|
|
} else if request.Search == nil {
|
|
response.Type = protocol.Error
|
|
response.Error = "search requires a query"
|
|
} else {
|
|
response.Type = protocol.SearchResults
|
|
var err error
|
|
response.SearchResults, err = stores[0].Search(ctx, *request.Search, time.Now())
|
|
if err != nil {
|
|
response.Type = protocol.Error
|
|
response.Error = err.Error()
|
|
}
|
|
}
|
|
} else if runs != nil && (request.Type == protocol.RunPipeline || request.Type == protocol.RetryRun || request.Type == protocol.ListRuns || request.Type == protocol.GetRun || request.Type == protocol.CancelRun || request.Type == protocol.DecideRun || request.Type == protocol.SetRunTitle || request.Type == protocol.GetRunEvidence) {
|
|
var err error
|
|
switch request.Type {
|
|
case protocol.GetRunEvidence:
|
|
response.Type = protocol.RunEvidence
|
|
response.Evidence, err = runs.evidence(ctx, request.RunID)
|
|
case protocol.RunPipeline:
|
|
response.Type = protocol.RunStarted
|
|
response.RunDetail, err = runs.start(request)
|
|
case protocol.RetryRun:
|
|
response.Type = protocol.RunStarted
|
|
response.RunDetail, err = runs.retry(request)
|
|
case protocol.DecideRun:
|
|
response.Type = protocol.Run
|
|
response.RunDetail, err = runs.decide(request)
|
|
case protocol.SetRunTitle:
|
|
response.Type = protocol.Run
|
|
response.RunDetail, err = runs.setTitle(request.RunID, request.Title)
|
|
case protocol.ListRuns:
|
|
response.Type = protocol.Runs
|
|
response.Runs, err = runs.listRuns()
|
|
if err == nil {
|
|
response.Usage, err = stores[0].UsageStats(ctx)
|
|
}
|
|
case protocol.GetRun:
|
|
response.Type = protocol.Run
|
|
response.RunDetail, err = runs.getRun(request.RunID)
|
|
case protocol.CancelRun:
|
|
response.Type = protocol.Run
|
|
err = runs.cancel(request.RunID)
|
|
if err == nil {
|
|
response.RunDetail, err = runs.getRun(request.RunID)
|
|
}
|
|
}
|
|
if err != nil {
|
|
response.Type = protocol.Error
|
|
response.Error = err.Error()
|
|
}
|
|
} else {
|
|
response.Type = protocol.Error
|
|
response.Error = "unknown command: " + request.Type
|
|
if runErr != nil {
|
|
response.Error = "execution unavailable: " + runErr.Error()
|
|
}
|
|
}
|
|
if err := write(response); err != nil {
|
|
log.Printf("write response: %v", err)
|
|
return
|
|
}
|
|
selectedVersion := response.Version
|
|
if response.Detail != nil {
|
|
selectedVersion = response.Detail.Version
|
|
}
|
|
log.Printf("response sent: client=%s type=%q id=%q time=%q error=%q version=%d", r.RemoteAddr, response.Type, response.ID, response.Time, response.Error, selectedVersion)
|
|
}
|
|
})
|
|
return &runHandler{Handler: mux, runner: runs}
|
|
}
|
|
|
|
type runHandler struct {
|
|
http.Handler
|
|
runner *runner
|
|
}
|
|
|
|
// WaitRuns drains active execution before the database is closed on shutdown.
|
|
func WaitRuns(handler http.Handler) {
|
|
if h, ok := handler.(*runHandler); ok && h.runner != nil {
|
|
h.runner.schedulerWG.Wait()
|
|
h.runner.wg.Wait()
|
|
}
|
|
}
|