* refactor(state-store): delete NATS storerpc; agent store is gRPC-only (archie-core-8cda.4.6) The agent is fully on the gRPC State Store contract, so the legacy NATS storerpc path is dead (docs/prds/state-store-contract.md §12 step 4): - delete internal/storerpc (Server, Client, subjects) and its tests - drop the storerpc registration from registerTaskRPCServers and the now-unused store param - make the agent transport's State Store URL required and Store() return only the gRPC staterpc.Client (no NATS fallback) - rework agentworker/agent transport tests to back the store with a real gRPC State Store server instead of the deleted NATS storerpc server The agent binary now fails fast when STATE_STORE_URL is absent. Agent store calls (workflow.Store) go over gRPC to the archie-state-store service. * refactor(state-store): delete daemon/gateway in-process store ownership (archie-core-8cda.4.6) The daemon and gateway no longer open archie.db in-process: the single SQLite file is owned by the standalone archie-state-store process, and both consumers dial its gRPC State StateStore contract (docs/prds/state-store-contract.md §12 step 7, no dual-store ownership). - openStores no longer opens the production task store or seeds b.st; it only wires secrets/forge and the gateway conversation store - openStateStoreAdapter now requires [services.state].target (the old local default is deleted) and resolves b.stateStore as the remote *staterpc.Client - delete the in-process startStateStoreServer (the multiplexed gRPC server and its per-task bearer-token registry) from the daemon composition - RunGateway now resolves the same remote State Store adapter; its session SQLite stays Gateway-owned and untouched - daemon.ConnectedStateStore carries the configured target plus the resolved bearer token, which containerEnv injects as STATE_STORE_URL / STATE_STORE_TOKEN so archie-agent authenticates to the same remote service - readiness store probe reads b.stateStore PRD-consistent choice (noted): with the in-process server gone, per-task token generation is removed; the daemon/gateway/agent all present the single [services.state].target_token (or STATE_STORE_TOKEN secret) that the standalone store validates. * docs(webui): require [services.state].target in config and deployment templates (archie-core-8cda.4.6) After the in-process store path is deleted, archied and archie-gateway dial the standalone archie-state-store gRPC service via [services.state].target and never open archie.db themselves (docs/prds/state-store-contract.md §12 step 7). - config.example.toml documents [services.state].target as required, with the loopback vs Docker-bridge gateway + target_token rule - deployment templates set [services.state] per topology: bridge gateway + token for container-mode agents, loopback for host-only - deployments/README.md and systemd-user-service.md describe start commands for both topologies and drop the stale "not yet consumed by the daemon" note * style: gofumpt alignment for State Store daemon literal; appease noctx/staticcheck (archie-core-8cda.4.6) * docs(state-store): refresh stale in-process references post-cutover (archie-core-8cda.4.6)
155 lines
5.5 KiB
Go
155 lines
5.5 KiB
Go
// Package agentworker composes and runs Archie's NATS-connected agent worker.
|
|
package agentworker
|
|
|
|
import (
|
|
"context"
|
|
"log/slog"
|
|
"time"
|
|
|
|
"github.com/samcharles93/archie-core/internal/agentexec"
|
|
"github.com/samcharles93/archie-core/internal/domain/workflow"
|
|
"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/storage"
|
|
"github.com/samcharles93/archie-core/internal/taskrun"
|
|
)
|
|
|
|
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
|
|
NATSToken string
|
|
WorkDir string
|
|
|
|
// StateStoreTarget and StateStoreToken are the daemon-injected State
|
|
// Store gRPC endpoint and bearer token (docs/prds/state-store-contract.md
|
|
// §6: STATE_STORE_URL/STATE_STORE_TOKEN, mirroring the NATS_URL/NATS_TOKEN
|
|
// handoff). StateStoreTarget is required: the legacy NATS storerpc path
|
|
// is deleted (docs/prds/state-store-contract.md §12 step 4).
|
|
StateStoreTarget string
|
|
StateStoreToken string
|
|
}
|
|
|
|
type workerTransport interface {
|
|
Close()
|
|
LogPublisher() agentexec.LogPublisher
|
|
EventPublisher() agentexec.EventPublisher
|
|
SubscribeTasks(context.Context, int64, agentnats.TaskHandler, *slog.Logger) (agentnats.Subscription, error)
|
|
Forger(string, time.Duration) workflow.Forger
|
|
Store(time.Duration) workflow.Store
|
|
Trees(string, string, time.Duration) agentnats.RemoteTrees
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
func productionWorkerDependencies() workerDependencies {
|
|
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.Info("archie-agent shutting down")
|
|
},
|
|
}
|
|
}
|
|
|
|
// 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 {
|
|
return run(ctx, settings, log, productionWorkerDependencies())
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
dependencies.markSafe(ctx, workDir, log)
|
|
|
|
transport, err := dependencies.connect(ctx, agentnats.Config{
|
|
URL: settings.NATSURL,
|
|
Token: settings.NATSToken,
|
|
StateStoreURL: settings.StateStoreTarget,
|
|
StateStoreToken: settings.StateStoreToken,
|
|
}, log)
|
|
if err != nil {
|
|
operation := "nats connect failed"
|
|
log.Error(operation, "err", err)
|
|
return &StartupError{Operation: operation, Err: err}
|
|
}
|
|
defer transport.Close()
|
|
|
|
taskID, err := dependencies.bootID(workDir)
|
|
if err != nil {
|
|
log.Error("task boot failed", "err", err)
|
|
return &StartupError{Operation: "task boot failed", Err: err}
|
|
}
|
|
log = slog.New(agentexec.NewSystemLogHandler(log.Handler(), transport.LogPublisher(), taskID))
|
|
log.Info("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)
|
|
}, log)
|
|
if err != nil {
|
|
log.Error("taskrun subscribe failed", "err", err)
|
|
return &StartupError{Operation: "taskrun subscribe failed", Err: err}
|
|
}
|
|
defer func() {
|
|
if err := subscription.Close(); err != nil {
|
|
log.Warn("task run unsubscribe failed", "err", err)
|
|
}
|
|
}()
|
|
|
|
log.Info("archie-agent ready", "nats", settings.NATSURL)
|
|
dependencies.wait(ctx, log)
|
|
return nil
|
|
}
|
|
|
|
type taskServiceTransport interface {
|
|
Forger(string, time.Duration) workflow.Forger
|
|
Store(time.Duration) workflow.Store
|
|
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) (*taskrun.Response, error) {
|
|
log.Info("running task", "task", request.Task.ID, "repo", request.Repo.FullName(), "issue", request.Task.IssueNumber)
|
|
dependencies := taskDependencies{
|
|
forge: transport.Forger(request.Task.Identity, rpcTimeout),
|
|
store: transport.Store(rpcTimeout),
|
|
trees: transport.Trees(request.Task.Identity, request.WorktreeGrant, rpcTimeout),
|
|
events: transport.EventPublisher(),
|
|
}
|
|
response, err := runTask(ctx, request, dependencies, newTaskRunner, workDir, log)
|
|
if err != nil {
|
|
log.Error("task run failed", "task", request.Task.ID, "err", err)
|
|
return nil, err
|
|
}
|
|
log.Info("task run complete", "task", request.Task.ID, "status", response.Status)
|
|
return response, nil
|
|
}
|