Files
pipelines/cmd/pipelines-server/main.go
T
alan c810437aa5 Claude Code chats survive server restarts in a detachable host
A pipelines-claude-host process owns each claude -p CLI and its pipes,
spools its stream-json output with offsets and serves a private Unix
socket. The server detaches on shutdown and reattaches on start,
replaying the spool to rebuild turns, approvals, questions, background
tasks and the live model. Explicit close, idle release and CLI exit stop
the host; a crashed host falls back to --resume with a notice.
2026-11-04 16:09:56 +00:00

169 lines
7.4 KiB
Go

package main
import (
"context"
"errors"
"flag"
"log"
"net/http"
"os"
"os/signal"
"path/filepath"
"syscall"
"time"
"git.a-wan.net/alan/pipelines/internal/buildinfo"
"git.a-wan.net/alan/pipelines/internal/claude"
"git.a-wan.net/alan/pipelines/internal/discovery"
"git.a-wan.net/alan/pipelines/internal/opencode"
"git.a-wan.net/alan/pipelines/internal/paths"
"git.a-wan.net/alan/pipelines/internal/pipeline"
"git.a-wan.net/alan/pipelines/internal/protocol"
"git.a-wan.net/alan/pipelines/internal/server"
"git.a-wan.net/alan/pipelines/internal/summarise"
)
func main() {
addr := flag.String("addr", "127.0.0.1:8080", "HTTP/WebSocket listen address")
allowAuthoring := flag.Bool("allow-authoring", false, "Explicitly enable pipeline definition publication (disabled on execution servers by default)")
// -opencode-endpoint opts in to brokering chat from an operator-supplied
// OpenCode service instead of the spawned default. Its default is the
// environment variable, so both are the same opt-in; the recorded choice (set
// by a previous run) is used when neither is present.
endpoint := flag.String("opencode-endpoint", os.Getenv(opencode.EndpointEnvKey), "Broker chat from this OpenCode endpoint instead of spawning one")
defaultDB, err := paths.Database()
if err != nil {
log.Fatal(err)
}
db := flag.String("db", defaultDB, "SQLite database path (honors XDG_DATA_HOME)")
mdnsOn := flag.Bool("mdns", envEnabled(os.Getenv("PIPELINES_MDNS")), "Advertise the server on the LAN with mDNS/DNS-SD ("+discovery.ServiceType+"); PIPELINES_MDNS=off disables")
mdnsPort := flag.Int("mdns-port", envPort(os.Getenv("PIPELINES_MDNS_PORT")), "Port LAN clients dial: the authenticated web proxy fronting this server (default: the -addr port when it is not loopback)")
flag.Parse()
if err := os.MkdirAll(filepath.Dir(*db), 0700); err != nil {
log.Fatal(err)
}
store, err := pipeline.Open(*db)
if err != nil {
log.Fatal(err)
}
defer store.Close()
if err := store.AcquireServerLock(); err != nil {
log.Fatal(err)
}
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
defer stop()
artifactsRoot := filepath.Join(filepath.Dir(*db), "artifacts")
// Each new run gets a bounded one-line title from the configured default
// harness; the summariser falls back to the prompt's first line, so title
// generation never blocks or fails run creation.
options := server.Options{AllowAuthoring: *allowAuthoring, ArtifactsRoot: artifactsRoot, RunTitles: summarise.GenerateTitle, StepVerdicts: summarise.GenerateVerdictReason, VerificationFixtures: server.VerificationFixturesFromEnvironment(os.Getenv)}
recorded := ""
if value, err := store.OpenCodeEndpoint(ctx); err != nil {
log.Printf("OpenCode endpoint setting unreadable: %v", err)
} else {
recorded = value
}
reference := opencode.ResolveEndpointRef(*endpoint, os.Getenv(opencode.EndpointEnvKey), recorded)
// Chat brokers OpenCode over one endpoint. When the operator configured an
// endpoint (flag, environment or a previously recorded choice) the broker
// attaches to it: it uses the password-file credential if one was supplied,
// otherwise it pairs once with the operator's local OpenCode service
// credential, stores the paired token owner-only beside the pipeline
// database and reuses it across restarts. An endpoint that cannot be
// attached is a log line and a status note, and chat then falls back to the
// server's own OpenCode instance rather than staying refused. Only a
// URL-bearing, SSE-capable connection enables chat; otherwise chat stays
// disabled and every chat_* request is answered with a protocol error naming
// the missing configuration rather than hanging.
openCodeStatus := protocol.ServiceStatus{Health: "unavailable"}
if reference != "" {
explicit, explicitErr := opencode.ReadEndpointCredentialFile(os.Getenv(opencode.EndpointPasswordFileEnvKey))
if explicitErr != nil {
log.Printf("OpenCode endpoint password file unreadable: %v", explicitErr)
}
// The pair bootstrap (the operator's local service credential) is only
// needed when no explicit password was supplied; a password-file setup
// therefore logs nothing here.
bootstrap := ""
if explicit == "" {
setting, _ := opencode.ServiceCredentialPath()
value, bootstrapErr := opencode.ReadServiceCredential(setting)
if bootstrapErr != nil {
log.Printf("OpenCode local service credential unreadable: %v", bootstrapErr)
}
bootstrap = value
}
credentialPath := filepath.Join(filepath.Dir(*db), "opencode-endpoint.json")
attach, attachErr := opencode.OpenEndpointAttached(ctx, reference, explicit, bootstrap, credentialPath)
if attachErr != nil {
log.Printf("OpenCode endpoint %s could not be attached (%v); falling back to the server's own OpenCode instance", reference, attachErr)
openCodeStatus = protocol.ServiceStatus{Health: "fallback", URL: reference}
} else {
options.Chat = opencode.NewChat(attach.Connection)
defer attach.Connection.Close()
openCodeStatus = protocol.ServiceStatus{Health: "endpoint", URL: reference}
if attach.Note != "" {
log.Printf("OpenCode endpoint %s: %s", reference, attach.Note)
}
if err := store.RecordOpenCodeEndpoint(ctx, reference); err != nil {
log.Printf("record OpenCode endpoint: %v", err)
}
}
}
if options.Chat == nil {
if conn, err := opencode.OpenChat(ctx, opencode.Executable(), ""); err != nil {
log.Printf("OpenCode chat unavailable: %v", err)
} else if conn.URL == "" {
conn.Close()
log.Printf("OpenCode chat unavailable: the connection exposes no streamable event endpoint")
} else {
options.Chat = opencode.NewChat(conn)
defer conn.Close()
if openCodeStatus.Health == "unavailable" {
openCodeStatus = protocol.ServiceStatus{Health: "spawned", URL: conn.URL}
}
}
}
// If neither the endpoint nor the spawned instance enabled chat, report that
// honestly rather than claiming the fallback is serving chat.
if options.Chat == nil && openCodeStatus.Health != "endpoint" {
openCodeStatus.Health = "unavailable"
}
options.OpenCodeStatus = openCodeStatus
// One manager routes each chat to its owning harness. OpenCode remains the
// default; Codex is attached when its app-server control socket is present.
// Claude Code chats run in detachable hosts scoped to this database, so a
// restart does not end them (internal/claudehost).
claude.ConfigureHosts(claude.DefaultHostDir(*db))
chats := server.NewChatManager(ctx, options.Chat, store)
if len(chats.Backends()) > 0 {
options.Chat = chats
defer chats.Close()
}
srv := &http.Server{Addr: *addr, Handler: server.HandlerWithOptions(ctx, options, store), ReadHeaderTimeout: 5 * time.Second}
defer server.WaitRuns(srv.Handler)
go func() {
<-ctx.Done()
shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := srv.Shutdown(shutdownCtx); err != nil {
log.Printf("shutdown: %v", err)
}
}()
var chatNames []string
if len(chats.Backends()) > 0 {
chatNames = chats.Backends()
}
if *mdnsOn {
if stopMDNS := advertise(*addr, *mdnsPort); stopMDNS != nil {
defer stopMDNS()
}
}
printBanner(startup{Build: buildinfo.Current(), Addr: *addr, Database: *db, Artifacts: artifactsRoot,
Authoring: *allowAuthoring, OpenCode: openCodeStatus, Chat: chatNames})
log.Printf("listening on %s (WebSocket endpoint: /connect)", *addr)
if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
log.Fatal(err)
}
}