Prepare c0mpute 0.2.43 benchmark metadata release (#82)

* Prepare v0.2.43 benchmark metadata release

* Benchmark automatically after self-update

---------

Co-authored-by: Anthony Ettinger <anthony@profullstack.com>

Author: sh1pt-actions-fleet[bot]

Cargo.lock

@@ -23,7 +23,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.2.42"
+version = "0.2.43"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/profullstack/c0mpute"

Cargo.toml

@@ -1,6 +1,6 @@
 {
   "name": "@c0mpute/tui",
-  "version": "0.2.42",
+  "version": "0.2.43",
   "private": true,
   "type": "module",
   "bin": {

apps/tui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c0mpute",
-  "version": "0.2.42",
+  "version": "0.2.43",
   "private": true,
   "type": "module",
   "scripts": {

apps/web/package.json

@@ -28,7 +28,7 @@ export const dynamic = "force-dynamic";
  * this in sync with the workspace version in `Cargo.toml` on each release so a
  * freshly built CLI reports "already latest" rather than a phantom upgrade.
  */
-const FALLBACK_VERSION = "0.2.42";
+const FALLBACK_VERSION = "0.2.43";
 const FALLBACK_MIN_REQUIRED = "0.0.1";
 
 type Channel = "stable" | "beta" | "nightly";

apps/web/src/app/releases/latest.json/route.ts

@@ -607,6 +607,17 @@ fn host_info() -> (String, String, Option<u64>) {
     (cpu, kernel, ram_bytes)
 }
 
+/// Current public host hardware summary for capability adverts. Bench reports
+/// remain the source of performance results, but this lets unbenchmarked nodes
+/// publish CPU, core count and installed memory too.
+pub fn hardware_summary() -> (String, usize, Option<u64>) {
+    let (cpu, _kernel, ram_bytes) = host_info();
+    let cores = std::thread::available_parallelism()
+        .map(|n| n.get())
+        .unwrap_or(1);
+    (cpu, cores, ram_bytes)
+}
+
 fn rfc3339_now() -> String {
     let secs = SystemTime::now()
         .duration_since(UNIX_EPOCH)

node/crates/c0mpute-bench/src/lib.rs

@@ -63,6 +63,7 @@ enum Cmd {
     /// Benchmark this machine (fib / matmul / hash at 1…N threads) and record
     /// a score the worker advertises to the network. Report lands in
     /// `<data-dir>/bench.json`, same shape as fleetcode's runtime-benchmarks.
+    #[command(alias = "benchmark")]
     Bench {
         #[command(subcommand)]
         cmd: Option<BenchCmd>,

node/crates/c0mpute-cli/src/main.rs

@@ -143,12 +143,13 @@ pub fn hardware_blob(config: &Config) -> serde_json::Value {
         "version": env!("CARGO_PKG_VERSION"),
         "free_disk_root": config.storage.root.display().to_string(),
     });
+    let (cpu, cores, ram_bytes) = c0mpute_bench::hardware_summary();
+    blob["cpu"] = serde_json::Value::String(cpu);
+    blob["cores"] = serde_json::Value::from(cores);
+    if let Some(ram_bytes) = ram_bytes {
+        blob["ram_bytes"] = serde_json::Value::from(ram_bytes);
+    }
     if let Some(report) = bench_report_path().and_then(|p| c0mpute_bench::load(&p).ok().flatten()) {
-        blob["cpu"] = serde_json::Value::String(report.metadata.cpu.clone());
-        blob["cores"] = serde_json::Value::from(report.metadata.cores);
-        if let Some(ram_bytes) = report.metadata.ram_bytes {
-            blob["ram_bytes"] = serde_json::Value::from(ram_bytes);
-        }
         blob["bench_at"] = serde_json::Value::String(report.metadata.start_time.clone());
         if !report.metadata.quick && report.score > 0 {
             blob["benchmark"] = benchmark_details(&report);

node/crates/c0mpute-core/src/capabilities.rs

@@ -131,13 +131,41 @@ pub async fn upgrade_now(current_version: &str, release_feed_url: &str) -> Resul
             current: current_version.to_string(),
         });
     }
+    // Save the executable path before replacing its on-disk inode. After the
+    // swap, launch the new binary's full benchmark under this node's identity
+    // so its refreshed report is what the worker advertises on restart.
+    let new_exe = std::env::current_exe().ok();
     perform_upgrade(&manifest).await?;
+    if let Some(exe) = new_exe {
+        if let Err(error) = run_post_update_benchmark(exe).await {
+            warn!(err = %error, "post-update benchmark failed; continuing with the updated binary");
+        }
+    } else {
+        warn!("could not locate updated executable to run the post-update benchmark");
+    }
     Ok(UpgradeOutcome::Upgraded {
         from: current_version.to_string(),
         to: manifest.version,
     })
 }
 
+async fn run_post_update_benchmark(exe: std::path::PathBuf) -> Result<()> {
+    let status = tokio::task::spawn_blocking(move || {
+        std::process::Command::new(exe)
+            .arg("benchmark")
+            // The child already is the newly installed version; avoid another
+            // release-feed request before it starts measuring this machine.
+            .env("C0MPUTE_NO_AUTO_UPDATE", "1")
+            .status()
+    })
+    .await
+    .context("join post-update benchmark")??;
+    if !status.success() {
+        anyhow::bail!("`c0mpute benchmark` exited with {status}");
+    }
+    Ok(())
+}
+
 /// Map the compile-time target to the release artifact's os/arch tokens
 /// (matching `.github/workflows/release.yml` naming).
 fn target_os_arch() -> Result<(&'static str, &'static str)> {

node/crates/c0mpute-update/src/lib.rs

@@ -1,6 +1,6 @@
 {
   "name": "c0mpute-monorepo",
-  "version": "0.2.42",
+  "version": "0.2.43",
   "private": true,
   "workspaces": [
     "apps/*",