[RFC][direnv-inspired] introduce export and hook commands, use in devbox shell, global and direnv (#1172)

## Summary

See #1156 for overall motivation.



**In this PR:**

1. Turn off adding bin-wrappers path to $PATH from `devbox shellenv`.
2. We add commands `devbox hook` and `devbox export`, analogous to
`direnv hook` and `direnv export`.
   - `export` is an alias of shellenv, and is hidden
- `hook` registers a shell prompt hook that wil call `eval $(devbox
export)`
3. During `devbox shell`, we add `eval $(devbox hook)` to the generated
shellrc file.
4. During `direnv`, the code is essentially unchanged except
calling`devbox export` instead of `devbox shellenv`.
5. For global, the users are currently expected to add `eval $(devbox
global hook <shell>)`

**RFC proposal to roll out:**
1. I don't think we need `devbox export`. We can continue with `devbox
shellenv`.
2. We can remove `devbox hook` entirely: in the generated shellrc, we
can inline the code of the hook that calls `devbox export`.
3. We can introduce `devbox global activate` to have the functionality
that `devbox global hook` has in this PR.
- `activate` is a generic word, enabling us to change its functionality
under-the-hood. It would save us the dilemma we have with this PR about
how to make users change their shellrc code from `devbox global
shellenv` to `devbox global hook`.
- We can make `devbox global shellenv` an alias of `devbox global
activate`. This would save users from needing to update their personal
shellrc files.

## How was it tested?

Added a feature flag: `DEVBOX_FEATURE_PROMPT_HOOK=1`.

Did some basic testing:
- project:
- `devbox shell` and then edited `devbox.json` to add a new package, and
saw the new package being installed prior to next prompt being
displayed.
- `devbox run -- iex -S mix` worked as expected, since we can turn off
the bin-wrappers.
- global: 
   - added `devbox global hook | source` to my fish shell.
   - `devbox global ls` worked.
   - `devbox global add <package>` worked as before.
   
**Note:** this PR adds the basic functionality, but the feature is not
yet robust. For a full list of pending scenarios that must work, please
refer to the (internal) notion doc.

Author: savil

devbox.go

@@ -21,6 +21,7 @@ type Devbox interface {
 	// Adding duplicate packages is a no-op.
 	Add(ctx context.Context, pkgs ...string) error
 	Config() *devconfig.Config
+	ExportHook(shellName string) (string, error)
 	ProjectDir() string
 	// Generate creates the directory of Nix files and the Dockerfile that define
 	// the devbox environment.

internal/boxcli/export.go

@@ -0,0 +1,30 @@
+package boxcli
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+)
+
+// exportCmd is an alias of shellenv, but is also hidden and hence we cannot define it
+// simply using `Aliases: []string{"export"}` in the shellEnvCmd definition.
+func exportCmd() *cobra.Command {
+	flags := shellEnvCmdFlags{}
+	cmd := &cobra.Command{
+		Use:    "export [shell]",
+		Hidden: true,
+		Short:  "Print shell command to setup the shell export to ensure an up-to-date environment",
+		Args:   cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			s, err := shellEnvFunc(cmd, flags)
+			if err != nil {
+				return err
+			}
+			fmt.Fprintln(cmd.OutOrStdout(), s)
+			return nil
+		},
+	}
+
+	registerShellEnvFlags(cmd, &flags)
+	return cmd
+}

internal/boxcli/featureflag/prompt_hook.go

@@ -0,0 +1,5 @@
+package featureflag
+
+// PromptHook controls the insertion of a shell prompt hook that invokes
+// devbox shellenv, in lieu of using binary wrappers.
+var PromptHook = disabled("PROMPT_HOOK")

internal/boxcli/global.go

@@ -26,6 +26,7 @@ func globalCmd() *cobra.Command {
 	}
 
 	addCommandAndHideConfigFlag(globalCmd, addCmd())
+	addCommandAndHideConfigFlag(globalCmd, hookCmd())
 	addCommandAndHideConfigFlag(globalCmd, installCmd())
 	addCommandAndHideConfigFlag(globalCmd, pathCmd())
 	addCommandAndHideConfigFlag(globalCmd, pullCmd())
@@ -112,7 +113,10 @@ func setGlobalConfigForDelegatedCommands(
 }
 
 func ensureGlobalEnvEnabled(cmd *cobra.Command, args []string) error {
-	if cmd.Name() == "shellenv" {
+	// Skip checking this for shellenv and hook sub-commands of devbox global
+	// since these commands are what will enable the global environment when
+	// invoked from the user's shellrc
+	if cmd.Name() == "shellenv" || cmd.Name() == "hook" {
 		return nil
 	}
 	path, err := ensureGlobalConfig(cmd)

internal/boxcli/hook.go

@@ -0,0 +1,41 @@
+package boxcli
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"go.jetpack.io/devbox"
+	"go.jetpack.io/devbox/internal/impl/devopt"
+)
+
+type hookFlags struct {
+	config configFlags
+}
+
+func hookCmd() *cobra.Command {
+	flags := hookFlags{}
+	cmd := &cobra.Command{
+		Use:   "hook [shell]",
+		Short: "Print shell command to setup the shell hook to ensure an up-to-date environment",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			output, err := hookFunc(cmd, args, flags)
+			if err != nil {
+				return err
+			}
+			fmt.Fprint(cmd.OutOrStdout(), output)
+			return nil
+		},
+	}
+
+	flags.config.register(cmd)
+	return cmd
+}
+
+func hookFunc(cmd *cobra.Command, args []string, flags hookFlags) (string, error) {
+	box, err := devbox.Open(&devopt.Opts{Dir: flags.config.path, Writer: cmd.ErrOrStderr()})
+	if err != nil {
+		return "", err
+	}
+	return box.ExportHook(args[0])
+}

internal/boxcli/root.go

@@ -52,8 +52,10 @@ func RootCmd() *cobra.Command {
 		command.AddCommand(authCmd())
 	}
 	command.AddCommand(createCmd())
+	command.AddCommand(exportCmd())
 	command.AddCommand(generateCmd())
 	command.AddCommand(globalCmd())
+	command.AddCommand(hookCmd())
 	command.AddCommand(infoCmd())
 	command.AddCommand(initCmd())
 	command.AddCommand(installCmd())

internal/boxcli/shellenv.go

@@ -36,6 +36,14 @@ func shellEnvCmd() *cobra.Command {
 		},
 	}
 
+	registerShellEnvFlags(command, &flags)
+	command.AddCommand(shellEnvOnlyPathWithoutWrappersCmd())
+
+	return command
+}
+
+func registerShellEnvFlags(command *cobra.Command, flags *shellEnvCmdFlags) {
+
 	command.Flags().BoolVar(
 		&flags.runInitHook, "init-hook", false, "runs init hook after exporting shell environment")
 	command.Flags().BoolVar(
@@ -45,10 +53,6 @@ func shellEnvCmd() *cobra.Command {
 		&flags.pure, "pure", false, "If this flag is specified, devbox creates an isolated environment inheriting almost no variables from the current environment. A few variables, in particular HOME, USER and DISPLAY, are retained.")
 
 	flags.config.register(command)
-
-	command.AddCommand(shellEnvOnlyPathWithoutWrappersCmd())
-
-	return command
 }
 
 func shellEnvFunc(cmd *cobra.Command, flags shellEnvCmdFlags) (string, error) {

internal/impl/devbox.go

@@ -822,21 +822,23 @@ func (d *Devbox) computeNixEnv(ctx context.Context, usePrintDevEnvCache bool) (m
 
 	addEnvIfNotPreviouslySetByDevbox(env, pluginEnv)
 
+	envPaths := []string{}
+	if !featureflag.PromptHook.Enabled() {
+		envPaths = append(envPaths, filepath.Join(d.projectDir, plugin.WrapperBinPath))
+	}
+	// Adding profile bin path is a temporary hack. Some packages .e.g. curl
+	// don't export the correct bin in the package, instead they export
+	// as a propagated build input. This can be fixed in 2 ways:
+	// * have NixBins() recursively look for bins in propagated build inputs
+	// * Turn existing planners into flakes (i.e. php, haskell) and use the bins
+	// in the profile.
+	// Landau: I prefer option 2 because it doesn't require us to re-implement
+	// nix recursive bin lookup.
+	envPaths = append(envPaths, nix.ProfileBinPath(d.projectDir), env["PATH"])
+
 	// Prepend virtenv bin path first so user can override it if needed. Virtenv
 	// is where the bin wrappers live
-	env["PATH"] = JoinPathLists(
-		filepath.Join(d.projectDir, plugin.WrapperBinPath),
-		// Adding profile bin path is a temporary hack. Some packages .e.g. curl
-		// don't export the correct bin in the package, instead they export
-		// as a propagated build input. This can be fixed in 2 ways:
-		// * have NixBins() recursively look for bins in propagated build inputs
-		// * Turn existing planners into flakes (i.e. php, haskell) and use the bins
-		// in the profile.
-		// Landau: I prefer option 2 because it doesn't require us to re-implement
-		// nix recursive bin lookup.
-		nix.ProfileBinPath(d.projectDir),
-		env["PATH"],
-	)
+	env["PATH"] = JoinPathLists(envPaths...)
 
 	// Include env variables in devbox.json
 	configEnv := d.configEnvs(env)

internal/impl/generate/devcontainer_util.go

@@ -17,6 +17,7 @@ import (
 	"runtime/trace"
 	"strings"
 
+	"go.jetpack.io/devbox/internal/boxcli/featureflag"
 	"go.jetpack.io/devbox/internal/debug"
 )
 
@@ -159,5 +160,9 @@ func getDevcontainerContent(pkgs []string) *devcontainerObject {
 func EnvrcContent(w io.Writer) error {
 	tmplName := "envrcContent.tmpl"
 	t := template.Must(template.ParseFS(tmplFS, "tmpl/"+tmplName))
-	return t.Execute(w, nil)
+	return t.Execute(w, struct {
+		PromptHookEnabled bool
+	}{
+		PromptHookEnabled: featureflag.PromptHook.Enabled(),
+	})
 }

internal/impl/generate/tmpl/envrcContent.tmpl

@@ -1,5 +1,9 @@
 use_devbox() {
     watch_file devbox.json
+    {{ .PromptHookEnabled }}
+    eval "$(devbox export --init-hook --install)"
+    {{ else }}
     eval "$(devbox shellenv --init-hook --install)"
+    {{ end }}
 }
 use devbox