Files
archie/internal/app/agentworker/task_execution_test.go
T
sam d320a1a01a feat(eda): workflow inputs, optional repository and agent profiles
Workflow definitions declare inputs, repository (none, optional or
required; default required) and profile. A binding assigns each input
from a mapped parameter or a constant and may take its repository from a
parameter, which must name a configured repo; both are checked when the
binding is saved and again at dispatch. Inputs travel as structured task
data (tasks.inputs, the task brief, and a JSON block in the agent's
mission), never as body text.

A task with no repository runs in a per-task scratch workspace with no
clone and no publication grant. The agent.run step runs one mission
without a repository and finishes the task in the new completed status.

Agent profiles live under [containers.profiles.<name>]: an image and an
allowlist over the tools archie adds (MCP, scripts, plugins).
[containers].image is the default profile; an unconfigured profile parks
the task. The workflow is now pinned before the container starts so the
profile can choose its image.

Also stop two archied tests writing embedded NATS state into the package
directory, refuse an empty state_dir for embedded NATS, and drop the NATS
store files an earlier lane commit tracked.
2026-09-24 20:29:33 +10:00

948 lines
34 KiB
Go

package agentworker
import (
"context"
"encoding/json"
"log/slog"
"net"
"os"
"os/exec"
"path/filepath"
"strconv"
"strings"
"sync"
"syscall"
"testing"
"time"
"github.com/go-git/go-git/v6"
"github.com/nats-io/nats-server/v2/server"
natssrv "github.com/nats-io/nats-server/v2/test"
natsio "github.com/nats-io/nats.go"
"google.golang.org/grpc"
"github.com/samcharles93/archie-core/internal/agentexec"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/workflow"
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
"github.com/samcharles93/archie-core/internal/domain/workintake"
"github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/forge"
"github.com/samcharles93/archie-core/internal/forgerpc"
agentnats "github.com/samcharles93/archie-core/internal/infrastructure/agenttransport/nats"
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/pgstore"
"github.com/samcharles93/archie-core/internal/infrastructure/staterpc"
"github.com/samcharles93/archie-core/internal/infrastructure/workflowsteps"
"github.com/samcharles93/archie-core/internal/installtype"
"github.com/samcharles93/archie-core/internal/taskrun"
"github.com/samcharles93/archie-core/internal/worktree"
"github.com/samcharles93/archie-core/internal/worktreerpc"
)
// testSteps builds the production workflow step vocabulary for tests that are
// not about the vocabulary itself (the composition-level agreement test in
// internal/app/controlplane is).
func testSteps(t *testing.T) *workflow.Manager {
t.Helper()
steps, err := workflowsteps.NewManager()
if err != nil {
t.Fatalf("build workflow step vocabulary: %v", err)
}
return steps
}
// ── regression: archie-core#520 -- worktree ownership must be
// reconciled before push, since the agent commits as root inside the
// container and the daemon reads those same loose objects as its own
// non-root host user ──────────────────────────────────────────────────
type fakePushTrees struct {
pushed bool
pushErr error
}
func (f *fakePushTrees) Push(context.Context) error {
f.pushed = true
return f.pushErr
}
func TestWorktreeOwnerIDParsesEnvValue(t *testing.T) {
cases := []struct {
name string
env string
want int
}{
{"unset", "", -1},
{"zero is a valid uid (root)", "0", 0},
{"typical non-root uid", "1000", 1000},
{"garbage falls back to unset", "not-a-number", -1},
{"negative falls back to unset", "-1", -1},
}
for _, c := range cases {
t.Run(c.name, func(t *testing.T) {
if got := worktreeOwnerID(c.env); got != c.want {
t.Errorf("worktreeOwnerID(%q) = %d, want %d", c.env, got, c.want)
}
})
}
}
// TestHybridTreesPushReconcilesOwnershipWhenConfigured chowns to the test
// process's own uid/gid -- a permission no-op that succeeds without root --
// so this proves the walk runs and still reaches the underlying push,
// without needing privilege to chown to an arbitrary owner.
func TestHybridTreesPushReconcilesOwnershipWhenConfigured(t *testing.T) {
dir := t.TempDir()
if err := os.WriteFile(filepath.Join(dir, "file.txt"), []byte("x"), 0o644); err != nil {
t.Fatal(err)
}
if err := os.MkdirAll(filepath.Join(dir, "sub"), 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(dir, "sub", "nested.txt"), []byte("y"), 0o644); err != nil {
t.Fatal(err)
}
fake := &fakePushTrees{}
trees := &hybridTrees{
push: fake,
localDir: dir,
worktreeUID: os.Getuid(),
worktreeGID: os.Getgid(),
}
if err := trees.Push(t.Context(), dir, "branch"); err != nil {
t.Fatalf("Push: %v", err)
}
if !fake.pushed {
t.Fatal("Push did not reach the underlying remote push")
}
}
// TestHybridTreesPushReconcilesOwnershipWithDanglingSymlink: a repo can
// legitimately track a symlink whose target doesn't exist inside the
// container (e.g. a relative link to something outside the checkout, or to
// a tool the image doesn't ship). Chowning must not follow it -- a
// following chown fails on a dangling target, which would abort a push
// that would otherwise have succeeded, a regression worse than the bug
// being fixed here.
func TestHybridTreesPushReconcilesOwnershipWithDanglingSymlink(t *testing.T) {
dir := t.TempDir()
if err := os.Symlink(filepath.Join(dir, "does-not-exist"), filepath.Join(dir, "broken-link")); err != nil {
t.Fatal(err)
}
fake := &fakePushTrees{}
trees := &hybridTrees{
push: fake,
localDir: dir,
worktreeUID: os.Getuid(),
worktreeGID: os.Getgid(),
}
if err := trees.Push(t.Context(), dir, "branch"); err != nil {
t.Fatalf("Push: %v", err)
}
if !fake.pushed {
t.Fatal("Push did not reach the underlying remote push")
}
}
// TestHybridTreesPushSkipsReconciliationWhenNotConfigured: an unset
// WORKTREE_UID/GID (archie-core's non-container and test callers) must not
// attempt any chown at all -- a nonexistent dir would otherwise fail the
// walk, so this proves the walk is skipped entirely, not just tolerant of
// this one input.
func TestHybridTreesPushSkipsReconciliationWhenNotConfigured(t *testing.T) {
fake := &fakePushTrees{}
trees := &hybridTrees{
push: fake,
localDir: filepath.Join(t.TempDir(), "does-not-exist"),
worktreeUID: -1,
worktreeGID: -1,
}
if err := trees.Push(t.Context(), trees.localDir, "branch"); err != nil {
t.Fatalf("Push: %v", err)
}
if !fake.pushed {
t.Fatal("Push did not reach the underlying remote push")
}
}
func TestHybridTreesCommitReconcilesOwnershipEvenWhenCommitFails(t *testing.T) {
missing := filepath.Join(t.TempDir(), "does-not-exist")
trees := &hybridTrees{
local: &worktree.Manager{},
localDir: missing,
worktreeUID: os.Getuid(),
worktreeGID: os.Getgid(),
}
_, err := trees.CommitAll(t.Context(), missing, "test commit")
if err == nil {
t.Fatal("CommitAll error = nil, want commit and ownership reconciliation failure")
}
if !strings.Contains(err.Error(), "reconcile worktree ownership after commit") {
t.Fatalf("CommitAll error = %q, want ownership reconciliation context", err)
}
}
// TestHybridTreesPushSurfacesOwnershipReconciliationFailure: a configured
// but broken reconciliation (the dir push is asked to fix vanished) must
// fail loudly rather than forward to a push that will only fail later with
// a much more confusing git-internal permission error.
func TestHybridTreesPushSurfacesOwnershipReconciliationFailure(t *testing.T) {
fake := &fakePushTrees{}
missing := filepath.Join(t.TempDir(), "does-not-exist")
trees := &hybridTrees{
push: fake,
localDir: missing,
worktreeUID: os.Getuid(),
worktreeGID: os.Getgid(),
}
err := trees.Push(t.Context(), missing, "branch")
if err == nil {
t.Fatal("expected an error reconciling ownership of a missing directory")
}
if fake.pushed {
t.Fatal("Push must not reach the underlying remote push when reconciliation fails")
}
}
// TestApplyToolLimitsWiresConfiguredPolicyIntoLoopRunner guards against
// regressing archie-core's tool-result cap and spill dir back to inert
// zero values on the worker path (agentexec-1 / tools-core-11): a
// *LoopRunner built for a task must carry the daemon's configured
// ToolPolicy, not the zero value NewLoopRunner leaves it at.
func TestApplyToolLimitsWiresConfiguredPolicyIntoLoopRunner(t *testing.T) {
runner := agentexec.NewLoopRunner(agentexec.NewRuntime(nil), slog.New(slog.DiscardHandler))
policy := config.ToolPolicy{MaxResultChars: 12345, SpillDir: "/var/tmp/archie-spill"}
applyToolLimits(runner, policy, []string{"whois"})
want := agentexec.ToolLimits{MaxResultChars: 12345, SpillDir: "/var/tmp/archie-spill"}
if runner.Limits != want {
t.Fatalf("runner.Limits = %+v, want %+v", runner.Limits, want)
}
if len(runner.AllowTools) != 1 || runner.AllowTools[0] != "whois" {
t.Fatalf("runner.AllowTools = %v, want the profile's allowlist", runner.AllowTools)
}
}
// TestApplyToolLimitsIgnoresNonLoopRunner confirms a test-fake runner (which
// is not a *agentexec.LoopRunner) is left untouched rather than panicking.
func TestApplyToolLimitsIgnoresNonLoopRunner(t *testing.T) {
applyToolLimits(panicRunner{t}, config.ToolPolicy{MaxResultChars: 1}, nil)
}
type panicRunner struct{ t *testing.T }
func (r panicRunner) Run(context.Context, string, agentexec.Request, agentexec.ToolCallReporter) (agentexec.Result, error) {
r.t.Fatal("bootstrap workflow must not invoke an LLM runner")
return agentexec.Result{}, nil
}
type prCapturingForge struct {
prs []struct{ owner, repo, title, head, base, body string }
}
func (f *prCapturingForge) Comment(context.Context, string, string, int, string) (int64, error) {
return 1, nil
}
func (f *prCapturingForge) CloseIssue(context.Context, string, string, int, string) error { return nil }
func (f *prCapturingForge) CreatePR(_ context.Context, owner, repo, title, head, base, body string) (int, error) {
f.prs = append(f.prs, struct{ owner, repo, title, head, base, body string }{owner, repo, title, head, base, body})
return 5, nil
}
func (f *prCapturingForge) SetStateLabel(context.Context, string, string, int, string, []string) {}
func (f *prCapturingForge) AcceptInvitations(context.Context) error { panic("unexpected call") }
func (f *prCapturingForge) AssignedIssues(context.Context, string, string, string) ([]forge.Issue, error) {
panic("unexpected call")
}
func (f *prCapturingForge) IssuesWithLabel(context.Context, string, string, string) ([]forge.Issue, error) {
panic("unexpected call")
}
func (f *prCapturingForge) PRState(context.Context, string, string, int) (string, error) {
panic("unexpected call")
}
func (f *prCapturingForge) CreateIssue(context.Context, string, string, string, string, []string) (int, error) {
panic("unexpected call")
}
func (f *prCapturingForge) React(context.Context, string, string, int, string) error {
panic("unexpected call")
}
func (f *prCapturingForge) VerifyPush(context.Context, string, string) error {
panic("unexpected call")
}
func (f *prCapturingForge) LinkBranch(context.Context, string, string, int, string) error { return nil }
func (f *prCapturingForge) CreateReviewComments(context.Context, string, string, int, string, []workflow.ReviewComment) error {
return nil
}
func (f *prCapturingForge) ReplyToReview(context.Context, string, string, int, int64, string) error {
return nil
}
type remoteManager struct {
manager *worktree.Manager
dir string
branch string
}
func (r *remoteManager) Prepare(ctx context.Context, owner, repo, base string, issue int, title, body, labels string) (string, string, error) {
dir, branch, err := r.manager.Prepare(ctx, owner, repo, base, issue, title, body, labels)
if err == nil {
r.dir = dir
r.branch = branch
}
return dir, branch, err
}
func (r *remoteManager) Push(ctx context.Context) error {
return r.manager.Push(ctx, r.dir, r.branch)
}
func newLocalRemote(t *testing.T, owner, repo string) string {
t.Helper()
host := t.TempDir()
bare := filepath.Join(host, owner, repo+".git")
seed := filepath.Join(t.TempDir(), "seed")
run := func(dir string, args ...string) {
t.Helper()
cmd := exec.CommandContext(t.Context(), "git", args...)
cmd.Dir = dir
cmd.Env = append(os.Environ(), "GIT_TERMINAL_PROMPT=0")
if out, err := cmd.CombinedOutput(); err != nil {
t.Fatalf("git %v: %v\n%s", args, err, out)
}
}
if err := os.MkdirAll(bare, 0o755); err != nil {
t.Fatal(err)
}
run(host, "init", "--bare", "-b", "main", bare)
if err := os.MkdirAll(seed, 0o755); err != nil {
t.Fatal(err)
}
run(seed, "init", "-b", "main")
run(seed, "config", "user.name", "seeder")
run(seed, "config", "user.email", "seed@example.com")
if err := os.WriteFile(filepath.Join(seed, "README.md"), []byte("seed\n"), 0o644); err != nil {
t.Fatal(err)
}
run(seed, "add", "-A")
run(seed, "commit", "-m", "seed")
run(seed, "push", "file://"+bare, "main")
return host
}
func startEmbeddedTaskRPCServer(t *testing.T) *server.Server {
t.Helper()
srv := natssrv.RunRandClientPortServer()
t.Cleanup(srv.Shutdown)
if err := srv.EnableJetStream(&server.JetStreamConfig{StoreDir: t.TempDir()}); err != nil {
t.Fatal(err)
}
return srv
}
func connectTaskRPC(t *testing.T, url string) *natsio.Conn {
t.Helper()
connection, err := natsio.Connect(url)
if err != nil {
t.Fatal(err)
}
t.Cleanup(connection.Close)
return connection
}
// startStateStoreGRPC serves the State Store gRPC contract over a loopback
// TCP listener fronting local, returning the dial address. The agent is fully
// on gRPC for its store calls (docs/prds/state-store-contract.md §12 step 4),
// so an agentworker test that drives executeTaskRequest needs a real State
// Store server rather than the deleted NATS storerpc path.
func startStateStoreGRPC(t *testing.T, local *pgstore.TaskDB) string {
t.Helper()
listener, err := (&net.ListenConfig{}).Listen(t.Context(), "tcp", "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
server := grpc.NewServer()
eda := pgstore.EDA(t, nil)
staterpc.RegisterServer(server, staterpc.Deps{
Tasks: local, Captures: eda, Mappings: eda, Bindings: eda,
BindingDispatcher: eda, BindingTaskCreator: local,
})
go func() { _ = server.Serve(listener) }()
t.Cleanup(func() { server.Stop(); _ = listener.Close() })
return listener.Addr().String()
}
func TestRunTaskExecutesBootstrapWorkflowEndToEnd(t *testing.T) {
if _, err := exec.LookPath("git"); err != nil {
t.Skip("git not installed")
}
ctx := t.Context()
host := newLocalRemote(t, "acme", "widget")
st := pgstore.Open(t)
if _, err := st.EnqueueIssue(ctx, "acme", "widget", 1, "feat: bootstrap test", "", "bootstrap", ""); err != nil {
t.Fatalf("enqueue: %v", err)
}
task, err := st.ClaimNext(ctx)
if err != nil || task == nil {
t.Fatalf("claim: (%v, %v)", task, err)
}
fg := &prCapturingForge{}
manager := &worktree.Manager{WorkDir: t.TempDir(), Token: "unused", BotUser: "archie-bot", BotEmail: "archie-bot@example.com", BaseURL: "file://" + host}
remote := &remoteManager{manager: manager}
hostDir, _, err := remote.Prepare(ctx, "acme", "widget", "main", 1, task.Title, "", "bootstrap")
if err != nil {
t.Fatalf("prepare: %v", err)
}
req := taskrun.Request{
Task: task,
Repo: config.Repo{Owner: "acme", Name: "widget", Base: "main"},
Cfg: config.Config{BotUser: "archie-bot", BotEmail: "archie-bot@example.com"}.ForTask(),
}
fakeRunner := runnerFactory(func(map[string]agentexec.Provider, *slog.Logger) agentexec.Runner { return panicRunner{t} })
response, err := runTask(ctx, req, taskDependencies{forge: fg, store: st, trees: remote, steps: testSteps(t)}, fakeRunner, hostDir, slog.New(slog.DiscardHandler))
if err != nil {
t.Fatalf("runTask: %v", err)
}
if response.Status != workflow.StatusPROpen || len(fg.prs) != 1 {
t.Fatalf("response status/PRs = (%q, %d), want (%q, 1)", response.Status, len(fg.prs), workflow.StatusPROpen)
}
stored, err := st.TaskByIssue(ctx, "acme", "widget", 1)
if err != nil || stored == nil || stored.Status != workflow.StatusPROpen || stored.PRNumber != 5 {
t.Fatalf("stored task = (%+v, %v), want PR-open task #5", stored, err)
}
if _, err := os.Stat(filepath.Join(hostDir, ".archie", "bootstrap.md")); err != nil {
t.Fatalf("expected bootstrap marker file: %v", err)
}
repo, err := git.PlainOpen(hostDir)
if err != nil {
t.Fatal(err)
}
head, err := repo.Head()
if err != nil {
t.Fatal(err)
}
commit, err := repo.CommitObject(head.Hash())
if err != nil {
t.Fatal(err)
}
if commit.Author.Name != "archie-bot" || commit.Author.Email != "archie-bot@example.com" ||
commit.Committer.Name != "archie-bot" || commit.Committer.Email != "archie-bot@example.com" {
t.Fatalf("commit identity = author %q <%s>, committer %q <%s>",
commit.Author.Name, commit.Author.Email, commit.Committer.Name, commit.Committer.Email)
}
// The change the run produced is captured at the push, through the
// container's hybridTrees, and persisted as durable provenance attributed
// to the attempt -- and captured once more by OpenPR, the first moment a
// capture can carry the pull-request number the view links. This is the
// only end-to-end path that matters: every production workflow.Run executes
// here.
timeline, err := st.TaskEvents(ctx, task.ID)
if err != nil {
t.Fatalf("TaskEvents: %v", err)
}
var captured []events.Event
for _, e := range timeline {
if e.Kind == events.KindChangesCaptured {
captured = append(captured, e)
}
}
if len(captured) != 2 {
t.Fatalf("changes_captured events = %d, want the push capture and the one OpenPR takes (%d)", len(captured), stored.PRNumber)
}
for i, e := range captured {
if e.Attempt != task.Attempt || task.Attempt == 0 {
t.Errorf("capture %d attempt = %d, want the task's own attempt %d", i, e.Attempt, task.Attempt)
}
}
if captured[0].Stage != "commit-push" {
t.Errorf("capture stage = %q, want the capturing stage", captured[0].Stage)
}
data, err := json.Marshal(captured[0].Data)
if err != nil {
t.Fatal(err)
}
var payload struct {
CapturedAfter string `json:"captured_after"`
PRNumber int `json:"pr_number"`
Files []struct {
Path string `json:"path"`
Status string `json:"status"`
} `json:"files"`
}
if err := json.Unmarshal(data, &payload); err != nil {
t.Fatalf("decode capture: %v", err)
}
if payload.CapturedAfter != "commit-push" {
t.Errorf("captured_after = %q, want commit-push", payload.CapturedAfter)
}
if payload.PRNumber != 0 {
t.Errorf("the push capture carries pr_number %d, want 0: no PR existed when it was taken", payload.PRNumber)
}
if len(payload.Files) != 1 || payload.Files[0].Path != ".archie/bootstrap.md" || payload.Files[0].Status != "added" {
t.Errorf("captured files = %+v, want the bootstrap marker as an added file", payload.Files)
}
finalData, err := json.Marshal(captured[1].Data)
if err != nil {
t.Fatal(err)
}
var final struct {
CapturedAfter string `json:"captured_after"`
PRNumber int `json:"pr_number"`
}
if err := json.Unmarshal(finalData, &final); err != nil {
t.Fatalf("decode the final capture: %v", err)
}
if final.CapturedAfter != "open-pr" || final.PRNumber != stored.PRNumber || final.PRNumber == 0 {
t.Errorf("final capture = %q pr %d, want open-pr carrying the stored PR number %d, without which the changed-files view has nothing to link",
final.CapturedAfter, final.PRNumber, stored.PRNumber)
}
}
// TestRunTaskRestoresWorktreeOwnershipOnEveryExit pins the half of the
// worktree-ownership contract that archie-core#520 left open. CommitAll and
// Push hand the worktree back to the daemon's own UID on the SUCCESS path;
// every other way a container run can end -- a gate failure that parks the
// task, a stage error, an early return -- used to leave the worktree owned by
// root, because the agent runs as root inside the container. The daemon then
// could not clean or reset those paths on the next attempt (a root-owned
// directory cannot be unlinked from by its non-root owner), so a retry failed
// before it could start no matter what the worktree refresh did.
//
// The run below exits early, which is the point: the restore has to be
// deferred over the whole run rather than attached to the paths that happen to
// commit. It is observed through a supplementary group -- a non-root process
// may move a file it owns into a group it is a member of, so this proves the
// chown ran without needing root.
func TestRunTaskRestoresWorktreeOwnershipOnEveryExit(t *testing.T) {
probeGroup := supplementaryGroup(t)
workDir := t.TempDir()
probe := filepath.Join(workDir, "probe.txt")
if err := os.WriteFile(probe, []byte("x\n"), 0o600); err != nil {
t.Fatal(err)
}
t.Setenv("WORKTREE_UID", strconv.Itoa(os.Getuid()))
t.Setenv("WORKTREE_GID", strconv.Itoa(probeGroup))
// A runner factory that yields nothing fails the run after the trees (and
// the ownership defer) are already in place.
_, err := runTask(t.Context(), taskrun.Request{
Task: &workflow.Task{ID: 77, Branch: "feat/77-probe", Workflow: "implement"},
Repo: config.Repo{Owner: "acme", Name: "widget", Base: "main"},
}, taskDependencies{steps: testSteps(t)}, runnerFactory(func(map[string]agentexec.Provider, *slog.Logger) agentexec.Runner {
return nil
}), workDir, slog.New(slog.DiscardHandler))
if err == nil {
t.Fatal("runTask error = nil, want the missing-runner failure this exit is built around")
}
info, statErr := os.Stat(probe)
if statErr != nil {
t.Fatal(statErr)
}
gid, ok := info.Sys().(*syscall.Stat_t)
if !ok {
t.Fatal("no syscall.Stat_t for the ownership probe")
}
if int(gid.Gid) != probeGroup {
t.Errorf("probe.txt gid = %d, want %d -- a run that never reached CommitAll or Push left the worktree owned by the container's own user", gid.Gid, probeGroup)
}
}
// supplementaryGroup returns a group this process is a member of but that is
// not its primary gid, so a test can observe a chown a non-root process is
// allowed to make.
func supplementaryGroup(t *testing.T) int {
t.Helper()
groups, err := os.Getgroups()
if err != nil {
t.Skipf("os.Getgroups: %v", err)
}
for _, gid := range groups {
if gid != os.Getgid() {
return gid
}
}
t.Skip("process belongs to no supplementary group to chown into")
return 0
}
// TestExecuteTaskRequestUsesInfrastructureRPCDependencies preserves the
// application-to-infrastructure proof: the application asks Transport for its
// forge/store/tree contracts, and those concrete clients cross embedded NATS
// to daemon-side RPC servers before the bootstrap workflow can complete.
func TestExecuteTaskRequestUsesInfrastructureRPCDependencies(t *testing.T) {
if _, err := exec.LookPath("git"); err != nil {
t.Skip("git not installed")
}
ctx := t.Context()
host := newLocalRemote(t, "acme", "rpc-widget")
st := pgstore.Open(t)
if _, err := st.EnqueueIssue(ctx, "acme", "rpc-widget", 2, "feat: RPC bootstrap test", "", "bootstrap", ""); err != nil {
t.Fatal(err)
}
task, err := st.ClaimNext(ctx)
if err != nil || task == nil {
t.Fatalf("claim = (%+v, %v)", task, err)
}
forge := &prCapturingForge{}
daemonTrees := &worktree.Manager{
WorkDir: t.TempDir(),
Token: "unused-for-file-remotes",
BotUser: "archie-bot",
BotEmail: "archie-bot@example.com",
BaseURL: "file://" + host,
}
hostDir, branch, err := daemonTrees.Prepare(ctx, "acme", "rpc-widget", "main", 2, task.Title, "", "bootstrap")
if err != nil {
t.Fatal(err)
}
task.Branch = branch
grants := worktreerpc.NewGrants()
grant, revokeGrant, err := grants.Issue(task)
if err != nil {
t.Fatal(err)
}
t.Cleanup(revokeGrant)
srv := startEmbeddedTaskRPCServer(t)
serverConn := connectTaskRPC(t, srv.ClientURL())
unsubForge, err := (&forgerpc.Server{Forge: forge, Log: slog.New(slog.DiscardHandler)}).Register(serverConn)
if err != nil {
t.Fatal(err)
}
t.Cleanup(unsubForge)
unsubTrees, err := (&worktreerpc.Server{Trees: daemonTrees, Grants: grants, Log: slog.New(slog.DiscardHandler)}).Register(serverConn)
if err != nil {
t.Fatal(err)
}
t.Cleanup(unsubTrees)
transport, err := agentnats.Connect(ctx, agentnats.Config{URL: srv.ClientURL(), StateStoreURL: startStateStoreGRPC(t, st)}, slog.New(slog.DiscardHandler))
if err != nil {
t.Fatal(err)
}
t.Cleanup(transport.Close)
request := taskrun.Request{
Task: task,
Repo: config.Repo{Owner: "acme", Name: "rpc-widget", Base: "main"},
Cfg: config.Config{}.ForTask(),
WorktreeGrant: grant,
}
response, err := executeTaskRequest(ctx, request, transport, hostDir, slog.New(slog.DiscardHandler), testSteps(t))
if err != nil {
t.Fatal(err)
}
if response.Status != workflow.StatusPROpen || len(forge.prs) != 1 {
t.Fatalf("response status/PRs = (%q, %d), want (%q, 1)", response.Status, len(forge.prs), workflow.StatusPROpen)
}
// archie-core-1786751948782-3-837a8fd0 point 4: every response reports
// what this worker actually is, since it's the only channel the daemon
// has to learn what's really running (see daemon.AgentStatus).
if response.AgentVersion != Version() {
t.Errorf("response.AgentVersion = %q, want Version() = %q", response.AgentVersion, Version())
}
if response.AgentInstallType != installtype.Type() {
t.Errorf("response.AgentInstallType = %q, want installtype.Type() = %q", response.AgentInstallType, installtype.Type())
}
stored, err := st.TaskByIssue(ctx, "acme", "rpc-widget", 2)
if err != nil || stored == nil || stored.Status != workflow.StatusPROpen || stored.PRNumber != 5 {
t.Fatalf("stored task = (%+v, %v), want RPC-persisted PR-open task #5", stored, err)
}
if _, err := os.Stat(filepath.Join(hostDir, ".archie", "bootstrap.md")); err != nil {
t.Fatalf("expected bootstrap marker file: %v", err)
}
}
// TestExecuteTaskRequestForwardsWorkflowEventsOverNATS is the regression test
// for the "No events yet" dashboard bug (archie-core-518): a workflow run
// through the NATS/container path publishes its stage/outcome events to an
// in-process *events.Bus nothing on the daemon side could see, because
// runTask never wired TaskContext.Bus. This proves the fix end to end -- a
// bystander subscribed directly to SubjectForEvents(task.ID) on the same
// embedded NATS server executeTaskRequest uses receives real events the
// bootstrap workflow emits, exactly as the daemon's own subscriber would.
func TestExecuteTaskRequestForwardsWorkflowEventsOverNATS(t *testing.T) {
if _, err := exec.LookPath("git"); err != nil {
t.Skip("git not installed")
}
ctx := t.Context()
host := newLocalRemote(t, "acme", "events-widget")
st := pgstore.Open(t)
if _, err := st.EnqueueIssue(ctx, "acme", "events-widget", 3, "feat: events bootstrap test", "", "bootstrap", ""); err != nil {
t.Fatal(err)
}
task, err := st.ClaimNext(ctx)
if err != nil || task == nil {
t.Fatalf("claim = (%+v, %v)", task, err)
}
forge := &prCapturingForge{}
daemonTrees := &worktree.Manager{
WorkDir: t.TempDir(),
Token: "unused-for-file-remotes",
BotUser: "archie-bot",
BotEmail: "archie-bot@example.com",
BaseURL: "file://" + host,
}
hostDir, branch, err := daemonTrees.Prepare(ctx, "acme", "events-widget", "main", 3, task.Title, "", "bootstrap")
if err != nil {
t.Fatal(err)
}
task.Branch = branch
grants := worktreerpc.NewGrants()
grant, revokeGrant, err := grants.Issue(task)
if err != nil {
t.Fatal(err)
}
t.Cleanup(revokeGrant)
srv := startEmbeddedTaskRPCServer(t)
serverConn := connectTaskRPC(t, srv.ClientURL())
unsubForge, err := (&forgerpc.Server{Forge: forge, Log: slog.New(slog.DiscardHandler)}).Register(serverConn)
if err != nil {
t.Fatal(err)
}
t.Cleanup(unsubForge)
unsubTrees, err := (&worktreerpc.Server{Trees: daemonTrees, Grants: grants, Log: slog.New(slog.DiscardHandler)}).Register(serverConn)
if err != nil {
t.Fatal(err)
}
t.Cleanup(unsubTrees)
// Stand in for the daemon's own SubjectEventsWildcard subscriber: bind
// to the exact per-task subject before the workflow runs, so nothing
// published during the run can be missed.
var (
mu sync.Mutex
received []events.Event
)
bystander := connectTaskRPC(t, srv.ClientURL())
eventSub, err := bystander.Subscribe(agentexec.SubjectForEvents(task.ID), func(msg *natsio.Msg) {
var e events.Event
if err := json.Unmarshal(msg.Data, &e); err != nil {
t.Errorf("undecodable event message: %v", err)
return
}
mu.Lock()
received = append(received, e)
mu.Unlock()
})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = eventSub.Unsubscribe() })
if err := bystander.Flush(); err != nil {
t.Fatal(err)
}
transport, err := agentnats.Connect(ctx, agentnats.Config{URL: srv.ClientURL(), StateStoreURL: startStateStoreGRPC(t, st)}, slog.New(slog.DiscardHandler))
if err != nil {
t.Fatal(err)
}
t.Cleanup(transport.Close)
request := taskrun.Request{
Task: task,
Repo: config.Repo{Owner: "acme", Name: "events-widget", Base: "main"},
Cfg: config.Config{}.ForTask(),
WorktreeGrant: grant,
}
response, err := executeTaskRequest(ctx, request, transport, hostDir, slog.New(slog.DiscardHandler), testSteps(t))
if err != nil {
t.Fatal(err)
}
if response.Status != workflow.StatusPROpen {
t.Fatalf("response status = %q, want %q", response.Status, workflow.StatusPROpen)
}
deadline := time.After(2 * time.Second)
for {
mu.Lock()
sawOutcome := false
for _, e := range received {
if e.Kind == events.KindOutcome {
sawOutcome = true
break
}
}
mu.Unlock()
if sawOutcome {
break
}
select {
case <-deadline:
t.Fatal("no \"outcome\" event arrived on SubjectForEvents(task.ID) within 2s")
case <-time.After(10 * time.Millisecond):
}
}
mu.Lock()
defer mu.Unlock()
sawOutcome := false
for _, e := range received {
if e.TaskID != task.ID {
t.Errorf("event %+v carries TaskID %d, want %d", e, e.TaskID, task.ID)
}
if e.Kind == events.KindOutcome {
sawOutcome = true
}
}
if !sawOutcome {
t.Errorf("received %d events %+v, want at least one %q", len(received), received, events.KindOutcome)
}
}
// TestRouteTaskUsesRequestKindOverride is the regression for
// workflow-engine-1: a kind -> workflow override loaded by the daemon is
// carried in the taskrun request and applied by the worker process, so
// workflow.Route honours it instead of silently falling back to the
// built-in default (bug -> tdd).
func TestRouteTaskUsesRequestKindOverride(t *testing.T) {
t.Cleanup(func() {
workflow.SetKindWorkflows(nil)
workflow.SetLabelWorkflows(nil)
})
registry := workflow.Registry{
"tdd": workflow.Workflow{Name: "tdd"},
"bootstrap": workflow.Workflow{Name: "bootstrap"},
"implement": workflow.Workflow{Name: "implement"},
}
req := taskrun.Request{
Task: &workflow.Task{Labels: "bug"},
KindWorkflows: workflow.KindWorkflows{workintake.KindBug: "bootstrap"},
}
wf := routeTask(req, registry)
if wf.Name != "bootstrap" {
t.Fatalf("routeTask() = %q, want %q (request kind override not applied)", wf.Name, "bootstrap")
}
}
// TestRouteTaskUsesRequestLabelOverride is the label counterpart: an
// arbitrary-label binding carried in the request also reaches the worker's
// routing decision.
func TestRouteTaskUsesRequestLabelOverride(t *testing.T) {
t.Cleanup(func() {
workflow.SetKindWorkflows(nil)
workflow.SetLabelWorkflows(nil)
})
registry := workflow.Registry{
"implement": workflow.Workflow{Name: "implement"},
"security-review": workflow.Workflow{Name: "security-review"},
}
req := taskrun.Request{
Task: &workflow.Task{Labels: "security"},
LabelWorkflows: workflow.LabelWorkflows{"security": "security-review"},
}
wf := routeTask(req, registry)
if wf.Name != "security-review" {
t.Fatalf("routeTask() = %q, want %q (request label override not applied)", wf.Name, "security-review")
}
}
// changeStatsReader mirrors the unexported optional interface package workflow
// type-asserts on TaskContext.Trees to capture what an attempt changed. It is
// restated here because an unexported interface cannot be named from this
// package; the assertion below is therefore the only way this side can pin
// that the in-container Trees is capable at all.
type changeStatsReader interface {
ChangedFileStats(ctx context.Context, dir, base string) (task.ChangeStats, error)
}
// TestHybridTreesCanReportWhatChanged is the in-container half of the change
// capture. Every production workflow.Run executes in archie-agent against a
// hybridTrees, so a Trees without this capability would make the capture a
// silent no-op in exactly the deployment that produces all the real data --
// the daemon-side manager being capable would prove nothing.
func TestHybridTreesCanReportWhatChanged(t *testing.T) {
var trees any = &hybridTrees{local: &worktree.Manager{}}
if _, ok := trees.(changeStatsReader); !ok {
t.Fatal("hybridTrees cannot report a diffstat; every capture inside a container would silently no-op")
}
}
// TestHybridTreesForwardsChangedFileStatsToItsLocalManager drives the
// capability against a real worktree, so satisfaction of the interface is not
// mistaken for a working forwarder.
func TestHybridTreesForwardsChangedFileStatsToItsLocalManager(t *testing.T) {
if _, err := exec.LookPath("git"); err != nil {
t.Skip("git not installed")
}
ctx := t.Context()
host := newLocalRemote(t, "acme", "diffstat")
manager := &worktree.Manager{
WorkDir: t.TempDir(), Token: "unused",
BotUser: "archie-bot", BotEmail: "archie-bot@example.com", BaseURL: "file://" + host,
}
dir, branch, err := manager.Prepare(ctx, "acme", "diffstat", "main", 4, "feat: widget", "", "")
if err != nil {
t.Fatalf("prepare: %v", err)
}
if err := os.WriteFile(filepath.Join(dir, "widget.txt"), []byte("one\ntwo\n"), 0o644); err != nil {
t.Fatal(err)
}
if _, err := manager.CommitAll(ctx, dir, "feat: widget"); err != nil {
t.Fatalf("commit: %v", err)
}
trees := &hybridTrees{local: manager, localDir: dir, branch: branch}
stats, err := trees.ChangedFileStats(ctx, dir, "main")
if err != nil {
t.Fatalf("ChangedFileStats: %v", err)
}
if len(stats.Files) != 1 || stats.Files[0].Path != "widget.txt" {
t.Fatalf("files = %+v, want the one committed file", stats.Files)
}
if stats.Totals != (task.ChangeTotals{Files: 1, Additions: 2}) {
t.Errorf("totals = %+v, want the file's two added lines", stats.Totals)
}
if stats.HeadSHA == "" || stats.BaseSHA == "" {
t.Errorf("SHAs = (%q, %q), want both resolved", stats.BaseSHA, stats.HeadSHA)
}
}
// uncommittedChangeReporter mirrors the unexported optional interface package
// workflow type-asserts on TaskContext.Trees to tell a change that is not
// committed yet from a branch with no change. It is restated here for the same
// reason changeStatsReader is: an unexported interface cannot be named from this
// package, so this assertion is the only way this side can pin that the
// in-container Trees can answer at all.
type uncommittedChangeReporter interface {
HasUncommittedChanges(ctx context.Context, dir string) (bool, error)
}
// TestHybridTreesCanReportUncommittedWork is the in-container half of the
// diff-rules placement guard. Every production workflow.Run executes in
// archie-agent against a hybridTrees, and a workflow whose only Trees cannot
// answer would fail the guard for the wrong reason -- or, worse, look capable
// while forwarding nothing.
func TestHybridTreesCanReportUncommittedWork(t *testing.T) {
var trees any = &hybridTrees{local: &worktree.Manager{}}
if _, ok := trees.(uncommittedChangeReporter); !ok {
t.Fatal("hybridTrees cannot report uncommitted work, so the in-container diff-rules guard would refuse every run")
}
}