feat: dev deploy --ref and --flavor flags

README.md

@@ -288,7 +288,9 @@ The `dev deploy` command performs the following operations
 
 - If local bundle: Creates Zarf packages for all local packages in a bundle
   - Creates the Zarf tarball in the same directory as the `zarf.yaml`
-  - Will only create the Zarf tarball if one does not already exist
+      - Can use `--flavor` and `--flavor-all` flags to specify what flavor of package you want to create
+  - Will only create the Zarf tarball if one does not already exist or can use `--force-create` to force the creation of a new zarf package even if one currently exists
   - Ignores any `kind: ZarfInitConfig` packages in the bundle
   - Creates a bundle from the newly created Zarf packages
 - Deploys the bundle in [YOLO](https://docs.zarf.dev/faq/#what-is-yolo-mode-and-why-would-i-use-it) mode, eliminating the need to do a `zarf init`
+- For remote packages you can specify what package ref you want to deploy by using the `--ref` flag and specifying the package name and desired ref. (example: `--ref podinfo=0.2.0`)

src/cmd/dev.go

@@ -5,6 +5,9 @@
 package cmd
 
 import (
+	"fmt"
+	"strings"
+
 	"github.com/defenseunicorns/pkg/helpers/v2"
 	"github.com/defenseunicorns/uds-cli/src/config"
 	"github.com/defenseunicorns/uds-cli/src/config/lang"
@@ -26,6 +29,7 @@ var devDeployCmd = &cobra.Command{
 	Long:  lang.CmdDevDeployLong,
 	Run: func(_ *cobra.Command, args []string) {
 		config.Dev = true
+		config.DevDeployRefs = bundleCfg.DevDeployOpts.Ref
 
 		// Get bundle source
 		src := ""
@@ -34,9 +38,15 @@ var devDeployCmd = &cobra.Command{
 		}
 
 		// Check if source is a local bundle
-		localBundle := helpers.IsDir(src)
+		isLocalBundle := isLocalBundle(src)
+
+		// Validate flags
+		err := validateDevDeployFlags(isLocalBundle)
+		if err != nil {
+			message.Fatalf(err, "Failed to validate flags: %s", err.Error())
+		}
 
-		if localBundle {
+		if isLocalBundle {
 			// Create Bundle
 			setBundleFile(args)
 
@@ -58,7 +68,7 @@ var devDeployCmd = &cobra.Command{
 		defer bndlClient.ClearPaths()
 
 		// Create dev bundle
-		if localBundle {
+		if isLocalBundle {
 			// Check if local zarf packages need to be created
 			bndlClient.CreateZarfPkgs()
 
@@ -68,7 +78,7 @@ var devDeployCmd = &cobra.Command{
 		}
 
 		// Set dev source
-		if localBundle {
+		if isLocalBundle {
 			bndlClient.SetDeploySource(src)
 		} else {
 			bundleCfg.DeployOpts.Source = src
@@ -79,11 +89,31 @@ var devDeployCmd = &cobra.Command{
 	},
 }
 
+// isLocalBundle checks if the bundle source is a local bundle
+func isLocalBundle(src string) bool {
+	return helpers.IsDir(src) || strings.Contains(src, ".tar.zst")
+}
+
+// validateDevDeployFlags validates the flags for dev deploy
+func validateDevDeployFlags(isLocalBundle bool) error {
+	if !isLocalBundle {
+		//Throw error if trying to run with --flavor, --flavor-all, or --force-create flag with remote bundle
+		if len(bundleCfg.DevDeployOpts.Flavor) > 0 || bundleCfg.DevDeployOpts.FlavorAll != "" || bundleCfg.DevDeployOpts.ForceCreate {
+			return fmt.Errorf("Cannot use --flavor, --flavor-all, or --force-create flags with remote bundle")
+		}
+	}
+	return nil
+}
+
 func init() {
 	initViper()
 	rootCmd.AddCommand(devCmd)
 	devCmd.AddCommand(devDeployCmd)
 	devDeployCmd.Flags().StringArrayVarP(&bundleCfg.DeployOpts.Packages, "packages", "p", []string{}, lang.CmdBundleDeployFlagPackages)
+	devDeployCmd.Flags().StringToStringVarP(&bundleCfg.DevDeployOpts.Ref, "ref", "r", map[string]string{}, lang.CmdBundleDeployFlagRef)
+	devDeployCmd.Flags().StringToStringVarP(&bundleCfg.DevDeployOpts.Flavor, "flavor", "f", map[string]string{}, lang.CmdBundleCreateFlagFlavor)
+	devDeployCmd.Flags().StringVar(&bundleCfg.DevDeployOpts.FlavorAll, "flavor-all", "", lang.CmdBundleCreateFlagFlavorAll)
+	devDeployCmd.Flags().BoolVar(&bundleCfg.DevDeployOpts.ForceCreate, "force-create", false, lang.CmdBundleCreateForceCreate)
 	devDeployCmd.Flags().BoolVarP(&config.CommonOptions.Confirm, "confirm", "c", false, lang.CmdBundleDeployFlagConfirm)
 	devDeployCmd.Flags().StringToStringVar(&bundleCfg.DeployOpts.SetVariables, "set", nil, lang.CmdBundleDeployFlagSet)
 }

src/config/config.go

@@ -77,6 +77,9 @@ var (
 
 	// Dev specifies if we are running in dev mode
 	Dev = false
+
+	// Map of refs specified for dev deploy
+	DevDeployRefs map[string]string
 )
 
 // GetArch returns the arch based on a priority list with options for overriding.

src/config/lang/lang.go

@@ -29,6 +29,8 @@ const (
 	CmdBundleCreateFlagOutput             = "Specify the output (an oci:// URL) for the created bundle"
 	CmdBundleCreateFlagSigningKey         = "Path to private key file for signing bundles"
 	CmdBundleCreateFlagSigningKeyPassword = "Password to the private key file used for signing bundles"
+	CmdBundleCreateFlagFlavor             = "Specify which zarf package flavor you want to use."
+	CmdBundleCreateFlagFlavorAll          = "Specify which zarf package flavor you want to use for all packages in the bundle"
 
 	// bundle deploy
 	CmdBundleDeployShort        = "Deploy a bundle from a local tarball or oci:// URL"
@@ -37,6 +39,7 @@ const (
 	CmdBundleDeployFlagResume   = "Only deploys packages from the bundle which haven't already been deployed"
 	CmdBundleDeployFlagSet      = "Specify deployment variables to set on the command line (KEY=value)"
 	CmdBundleDeployFlagRetries  = "Specify the number of retries for package deployments (applies to all pkgs in a bundle)"
+	CmdBundleDeployFlagRef      = "Specify which zarf package ref you want to deploy. By default the ref set in the bundle yaml is used."
 
 	// bundle inspect
 	CmdBundleInspectShort            = "Display the metadata of a bundle"
@@ -81,7 +84,8 @@ const (
 	CmdZarfShort = "Run a zarf command"
 
 	// uds dev
-	CmdDevShort       = "Commands useful for developing bundles"
-	CmdDevDeployShort = "[beta] Creates and deploys a UDS bundle from a given directory in dev mode"
-	CmdDevDeployLong  = "[beta] Creates and deploys a UDS bundle from a given directory in dev mode, setting package options like YOLO mode for faster iteration."
+	CmdDevShort                = "Commands useful for developing bundles"
+	CmdDevDeployShort          = "[beta] Creates and deploys a UDS bundle from a given directory in dev mode"
+	CmdDevDeployLong           = "[beta] Creates and deploys a UDS bundle from a given directory in dev mode, setting package options like YOLO mode for faster iteration."
+	CmdBundleCreateForceCreate = "For local bundles with local packages, specify whether to create a zarf package even if it already exists."
 )

src/pkg/bundle/create.go

@@ -5,10 +5,12 @@
 package bundle
 
 import (
+	"context"
 	"fmt"
 	"path/filepath"
 
 	"github.com/AlecAivazis/survey/v2"
+	"github.com/defenseunicorns/pkg/oci"
 	"github.com/defenseunicorns/uds-cli/src/config"
 	"github.com/defenseunicorns/uds-cli/src/pkg/bundler"
 	"github.com/defenseunicorns/uds-cli/src/pkg/utils"
@@ -17,6 +19,8 @@ import (
 	"github.com/defenseunicorns/zarf/src/pkg/interactive"
 	"github.com/defenseunicorns/zarf/src/pkg/message"
 	zarfUtils "github.com/defenseunicorns/zarf/src/pkg/utils"
+	"github.com/defenseunicorns/zarf/src/pkg/zoci"
+	ocispec "github.com/opencontainers/image-spec/specs-go/v1"
 	"github.com/pterm/pterm"
 	"helm.sh/helm/v3/pkg/chartutil"
 )
@@ -34,11 +38,6 @@ func (b *Bundle) Create() error {
 		return err
 	}
 
-	// Populate values from valuesFiles if provided
-	if err := b.processValuesFiles(); err != nil {
-		return err
-	}
-
 	// confirm creation
 	if ok := b.confirmBundleCreation(); !ok {
 		return fmt.Errorf("bundle creation cancelled")
@@ -86,16 +85,56 @@ func (b *Bundle) Create() error {
 		}
 	}
 
+	// for dev mode update package ref for local bundles, refs for remote bundles updated on deploy
+	if config.Dev {
+		if len(b.cfg.DevDeployOpts.Ref) != 0 {
+			for i, pkg := range b.bundle.Packages {
+				pkg = b.setPackageRef(pkg)
+				b.bundle.Packages[i] = pkg
+			}
+		}
+	}
+
 	opts := bundler.Options{
 		Bundle:    &b.bundle,
 		Output:    b.cfg.CreateOpts.Output,
 		TmpDstDir: b.tmp,
 		SourceDir: b.cfg.CreateOpts.SourceDirectory,
 	}
 	bundlerClient := bundler.NewBundler(&opts)
+
 	return bundlerClient.Create()
 }
 
+func (b *Bundle) setPackageRef(pkg types.Package) types.Package {
+	if ref, ok := b.cfg.DevDeployOpts.Ref[pkg.Name]; ok {
+		pkg.Ref = ref
+		errMsg := fmt.Sprintf("Unable to access %s:%s", pkg.Repository, pkg.Ref)
+
+		// Get SHA from registry
+		url := fmt.Sprintf("%s:%s", pkg.Repository, pkg.Ref)
+
+		platform := ocispec.Platform{
+			Architecture: config.GetArch(),
+			OS:           oci.MultiOS,
+		}
+		remote, err := zoci.NewRemote(url, platform)
+		if err != nil {
+			message.Fatalf(err, errMsg)
+		}
+		if err := remote.Repo().Reference.ValidateReferenceAsDigest(); err != nil {
+			manifestDesc, err := remote.ResolveRoot(context.TODO())
+			if err != nil {
+				message.Fatalf(err, errMsg)
+			}
+			pkg.Ref = pkg.Ref + "@sha256:" + manifestDesc.Digest.Encoded()
+		} else {
+			message.Fatalf(err, errMsg)
+		}
+	}
+	return pkg
+}
+
 // confirmBundleCreation prompts the user to confirm bundle creation
 func (b *Bundle) confirmBundleCreation() (confirm bool) {
 

src/pkg/bundle/deploy.go

@@ -54,10 +54,10 @@ func (b *Bundle) Deploy() error {
 		if len(userSpecifiedPackages) != len(packagesToDeploy) {
 			return fmt.Errorf("invalid zarf packages specified by --packages")
 		}
-		return deployPackages(packagesToDeploy, resume, b)
+	} else {
+		packagesToDeploy = b.bundle.Packages
 	}
-
-	return deployPackages(b.bundle.Packages, resume, b)
+	return deployPackages(packagesToDeploy, resume, b)
 }
 
 func deployPackages(packages []types.Package, resume bool, b *Bundle) error {
@@ -78,7 +78,12 @@ func deployPackages(packages []types.Package, resume bool, b *Bundle) error {
 	}
 
 	// deploy each package
-	for _, pkg := range packagesToDeploy {
+	for i, pkg := range packagesToDeploy {
+		// for dev mode update package ref for remote bundles, refs for local bundles updated on create
+		if config.Dev && !strings.Contains(b.cfg.DeployOpts.Source, "tar.zst") {
+			pkg = b.setPackageRef(pkg)
+			b.bundle.Packages[i] = pkg
+		}
 		sha := strings.Split(pkg.Ref, "@sha256:")[1] // using appended SHA from create!
 		pkgTmp, err := utils.MakeTempDir(config.CommonOptions.TempDirectory)
 		if err != nil {

src/pkg/bundle/dev.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/defenseunicorns/uds-cli/src/config"
 	"github.com/defenseunicorns/uds-cli/src/pkg/utils"
+	"github.com/defenseunicorns/uds-cli/src/types"
 
 	zarfCLI "github.com/defenseunicorns/zarf/src/cmd"
 	"github.com/defenseunicorns/zarf/src/pkg/message"
@@ -26,7 +27,8 @@ func (b *Bundle) CreateZarfPkgs() {
 	}
 
 	zarfPackagePattern := `^zarf-.*\.tar\.zst$`
-	for _, pkg := range b.bundle.Packages {
+	for i := range b.bundle.Packages {
+		pkg := b.bundle.Packages[i]
 		// if pkg is a local zarf package, attempt to create it if it doesn't exist
 		if pkg.Path != "" {
 			path := getPkgPath(pkg, config.GetArch(b.bundle.Metadata.Architecture), srcDir)
@@ -47,8 +49,13 @@ func (b *Bundle) CreateZarfPkgs() {
 				}
 			}
 			// create local zarf package if it doesn't exist
-			if !packageFound {
-				os.Args = []string{"zarf", "package", "create", pkgDir, "--confirm", "-o", pkgDir, "--skip-sbom"}
+			if !packageFound || b.cfg.DevDeployOpts.ForceCreate {
+				if len(b.cfg.DevDeployOpts.Flavor) != 0 || b.cfg.DevDeployOpts.FlavorAll != "" {
+					b.setPackageFlavor(&pkg)
+					os.Args = []string{"zarf", "package", "create", pkgDir, "--confirm", "-o", pkgDir, "--skip-sbom", "--flavor", pkg.Flavor}
+				} else {
+					os.Args = []string{"zarf", "package", "create", pkgDir, "--confirm", "-o", pkgDir, "--skip-sbom"}
+				}
 				zarfCLI.Execute()
 				if err != nil {
 					message.Fatalf(err, "Failed to create package %s: %s", pkg.Name, err.Error())
@@ -58,6 +65,15 @@ func (b *Bundle) CreateZarfPkgs() {
 	}
 }
 
+func (b *Bundle) setPackageFlavor(pkg *types.Package) {
+	// handle case when flavor applies to all packages
+	if b.cfg.DevDeployOpts.FlavorAll != "" {
+		pkg.Flavor = b.cfg.DevDeployOpts.FlavorAll
+	} else if flavor, ok := b.cfg.DevDeployOpts.Flavor[pkg.Name]; ok {
+		pkg.Flavor = flavor
+	}
+}
+
 // SetDeploySource sets the source for the bundle when in dev mode
 func (b *Bundle) SetDeploySource(srcDir string) {
 	filename := fmt.Sprintf("%s%s-%s-%s.tar.zst", config.BundlePrefix, b.bundle.Metadata.Name, b.bundle.Metadata.Architecture, b.bundle.Metadata.Version)

src/pkg/bundler/localbundle.go

@@ -66,7 +66,7 @@ func (lo *LocalBundle) create(signature []byte) error {
 
 	message.HeaderInfof("🐕 Fetching Packages")
 
-	// create root manifest for bundle, will populate with refs to uds-bundle.yaml and zarf image manifests
+	// create root manifest for bundle, will populate with ref to uds-bundle.yaml and zarf image manifests
 	rootManifest := ocispec.Manifest{
 		MediaType: ocispec.MediaTypeImageManifest,
 	}

src/pkg/sources/remote.go

@@ -42,7 +42,27 @@ type RemoteBundle struct {
 // LoadPackage loads a Zarf package from a remote bundle
 func (r *RemoteBundle) LoadPackage(dst *layout.PackagePaths, filter filters.ComponentFilterStrategy, unarchiveAll bool) (zarfTypes.ZarfPackage, []string, error) {
 	// todo: progress bar??
-	layers, err := r.downloadPkgFromRemoteBundle()
+	var layers []ocispec.Descriptor
+	var err error
+
+	if config.Dev {
+		if _, ok := config.DevDeployRefs[r.Pkg.Name]; ok {
+			// create new oras remote for package
+			platform := ocispec.Platform{
+				Architecture: config.GetArch(),
+				OS:           oci.MultiOS,
+			}
+			// get remote client
+			repoUrl := fmt.Sprintf("%s:%s", r.Pkg.Repository, r.Pkg.Ref)
+			remote, _ := zoci.NewRemote(repoUrl, platform)
+			layers, err = remote.PullPackage(context.TODO(), r.TmpDir, config.CommonOptions.OCIConcurrency)
+		} else {
+			layers, err = r.downloadPkgFromRemoteBundle()
+		}
+	} else {
+		layers, err = r.downloadPkgFromRemoteBundle()
+	}
+
 	if err != nil {
 		return zarfTypes.ZarfPackage{}, nil, err
 	}