fix(cli): volume rm exit code + Docker volume-inspect schema, and cp mode/large-file

Round-2 parity fixes:
- volume rm now returns a non-zero exit when a removal fails (e.g. volume in
  use) instead of printing the error to stderr and exiting 0.
- volume inspect emits a top-level JSON array of Docker-shaped objects
  (Name/Driver/Mountpoint/Scope/Labels/Options/CreatedAt), not the raw
  snake_case VolumeConfig.
- cp to a box streams file bytes over the exec channel's stdin (cat > dst)
  instead of embedding base64 in the command line, so large files no longer
  hit ARG_MAX (verified: 3 MB copy succeeds); it also restores the source
  file's mode via chmod (cp preserves permissions, verified 0755).

Author: Roy Lin

src/cli/src/commands/cp.rs

@@ -208,25 +208,24 @@ async fn copy_file_to_box(
 ) -> Result<(), Box<dyn std::error::Error>> {
     let content =
         std::fs::read(host_path).map_err(|e| format!("Failed to read {host_path}: {e}"))?;
+    let len = content.len();
+    let mode = host_file_mode(host_path);
 
-    use base64::Engine;
-    let encoded = base64::engine::general_purpose::STANDARD.encode(&content);
-
+    // Stream the raw bytes over the exec channel's stdin (not the command line)
+    // so large files do not exceed ARG_MAX, and restore the source file's mode
+    // (Docker `cp` preserves permissions).
+    let dst = shell_escape(box_path);
     let request = ExecRequest {
         cmd: vec![
             "sh".to_string(),
             "-c".to_string(),
-            format!(
-                "echo '{}' | base64 -d > {}",
-                encoded,
-                shell_escape(box_path)
-            ),
+            format!("cat > {dst} && chmod {mode:o} {dst}"),
         ],
         timeout_ns: DEFAULT_EXEC_TIMEOUT_NS,
         env: vec![],
         working_dir: None,
         rootfs: None,
-        stdin: None,
+        stdin: Some(content),
         stdin_streaming: false,
         user: None,
         streaming: false,
@@ -239,13 +238,27 @@ async fn copy_file_to_box(
         return Err(format!("Failed to write {box_path} in box: {stderr}").into());
     }
 
-    println!(
-        "{host_path} → {box_name}:{box_path} ({} bytes)",
-        content.len()
-    );
+    println!("{host_path} → {box_name}:{box_path} ({len} bytes)");
     Ok(())
 }
 
+/// Source file's permission bits (lower 12) for `cp` to restore in the box;
+/// defaults to 0o644 off-Unix or on stat failure.
+fn host_file_mode(host_path: &str) -> u32 {
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        std::fs::metadata(host_path)
+            .map(|m| m.permissions().mode() & 0o7777)
+            .unwrap_or(0o644)
+    }
+    #[cfg(not(unix))]
+    {
+        let _ = host_path;
+        0o644
+    }
+}
+
 // ---------------------------------------------------------------------------
 // Directory transfers
 // ---------------------------------------------------------------------------

src/cli/src/commands/volume.rs

@@ -144,14 +144,20 @@ async fn execute_rm(args: RmArgs) -> Result<(), Box<dyn std::error::Error>> {
 
     let store = VolumeStore::default_path()?;
 
+    let mut errors = Vec::new();
     for name in &args.names {
         match store.remove(name, args.force) {
             Ok(_) => println!("{name}"),
-            Err(e) => eprintln!("Error removing volume '{name}': {e}"),
+            Err(e) => errors.push(format!("Error removing volume '{name}': {e}")),
         }
     }
 
-    Ok(())
+    if errors.is_empty() {
+        Ok(())
+    } else {
+        // A failed removal (e.g. volume in use) must be a non-zero exit, like Docker.
+        Err(errors.join("\n").into())
+    }
 }
 
 async fn execute_inspect(args: InspectArgs) -> Result<(), Box<dyn std::error::Error>> {
@@ -161,8 +167,18 @@ async fn execute_inspect(args: InspectArgs) -> Result<(), Box<dyn std::error::Er
         .get(&args.name)?
         .ok_or_else(|| format!("volume '{}' not found", args.name))?;
 
-    let json = serde_json::to_string_pretty(&config)?;
-    println!("{json}");
+    // Match `docker volume inspect`: a top-level JSON array of PascalCase objects
+    // (Mountpoint, Scope, etc.), not the raw snake_case VolumeConfig.
+    let output = serde_json::json!([{
+        "Name": config.name,
+        "Driver": config.driver,
+        "Mountpoint": config.mount_point,
+        "Scope": "local",
+        "Labels": config.labels,
+        "Options": serde_json::Map::new(),
+        "CreatedAt": config.created_at,
+    }]);
+    println!("{}", serde_json::to_string_pretty(&output)?);
     Ok(())
 }