[devbox] run: skip re-computing Devbox State if in devbox shell (#2144)

## Summary

This PR implements a change to the semantics of `devbox run`.
BEFORE:
`devbox run` would always ensure that the Devbox State and Environment
is up-to-date.
AFTER:
`devbox run` will only do so when _outside_ a Devbox Environment (i.e.
`devbox shell` or equivalent like direnv-enabled shell).

The motivation is two fold:
1. Speed. Users often want to just run a quick script, this slows them
down.
2. Users often have init-hooks which are more appropriate for one-time
setup, rather than when running a utility script inside a `devbox shell`
that has already been set up appropriately.

This was shared in the Discord channel for feedback:
https://discord.com/channels/903306922852245526/1009933892385517619/1248724103750483978

Notably, the focus there was on skipping the init-hooks, but in this PR,
we are going one-step beyond that to ensure the Devbox State itself is
not re-computed. The reason is that rather than _partially_ updating the
Devbox State and Environment (partially, because init-hooks are part of
setting up the environment) we'd rather eschew the step entirely. This
feels more straightforward for users to reason about.

## How was it tested?

Did a basic sanity test in two scenarios:

1. Running the script in a `devbox shell` or direnv-enabled environment
does NOT recompute the Devbox state.
2. Repeated the sanity test when outside of the Devbox environment, and
confirmed it does recompute the Devbox state.

Author: savil

internal/devbox/devbox.go

@@ -243,9 +243,21 @@ func (d *Devbox) RunScript(ctx context.Context, cmdName string, cmdArgs []string
 	}
 
 	lock.SetIgnoreShellMismatch(true)
-	env, err := d.ensureStateIsUpToDateAndComputeEnv(ctx)
-	if err != nil {
-		return err
+
+	var env map[string]string
+	if d.IsEnvEnabled() {
+		// Skip ensureStateIsUpToDate if we are already in a shell of this devbox-project
+		env = envir.PairsToMap(os.Environ())
+
+		// We set this to ensure that init-hooks do NOT re-run. They would have
+		// run when initializing the Devbox Environment in the current shell.
+		env[d.SkipInitHookEnvName()] = "true"
+	} else {
+		var err error
+		env, err = d.ensureStateIsUpToDateAndComputeEnv(ctx)
+		if err != nil {
+			return err
+		}
 	}
 
 	// Used to determine whether we're inside a shell (e.g. to prevent shell inception)

internal/devbox/envvars.go

@@ -78,3 +78,7 @@ func (d *Devbox) IsEnvEnabled() bool {
 	pathStack := envpath.Stack(fakeEnv, envir.PairsToMap(os.Environ()))
 	return pathStack.Has(d.ProjectDirHash())
 }
+
+func (d *Devbox) SkipInitHookEnvName() string {
+	return "__DEVBOX_SKIP_INIT_HOOK_" + d.ProjectDirHash()
+}

internal/shellgen/scripts.go

@@ -2,15 +2,14 @@ package shellgen
 
 import (
 	"bytes"
+	_ "embed"
 	"fmt"
 	"log/slog"
 	"os"
 	"path/filepath"
 	"strings"
 	"text/template"
 
-	_ "embed"
-
 	"github.com/pkg/errors"
 	"go.jetpack.io/devbox/internal/boxcli/featureflag"
 	"go.jetpack.io/devbox/internal/debug"
@@ -24,26 +23,17 @@ import (
 var scriptWrapperTmplString string
 var scriptWrapperTmpl = template.Must(template.New("script-wrapper").Parse(scriptWrapperTmplString))
 
-//go:embed tmpl/init-hook-wrapper.tmpl
-var initHookWrapperString string
-var initHookWrapperTmpl = template.Must(template.New("init-hook-wrapper").Parse(initHookWrapperString))
-
 const scriptsDir = ".devbox/gen/scripts"
 
-// HooksFilename is the name of the file that contains a wrapper of the
-// project's init-hooks and plugin hooks
-const (
-	HooksFilename    = ".hooks"
-	rawHooksFilename = ".raw-hooks"
-)
+const HooksFilename = ".hooks"
 
 type devboxer interface {
 	Config() *devconfig.Config
 	Lockfile() *lock.File
 	InstallablePackages() []*devpkg.Package
 	PluginManager() *plugin.Manager
 	ProjectDir() string
-	ProjectDirHash() string
+	SkipInitHookEnvName() string
 }
 
 // WriteScriptsToFiles writes scripts defined in devbox.json into files inside .devbox/gen/scripts.
@@ -68,12 +58,6 @@ func WriteScriptsToFiles(devbox devboxer) error {
 	if err != nil {
 		return errors.WithStack(err)
 	}
-	written[rawHooksFilename] = struct{}{}
-
-	err = writeInitHookWrapperFile(devbox)
-	if err != nil {
-		return errors.WithStack(err)
-	}
 	written[HooksFilename] = struct{}{}
 
 	// Write scripts to files.
@@ -104,7 +88,7 @@ func WriteScriptsToFiles(devbox devboxer) error {
 }
 
 func writeRawInitHookFile(devbox devboxer, body string) (err error) {
-	script, err := createScriptFile(devbox, rawHooksFilename)
+	script, err := createScriptFile(devbox, HooksFilename)
 	if err != nil {
 		return errors.WithStack(err)
 	}
@@ -114,19 +98,6 @@ func writeRawInitHookFile(devbox devboxer, body string) (err error) {
 	return errors.WithStack(err)
 }
 
-func writeInitHookWrapperFile(devbox devboxer) (err error) {
-	script, err := createScriptFile(devbox, HooksFilename)
-	if err != nil {
-		return errors.WithStack(err)
-	}
-	defer script.Close() // best effort: close file
-
-	return initHookWrapperTmpl.Execute(script, map[string]string{
-		"InitHookHash": "__DEVBOX_INIT_HOOK_" + devbox.ProjectDirHash(),
-		"RawHooksFile": ScriptPath(devbox.ProjectDir(), rawHooksFilename),
-	})
-}
-
 func WriteScriptFile(devbox devboxer, name, body string) (err error) {
 	script, err := createScriptFile(devbox, name)
 	if err != nil {
@@ -168,9 +139,9 @@ func ScriptPath(projectDir, scriptName string) string {
 func ScriptBody(d devboxer, body string) (string, error) {
 	var buf bytes.Buffer
 	err := scriptWrapperTmpl.Execute(&buf, map[string]string{
-		"Body":         body,
-		"InitHookHash": "__DEVBOX_INIT_HOOK_" + d.ProjectDirHash(),
-		"InitHookPath": ScriptPath(d.ProjectDir(), HooksFilename),
+		"Body":             body,
+		"SkipInitHookHash": d.SkipInitHookEnvName(),
+		"InitHookPath":     ScriptPath(d.ProjectDir(), HooksFilename),
 	})
 	if err != nil {
 		return "", errors.WithStack(err)

internal/shellgen/tmpl/init-hook-wrapper.tmpl

@@ -7,8 +7,7 @@
     scripts. (though users can run a fish script within their script)
 */ -}}
 
-if [ -z "${{ .InitHookHash }}" ]; then
-    {{/* init hooks will export InitHookHash ensuring no recursive sourcing*/ -}}
+if [ -z "${{ .SkipInitHookHash }}" ]; then
     . {{ .InitHookPath }}
 fi