feat: per-directory dev environments with declarative manifest

Author: trankimtung

.gitignore

@@ -0,0 +1,5 @@
+.idea
+bin
+dist
+*.out
+nem.ver

cmd/activate.go

@@ -0,0 +1,68 @@
+package cmd
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"github.com/vi-dev/nem/internal/output"
+	"github.com/vi-dev/nem/internal/shell"
+)
+
+func newActivateCmd() *cobra.Command {
+	c := &cobra.Command{
+		Use:     "activate [bash|zsh|fish]",
+		Short:   "Install nem shell integration",
+		GroupID: groupShell,
+		Long: `Install the nem shell integration into your shell rc file.
+
+Without arguments, the shell is detected from $SHELL.
+
+The integration enables:
+  - Automatic PATH updates when changing directories and after running
+    'nem use', 'nem unuse', 'nem refresh', or 'nem set-env/unset-env'.
+  - Tab-completion for the 'nem' command (dynamic for package and
+    catalog names where applicable).
+
+Run 'nem deactivate' to remove the integration.
+
+When stdout is not a terminal (e.g. 'eval "$(nem activate zsh)"') the
+script is printed instead of being installed, so legacy setups continue
+to work. Pass --print to force this behaviour.`,
+		Args: cobra.MaximumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			printOnly, _ := cmd.Flags().GetBool("print")
+			name := shell.DetectShell()
+			if len(args) > 0 {
+				name = strings.ToLower(args[0])
+			}
+			body, err := shell.Script(name)
+			if err != nil {
+				return err
+			}
+			if printOnly || !shell.StdoutIsTerminal() {
+				fmt.Print(body)
+				return nil
+			}
+			path, err := shell.RCPath(name)
+			if err != nil {
+				return err
+			}
+			added, err := shell.AppendBlock(path, body)
+			if err != nil {
+				return err
+			}
+			if !added {
+				output.Infof("nem integration already present in %q", path)
+				output.Infof("to refresh (e.g. pick up new shell features), run: nem deactivate && nem activate")
+				return nil
+			}
+			output.Infof("added nem integration to %q", path)
+			output.Infof("reload your shell or run 'source %s' to activate", path)
+			return nil
+		},
+	}
+	c.Flags().Bool("print", false, "print the integration script to stdout instead of installing it")
+	return c
+}

cmd/author/cmd.go

@@ -0,0 +1,12 @@
+package author
+
+import "github.com/spf13/cobra"
+
+var AuthorCmd = &cobra.Command{
+	Use:   "author",
+	Short: "Catalog authoring tools",
+}
+
+func init() {
+	AuthorCmd.AddCommand(lintCmd)
+}

cmd/author/lint.go

@@ -0,0 +1,83 @@
+package author
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/spf13/cobra"
+
+	"github.com/vi-dev/nem/internal/app"
+	"github.com/vi-dev/nem/internal/config"
+	"github.com/vi-dev/nem/internal/linter"
+	"github.com/vi-dev/nem/internal/pkg"
+)
+
+var lintCmd = &cobra.Command{
+	Use:   "lint [path]",
+	Short: "Validate pkg.yaml manifests before publishing",
+	Long: `Validate one or more pkg.yaml package manifests for structural and
+semantic errors. The path may be:
+  - a pkg.yaml file
+  - a package directory containing pkg.yaml
+  - a catalog directory containing <name>/pkg.yaml entries (lints all)
+  - omitted, in which case the current directory is used
+
+With --install, every package that passes the offline checks is then
+installed and tested against an isolated NEM_HOME. Install/test
+failures are reported as findings just like offline ones.`,
+	Args: cobra.MaximumNArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		installFlag, _ := cmd.Flags().GetBool("install")
+		path := "."
+		if len(args) == 1 {
+			path = args[0]
+		}
+		res, err := runLint(cmd.Context(), path, installFlag)
+		if err != nil {
+			return err
+		}
+		w := cmd.OutOrStdout()
+		for _, f := range res.Findings {
+			if f.Field != "" {
+				fmt.Fprintf(w, "%s: %s: %s\n", f.File, f.Field, f.Message)
+			} else {
+				fmt.Fprintf(w, "%s: %s\n", f.File, f.Message)
+			}
+		}
+		if len(res.Findings) > 0 {
+			return fmt.Errorf("%d finding(s)", len(res.Findings))
+		}
+		fmt.Fprintln(w, "ok")
+		return nil
+	},
+}
+
+func init() {
+	lintCmd.Flags().Bool("install", false, "also install and test each package that passes offline checks")
+}
+
+func runLint(ctx context.Context, path string, install bool) (linter.Result, error) {
+	if !install {
+		return linter.Lint(path)
+	}
+	userCfg, err := config.Load()
+	if err != nil {
+		return linter.Result{}, fmt.Errorf("load user config: %w", err)
+	}
+	return linter.LintWithInstall(ctx, path, userCfg.Auth, installProbe)
+}
+
+func installProbe(ctx context.Context, name string) (string, error) {
+	a, err := app.Open()
+	if err != nil {
+		return "", fmt.Errorf("app.Open: %w", err)
+	}
+	latest, _, err := a.Catalogs().Latest(ctx, name)
+	if err != nil {
+		return "", err
+	}
+	if _, err := a.Pkg().Install(ctx, pkg.Refs{{Name: name, Version: latest}}); err != nil {
+		return latest, err
+	}
+	return latest, nil
+}

cmd/author/lint_auth_test.go

@@ -0,0 +1,70 @@
+package author
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"os"
+	"path/filepath"
+	"sync/atomic"
+	"testing"
+)
+
+// TestLint_InstallPropagatesUserAuth verifies that auth credentials configured
+// in the user's $NEM_HOME/config.yaml reach the fetcher during
+// `nem author lint --install`, which runs the install against an isolated
+// temp NEM_HOME.
+func TestLint_InstallPropagatesUserAuth(t *testing.T) {
+	var sawAuth atomic.Value
+	sawAuth.Store("")
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		sawAuth.Store(r.Header.Get("Authorization"))
+		w.WriteHeader(http.StatusUnauthorized)
+		_, _ = io.WriteString(w, "unauthorized")
+	}))
+	t.Cleanup(srv.Close)
+
+	u, err := url.Parse(srv.URL)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	nemHome := t.TempDir()
+	t.Setenv("NEM_HOME", nemHome)
+	cfgYAML := fmt.Sprintf(
+		"catalogs: []\nauth:\n  http:\n    - host: %s\n      bearer: lint-secret\n",
+		u.Host,
+	)
+	if err := os.WriteFile(filepath.Join(nemHome, "config.yaml"), []byte(cfgYAML), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	pkgDir := filepath.Join(t.TempDir(), "lint-auth-pkg")
+	if err := os.MkdirAll(pkgDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	pkgYAML := fmt.Sprintf(
+		"name: lint-auth-pkg\n"+
+			"archive:\n"+
+			"  fetcher:\n"+
+			"    http:\n"+
+			"      url: %s/pkg-{{.Version}}.tar.gz\n"+
+			"  verify:\n"+
+			"    sha256: \"0000000000000000000000000000000000000000000000000000000000000000\"\n"+
+			"versions:\n"+
+			"  - version: 1.0.0\n",
+		srv.URL)
+	if err := os.WriteFile(filepath.Join(pkgDir, "pkg.yaml"), []byte(pkgYAML), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	root, _ := newRootWithAuthor(t)
+	root.SetArgs([]string{"author", "lint", "--install", pkgDir})
+	_ = root.Execute()
+
+	if got, _ := sawAuth.Load().(string); got != "Bearer lint-secret" {
+		t.Errorf("test server saw Authorization = %q; want %q", got, "Bearer lint-secret")
+	}
+}

cmd/author/lint_install_test.go

@@ -0,0 +1,48 @@
+package author
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func ensureSandboxAvailable(t *testing.T) {
+	t.Helper()
+	switch runtime.GOOS {
+	case "darwin":
+		if _, err := os.Stat("/usr/bin/sandbox-exec"); err != nil {
+			t.Skipf("sandbox-exec unavailable: %v", err)
+		}
+	case "linux":
+		if _, err := exec.LookPath("bwrap"); err != nil {
+			t.Skip("bwrap not installed")
+		}
+	default:
+		t.Skipf("sandbox not supported on %s", runtime.GOOS)
+	}
+}
+
+// TestLint_InstallSurfacesFetchFailureAsFinding is a sandbox-gated
+// end-to-end test that confirms --install routes installer errors through
+// to a Finding (rather than crashing). It uses the linter's `valid`
+// fixture, whose github_release fetcher points at a nonexistent repo so
+// the fetch deterministically fails.
+func TestLint_InstallSurfacesFetchFailureAsFinding(t *testing.T) {
+	if testing.Short() {
+		t.Skip("end-to-end --install test skipped under -short")
+	}
+	ensureSandboxAvailable(t)
+	valid := filepath.Join(repoRoot(t), "internal", "linter", "testdata", "valid")
+	root, stdout := newRootWithAuthor(t)
+	root.SetArgs([]string{"author", "lint", "--install", valid})
+	err := root.Execute()
+	if err == nil {
+		t.Fatalf("expected install failure to surface as a finding; stdout=%q", stdout.String())
+	}
+	if !strings.Contains(stdout.String(), ": install:") {
+		t.Errorf("expected install: finding line in stdout; got %q", stdout.String())
+	}
+}

cmd/author/lint_test.go

@@ -0,0 +1,100 @@
+package author
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/spf13/cobra"
+)
+
+func newRootWithAuthor(t *testing.T) (*cobra.Command, *bytes.Buffer) {
+	t.Helper()
+	root := &cobra.Command{Use: "nem", SilenceUsage: true}
+	root.AddCommand(AuthorCmd)
+	t.Cleanup(func() { lintCmd.Flags().Set("install", "false") })
+	var stdout, stderr bytes.Buffer
+	root.SetOut(&stdout)
+	root.SetErr(&stderr)
+	return root, &stdout
+}
+
+func TestLint_CleanFixtureExitsZero(t *testing.T) {
+	valid := filepath.Join(repoRoot(t), "internal", "linter", "testdata", "valid")
+	root, _ := newRootWithAuthor(t)
+	root.SetArgs([]string{"author", "lint", valid})
+	if err := root.Execute(); err != nil {
+		t.Fatalf("lint clean fixture: unexpected error %v", err)
+	}
+}
+
+func TestLint_FixtureWithFindingExitsNonZero(t *testing.T) {
+	missingName := filepath.Join(repoRoot(t), "internal", "linter", "testdata", "missing-name")
+	root, stdout := newRootWithAuthor(t)
+	root.SetArgs([]string{"author", "lint", missingName})
+	err := root.Execute()
+	if err == nil {
+		t.Fatalf("expected non-nil error for fixture with findings; stdout=%q", stdout.String())
+	}
+	if !strings.Contains(stdout.String(), "name: must not be empty") {
+		t.Errorf("expected finding in stdout; got %q", stdout.String())
+	}
+}
+
+func TestLint_InstallSkipsPackagesWithOfflineFindings(t *testing.T) {
+	// Build a tiny repo dir with one package that has a malformed manifest.
+	// With --install set, the failing-offline package contributes a finding
+	// and the install loop must NOT attempt it (the broken manifest has no
+	// archive/versions, so any install attempt would surface a SECOND
+	// finding from the install path).
+	repo := t.TempDir()
+	bad := filepath.Join(repo, "broken")
+	if err := os.MkdirAll(bad, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(bad, "pkg.yaml"),
+		[]byte("name: broken\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	root, stdout := newRootWithAuthor(t)
+	root.SetArgs([]string{"author", "lint", "--install", repo})
+	err := root.Execute()
+	if err == nil {
+		t.Fatalf("expected non-nil error; stdout=%q", stdout.String())
+	}
+	// Exactly one finding line should appear in captured stdout: the offline
+	// "archive must be set" (B6) finding. If --install were attempting the
+	// broken package, additional findings would show up.
+	findingLines := 0
+	for _, line := range strings.Split(strings.TrimRight(stdout.String(), "\n"), "\n") {
+		if line != "" {
+			findingLines++
+		}
+	}
+	if findingLines != 1 {
+		t.Errorf("expected exactly 1 finding line (offline only); got %d: %q", findingLines, stdout.String())
+	}
+}
+
+// repoRoot walks up from the test working directory until it finds go.mod,
+// so the test can reference internal/linter/testdata regardless of which
+// package directory `go test` runs in.
+func repoRoot(t *testing.T) string {
+	t.Helper()
+	dir, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	for {
+		if _, err := os.Stat(filepath.Join(dir, "go.mod")); err == nil {
+			return dir
+		}
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			t.Fatal("could not locate go.mod from cwd")
+		}
+		dir = parent
+	}
+}