(#175) Add podinfo oci example

This patch adds to more example helm chart based components.  podinfo
installs as a normal https repository based helm chart.  podinfo-oci
uses an oci image to manage the helm chart.

The way holos handls OCI images is subtle, so it's good to include an
example right out of the chute.  Github actions uses OCI images for
example.

docs/examples/platform.config.cue

@@ -0,0 +1,3 @@
+package holos
+
+_platform_config: string @tag(platform_config, type=string)

docs/examples/platform.config.json

@@ -0,0 +1 @@
+{}

internal/builder/platform.go

@@ -24,17 +24,18 @@ func (b *Builder) Platform(ctx context.Context, cfg *client.Config) (*v1alpha1.P
 		return nil, errors.Wrap(err)
 	}
 
-	// We only process the first instance, assume the render platform subcommand enforces this.
-	for idx, instance := range instances {
-		log.DebugContext(ctx, "cue: building instance", "idx", idx, "dir", instance.Dir)
-		p, err := b.runPlatform(ctx, instance)
-		if err != nil {
-			return nil, errors.Wrap(fmt.Errorf("could not build platform: %w", err))
-		}
-		return p, nil
+	if len(instances) != 1 {
+		return nil, errors.Wrap(errors.New(fmt.Sprintf("instances length %d must be exactly 1", len(instances))))
 	}
 
-	return nil, errors.Wrap(errors.New("missing platform instance"))
+	// We only process the first instance, assume the render platform subcommand enforces this.
+	instance := instances[0]
+	log.DebugContext(ctx, "cue: building instance", "dir", instance.Dir)
+	p, err := b.runPlatform(ctx, instance)
+	if err != nil {
+		return nil, errors.Wrap(fmt.Errorf("could not build platform: %w", err))
+	}
+	return p, nil
 }
 
 func (b Builder) runPlatform(ctx context.Context, instance *build.Instance) (*v1alpha1.Platform, error) {

internal/cli/build/build.go

@@ -10,6 +10,7 @@ import (
 	"github.com/holos-run/holos/internal/client"
 	"github.com/holos-run/holos/internal/errors"
 	"github.com/holos-run/holos/internal/holos"
+	"github.com/holos-run/holos/internal/server/middleware/logger"
 	"github.com/spf13/cobra"
 )
 
@@ -17,6 +18,7 @@ import (
 func makeBuildRunFunc(cfg *client.Config) command.RunFunc {
 	return func(cmd *cobra.Command, args []string) error {
 		ctx := cmd.Root().Context()
+		logger.FromContext(ctx).DebugContext(ctx, "RunE", "args", args)
 		build := builder.New(builder.Entrypoints(args), builder.Cluster(cfg.Holos().ClusterName()))
 		results, err := build.Run(ctx, cfg)
 		if err != nil {

internal/cli/generate/generate.go

@@ -2,6 +2,8 @@ package generate
 
 import (
 	"fmt"
+	"log/slog"
+	"path/filepath"
 	"strings"
 
 	"github.com/holos-run/holos/internal/cli/command"
@@ -20,6 +22,7 @@ func New(cfg *holos.Config) *cobra.Command {
 	cmd.Args = cobra.NoArgs
 
 	cmd.AddCommand(NewPlatform(cfg))
+	cmd.AddCommand(NewComponent())
 
 	return cmd
 }
@@ -40,6 +43,81 @@ func NewPlatform(cfg *holos.Config) *cobra.Command {
 				return errors.Wrap(err)
 			}
 		}
+
+		return nil
+	}
+
+	return cmd
+}
+
+// NewComponent returns a command to generate a holos component
+func NewComponent() *cobra.Command {
+	cmd := command.New("component")
+	cmd.Short = "generate a component from an embedded schematic"
+
+	cmd.AddCommand(NewCueComponent())
+	cmd.AddCommand(NewHelmComponent())
+
+	return cmd
+}
+
+func NewHelmComponent() *cobra.Command {
+	cmd := command.New("helm")
+	cmd.Short = "generate a helm component from a schematic"
+
+	for _, name := range generate.HelmComponents() {
+		cmd.AddCommand(makeHelmCommand(name))
+	}
+
+	return cmd
+}
+
+func NewCueComponent() *cobra.Command {
+	cmd := command.New("cue")
+	cmd.Short = "generate a cue component from a schematic"
+
+	for _, name := range generate.CueComponents() {
+		cmd.AddCommand(makeCueCommand(name))
+	}
+	return cmd
+}
+
+func makeCueCommand(name string) *cobra.Command {
+	cmd := command.New(name)
+	cmd.Short = fmt.Sprintf("generate a %s cue component from an embedded schematic", name)
+	cmd.Args = cobra.NoArgs
+
+	cfg := &generate.CueConfig{}
+	cmd.Flags().AddGoFlagSet(cfg.FlagSet())
+
+	cmd.RunE = func(cmd *cobra.Command, args []string) error {
+		ctx := cmd.Root().Context()
+		if err := generate.GenerateCueComponent(ctx, name, cfg); err != nil {
+			return errors.Wrap(err)
+		}
+		return nil
+	}
+
+	return cmd
+}
+
+func makeHelmCommand(name string) *cobra.Command {
+	cmd := command.New(name)
+	cfg, err := generate.NewSchematic(filepath.Join("components", "helm"), name)
+	if err != nil {
+		slog.Error("could not get schematic", "err", err)
+		return nil
+	}
+	cmd.Short = cfg.Short
+	cmd.Long = cfg.Long
+	cmd.Args = cobra.NoArgs
+	cmd.Flags().AddGoFlagSet(cfg.FlagSet())
+
+	cmd.RunE = func(cmd *cobra.Command, args []string) error {
+		ctx := cmd.Root().Context()
+		if err := generate.GenerateHelmComponent(ctx, name, cfg); err != nil {
+			return errors.Wrap(err)
+		}
 		return nil
 	}
 

internal/generate/component.go

@@ -0,0 +1,204 @@
+package generate
+
+import (
+	"bytes"
+	"context"
+	"embed"
+	"encoding/json"
+	"flag"
+	"io/fs"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"text/template"
+
+	"github.com/holos-run/holos/internal/errors"
+	"github.com/holos-run/holos/internal/server/middleware/logger"
+)
+
+//go:embed all:components
+var components embed.FS
+
+// componentsRoot is the root path to copy component cue code from.
+const componentsRoot = "components"
+
+func NewSchematic(root string, name string) (*Schematic, error) {
+	data, err := components.ReadFile(filepath.Join(root, name, "schematic.json"))
+	if err != nil {
+		return nil, errors.Wrap(err)
+	}
+	schematic := Schematic{Name: name}
+	if err := json.Unmarshal(data, &schematic); err != nil {
+		return nil, errors.Wrap(err)
+	}
+	return &schematic, nil
+}
+
+// Schematic represents the flags and command metadata stored in the
+// schematic.yaml file along side each schematic.
+type Schematic struct {
+	// Name represents the name of the resource the schematic generates.
+	Name string `json:"name,omitempty" yaml:"name,omitempty"`
+
+	Short string `json:"short,omitempty" yaml:"short,omitempty"`
+	Long  string `json:"long,omitempty" yaml:"long,omitempty"`
+
+	Chart     *string `json:"chart,omitempty" yaml:"chart,omitempty"`
+	Version   *string `json:"version,omitempty" yaml:"version,omitempty"`
+	Namespace *string `json:"namespace,omitempty" yaml:"namespace,omitempty"`
+
+	RepoName *string `json:"reponame,omitempty" yaml:"reponame,omitempty"`
+	RepoURL  *string `json:"repourl,omitempty" yaml:"repourl,omitempty"`
+
+	flagSet *flag.FlagSet
+}
+
+func (s *Schematic) FlagSet() *flag.FlagSet {
+	if s == nil {
+		return nil
+	}
+	if s.flagSet != nil {
+		return s.flagSet
+	}
+	fs := flag.NewFlagSet("", flag.ContinueOnError)
+	fs.StringVar(&s.Name, "name", s.Name, "component name")
+	if s.Chart != nil {
+		fs.StringVar(s.Chart, "chart", *s.Chart, "chart name")
+	}
+	if s.Version != nil {
+		fs.StringVar(s.Version, "component-version", *s.Version, "component version")
+	}
+	if s.Namespace != nil {
+		fs.StringVar(s.Namespace, "namespace", *s.Namespace, "namespace")
+	}
+	if s.RepoName != nil {
+		fs.StringVar(s.RepoName, "repo-name", *s.RepoName, "chart repository name")
+	}
+	if s.RepoURL != nil {
+		fs.StringVar(s.RepoURL, "repo-url", *s.RepoURL, "chart repository url")
+	}
+	s.flagSet = fs
+	return fs
+}
+
+// CueConfig represents the config values passed to cue go templates.
+type CueConfig struct {
+	ComponentName string
+	flagSet       *flag.FlagSet
+}
+
+func (c *CueConfig) FlagSet() *flag.FlagSet {
+	if c == nil {
+		return nil
+	}
+	if c.flagSet != nil {
+		return c.flagSet
+	}
+	fs := flag.NewFlagSet("", flag.ContinueOnError)
+	fs.StringVar(&c.ComponentName, "name", "example", "component name")
+	c.flagSet = fs
+	return fs
+}
+
+type HelmConfig struct {
+	ComponentName string
+	flagSet       *flag.FlagSet
+}
+
+func (c *HelmConfig) FlagSet(name string) *flag.FlagSet {
+	if c == nil {
+		return nil
+	}
+	if c.flagSet != nil {
+		return c.flagSet
+	}
+	fs := flag.NewFlagSet("", flag.ContinueOnError)
+	fs.StringVar(&c.ComponentName, "name", name, "component name")
+	c.flagSet = fs
+	return fs
+}
+
+// CueComponents returns a slice of embedded component schematics or nil if there are none.
+func CueComponents() []string {
+	entries, err := fs.ReadDir(components, filepath.Join(componentsRoot, "cue"))
+	if err != nil {
+		return nil
+	}
+	dirs := make([]string, 0, len(entries))
+	for _, entry := range entries {
+		dirs = append(dirs, entry.Name())
+	}
+	return dirs
+}
+
+// HelmComponents returns a slice of embedded component schematics or nil if there are none.
+func HelmComponents() []string {
+	entries, err := fs.ReadDir(components, filepath.Join(componentsRoot, "helm"))
+	if err != nil {
+		return nil
+	}
+	dirs := make([]string, 0, len(entries))
+	for _, entry := range entries {
+		dirs = append(dirs, entry.Name())
+	}
+	return dirs
+}
+
+// makeRenderFunc makes a template rendering function for embedded files.
+func makeRenderFunc[T any](log *slog.Logger, path string, cfg T) func([]byte) *bytes.Buffer {
+	return func(content []byte) *bytes.Buffer {
+		tmpl, err := template.New(filepath.Base(path)).Parse(string(content))
+		if err != nil {
+			log.Error("could not load template", "err", err)
+			return bytes.NewBuffer(content)
+		}
+
+		var rendered bytes.Buffer
+		if err := tmpl.Execute(&rendered, cfg); err != nil {
+			log.Error("could not execute template", "err", err)
+			return bytes.NewBuffer(content)
+		}
+
+		return &rendered
+	}
+}
+
+// GenerateCueComponent writes the cue code for a component to the local working
+// directory.
+func GenerateCueComponent(ctx context.Context, name string, cfg *CueConfig) error {
+	path := filepath.Join(componentsRoot, "cue", name)
+	dstPath := filepath.Join(getCwd(ctx), cfg.ComponentName)
+	log := logger.FromContext(ctx).With("name", cfg.ComponentName, "path", dstPath)
+	log.DebugContext(ctx, "mkdir")
+	if err := os.MkdirAll(dstPath, os.ModePerm); err != nil {
+		return errors.Wrap(err)
+	}
+
+	mapper := makeRenderFunc(log, path, cfg)
+	if err := copyEmbedFS(ctx, components, path, dstPath, mapper); err != nil {
+		return errors.Wrap(err)
+	}
+
+	log.InfoContext(ctx, "generated component")
+	return nil
+}
+
+// GenerateHelmComponent writes the cue code for a component to the local working
+// directory.
+func GenerateHelmComponent(ctx context.Context, name string, cfg *Schematic) error {
+	path := filepath.Join(componentsRoot, "helm", name)
+	dstPath := filepath.Join(getCwd(ctx), cfg.Name)
+	log := logger.FromContext(ctx).With("name", cfg.Name, "path", dstPath)
+	log.DebugContext(ctx, "mkdir")
+	if err := os.MkdirAll(dstPath, os.ModePerm); err != nil {
+		return errors.Wrap(err)
+	}
+
+	mapper := makeRenderFunc(log, path, cfg)
+	if err := copyEmbedFS(ctx, components, path, dstPath, mapper); err != nil {
+		return errors.Wrap(err)
+	}
+
+	log.InfoContext(ctx, "generated component")
+	return nil
+}

internal/generate/components/cue/minimal/component.cue

@@ -0,0 +1,33 @@
+package holos
+
+import v1 "github.com/holos-run/holos/api/v1alpha1"
+
+import "encoding/yaml"
+
+let ComponentName = "{{ .ComponentName }}"
+
+// The BuildPlan represents the kubernetes api objects to manage.  CUE returns
+// the build plan to the holos CLI for rendering to plain yaml files.
+v1.#BuildPlan & {
+	spec: components: resources: "\(ComponentName)": {
+		metadata: name: ComponentName
+		apiObjectMap: OBJECTS.apiObjectMap
+	}
+}
+
+// OBJECTS represents the kubernetes api objects to manage.
+let OBJECTS = v1.#APIObjects & {
+	// Add Kubernetes API Objects to manage here.
+	apiObjects: ConfigMap: "\(ComponentName)": {
+		metadata: {
+			name:      ComponentName
+			namespace: "default"
+		}
+		data: platform: yaml.Marshal(PLATFORM)
+	}
+}
+
+// This is an example of how to refer to the Platform model.
+let PLATFORM = {
+	spec: model: _Platform.spec.model
+}

internal/generate/components/helm/cert-manager/cert-manager.cue

@@ -0,0 +1,20 @@
+package holos
+
+// Produce a helm chart build plan.
+(#Helm & Chart).Output
+
+let Chart = {
+	Name:      "{{ .Name }}"
+	Version:   "{{ .Version }}"
+	Namespace: "{{ .Namespace }}"
+
+	Repo: name: "{{ .RepoName }}"
+	Repo: url:  "{{ .RepoURL }}"
+
+	Values: {
+		installCRDs: true
+		startupapicheck: enabled: false
+		// Must not use kube-system on gke autopilot.  GKE Warden blocks access.
+		global: leaderElection: namespace: Namespace
+	}
+}

internal/generate/components/helm/cert-manager/schematic.json

@@ -0,0 +1,10 @@
+{
+  "name": "cert-manager",
+  "short": "cloud native certificate management",
+  "long": "Automatically provision and manage TLS certificates in Kubernetes",
+  "chart": "cert-manager",
+  "version": "1.14.5",
+  "namespace": "cert-manager",
+  "reponame": "jetstack",
+  "repourl": "https://charts.jetstack.io"
+}

internal/generate/components/helm/podinfo-oci/podinfo.cue

@@ -0,0 +1,15 @@
+package holos
+
+// Produce a helm chart build plan.
+(#Helm & Chart).Output
+
+let Chart = {
+	Name:      "{{ .Name }}"
+	Version:   "{{ .Version }}"
+	Namespace: "{{ .Namespace }}"
+
+	// OCI helm charts use the image url as the chart name
+	Chart: chart: name: "{{ .Chart }}"
+
+	Values: {}
+}

internal/generate/components/helm/podinfo-oci/schematic.json

@@ -0,0 +1,8 @@
+{
+  "name": "podinfo-oci",
+  "short": "oci helm chart example",
+  "long": "Podinfo is a tiny web application made with Go that showcases best practices of running microservices in Kubernetes.",
+  "chart": "oci://ghcr.io/stefanprodan/charts/podinfo",
+  "version": "6.6.2",
+  "namespace": "default"
+}

internal/generate/components/helm/podinfo/podinfo.cue

@@ -0,0 +1,15 @@
+package holos
+
+// Produce a helm chart build plan.
+(#Helm & Chart).Output
+
+let Chart = {
+	Name:      "{{ .Name }}"
+	Version:   "{{ .Version }}"
+	Namespace: "{{ .Namespace }}"
+
+	Repo: name: "{{ .RepoName }}"
+	Repo: url:  "{{ .RepoURL }}"
+
+	Values: {}
+}

internal/generate/components/helm/podinfo/schematic.json

@@ -0,0 +1,10 @@
+{
+  "name": "podinfo",
+  "short": "simple helm chart example",
+  "long": "Podinfo is a tiny web application made with Go that showcases best practices of running microservices in Kubernetes.",
+  "chart": "podinfo",
+  "reponame": "podinfo",
+  "repourl": "https://stefanprodan.github.io/podinfo",
+  "version": "6.6.2",
+  "namespace": "default"
+}

internal/generate/generate.go

@@ -1,97 +1,17 @@
 package generate
 
 import (
+	"bytes"
 	"context"
 	"embed"
-	"encoding/json"
-	"fmt"
 	"io/fs"
 	"os"
 	"path/filepath"
 
-	"github.com/holos-run/holos/internal/client"
 	"github.com/holos-run/holos/internal/errors"
 	"github.com/holos-run/holos/internal/server/middleware/logger"
-	platform "github.com/holos-run/holos/service/gen/holos/platform/v1alpha1"
 )
 
-//go:embed all:platforms
-var platforms embed.FS
-
-// root is the root path to copy platform cue code from.
-const root = "platforms"
-
-// Platforms returns a slice of embedded platforms or nil if there are none.
-func Platforms() []string {
-	entries, err := fs.ReadDir(platforms, root)
-	if err != nil {
-		return nil
-	}
-	dirs := make([]string, 0, len(entries))
-	for _, entry := range entries {
-		if entry.IsDir() && entry.Name() != "cue.mod" {
-			dirs = append(dirs, entry.Name())
-		}
-	}
-	return dirs
-}
-
-// GeneratePlatform writes the cue code for a platform to the local working
-// directory.
-func GeneratePlatform(ctx context.Context, rpc *client.Client, orgID string, name string) error {
-	log := logger.FromContext(ctx)
-	// Check for a valid platform
-	platformPath := filepath.Join(root, name)
-	if !dirExists(platforms, platformPath) {
-		return errors.Wrap(fmt.Errorf("cannot generate: have: [%s] want: %+v", name, Platforms()))
-	}
-
-	// Link the local platform the SaaS platform ID.
-	rpcPlatforms, err := rpc.Platforms(ctx, orgID)
-	if err != nil {
-		return errors.Wrap(err)
-	}
-
-	var rpcPlatform *platform.Platform
-	for _, p := range rpcPlatforms {
-		if p.GetName() == name {
-			rpcPlatform = p
-			break
-		}
-	}
-	if rpcPlatform == nil {
-		return errors.Wrap(errors.New("cannot generate: platform not found in the holos server"))
-	}
-
-	// Write the platform data.
-	data, err := json.MarshalIndent(rpcPlatform, "", "  ")
-	if err != nil {
-		return errors.Wrap(err)
-	}
-	if len(data) > 0 {
-		data = append(data, '\n')
-	}
-	log = log.With("platform_id", rpcPlatform.GetId())
-	if err := os.WriteFile(client.PlatformMetadataFile, data, 0644); err != nil {
-		return errors.Wrap(fmt.Errorf("could not write platform metadata: %w", err))
-	}
-	log.InfoContext(ctx, "wrote "+client.PlatformMetadataFile, "path", filepath.Join(getCwd(ctx), client.PlatformMetadataFile))
-
-	// Copy the cue.mod directory
-	if err := copyEmbedFS(ctx, platforms, filepath.Join(root, "cue.mod"), "cue.mod"); err != nil {
-		return errors.Wrap(err)
-	}
-
-	// Copy the named platform
-	if err := copyEmbedFS(ctx, platforms, platformPath, "."); err != nil {
-		return errors.Wrap(err)
-	}
-
-	log.InfoContext(ctx, "generated platform "+name, "path", getCwd(ctx))
-
-	return nil
-}
-
 func dirExists(srcFS embed.FS, path string) bool {
 	entries, err := fs.ReadDir(srcFS, path)
 	if err != nil {
@@ -100,7 +20,9 @@ func dirExists(srcFS embed.FS, path string) bool {
 	return len(entries) > 0
 }
 
-func copyEmbedFS(ctx context.Context, srcFS embed.FS, srcPath, dstPath string) error {
+// copyEmbedFS copies embedded files from srcPath to dstPath passing the
+// contents through mapFunc.
+func copyEmbedFS(ctx context.Context, srcFS embed.FS, srcPath, dstPath string, mapFunc func([]byte) *bytes.Buffer) error {
 	log := logger.FromContext(ctx)
 	return fs.WalkDir(srcFS, srcPath, func(path string, d fs.DirEntry, err error) error {
 		if err != nil {
@@ -119,16 +41,25 @@ func copyEmbedFS(ctx context.Context, srcFS embed.FS, srcPath, dstPath string) e
 				return errors.Wrap(err)
 			}
 			log.DebugContext(ctx, "created", "directory", dstFullPath)
-		} else {
-			data, err := srcFS.ReadFile(path)
-			if err != nil {
-				return errors.Wrap(err)
-			}
-			if err := os.WriteFile(dstFullPath, data, os.ModePerm); err != nil {
-				return errors.Wrap(err)
-			}
-			log.DebugContext(ctx, "wrote", "file", dstFullPath)
+			return nil
 		}
+
+		if filepath.Base(path) == "schematic.json" {
+			log.DebugContext(ctx, "skipped", "file", dstFullPath)
+			return nil
+		}
+
+		data, err := srcFS.ReadFile(path)
+		if err != nil {
+			return errors.Wrap(err)
+		}
+
+		buf := mapFunc(data)
+		if err := os.WriteFile(dstFullPath, buf.Bytes(), os.ModePerm); err != nil {
+			return errors.Wrap(err)
+		}
+
+		log.DebugContext(ctx, "wrote", "file", dstFullPath)
 		return nil
 	})
 }

internal/generate/platform.go

@@ -0,0 +1,94 @@
+package generate
+
+import (
+	"bytes"
+	"context"
+	"embed"
+	"encoding/json"
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+
+	"github.com/holos-run/holos/internal/client"
+	"github.com/holos-run/holos/internal/errors"
+	"github.com/holos-run/holos/internal/logger"
+	platform "github.com/holos-run/holos/service/gen/holos/platform/v1alpha1"
+)
+
+//go:embed all:platforms
+var platforms embed.FS
+
+// platformsRoot is the root path to copy platform cue code from.
+const platformsRoot = "platforms"
+
+// Platforms returns a slice of embedded platforms or nil if there are none.
+func Platforms() []string {
+	entries, err := fs.ReadDir(platforms, platformsRoot)
+	if err != nil {
+		return nil
+	}
+	dirs := make([]string, 0, len(entries))
+	for _, entry := range entries {
+		if entry.IsDir() && entry.Name() != "cue.mod" {
+			dirs = append(dirs, entry.Name())
+		}
+	}
+	return dirs
+}
+
+// GeneratePlatform writes the cue code for a platform to the local working
+// directory.
+func GeneratePlatform(ctx context.Context, rpc *client.Client, orgID string, name string) error {
+	log := logger.FromContext(ctx)
+	// Check for a valid platform
+	platformPath := filepath.Join(platformsRoot, name)
+	if !dirExists(platforms, platformPath) {
+		return errors.Wrap(fmt.Errorf("cannot generate: have: [%s] want: %+v", name, Platforms()))
+	}
+
+	// Link the local platform the SaaS platform ID.
+	rpcPlatforms, err := rpc.Platforms(ctx, orgID)
+	if err != nil {
+		return errors.Wrap(err)
+	}
+
+	var rpcPlatform *platform.Platform
+	for _, p := range rpcPlatforms {
+		if p.GetName() == name {
+			rpcPlatform = p
+			break
+		}
+	}
+	if rpcPlatform == nil {
+		return errors.Wrap(errors.New("cannot generate: platform not found in the holos server"))
+	}
+
+	// Write the platform data.
+	data, err := json.MarshalIndent(rpcPlatform, "", "  ")
+	if err != nil {
+		return errors.Wrap(err)
+	}
+	if len(data) > 0 {
+		data = append(data, '\n')
+	}
+	log = log.With("platform_id", rpcPlatform.GetId())
+	if err := os.WriteFile(client.PlatformMetadataFile, data, 0644); err != nil {
+		return errors.Wrap(fmt.Errorf("could not write platform metadata: %w", err))
+	}
+	log.InfoContext(ctx, "wrote "+client.PlatformMetadataFile, "path", filepath.Join(getCwd(ctx), client.PlatformMetadataFile))
+
+	// Copy the cue.mod directory
+	if err := copyEmbedFS(ctx, platforms, filepath.Join(platformsRoot, "cue.mod"), "cue.mod", bytes.NewBuffer); err != nil {
+		return errors.Wrap(err)
+	}
+
+	// Copy the named platform
+	if err := copyEmbedFS(ctx, platforms, platformPath, ".", bytes.NewBuffer); err != nil {
+		return errors.Wrap(err)
+	}
+
+	log.InfoContext(ctx, "generated platform "+name, "path", getCwd(ctx))
+
+	return nil
+}

internal/generate/platforms/bare/buildplan.cue

@@ -0,0 +1,33 @@
+package holos
+
+import "encoding/yaml"
+import v1 "github.com/holos-run/holos/api/v1alpha1"
+
+// #Helm represents a holos build plan composed of one or more helm charts.
+#Helm: {
+  Name: string
+  Version: string
+  Namespace: string
+
+  Repo: {
+    name: string | *""
+    url: string | *""
+  }
+
+  Values: {...}
+
+  Chart: v1.#HelmChart & {
+    metadata: name: string | *Name
+    namespace: string | *Namespace
+    chart: name: string | *Name
+    chart: version: string | *Version
+    chart: repository: Repo
+    // Render the values to yaml for holos to provide to helm.
+    valuesContent: yaml.Marshal(Values)
+  }
+
+  // output represents the build plan provided to the holos cli.
+	Output: v1.#BuildPlan & {
+    spec: components: helmChartList: [Chart]
+  }
+}

internal/generate/platforms/bare/components/configmap/configmap.cue

@@ -1,6 +1,7 @@
 package holos
 
 import "encoding/yaml"
+
 import v1 "github.com/holos-run/holos/api/v1alpha1"
 
 // Provide a BuildPlan to the holos cli to render k8s api objects.

internal/generate/platforms/bare/forms/platform/platform-form.cue

@@ -140,7 +140,7 @@ let FormBuilder = v1.#FormBuilder & {
 					required:    true
 				}
 				validation: messages: {
-					pattern: "It must be \(props.minLength) to \(props.maxLength) lowercase letters, digits, or hyphens. It must start with a letter. Trailing hyphens are prohibited."
+					pattern:   "It must be \(props.minLength) to \(props.maxLength) lowercase letters, digits, or hyphens. It must start with a letter. Trailing hyphens are prohibited."
 					minLength: "Must be at least \(props.minLength) characters."
 					maxLength: "Must be at most \(props.maxLength) characters."
 				}

internal/generate/platforms/bare/forms/projects/greeter/greeter-form.cue

@@ -0,0 +1 @@
+

internal/generate/platforms/bare/platform.cue

@@ -3,11 +3,12 @@ package holos
 import "encoding/json"
 
 import v1 "github.com/holos-run/holos/api/v1alpha1"
+
 import dto "github.com/holos-run/holos/service/gen/holos/object/v1alpha1:object"
 
 // _PlatformConfig represents all of the data passed from holos to cue.
 // Intended to carry the platform model and project models.
-_PlatformConfig: dto.#PlatformConfig & json.Unmarshal(_PlatformConfigJSON)
+_PlatformConfig:     dto.#PlatformConfig & json.Unmarshal(_PlatformConfigJSON)
 _PlatformConfigJSON: string | *"{}" @tag(platform_config, type=string)
 
 // _Platform provides a platform resource to the holos cli for rendering.  The
@@ -16,7 +17,9 @@ _PlatformConfigJSON: string | *"{}" @tag(platform_config, type=string)
 // resource itself is output once when rendering the entire platform, see the
 // platform/ subdirectory.
 _Platform: v1.#Platform & {
-	metadata: name: string | *"bare" @tag(platform_name, type=string)
+	metadata: {
+		name: string | *"bare" @tag(platform_name, type=string)
+	}
 
 	// spec is the platform specification
 	spec: {
@@ -28,7 +31,7 @@ _Platform: v1.#Platform & {
 		_components: {
 			for WorkloadCluster in _Clusters.Workload {
 				"\(WorkloadCluster)-configmap": {
-					path: "components/configmap"
+					path:    "components/configmap"
 					cluster: WorkloadCluster
 				}
 			}

internal/generate/platforms/cue.mod/pkg/github.com/holos-run/holos/api/v1alpha1/buildplan.cue

@@ -4,3 +4,12 @@ package v1alpha1
 	apiVersion: #APIVersion
 	kind:       #BuildPlanKind
 }
+
+#HelmChart: {
+	apiVersion: #APIVersion
+	kind:       "HelmChart"
+
+	metadata: name: string
+	chart: name:    string | *metadata.name
+	chart: release: string | *metadata.name
+}

internal/generate/platforms/cue.mod/usr/github.com/holos-run/holos/api/v1alpha1/buildplan.cue

@@ -1,8 +0,0 @@
-package v1alpha1
-
-// #BuildPlan is the API contract between CUE and the Holos cli.
-// Holos requires CUE to evaluate and provide a valid #BuildPlan.
-#BuildPlan: {
-	kind:       #BuildPlanKind
-	apiVersion: #APIVersion
-}

internal/generate/platforms/example/components/configmap/configmap.cue

@@ -1,6 +1,7 @@
 package holos
 
 import "encoding/yaml"
+
 import v1 "github.com/holos-run/holos/api/v1alpha1"
 
 let PLATFORM = {message: "TODO: Load the platform from the API."}

internal/generate/platforms/example/forms/projects/greeter/greeter-form.cue

@@ -0,0 +1 @@
+

internal/render/platform.go

@@ -22,7 +22,7 @@ func Platform(ctx context.Context, pf *v1alpha1.Platform, stderr io.Writer) erro
 		args := []string{"render", "component", "--cluster-name", component.Cluster, component.Path}
 		result, err := util.RunCmd(ctx, "holos", args...)
 		if err != nil {
-			io.Copy(stderr, result.Stderr)
+			_, _ = io.Copy(stderr, result.Stderr)
 			return errors.Wrap(fmt.Errorf("could not render component: %w", err))
 		}
 		duration := time.Since(start)

version/embedded/minor

@@ -1 +1 @@
-80
+81