[services] Fix services when using versioned packages (#994)

## Summary

This addresses related 3 bugs:

* "versioned" packages where not triggering plugins/services. This was
solved by updating plugin packages to use `nix.Input` and then using
`CanonicalName()` as the triggering name (In short, this means we use
`python` instead of `python@3`)
* Updated plugins to recognize canonical names in `match` field. (e.g.
`apache` plugin should trigger for `apache` and `apacheHttpd`). This was
implemented by augmenting the regular expression. Another approach would
have been to save the attribute path returned by search and use that
instead. Since it only affects a very limited number of plugins and we
don't really want to expand usage of `match` too much, I think this is
an OK tradeoff.
* minor bug: `PackageAttributePath()` in `input.go` was causing legacy
packages that don't exist to get resolved (e.g. when doing `devbox add
foobar`). This wasn't breaking anything because no packages get added to
`devbox.json` but it would leave bad data in lockfile.


## How was it tested?

`devbox add apach@2`
`devbox add php`
`devbox services ls`
`devbox add foobar` shows error and doesn't add to lockfile.

Author: mikeland73

devbox.lock

@@ -17,4 +17,4 @@
       "version": "1.52.2"
     }
   }
-}
+}

internal/impl/devbox.go

@@ -327,7 +327,7 @@ func (d *Devbox) Info(pkg string, markdown bool) error {
 		return errors.WithStack(err)
 	}
 	return plugin.PrintReadme(
-		pkg,
+		nix.InputFromString(pkg, d.lockfile),
 		d.projectDir,
 		d.writer,
 		markdown,
@@ -444,7 +444,7 @@ func (d *Devbox) saveCfg() error {
 }
 
 func (d *Devbox) Services() (services.Services, error) {
-	pluginSvcs, err := plugin.GetServices(d.packages(), d.projectDir)
+	pluginSvcs, err := plugin.GetServices(d.packagesAsInputs(), d.projectDir)
 	if err != nil {
 		return nil, err
 	}
@@ -778,7 +778,7 @@ func (d *Devbox) computeNixEnv(ctx context.Context, usePrintDevEnvCache bool) (m
 	// We still need to be able to add env variables to non-service binaries
 	// (e.g. ruby). This would involve understanding what binaries are associated
 	// to a given plugin.
-	pluginEnv, err := plugin.Env(d.packages(), d.projectDir, env)
+	pluginEnv, err := plugin.Env(d.packagesAsInputs(), d.projectDir, env)
 	if err != nil {
 		return nil, err
 	}
@@ -866,7 +866,7 @@ func (d *Devbox) writeScriptsToFiles() error {
 
 	// Write all hooks to a file.
 	written := map[string]struct{}{} // set semantics; value is irrelevant
-	pluginHooks, err := plugin.InitHooks(d.packages(), d.projectDir)
+	pluginHooks, err := plugin.InitHooks(d.packagesAsInputs(), d.projectDir)
 	if err != nil {
 		return errors.WithStack(err)
 	}
@@ -950,6 +950,10 @@ func (d *Devbox) packages() []string {
 	return d.cfg.Packages
 }
 
+func (d *Devbox) packagesAsInputs() []*nix.Input {
+	return nix.InputsFromStrings(d.packages(), d.lockfile)
+}
+
 func (d *Devbox) findPackageByName(name string) (string, error) {
 	results := []string{}
 	for _, pkg := range d.cfg.Packages {

internal/impl/generate.go

@@ -60,7 +60,7 @@ func (d *Devbox) generateShellFiles() error {
 		}
 	}
 
-	for _, pkg := range d.packages() {
+	for _, pkg := range d.packagesAsInputs() {
 		if err := d.pluginManager.CreateFilesAndShowReadme(d.writer, pkg, d.projectDir); err != nil {
 			return err
 		}

internal/impl/packages.go

@@ -76,9 +76,9 @@ func (d *Devbox) Add(ctx context.Context, pkgs ...string) error {
 		return err
 	}
 
-	for _, pkg := range pkgs {
+	for _, input := range nix.InputsFromStrings(pkgs, d.lockfile) {
 		if err := plugin.PrintReadme(
-			pkg,
+			input,
 			d.projectDir,
 			d.writer,
 			false, /*markdown*/

internal/lock/lockfile.go

@@ -79,13 +79,7 @@ func (l *File) Resolve(pkg string) (*Package, error) {
 		} else {
 			// These are legacy packages without a version. Resolve to nixpkgs with
 			// whatever hash is in the devbox.json
-			locked = &Package{
-				Resolved: fmt.Sprintf(
-					"github:NixOS/nixpkgs/%s#%s",
-					l.NixPkgsCommitHash(),
-					pkg,
-				),
-			}
+			locked = &Package{Resolved: l.LegacyNixpkgsPath(pkg)}
 		}
 		l.Packages[pkg] = locked
 		if err := l.Update(); err != nil {
@@ -114,6 +108,14 @@ func (l *File) Update() error {
 	return cuecfg.WriteFile(lockFilePath(l), l)
 }
 
+func (l *File) LegacyNixpkgsPath(pkg string) string {
+	return fmt.Sprintf(
+		"github:NixOS/nixpkgs/%s#%s",
+		l.NixPkgsCommitHash(),
+		pkg,
+	)
+}
+
 func IsVersionedPackage(pkg string) bool {
 	name, version, found := strings.Cut(pkg, "@")
 	return found && name != "" && version != ""

internal/lock/resolvers.go

@@ -16,4 +16,5 @@ type resolver interface {
 type Locker interface {
 	devboxProject
 	resolver
+	LegacyNixpkgsPath(string) string
 }

internal/nix/input.go

@@ -24,6 +24,14 @@ type Input struct {
 	lockfile lock.Locker
 }
 
+func InputsFromStrings(names []string, l lock.Locker) []*Input {
+	inputs := []*Input{}
+	for _, name := range names {
+		inputs = append(inputs, InputFromString(name, l))
+	}
+	return inputs
+}
+
 func InputFromString(s string, l lock.Locker) *Input {
 	u, _ := url.Parse(s)
 	if u.Path == "" && u.Opaque != "" && u.Scheme == "path" {
@@ -101,12 +109,14 @@ func (i *Input) URLForInstall() (string, error) {
 // packages.x86_64-linux.hello
 func (i *Input) PackageAttributePath() (string, error) {
 	var infos map[string]*Info
-	if i.IsDevboxPackage() {
+	if i.isVersioned() {
 		entry, err := i.lockfile.Resolve(i.String())
 		if err != nil {
 			return "", err
 		}
 		infos = search(entry.Resolved)
+	} else if i.IsDevboxPackage() {
+		infos = search(i.lockfile.LegacyNixpkgsPath(i.String()))
 	} else {
 		infos = search(i.String())
 	}

internal/nix/input_test.go

@@ -118,19 +118,23 @@ func (l *lockfile) ProjectDir() string {
 	return l.projectDir
 }
 
-func (lockfile) Resolve(pkg string) (*lock.Package, error) {
+func (l *lockfile) LegacyNixpkgsPath(pkg string) string {
+	return fmt.Sprintf(
+		"github:NixOS/nixpkgs/%s#%s",
+		nixCommitHash,
+		pkg,
+	)
+}
+
+func (l *lockfile) Resolve(pkg string) (*lock.Package, error) {
 	switch {
 	case strings.Contains(pkg, "path:"):
 		return &lock.Package{Resolved: pkg}, nil
 	case strings.Contains(pkg, "github:"):
 		return &lock.Package{Resolved: pkg}, nil
 	default:
 		return &lock.Package{
-			Resolved: fmt.Sprintf(
-				"github:NixOS/nixpkgs/%s#%s",
-				nixCommitHash,
-				pkg,
-			),
+			Resolved: l.LegacyNixpkgsPath(pkg),
 		}, nil
 	}
 }

internal/plugin/files.go

@@ -8,10 +8,11 @@ import (
 	"strings"
 
 	"github.com/pkg/errors"
+	"go.jetpack.io/devbox/internal/nix"
 	"go.jetpack.io/devbox/plugins"
 )
 
-func getConfigIfAny(pkg, projectDir string) (*config, error) {
+func getConfigIfAny(pkg *nix.Input, projectDir string) (*config, error) {
 	configFiles, err := plugins.BuiltIn.ReadDir(".")
 	if err != nil {
 		return nil, errors.WithStack(err)
@@ -27,14 +28,15 @@ func getConfigIfAny(pkg, projectDir string) (*config, error) {
 			return nil, errors.WithStack(err)
 		}
 
+		name := pkg.CanonicalName()
 		cfg, err := buildConfig(pkg, projectDir, string(content))
 		if err != nil {
 			return nil, errors.WithStack(err)
 		}
 		// if match regex is set we use it to check. Otherwise we assume it's a
 		// perfect match
-		if (cfg.Match != "" && !regexp.MustCompile(cfg.Match).MatchString(pkg)) ||
-			(cfg.Match == "" && strings.Split(file.Name(), ".")[0] != pkg) {
+		if (cfg.Match != "" && !regexp.MustCompile(cfg.Match).MatchString(name)) ||
+			(cfg.Match == "" && strings.Split(file.Name(), ".")[0] != name) {
 			continue
 		}
 		return cfg, nil

internal/plugin/hooks.go

@@ -3,7 +3,9 @@
 
 package plugin
 
-func InitHooks(pkgs []string, projectDir string) ([]string, error) {
+import "go.jetpack.io/devbox/internal/nix"
+
+func InitHooks(pkgs []*nix.Input, projectDir string) ([]string, error) {
 	hooks := []string{}
 	for _, pkg := range pkgs {
 		c, err := getConfigIfAny(pkg, projectDir)