Merge branch 'main' into landau/fix-release

Author: mikeland73

.github/workflows/cli-tests.yaml

@@ -147,7 +147,7 @@ jobs:
         uses: easimon/maximize-build-space@v8
         if: matrix.os == 'ubuntu-latest'
         with:
-          root-reserve-mb: 40000
+          root-reserve-mb: 32768
           temp-reserve-mb: 10000
           remove-dotnet: true
           remove-android: true

internal/devbox/devbox.go

@@ -233,6 +233,7 @@ func (d *Devbox) RunScript(ctx context.Context, cmdName string, cmdArgs []string
 		return err
 	}
 
+	lock.SetIgnoreShellMismatch(true)
 	env, err := d.ensureStateIsUpToDateAndComputeEnv(ctx)
 	if err != nil {
 		return err

internal/devbox/update.go

@@ -183,7 +183,7 @@ func (d *Devbox) attemptToUpgradeFlake(pkg *devpkg.Package) error {
 
 	err = nixprofile.ProfileUpgrade(profilePath, pkg, d.lockfile)
 	if err != nil {
-		ux.Ferror(
+		ux.Fwarning(
 			d.stderr,
 			"Failed to upgrade %s using `nix profile upgrade`: %s\n",
 			pkg.Raw,

internal/devpkg/flakeref_test.go

@@ -21,6 +21,7 @@ import (
 	"go.jetpack.io/devbox/internal/devpkg/pkgtype"
 	"go.jetpack.io/devbox/internal/lock"
 	"go.jetpack.io/devbox/internal/nix"
+	"go.jetpack.io/devbox/nix/flake"
 	"go.jetpack.io/devbox/plugins"
 )
 
@@ -45,7 +46,7 @@ type Package struct {
 	//
 	// This is done for performance reasons. Some commands don't require the
 	// fully-resolved package, so we don't want to waste time computing it.
-	installable FlakeInstallable
+	installable flake.Installable
 
 	// resolve resolves a Devbox package string to a Nix installable.
 	//
@@ -152,7 +153,7 @@ func newPackage(raw string, isInstallable bool, locker lock.Locker) *Package {
 	// or it's a flake installable. In some cases they're ambiguous
 	// ("nixpkgs" is a devbox package and a flake). When that happens, we
 	// assume a Devbox package.
-	parsed, err := ParseFlakeInstallable(raw)
+	parsed, err := flake.ParseInstallable(raw)
 	if err != nil || isAmbiguous(raw, parsed) {
 		pkg.IsDevboxPackage = true
 		pkg.resolve = sync.OnceValue(func() error { return resolve(pkg) })
@@ -169,21 +170,21 @@ func newPackage(raw string, isInstallable bool, locker lock.Locker) *Package {
 // isAmbiguous returns true if a package string could be a Devbox package or
 // a flake installable. For example, "nixpkgs" is both a Devbox package and a
 // flake.
-func isAmbiguous(raw string, parsed FlakeInstallable) bool {
+func isAmbiguous(raw string, parsed flake.Installable) bool {
 	// Devbox package strings never have a #attr_path in them.
 	if parsed.AttrPath != "" {
 		return false
 	}
 
 	// Indirect installables must have a "flake:" scheme to disambiguate
 	// them from legacy (unversioned) devbox package strings.
-	if parsed.Ref.Type == FlakeTypeIndirect {
+	if parsed.Ref.Type == flake.TypeIndirect {
 		return !strings.HasPrefix(raw, "flake:")
 	}
 
 	// Path installables must have a "path:" scheme, start with "/" or start
 	// with "./" to disambiguate them from devbox package strings.
-	if parsed.Ref.Type == FlakeTypePath {
+	if parsed.Ref.Type == flake.TypePath {
 		if raw[0] == '.' || raw[0] == '/' {
 			return false
 		}
@@ -208,16 +209,16 @@ func resolve(pkg *Package) error {
 	if inCache, err := pkg.IsInBinaryCache(); err == nil && inCache {
 		pkg.storePath = resolved.Systems[nix.System()].StorePath
 	}
-	parsed, err := ParseFlakeInstallable(resolved.Resolved)
+	parsed, err := flake.ParseInstallable(resolved.Resolved)
 	if err != nil {
 		return err
 	}
 	pkg.setInstallable(parsed, pkg.lockfile.ProjectDir())
 	return nil
 }
 
-func (p *Package) setInstallable(i FlakeInstallable, projectDir string) {
-	if i.Ref.Type == FlakeTypePath && !filepath.IsAbs(i.Ref.Path) {
+func (p *Package) setInstallable(i flake.Installable, projectDir string) {
+	if i.Ref.Type == flake.TypePath && !filepath.IsAbs(i.Ref.Path) {
 		i.Ref.Path = filepath.Join(projectDir, i.Ref.Path)
 	}
 	p.installable = i
@@ -234,9 +235,9 @@ func (p *Package) FlakeInputName() string {
 
 	result := ""
 	switch p.installable.Ref.Type {
-	case FlakeTypePath:
+	case flake.TypePath:
 		result = filepath.Base(p.installable.Ref.Path) + "-" + p.Hash()
-	case FlakeTypeGitHub:
+	case flake.TypeGitHub:
 		isNixOS := strings.ToLower(p.installable.Ref.Owner) == "nixos"
 		isNixpkgs := isNixOS && strings.ToLower(p.installable.Ref.Repo) == "nixpkgs"
 		if isNixpkgs && p.IsDevboxPackage {
@@ -300,8 +301,8 @@ func (p *Package) Installable() (string, error) {
 // FlakeInstallable returns a flake installable. The raw string must contain
 // a valid flake reference parsable by ParseFlakeRef, optionally followed by an
 // #attrpath and/or an ^output.
-func (p *Package) FlakeInstallable() (FlakeInstallable, error) {
-	return ParseFlakeInstallable(p.Raw)
+func (p *Package) FlakeInstallable() (flake.Installable, error) {
+	return flake.ParseInstallable(p.Raw)
 }
 
 // urlForInstall is used during `nix profile install`.
@@ -446,7 +447,7 @@ var ErrCannotBuildPackageOnSystem = errors.New("unable to build for system")
 
 func (p *Package) Hash() string {
 	sum := ""
-	if p.installable.Ref.Type == FlakeTypePath {
+	if p.installable.Ref.Type == flake.TypePath {
 		// For local flakes, use content hash of the flake.nix file to ensure
 		// user always gets newest flake.
 		sum, _ = cachehash.File(filepath.Join(p.installable.Ref.Path, "flake.nix"))

internal/devpkg/package.go

@@ -13,6 +13,8 @@ import (
 	"go.jetpack.io/devbox/internal/cuecfg"
 )
 
+var ignoreShellMismatch = false
+
 // stateHashFile is a non-shared lock file that helps track the state of the
 // local devbox environment. It contains hashes that may not be the same across
 // machines (e.g. manifest hash).
@@ -46,6 +48,12 @@ func UpdateAndSaveStateHashFile(args UpdateStateHashFileArgs) error {
 	return cuecfg.WriteFile(stateHashFilePath(args.ProjectDir), newLock)
 }
 
+// SetIgnoreShellMismatch is used to disable the shell comparison when checking
+// if the state is up to date. This is useful when we don't load shellrc (e.g. running)
+func SetIgnoreShellMismatch(ignore bool) {
+	ignoreShellMismatch = ignore
+}
+
 func isStateUpToDate(args UpdateStateHashFileArgs) (bool, error) {
 	filesystemStateHash, err := readStateHashFile(args.ProjectDir)
 	if err != nil {
@@ -56,6 +64,10 @@ func isStateUpToDate(args UpdateStateHashFileArgs) (bool, error) {
 		return false, err
 	}
 
+	if ignoreShellMismatch {
+		filesystemStateHash.IsFish = newStateHash.IsFish
+	}
+
 	return *filesystemStateHash == *newStateHash, nil
 }
 

internal/lock/statehash.go

@@ -18,6 +18,7 @@ import (
 	"github.com/pkg/errors"
 	"go.jetpack.io/devbox/internal/boxcli/featureflag"
 	"go.jetpack.io/devbox/internal/boxcli/usererr"
+	"go.jetpack.io/devbox/internal/redact"
 
 	"go.jetpack.io/devbox/internal/debug"
 )
@@ -63,11 +64,16 @@ func (*Nix) PrintDevEnv(ctx context.Context, args *PrintDevEnvArgs) (*PrintDevEn
 		}
 	}
 
+	flakeDirResolved, err := filepath.EvalSymlinks(args.FlakeDir)
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+
 	if len(data) == 0 {
 		cmd := exec.CommandContext(
 			ctx,
 			"nix", "print-dev-env",
-			args.FlakeDir,
+			"path:"+flakeDirResolved,
 		)
 		cmd.Args = append(cmd.Args, ExperimentalFlags()...)
 		cmd.Args = append(cmd.Args, "--json")
@@ -76,15 +82,15 @@ func (*Nix) PrintDevEnv(ctx context.Context, args *PrintDevEnvArgs) (*PrintDevEn
 		if insecure, insecureErr := IsExitErrorInsecurePackage(err, "" /*installable*/); insecure {
 			return nil, insecureErr
 		} else if err != nil {
-			return nil, errors.Wrapf(err, "Command: %s", cmd)
+			return nil, redact.Errorf("nix print-dev-env --json \"path:%s\": %w", flakeDirResolved, err)
 		}
 
 		if err := json.Unmarshal(data, &out); err != nil {
-			return nil, errors.WithStack(err)
+			return nil, redact.Errorf("unmarshal nix print-dev-env output: %w", redact.Safe(err))
 		}
 
 		if err = savePrintDevEnvCache(args.PrintDevEnvCachePath, out); err != nil {
-			return nil, errors.WithStack(err)
+			return nil, redact.Errorf("savePrintDevEnvCache: %w", redact.Safe(err))
 		}
 	}
 
@@ -175,12 +181,13 @@ func Version() (string, error) {
 	cmd := command("--version")
 	outBytes, err := cmd.Output()
 	if err != nil {
-		return "", errors.WithStack(err)
+		return "", redact.Errorf("nix command: %s", redact.Safe(cmd))
 	}
 	out := string(outBytes)
 	const prefix = "nix (Nix) "
 	if !strings.HasPrefix(out, prefix) {
-		return "", errors.Errorf(`Expected "%s" prefix, but output from nix --version was: %s`, prefix, out)
+		return "", redact.Errorf(`nix command %s: expected %q prefix, but output was: %s`,
+			redact.Safe(cmd), redact.Safe(prefix), redact.Safe(out))
 	}
 	version = strings.TrimSpace(strings.TrimPrefix(out, prefix))
 	return version, nil