feat(forge): github and gitea forge extensions

This commit is contained in:
sam committed 2026-10-04 14:26:27 +11:00
1 parent 850b2019ad
commit 487a58e24b
15 files changed
+2259 -54

No files matched your search

+1
View File
@@ -6,6 +6,7 @@ directory holds one subdirectory per extension.
```
secret-engines/<name>/ package.yaml + Go source, served over secretengine.v1
workflows/<name>/ package.yaml + workflow YAML, projected into workflow-definitions
forge/<name>/ package.yaml + Go source, served over forge.v1 (github, gitea)
playbooks/<name>/ package.yaml + EDA playbook YAML, projected into eda-playbooks
profiles/<name>/ package.yaml + agent profile YAML, projected into agent-profiles
sdk/ generated surface stubs and the Serve helper
+491
View File
@@ -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()
}
+15
View File
@@ -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())
})
}
+11
View File
@@ -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
+453
View File
@@ -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
}
+33
View File
@@ -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)
}
}
+15
View File
@@ -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
+89
View File
@@ -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,
}
}
+8
View File
@@ -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
+34 -1
View File
@@ -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=
+173
View File
@@ -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,
)
}
+2 -1
View File
@@ -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,
+318
View File
@@ -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
}
+572 -52
View File
@@ -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,
},
+44
View File
@@ -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{
{