[plugins] Implement --disable-plugin flag (#1666)

## Summary

This adds a new `--disable-plugin` flag to `devbox add`. It also adds a
new `disable_plugin` field to the package object in the config. If this
field is true packages with built in plugins will not install the
plugin. If the package does not trigger a plugin, the field is ignored.
The field can be added via flag or manually. It can be removed manually
or by running `devbox add <pkg>` again without the flag.

Other fixes/improvements:

* Moved allowInsecure to `AddOpts` instead of devbox general options.
* Refactored Add() so it no longer violates the linter complexity rule.

Fixes: #1615

cc: @Lagoja 

## How was it tested?

* Unit tests
* `devbox add python --disable-plugin`

Author: mikeland73

devbox.go

@@ -16,7 +16,7 @@ import (
 
 // Devbox provides an isolated development environment.
 type Devbox interface {
-	Add(ctx context.Context, platforms, excludePlatforms []string, pkgs ...string) error
+	Add(ctx context.Context, pkgs []string, opts devopt.AddOpts) error
 	Config() *devconfig.Config
 	EnvVars(ctx context.Context) ([]string, error)
 	Info(ctx context.Context, pkg string, markdown bool) (string, error)

devbox.json

@@ -1,9 +1,9 @@
 {
-  "packages": [
-    "go@latest",
-    "runx:golangci/golangci-lint@latest",
-    "runx:mvdan/gofumpt@latest"
-  ],
+  "packages": {
+    "go":                          "latest",
+    "runx:golangci/golangci-lint": "latest",
+    "runx:mvdan/gofumpt":          "latest"
+  },
   "env": {
     "GOENV": "off",
     "PATH":  "$PATH:$PWD/dist"

internal/boxcli/add.go

@@ -20,6 +20,7 @@ const toSearchForPackages = "To search for packages, use the `devbox search` com
 type addCmdFlags struct {
 	config           configFlags
 	allowInsecure    bool
+	disablePlugin    bool
 	platforms        []string
 	excludePlatforms []string
 }
@@ -53,6 +54,9 @@ func addCmd() *cobra.Command {
 	command.Flags().BoolVar(
 		&flags.allowInsecure, "allow-insecure", false,
 		"allow adding packages marked as insecure.")
+	command.Flags().BoolVar(
+		&flags.disablePlugin, "disable-plugin", false,
+		"disable plugin (if any) for this package.")
 	command.Flags().StringSliceVarP(
 		&flags.platforms, "platform", "p", []string{},
 		"add packages to run on only this platform.")
@@ -65,13 +69,17 @@ func addCmd() *cobra.Command {
 
 func addCmdFunc(cmd *cobra.Command, args []string, flags addCmdFlags) error {
 	box, err := devbox.Open(&devopt.Opts{
-		Dir:               flags.config.path,
-		Stderr:            cmd.ErrOrStderr(),
-		AllowInsecureAdds: flags.allowInsecure,
+		Dir:    flags.config.path,
+		Stderr: cmd.ErrOrStderr(),
 	})
 	if err != nil {
 		return errors.WithStack(err)
 	}
 
-	return box.Add(cmd.Context(), flags.platforms, flags.excludePlatforms, args...)
+	return box.Add(cmd.Context(), args, devopt.AddOpts{
+		AllowInsecure:    flags.allowInsecure,
+		DisablePlugin:    flags.disablePlugin,
+		Platforms:        flags.platforms,
+		ExcludePlatforms: flags.excludePlatforms,
+	})
 }

internal/devconfig/ast.go

@@ -170,25 +170,37 @@ func (c *configAST) removePackageElement(arr *hujson.Array, name string) {
 	arr.Elements = slices.Delete(arr.Elements, i, i+1)
 }
 
-// appendPlatforms appends a platform to a package's "platforms" or
-// "excluded_platforms" field. It automatically converts the package to an
-// object if it isn't already.
+// setPackageBool sets a bool field on a package.
+func (c *configAST) setPackageBool(name, fieldName string, val bool) {
+	pkgObject := c.FindPkgObject(name)
+	if pkgObject == nil {
+		return
+	}
+	if i := c.memberIndex(pkgObject, fieldName); i == -1 {
+		pkgObject.Members = append(pkgObject.Members, hujson.ObjectMember{
+			Name: hujson.Value{
+				Value:       hujson.String(fieldName),
+				BeforeExtra: []byte{'\n'},
+			},
+			Value: hujson.Value{Value: hujson.Bool(val)},
+		})
+	} else {
+		pkgObject.Members[i].Value.Value = hujson.Bool(val)
+	}
+
+	c.root.Format()
+}
+
 func (c *configAST) appendPlatforms(name, fieldName string, platforms []string) {
 	if len(platforms) == 0 {
 		return
 	}
 
-	pkgs := c.packagesField(true).Value.Value.(*hujson.Object)
-	i := c.memberIndex(pkgs, name)
-	if i == -1 {
+	pkgObject := c.FindPkgObject(name)
+	if pkgObject == nil {
 		return
 	}
 
-	// We need to ensure that the package value is a full object
-	// (not a version string) before we can add a platform.
-	c.convertVersionToObject(&pkgs.Members[i].Value)
-
-	pkgObject := pkgs.Members[i].Value.Value.(*hujson.Object)
 	var arr *hujson.Array
 	if i := c.memberIndex(pkgObject, fieldName); i == -1 {
 		arr = &hujson.Array{
@@ -212,6 +224,21 @@ func (c *configAST) appendPlatforms(name, fieldName string, platforms []string)
 	c.root.Format()
 }
 
+func (c *configAST) FindPkgObject(name string) *hujson.Object {
+	pkgs := c.packagesField(true).Value.Value.(*hujson.Object)
+	i := c.memberIndex(pkgs, name)
+	if i == -1 {
+		return nil
+	}
+
+	// We need to ensure that the package value is a full object
+	// (not a version string) before we can set a custom field on it.
+	c.convertVersionToObject(&pkgs.Members[i].Value)
+
+	pkgObject := pkgs.Members[i].Value.Value.(*hujson.Object)
+	return pkgObject
+}
+
 // migratePackagesArray migrates a legacy array of package versionedNames to an
 // object. See packagesField for details.
 func (c *configAST) migratePackagesArray(pkgs *hujson.Value) {

internal/devconfig/packages.go

@@ -177,6 +177,19 @@ func (pkgs *Packages) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
+func (pkgs *Packages) DisablePlugin(versionedName string, v bool) error {
+	name, version := parseVersionedName(versionedName)
+	i := pkgs.index(name, version)
+	if i == -1 {
+		return errors.Errorf("package %s not found", versionedName)
+	}
+	if pkgs.Collection[i].DisablePlugin != v {
+		pkgs.Collection[i].DisablePlugin = v
+		pkgs.ast.setPackageBool(name, "disable_plugin", v)
+	}
+	return nil
+}
+
 func (pkgs *Packages) index(name, version string) int {
 	return slices.IndexFunc(pkgs.Collection, func(p Package) bool {
 		return p.name == name && p.Version == version
@@ -187,6 +200,7 @@ type Package struct {
 	name    string
 	Version string `json:"version,omitempty"`
 
+	DisablePlugin     bool     `json:"disable_plugin,omitempty"`
 	Platforms         []string `json:"platforms,omitempty"`
 	ExcludedPlatforms []string `json:"excluded_platforms,omitempty"`
 

internal/devpkg/package.go

@@ -20,6 +20,7 @@ import (
 	"go.jetpack.io/devbox/internal/cuecfg"
 	"go.jetpack.io/devbox/internal/devconfig"
 	"go.jetpack.io/devbox/internal/devpkg/pkgtype"
+	"go.jetpack.io/devbox/internal/impl/devopt"
 	"go.jetpack.io/devbox/internal/lock"
 	"go.jetpack.io/devbox/internal/nix"
 	"go.jetpack.io/devbox/plugins"
@@ -33,6 +34,10 @@ type Package struct {
 	lockfile        lock.Locker
 	IsDevboxPackage bool
 
+	// If package triggers a built-in plugin, setting this to true will disable it.
+	// If package does not trigger plugin, this will have no effect.
+	DisablePlugin bool
+
 	// installable is the flake attribute that the package resolves to.
 	// When it gets set depends on the original package string:
 	//
@@ -85,12 +90,21 @@ type Package struct {
 	normalizedPackageAttributePathCache string // memoized value from normalizedPackageAttributePath()
 }
 
-// PackageFromStrings constructs Package from the list of package names provided.
+// PackagesFromStringsWithDefaults constructs Package from the list of package names provided.
 // These names correspond to devbox packages from the devbox.json config.
-func PackageFromStrings(rawNames []string, l lock.Locker) []*Package {
+func PackagesFromStringsWithDefaults(rawNames []string, l lock.Locker) []*Package {
 	packages := []*Package{}
 	for _, rawName := range rawNames {
-		packages = append(packages, PackageFromString(rawName, l))
+		pkg := PackageFromStringWithDefaults(rawName, l)
+		packages = append(packages, pkg)
+	}
+	return packages
+}
+
+func PackagesFromStringsWithOptions(rawNames []string, l lock.Locker, opts devopt.AddOpts) []*Package {
+	packages := []*Package{}
+	for _, name := range rawNames {
+		packages = append(packages, PackageFromStringWithOptions(name, l, opts))
 	}
 	return packages
 }
@@ -99,19 +113,24 @@ func PackagesFromConfig(config *devconfig.Config, l lock.Locker) []*Package {
 	result := []*Package{}
 	for _, cfgPkg := range config.Packages.Collection {
 		pkg := newPackage(cfgPkg.VersionedName(), cfgPkg.IsEnabledOnPlatform(), l)
+		pkg.DisablePlugin = cfgPkg.DisablePlugin
 		pkg.PatchGlibc = cfgPkg.PatchGlibc
 		result = append(result, pkg)
 	}
 	return result
 }
 
-// PackageFromString constructs Package from the raw name provided.
-// The raw name corresponds to a devbox package from the devbox.json config.
-func PackageFromString(raw string, locker lock.Locker) *Package {
-	// Packages are installable by default.
+func PackageFromStringWithDefaults(raw string, locker lock.Locker) *Package {
 	return newPackage(raw, true /*isInstallable*/, locker)
 }
 
+func PackageFromStringWithOptions(raw string, locker lock.Locker, opts devopt.AddOpts) *Package {
+	pkg := PackageFromStringWithDefaults(raw, locker)
+	pkg.DisablePlugin = opts.DisablePlugin
+	// TODO: add patchGlibc flag
+	return pkg
+}
+
 func newPackage(raw string, isInstallable bool, locker lock.Locker) *Package {
 	pkg := &Package{
 		Raw:           raw,

internal/devpkg/package_test.go

@@ -134,7 +134,7 @@ func (l *lockfile) Resolve(pkg string) (*lock.Package, error) {
 }
 
 func testInputFromString(s, projectDir string) *testInput {
-	return lo.ToPtr(testInput{Package: PackageFromString(s, &lockfile{projectDir})})
+	return lo.ToPtr(testInput{Package: PackageFromStringWithDefaults(s, &lockfile{projectDir})})
 }
 
 func TestHashFromNixPkgsURL(t *testing.T) {
@@ -241,7 +241,7 @@ func TestCanonicalName(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.pkgName, func(t *testing.T) {
-			pkg := PackageFromString(tt.pkgName, &lockfile{})
+			pkg := PackageFromStringWithDefaults(tt.pkgName, &lockfile{})
 			got := pkg.CanonicalName()
 			if got != tt.expectedName {
 				t.Errorf("Expected canonical name %q, but got %q", tt.expectedName, got)

internal/impl/devbox.go

@@ -64,7 +64,6 @@ type Devbox struct {
 	pluginManager            *plugin.Manager
 	preservePathStack        bool
 	pure                     bool
-	allowInsecureAdds        bool
 	customProcessComposeFile string
 
 	// This is needed because of the --quiet flag.
@@ -94,7 +93,6 @@ func Open(opts *devopt.Opts) (*Devbox, error) {
 		preservePathStack:        opts.PreservePathStack,
 		pure:                     opts.Pure,
 		customProcessComposeFile: opts.CustomProcessComposeFile,
-		allowInsecureAdds:        opts.AllowInsecureAdds,
 	}
 
 	lock, err := lock.GetFile(box)
@@ -103,7 +101,7 @@ func Open(opts *devopt.Opts) (*Devbox, error) {
 	}
 	// if lockfile has any allow insecure, we need to set the env var to ensure
 	// all nix commands work.
-	if opts.AllowInsecureAdds || lock.HasAllowInsecurePackages() {
+	if lock.HasAllowInsecurePackages() {
 		nix.AllowInsecurePackages()
 	}
 	box.pluginManager.ApplyOptions(
@@ -357,7 +355,7 @@ func (d *Devbox) Info(ctx context.Context, pkg string, markdown bool) (string, e
 	)
 	readme, err := plugin.Readme(
 		ctx,
-		devpkg.PackageFromString(pkg, d.lockfile),
+		devpkg.PackageFromStringWithDefaults(pkg, d.lockfile),
 		d.projectDir,
 		markdown,
 	)

internal/impl/devopt/devboxopts.go

@@ -5,7 +5,6 @@ import (
 )
 
 type Opts struct {
-	AllowInsecureAdds        bool
 	Dir                      string
 	Env                      map[string]string
 	PreservePathStack        bool
@@ -38,6 +37,13 @@ type Credentials struct {
 	Sub   string
 }
 
+type AddOpts struct {
+	AllowInsecure    bool
+	Platforms        []string
+	ExcludePlatforms []string
+	DisablePlugin    bool
+}
+
 type UpdateOpts struct {
 	Pkgs                  []string
 	IgnoreMissingPackages bool