feat: add codspeed setup status cli command

Author: GuillaumeLagrange

src/cli/mod.rs

@@ -84,7 +84,7 @@ enum Commands {
     /// Manage the CLI authentication state
     Auth(auth::AuthArgs),
     /// Pre-install the codspeed executors
-    Setup,
+    Setup(setup::SetupArgs),
     /// Set the codspeed mode for the rest of the shell session
     Use(use_mode::UseArgs),
     /// Show the codspeed mode previously set in this shell session with `codspeed use`
@@ -137,7 +137,7 @@ pub async fn run() -> Result<()> {
             .await?
         }
         Commands::Auth(args) => auth::run(args, &api_client, cli.config_name.as_deref()).await?,
-        Commands::Setup => setup::setup(setup_cache_dir).await?,
+        Commands::Setup(args) => setup::run(args, &api_client, setup_cache_dir).await?,
         Commands::Use(args) => use_mode::run(args)?,
         Commands::Show => show::run()?,
     }
@@ -154,7 +154,7 @@ impl Cli {
             config_name: None,
             config: None,
             setup_cache_dir: None,
-            command: Commands::Setup,
+            command: Commands::Setup(setup::SetupArgs::default()),
         }
     }
 }

src/cli/setup.rs

@@ -1,9 +1,37 @@
-use crate::executor::get_all_executors;
+use crate::VERSION;
+use crate::api_client::CodSpeedAPIClient;
+use crate::config::CodSpeedConfig;
+use crate::executor::{ToolInstallStatus, get_all_executors};
 use crate::prelude::*;
 use crate::system::SystemInfo;
+use clap::{Args, Subcommand};
+use console::style;
 use std::path::Path;
 
-pub async fn setup(setup_cache_dir: Option<&Path>) -> Result<()> {
+#[derive(Debug, Default, Args)]
+pub struct SetupArgs {
+    #[command(subcommand)]
+    command: Option<SetupCommands>,
+}
+
+#[derive(Debug, Subcommand)]
+enum SetupCommands {
+    /// Show the status of the CodSpeed setup (authentication, installed tools, system info)
+    Status,
+}
+
+pub async fn run(
+    args: SetupArgs,
+    api_client: &CodSpeedAPIClient,
+    setup_cache_dir: Option<&Path>,
+) -> Result<()> {
+    match args.command {
+        None => setup(setup_cache_dir).await,
+        Some(SetupCommands::Status) => status(api_client).await,
+    }
+}
+
+async fn setup(setup_cache_dir: Option<&Path>) -> Result<()> {
     let system_info = SystemInfo::new()?;
     let executors = get_all_executors();
     start_group!("Setting up the environment for all executors");
@@ -18,3 +46,82 @@ pub async fn setup(setup_cache_dir: Option<&Path>) -> Result<()> {
     end_group!();
     Ok(())
 }
+
+fn check_mark() -> console::StyledObject<&'static str> {
+    style("✓").green()
+}
+
+fn cross_mark() -> console::StyledObject<&'static str> {
+    style("✗").red()
+}
+
+fn warn_mark() -> console::StyledObject<&'static str> {
+    style("!").yellow()
+}
+
+async fn status(api_client: &CodSpeedAPIClient) -> Result<()> {
+    // Authentication
+    info!("{}", style("Authentication").bold());
+    let config = CodSpeedConfig::load_with_override(None, None)?;
+    if config.auth.token.is_some() {
+        if api_client.is_token_valid().await {
+            info!("  {} Logged in", check_mark());
+        } else {
+            info!(
+                "  {} Token expired (run {} to re-authenticate)",
+                cross_mark(),
+                style("codspeed auth login").cyan()
+            );
+        }
+    } else {
+        info!(
+            "  {} Not logged in (run {} to authenticate)",
+            cross_mark(),
+            style("codspeed auth login").cyan()
+        );
+    }
+    info!("");
+
+    // Installed tools
+    info!("{}", style("Tools").bold());
+    for executor in get_all_executors() {
+        let tool_status = executor.tool_status();
+        match &tool_status.status {
+            ToolInstallStatus::Installed { version } => {
+                info!("  {} {} ({})", check_mark(), tool_status.tool_name, version);
+            }
+            ToolInstallStatus::IncorrectVersion { version, message } => {
+                info!(
+                    "  {} {} ({}, {})",
+                    warn_mark(),
+                    tool_status.tool_name,
+                    version,
+                    message
+                );
+            }
+            ToolInstallStatus::NotInstalled => {
+                info!(
+                    "  {} {} (not installed)",
+                    cross_mark(),
+                    tool_status.tool_name
+                );
+            }
+        }
+    }
+    info!("");
+
+    // System info
+    info!("{}", style("System").bold());
+    info!("  codspeed {VERSION}");
+    let system_info = SystemInfo::new()?;
+    info!(
+        "  {} {} ({})",
+        system_info.os, system_info.os_version, system_info.arch
+    );
+    info!(
+        "  {} ({}C / {}GB)",
+        system_info.cpu_brand, system_info.cpu_cores, system_info.total_memory_gb
+    );
+
+    Ok(())
+}