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 }