From 5fe8716d5938baf28d44c56d78559f3a71cf366a Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Sun, 11 Oct 2026 03:37:16 +1100 Subject: [PATCH] feat(forgerpc): bound a package workflow's forge calls by its accepted authority --- internal/app/archied/bootstrap.go | 2 +- internal/app/archied/installed_authorities.go | 21 ++++++++ internal/app/archied/main.go | 4 +- .../app/controlplane/workflow_projector.go | 5 +- internal/domain/workflow/definition.go | 20 ++++++- internal/forgerpc/forgerpc.go | 49 ++++++++++++----- internal/forgerpc/forgerpc_test.go | 53 ++++++++++++++----- 7 files changed, 122 insertions(+), 32 deletions(-) create mode 100644 internal/app/archied/installed_authorities.go diff --git a/internal/app/archied/bootstrap.go b/internal/app/archied/bootstrap.go index 411daa093..9b2f3094f 100644 --- a/internal/app/archied/bootstrap.go +++ b/internal/app/archied/bootstrap.go @@ -527,7 +527,7 @@ func (b *boot) registerNATSRPC() error { log.Error("nats connection unavailable for task RPC", "err", err) return err } - unsubscribe, err := registerTaskRPCServers(coreConn, b.forgeClient, b.trees, b.identityRunners, b.stateStoreGrants.Client, log) + unsubscribe, err := registerTaskRPCServers(coreConn, b.forgeClient, b.trees, b.identityRunners, b.stateStoreGrants.Client, installedAuthorities{b.stateStoreGrants.Client}, log) if err != nil { log.Error("task RPC server registration failed", "err", err) return err diff --git a/internal/app/archied/installed_authorities.go b/internal/app/archied/installed_authorities.go new file mode 100644 index 000000000..4bea359d5 --- /dev/null +++ b/internal/app/archied/installed_authorities.go @@ -0,0 +1,21 @@ +package archied + +import ( + "context" + + "github.com/samcharles93/archie-core/internal/domain/storepkg" +) + +// installedAuthorities answers a package's accepted authority from the State +// Store. A package the operator has not accepted has none. +type installedAuthorities struct { + packages storepkg.Installations +} + +func (a installedAuthorities) AcceptedAuthority(ctx context.Context, name string) (storepkg.Authority, error) { + installed, err := a.packages.GetInstalled(ctx, name) + if err != nil || installed.AcceptedAuthority == nil { + return storepkg.Authority{}, err + } + return *installed.AcceptedAuthority, nil +} diff --git a/internal/app/archied/main.go b/internal/app/archied/main.go index 3752784f7..c281c6ee0 100644 --- a/internal/app/archied/main.go +++ b/internal/app/archied/main.go @@ -356,7 +356,7 @@ func subscribeAgentEvents(nc *natsio.Conn, bus *events.Bus, log *slog.Logger) (u // tasks, and one server pair per identity answers that identity's scoped // subjects so a container-mode task owned by a non-root identity has its RPC // calls served by its own forge client and worktree manager. -func registerTaskRPCServers(nc *natsio.Conn, forgeClient forge.Forge, trees *worktree.Manager, identities []*daemon.IdentityRunner, runs worktreerpc.Runs, log *slog.Logger) (unsubscribe func(), err error) { +func registerTaskRPCServers(nc *natsio.Conn, forgeClient forge.Forge, trees *worktree.Manager, identities []*daemon.IdentityRunner, runs worktreerpc.Runs, authorities forgerpc.Authorities, log *slog.Logger) (unsubscribe func(), err error) { unsubs := make([]func(), 0, 2+2*len(identities)) unsubAll := func() { for _, u := range unsubs { @@ -365,7 +365,7 @@ func registerTaskRPCServers(nc *natsio.Conn, forgeClient forge.Forge, trees *wor } registerForge := func(fg forge.Forge, identity string) error { - srv := &forgerpc.Server{Forge: fg, Runs: runs, Log: log.With("rpc_identity", identity)} + srv := &forgerpc.Server{Forge: fg, Runs: runs, Authorities: authorities, 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/app/controlplane/workflow_projector.go b/internal/app/controlplane/workflow_projector.go index 5e8fed1fc..7aed85a31 100644 --- a/internal/app/controlplane/workflow_projector.go +++ b/internal/app/controlplane/workflow_projector.go @@ -56,7 +56,10 @@ func (p *WorkflowProjector) Apply(ctx context.Context, orgID, name, digest strin if err != nil { return fmt.Errorf("contributed workflow %q: %w", contentName, err) } - entries = append(entries, workflow.WorkflowDefinitionEntry{ID: id, YAML: string(content)}) + if workflow.PackageOf(string(content)) != "" { + return fmt.Errorf("contributed workflow %q: package is set by the installer, not the workflow", contentName) + } + entries = append(entries, workflow.WorkflowDefinitionEntry{ID: id, YAML: "package: " + strconv.Quote(name) + "\n" + string(content)}) recorded = append(recorded, storepkg.ProjectionEntry{Family: storepkg.FamilyWorkflows, EntryID: id}) } // One apply, one request: a retried PutResource reuses the same request ID diff --git a/internal/domain/workflow/definition.go b/internal/domain/workflow/definition.go index 64e05315d..811949bbe 100644 --- a/internal/domain/workflow/definition.go +++ b/internal/domain/workflow/definition.go @@ -18,8 +18,12 @@ import ( // YAMLDefinition is the portable, versioned workflow representation. type YAMLDefinition struct { - ID string `yaml:"id" json:"id"` - Steps []StepRecord `yaml:"steps" json:"steps"` + ID string `yaml:"id" json:"id"` + // Package names the installed package that contributed this workflow. The + // package projector sets it; a run of the workflow is bounded by the + // authority accepted for that package. + Package string `yaml:"package,omitempty" json:"package,omitempty"` + Steps []StepRecord `yaml:"steps" json:"steps"` // WorkflowInterface declares the workflow's inputs, repository mode and // agent profile. task.WorkflowInterface `yaml:",inline" json:",inline"` @@ -108,6 +112,18 @@ func ParseDefinition(src string, registry StepRegistry) (YAMLDefinition, error) return definition, nil } +// PackageOf returns the package a pinned definition was projected from, or +// empty for a workflow the operator wrote. +func PackageOf(src string) string { + var declared struct { + Package string `yaml:"package"` + } + if err := yaml.Unmarshal([]byte(src), &declared); err != nil { + return "" + } + return declared.Package +} + // StageNames returns the names a definition's steps run under, in order. It // reads a definition already pinned, so it decodes without validating. func StageNames(src string) ([]string, error) { diff --git a/internal/forgerpc/forgerpc.go b/internal/forgerpc/forgerpc.go index c965c1bfb..c09b1e375 100644 --- a/internal/forgerpc/forgerpc.go +++ b/internal/forgerpc/forgerpc.go @@ -8,12 +8,14 @@ import ( "errors" "fmt" "log/slog" + "slices" "strings" "time" "github.com/nats-io/nats.go" domainidentity "github.com/samcharles93/archie-core/internal/domain/identity" + "github.com/samcharles93/archie-core/internal/domain/storepkg" "github.com/samcharles93/archie-core/internal/domain/workflow" "github.com/samcharles93/archie-core/internal/forge" "github.com/samcharles93/archie-core/internal/natsrpc" @@ -136,11 +138,18 @@ type Response struct { natsrpc.Envelope } +// Authorities answers what operator accepted for an installed package. A +// package that is not installed, or not accepted, has no authority. +type Authorities interface { + AcceptedAuthority(ctx context.Context, name string) (storepkg.Authority, error) +} + // Server proxies forgerpc requests to a real forge.Forge implementation. type Server struct { - Forge forge.Forge - Runs Runs - Log *slog.Logger + Forge forge.Forge + Runs Runs + Authorities Authorities + Log *slog.Logger } // Register subscribes all handlers on nc under the root (identity-less) @@ -166,8 +175,10 @@ func (s *Server) RegisterFor(nc *nats.Conn, identity string) (unsubscribe func() } // 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 { +// server's identity and that the run's repository is the one targeted. A run +// of a package's workflow also needs the forge permission accepted for that +// package. +func (s *Server) authorize(identity string, target Target, permission string) error { if s.Runs == nil || target.Credential == "" { return errors.New("forge request needs a run credential") } @@ -179,6 +190,20 @@ func (s *Server) authorize(identity string, target Target) error { !strings.EqualFold(task.Owner, target.Owner) || !strings.EqualFold(task.Repo, target.Repo) { return errors.New("forge request is outside its run's repository") } + name := workflow.PackageOf(task.WorkflowDefinitionYAML) + if name == "" { + return nil + } + if s.Authorities == nil { + return fmt.Errorf("package %q: forge permission %q is not accepted", name, permission) + } + accepted, err := s.Authorities.AcceptedAuthority(context.Background(), name) + if err != nil { + return fmt.Errorf("package %q authority: %w", name, err) + } + if !slices.Contains(accepted.ForgePermissions, permission) { + return fmt.Errorf("package %q: forge permission %q is not accepted", name, permission) + } return nil } @@ -188,7 +213,7 @@ func (s *Server) handleComment(identity string, msg *nats.Msg) { s.respond(msg, CommentResponse{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode comment request: %w", err))}) return } - if err := s.authorize(identity, req.Target); err != nil { + if err := s.authorize(identity, req.Target, "comment"); err != nil { s.respond(msg, CommentResponse{Envelope: natsrpc.NewEnvelope(err)}) return } @@ -202,7 +227,7 @@ func (s *Server) handleCloseIssue(identity string, msg *nats.Msg) { 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 { + if err := s.authorize(identity, req.Target, "comment"); err != nil { s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)}) return } @@ -216,7 +241,7 @@ func (s *Server) handleCreatePR(identity string, msg *nats.Msg) { 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 { + if err := s.authorize(identity, req.Target, "open_pr"); err != nil { s.respond(msg, CreatePRResponse{Envelope: natsrpc.NewEnvelope(err)}) return } @@ -230,7 +255,7 @@ func (s *Server) handleLinkBranch(identity string, msg *nats.Msg) { 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 { + if err := s.authorize(identity, req.Target, "open_pr"); err != nil { s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)}) return } @@ -244,7 +269,7 @@ func (s *Server) handleCreateReviewComments(identity string, msg *nats.Msg) { 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 { + if err := s.authorize(identity, req.Target, "review"); err != nil { s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)}) return } @@ -267,7 +292,7 @@ func (s *Server) handleReplyToReview(identity string, msg *nats.Msg) { 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 { + if err := s.authorize(identity, req.Target, "review"); err != nil { s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)}) return } @@ -286,7 +311,7 @@ func (s *Server) handleSetStateLabel(identity string, msg *nats.Msg) { 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 { + if err := s.authorize(identity, req.Target, "comment"); err != nil { s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)}) return } diff --git a/internal/forgerpc/forgerpc_test.go b/internal/forgerpc/forgerpc_test.go index 69e811d76..28250418c 100644 --- a/internal/forgerpc/forgerpc_test.go +++ b/internal/forgerpc/forgerpc_test.go @@ -5,9 +5,19 @@ import ( "errors" "testing" + "github.com/samcharles93/archie-core/internal/domain/storepkg" "github.com/samcharles93/archie-core/internal/domain/workflow" ) +type acceptedByPackage map[string]storepkg.Authority + +func (a acceptedByPackage) AcceptedAuthority(_ context.Context, name string) (storepkg.Authority, error) { + if authority, ok := a[name]; ok { + return authority, nil + } + return storepkg.Authority{}, errors.New("not installed") +} + type runsByToken map[string]*workflow.Task func (r runsByToken) TaskForCredential(_ context.Context, token string) (*workflow.Task, error) { @@ -17,26 +27,41 @@ func (r runsByToken) TaskForCredential(_ context.Context, token string) (*workfl return nil, errors.New("unknown") } -// TestForgeCallStaysInItsRunsRepository pins that a forge call is authorized +// TestForgeCallStaysInItsRunsAuthority 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"}}} +// repository, and for a package's workflow only within the forge permissions +// accepted for that package. +func TestForgeCallStaysInItsRunsAuthority(t *testing.T) { + packaged := "package: triage\nid: triage\n" + s := &Server{ + Runs: runsByToken{ + "live": {Identity: "bot", Owner: "acme", Repo: "app"}, + "pkg": {Identity: "bot", Owner: "acme", Repo: "app", WorkflowDefinitionYAML: packaged}, + "removed": {Identity: "bot", Owner: "acme", Repo: "app", WorkflowDefinitionYAML: "package: gone\nid: gone\n"}, + }, + Authorities: acceptedByPackage{"triage": {ForgePermissions: []string{"comment"}}}, + } + own := func(credential string) Target { return Target{Credential: credential, Owner: "acme", Repo: "app"} } tests := []struct { - name string - identity string - target Target - allowed bool + name string + identity string + target Target + permission string + 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}, + {"own repository", "bot", own("live"), "comment", true}, + {"another repository", "bot", Target{Credential: "live", Owner: "acme", Repo: "other"}, "comment", false}, + {"another identity's server", "other", own("live"), "comment", false}, + {"unknown credential", "bot", own("gone"), "comment", false}, + {"no credential", "bot", Target{Owner: "acme", Repo: "app"}, "comment", false}, + {"operator workflow is not bounded by a package", "bot", own("live"), "open_pr", true}, + {"package workflow within its accepted permissions", "bot", own("pkg"), "comment", true}, + {"package workflow beyond its accepted permissions", "bot", own("pkg"), "open_pr", false}, + {"package workflow whose package is gone", "bot", own("removed"), "comment", 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 { + if err := s.authorize(tt.identity, tt.target, tt.permission); (err == nil) != tt.allowed { t.Fatalf("err %v, want allowed %v", err, tt.allowed) } })