lib/src/status: add verbose human readable output

Assisted-by: Claude Code

Author: jmarrero

lib/src/cli.rs

@@ -188,6 +188,10 @@ pub(crate) struct StatusOpts {
     /// Only display status for the booted deployment.
     #[clap(long)]
     pub(crate) booted: bool,
+
+    /// Show verbose output for human readable format.
+    #[clap(long, short = 'v')]
+    pub(crate) verbose: bool,
 }
 
 #[derive(Debug, clap::Subcommand, PartialEq, Eq)]
@@ -1343,7 +1347,8 @@ mod tests {
                 json: false,
                 format: None,
                 format_version: None,
-                booted: false
+                booted: false,
+                verbose: false
             })
         ));
         assert!(matches!(
@@ -1353,6 +1358,24 @@ mod tests {
                 ..
             })
         ));
+        
+        // Test verbose long form
+        assert!(matches!(
+            Opt::parse_including_static(["bootc", "status", "--verbose"]),
+            Opt::Status(StatusOpts {
+                verbose: true,
+                ..
+            })
+        ));
+        
+        // Test verbose short form
+        assert!(matches!(
+            Opt::parse_including_static(["bootc", "status", "-v"]),
+            Opt::Status(StatusOpts {
+                verbose: true,
+                ..
+            })
+        ));
     }
 
     #[test]

lib/src/status.rs

@@ -325,7 +325,7 @@ pub(crate) async fn status(opts: super::cli::StatusOpts) -> Result<()> {
             .to_canon_json_writer(&mut out)
             .map_err(anyhow::Error::new),
         OutputFormat::Yaml => serde_yaml::to_writer(&mut out, &host).map_err(anyhow::Error::new),
-        OutputFormat::HumanReadable => human_readable_output(&mut out, &host),
+        OutputFormat::HumanReadable => human_readable_output(&mut out, &host, opts.verbose),
     }
     .context("Writing to stdout")?;
 
@@ -365,6 +365,7 @@ fn human_render_slot(
     slot: Option<Slot>,
     entry: &crate::spec::BootEntry,
     image: &crate::spec::ImageStatus,
+    verbose: bool,
 ) -> Result<()> {
     let transport = &image.image.transport;
     let imagename = &image.image.image;
@@ -415,6 +416,43 @@ fn human_render_slot(
         writeln!(out, "yes")?;
     }
 
+    if verbose {
+        // Show additional information in verbose mode similar to rpm-ostree
+        if let Some(ostree) = &entry.ostree {
+            write_row_name(&mut out, "StateRoot", prefix_len)?;
+            writeln!(out, "{}", ostree.stateroot)?;
+            
+            // Show deployment serial (similar to Index in rpm-ostree)
+            write_row_name(&mut out, "Deploy serial", prefix_len)?;
+            writeln!(out, "{}", ostree.deploy_serial)?;
+            
+            // Show if this is staged
+            let is_staged = matches!(slot, Some(Slot::Staged));
+            write_row_name(&mut out, "Staged", prefix_len)?;
+            writeln!(out, "{}", if is_staged { "yes" } else { "no" })?;
+            
+            // Show the commit (equivalent to Base Commit in rpm-ostree)
+            write_row_name(&mut out, "Commit", prefix_len)?;
+            writeln!(out, "{}", ostree.checksum)?;
+        }
+        
+        // Show signature information if available
+        if let Some(signature) = &image.image.signature {
+            write_row_name(&mut out, "Signature", prefix_len)?;
+            match signature {
+                crate::spec::ImageSignature::OstreeRemote(remote) => {
+                    writeln!(out, "ostree-remote:{}", remote)?;
+                }
+                crate::spec::ImageSignature::ContainerPolicy => {
+                    writeln!(out, "container-policy")?;
+                }
+                crate::spec::ImageSignature::Insecure => {
+                    writeln!(out, "insecure")?;
+                }
+            }
+        }
+    }
+
     tracing::debug!("pinned={}", entry.pinned);
 
     Ok(())
@@ -426,6 +464,7 @@ fn human_render_slot_ostree(
     slot: Option<Slot>,
     entry: &crate::spec::BootEntry,
     ostree_commit: &str,
+    verbose: bool,
 ) -> Result<()> {
     // TODO consider rendering more ostree stuff here like rpm-ostree status does
     let prefix = match slot {
@@ -444,11 +483,28 @@ fn human_render_slot_ostree(
         writeln!(out, "yes")?;
     }
 
+    if verbose {
+        // Show additional information in verbose mode similar to rpm-ostree
+        if let Some(ostree) = &entry.ostree {
+            write_row_name(&mut out, "StateRoot", prefix_len)?;
+            writeln!(out, "{}", ostree.stateroot)?;
+            
+            // Show deployment serial (similar to Index in rpm-ostree)
+            write_row_name(&mut out, "Deploy serial", prefix_len)?;
+            writeln!(out, "{}", ostree.deploy_serial)?;
+            
+            // Show if this is staged
+            let is_staged = matches!(slot, Some(Slot::Staged));
+            write_row_name(&mut out, "Staged", prefix_len)?;
+            writeln!(out, "{}", if is_staged { "yes" } else { "no" })?;
+        }
+    }
+
     tracing::debug!("pinned={}", entry.pinned);
     Ok(())
 }
 
-fn human_readable_output_booted(mut out: impl Write, host: &Host) -> Result<()> {
+fn human_readable_output_booted(mut out: impl Write, host: &Host, verbose: bool) -> Result<()> {
     let mut first = true;
     for (slot_name, status) in [
         (Slot::Staged, &host.status.staged),
@@ -462,9 +518,9 @@ fn human_readable_output_booted(mut out: impl Write, host: &Host) -> Result<()>
                 writeln!(out)?;
             }
             if let Some(image) = &host_status.image {
-                human_render_slot(&mut out, Some(slot_name), host_status, image)?;
+                human_render_slot(&mut out, Some(slot_name), host_status, image, verbose)?;
             } else if let Some(ostree) = host_status.ostree.as_ref() {
-                human_render_slot_ostree(&mut out, Some(slot_name), host_status, &ostree.checksum)?;
+                human_render_slot_ostree(&mut out, Some(slot_name), host_status, &ostree.checksum, verbose)?;
             } else {
                 writeln!(out, "Current {slot_name} state is unknown")?;
             }
@@ -476,9 +532,9 @@ fn human_readable_output_booted(mut out: impl Write, host: &Host) -> Result<()>
             writeln!(out)?;
 
             if let Some(image) = &entry.image {
-                human_render_slot(&mut out, None, entry, image)?;
+                human_render_slot(&mut out, None, entry, image, verbose)?;
             } else if let Some(ostree) = entry.ostree.as_ref() {
-                human_render_slot_ostree(&mut out, None, entry, &ostree.checksum)?;
+                human_render_slot_ostree(&mut out, None, entry, &ostree.checksum, verbose)?;
             }
         }
     }
@@ -487,9 +543,9 @@ fn human_readable_output_booted(mut out: impl Write, host: &Host) -> Result<()>
 }
 
 /// Implementation of rendering our host structure in a "human readable" way.
-fn human_readable_output(mut out: impl Write, host: &Host) -> Result<()> {
+fn human_readable_output(mut out: impl Write, host: &Host, verbose: bool) -> Result<()> {
     if host.status.booted.is_some() {
-        human_readable_output_booted(out, host)?;
+        human_readable_output_booted(out, host, verbose)?;
     } else {
         writeln!(out, "System is not deployed via bootc.")?;
     }
@@ -503,7 +559,17 @@ mod tests {
     fn human_status_from_spec_fixture(spec_fixture: &str) -> Result<String> {
         let host: Host = serde_yaml::from_str(spec_fixture).unwrap();
         let mut w = Vec::new();
-        human_readable_output(&mut w, &host).unwrap();
+        human_readable_output(&mut w, &host, false).unwrap();
+        let w = String::from_utf8(w).unwrap();
+        Ok(w)
+    }
+
+    /// Helper function to generate human-readable status output with verbose mode enabled
+    /// from a YAML fixture string. Used for testing verbose output formatting.
+    fn human_status_from_spec_fixture_verbose(spec_fixture: &str) -> Result<String> {
+        let host: Host = serde_yaml::from_str(spec_fixture).unwrap();
+        let mut w = Vec::new();
+        human_readable_output(&mut w, &host, true).unwrap();
         let w = String::from_utf8(w).unwrap();
         Ok(w)
     }
@@ -634,4 +700,17 @@ mod tests {
         "};
         similar_asserts::assert_eq!(w, expected);
     }
+
+    #[test]
+    fn test_human_readable_verbose_spec() {
+        // Test verbose output includes additional fields
+        let w = human_status_from_spec_fixture_verbose(include_str!("fixtures/spec-only-booted.yaml"))
+            .expect("No spec found");
+        
+        // Verbose output should include StateRoot, Deploy serial, Staged, and Commit
+        assert!(w.contains("StateRoot:"));
+        assert!(w.contains("Deploy serial:"));
+        assert!(w.contains("Staged:"));
+        assert!(w.contains("Commit:"));
+    }
 }