Files

640 lines
21 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
// app is set when the connection authenticates as a GitHub App.
app *app
}
// 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) {
host = strings.TrimRight(host, "/")
base := github_ratelimit.NewClient(nil, github_secondary_ratelimit.WithSingleSleepLimit(maxRateLimitWait, nil)).Transport
enterprise := func(c *github.Client) (*github.Client, error) {
if host == "https://github.com" {
return c, nil
}
c, err := c.WithEnterpriseURLs(host, host)
if err != nil {
return nil, fmt.Errorf("configure GitHub host %q: %w", host, err)
}
return c, nil
}
cred, isApp := parseAppCredential(token)
if !isApp {
client, err := enterprise(github.NewClient(&http.Client{Transport: base}))
if err != nil {
return nil, err
}
return &GitHubClient{gh: client.WithAuthToken(token), log: log}, nil
}
apiBase := "https://api.github.com"
if host != "https://github.com" {
apiBase = host + "/api/v3"
}
a, err := newApp(base, cred, apiBase, enterprise)
if err != nil {
return nil, err
}
client, err := enterprise(github.NewClient(&http.Client{Transport: a}))
if err != nil {
return nil, err
}
return &GitHubClient{gh: client, log: log, app: a}, nil
}
// AcceptInvitations accepts pending repository invitations, but only to the
// repositories the operator configured this connection for, so adding archie
// as a collaborator to a configured repository is all a human has to do. An
// invitation to anything else is left pending.
func (c *GitHubClient) AcceptInvitations(ctx context.Context, repos []forge.RepoRef) error {
if c.app != nil {
return nil // an app reaches repositories by installation, not invitation
}
invites, _, err := c.gh.Users.ListInvitations(ctx, nil)
if err != nil {
return apiError("list invitations", err)
}
accept, pending := splitInvitations(invites, repos)
for _, inv := range pending {
c.log.Warn("ignoring repository invitation outside the configured repositories",
"repo", inv.GetRepo().GetFullName(), "inviter", inv.GetInviter().GetLogin())
}
for _, inv := range accept {
full := inv.GetRepo().GetFullName()
if _, err := c.gh.Users.AcceptInvitation(ctx, inv.GetID()); err != nil {
c.log.Warn("accept invitation failed", "repo", full, "err", apiError("accept invitation", err))
continue
}
c.log.Info("accepted repository invitation", "repo", full)
}
return nil
}
// splitInvitations partitions pending invitations into those to accept --
// invitations to repositories the operator configured -- and those to leave
// pending. Matching is on the lower-cased "owner/repo" full name, because
// GitHub names are case-insensitive.
func splitInvitations(invites []*github.RepositoryInvitation, repos []forge.RepoRef) (accept, pending []*github.RepositoryInvitation) {
allowed := make(map[string]bool, len(repos))
for _, r := range repos {
allowed[strings.ToLower(r.Owner+"/"+r.Repo)] = true
}
for _, inv := range invites {
if allowed[strings.ToLower(inv.GetRepo().GetFullName())] {
accept = append(accept, inv)
} else {
pending = append(pending, inv)
}
}
return accept, pending
}
// 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),
Author: is.GetUser().GetLogin(),
})
}
}
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",
ListOptions: github.ListOptions{PerPage: 50},
}
if label != "" {
opts.Labels = []string{label}
}
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),
Author: is.GetUser().GetLogin(),
})
}
}
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
}
if c.app != nil {
login, _, err := c.app.identity(ctx)
c.login = login
return login, err
}
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
}
// CreateIssue opens an issue with title, body and optional labels.
func (c *GitHubClient) CreateIssue(ctx context.Context, owner, repo, title, body string, labels []string) (int, error) {
req := &github.IssueRequest{Title: new(title), Body: new(body)}
if len(labels) > 0 {
req.Labels = &labels
}
issue, _, err := c.gh.Issues.Create(ctx, owner, repo, req)
if err != nil {
return 0, apiError(fmt.Sprintf("create issue in %s/%s", owner, repo), err)
}
return issue.GetNumber(), 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 {
if c.app != nil {
ok, err := c.app.canPush(ctx, owner, repo)
if err == nil && !ok {
err = fmt.Errorf("the GitHub App needs Contents: write on %s/%s", owner, repo)
}
return err
}
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
}
// HasWriteAccess reports whether user holds write, maintain or admin access to
// owner/repo. A user the forge does not know has none.
func (c *GitHubClient) HasWriteAccess(ctx context.Context, owner, repo, user string) (bool, error) {
if user == "" {
return false, nil
}
level, resp, err := c.gh.Repositories.GetPermissionLevel(ctx, owner, repo, user)
if resp != nil && resp.StatusCode == http.StatusNotFound {
return false, nil
}
if err != nil {
return false, apiError(fmt.Sprintf("check write access for %s on %s/%s", user, owner, repo), err)
}
return canWrite(level.GetPermission(), level.GetRoleName()), nil
}
// canWrite maps a permission and role name onto write access. The permission
// field folds maintain into write, but the role name is checked too so a
// custom role named for it is not dropped.
func canWrite(permission, role string) bool {
switch strings.ToLower(permission) {
case "admin", "write", "maintain":
return true
}
switch strings.ToLower(role) {
case "admin", "write", "maintain":
return true
}
return false
}