Files
archie/internal/app/agentworker/worker.go
T

209 lines
8.2 KiB
Go

// Package agentworker composes and runs Archie's NATS-connected agent worker.
package agentworker
import (
"context"
"log/slog"
"net/http"
"os"
"time"
"github.com/samcharles93/archie-core/internal/agentexec"
"github.com/samcharles93/archie-core/internal/domain/workflow"
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
"github.com/samcharles93/archie-core/internal/infrastructure/agentboot"
"github.com/samcharles93/archie-core/internal/infrastructure/agentgit"
agentnats "github.com/samcharles93/archie-core/internal/infrastructure/agenttransport/nats"
"github.com/samcharles93/archie-core/internal/infrastructure/egress"
"github.com/samcharles93/archie-core/internal/infrastructure/workflowsteps"
"github.com/samcharles93/archie-core/internal/logging"
"github.com/samcharles93/archie-core/internal/storage"
"github.com/samcharles93/archie-core/internal/taskrun"
"github.com/samcharles93/archie-core/internal/tools"
)
const rpcTimeout = 60 * time.Second
// StartupError reports which worker startup operation failed. The application
// logs the operation-specific failure once; the command only maps it to exit 1.
type StartupError struct {
Operation string
Err error
}
func (e *StartupError) Error() string { return e.Operation + ": " + e.Err.Error() }
func (e *StartupError) Unwrap() error { return e.Err }
// Settings are process-derived inputs for one worker runtime.
type Settings struct {
NATSURL string
WorkDir string
// StateStoreTarget and StateStoreToken are the daemon-injected State Store
// gRPC endpoint and bearer token. StateStoreTarget is required: the legacy
// NATS storerpc path is deleted.
StateStoreTarget string
StateStoreToken string
// StateStoreCA is the PEM CA the State Store's certificate chains to.
StateStoreCA []byte
// ModelProxy, ModelProxyHosts and ModelProxyCA route model provider
// requests through the daemon's egress proxy, which holds the keys.
// Empty ModelProxy sends them directly.
ModelProxy string
ModelProxyHosts []string
ModelProxyCA string
}
type workerTransport interface {
taskServiceTransport
Close()
LogPublisher() agentexec.LogPublisher
SubscribeTasks(context.Context, int64, agentnats.TaskHandler, *slog.Logger) (agentnats.Subscription, error)
}
type workerDependencies struct {
connect func(context.Context, agentnats.Config, *slog.Logger) (workerTransport, error)
markSafe func(context.Context, string, *slog.Logger) bool
bootID func(string) (int64, error)
wait func(context.Context, *slog.Logger)
// steps is the workflow step vocabulary this process compiles pinned
// definitions against, registered by the composition root before the first
// task is served (infrastructure/workflowsteps is the provider set).
steps *workflow.Manager
// guardrails is the guardrail engine every served task records agent-stage
// outcomes against, built once at this process's composition root.
// archie-agent is the process that runs the stages, so the engine that
// observes them lives here; a live engine cannot cross the task handoff.
guardrails *tools.GuardrailEngine
}
// productionWorkerDependencies builds the worker's process dependencies.
func productionWorkerDependencies() (workerDependencies, error) {
steps, err := workflowsteps.NewManager()
if err != nil {
return workerDependencies{}, err
}
return workerDependencies{
connect: func(ctx context.Context, config agentnats.Config, log *slog.Logger) (workerTransport, error) {
return agentnats.Connect(ctx, config, log)
},
markSafe: agentgit.MarkSafe,
bootID: agentboot.TaskID,
wait: func(ctx context.Context, log *slog.Logger) {
<-ctx.Done()
log.InfoContext(ctx, "archie-agent shutting down")
},
steps: steps,
guardrails: tools.NewGuardrailEngine(tools.DefaultGuardrailConfig()),
}, nil
}
// Run starts the worker, serves full-task requests, and returns after ctx
// cancellation or a startup failure.
func Run(ctx context.Context, settings Settings, log *slog.Logger) error {
dependencies, err := productionWorkerDependencies()
if err != nil {
return &StartupError{Operation: "register workflow step vocabulary", Err: err}
}
return run(ctx, settings, log, dependencies)
}
func run(ctx context.Context, settings Settings, log *slog.Logger, dependencies workerDependencies) error {
if log == nil {
log = slog.New(slog.DiscardHandler)
}
workDir := settings.WorkDir
if workDir == "" {
workDir = storage.WorktreeMountDir
}
var modelTransport http.RoundTripper
if settings.ModelProxy != "" {
var err error
modelTransport, err = egress.ModelTransport(settings.ModelProxy, settings.ModelProxyHosts, settings.ModelProxyCA)
if err != nil {
return &StartupError{Operation: "model proxy", Err: err}
}
}
// Commands run with no directory of their own run in the worktree. The
// runtime's starting directory is not it: an OpenShell sandbox starts
// elsewhere, and a resumed stage carries no directory.
if err := os.Chdir(workDir); err != nil {
return &StartupError{Operation: "enter worktree", Err: err}
}
dependencies.markSafe(ctx, workDir, log)
// The task is known before connecting: the worker logs in as its task,
// with its run credential.
taskID, err := dependencies.bootID(workDir)
if err != nil {
log.ErrorContext(ctx, "task boot failed", "err", err)
return &StartupError{Operation: "task boot failed", Err: err}
}
transport, err := dependencies.connect(ctx, agentnats.Config{
URL: settings.NATSURL,
TaskID: taskID,
StateStoreURL: settings.StateStoreTarget,
StateStoreToken: settings.StateStoreToken,
StateStoreCA: settings.StateStoreCA,
}, log)
if err != nil {
operation := "nats connect failed"
log.ErrorContext(ctx, operation, "err", err)
return &StartupError{Operation: operation, Err: err}
}
defer transport.Close()
log = slog.New(logging.WithTrace(agentexec.NewSystemLogHandler(log.Handler(), transport.LogPublisher(), taskID)))
log.InfoContext(ctx, "system log publisher attached", "task", taskID)
subscription, err := transport.SubscribeTasks(ctx, taskID, func(ctx context.Context, request taskrun.Request) (*taskrun.Response, error) {
return executeTaskRequest(ctx, request, transport, workDir, log, dependencies.steps, dependencies.guardrails, modelTransport)
}, log)
if err != nil {
log.ErrorContext(ctx, "taskrun subscribe failed", "err", err)
return &StartupError{Operation: "taskrun subscribe failed", Err: err}
}
defer func() {
if err := subscription.Close(); err != nil {
log.WarnContext(ctx, "task run unsubscribe failed", "err", err)
}
}()
log.InfoContext(ctx, "archie-agent ready", "nats", settings.NATSURL)
dependencies.wait(ctx, log)
return nil
}
type taskServiceTransport interface {
Forger(identity, credential string, timeout time.Duration) workflow.Forger
Messenger(identity, credential string, timeout time.Duration) workflow.Messenger
Store(time.Duration) workflow.Store
Calls(time.Duration) task.Caller
Trees(string, string, time.Duration) agentnats.RemoteTrees
EventPublisher() agentexec.EventPublisher
}
func executeTaskRequest(ctx context.Context, request taskrun.Request, transport taskServiceTransport, workDir string, log *slog.Logger, steps *workflow.Manager, guardrails *tools.GuardrailEngine, modelTransport http.RoundTripper) (*taskrun.Response, error) {
log.InfoContext(ctx, "running task", "task", request.Task.ID, "repo", request.Repo.FullName(), "issue", request.Task.IssueNumber)
dependencies := taskDependencies{
forge: transport.Forger(request.Task.Identity, request.RunCredential, rpcTimeout),
messenger: transport.Messenger(request.Task.Identity, request.RunCredential, rpcTimeout),
store: transport.Store(rpcTimeout),
calls: transport.Calls(rpcTimeout),
trees: transport.Trees(request.Task.Identity, request.RunCredential, rpcTimeout),
events: transport.EventPublisher(),
steps: steps,
guardrails: guardrails,
modelTransport: modelTransport,
}
response, err := runTask(ctx, request, dependencies, newTaskRunner(modelTransport), workDir, log)
if err != nil {
log.ErrorContext(ctx, "task run failed", "task", request.Task.ID, "err", err)
return nil, err
}
log.InfoContext(ctx, "task run complete", "task", request.Task.ID, "status", response.Status)
return response, nil
}