Make runtime defaults portable

Stop assuming one workstation layout for runtime artifacts, mapdns, and host tooling. The daemon and shell helpers now use portable mapdns configuration, and runtime bundles can carry bundle.json metadata for their default kernel, initrd, modules, rootfs, and helper paths.

Load bundle metadata through config with a legacy layout fallback, thread mapdns_bin/mapdns_data_file through the Go and shell paths, and add command-scoped preflight checks for VM start, NAT, image build, work-disk resize, and SSH so missing tools or artifacts fail with actionable errors.

Update the runtime-bundle manifest, docs, and tests to match the new model. Verified with go test ./..., make build, and bash -n customize.sh interactive.sh dns.sh make-rootfs.sh verify.sh.

internal/daemon/daemon_test.go

@@ -52,3 +52,57 @@ func TestEnsureDefaultImageUsesConfiguredDefaultRootfs(t *testing.T) {
 		t.Fatalf("KernelPath = %q, want %q", image.KernelPath, kernel)
 	}
 }
+
+func TestSetDNSUsesConfiguredMapDNSDataFile(t *testing.T) {
+	t.Parallel()
+
+	dataFile := filepath.Join(t.TempDir(), "mapdns", "records.json")
+	runner := &scriptedRunner{
+		t: t,
+		steps: []runnerStep{
+			{
+				call: runnerCall{
+					name: "custom-mapdns",
+					args: []string{"set", "--data-file", dataFile, "devbox.vm", "172.16.0.8"},
+				},
+			},
+		},
+	}
+	d := &Daemon{
+		runner: runner,
+		config: model.DaemonConfig{
+			MapDNSBin:      "custom-mapdns",
+			MapDNSDataFile: dataFile,
+		},
+	}
+
+	if err := d.setDNS(context.Background(), "devbox", "172.16.0.8"); err != nil {
+		t.Fatalf("setDNS: %v", err)
+	}
+	runner.assertExhausted()
+}
+
+func TestSetDNSUsesMapDNSDefaultsWhenDataFileUnset(t *testing.T) {
+	t.Parallel()
+
+	runner := &scriptedRunner{
+		t: t,
+		steps: []runnerStep{
+			{
+				call: runnerCall{
+					name: "mapdns",
+					args: []string{"set", "devbox.vm", "172.16.0.8"},
+				},
+			},
+		},
+	}
+	d := &Daemon{
+		runner: runner,
+		config: model.DaemonConfig{},
+	}
+
+	if err := d.setDNS(context.Background(), "devbox", "172.16.0.8"); err != nil {
+		t.Fatalf("setDNS: %v", err)
+	}
+	runner.assertExhausted()
+}

internal/daemon/images.go

@@ -75,6 +75,9 @@ func (d *Daemon) BuildImage(ctx context.Context, params api.ImageBuildParams) (m
 	if params.Docker {
 		args = append(args, "--docker")
 	}
+	if err := d.validateImageBuildPrereqs(ctx, baseRootfs, kernelPath, initrdPath, modulesDir); err != nil {
+		return model.Image{}, err
+	}
 	cmd := exec.CommandContext(ctx, "bash", args...)
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
@@ -85,6 +88,12 @@ func (d *Daemon) BuildImage(ctx context.Context, params api.ImageBuildParams) (m
 		"BANGER_RUNTIME_DIR="+d.config.RuntimeDir,
 		"BANGER_STATE_DIR="+filepath.Join(d.layout.StateDir, "image-build"),
 	)
+	if d.config.MapDNSBin != "" {
+		cmd.Env = append(cmd.Env, "BANGER_MAPDNS_BIN="+d.config.MapDNSBin)
+	}
+	if d.config.MapDNSDataFile != "" {
+		cmd.Env = append(cmd.Env, "BANGER_MAPDNS_DATA_FILE="+d.config.MapDNSDataFile)
+	}
 	if err := cmd.Run(); err != nil {
 		_ = os.RemoveAll(artifactDir)
 		return model.Image{}, err

internal/daemon/nat.go

@@ -17,10 +17,7 @@ type natRule struct {
 }
 
 func (d *Daemon) ensureNAT(ctx context.Context, vm model.VMRecord, enable bool) error {
-	if err := system.RequireCommands(ctx, "iptables", "sysctl"); err != nil {
-		return err
-	}
-	uplink, err := d.defaultUplink(ctx)
+	uplink, err := d.validateNATPrereqs(ctx)
 	if err != nil {
 		return err
 	}
@@ -47,6 +44,16 @@ func (d *Daemon) ensureNAT(ctx context.Context, vm model.VMRecord, enable bool)
 	return nil
 }
 
+func (d *Daemon) validateNATPrereqs(ctx context.Context) (string, error) {
+	checks := system.NewPreflight()
+	checks.RequireCommand("ip", toolHint("ip"))
+	d.addNATPrereqs(ctx, checks)
+	if err := checks.Err("nat preflight failed"); err != nil {
+		return "", err
+	}
+	return d.defaultUplink(ctx)
+}
+
 func (d *Daemon) defaultUplink(ctx context.Context) (string, error) {
 	out, err := d.runner.Run(ctx, "ip", "route", "show", "default")
 	if err != nil {

internal/daemon/preflight.go

@@ -0,0 +1,123 @@
+package daemon
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"banger/internal/model"
+	"banger/internal/paths"
+	"banger/internal/system"
+)
+
+func (d *Daemon) validateStartPrereqs(ctx context.Context, vm model.VMRecord, image model.Image) error {
+	checks := system.NewPreflight()
+	hint := paths.RuntimeBundleHint()
+
+	for _, command := range []string{"sudo", "ip", "dmsetup", "losetup", "blockdev", "truncate", "pgrep", "ps", "chown", "chmod", "kill", "e2cp", "e2rm", "debugfs"} {
+		checks.RequireCommand(command, toolHint(command))
+	}
+	checks.RequireExecutable(d.config.FirecrackerBin, "firecracker binary", hint)
+	checks.RequireExecutable(d.config.MapDNSBin, "mapdns binary", `install mapdns or set "mapdns_bin" / BANGER_MAPDNS_BIN`)
+	checks.RequireFile(image.RootfsPath, "rootfs image", "select a valid image or rebuild the runtime bundle")
+	checks.RequireFile(image.KernelPath, "kernel image", `set "default_kernel" or refresh the runtime bundle`)
+	if strings.TrimSpace(image.InitrdPath) != "" {
+		checks.RequireFile(image.InitrdPath, "initrd image", `set "default_initrd" or refresh the runtime bundle`)
+	}
+	if !exists(vm.Runtime.WorkDiskPath) {
+		for _, command := range []string{"mkfs.ext4", "mount", "umount", "cp"} {
+			checks.RequireCommand(command, toolHint(command))
+		}
+	}
+	if vm.Spec.NATEnabled {
+		d.addNATPrereqs(ctx, checks)
+	}
+	if dataFile := strings.TrimSpace(d.config.MapDNSDataFile); dataFile != "" {
+		parent := filepath.Dir(dataFile)
+		if parent != "." && parent != "" {
+			if _, err := os.Stat(parent); err != nil && !os.IsNotExist(err) {
+				checks.Addf("mapdns data directory %s is not accessible (%v)", parent, err)
+			}
+		}
+	}
+	return checks.Err("vm start preflight failed")
+}
+
+func (d *Daemon) validateImageBuildPrereqs(ctx context.Context, baseRootfs, kernelPath, initrdPath, modulesDir string) error {
+	checks := system.NewPreflight()
+	hint := paths.RuntimeBundleHint()
+
+	for _, command := range []string{"bash", "sudo", "ip", "curl", "ssh", "jq", "sha256sum", "e2fsck", "resize2fs"} {
+		checks.RequireCommand(command, toolHint(command))
+	}
+	checks.RequireExecutable(d.config.CustomizeScript, "customize.sh helper", hint)
+	checks.RequireExecutable(d.config.MapDNSBin, "mapdns binary", `install mapdns or set "mapdns_bin" / BANGER_MAPDNS_BIN`)
+	checks.RequireFile(baseRootfs, "base rootfs image", `pass --base-rootfs or set "default_base_rootfs"`)
+	checks.RequireFile(kernelPath, "kernel image", `pass --kernel or set "default_kernel"`)
+	if strings.TrimSpace(initrdPath) != "" {
+		checks.RequireFile(initrdPath, "initrd image", `pass --initrd or set "default_initrd"`)
+	}
+	if strings.TrimSpace(modulesDir) != "" {
+		checks.RequireDir(modulesDir, "modules directory", `pass --modules or set "default_modules_dir"`)
+	}
+	return checks.Err("image build preflight failed")
+}
+
+func (d *Daemon) validateWorkDiskResizePrereqs() error {
+	checks := system.NewPreflight()
+	checks.RequireCommand("truncate", toolHint("truncate"))
+	checks.RequireCommand("e2fsck", `install e2fsprogs`)
+	checks.RequireCommand("resize2fs", `install e2fsprogs`)
+	return checks.Err("work disk resize preflight failed")
+}
+
+func (d *Daemon) addNATPrereqs(ctx context.Context, checks *system.Preflight) {
+	checks.RequireCommand("iptables", toolHint("iptables"))
+	checks.RequireCommand("sysctl", toolHint("sysctl"))
+	out, err := d.runner.Run(ctx, "ip", "route", "show", "default")
+	if err != nil {
+		checks.Addf("failed to inspect the default route for NAT: %v", err)
+		return
+	}
+	if _, err := parseDefaultUplink(string(out)); err != nil {
+		checks.Addf("failed to detect the uplink interface for NAT: %v", err)
+	}
+}
+
+func toolHint(command string) string {
+	switch command {
+	case "ip":
+		return "install iproute2"
+	case "iptables":
+		return "install iptables"
+	case "sysctl", "losetup", "blockdev", "mount", "umount":
+		return "install util-linux"
+	case "dmsetup":
+		return "install device-mapper"
+	case "pgrep", "ps", "kill":
+		return "install procps"
+	case "chown", "chmod", "cp", "truncate":
+		return "install coreutils"
+	case "e2fsck", "resize2fs", "debugfs", "mkfs.ext4":
+		return "install e2fsprogs"
+	case "e2cp", "e2rm":
+		return "install e2tools"
+	case "curl":
+		return "install curl"
+	case "jq":
+		return "install jq"
+	case "sha256sum":
+		return "install coreutils"
+	case "mapdns":
+		return `install mapdns or set "mapdns_bin" / BANGER_MAPDNS_BIN`
+	case "ssh":
+		return "install openssh-client"
+	case "bash":
+		return "install bash"
+	case "sudo":
+		return "install sudo"
+	default:
+		return ""
+	}
+}

internal/daemon/vm.go

@@ -125,7 +125,7 @@ func (d *Daemon) StartVM(ctx context.Context, idOrName string) (model.VMRecord,
 }
 
 func (d *Daemon) startVMLocked(ctx context.Context, vm model.VMRecord, image model.Image) (model.VMRecord, error) {
-	if err := d.requireStartPrereqs(ctx); err != nil {
+	if err := d.validateStartPrereqs(ctx, vm, image); err != nil {
 		return model.VMRecord{}, err
 	}
 	if err := os.MkdirAll(vm.Runtime.VMDir, 0o755); err != nil {
@@ -389,6 +389,9 @@ func (d *Daemon) SetVM(ctx context.Context, params api.VMSetParams) (model.VMRec
 		}
 		if size > vm.Spec.WorkDiskSizeBytes {
 			if exists(vm.Runtime.WorkDiskPath) {
+				if err := d.validateWorkDiskResizePrereqs(); err != nil {
+					return model.VMRecord{}, err
+				}
 				if err := system.ResizeExt4Image(ctx, d.runner, vm.Runtime.WorkDiskPath, size); err != nil {
 					return model.VMRecord{}, err
 				}
@@ -690,7 +693,12 @@ func clearRuntimeHandles(vm *model.VMRecord) {
 }
 
 func (d *Daemon) setDNS(ctx context.Context, vmName, guestIP string) error {
-	_, err := d.runner.Run(ctx, "mapdns", "set", "--data-file", "/home/thales/.local/share/mapdns/records.json", vmName+".vm", guestIP)
+	if dataFile := strings.TrimSpace(d.config.MapDNSDataFile); dataFile != "" {
+		if err := os.MkdirAll(filepath.Dir(dataFile), 0o755); err != nil {
+			return err
+		}
+	}
+	_, err := d.runner.Run(ctx, d.mapdnsBinary(), d.mapdnsArgs("set", vmName+".vm", guestIP)...)
 	return err
 }
 
@@ -698,7 +706,7 @@ func (d *Daemon) removeDNS(ctx context.Context, dnsName string) error {
 	if dnsName == "" {
 		return nil
 	}
-	_, err := d.runner.Run(ctx, "mapdns", "rm", "--data-file", "/home/thales/.local/share/mapdns/records.json", dnsName)
+	_, err := d.runner.Run(ctx, d.mapdnsBinary(), d.mapdnsArgs("rm", dnsName)...)
 	if err != nil && strings.Contains(err.Error(), "not found") {
 		return nil
 	}
@@ -710,28 +718,6 @@ func (d *Daemon) killVMProcess(ctx context.Context, pid int) error {
 	return err
 }
 
-func (d *Daemon) requireStartPrereqs(ctx context.Context) error {
-	return system.RequireCommands(
-		ctx,
-		"sudo",
-		"ip",
-		"dmsetup",
-		"losetup",
-		"blockdev",
-		"e2cp",
-		"e2rm",
-		"debugfs",
-		"mkfs.ext4",
-		"truncate",
-		"pgrep",
-		"mount",
-		"umount",
-		"cp",
-		"ps",
-		"mapdns",
-	)
-}
-
 func (d *Daemon) generateName(ctx context.Context) (string, error) {
 	if exists(d.config.NamegenPath) {
 		out, err := d.runner.Run(ctx, d.config.NamegenPath)
@@ -759,3 +745,19 @@ func defaultInt(value, fallback int) int {
 	}
 	return fallback
 }
+
+func (d *Daemon) mapdnsBinary() string {
+	if value := strings.TrimSpace(d.config.MapDNSBin); value != "" {
+		return value
+	}
+	return "mapdns"
+}
+
+func (d *Daemon) mapdnsArgs(subcommand string, args ...string) []string {
+	out := []string{subcommand}
+	if value := strings.TrimSpace(d.config.MapDNSDataFile); value != "" {
+		out = append(out, "--data-file", value)
+	}
+	out = append(out, args...)
+	return out
+}