From 153dfc094c1c093aef8a5fff01deb5261b0ba987 Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Sun, 4 Oct 2026 13:56:32 +1100 Subject: [PATCH] feat(forgeext): forge surface served by extensions; forge.type names the installed package --- internal/app/archied/bootstrap.go | 12 +- internal/app/archied/forge_extensions.go | 96 + internal/app/archied/main.go | 7 +- internal/contracts/forge/v1/forge.pb.go | 2684 +++++++++++++++++ internal/contracts/forge/v1/forge_grpc.pb.go | 829 +++++ internal/domain/storepkg/descriptor.go | 9 +- internal/domain/storepkg/descriptor_test.go | 2 +- .../infrastructure/configuration/validate.go | 14 +- internal/infrastructure/extension/source.go | 99 + internal/infrastructure/forgeext/forgeext.go | 350 +++ .../infrastructure/secretengine/runner.go | 90 +- proto/forge/v1/forge.proto | 209 ++ 12 files changed, 4303 insertions(+), 98 deletions(-) create mode 100644 internal/app/archied/forge_extensions.go create mode 100644 internal/contracts/forge/v1/forge.pb.go create mode 100644 internal/contracts/forge/v1/forge_grpc.pb.go create mode 100644 internal/infrastructure/extension/source.go create mode 100644 internal/infrastructure/forgeext/forgeext.go create mode 100644 proto/forge/v1/forge.proto diff --git a/internal/app/archied/bootstrap.go b/internal/app/archied/bootstrap.go index 511790f00..477a0af42 100644 --- a/internal/app/archied/bootstrap.go +++ b/internal/app/archied/bootstrap.go @@ -47,6 +47,7 @@ import ( infraaccess "github.com/samcharles93/archie-core/internal/infrastructure/access" "github.com/samcharles93/archie-core/internal/infrastructure/configuration" "github.com/samcharles93/archie-core/internal/infrastructure/eventbus/nats" + "github.com/samcharles93/archie-core/internal/infrastructure/extension" "github.com/samcharles93/archie-core/internal/infrastructure/modelcatalog" "github.com/samcharles93/archie-core/internal/infrastructure/staterpc" "github.com/samcharles93/archie-core/internal/infrastructure/taskactions" @@ -84,6 +85,7 @@ type boot struct { secrets *secret.Registry forgeClient forge.Forge + forgeExt *forgeExtensions token string // stateStore is the State Store contract adapter every daemon and gateway @@ -251,8 +253,12 @@ func (b *boot) openStores(ctx context.Context) error { // openForge builds the forge client. It runs after the runtime settings are // layered, so a token held by an extension engine can resolve. -func (b *boot) openForge() { - b.forgeClient, b.token = resolveForge(b.cfg.Forge, b.secrets, b.log) +func (b *boot) openForge(ctx context.Context) { + if packages, ok := b.stateStore.(extension.Packages); ok { + b.forgeExt = newForgeExtensions(extension.Source{Query: b.controlPlane, Packages: packages}, b.log) + b.addCleanup(b.forgeExt.close) + } + b.forgeClient, b.token = resolveForge(ctx, b.cfg.Forge, "default", b.secrets, b.forgeExt, b.log) } func (b *boot) openStateStoreAdapter(ctx context.Context) error { @@ -530,7 +536,7 @@ func (b *boot) buildTreesAndIdentities(ctx context.Context) error { b.buildWorktreeManager() for _, idCfg := range cfg.Identities { - idForge, idToken := resolveForge(idCfg.Forge, b.secrets, log.With("identity", idCfg.Name)) + idForge, idToken := resolveForge(ctx, idCfg.Forge, idCfg.Name, b.secrets, b.forgeExt, log.With("identity", idCfg.Name)) idTrees := &worktree.Manager{ WorkDir: filepath.Join(cfg.WorkDir, "identity-"+idCfg.Name), Token: idToken, diff --git a/internal/app/archied/forge_extensions.go b/internal/app/archied/forge_extensions.go new file mode 100644 index 000000000..4fe418846 --- /dev/null +++ b/internal/app/archied/forge_extensions.go @@ -0,0 +1,96 @@ +package archied + +import ( + "context" + "log/slog" + "os" + "path/filepath" + "slices" + + "github.com/hashicorp/go-hclog" + + "github.com/samcharles93/archie-core/internal/domain/storepkg" + "github.com/samcharles93/archie-core/internal/forge" + "github.com/samcharles93/archie-core/internal/infrastructure/extension" + "github.com/samcharles93/archie-core/internal/infrastructure/forgeext" +) + +// forgeExtensions opens forge instances served by installed forge extensions: +// the package named by forge.type, with its authority accepted and enabled in +// extension-settings. Changing which extension serves a forge takes a restart, +// as every forge setting does. +type forgeExtensions struct { + host *extension.Host + source extension.Source + cacheDir string + log *slog.Logger +} + +func newForgeExtensions(source extension.Source, log *slog.Logger) *forgeExtensions { + cache, err := os.UserCacheDir() + if err != nil { + log.Warn("forge extensions unavailable: no cache directory", "err", err) + return nil + } + return &forgeExtensions{ + host: extension.NewHost(hclog.New(&hclog.LoggerOptions{Name: "extension", Level: hclog.Warn})), + source: source, + cacheDir: filepath.Join(cache, "archie", "extensions", "forge"), + log: log, + } +} + +// open returns the instance's forge when an enabled extension named typ serves +// it. handled is false when none does, so the caller falls back to the +// compiled-in forge; an extension that is enabled but will not start is +// handled, as a forge that fails rather than a different one. +func (e *forgeExtensions) open(ctx context.Context, typ, instance, host, token string) (f forge.Forge, handled bool) { + if e == nil { + return nil, false + } + settings, _, err := e.source.Enabled(ctx) + if err != nil { + e.log.Warn("forge extensions: extension settings unavailable", "err", err) + return nil, false + } + setting, ok := settings[typ] + if !ok || !setting.Enabled { + return nil, false + } + installed, err := e.source.Packages.ListInstalled(ctx, extension.OrgID) + if err != nil { + e.log.Warn("forge extensions: installed packages unavailable", "err", err) + return nil, false + } + for _, pkg := range installed { + if pkg.Name != typ || pkg.AcceptedAuthority == nil { + continue + } + index := slices.IndexFunc(pkg.Descriptor.Contributes.Extensions, func(x storepkg.Extension) bool { return x.Surface == storepkg.SurfaceForge }) + if index < 0 { + continue + } + forgeClient, err := e.start(ctx, pkg, pkg.Descriptor.Contributes.Extensions[index].Path, instance, host, token, setting.Settings) + if err != nil { + e.log.Warn("forge disabled: extension did not start", "forge_type", typ, "instance", instance, "err", err) + return forge.NewNoop(e.log), true + } + return forgeClient, true + } + return nil, false +} + +func (e *forgeExtensions) start(ctx context.Context, pkg storepkg.Installed, file, instance, host, token string, settings map[string]string) (forge.Forge, error) { + binary, sum, err := extension.Materialize(ctx, e.source.Packages, e.cacheDir, pkg, file) + if err != nil { + return nil, err + } + spec := extension.Spec{Name: "forge/" + instance, Path: binary, SHA256: sum, Env: slices.Clone(pkg.AcceptedAuthority.Env)} + return forgeext.Open(ctx, e.host, forgeext.Instance{Spec: spec, Host: host, Token: token, Settings: settings}, e.log) +} + +func (e *forgeExtensions) close() { + if e != nil { + e.host.Close() + } +} diff --git a/internal/app/archied/main.go b/internal/app/archied/main.go index 0d53e7f33..ed8c2b7c2 100644 --- a/internal/app/archied/main.go +++ b/internal/app/archied/main.go @@ -53,7 +53,7 @@ import ( // becomes a crash loop where the error scrolls past unread. A malformed // configuration is a different matter and still fails fast in validation, well // before this point. -func resolveForge(cfg config.Forge, secrets *secret.Registry, log *slog.Logger) (forge.Forge, string) { +func resolveForge(ctx context.Context, cfg config.Forge, instance string, secrets *secret.Registry, extensions *forgeExtensions, log *slog.Logger) (forge.Forge, string) { if configuration.ForgeDisabled(cfg.Type) { return forge.NewNoop(log), "" } @@ -66,6 +66,9 @@ func resolveForge(cfg config.Forge, secrets *secret.Registry, log *slog.Logger) "err", err) return forge.NewNoop(log), "" } + if client, handled := extensions.open(ctx, cfg.Type, instance, cfg.Host, token); handled { + return client, token + } client, err := forge.New(cfg.Type, token, cfg.Host, log) if err != nil { log.Warn("forge disabled: client construction failed", @@ -157,7 +160,7 @@ func Run() int { //nolint:cyclop,funlen // the composition root's setup sequence b.log.Error("runtime settings unavailable", "err", err) return 1 } - b.openForge() + b.openForge(ctx) if err := b.startLiveSettings(ctx); err != nil { b.log.Error("live settings unavailable", "err", err) return 1 diff --git a/internal/contracts/forge/v1/forge.pb.go b/internal/contracts/forge/v1/forge.pb.go new file mode 100644 index 000000000..99647fccf --- /dev/null +++ b/internal/contracts/forge/v1/forge.pb.go @@ -0,0 +1,2684 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.36.11 +// protoc (unknown) +// source: forge/v1/forge.proto + +package forgev1 + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" + unsafe "unsafe" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type ConfigureRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Host string `protobuf:"bytes,1,opt,name=host,proto3" json:"host,omitempty"` + Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"` + Settings map[string]string `protobuf:"bytes,3,rep,name=settings,proto3" json:"settings,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ConfigureRequest) Reset() { + *x = ConfigureRequest{} + mi := &file_forge_v1_forge_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ConfigureRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ConfigureRequest) ProtoMessage() {} + +func (x *ConfigureRequest) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[0] + 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 ConfigureRequest.ProtoReflect.Descriptor instead. +func (*ConfigureRequest) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{0} +} + +func (x *ConfigureRequest) GetHost() string { + if x != nil { + return x.Host + } + return "" +} + +func (x *ConfigureRequest) GetToken() string { + if x != nil { + return x.Token + } + return "" +} + +func (x *ConfigureRequest) GetSettings() map[string]string { + if x != nil { + return x.Settings + } + return nil +} + +type ConfigureResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ConfigureResponse) Reset() { + *x = ConfigureResponse{} + mi := &file_forge_v1_forge_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ConfigureResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ConfigureResponse) ProtoMessage() {} + +func (x *ConfigureResponse) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[1] + 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 ConfigureResponse.ProtoReflect.Descriptor instead. +func (*ConfigureResponse) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{1} +} + +type RepoRef struct { + state protoimpl.MessageState `protogen:"open.v1"` + Owner string `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"` + Repo string `protobuf:"bytes,2,opt,name=repo,proto3" json:"repo,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RepoRef) Reset() { + *x = RepoRef{} + mi := &file_forge_v1_forge_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RepoRef) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RepoRef) ProtoMessage() {} + +func (x *RepoRef) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[2] + 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 RepoRef.ProtoReflect.Descriptor instead. +func (*RepoRef) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{2} +} + +func (x *RepoRef) GetOwner() string { + if x != nil { + return x.Owner + } + return "" +} + +func (x *RepoRef) GetRepo() string { + if x != nil { + return x.Repo + } + return "" +} + +type PullRequestRef struct { + state protoimpl.MessageState `protogen:"open.v1"` + Repo *RepoRef `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"` + Number int32 `protobuf:"varint,2,opt,name=number,proto3" json:"number,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *PullRequestRef) Reset() { + *x = PullRequestRef{} + mi := &file_forge_v1_forge_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PullRequestRef) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PullRequestRef) ProtoMessage() {} + +func (x *PullRequestRef) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[3] + 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 PullRequestRef.ProtoReflect.Descriptor instead. +func (*PullRequestRef) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{3} +} + +func (x *PullRequestRef) GetRepo() *RepoRef { + if x != nil { + return x.Repo + } + return nil +} + +func (x *PullRequestRef) GetNumber() int32 { + if x != nil { + return x.Number + } + return 0 +} + +type Issue struct { + state protoimpl.MessageState `protogen:"open.v1"` + Number int32 `protobuf:"varint,1,opt,name=number,proto3" json:"number,omitempty"` + Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"` + Body string `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"` + Labels []string `protobuf:"bytes,4,rep,name=labels,proto3" json:"labels,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Issue) Reset() { + *x = Issue{} + mi := &file_forge_v1_forge_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Issue) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Issue) ProtoMessage() {} + +func (x *Issue) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[4] + 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 Issue.ProtoReflect.Descriptor instead. +func (*Issue) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{4} +} + +func (x *Issue) GetNumber() int32 { + if x != nil { + return x.Number + } + return 0 +} + +func (x *Issue) GetTitle() string { + if x != nil { + return x.Title + } + return "" +} + +func (x *Issue) GetBody() string { + if x != nil { + return x.Body + } + return "" +} + +func (x *Issue) GetLabels() []string { + if x != nil { + return x.Labels + } + return nil +} + +type AssignedIssuesResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Issues []*Issue `protobuf:"bytes,1,rep,name=issues,proto3" json:"issues,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AssignedIssuesResponse) Reset() { + *x = AssignedIssuesResponse{} + mi := &file_forge_v1_forge_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AssignedIssuesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AssignedIssuesResponse) ProtoMessage() {} + +func (x *AssignedIssuesResponse) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[5] + 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 AssignedIssuesResponse.ProtoReflect.Descriptor instead. +func (*AssignedIssuesResponse) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{5} +} + +func (x *AssignedIssuesResponse) GetIssues() []*Issue { + if x != nil { + return x.Issues + } + return nil +} + +type IssuesWithLabelResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Issues []*Issue `protobuf:"bytes,1,rep,name=issues,proto3" json:"issues,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *IssuesWithLabelResponse) Reset() { + *x = IssuesWithLabelResponse{} + mi := &file_forge_v1_forge_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *IssuesWithLabelResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*IssuesWithLabelResponse) ProtoMessage() {} + +func (x *IssuesWithLabelResponse) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[6] + 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 IssuesWithLabelResponse.ProtoReflect.Descriptor instead. +func (*IssuesWithLabelResponse) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{6} +} + +func (x *IssuesWithLabelResponse) GetIssues() []*Issue { + if x != nil { + return x.Issues + } + return nil +} + +type AssignedIssuesRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Repo *RepoRef `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"` + Assignee string `protobuf:"bytes,2,opt,name=assignee,proto3" json:"assignee,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AssignedIssuesRequest) Reset() { + *x = AssignedIssuesRequest{} + mi := &file_forge_v1_forge_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AssignedIssuesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AssignedIssuesRequest) ProtoMessage() {} + +func (x *AssignedIssuesRequest) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[7] + 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 AssignedIssuesRequest.ProtoReflect.Descriptor instead. +func (*AssignedIssuesRequest) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{7} +} + +func (x *AssignedIssuesRequest) GetRepo() *RepoRef { + if x != nil { + return x.Repo + } + return nil +} + +func (x *AssignedIssuesRequest) GetAssignee() string { + if x != nil { + return x.Assignee + } + return "" +} + +type IssuesWithLabelRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Repo *RepoRef `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"` + Label string `protobuf:"bytes,2,opt,name=label,proto3" json:"label,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *IssuesWithLabelRequest) Reset() { + *x = IssuesWithLabelRequest{} + mi := &file_forge_v1_forge_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *IssuesWithLabelRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*IssuesWithLabelRequest) ProtoMessage() {} + +func (x *IssuesWithLabelRequest) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[8] + 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 IssuesWithLabelRequest.ProtoReflect.Descriptor instead. +func (*IssuesWithLabelRequest) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{8} +} + +func (x *IssuesWithLabelRequest) GetRepo() *RepoRef { + if x != nil { + return x.Repo + } + return nil +} + +func (x *IssuesWithLabelRequest) GetLabel() string { + if x != nil { + return x.Label + } + return "" +} + +type CommentRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Repo *RepoRef `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"` + Number int32 `protobuf:"varint,2,opt,name=number,proto3" json:"number,omitempty"` + Body string `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CommentRequest) Reset() { + *x = CommentRequest{} + mi := &file_forge_v1_forge_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CommentRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CommentRequest) ProtoMessage() {} + +func (x *CommentRequest) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[9] + 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 CommentRequest.ProtoReflect.Descriptor instead. +func (*CommentRequest) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{9} +} + +func (x *CommentRequest) GetRepo() *RepoRef { + if x != nil { + return x.Repo + } + return nil +} + +func (x *CommentRequest) GetNumber() int32 { + if x != nil { + return x.Number + } + return 0 +} + +func (x *CommentRequest) GetBody() string { + if x != nil { + return x.Body + } + return "" +} + +type CommentResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CommentResponse) Reset() { + *x = CommentResponse{} + mi := &file_forge_v1_forge_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CommentResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CommentResponse) ProtoMessage() {} + +func (x *CommentResponse) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[10] + 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 CommentResponse.ProtoReflect.Descriptor instead. +func (*CommentResponse) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{10} +} + +func (x *CommentResponse) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +type CloseIssueRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Repo *RepoRef `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"` + Number int32 `protobuf:"varint,2,opt,name=number,proto3" json:"number,omitempty"` + Comment string `protobuf:"bytes,3,opt,name=comment,proto3" json:"comment,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CloseIssueRequest) Reset() { + *x = CloseIssueRequest{} + mi := &file_forge_v1_forge_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CloseIssueRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CloseIssueRequest) ProtoMessage() {} + +func (x *CloseIssueRequest) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[11] + 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 CloseIssueRequest.ProtoReflect.Descriptor instead. +func (*CloseIssueRequest) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{11} +} + +func (x *CloseIssueRequest) GetRepo() *RepoRef { + if x != nil { + return x.Repo + } + return nil +} + +func (x *CloseIssueRequest) GetNumber() int32 { + if x != nil { + return x.Number + } + return 0 +} + +func (x *CloseIssueRequest) GetComment() string { + if x != nil { + return x.Comment + } + return "" +} + +type CloseIssueResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CloseIssueResponse) Reset() { + *x = CloseIssueResponse{} + mi := &file_forge_v1_forge_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CloseIssueResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CloseIssueResponse) ProtoMessage() {} + +func (x *CloseIssueResponse) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[12] + 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 CloseIssueResponse.ProtoReflect.Descriptor instead. +func (*CloseIssueResponse) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{12} +} + +type ReactRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Repo *RepoRef `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"` + Number int32 `protobuf:"varint,2,opt,name=number,proto3" json:"number,omitempty"` + Reaction string `protobuf:"bytes,3,opt,name=reaction,proto3" json:"reaction,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ReactRequest) Reset() { + *x = ReactRequest{} + mi := &file_forge_v1_forge_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ReactRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReactRequest) ProtoMessage() {} + +func (x *ReactRequest) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[13] + 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 ReactRequest.ProtoReflect.Descriptor instead. +func (*ReactRequest) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{13} +} + +func (x *ReactRequest) GetRepo() *RepoRef { + if x != nil { + return x.Repo + } + return nil +} + +func (x *ReactRequest) GetNumber() int32 { + if x != nil { + return x.Number + } + return 0 +} + +func (x *ReactRequest) GetReaction() string { + if x != nil { + return x.Reaction + } + return "" +} + +type ReactResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ReactResponse) Reset() { + *x = ReactResponse{} + mi := &file_forge_v1_forge_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ReactResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReactResponse) ProtoMessage() {} + +func (x *ReactResponse) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[14] + 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 ReactResponse.ProtoReflect.Descriptor instead. +func (*ReactResponse) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{14} +} + +type SetStateLabelRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Repo *RepoRef `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"` + Number int32 `protobuf:"varint,2,opt,name=number,proto3" json:"number,omitempty"` + Label string `protobuf:"bytes,3,opt,name=label,proto3" json:"label,omitempty"` + KnownLabels []string `protobuf:"bytes,4,rep,name=known_labels,json=knownLabels,proto3" json:"known_labels,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SetStateLabelRequest) Reset() { + *x = SetStateLabelRequest{} + mi := &file_forge_v1_forge_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SetStateLabelRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetStateLabelRequest) ProtoMessage() {} + +func (x *SetStateLabelRequest) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[15] + 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 SetStateLabelRequest.ProtoReflect.Descriptor instead. +func (*SetStateLabelRequest) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{15} +} + +func (x *SetStateLabelRequest) GetRepo() *RepoRef { + if x != nil { + return x.Repo + } + return nil +} + +func (x *SetStateLabelRequest) GetNumber() int32 { + if x != nil { + return x.Number + } + return 0 +} + +func (x *SetStateLabelRequest) GetLabel() string { + if x != nil { + return x.Label + } + return "" +} + +func (x *SetStateLabelRequest) GetKnownLabels() []string { + if x != nil { + return x.KnownLabels + } + return nil +} + +type SetStateLabelResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SetStateLabelResponse) Reset() { + *x = SetStateLabelResponse{} + mi := &file_forge_v1_forge_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SetStateLabelResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetStateLabelResponse) ProtoMessage() {} + +func (x *SetStateLabelResponse) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[16] + 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 SetStateLabelResponse.ProtoReflect.Descriptor instead. +func (*SetStateLabelResponse) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{16} +} + +type CreatePRRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Repo *RepoRef `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"` + Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"` + Head string `protobuf:"bytes,3,opt,name=head,proto3" json:"head,omitempty"` + Base string `protobuf:"bytes,4,opt,name=base,proto3" json:"base,omitempty"` + Body string `protobuf:"bytes,5,opt,name=body,proto3" json:"body,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CreatePRRequest) Reset() { + *x = CreatePRRequest{} + mi := &file_forge_v1_forge_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CreatePRRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreatePRRequest) ProtoMessage() {} + +func (x *CreatePRRequest) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[17] + 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 CreatePRRequest.ProtoReflect.Descriptor instead. +func (*CreatePRRequest) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{17} +} + +func (x *CreatePRRequest) GetRepo() *RepoRef { + if x != nil { + return x.Repo + } + return nil +} + +func (x *CreatePRRequest) GetTitle() string { + if x != nil { + return x.Title + } + return "" +} + +func (x *CreatePRRequest) GetHead() string { + if x != nil { + return x.Head + } + return "" +} + +func (x *CreatePRRequest) GetBase() string { + if x != nil { + return x.Base + } + return "" +} + +func (x *CreatePRRequest) GetBody() string { + if x != nil { + return x.Body + } + return "" +} + +type CreatePRResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Number int32 `protobuf:"varint,1,opt,name=number,proto3" json:"number,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CreatePRResponse) Reset() { + *x = CreatePRResponse{} + mi := &file_forge_v1_forge_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CreatePRResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreatePRResponse) ProtoMessage() {} + +func (x *CreatePRResponse) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[18] + 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 CreatePRResponse.ProtoReflect.Descriptor instead. +func (*CreatePRResponse) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{18} +} + +func (x *CreatePRResponse) GetNumber() int32 { + if x != nil { + return x.Number + } + return 0 +} + +type PRStateRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Repo *RepoRef `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"` + Number int32 `protobuf:"varint,2,opt,name=number,proto3" json:"number,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *PRStateRequest) Reset() { + *x = PRStateRequest{} + mi := &file_forge_v1_forge_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PRStateRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PRStateRequest) ProtoMessage() {} + +func (x *PRStateRequest) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[19] + 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 PRStateRequest.ProtoReflect.Descriptor instead. +func (*PRStateRequest) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{19} +} + +func (x *PRStateRequest) GetRepo() *RepoRef { + if x != nil { + return x.Repo + } + return nil +} + +func (x *PRStateRequest) GetNumber() int32 { + if x != nil { + return x.Number + } + return 0 +} + +type PRStateResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + State string `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *PRStateResponse) Reset() { + *x = PRStateResponse{} + mi := &file_forge_v1_forge_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PRStateResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PRStateResponse) ProtoMessage() {} + +func (x *PRStateResponse) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[20] + 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 PRStateResponse.ProtoReflect.Descriptor instead. +func (*PRStateResponse) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{20} +} + +func (x *PRStateResponse) GetState() string { + if x != nil { + return x.State + } + return "" +} + +type PullRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Number int32 `protobuf:"varint,1,opt,name=number,proto3" json:"number,omitempty"` + Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"` + Body string `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"` + HeadRef string `protobuf:"bytes,4,opt,name=head_ref,json=headRef,proto3" json:"head_ref,omitempty"` + BaseRef string `protobuf:"bytes,5,opt,name=base_ref,json=baseRef,proto3" json:"base_ref,omitempty"` + HeadSha string `protobuf:"bytes,6,opt,name=head_sha,json=headSha,proto3" json:"head_sha,omitempty"` + BaseSha string `protobuf:"bytes,7,opt,name=base_sha,json=baseSha,proto3" json:"base_sha,omitempty"` + State string `protobuf:"bytes,8,opt,name=state,proto3" json:"state,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *PullRequest) Reset() { + *x = PullRequest{} + mi := &file_forge_v1_forge_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PullRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PullRequest) ProtoMessage() {} + +func (x *PullRequest) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[21] + 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 PullRequest.ProtoReflect.Descriptor instead. +func (*PullRequest) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{21} +} + +func (x *PullRequest) GetNumber() int32 { + if x != nil { + return x.Number + } + return 0 +} + +func (x *PullRequest) GetTitle() string { + if x != nil { + return x.Title + } + return "" +} + +func (x *PullRequest) GetBody() string { + if x != nil { + return x.Body + } + return "" +} + +func (x *PullRequest) GetHeadRef() string { + if x != nil { + return x.HeadRef + } + return "" +} + +func (x *PullRequest) GetBaseRef() string { + if x != nil { + return x.BaseRef + } + return "" +} + +func (x *PullRequest) GetHeadSha() string { + if x != nil { + return x.HeadSha + } + return "" +} + +func (x *PullRequest) GetBaseSha() string { + if x != nil { + return x.BaseSha + } + return "" +} + +func (x *PullRequest) GetState() string { + if x != nil { + return x.State + } + return "" +} + +type GetPullRequestRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Repo *RepoRef `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"` + Number int32 `protobuf:"varint,2,opt,name=number,proto3" json:"number,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetPullRequestRequest) Reset() { + *x = GetPullRequestRequest{} + mi := &file_forge_v1_forge_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetPullRequestRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetPullRequestRequest) ProtoMessage() {} + +func (x *GetPullRequestRequest) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[22] + 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 GetPullRequestRequest.ProtoReflect.Descriptor instead. +func (*GetPullRequestRequest) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{22} +} + +func (x *GetPullRequestRequest) GetRepo() *RepoRef { + if x != nil { + return x.Repo + } + return nil +} + +func (x *GetPullRequestRequest) GetNumber() int32 { + if x != nil { + return x.Number + } + return 0 +} + +type GetPullRequestResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + PullRequest *PullRequest `protobuf:"bytes,1,opt,name=pull_request,json=pullRequest,proto3" json:"pull_request,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetPullRequestResponse) Reset() { + *x = GetPullRequestResponse{} + mi := &file_forge_v1_forge_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetPullRequestResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetPullRequestResponse) ProtoMessage() {} + +func (x *GetPullRequestResponse) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[23] + 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 GetPullRequestResponse.ProtoReflect.Descriptor instead. +func (*GetPullRequestResponse) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{23} +} + +func (x *GetPullRequestResponse) GetPullRequest() *PullRequest { + if x != nil { + return x.PullRequest + } + return nil +} + +type GetPullRequestDiffRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Repo *RepoRef `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"` + Number int32 `protobuf:"varint,2,opt,name=number,proto3" json:"number,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetPullRequestDiffRequest) Reset() { + *x = GetPullRequestDiffRequest{} + mi := &file_forge_v1_forge_proto_msgTypes[24] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetPullRequestDiffRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetPullRequestDiffRequest) ProtoMessage() {} + +func (x *GetPullRequestDiffRequest) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[24] + 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 GetPullRequestDiffRequest.ProtoReflect.Descriptor instead. +func (*GetPullRequestDiffRequest) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{24} +} + +func (x *GetPullRequestDiffRequest) GetRepo() *RepoRef { + if x != nil { + return x.Repo + } + return nil +} + +func (x *GetPullRequestDiffRequest) GetNumber() int32 { + if x != nil { + return x.Number + } + return 0 +} + +type GetPullRequestDiffResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Diff string `protobuf:"bytes,1,opt,name=diff,proto3" json:"diff,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetPullRequestDiffResponse) Reset() { + *x = GetPullRequestDiffResponse{} + mi := &file_forge_v1_forge_proto_msgTypes[25] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetPullRequestDiffResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetPullRequestDiffResponse) ProtoMessage() {} + +func (x *GetPullRequestDiffResponse) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[25] + 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 GetPullRequestDiffResponse.ProtoReflect.Descriptor instead. +func (*GetPullRequestDiffResponse) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{25} +} + +func (x *GetPullRequestDiffResponse) GetDiff() string { + if x != nil { + return x.Diff + } + return "" +} + +type ListReviewsRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + PullRequest *PullRequestRef `protobuf:"bytes,1,opt,name=pull_request,json=pullRequest,proto3" json:"pull_request,omitempty"` + SinceId int64 `protobuf:"varint,2,opt,name=since_id,json=sinceId,proto3" json:"since_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListReviewsRequest) Reset() { + *x = ListReviewsRequest{} + mi := &file_forge_v1_forge_proto_msgTypes[26] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListReviewsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListReviewsRequest) ProtoMessage() {} + +func (x *ListReviewsRequest) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[26] + 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 ListReviewsRequest.ProtoReflect.Descriptor instead. +func (*ListReviewsRequest) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{26} +} + +func (x *ListReviewsRequest) GetPullRequest() *PullRequestRef { + if x != nil { + return x.PullRequest + } + return nil +} + +func (x *ListReviewsRequest) GetSinceId() int64 { + if x != nil { + return x.SinceId + } + return 0 +} + +type Review struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Author string `protobuf:"bytes,2,opt,name=author,proto3" json:"author,omitempty"` + State string `protobuf:"bytes,3,opt,name=state,proto3" json:"state,omitempty"` + Body string `protobuf:"bytes,4,opt,name=body,proto3" json:"body,omitempty"` + SubmittedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=submitted_at,json=submittedAt,proto3" json:"submitted_at,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Review) Reset() { + *x = Review{} + mi := &file_forge_v1_forge_proto_msgTypes[27] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Review) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Review) ProtoMessage() {} + +func (x *Review) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[27] + 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 Review.ProtoReflect.Descriptor instead. +func (*Review) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{27} +} + +func (x *Review) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *Review) GetAuthor() string { + if x != nil { + return x.Author + } + return "" +} + +func (x *Review) GetState() string { + if x != nil { + return x.State + } + return "" +} + +func (x *Review) GetBody() string { + if x != nil { + return x.Body + } + return "" +} + +func (x *Review) GetSubmittedAt() *timestamppb.Timestamp { + if x != nil { + return x.SubmittedAt + } + return nil +} + +type ListReviewsResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Reviews []*Review `protobuf:"bytes,1,rep,name=reviews,proto3" json:"reviews,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListReviewsResponse) Reset() { + *x = ListReviewsResponse{} + mi := &file_forge_v1_forge_proto_msgTypes[28] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListReviewsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListReviewsResponse) ProtoMessage() {} + +func (x *ListReviewsResponse) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[28] + 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 ListReviewsResponse.ProtoReflect.Descriptor instead. +func (*ListReviewsResponse) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{28} +} + +func (x *ListReviewsResponse) GetReviews() []*Review { + if x != nil { + return x.Reviews + } + return nil +} + +type ReviewComment struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + ReviewId int64 `protobuf:"varint,2,opt,name=review_id,json=reviewId,proto3" json:"review_id,omitempty"` + Author string `protobuf:"bytes,3,opt,name=author,proto3" json:"author,omitempty"` + Body string `protobuf:"bytes,4,opt,name=body,proto3" json:"body,omitempty"` + Path string `protobuf:"bytes,5,opt,name=path,proto3" json:"path,omitempty"` + Line int32 `protobuf:"varint,6,opt,name=line,proto3" json:"line,omitempty"` + InReplyTo int64 `protobuf:"varint,7,opt,name=in_reply_to,json=inReplyTo,proto3" json:"in_reply_to,omitempty"` + CreatedAt *timestamppb.Timestamp `protobuf:"bytes,8,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ReviewComment) Reset() { + *x = ReviewComment{} + mi := &file_forge_v1_forge_proto_msgTypes[29] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ReviewComment) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReviewComment) ProtoMessage() {} + +func (x *ReviewComment) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[29] + 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 ReviewComment.ProtoReflect.Descriptor instead. +func (*ReviewComment) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{29} +} + +func (x *ReviewComment) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *ReviewComment) GetReviewId() int64 { + if x != nil { + return x.ReviewId + } + return 0 +} + +func (x *ReviewComment) GetAuthor() string { + if x != nil { + return x.Author + } + return "" +} + +func (x *ReviewComment) GetBody() string { + if x != nil { + return x.Body + } + return "" +} + +func (x *ReviewComment) GetPath() string { + if x != nil { + return x.Path + } + return "" +} + +func (x *ReviewComment) GetLine() int32 { + if x != nil { + return x.Line + } + return 0 +} + +func (x *ReviewComment) GetInReplyTo() int64 { + if x != nil { + return x.InReplyTo + } + return 0 +} + +func (x *ReviewComment) GetCreatedAt() *timestamppb.Timestamp { + if x != nil { + return x.CreatedAt + } + return nil +} + +type ListReviewCommentsRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + PullRequest *PullRequestRef `protobuf:"bytes,1,opt,name=pull_request,json=pullRequest,proto3" json:"pull_request,omitempty"` + SinceId int64 `protobuf:"varint,2,opt,name=since_id,json=sinceId,proto3" json:"since_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListReviewCommentsRequest) Reset() { + *x = ListReviewCommentsRequest{} + mi := &file_forge_v1_forge_proto_msgTypes[30] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListReviewCommentsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListReviewCommentsRequest) ProtoMessage() {} + +func (x *ListReviewCommentsRequest) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[30] + 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 ListReviewCommentsRequest.ProtoReflect.Descriptor instead. +func (*ListReviewCommentsRequest) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{30} +} + +func (x *ListReviewCommentsRequest) GetPullRequest() *PullRequestRef { + if x != nil { + return x.PullRequest + } + return nil +} + +func (x *ListReviewCommentsRequest) GetSinceId() int64 { + if x != nil { + return x.SinceId + } + return 0 +} + +type ListReviewCommentsResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Comments []*ReviewComment `protobuf:"bytes,1,rep,name=comments,proto3" json:"comments,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListReviewCommentsResponse) Reset() { + *x = ListReviewCommentsResponse{} + mi := &file_forge_v1_forge_proto_msgTypes[31] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListReviewCommentsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListReviewCommentsResponse) ProtoMessage() {} + +func (x *ListReviewCommentsResponse) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[31] + 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 ListReviewCommentsResponse.ProtoReflect.Descriptor instead. +func (*ListReviewCommentsResponse) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{31} +} + +func (x *ListReviewCommentsResponse) GetComments() []*ReviewComment { + if x != nil { + return x.Comments + } + return nil +} + +type ReplyToReviewRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + PullRequest *PullRequestRef `protobuf:"bytes,1,opt,name=pull_request,json=pullRequest,proto3" json:"pull_request,omitempty"` + CommentId int64 `protobuf:"varint,2,opt,name=comment_id,json=commentId,proto3" json:"comment_id,omitempty"` + Body string `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ReplyToReviewRequest) Reset() { + *x = ReplyToReviewRequest{} + mi := &file_forge_v1_forge_proto_msgTypes[32] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ReplyToReviewRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReplyToReviewRequest) ProtoMessage() {} + +func (x *ReplyToReviewRequest) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[32] + 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 ReplyToReviewRequest.ProtoReflect.Descriptor instead. +func (*ReplyToReviewRequest) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{32} +} + +func (x *ReplyToReviewRequest) GetPullRequest() *PullRequestRef { + if x != nil { + return x.PullRequest + } + return nil +} + +func (x *ReplyToReviewRequest) GetCommentId() int64 { + if x != nil { + return x.CommentId + } + return 0 +} + +func (x *ReplyToReviewRequest) GetBody() string { + if x != nil { + return x.Body + } + return "" +} + +type ReplyToReviewResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ReplyToReviewResponse) Reset() { + *x = ReplyToReviewResponse{} + mi := &file_forge_v1_forge_proto_msgTypes[33] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ReplyToReviewResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReplyToReviewResponse) ProtoMessage() {} + +func (x *ReplyToReviewResponse) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[33] + 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 ReplyToReviewResponse.ProtoReflect.Descriptor instead. +func (*ReplyToReviewResponse) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{33} +} + +type InlineReviewComment struct { + state protoimpl.MessageState `protogen:"open.v1"` + Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` + Line int32 `protobuf:"varint,2,opt,name=line,proto3" json:"line,omitempty"` + Body string `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *InlineReviewComment) Reset() { + *x = InlineReviewComment{} + mi := &file_forge_v1_forge_proto_msgTypes[34] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *InlineReviewComment) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*InlineReviewComment) ProtoMessage() {} + +func (x *InlineReviewComment) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[34] + 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 InlineReviewComment.ProtoReflect.Descriptor instead. +func (*InlineReviewComment) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{34} +} + +func (x *InlineReviewComment) GetPath() string { + if x != nil { + return x.Path + } + return "" +} + +func (x *InlineReviewComment) GetLine() int32 { + if x != nil { + return x.Line + } + return 0 +} + +func (x *InlineReviewComment) GetBody() string { + if x != nil { + return x.Body + } + return "" +} + +type CreateReviewCommentsRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + PullRequest *PullRequestRef `protobuf:"bytes,1,opt,name=pull_request,json=pullRequest,proto3" json:"pull_request,omitempty"` + ReviewedHeadSha string `protobuf:"bytes,2,opt,name=reviewed_head_sha,json=reviewedHeadSha,proto3" json:"reviewed_head_sha,omitempty"` + Comments []*InlineReviewComment `protobuf:"bytes,3,rep,name=comments,proto3" json:"comments,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CreateReviewCommentsRequest) Reset() { + *x = CreateReviewCommentsRequest{} + mi := &file_forge_v1_forge_proto_msgTypes[35] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CreateReviewCommentsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateReviewCommentsRequest) ProtoMessage() {} + +func (x *CreateReviewCommentsRequest) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[35] + 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 CreateReviewCommentsRequest.ProtoReflect.Descriptor instead. +func (*CreateReviewCommentsRequest) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{35} +} + +func (x *CreateReviewCommentsRequest) GetPullRequest() *PullRequestRef { + if x != nil { + return x.PullRequest + } + return nil +} + +func (x *CreateReviewCommentsRequest) GetReviewedHeadSha() string { + if x != nil { + return x.ReviewedHeadSha + } + return "" +} + +func (x *CreateReviewCommentsRequest) GetComments() []*InlineReviewComment { + if x != nil { + return x.Comments + } + return nil +} + +type CreateReviewCommentsResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CreateReviewCommentsResponse) Reset() { + *x = CreateReviewCommentsResponse{} + mi := &file_forge_v1_forge_proto_msgTypes[36] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CreateReviewCommentsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateReviewCommentsResponse) ProtoMessage() {} + +func (x *CreateReviewCommentsResponse) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[36] + 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 CreateReviewCommentsResponse.ProtoReflect.Descriptor instead. +func (*CreateReviewCommentsResponse) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{36} +} + +type LinkBranchRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Repo *RepoRef `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"` + IssueNumber int32 `protobuf:"varint,2,opt,name=issue_number,json=issueNumber,proto3" json:"issue_number,omitempty"` + Branch string `protobuf:"bytes,3,opt,name=branch,proto3" json:"branch,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *LinkBranchRequest) Reset() { + *x = LinkBranchRequest{} + mi := &file_forge_v1_forge_proto_msgTypes[37] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *LinkBranchRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LinkBranchRequest) ProtoMessage() {} + +func (x *LinkBranchRequest) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[37] + 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 LinkBranchRequest.ProtoReflect.Descriptor instead. +func (*LinkBranchRequest) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{37} +} + +func (x *LinkBranchRequest) GetRepo() *RepoRef { + if x != nil { + return x.Repo + } + return nil +} + +func (x *LinkBranchRequest) GetIssueNumber() int32 { + if x != nil { + return x.IssueNumber + } + return 0 +} + +func (x *LinkBranchRequest) GetBranch() string { + if x != nil { + return x.Branch + } + return "" +} + +type LinkBranchResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *LinkBranchResponse) Reset() { + *x = LinkBranchResponse{} + mi := &file_forge_v1_forge_proto_msgTypes[38] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *LinkBranchResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LinkBranchResponse) ProtoMessage() {} + +func (x *LinkBranchResponse) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[38] + 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 LinkBranchResponse.ProtoReflect.Descriptor instead. +func (*LinkBranchResponse) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{38} +} + +type AcceptInvitationsRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AcceptInvitationsRequest) Reset() { + *x = AcceptInvitationsRequest{} + mi := &file_forge_v1_forge_proto_msgTypes[39] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AcceptInvitationsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AcceptInvitationsRequest) ProtoMessage() {} + +func (x *AcceptInvitationsRequest) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[39] + 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 AcceptInvitationsRequest.ProtoReflect.Descriptor instead. +func (*AcceptInvitationsRequest) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{39} +} + +type AcceptInvitationsResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AcceptInvitationsResponse) Reset() { + *x = AcceptInvitationsResponse{} + mi := &file_forge_v1_forge_proto_msgTypes[40] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AcceptInvitationsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AcceptInvitationsResponse) ProtoMessage() {} + +func (x *AcceptInvitationsResponse) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[40] + 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 AcceptInvitationsResponse.ProtoReflect.Descriptor instead. +func (*AcceptInvitationsResponse) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{40} +} + +type VerifyPushRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Repo *RepoRef `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *VerifyPushRequest) Reset() { + *x = VerifyPushRequest{} + mi := &file_forge_v1_forge_proto_msgTypes[41] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *VerifyPushRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VerifyPushRequest) ProtoMessage() {} + +func (x *VerifyPushRequest) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[41] + 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 VerifyPushRequest.ProtoReflect.Descriptor instead. +func (*VerifyPushRequest) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{41} +} + +func (x *VerifyPushRequest) GetRepo() *RepoRef { + if x != nil { + return x.Repo + } + return nil +} + +type VerifyPushResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *VerifyPushResponse) Reset() { + *x = VerifyPushResponse{} + mi := &file_forge_v1_forge_proto_msgTypes[42] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *VerifyPushResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VerifyPushResponse) ProtoMessage() {} + +func (x *VerifyPushResponse) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[42] + 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 VerifyPushResponse.ProtoReflect.Descriptor instead. +func (*VerifyPushResponse) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{42} +} + +type GetRepoArchiveRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Repo *RepoRef `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"` + Ref string `protobuf:"bytes,2,opt,name=ref,proto3" json:"ref,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetRepoArchiveRequest) Reset() { + *x = GetRepoArchiveRequest{} + mi := &file_forge_v1_forge_proto_msgTypes[43] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetRepoArchiveRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetRepoArchiveRequest) ProtoMessage() {} + +func (x *GetRepoArchiveRequest) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[43] + 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 GetRepoArchiveRequest.ProtoReflect.Descriptor instead. +func (*GetRepoArchiveRequest) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{43} +} + +func (x *GetRepoArchiveRequest) GetRepo() *RepoRef { + if x != nil { + return x.Repo + } + return nil +} + +func (x *GetRepoArchiveRequest) GetRef() string { + if x != nil { + return x.Ref + } + return "" +} + +type GetRepoArchiveResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetRepoArchiveResponse) Reset() { + *x = GetRepoArchiveResponse{} + mi := &file_forge_v1_forge_proto_msgTypes[44] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetRepoArchiveResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetRepoArchiveResponse) ProtoMessage() {} + +func (x *GetRepoArchiveResponse) ProtoReflect() protoreflect.Message { + mi := &file_forge_v1_forge_proto_msgTypes[44] + 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 GetRepoArchiveResponse.ProtoReflect.Descriptor instead. +func (*GetRepoArchiveResponse) Descriptor() ([]byte, []int) { + return file_forge_v1_forge_proto_rawDescGZIP(), []int{44} +} + +func (x *GetRepoArchiveResponse) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +var File_forge_v1_forge_proto protoreflect.FileDescriptor + +const file_forge_v1_forge_proto_rawDesc = "" + + "\n" + + "\x14forge/v1/forge.proto\x12\bforge.v1\x1a\x1fgoogle/protobuf/timestamp.proto\"\xbf\x01\n" + + "\x10ConfigureRequest\x12\x12\n" + + "\x04host\x18\x01 \x01(\tR\x04host\x12\x14\n" + + "\x05token\x18\x02 \x01(\tR\x05token\x12D\n" + + "\bsettings\x18\x03 \x03(\v2(.forge.v1.ConfigureRequest.SettingsEntryR\bsettings\x1a;\n" + + "\rSettingsEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\x13\n" + + "\x11ConfigureResponse\"3\n" + + "\aRepoRef\x12\x14\n" + + "\x05owner\x18\x01 \x01(\tR\x05owner\x12\x12\n" + + "\x04repo\x18\x02 \x01(\tR\x04repo\"O\n" + + "\x0ePullRequestRef\x12%\n" + + "\x04repo\x18\x01 \x01(\v2\x11.forge.v1.RepoRefR\x04repo\x12\x16\n" + + "\x06number\x18\x02 \x01(\x05R\x06number\"a\n" + + "\x05Issue\x12\x16\n" + + "\x06number\x18\x01 \x01(\x05R\x06number\x12\x14\n" + + "\x05title\x18\x02 \x01(\tR\x05title\x12\x12\n" + + "\x04body\x18\x03 \x01(\tR\x04body\x12\x16\n" + + "\x06labels\x18\x04 \x03(\tR\x06labels\"A\n" + + "\x16AssignedIssuesResponse\x12'\n" + + "\x06issues\x18\x01 \x03(\v2\x0f.forge.v1.IssueR\x06issues\"B\n" + + "\x17IssuesWithLabelResponse\x12'\n" + + "\x06issues\x18\x01 \x03(\v2\x0f.forge.v1.IssueR\x06issues\"Z\n" + + "\x15AssignedIssuesRequest\x12%\n" + + "\x04repo\x18\x01 \x01(\v2\x11.forge.v1.RepoRefR\x04repo\x12\x1a\n" + + "\bassignee\x18\x02 \x01(\tR\bassignee\"U\n" + + "\x16IssuesWithLabelRequest\x12%\n" + + "\x04repo\x18\x01 \x01(\v2\x11.forge.v1.RepoRefR\x04repo\x12\x14\n" + + "\x05label\x18\x02 \x01(\tR\x05label\"c\n" + + "\x0eCommentRequest\x12%\n" + + "\x04repo\x18\x01 \x01(\v2\x11.forge.v1.RepoRefR\x04repo\x12\x16\n" + + "\x06number\x18\x02 \x01(\x05R\x06number\x12\x12\n" + + "\x04body\x18\x03 \x01(\tR\x04body\"!\n" + + "\x0fCommentResponse\x12\x0e\n" + + "\x02id\x18\x01 \x01(\x03R\x02id\"l\n" + + "\x11CloseIssueRequest\x12%\n" + + "\x04repo\x18\x01 \x01(\v2\x11.forge.v1.RepoRefR\x04repo\x12\x16\n" + + "\x06number\x18\x02 \x01(\x05R\x06number\x12\x18\n" + + "\acomment\x18\x03 \x01(\tR\acomment\"\x14\n" + + "\x12CloseIssueResponse\"i\n" + + "\fReactRequest\x12%\n" + + "\x04repo\x18\x01 \x01(\v2\x11.forge.v1.RepoRefR\x04repo\x12\x16\n" + + "\x06number\x18\x02 \x01(\x05R\x06number\x12\x1a\n" + + "\breaction\x18\x03 \x01(\tR\breaction\"\x0f\n" + + "\rReactResponse\"\x8e\x01\n" + + "\x14SetStateLabelRequest\x12%\n" + + "\x04repo\x18\x01 \x01(\v2\x11.forge.v1.RepoRefR\x04repo\x12\x16\n" + + "\x06number\x18\x02 \x01(\x05R\x06number\x12\x14\n" + + "\x05label\x18\x03 \x01(\tR\x05label\x12!\n" + + "\fknown_labels\x18\x04 \x03(\tR\vknownLabels\"\x17\n" + + "\x15SetStateLabelResponse\"\x8a\x01\n" + + "\x0fCreatePRRequest\x12%\n" + + "\x04repo\x18\x01 \x01(\v2\x11.forge.v1.RepoRefR\x04repo\x12\x14\n" + + "\x05title\x18\x02 \x01(\tR\x05title\x12\x12\n" + + "\x04head\x18\x03 \x01(\tR\x04head\x12\x12\n" + + "\x04base\x18\x04 \x01(\tR\x04base\x12\x12\n" + + "\x04body\x18\x05 \x01(\tR\x04body\"*\n" + + "\x10CreatePRResponse\x12\x16\n" + + "\x06number\x18\x01 \x01(\x05R\x06number\"O\n" + + "\x0ePRStateRequest\x12%\n" + + "\x04repo\x18\x01 \x01(\v2\x11.forge.v1.RepoRefR\x04repo\x12\x16\n" + + "\x06number\x18\x02 \x01(\x05R\x06number\"'\n" + + "\x0fPRStateResponse\x12\x14\n" + + "\x05state\x18\x01 \x01(\tR\x05state\"\xd1\x01\n" + + "\vPullRequest\x12\x16\n" + + "\x06number\x18\x01 \x01(\x05R\x06number\x12\x14\n" + + "\x05title\x18\x02 \x01(\tR\x05title\x12\x12\n" + + "\x04body\x18\x03 \x01(\tR\x04body\x12\x19\n" + + "\bhead_ref\x18\x04 \x01(\tR\aheadRef\x12\x19\n" + + "\bbase_ref\x18\x05 \x01(\tR\abaseRef\x12\x19\n" + + "\bhead_sha\x18\x06 \x01(\tR\aheadSha\x12\x19\n" + + "\bbase_sha\x18\a \x01(\tR\abaseSha\x12\x14\n" + + "\x05state\x18\b \x01(\tR\x05state\"V\n" + + "\x15GetPullRequestRequest\x12%\n" + + "\x04repo\x18\x01 \x01(\v2\x11.forge.v1.RepoRefR\x04repo\x12\x16\n" + + "\x06number\x18\x02 \x01(\x05R\x06number\"R\n" + + "\x16GetPullRequestResponse\x128\n" + + "\fpull_request\x18\x01 \x01(\v2\x15.forge.v1.PullRequestR\vpullRequest\"Z\n" + + "\x19GetPullRequestDiffRequest\x12%\n" + + "\x04repo\x18\x01 \x01(\v2\x11.forge.v1.RepoRefR\x04repo\x12\x16\n" + + "\x06number\x18\x02 \x01(\x05R\x06number\"0\n" + + "\x1aGetPullRequestDiffResponse\x12\x12\n" + + "\x04diff\x18\x01 \x01(\tR\x04diff\"l\n" + + "\x12ListReviewsRequest\x12;\n" + + "\fpull_request\x18\x01 \x01(\v2\x18.forge.v1.PullRequestRefR\vpullRequest\x12\x19\n" + + "\bsince_id\x18\x02 \x01(\x03R\asinceId\"\x99\x01\n" + + "\x06Review\x12\x0e\n" + + "\x02id\x18\x01 \x01(\x03R\x02id\x12\x16\n" + + "\x06author\x18\x02 \x01(\tR\x06author\x12\x14\n" + + "\x05state\x18\x03 \x01(\tR\x05state\x12\x12\n" + + "\x04body\x18\x04 \x01(\tR\x04body\x12=\n" + + "\fsubmitted_at\x18\x05 \x01(\v2\x1a.google.protobuf.TimestampR\vsubmittedAt\"A\n" + + "\x13ListReviewsResponse\x12*\n" + + "\areviews\x18\x01 \x03(\v2\x10.forge.v1.ReviewR\areviews\"\xeb\x01\n" + + "\rReviewComment\x12\x0e\n" + + "\x02id\x18\x01 \x01(\x03R\x02id\x12\x1b\n" + + "\treview_id\x18\x02 \x01(\x03R\breviewId\x12\x16\n" + + "\x06author\x18\x03 \x01(\tR\x06author\x12\x12\n" + + "\x04body\x18\x04 \x01(\tR\x04body\x12\x12\n" + + "\x04path\x18\x05 \x01(\tR\x04path\x12\x12\n" + + "\x04line\x18\x06 \x01(\x05R\x04line\x12\x1e\n" + + "\vin_reply_to\x18\a \x01(\x03R\tinReplyTo\x129\n" + + "\n" + + "created_at\x18\b \x01(\v2\x1a.google.protobuf.TimestampR\tcreatedAt\"s\n" + + "\x19ListReviewCommentsRequest\x12;\n" + + "\fpull_request\x18\x01 \x01(\v2\x18.forge.v1.PullRequestRefR\vpullRequest\x12\x19\n" + + "\bsince_id\x18\x02 \x01(\x03R\asinceId\"Q\n" + + "\x1aListReviewCommentsResponse\x123\n" + + "\bcomments\x18\x01 \x03(\v2\x17.forge.v1.ReviewCommentR\bcomments\"\x86\x01\n" + + "\x14ReplyToReviewRequest\x12;\n" + + "\fpull_request\x18\x01 \x01(\v2\x18.forge.v1.PullRequestRefR\vpullRequest\x12\x1d\n" + + "\n" + + "comment_id\x18\x02 \x01(\x03R\tcommentId\x12\x12\n" + + "\x04body\x18\x03 \x01(\tR\x04body\"\x17\n" + + "\x15ReplyToReviewResponse\"Q\n" + + "\x13InlineReviewComment\x12\x12\n" + + "\x04path\x18\x01 \x01(\tR\x04path\x12\x12\n" + + "\x04line\x18\x02 \x01(\x05R\x04line\x12\x12\n" + + "\x04body\x18\x03 \x01(\tR\x04body\"\xc1\x01\n" + + "\x1bCreateReviewCommentsRequest\x12;\n" + + "\fpull_request\x18\x01 \x01(\v2\x18.forge.v1.PullRequestRefR\vpullRequest\x12*\n" + + "\x11reviewed_head_sha\x18\x02 \x01(\tR\x0freviewedHeadSha\x129\n" + + "\bcomments\x18\x03 \x03(\v2\x1d.forge.v1.InlineReviewCommentR\bcomments\"\x1e\n" + + "\x1cCreateReviewCommentsResponse\"u\n" + + "\x11LinkBranchRequest\x12%\n" + + "\x04repo\x18\x01 \x01(\v2\x11.forge.v1.RepoRefR\x04repo\x12!\n" + + "\fissue_number\x18\x02 \x01(\x05R\vissueNumber\x12\x16\n" + + "\x06branch\x18\x03 \x01(\tR\x06branch\"\x14\n" + + "\x12LinkBranchResponse\"\x1a\n" + + "\x18AcceptInvitationsRequest\"\x1b\n" + + "\x19AcceptInvitationsResponse\":\n" + + "\x11VerifyPushRequest\x12%\n" + + "\x04repo\x18\x01 \x01(\v2\x11.forge.v1.RepoRefR\x04repo\"\x14\n" + + "\x12VerifyPushResponse\"P\n" + + "\x15GetRepoArchiveRequest\x12%\n" + + "\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" + + "\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" + + "\x0fIssuesWithLabel\x12 .forge.v1.IssuesWithLabelRequest\x1a!.forge.v1.IssuesWithLabelResponse\x12>\n" + + "\aComment\x12\x18.forge.v1.CommentRequest\x1a\x19.forge.v1.CommentResponse\x12G\n" + + "\n" + + "CloseIssue\x12\x1b.forge.v1.CloseIssueRequest\x1a\x1c.forge.v1.CloseIssueResponse\x128\n" + + "\x05React\x12\x16.forge.v1.ReactRequest\x1a\x17.forge.v1.ReactResponse\x12P\n" + + "\rSetStateLabel\x12\x1e.forge.v1.SetStateLabelRequest\x1a\x1f.forge.v1.SetStateLabelResponse\x12A\n" + + "\bCreatePR\x12\x19.forge.v1.CreatePRRequest\x1a\x1a.forge.v1.CreatePRResponse\x12>\n" + + "\aPRState\x12\x18.forge.v1.PRStateRequest\x1a\x19.forge.v1.PRStateResponse\x12S\n" + + "\x0eGetPullRequest\x12\x1f.forge.v1.GetPullRequestRequest\x1a .forge.v1.GetPullRequestResponse\x12_\n" + + "\x12GetPullRequestDiff\x12#.forge.v1.GetPullRequestDiffRequest\x1a$.forge.v1.GetPullRequestDiffResponse\x12J\n" + + "\vListReviews\x12\x1c.forge.v1.ListReviewsRequest\x1a\x1d.forge.v1.ListReviewsResponse\x12_\n" + + "\x12ListReviewComments\x12#.forge.v1.ListReviewCommentsRequest\x1a$.forge.v1.ListReviewCommentsResponse\x12P\n" + + "\rReplyToReview\x12\x1e.forge.v1.ReplyToReviewRequest\x1a\x1f.forge.v1.ReplyToReviewResponse\x12e\n" + + "\x14CreateReviewComments\x12%.forge.v1.CreateReviewCommentsRequest\x1a&.forge.v1.CreateReviewCommentsResponse\x12\\\n" + + "\x11AcceptInvitations\x12\".forge.v1.AcceptInvitationsRequest\x1a#.forge.v1.AcceptInvitationsResponse\x12G\n" + + "\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" + + "\x0eGetRepoArchive\x12\x1f.forge.v1.GetRepoArchiveRequest\x1a .forge.v1.GetRepoArchiveResponse0\x01B\xa4\x01\n" + + "\fcom.forge.v1B\n" + + "ForgeProtoP\x01ZGgithub.com/samcharles93/archie-core/internal/contracts/forge/v1;forgev1\xa2\x02\x03FXX\xaa\x02\bForge.V1\xca\x02\bForge\\V1\xe2\x02\x14Forge\\V1\\GPBMetadata\xea\x02\tForge::V1b\x06proto3" + +var ( + file_forge_v1_forge_proto_rawDescOnce sync.Once + file_forge_v1_forge_proto_rawDescData []byte +) + +func file_forge_v1_forge_proto_rawDescGZIP() []byte { + file_forge_v1_forge_proto_rawDescOnce.Do(func() { + file_forge_v1_forge_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_forge_v1_forge_proto_rawDesc), len(file_forge_v1_forge_proto_rawDesc))) + }) + return file_forge_v1_forge_proto_rawDescData +} + +var file_forge_v1_forge_proto_msgTypes = make([]protoimpl.MessageInfo, 46) +var file_forge_v1_forge_proto_goTypes = []any{ + (*ConfigureRequest)(nil), // 0: forge.v1.ConfigureRequest + (*ConfigureResponse)(nil), // 1: forge.v1.ConfigureResponse + (*RepoRef)(nil), // 2: forge.v1.RepoRef + (*PullRequestRef)(nil), // 3: forge.v1.PullRequestRef + (*Issue)(nil), // 4: forge.v1.Issue + (*AssignedIssuesResponse)(nil), // 5: forge.v1.AssignedIssuesResponse + (*IssuesWithLabelResponse)(nil), // 6: forge.v1.IssuesWithLabelResponse + (*AssignedIssuesRequest)(nil), // 7: forge.v1.AssignedIssuesRequest + (*IssuesWithLabelRequest)(nil), // 8: forge.v1.IssuesWithLabelRequest + (*CommentRequest)(nil), // 9: forge.v1.CommentRequest + (*CommentResponse)(nil), // 10: forge.v1.CommentResponse + (*CloseIssueRequest)(nil), // 11: forge.v1.CloseIssueRequest + (*CloseIssueResponse)(nil), // 12: forge.v1.CloseIssueResponse + (*ReactRequest)(nil), // 13: forge.v1.ReactRequest + (*ReactResponse)(nil), // 14: forge.v1.ReactResponse + (*SetStateLabelRequest)(nil), // 15: forge.v1.SetStateLabelRequest + (*SetStateLabelResponse)(nil), // 16: forge.v1.SetStateLabelResponse + (*CreatePRRequest)(nil), // 17: forge.v1.CreatePRRequest + (*CreatePRResponse)(nil), // 18: forge.v1.CreatePRResponse + (*PRStateRequest)(nil), // 19: forge.v1.PRStateRequest + (*PRStateResponse)(nil), // 20: forge.v1.PRStateResponse + (*PullRequest)(nil), // 21: forge.v1.PullRequest + (*GetPullRequestRequest)(nil), // 22: forge.v1.GetPullRequestRequest + (*GetPullRequestResponse)(nil), // 23: forge.v1.GetPullRequestResponse + (*GetPullRequestDiffRequest)(nil), // 24: forge.v1.GetPullRequestDiffRequest + (*GetPullRequestDiffResponse)(nil), // 25: forge.v1.GetPullRequestDiffResponse + (*ListReviewsRequest)(nil), // 26: forge.v1.ListReviewsRequest + (*Review)(nil), // 27: forge.v1.Review + (*ListReviewsResponse)(nil), // 28: forge.v1.ListReviewsResponse + (*ReviewComment)(nil), // 29: forge.v1.ReviewComment + (*ListReviewCommentsRequest)(nil), // 30: forge.v1.ListReviewCommentsRequest + (*ListReviewCommentsResponse)(nil), // 31: forge.v1.ListReviewCommentsResponse + (*ReplyToReviewRequest)(nil), // 32: forge.v1.ReplyToReviewRequest + (*ReplyToReviewResponse)(nil), // 33: forge.v1.ReplyToReviewResponse + (*InlineReviewComment)(nil), // 34: forge.v1.InlineReviewComment + (*CreateReviewCommentsRequest)(nil), // 35: forge.v1.CreateReviewCommentsRequest + (*CreateReviewCommentsResponse)(nil), // 36: forge.v1.CreateReviewCommentsResponse + (*LinkBranchRequest)(nil), // 37: forge.v1.LinkBranchRequest + (*LinkBranchResponse)(nil), // 38: forge.v1.LinkBranchResponse + (*AcceptInvitationsRequest)(nil), // 39: forge.v1.AcceptInvitationsRequest + (*AcceptInvitationsResponse)(nil), // 40: forge.v1.AcceptInvitationsResponse + (*VerifyPushRequest)(nil), // 41: forge.v1.VerifyPushRequest + (*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 +} +var file_forge_v1_forge_proto_depIdxs = []int32{ + 45, // 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 + 2, // 4: forge.v1.AssignedIssuesRequest.repo:type_name -> forge.v1.RepoRef + 2, // 5: forge.v1.IssuesWithLabelRequest.repo:type_name -> forge.v1.RepoRef + 2, // 6: forge.v1.CommentRequest.repo:type_name -> forge.v1.RepoRef + 2, // 7: forge.v1.CloseIssueRequest.repo:type_name -> forge.v1.RepoRef + 2, // 8: forge.v1.ReactRequest.repo:type_name -> forge.v1.RepoRef + 2, // 9: forge.v1.SetStateLabelRequest.repo:type_name -> forge.v1.RepoRef + 2, // 10: forge.v1.CreatePRRequest.repo:type_name -> forge.v1.RepoRef + 2, // 11: forge.v1.PRStateRequest.repo:type_name -> forge.v1.RepoRef + 2, // 12: forge.v1.GetPullRequestRequest.repo:type_name -> forge.v1.RepoRef + 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 + 27, // 17: forge.v1.ListReviewsResponse.reviews:type_name -> forge.v1.Review + 46, // 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 + 3, // 22: forge.v1.CreateReviewCommentsRequest.pull_request:type_name -> forge.v1.PullRequestRef + 34, // 23: forge.v1.CreateReviewCommentsRequest.comments:type_name -> forge.v1.InlineReviewComment + 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 +} + +func init() { file_forge_v1_forge_proto_init() } +func file_forge_v1_forge_proto_init() { + if File_forge_v1_forge_proto != nil { + return + } + 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, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_forge_v1_forge_proto_goTypes, + DependencyIndexes: file_forge_v1_forge_proto_depIdxs, + MessageInfos: file_forge_v1_forge_proto_msgTypes, + }.Build() + File_forge_v1_forge_proto = out.File + file_forge_v1_forge_proto_goTypes = nil + file_forge_v1_forge_proto_depIdxs = nil +} diff --git a/internal/contracts/forge/v1/forge_grpc.pb.go b/internal/contracts/forge/v1/forge_grpc.pb.go new file mode 100644 index 000000000..1418171c6 --- /dev/null +++ b/internal/contracts/forge/v1/forge_grpc.pb.go @@ -0,0 +1,829 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.6.2 +// - protoc (unknown) +// source: forge/v1/forge.proto + +package forgev1 + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 + +const ( + ForgeService_Configure_FullMethodName = "/forge.v1.ForgeService/Configure" + ForgeService_AssignedIssues_FullMethodName = "/forge.v1.ForgeService/AssignedIssues" + ForgeService_IssuesWithLabel_FullMethodName = "/forge.v1.ForgeService/IssuesWithLabel" + ForgeService_Comment_FullMethodName = "/forge.v1.ForgeService/Comment" + ForgeService_CloseIssue_FullMethodName = "/forge.v1.ForgeService/CloseIssue" + ForgeService_React_FullMethodName = "/forge.v1.ForgeService/React" + ForgeService_SetStateLabel_FullMethodName = "/forge.v1.ForgeService/SetStateLabel" + ForgeService_CreatePR_FullMethodName = "/forge.v1.ForgeService/CreatePR" + ForgeService_PRState_FullMethodName = "/forge.v1.ForgeService/PRState" + ForgeService_GetPullRequest_FullMethodName = "/forge.v1.ForgeService/GetPullRequest" + ForgeService_GetPullRequestDiff_FullMethodName = "/forge.v1.ForgeService/GetPullRequestDiff" + ForgeService_ListReviews_FullMethodName = "/forge.v1.ForgeService/ListReviews" + ForgeService_ListReviewComments_FullMethodName = "/forge.v1.ForgeService/ListReviewComments" + ForgeService_ReplyToReview_FullMethodName = "/forge.v1.ForgeService/ReplyToReview" + ForgeService_CreateReviewComments_FullMethodName = "/forge.v1.ForgeService/CreateReviewComments" + ForgeService_AcceptInvitations_FullMethodName = "/forge.v1.ForgeService/AcceptInvitations" + ForgeService_VerifyPush_FullMethodName = "/forge.v1.ForgeService/VerifyPush" + ForgeService_LinkBranch_FullMethodName = "/forge.v1.ForgeService/LinkBranch" + ForgeService_GetRepoArchive_FullMethodName = "/forge.v1.ForgeService/GetRepoArchive" +) + +// ForgeServiceClient is the client API for ForgeService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +// +// ForgeService is the surface a forge extension serves. The host launches one +// plugin process per configured forge instance and routes every issue, pull +// request and repository call of that instance through it. The calls follow +// the host's forge interfaces; a capability the forge lacks answers +// UNIMPLEMENTED. +type ForgeServiceClient interface { + // Configure hands the plugin its instance once, right after launch and + // before any other call. The token is the instance's resolved credential; + // the plugin process does not inherit the host environment. + Configure(ctx context.Context, in *ConfigureRequest, opts ...grpc.CallOption) (*ConfigureResponse, error) + AssignedIssues(ctx context.Context, in *AssignedIssuesRequest, opts ...grpc.CallOption) (*AssignedIssuesResponse, error) + IssuesWithLabel(ctx context.Context, in *IssuesWithLabelRequest, opts ...grpc.CallOption) (*IssuesWithLabelResponse, error) + Comment(ctx context.Context, in *CommentRequest, opts ...grpc.CallOption) (*CommentResponse, error) + CloseIssue(ctx context.Context, in *CloseIssueRequest, opts ...grpc.CallOption) (*CloseIssueResponse, error) + React(ctx context.Context, in *ReactRequest, opts ...grpc.CallOption) (*ReactResponse, error) + SetStateLabel(ctx context.Context, in *SetStateLabelRequest, opts ...grpc.CallOption) (*SetStateLabelResponse, error) + CreatePR(ctx context.Context, in *CreatePRRequest, opts ...grpc.CallOption) (*CreatePRResponse, error) + PRState(ctx context.Context, in *PRStateRequest, opts ...grpc.CallOption) (*PRStateResponse, error) + GetPullRequest(ctx context.Context, in *GetPullRequestRequest, opts ...grpc.CallOption) (*GetPullRequestResponse, error) + GetPullRequestDiff(ctx context.Context, in *GetPullRequestDiffRequest, opts ...grpc.CallOption) (*GetPullRequestDiffResponse, error) + ListReviews(ctx context.Context, in *ListReviewsRequest, opts ...grpc.CallOption) (*ListReviewsResponse, error) + ListReviewComments(ctx context.Context, in *ListReviewCommentsRequest, opts ...grpc.CallOption) (*ListReviewCommentsResponse, error) + ReplyToReview(ctx context.Context, in *ReplyToReviewRequest, opts ...grpc.CallOption) (*ReplyToReviewResponse, error) + CreateReviewComments(ctx context.Context, in *CreateReviewCommentsRequest, opts ...grpc.CallOption) (*CreateReviewCommentsResponse, error) + 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) + // GetRepoArchive streams a gzipped tar of the repository at a ref. + GetRepoArchive(ctx context.Context, in *GetRepoArchiveRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[GetRepoArchiveResponse], error) +} + +type forgeServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewForgeServiceClient(cc grpc.ClientConnInterface) ForgeServiceClient { + return &forgeServiceClient{cc} +} + +func (c *forgeServiceClient) Configure(ctx context.Context, in *ConfigureRequest, opts ...grpc.CallOption) (*ConfigureResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ConfigureResponse) + err := c.cc.Invoke(ctx, ForgeService_Configure_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *forgeServiceClient) AssignedIssues(ctx context.Context, in *AssignedIssuesRequest, opts ...grpc.CallOption) (*AssignedIssuesResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(AssignedIssuesResponse) + err := c.cc.Invoke(ctx, ForgeService_AssignedIssues_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *forgeServiceClient) IssuesWithLabel(ctx context.Context, in *IssuesWithLabelRequest, opts ...grpc.CallOption) (*IssuesWithLabelResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(IssuesWithLabelResponse) + err := c.cc.Invoke(ctx, ForgeService_IssuesWithLabel_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *forgeServiceClient) Comment(ctx context.Context, in *CommentRequest, opts ...grpc.CallOption) (*CommentResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(CommentResponse) + err := c.cc.Invoke(ctx, ForgeService_Comment_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *forgeServiceClient) CloseIssue(ctx context.Context, in *CloseIssueRequest, opts ...grpc.CallOption) (*CloseIssueResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(CloseIssueResponse) + err := c.cc.Invoke(ctx, ForgeService_CloseIssue_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *forgeServiceClient) React(ctx context.Context, in *ReactRequest, opts ...grpc.CallOption) (*ReactResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ReactResponse) + err := c.cc.Invoke(ctx, ForgeService_React_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *forgeServiceClient) SetStateLabel(ctx context.Context, in *SetStateLabelRequest, opts ...grpc.CallOption) (*SetStateLabelResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(SetStateLabelResponse) + err := c.cc.Invoke(ctx, ForgeService_SetStateLabel_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *forgeServiceClient) CreatePR(ctx context.Context, in *CreatePRRequest, opts ...grpc.CallOption) (*CreatePRResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(CreatePRResponse) + err := c.cc.Invoke(ctx, ForgeService_CreatePR_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *forgeServiceClient) PRState(ctx context.Context, in *PRStateRequest, opts ...grpc.CallOption) (*PRStateResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(PRStateResponse) + err := c.cc.Invoke(ctx, ForgeService_PRState_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *forgeServiceClient) GetPullRequest(ctx context.Context, in *GetPullRequestRequest, opts ...grpc.CallOption) (*GetPullRequestResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetPullRequestResponse) + err := c.cc.Invoke(ctx, ForgeService_GetPullRequest_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *forgeServiceClient) GetPullRequestDiff(ctx context.Context, in *GetPullRequestDiffRequest, opts ...grpc.CallOption) (*GetPullRequestDiffResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetPullRequestDiffResponse) + err := c.cc.Invoke(ctx, ForgeService_GetPullRequestDiff_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *forgeServiceClient) ListReviews(ctx context.Context, in *ListReviewsRequest, opts ...grpc.CallOption) (*ListReviewsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ListReviewsResponse) + err := c.cc.Invoke(ctx, ForgeService_ListReviews_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *forgeServiceClient) ListReviewComments(ctx context.Context, in *ListReviewCommentsRequest, opts ...grpc.CallOption) (*ListReviewCommentsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ListReviewCommentsResponse) + err := c.cc.Invoke(ctx, ForgeService_ListReviewComments_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *forgeServiceClient) ReplyToReview(ctx context.Context, in *ReplyToReviewRequest, opts ...grpc.CallOption) (*ReplyToReviewResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ReplyToReviewResponse) + err := c.cc.Invoke(ctx, ForgeService_ReplyToReview_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *forgeServiceClient) CreateReviewComments(ctx context.Context, in *CreateReviewCommentsRequest, opts ...grpc.CallOption) (*CreateReviewCommentsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(CreateReviewCommentsResponse) + err := c.cc.Invoke(ctx, ForgeService_CreateReviewComments_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *forgeServiceClient) AcceptInvitations(ctx context.Context, in *AcceptInvitationsRequest, opts ...grpc.CallOption) (*AcceptInvitationsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(AcceptInvitationsResponse) + err := c.cc.Invoke(ctx, ForgeService_AcceptInvitations_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *forgeServiceClient) VerifyPush(ctx context.Context, in *VerifyPushRequest, opts ...grpc.CallOption) (*VerifyPushResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(VerifyPushResponse) + err := c.cc.Invoke(ctx, ForgeService_VerifyPush_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *forgeServiceClient) LinkBranch(ctx context.Context, in *LinkBranchRequest, opts ...grpc.CallOption) (*LinkBranchResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(LinkBranchResponse) + err := c.cc.Invoke(ctx, ForgeService_LinkBranch_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...) + if err != nil { + return nil, err + } + x := &grpc.GenericClientStream[GetRepoArchiveRequest, GetRepoArchiveResponse]{ClientStream: stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type ForgeService_GetRepoArchiveClient = grpc.ServerStreamingClient[GetRepoArchiveResponse] + +// ForgeServiceServer is the server API for ForgeService service. +// All implementations must embed UnimplementedForgeServiceServer +// for forward compatibility. +// +// ForgeService is the surface a forge extension serves. The host launches one +// plugin process per configured forge instance and routes every issue, pull +// request and repository call of that instance through it. The calls follow +// the host's forge interfaces; a capability the forge lacks answers +// UNIMPLEMENTED. +type ForgeServiceServer interface { + // Configure hands the plugin its instance once, right after launch and + // before any other call. The token is the instance's resolved credential; + // the plugin process does not inherit the host environment. + Configure(context.Context, *ConfigureRequest) (*ConfigureResponse, error) + AssignedIssues(context.Context, *AssignedIssuesRequest) (*AssignedIssuesResponse, error) + IssuesWithLabel(context.Context, *IssuesWithLabelRequest) (*IssuesWithLabelResponse, error) + Comment(context.Context, *CommentRequest) (*CommentResponse, error) + CloseIssue(context.Context, *CloseIssueRequest) (*CloseIssueResponse, error) + React(context.Context, *ReactRequest) (*ReactResponse, error) + SetStateLabel(context.Context, *SetStateLabelRequest) (*SetStateLabelResponse, error) + CreatePR(context.Context, *CreatePRRequest) (*CreatePRResponse, error) + PRState(context.Context, *PRStateRequest) (*PRStateResponse, error) + GetPullRequest(context.Context, *GetPullRequestRequest) (*GetPullRequestResponse, error) + GetPullRequestDiff(context.Context, *GetPullRequestDiffRequest) (*GetPullRequestDiffResponse, error) + ListReviews(context.Context, *ListReviewsRequest) (*ListReviewsResponse, error) + ListReviewComments(context.Context, *ListReviewCommentsRequest) (*ListReviewCommentsResponse, error) + ReplyToReview(context.Context, *ReplyToReviewRequest) (*ReplyToReviewResponse, error) + CreateReviewComments(context.Context, *CreateReviewCommentsRequest) (*CreateReviewCommentsResponse, error) + AcceptInvitations(context.Context, *AcceptInvitationsRequest) (*AcceptInvitationsResponse, error) + VerifyPush(context.Context, *VerifyPushRequest) (*VerifyPushResponse, error) + LinkBranch(context.Context, *LinkBranchRequest) (*LinkBranchResponse, error) + // GetRepoArchive streams a gzipped tar of the repository at a ref. + GetRepoArchive(*GetRepoArchiveRequest, grpc.ServerStreamingServer[GetRepoArchiveResponse]) error + mustEmbedUnimplementedForgeServiceServer() +} + +// UnimplementedForgeServiceServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedForgeServiceServer struct{} + +func (UnimplementedForgeServiceServer) Configure(context.Context, *ConfigureRequest) (*ConfigureResponse, error) { + return nil, status.Error(codes.Unimplemented, "method Configure not implemented") +} +func (UnimplementedForgeServiceServer) AssignedIssues(context.Context, *AssignedIssuesRequest) (*AssignedIssuesResponse, error) { + return nil, status.Error(codes.Unimplemented, "method AssignedIssues not implemented") +} +func (UnimplementedForgeServiceServer) IssuesWithLabel(context.Context, *IssuesWithLabelRequest) (*IssuesWithLabelResponse, error) { + return nil, status.Error(codes.Unimplemented, "method IssuesWithLabel not implemented") +} +func (UnimplementedForgeServiceServer) Comment(context.Context, *CommentRequest) (*CommentResponse, error) { + return nil, status.Error(codes.Unimplemented, "method Comment not implemented") +} +func (UnimplementedForgeServiceServer) CloseIssue(context.Context, *CloseIssueRequest) (*CloseIssueResponse, error) { + return nil, status.Error(codes.Unimplemented, "method CloseIssue not implemented") +} +func (UnimplementedForgeServiceServer) React(context.Context, *ReactRequest) (*ReactResponse, error) { + return nil, status.Error(codes.Unimplemented, "method React not implemented") +} +func (UnimplementedForgeServiceServer) SetStateLabel(context.Context, *SetStateLabelRequest) (*SetStateLabelResponse, error) { + return nil, status.Error(codes.Unimplemented, "method SetStateLabel not implemented") +} +func (UnimplementedForgeServiceServer) CreatePR(context.Context, *CreatePRRequest) (*CreatePRResponse, error) { + return nil, status.Error(codes.Unimplemented, "method CreatePR not implemented") +} +func (UnimplementedForgeServiceServer) PRState(context.Context, *PRStateRequest) (*PRStateResponse, error) { + return nil, status.Error(codes.Unimplemented, "method PRState not implemented") +} +func (UnimplementedForgeServiceServer) GetPullRequest(context.Context, *GetPullRequestRequest) (*GetPullRequestResponse, error) { + return nil, status.Error(codes.Unimplemented, "method GetPullRequest not implemented") +} +func (UnimplementedForgeServiceServer) GetPullRequestDiff(context.Context, *GetPullRequestDiffRequest) (*GetPullRequestDiffResponse, error) { + return nil, status.Error(codes.Unimplemented, "method GetPullRequestDiff not implemented") +} +func (UnimplementedForgeServiceServer) ListReviews(context.Context, *ListReviewsRequest) (*ListReviewsResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ListReviews not implemented") +} +func (UnimplementedForgeServiceServer) ListReviewComments(context.Context, *ListReviewCommentsRequest) (*ListReviewCommentsResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ListReviewComments not implemented") +} +func (UnimplementedForgeServiceServer) ReplyToReview(context.Context, *ReplyToReviewRequest) (*ReplyToReviewResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ReplyToReview not implemented") +} +func (UnimplementedForgeServiceServer) CreateReviewComments(context.Context, *CreateReviewCommentsRequest) (*CreateReviewCommentsResponse, error) { + return nil, status.Error(codes.Unimplemented, "method CreateReviewComments not implemented") +} +func (UnimplementedForgeServiceServer) AcceptInvitations(context.Context, *AcceptInvitationsRequest) (*AcceptInvitationsResponse, error) { + return nil, status.Error(codes.Unimplemented, "method AcceptInvitations not implemented") +} +func (UnimplementedForgeServiceServer) VerifyPush(context.Context, *VerifyPushRequest) (*VerifyPushResponse, error) { + return nil, status.Error(codes.Unimplemented, "method VerifyPush not implemented") +} +func (UnimplementedForgeServiceServer) LinkBranch(context.Context, *LinkBranchRequest) (*LinkBranchResponse, error) { + return nil, status.Error(codes.Unimplemented, "method LinkBranch not implemented") +} +func (UnimplementedForgeServiceServer) GetRepoArchive(*GetRepoArchiveRequest, grpc.ServerStreamingServer[GetRepoArchiveResponse]) error { + return status.Error(codes.Unimplemented, "method GetRepoArchive not implemented") +} +func (UnimplementedForgeServiceServer) mustEmbedUnimplementedForgeServiceServer() {} +func (UnimplementedForgeServiceServer) testEmbeddedByValue() {} + +// UnsafeForgeServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to ForgeServiceServer will +// result in compilation errors. +type UnsafeForgeServiceServer interface { + mustEmbedUnimplementedForgeServiceServer() +} + +func RegisterForgeServiceServer(s grpc.ServiceRegistrar, srv ForgeServiceServer) { + // If the following call panics, it indicates UnimplementedForgeServiceServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } + s.RegisterService(&ForgeService_ServiceDesc, srv) +} + +func _ForgeService_Configure_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ConfigureRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ForgeServiceServer).Configure(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ForgeService_Configure_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ForgeServiceServer).Configure(ctx, req.(*ConfigureRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ForgeService_AssignedIssues_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AssignedIssuesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ForgeServiceServer).AssignedIssues(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ForgeService_AssignedIssues_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ForgeServiceServer).AssignedIssues(ctx, req.(*AssignedIssuesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ForgeService_IssuesWithLabel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(IssuesWithLabelRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ForgeServiceServer).IssuesWithLabel(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ForgeService_IssuesWithLabel_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ForgeServiceServer).IssuesWithLabel(ctx, req.(*IssuesWithLabelRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ForgeService_Comment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CommentRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ForgeServiceServer).Comment(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ForgeService_Comment_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ForgeServiceServer).Comment(ctx, req.(*CommentRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ForgeService_CloseIssue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CloseIssueRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ForgeServiceServer).CloseIssue(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ForgeService_CloseIssue_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ForgeServiceServer).CloseIssue(ctx, req.(*CloseIssueRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ForgeService_React_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ReactRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ForgeServiceServer).React(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ForgeService_React_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ForgeServiceServer).React(ctx, req.(*ReactRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ForgeService_SetStateLabel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SetStateLabelRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ForgeServiceServer).SetStateLabel(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ForgeService_SetStateLabel_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ForgeServiceServer).SetStateLabel(ctx, req.(*SetStateLabelRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ForgeService_CreatePR_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CreatePRRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ForgeServiceServer).CreatePR(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ForgeService_CreatePR_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ForgeServiceServer).CreatePR(ctx, req.(*CreatePRRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ForgeService_PRState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PRStateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ForgeServiceServer).PRState(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ForgeService_PRState_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ForgeServiceServer).PRState(ctx, req.(*PRStateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ForgeService_GetPullRequest_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetPullRequestRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ForgeServiceServer).GetPullRequest(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ForgeService_GetPullRequest_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ForgeServiceServer).GetPullRequest(ctx, req.(*GetPullRequestRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ForgeService_GetPullRequestDiff_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetPullRequestDiffRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ForgeServiceServer).GetPullRequestDiff(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ForgeService_GetPullRequestDiff_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ForgeServiceServer).GetPullRequestDiff(ctx, req.(*GetPullRequestDiffRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ForgeService_ListReviews_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListReviewsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ForgeServiceServer).ListReviews(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ForgeService_ListReviews_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ForgeServiceServer).ListReviews(ctx, req.(*ListReviewsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ForgeService_ListReviewComments_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListReviewCommentsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ForgeServiceServer).ListReviewComments(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ForgeService_ListReviewComments_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ForgeServiceServer).ListReviewComments(ctx, req.(*ListReviewCommentsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ForgeService_ReplyToReview_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ReplyToReviewRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ForgeServiceServer).ReplyToReview(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ForgeService_ReplyToReview_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ForgeServiceServer).ReplyToReview(ctx, req.(*ReplyToReviewRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ForgeService_CreateReviewComments_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CreateReviewCommentsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ForgeServiceServer).CreateReviewComments(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ForgeService_CreateReviewComments_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ForgeServiceServer).CreateReviewComments(ctx, req.(*CreateReviewCommentsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ForgeService_AcceptInvitations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AcceptInvitationsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ForgeServiceServer).AcceptInvitations(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ForgeService_AcceptInvitations_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ForgeServiceServer).AcceptInvitations(ctx, req.(*AcceptInvitationsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ForgeService_VerifyPush_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(VerifyPushRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ForgeServiceServer).VerifyPush(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ForgeService_VerifyPush_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ForgeServiceServer).VerifyPush(ctx, req.(*VerifyPushRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ForgeService_LinkBranch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(LinkBranchRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ForgeServiceServer).LinkBranch(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: ForgeService_LinkBranch_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ForgeServiceServer).LinkBranch(ctx, req.(*LinkBranchRequest)) + } + 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 { + return err + } + return srv.(ForgeServiceServer).GetRepoArchive(m, &grpc.GenericServerStream[GetRepoArchiveRequest, GetRepoArchiveResponse]{ServerStream: stream}) +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type ForgeService_GetRepoArchiveServer = grpc.ServerStreamingServer[GetRepoArchiveResponse] + +// ForgeService_ServiceDesc is the grpc.ServiceDesc for ForgeService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var ForgeService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "forge.v1.ForgeService", + HandlerType: (*ForgeServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Configure", + Handler: _ForgeService_Configure_Handler, + }, + { + MethodName: "AssignedIssues", + Handler: _ForgeService_AssignedIssues_Handler, + }, + { + MethodName: "IssuesWithLabel", + Handler: _ForgeService_IssuesWithLabel_Handler, + }, + { + MethodName: "Comment", + Handler: _ForgeService_Comment_Handler, + }, + { + MethodName: "CloseIssue", + Handler: _ForgeService_CloseIssue_Handler, + }, + { + MethodName: "React", + Handler: _ForgeService_React_Handler, + }, + { + MethodName: "SetStateLabel", + Handler: _ForgeService_SetStateLabel_Handler, + }, + { + MethodName: "CreatePR", + Handler: _ForgeService_CreatePR_Handler, + }, + { + MethodName: "PRState", + Handler: _ForgeService_PRState_Handler, + }, + { + MethodName: "GetPullRequest", + Handler: _ForgeService_GetPullRequest_Handler, + }, + { + MethodName: "GetPullRequestDiff", + Handler: _ForgeService_GetPullRequestDiff_Handler, + }, + { + MethodName: "ListReviews", + Handler: _ForgeService_ListReviews_Handler, + }, + { + MethodName: "ListReviewComments", + Handler: _ForgeService_ListReviewComments_Handler, + }, + { + MethodName: "ReplyToReview", + Handler: _ForgeService_ReplyToReview_Handler, + }, + { + MethodName: "CreateReviewComments", + Handler: _ForgeService_CreateReviewComments_Handler, + }, + { + MethodName: "AcceptInvitations", + Handler: _ForgeService_AcceptInvitations_Handler, + }, + { + MethodName: "VerifyPush", + Handler: _ForgeService_VerifyPush_Handler, + }, + { + MethodName: "LinkBranch", + Handler: _ForgeService_LinkBranch_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "GetRepoArchive", + Handler: _ForgeService_GetRepoArchive_Handler, + ServerStreams: true, + }, + }, + Metadata: "forge/v1/forge.proto", +} diff --git a/internal/domain/storepkg/descriptor.go b/internal/domain/storepkg/descriptor.go index 42ba1be24..9f2b98bb5 100644 --- a/internal/domain/storepkg/descriptor.go +++ b/internal/domain/storepkg/descriptor.go @@ -51,9 +51,14 @@ type Extension struct { } // Surfaces are the extension surfaces the host defines a contract for. -const SurfaceSecretEngine = "secretengine" +const ( + SurfaceSecretEngine = "secretengine" + SurfaceForge = "forge" +) -func validSurface(surface string) bool { return surface == SurfaceSecretEngine } +func validSurface(surface string) bool { + return surface == SurfaceSecretEngine || surface == SurfaceForge +} // PackageRef identifies a required package or Kit. References are pinned to // immutable content digests so dependency resolution cannot drift by tag. diff --git a/internal/domain/storepkg/descriptor_test.go b/internal/domain/storepkg/descriptor_test.go index b5344a0de..978f94fd6 100644 --- a/internal/domain/storepkg/descriptor_test.go +++ b/internal/domain/storepkg/descriptor_test.go @@ -37,7 +37,7 @@ func TestDescriptorExecutableOnlyForExtensions(t *testing.T) { d.Contributes.Extensions[0].Path = "bin/other" }, wantErr: "not a declared package file"}, {name: "an unknown surface is refused", mutate: func(d *Descriptor) { - d.Contributes.Extensions[0].Surface = "forge" + d.Contributes.Extensions[0].Surface = "issue-tracker" }, wantErr: "unknown surface"}, } for _, tt := range tests { diff --git a/internal/infrastructure/configuration/validate.go b/internal/infrastructure/configuration/validate.go index a78228c8b..08812fc2c 100644 --- a/internal/infrastructure/configuration/validate.go +++ b/internal/infrastructure/configuration/validate.go @@ -4,6 +4,7 @@ import ( "fmt" "net/url" "path/filepath" + "regexp" "slices" "strings" @@ -30,8 +31,11 @@ const ( memoryEngineBuiltin = "builtin" ) +// forgeTypePattern is a package name: forge.type names the installed forge +// package that serves the instance, or disables the forge. +var forgeTypePattern = regexp.MustCompile(`^[a-z0-9][a-z0-9-]*$`) + var ( - forgeTypes = []string{forgeTypeGitHub, forgeTypeGitea, forgeTypeNone, forgeTypeOff, forgeTypeDisabled} dispatchTriggers = []string{dispatchTriggerAssignee, dispatchTriggerLabel, dispatchTriggerEither} natsModes = []string{config.NATSModeEmbedded, config.NATSModeExternal} forgeIntakes = []string{config.ForgeIntakePoll, config.ForgeIntakeWebhook, config.ForgeIntakeBoth} @@ -264,8 +268,8 @@ func validateIdentities(identities []config.IdentityConfig) error { if len(id.Repos) == 0 { return fmt.Errorf("%w: identities[%d] has no [[identities.repos]] entries -- at least one is required", ErrInvalidInput, i) } - if !oneOf(id.Forge.Type, forgeTypes) { - return fmt.Errorf("%w: identities[%d].forge.type %q (want %s)", ErrInvalidInput, i, id.Forge.Type, list(forgeTypes)) + if !forgeTypePattern.MatchString(id.Forge.Type) { + return fmt.Errorf("%w: identities[%d].forge.type %q (want none or the name of an installed forge package)", ErrInvalidInput, i, id.Forge.Type) } if !ForgeDisabled(id.Forge.Type) && id.Forge.Token == (config.SecretRef{}) { return fmt.Errorf("%w: identities[%d].forge.token is required (each identity needs its own secret reference; unlike the top-level [forge], there is no default)", ErrInvalidInput, i) @@ -286,8 +290,8 @@ func validateSingleIdentity(cfg *config.Config) error { if !identity.ValidDisplayName(cfg.BotUser) { return fmt.Errorf("%w: bot_user is required (or define [[identities]])", ErrInvalidInput) } - if !oneOf(cfg.Forge.Type, forgeTypes) { - return fmt.Errorf("%w: forge.type %q (want %s)", ErrInvalidInput, cfg.Forge.Type, list(forgeTypes)) + if !forgeTypePattern.MatchString(cfg.Forge.Type) { + return fmt.Errorf("%w: forge.type %q (want none or the name of an installed forge package)", ErrInvalidInput, cfg.Forge.Type) } return nil } diff --git a/internal/infrastructure/extension/source.go b/internal/infrastructure/extension/source.go new file mode 100644 index 000000000..252d5dccb --- /dev/null +++ b/internal/infrastructure/extension/source.go @@ -0,0 +1,99 @@ +package extension + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "encoding/json" + "fmt" + "os" + "path" + "path/filepath" + + "github.com/samcharles93/archie-core/internal/domain/storepkg" + "github.com/samcharles93/archie-core/internal/infrastructure/controlplanerpc" +) + +// OrgID is the single-operator install's org, the one packages are installed in. +const OrgID = "default" + +// Packages reads installed packages, as *staterpc.Client does. +type Packages interface { + ListInstalled(ctx context.Context, orgID string) ([]storepkg.Installed, error) + GetInstalled(ctx context.Context, orgID, name string) (storepkg.Installed, error) +} + +// Source is what an extension supervisor reads: the extension-settings +// resource and the installed packages. +type Source struct { + // Query reads a control-plane resource, as *controlplanerpc.Client does. + Query controlplanerpc.ResourceReader + Packages Packages +} + +// Enabled reads the extension-settings resource, keyed by extension name, and +// its version. +func (s Source) Enabled(ctx context.Context) (map[string]controlplanerpc.ExtensionSetting, int64, error) { + byName := make(map[string]controlplanerpc.ExtensionSetting) + version, _, err := s.Query.Query(ctx, controlplanerpc.ExtensionSettingsKind, func(value []byte) error { + var doc controlplanerpc.ExtensionSettings + if err := json.Unmarshal(value, &doc); err != nil { + return err + } + for _, setting := range doc.Extensions { + byName[setting.Name] = setting + } + return nil + }) + if err != nil { + return nil, 0, fmt.Errorf("read extension settings: %w", err) + } + return byName, version, nil +} + +// Materialize writes the package's extension binary under cacheDir, keyed by +// package digest, and returns its path and sha256. A binary already there for +// this digest is reused. +func Materialize(ctx context.Context, packages Packages, cacheDir string, pkg storepkg.Installed, file string) (string, string, error) { + full, err := packages.GetInstalled(ctx, OrgID, pkg.Name) + if err != nil { + return "", "", fmt.Errorf("get installed package: %w", err) + } + files, err := storepkg.FilesFromLayer(full.Layer) + if err != nil { + return "", "", err + } + content, ok := files[file] + if !ok { + return "", "", fmt.Errorf("package layer has no %q", file) + } + sum := sha256.Sum256(content) + dir := filepath.Join(cacheDir, pkg.Name, hex.EncodeToString(sum[:8])) + target := filepath.Join(dir, path.Base(file)) + if existing, err := os.ReadFile(target); err == nil && sha256.Sum256(existing) == sum { + return target, hex.EncodeToString(sum[:]), nil + } + if err := os.MkdirAll(dir, 0o700); err != nil { + return "", "", err + } + tmp, err := os.CreateTemp(dir, ".extract-*") + if err != nil { + return "", "", err + } + defer func() { _ = os.Remove(tmp.Name()) }() + if _, err := tmp.Write(content); err != nil { + _ = tmp.Close() + return "", "", err + } + if err := tmp.Chmod(0o700); err != nil { + _ = tmp.Close() + return "", "", err + } + if err := tmp.Close(); err != nil { + return "", "", err + } + if err := os.Rename(tmp.Name(), target); err != nil { + return "", "", err + } + return target, hex.EncodeToString(sum[:]), nil +} diff --git a/internal/infrastructure/forgeext/forgeext.go b/internal/infrastructure/forgeext/forgeext.go new file mode 100644 index 000000000..3b596feb7 --- /dev/null +++ b/internal/infrastructure/forgeext/forgeext.go @@ -0,0 +1,350 @@ +// Package forgeext adapts a forge extension, served over the forge.v1 gRPC +// surface, to the host's forge.Forge. One extension process serves one +// configured forge instance. +package forgeext + +import ( + "context" + "errors" + "fmt" + "io" + "log/slog" + "sync" + + goplugin "github.com/hashicorp/go-plugin" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + forgev1 "github.com/samcharles93/archie-core/internal/contracts/forge/v1" + "github.com/samcharles93/archie-core/internal/forge" + "github.com/samcharles93/archie-core/internal/infrastructure/extension" +) + +// Surface is the go-plugin surface name a forge binary serves. +const Surface = "forge" + +// Plugin is the go-plugin shim for the surface. Impl is set only by a forge +// binary serving it. +type Plugin struct { + goplugin.NetRPCUnsupportedPlugin + Impl forgev1.ForgeServiceServer +} + +func (p *Plugin) GRPCServer(_ *goplugin.GRPCBroker, s *grpc.Server) error { + forgev1.RegisterForgeServiceServer(s, p.Impl) + return nil +} + +func (*Plugin) GRPCClient(_ context.Context, _ *goplugin.GRPCBroker, c *grpc.ClientConn) (any, error) { + return forgev1.NewForgeServiceClient(c), nil +} + +// Instance is one forge to run: the plugin binary and what Configure hands it. +type Instance struct { + Spec extension.Spec + Host string + Token string + Settings map[string]string +} + +// Forge calls a forge extension. It owns its process: a call that finds the +// process dead starts it again and retries once, and a process that cannot +// start fails the call. Callers already retry and report a failing forge, so +// nothing is dropped silently. +type Forge struct { + host *extension.Host + inst Instance + log *slog.Logger + + mu sync.Mutex + client forgev1.ForgeServiceClient +} + +var ( + _ forge.Forge = (*Forge)(nil) + _ forge.PullRequestReader = (*Forge)(nil) + _ forge.PullRequestDiffReader = (*Forge)(nil) + _ forge.RepoArchiveReader = (*Forge)(nil) + _ forge.PullRequestReviewReader = (*Forge)(nil) + _ forge.ReviewCommentWriter = (*Forge)(nil) +) + +// Open starts the instance's extension process and configures it. The process +// runs until Close is called, whatever happens to ctx. +func Open(ctx context.Context, host *extension.Host, inst Instance, log *slog.Logger) (*Forge, error) { + f := &Forge{host: host, inst: inst, log: log} + if _, err := f.connect(ctx, nil); err != nil { + return nil, err + } + return f, nil +} + +// Close stops the extension process. +func (f *Forge) Close() { f.host.Stop(f.inst.Spec.Name) } + +// connect returns the live client, starting the process when stale is nil or +// is the client the caller just saw fail. +func (f *Forge) connect(ctx context.Context, stale forgev1.ForgeServiceClient) (forgev1.ForgeServiceClient, error) { + f.mu.Lock() + defer f.mu.Unlock() + if f.client != nil && f.client != stale && f.host.Alive(f.inst.Spec.Name) { + return f.client, nil + } + raw, err := f.host.Start(context.WithoutCancel(ctx), f.inst.Spec, Surface, &Plugin{}) + if err != nil { + return nil, err + } + client, ok := raw.(forgev1.ForgeServiceClient) + if !ok { + f.host.Stop(f.inst.Spec.Name) + return nil, fmt.Errorf("extension %q: unexpected client type %T", f.inst.Spec.Name, raw) + } + if _, err := client.Configure(ctx, &forgev1.ConfigureRequest{Host: f.inst.Host, Token: f.inst.Token, Settings: f.inst.Settings}); err != nil { + f.host.Stop(f.inst.Spec.Name) + return nil, fmt.Errorf("extension %q: configure: %w", f.inst.Spec.Name, err) + } + f.client = client + return client, nil +} + +// call runs fn on the live client, restarting the process once when the call +// finds it gone. +func call[T any](ctx context.Context, f *Forge, op string, fn func(forgev1.ForgeServiceClient) (T, error)) (T, error) { + var zero T + client, err := f.connect(ctx, nil) + if err != nil { + return zero, fmt.Errorf("forge %s: %w", op, err) + } + out, err := fn(client) + if status.Code(err) == codes.Unavailable { + if client, err = f.connect(ctx, client); err != nil { + return zero, fmt.Errorf("forge %s: %w", op, err) + } + out, err = fn(client) + } + if status.Code(err) == codes.Unimplemented { + return zero, fmt.Errorf("this forge does not support %s", op) + } + if err != nil { + return zero, fmt.Errorf("forge %s: %w", op, err) + } + return out, nil +} + +func ref(owner, repo string) *forgev1.RepoRef { return &forgev1.RepoRef{Owner: owner, Repo: repo} } + +func prRef(owner, repo string, number int) *forgev1.PullRequestRef { + return &forgev1.PullRequestRef{Repo: ref(owner, repo), Number: int32(number)} //nolint:gosec // issue numbers fit int32 +} + +func issues(in []*forgev1.Issue) []forge.Issue { + out := make([]forge.Issue, 0, len(in)) + for _, i := range in { + out = append(out, forge.Issue{Number: int(i.GetNumber()), Title: i.GetTitle(), Body: i.GetBody(), Labels: i.GetLabels()}) + } + return out +} + +func (f *Forge) AssignedIssues(ctx context.Context, owner, repo, assignee string) ([]forge.Issue, error) { + resp, err := call(ctx, f, "assigned issues", func(c forgev1.ForgeServiceClient) (*forgev1.AssignedIssuesResponse, error) { + return c.AssignedIssues(ctx, &forgev1.AssignedIssuesRequest{Repo: ref(owner, repo), Assignee: assignee}) + }) + if err != nil { + return nil, err + } + return issues(resp.GetIssues()), nil +} + +func (f *Forge) IssuesWithLabel(ctx context.Context, owner, repo, label string) ([]forge.Issue, error) { + resp, err := call(ctx, f, "issues with label", func(c forgev1.ForgeServiceClient) (*forgev1.IssuesWithLabelResponse, error) { + return c.IssuesWithLabel(ctx, &forgev1.IssuesWithLabelRequest{Repo: ref(owner, repo), Label: label}) + }) + if err != nil { + return nil, err + } + return issues(resp.GetIssues()), nil +} + +func (f *Forge) Comment(ctx context.Context, owner, repo string, number int, body string) (int64, error) { + resp, err := call(ctx, f, "comment", func(c forgev1.ForgeServiceClient) (*forgev1.CommentResponse, error) { + return c.Comment(ctx, &forgev1.CommentRequest{Repo: ref(owner, repo), Number: int32(number), Body: body}) //nolint:gosec // issue numbers fit int32 + }) + return resp.GetId(), err +} + +func (f *Forge) CloseIssue(ctx context.Context, owner, repo string, number int, comment string) error { + _, err := call(ctx, f, "close issue", func(c forgev1.ForgeServiceClient) (*forgev1.CloseIssueResponse, error) { + return c.CloseIssue(ctx, &forgev1.CloseIssueRequest{Repo: ref(owner, repo), Number: int32(number), Comment: comment}) //nolint:gosec // issue numbers fit int32 + }) + return err +} + +func (f *Forge) React(ctx context.Context, owner, repo string, number int, reaction string) error { + _, err := call(ctx, f, "react", func(c forgev1.ForgeServiceClient) (*forgev1.ReactResponse, error) { + return c.React(ctx, &forgev1.ReactRequest{Repo: ref(owner, repo), Number: int32(number), Reaction: reaction}) //nolint:gosec // issue numbers fit int32 + }) + return err +} + +// SetStateLabel has no error to return; a failure is logged and the next +// state change corrects the label. +func (f *Forge) SetStateLabel(ctx context.Context, owner, repo string, number int, label string, knownLabels []string) { + _, err := call(ctx, f, "set state label", func(c forgev1.ForgeServiceClient) (*forgev1.SetStateLabelResponse, error) { + return c.SetStateLabel(ctx, &forgev1.SetStateLabelRequest{Repo: ref(owner, repo), Number: int32(number), Label: label, KnownLabels: knownLabels}) //nolint:gosec // issue numbers fit int32 + }) + if err != nil { + f.log.Warn("set state label", "owner", owner, "repo", repo, "number", number, "err", err) + } +} + +func (f *Forge) CreatePR(ctx context.Context, owner, repo, title, head, base, body string) (int, error) { + resp, err := call(ctx, f, "create pull request", func(c forgev1.ForgeServiceClient) (*forgev1.CreatePRResponse, error) { + return c.CreatePR(ctx, &forgev1.CreatePRRequest{Repo: ref(owner, repo), Title: title, Head: head, Base: base, Body: body}) + }) + return int(resp.GetNumber()), err +} + +func (f *Forge) PRState(ctx context.Context, owner, repo string, number int) (string, error) { + resp, err := call(ctx, f, "pull request state", func(c forgev1.ForgeServiceClient) (*forgev1.PRStateResponse, error) { + return c.PRState(ctx, &forgev1.PRStateRequest{Repo: ref(owner, repo), Number: int32(number)}) //nolint:gosec // issue numbers fit int32 + }) + return resp.GetState(), err +} + +func (f *Forge) GetPullRequest(ctx context.Context, owner, repo string, number int) (forge.PullRequest, error) { + resp, err := call(ctx, f, "get pull request", func(c forgev1.ForgeServiceClient) (*forgev1.GetPullRequestResponse, error) { + return c.GetPullRequest(ctx, &forgev1.GetPullRequestRequest{Repo: ref(owner, repo), Number: int32(number)}) //nolint:gosec // issue numbers fit int32 + }) + if err != nil { + return forge.PullRequest{}, err + } + pr := resp.GetPullRequest() + return forge.PullRequest{ + Number: int(pr.GetNumber()), Title: pr.GetTitle(), Body: pr.GetBody(), + HeadRef: pr.GetHeadRef(), BaseRef: pr.GetBaseRef(), HeadSHA: pr.GetHeadSha(), BaseSHA: pr.GetBaseSha(), + State: pr.GetState(), + }, nil +} + +func (f *Forge) GetPullRequestDiff(ctx context.Context, owner, repo string, number int) (string, error) { + resp, err := call(ctx, f, "get pull request diff", func(c forgev1.ForgeServiceClient) (*forgev1.GetPullRequestDiffResponse, error) { + return c.GetPullRequestDiff(ctx, &forgev1.GetPullRequestDiffRequest{Repo: ref(owner, repo), Number: int32(number)}) //nolint:gosec // issue numbers fit int32 + }) + return resp.GetDiff(), err +} + +func (f *Forge) ListReviews(ctx context.Context, owner, repo string, number int, sinceID int64) ([]forge.Review, error) { + resp, err := call(ctx, f, "list reviews", func(c forgev1.ForgeServiceClient) (*forgev1.ListReviewsResponse, error) { + return c.ListReviews(ctx, &forgev1.ListReviewsRequest{PullRequest: prRef(owner, repo, number), SinceId: sinceID}) + }) + if err != nil { + return nil, err + } + out := make([]forge.Review, 0, len(resp.GetReviews())) + for _, r := range resp.GetReviews() { + out = append(out, forge.Review{ID: r.GetId(), Author: r.GetAuthor(), State: r.GetState(), Body: r.GetBody(), SubmittedAt: r.GetSubmittedAt().AsTime()}) + } + return out, nil +} + +func (f *Forge) ListReviewComments(ctx context.Context, owner, repo string, number int, sinceID int64) ([]forge.ReviewComment, error) { + resp, err := call(ctx, f, "list review comments", func(c forgev1.ForgeServiceClient) (*forgev1.ListReviewCommentsResponse, error) { + return c.ListReviewComments(ctx, &forgev1.ListReviewCommentsRequest{PullRequest: prRef(owner, repo, number), SinceId: sinceID}) + }) + if err != nil { + return nil, err + } + out := make([]forge.ReviewComment, 0, len(resp.GetComments())) + for _, c := range resp.GetComments() { + out = append(out, forge.ReviewComment{ + ID: c.GetId(), ReviewID: c.GetReviewId(), Author: c.GetAuthor(), Body: c.GetBody(), Path: c.GetPath(), + Line: int(c.GetLine()), InReplyTo: c.GetInReplyTo(), CreatedAt: c.GetCreatedAt().AsTime(), + }) + } + return out, nil +} + +func (f *Forge) ReplyToReview(ctx context.Context, owner, repo string, number int, commentID int64, body string) error { + _, err := call(ctx, f, "reply to review", func(c forgev1.ForgeServiceClient) (*forgev1.ReplyToReviewResponse, error) { + return c.ReplyToReview(ctx, &forgev1.ReplyToReviewRequest{PullRequest: prRef(owner, repo, number), CommentId: commentID, Body: body}) + }) + return err +} + +func (f *Forge) CreateReviewComments(ctx context.Context, owner, repo string, number int, reviewedHeadSHA string, comments []forge.InlineReviewComment) error { + in := make([]*forgev1.InlineReviewComment, 0, len(comments)) + for _, c := range comments { + in = append(in, &forgev1.InlineReviewComment{Path: c.Path, Line: int32(c.Line), Body: c.Body}) //nolint:gosec // line numbers fit int32 + } + _, err := call(ctx, f, "create review comments", func(c forgev1.ForgeServiceClient) (*forgev1.CreateReviewCommentsResponse, error) { + return c.CreateReviewComments(ctx, &forgev1.CreateReviewCommentsRequest{PullRequest: prRef(owner, repo, number), ReviewedHeadSha: reviewedHeadSHA, Comments: in}) + }) + return err +} + +func (f *Forge) AcceptInvitations(ctx context.Context) error { + _, err := call(ctx, f, "accept invitations", func(c forgev1.ForgeServiceClient) (*forgev1.AcceptInvitationsResponse, error) { + return c.AcceptInvitations(ctx, &forgev1.AcceptInvitationsRequest{}) + }) + return err +} + +func (f *Forge) VerifyPush(ctx context.Context, owner, repo string) error { + _, err := call(ctx, f, "verify push", func(c forgev1.ForgeServiceClient) (*forgev1.VerifyPushResponse, error) { + return c.VerifyPush(ctx, &forgev1.VerifyPushRequest{Repo: ref(owner, repo)}) + }) + return err +} + +func (f *Forge) LinkBranch(ctx context.Context, owner, repo string, issueNumber int, branch string) error { + _, err := call(ctx, f, "link branch", func(c forgev1.ForgeServiceClient) (*forgev1.LinkBranchResponse, error) { + return c.LinkBranch(ctx, &forgev1.LinkBranchRequest{Repo: ref(owner, repo), IssueNumber: int32(issueNumber), Branch: branch}) //nolint:gosec // issue numbers fit int32 + }) + return err +} + +// GetRepoArchive streams the archive. The first chunk is read before +// returning so an unsupported or failing forge surfaces as the call's error. +func (f *Forge) GetRepoArchive(ctx context.Context, owner, repo, ref string) (io.ReadCloser, error) { + ctx, cancel := context.WithCancel(ctx) + stream, err := call(ctx, f, "get repo archive", func(c forgev1.ForgeServiceClient) (grpc.ServerStreamingClient[forgev1.GetRepoArchiveResponse], error) { + return c.GetRepoArchive(ctx, &forgev1.GetRepoArchiveRequest{Repo: &forgev1.RepoRef{Owner: owner, Repo: repo}, Ref: ref}) + }) + if err != nil { + cancel() + return nil, err + } + first, err := stream.Recv() + if err != nil && !errors.Is(err, io.EOF) { + cancel() + if status.Code(err) == codes.Unimplemented { + return nil, errors.New("this forge does not support get repo archive") + } + return nil, fmt.Errorf("forge get repo archive: %w", err) + } + pr, pw := io.Pipe() + go func() { + defer cancel() + if err == nil { + if _, werr := pw.Write(first.GetData()); werr != nil { + return + } + for { + chunk, rerr := stream.Recv() + if errors.Is(rerr, io.EOF) { + break + } + if rerr != nil { + _ = pw.CloseWithError(rerr) + return + } + if _, werr := pw.Write(chunk.GetData()); werr != nil { + return + } + } + } + _ = pw.Close() + }() + return pr, nil +} diff --git a/internal/infrastructure/secretengine/runner.go b/internal/infrastructure/secretengine/runner.go index c47bf0d1b..533f4bb69 100644 --- a/internal/infrastructure/secretengine/runner.go +++ b/internal/infrastructure/secretengine/runner.go @@ -2,14 +2,11 @@ package secretengine import ( "context" - "crypto/sha256" - "encoding/hex" "encoding/json" "errors" "fmt" "log/slog" "os" - "path" "path/filepath" "slices" "sync" @@ -24,20 +21,8 @@ import ( "github.com/samcharles93/archie-core/internal/secret" ) -// orgID is the single-operator install's org, the one packages are installed in. -const orgID = "default" - -// Source is what the runner reads: the extension-settings resource and the -// installed packages. -type Source struct { - // Query reads a control-plane resource, as *controlplanerpc.Client does. - Query controlplanerpc.ResourceReader - // Packages reads installed packages, as *staterpc.Client does. - Packages interface { - ListInstalled(ctx context.Context, orgID string) ([]storepkg.Installed, error) - GetInstalled(ctx context.Context, orgID, name string) (storepkg.Installed, error) - } -} +// Source is what the runner reads. +type Source = extension.Source // Runner keeps the enabled secret-engine extensions running and registered. // An extension runs when its package is installed, its authority is accepted @@ -94,7 +79,7 @@ func (r *Runner) Run(ctx context.Context, interval time.Duration) { // package, settings or process changed, and stops the rest. It returns the // problems it met; a failed engine does not stop the others. func (r *Runner) Sync(ctx context.Context) error { - settings, version, err := r.enabled(ctx) + settings, version, err := r.source.Enabled(ctx) if err == nil { err = r.apply(ctx, settings) } @@ -105,7 +90,7 @@ func (r *Runner) Sync(ctx context.Context) error { } func (r *Runner) apply(ctx context.Context, settings map[string]controlplanerpc.ExtensionSetting) error { - installed, err := r.source.Packages.ListInstalled(ctx, orgID) + installed, err := r.source.Packages.ListInstalled(ctx, extension.OrgID) if err != nil { return fmt.Errorf("list installed packages: %w", err) } @@ -136,24 +121,6 @@ func (r *Runner) apply(ctx context.Context, settings map[string]controlplanerpc. return errors.Join(problems...) } -func (r *Runner) enabled(ctx context.Context) (map[string]controlplanerpc.ExtensionSetting, int64, error) { - byName := make(map[string]controlplanerpc.ExtensionSetting) - version, _, err := r.source.Query.Query(ctx, controlplanerpc.ExtensionSettingsKind, func(value []byte) error { - var doc controlplanerpc.ExtensionSettings - if err := json.Unmarshal(value, &doc); err != nil { - return err - } - for _, setting := range doc.Extensions { - byName[setting.Name] = setting - } - return nil - }) - if err != nil { - return nil, 0, fmt.Errorf("read extension settings: %w", err) - } - return byName, version, nil -} - func secretEngines(d storepkg.Descriptor) []storepkg.Extension { var out []storepkg.Extension for _, extension := range d.Contributes.Extensions { @@ -178,7 +145,7 @@ func (r *Runner) ensure(ctx context.Context, pkg storepkg.Installed, setting con if len(engines) != 1 { return fmt.Errorf("a package serves one secret engine, this one declares %d", len(engines)) } - binary, sum, err := r.materialize(ctx, pkg, engines[0].Path) + binary, sum, err := extension.Materialize(ctx, r.source.Packages, r.cacheDir, pkg, engines[0].Path) if err != nil { return err } @@ -192,53 +159,6 @@ func (r *Runner) ensure(ctx context.Context, pkg storepkg.Installed, setting con return nil } -// materialize writes the package's extension binary under the cache, keyed by -// package digest, and returns its path and sha256. A binary already there for -// this digest is reused. -func (r *Runner) materialize(ctx context.Context, pkg storepkg.Installed, file string) (string, string, error) { - full, err := r.source.Packages.GetInstalled(ctx, orgID, pkg.Name) - if err != nil { - return "", "", fmt.Errorf("get installed package: %w", err) - } - files, err := storepkg.FilesFromLayer(full.Layer) - if err != nil { - return "", "", err - } - content, ok := files[file] - if !ok { - return "", "", fmt.Errorf("package layer has no %q", file) - } - sum := sha256.Sum256(content) - dir := filepath.Join(r.cacheDir, pkg.Name, hex.EncodeToString(sum[:8])) - target := filepath.Join(dir, path.Base(file)) - if existing, err := os.ReadFile(target); err == nil && sha256.Sum256(existing) == sum { - return target, hex.EncodeToString(sum[:]), nil - } - if err := os.MkdirAll(dir, 0o700); err != nil { - return "", "", err - } - tmp, err := os.CreateTemp(dir, ".extract-*") - if err != nil { - return "", "", err - } - defer func() { _ = os.Remove(tmp.Name()) }() - if _, err := tmp.Write(content); err != nil { - _ = tmp.Close() - return "", "", err - } - if err := tmp.Chmod(0o700); err != nil { - _ = tmp.Close() - return "", "", err - } - if err := tmp.Close(); err != nil { - return "", "", err - } - if err := os.Rename(tmp.Name(), target); err != nil { - return "", "", err - } - return target, hex.EncodeToString(sum[:]), nil -} - // Close stops every running engine. func (r *Runner) Close() { r.host.Close() } diff --git a/proto/forge/v1/forge.proto b/proto/forge/v1/forge.proto new file mode 100644 index 000000000..cded18d94 --- /dev/null +++ b/proto/forge/v1/forge.proto @@ -0,0 +1,209 @@ +syntax = "proto3"; + +package forge.v1; + +import "google/protobuf/timestamp.proto"; + +// ForgeService is the surface a forge extension serves. The host launches one +// plugin process per configured forge instance and routes every issue, pull +// request and repository call of that instance through it. The calls follow +// the host's forge interfaces; a capability the forge lacks answers +// UNIMPLEMENTED. +service ForgeService { + // Configure hands the plugin its instance once, right after launch and + // before any other call. The token is the instance's resolved credential; + // the plugin process does not inherit the host environment. + rpc Configure(ConfigureRequest) returns (ConfigureResponse); + + rpc AssignedIssues(AssignedIssuesRequest) returns (AssignedIssuesResponse); + rpc IssuesWithLabel(IssuesWithLabelRequest) returns (IssuesWithLabelResponse); + rpc Comment(CommentRequest) returns (CommentResponse); + rpc CloseIssue(CloseIssueRequest) returns (CloseIssueResponse); + rpc React(ReactRequest) returns (ReactResponse); + rpc SetStateLabel(SetStateLabelRequest) returns (SetStateLabelResponse); + + rpc CreatePR(CreatePRRequest) returns (CreatePRResponse); + rpc PRState(PRStateRequest) returns (PRStateResponse); + rpc GetPullRequest(GetPullRequestRequest) returns (GetPullRequestResponse); + rpc GetPullRequestDiff(GetPullRequestDiffRequest) returns (GetPullRequestDiffResponse); + rpc ListReviews(ListReviewsRequest) returns (ListReviewsResponse); + rpc ListReviewComments(ListReviewCommentsRequest) returns (ListReviewCommentsResponse); + rpc ReplyToReview(ReplyToReviewRequest) returns (ReplyToReviewResponse); + rpc CreateReviewComments(CreateReviewCommentsRequest) returns (CreateReviewCommentsResponse); + + rpc AcceptInvitations(AcceptInvitationsRequest) returns (AcceptInvitationsResponse); + rpc VerifyPush(VerifyPushRequest) returns (VerifyPushResponse); + rpc LinkBranch(LinkBranchRequest) returns (LinkBranchResponse); + // GetRepoArchive streams a gzipped tar of the repository at a ref. + rpc GetRepoArchive(GetRepoArchiveRequest) returns (stream GetRepoArchiveResponse); +} + +message ConfigureRequest { + string host = 1; + string token = 2; + map settings = 3; +} +message ConfigureResponse {} + +message RepoRef { + string owner = 1; + string repo = 2; +} + +message PullRequestRef { + RepoRef repo = 1; + int32 number = 2; +} + +message Issue { + int32 number = 1; + string title = 2; + string body = 3; + repeated string labels = 4; +} +message AssignedIssuesResponse { repeated Issue issues = 1; } +message IssuesWithLabelResponse { repeated Issue issues = 1; } + +message AssignedIssuesRequest { + RepoRef repo = 1; + string assignee = 2; +} +message IssuesWithLabelRequest { + RepoRef repo = 1; + string label = 2; +} + +message CommentRequest { + RepoRef repo = 1; + int32 number = 2; + string body = 3; +} +message CommentResponse { int64 id = 1; } + +message CloseIssueRequest { + RepoRef repo = 1; + int32 number = 2; + string comment = 3; +} +message CloseIssueResponse {} + +message ReactRequest { + RepoRef repo = 1; + int32 number = 2; + string reaction = 3; +} +message ReactResponse {} + +message SetStateLabelRequest { + RepoRef repo = 1; + int32 number = 2; + string label = 3; + repeated string known_labels = 4; +} +message SetStateLabelResponse {} + +message CreatePRRequest { + RepoRef repo = 1; + string title = 2; + string head = 3; + string base = 4; + string body = 5; +} +message CreatePRResponse { int32 number = 1; } + +message PRStateRequest { + RepoRef repo = 1; + int32 number = 2; +} +message PRStateResponse { string state = 1; } + +message PullRequest { + int32 number = 1; + string title = 2; + string body = 3; + string head_ref = 4; + string base_ref = 5; + string head_sha = 6; + string base_sha = 7; + string state = 8; +} + +message GetPullRequestRequest { + RepoRef repo = 1; + int32 number = 2; +} +message GetPullRequestResponse { PullRequest pull_request = 1; } + +message GetPullRequestDiffRequest { + RepoRef repo = 1; + int32 number = 2; +} +message GetPullRequestDiffResponse { string diff = 1; } + +message ListReviewsRequest { + PullRequestRef pull_request = 1; + int64 since_id = 2; +} + +message Review { + int64 id = 1; + string author = 2; + string state = 3; + string body = 4; + google.protobuf.Timestamp submitted_at = 5; +} +message ListReviewsResponse { repeated Review reviews = 1; } + +message ReviewComment { + int64 id = 1; + int64 review_id = 2; + string author = 3; + string body = 4; + string path = 5; + int32 line = 6; + int64 in_reply_to = 7; + google.protobuf.Timestamp created_at = 8; +} +message ListReviewCommentsRequest { + PullRequestRef pull_request = 1; + int64 since_id = 2; +} +message ListReviewCommentsResponse { repeated ReviewComment comments = 1; } + +message ReplyToReviewRequest { + PullRequestRef pull_request = 1; + int64 comment_id = 2; + string body = 3; +} +message ReplyToReviewResponse {} + +message InlineReviewComment { + string path = 1; + int32 line = 2; + string body = 3; +} +message CreateReviewCommentsRequest { + PullRequestRef pull_request = 1; + string reviewed_head_sha = 2; + repeated InlineReviewComment comments = 3; +} +message CreateReviewCommentsResponse {} + +message LinkBranchRequest { + RepoRef repo = 1; + int32 issue_number = 2; + string branch = 3; +} +message LinkBranchResponse {} + +message AcceptInvitationsRequest {} +message AcceptInvitationsResponse {} + +message VerifyPushRequest { RepoRef repo = 1; } +message VerifyPushResponse {} + +message GetRepoArchiveRequest { + RepoRef repo = 1; + string ref = 2; +} +message GetRepoArchiveResponse { bytes data = 1; }