[Config Packages] Add platforms and excluded_platforms functionality

Author: savil

devbox.go

@@ -19,7 +19,7 @@ type Devbox interface {
 	// Add adds Nix packages to the config so that they're available in the devbox
 	// environment. It validates that the Nix packages exist, and install them.
 	// Adding duplicate packages is a no-op.
-	Add(ctx context.Context, pkgs ...string) error
+	Add(ctx context.Context, platform, excludePlatform string, pkgs ...string) error
 	Config() *devconfig.Config
 	ProjectDir() string
 	// Generate creates the directory of Nix files and the Dockerfile that define

internal/boxcli/add.go

@@ -18,8 +18,10 @@ import (
 const toSearchForPackages = "To search for packages, use the `devbox search` command"
 
 type addCmdFlags struct {
-	config        configFlags
-	allowInsecure bool
+	config          configFlags
+	allowInsecure   bool
+	platform        string
+	excludePlatform string
 }
 
 func addCmd() *cobra.Command {
@@ -50,7 +52,13 @@ func addCmd() *cobra.Command {
 	flags.config.register(command)
 	command.Flags().BoolVar(
 		&flags.allowInsecure, "allow-insecure", false,
-		"Allow adding packages marked as insecure.")
+		"allow adding packages marked as insecure.")
+	command.Flags().StringVar(
+		&flags.platform, "platform", "",
+		"add packages to run on only this platform.")
+	command.Flags().StringVar(
+		&flags.excludePlatform, "exclude-platform", "",
+		"exclude packages from a specific platform.")
 
 	return command
 }
@@ -65,5 +73,5 @@ func addCmdFunc(cmd *cobra.Command, args []string, flags addCmdFlags) error {
 		return errors.WithStack(err)
 	}
 
-	return box.Add(cmd.Context(), args...)
+	return box.Add(cmd.Context(), flags.platform, flags.excludePlatform, args...)
 }

internal/devconfig/packages.go

@@ -2,10 +2,14 @@ package devconfig
 
 import (
 	"encoding/json"
+	"os"
+	"strings"
 
 	"github.com/pkg/errors"
 	orderedmap "github.com/wk8/go-ordered-map/v2"
+	"go.jetpack.io/devbox/internal/nix"
 	"go.jetpack.io/devbox/internal/searcher"
+	"go.jetpack.io/devbox/internal/ux"
 	"golang.org/x/exp/slices"
 )
 
@@ -28,6 +32,11 @@ type Packages struct {
 	Collection []Package `json:"-,omitempty"`
 }
 
+// TODO savil: rm
+func (pkgs *Packages) Kind() int {
+	return int(pkgs.jsonKind)
+}
+
 // VersionedNames returns a list of package names with versions.
 // NOTE: if the package is unversioned, the version will be omitted (doesn't default to @latest).
 //
@@ -55,6 +64,84 @@ func (pkgs *Packages) Remove(versionedName string) {
 	})
 }
 
+// AddPlatform adds a platform to the list of platforms for a given package
+func (pkgs *Packages) AddPlatform(versionedname, platform string) error {
+	if err := nix.EnsureValidPlatform(platform); err != nil {
+		return errors.WithStack(err)
+	}
+
+	name, version := parseVersionedName(versionedname)
+	for idx, pkg := range pkgs.Collection {
+		if pkg.name == name && pkg.Version == version {
+
+			// Check if the platform is already present
+			alreadyPresent := false
+			for _, existing := range pkg.Platforms {
+				if existing == platform {
+					alreadyPresent = true
+					break
+				}
+			}
+
+			// Add the platform if it's not already present
+			if !alreadyPresent {
+				pkg.Platforms = append(pkg.Platforms, platform)
+			}
+
+			// Adding any platform will restrict installation to it, so
+			// the ExcludedPlatforms are no longer needed
+			pkg.ExcludedPlatforms = nil
+
+			pkgs.jsonKind = jsonMap
+			pkg.kind = regular
+			pkgs.Collection[idx] = pkg
+			return nil
+		}
+	}
+	return errors.Errorf("package %s not found", versionedname)
+}
+
+// ExcludePlatform adds a platform to the list of excluded platforms for a given package
+func (pkgs *Packages) ExcludePlatform(versionedName, platform string) error {
+	if err := nix.EnsureValidPlatform(platform); err != nil {
+		return errors.WithStack(err)
+	}
+
+	name, version := parseVersionedName(versionedName)
+	for idx, pkg := range pkgs.Collection {
+		if pkg.name == name && pkg.Version == version {
+
+			// Check if the platform is already present
+			alreadyPresent := false
+			for _, existing := range pkg.ExcludedPlatforms {
+				if existing == platform {
+					alreadyPresent = true
+					break
+				}
+			}
+
+			if !alreadyPresent {
+				pkg.ExcludedPlatforms = append(pkg.ExcludedPlatforms, platform)
+			}
+			if len(pkg.Platforms) > 0 {
+				ux.Finfo(
+					os.Stderr,
+					"Excluding a platform for %[1]s is a bit redundant because it will only be installed on: %[2]v. "+
+						"Consider removing the `platform` field from %[1]s's definition in your devbox."+
+						"json if you intend for %[1]s to be installed on all platforms except %[3]s.\n",
+					versionedName, strings.Join(pkg.Platforms, ", "), platform,
+				)
+			}
+
+			pkgs.jsonKind = jsonMap
+			pkg.kind = regular
+			pkgs.Collection[idx] = pkg
+			return nil
+		}
+	}
+	return errors.Errorf("package %s not found", versionedName)
+}
+
 func (pkgs *Packages) UnmarshalJSON(data []byte) error {
 
 	// First, attempt to unmarshal as a list of strings (legacy format)
@@ -123,7 +210,8 @@ type Package struct {
 	// deliberately not adding omitempty
 	Version string `json:"version"`
 
-	// TODO: add other fields like platforms
+	Platforms         []string `json:"platforms,omitempty"`
+	ExcludedPlatforms []string `json:"excluded_platforms,omitempty"`
 }
 
 func NewVersionOnlyPackage(name, version string) Package {
@@ -143,13 +231,34 @@ func NewPackage(name string, values map[string]any) Package {
 		version = ""
 	}
 
+	var platforms []string
+	if p, ok := values["platforms"]; ok {
+		platforms = p.([]string)
+	}
+	var excludedPlatforms []string
+	if e, ok := values["excluded_platforms"]; ok {
+		excludedPlatforms = e.([]string)
+	}
+
 	return Package{
-		kind:    regular,
-		name:    name,
-		Version: version.(string),
+		kind:              regular,
+		name:              name,
+		Version:           version.(string),
+		Platforms:         platforms,
+		ExcludedPlatforms: excludedPlatforms,
 	}
 }
 
+// TODO savil: rm
+func (p *Package) Name() string {
+	return p.name
+}
+
+// TODO savil: rm
+func (p *Package) Kind() int {
+	return int(p.kind)
+}
+
 func (p *Package) VersionedName() string {
 	name := p.name
 	if p.Version != "" {
@@ -181,6 +290,10 @@ func (p *Package) UnmarshalJSON(data []byte) error {
 
 	*p = Package(*alias)
 	p.kind = regular
+
+	// TODO savil. needed?
+	//p.Platforms = alias.Platforms
+	//p.ExcludedPlatforms = alias.ExcludedPlatforms
 	return nil
 }
 

internal/devconfig/packages_test.go

@@ -74,6 +74,50 @@ func TestJsonifyConfigPackages(t *testing.T) {
 				},
 			},
 		},
+		{
+			name: "map-with-platforms",
+			jsonConfig: `{"packages":{"python":{"version":"latest",` +
+				`"platforms":["x86_64-darwin","aarch64-linux"]}}}`,
+			expected: Packages{
+				jsonKind: jsonMap,
+				Collection: []Package{
+					NewPackage("python", map[string]any{
+						"version":   "latest",
+						"platforms": []string{"x86_64-darwin", "aarch64-linux"},
+					}),
+				},
+			},
+		},
+		{
+			name: "map-with-excluded-platforms",
+			jsonConfig: `{"packages":{"python":{"version":"latest",` +
+				`"excluded_platforms":["x86_64-linux"]}}}`,
+			expected: Packages{
+				jsonKind: jsonMap,
+				Collection: []Package{
+					NewPackage("python", map[string]any{
+						"version":            "latest",
+						"excluded_platforms": []string{"x86_64-linux"},
+					}),
+				},
+			},
+		},
+		{
+			name: "map-with-platforms-and-excluded-platforms",
+			jsonConfig: `{"packages":{"python":{"version":"latest",` +
+				`"platforms":["x86_64-darwin","aarch64-linux"],` +
+				`"excluded_platforms":["x86_64-linux"]}}}`,
+			expected: Packages{
+				jsonKind: jsonMap,
+				Collection: []Package{
+					NewPackage("python", map[string]any{
+						"version":            "latest",
+						"platforms":          []string{"x86_64-darwin", "aarch64-linux"},
+						"excluded_platforms": []string{"x86_64-linux"},
+					}),
+				},
+			},
+		},
 	}
 
 	for _, testCase := range testCases {
@@ -165,3 +209,24 @@ func TestParseVersionedName(t *testing.T) {
 		})
 	}
 }
+
+func TestConvertToKind(t *testing.T) {
+	testCase := Packages{
+		jsonKind:   jsonList,
+		Collection: packagesFromLegacyList([]string{"python", "hello@latest", "[email protected]"}),
+	}
+
+	expected := Packages{
+		jsonKind: jsonMap,
+		Collection: []Package{
+			NewVersionOnlyPackage("python", "" /*version*/),
+			NewVersionOnlyPackage("hello", "latest"),
+			NewVersionOnlyPackage("go", "1.20"),
+		},
+	}
+
+	testCase.convertToKind(jsonMap)
+	if !reflect.DeepEqual(testCase, expected) {
+		t.Errorf("expected: %+v, got: %+v", expected, testCase)
+	}
+}

internal/impl/packages.go

@@ -33,7 +33,8 @@ import (
 
 // 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, pkgsNames ...string) error {
+// nolint:revive // warns about cognitive complexity
+func (d *Devbox) Add(ctx context.Context, platform, excludePlatform string, pkgsNames ...string) error {
 	ctx, task := trace.NewTask(ctx, "devboxAdd")
 	defer task.End()
 
@@ -47,6 +48,7 @@ func (d *Devbox) Add(ctx context.Context, pkgsNames ...string) error {
 	addedPackageNames := []string{}
 	existingPackageNames := d.ConfigPackageNames()
 	for _, pkg := range pkgs {
+
 		// If exact versioned package is already in the config, skip.
 		if slices.Contains(existingPackageNames, pkg.Versioned()) {
 			addedPackageNames = append(addedPackageNames, pkg.Versioned())
@@ -87,6 +89,19 @@ func (d *Devbox) Add(ctx context.Context, pkgsNames ...string) error {
 		addedPackageNames = append(addedPackageNames, packageNameForConfig)
 	}
 
+	for _, pkg := range addedPackageNames {
+		if platform != "" {
+			if err := d.cfg.Packages.AddPlatform(pkg, platform); err != nil {
+				return err
+			}
+		}
+		if excludePlatform != "" {
+			if err := d.cfg.Packages.ExcludePlatform(pkg, excludePlatform); err != nil {
+				return err
+			}
+		}
+	}
+
 	// Resolving here ensures we allow insecure before running ensurePackagesAreInstalled
 	// which will call print-dev-env. Resolving does not save the lockfile, we
 	// save at the end when everything has succeeded.

internal/impl/update.go

@@ -34,7 +34,7 @@ func (d *Devbox) Update(ctx context.Context, pkgs ...string) error {
 			// Calling Add function with the original package names, since
 			// Add will automatically append @latest if search is able to handle that.
 			// If not, it will fallback to the nixpkg format.
-			if err := d.Add(ctx, pkg.Raw); err != nil {
+			if err := d.Add(ctx, "" /*platform*/, "" /*excludePlatform*/, pkg.Raw); err != nil {
 				return err
 			}
 		} else {

internal/nix/nix.go

@@ -120,6 +120,7 @@ func ExperimentalFlags() []string {
 
 var cachedSystem string
 
+// TODO: rename to Platform?
 func System() (string, error) {
 	// For Savil to debug "remove nixpkgs" feature. The Search api lacks x86-darwin info.
 	// So, I need to fake that I am x86-linux and inspect the output in generated devbox.lock
@@ -169,6 +170,28 @@ func Version() (string, error) {
 	return version, nil
 }
 
+var nixPlatforms = []string{
+	"aarch64-darwin",
+	"aarch64-linux",
+	"i686-linux",
+	"x86_64-darwin",
+	"x86_64-linux",
+	// not technically supported, but should work?
+	// ref.
+	"armv7l-linux",
+}
+
+// EnsureValidPlatform returns an error if the platform is not supported by nix.
+// https://nixos.org/manual/nix/stable/installation/supported-platforms.html
+func EnsureValidPlatform(platform string) error {
+	for _, p := range nixPlatforms {
+		if p == platform {
+			return nil
+		}
+	}
+	return usererr.New("Unsupported platform: %s. Valid platforms are: %v", platform, nixPlatforms)
+}
+
 // Warning: be careful using the bins in default/bin, they won't always match bins
 // produced by the flakes.nix. Use devbox.NixBins() instead.
 func ProfileBinPath(projectDir string) string {