[versioned] Add @latest to unversioned packages (#998)

## Summary

Stacked on #997

This adds `@latest` whenever an unversioned non-flake package is added.

This PR will be blocked until the php and haskell planners are updated
to work with versioned packages.

## How was it tested?

```bash
devbox add apache php curl
```

inspected devbox.json and lockfile.

Author: mikeland73

examples/development/csharp/hello-world/devbox.json

@@ -1,6 +1,6 @@
 {
     "packages": [
-        "dotnet-sdk"
+        "dotnet-sdk@latest"
     ],
     "shell": {
         "init_hook": null,

internal/boxcli/featureflag/autolatest.go

@@ -0,0 +1,3 @@
+package featureflag
+
+var AutoLatest = disabled("AUTO_LATEST")

internal/impl/devbox.go

@@ -959,24 +959,24 @@ func (d *Devbox) packagesAsInputs() []*nix.Input {
 }
 
 func (d *Devbox) findPackageByName(name string) (string, error) {
-	results := []string{}
+	results := map[string]bool{}
 	for _, pkg := range d.cfg.Packages {
 		i := nix.InputFromString(pkg, d.lockfile)
 		if i.String() == name || i.CanonicalName() == name {
-			results = append(results, pkg)
+			results[i.String()] = true
 		}
 	}
 	if len(results) > 1 {
 		return "", usererr.New(
 			"found multiple packages with name %s: %s. Please specify version",
 			name,
-			results,
+			lo.Keys(results),
 		)
 	}
 	if len(results) == 0 {
 		return "", usererr.New("no package found with name %s", name)
 	}
-	return results[0], nil
+	return lo.Keys(results)[0], nil
 }
 
 // configEnvs takes the computed env variables (nix + plugin) and adds env

internal/impl/packages.go

@@ -13,11 +13,11 @@ import (
 	"runtime/trace"
 	"strings"
 
-	"github.com/fatih/color"
 	"github.com/pkg/errors"
 	"github.com/samber/lo"
 	"golang.org/x/exp/slices"
 
+	"go.jetpack.io/devbox/internal/boxcli/usererr"
 	"go.jetpack.io/devbox/internal/debug"
 	"go.jetpack.io/devbox/internal/lock"
 	"go.jetpack.io/devbox/internal/nix"
@@ -29,54 +29,53 @@ import (
 // packages.go has functions for adding, removing and getting info about nix packages
 
 // Add adds the `pkgs` to the config (i.e. devbox.json) and nix profile for this devbox project
-func (d *Devbox) Add(ctx context.Context, pkgs ...string) error {
+func (d *Devbox) Add(ctx context.Context, pkgsNames ...string) error {
 	ctx, task := trace.NewTask(ctx, "devboxAdd")
 	defer task.End()
 
-	pkgs = lo.Uniq(pkgs)
+	pkgs := nix.InputsFromStrings(lo.Uniq(pkgsNames), d.lockfile)
 
-	original := d.cfg.Packages
+	versionedPackages := []*nix.Input{}
+	// Add to Packages of the config only if it's not already there. We do this
+	// before addin @latest to ensure we don't accidentally add a package that
+	// is already in the config.
+	for _, pkg := range pkgs {
+		versioned := pkg.Versioned()
+		versionedPackages = append(
+			versionedPackages,
+			nix.InputFromString(versioned, d.lockfile),
+		)
+		// Only add if the package doesn't exist versioned or unversioned.
+		if !slices.Contains(d.cfg.Packages, pkg.Raw) && !slices.Contains(d.cfg.Packages, versioned) {
+			d.cfg.Packages = append(d.cfg.Packages, versioned)
+		}
+	}
+	pkgs = versionedPackages
 
 	// Check packages are valid before adding.
 	for _, pkg := range pkgs {
-		ok, err := nix.PkgExists(pkg, d.lockfile)
+		ok, err := pkg.ValidateExists()
 		if err != nil {
 			return err
 		}
 		if !ok {
-			return errors.WithMessage(nix.ErrPackageNotFound, pkg)
-		}
-	}
-
-	// Add to Packages of the config only if it's not already there
-	for _, pkg := range pkgs {
-		if slices.Contains(d.cfg.Packages, pkg) {
-			continue
+			return errors.WithMessage(nix.ErrPackageNotFound, pkg.Raw)
 		}
-		d.cfg.Packages = append(d.cfg.Packages, pkg)
-	}
-	if err := d.saveCfg(); err != nil {
-		return err
 	}
 
 	d.pluginManager.ApplyOptions(plugin.WithAddMode())
 	if err := d.ensurePackagesAreInstalled(ctx, install); err != nil {
-		// if installation fails, revert devbox.json
-		// This is not perfect because there may be more than 1 package being
-		// installed and we don't know which one failed. But it's better than
-		// blindly add all packages.
-		color.New(color.FgRed).Fprintf(
-			d.writer,
-			"There was an error installing nix packages: %v. "+
-				"Packages were not added to devbox.json\n",
-			strings.Join(pkgs, ", "),
+		return usererr.WithUserMessage(
+			err,
+			"There was an error installing nix packages",
 		)
-		d.cfg.Packages = original
-		_ = d.saveCfg() // ignore error to ensure we return the original error
+	}
+
+	if err := d.saveCfg(); err != nil {
 		return err
 	}
 
-	for _, input := range nix.InputsFromStrings(pkgs, d.lockfile) {
+	for _, input := range pkgs {
 		if err := plugin.PrintReadme(
 			input,
 			d.projectDir,
@@ -87,48 +86,58 @@ func (d *Devbox) Add(ctx context.Context, pkgs ...string) error {
 		}
 	}
 
-	if err := d.lockfile.Add(pkgs...); err != nil {
+	if err := d.lockfile.Add(
+		lo.Map(pkgs, func(pkg *nix.Input, _ int) string { return pkg.Raw })...,
+	); err != nil {
 		return err
 	}
 
 	return wrapnix.CreateWrappers(ctx, d)
 }
 
-// Remove removes the `pkgs` from the config (i.e. devbox.json) and nix profile for this devbox project
+// Remove removes the `pkgs` from the config (i.e. devbox.json) and nix profile
+// for this devbox project
 func (d *Devbox) Remove(ctx context.Context, pkgs ...string) error {
 	ctx, task := trace.NewTask(ctx, "devboxRemove")
 	defer task.End()
 
-	pkgs = lo.Uniq(pkgs)
+	packagesToUninstall := []string{}
+	missingPkgs := []string{}
+	for _, pkg := range lo.Uniq(pkgs) {
+		found, _ := d.findPackageByName(pkg)
+		if found != "" {
+			packagesToUninstall = append(packagesToUninstall, found)
+			d.cfg.Packages = lo.Without(d.cfg.Packages, found)
+		} else {
+			missingPkgs = append(missingPkgs, pkg)
+		}
+	}
 
-	// First, save which packages are being uninstalled. Do this before we modify d.cfg.RawPackages below.
-	uninstalledPackages := lo.Intersect(d.cfg.Packages, pkgs)
-	remainingPkgs, missingPkgs := lo.Difference(d.cfg.Packages, pkgs)
 	if len(missingPkgs) > 0 {
 		ux.Fwarning(
 			d.writer,
 			"the following packages were not found in your devbox.json: %s\n",
 			strings.Join(missingPkgs, ", "),
 		)
 	}
-	d.cfg.Packages = remainingPkgs
-	if err := d.saveCfg(); err != nil {
+
+	if err := plugin.Remove(d.projectDir, packagesToUninstall); err != nil {
 		return err
 	}
 
-	if err := plugin.Remove(d.projectDir, uninstalledPackages); err != nil {
+	if err := d.removePackagesFromProfile(ctx, packagesToUninstall); err != nil {
 		return err
 	}
 
-	if err := d.removePackagesFromProfile(ctx, uninstalledPackages); err != nil {
+	if err := d.ensurePackagesAreInstalled(ctx, uninstall); err != nil {
 		return err
 	}
 
-	if err := d.ensurePackagesAreInstalled(ctx, uninstall); err != nil {
+	if err := d.lockfile.Remove(packagesToUninstall...); err != nil {
 		return err
 	}
 
-	if err := d.lockfile.Remove(uninstalledPackages...); err != nil {
+	if err := d.saveCfg(); err != nil {
 		return err
 	}
 

internal/nix/input.go

@@ -14,6 +14,7 @@ import (
 
 	"github.com/samber/lo"
 
+	"go.jetpack.io/devbox/internal/boxcli/featureflag"
 	"go.jetpack.io/devbox/internal/boxcli/usererr"
 	"go.jetpack.io/devbox/internal/lock"
 	"go.jetpack.io/devbox/internal/searcher"
@@ -22,6 +23,7 @@ import (
 type Input struct {
 	url.URL
 	lockfile lock.Locker
+	Raw      string
 }
 
 func InputsFromStrings(names []string, l lock.Locker) []*Input {
@@ -39,7 +41,7 @@ func InputFromString(s string, l lock.Locker) *Input {
 		// path urls have a single slash (instead of possibly 3 slashes)
 		u, _ = url.Parse("path:" + filepath.Join(l.ProjectDir(), u.Opaque))
 	}
-	return &Input{*u, l}
+	return &Input{*u, l, s}
 }
 
 func (i *Input) IsLocal() bool {
@@ -180,7 +182,7 @@ func (i *Input) hash() string {
 	return shortHash
 }
 
-func (i *Input) validateExists() (bool, error) {
+func (i *Input) ValidateExists() (bool, error) {
 	if i.isVersioned() {
 		version := i.version()
 		if version == "" && i.isVersioned() {
@@ -223,6 +225,13 @@ func (i *Input) CanonicalName() string {
 	return name
 }
 
+func (i *Input) Versioned() string {
+	if featureflag.AutoLatest.Enabled() && i.IsDevboxPackage() && !i.isVersioned() {
+		return i.Raw + "@latest"
+	}
+	return i.Raw
+}
+
 // version returns the version of the package
 // it only applies to devbox packages
 func (i *Input) version() string {

internal/nix/search.go

@@ -16,7 +16,7 @@ var ErrPackageNotFound = errors.New("package not found")
 var ErrPackageNotInstalled = errors.New("package not installed")
 
 func PkgExists(pkg string, lock *lock.File) (bool, error) {
-	return InputFromString(pkg, lock).validateExists()
+	return InputFromString(pkg, lock).ValidateExists()
 }
 
 type Info struct {