Reject invalid VM CPU and memory values

VM create and vm set accepted zero or negative CPU and memory values, which either got stored directly or silently fell back to defaults and only surfaced as failures later. This tightens validation so bad settings are rejected at the user boundary and again in the daemon before any VM record is persisted.

Change vm.create CPU and memory request fields to optional pointers so omitted values still mean defaults, while explicit non-positive values can be distinguished and rejected. Update Cobra create/set parsing, keep the TUI aligned with the new API shape, and add regression tests for CLI parsing, daemon-side validation, and the create-defaults path.

Validation: go test ./... and make build. Left my-rootfs.ext4 untracked.

internal/daemon/vm.go

@@ -28,6 +28,12 @@ func (d *Daemon) CreateVM(ctx context.Context, params api.VMCreateParams) (vm mo
 		}
 		op.done(vmLogAttrs(vm)...)
 	}()
+	if err := validateOptionalPositiveSetting("vcpu", params.VCPUCount); err != nil {
+		return model.VMRecord{}, err
+	}
+	if err := validateOptionalPositiveSetting("memory", params.MemoryMiB); err != nil {
+		return model.VMRecord{}, err
+	}
 
 	imageName := params.ImageName
 	if imageName == "" {
@@ -76,8 +82,8 @@ func (d *Daemon) CreateVM(ctx context.Context, params api.VMCreateParams) (vm mo
 	}
 	now := model.Now()
 	spec := model.VMSpec{
-		VCPUCount:             defaultInt(params.VCPUCount, model.DefaultVCPUCount),
-		MemoryMiB:             defaultInt(params.MemoryMiB, model.DefaultMemoryMiB),
+		VCPUCount:             optionalIntOrDefault(params.VCPUCount, model.DefaultVCPUCount),
+		MemoryMiB:             optionalIntOrDefault(params.MemoryMiB, model.DefaultMemoryMiB),
 		SystemOverlaySizeByte: systemOverlaySize,
 		WorkDiskSizeBytes:     workDiskSize,
 		NATEnabled:            params.NATEnabled,
@@ -462,6 +468,9 @@ func (d *Daemon) SetVM(ctx context.Context, params api.VMSetParams) (vm model.VM
 	}
 	running := vm.State == model.VMStateRunning && system.ProcessRunning(vm.Runtime.PID, vm.Runtime.APISockPath)
 	if params.VCPUCount != nil {
+		if err := validateOptionalPositiveSetting("vcpu", params.VCPUCount); err != nil {
+			return model.VMRecord{}, err
+		}
 		if running {
 			return model.VMRecord{}, errors.New("vcpu changes require the VM to be stopped")
 		}
@@ -469,6 +478,9 @@ func (d *Daemon) SetVM(ctx context.Context, params api.VMSetParams) (vm model.VM
 		vm.Spec.VCPUCount = *params.VCPUCount
 	}
 	if params.MemoryMiB != nil {
+		if err := validateOptionalPositiveSetting("memory", params.MemoryMiB); err != nil {
+			return model.VMRecord{}, err
+		}
 		if running {
 			return model.VMRecord{}, errors.New("memory changes require the VM to be stopped")
 		}
@@ -864,13 +876,23 @@ func bridgePrefix(bridgeIP string) string {
 	return strings.Join(parts[:3], ".")
 }
 
-func defaultInt(value, fallback int) int {
-	if value > 0 {
-		return value
+func optionalIntOrDefault(value *int, fallback int) int {
+	if value != nil {
+		return *value
 	}
 	return fallback
 }
 
+func validateOptionalPositiveSetting(label string, value *int) error {
+	if value == nil {
+		return nil
+	}
+	if *value <= 0 {
+		return fmt.Errorf("%s must be a positive integer", label)
+	}
+	return nil
+}
+
 func (d *Daemon) mapdnsBinary() string {
 	if value := strings.TrimSpace(d.config.MapDNSBin); value != "" {
 		return value

internal/daemon/vm_test.go

@@ -13,6 +13,7 @@ import (
 
 	"banger/internal/api"
 	"banger/internal/model"
+	"banger/internal/paths"
 	"banger/internal/store"
 )
 
@@ -218,6 +219,63 @@ func TestSetVMDiskResizeFailsPreflightWhenToolsMissing(t *testing.T) {
 	}
 }
 
+func TestCreateVMRejectsNonPositiveCPUAndMemory(t *testing.T) {
+	d := &Daemon{}
+	if _, err := d.CreateVM(context.Background(), api.VMCreateParams{VCPUCount: ptr(0)}); err == nil || !strings.Contains(err.Error(), "vcpu must be a positive integer") {
+		t.Fatalf("CreateVM(vcpu=0) error = %v", err)
+	}
+	if _, err := d.CreateVM(context.Background(), api.VMCreateParams{MemoryMiB: ptr(-1)}); err == nil || !strings.Contains(err.Error(), "memory must be a positive integer") {
+		t.Fatalf("CreateVM(memory=-1) error = %v", err)
+	}
+}
+
+func TestCreateVMUsesDefaultsWhenCPUAndMemoryOmitted(t *testing.T) {
+	ctx := context.Background()
+	db := openDaemonStore(t)
+	image := testImage("default")
+	if err := db.UpsertImage(ctx, image); err != nil {
+		t.Fatalf("UpsertImage: %v", err)
+	}
+	d := &Daemon{
+		store: db,
+		layout: paths.Layout{
+			VMsDir: t.TempDir(),
+		},
+		config: model.DaemonConfig{
+			DefaultImageName: image.Name,
+			BridgeIP:         model.DefaultBridgeIP,
+		},
+	}
+
+	vm, err := d.CreateVM(ctx, api.VMCreateParams{Name: "defaults", ImageName: image.Name, NoStart: true})
+	if err != nil {
+		t.Fatalf("CreateVM: %v", err)
+	}
+	if vm.Spec.VCPUCount != model.DefaultVCPUCount {
+		t.Fatalf("VCPUCount = %d, want %d", vm.Spec.VCPUCount, model.DefaultVCPUCount)
+	}
+	if vm.Spec.MemoryMiB != model.DefaultMemoryMiB {
+		t.Fatalf("MemoryMiB = %d, want %d", vm.Spec.MemoryMiB, model.DefaultMemoryMiB)
+	}
+}
+
+func TestSetVMRejectsNonPositiveCPUAndMemory(t *testing.T) {
+	ctx := context.Background()
+	db := openDaemonStore(t)
+	vm := testVM("validate", "image-validate", "172.16.0.13")
+	if err := db.UpsertVM(ctx, vm); err != nil {
+		t.Fatalf("UpsertVM: %v", err)
+	}
+	d := &Daemon{store: db}
+
+	if _, err := d.SetVM(ctx, api.VMSetParams{IDOrName: vm.ID, VCPUCount: ptr(0)}); err == nil || !strings.Contains(err.Error(), "vcpu must be a positive integer") {
+		t.Fatalf("SetVM(vcpu=0) error = %v", err)
+	}
+	if _, err := d.SetVM(ctx, api.VMSetParams{IDOrName: vm.ID, MemoryMiB: ptr(0)}); err == nil || !strings.Contains(err.Error(), "memory must be a positive integer") {
+		t.Fatalf("SetVM(memory=0) error = %v", err)
+	}
+}
+
 func TestCollectStatsIgnoresMalformedMetricsFile(t *testing.T) {
 	t.Parallel()