utils: Add DiskSize type for parsing human-readable sizes

Add a DiskSize newtype that wraps u64 bytes and implements FromStr,
allowing clap to parse disk sizes directly from command line arguments.
This eliminates the need for manual parsing at each call site.

The type supports human-readable formats like '10G', '5120M', '1T' and
provides both from_bytes() constructor and as_bytes() accessor.

Update all disk_size Option<String> fields to use Option<DiskSize>:
- to_disk::ToDiskAdditionalOpts
- libvirt/upload::LibvirtUploadOpts
- libvirt_upload_disk::LibvirtUploadDiskOpts
- libvirt/base_disks (internal usage)

Assisted-by: OpenCode (Claude sonnet-4-20250514)
Signed-off-by: Colin Walters <walters@verbum.org>

Author: cgwalters

crates/kit/src/libvirt/base_disks.rs

@@ -6,6 +6,7 @@
 
 use crate::cache_metadata::DiskImageMetadata;
 use crate::install_options::InstallOptions;
+use crate::utils::DiskSize;
 use camino::{Utf8Path, Utf8PathBuf};
 use color_eyre::eyre::{eyre, Context};
 use color_eyre::Result;
@@ -109,8 +110,9 @@ fn create_base_disk(
         additional: ToDiskAdditionalOpts {
             disk_size: install_options
                 .root_size
-                .clone()
-                .or(Some(super::LIBVIRT_DEFAULT_DISK_SIZE.to_string())),
+                .as_ref()
+                .and_then(|s| s.parse::<DiskSize>().ok())
+                .or_else(|| super::LIBVIRT_DEFAULT_DISK_SIZE.parse::<DiskSize>().ok()),
             format: Format::Qcow2, // Use qcow2 for CoW cloning
             common: CommonVmOpts {
                 memory: crate::common_opts::MemoryOpts {

crates/kit/src/libvirt/upload.rs

@@ -4,9 +4,10 @@
 //! to libvirt storage pools, maintaining container image metadata as libvirt annotations.
 
 use crate::common_opts::MemoryOpts;
+use crate::images;
 use crate::install_options::InstallOptions;
 use crate::to_disk::{run as to_disk, ToDiskAdditionalOpts, ToDiskOpts};
-use crate::{images, utils};
+use crate::utils::DiskSize;
 use camino::Utf8PathBuf;
 use clap::Parser;
 use color_eyre::{eyre::eyre, Result};
@@ -30,7 +31,7 @@ pub struct LibvirtUploadOpts {
 
     /// Size of the disk image (e.g., '20G', '10240M'). If not specified, uses the actual size of the created disk.
     #[clap(long)]
-    pub disk_size: Option<String>,
+    pub disk_size: Option<DiskSize>,
 
     /// Installation options (filesystem, root-size, storage-path)
     #[clap(flatten)]
@@ -189,14 +190,14 @@ pub fn run(global_opts: &crate::libvirt::LibvirtOptions, opts: LibvirtUploadOpts
     debug!("Container image digest: {}", image_digest);
 
     // Phase 2: Calculate disk size to use
-    let disk_size = if let Some(ref size_str) = opts.disk_size {
+    let disk_size = if let Some(size) = opts.disk_size {
         // Use explicit size if provided
-        utils::parse_size(size_str)?
+        size
     } else {
         // Use same logic as to_disk: 2x source image size with 4GB minimum
         let image_size = images::get_image_size(&opts.source_image)?;
 
-        std::cmp::max(image_size * 2, 4u64 * 1024 * 1024 * 1024)
+        DiskSize::from_bytes(std::cmp::max(image_size * 2, 4u64 * 1024 * 1024 * 1024))
     };
 
     // Phase 2: Create temporary disk path
@@ -211,7 +212,7 @@ pub fn run(global_opts: &crate::libvirt::LibvirtOptions, opts: LibvirtUploadOpts
         target_disk: temp_disk_path.clone(),
         install: opts.install.clone(),
         additional: ToDiskAdditionalOpts {
-            disk_size: Some(disk_size.to_string()),
+            disk_size: Some(disk_size),
             common: crate::run_ephemeral::CommonVmOpts {
                 memory: opts.memory.clone(),
                 vcpus: opts.vcpus,
@@ -226,7 +227,7 @@ pub fn run(global_opts: &crate::libvirt::LibvirtOptions, opts: LibvirtUploadOpts
     opts.upload_to_libvirt(
         global_opts,
         temp_disk_path.as_std_path(),
-        disk_size,
+        disk_size.as_bytes(),
         &image_digest,
     )?;
 

crates/kit/src/libvirt_upload_disk.rs

@@ -4,10 +4,11 @@
 //! to libvirt storage pools, maintaining container image metadata as libvirt annotations.
 
 use crate::common_opts::MemoryOpts;
+use crate::images;
 use crate::install_options::InstallOptions;
 use crate::to_disk::{run as to_disk, ToDiskAdditionalOpts, ToDiskOpts};
+use crate::utils::DiskSize;
 use crate::xml_utils::{self, XmlWriter};
-use crate::{images, utils};
 use camino::Utf8Path;
 use clap::Parser;
 use color_eyre::{eyre::eyre, Result};
@@ -31,7 +32,7 @@ pub struct LibvirtUploadDiskOpts {
 
     /// Size of the disk image (e.g., '20G', '10240M'). If not specified, uses the actual size of the created disk.
     #[clap(long)]
-    pub disk_size: Option<String>,
+    pub disk_size: Option<DiskSize>,
 
     /// Installation options (filesystem, root-size, storage-path)
     #[clap(flatten)]
@@ -258,9 +259,9 @@ pub fn run(opts: LibvirtUploadDiskOpts) -> Result<()> {
     );
 
     // Phase 1: Calculate disk size to use
-    let disk_size = if let Some(ref size_str) = opts.disk_size {
+    let disk_size = if let Some(size) = opts.disk_size {
         // Use explicit size if provided
-        utils::parse_size(size_str)?
+        size.as_bytes()
     } else {
         // Use same logic as to_disk: 2x source image size with 4GB minimum
         let image_size = images::get_image_size(&opts.source_image)?;
@@ -282,7 +283,7 @@ pub fn run(opts: LibvirtUploadDiskOpts) -> Result<()> {
         target_disk: temp_disk.clone(),
         install: opts.install.clone(),
         additional: ToDiskAdditionalOpts {
-            disk_size: Some(disk_size.to_string()),
+            disk_size: Some(DiskSize::from_bytes(disk_size)),
             common: crate::run_ephemeral::CommonVmOpts {
                 memory: opts.memory.clone(),
                 vcpus: opts.vcpus,

crates/kit/src/to_disk.rs

@@ -79,6 +79,7 @@ use crate::cache_metadata::DiskImageMetadata;
 use crate::install_options::InstallOptions;
 use crate::run_ephemeral::{run_detached, CommonVmOpts, RunEphemeralOpts};
 use crate::run_ephemeral_ssh::wait_for_ssh_ready;
+use crate::utils::DiskSize;
 use crate::{images, ssh, utils};
 use camino::Utf8PathBuf;
 use clap::{Parser, ValueEnum};
@@ -119,7 +120,7 @@ impl std::fmt::Display for Format {
 pub struct ToDiskAdditionalOpts {
     /// Disk size to create (e.g. 10G, 5120M, or plain number for bytes)
     #[clap(long)]
-    pub disk_size: Option<String>,
+    pub disk_size: Option<DiskSize>,
 
     /// Output disk image format
     #[clap(long, default_value_t = Format::Raw)]
@@ -337,13 +338,11 @@ EOF
 
     /// Calculate the optimal target disk size based on the source image or explicit size
     ///
-    /// Returns explicit disk_size if provided (parsed from human-readable format),
-    /// otherwise 2x the image size with a 4GB minimum.
+    /// Returns explicit disk_size if provided, otherwise 2x the image size with a 4GB minimum.
     fn calculate_disk_size(&self) -> Result<u64> {
-        if let Some(ref size_str) = self.additional.disk_size {
-            let parsed = utils::parse_size(size_str)?;
-            debug!("Using explicit disk size: {} -> {} bytes", size_str, parsed);
-            return Ok(parsed);
+        if let Some(size) = self.additional.disk_size {
+            debug!("Using explicit disk size: {} bytes", size.as_bytes());
+            return Ok(size.as_bytes());
         }
 
         // Get the image size and multiply by 2 for installation space
@@ -639,7 +638,7 @@ mod tests {
                 ..Default::default()
             },
             additional: ToDiskAdditionalOpts {
-                disk_size: Some("10G".to_string()),
+                disk_size: Some("10G".parse().unwrap()),
                 ..Default::default()
             },
         };
@@ -657,7 +656,7 @@ mod tests {
                 ..Default::default()
             },
             additional: ToDiskAdditionalOpts {
-                disk_size: Some("5120M".to_string()),
+                disk_size: Some("5120M".parse().unwrap()),
                 ..Default::default()
             },
         };

crates/kit/src/utils.rs

@@ -167,6 +167,59 @@ pub(crate) fn validate_container_storage_path(path: &Utf8Path) -> Result<()> {
     Ok(())
 }
 
+/// A disk/file size in bytes, parsed from human-readable strings like "10G", "5120M", "1T"
+///
+/// Implements `FromStr` for direct use with clap's `value_parser`.
+///
+/// # Examples
+///
+/// ```ignore
+/// use bcvk::utils::DiskSize;
+///
+/// let size: DiskSize = "10G".parse().unwrap();
+/// assert_eq!(size.as_bytes(), 10 * 1024 * 1024 * 1024);
+/// ```
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct DiskSize(u64);
+
+impl DiskSize {
+    /// Create a new DiskSize from bytes
+    pub fn from_bytes(bytes: u64) -> Self {
+        Self(bytes)
+    }
+
+    /// Get the size in bytes
+    pub fn as_bytes(&self) -> u64 {
+        self.0
+    }
+}
+
+impl std::str::FromStr for DiskSize {
+    type Err = color_eyre::eyre::Error;
+
+    fn from_str(s: &str) -> Result<Self> {
+        parse_size(s).map(DiskSize)
+    }
+}
+
+impl std::fmt::Display for DiskSize {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        // Display in human-readable form
+        let bytes = self.0;
+        if bytes >= 1024 * 1024 * 1024 * 1024 && bytes % (1024 * 1024 * 1024 * 1024) == 0 {
+            write!(f, "{}T", bytes / (1024 * 1024 * 1024 * 1024))
+        } else if bytes >= 1024 * 1024 * 1024 && bytes % (1024 * 1024 * 1024) == 0 {
+            write!(f, "{}G", bytes / (1024 * 1024 * 1024))
+        } else if bytes >= 1024 * 1024 && bytes % (1024 * 1024) == 0 {
+            write!(f, "{}M", bytes / (1024 * 1024))
+        } else if bytes >= 1024 && bytes % 1024 == 0 {
+            write!(f, "{}K", bytes / 1024)
+        } else {
+            write!(f, "{}", bytes)
+        }
+    }
+}
+
 /// Parse size string (e.g., "10G", "5120M", "1T") to bytes
 pub(crate) fn parse_size(size_str: &str) -> Result<u64> {
     let size_str = size_str.trim().to_uppercase();