vm create: auto-pull image and kernel from catalogs if missing

One-command sandbox: `banger vm run` on a fresh host now Just Works.
No prior `banger image pull` or `banger kernel pull` needed.

Changes:

- Default `default_image_name` flips from "default" to "debian-bookworm"
  so the golden image is the implicit target when `--image` is omitted.
- `CreateVM` resolves the image via a new `findOrAutoPullImage`: try
  the local store first, and on miss fall back to the embedded imagecat
  catalog + auto-pull. Emits a vm-create progress stage so the user
  sees "pulling from image catalog" in the create output.
- `resolveKernelInputs` gains context + the same pattern via
  `readOrAutoPullKernel`: try the local kernelcat, and on miss look up
  the embedded kernelcat and auto-pull. Fires whenever a bundle's
  manifest references a kernel the user hasn't pulled yet, not just
  during image pull — any CreateVM with an image that needs a kernel
  not yet local will resolve it.
- `--image` help text updated on both `vm run` and `vm create`.

Six tests cover local-hit-no-pull, auto-pull-on-miss, not-in-catalog
error propagation, and a non-ENOENT kernel read error does NOT trigger
a misleading "not in catalog" claim.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

internal/daemon/autopull_test.go

@@ -0,0 +1,136 @@
+package daemon
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"banger/internal/imagecat"
+	"banger/internal/model"
+	"banger/internal/paths"
+	"banger/internal/system"
+)
+
+func TestFindOrAutoPullImageReturnsLocalWithoutPulling(t *testing.T) {
+	d := &Daemon{
+		layout: paths.Layout{ImagesDir: t.TempDir()},
+		store:  openDaemonStore(t),
+		runner: system.NewRunner(),
+		bundleFetch: func(context.Context, string, imagecat.CatEntry) (imagecat.Manifest, error) {
+			t.Fatal("bundleFetch should not be called when image is local")
+			return imagecat.Manifest{}, nil
+		},
+	}
+	id, _ := model.NewID()
+	if err := d.store.UpsertImage(context.Background(), model.Image{
+		ID:        id,
+		Name:      "my-local-image",
+		CreatedAt: model.Now(),
+		UpdatedAt: model.Now(),
+	}); err != nil {
+		t.Fatal(err)
+	}
+	image, err := d.findOrAutoPullImage(context.Background(), "my-local-image")
+	if err != nil {
+		t.Fatalf("findOrAutoPullImage: %v", err)
+	}
+	if image.Name != "my-local-image" {
+		t.Fatalf("Name = %q, want my-local-image", image.Name)
+	}
+}
+
+func TestFindOrAutoPullImagePullsFromCatalog(t *testing.T) {
+	imagesDir := t.TempDir()
+	kernelsDir := t.TempDir()
+	seedKernel(t, kernelsDir, "generic-6.12")
+
+	pullCalls := 0
+	d := &Daemon{
+		layout: paths.Layout{ImagesDir: imagesDir, KernelsDir: kernelsDir},
+		store:  openDaemonStore(t),
+		runner: system.NewRunner(),
+		bundleFetch: func(ctx context.Context, destDir string, entry imagecat.CatEntry) (imagecat.Manifest, error) {
+			pullCalls++
+			return stubBundleFetch(imagecat.Manifest{KernelRef: "generic-6.12"})(ctx, destDir, entry)
+		},
+	}
+	// "debian-bookworm" is in the embedded imagecat catalog.
+	image, err := d.findOrAutoPullImage(context.Background(), "debian-bookworm")
+	if err != nil {
+		t.Fatalf("findOrAutoPullImage: %v", err)
+	}
+	if image.Name != "debian-bookworm" {
+		t.Fatalf("Name = %q, want debian-bookworm", image.Name)
+	}
+	if pullCalls != 1 {
+		t.Fatalf("bundleFetch calls = %d, want 1", pullCalls)
+	}
+}
+
+func TestFindOrAutoPullImageReturnsOriginalErrorWhenNotInCatalog(t *testing.T) {
+	d := &Daemon{
+		layout: paths.Layout{ImagesDir: t.TempDir()},
+		store:  openDaemonStore(t),
+		runner: system.NewRunner(),
+	}
+	_, err := d.findOrAutoPullImage(context.Background(), "not-in-catalog-or-store")
+	if err == nil || !strings.Contains(err.Error(), "not found") {
+		t.Fatalf("err = %v, want not-found", err)
+	}
+}
+
+func TestReadOrAutoPullKernelReturnsLocalWithoutPulling(t *testing.T) {
+	kernelsDir := t.TempDir()
+	seedKernel(t, kernelsDir, "generic-6.12")
+	d := &Daemon{layout: paths.Layout{KernelsDir: kernelsDir}}
+
+	entry, err := d.readOrAutoPullKernel(context.Background(), "generic-6.12")
+	if err != nil {
+		t.Fatalf("readOrAutoPullKernel: %v", err)
+	}
+	if entry.Name != "generic-6.12" {
+		t.Fatalf("Name = %q", entry.Name)
+	}
+}
+
+func TestReadOrAutoPullKernelErrorsWhenNotInCatalog(t *testing.T) {
+	d := &Daemon{layout: paths.Layout{KernelsDir: t.TempDir()}}
+	_, err := d.readOrAutoPullKernel(context.Background(), "nonexistent-kernel")
+	if err == nil || !strings.Contains(err.Error(), "not found") {
+		t.Fatalf("err = %v, want not-found", err)
+	}
+}
+
+// TestReadOrAutoPullKernelSurfacesNonNotExistError covers the path where
+// kernelcat.ReadLocal fails for a reason other than missing entry (e.g.
+// corrupt manifest); the autopull logic should NOT try to fetch in that
+// case since the entry clearly exists in some broken form.
+func TestReadOrAutoPullKernelSurfacesNonNotExistError(t *testing.T) {
+	kernelsDir := t.TempDir()
+	// Seed a manifest that doesn't match the entry's own Name field —
+	// kernelcat.ReadLocal returns an error, not os.ErrNotExist.
+	dir := filepath.Join(kernelsDir, "broken-kernel")
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "manifest.json"), []byte(`{"name":"different-name"}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	d := &Daemon{layout: paths.Layout{KernelsDir: kernelsDir}}
+	_, err := d.readOrAutoPullKernel(context.Background(), "broken-kernel")
+	if err == nil {
+		t.Fatal("want error")
+	}
+	// Must not be wrapped in an "auto-pull" message — the corrupt-manifest
+	// failure should surface as the primary cause.
+	if strings.Contains(err.Error(), "not found in catalog") {
+		t.Fatalf("err = %v, should not claim 'not in catalog'", err)
+	}
+	// Sanity: ensure it's not os.ErrNotExist-compatible.
+	if errors.Is(err, os.ErrNotExist) {
+		t.Fatalf("err = %v, should not be os.ErrNotExist", err)
+	}
+}