0ba1204895
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.
334 lines
12 KiB
Go
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()
|
|
}
|
|
}
|