diff --git a/internal/app/archied/bootstrap.go b/internal/app/archied/bootstrap.go index a2120b7e2..10d817bee 100644 --- a/internal/app/archied/bootstrap.go +++ b/internal/app/archied/bootstrap.go @@ -670,7 +670,7 @@ func (b *boot) buildDaemon(ctx context.Context) { Playbooks: b.livePlaybooks(), } - d.ReviewScanner = daemon.NewReviewScanner(b.stateStore, b.reactionClient, b.natsClient.PublishUnique, b.bus, d, d.Identity, d, log) + d.ReviewScanner = daemon.NewReviewScanner(b.stateStore, b.reactionClient, b.natsClient.PublishUnique, b.bus, d, d.Identity, d, b.repositoryForge, log) d.BindingDispatch = daemon.NewBindingDispatch(daemon.BindingDispatchDeps{ Store: b.stateStore, Mappings: b.stateClient, diff --git a/internal/daemon/review_reconcile_test.go b/internal/daemon/review_reconcile_test.go new file mode 100644 index 000000000..886edba5b --- /dev/null +++ b/internal/daemon/review_reconcile_test.go @@ -0,0 +1,79 @@ +package daemon + +import ( + "context" + "log/slog" + "slices" + "testing" + + "github.com/samcharles93/archie-core/internal/domain/org" + "github.com/samcharles93/archie-core/internal/domain/storecontract" + "github.com/samcharles93/archie-core/internal/domain/workflow" + workflowtask "github.com/samcharles93/archie-core/internal/domain/workflow/task" + "github.com/samcharles93/archie-core/internal/events" + "github.com/samcharles93/archie-core/internal/forge" + "github.com/samcharles93/archie-core/internal/worktree" +) + +type reconcileStore struct { + storecontract.TaskStore + open []workflowtask.Task + transitions []string +} + +func (s *reconcileStore) OpenPRs(context.Context) ([]workflowtask.Task, error) { return s.open, nil } + +func (s *reconcileStore) Transition(_ context.Context, _ int64, _, to, _ string) error { + s.transitions = append(s.transitions, to) + return nil +} + +// identityGatedHub refuses every task the way the execution-identity gate +// refuses an operator-started one. +type identityGatedHub struct { + repoHub + log *slog.Logger +} + +func (h identityGatedHub) forgeFor(context.Context, *workflow.Task) forge.Forge { + return forge.NewNoop(h.log) +} + +func (identityGatedHub) treesFor(*workflow.Task) *worktree.Manager { + return &worktree.Manager{WorkDir: "/nonexistent"} +} + +type mergedForge struct{ forge.Forge } + +func (mergedForge) PRState(context.Context, string, string, int) (string, error) { + return forge.PRStateMerged, nil +} + +func (mergedForge) CloseIssue(context.Context, string, string, int, string) error { return nil } + +// TestReconcilePRsIgnoresTaskIdentity guards #1872: a merged PR of an +// operator-started task stayed In review because the reconciler resolved its +// forge through the task's execution identity. +func TestReconcilePRsIgnoresTaskIdentity(t *testing.T) { + log := slog.New(slog.DiscardHandler) + task := workflowtask.Task{ID: 7, Owner: "o", Repo: "r", PRNumber: 3, Org: "acme", Identity: "operator", Status: workflow.StatusPROpen} + store := &reconcileStore{open: []workflowtask.Task{task}} + var resolvedOrg org.OrgID + s := &ReviewScanner{ + store: store, bus: events.NewBus(), log: log, + repos: identityGatedHub{log: log}, + forges: func(ctx context.Context, _, _ string) (forge.Forge, error) { + resolvedOrg = org.OrgFromContext(ctx) + return mergedForge{}, nil + }, + } + if err := s.reconcilePRs(t.Context()); err != nil { + t.Fatal(err) + } + if !slices.Equal(store.transitions, []string{workflow.StatusMerged}) { + t.Errorf("transitions = %v, want [merged]", store.transitions) + } + if resolvedOrg != "acme" { + t.Errorf("forge resolved in org %q, want the task's org", resolvedOrg) + } +} diff --git a/internal/daemon/review_scan.go b/internal/daemon/review_scan.go index b2fdf8d87..f4ade41e5 100644 --- a/internal/daemon/review_scan.go +++ b/internal/daemon/review_scan.go @@ -2,11 +2,12 @@ package daemon import ( "context" + "errors" "fmt" "log/slog" - "github.com/samcharles93/archie-core/internal/config" "github.com/samcharles93/archie-core/internal/domain/identity" + "github.com/samcharles93/archie-core/internal/domain/org" "github.com/samcharles93/archie-core/internal/domain/storecontract" "github.com/samcharles93/archie-core/internal/domain/workflow" workflowtask "github.com/samcharles93/archie-core/internal/domain/workflow/task" @@ -129,6 +130,11 @@ func scanPRReviewReactions( return newReviewCursor, newCommentCursor, nil } +// RepositoryForgeResolver returns the forge client of owner/repo's bound +// connection in the org ctx carries. It is the daemon's own access, not a +// task identity's. +type RepositoryForgeResolver func(ctx context.Context, owner, repo string) (forge.Forge, error) + // ReviewScanner runs the pull request maintenance: it reconciles open PRs with // forge state, scans their reviews into the reaction stream, and drains that // stream into remediate runs. @@ -140,6 +146,7 @@ type ReviewScanner struct { repos repoHub orgs orgResolver bots botUserSource + forges RepositoryForgeResolver log *slog.Logger consumer *reactionConsumer publish ReactionPublisher @@ -156,11 +163,12 @@ func NewReviewScanner( repos repoHub, orgs orgResolver, bots botUserSource, + forges RepositoryForgeResolver, log *slog.Logger, ) *ReviewScanner { s := &ReviewScanner{ store: store, reactions: reactions, publishTask: publishTask, bus: bus, - repos: repos, orgs: orgs, bots: bots, log: log, + repos: repos, orgs: orgs, bots: bots, forges: forges, log: log, } s.consumer = newReactionConsumer(store, store, store, bots.botUserForTask, log) s.publish = s.PublishReaction @@ -262,9 +270,9 @@ func (s *ReviewScanner) reconcilePRs(ctx context.Context) error { } var failed []string for _, t := range tasks { - fg := s.repos.forgeFor(ctx, &t) - if _, unavailable := fg.(*forge.NoopForge); unavailable { - s.log.WarnContext(ctx, "PR state check skipped: no forge for task", "task", t.ID, "pr", t.PRNumber) + fg, err := s.reconcileForge(ctx, &t) + if err != nil { + s.log.WarnContext(ctx, "PR state check skipped: no forge for task", "task", t.ID, "pr", t.PRNumber, "err", err) continue } trees := s.repos.treesFor(&t) @@ -319,18 +327,33 @@ func (s *ReviewScanner) reconcilePRs(ctx context.Context) error { return passFailed("PR reconcile", failed) } +// reconcileForge is the forge for reading PR state and closing the issue. That +// is the daemon's own reconciliation, so it uses the repository's connection in +// the task's org rather than the task's execution identity, which may be an +// operator. A task without a repository keeps the identity-owned forge. +func (s *ReviewScanner) reconcileForge(ctx context.Context, task *workflow.Task) (forge.Forge, error) { + if !task.HasRepository() { + fg := s.repos.forgeFor(ctx, task) + if _, unavailable := fg.(*forge.NoopForge); unavailable { + return nil, errors.New("no forge for task") + } + return fg, nil + } + return s.forges(org.WithOrg(ctx, org.OrgID(task.OrgOrDefault())), task.Owner, task.Repo) +} + // closeResolvedIssue closes a finished task's forge issue, skipping chat // tasks. Failures are logged. func (s *ReviewScanner) closeResolvedIssue(ctx context.Context, task *workflow.Task, comment string) { if !task.IsForgeBacked() { return } - resolved, err := s.repos.Repository(ctx, task, config.OperationPR) + fg, err := s.reconcileForge(ctx, task) if err != nil { - s.log.WarnContext(ctx, "issue closure not permitted", "task", task.ID) + s.log.WarnContext(ctx, "issue closure skipped: no forge for task", "task", task.ID, "err", err) return } - if err := resolved.Forge.CloseIssue(ctx, task.Owner, task.Repo, task.IssueNumber, comment); err != nil { + if err := fg.CloseIssue(ctx, task.Owner, task.Repo, task.IssueNumber, comment); err != nil { s.log.WarnContext(ctx, "closing resolved issue failed; it stays open and will be re-polled", "repo", task.Owner+"/"+task.Repo, "issue", task.IssueNumber, "err", err) } diff --git a/internal/daemon/wiring_test.go b/internal/daemon/wiring_test.go index b5adf5288..853af3926 100644 --- a/internal/daemon/wiring_test.go +++ b/internal/daemon/wiring_test.go @@ -79,7 +79,7 @@ func wired(d *Daemon) *Daemon { func(context.Context) []IssueSource { return nil }, func(context.Context, int64, string) error { return nil }, d.TaskBus.PublishTask, d.Identity, d.BindingDispatch) - d.ReviewScanner = NewReviewScanner(d.Store, neutralReactions{}, d.TaskTransport.PublishUnique, d.Bus, d, d.Identity, d, d.Log) + d.ReviewScanner = NewReviewScanner(d.Store, neutralReactions{}, d.TaskTransport.PublishUnique, d.Bus, d, d.Identity, d, nil, d.Log) return d }