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, WorkflowCalls: local, Steps: local, Canceller: 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") } }