Serve a local web UI from bangerd

Add a localhost-only web console so VM and image management no longer depends on the CLI for every inspection and lifecycle action.

Wire bangerd up to a configurable web listener, expose dashboard and async image-build state through the daemon, and serve CSRF-protected HTML pages with host-path picking, VM/image detail views, logs, ports, and progress polling for long-running operations.

Keep the browser path aligned with the existing sudo and host-owned artifact model: surface sudo readiness, print the web URL in daemon status, and document the new workflow. Polish the UI with resource usage cards, clearer clickable affordances, cancel paths, confirmation prompts, image-name links, and HTTP port links.

Validation: GOCACHE=/tmp/banger-gocache go test ./...

internal/daemon/image_build_ops.go

@@ -0,0 +1,218 @@
+package daemon
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	"banger/internal/api"
+	"banger/internal/model"
+)
+
+type imageBuildProgressKey struct{}
+
+type imageBuildOperationState struct {
+	mu     sync.Mutex
+	cancel context.CancelFunc
+	op     api.ImageBuildOperation
+}
+
+func newImageBuildOperationState() (*imageBuildOperationState, error) {
+	id, err := model.NewID()
+	if err != nil {
+		return nil, err
+	}
+	now := model.Now()
+	return &imageBuildOperationState{
+		op: api.ImageBuildOperation{
+			ID:        id,
+			Stage:     "queued",
+			Detail:    "waiting to start",
+			StartedAt: now,
+			UpdatedAt: now,
+		},
+	}, nil
+}
+
+func withImageBuildProgress(ctx context.Context, op *imageBuildOperationState) context.Context {
+	if op == nil {
+		return ctx
+	}
+	return context.WithValue(ctx, imageBuildProgressKey{}, op)
+}
+
+func imageBuildProgressFromContext(ctx context.Context) *imageBuildOperationState {
+	if ctx == nil {
+		return nil
+	}
+	op, _ := ctx.Value(imageBuildProgressKey{}).(*imageBuildOperationState)
+	return op
+}
+
+func imageBuildStage(ctx context.Context, stage, detail string) {
+	if op := imageBuildProgressFromContext(ctx); op != nil {
+		op.stage(stage, detail)
+	}
+}
+
+func imageBuildBindImage(ctx context.Context, image model.Image) {
+	if op := imageBuildProgressFromContext(ctx); op != nil {
+		op.bindImage(image)
+	}
+}
+
+func imageBuildSetLogPath(ctx context.Context, path string) {
+	if op := imageBuildProgressFromContext(ctx); op != nil {
+		op.setLogPath(path)
+	}
+}
+
+func (op *imageBuildOperationState) setCancel(cancel context.CancelFunc) {
+	op.mu.Lock()
+	defer op.mu.Unlock()
+	op.cancel = cancel
+}
+
+func (op *imageBuildOperationState) setLogPath(path string) {
+	op.mu.Lock()
+	defer op.mu.Unlock()
+	op.op.BuildLogPath = strings.TrimSpace(path)
+	op.op.UpdatedAt = model.Now()
+}
+
+func (op *imageBuildOperationState) bindImage(image model.Image) {
+	op.mu.Lock()
+	defer op.mu.Unlock()
+	op.op.ImageID = image.ID
+	op.op.ImageName = image.Name
+}
+
+func (op *imageBuildOperationState) stage(stage, detail string) {
+	op.mu.Lock()
+	defer op.mu.Unlock()
+	stage = strings.TrimSpace(stage)
+	detail = strings.TrimSpace(detail)
+	if stage == "" {
+		stage = op.op.Stage
+	}
+	if stage == op.op.Stage && detail == op.op.Detail {
+		return
+	}
+	op.op.Stage = stage
+	op.op.Detail = detail
+	op.op.UpdatedAt = model.Now()
+}
+
+func (op *imageBuildOperationState) done(image model.Image) {
+	op.mu.Lock()
+	defer op.mu.Unlock()
+	imageCopy := image
+	op.op.ImageID = image.ID
+	op.op.ImageName = image.Name
+	op.op.Stage = "ready"
+	op.op.Detail = "image is ready"
+	op.op.Done = true
+	op.op.Success = true
+	op.op.Error = ""
+	op.op.Image = &imageCopy
+	op.op.UpdatedAt = model.Now()
+}
+
+func (op *imageBuildOperationState) fail(err error) {
+	op.mu.Lock()
+	defer op.mu.Unlock()
+	op.op.Done = true
+	op.op.Success = false
+	if err != nil {
+		op.op.Error = err.Error()
+	}
+	if strings.TrimSpace(op.op.Detail) == "" {
+		op.op.Detail = "image build failed"
+	}
+	op.op.UpdatedAt = model.Now()
+}
+
+func (op *imageBuildOperationState) snapshot() api.ImageBuildOperation {
+	op.mu.Lock()
+	defer op.mu.Unlock()
+	snapshot := op.op
+	if snapshot.Image != nil {
+		imageCopy := *snapshot.Image
+		snapshot.Image = &imageCopy
+	}
+	return snapshot
+}
+
+func (op *imageBuildOperationState) cancelOperation() {
+	op.mu.Lock()
+	cancel := op.cancel
+	op.mu.Unlock()
+	if cancel != nil {
+		cancel()
+	}
+}
+
+func (d *Daemon) BeginImageBuild(_ context.Context, params api.ImageBuildParams) (api.ImageBuildOperation, error) {
+	op, err := newImageBuildOperationState()
+	if err != nil {
+		return api.ImageBuildOperation{}, err
+	}
+	buildCtx, cancel := context.WithCancel(context.Background())
+	op.setCancel(cancel)
+
+	d.imageBuildOpsMu.Lock()
+	if d.imageBuildOps == nil {
+		d.imageBuildOps = map[string]*imageBuildOperationState{}
+	}
+	d.imageBuildOps[op.op.ID] = op
+	d.imageBuildOpsMu.Unlock()
+
+	go d.runImageBuildOperation(withImageBuildProgress(buildCtx, op), op, params)
+	return op.snapshot(), nil
+}
+
+func (d *Daemon) runImageBuildOperation(ctx context.Context, op *imageBuildOperationState, params api.ImageBuildParams) {
+	image, err := d.BuildImage(ctx, params)
+	if err != nil {
+		op.fail(err)
+		return
+	}
+	op.done(image)
+}
+
+func (d *Daemon) ImageBuildStatus(_ context.Context, id string) (api.ImageBuildOperation, error) {
+	d.imageBuildOpsMu.Lock()
+	op, ok := d.imageBuildOps[strings.TrimSpace(id)]
+	d.imageBuildOpsMu.Unlock()
+	if !ok {
+		return api.ImageBuildOperation{}, fmt.Errorf("image build operation not found: %s", id)
+	}
+	return op.snapshot(), nil
+}
+
+func (d *Daemon) CancelImageBuild(_ context.Context, id string) error {
+	d.imageBuildOpsMu.Lock()
+	op, ok := d.imageBuildOps[strings.TrimSpace(id)]
+	d.imageBuildOpsMu.Unlock()
+	if !ok {
+		return fmt.Errorf("image build operation not found: %s", id)
+	}
+	op.cancelOperation()
+	return nil
+}
+
+func (d *Daemon) pruneImageBuildOperations(olderThan time.Time) {
+	d.imageBuildOpsMu.Lock()
+	defer d.imageBuildOpsMu.Unlock()
+	for id, op := range d.imageBuildOps {
+		snapshot := op.snapshot()
+		if !snapshot.Done {
+			continue
+		}
+		if snapshot.UpdatedAt.Before(olderThan) {
+			delete(d.imageBuildOps, id)
+		}
+	}
+}