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
EventPublisher() agentexec.EventPublisher
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
Calls(time.Duration) task.Caller
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 {
Forger(string, time.Duration) workflow.Forger
Forger(identity, credential string, timeout time.Duration) workflow.Forger
Store(time.Duration) workflow.Store
Calls(time.Duration) task.Caller
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) {
log.Info("running task", "task", request.Task.ID, "repo", request.Repo.FullName(), "issue", request.Task.IssueNumber)
dependencies := taskDependencies{
forge: transport.Forger(request.Task.Identity, rpcTimeout),
forge: transport.Forger(request.Task.Identity, request.RunCredential, rpcTimeout),
store: transport.Store(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(),
steps: steps,
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 {
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)
if err != nil {
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,
Providers: agentexec.ProvidersFromConfig(cfg.Providers),
MCPServers: cfg.Tools.MCPServers,
WorktreeGrant: credential,
RunCredential: credential,
KindWorkflows: d.KindWorkflows,
LabelWorkflows: d.LabelWorkflows,
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.")
}
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
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 {
@@ -49,13 +62,14 @@ type CommentResponse struct {
}
type CloseIssueRequest struct {
Owner, Repo string
Number int
Comment string
Target
Number int
Comment string
}
type CreatePRRequest struct {
Owner, Repo, Title, Head, Base, Body string
Target
Title, Head, Base, Body string
}
type CreatePRResponse struct {
@@ -64,13 +78,13 @@ type CreatePRResponse struct {
}
type LinkBranchRequest struct {
Owner, Repo string
Target
IssueNumber int
Branch string
}
type SetStateLabelRequest struct {
Owner, Repo string
Target
Number int
Label string
KnownLabels []string
@@ -78,8 +92,8 @@ type SetStateLabelRequest struct {
// CreateReviewCommentsRequest is one review's line-anchored comments.
type CreateReviewCommentsRequest struct {
Owner, Repo string
Number int
Target
Number int
// ReviewedHeadSHA is the revision the line numbers were measured on.
ReviewedHeadSHA string
Comments []InlineReviewCommentPayload
@@ -94,10 +108,10 @@ type InlineReviewCommentPayload struct {
// ReplyToReviewRequest carries one threaded reply to a review comment.
type ReplyToReviewRequest struct {
Owner, Repo string
Number int
CommentID int64
Body string
Target
Number int
CommentID int64
Body string
}
// 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.
type Server struct {
Forge forge.Forge
Runs Runs
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.
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{
{Subject: SubjectFor(identity, SubjectComment), Handler: s.handleComment},
{Subject: SubjectFor(identity, SubjectCloseIssue), Handler: s.handleCloseIssue},
{Subject: SubjectFor(identity, SubjectCreatePR), Handler: s.handleCreatePR},
{Subject: SubjectFor(identity, SubjectLinkBranch), Handler: s.handleLinkBranch},
{Subject: SubjectFor(identity, SubjectSetStateLabel), Handler: s.handleSetStateLabel},
{Subject: SubjectFor(identity, SubjectCreateReviewComment), Handler: s.handleCreateReviewComments},
{Subject: SubjectFor(identity, SubjectReplyToReview), Handler: s.handleReplyToReview},
{Subject: SubjectFor(identity, SubjectComment), Handler: as(s.handleComment)},
{Subject: SubjectFor(identity, SubjectCloseIssue), Handler: as(s.handleCloseIssue)},
{Subject: SubjectFor(identity, SubjectCreatePR), Handler: as(s.handleCreatePR)},
{Subject: SubjectFor(identity, SubjectLinkBranch), Handler: as(s.handleLinkBranch)},
{Subject: SubjectFor(identity, SubjectSetStateLabel), Handler: as(s.handleSetStateLabel)},
{Subject: SubjectFor(identity, SubjectCreateReviewComment), Handler: as(s.handleCreateReviewComments)},
{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
if err := json.Unmarshal(msg.Data, &req); err != nil {
s.respond(msg, CommentResponse{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode comment request: %w", err))})
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)
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
if err := json.Unmarshal(msg.Data, &req); err != nil {
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode close_issue request: %w", err))})
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)
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
if err := json.Unmarshal(msg.Data, &req); err != nil {
s.respond(msg, CreatePRResponse{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode create_pr request: %w", err))})
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)
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
if err := json.Unmarshal(msg.Data, &req); err != nil {
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode link_branch request: %w", err))})
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)
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
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))})
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)
if !ok {
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)})
}
func (s *Server) handleReplyToReview(msg *nats.Msg) {
func (s *Server) handleReplyToReview(identity string, msg *nats.Msg) {
var req ReplyToReviewRequest
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))})
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)
if !ok {
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)})
}
func (s *Server) handleSetStateLabel(msg *nats.Msg) {
func (s *Server) handleSetStateLabel(identity string, msg *nats.Msg) {
var req SetStateLabelRequest
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))})
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.respond(msg, Response{})
}
@@ -230,6 +291,12 @@ type Client struct {
// Identity scopes this client's calls to one identity's RPC server.
// Empty uses the root subjects (single-identity deployments).
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} }
@@ -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) 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)
if err != nil {
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 {
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)
if err != nil {
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) {
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)
if err != nil {
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 {
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)
if err != nil {
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;
// the current workflow deliberately never calls it.
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)
}
@@ -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})
}
req := CreateReviewCommentsRequest{
Owner: owner, Repo: repo, Number: number,
Target: c.target(owner, repo), Number: number,
ReviewedHeadSHA: reviewedHeadSHA, Comments: payload,
}
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
// the remediate workflow.
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)
if err != nil {
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.
func (t *Transport) Forger(identity string, timeout time.Duration) workflow.Forger {
return &forgerpc.Client{Conn: t.conn, Timeout: timeout, Identity: identity}
func (t *Transport) Forger(identity, credential string, timeout time.Duration) workflow.Forger {
return &forgerpc.Client{Conn: t.conn, Timeout: timeout, Identity: identity, Credential: credential}
}
// 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.
KindWorkflows workflow.KindWorkflows `json:"kind_workflows,omitempty"`
LabelWorkflows workflow.LabelWorkflows `json:"label_workflows,omitempty"`
// WorktreeGrant is an opaque, per-dispatch capability authorizing the
// daemon to publish this task's already-prepared branch. Repository
// RunCredential is the task's run credential: it authorizes the push of
// this task's branch and forge calls on its own repository. Repository
// 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 string `json:"workflow_definition"`
// 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 {
return fmt.Errorf("task ID must be positive, got %d", r.Task.ID)
}
if r.WorktreeGrant == "" && r.Task.HasRepository() {
return errors.New("worktree grant is required")
if r.RunCredential == "" && r.Task.HasRepository() {
return errors.New("run credential is required")
}
if r.WorkflowDefinition == "" {
return errors.New("workflow definition is required")