feat(controlplane): playbooks and agent profiles install from packages; the daemon reads eda-playbooks live

This commit is contained in:
sam committed 2026-10-04 13:49:03 +11:00
1 parent 5d03513633
commit f0b34892da
17 files changed
+475 -141

No files matched your search

-1
View File
@@ -20,7 +20,6 @@
# workflow_routing_file = "~/.local/share/archie/workflow-routing.yaml" # kind->workflow rebinding (bug/feature/bootstrap)
# workflow_labels_file = "~/.local/share/archie/workflow-labels.yaml" # arbitrary forge label -> workflow (EDA playbook slice 2)
# playbook_dirs = ["~/.local/share/archie/workflows"] # list of dirs of *.yaml binding files, merged with the two above (slice 3); a key bound twice across sources is a load failure
# eda_playbook_dir = "~/.local/share/archie/eda-playbooks" # rich EDA playbook documents (one trigger; either a CEL-gated workflow action or a list of module actions); a matching workflow playbook decides the task's workflow ahead of the three binding sources above; distinct from playbook_dirs
poll_interval = "60s"
label = "archie"
-48
View File
@@ -1,48 +0,0 @@
# Example EDA playbook document (t2db.15 slice).
#
# Install: copy this file into the configured eda_playbook_dir (default
# ~/.config/archie/eda-playbooks) and restart archied. It is loaded at
# startup with the reject-at-load rule: any malformed playbook, a mixed
# workflow/module action shape, or a `when`/args compile failure aborts
# startup with a reported error -- a partially-valid set never runs.
#
# This file is the workflow playbook shape: exactly one action, position:
# workflow. Action playbooks (one or more module actions) load and type-check
# but do not execute yet.
#
# A trigger matches on either axis, and both are checked when both are given:
#
# kind: the closed workintake routing vocabulary -- bug, feature,
# bootstrap, default. It is closed because a kind also addresses the
# task's NATS subject; anything else is rejected at load. Set it
# when you want the rule to follow archie's own classification.
# labels: any labels you like, including ones no kind recognises
# ("ops::security-review"). All of them must be present on the
# issue. This is the axis an instance defines for itself: it binds
# your own taxonomy to a workflow with no code change. See
# label-trigger.yaml. The `when` condition is a CEL
# expression over `event`.
#
# A matching playbook decides the task's workflow ahead of the kind/label
# binding files, and a workflow it names that is not defined parks the task
# rather than falling back. For a forge-discovered task, `event` carries:
#
# kind routing kind the labels produced (bug/feature/bootstrap/default)
# labels the issue's labels, as a list
# owner repo owner
# repo repo name
# number issue number
# title issue title
# body issue body
# source "forge" or "chat"
#
# Reading a field that is not in that set is an evaluation error, which the
# coordinator treats as the condition being false (the playbook is skipped).
trigger:
kind: bug
actions:
- position: workflow
workflow: tdd
when: '"regression" in event.labels'
-19
View File
@@ -1,19 +0,0 @@
# Example EDA playbook triggering on an instance-defined label.
#
# The kind axis (bug/feature/bootstrap/default) is archie's own closed
# classification. This file is the other axis: a label set of your own
# choosing, matched as a subset of the issue's labels. Every label listed here
# must be present on the issue for the playbook to fire.
#
# A matching playbook decides the task's workflow ahead of the
# workflow_routing_file, workflow_labels_file and playbook_dirs bindings. The
# workflow it names must be a defined workflow; naming one that is not parks
# the task with a reported error rather than quietly running a different one.
trigger:
labels:
- ops::security-review
actions:
- position: workflow
workflow: feasibility
+1 -1
View File
@@ -1,6 +1,6 @@
# An agent profile image: the archie-agent image plus network lookup tools,
# for a workflow that investigates addresses rather than code. Select it with
# [containers.profiles.network-investigator] image = "archie-agent-net:local".
# the network-investigator profile package (archipelago: profiles/network-investigator).
#
# Build: docker compose build agent-net
ARG AGENT_IMAGE=ghcr.io/samcharles93/archie-agent:latest
+4 -36
View File
@@ -33,8 +33,6 @@ import (
"github.com/samcharles93/archie-core/internal/domain/access"
"github.com/samcharles93/archie-core/internal/domain/agent"
"github.com/samcharles93/archie-core/internal/domain/applystatus"
"github.com/samcharles93/archie-core/internal/domain/eda/module"
"github.com/samcharles93/archie-core/internal/domain/eda/playbook"
"github.com/samcharles93/archie-core/internal/domain/health"
"github.com/samcharles93/archie-core/internal/domain/identity"
"github.com/samcharles93/archie-core/internal/domain/presence"
@@ -88,10 +86,6 @@ type boot struct {
forgeClient forge.Forge
token string
modules *module.ModuleRegistry
playbooks *playbook.Store
// stateStore is the State Store contract adapter every daemon and gateway
// store consumer depends on. It is ALWAYS the remote *staterpc.Client
// dialed to the standalone archie-state-store gRPC service at
@@ -479,10 +473,6 @@ func (b *boot) loadWorkflows() error {
if err := b.loadWorkflowRouting(cfg, log); err != nil {
return err
}
b.modules = module.New()
if err := b.loadEDAPlaybooks(cfg, log); err != nil {
return err
}
log.Info("workflow step registry built", "shipped_workflows", len(workflow.ShippedDefinitions().Definitions))
return nil
@@ -524,24 +514,6 @@ func (b *boot) loadWorkflowRouting(cfg config.Config, log *slog.Logger) error {
return nil
}
// loadEDAPlaybooks loads the EDA playbook documents: trigger + workflow-kind
// actions and module-kind action playbooks with CEL when conditions and args
// values. Loaded at startup with the same reject-at-load rule -- any malformed
// playbook, mixed/unsupported action shape, unknown module kind, when compile
// failure, or args key failure aborts startup, matching the routing-file load
// pattern (not degrade-and-skip). A nonexistent dir is an empty store. Action
// playbooks run through the daemon once buildDaemon wires the dispatch ledger.
func (b *boot) loadEDAPlaybooks(cfg config.Config, log *slog.Logger) error {
var err error
b.playbooks, err = playbook.Load(cfg.EDAPlaybookDir, b.modules)
if err != nil {
log.Error("eda playbook load failed", "dir", cfg.EDAPlaybookDir, "err", err)
return err
}
log.Info("eda playbooks loaded", "dir", cfg.EDAPlaybookDir, "playbooks", len(b.playbooks.Playbooks))
return nil
}
func (b *boot) buildWorktreeManager() {
cfg := b.cfg
b.trees = &worktree.Manager{
@@ -644,7 +616,7 @@ func (b *boot) buildDaemon() {
LabelWorkflows: b.labelWorkflows,
WorkflowDefinitions: b.workflowDefinitions,
WorkflowEnablement: b.controlPlane,
Playbooks: b.playbooks,
Playbooks: controlplane.NewLivePlaybooks(b.controlPlaneRPC, b.log),
}
if identities, ok := b.stateStore.(identity.Repository); ok {
@@ -680,19 +652,15 @@ func (b *boot) buildDaemon() {
b.d.Denials = denials
}
}
b.d.PlaybookLedger = playbookLedger(b.stateStore, b.playbooks, b.log)
b.d.PlaybookLedger = playbookLedger(b.stateStore, b.log)
b.setupForgeWebhook()
}
func playbookLedger(source any, playbooks *playbook.Store, log *slog.Logger) storecontract.PlaybookDispatcher {
func playbookLedger(source any, log *slog.Logger) storecontract.PlaybookDispatcher {
if pd, ok := source.(storecontract.PlaybookDispatcher); ok {
return pd
}
for _, pb := range playbooks.Playbooks {
if pb.IsActionPlaybook() {
log.Warn("eda action playbook will not run: no dispatch ledger is wired", "playbook", pb.ID)
}
}
log.Warn("eda action playbooks will not run: no dispatch ledger is wired")
return nil
}
+1 -1
View File
@@ -44,7 +44,7 @@ func runLint(args []string, stderr io.Writer) int {
flags.SetOutput(stderr)
var dirs multiFlag
flags.Var(&dirs, "dir", "routing binding directory to lint (repeatable)")
edaDir := flags.String("eda-dir", "", "EDA playbook directory to lint (the daemon's eda_playbook_dir)")
edaDir := flags.String("eda-dir", "", "EDA playbook directory to lint")
if err := flags.Parse(args); err != nil {
return 2 // flag.ContinueOnError already printed the message
}
+2 -2
View File
@@ -37,8 +37,8 @@ func Lint(dirs []string, stderr io.Writer) Result {
return Result{ExitCode: 0, Findings: nil}
}
// LintEDA validates an EDA playbook directory (the daemon's eda_playbook_dir)
// with playbook.Load, the loader the daemon runs at startup.
// LintEDA validates a directory of EDA playbook documents with the compiler
// the eda-playbooks resource validates against.
func LintEDA(dir string, stderr io.Writer) Result {
if _, err := playbook.Load(dir, module.New()); err != nil {
fmt.Fprintln(stderr, err)
+1 -1
View File
@@ -8,7 +8,7 @@ import (
// Schemas are not declared here: each Definition names its document type, and
// Definition.Descriptor derives the JSON Schema from it (internal/app/controlplane/schema.go).
func builtinDefinitions(steps workflow.StepRegistry) []Definition {
definitions := []Definition{workflowDefinition(), workflowDefinitionsDefinition(steps), workflowEnablementDefinition(), personaDefinition(), scheduleDefinition(), agentProfileDefinition(), credentialBindingsDefinition(), reviewSettingsDefinition()}
definitions := []Definition{workflowDefinition(), workflowDefinitionsDefinition(steps), workflowEnablementDefinition(), personaDefinition(), scheduleDefinition(), agentProfileDefinition(), playbooksDefinition(), credentialBindingsDefinition(), reviewSettingsDefinition()}
definitions = append(definitions, modelDefinitions()...)
definitions = append(definitions, operationalDefinitions()...)
return definitions
@@ -0,0 +1,47 @@
package controlplane
import (
"context"
"errors"
"fmt"
"strconv"
"time"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
)
// projectDocument edits one org resource on behalf of an installed package.
// Each attempt re-reads the stored document and re-applies edit, so an
// operator edit made during the projection is folded in, and only a
// persistently moving document refuses it. edit receives nil for a resource
// the org never wrote.
func projectDocument(ctx context.Context, store ResourceStore, orgID, kind, source, requestPrefix string, edit func(current []byte) ([]byte, error)) error {
requestID := requestPrefix + ":" + strconv.FormatInt(time.Now().UTC().UnixNano(), 36)
for attempt := 0; ; attempt++ {
var current []byte
var version int64
resource, err := store.Resource(ctx, orgID, kind)
switch {
case errors.Is(err, storecontract.ErrResourceNotFound):
case err != nil:
return err
default:
current, version = resource.Value, resource.Version
}
value, err := edit(current)
if err != nil {
return err
}
_, err = store.PutResource(ctx, storecontract.ResourceWrite{
OrgID: orgID, Kind: kind, Value: value, ExpectedVersion: version,
Actor: projectionActor, Source: source, RequestID: requestID,
})
if errors.Is(err, storecontract.ErrResourceVersionConflict) && attempt < projectWriteAttempts-1 {
continue
}
if err != nil {
return fmt.Errorf("write %s: %w", kind, err)
}
return nil
}
}
+160
View File
@@ -0,0 +1,160 @@
package controlplane
import (
"context"
"encoding/json"
"errors"
"fmt"
"path"
"slices"
"strings"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/eda/module"
"github.com/samcharles93/archie-core/internal/domain/eda/playbook"
"github.com/samcharles93/archie-core/internal/domain/storepkg"
)
// PlaybooksKind is the control-plane resource holding the org's EDA playbook
// documents.
const PlaybooksKind = "eda-playbooks"
// PlaybookCollection is the eda-playbooks document: playbook sources under
// their stable ids.
type PlaybookCollection struct {
Playbooks []PlaybookEntry `json:"playbooks"`
}
type PlaybookEntry struct {
ID string `json:"id"`
YAML string `json:"yaml"`
}
func playbooksDefinition() Definition {
return Definition{
Kind: PlaybooksKind,
Title: "EDA playbooks",
Document: PlaybookCollection{},
ApplyMode: "live",
Seed: func(config.Config) any { return PlaybookCollection{Playbooks: []PlaybookEntry{}} },
Validate: func(input []byte) error {
return validateAs(input, func(c PlaybookCollection) error {
_, err := CompilePlaybooks(c)
return err
})
},
}
}
// CompilePlaybooks compiles a collection against the module vocabulary. Any
// invalid playbook fails the set.
func CompilePlaybooks(c PlaybookCollection) (*playbook.Store, error) {
docs := make([]playbook.Document, 0, len(c.Playbooks))
seen := map[string]bool{}
for _, entry := range c.Playbooks {
if entry.ID == "" || seen[entry.ID] {
return nil, fmt.Errorf("%w: playbook id %q is empty or repeated", ErrValidation, entry.ID)
}
seen[entry.ID] = true
docs = append(docs, playbook.Document{ID: entry.ID, YAML: []byte(entry.YAML)})
}
store, err := playbook.Compile(docs, module.New())
if err != nil {
return nil, fmt.Errorf("%w: %w", ErrValidation, err)
}
return store, nil
}
// PlaybookProjector merges an installed package's playbooks into the org's
// eda-playbooks resource. Ids owned by an operator or another package are
// refused.
type PlaybookProjector struct {
store ResourceStore
ledger storepkg.ProjectionLedger
}
var _ storepkg.FamilyProjector = (*PlaybookProjector)(nil)
func NewPlaybookPackageProjector(resources ResourceStore, ledger storepkg.ProjectionLedger) (*PlaybookProjector, error) {
if resources == nil || ledger == nil {
return nil, errors.New("control plane: playbook projection needs a resource store and a contributions ledger")
}
return &PlaybookProjector{store: resources, ledger: ledger}, nil
}
func (p *PlaybookProjector) Apply(ctx context.Context, orgID, name, digest string, contents map[string][]byte) error {
incoming := make([]PlaybookEntry, 0, len(contents))
recorded := make([]storepkg.ProjectionEntry, 0, len(contents))
for contentName, content := range contents {
id := path.Base(contentName)
incoming = append(incoming, PlaybookEntry{ID: id, YAML: string(content)})
recorded = append(recorded, storepkg.ProjectionEntry{Family: storepkg.FamilyPlaybooks, EntryID: id})
}
slices.SortFunc(incoming, func(a, b PlaybookEntry) int { return strings.Compare(a.ID, b.ID) })
err := projectDocument(ctx, p.store, orgID, PlaybooksKind, "package:"+name+"@"+digest, "package-project:"+digest, func(current []byte) ([]byte, error) {
collection, err := decodePlaybooks(current)
if err != nil {
return nil, err
}
for _, entry := range collection.Playbooks {
if slices.ContainsFunc(incoming, func(in PlaybookEntry) bool { return in.ID == entry.ID }) {
return nil, fmt.Errorf("package %q: %w: playbook %q", name, storepkg.ErrContributionCollision, entry.ID)
}
}
collection.Playbooks = append(collection.Playbooks, incoming...)
return encodePlaybooks(collection)
})
if err != nil {
return err
}
if err := p.ledger.Record(ctx, orgID, name, recorded); err != nil {
return fmt.Errorf("record contributions of %q: %w", name, err)
}
return nil
}
func (p *PlaybookProjector) Withdraw(ctx context.Context, orgID, name, digest string) error {
entries, err := p.ledger.Entries(ctx, orgID, name)
if err != nil {
return fmt.Errorf("entries of package %q: %w", name, err)
}
var withdrawn []string
for _, entry := range entries {
if entry.Family == storepkg.FamilyPlaybooks {
withdrawn = append(withdrawn, entry.EntryID)
}
}
if len(withdrawn) == 0 {
return nil
}
err = projectDocument(ctx, p.store, orgID, PlaybooksKind, "package-withdraw:"+name+"@"+digest, "package-withdraw:"+digest, func(current []byte) ([]byte, error) {
collection, err := decodePlaybooks(current)
if err != nil {
return nil, err
}
collection.Playbooks = slices.DeleteFunc(collection.Playbooks, func(e PlaybookEntry) bool { return slices.Contains(withdrawn, e.ID) })
return encodePlaybooks(collection)
})
if err != nil {
return err
}
return p.ledger.Forget(ctx, orgID, name, storepkg.FamilyPlaybooks)
}
func decodePlaybooks(value []byte) (PlaybookCollection, error) {
collection := PlaybookCollection{Playbooks: []PlaybookEntry{}}
if value == nil {
return collection, nil
}
if err := json.Unmarshal(value, &collection); err != nil {
return PlaybookCollection{}, fmt.Errorf("decode %s: %w", PlaybooksKind, err)
}
return collection, nil
}
func encodePlaybooks(collection PlaybookCollection) ([]byte, error) {
if _, err := CompilePlaybooks(collection); err != nil {
return nil, err
}
return json.Marshal(collection)
}
@@ -0,0 +1,70 @@
package controlplane
import (
"context"
"encoding/json"
"log/slog"
"sync"
"time"
pb "github.com/samcharles93/archie-core/internal/contracts/controlplane/v1"
"github.com/samcharles93/archie-core/internal/domain/eda/playbook"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/infrastructure/controlplanerpc"
)
const playbookQueryTimeout = 5 * time.Second
// LivePlaybooks serves the daemon the org's eda-playbooks resource. Each call
// reads the resource's version and recompiles only when it moved, so an
// install or an operator edit applies to the next task. A control plane that
// cannot be reached, or a document that no longer compiles, leaves the last
// good set in force.
type LivePlaybooks struct {
rpc pb.ControlPlaneServiceClient
log *slog.Logger
mu sync.Mutex
version int64
store *playbook.Store
}
func NewLivePlaybooks(client pb.ControlPlaneServiceClient, log *slog.Logger) *LivePlaybooks {
return &LivePlaybooks{rpc: client, log: log}
}
func (l *LivePlaybooks) current(ctx context.Context) *playbook.Store {
l.mu.Lock()
defer l.mu.Unlock()
ctx, cancel := context.WithTimeout(ctx, playbookQueryTimeout)
defer cancel()
response, err := l.rpc.Query(ctx, controlplanerpc.QueryRequest(ctx, PlaybooksKind))
if err != nil {
l.log.Warn("eda playbooks unavailable; keeping the last good set", "err", controlplanerpc.ClientError(err))
return l.store
}
if l.store != nil && response.Resource.Version == l.version {
return l.store
}
var collection PlaybookCollection
if err := json.Unmarshal(response.Resource.ValueJson, &collection); err != nil {
l.log.Error("eda playbooks undecodable; keeping the last good set", "err", err)
return l.store
}
store, err := CompilePlaybooks(collection)
if err != nil {
l.log.Error("eda playbooks do not compile; keeping the last good set", "err", err)
return l.store
}
l.version, l.store = response.Resource.Version, store
l.log.Info("eda playbooks loaded", "version", l.version, "playbooks", len(store.Playbooks))
return store
}
func (l *LivePlaybooks) Dispatch(input playbook.DispatchInput) (playbook.Decision, bool) {
return l.current(context.Background()).Dispatch(input)
}
func (l *LivePlaybooks) Run(ctx context.Context, ledger storecontract.PlaybookDispatcher, log *slog.Logger, input playbook.DispatchInput) error {
return l.current(ctx).Run(ctx, ledger, log, input)
}
@@ -0,0 +1,133 @@
package controlplane
import (
"context"
"encoding/json"
"errors"
"fmt"
"slices"
"gopkg.in/yaml.v3"
"github.com/samcharles93/archie-core/internal/domain/storepkg"
)
// profileFile is one contributed profile: a name and the profile it defines.
// The image is a reference to a published image, never a build.
type profileFile struct {
Name string `yaml:"name"`
Image string `yaml:"image"`
Kit string `yaml:"kit"`
Adapter string `yaml:"adapter"`
Tools []string `yaml:"tools"`
}
// ProfileProjector merges an installed package's agent profiles into the
// org's agent-profiles resource. Names owned by an operator or another
// package are refused.
type ProfileProjector struct {
store ResourceStore
ledger storepkg.ProjectionLedger
}
var _ storepkg.FamilyProjector = (*ProfileProjector)(nil)
func NewProfilePackageProjector(resources ResourceStore, ledger storepkg.ProjectionLedger) (*ProfileProjector, error) {
if resources == nil || ledger == nil {
return nil, errors.New("control plane: profile projection needs a resource store and a contributions ledger")
}
return &ProfileProjector{store: resources, ledger: ledger}, nil
}
func (p *ProfileProjector) Apply(ctx context.Context, orgID, name, digest string, contents map[string][]byte) error {
incoming := make(map[string]agentProfile, len(contents))
recorded := make([]storepkg.ProjectionEntry, 0, len(contents))
for contentName, content := range contents {
var file profileFile
if err := yaml.Unmarshal(content, &file); err != nil {
return fmt.Errorf("contributed profile %q: %w", contentName, err)
}
if file.Name == "" {
return fmt.Errorf("contributed profile %q has no name", contentName)
}
incoming[file.Name] = agentProfile{Image: file.Image, Kit: file.Kit, Adapter: file.Adapter, Tools: file.Tools}
recorded = append(recorded, storepkg.ProjectionEntry{Family: storepkg.FamilyProfiles, EntryID: file.Name})
}
err := projectDocument(ctx, p.store, orgID, AgentProfileKind, "package:"+name+"@"+digest, "package-project:"+digest, func(current []byte) ([]byte, error) {
profiles, err := decodeProfiles(current)
if err != nil {
return nil, err
}
for profile, value := range incoming {
if _, taken := profiles[profile]; taken {
return nil, fmt.Errorf("package %q: %w: profile %q", name, storepkg.ErrContributionCollision, profile)
}
profiles[profile] = value
}
return encodeProfiles(profiles)
})
if err != nil {
return err
}
if err := p.ledger.Record(ctx, orgID, name, recorded); err != nil {
return fmt.Errorf("record contributions of %q: %w", name, err)
}
return nil
}
func (p *ProfileProjector) Withdraw(ctx context.Context, orgID, name, digest string) error {
entries, err := p.ledger.Entries(ctx, orgID, name)
if err != nil {
return fmt.Errorf("entries of package %q: %w", name, err)
}
var withdrawn []string
for _, entry := range entries {
if entry.Family == storepkg.FamilyProfiles {
withdrawn = append(withdrawn, entry.EntryID)
}
}
if len(withdrawn) == 0 {
return nil
}
err = projectDocument(ctx, p.store, orgID, AgentProfileKind, "package-withdraw:"+name+"@"+digest, "package-withdraw:"+digest, func(current []byte) ([]byte, error) {
profiles, err := decodeProfiles(current)
if err != nil {
return nil, err
}
for profile := range profiles {
if slices.Contains(withdrawn, profile) {
delete(profiles, profile)
}
}
return encodeProfiles(profiles)
})
if err != nil {
return err
}
return p.ledger.Forget(ctx, orgID, name, storepkg.FamilyProfiles)
}
func decodeProfiles(value []byte) (map[string]agentProfile, error) {
profiles := map[string]agentProfile{}
if value == nil {
return profiles, nil
}
if err := json.Unmarshal(value, &profiles); err != nil {
return nil, fmt.Errorf("decode %s: %w", AgentProfileKind, err)
}
if profiles == nil {
profiles = map[string]agentProfile{}
}
return profiles, nil
}
func encodeProfiles(profiles map[string]agentProfile) ([]byte, error) {
value, err := json.Marshal(profiles)
if err != nil {
return nil, err
}
if err := validateAgentProfiles(value); err != nil {
return nil, fmt.Errorf("%w: %w", ErrValidation, err)
}
return value, nil
}
+16 -3
View File
@@ -499,8 +499,8 @@ func stateStoreServerOpts(listen, token string, grants *staterpc.TaskGrants) (op
}
// newPackageProjections builds the family projectors an installed package's
// contributions apply through: workflows become org workflow definitions, the
// one resource kind the runtime reads live today. The step vocabulary
// contributions apply through: workflows, playbooks and agent profiles become
// the org resources the runtime reads live. The step vocabulary
// (stepVocabulary) is the same one this process's control plane validates
// dashboard edits with, so a definition the projector admits is compilable
// where it dispatches (openStateStoreControlPlane for the pairing).
@@ -514,5 +514,18 @@ func newPackageProjections(pool *pgxpool.Pool) (map[string]storepkg.FamilyProjec
if err != nil {
return nil, fmt.Errorf("build workflow package projector: %w", err)
}
return map[string]storepkg.FamilyProjector{storepkg.FamilyWorkflows: workflows}, nil
resources, ledger := postgres.NewResources(pool), postgres.NewPackageContributions(pool)
playbooks, err := controlplane.NewPlaybookPackageProjector(resources, ledger)
if err != nil {
return nil, fmt.Errorf("build playbook package projector: %w", err)
}
profiles, err := controlplane.NewProfilePackageProjector(resources, ledger)
if err != nil {
return nil, fmt.Errorf("build profile package projector: %w", err)
}
return map[string]storepkg.FamilyProjector{
storepkg.FamilyWorkflows: workflows,
storepkg.FamilyPlaybooks: playbooks,
storepkg.FamilyProfiles: profiles,
}, nil
}
-3
View File
@@ -370,9 +370,6 @@ type Config struct {
// PlaybookDirs are optional directories of kind/label-to-workflow binding
// files. A key bound in more than one file is a load error.
PlaybookDirs []string `toml:"playbook_dirs" yaml:"playbook_dirs"`
// EDAPlaybookDir is an optional directory of EDA playbook documents: a
// trigger plus ordered actions with CEL conditions.
EDAPlaybookDir string `toml:"eda_playbook_dir" yaml:"eda_playbook_dir"`
// MaxRetries caps how many times a parked task is retried before
// being permanently parked (status "dead"). Defaults to 3.
MaxRetries int `toml:"max_retries" yaml:"max_retries"`
+29 -24
View File
@@ -46,7 +46,7 @@ type Store struct {
// Playbook is one trigger+actions document.
type Playbook struct {
// ID is the playbook's path relative to the directory root.
// ID is the playbook's stable name.
ID string
// Version is a content hash of the loaded file, recomputed on every
// load. It pins dispatched-run provenance to the exact definition active
@@ -198,6 +198,12 @@ func validateModuleActionIDs(path string, actions []rawAction) error {
return nil
}
// Document is one playbook's source text under its stable id.
type Document struct {
ID string
YAML []byte
}
// Load reads and compiles every playbook in dir. Any invalid playbook fails
// the load. A missing directory is an empty store.
func Load(dir string, modules Modules) (*Store, error) {
@@ -209,21 +215,30 @@ func Load(dir string, modules Modules) (*Store, error) {
return nil, fmt.Errorf("read playbook dir %s: %w", dir, err)
}
var names []string
var docs []Document
for _, e := range entries {
if e.IsDir() {
continue
}
if ext := strings.ToLower(filepath.Ext(e.Name())); ext == ".yaml" || ext == ".yml" {
names = append(names, e.Name())
if ext := strings.ToLower(filepath.Ext(e.Name())); ext != ".yaml" && ext != ".yml" {
continue
}
data, err := os.ReadFile(filepath.Join(dir, e.Name()))
if err != nil {
return nil, fmt.Errorf("read playbook %s: %w", e.Name(), err)
}
docs = append(docs, Document{ID: e.Name(), YAML: data})
}
sort.Strings(names)
return Compile(docs, modules)
}
// Compile validates and compiles playbook documents in id order. Any invalid
// playbook fails the whole set: a partially valid set never runs.
func Compile(docs []Document, modules Modules) (*Store, error) {
sort.Slice(docs, func(i, j int) bool { return docs[i].ID < docs[j].ID })
store := &Store{modules: modules}
for _, name := range names {
path := filepath.Join(dir, name)
pb, err := loadOne(dir, path, modules)
for _, doc := range docs {
pb, err := compileOne(doc, modules)
if err != nil {
return nil, err
}
@@ -232,27 +247,17 @@ func Load(dir string, modules Modules) (*Store, error) {
return store, nil
}
// loadOne loads and validates a single playbook file, deriving its stable ID
// (path relative to the configured root) and a content-hash Version.
func loadOne(dir, path string, schemas KindSchemas) (*Playbook, error) {
data, err := os.ReadFile(path)
if err != nil {
return nil, fmt.Errorf("read playbook %s: %w", path, err)
}
id := path
if rel, relErr := filepath.Rel(dir, path); relErr == nil {
id = rel
}
// compileOne validates a single playbook, deriving its content-hash Version.
func compileOne(doc Document, schemas KindSchemas) (*Playbook, error) {
path := doc.ID
var raw rawPlaybook
if err := yaml.Unmarshal(data, &raw); err != nil {
if err := yaml.Unmarshal(doc.YAML, &raw); err != nil {
return nil, fmt.Errorf("parse playbook %s: %w", path, err)
}
pb := &Playbook{
ID: filepath.ToSlash(id),
Version: fmt.Sprintf("%x", sha256.Sum256(data)),
ID: path,
Version: fmt.Sprintf("%x", sha256.Sum256(doc.YAML)),
Trigger: Trigger{
Kind: workintake.Kind(strings.TrimSpace(raw.Trigger.Kind)),
Labels: raw.Trigger.Labels,
+7 -1
View File
@@ -13,11 +13,13 @@ const (
FamilySkills = "skills"
FamilyMCPServer = "mcpServers"
FamilyDefaults = "defaults"
FamilyPlaybooks = "playbooks"
FamilyProfiles = "profiles"
)
// families is the family order projection follows, for a deterministic
// install and withdrawal.
var families = []string{FamilyWorkflows, FamilyPrompts, FamilySkills, FamilyMCPServer, FamilyDefaults}
var families = []string{FamilyWorkflows, FamilyPrompts, FamilySkills, FamilyMCPServer, FamilyDefaults, FamilyPlaybooks, FamilyProfiles}
// familyNames returns the names one descriptor family contributes.
func (c Contributions) familyNames(family string) []string {
@@ -32,6 +34,10 @@ func (c Contributions) familyNames(family string) []string {
return c.MCPServers
case FamilyDefaults:
return c.Defaults
case FamilyPlaybooks:
return c.Playbooks
case FamilyProfiles:
return c.Profiles
default:
return nil
}
+4 -1
View File
@@ -36,6 +36,8 @@ type Contributions struct {
Skills []string `yaml:"skills"`
MCPServers []string `yaml:"mcpServers"`
Defaults []string `yaml:"defaults"`
Playbooks []string `yaml:"playbooks"`
Profiles []string `yaml:"profiles"`
// Extensions are executable plugins the host launches as processes. They
// are the only package files allowed to carry an executable mode.
Extensions []Extension `yaml:"extensions"`
@@ -171,7 +173,8 @@ func (d Descriptor) validateExtensions() (map[string]bool, error) {
func (d Descriptor) hasContribution() bool {
return len(d.Contributes.Workflows)+len(d.Contributes.Prompts)+len(d.Contributes.Skills)+
len(d.Contributes.MCPServers)+len(d.Contributes.Defaults)+len(d.Contributes.Extensions) > 0
len(d.Contributes.MCPServers)+len(d.Contributes.Defaults)+len(d.Contributes.Playbooks)+
len(d.Contributes.Profiles)+len(d.Contributes.Extensions) > 0
}
func validForgePermission(permission string) bool {