feat(pull): improve layer download progress display

Enhanced the pull progress display to show download status for each layer:
- Shows "Downloading X MB..." when starting to download a layer
- Shows "X MB ✓" when layer download completes
- Uses \r to overwrite the same line for cleaner output
- Properly formats sizes (MB/KB/B) based on layer size

Changes:
- Modified progress callback to be called twice per layer (start + complete)
- Use negative size value to signal completion in the callback
- Updated both `pull` and `run` commands to use the new progress format

This provides better visibility into the download process, especially for
large images with multiple layers.

Author: RoyLin

src/Cargo.lock

@@ -12,7 +12,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "0.8.3"
+version = "0.8.4"
 edition = "2021"
 authors = ["A3S Lab Team"]
 license = "MIT"

src/Cargo.toml

@@ -61,14 +61,30 @@ pub async fn execute(args: PullArgs) -> Result<(), Box<dyn std::error::Error>> {
         println!("Pulling {}...", args.image);
         puller = puller.with_progress_fn(std::sync::Arc::new(|current, total, digest, size| {
             let short = &digest[digest.len().saturating_sub(12)..];
-            let size_str = if size >= 1_048_576 {
-                format!("{:.1} MB", size as f64 / 1_048_576.0)
-            } else if size >= 1024 {
-                format!("{:.1} KB", size as f64 / 1024.0)
+            if size < 0 {
+                // Negative size signals completion
+                let actual_size = (-size) as i64;
+                let size_str = if actual_size >= 1_048_576 {
+                    format!("{:.1} MB", actual_size as f64 / 1_048_576.0)
+                } else if actual_size >= 1024 {
+                    format!("{:.1} KB", actual_size as f64 / 1024.0)
+                } else {
+                    format!("{} B", actual_size)
+                };
+                eprintln!("\r  [{current}/{total}] {short}: {size_str} ✓");
             } else {
-                format!("{} B", size)
-            };
-            println!("  [{current}/{total}] {short}: {size_str}");
+                // Positive size means downloading
+                let size_str = if size >= 1_048_576 {
+                    format!("{:.1} MB", size as f64 / 1_048_576.0)
+                } else if size >= 1024 {
+                    format!("{:.1} KB", size as f64 / 1024.0)
+                } else {
+                    format!("{} B", size)
+                };
+                eprint!("\r  [{current}/{total}] {short}: Downloading {size_str}...");
+                use std::io::Write;
+                let _ = std::io::stderr().flush();
+            }
         }));
     }
     let image = puller.pull(&args.image).await?;

src/cli/src/commands/pull.rs

@@ -191,18 +191,34 @@ async fn setup_and_boot(args: &RunArgs) -> Result<RunContext, Box<dyn std::error
 
     let image_name = args.common.image.clone();
     vm.set_pull_progress_fn(std::sync::Arc::new(move |current, total, digest, size| {
-        if current == 1 {
+        if current == 1 && size > 0 {
             println!("Pulling {}...", image_name);
         }
         let short = &digest[digest.len().saturating_sub(12)..];
-        let size_str = if size >= 1_048_576 {
-            format!("{:.1} MB", size as f64 / 1_048_576.0)
-        } else if size >= 1024 {
-            format!("{:.1} KB", size as f64 / 1024.0)
+        if size < 0 {
+            // Negative size signals completion
+            let actual_size = (-size) as i64;
+            let size_str = if actual_size >= 1_048_576 {
+                format!("{:.1} MB", actual_size as f64 / 1_048_576.0)
+            } else if actual_size >= 1024 {
+                format!("{:.1} KB", actual_size as f64 / 1024.0)
+            } else {
+                format!("{} B", actual_size)
+            };
+            eprintln!("\r  [{current}/{total}] {short}: {size_str} ✓");
         } else {
-            format!("{} B", size)
-        };
-        println!("  [{current}/{total}] {short}: {size_str}");
+            // Positive size means downloading
+            let size_str = if size >= 1_048_576 {
+                format!("{:.1} MB", size as f64 / 1_048_576.0)
+            } else if size >= 1024 {
+                format!("{:.1} KB", size as f64 / 1024.0)
+            } else {
+                format!("{} B", size)
+            };
+            eprint!("\r  [{current}/{total}] {short}: Downloading {size_str}...");
+            use std::io::Write;
+            let _ = std::io::stderr().flush();
+        }
     }));
 
     connect_network(args.common.network.as_deref(), &box_id, &name)?;

src/cli/src/commands/run.rs

@@ -315,6 +315,11 @@ impl RegistryPuller {
                     message: format!("Failed to pull layer {}: {}", layer.digest, e),
                 })?;
 
+            // Call progress callback again with negative size to signal completion
+            if let Some(ref f) = self.progress_fn {
+                f(idx + 1, total, &layer.digest, -(layer.size as i64));
+            }
+
             let layer_digest_hex = layer
                 .digest
                 .strip_prefix("sha256:")