From 487a58e24b493e8aa75cc7dd9792668e8bb597c9 Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Sun, 4 Oct 2026 14:26:27 +1100 Subject: [PATCH] feat(forge): github and gitea forge extensions --- README.md | 1 + forge/gitea/client.go | 491 ++++++++++++++++++++++++++ forge/gitea/main.go | 15 + forge/gitea/package.yaml | 11 + forge/github/client.go | 453 ++++++++++++++++++++++++ forge/github/main.go | 33 ++ forge/github/package.yaml | 15 + forge/github/webhook.go | 89 +++++ go.mod | 8 + go.sum | 35 +- sdk/forge/forge.go | 173 ++++++++++ sdk/forge/serve.go | 3 +- sdk/forge/server.go | 318 +++++++++++++++++ sdk/forge/v1/forge.pb.go | 624 +++++++++++++++++++++++++++++++--- sdk/forge/v1/forge_grpc.pb.go | 44 +++ 15 files changed, 2259 insertions(+), 54 deletions(-) create mode 100644 forge/gitea/client.go create mode 100644 forge/gitea/main.go create mode 100644 forge/gitea/package.yaml create mode 100644 forge/github/client.go create mode 100644 forge/github/main.go create mode 100644 forge/github/package.yaml create mode 100644 forge/github/webhook.go create mode 100644 sdk/forge/forge.go create mode 100644 sdk/forge/server.go diff --git a/README.md b/README.md index f1d2720..f391b29 100644 --- a/README.md +++ b/README.md @@ -6,6 +6,7 @@ directory holds one subdirectory per extension. ``` secret-engines// package.yaml + Go source, served over secretengine.v1 workflows// package.yaml + workflow YAML, projected into workflow-definitions +forge// package.yaml + Go source, served over forge.v1 (github, gitea) playbooks// package.yaml + EDA playbook YAML, projected into eda-playbooks profiles// package.yaml + agent profile YAML, projected into agent-profiles sdk/ generated surface stubs and the Serve helper diff --git a/forge/gitea/client.go b/forge/gitea/client.go new file mode 100644 index 0000000..205943f --- /dev/null +++ b/forge/gitea/client.go @@ -0,0 +1,491 @@ +package main + +import ( + "context" + "fmt" + "io" + "log/slog" + "math" + "net/http" + "strings" + "sync" + + "github.com/samcharles93/archipelago/sdk/forge" + + "code.gitea.io/sdk/gitea" +) + +// GiteaClient implements Forge against a Gitea instance. +type GiteaClient struct { + cli *gitea.Client + host string + token string + log *slog.Logger + + labelMu sync.Mutex + labelsEnsured map[string]bool +} + +// NewGitea creates a Gitea-backed Forge implementation. +func newGitea(token, host string, log *slog.Logger) (forge.Forge, error) { + host = strings.TrimRight(host, "/") + cli, err := gitea.NewClient(host, gitea.SetToken(token)) + if err != nil { + return nil, fmt.Errorf("gitea client %s: %w", host, err) + } + return &GiteaClient{cli: cli, host: host, token: token, log: log}, nil +} + +// ── Forge interface ────────────────────────────────────────────────── + +// AcceptInvitations auto-accepts pending repository invitations. +func (c *GiteaClient) AcceptInvitations(ctx context.Context) error { + // Gitea doesn't have a direct equivalent to GitHub's user invitations + // API. Repository collaborators are added directly by the owner. + return nil +} + +// AssignedIssues returns open issues assigned to the given user, excluding PRs. +func (c *GiteaClient) AssignedIssues(ctx context.Context, owner, repo, assignee string) ([]forge.Issue, error) { + opts := gitea.ListIssueOption{ + PageSize: 50, + State: gitea.StateOpen, + AssignedBy: assignee, + } + var out []forge.Issue + for { + issues, resp, err := c.cli.ListRepoIssues(owner, repo, opts) + if err != nil { + return nil, fmt.Errorf("list issues %s/%s: %w", owner, repo, err) + } + for _, is := range issues { + if is.PullRequest == nil { + out = append(out, forge.Issue{ + Number: int(is.Index), + Title: is.Title, + Body: is.Body, + Labels: labelNamesGitea(is.Labels), + }) + } + } + if resp.NextPage == 0 { + break + } + opts.Page = resp.NextPage + } + return out, nil +} + +// IssuesWithLabel returns open issues matching the given label, excluding PRs. +func (c *GiteaClient) IssuesWithLabel(ctx context.Context, owner, repo, label string) ([]forge.Issue, error) { + opts := gitea.ListIssueOption{ + PageSize: 50, + State: gitea.StateOpen, + Labels: []string{label}, + } + var out []forge.Issue + for { + issues, resp, err := c.cli.ListRepoIssues(owner, repo, opts) + if err != nil { + return nil, fmt.Errorf("list issues %s/%s: %w", owner, repo, err) + } + for _, is := range issues { + if is.PullRequest == nil { + out = append(out, forge.Issue{ + Number: int(is.Index), + Title: is.Title, + Body: is.Body, + Labels: labelNamesGitea(is.Labels), + }) + } + } + if resp.NextPage == 0 { + break + } + opts.Page = resp.NextPage + } + return out, nil +} + +// Comment posts an issue comment and returns its id. +func (c *GiteaClient) Comment(ctx context.Context, owner, repo string, number int, body string) (int64, error) { + cm, _, err := c.cli.CreateIssueComment(owner, repo, int64(number), gitea.CreateIssueCommentOption{Body: body}) + if err != nil { + return 0, err + } + return cm.ID, nil +} + +// CreatePR opens a pull request and returns its number. +func (c *GiteaClient) CreatePR(ctx context.Context, owner, repo, title, head, base, body string) (int, error) { + pr, _, err := c.cli.CreatePullRequest(owner, repo, gitea.CreatePullRequestOption{ + Title: title, + Head: head, + Base: base, + Body: body, + }) + if err != nil { + return 0, fmt.Errorf("create PR %s/%s: %w", owner, repo, err) + } + return int(pr.Index), nil +} + +// PRState returns "open", "merged", or "closed" for a PR. +// Returns "closed" for non-existent PRs (already merged/closed/removed). +func (c *GiteaClient) PRState(ctx context.Context, owner, repo string, number int) (string, error) { + pr, _, err := c.cli.GetPullRequest(owner, repo, int64(number)) + if err != nil { + // "not found" means the PR was already merged/closed and cleaned up. + if strings.Contains(err.Error(), "not found") || strings.Contains(err.Error(), "GetUserByName") { + return "closed", nil + } + return "", err + } + if pr.HasMerged { + return "merged", nil + } + return string(pr.State), nil +} + +// GetPullRequest returns the forge-neutral metadata for an existing PR. +func (c *GiteaClient) GetPullRequest(ctx context.Context, owner, repo string, number int) (forge.PullRequest, error) { + pr, _, err := c.cli.GetPullRequest(owner, repo, int64(number)) + if err != nil { + return forge.PullRequest{}, fmt.Errorf("get pull request %s/%s#%d: %w", owner, repo, number, err) + } + // A merged/closed PR whose head branch was deleted returns nil head/base + // from Gitea; dereferencing it would panic. + if pr.Head == nil || pr.Base == nil { + return forge.PullRequest{}, fmt.Errorf("pull request %s/%s#%d has a missing head or base ref", owner, repo, number) + } + state := string(pr.State) + if pr.HasMerged { + state = "merged" + } + return forge.PullRequest{ + Number: int(pr.Index), + Title: pr.Title, + Body: pr.Body, + HeadRef: pr.Head.Ref, + BaseRef: pr.Base.Ref, + HeadSHA: pr.Head.Sha, + BaseSHA: pr.Base.Sha, + State: state, + }, nil +} + +// GetPullRequestDiff fetches the pull request's unified diff over the Gitea +// API, never a local git clone. +func (c *GiteaClient) GetPullRequestDiff(_ context.Context, owner, repo string, number int) (string, error) { + diff, _, err := c.cli.GetPullRequestDiff(owner, repo, int64(number), gitea.PullRequestDiffOptions{}) + if err != nil { + return "", fmt.Errorf("get pull request diff %s/%s#%d: %w", owner, repo, number, err) + } + return string(diff), nil +} + +// GetRepoArchive fetches a gzipped tar archive of the repository at ref +// directly from Gitea's own API -- unlike GitHub, no separate unauthenticated +// fetch is needed. +func (c *GiteaClient) GetRepoArchive(_ context.Context, owner, repo, ref string) (io.ReadCloser, error) { + body, _, err := c.cli.GetArchiveReader(owner, repo, ref, gitea.TarGZArchive) + if err != nil { + return nil, fmt.Errorf("get repo archive %s/%s@%s: %w", owner, repo, ref, err) + } + return body, nil +} + +// ListReviews returns the reviews on a PR with ID > sinceID. +func (c *GiteaClient) ListReviews(ctx context.Context, owner, repo string, number int, sinceID int64) ([]forge.Review, error) { + var out []forge.Review + opts := gitea.ListPullReviewsOptions{} + for { + reviews, resp, err := c.cli.ListPullReviews(owner, repo, int64(number), opts) + if err != nil { + return nil, fmt.Errorf("list reviews %s/%s#%d: %w", owner, repo, number, err) + } + for _, r := range reviews { + if r.ID <= sinceID { + continue + } + out = append(out, forge.Review{ + ID: r.ID, + Author: giteaReviewAuthor(r.Reviewer), + State: normalizeGiteaReviewState(r.State), + Body: r.Body, + SubmittedAt: r.Submitted, + }) + } + if resp.NextPage == 0 { + break + } + opts.Page = resp.NextPage + } + return out, nil +} + +// ListReviewComments returns the inline review comments on a PR with +// ID > sinceID. Gitea nests comments under reviews, so this lists each +// review's comments. +func (c *GiteaClient) ListReviewComments(ctx context.Context, owner, repo string, number int, sinceID int64) ([]forge.ReviewComment, error) { + reviews, err := c.ListReviews(ctx, owner, repo, number, 0) + if err != nil { + return nil, err + } + var out []forge.ReviewComment + for _, rv := range reviews { + comments, _, err := c.cli.ListPullReviewComments(owner, repo, int64(number), rv.ID) + if err != nil { + return nil, fmt.Errorf("list review comments %s/%s#%d review %d: %w", owner, repo, number, rv.ID, err) + } + for _, cm := range comments { + if cm.ID <= sinceID { + continue + } + // LineNum is the forge's uint64. A value past the int range is not a + // line this client can name, and wrapping it would put a negative + // line number in front of a reviewer. + if cm.LineNum > math.MaxInt { + return nil, fmt.Errorf("review comment %d on %s/%s#%d has line number %d, which does not fit an int", cm.ID, owner, repo, number, cm.LineNum) + } + out = append(out, forge.ReviewComment{ + ID: cm.ID, + ReviewID: rv.ID, + Author: giteaReviewAuthor(cm.Reviewer), + Body: cm.Body, + Path: cm.Path, + Line: int(cm.LineNum), + CreatedAt: cm.Created, + }) + } + } + return out, nil +} + +// ReplyToReview posts a reply to an existing review comment. +func (c *GiteaClient) ReplyToReview(ctx context.Context, owner, repo string, number int, commentID int64, body string) error { + if _, _, err := c.cli.CreatePullReviewCommentReply(owner, repo, int64(number), commentID, gitea.CreatePullReviewCommentReplyOptions{Body: body}); err != nil { + return fmt.Errorf("reply to review comment %d on %s/%s#%d: %w", commentID, owner, repo, number, err) + } + return nil +} + +// CreateReviewComments posts the comments as one COMMENT review on the PR's +// head, refused if the head moved past reviewedHeadSHA. +func (c *GiteaClient) CreateReviewComments(ctx context.Context, owner, repo string, number int, reviewedHeadSHA string, comments []forge.InlineReviewComment) error { + pr, err := c.GetPullRequest(ctx, owner, repo, number) + if err != nil { + return err + } + if pr.HeadSHA == "" { + 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, pr.HeadSHA, reviewedHeadSHA); err != nil { + return err + } + reviewComments := make([]gitea.CreatePullReviewComment, 0, len(comments)) + for _, cm := range comments { + reviewComments = append(reviewComments, gitea.CreatePullReviewComment{ + Path: cm.Path, + Body: cm.Body, + NewLineNum: int64(cm.Line), + }) + } + if _, _, err := c.cli.CreatePullReview(owner, repo, int64(number), gitea.CreatePullReviewOptions{ + State: gitea.ReviewStateComment, + CommitID: pr.HeadSHA, + Comments: reviewComments, + }); err != nil { + return fmt.Errorf("create review comments on %s/%s#%d: %w", owner, repo, number, err) + } + return nil +} + +// giteaReviewAuthor returns a review/comment author's login, or "" when the +// author is absent (a team review, or a deleted user). +func giteaReviewAuthor(u *gitea.User) string { + if u == nil { + return "" + } + return u.UserName +} + +// normalizeGiteaReviewState maps a Gitea review state onto the neutral +// ReviewState* constants. Pending and request-review reviews are not a +// decision and pass through lowercased so the caller can ignore them. +func normalizeGiteaReviewState(s gitea.ReviewStateType) string { + switch s { + case gitea.ReviewStateApproved: + return forge.ReviewStateApproved + case gitea.ReviewStateRequestChanges: + return forge.ReviewStateRequestedChanges + case gitea.ReviewStateComment: + return forge.ReviewStateCommented + default: + return strings.ToLower(string(s)) + } +} + +// CloseIssue closes an issue with an optional final comment. +func (c *GiteaClient) 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 + } + } + state := gitea.StateClosed + _, _, err := c.cli.EditIssue(owner, repo, int64(number), gitea.EditIssueOption{State: &state}) + return err +} + +// React adds an emoji reaction to an issue. +func (c *GiteaClient) React(ctx context.Context, owner, repo string, number int, reaction string) error { + _, _, err := c.cli.PostIssueReaction(owner, repo, int64(number), reaction) + return err +} + +// LinkBranch associates a branch with an issue via the Gitea API. +func (c *GiteaClient) LinkBranch(ctx context.Context, owner, repo string, issueNumber int, branch string) error { + url := fmt.Sprintf("%s/api/v1/repos/%s/%s/issues/%d/refs", c.host, owner, repo, issueNumber) + body := fmt.Sprintf(`{"ref": "%s"}`, branch) + req, _ := http.NewRequestWithContext(ctx, http.MethodPost, url, strings.NewReader(body)) + req.Header.Set("Authorization", "token "+c.token) + req.Header.Set("Content-Type", "application/json") + resp, err := http.DefaultClient.Do(req) + if err != nil { + return err + } + _, _ = io.Copy(io.Discard, resp.Body) + _ = resp.Body.Close() + if resp.StatusCode >= 300 { + return fmt.Errorf("link branch: HTTP %d", resp.StatusCode) + } + return nil +} + +// SetStateLabel makes label the issue's only state label. +func (c *GiteaClient) 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.cli.GetIssue(owner, repo, int64(number)) + if err != nil { + c.log.Warn("set state label: get issue failed", "issue", number, "err", err) + return + } + // Remove known state labels (except the target). + for _, l := range issue.Labels { + if l.Name == label { + label = "" // already present + } else if known[l.Name] { + if _, err := c.cli.DeleteIssueLabel(owner, repo, int64(number), l.ID); err != nil { + c.log.Warn("remove state label failed", "label", l.Name, "err", err) + } + } + } + if label == "" { + return + } + // Find or create the target label and add it by ID. + labelID := c.resolveLabelID(owner, repo, label) + if labelID == 0 { + return // ensureLabel already logged + } + if _, _, err := c.cli.AddIssueLabels(owner, repo, int64(number), gitea.IssueLabelsOption{ + Labels: []int64{labelID}, + }); err != nil { + c.log.Warn("add state label failed", "label", label, "err", err) + } +} + +// resolveLabelID returns the ID of a label, creating it if necessary. +func (c *GiteaClient) resolveLabelID(owner, repo, name string) int64 { + labels, _, err := c.cli.ListRepoLabels(owner, repo, gitea.ListLabelsOptions{PageSize: 100}) + if err != nil { + c.log.Warn("list repo labels failed", "err", err) + return 0 + } + for _, l := range labels { + if l.Name == name { + return l.ID + } + } + // Create the label. + c.ensureLabel(owner, repo, name) + // Re-list to get the new ID. + labels, _, err = c.cli.ListRepoLabels(owner, repo, gitea.ListLabelsOptions{PageSize: 100}) + if err != nil { + return 0 + } + for _, l := range labels { + if l.Name == name { + return l.ID + } + } + return 0 +} + +// VerifyPush confirms the token can push to the repo. +func (c *GiteaClient) VerifyPush(ctx context.Context, owner, repo string) error { + r, _, err := c.cli.GetRepo(owner, repo) + if err != nil { + // Gitea SDK may return "GetUserByName" for a non-existent repo. + if strings.Contains(err.Error(), "GetUserByName") { + return fmt.Errorf("repo %s/%s not found or token lacks access", owner, repo) + } + return fmt.Errorf("get repo %s/%s: %w", owner, repo, err) + } + if !r.Permissions.Push { + return fmt.Errorf("no push permission on %s/%s", owner, repo) + } + return nil +} + +// ── helpers ────────────────────────────────────────────────────────── + +func labelNamesGitea(labels []*gitea.Label) []string { + var names []string + for _, l := range labels { + names = append(names, l.Name) + } + return names +} + +// Gitea state label colours matching the GitHub palette. +var giteaStateLabelColors = map[string]string{ + "archie:queued": "#bfd4f2", + "archie:working": "#1d76db", + "archie:waiting": "#fbca04", + "archie:pr": "#0e8a16", + "archie:parked": "#d93f0b", +} + +func (c *GiteaClient) ensureLabel(owner, repo, name string) { + key := owner + "/" + repo + "/" + name + c.labelMu.Lock() + seen := c.labelsEnsured[key] + c.labelMu.Unlock() + if seen { + return + } + color := giteaStateLabelColors[name] + if color == "" { + color = "#bfd4f2" + } + _, _, err := c.cli.CreateLabel(owner, repo, gitea.CreateLabelOption{ + Name: name, + Color: color, + Description: "archie task state (managed automatically)", + }) + if err != nil && !strings.Contains(err.Error(), "already exists") && !strings.Contains(err.Error(), "422") { + c.log.Warn("create label failed", "label", name, "err", err) + return + } + c.labelMu.Lock() + if c.labelsEnsured == nil { + c.labelsEnsured = map[string]bool{} + } + c.labelsEnsured[key] = true + c.labelMu.Unlock() +} diff --git a/forge/gitea/main.go b/forge/gitea/main.go new file mode 100644 index 0000000..fee407f --- /dev/null +++ b/forge/gitea/main.go @@ -0,0 +1,15 @@ +// Command gitea is the Gitea forge extension: issues, pull requests and +// reviews over the Gitea API. +package main + +import ( + "log/slog" + + "github.com/samcharles93/archipelago/sdk/forge" +) + +func main() { + forge.Serve(func(cfg forge.Config) (forge.Forge, error) { + return newGitea(cfg.Token, cfg.Host, slog.Default()) + }) +} diff --git a/forge/gitea/package.yaml b/forge/gitea/package.yaml new file mode 100644 index 0000000..36665a2 --- /dev/null +++ b/forge/gitea/package.yaml @@ -0,0 +1,11 @@ +apiVersion: dev.archie.package.v1 +displayName: Gitea forge +description: Gitea issues, pull requests and reviews for archie-core. The instance's host is named by the operator's egress acceptance. +version: 1.0.0 +contributes: + extensions: + - surface: forge + path: bin/gitea +files: + - path: bin/gitea + mode: 493 diff --git a/forge/github/client.go b/forge/github/client.go new file mode 100644 index 0000000..80d7f50 --- /dev/null +++ b/forge/github/client.go @@ -0,0 +1,453 @@ +package main + +import ( + "context" + "errors" + "fmt" + "io" + "log/slog" + "net/http" + "strings" + "sync" + + "github.com/samcharles93/archipelago/sdk/forge" + + "github.com/google/go-github/v78/github" +) + +// GitHubClient implements Forge against the GitHub API. +type GitHubClient struct { + gh *github.Client + log *slog.Logger + + labelMu sync.Mutex + labelsEnsured map[string]bool +} + +// 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(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 fmt.Errorf("list invitations: %w", 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", 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, fmt.Errorf("list issues %s/%s: %w", 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, fmt.Errorf("list issues %s/%s: %w", 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, 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, fmt.Errorf("create PR %s/%s: %w", 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 "", 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{}, fmt.Errorf("get pull request %s/%s#%d: %w", 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 "", fmt.Errorf("get pull request diff %s/%s#%d: %w", 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, fmt.Errorf("resolve archive link %s/%s@%s: %w", 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, 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 +} + +// 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, fmt.Errorf("list reviews %s/%s#%d: %w", 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, fmt.Errorf("list review comments %s/%s#%d: %w", 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 fmt.Errorf("reply to review comment %d on %s/%s#%d: %w", commentID, owner, repo, number, err) + } + return nil +} + +// CreateReviewComments posts each comment on the PR head's new side, refused +// if the head moved past reviewedHeadSHA. Failures are joined; the rest are +// still posted. +func (c *GitHubClient) CreateReviewComments(ctx context.Context, owner, repo string, number int, reviewedHeadSHA string, comments []forge.InlineReviewComment) error { + head, err := c.reviewHeadSHA(ctx, owner, repo, number) + if err != nil { + return err + } + if err := forge.ReviewHeadDrift(owner, repo, number, head, reviewedHeadSHA); err != nil { + return err + } + var errs []error + for _, cm := range comments { + comment := &github.PullRequestComment{ + Body: new(cm.Body), + Path: new(cm.Path), + Line: new(cm.Line), + Side: new("RIGHT"), + CommitID: new(head), + } + if _, _, err := c.gh.PullRequests.CreateComment(ctx, owner, repo, number, comment); err != nil { + errs = append(errs, fmt.Errorf("create review comment %s:%d on %s/%s#%d: %w", cm.Path, cm.Line, owner, repo, number, err)) + } + } + return errors.Join(errs...) +} + +// reviewHeadSHA resolves the commit a PR's line numbers are anchored to. A +// forge that reports an empty head SHA is a failure, not an anchor: an empty +// commit_id makes GitHub reject every comment in the set with nothing that says +// why. +func (c *GitHubClient) reviewHeadSHA(ctx context.Context, owner, repo string, number int) (string, error) { + pr, err := c.GetPullRequest(ctx, owner, repo, number) + if err != nil { + return "", err + } + if pr.HeadSHA == "" { + return "", fmt.Errorf("resolve head revision of %s/%s#%d: the forge reported no head sha", owner, repo, number) + } + return pr.HeadSHA, 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 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 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)"), + }) + // 422 = already exists; both outcomes mean the label is available. + if err != nil && !strings.Contains(err.Error(), "already_exists") { + c.log.Warn("create label failed", "label", name, "err", 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", 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", 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", 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 fmt.Errorf("get repo %s/%s: %w", owner, repo, err) + } + perms := r.GetPermissions() + if !perms["push"] { + return fmt.Errorf("no push permission on %s/%s", owner, repo) + } + return nil +} diff --git a/forge/github/main.go b/forge/github/main.go new file mode 100644 index 0000000..a682e13 --- /dev/null +++ b/forge/github/main.go @@ -0,0 +1,33 @@ +// Command github is the GitHub forge extension: issues, pull requests and +// reviews over the GitHub API, and webhook decoding. +package main + +import ( + "log/slog" + "strings" + + "github.com/samcharles93/archipelago/sdk/forge" +) + +func main() { + forge.Serve(func(cfg forge.Config) (forge.Forge, error) { + return newGitHub(cfg.Token, cfg.Host, slog.Default()) + }) +} + +// normalizeReviewState maps a GitHub review state onto the neutral states. +// Unknown states pass through lowercased. +func normalizeReviewState(s string) string { + switch s { + case "APPROVED": + return forge.ReviewStateApproved + case "CHANGES_REQUESTED": + return forge.ReviewStateRequestedChanges + case "COMMENTED": + return forge.ReviewStateCommented + case "DISMISSED": + return forge.ReviewStateDismissed + default: + return strings.ToLower(s) + } +} diff --git a/forge/github/package.yaml b/forge/github/package.yaml new file mode 100644 index 0000000..e76d553 --- /dev/null +++ b/forge/github/package.yaml @@ -0,0 +1,15 @@ +apiVersion: dev.archie.package.v1 +displayName: GitHub forge +description: GitHub issues, pull requests, reviews and webhooks for archie-core. +version: 1.0.0 +contributes: + extensions: + - surface: forge + path: bin/github +authority: + egressHosts: + - api.github.com + - github.com +files: + - path: bin/github + mode: 493 diff --git a/forge/github/webhook.go b/forge/github/webhook.go new file mode 100644 index 0000000..1efa419 --- /dev/null +++ b/forge/github/webhook.go @@ -0,0 +1,89 @@ +package main + +import ( + "fmt" + "net/http" + + "github.com/google/go-github/v78/github" + + "github.com/samcharles93/archipelago/sdk/forge" +) + +// ParseWebhook decodes a delivery the host has authenticated. Events the host +// does not act on (ping, push) decode to no event. +func (c *GitHubClient) ParseWebhook(headers map[string]string, body []byte) (forge.WebhookEvent, error) { + event, err := github.ParseWebHook(headers[http.CanonicalHeaderKey("X-GitHub-Event")], body) + if err != nil { + return forge.WebhookEvent{}, fmt.Errorf("%w: %w", forge.ErrBadWebhook, err) + } + switch e := event.(type) { + case *github.IssuesEvent: + return forge.WebhookEvent{Issue: issueEvent(e)}, nil + case *github.PullRequestReviewEvent: + review := e.GetReview() + if review == nil { + return forge.WebhookEvent{}, nil + } + return forge.WebhookEvent{Review: &forge.ReviewEvent{ + Action: e.GetAction(), + Owner: e.GetRepo().GetOwner().GetLogin(), + Repo: e.GetRepo().GetName(), + PRNumber: e.GetPullRequest().GetNumber(), + ReviewID: review.GetID(), + Author: review.GetUser().GetLogin(), + State: review.GetState(), + Body: review.GetBody(), + }}, nil + case *github.PullRequestReviewCommentEvent: + comment := e.GetComment() + if comment == nil { + return forge.WebhookEvent{}, nil + } + return forge.WebhookEvent{ReviewComment: &forge.ReviewCommentEvent{ + Action: e.GetAction(), + Owner: e.GetRepo().GetOwner().GetLogin(), + Repo: e.GetRepo().GetName(), + PRNumber: e.GetPullRequest().GetNumber(), + ReviewID: comment.GetPullRequestReviewID(), + CommentID: comment.GetID(), + Author: comment.GetUser().GetLogin(), + Body: comment.GetBody(), + Path: comment.GetPath(), + Line: comment.GetLine(), + }}, nil + } + return forge.WebhookEvent{}, nil +} + +func issueEvent(e *github.IssuesEvent) *forge.IssueEvent { + issue := e.GetIssue() + if issue == nil { + return &forge.IssueEvent{Action: e.GetAction()} + } + var labels []string + for _, l := range issue.Labels { + if name := l.GetName(); name != "" { + labels = append(labels, name) + } + } + seen := map[string]bool{} + var assignees []string + for _, u := range append(append([]*github.User{}, issue.Assignees...), issue.Assignee, e.GetAssignee()) { + if login := u.GetLogin(); login != "" && !seen[login] { + seen[login] = true + assignees = append(assignees, login) + } + } + return &forge.IssueEvent{ + Action: e.GetAction(), + State: issue.GetState(), + PullRequest: issue.IsPullRequest(), + Owner: e.GetRepo().GetOwner().GetLogin(), + Repo: e.GetRepo().GetName(), + Number: issue.GetNumber(), + Title: issue.GetTitle(), + Body: issue.GetBody(), + Labels: labels, + Assignees: assignees, + } +} diff --git a/go.mod b/go.mod index adb7e64..ba6b31f 100644 --- a/go.mod +++ b/go.mod @@ -3,19 +3,27 @@ module github.com/samcharles93/archipelago go 1.27 require ( + code.gitea.io/sdk/gitea v0.25.1 + github.com/google/go-github/v78 v78.0.0 github.com/hashicorp/go-plugin v1.8.0 google.golang.org/grpc v1.84.0 google.golang.org/protobuf v1.36.12 ) require ( + github.com/42wim/httpsig v1.2.4 // indirect + github.com/davidmz/go-pageant v1.0.2 // indirect github.com/fatih/color v1.13.0 // indirect + github.com/go-fed/httpsig v1.1.0 // indirect github.com/golang/protobuf v1.5.4 // indirect + github.com/google/go-querystring v1.1.0 // indirect github.com/hashicorp/go-hclog v1.6.3 // indirect + github.com/hashicorp/go-version v1.9.0 // indirect github.com/hashicorp/yamux v0.1.2 // indirect github.com/mattn/go-colorable v0.1.12 // indirect github.com/mattn/go-isatty v0.0.17 // indirect github.com/oklog/run v1.1.0 // indirect + golang.org/x/crypto v0.54.0 // indirect golang.org/x/net v0.57.0 // indirect golang.org/x/sys v0.47.0 // indirect golang.org/x/text v0.40.0 // indirect diff --git a/go.sum b/go.sum index e4c8e0e..50e5c3c 100644 --- a/go.sum +++ b/go.sum @@ -1,18 +1,33 @@ +code.gitea.io/sdk/gitea v0.25.1 h1:yywxWwoV+SdjHtbC6unBiXojWdZOtoHuGhEazEXeWuE= +code.gitea.io/sdk/gitea v0.25.1/go.mod h1:uDFWYBU8dgZsgOHwe6C/6olxvf8FHguNB3wW1i83fgg= +github.com/42wim/httpsig v1.2.4 h1:mI5bH0nm4xn7K18fo1K3okNDRq8CCJ0KbBYWyA6r8lU= +github.com/42wim/httpsig v1.2.4/go.mod h1:yKsYfSyTBEohkPik224QPFylmzEBtda/kjyIAJjh3ps= github.com/bufbuild/protocompile v0.14.1 h1:iA73zAf/fyljNjQKwYzUHD6AD4R8KMasmwa/FBatYVw= github.com/bufbuild/protocompile v0.14.1/go.mod h1:ppVdAIhbr2H8asPk6k4pY7t9zB1OU5DoEw9xY/FUi1c= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davidmz/go-pageant v1.0.2 h1:bPblRCh5jGU+Uptpz6LgMZGD5hJoOt7otgT454WvHn0= +github.com/davidmz/go-pageant v1.0.2/go.mod h1:P2EDDnMqIwG5Rrp05dTRITj9z2zpGcD9efWSkTNKLIE= github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w= github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk= +github.com/go-fed/httpsig v1.1.0 h1:9M+hb0jkEICD8/cAiNqEB66R87tTINszBRTjwjQzWcI= +github.com/go-fed/httpsig v1.1.0/go.mod h1:RCMrTZvN1bJYtofsG4rd5NaO5obxQ5xBkdiS7xsT7bM= github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= +github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= +github.com/google/go-github/v78 v78.0.0 h1:b1tytzFE8i//lRVDx5Qh/EdJbtTPtSVD3nF7hraEs9w= +github.com/google/go-github/v78 v78.0.0/go.mod h1:Uxvdzy82AkNlC6JQ57se9TqvmgBT7RF0ouHDNg2jd6g= +github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8= +github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU= github.com/hashicorp/go-hclog v1.6.3 h1:Qr2kF+eVWjTiYmU7Y31tYlP1h0q/X3Nl3tPGdaB11/k= github.com/hashicorp/go-hclog v1.6.3/go.mod h1:W4Qnvbt70Wk/zYJryRzDRU/4r0kIg0PVHBcfoyhpF5M= github.com/hashicorp/go-plugin v1.8.0 h1:ie8S6RRY8RvB2usYZv+AAZ/wBvx2AU5p5QeP5j/FORs= github.com/hashicorp/go-plugin v1.8.0/go.mod h1:BExt6KEaIYx804z8k4gRzRLEvxKVb+kn0NMcihqOqb8= +github.com/hashicorp/go-version v1.9.0 h1:CeOIz6k+LoN3qX9Z0tyQrPtiB1DFYRPfCIBtaXPSCnA= +github.com/hashicorp/go-version v1.9.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= github.com/hashicorp/yamux v0.1.2 h1:XtB8kyFOyHXYVFnwT5C3+Bdo8gArse7j2AQ0DA0Uey8= github.com/hashicorp/yamux v0.1.2/go.mod h1:C+zze2n6e/7wshOZep2A70/aQU6QBRWJO/G6FT1wIns= github.com/jhump/protoreflect v1.17.0 h1:qOEr613fac2lOuTgWN4tPAtLL7fUSbuJL5X5XumQh94= @@ -29,20 +44,38 @@ github.com/oklog/run v1.1.0/go.mod h1:sVPdnTZT1zYwAJeCMu2Th4T21pA3FPOQRfWjQlk7DV github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/testify v1.7.2 h1:4jaiDzPyXQvSd7D0EjG45355tLlV3VOECpq10pLC+8s= github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals= +github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= +github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8= +golang.org/x/crypto v0.54.0 h1:YLIA59K4fiNzHzjnZt2tUJQjQtUWfWbeHBqKtk3eScw= +golang.org/x/crypto v0.54.0/go.mod h1:KWL8ny2AZdGR2cWmzeHrp2azQPGogOv+HeQaVEXC2dk= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0= +golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.40.0 h1:Ub2Z6/xjgF1WrYQz2nuITOEegKFtiIy+rieRJ5lHZKs= golang.org/x/text v0.40.0/go.mod h1:hpnzDAfGV753zIKo+wk3u1bVKCGPbrnF7+7LBF/UHVY= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= google.golang.org/genproto/googleapis/rpc v0.0.0-20260706201446-f0a921348800 h1:qEHAMpSaUhtD0p3NbEEI83HwNGFxEwaSJ1G9PLnCBZE= diff --git a/sdk/forge/forge.go b/sdk/forge/forge.go new file mode 100644 index 0000000..557f7a2 --- /dev/null +++ b/sdk/forge/forge.go @@ -0,0 +1,173 @@ +package forge + +import ( + "context" + "errors" + "fmt" + "io" + "strings" + "time" +) + +// Config is what the host hands a forge extension once, after launch. +type Config struct { + Host string + Token string + Settings map[string]string +} + +// Issue is an issue (never a pull request). +type Issue struct { + Number int + Title string + Body string + Labels []string +} + +// Forge is the capability every forge extension has. +type Forge interface { + AssignedIssues(ctx context.Context, owner, repo, assignee string) ([]Issue, error) + IssuesWithLabel(ctx context.Context, owner, repo, label string) ([]Issue, error) + Comment(ctx context.Context, owner, repo string, number int, body string) (int64, error) + CloseIssue(ctx context.Context, owner, repo string, number int, comment string) error + React(ctx context.Context, owner, repo string, number int, reaction string) error + // SetStateLabel makes label the issue's only state label, removing any + // other label in knownLabels first. An empty label clears them. + SetStateLabel(ctx context.Context, owner, repo string, number int, label string, knownLabels []string) + CreatePR(ctx context.Context, owner, repo, title, head, base, body string) (int, error) + // PRState is "open", "merged" or "closed". + PRState(ctx context.Context, owner, repo string, number int) (string, error) + AcceptInvitations(ctx context.Context) error + VerifyPush(ctx context.Context, owner, repo string) error + LinkBranch(ctx context.Context, owner, repo string, issueNumber int, branch string) error +} + +// PullRequest summarises an existing pull request. +type PullRequest struct { + Number int + Title string + Body string + HeadRef string + BaseRef string + HeadSHA string + BaseSHA string + State string +} + +// PullRequestReader, PullRequestDiffReader, RepoArchiveReader, ReviewReader, +// ReviewCommentWriter and WebhookParser are optional: an extension implements +// the ones its forge supports and the host sees the rest as unsupported. +type PullRequestReader interface { + GetPullRequest(ctx context.Context, owner, repo string, number int) (PullRequest, error) +} + +type PullRequestDiffReader interface { + GetPullRequestDiff(ctx context.Context, owner, repo string, number int) (string, error) +} + +type RepoArchiveReader interface { + GetRepoArchive(ctx context.Context, owner, repo, ref string) (io.ReadCloser, error) +} + +// Review states, normalised across forges. +const ( + ReviewStateApproved = "approved" + ReviewStateRequestedChanges = "requested_changes" + ReviewStateCommented = "commented" + ReviewStateDismissed = "dismissed" +) + +type Review struct { + ID int64 + Author string + State string + Body string + SubmittedAt time.Time +} + +type ReviewComment struct { + ID int64 + ReviewID int64 + Author string + Body string + Path string + Line int + InReplyTo int64 + CreatedAt time.Time +} + +type ReviewReader interface { + ListReviews(ctx context.Context, owner, repo string, number int, sinceID int64) ([]Review, error) + ListReviewComments(ctx context.Context, owner, repo string, number int, sinceID int64) ([]ReviewComment, error) + ReplyToReview(ctx context.Context, owner, repo string, number int, commentID int64, body string) error +} + +type InlineReviewComment struct { + Path string + Line int + Body string +} + +type ReviewCommentWriter interface { + CreateReviewComments(ctx context.Context, owner, repo string, number int, reviewedHeadSHA string, comments []InlineReviewComment) error +} + +// WebhookEvent is a decoded delivery; at most one field is set. +type WebhookEvent struct { + Issue *IssueEvent + Review *ReviewEvent + ReviewComment *ReviewCommentEvent +} + +type IssueEvent struct { + Action string + State string + PullRequest bool + Owner, Repo string + Number int + Title, Body string + Labels []string + Assignees []string +} + +type ReviewEvent struct { + Action string + Owner, Repo string + PRNumber int + ReviewID int64 + Author string + State string + Body string +} + +type ReviewCommentEvent struct { + Action string + Owner, Repo string + PRNumber int + ReviewID int64 + CommentID int64 + Author string + Body string + Path string + Line int +} + +// ErrBadWebhook marks a body the forge could not decode. +var ErrBadWebhook = errors.New("undecodable webhook payload") + +// WebhookParser decodes a delivery the host has already authenticated. +type WebhookParser interface { + ParseWebhook(headers map[string]string, body []byte) (WebhookEvent, error) +} + +// ReviewHeadDrift is an error when head is no longer reviewedHeadSHA; an empty +// reviewedHeadSHA skips the check. +func ReviewHeadDrift(owner, repo string, number int, head, reviewedHeadSHA string) error { + if reviewedHeadSHA == "" || strings.EqualFold(head, reviewedHeadSHA) { + return nil + } + return fmt.Errorf( + "pull request %s/%s#%d has moved off the reviewed revision (%s): head is now %s, so the line-anchored comments would land on lines they were not measured against", + owner, repo, number, reviewedHeadSHA, head, + ) +} diff --git a/sdk/forge/serve.go b/sdk/forge/serve.go index a71ddeb..141bf98 100644 --- a/sdk/forge/serve.go +++ b/sdk/forge/serve.go @@ -30,7 +30,8 @@ func (*plugin) GRPCClient(context.Context, *goplugin.GRPCBroker, *grpc.ClientCon // Serve runs impl as the extension process. It returns when archie-core stops // the extension. -func Serve(impl forgev1.ForgeServiceServer) { +func Serve(build func(Config) (Forge, error)) { + impl := &server{build: build} goplugin.Serve(&goplugin.ServeConfig{ HandshakeConfig: goplugin.HandshakeConfig{ ProtocolVersion: 1, diff --git a/sdk/forge/server.go b/sdk/forge/server.go new file mode 100644 index 0000000..ac277ff --- /dev/null +++ b/sdk/forge/server.go @@ -0,0 +1,318 @@ +package forge + +import ( + "context" + "errors" + "io" + "sync" + "sync/atomic" + + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + "google.golang.org/protobuf/types/known/timestamppb" + + forgev1 "github.com/samcharles93/archipelago/sdk/forge/v1" +) + +// archiveChunk bounds one message of a streamed archive. +const archiveChunk = 256 << 10 + +// server adapts a Forge to the gRPC surface. Optional capabilities the Forge +// lacks answer UNIMPLEMENTED. +type server struct { + forgev1.UnimplementedForgeServiceServer + build func(Config) (Forge, error) + + mu sync.Mutex + f atomic.Pointer[Forge] +} + +func (s *server) forge() (Forge, error) { + f := s.f.Load() + if f == nil { + return nil, status.Error(codes.FailedPrecondition, "forge is not configured") + } + return *f, nil +} + +func (s *server) Configure(_ context.Context, r *forgev1.ConfigureRequest) (*forgev1.ConfigureResponse, error) { + s.mu.Lock() + defer s.mu.Unlock() + f, err := s.build(Config{Host: r.GetHost(), Token: r.GetToken(), Settings: r.GetSettings()}) + if err != nil { + return nil, status.Error(codes.InvalidArgument, err.Error()) + } + s.f.Store(&f) + return &forgev1.ConfigureResponse{}, nil +} + +func capability[T any](s *server) (T, error) { + var zero T + f, err := s.forge() + if err != nil { + return zero, err + } + c, ok := f.(T) + if !ok { + return zero, status.Error(codes.Unimplemented, "not supported by this forge") + } + return c, nil +} + +func fail(err error) error { + if err == nil { + return nil + } + if _, ok := status.FromError(err); ok { + return err + } + return status.Error(codes.Unknown, err.Error()) +} + +func issues(in []Issue) []*forgev1.Issue { + out := make([]*forgev1.Issue, 0, len(in)) + for _, i := range in { + out = append(out, &forgev1.Issue{Number: int32(i.Number), Title: i.Title, Body: i.Body, Labels: i.Labels}) //nolint:gosec // issue numbers fit int32 + } + return out +} + +func (s *server) AssignedIssues(ctx context.Context, r *forgev1.AssignedIssuesRequest) (*forgev1.AssignedIssuesResponse, error) { + f, err := s.forge() + if err != nil { + return nil, err + } + out, err := f.AssignedIssues(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), r.GetAssignee()) + return &forgev1.AssignedIssuesResponse{Issues: issues(out)}, fail(err) +} + +func (s *server) IssuesWithLabel(ctx context.Context, r *forgev1.IssuesWithLabelRequest) (*forgev1.IssuesWithLabelResponse, error) { + f, err := s.forge() + if err != nil { + return nil, err + } + out, err := f.IssuesWithLabel(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), r.GetLabel()) + return &forgev1.IssuesWithLabelResponse{Issues: issues(out)}, fail(err) +} + +func (s *server) Comment(ctx context.Context, r *forgev1.CommentRequest) (*forgev1.CommentResponse, error) { + f, err := s.forge() + if err != nil { + return nil, err + } + id, err := f.Comment(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), int(r.GetNumber()), r.GetBody()) + return &forgev1.CommentResponse{Id: id}, fail(err) +} + +func (s *server) CloseIssue(ctx context.Context, r *forgev1.CloseIssueRequest) (*forgev1.CloseIssueResponse, error) { + f, err := s.forge() + if err != nil { + return nil, err + } + return &forgev1.CloseIssueResponse{}, fail(f.CloseIssue(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), int(r.GetNumber()), r.GetComment())) +} + +func (s *server) React(ctx context.Context, r *forgev1.ReactRequest) (*forgev1.ReactResponse, error) { + f, err := s.forge() + if err != nil { + return nil, err + } + return &forgev1.ReactResponse{}, fail(f.React(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), int(r.GetNumber()), r.GetReaction())) +} + +func (s *server) SetStateLabel(ctx context.Context, r *forgev1.SetStateLabelRequest) (*forgev1.SetStateLabelResponse, error) { + f, err := s.forge() + if err != nil { + return nil, err + } + f.SetStateLabel(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), int(r.GetNumber()), r.GetLabel(), r.GetKnownLabels()) + return &forgev1.SetStateLabelResponse{}, nil +} + +func (s *server) CreatePR(ctx context.Context, r *forgev1.CreatePRRequest) (*forgev1.CreatePRResponse, error) { + f, err := s.forge() + if err != nil { + return nil, err + } + n, err := f.CreatePR(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), r.GetTitle(), r.GetHead(), r.GetBase(), r.GetBody()) + return &forgev1.CreatePRResponse{Number: int32(n)}, fail(err) //nolint:gosec // issue numbers fit int32 +} + +func (s *server) PRState(ctx context.Context, r *forgev1.PRStateRequest) (*forgev1.PRStateResponse, error) { + f, err := s.forge() + if err != nil { + return nil, err + } + state, err := f.PRState(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), int(r.GetNumber())) + return &forgev1.PRStateResponse{State: state}, fail(err) +} + +func (s *server) GetPullRequest(ctx context.Context, r *forgev1.GetPullRequestRequest) (*forgev1.GetPullRequestResponse, error) { + c, err := capability[PullRequestReader](s) + if err != nil { + return nil, err + } + pr, err := c.GetPullRequest(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), int(r.GetNumber())) + if err != nil { + return nil, fail(err) + } + return &forgev1.GetPullRequestResponse{PullRequest: &forgev1.PullRequest{ + Number: int32(pr.Number), Title: pr.Title, Body: pr.Body, HeadRef: pr.HeadRef, BaseRef: pr.BaseRef, //nolint:gosec // issue numbers fit int32 + HeadSha: pr.HeadSHA, BaseSha: pr.BaseSHA, State: pr.State, + }}, nil +} + +func (s *server) GetPullRequestDiff(ctx context.Context, r *forgev1.GetPullRequestDiffRequest) (*forgev1.GetPullRequestDiffResponse, error) { + c, err := capability[PullRequestDiffReader](s) + if err != nil { + return nil, err + } + diff, err := c.GetPullRequestDiff(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), int(r.GetNumber())) + return &forgev1.GetPullRequestDiffResponse{Diff: diff}, fail(err) +} + +func (s *server) ListReviews(ctx context.Context, r *forgev1.ListReviewsRequest) (*forgev1.ListReviewsResponse, error) { + c, err := capability[ReviewReader](s) + if err != nil { + return nil, err + } + pr := r.GetPullRequest() + reviews, err := c.ListReviews(ctx, pr.GetRepo().GetOwner(), pr.GetRepo().GetRepo(), int(pr.GetNumber()), r.GetSinceId()) + if err != nil { + return nil, fail(err) + } + out := make([]*forgev1.Review, 0, len(reviews)) + for _, rv := range reviews { + out = append(out, &forgev1.Review{Id: rv.ID, Author: rv.Author, State: rv.State, Body: rv.Body, SubmittedAt: timestamppb.New(rv.SubmittedAt)}) + } + return &forgev1.ListReviewsResponse{Reviews: out}, nil +} + +func (s *server) ListReviewComments(ctx context.Context, r *forgev1.ListReviewCommentsRequest) (*forgev1.ListReviewCommentsResponse, error) { + c, err := capability[ReviewReader](s) + if err != nil { + return nil, err + } + pr := r.GetPullRequest() + comments, err := c.ListReviewComments(ctx, pr.GetRepo().GetOwner(), pr.GetRepo().GetRepo(), int(pr.GetNumber()), r.GetSinceId()) + if err != nil { + return nil, fail(err) + } + out := make([]*forgev1.ReviewComment, 0, len(comments)) + for _, cm := range comments { + out = append(out, &forgev1.ReviewComment{ + Id: cm.ID, ReviewId: cm.ReviewID, Author: cm.Author, Body: cm.Body, Path: cm.Path, + Line: int32(cm.Line), InReplyTo: cm.InReplyTo, CreatedAt: timestamppb.New(cm.CreatedAt), //nolint:gosec // line numbers fit int32 + }) + } + return &forgev1.ListReviewCommentsResponse{Comments: out}, nil +} + +func (s *server) ReplyToReview(ctx context.Context, r *forgev1.ReplyToReviewRequest) (*forgev1.ReplyToReviewResponse, error) { + c, err := capability[ReviewReader](s) + if err != nil { + return nil, err + } + pr := r.GetPullRequest() + return &forgev1.ReplyToReviewResponse{}, fail(c.ReplyToReview(ctx, pr.GetRepo().GetOwner(), pr.GetRepo().GetRepo(), int(pr.GetNumber()), r.GetCommentId(), r.GetBody())) +} + +func (s *server) CreateReviewComments(ctx context.Context, r *forgev1.CreateReviewCommentsRequest) (*forgev1.CreateReviewCommentsResponse, error) { + c, err := capability[ReviewCommentWriter](s) + if err != nil { + return nil, err + } + pr := r.GetPullRequest() + comments := make([]InlineReviewComment, 0, len(r.GetComments())) + for _, cm := range r.GetComments() { + comments = append(comments, InlineReviewComment{Path: cm.GetPath(), Line: int(cm.GetLine()), Body: cm.GetBody()}) + } + return &forgev1.CreateReviewCommentsResponse{}, fail(c.CreateReviewComments(ctx, pr.GetRepo().GetOwner(), pr.GetRepo().GetRepo(), int(pr.GetNumber()), r.GetReviewedHeadSha(), comments)) +} + +func (s *server) AcceptInvitations(ctx context.Context, _ *forgev1.AcceptInvitationsRequest) (*forgev1.AcceptInvitationsResponse, error) { + f, err := s.forge() + if err != nil { + return nil, err + } + return &forgev1.AcceptInvitationsResponse{}, fail(f.AcceptInvitations(ctx)) +} + +func (s *server) VerifyPush(ctx context.Context, r *forgev1.VerifyPushRequest) (*forgev1.VerifyPushResponse, error) { + f, err := s.forge() + if err != nil { + return nil, err + } + return &forgev1.VerifyPushResponse{}, fail(f.VerifyPush(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo())) +} + +func (s *server) LinkBranch(ctx context.Context, r *forgev1.LinkBranchRequest) (*forgev1.LinkBranchResponse, error) { + f, err := s.forge() + if err != nil { + return nil, err + } + return &forgev1.LinkBranchResponse{}, fail(f.LinkBranch(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), int(r.GetIssueNumber()), r.GetBranch())) +} + +func (s *server) GetRepoArchive(r *forgev1.GetRepoArchiveRequest, stream forgev1.ForgeService_GetRepoArchiveServer) error { + c, err := capability[RepoArchiveReader](s) + if err != nil { + return err + } + body, err := c.GetRepoArchive(stream.Context(), r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), r.GetRef()) + if err != nil { + return fail(err) + } + defer func() { _ = body.Close() }() + buf := make([]byte, archiveChunk) + for { + n, rerr := body.Read(buf) + if n > 0 { + if serr := stream.Send(&forgev1.GetRepoArchiveResponse{Data: buf[:n]}); serr != nil { + return serr + } + } + if errors.Is(rerr, io.EOF) { + return nil + } + if rerr != nil { + return fail(rerr) + } + } +} + +func (s *server) ParseWebhook(_ context.Context, r *forgev1.ParseWebhookRequest) (*forgev1.ParseWebhookResponse, error) { + c, err := capability[WebhookParser](s) + if err != nil { + return nil, err + } + event, err := c.ParseWebhook(r.GetHeaders(), r.GetBody()) + if errors.Is(err, ErrBadWebhook) { + return nil, status.Error(codes.InvalidArgument, err.Error()) + } + if err != nil { + return nil, fail(err) + } + repo := func(owner, name string) *forgev1.RepoRef { return &forgev1.RepoRef{Owner: owner, Repo: name} } + switch { + case event.Issue != nil: + i := event.Issue + return &forgev1.ParseWebhookResponse{Event: &forgev1.ParseWebhookResponse_Issue{Issue: &forgev1.IssueEvent{ + Action: i.Action, State: i.State, IsPullRequest: i.PullRequest, Repo: repo(i.Owner, i.Repo), Number: int32(i.Number), //nolint:gosec // issue numbers fit int32 + Title: i.Title, Body: i.Body, Labels: i.Labels, Assignees: i.Assignees, + }}}, nil + case event.Review != nil: + v := event.Review + return &forgev1.ParseWebhookResponse{Event: &forgev1.ParseWebhookResponse_Review{Review: &forgev1.ReviewEvent{ + Action: v.Action, Repo: repo(v.Owner, v.Repo), PrNumber: int32(v.PRNumber), ReviewId: v.ReviewID, //nolint:gosec // issue numbers fit int32 + Author: v.Author, State: v.State, Body: v.Body, + }}}, nil + case event.ReviewComment != nil: + c := event.ReviewComment + return &forgev1.ParseWebhookResponse{Event: &forgev1.ParseWebhookResponse_ReviewComment{ReviewComment: &forgev1.ReviewCommentEvent{ + Action: c.Action, Repo: repo(c.Owner, c.Repo), PrNumber: int32(c.PRNumber), ReviewId: c.ReviewID, CommentId: c.CommentID, //nolint:gosec // issue numbers fit int32 + Author: c.Author, Body: c.Body, Path: c.Path, Line: int32(c.Line), //nolint:gosec // line numbers fit int32 + }}}, nil + } + return &forgev1.ParseWebhookResponse{}, nil +} diff --git a/sdk/forge/v1/forge.pb.go b/sdk/forge/v1/forge.pb.go index b96e518..f79387d 100644 --- a/sdk/forge/v1/forge.pb.go +++ b/sdk/forge/v1/forge.pb.go @@ -2354,6 +2354,464 @@ func (x *GetRepoArchiveResponse) GetData() []byte { return nil } +type ParseWebhookRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Headers map[string]string `protobuf:"bytes,1,rep,name=headers,proto3" json:"headers,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + Body []byte `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ParseWebhookRequest) Reset() { + *x = ParseWebhookRequest{} + mi := &file_forge_v1_forge_proto_msgTypes[45] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ParseWebhookRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ParseWebhookRequest) ProtoMessage() {} + +func (x *ParseWebhookRequest) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[45] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ParseWebhookRequest.ProtoReflect.Descriptor instead. +func (*ParseWebhookRequest) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{45} +} + +func (x *ParseWebhookRequest) GetHeaders() map[string]string { + if x != nil { + return x.Headers + } + return nil +} + +func (x *ParseWebhookRequest) GetBody() []byte { + if x != nil { + return x.Body + } + return nil +} + +type ParseWebhookResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Event: + // + // *ParseWebhookResponse_Issue + // *ParseWebhookResponse_Review + // *ParseWebhookResponse_ReviewComment + Event isParseWebhookResponse_Event `protobuf_oneof:"event"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ParseWebhookResponse) Reset() { + *x = ParseWebhookResponse{} + mi := &file_forge_v1_forge_proto_msgTypes[46] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ParseWebhookResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ParseWebhookResponse) ProtoMessage() {} + +func (x *ParseWebhookResponse) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[46] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ParseWebhookResponse.ProtoReflect.Descriptor instead. +func (*ParseWebhookResponse) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{46} +} + +func (x *ParseWebhookResponse) GetEvent() isParseWebhookResponse_Event { + if x != nil { + return x.Event + } + return nil +} + +func (x *ParseWebhookResponse) GetIssue() *IssueEvent { + if x != nil { + if x, ok := x.Event.(*ParseWebhookResponse_Issue); ok { + return x.Issue + } + } + return nil +} + +func (x *ParseWebhookResponse) GetReview() *ReviewEvent { + if x != nil { + if x, ok := x.Event.(*ParseWebhookResponse_Review); ok { + return x.Review + } + } + return nil +} + +func (x *ParseWebhookResponse) GetReviewComment() *ReviewCommentEvent { + if x != nil { + if x, ok := x.Event.(*ParseWebhookResponse_ReviewComment); ok { + return x.ReviewComment + } + } + return nil +} + +type isParseWebhookResponse_Event interface { + isParseWebhookResponse_Event() +} + +type ParseWebhookResponse_Issue struct { + Issue *IssueEvent `protobuf:"bytes,1,opt,name=issue,proto3,oneof"` +} + +type ParseWebhookResponse_Review struct { + Review *ReviewEvent `protobuf:"bytes,2,opt,name=review,proto3,oneof"` +} + +type ParseWebhookResponse_ReviewComment struct { + ReviewComment *ReviewCommentEvent `protobuf:"bytes,3,opt,name=review_comment,json=reviewComment,proto3,oneof"` +} + +func (*ParseWebhookResponse_Issue) isParseWebhookResponse_Event() {} + +func (*ParseWebhookResponse_Review) isParseWebhookResponse_Event() {} + +func (*ParseWebhookResponse_ReviewComment) isParseWebhookResponse_Event() {} + +type IssueEvent struct { + state protoimpl.MessageState `protogen:"open.v1"` + Action string `protobuf:"bytes,1,opt,name=action,proto3" json:"action,omitempty"` + State string `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty"` + IsPullRequest bool `protobuf:"varint,3,opt,name=is_pull_request,json=isPullRequest,proto3" json:"is_pull_request,omitempty"` + Repo *RepoRef `protobuf:"bytes,4,opt,name=repo,proto3" json:"repo,omitempty"` + Number int32 `protobuf:"varint,5,opt,name=number,proto3" json:"number,omitempty"` + Title string `protobuf:"bytes,6,opt,name=title,proto3" json:"title,omitempty"` + Body string `protobuf:"bytes,7,opt,name=body,proto3" json:"body,omitempty"` + Labels []string `protobuf:"bytes,8,rep,name=labels,proto3" json:"labels,omitempty"` + Assignees []string `protobuf:"bytes,9,rep,name=assignees,proto3" json:"assignees,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *IssueEvent) Reset() { + *x = IssueEvent{} + mi := &file_forge_v1_forge_proto_msgTypes[47] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *IssueEvent) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*IssueEvent) ProtoMessage() {} + +func (x *IssueEvent) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[47] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use IssueEvent.ProtoReflect.Descriptor instead. +func (*IssueEvent) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{47} +} + +func (x *IssueEvent) GetAction() string { + if x != nil { + return x.Action + } + return "" +} + +func (x *IssueEvent) GetState() string { + if x != nil { + return x.State + } + return "" +} + +func (x *IssueEvent) GetIsPullRequest() bool { + if x != nil { + return x.IsPullRequest + } + return false +} + +func (x *IssueEvent) GetRepo() *RepoRef { + if x != nil { + return x.Repo + } + return nil +} + +func (x *IssueEvent) GetNumber() int32 { + if x != nil { + return x.Number + } + return 0 +} + +func (x *IssueEvent) GetTitle() string { + if x != nil { + return x.Title + } + return "" +} + +func (x *IssueEvent) GetBody() string { + if x != nil { + return x.Body + } + return "" +} + +func (x *IssueEvent) GetLabels() []string { + if x != nil { + return x.Labels + } + return nil +} + +func (x *IssueEvent) GetAssignees() []string { + if x != nil { + return x.Assignees + } + return nil +} + +type ReviewEvent struct { + state protoimpl.MessageState `protogen:"open.v1"` + Action string `protobuf:"bytes,1,opt,name=action,proto3" json:"action,omitempty"` + Repo *RepoRef `protobuf:"bytes,2,opt,name=repo,proto3" json:"repo,omitempty"` + PrNumber int32 `protobuf:"varint,3,opt,name=pr_number,json=prNumber,proto3" json:"pr_number,omitempty"` + ReviewId int64 `protobuf:"varint,4,opt,name=review_id,json=reviewId,proto3" json:"review_id,omitempty"` + Author string `protobuf:"bytes,5,opt,name=author,proto3" json:"author,omitempty"` + State string `protobuf:"bytes,6,opt,name=state,proto3" json:"state,omitempty"` + Body string `protobuf:"bytes,7,opt,name=body,proto3" json:"body,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ReviewEvent) Reset() { + *x = ReviewEvent{} + mi := &file_forge_v1_forge_proto_msgTypes[48] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ReviewEvent) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReviewEvent) ProtoMessage() {} + +func (x *ReviewEvent) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[48] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReviewEvent.ProtoReflect.Descriptor instead. +func (*ReviewEvent) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{48} +} + +func (x *ReviewEvent) GetAction() string { + if x != nil { + return x.Action + } + return "" +} + +func (x *ReviewEvent) GetRepo() *RepoRef { + if x != nil { + return x.Repo + } + return nil +} + +func (x *ReviewEvent) GetPrNumber() int32 { + if x != nil { + return x.PrNumber + } + return 0 +} + +func (x *ReviewEvent) GetReviewId() int64 { + if x != nil { + return x.ReviewId + } + return 0 +} + +func (x *ReviewEvent) GetAuthor() string { + if x != nil { + return x.Author + } + return "" +} + +func (x *ReviewEvent) GetState() string { + if x != nil { + return x.State + } + return "" +} + +func (x *ReviewEvent) GetBody() string { + if x != nil { + return x.Body + } + return "" +} + +type ReviewCommentEvent struct { + state protoimpl.MessageState `protogen:"open.v1"` + Action string `protobuf:"bytes,1,opt,name=action,proto3" json:"action,omitempty"` + Repo *RepoRef `protobuf:"bytes,2,opt,name=repo,proto3" json:"repo,omitempty"` + PrNumber int32 `protobuf:"varint,3,opt,name=pr_number,json=prNumber,proto3" json:"pr_number,omitempty"` + ReviewId int64 `protobuf:"varint,4,opt,name=review_id,json=reviewId,proto3" json:"review_id,omitempty"` + CommentId int64 `protobuf:"varint,5,opt,name=comment_id,json=commentId,proto3" json:"comment_id,omitempty"` + Author string `protobuf:"bytes,6,opt,name=author,proto3" json:"author,omitempty"` + Body string `protobuf:"bytes,7,opt,name=body,proto3" json:"body,omitempty"` + Path string `protobuf:"bytes,8,opt,name=path,proto3" json:"path,omitempty"` + Line int32 `protobuf:"varint,9,opt,name=line,proto3" json:"line,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ReviewCommentEvent) Reset() { + *x = ReviewCommentEvent{} + mi := &file_forge_v1_forge_proto_msgTypes[49] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ReviewCommentEvent) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReviewCommentEvent) ProtoMessage() {} + +func (x *ReviewCommentEvent) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[49] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReviewCommentEvent.ProtoReflect.Descriptor instead. +func (*ReviewCommentEvent) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{49} +} + +func (x *ReviewCommentEvent) GetAction() string { + if x != nil { + return x.Action + } + return "" +} + +func (x *ReviewCommentEvent) GetRepo() *RepoRef { + if x != nil { + return x.Repo + } + return nil +} + +func (x *ReviewCommentEvent) GetPrNumber() int32 { + if x != nil { + return x.PrNumber + } + return 0 +} + +func (x *ReviewCommentEvent) GetReviewId() int64 { + if x != nil { + return x.ReviewId + } + return 0 +} + +func (x *ReviewCommentEvent) GetCommentId() int64 { + if x != nil { + return x.CommentId + } + return 0 +} + +func (x *ReviewCommentEvent) GetAuthor() string { + if x != nil { + return x.Author + } + return "" +} + +func (x *ReviewCommentEvent) GetBody() string { + if x != nil { + return x.Body + } + return "" +} + +func (x *ReviewCommentEvent) GetPath() string { + if x != nil { + return x.Path + } + return "" +} + +func (x *ReviewCommentEvent) GetLine() int32 { + if x != nil { + return x.Line + } + return 0 +} + var File_forge_v1_forge_proto protoreflect.FileDescriptor const file_forge_v1_forge_proto_rawDesc = "" + @@ -2497,7 +2955,48 @@ const file_forge_v1_forge_proto_rawDesc = "" + "\x04repo\x18\x01 \x01(\v2\x11.forge.v1.RepoRefR\x04repo\x12\x10\n" + "\x03ref\x18\x02 \x01(\tR\x03ref\",\n" + "\x16GetRepoArchiveResponse\x12\x12\n" + - "\x04data\x18\x01 \x01(\fR\x04data2\xfc\v\n" + + "\x04data\x18\x01 \x01(\fR\x04data\"\xab\x01\n" + + "\x13ParseWebhookRequest\x12D\n" + + "\aheaders\x18\x01 \x03(\v2*.forge.v1.ParseWebhookRequest.HeadersEntryR\aheaders\x12\x12\n" + + "\x04body\x18\x02 \x01(\fR\x04body\x1a:\n" + + "\fHeadersEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xc5\x01\n" + + "\x14ParseWebhookResponse\x12,\n" + + "\x05issue\x18\x01 \x01(\v2\x14.forge.v1.IssueEventH\x00R\x05issue\x12/\n" + + "\x06review\x18\x02 \x01(\v2\x15.forge.v1.ReviewEventH\x00R\x06review\x12E\n" + + "\x0ereview_comment\x18\x03 \x01(\v2\x1c.forge.v1.ReviewCommentEventH\x00R\rreviewCommentB\a\n" + + "\x05event\"\x81\x02\n" + + "\n" + + "IssueEvent\x12\x16\n" + + "\x06action\x18\x01 \x01(\tR\x06action\x12\x14\n" + + "\x05state\x18\x02 \x01(\tR\x05state\x12&\n" + + "\x0fis_pull_request\x18\x03 \x01(\bR\risPullRequest\x12%\n" + + "\x04repo\x18\x04 \x01(\v2\x11.forge.v1.RepoRefR\x04repo\x12\x16\n" + + "\x06number\x18\x05 \x01(\x05R\x06number\x12\x14\n" + + "\x05title\x18\x06 \x01(\tR\x05title\x12\x12\n" + + "\x04body\x18\a \x01(\tR\x04body\x12\x16\n" + + "\x06labels\x18\b \x03(\tR\x06labels\x12\x1c\n" + + "\tassignees\x18\t \x03(\tR\tassignees\"\xc8\x01\n" + + "\vReviewEvent\x12\x16\n" + + "\x06action\x18\x01 \x01(\tR\x06action\x12%\n" + + "\x04repo\x18\x02 \x01(\v2\x11.forge.v1.RepoRefR\x04repo\x12\x1b\n" + + "\tpr_number\x18\x03 \x01(\x05R\bprNumber\x12\x1b\n" + + "\treview_id\x18\x04 \x01(\x03R\breviewId\x12\x16\n" + + "\x06author\x18\x05 \x01(\tR\x06author\x12\x14\n" + + "\x05state\x18\x06 \x01(\tR\x05state\x12\x12\n" + + "\x04body\x18\a \x01(\tR\x04body\"\x80\x02\n" + + "\x12ReviewCommentEvent\x12\x16\n" + + "\x06action\x18\x01 \x01(\tR\x06action\x12%\n" + + "\x04repo\x18\x02 \x01(\v2\x11.forge.v1.RepoRefR\x04repo\x12\x1b\n" + + "\tpr_number\x18\x03 \x01(\x05R\bprNumber\x12\x1b\n" + + "\treview_id\x18\x04 \x01(\x03R\breviewId\x12\x1d\n" + + "\n" + + "comment_id\x18\x05 \x01(\x03R\tcommentId\x12\x16\n" + + "\x06author\x18\x06 \x01(\tR\x06author\x12\x12\n" + + "\x04body\x18\a \x01(\tR\x04body\x12\x12\n" + + "\x04path\x18\b \x01(\tR\x04path\x12\x12\n" + + "\x04line\x18\t \x01(\x05R\x04line2\xcb\f\n" + "\fForgeService\x12D\n" + "\tConfigure\x12\x1a.forge.v1.ConfigureRequest\x1a\x1b.forge.v1.ConfigureResponse\x12S\n" + "\x0eAssignedIssues\x12\x1f.forge.v1.AssignedIssuesRequest\x1a .forge.v1.AssignedIssuesResponse\x12V\n" + @@ -2519,7 +3018,8 @@ const file_forge_v1_forge_proto_rawDesc = "" + "\n" + "VerifyPush\x12\x1b.forge.v1.VerifyPushRequest\x1a\x1c.forge.v1.VerifyPushResponse\x12G\n" + "\n" + - "LinkBranch\x12\x1b.forge.v1.LinkBranchRequest\x1a\x1c.forge.v1.LinkBranchResponse\x12U\n" + + "LinkBranch\x12\x1b.forge.v1.LinkBranchRequest\x1a\x1c.forge.v1.LinkBranchResponse\x12M\n" + + "\fParseWebhook\x12\x1d.forge.v1.ParseWebhookRequest\x1a\x1e.forge.v1.ParseWebhookResponse\x12U\n" + "\x0eGetRepoArchive\x12\x1f.forge.v1.GetRepoArchiveRequest\x1a .forge.v1.GetRepoArchiveResponse0\x01B\x95\x01\n" + "\fcom.forge.v1B\n" + "ForgeProtoP\x01Z8github.com/samcharles93/archipelago/sdk/forge/v1;forgev1\xa2\x02\x03FXX\xaa\x02\bForge.V1\xca\x02\bForge\\V1\xe2\x02\x14Forge\\V1\\GPBMetadata\xea\x02\tForge::V1b\x06proto3" @@ -2536,7 +3036,7 @@ func file_forge_v1_forge_proto_rawDescGZIP() []byte { return file_forge_v1_forge_proto_rawDescData } -var file_forge_v1_forge_proto_msgTypes = make([]protoimpl.MessageInfo, 46) +var file_forge_v1_forge_proto_msgTypes = make([]protoimpl.MessageInfo, 52) var file_forge_v1_forge_proto_goTypes = []any{ (*ConfigureRequest)(nil), // 0: forge.v1.ConfigureRequest (*ConfigureResponse)(nil), // 1: forge.v1.ConfigureResponse @@ -2583,11 +3083,17 @@ var file_forge_v1_forge_proto_goTypes = []any{ (*VerifyPushResponse)(nil), // 42: forge.v1.VerifyPushResponse (*GetRepoArchiveRequest)(nil), // 43: forge.v1.GetRepoArchiveRequest (*GetRepoArchiveResponse)(nil), // 44: forge.v1.GetRepoArchiveResponse - nil, // 45: forge.v1.ConfigureRequest.SettingsEntry - (*timestamppb.Timestamp)(nil), // 46: google.protobuf.Timestamp + (*ParseWebhookRequest)(nil), // 45: forge.v1.ParseWebhookRequest + (*ParseWebhookResponse)(nil), // 46: forge.v1.ParseWebhookResponse + (*IssueEvent)(nil), // 47: forge.v1.IssueEvent + (*ReviewEvent)(nil), // 48: forge.v1.ReviewEvent + (*ReviewCommentEvent)(nil), // 49: forge.v1.ReviewCommentEvent + nil, // 50: forge.v1.ConfigureRequest.SettingsEntry + nil, // 51: forge.v1.ParseWebhookRequest.HeadersEntry + (*timestamppb.Timestamp)(nil), // 52: google.protobuf.Timestamp } var file_forge_v1_forge_proto_depIdxs = []int32{ - 45, // 0: forge.v1.ConfigureRequest.settings:type_name -> forge.v1.ConfigureRequest.SettingsEntry + 50, // 0: forge.v1.ConfigureRequest.settings:type_name -> forge.v1.ConfigureRequest.SettingsEntry 2, // 1: forge.v1.PullRequestRef.repo:type_name -> forge.v1.RepoRef 4, // 2: forge.v1.AssignedIssuesResponse.issues:type_name -> forge.v1.Issue 4, // 3: forge.v1.IssuesWithLabelResponse.issues:type_name -> forge.v1.Issue @@ -2603,9 +3109,9 @@ var file_forge_v1_forge_proto_depIdxs = []int32{ 21, // 13: forge.v1.GetPullRequestResponse.pull_request:type_name -> forge.v1.PullRequest 2, // 14: forge.v1.GetPullRequestDiffRequest.repo:type_name -> forge.v1.RepoRef 3, // 15: forge.v1.ListReviewsRequest.pull_request:type_name -> forge.v1.PullRequestRef - 46, // 16: forge.v1.Review.submitted_at:type_name -> google.protobuf.Timestamp + 52, // 16: forge.v1.Review.submitted_at:type_name -> google.protobuf.Timestamp 27, // 17: forge.v1.ListReviewsResponse.reviews:type_name -> forge.v1.Review - 46, // 18: forge.v1.ReviewComment.created_at:type_name -> google.protobuf.Timestamp + 52, // 18: forge.v1.ReviewComment.created_at:type_name -> google.protobuf.Timestamp 3, // 19: forge.v1.ListReviewCommentsRequest.pull_request:type_name -> forge.v1.PullRequestRef 29, // 20: forge.v1.ListReviewCommentsResponse.comments:type_name -> forge.v1.ReviewComment 3, // 21: forge.v1.ReplyToReviewRequest.pull_request:type_name -> forge.v1.PullRequestRef @@ -2614,49 +3120,58 @@ var file_forge_v1_forge_proto_depIdxs = []int32{ 2, // 24: forge.v1.LinkBranchRequest.repo:type_name -> forge.v1.RepoRef 2, // 25: forge.v1.VerifyPushRequest.repo:type_name -> forge.v1.RepoRef 2, // 26: forge.v1.GetRepoArchiveRequest.repo:type_name -> forge.v1.RepoRef - 0, // 27: forge.v1.ForgeService.Configure:input_type -> forge.v1.ConfigureRequest - 7, // 28: forge.v1.ForgeService.AssignedIssues:input_type -> forge.v1.AssignedIssuesRequest - 8, // 29: forge.v1.ForgeService.IssuesWithLabel:input_type -> forge.v1.IssuesWithLabelRequest - 9, // 30: forge.v1.ForgeService.Comment:input_type -> forge.v1.CommentRequest - 11, // 31: forge.v1.ForgeService.CloseIssue:input_type -> forge.v1.CloseIssueRequest - 13, // 32: forge.v1.ForgeService.React:input_type -> forge.v1.ReactRequest - 15, // 33: forge.v1.ForgeService.SetStateLabel:input_type -> forge.v1.SetStateLabelRequest - 17, // 34: forge.v1.ForgeService.CreatePR:input_type -> forge.v1.CreatePRRequest - 19, // 35: forge.v1.ForgeService.PRState:input_type -> forge.v1.PRStateRequest - 22, // 36: forge.v1.ForgeService.GetPullRequest:input_type -> forge.v1.GetPullRequestRequest - 24, // 37: forge.v1.ForgeService.GetPullRequestDiff:input_type -> forge.v1.GetPullRequestDiffRequest - 26, // 38: forge.v1.ForgeService.ListReviews:input_type -> forge.v1.ListReviewsRequest - 30, // 39: forge.v1.ForgeService.ListReviewComments:input_type -> forge.v1.ListReviewCommentsRequest - 32, // 40: forge.v1.ForgeService.ReplyToReview:input_type -> forge.v1.ReplyToReviewRequest - 35, // 41: forge.v1.ForgeService.CreateReviewComments:input_type -> forge.v1.CreateReviewCommentsRequest - 39, // 42: forge.v1.ForgeService.AcceptInvitations:input_type -> forge.v1.AcceptInvitationsRequest - 41, // 43: forge.v1.ForgeService.VerifyPush:input_type -> forge.v1.VerifyPushRequest - 37, // 44: forge.v1.ForgeService.LinkBranch:input_type -> forge.v1.LinkBranchRequest - 43, // 45: forge.v1.ForgeService.GetRepoArchive:input_type -> forge.v1.GetRepoArchiveRequest - 1, // 46: forge.v1.ForgeService.Configure:output_type -> forge.v1.ConfigureResponse - 5, // 47: forge.v1.ForgeService.AssignedIssues:output_type -> forge.v1.AssignedIssuesResponse - 6, // 48: forge.v1.ForgeService.IssuesWithLabel:output_type -> forge.v1.IssuesWithLabelResponse - 10, // 49: forge.v1.ForgeService.Comment:output_type -> forge.v1.CommentResponse - 12, // 50: forge.v1.ForgeService.CloseIssue:output_type -> forge.v1.CloseIssueResponse - 14, // 51: forge.v1.ForgeService.React:output_type -> forge.v1.ReactResponse - 16, // 52: forge.v1.ForgeService.SetStateLabel:output_type -> forge.v1.SetStateLabelResponse - 18, // 53: forge.v1.ForgeService.CreatePR:output_type -> forge.v1.CreatePRResponse - 20, // 54: forge.v1.ForgeService.PRState:output_type -> forge.v1.PRStateResponse - 23, // 55: forge.v1.ForgeService.GetPullRequest:output_type -> forge.v1.GetPullRequestResponse - 25, // 56: forge.v1.ForgeService.GetPullRequestDiff:output_type -> forge.v1.GetPullRequestDiffResponse - 28, // 57: forge.v1.ForgeService.ListReviews:output_type -> forge.v1.ListReviewsResponse - 31, // 58: forge.v1.ForgeService.ListReviewComments:output_type -> forge.v1.ListReviewCommentsResponse - 33, // 59: forge.v1.ForgeService.ReplyToReview:output_type -> forge.v1.ReplyToReviewResponse - 36, // 60: forge.v1.ForgeService.CreateReviewComments:output_type -> forge.v1.CreateReviewCommentsResponse - 40, // 61: forge.v1.ForgeService.AcceptInvitations:output_type -> forge.v1.AcceptInvitationsResponse - 42, // 62: forge.v1.ForgeService.VerifyPush:output_type -> forge.v1.VerifyPushResponse - 38, // 63: forge.v1.ForgeService.LinkBranch:output_type -> forge.v1.LinkBranchResponse - 44, // 64: forge.v1.ForgeService.GetRepoArchive:output_type -> forge.v1.GetRepoArchiveResponse - 46, // [46:65] is the sub-list for method output_type - 27, // [27:46] is the sub-list for method input_type - 27, // [27:27] is the sub-list for extension type_name - 27, // [27:27] is the sub-list for extension extendee - 0, // [0:27] is the sub-list for field type_name + 51, // 27: forge.v1.ParseWebhookRequest.headers:type_name -> forge.v1.ParseWebhookRequest.HeadersEntry + 47, // 28: forge.v1.ParseWebhookResponse.issue:type_name -> forge.v1.IssueEvent + 48, // 29: forge.v1.ParseWebhookResponse.review:type_name -> forge.v1.ReviewEvent + 49, // 30: forge.v1.ParseWebhookResponse.review_comment:type_name -> forge.v1.ReviewCommentEvent + 2, // 31: forge.v1.IssueEvent.repo:type_name -> forge.v1.RepoRef + 2, // 32: forge.v1.ReviewEvent.repo:type_name -> forge.v1.RepoRef + 2, // 33: forge.v1.ReviewCommentEvent.repo:type_name -> forge.v1.RepoRef + 0, // 34: forge.v1.ForgeService.Configure:input_type -> forge.v1.ConfigureRequest + 7, // 35: forge.v1.ForgeService.AssignedIssues:input_type -> forge.v1.AssignedIssuesRequest + 8, // 36: forge.v1.ForgeService.IssuesWithLabel:input_type -> forge.v1.IssuesWithLabelRequest + 9, // 37: forge.v1.ForgeService.Comment:input_type -> forge.v1.CommentRequest + 11, // 38: forge.v1.ForgeService.CloseIssue:input_type -> forge.v1.CloseIssueRequest + 13, // 39: forge.v1.ForgeService.React:input_type -> forge.v1.ReactRequest + 15, // 40: forge.v1.ForgeService.SetStateLabel:input_type -> forge.v1.SetStateLabelRequest + 17, // 41: forge.v1.ForgeService.CreatePR:input_type -> forge.v1.CreatePRRequest + 19, // 42: forge.v1.ForgeService.PRState:input_type -> forge.v1.PRStateRequest + 22, // 43: forge.v1.ForgeService.GetPullRequest:input_type -> forge.v1.GetPullRequestRequest + 24, // 44: forge.v1.ForgeService.GetPullRequestDiff:input_type -> forge.v1.GetPullRequestDiffRequest + 26, // 45: forge.v1.ForgeService.ListReviews:input_type -> forge.v1.ListReviewsRequest + 30, // 46: forge.v1.ForgeService.ListReviewComments:input_type -> forge.v1.ListReviewCommentsRequest + 32, // 47: forge.v1.ForgeService.ReplyToReview:input_type -> forge.v1.ReplyToReviewRequest + 35, // 48: forge.v1.ForgeService.CreateReviewComments:input_type -> forge.v1.CreateReviewCommentsRequest + 39, // 49: forge.v1.ForgeService.AcceptInvitations:input_type -> forge.v1.AcceptInvitationsRequest + 41, // 50: forge.v1.ForgeService.VerifyPush:input_type -> forge.v1.VerifyPushRequest + 37, // 51: forge.v1.ForgeService.LinkBranch:input_type -> forge.v1.LinkBranchRequest + 45, // 52: forge.v1.ForgeService.ParseWebhook:input_type -> forge.v1.ParseWebhookRequest + 43, // 53: forge.v1.ForgeService.GetRepoArchive:input_type -> forge.v1.GetRepoArchiveRequest + 1, // 54: forge.v1.ForgeService.Configure:output_type -> forge.v1.ConfigureResponse + 5, // 55: forge.v1.ForgeService.AssignedIssues:output_type -> forge.v1.AssignedIssuesResponse + 6, // 56: forge.v1.ForgeService.IssuesWithLabel:output_type -> forge.v1.IssuesWithLabelResponse + 10, // 57: forge.v1.ForgeService.Comment:output_type -> forge.v1.CommentResponse + 12, // 58: forge.v1.ForgeService.CloseIssue:output_type -> forge.v1.CloseIssueResponse + 14, // 59: forge.v1.ForgeService.React:output_type -> forge.v1.ReactResponse + 16, // 60: forge.v1.ForgeService.SetStateLabel:output_type -> forge.v1.SetStateLabelResponse + 18, // 61: forge.v1.ForgeService.CreatePR:output_type -> forge.v1.CreatePRResponse + 20, // 62: forge.v1.ForgeService.PRState:output_type -> forge.v1.PRStateResponse + 23, // 63: forge.v1.ForgeService.GetPullRequest:output_type -> forge.v1.GetPullRequestResponse + 25, // 64: forge.v1.ForgeService.GetPullRequestDiff:output_type -> forge.v1.GetPullRequestDiffResponse + 28, // 65: forge.v1.ForgeService.ListReviews:output_type -> forge.v1.ListReviewsResponse + 31, // 66: forge.v1.ForgeService.ListReviewComments:output_type -> forge.v1.ListReviewCommentsResponse + 33, // 67: forge.v1.ForgeService.ReplyToReview:output_type -> forge.v1.ReplyToReviewResponse + 36, // 68: forge.v1.ForgeService.CreateReviewComments:output_type -> forge.v1.CreateReviewCommentsResponse + 40, // 69: forge.v1.ForgeService.AcceptInvitations:output_type -> forge.v1.AcceptInvitationsResponse + 42, // 70: forge.v1.ForgeService.VerifyPush:output_type -> forge.v1.VerifyPushResponse + 38, // 71: forge.v1.ForgeService.LinkBranch:output_type -> forge.v1.LinkBranchResponse + 46, // 72: forge.v1.ForgeService.ParseWebhook:output_type -> forge.v1.ParseWebhookResponse + 44, // 73: forge.v1.ForgeService.GetRepoArchive:output_type -> forge.v1.GetRepoArchiveResponse + 54, // [54:74] is the sub-list for method output_type + 34, // [34:54] is the sub-list for method input_type + 34, // [34:34] is the sub-list for extension type_name + 34, // [34:34] is the sub-list for extension extendee + 0, // [0:34] is the sub-list for field type_name } func init() { file_forge_v1_forge_proto_init() } @@ -2664,13 +3179,18 @@ func file_forge_v1_forge_proto_init() { if File_forge_v1_forge_proto != nil { return } + file_forge_v1_forge_proto_msgTypes[46].OneofWrappers = []any{ + (*ParseWebhookResponse_Issue)(nil), + (*ParseWebhookResponse_Review)(nil), + (*ParseWebhookResponse_ReviewComment)(nil), + } type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_forge_v1_forge_proto_rawDesc), len(file_forge_v1_forge_proto_rawDesc)), NumEnums: 0, - NumMessages: 46, + NumMessages: 52, NumExtensions: 0, NumServices: 1, }, diff --git a/sdk/forge/v1/forge_grpc.pb.go b/sdk/forge/v1/forge_grpc.pb.go index 1418171..724d1cf 100644 --- a/sdk/forge/v1/forge_grpc.pb.go +++ b/sdk/forge/v1/forge_grpc.pb.go @@ -37,6 +37,7 @@ const ( ForgeService_AcceptInvitations_FullMethodName = "/forge.v1.ForgeService/AcceptInvitations" ForgeService_VerifyPush_FullMethodName = "/forge.v1.ForgeService/VerifyPush" ForgeService_LinkBranch_FullMethodName = "/forge.v1.ForgeService/LinkBranch" + ForgeService_ParseWebhook_FullMethodName = "/forge.v1.ForgeService/ParseWebhook" ForgeService_GetRepoArchive_FullMethodName = "/forge.v1.ForgeService/GetRepoArchive" ) @@ -71,6 +72,10 @@ type ForgeServiceClient interface { AcceptInvitations(ctx context.Context, in *AcceptInvitationsRequest, opts ...grpc.CallOption) (*AcceptInvitationsResponse, error) VerifyPush(ctx context.Context, in *VerifyPushRequest, opts ...grpc.CallOption) (*VerifyPushResponse, error) LinkBranch(ctx context.Context, in *LinkBranchRequest, opts ...grpc.CallOption) (*LinkBranchResponse, error) + // ParseWebhook decodes one webhook delivery the host has already + // authenticated. A delivery that is not an event the host acts on returns no + // event; an undecodable body is INVALID_ARGUMENT. + ParseWebhook(ctx context.Context, in *ParseWebhookRequest, opts ...grpc.CallOption) (*ParseWebhookResponse, error) // GetRepoArchive streams a gzipped tar of the repository at a ref. GetRepoArchive(ctx context.Context, in *GetRepoArchiveRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[GetRepoArchiveResponse], error) } @@ -263,6 +268,16 @@ func (c *forgeServiceClient) LinkBranch(ctx context.Context, in *LinkBranchReque return out, nil } +func (c *forgeServiceClient) ParseWebhook(ctx context.Context, in *ParseWebhookRequest, opts ...grpc.CallOption) (*ParseWebhookResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ParseWebhookResponse) + err := c.cc.Invoke(ctx, ForgeService_ParseWebhook_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *forgeServiceClient) GetRepoArchive(ctx context.Context, in *GetRepoArchiveRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[GetRepoArchiveResponse], error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) stream, err := c.cc.NewStream(ctx, &ForgeService_ServiceDesc.Streams[0], ForgeService_GetRepoArchive_FullMethodName, cOpts...) @@ -313,6 +328,10 @@ type ForgeServiceServer interface { AcceptInvitations(context.Context, *AcceptInvitationsRequest) (*AcceptInvitationsResponse, error) VerifyPush(context.Context, *VerifyPushRequest) (*VerifyPushResponse, error) LinkBranch(context.Context, *LinkBranchRequest) (*LinkBranchResponse, error) + // ParseWebhook decodes one webhook delivery the host has already + // authenticated. A delivery that is not an event the host acts on returns no + // event; an undecodable body is INVALID_ARGUMENT. + ParseWebhook(context.Context, *ParseWebhookRequest) (*ParseWebhookResponse, error) // GetRepoArchive streams a gzipped tar of the repository at a ref. GetRepoArchive(*GetRepoArchiveRequest, grpc.ServerStreamingServer[GetRepoArchiveResponse]) error mustEmbedUnimplementedForgeServiceServer() @@ -379,6 +398,9 @@ func (UnimplementedForgeServiceServer) VerifyPush(context.Context, *VerifyPushRe func (UnimplementedForgeServiceServer) LinkBranch(context.Context, *LinkBranchRequest) (*LinkBranchResponse, error) { return nil, status.Error(codes.Unimplemented, "method LinkBranch not implemented") } +func (UnimplementedForgeServiceServer) ParseWebhook(context.Context, *ParseWebhookRequest) (*ParseWebhookResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ParseWebhook not implemented") +} func (UnimplementedForgeServiceServer) GetRepoArchive(*GetRepoArchiveRequest, grpc.ServerStreamingServer[GetRepoArchiveResponse]) error { return status.Error(codes.Unimplemented, "method GetRepoArchive not implemented") } @@ -727,6 +749,24 @@ func _ForgeService_LinkBranch_Handler(srv interface{}, ctx context.Context, dec return interceptor(ctx, in, info, handler) } +func _ForgeService_ParseWebhook_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ParseWebhookRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ForgeServiceServer).ParseWebhook(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ForgeService_ParseWebhook_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ForgeServiceServer).ParseWebhook(ctx, req.(*ParseWebhookRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _ForgeService_GetRepoArchive_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(GetRepoArchiveRequest) if err := stream.RecvMsg(m); err != nil { @@ -817,6 +857,10 @@ var ForgeService_ServiceDesc = grpc.ServiceDesc{ MethodName: "LinkBranch", Handler: _ForgeService_LinkBranch_Handler, }, + { + MethodName: "ParseWebhook", + Handler: _ForgeService_ParseWebhook_Handler, + }, }, Streams: []grpc.StreamDesc{ {