fix: fix PTY stdin freeze and add run pull progress and improve size display

- Fix exec/shell -it hang on macOS: tokio::io::stdin() uses kqueue which
  does not generate readiness events for TTY fds in raw mode; replace with
  spawn_blocking + std::io::stdin() + mpsc channel so raw-mode keystrokes
  are reliably forwarded to the guest PTY
- Add pull progress to `a3s-box run`: VmManager gains set_pull_progress_fn;
  layout.rs wires it into ImagePuller so runs that need to fetch a missing
  image print per-layer progress instead of silently hanging at
  "Creating box..."
- Fix size display: small layers (< 1 MB) now show KB / B instead of
  "0.0 MB"; applies to both `pull` and `run` progress output
- Bump version to 0.8.2

Author: RoyLin

src/Cargo.lock

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

src/Cargo.toml

@@ -194,7 +194,6 @@ pub(crate) async fn run_pty_session(
     mut writer: a3s_transport::FrameWriter<tokio::io::WriteHalf<tokio::net::UnixStream>>,
 ) -> i32 {
     use a3s_box_core::pty::{FRAME_PTY_DATA, FRAME_PTY_ERROR, FRAME_PTY_EXIT};
-    use tokio::io::AsyncReadExt;
 
     // Task 1: Read from guest PTY → write to stdout
     let reader_task = tokio::spawn(async move {
@@ -233,25 +232,44 @@ pub(crate) async fn run_pty_session(
         }
     });
 
-    // Task 2: Read from stdin + handle SIGWINCH → send frames to guest
+    // Task 2: Read from stdin + handle SIGWINCH → send frames to guest.
+    //
+    // tokio::io::stdin() uses kqueue on macOS which does not generate
+    // readiness events for TTY fds in raw mode, causing reads to block
+    // indefinitely. Use a dedicated blocking thread via spawn_blocking +
+    // an mpsc channel to relay stdin bytes into the async writer task.
     let writer_task = tokio::spawn(async move {
-        let mut stdin = tokio::io::stdin();
-        let mut buf = [0u8; 4096];
+        let (tx, mut rx) = tokio::sync::mpsc::channel::<Vec<u8>>(64);
+
+        tokio::task::spawn_blocking(move || {
+            use std::io::Read;
+            let mut stdin = std::io::stdin();
+            let mut buf = [0u8; 4096];
+            loop {
+                match stdin.read(&mut buf) {
+                    Ok(0) | Err(_) => break,
+                    Ok(n) => {
+                        if tx.blocking_send(buf[..n].to_vec()).is_err() {
+                            break;
+                        }
+                    }
+                }
+            }
+        });
 
         let mut sigwinch =
             tokio::signal::unix::signal(tokio::signal::unix::SignalKind::window_change()).ok();
 
         loop {
             tokio::select! {
-                result = stdin.read(&mut buf) => {
-                    match result {
-                        Ok(0) => break,
-                        Ok(n) => {
-                            if writer.write_data(&buf[..n]).await.is_err() {
+                data = rx.recv() => {
+                    match data {
+                        Some(bytes) => {
+                            if writer.write_data(&bytes).await.is_err() {
                                 break;
                             }
                         }
-                        Err(_) => break,
+                        None => break,
                     }
                 },
                 _ = async {

src/cli/src/commands/exec.rs

@@ -61,8 +61,14 @@ 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 mb = size as f64 / 1_048_576.0;
-            println!("  [{current}/{total}] {short}: {mb:.1} MB");
+            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)
+            };
+            println!("  [{current}/{total}] {short}: {size_str}");
         }));
     }
     let image = puller.pull(&args.image).await?;

src/cli/src/commands/pull.rs

@@ -189,6 +189,22 @@ async fn setup_and_boot(args: &RunArgs) -> Result<RunContext, Box<dyn std::error
         &BoxRecord::make_short_id(&box_id)
     );
 
+    let image_name = args.common.image.clone();
+    vm.set_pull_progress_fn(std::sync::Arc::new(move |current, total, digest, size| {
+        if current == 1 {
+            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)
+        } else {
+            format!("{} B", size)
+        };
+        println!("  [{current}/{total}] {short}: {size_str}");
+    }));
+
     connect_network(args.common.network.as_deref(), &box_id, &name)?;
     vm.boot().await?;
 

src/cli/src/commands/run.rs

@@ -64,6 +64,9 @@ impl VmManager {
         if let Some(ref m) = self.prom {
             puller = puller.set_metrics(m.clone());
         }
+        if let Some(ref f) = self.pull_progress_fn {
+            puller = puller.with_progress_fn(f.clone());
+        }
 
         tracing::info!(reference = %reference, "Pulling OCI image from registry");
 

src/runtime/src/vm/layout.rs

@@ -114,6 +114,9 @@ pub struct VmManager {
 
     /// Exit code captured from the shim process after it exits.
     pub(crate) shim_exit_code: Option<i32>,
+
+    /// Optional progress callback for image pulls: `(current, total, digest, size_bytes)`.
+    pub(crate) pull_progress_fn: Option<Arc<dyn Fn(usize, usize, &str, i64) + Send + Sync>>,
 }
 
 impl VmManager {
@@ -141,6 +144,7 @@ impl VmManager {
             pty_socket_path: None,
             prom: None,
             shim_exit_code: None,
+            pull_progress_fn: None,
         }
     }
 
@@ -167,6 +171,7 @@ impl VmManager {
             pty_socket_path: None,
             prom: None,
             shim_exit_code: None,
+            pull_progress_fn: None,
         }
     }
 
@@ -197,6 +202,7 @@ impl VmManager {
             pty_socket_path: None,
             prom: None,
             shim_exit_code: None,
+            pull_progress_fn: None,
         }
     }
 
@@ -247,6 +253,12 @@ impl VmManager {
         self.rootfs_provider.name()
     }
 
+    /// Set a progress callback for image pulls: `(current, total, digest, size_bytes)`.
+    /// Called once per layer when `run` pulls an image that is not yet cached.
+    pub fn set_pull_progress_fn(&mut self, f: Arc<dyn Fn(usize, usize, &str, i64) + Send + Sync>) {
+        self.pull_progress_fn = Some(f);
+    }
+
     /// Attach Prometheus metrics to this VM manager.
     pub fn set_metrics(&mut self, metrics: crate::prom::RuntimeMetrics) {
         self.prom = Some(metrics);