Errors say what GitHub refused in its own words instead of the request URL and an empty field list. Webhook review states arrive lower-case and were never normalised, so a webhook-delivered change request did not read as one. A review the token would post as REQUEST_CHANGES on its own pull request comments instead, which GitHub accepts. Secondary rate limits wait up to two minutes and retry.
524 lines
18 KiB
Go
524 lines
18 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"log/slog"
|
|
"net/http"
|
|
"net/url"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/samcharles93/archipelago/sdk/forge"
|
|
|
|
"github.com/gofri/go-github-ratelimit/v2/github_ratelimit"
|
|
"github.com/gofri/go-github-ratelimit/v2/github_ratelimit/github_secondary_ratelimit"
|
|
"github.com/google/go-github/v78/github"
|
|
)
|
|
|
|
// maxRateLimitWait bounds one wait on a secondary rate limit; a longer one
|
|
// fails the call rather than holding it past what a caller waits for.
|
|
const maxRateLimitWait = 2 * time.Minute
|
|
|
|
// GitHubClient implements Forge against the GitHub API.
|
|
type GitHubClient struct {
|
|
gh *github.Client
|
|
log *slog.Logger
|
|
|
|
labelMu sync.Mutex
|
|
labelsEnsured map[string]bool
|
|
|
|
loginMu sync.Mutex
|
|
login string
|
|
}
|
|
|
|
// NewGitHub creates a GitHub-backed Forge implementation. Non-github.com
|
|
// hosts are configured using GitHub Enterprise's API and upload URL conventions.
|
|
func newGitHub(token, host string, log *slog.Logger) (forge.Forge, error) {
|
|
client := github.NewClient(github_ratelimit.NewClient(nil,
|
|
github_secondary_ratelimit.WithSingleSleepLimit(maxRateLimitWait, nil)))
|
|
if strings.TrimRight(host, "/") != "https://github.com" {
|
|
var err error
|
|
client, err = client.WithEnterpriseURLs(host, host)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("configure GitHub host %q: %w", host, err)
|
|
}
|
|
}
|
|
return &GitHubClient{gh: client.WithAuthToken(token), log: log}, nil
|
|
}
|
|
|
|
// AcceptInvitations auto-accepts pending repository invitations so
|
|
// adding archie as a collaborator is all a human has to do.
|
|
func (c *GitHubClient) AcceptInvitations(ctx context.Context) error {
|
|
invites, _, err := c.gh.Users.ListInvitations(ctx, nil)
|
|
if err != nil {
|
|
return apiError("list invitations", err)
|
|
}
|
|
for _, inv := range invites {
|
|
if _, err := c.gh.Users.AcceptInvitation(ctx, inv.GetID()); err != nil {
|
|
c.log.Warn("accept invitation failed", "repo", inv.GetRepo().GetFullName(), "err", apiError("accept invitation", err))
|
|
continue
|
|
}
|
|
c.log.Info("accepted repository invitation", "repo", inv.GetRepo().GetFullName())
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// AssignedIssues returns open issues assigned to the given user,
|
|
// excluding PRs. Assigning an issue to the bot is how work is handed to
|
|
// archie (tink-bot style); labels only influence workflow routing.
|
|
func (c *GitHubClient) AssignedIssues(ctx context.Context, owner, repo, assignee string) ([]forge.Issue, error) {
|
|
var out []forge.Issue
|
|
opts := &github.IssueListByRepoOptions{
|
|
State: "open",
|
|
Assignee: assignee,
|
|
ListOptions: github.ListOptions{PerPage: 50},
|
|
}
|
|
for {
|
|
issues, resp, err := c.gh.Issues.ListByRepo(ctx, owner, repo, opts)
|
|
if err != nil {
|
|
return nil, apiError(fmt.Sprintf("list issues %s/%s", owner, repo), err)
|
|
}
|
|
for _, is := range issues {
|
|
if !is.IsPullRequest() {
|
|
out = append(out, forge.Issue{
|
|
Number: is.GetNumber(),
|
|
Title: is.GetTitle(),
|
|
Body: is.GetBody(),
|
|
Labels: labelNames(is),
|
|
})
|
|
}
|
|
}
|
|
if resp.NextPage == 0 {
|
|
break
|
|
}
|
|
opts.ListOptions.Page = resp.NextPage
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// labelNames extracts label names without flattening them, preserving
|
|
// valid label names that contain commas or leading/trailing whitespace.
|
|
func labelNames(is *github.Issue) []string {
|
|
var names []string
|
|
for _, l := range is.Labels {
|
|
names = append(names, l.GetName())
|
|
}
|
|
return names
|
|
}
|
|
|
|
// IssuesWithLabel returns open issues matching the given label, excluding
|
|
// PRs. Used when Dispatch.Trigger is "label" or "either" -- no assignee
|
|
// required, just the label.
|
|
func (c *GitHubClient) IssuesWithLabel(ctx context.Context, owner, repo, label string) ([]forge.Issue, error) {
|
|
var out []forge.Issue
|
|
opts := &github.IssueListByRepoOptions{
|
|
State: "open",
|
|
Labels: []string{label},
|
|
ListOptions: github.ListOptions{PerPage: 50},
|
|
}
|
|
for {
|
|
issues, resp, err := c.gh.Issues.ListByRepo(ctx, owner, repo, opts)
|
|
if err != nil {
|
|
return nil, apiError(fmt.Sprintf("list issues %s/%s", owner, repo), err)
|
|
}
|
|
for _, is := range issues {
|
|
if !is.IsPullRequest() {
|
|
out = append(out, forge.Issue{
|
|
Number: is.GetNumber(),
|
|
Title: is.GetTitle(),
|
|
Body: is.GetBody(),
|
|
Labels: labelNames(is),
|
|
})
|
|
}
|
|
}
|
|
if resp.NextPage == 0 {
|
|
break
|
|
}
|
|
opts.ListOptions.Page = resp.NextPage
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// Comment posts an issue (or PR) comment and returns its id, so a
|
|
// workflow can watch for replies that come after it.
|
|
func (c *GitHubClient) Comment(ctx context.Context, owner, repo string, number int, body string) (int64, error) {
|
|
cm, _, err := c.gh.Issues.CreateComment(ctx, owner, repo, number,
|
|
&github.IssueComment{Body: new(body)})
|
|
if err != nil {
|
|
return 0, apiError(fmt.Sprintf("comment on %s/%s#%d", owner, repo, number), err)
|
|
}
|
|
return cm.GetID(), nil
|
|
}
|
|
|
|
// CreatePR opens a pull request and returns its number.
|
|
func (c *GitHubClient) CreatePR(ctx context.Context, owner, repo, title, head, base, body string) (int, error) {
|
|
pr, _, err := c.gh.PullRequests.Create(ctx, owner, repo, &github.NewPullRequest{
|
|
Title: new(title),
|
|
Head: new(head),
|
|
Base: new(base),
|
|
Body: new(body),
|
|
})
|
|
if err != nil {
|
|
return 0, apiError(fmt.Sprintf("create pull request %s/%s", owner, repo), err)
|
|
}
|
|
return pr.GetNumber(), nil
|
|
}
|
|
|
|
// PRState returns "open", "merged", or "closed" for a PR.
|
|
func (c *GitHubClient) PRState(ctx context.Context, owner, repo string, number int) (string, error) {
|
|
pr, _, err := c.gh.PullRequests.Get(ctx, owner, repo, number)
|
|
if err != nil {
|
|
return "", apiError(fmt.Sprintf("get pull request %s/%s#%d", owner, repo, number), err)
|
|
}
|
|
if pr.GetMerged() {
|
|
return "merged", nil
|
|
}
|
|
return pr.GetState(), nil
|
|
}
|
|
|
|
// GetPullRequest returns the forge-neutral metadata for an existing PR.
|
|
func (c *GitHubClient) GetPullRequest(ctx context.Context, owner, repo string, number int) (forge.PullRequest, error) {
|
|
pr, _, err := c.gh.PullRequests.Get(ctx, owner, repo, number)
|
|
if err != nil {
|
|
return forge.PullRequest{}, apiError(fmt.Sprintf("get pull request %s/%s#%d", owner, repo, number), err)
|
|
}
|
|
state := pr.GetState()
|
|
if pr.GetMerged() {
|
|
state = "merged"
|
|
}
|
|
return forge.PullRequest{
|
|
Number: pr.GetNumber(),
|
|
Title: pr.GetTitle(),
|
|
Body: pr.GetBody(),
|
|
HeadRef: pr.GetHead().GetRef(),
|
|
BaseRef: pr.GetBase().GetRef(),
|
|
HeadSHA: pr.GetHead().GetSHA(),
|
|
BaseSHA: pr.GetBase().GetSHA(),
|
|
State: state,
|
|
}, nil
|
|
}
|
|
|
|
// GetPullRequestDiff fetches the pull request's unified diff over the
|
|
// GitHub API, never a local git clone.
|
|
func (c *GitHubClient) GetPullRequestDiff(ctx context.Context, owner, repo string, number int) (string, error) {
|
|
diff, _, err := c.gh.PullRequests.GetRaw(ctx, owner, repo, number, github.RawOptions{Type: github.Diff})
|
|
if err != nil {
|
|
return "", apiError(fmt.Sprintf("get pull request diff %s/%s#%d", owner, repo, number), err)
|
|
}
|
|
return diff, nil
|
|
}
|
|
|
|
// GetRepoArchive downloads a gzipped tar of the repository at ref. The
|
|
// download URL is pre-signed, so no token is sent.
|
|
func (c *GitHubClient) GetRepoArchive(ctx context.Context, owner, repo, ref string) (io.ReadCloser, error) {
|
|
url, _, err := c.gh.Repositories.GetArchiveLink(ctx, owner, repo, github.Tarball, &github.RepositoryContentGetOptions{Ref: ref}, 5)
|
|
if err != nil {
|
|
return nil, apiError(fmt.Sprintf("resolve archive link %s/%s@%s", owner, repo, ref), err)
|
|
}
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url.String(), nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("build archive request %s/%s@%s: %w", owner, repo, ref, err)
|
|
}
|
|
resp, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("fetch archive %s/%s@%s: %w", owner, repo, ref, withoutURL(err))
|
|
}
|
|
if resp.StatusCode != http.StatusOK {
|
|
body, _ := io.ReadAll(io.LimitReader(resp.Body, 2048))
|
|
_ = resp.Body.Close()
|
|
return nil, fmt.Errorf("fetch archive %s/%s@%s: status %s: %s", owner, repo, ref, resp.Status, body)
|
|
}
|
|
return resp.Body, nil
|
|
}
|
|
|
|
// withoutURL drops the request URL from a transport error. The pre-signed
|
|
// archive URL carries a token, so it must not reach logs or task errors.
|
|
func withoutURL(err error) error {
|
|
var uerr *url.Error
|
|
if errors.As(err, &uerr) {
|
|
return uerr.Err
|
|
}
|
|
return err
|
|
}
|
|
|
|
// ListReviews returns the reviews on a PR with ID > sinceID.
|
|
func (c *GitHubClient) ListReviews(ctx context.Context, owner, repo string, number int, sinceID int64) ([]forge.Review, error) {
|
|
var out []forge.Review
|
|
opts := &github.ListOptions{PerPage: 100}
|
|
for {
|
|
reviews, resp, err := c.gh.PullRequests.ListReviews(ctx, owner, repo, number, opts)
|
|
if err != nil {
|
|
return nil, apiError(fmt.Sprintf("list reviews %s/%s#%d", owner, repo, number), err)
|
|
}
|
|
for _, r := range reviews {
|
|
if r.GetID() <= sinceID {
|
|
continue
|
|
}
|
|
out = append(out, forge.Review{
|
|
ID: r.GetID(),
|
|
Author: r.GetUser().GetLogin(),
|
|
State: normalizeReviewState(r.GetState()),
|
|
Body: r.GetBody(),
|
|
SubmittedAt: r.GetSubmittedAt().Time,
|
|
})
|
|
}
|
|
if resp.NextPage == 0 {
|
|
break
|
|
}
|
|
opts.Page = resp.NextPage
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// ListReviewComments returns the review comments on a PR with ID > sinceID.
|
|
func (c *GitHubClient) ListReviewComments(ctx context.Context, owner, repo string, number int, sinceID int64) ([]forge.ReviewComment, error) {
|
|
var out []forge.ReviewComment
|
|
opts := &github.PullRequestListCommentsOptions{PerPage: 100}
|
|
for {
|
|
comments, resp, err := c.gh.PullRequests.ListComments(ctx, owner, repo, number, opts)
|
|
if err != nil {
|
|
return nil, apiError(fmt.Sprintf("list review comments %s/%s#%d", owner, repo, number), err)
|
|
}
|
|
for _, cm := range comments {
|
|
if cm.GetID() <= sinceID {
|
|
continue
|
|
}
|
|
line := cm.GetOriginalLine()
|
|
if line == 0 {
|
|
line = cm.GetLine()
|
|
}
|
|
out = append(out, forge.ReviewComment{
|
|
ID: cm.GetID(),
|
|
ReviewID: cm.GetPullRequestReviewID(),
|
|
Author: cm.GetUser().GetLogin(),
|
|
Body: cm.GetBody(),
|
|
Path: cm.GetPath(),
|
|
Line: line,
|
|
InReplyTo: cm.GetInReplyTo(),
|
|
CreatedAt: cm.GetCreatedAt().Time,
|
|
})
|
|
}
|
|
if resp.NextPage == 0 {
|
|
break
|
|
}
|
|
opts.Page = resp.NextPage
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// ReplyToReview posts a reply to an existing review comment.
|
|
func (c *GitHubClient) ReplyToReview(ctx context.Context, owner, repo string, number int, commentID int64, body string) error {
|
|
if _, _, err := c.gh.PullRequests.CreateCommentInReplyTo(ctx, owner, repo, number, body, commentID); err != nil {
|
|
return apiError(fmt.Sprintf("reply to review comment %d on %s/%s#%d", commentID, owner, repo, number), err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// CreateReviewComments submits the review on the PR head's new side, refused
|
|
// if the head moved past reviewedHeadSHA.
|
|
func (c *GitHubClient) CreateReviewComments(ctx context.Context, owner, repo string, number int, reviewedHeadSHA string, review forge.ReviewSubmission) error {
|
|
pr, _, err := c.gh.PullRequests.Get(ctx, owner, repo, number)
|
|
if err != nil {
|
|
return apiError(fmt.Sprintf("get pull request %s/%s#%d", owner, repo, number), err)
|
|
}
|
|
head := pr.GetHead().GetSHA()
|
|
if head == "" {
|
|
return fmt.Errorf("resolve head revision of %s/%s#%d: the forge reported no head sha", owner, repo, number)
|
|
}
|
|
if err := forge.ReviewHeadDrift(owner, repo, number, head, reviewedHeadSHA); err != nil {
|
|
return err
|
|
}
|
|
if review.Event == forge.ReviewEventRequestChanges {
|
|
self, err := c.selfLogin(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
review.Event = reviewEvent(review.Event, pr.GetUser().GetLogin(), self)
|
|
}
|
|
comments := make([]*github.DraftReviewComment, 0, len(review.Comments))
|
|
for _, cm := range review.Comments {
|
|
comments = append(comments, &github.DraftReviewComment{
|
|
Body: new(cm.Body),
|
|
Path: new(cm.Path),
|
|
Line: new(cm.Line),
|
|
Side: new("RIGHT"),
|
|
})
|
|
}
|
|
body := review.Body
|
|
// GitHub rejects a REQUEST_CHANGES review with an empty body.
|
|
if body == "" && review.Event == forge.ReviewEventRequestChanges {
|
|
body = "Changes requested."
|
|
}
|
|
req := &github.PullRequestReviewRequest{
|
|
CommitID: new(head),
|
|
Body: new(body),
|
|
Event: new(review.Event),
|
|
Comments: comments,
|
|
}
|
|
if _, _, err := c.gh.PullRequests.CreateReview(ctx, owner, repo, number, req); err != nil {
|
|
return apiError(fmt.Sprintf("create review on %s/%s#%d", owner, repo, number), err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// reviewEvent is the event a review can post as: GitHub refuses
|
|
// REQUEST_CHANGES from the pull request's own author, so it comments instead.
|
|
func reviewEvent(event, author, self string) string {
|
|
if event == forge.ReviewEventRequestChanges && author != "" && strings.EqualFold(author, self) {
|
|
return forge.ReviewEventComment
|
|
}
|
|
return event
|
|
}
|
|
|
|
// selfLogin is the login the token acts as, read once.
|
|
func (c *GitHubClient) selfLogin(ctx context.Context) (string, error) {
|
|
c.loginMu.Lock()
|
|
defer c.loginMu.Unlock()
|
|
if c.login != "" {
|
|
return c.login, nil
|
|
}
|
|
user, _, err := c.gh.Users.Get(ctx, "")
|
|
if err != nil {
|
|
return "", apiError("read the token's user", err)
|
|
}
|
|
c.login = user.GetLogin()
|
|
return c.login, nil
|
|
}
|
|
|
|
// CloseIssue closes an issue with a final comment (feasibility "won't do").
|
|
func (c *GitHubClient) CloseIssue(ctx context.Context, owner, repo string, number int, comment string) error {
|
|
if comment != "" {
|
|
if _, err := c.Comment(ctx, owner, repo, number, comment); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
_, _, err := c.gh.Issues.Edit(ctx, owner, repo, number,
|
|
&github.IssueRequest{State: new("closed")})
|
|
return apiError(fmt.Sprintf("close issue %s/%s#%d", owner, repo, number), err)
|
|
}
|
|
|
|
// ClosePR closes a pull request without merging, with an optional final
|
|
// comment.
|
|
func (c *GitHubClient) ClosePR(ctx context.Context, owner, repo string, number int, comment string) error {
|
|
if comment != "" {
|
|
if _, err := c.Comment(ctx, owner, repo, number, comment); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
_, _, err := c.gh.PullRequests.Edit(ctx, owner, repo, number,
|
|
&github.PullRequest{State: new("closed")})
|
|
return apiError(fmt.Sprintf("close pull request %s/%s#%d", owner, repo, number), err)
|
|
}
|
|
|
|
// MergePR merges a pull request with the repository's default method.
|
|
func (c *GitHubClient) MergePR(ctx context.Context, owner, repo string, number int) error {
|
|
_, _, err := c.gh.PullRequests.Merge(ctx, owner, repo, number, "", nil)
|
|
return apiError(fmt.Sprintf("merge pull request %s/%s#%d", owner, repo, number), err)
|
|
}
|
|
|
|
// LinkBranch associates a branch with an issue (GitHub stub -- Gitea is primary).
|
|
func (c *GitHubClient) LinkBranch(ctx context.Context, owner, repo string, issueNumber int, branch string) error {
|
|
return nil
|
|
}
|
|
|
|
// stateLabelColors maps label name → colour for on-demand creation.
|
|
var stateLabelColors = map[string]string{
|
|
"archie:queued": "bfd4f2", // grey-blue
|
|
"archie:working": "1d76db", // blue
|
|
"archie:waiting": "fbca04", // yellow
|
|
"archie:pr": "0e8a16", // green
|
|
"archie:parked": "d93f0b", // orange-red
|
|
}
|
|
|
|
// defaultLabelColor is used for custom labels not in stateLabelColors.
|
|
const defaultLabelColor = "bfd4f2"
|
|
|
|
// React adds an emoji reaction to an issue -- the instant "received"
|
|
// acknowledgement on pickup.
|
|
func (c *GitHubClient) React(ctx context.Context, owner, repo string, number int, reaction string) error {
|
|
_, _, err := c.gh.Reactions.CreateIssueReaction(ctx, owner, repo, number, reaction)
|
|
return apiError(fmt.Sprintf("react to %s/%s#%d", owner, repo, number), err)
|
|
}
|
|
|
|
// ensureLabel creates the state label in the repo if it doesn't exist.
|
|
func (c *GitHubClient) ensureLabel(ctx context.Context, owner, repo, name string) {
|
|
key := owner + "/" + repo + "/" + name
|
|
c.labelMu.Lock()
|
|
seen := c.labelsEnsured[key]
|
|
c.labelMu.Unlock()
|
|
if seen {
|
|
return
|
|
}
|
|
color := stateLabelColors[name]
|
|
if color == "" {
|
|
color = defaultLabelColor
|
|
}
|
|
_, _, err := c.gh.Issues.CreateLabel(ctx, owner, repo, &github.Label{
|
|
Name: new(name),
|
|
Color: new(color),
|
|
Description: new("archie task state (managed automatically)"),
|
|
})
|
|
// Already existing is as good as created.
|
|
if err != nil && !alreadyExists(err) {
|
|
c.log.Warn("create label failed", "label", name, "err", apiError("create label", err))
|
|
return
|
|
}
|
|
c.labelMu.Lock()
|
|
if c.labelsEnsured == nil {
|
|
c.labelsEnsured = map[string]bool{}
|
|
}
|
|
c.labelsEnsured[key] = true
|
|
c.labelMu.Unlock()
|
|
}
|
|
|
|
// SetStateLabel makes label the issue's only state label, removing any
|
|
// other label found in knownLabels first. An empty label clears all
|
|
// state labels (terminal states).
|
|
func (c *GitHubClient) SetStateLabel(ctx context.Context, owner, repo string, number int, label string, knownLabels []string) {
|
|
known := make(map[string]bool, len(knownLabels))
|
|
for _, l := range knownLabels {
|
|
known[l] = true
|
|
}
|
|
issue, _, err := c.gh.Issues.Get(ctx, owner, repo, number)
|
|
if err != nil {
|
|
c.log.Warn("set state label: get issue failed", "issue", number, "err", apiError("get issue", err))
|
|
return
|
|
}
|
|
for _, l := range issue.Labels {
|
|
name := l.GetName()
|
|
if name != label && known[name] {
|
|
if _, err := c.gh.Issues.RemoveLabelForIssue(ctx, owner, repo, number, name); err != nil {
|
|
c.log.Warn("remove state label failed", "label", name, "err", apiError("remove label", err))
|
|
}
|
|
}
|
|
if name == label {
|
|
label = "" // already present; nothing to add
|
|
}
|
|
}
|
|
if label == "" {
|
|
return
|
|
}
|
|
c.ensureLabel(ctx, owner, repo, label)
|
|
if _, _, err := c.gh.Issues.AddLabelsToIssue(ctx, owner, repo, number, []string{label}); err != nil {
|
|
c.log.Warn("add state label failed", "label", label, "err", apiError("add label", err))
|
|
}
|
|
}
|
|
|
|
// VerifyPush confirms the token can push to the repo (permission check
|
|
// at startup so misconfiguration surfaces before any work is claimed).
|
|
func (c *GitHubClient) VerifyPush(ctx context.Context, owner, repo string) error {
|
|
r, _, err := c.gh.Repositories.Get(ctx, owner, repo)
|
|
if err != nil {
|
|
return apiError(fmt.Sprintf("get repository %s/%s", owner, repo), err)
|
|
}
|
|
perms := r.GetPermissions()
|
|
if !perms["push"] {
|
|
return fmt.Errorf("no push permission on %s/%s", owner, repo)
|
|
}
|
|
return nil
|
|
}
|