fix: dry-run must not write packages cache; adapt vm e2e for pre-release CI

- config: RefreshPackagesFromRemoteDryRun() skips writePackagesCache so
  --dry-run has zero side effects on ~/.openboot/
- root.go: call the dry-run variant when installCfg.DryRun is set
- TestVM_Journey_FirstTimeUser: use dev binary (vmCopyDevBinary) instead
  of brew tap install — brew formula requires a published release
- TestVM_Interactive_InstallScript: skip when openboot formula is not
  available in Homebrew (pre-release CI environment)

Author: fullstackjam

internal/cli/root.go

@@ -55,7 +55,11 @@ shell configuration, and macOS preferences.`,
 		// network overhead.
 		if cmd.Name() == "install" {
 			updater.AutoUpgrade(version)
-			config.RefreshPackagesFromRemote()
+			if installCfg.DryRun {
+				config.RefreshPackagesFromRemoteDryRun()
+			} else {
+				config.RefreshPackagesFromRemote()
+			}
 		}
 
 		return nil

internal/config/packages_remote.go

@@ -38,7 +38,18 @@ type packagesCacheEntry struct {
 // into the global Categories slice. Safe to call multiple times; it is a no-op
 // if the cache is fresh. Falls back to the embedded packages.yaml silently.
 func RefreshPackagesFromRemote() {
-	pkgs, err := loadRemotePackages()
+	refreshPackages(false)
+}
+
+// RefreshPackagesFromRemoteDryRun is identical to RefreshPackagesFromRemote
+// but suppresses writing the on-disk cache. Use during --dry-run so the
+// command has zero side effects on ~/.openboot/.
+func RefreshPackagesFromRemoteDryRun() {
+	refreshPackages(true)
+}
+
+func refreshPackages(dryRun bool) {
+	pkgs, err := loadRemotePackages(dryRun)
 	if err != nil || len(pkgs) == 0 {
 		return // keep embedded fallback
 	}
@@ -47,7 +58,7 @@ func RefreshPackagesFromRemote() {
 	mergeRemotePackages(pkgs)
 }
 
-func loadRemotePackages() ([]remotePackage, error) {
+func loadRemotePackages(dryRun bool) ([]remotePackage, error) {
 	// Try disk cache first.
 	if pkgs, err := readPackagesCache(); err == nil {
 		return pkgs, nil
@@ -59,8 +70,10 @@ func loadRemotePackages() ([]remotePackage, error) {
 		return nil, err
 	}
 
-	// Write cache (best-effort).
-	_ = writePackagesCache(pkgs)
+	// Write cache (best-effort) — skip during dry-run to avoid disk side effects.
+	if !dryRun {
+		_ = writePackagesCache(pkgs)
+	}
 	return pkgs, nil
 }
 

internal/config/packages_remote_test.go

@@ -291,7 +291,7 @@ func TestLoadRemotePackages_UsesCacheThenFallsToNetwork(t *testing.T) {
 
 	// No cache, no server → error.
 	t.Setenv("OPENBOOT_API_URL", "http://localhost:1")
-	_, err := loadRemotePackages()
+	_, err := loadRemotePackages(false)
 	assert.Error(t, err)
 
 	// Write fresh cache.
@@ -303,7 +303,7 @@ func TestLoadRemotePackages_UsesCacheThenFallsToNetwork(t *testing.T) {
 	os.WriteFile(filepath.Join(dir, packagesCacheFile), data, 0600)
 
 	// Cache hit → no network call needed.
-	pkgs, err := loadRemotePackages()
+	pkgs, err := loadRemotePackages(false)
 	require.NoError(t, err)
 	assert.Equal(t, "cached-pkg", pkgs[0].Name)
 }

test/e2e/vm_interactive_test.go

@@ -20,6 +20,18 @@ func TestVM_Interactive_InstallScript(t *testing.T) {
 	}
 
 	vm := testutil.NewMacHost(t)
+
+	// This test exercises install.sh's reinstall prompt, which requires openboot
+	// to be registered with Homebrew (`brew list openboot`). Skip if the formula
+	// isn't available — that means we're in a pre-release CI environment where
+	// the tap has no published formula yet.
+	tapScript := fmt.Sprintf(
+		"export PATH=%q && brew tap openbootdotdev/openboot 2>/dev/null; brew info openboot &>/dev/null",
+		brewPath,
+	)
+	if _, err := vm.Run(tapScript); err != nil {
+		t.Skip("openboot Homebrew formula not available — skipping brew-dependent interactive test")
+	}
 	vmInstallViaBrew(t, vm) // Install first (no TTY required)
 
 	// expect is required for interactive tests.

test/e2e/vm_user_journey_test.go

@@ -40,38 +40,38 @@ func TestVM_Journey_FirstTimeUser(t *testing.T) {
 	}
 
 	vm := testutil.NewMacHost(t)
-
-	// Clean up any openboot left over from a prior test run.
-	vm.Run(fmt.Sprintf("export PATH=%q && brew uninstall openboot 2>/dev/null || true", brewPath)) //nolint:errcheck // best-effort cleanup
+	vmInstallHomebrew(t, vm)
+	bin := vmCopyDevBinary(t, vm)
 
 	// Step 1: openboot shouldn't leak in from a prior step.
 	t.Run("bare_system_has_no_openboot", func(t *testing.T) {
 		out, _ := vm.Run("which openboot 2>/dev/null || echo not-found")
 		assert.Contains(t, out, "not-found", "openboot should not exist before install")
 	})
 
-	// Step 2: Install via brew tap (no TTY required; mirrors the curl|bash tap path).
-	t.Run("installs_via_brew_tap", func(t *testing.T) {
-		version := vmInstallViaBrew(t, vm)
-		assert.Contains(t, version, "OpenBoot v", "should report version after install")
+	// Step 2: Dev binary runs and reports a version.
+	t.Run("binary_is_available", func(t *testing.T) {
+		out, err := vm.Run(bin + " version")
+		require.NoError(t, err)
+		assert.Contains(t, out, "OpenBoot", "binary should report version")
 	})
 
 	// Step 3: Run openboot with minimal preset
 	t.Run("minimal_preset_installs_usable_tools", func(t *testing.T) {
-		output, err := vmRunOpenbootWithGit(t, vm, "install --preset minimal --silent --packages-only")
+		output, err := vmRunDevBinaryWithGit(t, vm, bin, "install --preset minimal --silent --packages-only")
 		t.Logf("install output:\n%s", output)
 		require.NoError(t, err, "minimal preset should succeed")
 
 		// User expectation: every tool should be USABLE, not just "in PATH"
 		toolChecks := map[string]string{
-			"jq":   `echo '{"a":1}' | jq '.a'`,          // Can it parse JSON?
-			"rg":   `echo 'hello world' | rg 'hello'`,   // Can it search?
-			"fd":   `fd --version`,                      // Does it run?
-			"bat":  `echo 'test' | bat --plain`,         // Can it display?
-			"fzf":  `echo 'a\nb\nc' | fzf --filter 'b'`, // Can it filter?
-			"htop": `htop --version`,                    // Does it run?
-			"tree": `tree --version`,                    // Does it run?
-			"gh":   `gh --version`,                      // Does it run?
+			"jq":   `echo '{"a":1}' | jq '.a'`,
+			"rg":   `echo 'hello world' | rg 'hello'`,
+			"fd":   `fd --version`,
+			"bat":  `echo 'test' | bat --plain`,
+			"fzf":  `echo 'a\nb\nc' | fzf --filter 'b'`,
+			"htop": `htop --version`,
+			"tree": `tree --version`,
+			"gh":   `gh --version`,
 		}
 
 		for name, cmd := range toolChecks {