diff --git a/internal/app/agentworker/worker.go b/internal/app/agentworker/worker.go index 313cf0355..0b17c76f1 100644 --- a/internal/app/agentworker/worker.go +++ b/internal/app/agentworker/worker.go @@ -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, diff --git a/internal/app/archied/main.go b/internal/app/archied/main.go index 2447b7809..91cbdcdd6 100644 --- a/internal/app/archied/main.go +++ b/internal/app/archied/main.go @@ -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) diff --git a/internal/daemon/daemon.go b/internal/daemon/daemon.go index 18a8a6ab6..b84e1f7e7 100644 --- a/internal/daemon/daemon.go +++ b/internal/daemon/daemon.go @@ -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, diff --git a/internal/forgerpc/forgerpc.go b/internal/forgerpc/forgerpc.go index 9e0d1420a..12d1b553b 100644 --- a/internal/forgerpc/forgerpc.go +++ b/internal/forgerpc/forgerpc.go @@ -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 diff --git a/internal/forgerpc/forgerpc_test.go b/internal/forgerpc/forgerpc_test.go new file mode 100644 index 000000000..69e811d76 --- /dev/null +++ b/internal/forgerpc/forgerpc_test.go @@ -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) + } + }) + } +} diff --git a/internal/infrastructure/agenttransport/nats/transport.go b/internal/infrastructure/agenttransport/nats/transport.go index ae464a467..936422819 100644 --- a/internal/infrastructure/agenttransport/nats/transport.go +++ b/internal/infrastructure/agenttransport/nats/transport.go @@ -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 diff --git a/internal/taskrun/taskrun.go b/internal/taskrun/taskrun.go index 84f3e7c52..86efb30cf 100644 --- a/internal/taskrun/taskrun.go +++ b/internal/taskrun/taskrun.go @@ -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")