fix(forgerpc): forge calls need the run credential and reach only the run's own repository

This commit is contained in:
sam committed 2026-10-04 18:34:16 +11:00
1 parent 319e8f4945
commit f4f0ec0504
7 files changed
+160 -49

No files matched your search

+4 -4
View File
@@ -48,7 +48,7 @@ type workerTransport interface {
LogPublisher() agentexec.LogPublisher LogPublisher() agentexec.LogPublisher
EventPublisher() agentexec.EventPublisher EventPublisher() agentexec.EventPublisher
SubscribeTasks(context.Context, int64, agentnats.TaskHandler, *slog.Logger) (agentnats.Subscription, error) SubscribeTasks(context.Context, int64, agentnats.TaskHandler, *slog.Logger) (agentnats.Subscription, error)
Forger(string, time.Duration) workflow.Forger Forger(identity, credential string, timeout time.Duration) workflow.Forger
Store(time.Duration) workflow.Store Store(time.Duration) workflow.Store
Calls(time.Duration) task.Caller Calls(time.Duration) task.Caller
Trees(string, string, time.Duration) agentnats.RemoteTrees Trees(string, string, time.Duration) agentnats.RemoteTrees
@@ -152,7 +152,7 @@ func run(ctx context.Context, settings Settings, log *slog.Logger, dependencies
} }
type taskServiceTransport interface { type taskServiceTransport interface {
Forger(string, time.Duration) workflow.Forger Forger(identity, credential string, timeout time.Duration) workflow.Forger
Store(time.Duration) workflow.Store Store(time.Duration) workflow.Store
Calls(time.Duration) task.Caller Calls(time.Duration) task.Caller
Trees(string, string, time.Duration) agentnats.RemoteTrees Trees(string, string, time.Duration) agentnats.RemoteTrees
@@ -162,10 +162,10 @@ type taskServiceTransport interface {
func executeTaskRequest(ctx context.Context, request taskrun.Request, transport taskServiceTransport, workDir string, log *slog.Logger, steps *workflow.Manager, guardrails *tools.GuardrailEngine) (*taskrun.Response, error) { func executeTaskRequest(ctx context.Context, request taskrun.Request, transport taskServiceTransport, workDir string, log *slog.Logger, steps *workflow.Manager, guardrails *tools.GuardrailEngine) (*taskrun.Response, error) {
log.Info("running task", "task", request.Task.ID, "repo", request.Repo.FullName(), "issue", request.Task.IssueNumber) log.Info("running task", "task", request.Task.ID, "repo", request.Repo.FullName(), "issue", request.Task.IssueNumber)
dependencies := taskDependencies{ dependencies := taskDependencies{
forge: transport.Forger(request.Task.Identity, rpcTimeout), forge: transport.Forger(request.Task.Identity, request.RunCredential, rpcTimeout),
store: transport.Store(rpcTimeout), store: transport.Store(rpcTimeout),
calls: transport.Calls(rpcTimeout), calls: transport.Calls(rpcTimeout),
trees: transport.Trees(request.Task.Identity, request.WorktreeGrant, rpcTimeout), trees: transport.Trees(request.Task.Identity, request.RunCredential, rpcTimeout),
events: transport.EventPublisher(), events: transport.EventPublisher(),
steps: steps, steps: steps,
guardrails: guardrails, guardrails: guardrails,
+1 -1
View File
@@ -352,7 +352,7 @@ func registerTaskRPCServers(nc *natsio.Conn, forgeClient forge.Forge, trees *wor
} }
registerForge := func(fg forge.Forge, identity string) error { registerForge := func(fg forge.Forge, identity string) error {
srv := &forgerpc.Server{Forge: fg, Log: log.With("rpc_identity", identity)} srv := &forgerpc.Server{Forge: fg, Runs: runs, Log: log.With("rpc_identity", identity)}
u, err := srv.RegisterFor(nc, identity) u, err := srv.RegisterFor(nc, identity)
if err != nil { if err != nil {
return fmt.Errorf("register forgerpc%s: %w", identitySuffix(identity), err) return fmt.Errorf("register forgerpc%s: %w", identitySuffix(identity), err)
+1 -1
View File
@@ -1648,7 +1648,7 @@ func (d *Daemon) runViaAgent(ctx context.Context, task *workflow.Task, repo conf
Cfg: taskCfg, Cfg: taskCfg,
Providers: agentexec.ProvidersFromConfig(cfg.Providers), Providers: agentexec.ProvidersFromConfig(cfg.Providers),
MCPServers: cfg.Tools.MCPServers, MCPServers: cfg.Tools.MCPServers,
WorktreeGrant: credential, RunCredential: credential,
KindWorkflows: d.KindWorkflows, KindWorkflows: d.KindWorkflows,
LabelWorkflows: d.LabelWorkflows, LabelWorkflows: d.LabelWorkflows,
WorkflowDefinition: task.WorkflowDefinitionYAML, WorkflowDefinition: task.WorkflowDefinitionYAML,
+103 -36
View File
@@ -37,10 +37,23 @@ func SubjectFor(identity, base string) string {
return "archie.forge." + identity + "." + strings.TrimPrefix(base, "archie.forge.") return "archie.forge." + identity + "." + strings.TrimPrefix(base, "archie.forge.")
} }
type CommentRequest struct { // Target is what every request acts on and the credential that authorizes
// it: the run credential of the task asking, which only reaches that task's
// own repository.
type Target struct {
Credential string
Owner, Repo string Owner, Repo string
Number int }
Body string
// Runs resolves a run credential to the task it was issued for.
type Runs interface {
TaskForCredential(ctx context.Context, token string) (*workflow.Task, error)
}
type CommentRequest struct {
Target
Number int
Body string
} }
type CommentResponse struct { type CommentResponse struct {
@@ -49,13 +62,14 @@ type CommentResponse struct {
} }
type CloseIssueRequest struct { type CloseIssueRequest struct {
Owner, Repo string Target
Number int Number int
Comment string Comment string
} }
type CreatePRRequest struct { type CreatePRRequest struct {
Owner, Repo, Title, Head, Base, Body string Target
Title, Head, Base, Body string
} }
type CreatePRResponse struct { type CreatePRResponse struct {
@@ -64,13 +78,13 @@ type CreatePRResponse struct {
} }
type LinkBranchRequest struct { type LinkBranchRequest struct {
Owner, Repo string Target
IssueNumber int IssueNumber int
Branch string Branch string
} }
type SetStateLabelRequest struct { type SetStateLabelRequest struct {
Owner, Repo string Target
Number int Number int
Label string Label string
KnownLabels []string KnownLabels []string
@@ -78,8 +92,8 @@ type SetStateLabelRequest struct {
// CreateReviewCommentsRequest is one review's line-anchored comments. // CreateReviewCommentsRequest is one review's line-anchored comments.
type CreateReviewCommentsRequest struct { type CreateReviewCommentsRequest struct {
Owner, Repo string Target
Number int Number int
// ReviewedHeadSHA is the revision the line numbers were measured on. // ReviewedHeadSHA is the revision the line numbers were measured on.
ReviewedHeadSHA string ReviewedHeadSHA string
Comments []InlineReviewCommentPayload Comments []InlineReviewCommentPayload
@@ -94,10 +108,10 @@ type InlineReviewCommentPayload struct {
// ReplyToReviewRequest carries one threaded reply to a review comment. // ReplyToReviewRequest carries one threaded reply to a review comment.
type ReplyToReviewRequest struct { type ReplyToReviewRequest struct {
Owner, Repo string Target
Number int Number int
CommentID int64 CommentID int64
Body string Body string
} }
// Response is a bare success/error envelope for calls with no return value. // Response is a bare success/error envelope for calls with no return value.
@@ -108,6 +122,7 @@ type Response struct {
// Server proxies forgerpc requests to a real forge.Forge implementation. // Server proxies forgerpc requests to a real forge.Forge implementation.
type Server struct { type Server struct {
Forge forge.Forge Forge forge.Forge
Runs Runs
Log *slog.Logger Log *slog.Logger
} }
@@ -121,63 +136,101 @@ func (s *Server) Register(nc *nats.Conn) (unsubscribe func(), err error) {
// RegisterFor registers all handlers under the subjects scoped to identity. // RegisterFor registers all handlers under the subjects scoped to identity.
func (s *Server) RegisterFor(nc *nats.Conn, identity string) (unsubscribe func(), err error) { func (s *Server) RegisterFor(nc *nats.Conn, identity string) (unsubscribe func(), err error) {
as := func(h func(string, *nats.Msg)) nats.MsgHandler { return func(msg *nats.Msg) { h(identity, msg) } }
return natsrpc.RegisterAll(nc, []natsrpc.Registration{ return natsrpc.RegisterAll(nc, []natsrpc.Registration{
{Subject: SubjectFor(identity, SubjectComment), Handler: s.handleComment}, {Subject: SubjectFor(identity, SubjectComment), Handler: as(s.handleComment)},
{Subject: SubjectFor(identity, SubjectCloseIssue), Handler: s.handleCloseIssue}, {Subject: SubjectFor(identity, SubjectCloseIssue), Handler: as(s.handleCloseIssue)},
{Subject: SubjectFor(identity, SubjectCreatePR), Handler: s.handleCreatePR}, {Subject: SubjectFor(identity, SubjectCreatePR), Handler: as(s.handleCreatePR)},
{Subject: SubjectFor(identity, SubjectLinkBranch), Handler: s.handleLinkBranch}, {Subject: SubjectFor(identity, SubjectLinkBranch), Handler: as(s.handleLinkBranch)},
{Subject: SubjectFor(identity, SubjectSetStateLabel), Handler: s.handleSetStateLabel}, {Subject: SubjectFor(identity, SubjectSetStateLabel), Handler: as(s.handleSetStateLabel)},
{Subject: SubjectFor(identity, SubjectCreateReviewComment), Handler: s.handleCreateReviewComments}, {Subject: SubjectFor(identity, SubjectCreateReviewComment), Handler: as(s.handleCreateReviewComments)},
{Subject: SubjectFor(identity, SubjectReplyToReview), Handler: s.handleReplyToReview}, {Subject: SubjectFor(identity, SubjectReplyToReview), Handler: as(s.handleReplyToReview)},
}) })
} }
func (s *Server) handleComment(msg *nats.Msg) { // authorize checks that target's credential belongs to a live run of this
// server's identity and that the run's repository is the one targeted.
func (s *Server) authorize(identity string, target Target) error {
if s.Runs == nil || target.Credential == "" {
return errors.New("forge request needs a run credential")
}
task, err := s.Runs.TaskForCredential(context.Background(), target.Credential)
if err != nil {
return fmt.Errorf("forge request credential is invalid: %w", err)
}
if task.Identity != identity || task.Owner == "" ||
!strings.EqualFold(task.Owner, target.Owner) || !strings.EqualFold(task.Repo, target.Repo) {
return errors.New("forge request is outside its run's repository")
}
return nil
}
func (s *Server) handleComment(identity string, msg *nats.Msg) {
var req CommentRequest var req CommentRequest
if err := json.Unmarshal(msg.Data, &req); err != nil { if err := json.Unmarshal(msg.Data, &req); err != nil {
s.respond(msg, CommentResponse{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode comment request: %w", err))}) s.respond(msg, CommentResponse{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode comment request: %w", err))})
return return
} }
if err := s.authorize(identity, req.Target); err != nil {
s.respond(msg, CommentResponse{Envelope: natsrpc.NewEnvelope(err)})
return
}
id, err := s.Forge.Comment(context.Background(), req.Owner, req.Repo, req.Number, req.Body) id, err := s.Forge.Comment(context.Background(), req.Owner, req.Repo, req.Number, req.Body)
s.respond(msg, CommentResponse{ID: id, Envelope: natsrpc.NewEnvelope(err)}) s.respond(msg, CommentResponse{ID: id, Envelope: natsrpc.NewEnvelope(err)})
} }
func (s *Server) handleCloseIssue(msg *nats.Msg) { func (s *Server) handleCloseIssue(identity string, msg *nats.Msg) {
var req CloseIssueRequest var req CloseIssueRequest
if err := json.Unmarshal(msg.Data, &req); err != nil { if err := json.Unmarshal(msg.Data, &req); err != nil {
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode close_issue request: %w", err))}) s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode close_issue request: %w", err))})
return return
} }
if err := s.authorize(identity, req.Target); err != nil {
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)})
return
}
err := s.Forge.CloseIssue(context.Background(), req.Owner, req.Repo, req.Number, req.Comment) err := s.Forge.CloseIssue(context.Background(), req.Owner, req.Repo, req.Number, req.Comment)
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)}) s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)})
} }
func (s *Server) handleCreatePR(msg *nats.Msg) { func (s *Server) handleCreatePR(identity string, msg *nats.Msg) {
var req CreatePRRequest var req CreatePRRequest
if err := json.Unmarshal(msg.Data, &req); err != nil { if err := json.Unmarshal(msg.Data, &req); err != nil {
s.respond(msg, CreatePRResponse{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode create_pr request: %w", err))}) s.respond(msg, CreatePRResponse{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode create_pr request: %w", err))})
return return
} }
if err := s.authorize(identity, req.Target); err != nil {
s.respond(msg, CreatePRResponse{Envelope: natsrpc.NewEnvelope(err)})
return
}
num, err := s.Forge.CreatePR(context.Background(), req.Owner, req.Repo, req.Title, req.Head, req.Base, req.Body) num, err := s.Forge.CreatePR(context.Background(), req.Owner, req.Repo, req.Title, req.Head, req.Base, req.Body)
s.respond(msg, CreatePRResponse{Number: num, Envelope: natsrpc.NewEnvelope(err)}) s.respond(msg, CreatePRResponse{Number: num, Envelope: natsrpc.NewEnvelope(err)})
} }
func (s *Server) handleLinkBranch(msg *nats.Msg) { func (s *Server) handleLinkBranch(identity string, msg *nats.Msg) {
var req LinkBranchRequest var req LinkBranchRequest
if err := json.Unmarshal(msg.Data, &req); err != nil { if err := json.Unmarshal(msg.Data, &req); err != nil {
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode link_branch request: %w", err))}) s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode link_branch request: %w", err))})
return return
} }
if err := s.authorize(identity, req.Target); err != nil {
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)})
return
}
err := s.Forge.LinkBranch(context.Background(), req.Owner, req.Repo, req.IssueNumber, req.Branch) err := s.Forge.LinkBranch(context.Background(), req.Owner, req.Repo, req.IssueNumber, req.Branch)
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)}) s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)})
} }
func (s *Server) handleCreateReviewComments(msg *nats.Msg) { func (s *Server) handleCreateReviewComments(identity string, msg *nats.Msg) {
var req CreateReviewCommentsRequest var req CreateReviewCommentsRequest
if err := json.Unmarshal(msg.Data, &req); err != nil { if err := json.Unmarshal(msg.Data, &req); err != nil {
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode create_review_comments request: %w", err))}) s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode create_review_comments request: %w", err))})
return return
} }
if err := s.authorize(identity, req.Target); err != nil {
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)})
return
}
writer, ok := s.Forge.(forge.ReviewCommentWriter) writer, ok := s.Forge.(forge.ReviewCommentWriter)
if !ok { if !ok {
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(errors.New("this forge cannot post review comments"))}) s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(errors.New("this forge cannot post review comments"))})
@@ -191,12 +244,16 @@ func (s *Server) handleCreateReviewComments(msg *nats.Msg) {
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)}) s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)})
} }
func (s *Server) handleReplyToReview(msg *nats.Msg) { func (s *Server) handleReplyToReview(identity string, msg *nats.Msg) {
var req ReplyToReviewRequest var req ReplyToReviewRequest
if err := json.Unmarshal(msg.Data, &req); err != nil { if err := json.Unmarshal(msg.Data, &req); err != nil {
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode reply_to_review request: %w", err))}) s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode reply_to_review request: %w", err))})
return return
} }
if err := s.authorize(identity, req.Target); err != nil {
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)})
return
}
reader, ok := s.Forge.(forge.PullRequestReviewReader) reader, ok := s.Forge.(forge.PullRequestReviewReader)
if !ok { if !ok {
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(errors.New("this forge cannot reply to reviews"))}) s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(errors.New("this forge cannot reply to reviews"))})
@@ -206,12 +263,16 @@ func (s *Server) handleReplyToReview(msg *nats.Msg) {
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)}) s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)})
} }
func (s *Server) handleSetStateLabel(msg *nats.Msg) { func (s *Server) handleSetStateLabel(identity string, msg *nats.Msg) {
var req SetStateLabelRequest var req SetStateLabelRequest
if err := json.Unmarshal(msg.Data, &req); err != nil { if err := json.Unmarshal(msg.Data, &req); err != nil {
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode set_state_label request: %w", err))}) s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode set_state_label request: %w", err))})
return return
} }
if err := s.authorize(identity, req.Target); err != nil {
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)})
return
}
s.Forge.SetStateLabel(context.Background(), req.Owner, req.Repo, req.Number, req.Label, req.KnownLabels) s.Forge.SetStateLabel(context.Background(), req.Owner, req.Repo, req.Number, req.Label, req.KnownLabels)
s.respond(msg, Response{}) s.respond(msg, Response{})
} }
@@ -230,6 +291,12 @@ type Client struct {
// Identity scopes this client's calls to one identity's RPC server. // Identity scopes this client's calls to one identity's RPC server.
// Empty uses the root subjects (single-identity deployments). // Empty uses the root subjects (single-identity deployments).
Identity string Identity string
// Credential is the task's run credential, presented on every call.
Credential string
}
func (c *Client) target(owner, repo string) Target {
return Target{Credential: c.Credential, Owner: owner, Repo: repo}
} }
func (c *Client) rpc() *natsrpc.Client { return &natsrpc.Client{Conn: c.Conn, Timeout: c.Timeout} } func (c *Client) rpc() *natsrpc.Client { return &natsrpc.Client{Conn: c.Conn, Timeout: c.Timeout} }
@@ -237,7 +304,7 @@ func (c *Client) rpc() *natsrpc.Client { return &natsrpc.Client{Conn: c.Conn, Ti
func (c *Client) subject(base string) string { return SubjectFor(c.Identity, base) } func (c *Client) subject(base string) string { return SubjectFor(c.Identity, base) }
func (c *Client) Comment(ctx context.Context, owner, repo string, number int, body string) (int64, error) { func (c *Client) Comment(ctx context.Context, owner, repo string, number int, body string) (int64, error) {
req := CommentRequest{Owner: owner, Repo: repo, Number: number, Body: body} req := CommentRequest{Target: c.target(owner, repo), Number: number, Body: body}
resp, err := natsrpc.Call[CommentResponse](ctx, c.rpc(), c.subject(SubjectComment), req) resp, err := natsrpc.Call[CommentResponse](ctx, c.rpc(), c.subject(SubjectComment), req)
if err != nil { if err != nil {
return 0, err return 0, err
@@ -249,7 +316,7 @@ func (c *Client) Comment(ctx context.Context, owner, repo string, number int, bo
} }
func (c *Client) CloseIssue(ctx context.Context, owner, repo string, number int, comment string) error { func (c *Client) CloseIssue(ctx context.Context, owner, repo string, number int, comment string) error {
req := CloseIssueRequest{Owner: owner, Repo: repo, Number: number, Comment: comment} req := CloseIssueRequest{Target: c.target(owner, repo), Number: number, Comment: comment}
resp, err := natsrpc.Call[Response](ctx, c.rpc(), c.subject(SubjectCloseIssue), req) resp, err := natsrpc.Call[Response](ctx, c.rpc(), c.subject(SubjectCloseIssue), req)
if err != nil { if err != nil {
return err return err
@@ -258,7 +325,7 @@ func (c *Client) CloseIssue(ctx context.Context, owner, repo string, number int,
} }
func (c *Client) CreatePR(ctx context.Context, owner, repo, title, head, base, body string) (int, error) { func (c *Client) CreatePR(ctx context.Context, owner, repo, title, head, base, body string) (int, error) {
req := CreatePRRequest{Owner: owner, Repo: repo, Title: title, Head: head, Base: base, Body: body} req := CreatePRRequest{Target: c.target(owner, repo), Title: title, Head: head, Base: base, Body: body}
resp, err := natsrpc.Call[CreatePRResponse](ctx, c.rpc(), c.subject(SubjectCreatePR), req) resp, err := natsrpc.Call[CreatePRResponse](ctx, c.rpc(), c.subject(SubjectCreatePR), req)
if err != nil { if err != nil {
return 0, err return 0, err
@@ -270,7 +337,7 @@ func (c *Client) CreatePR(ctx context.Context, owner, repo, title, head, base, b
} }
func (c *Client) LinkBranch(ctx context.Context, owner, repo string, issueNumber int, branch string) error { func (c *Client) LinkBranch(ctx context.Context, owner, repo string, issueNumber int, branch string) error {
req := LinkBranchRequest{Owner: owner, Repo: repo, IssueNumber: issueNumber, Branch: branch} req := LinkBranchRequest{Target: c.target(owner, repo), IssueNumber: issueNumber, Branch: branch}
resp, err := natsrpc.Call[Response](ctx, c.rpc(), c.subject(SubjectLinkBranch), req) resp, err := natsrpc.Call[Response](ctx, c.rpc(), c.subject(SubjectLinkBranch), req)
if err != nil { if err != nil {
return err return err
@@ -281,7 +348,7 @@ func (c *Client) LinkBranch(ctx context.Context, owner, repo string, issueNumber
// SetStateLabel remains available for RPC compatibility with older workers; // SetStateLabel remains available for RPC compatibility with older workers;
// the current workflow deliberately never calls it. // the current workflow deliberately never calls it.
func (c *Client) SetStateLabel(ctx context.Context, owner, repo string, number int, label string, knownLabels []string) { func (c *Client) SetStateLabel(ctx context.Context, owner, repo string, number int, label string, knownLabels []string) {
req := SetStateLabelRequest{Owner: owner, Repo: repo, Number: number, Label: label, KnownLabels: knownLabels} req := SetStateLabelRequest{Target: c.target(owner, repo), Number: number, Label: label, KnownLabels: knownLabels}
_, _ = natsrpc.Call[Response](ctx, c.rpc(), c.subject(SubjectSetStateLabel), req) _, _ = natsrpc.Call[Response](ctx, c.rpc(), c.subject(SubjectSetStateLabel), req)
} }
@@ -293,7 +360,7 @@ func (c *Client) CreateReviewComments(ctx context.Context, owner, repo string, n
payload = append(payload, InlineReviewCommentPayload{Path: cm.Path, Line: cm.Line, Body: cm.Body}) payload = append(payload, InlineReviewCommentPayload{Path: cm.Path, Line: cm.Line, Body: cm.Body})
} }
req := CreateReviewCommentsRequest{ req := CreateReviewCommentsRequest{
Owner: owner, Repo: repo, Number: number, Target: c.target(owner, repo), Number: number,
ReviewedHeadSHA: reviewedHeadSHA, Comments: payload, ReviewedHeadSHA: reviewedHeadSHA, Comments: payload,
} }
resp, err := natsrpc.Call[Response](ctx, c.rpc(), c.subject(SubjectCreateReviewComment), req) resp, err := natsrpc.Call[Response](ctx, c.rpc(), c.subject(SubjectCreateReviewComment), req)
@@ -306,7 +373,7 @@ func (c *Client) CreateReviewComments(ctx context.Context, owner, repo string, n
// ReplyToReview posts a threaded reply to one review comment, on behalf of // ReplyToReview posts a threaded reply to one review comment, on behalf of
// the remediate workflow. // the remediate workflow.
func (c *Client) ReplyToReview(ctx context.Context, owner, repo string, number int, commentID int64, body string) error { func (c *Client) ReplyToReview(ctx context.Context, owner, repo string, number int, commentID int64, body string) error {
req := ReplyToReviewRequest{Owner: owner, Repo: repo, Number: number, CommentID: commentID, Body: body} req := ReplyToReviewRequest{Target: c.target(owner, repo), Number: number, CommentID: commentID, Body: body}
resp, err := natsrpc.Call[Response](ctx, c.rpc(), c.subject(SubjectReplyToReview), req) resp, err := natsrpc.Call[Response](ctx, c.rpc(), c.subject(SubjectReplyToReview), req)
if err != nil { if err != nil {
return err return err
+44
View File
@@ -0,0 +1,44 @@
package forgerpc
import (
"context"
"errors"
"testing"
"github.com/samcharles93/archie-core/internal/domain/workflow"
)
type runsByToken map[string]*workflow.Task
func (r runsByToken) TaskForCredential(_ context.Context, token string) (*workflow.Task, error) {
if task, ok := r[token]; ok {
return task, nil
}
return nil, errors.New("unknown")
}
// TestForgeCallStaysInItsRunsRepository pins that a forge call is authorized
// only by a live run credential, on its identity's server, for its own
// repository.
func TestForgeCallStaysInItsRunsRepository(t *testing.T) {
s := &Server{Runs: runsByToken{"live": {Identity: "bot", Owner: "acme", Repo: "app"}}}
tests := []struct {
name string
identity string
target Target
allowed bool
}{
{"own repository", "bot", Target{Credential: "live", Owner: "acme", Repo: "app"}, true},
{"another repository", "bot", Target{Credential: "live", Owner: "acme", Repo: "other"}, false},
{"another identity's server", "other", Target{Credential: "live", Owner: "acme", Repo: "app"}, false},
{"unknown credential", "bot", Target{Credential: "gone", Owner: "acme", Repo: "app"}, false},
{"no credential", "bot", Target{Owner: "acme", Repo: "app"}, false},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if err := s.authorize(tt.identity, tt.target); (err == nil) != tt.allowed {
t.Fatalf("err %v, want allowed %v", err, tt.allowed)
}
})
}
}
@@ -125,8 +125,8 @@ type RemoteTrees interface {
} }
// Forger constructs the identity-scoped forge RPC client. // Forger constructs the identity-scoped forge RPC client.
func (t *Transport) Forger(identity string, timeout time.Duration) workflow.Forger { func (t *Transport) Forger(identity, credential string, timeout time.Duration) workflow.Forger {
return &forgerpc.Client{Conn: t.conn, Timeout: timeout, Identity: identity} return &forgerpc.Client{Conn: t.conn, Timeout: timeout, Identity: identity, Credential: credential}
} }
// Store returns the State Store client, bounding each call by timeout when // Store returns the State Store client, bounding each call by timeout when
+5 -5
View File
@@ -26,10 +26,10 @@ type Request struct {
// Nil means defaults. // Nil means defaults.
KindWorkflows workflow.KindWorkflows `json:"kind_workflows,omitempty"` KindWorkflows workflow.KindWorkflows `json:"kind_workflows,omitempty"`
LabelWorkflows workflow.LabelWorkflows `json:"label_workflows,omitempty"` LabelWorkflows workflow.LabelWorkflows `json:"label_workflows,omitempty"`
// WorktreeGrant is an opaque, per-dispatch capability authorizing the // RunCredential is the task's run credential: it authorizes the push of
// daemon to publish this task's already-prepared branch. Repository // this task's branch and forge calls on its own repository. Repository
// coordinates never cross back from the sandbox as authority. // coordinates never cross back from the sandbox as authority.
WorktreeGrant string `json:"worktree_grant,omitempty"` RunCredential string `json:"run_credential,omitempty"`
// WorkflowDefinition is the exact YAML pinned on Task before dispatch. // WorkflowDefinition is the exact YAML pinned on Task before dispatch.
WorkflowDefinition string `json:"workflow_definition"` WorkflowDefinition string `json:"workflow_definition"`
// Tools is the agent profile's tool allowlist; empty allows every tool. // Tools is the agent profile's tool allowlist; empty allows every tool.
@@ -48,8 +48,8 @@ func (r Request) Validate() error {
if r.Task.ID <= 0 { if r.Task.ID <= 0 {
return fmt.Errorf("task ID must be positive, got %d", r.Task.ID) return fmt.Errorf("task ID must be positive, got %d", r.Task.ID)
} }
if r.WorktreeGrant == "" && r.Task.HasRepository() { if r.RunCredential == "" && r.Task.HasRepository() {
return errors.New("worktree grant is required") return errors.New("run credential is required")
} }
if r.WorkflowDefinition == "" { if r.WorkflowDefinition == "" {
return errors.New("workflow definition is required") return errors.New("workflow definition is required")