init: show copy progress for init --from

`init --from /` on a multi-GB rootfs takes minutes; the previous single
'one-time copy...' line made it look hung. SeedDir now takes an optional
Progress callback (files, bytes); InitFrom renders a throttled (~4/s)
stderr line and a final 'N files, X copied in Ys' summary.

Wiring: image.SeedDir gains a Progress param (nil = silent); repo gains a
local humanBytes helper (repo can't import the cli copy). Test exercises
the callback counts.

Author: css521

.devcontainer/devcontainer.json

@@ -26,7 +26,7 @@
   // behind deb.debian.org from mainland China. The env var flows in via
   // containerEnv below; OSS users outside China leave it unset and the
   // mirror swap is a no-op.
-  "postCreateCommand": ".devcontainer/postcreate.sh",
+  "postCreateCommand": "bash .devcontainer/postcreate.sh",
   "containerEnv": {
     "AGENTENV_CN_MIRROR": "${localEnv:AGENTENV_CN_MIRROR}"
   },

internal/image/image.go

@@ -85,13 +85,26 @@ func openTarballSource(src string) (io.Reader, func(), error) {
 	return f, func() { f.Close() }, nil
 }
 
+// Progress reports seeding progress. It is called after each regular file is
+// copied, with the running count of files and bytes copied so far. Callers
+// typically throttle their own rendering (it fires very frequently); pass nil
+// to SeedDir to disable. Directories and symlinks don't trigger it (they carry
+// ~no bytes and would just add noise to a "GB copied" readout).
+type Progress func(files int, bytes int64)
+
 // SeedDir copies the tree at src into dst, skipping any path in exclude (and not
 // descending into excluded directories). It is best-effort: unreadable files
 // (e.g. root-owned files when running unprivileged) and special files (devices,
 // FIFOs, sockets) are skipped rather than aborting — so seeding from "/" inside a
 // container works even as a non-root user.
-func SeedDir(src, dst string, exclude map[string]bool) error {
+//
+// If progress is non-nil it is called after each regular file with cumulative
+// (files, bytes) counts — `init --from /` on a multi-GB image can take minutes,
+// and a silent copy looks like a hang.
+func SeedDir(src, dst string, exclude map[string]bool, progress Progress) error {
 	src = filepath.Clean(src)
+	var files int
+	var bytes int64
 	return filepath.Walk(src, func(path string, fi os.FileInfo, err error) error {
 		if err != nil {
 			return nil // tolerate unreadable/disappearing entries (e.g. /proc races)
@@ -120,7 +133,11 @@ func SeedDir(src, dst string, exclude map[string]bool) error {
 				_ = os.Symlink(link, target)
 			}
 		case fi.Mode().IsRegular():
-			_ = seedCopyFile(path, target, fi)
+			if seedCopyFile(path, target, fi) == nil && progress != nil {
+				files++
+				bytes += fi.Size()
+				progress(files, bytes)
+			}
 		}
 		return nil
 	})

internal/image/image_test.go

@@ -52,9 +52,20 @@ func TestSeedDirCopiesAndExcludes(t *testing.T) {
 
 	dst := t.TempDir()
 	exclude := map[string]bool{filepath.Join(src, "proc"): true}
-	if err := SeedDir(src, dst, exclude); err != nil {
+	var lastFiles int
+	var lastBytes int64
+	prog := func(files int, bytes int64) { lastFiles, lastBytes = files, bytes }
+	if err := SeedDir(src, dst, exclude, prog); err != nil {
 		t.Fatalf("SeedDir: %v", err)
 	}
+	// Two regular files copied (root/a.txt + usr/bin/tool; proc/fake excluded,
+	// the symlink doesn't count). Bytes = len("A") + len("bin") = 4.
+	if lastFiles != 2 {
+		t.Errorf("progress files = %d, want 2", lastFiles)
+	}
+	if lastBytes != 4 {
+		t.Errorf("progress bytes = %d, want 4", lastBytes)
+	}
 
 	if b, err := os.ReadFile(filepath.Join(dst, "root/a.txt")); err != nil || string(b) != "A" {
 		t.Errorf("root/a.txt = %q, %v", b, err)

internal/repo/repo.go

@@ -221,10 +221,31 @@ func (r *Repo) InitFrom(src string) (*dag.Node, error) {
 			exclude[p] = true
 		}
 	}
-	fmt.Printf("seeding rootfs from %s (this is a one-time copy) ...\n", src)
-	if err := image.SeedDir(src, r.workRoot(), exclude); err != nil {
+	fmt.Fprintf(os.Stderr, "seeding rootfs from %s (one-time copy)...\n", src)
+	// Throttled progress: `init --from /` on a multi-GB image takes minutes,
+	// and a silent copy is indistinguishable from a hang. Repaint a single
+	// stderr line ~4×/s with running file + byte counts. Throttling keeps the
+	// hot copy loop from doing a syscall per file just to print.
+	start := time.Now()
+	var last time.Time
+	var totFiles int
+	var totBytes int64
+	prog := func(files int, bytes int64) {
+		totFiles, totBytes = files, bytes
+		now := time.Now()
+		if now.Sub(last) < 250*time.Millisecond {
+			return
+		}
+		last = now
+		fmt.Fprintf(os.Stderr, "\r  %d files, %s copied...", files, humanBytes(bytes))
+	}
+	if err := image.SeedDir(src, r.workRoot(), exclude, prog); err != nil {
+		fmt.Fprintln(os.Stderr)
 		return nil, err
 	}
+	// \r + trailing spaces overwrite the last (possibly longer) progress line.
+	fmt.Fprintf(os.Stderr, "\r  %d files, %s copied in %s%s\n",
+		totFiles, humanBytes(totBytes), time.Since(start).Round(time.Second), strings.Repeat(" ", 12))
 	id := r.newID()
 	if err := r.be.Snapshotter.Freeze(id, ""); err != nil {
 		return nil, err

internal/repo/status.go

@@ -3,6 +3,7 @@
 package repo
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 	"syscall"
@@ -96,3 +97,20 @@ func dirRealSize(dir string) int64 {
 	})
 	return total
 }
+
+// humanBytes formats a byte count as a short human-readable string (B/KB/MB/GB).
+// Used by the init --from progress readout. (The CLI layer has its own copy for
+// `status` output; this one keeps the repo package self-contained.)
+func humanBytes(n int64) string {
+	const k = 1024
+	switch {
+	case n < k:
+		return fmt.Sprintf("%dB", n)
+	case n < k*k:
+		return fmt.Sprintf("%.1fKB", float64(n)/k)
+	case n < k*k*k:
+		return fmt.Sprintf("%.1fMB", float64(n)/(k*k))
+	default:
+		return fmt.Sprintf("%.2fGB", float64(n)/(k*k*k))
+	}
+}