Files
archie/internal/app/archied/gateway.go
T
sam ca433865b0 fix(archied): build the Gateway's worktree manager so it serves review_pr
boot.prReviewer returns nil without a worktree manager, and a nil reviewer
omits review_pr from every channel's tool set. RunGateway never called
buildTreesAndIdentities, so the Gateway resolved a nil reviewer and no
channel could review a PR.

Extract the manager's construction into boot.buildWorktreeManager, called
by buildTreesAndIdentities (daemon, unchanged field-for-field) and by
startGatewayRuntime before setupGatewayChat. The Gateway does not call
buildTreesAndIdentities: that also registers daemon identity runners the
Gateway must not own, and PR review only needs a clone of the PR head,
which worktree.Manager.CheckoutPR does from the forge.

Pin the ordering by source position in composition_order_test.go, alongside
the memory-engine ordering the same function already carries, and pin both
compositions behaviourally in worktree_manager_composition_test.go: the
Gateway's step must yield a reviewer that advertises review_pr, and the
daemon must still build its root manager plus one runner per identity with
a distinct WorkDir.

Correct docs/prds/operator-pr-review.md, which still asserted the daemon
supplies ChatPRReviewer and holds the review in-flight set.
2026-09-22 03:44:45 +10:00

219 lines
8.1 KiB
Go

package archied
import (
"context"
"fmt"
"net"
"os"
"time"
natsio "github.com/nats-io/nats.go"
"google.golang.org/grpc"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/applystatus"
"github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/gateway"
"github.com/samcharles93/archie-core/internal/infrastructure/gatewayrpc"
"github.com/samcharles93/archie-core/internal/infrastructure/taskactions"
"github.com/samcharles93/archie-core/internal/plugin"
)
// GatewayOptions contains process inputs for the standalone Gateway.
type GatewayOptions struct {
Config string
Overlay string
Listen string
// Token is the Bearer [REDACTED] the Gateway server validates for a
// non-loopback listener. Empty falls back to
// [services.gateway].target_token.
Token string
}
// gatewayListenAndToken resolves the two per-listener inputs RunGateway needs:
// the address it binds and the bearer token a non-loopback bind validates.
//
// Both are flag-first and config-second, and both fail closed rather than
// inventing a value -- resolveServiceListen explains why an empty address is an
// error rather than a default.
func gatewayListenAndToken(b *boot, options GatewayOptions) (listen, token string, err error) {
listen, err = resolveServiceListen("gateway", options.Listen, b.cfg.Services.Get(config.ServiceNameGateway).Listen)
if err != nil {
return "", "", err
}
token = options.Token
if token == "" {
token = b.cfg.Services.ResolvedToken(config.ServiceNameGateway, b.secrets.Getenv)
}
return listen, token, nil
}
// RunGateway owns conversation persistence, model runtime and tool-provider
// lifecycles. Task-store adapters access the State Store contract (remote
// *staterpc.Client via [services.state].target), not archie.db directly: the
// single SQLite file is owned by archie-state-store, and the Gateway keeps its
// own already-separate session SQLite (docs/prds/state-store-contract.md §12
// step 8), which is out of state-store scope.
func RunGateway(ctx context.Context, options GatewayOptions) error {
b := newBootstrap()
b.processName = applystatus.Gateway
defer b.cleanup()
if err := b.loadConfig(ctx, options.Config, options.Overlay); err != nil {
return err
}
b.log = b.log.With("component", "gateway")
if err := b.openStores(ctx); err != nil {
return err
}
// The Gateway also no longer opens archie.db directly: it consumes the
// same remote State Store contract the daemon does via
// [services.state].target (docs/prds/state-store-contract.md §12 step 7).
// Its own session SQLite is untouched and stays Gateway-owned.
if err := b.openGatewayState(ctx); err != nil {
return err
}
b.loadCatalog(ctx, options.Config)
url, token := b.cfg.NATS.URL, ""
var nc *natsio.Conn
var err error
if b.cfg.NATS.Mode == config.NATSModeExternal { //nolint:nestif // external and embedded transports have distinct credential and discovery flows
token, err = configuredNATSToken(b.cfg.NATS, os.Getenv)
if err != nil {
return err
}
nc, err = natsio.Connect(url, natsio.Token(token))
} else {
var endpoint embeddedNATSEndpoint
endpoint, err = readEmbeddedNATSEndpoint(b.cfg.DBPath)
if err == nil {
url, token = endpoint.URL, endpoint.Token
nc, err = natsio.Connect(url, natsio.Token(token))
}
if nc == nil || err != nil {
url, token, err = b.startEmbeddedNATS(ctx)
if err != nil {
return err
}
nc, err = natsio.Connect(url, natsio.Token(token))
}
}
if err != nil {
return fmt.Errorf("connect gateway task actions: %w", err)
}
b.addCleanup(nc.Close)
// Held so /status can report this process's own broker connection: the
// health source reads it through boot rather than dialling.
b.taskActionsConn = nc
contract, err := b.startGatewayRuntime(ctx, taskactions.Client{Conn: nc, Timeout: 30 * time.Second})
if err != nil {
return err
}
listen, gatewayToken, err := gatewayListenAndToken(b, options)
if err != nil {
return err
}
//nolint:contextcheck // grpc.StreamServerInterceptor has no context.Context parameter; gatewayrpc.StreamServerInterceptor derives its context from stream.Context() instead
opts, loopback, err := gatewayServerOpts(listen, gatewayToken)
if err != nil {
return err
}
listener, err := (&net.ListenConfig{}).Listen(ctx, "tcp", listen)
if err != nil {
return fmt.Errorf("listen for gateway: %w", err)
}
defer listener.Close()
b.log.Info("archie-gateway running", "addr", listener.Addr().String(), "token_required", !loopback)
return serveGateway(ctx, listener, contract, b.chatSessionStore, opts)
}
func (b *boot) openGatewayState(ctx context.Context) error {
if err := b.openStateStoreAdapter(); err != nil {
return err
}
if err := b.loadRuntimeConfig(ctx); err != nil {
return fmt.Errorf("load runtime settings: %w", err)
}
go b.applyStatus.Run(ctx)
return nil
}
func (b *boot) startGatewayRuntime(ctx context.Context, actor gateway.ChatTaskActor) (gateway.ChatContract, error) {
b.bus = events.NewBus()
b.addCleanup(b.bus.Close)
b.capabilityHost = plugin.NewHost()
b.startRateLimiter(ctx, b.cfg.Chat.RateLimit)
// The Gateway owns PR review (docs/prds/operator-pr-review.md §4), so it
// composes the process-wide worktree manager before setupGatewayChat
// resolves boot.prReviewer: prReviewer returns nil without a manager, and
// a nil reviewer omits review_pr from every channel's tool set. The
// manager is the only part of the daemon's tree composition the Gateway
// takes -- it must not own identity runners, so it does not call
// buildTreesAndIdentities.
b.buildWorktreeManager()
// setupMemoryEngine must run before setupGatewayChat: setupGatewayChat
// constructs the turn runner, which captures b.memEngines at
// construction time (see the identical ordering note in main.go's Run).
if err := b.setupMemoryEngine(); err != nil { //nolint:contextcheck // setupMemoryEngine owns its own lifecycle context, matching the daemon's setupMemoryEngine
return nil, err
}
contract, err := b.setupGatewayChat(ctx, actor)
if err != nil {
return nil, err
}
if err := b.registerTools(ctx); err != nil {
return nil, err
}
b.registerStandaloneTools()
b.addCleanup(shutdownCapabilityHost(b.capabilityHost, b.log))
if err := b.capabilityHost.Start(ctx); err != nil {
return nil, fmt.Errorf("start gateway tool providers: %w", err)
}
for _, skipped := range b.providerRegistry.Skipped() {
b.log.Warn("gateway tool provider unavailable", "provider", skipped.ID, "err", skipped.Err)
}
return contract, nil
}
// gatewayServerOpts applies the transport security boundary: a loopback
// listener is served insecure with no token; any non-loopback address
// requires a Bearer [REDACTED], else the process fails closed. It mirrors
// stateStoreServerOpts, minus the State Store's task-scoped grants: the
// Gateway has one administrative token for all callers.
func gatewayServerOpts(listen, token string) (opts []grpc.ServerOption, loopback bool, err error) {
loopback, err = gatewayrpc.TargetIsLoopback(listen)
if err != nil {
return nil, false, err
}
if loopback {
return nil, true, nil
}
if token == "" {
return nil, false, fmt.Errorf(
"gateway listen address %q is non-loopback; non-loopback exposure requires a Bearer [REDACTED] (--token / [services.gateway].target_token) or TLS",
listen,
)
}
return []grpc.ServerOption{
grpc.ChainUnaryInterceptor(gatewayrpc.UnaryServerInterceptor(token)),
grpc.ChainStreamInterceptor(gatewayrpc.StreamServerInterceptor(token)),
}, false, nil
}
func serveGateway(ctx context.Context, listener net.Listener, contract gateway.ChatContract, sessions gateway.SessionStore, opts []grpc.ServerOption) error {
server := grpc.NewServer(opts...)
gatewayrpc.RegisterServer(server, contract, sessions)
serveErr := make(chan error, 1)
go func() { serveErr <- server.Serve(listener) }()
select {
case <-ctx.Done():
// A client can keep a streaming RPC open indefinitely. Allow draining,
// then force cancellation before closing the session store and tools.
timer := time.AfterFunc(10*time.Second, server.Stop)
server.GracefulStop()
timer.Stop()
return nil
case err := <-serveErr:
return err
}
}