Files
pipelines/internal/server/websocket.go
T
alan 0ba1204895 chat: attach to the operator's own OpenCode by pairing, fall back honestly
Brokered chat accepted an operator-supplied endpoint (-opencode-endpoint /
PIPELINES_OPENCODE_ENDPOINT) but failed closed against the operator's running
V2 service: that API authenticates every request with HTTP Basic auth (fixed
user "opencode" plus a password), the broker had no credential, so the health
probe answered 401 and startup logged "OpenCode endpoint ... is unreachable or
is not an OpenCode service", disabling chat entirely.

Established from the installed binary (opencode v2.0.20), not from docs:
`opencode --help` advertises `api`, `pair`, `serve`, `service` and `auth`;
`GET /api/info` is unauthenticated-401 with www-authenticate Basic realm
"Secure Area"; Basic auth user `opencode` with the password from
~/.local/state/opencode/service.json answers 200; `POST /api/pair` returns a
code and `GET /auth/connect/{code}` returns a token that is then accepted as
the Basic password.

- internal/opencode/pair.go (new): PairEndpoint does the pair exchange over the
  shared nativeRequest transport (same auth, bounds and JSON checks);
  ReadServiceCredential reads the operator's local service password under the
  private-file rule; OpenEndpointAttached resolves the credential in precedence
  order - explicit password file, a paired token stored by an earlier run, then
  a fresh pairing bootstrapped by the local service credential - stores the
  token owner-only and re-pairs once when a stored token is refused (401).
- internal/opencode/endpoint.go: OpenEndpoint wraps probeEndpoint, which returns
  the connection even on failure; Connection.unauthorized (set on HTTP 401 by
  the request paths, cleared per probe) distinguishes an authentication refusal
  from any other refusal.
- cmd/pipelines-server/main.go: the endpoint attach uses OpenEndpointAttached
  with the paired-credential file beside the pipeline database. An endpoint that
  cannot be attached logs a line naming it and falls back to the server's own
  OpenCode instance instead of leaving chat refused.
- internal/protocol/status.go, internal/server/websocket.go: get_status gains an
  opencode object (health = endpoint | fallback | spawned | unavailable, plus
  the endpoint url), the honest status evidence for the fallback. No credential
  is ever placed there.
- Tests: internal/opencode/pair_test.go, internal/protocol/status_test.go and a
  TestStatusReportsOpenCodeAttachment case in internal/server/status_test.go.

Repository checks: go build ./..., go vet ./... and gofmt -l . clean;
go test ./internal/... ./cmd/... green.

Packaged templates and skill references: the repository has no template tree
that mentions the OpenCode endpoint, and no packaged reference file is added, so
internal/author/install.go's managed inventory is unchanged. The packaged
authoring reference internal/author/skill/references/operations.md (the endpoint
paragraph around line 289, the "clear refusal and no fallback" wording and the
password-file/username-only credential story, and the missing opencode status
field) is now stale; per the maintenance convention the item does not edit the
shared document and instead records the stale points, with the exact wording
they should take, in docs/notes/chat-persistence.md for the docs-fold writer.
2026-10-18 00:55:26 +01:00

334 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
// OpenCodeStatus is the honest report of how chat is attached to OpenCode,
// echoed on get_status: "endpoint" when the broker is attached to the
// operator's configured endpoint, "fallback" when that endpoint could not be
// attached and chat fell back to the server's own instance, "spawned" when
// no endpoint is configured, and "unavailable" when chat is disabled. It
// carries the endpoint URL but never a credential.
OpenCodeStatus protocol.ServiceStatus
// 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]
}
hub.baseCtx = ctx
hub.registry = registry
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)
// Drop every chat subscription too, so a chat room held only by this
// connection releases its broker stream and turn runner.
defer hub.detachClient(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)
// How chat is attached to OpenCode is part of the server's status:
// a configured endpoint that could not be attached reports
// "fallback" here rather than silently disappearing.
response.Status.OpenCode = options.OpenCodeStatus
} 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()
}
}