[run] improve UX by not requiring '--' (#1326)

## Summary

Inspired by @jimmidyson's awesome
[post](https://eng.d2iq.com/blog/a-long-journey-to-cross-platform-developer-tooling-utopia-for-now/)
I thought we could remove the need for `--` every time you want to run
something with devbox that has flags.

This change assumes that when a user runs `devbox run` the first
non-flag arg after "run" is part of the command or the script name the
user wants to run. This relies on `run` never having subcommands (which
I think will be true forever). So we transform:

`devbox run python --version`

into

`devbox run -- python --version`


If command already has `--` then we do nothing. 

This change is fully backward compatible.

@LucilleH I'm somewhat sure I fixed the issues from demo. PTAL
 
## How was it tested?

```
devbox add python
devbox run python --version
Python 3.11.4
devbox run -c examples/development/python/pip python --version
```

Author: mikeland73

examples/development/python/pip/devbox.lock

@@ -12,4 +12,4 @@
       "version": "23.0.1"
     }
   }
-}
+}

internal/boxcli/midcobra/midcobra.go

@@ -54,6 +54,9 @@ func (ex *midcobraExecutable) Execute(ctx context.Context, args []string) int {
 		m.preRun(ex.cmd, args)
 	}
 
+	// set args (needed in case caller transforms args in any way)
+	ex.cmd.SetArgs(args)
+
 	// Execute the cobra command:
 	err := ex.cmd.Execute()
 

internal/boxcli/root.go

@@ -95,11 +95,12 @@ func RootCmd() *cobra.Command {
 
 func Execute(ctx context.Context, args []string) int {
 	defer debug.Recover()
-	exe := midcobra.New(RootCmd())
+	rootCmd := RootCmd()
+	exe := midcobra.New(rootCmd)
 	exe.AddMiddleware(traceMiddleware)
 	exe.AddMiddleware(midcobra.Telemetry())
 	exe.AddMiddleware(debugMiddleware)
-	return exe.Execute(ctx, args)
+	return exe.Execute(ctx, wrapArgsForRun(rootCmd, args))
 }
 
 func Main() {

internal/boxcli/run.go

@@ -5,8 +5,12 @@ package boxcli
 
 import (
 	"fmt"
+	"strings"
 
+	"github.com/samber/lo"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+	"golang.org/x/exp/slices"
 
 	"go.jetpack.io/devbox"
 	"go.jetpack.io/devbox/internal/boxcli/usererr"
@@ -113,3 +117,70 @@ func parseScriptArgs(args []string, flags runCmdFlags) (string, string, []string
 
 	return flags.config.path, script, scriptArgs, nil
 }
+
+func wrapArgsForRun(rootCmd *cobra.Command, args []string) []string {
+	// if the first argument is not "run", we don't need to do anything. If there
+	// are 2 or fewer arguments, we also don't need to do anything because there
+	// are no flags after a non-run non-flag arg.
+	// IMPROVEMENT: technically users can pass a flag before the subcommand "run"
+	if len(args) <= 2 || args[0] != "run" || slices.Contains(args, "--") {
+		return args
+	}
+
+	cmd, found := lo.Find(
+		rootCmd.Commands(),
+		func(item *cobra.Command) bool { return item.Name() == "run" },
+	)
+	if !found {
+		return args
+	}
+	_ = cmd.InheritedFlags() // bug in cobra requires this to be called to ensure flags contains inherited flags.
+	runFlags := cmd.Flags()
+	// typical args can be of the form:
+	// run --flag1 val1 -f val2 --flag3=val3 --bool-flag python --version
+	// We handle each different type of flag
+	// (flag with equals, long-form, short-form, and defaulted flags)
+	// Note that defaulted does not mean initial value, it only means flags
+	// that don't require a value.
+	// For example, --bool-flag has NoOptDefVal set to "true".
+	i := 1
+	for i < len(args) {
+		arg := args[i]
+		if !strings.HasPrefix(arg, "-") {
+			// We found and argument that is not part of the flags, so we can stop
+			// This inserts a "--" before the first non-flag argument
+			// Turning
+			// run --flag1 val1 command --flag2 val2
+			// into
+			// run --flag1 val1 -- command --flag2 val2
+			return append(args[:i+1], append([]string{"--"}, args[i+1:]...)...)
+		}
+
+		if strings.HasPrefix(arg, "-") && strings.Contains(arg, "=") {
+			// This is a flag with an equals sign, so we can skip it
+			i++
+			continue
+		}
+
+		var flag *pflag.Flag
+		if strings.HasPrefix(arg, "--") {
+			flag = runFlags.Lookup(strings.TrimLeft(arg, "-"))
+		} else {
+			flag = runFlags.ShorthandLookup(strings.TrimLeft(arg, "-"))
+		}
+		if flag == nil {
+			// found an invalid flag, just return args as-is
+			return args
+		}
+		if flag.NoOptDefVal == "" {
+			// This is a non-boolean flag, e.g. --flag1 val1
+			i += 2
+		} else {
+			// This is a boolean flag, e.g. --bool-flag
+			i++
+		}
+	}
+
+	// This means there is no non-flag command. Just return as is.
+	return args
+}