[update] Implement devbox update (#978)

## Summary

Implements `devbox update [pkg]...`

It basically just re-resolves version. If there's a new version that
satisfies constraints, it installs it and removes the previous one.

Other improvements:

* implemented `findPackageByName` which allows us to use `devbox update
go` instead of `devbox update [email protected]`. In follow up we can also use
this for `devbox rm`
* flake.nix optimization: If there are no dev packages (this is a legacy
planner concept that is almost never used) and we add at least one
nixpkgs flake input, we use that input for mkShell. This avoids having
to download an additional nixpkgs.


## How was it tested?

* Manually modified lockfile to point to older versions and ran `devbox
update` and `devbox update go`
* Inspected flake.nix 
* Inspected nix profile

Author: mikeland73

devbox.go

@@ -49,6 +49,8 @@ type Devbox interface {
 	StartServices(ctx context.Context, services ...string) error
 	StopServices(ctx context.Context, allProjects bool, services ...string) error
 	ListServices(ctx context.Context) error
+
+	Update(ctx context.Context, pkgs ...string) error
 }
 
 // Open opens a devbox by reading the config file in dir.

devbox.json

@@ -1,8 +1,8 @@
 {
   "packages": [
-    "go_1_20",
-    "golangci-lint",
-    "actionlint"
+    "[email protected]",
+    "[email protected]",
+    "[email protected]"
   ],
   "env": {
     "PATH": "$PATH:$PWD/dist"

devbox.lock

@@ -1,20 +1,20 @@
 {
   "lockfile_version": "1",
   "packages": {
-    "actionlint": {
-      "last_modified": "",
-      "resolved": "github:NixOS/nixpkgs/3364b5b117f65fe1ce65a3cdd5612a078a3b31e3#actionlint",
-      "version": ""
+    "actionlint@1.6.23": {
+      "last_modified": "2023-03-31T22:52:29Z",
+      "resolved": "github:NixOS/nixpkgs/242246ee1e58f54d2322227fc5eef53b4a616a31#actionlint",
+      "version": "1.6.23"
     },
-    "go_1_20": {
-      "last_modified": "",
-      "resolved": "github:NixOS/nixpkgs/3364b5b117f65fe1ce65a3cdd5612a078a3b31e3#go_1_20",
-      "version": ""
+    "[email protected]": {
+      "last_modified": "2023-03-31T22:52:29Z",
+      "resolved": "github:NixOS/nixpkgs/242246ee1e58f54d2322227fc5eef53b4a616a31#go",
+      "version": "1.20.2"
     },
-    "golangci-lint": {
-      "last_modified": "",
-      "resolved": "github:NixOS/nixpkgs/3364b5b117f65fe1ce65a3cdd5612a078a3b31e3#golangci-lint",
-      "version": ""
+    "golangci-lint@1.52.2": {
+      "last_modified": "2023-03-31T22:52:29Z",
+      "resolved": "github:NixOS/nixpkgs/242246ee1e58f54d2322227fc5eef53b4a616a31#golangci-lint",
+      "version": "1.52.2"
     }
   }
-}
+}

internal/boxcli/root.go

@@ -61,6 +61,7 @@ func RootCmd() *cobra.Command {
 	command.AddCommand(setupCmd())
 	command.AddCommand(shellCmd())
 	command.AddCommand(shellEnvCmd())
+	command.AddCommand(updateCmd())
 	command.AddCommand(versionCmd())
 	// Preview commands
 	command.AddCommand(cloudCmd())

internal/boxcli/update.go

@@ -0,0 +1,46 @@
+// Copyright 2023 Jetpack Technologies Inc and contributors. All rights reserved.
+// Use of this source code is governed by the license in the LICENSE file.
+
+package boxcli
+
+import (
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"go.jetpack.io/devbox"
+)
+
+type updateCmdFlags struct {
+	config configFlags
+}
+
+func updateCmd() *cobra.Command {
+	flags := &updateCmdFlags{}
+
+	command := &cobra.Command{
+		Use:   "update [pkg]...",
+		Short: "Updates packages in your devbox",
+		Long: "Updates one, many, or all packages in your devbox. " +
+			"If no packages are specified, all packages will be updated. " +
+			"Only updates versioned packages (e.g. `[email protected]`), not packages that are pinned to a nix channel (e.g. `python3`)",
+		PreRunE: ensureNixInstalled,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return updateCmdFunc(cmd, args, flags)
+		},
+	}
+
+	flags.config.register(command)
+	return command
+}
+
+func updateCmdFunc(
+	cmd *cobra.Command,
+	args []string,
+	flags *updateCmdFlags,
+) error {
+	box, err := devbox.Open(flags.config.path, cmd.ErrOrStderr())
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	return box.Update(cmd.Context(), args...)
+}

internal/impl/devbox.go

@@ -150,6 +150,19 @@ func (d *Devbox) ShellPlan() (*plansdk.ShellPlan, error) {
 	shellPlan.FlakeInputs = d.flakeInputs()
 
 	nixpkgsInfo := plansdk.GetNixpkgsInfo(d.cfg.Nixpkgs.Commit)
+
+	// This is an optimization. If there are no dev packages (which we only use
+	// for php/haskell planners) we can use nixpkgs from one of the flakes.
+	// That saves us from downloading nixpkgs an additional time for mkShell.
+	if len(shellPlan.DevPackages) == 0 {
+		for _, input := range shellPlan.FlakeInputs {
+			if input.IsNixpkgs() {
+				nixpkgsInfo = plansdk.GetNixpkgsInfo(input.HashFromNixPkgsURL())
+				break
+			}
+		}
+	}
+
 	shellPlan.NixpkgsInfo = nixpkgsInfo
 
 	return shellPlan, nil
@@ -942,6 +955,27 @@ func (d *Devbox) packages() []string {
 	return d.cfg.Packages
 }
 
+func (d *Devbox) findPackageByName(name string) (string, error) {
+	results := []string{}
+	for _, pkg := range d.cfg.Packages {
+		i := nix.InputFromString(pkg, d.lockfile)
+		if i.String() == name || i.CanonicalName() == name {
+			results = append(results, pkg)
+		}
+	}
+	if len(results) > 1 {
+		return "", usererr.New(
+			"found multiple packages with name %s: %s. Please specify version",
+			name,
+			results,
+		)
+	}
+	if len(results) == 0 {
+		return "", usererr.New("no package found with name %s", name)
+	}
+	return results[0], nil
+}
+
 // configEnvs takes the computed env variables (nix + plugin) and adds env
 // variables defined in Config. It also parses variables in config
 // that are referenced by $VAR or ${VAR} and replaces them with

internal/impl/update.go

@@ -0,0 +1,47 @@
+package impl
+
+import (
+	"context"
+	"fmt"
+
+	"go.jetpack.io/devbox/internal/lock"
+)
+
+func (d *Devbox) Update(ctx context.Context, pkgs ...string) error {
+	var pkgsToUpdate []string
+	for _, pkg := range pkgs {
+		found, err := d.findPackageByName(pkg)
+		if err != nil {
+			return err
+		}
+		pkgsToUpdate = append(pkgsToUpdate, found)
+	}
+	if len(pkgsToUpdate) == 0 {
+		pkgsToUpdate = d.packages()
+	}
+
+	for _, pkg := range pkgsToUpdate {
+		if !lock.IsVersionedPackage(pkg) {
+			fmt.Fprintf(d.writer, "Skipping %s because it is not a versioned package\n", pkg)
+			continue
+		}
+		existing := d.lockfile.Entry(pkg)
+		newEntry, err := d.lockfile.ForceResolve(pkg)
+		if err != nil {
+			return err
+		}
+		if existing != nil && existing.Version != newEntry.Version {
+			fmt.Fprintf(d.writer, "Updating %s %s -> %s\n", pkg, existing.Version, newEntry.Version)
+			if err := d.removePackagesFromProfile(ctx, []string{pkg}); err != nil {
+				return err
+			}
+		} else if existing == nil {
+			fmt.Fprintf(d.writer, "Resolved %s to %[1]s %[2]s\n", pkg, newEntry.Resolved)
+		} else {
+			fmt.Fprintf(d.writer, "Already up-to-date %s %s\n", pkg, existing.Version)
+		}
+	}
+
+	// TODO(landau): Improve output
+	return d.ensurePackagesAreInstalled(ctx, ensure)
+}

internal/lock/lockfile.go

@@ -21,8 +21,8 @@ type File struct {
 	devboxProject
 	resolver
 
-	LockFileVersion string             `json:"lockfile_version"`
-	Packages        map[string]Package `json:"packages"`
+	LockFileVersion string              `json:"lockfile_version"`
+	Packages        map[string]*Package `json:"packages"`
 }
 
 type Package struct {
@@ -37,7 +37,7 @@ func GetFile(project devboxProject, resolver resolver) (*File, error) {
 		resolver:      resolver,
 
 		LockFileVersion: lockFileVersion,
-		Packages:        map[string]Package{},
+		Packages:        map[string]*Package{},
 	}
 	err := cuecfg.ParseFile(lockFilePath(project), lockFile)
 	if errors.Is(err, fs.ErrNotExist) {
@@ -51,7 +51,7 @@ func GetFile(project devboxProject, resolver resolver) (*File, error) {
 
 func (l *File) Add(pkgs ...string) error {
 	for _, p := range pkgs {
-		if l.IsVersionedPackage(p) {
+		if IsVersionedPackage(p) {
 			if _, err := l.Resolve(p); err != nil {
 				return err
 			}
@@ -67,15 +67,14 @@ func (l *File) Remove(pkgs ...string) error {
 	return l.Update()
 }
 
-func (l *File) Resolve(pkg string) (string, error) {
-	if _, ok := l.Packages[pkg]; !ok {
+func (l *File) Resolve(pkg string) (*Package, error) {
+	if entry, ok := l.Packages[pkg]; !ok || entry.Resolved == "" {
 		var locked *Package
 		var err error
-		if l.IsVersionedPackage(pkg) {
-			name, version, _ := strings.Cut(pkg, "@")
-			locked, err = l.resolver.Resolve(name, version)
+		if IsVersionedPackage(pkg) {
+			locked, err = l.resolver.Resolve(pkg)
 			if err != nil {
-				return "", err
+				return nil, err
 			}
 		} else {
 			// These are legacy packages without a version. Resolve to nixpkgs with
@@ -88,13 +87,22 @@ func (l *File) Resolve(pkg string) (string, error) {
 				),
 			}
 		}
-		l.Packages[pkg] = *locked
+		l.Packages[pkg] = locked
 		if err := l.Update(); err != nil {
-			return "", err
+			return nil, err
 		}
 	}
 
-	return l.Packages[pkg].Resolved, nil
+	return l.Packages[pkg], nil
+}
+
+func (l *File) ForceResolve(pkg string) (*Package, error) {
+	delete(l.Packages, pkg)
+	return l.Resolve(pkg)
+}
+
+func (l *File) Entry(pkg string) *Package {
+	return l.Packages[pkg]
 }
 
 func (l *File) Update() error {
@@ -106,6 +114,11 @@ func (l *File) Update() error {
 	return cuecfg.WriteFile(lockFilePath(l), l)
 }
 
+func IsVersionedPackage(pkg string) bool {
+	name, version, found := strings.Cut(pkg, "@")
+	return found && name != "" && version != ""
+}
+
 func lockFilePath(project devboxProject) string {
 	return filepath.Join(project.ProjectDir(), "devbox.lock")
 }

internal/lock/resolvers.go

@@ -10,11 +10,10 @@ type devboxProject interface {
 }
 
 type resolver interface {
-	IsVersionedPackage(pkg string) bool
-	Resolve(pkg, version string) (*Package, error)
+	Resolve(pkg string) (*Package, error)
 }
 
 type Locker interface {
 	devboxProject
-	Resolve(pkg string) (string, error)
+	resolver
 }

internal/nix/input.go

@@ -69,20 +69,24 @@ func (i *Input) Name() string {
 
 func (i *Input) URLForInput() string {
 	if i.IsDevboxPackage() {
-		resolved, err := i.lockfile.Resolve(i.String())
+		entry, err := i.lockfile.Resolve(i.String())
 		if err != nil {
 			panic(err)
 			// TODO(landau): handle error
 		}
-		withoutFragment, _, _ := strings.Cut(resolved, "#")
+		withoutFragment, _, _ := strings.Cut(entry.Resolved, "#")
 		return withoutFragment
 	}
 	return i.urlWithoutFragment()
 }
 
 func (i *Input) URLForInstall() (string, error) {
 	if i.IsDevboxPackage() {
-		return i.lockfile.Resolve(i.String())
+		entry, err := i.lockfile.Resolve(i.String())
+		if err != nil {
+			return "", err
+		}
+		return entry.Resolved, nil
 	}
 	attrPath, err := i.PackageAttributePath()
 	if err != nil {
@@ -97,11 +101,11 @@ func (i *Input) URLForInstall() (string, error) {
 func (i *Input) PackageAttributePath() (string, error) {
 	var infos map[string]*Info
 	if i.IsDevboxPackage() {
-		path, err := i.lockfile.Resolve(i.String())
+		entry, err := i.lockfile.Resolve(i.String())
 		if err != nil {
 			return "", err
 		}
-		infos = search(path)
+		infos = search(entry.Resolved)
 	} else {
 		infos = search(i.String())
 	}
@@ -158,7 +162,11 @@ func (i *Input) hash() string {
 
 func (i *Input) validateExists() (bool, error) {
 	if i.IsDevboxPackage() {
-		return searcher.Exists(i.canonicalName(), i.version())
+		version := i.version()
+		if version == "" && i.isVersioned() {
+			return false, usererr.New("No version specified for %q.", i.Path)
+		}
+		return searcher.Exists(i.CanonicalName(), version)
 	}
 	info, err := i.PackageAttributePath()
 	return info != "", err
@@ -185,9 +193,9 @@ func (i *Input) equals(other *Input) bool {
 	return name == otherName
 }
 
-// canonicalName returns the name of the package without the version
+// CanonicalName returns the name of the package without the version
 // it only applies to devbox packages
-func (i *Input) canonicalName() string {
+func (i *Input) CanonicalName() string {
 	if !i.IsDevboxPackage() {
 		return ""
 	}
@@ -205,6 +213,10 @@ func (i *Input) version() string {
 	return version
 }
 
+func (i *Input) isVersioned() bool {
+	return i.IsDevboxPackage() && strings.Contains(i.Path, "@")
+}
+
 func (i *Input) hashFromNiPkgsURL() string {
 	return HashFromNixPkgsURL(i.URLForInput())
 }