Show fabric build version

Author: myobie

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "fabric"
-version = "0.1.4"
+version = "0.1.5"
 edition = "2024"
 
 [dependencies]

Cargo.toml

@@ -91,6 +91,12 @@ endpoint allow-list.
 
 ## Commands
 
+```sh
+fabric --version
+```
+
+Print the installed build version as `<semver>+<short-git-sha>`.
+
 ```sh
 fabric key gen --out <path>
 ```
@@ -118,6 +124,7 @@ fabric status
 Show the running daemon's local state and echo-ping every trusted peer. Each
 peer is reported as reachable or unreachable with round-trip latency and, when
 iroh exposes it, the active transport path: `direct`, `relay`, or `mixed`.
+Status also prints the daemon build version.
 
 ```sh
 fabric add <nodeid> [name] [--addr-json JSON]

README.md

@@ -0,0 +1,34 @@
+use std::{env, process::Command};
+
+fn main() {
+    println!("cargo:rerun-if-env-changed=GITHUB_SHA");
+    println!("cargo:rerun-if-changed=.git/HEAD");
+
+    let sha = env::var("GITHUB_SHA")
+        .ok()
+        .and_then(|sha| short_sha(&sha))
+        .or_else(git_sha)
+        .unwrap_or_else(|| "unknown".to_string());
+    println!("cargo:rustc-env=FABRIC_BUILD_SHA={sha}");
+}
+
+fn git_sha() -> Option<String> {
+    let output = Command::new("git")
+        .args(["rev-parse", "--short=7", "HEAD"])
+        .output()
+        .ok()?;
+    if !output.status.success() {
+        return None;
+    }
+    let sha = String::from_utf8(output.stdout).ok()?;
+    short_sha(sha.trim())
+}
+
+fn short_sha(sha: &str) -> Option<String> {
+    let sha = sha.trim();
+    if sha.is_empty() {
+        None
+    } else {
+        Some(sha.chars().take(7).collect())
+    }
+}

build.rs

@@ -26,6 +26,7 @@ pub enum ControlResponse {
         dial_sockets: Vec<PathBuf>,
     },
     ReachabilityStatus {
+        version: String,
         node_id: String,
         endpoint_addr: serde_json::Value,
         exposed_protocols: Vec<String>,

src/control.rs

@@ -247,6 +247,7 @@ impl DaemonState {
             self.local_status_fields().await?;
         let peers = self.peer_reachability().await;
         Ok(ControlResponse::ReachabilityStatus {
+            version: crate::version_string(),
             node_id,
             endpoint_addr,
             exposed_protocols,

src/daemon.rs

@@ -12,6 +12,14 @@ pub mod shell;
 
 const SPIKE_ALPN: &[u8] = b"fabric/spike/echo/0";
 
+pub fn version_string() -> String {
+    format!(
+        "{}+{}",
+        env!("CARGO_PKG_VERSION"),
+        option_env!("FABRIC_BUILD_SHA").unwrap_or("unknown")
+    )
+}
+
 pub async fn iroh_spike_round_trip(payload: &[u8]) -> Result<Vec<u8>> {
     let router = start_spike_accept_side().await?;
     router.endpoint().online().await;

src/lib.rs

@@ -7,7 +7,7 @@ use std::{
 };
 
 use anyhow::{Result, bail};
-use clap::{Parser, Subcommand};
+use clap::{CommandFactory, Parser, Subcommand};
 use fabric::{
     config::{
         FabricHome, PeerBook, generate_identity_file, load_or_create_identity, parse_addr_json,
@@ -23,11 +23,14 @@ use tokio::io::{AsyncReadExt, AsyncWriteExt};
 #[command(name = "fabric")]
 #[command(about = "Local socket facade for iroh-backed cross-machine transports")]
 struct Cli {
+    #[arg(long)]
+    version: bool,
+
     #[arg(long, global = true)]
     home: Option<PathBuf>,
 
     #[command(subcommand)]
-    command: Commands,
+    command: Option<Commands>,
 }
 
 #[derive(Debug, Subcommand)]
@@ -99,8 +102,18 @@ enum KeyCommands {
 #[tokio::main]
 async fn main() -> Result<()> {
     let cli = Cli::parse();
+    if cli.version {
+        println!("{}", fabric::version_string());
+        return Ok(());
+    }
+
+    let Some(command) = cli.command else {
+        Cli::command().print_help()?;
+        println!();
+        return Ok(());
+    };
 
-    match cli.command {
+    match command {
         Commands::Key {
             command: KeyCommands::Gen { out },
         } => {
@@ -124,13 +137,15 @@ async fn main() -> Result<()> {
                 Commands::Status => {
                     match send_control(&home, ControlRequest::ReachabilityStatus).await? {
                         ControlResponse::ReachabilityStatus {
+                            version,
                             node_id,
                             endpoint_addr,
                             exposed_protocols,
                             dial_sockets,
                             peers,
                         } => {
                             print_status(
+                                &version,
                                 &node_id,
                                 &endpoint_addr,
                                 &exposed_protocols,
@@ -240,12 +255,14 @@ async fn main() -> Result<()> {
 }
 
 fn print_status(
+    version: &str,
     node_id: &str,
     endpoint_addr: &serde_json::Value,
     exposed_protocols: &[String],
     dial_sockets: &[PathBuf],
     peers: &[PeerReachability],
 ) -> Result<()> {
+    println!("version\t{version}");
     println!("node\t{node_id}");
     println!("addr\t{}", serde_json::to_string(endpoint_addr)?);
     println!("exposed\t{}", joined_or_dash(exposed_protocols));

src/main.rs

@@ -237,9 +237,10 @@ async fn status_reports_peer_reachability() -> Result<()> {
     .await?;
 
     let response = send_control(&node_b_home, ControlRequest::ReachabilityStatus).await?;
-    let ControlResponse::ReachabilityStatus { peers, .. } = response else {
+    let ControlResponse::ReachabilityStatus { version, peers, .. } = response else {
         panic!("unexpected response: {response:?}");
     };
+    assert_eq!(version, fabric::version_string());
     let peer = peers
         .iter()
         .find(|peer| peer.name.as_deref() == Some("node-a"))

tests/local_slice.rs

@@ -49,6 +49,23 @@ fn key_gen_writes_identity_consumed_by_id() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn version_flag_prints_semver_and_build_sha() -> Result<()> {
+    let version = stdout(
+        Command::new(fabric_bin())
+            .arg("--version")
+            .output()
+            .context("failed to run fabric --version")?,
+    )?;
+    let prefix = format!("{}+", env!("CARGO_PKG_VERSION"));
+    assert!(
+        version.starts_with(&prefix),
+        "version {version:?} did not start with {prefix:?}"
+    );
+    assert!(version.len() > prefix.len());
+    Ok(())
+}
+
 #[test]
 fn peers_lists_declarative_config_without_add() -> Result<()> {
     let temp = TempDir::new()?;