Files
sam 9f830db510 fix(daemon): publish polled issues only from authors with write access (#1830)
The issue poller published title and body of every labelled or assigned
issue to the agent. It now keeps only write-access authors, failing closed
when the forge cannot answer. The filter moves to forge.WriterIssues,
shared with the issue_list tool.
2026-11-14 18:31:54 +11:00

291 lines
11 KiB
Go

package daemon
import (
"context"
"log/slog"
"strings"
"sync"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/identity"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/domain/workintake"
"github.com/samcharles93/archie-core/internal/forge"
"github.com/samcharles93/archie-core/internal/taskstate"
)
// activeIdentities answers whether an identity may still act; a poll skips
// sources whose identity is suspended.
type activeIdentities interface {
identityActive(ctx context.Context, id identity.IdentityID) bool
}
// routedWorkflows answers whether an issue's labels route it to a workflow
// its org disabled.
type routedWorkflows interface {
disabledRoutedWorkflow(ctx context.Context, labels, identityID string) (routed string, disabled bool, err error)
}
// IssuePoller discovers the forge issues that dispatch rules make work and
// publishes them as tasks, and withdraws tasks whose issue drops out.
type IssuePoller struct {
cfg *config.Holder
store storecontract.TaskStore
log *slog.Logger
sources func(context.Context) []IssueSource
withdrawTask func(ctx context.Context, taskID int64, reason string) error
publishTask func(context.Context, workintake.TaskEnvelope) error
identities activeIdentities
routing routedWorkflows
// lastPolled remembers each repo's eligible issues from its previous
// complete poll, under the dispatch rule that produced them, so only an
// issue that was eligible and dropped out reads as withdrawn.
lastPolledMu sync.Mutex
lastPolled map[string]polledIssues
}
// NewIssuePoller builds the poller over the running configuration, the task
// store and the task publisher. sources resolves each poll cycle's connections,
// withdrawTask declines a task whose issue a complete poll no longer returns,
// identities and routing answer the identity and routed-workflow checks.
func NewIssuePoller(
cfg *config.Holder,
store storecontract.TaskStore,
log *slog.Logger,
sources func(context.Context) []IssueSource,
withdrawTask func(ctx context.Context, taskID int64, reason string) error,
publishTask func(context.Context, workintake.TaskEnvelope) error,
identities activeIdentities,
routing routedWorkflows,
) *IssuePoller {
return &IssuePoller{
cfg: cfg,
store: store,
log: log,
sources: sources,
withdrawTask: withdrawTask,
publishTask: publishTask,
identities: identities,
routing: routing,
lastPolled: map[string]polledIssues{},
}
}
func (p *IssuePoller) issueSources(ctx context.Context) []IssueSource {
return p.sources(ctx)
}
// pollIssuesWithConfig returns the repo's issues the dispatch rule makes
// work, using the given forge client and dispatch config. complete is false when any part of the poll failed or was skipped, so
// the result must not be read as the whole eligible set.
func (p *IssuePoller) pollIssuesWithConfig(ctx context.Context, fg forge.Forge, cfg config.Config, repo config.Repo) (issues []forge.Issue, complete bool) {
labelled := func() ([]forge.Issue, bool) {
// A label trigger needs a non-empty label or it would match every open issue.
if cfg.Label == "" {
p.log.ErrorContext(ctx, "label trigger configured with an empty label; refusing to poll (an empty label matches every open issue)", "repo", repo.FullName())
return nil, false
}
issues, err := fg.IssuesWithLabel(ctx, repo.Owner, repo.Name, cfg.Label)
if err != nil {
p.log.ErrorContext(ctx, "label poll failed", "repo", repo.FullName(), "err", err)
return nil, false
}
return issues, true
}
assigned := func() ([]forge.Issue, bool) {
if cfg.BotUser == "" {
p.log.ErrorContext(ctx, "assignee trigger needs the connection's account; refusing to poll", "repo", repo.FullName())
return nil, false
}
issues, err := fg.AssignedIssues(ctx, repo.Owner, repo.Name, cfg.BotUser)
if err != nil {
p.log.ErrorContext(ctx, "assigned poll failed", "repo", repo.FullName(), "err", err)
return nil, false
}
return issues, true
}
switch cfg.Dispatch.Trigger {
case "label":
return labelled()
case "either":
byAssignee, assignedOK := assigned()
byLabel, labelledOK := labelled()
seen := map[int]bool{}
for _, is := range byAssignee {
seen[is.Number] = true
}
issues = byAssignee
for _, is := range byLabel {
if !seen[is.Number] {
issues = append(issues, is)
}
}
return issues, assignedOK && labelledOK
default: // "assignee" (default)
return assigned()
}
}
// poll discovers work through every organisation connection, resolved
// afresh each cycle so a rotated credential or a new connection applies to
// the next poll.
func (p *IssuePoller) poll(ctx context.Context) error {
var failed []string
room := p.cfg.Get().IntakePerPass
for _, source := range p.issueSources(ctx) {
if !p.identities.identityActive(ctx, source.Identity) {
continue
}
cfg := p.cfg.Get()
cfg.BotUser = source.BotUser
if source.Dispatch.Trigger != "" {
cfg.Dispatch, cfg.Label = source.Dispatch, source.Label
}
tag := string(source.Identity)
for _, repo := range source.Repos {
issues, complete := p.pollIssuesWithConfig(ctx, source.Forge, cfg, repo)
if complete {
p.withdrawUnpolled(ctx, repo, tag, dispatchRule(cfg), issues)
} else {
failed = append(failed, repo.FullName())
}
p.publishDiscovered(ctx, source.Forge, cfg, repo, issues, tag, &room)
}
}
return passFailed("issue poll", failed)
}
// rememberPoll records a repo's latest eligible set and returns the previous
// one, reporting whether it was taken under the same rule.
func (p *IssuePoller) rememberPoll(key string, current polledIssues) (polledIssues, bool) {
p.lastPolledMu.Lock()
defer p.lastPolledMu.Unlock()
previous, seen := p.lastPolled[key]
p.lastPolled[key] = current
return previous, seen && previous.rule == current.rule
}
// withdrawUnpolled declines the queued or running work of an identity's
// issues in repo that a complete poll no longer returns: the issue was
// closed, unlabelled or unassigned.
func (p *IssuePoller) withdrawUnpolled(ctx context.Context, repo config.Repo, identity, rule string, polled []forge.Issue) {
eligible := make(map[int]bool, len(polled))
for _, is := range polled {
eligible[is.Number] = true
}
// Only an issue the same rule found eligible last time and no longer
// finds was withdrawn. A changed label, trigger or bot user, or the first
// poll after a restart, only records the new set: tasks picked up under
// the old rule were not withdrawn by anyone.
previous, sameRule := p.rememberPoll(identity+"\x00"+repo.FullName(), polledIssues{rule: rule, eligible: eligible})
if !sameRule {
return
}
active, err := p.store.TasksPage(ctx, storecontract.TaskPage{
Statuses: []string{taskstate.Queued, taskstate.Running}, Limit: 500,
})
if err != nil {
p.log.WarnContext(ctx, "withdrawal check: active tasks unavailable", "repo", repo.FullName(), "err", err)
return
}
for _, t := range active {
if t.Owner != repo.Owner || t.Repo != repo.Name || t.Identity != identity ||
!t.IsForgeBacked() || t.PRNumber > 0 || eligible[t.IssueNumber] || !previous.eligible[t.IssueNumber] {
continue
}
if err := p.withdrawTask(ctx, t.ID, "the issue is no longer assigned, labelled or open"); err != nil {
p.log.WarnContext(ctx, "withdraw task", "task", t.ID, "err", err)
}
}
}
// publishDiscovered publishes a repo's discovered issues until the pass has
// created its cap of tasks. room is what is left of the cap; the issues left
// over are found again by the next poll, because an issue with a task is
// skipped and one without is not. A cap of zero or less is no cap.
func (p *IssuePoller) publishDiscovered(ctx context.Context, fg forge.Forge, cfg config.Config, repo config.Repo, issues []forge.Issue, identity string, room *int) {
// A label or assignment is an operator's act, but the title and body that
// reach the agent were written by the issue's author, who on a public
// repository can be anyone.
issues, err := forge.WriterIssues(ctx, p.log, fg, repo.Owner, repo.Name, issues)
if err != nil {
p.log.ErrorContext(ctx, "issues not published: author write access unknown", "repo", repo.FullName(), "err", err)
return
}
capped := *room > 0
for _, is := range issues {
if capped && *room == 0 {
p.log.InfoContext(ctx, "intake cap reached; remaining issues wait for the next poll", "repo", repo.FullName())
return
}
if p.pollNATS(ctx, fg, cfg, repo, is, strings.Join(is.Labels, ","), identity) && capped {
*room--
}
}
}
// pollNATS publishes a discovered issue to NATS and reports whether it created
// a task.
func (p *IssuePoller) pollNATS(ctx context.Context, fg forge.Forge, cfg config.Config, repo config.Repo, is forge.Issue, labels, identity string) bool {
// Read-only existence check prevents rediscovering an existing task.
existing, err := p.store.TaskByIssue(ctx, repo.Owner, repo.Name, is.Number)
if err != nil {
p.log.ErrorContext(ctx, "task lookup failed", "repo", repo.FullName(), "issue", is.Number, "err", err)
return false
}
if existing != nil {
return false
}
// An issue whose label-routed workflow the identity's org disabled must
// not queue a task at all. Skip without acknowledging, so a later poll
// picks the issue up again if the workflow is re-enabled.
if routed, disabled, err := p.routing.disabledRoutedWorkflow(ctx, labels, identity); err != nil {
p.log.WarnContext(ctx, "routed workflow check failed; publishing anyway", "repo", repo.FullName(), "issue", is.Number, "err", err)
} else if disabled {
p.log.InfoContext(ctx, "issue skipped: its routed workflow is disabled for this org", "repo", repo.FullName(), "issue", is.Number, "workflow", routed)
return false
}
// Encode here: the envelope and its subject belong to the work-intake
// domain, not to the transport.
parsed := workintake.SplitLabels(labels)
task := workintake.TaskEnvelope{
Owner: repo.Owner,
Repo: repo.Name,
Number: is.Number,
Title: is.Title,
Body: is.Body,
Labels: parsed,
Identity: identity,
}
if err := p.publishTask(ctx, task); err != nil {
p.log.ErrorContext(ctx, "task publish failed", "repo", repo.FullName(), "issue", is.Number, "err", err)
return false
}
p.acknowledge(ctx, fg, cfg, repo, is)
return true
}
// acknowledge posts the pickup reaction
// using fg -- the forge client that owns repo (identity-scoped or root) --
// and the ack reaction from cfg, the dispatch config that owns this poll.
func (p *IssuePoller) acknowledge(ctx context.Context, fg forge.Forge, cfg config.Config, repo config.Repo, is forge.Issue) {
p.log.InfoContext(ctx, "issue queued", "repo", repo.FullName(), "issue", is.Number, "title", is.Title)
if ack := cfg.Dispatch.AckReaction; ack != "" {
if err := fg.React(ctx, repo.Owner, repo.Name, is.Number, ack); err != nil {
p.log.WarnContext(ctx, "ack reaction failed", "issue", is.Number, "err", err)
}
}
}
// polledIssues is one repo's eligible issues under one dispatch rule.
type polledIssues struct {
rule string
eligible map[int]bool
}
// dispatchRule identifies the rule a poll selects issues by.
func dispatchRule(cfg config.Config) string {
return cfg.Dispatch.Trigger + "\x00" + cfg.Label + "\x00" + cfg.BotUser
}