feat: implement cmd/version (#117)

* feat: implement cmd/version

* fix: implement the dependencies list in cli/version

* test: add test for cli/version

* fix: address comments

Author: iamquang95

Cargo.lock

@@ -24,7 +24,7 @@ publish = false
 
 [workspace.dependencies]
 alloy = { version = "1.3", features = ["essentials"] }
-built = { version = "0.8.0", features = ["git2", "chrono"] }
+built = { version = "0.8.0", features = ["git2", "chrono", "cargo-lock"] }
 blst = "0.3"
 anyhow = "1"
 cancellation = "0.1.0"

Cargo.toml

@@ -16,6 +16,7 @@ thiserror.workspace = true
 k256.workspace = true
 hex.workspace = true
 tokio.workspace = true
+charon-core.workspace = true
 charon-p2p.workspace = true
 charon-eth2.workspace = true
 charon-k1util.workspace = true

crates/charon-cli/Cargo.toml

@@ -2,7 +2,7 @@
 
 use clap::{Parser, Subcommand};
 
-use crate::commands::enr::EnrArgs;
+use crate::commands::{enr::EnrArgs, version::VersionArgs};
 
 /// Pluto - Proof of Stake Ethereum Distributed Validator Client
 #[derive(Parser)]
@@ -26,8 +26,10 @@ pub enum Commands {
         long_about = "Prints an Ethereum Node Record (ENR) from this client's charon-enr-private-key. This serves as a public key that identifies this client to its peers."
     )]
     Enr(EnrArgs),
+
+    #[command(about = "Print version and exit", long_about = "Output version info")]
+    Version(VersionArgs),
     // Future commands will be added here:
-    // Version(VersionArgs),
     // Run(RunArgs),
     // Create(CreateArgs),
 }

crates/charon-cli/src/cli.rs

@@ -1 +1,2 @@
 pub mod enr;
+pub mod version;

crates/charon-cli/src/commands/mod.rs

@@ -0,0 +1,145 @@
+use std::io::{self, Write};
+
+use crate::error::Result;
+
+/// Arguments for the version command.
+#[derive(clap::Args)]
+pub struct VersionArgs {
+    #[arg(
+        long = "verbose",
+        help = "Includes detailed module version info and supported protocols."
+    )]
+    pub verbose: bool,
+}
+
+/// Runs the version command.
+pub fn run(args: VersionArgs) -> Result<()> {
+    run_with_writer(args, &mut io::stdout())
+}
+
+/// Runs the version command with a custom writer (used for testing).
+fn run_with_writer<W: Write>(args: VersionArgs, writer: &mut W) -> Result<()> {
+    let (hash, timestamp) = charon_core::version::git_commit();
+    writeln!(
+        writer,
+        "{} [git_commit_hash={},git_commit_time={}]",
+        *charon_core::version::VERSION,
+        hash,
+        timestamp
+    )?;
+
+    if !args.verbose {
+        return Ok(());
+    }
+
+    writeln!(writer, "Package: {}", env!("CARGO_PKG_NAME"))?;
+    writeln!(writer, "Dependencies:")?;
+
+    for dependency in charon_core::version::dependencies() {
+        writeln!(writer, "\t{dependency}")?;
+    }
+
+    writeln!(writer, "Consensus protocols:")?;
+    for protocol in charon_core::consensus::protocols::protocols() {
+        writeln!(writer, "\t{}", protocol)?;
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_run_version_cmd_default() {
+        let mut buf = Vec::new();
+        let args = VersionArgs { verbose: false };
+
+        let result = run_with_writer(args, &mut buf);
+        assert!(result.is_ok());
+
+        let output = String::from_utf8(buf).expect("valid UTF-8 output");
+
+        // Check that output contains git info
+        assert!(
+            output.contains("git_commit_hash"),
+            "Output should contain git_commit_hash"
+        );
+        assert!(
+            output.contains("git_commit_time"),
+            "Output should contain git_commit_time"
+        );
+
+        // Check that verbose-only content is NOT present
+        assert!(
+            !output.contains("Package:"),
+            "Default output should not contain Package:"
+        );
+
+        // Parse the version from output
+        // Format: "v1.7.1
+        // [git_commit_hash=abc1234,git_commit_time=2024-01-01T00:00:00Z]\n"
+        let parts: Vec<&str> = output.split_whitespace().collect();
+        assert_eq!(
+            parts.len(),
+            2,
+            "Default output should have exactly 2 space-separated parts"
+        );
+
+        // Parse the version string
+        let version_str = parts[0];
+        let parsed_version =
+            charon_core::version::SemVer::parse(version_str).expect("valid semver");
+        assert_eq!(
+            parsed_version,
+            *charon_core::version::VERSION,
+            "Parsed version should match VERSION constant"
+        );
+    }
+
+    #[test]
+    fn test_run_version_cmd_verbose() {
+        let mut buf = Vec::new();
+        let args = VersionArgs { verbose: true };
+
+        let result = run_with_writer(args, &mut buf);
+        assert!(result.is_ok());
+
+        let output = String::from_utf8(buf).expect("valid UTF-8 output");
+
+        // Check that output contains git info
+        assert!(
+            output.contains("git_commit_hash"),
+            "Output should contain git_commit_hash"
+        );
+        assert!(
+            output.contains("git_commit_time"),
+            "Output should contain git_commit_time"
+        );
+
+        // Check that verbose content is present
+        assert!(
+            output.contains("Package:"),
+            "Verbose output should contain Package:"
+        );
+        assert!(
+            output.contains("Dependencies:"),
+            "Verbose output should contain Dependencies:"
+        );
+        assert!(
+            output.contains("Consensus protocols:"),
+            "Verbose output should contain Consensus protocols:"
+        );
+
+        // Check that the first protocol is listed
+        let protocols = charon_core::consensus::protocols::protocols();
+        assert!(!protocols.is_empty(), "Should have at least one protocol");
+        let first_protocol = protocols[0].to_string();
+        assert!(
+            output.contains(&first_protocol),
+            "Verbose output should contain the first protocol: {}",
+            first_protocol
+        );
+    }
+}

crates/charon-cli/src/commands/version.rs

@@ -18,5 +18,6 @@ fn main() -> Result<()> {
 
     match cli.command {
         Commands::Enr(args) => commands::enr::run(args),
+        Commands::Version(args) => commands::version::run(args),
     }
 }

crates/charon-cli/src/main.rs

@@ -7,6 +7,7 @@ use std::io::Result;
 fn main() -> Result<()> {
     charon_build_proto::compile_protos("src/corepb/v1")?;
     built::write_built_file()?;
+    println!("cargo:rerun-if-changed=../../Cargo.lock");
 
     Ok(())
 }

crates/charon-core/build.rs

@@ -49,14 +49,31 @@ pub fn git_commit() -> (String, String) {
         include!(concat!(env!("OUT_DIR"), "/built.rs"));
     }
 
-    let hash = built_info::GIT_COMMIT_HASH.unwrap_or("unknown").into();
+    let hash = built_info::GIT_COMMIT_HASH
+        .map(|h| h.chars().take(7).collect())
+        .unwrap_or_else(|| "unknown".into());
+
     let timestamp = chrono::DateTime::parse_from_rfc2822(built_info::BUILT_TIME_UTC)
-        .map(|dt| dt.timestamp().to_string())
+        .map(|dt| dt.to_rfc3339_opts(chrono::SecondsFormat::Secs, true))
         .unwrap_or_else(|_| "unknown".into());
 
     (hash, timestamp)
 }
 
+/// Dependency list from build info in `name v{version}` format.
+pub fn dependencies() -> Vec<String> {
+    mod built_info {
+        include!(concat!(env!("OUT_DIR"), "/built.rs"));
+    }
+
+    let mut deps: Vec<String> = built_info::DEPENDENCIES
+        .iter()
+        .map(|(name, version)| format!("{name} v{version}"))
+        .collect();
+    deps.sort_unstable();
+    deps
+}
+
 /// The type of semantic version, i.e., minor, patch, or pre-release.
 #[derive(Eq, PartialEq, Debug, Copy, Clone)]
 pub enum SemVerType {