Replace the service bearer tokens with [tls] ca_file and cert_dir. Caller identity comes from the verified certificate, not metadata. Without TLS, services listen and dial on loopback only. Task containers get only the CA and keep their grant.
186 lines
5.8 KiB
Go
186 lines
5.8 KiB
Go
// Command archie-agent runs Archie's NATS-connected agent worker.
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"log/slog"
|
|
"net"
|
|
"os"
|
|
"os/signal"
|
|
"strings"
|
|
"syscall"
|
|
|
|
"github.com/samcharles93/archie-core/internal/app/agentworker"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/egress"
|
|
)
|
|
|
|
type workerRunner func(context.Context, agentworker.Settings, *slog.Logger) error
|
|
|
|
// runHold blocks until signalled and exits 0. It is the keepalive for a Kit
|
|
// container that runs no worker: the agent binary is archie's own and is
|
|
// mounted into every Kit, so the container needs no binary the image may not
|
|
// ship, and holds no environment of its own.
|
|
func runHold() int {
|
|
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
|
|
defer stop()
|
|
<-ctx.Done()
|
|
return 0
|
|
}
|
|
|
|
func main() {
|
|
os.Exit(run())
|
|
}
|
|
|
|
func run() int {
|
|
return runCommand(os.Args[1:], os.Getenv, os.Stderr, agentworker.Run)
|
|
}
|
|
|
|
func runCommand(args []string, getenv func(string) string, stderr io.Writer, runWorker workerRunner) int {
|
|
if len(args) > 0 && args[0] == "hold" {
|
|
return runHold()
|
|
}
|
|
if len(args) > 0 && args[0] == "relay" {
|
|
return runRelay(args[1:], stderr, agentworker.RunRelay)
|
|
}
|
|
if len(args) > 0 && args[0] == "mcp" {
|
|
return runMCP(args[1:], stderr, agentworker.RunCaptureMCP)
|
|
}
|
|
flags := flag.NewFlagSet("archie-agent", flag.ContinueOnError)
|
|
flags.SetOutput(stderr)
|
|
natsURLFlag := flags.String("nats-url", "", "NATS server URL (defaults to NATS_URL)")
|
|
stateStoreURLFlag := flags.String("state-store-url", "", "State Store gRPC target (defaults to STATE_STORE_URL; required -- the legacy NATS storerpc path is deleted)")
|
|
stateStoreTokenFlag := flags.String("state-store-token", "", "State Store bearer token (defaults to STATE_STORE_TOKEN)")
|
|
if err := flags.Parse(args); err != nil {
|
|
if errors.Is(err, flag.ErrHelp) {
|
|
return 0
|
|
}
|
|
return 2
|
|
}
|
|
|
|
natsURL, natsToken := natsConnectionSettings(*natsURLFlag, getenv)
|
|
if natsURL == "" {
|
|
fmt.Fprintln(stderr, "error: -nats-url or NATS_URL is required")
|
|
flags.Usage()
|
|
return 1
|
|
}
|
|
|
|
log := slog.New(slog.NewJSONHandler(stderr, nil))
|
|
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
|
|
defer stop()
|
|
|
|
stateStoreURL := *stateStoreURLFlag
|
|
if stateStoreURL == "" {
|
|
stateStoreURL = getenv("STATE_STORE_URL")
|
|
}
|
|
if stateStoreURL == "" {
|
|
fmt.Fprintln(stderr, "error: -state-store-url or STATE_STORE_URL is required (the legacy NATS storerpc path is deleted)")
|
|
flags.Usage()
|
|
return 1
|
|
}
|
|
stateStoreToken := *stateStoreTokenFlag
|
|
if stateStoreToken == "" {
|
|
stateStoreToken = getenv("STATE_STORE_TOKEN")
|
|
}
|
|
|
|
if err := runWorker(ctx, agentworker.Settings{
|
|
NATSURL: natsURL,
|
|
NATSToken: natsToken,
|
|
StateStoreTarget: stateStoreURL,
|
|
StateStoreToken: stateStoreToken,
|
|
StateStoreCA: []byte(getenv("STATE_STORE_CA")),
|
|
ModelProxy: getenv(egress.ModelProxyEnv),
|
|
ModelProxyHosts: egress.ParseHosts(getenv(egress.ModelProxyHostsEnv)),
|
|
ModelProxyCA: getenv(egress.ModelProxyCAEnv),
|
|
}, log); err != nil {
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func natsConnectionSettings(flagURL string, getenv func(string) string) (url, token string) {
|
|
url = flagURL
|
|
if url == "" {
|
|
url = getenv("NATS_URL")
|
|
}
|
|
return url, getenv("NATS_TOKEN")
|
|
}
|
|
|
|
type relayServer func(ctx context.Context, forwards map[string]string) error
|
|
|
|
// runRelay is the sandbox egress relay: the container on both a sandbox's
|
|
// isolated network and the host-reachable one, forwarding a fixed set of
|
|
// ports to the proxy, NATS and the State Store.
|
|
func runRelay(args []string, stderr io.Writer, serve relayServer) int {
|
|
flags := flag.NewFlagSet("archie-agent relay", flag.ContinueOnError)
|
|
flags.SetOutput(stderr)
|
|
forwards := map[string]string{}
|
|
flags.Func("forward", "listen=target: forward connections on listen to target (repeatable)", func(v string) error {
|
|
listen, target, ok := strings.Cut(v, "=")
|
|
if !ok || listen == "" || target == "" {
|
|
return fmt.Errorf("%q is not listen=target", v)
|
|
}
|
|
if _, _, err := net.SplitHostPort(listen); err != nil {
|
|
return fmt.Errorf("listen address %q: %w", listen, err)
|
|
}
|
|
if _, _, err := net.SplitHostPort(target); err != nil {
|
|
return fmt.Errorf("target %q: %w", target, err)
|
|
}
|
|
if _, dup := forwards[listen]; dup {
|
|
return fmt.Errorf("listen address %q is forwarded twice", listen)
|
|
}
|
|
forwards[listen] = target
|
|
return nil
|
|
})
|
|
if err := flags.Parse(args); err != nil {
|
|
if errors.Is(err, flag.ErrHelp) {
|
|
return 0
|
|
}
|
|
return 2
|
|
}
|
|
if len(forwards) == 0 {
|
|
fmt.Fprintln(stderr, "error: at least one -forward is required")
|
|
flags.Usage()
|
|
return 1
|
|
}
|
|
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
|
|
defer stop()
|
|
if err := serve(ctx, forwards); err != nil {
|
|
fmt.Fprintln(stderr, "error:", err)
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type mcpServer func(ctx context.Context, specPath, capturesPath string) error
|
|
|
|
// runMCP serves a stage's capture tools to a harness over stdio. The
|
|
// harness starts it, so it runs as the harness user and holds no secrets.
|
|
func runMCP(args []string, stderr io.Writer, serve mcpServer) int {
|
|
flags := flag.NewFlagSet("archie-agent mcp", flag.ContinueOnError)
|
|
flags.SetOutput(stderr)
|
|
spec := flags.String("spec", "", "JSON file listing the stage's capture tools")
|
|
captures := flags.String("captures", "", "file accepted capture calls are appended to")
|
|
if err := flags.Parse(args); err != nil {
|
|
if errors.Is(err, flag.ErrHelp) {
|
|
return 0
|
|
}
|
|
return 2
|
|
}
|
|
if *spec == "" || *captures == "" {
|
|
fmt.Fprintln(stderr, "error: -spec and -captures are required")
|
|
flags.Usage()
|
|
return 1
|
|
}
|
|
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
|
|
defer stop()
|
|
if err := serve(ctx, *spec, *captures); err != nil {
|
|
fmt.Fprintln(stderr, "error:", err)
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|