Merge remote-tracking branch 'origin/main' into vaultsv2

Author: jahvon

cmd/internal/cache.go

@@ -79,7 +79,7 @@ func cacheSetFunc(ctx *context.Context, _ *cobra.Command, args []string) {
 	if err != nil {
 		ctx.Logger.FatalErr(err)
 	}
-	if err = s.CreateBucket(store.EnvironmentBucket()); err != nil {
+	if _, err = s.CreateAndSetBucket(store.EnvironmentBucket()); err != nil {
 		ctx.Logger.FatalErr(err)
 	}
 	defer func() {

cmd/internal/exec.go

@@ -11,6 +11,7 @@ import (
 	"github.com/jahvon/tuikit/views"
 	"github.com/spf13/cobra"
 
+	"github.com/jahvon/flow/cmd/internal/flags"
 	"github.com/jahvon/flow/internal/cache"
 	"github.com/jahvon/flow/internal/context"
 	"github.com/jahvon/flow/internal/io"
@@ -61,6 +62,7 @@ func RegisterExecCmd(ctx *context.Context, rootCmd *cobra.Command) {
 			execFunc(ctx, cmd, verb, args)
 		},
 	}
+	RegisterFlag(ctx, subCmd, *flags.ParameterValueFlag)
 	rootCmd.AddCommand(subCmd)
 }
 
@@ -114,6 +116,7 @@ func execFunc(ctx *context.Context, cmd *cobra.Command, verb executable.Verb, ar
 		))
 	}
 
+	// add args to the env map
 	execArgs := make([]string, 0)
 	if len(args) >= 2 {
 		execArgs = args[1:]
@@ -134,10 +137,12 @@ func execFunc(ctx *context.Context, cmd *cobra.Command, verb executable.Verb, ar
 		envMap = make(map[string]string)
 	}
 
-	if ctx.Config.CurrentVault == nil || *ctx.Config.CurrentVault == vault.LegacyVaultReservedName {
-		setAuthEnv(ctx, cmd, e)
-	}
-	textInputs := pendingFormFields(ctx, e)
+	// add --param overrides to the env map
+	paramOverrides := flags.ValueFor[[]string](ctx, cmd, *flags.ParameterValueFlag, false)
+	applyParameterOverrides(paramOverrides, envMap)
+
+	// add values from the prompt param type to the env map
+	textInputs := pendingFormFields(ctx, e, envMap)
 	if len(textInputs) > 0 {
 		form, err := views.NewForm(io.Theme(ctx.Config.Theme.String()), ctx.StdIn(), ctx.StdOut(), textInputs...)
 		if err != nil {
@@ -150,6 +155,10 @@ func execFunc(ctx *context.Context, cmd *cobra.Command, verb executable.Verb, ar
 			envMap[key] = fmt.Sprintf("%v", val)
 		}
 	}
+
+	if ctx.Config.CurrentVault == nil || *ctx.Config.CurrentVault == vault.LegacyVaultReservedName {
+		setAuthEnv(ctx, cmd, e)
+	}
 	startTime := time.Now()
 	eng := engine.NewExecEngine()
 	if err := runner.Exec(ctx, e, eng, envMap); err != nil {
@@ -306,36 +315,43 @@ func authRequired(ctx *context.Context, rootExec *executable.Executable) bool {
 }
 
 //nolint:gocognit
-func pendingFormFields(ctx *context.Context, rootExec *executable.Executable) []*views.FormField {
+func pendingFormFields(
+	ctx *context.Context, rootExec *executable.Executable, envMap map[string]string,
+) []*views.FormField {
 	pending := make([]*views.FormField, 0)
 	switch {
 	case rootExec.Exec != nil:
 		for _, param := range rootExec.Exec.Params {
-			if param.Prompt != "" {
+			_, exists := envMap[param.EnvKey]
+			if param.Prompt != "" && !exists {
 				pending = append(pending, &views.FormField{Key: param.EnvKey, Title: param.Prompt})
 			}
 		}
 	case rootExec.Launch != nil:
 		for _, param := range rootExec.Launch.Params {
-			if param.Prompt != "" {
+			_, exists := envMap[param.EnvKey]
+			if param.Prompt != "" && !exists {
 				pending = append(pending, &views.FormField{Key: param.EnvKey, Title: param.Prompt})
 			}
 		}
 	case rootExec.Request != nil:
 		for _, param := range rootExec.Request.Params {
-			if param.Prompt != "" {
+			_, exists := envMap[param.EnvKey]
+			if param.Prompt != "" && !exists {
 				pending = append(pending, &views.FormField{Key: param.EnvKey, Title: param.Prompt})
 			}
 		}
 	case rootExec.Render != nil:
 		for _, param := range rootExec.Render.Params {
-			if param.Prompt != "" {
+			_, exists := envMap[param.EnvKey]
+			if param.Prompt != "" && !exists {
 				pending = append(pending, &views.FormField{Key: param.EnvKey, Title: param.Prompt})
 			}
 		}
 	case rootExec.Serial != nil:
 		for _, param := range rootExec.Serial.Params {
-			if param.Prompt != "" {
+			_, exists := envMap[param.EnvKey]
+			if param.Prompt != "" && !exists {
 				pending = append(pending, &views.FormField{Key: param.EnvKey, Title: param.Prompt})
 			}
 		}
@@ -345,7 +361,7 @@ func pendingFormFields(ctx *context.Context, rootExec *executable.Executable) []
 				if err != nil {
 					continue
 				}
-				childPending := pendingFormFields(ctx, childExec)
+				childPending := pendingFormFields(ctx, childExec, envMap)
 				pending = append(pending, childPending...)
 			}
 		}
@@ -361,14 +377,25 @@ func pendingFormFields(ctx *context.Context, rootExec *executable.Executable) []
 				if err != nil {
 					continue
 				}
-				childPending := pendingFormFields(ctx, childExec)
+				childPending := pendingFormFields(ctx, childExec, envMap)
 				pending = append(pending, childPending...)
 			}
 		}
 	}
 	return pending
 }
 
+func applyParameterOverrides(overrides []string, envMap map[string]string) {
+	for _, override := range overrides {
+		parts := strings.SplitN(override, "=", 2)
+		if len(parts) != 2 {
+			continue // skip invalid overrides
+		}
+		key, value := parts[0], parts[1]
+		envMap[key] = value
+	}
+}
+
 var (
 	//nolint:lll
 	execDocumentation = `

cmd/internal/flags/types.go

@@ -176,6 +176,14 @@ var StoreAllFlag = &Metadata{
 	Default: false,
 }
 
+var ParameterValueFlag = &Metadata{
+	Name:      "param",
+	Shorthand: "p",
+	Usage: "Set a parameter value by env key. (i.e. KEY=value) Use multiple times to set multiple parameters." +
+		"This will override any existing parameter values defined for the executable.",
+	Default: []string{},
+}
+
 var VaultTypeFlag = &Metadata{
 	Name:      "type",
 	Shorthand: "t",

desktop/src-tauri/src/command_runner.rs

@@ -181,20 +181,21 @@ impl CommandRunner {
         args: &[&str],
         params: Option<std::collections::HashMap<String, String>>,
     ) -> CommandResult<()> {
-        let mut cmd_args = vec![verb, executable_id];
-        cmd_args.extend(args);
+        let mut cmd_args = vec![verb.to_string(), executable_id.to_string()];
+        cmd_args.extend(args.iter().map(|&s| s.to_string()));
 
         let mut cmd =
             TokioCommand::new("/Users/jahvon/workspaces/github.com/jahvon/flow/.bin/flow");
-        cmd.args(&cmd_args);
-        cmd.stdout(Stdio::piped()).stderr(Stdio::piped());
 
-        // TODO: ensure that the CLI supports this
         if let Some(params) = params {
             for (key, value) in params {
-                cmd.env(key, value);
+                cmd_args.push("--param".to_string());
+                let param_arg = format!("{}={}", key, value);
+                cmd_args.push(param_arg);
             }
         }
+        cmd.args(&cmd_args);
+        cmd.stdout(Stdio::piped()).stderr(Stdio::piped());
 
         println!("streaming cmd: {:?}", cmd);
 

docs/cli/flow_exec.md

@@ -50,7 +50,8 @@ flow exec EXECUTABLE_ID [args...] [flags]
 ### Options
 
 ```
-  -h, --help   help for exec
+  -h, --help                help for exec
+  -p, --param stringArray   Set a parameter value by env key. (i.e. KEY=value) Use multiple times to set multiple parameters.This will override any existing parameter values defined for the executable.
 ```
 
 ### Options inherited from parent commands

docs/guide/executable.md

@@ -157,6 +157,13 @@ parameter type sets a static value for the environment variable.
 
 _This example used the `exec` type, but the `params` field can be used with any executable type._
 
+You can override any environment variable defined in the `params` or provide additional ones by using the `--param` flag
+when running the executable:
+
+```shell
+flow deploy devbox --param API_TOKEN=token --param DRY_RUN=true --param VERBOSE=value
+```
+
 **Args**
 
 

internal/runner/env.go

@@ -38,6 +38,11 @@ func ResolveParameterValue(
 	param executable.Parameter,
 	promptedEnv map[string]string,
 ) (string, error) {
+	if val, found := promptedEnv[param.EnvKey]; found {
+		// existing values win - these could come in as a param override from the CLI
+		return val, nil
+	}
+
 	switch {
 	case param.Text == "" && param.SecretRef == "" && param.Prompt == "":
 		return "", nil

internal/services/store/store.go

@@ -93,7 +93,7 @@ func (s *BoltStore) CreateAndSetBucket(id string) (string, error) {
 
 func EnvironmentBucket() string {
 	id := RootBucket
-	if val, set := os.LookupEnv(BucketEnv); set {
+	if val, set := os.LookupEnv(BucketEnv); set && val != "" {
 		id = val
 	}
 	replacer := strings.NewReplacer(":", "_", "/", "_", " ", "_")
@@ -163,11 +163,38 @@ func (s *BoltStore) GetKeys() ([]string, error) {
 		if bucket == nil {
 			return fmt.Errorf("bucket %s not found", s.processBucket)
 		}
-		bucket.Stats()
-		return bucket.ForEach(func(k, _ []byte) error {
-			keys = append(keys, string(k))
+
+		// Collect keys from process bucket
+		processKeys := make(map[string]bool)
+		err := bucket.ForEach(func(k, _ []byte) error {
+			key := string(k)
+			keys = append(keys, key)
+			processKeys[key] = true
 			return nil
 		})
+		if err != nil {
+			return err
+		}
+
+		// If not using root bucket, also collect keys from root bucket
+		if s.processBucket != RootBucket {
+			rBucket := tx.Bucket([]byte(RootBucket))
+			if rBucket == nil {
+				return nil
+			}
+			err := rBucket.ForEach(func(k, _ []byte) error {
+				// Only add keys that aren't already in the process bucket
+				if key := string(k); !processKeys[key] {
+					keys = append(keys, key)
+				}
+				return nil
+			})
+			if err != nil {
+				return err
+			}
+		}
+
+		return nil
 	})
 	return keys, err
 }
@@ -186,10 +213,36 @@ func (s *BoltStore) GetAll() (map[string]string, error) {
 		if bucket == nil {
 			return fmt.Errorf("bucket %s not found", s.processBucket)
 		}
-		return bucket.ForEach(func(k, v []byte) error {
+
+		// First, collect all key-value pairs from process bucket
+		err := bucket.ForEach(func(k, v []byte) error {
 			m[string(k)] = string(v)
 			return nil
 		})
+		if err != nil {
+			return err
+		}
+
+		// If not using root bucket, also collect from root bucket
+		if s.processBucket != RootBucket {
+			rBucket := tx.Bucket([]byte(RootBucket))
+			if rBucket == nil {
+				return nil
+			}
+			err := rBucket.ForEach(func(k, v []byte) error {
+				key := string(k)
+				// Only add if key doesn't already exist in process bucket
+				if _, exists := m[key]; !exists {
+					m[key] = string(v)
+				}
+				return nil
+			})
+			if err != nil {
+				return err
+			}
+		}
+
+		return nil
 	})
 	return m, err
 }

tests/browse_cmds_e2e_test.go

@@ -6,13 +6,12 @@ import (
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 
-	"github.com/jahvon/flow/internal/context"
 	"github.com/jahvon/flow/tests/utils"
 )
 
 var _ = Describe("browse e2e", Ordered, func() {
 	var (
-		ctx *context.Context
+		ctx *utils.Context
 		run *utils.CommandRunner
 	)
 
@@ -33,7 +32,7 @@ var _ = Describe("browse e2e", Ordered, func() {
 		func(args []string) {
 			stdOut := ctx.StdOut()
 			cmdArgs := append([]string{"browse", "--list"}, args...)
-			Expect(run.Run(ctx, cmdArgs...)).To(Succeed())
+			Expect(run.Run(ctx.Context, cmdArgs...)).To(Succeed())
 			out, err := readFileContent(stdOut)
 			Expect(err).NotTo(HaveOccurred())
 			Expect(out).To(ContainSubstring("executables:"))
@@ -50,7 +49,7 @@ var _ = Describe("browse e2e", Ordered, func() {
 
 	It("should show executable details by verb and name", func() {
 		stdOut := ctx.StdOut()
-		Expect(run.Run(ctx, "browse", "exec", "examples:simple-print")).To(Succeed())
+		Expect(run.Run(ctx.Context, "browse", "exec", "examples:simple-print")).To(Succeed())
 		out, err := readFileContent(stdOut)
 		Expect(err).NotTo(HaveOccurred())
 		Expect(out).To(ContainSubstring("name: simple-print"))