feat: add codspeed auth status, codspeed setup status, and codspeed status commands

- `codspeed auth status`: checks token validity via API, detects
  repository from git remote, and verifies it exists on CodSpeed
- `codspeed setup status`: shows tool installation status for each
  executor via the new `tool_status()` trait method
- `codspeed status`: combines auth, setup, and system info
- Remove noisy warning from `find_repository_root`

Author: GuillaumeLagrange

src/api_client.rs

@@ -243,7 +243,29 @@ nest! {
     }
 }
 
+nest! {
+    #[derive(Debug, Deserialize, Serialize)]*
+    #[serde(rename_all = "camelCase")]*
+    struct CurrentUserData {
+        user: Option<pub struct CurrentUserPayload {
+            pub id: String,
+        }>,
+    }
+}
+
 impl CodSpeedAPIClient {
+    /// Check if the current token is valid by querying the user resolver.
+    pub async fn is_token_valid(&self) -> bool {
+        let response = self
+            .gql_client
+            .query_unwrap::<CurrentUserData>(include_str!("queries/CurrentUser.gql"))
+            .await;
+        match response {
+            Ok(data) => data.user.is_some(),
+            Err(_) => false,
+        }
+    }
+
     pub async fn create_login_session(&self) -> Result<CreateLoginSessionPayload> {
         let response = self
             .unauthenticated_gql_client

src/cli/auth.rs

@@ -1,10 +1,18 @@
 use std::time::Duration;
 
-use crate::{api_client::CodSpeedAPIClient, config::CodSpeedConfig, prelude::*};
+use crate::api_client::{CodSpeedAPIClient, GetRepositoryVars};
+use crate::cli::run::helpers::{
+    ParsedRepository, find_repository_root, parse_repository_from_remote,
+};
+use crate::config::CodSpeedConfig;
+use crate::prelude::*;
 use clap::{Args, Subcommand};
 use console::style;
+use git2::Repository;
 use tokio::time::{Instant, sleep};
 
+use super::status::{check_mark, cross_mark};
+
 #[derive(Debug, Args)]
 pub struct AuthArgs {
     #[command(subcommand)]
@@ -15,6 +23,8 @@ pub struct AuthArgs {
 enum AuthCommands {
     /// Login to CodSpeed
     Login,
+    /// Show the authentication status
+    Status,
 }
 
 pub async fn run(
@@ -24,6 +34,7 @@ pub async fn run(
 ) -> Result<()> {
     match args.command {
         AuthCommands::Login => login(api_client, config_name).await?,
+        AuthCommands::Status => status(api_client).await?,
     }
     Ok(())
 }
@@ -80,3 +91,92 @@ async fn login(api_client: &CodSpeedAPIClient, config_name: Option<&str>) -> Res
 
     Ok(())
 }
+
+/// Detect the repository from the git remote of the current directory
+fn detect_repository() -> Option<ParsedRepository> {
+    let current_dir = std::env::current_dir().ok()?;
+    let root_path = find_repository_root(&current_dir)?;
+    let git_repository = Repository::open(&root_path).ok()?;
+    let remote = git_repository.find_remote("origin").ok()?;
+    let url = remote.url()?;
+    parse_repository_from_remote(url).ok()
+}
+
+fn provider_label(provider: &crate::run_environment::RepositoryProvider) -> &'static str {
+    match provider {
+        crate::run_environment::RepositoryProvider::GitHub => "GitHub",
+        crate::run_environment::RepositoryProvider::GitLab => "GitLab",
+        crate::run_environment::RepositoryProvider::Project => "Project",
+    }
+}
+
+pub async fn status(api_client: &CodSpeedAPIClient) -> Result<()> {
+    let config = CodSpeedConfig::load_with_override(None, None)?;
+    let has_token = config.auth.token.is_some();
+    let detected_repo = detect_repository();
+
+    // 1. Check token validity
+    let token_valid = has_token && api_client.is_token_valid().await;
+
+    info!("{}", style("Authentication").bold());
+    if token_valid {
+        info!("  {} Logged in", check_mark());
+    } else if has_token {
+        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!("");
+
+    // 2. If token is valid and we detected a repo, check repository existence
+    info!("{}", style("Repository").bold());
+    match detected_repo {
+        Some(parsed) => {
+            let label = provider_label(&parsed.provider);
+            if token_valid {
+                let repo_exists = api_client
+                    .get_repository(GetRepositoryVars {
+                        owner: parsed.owner.clone(),
+                        name: parsed.name.clone(),
+                        provider: parsed.provider.clone(),
+                    })
+                    .await
+                    .ok()
+                    .flatten()
+                    .is_some();
+                if repo_exists {
+                    info!(
+                        "  {} {}/{} ({})",
+                        check_mark(),
+                        parsed.owner,
+                        parsed.name,
+                        label
+                    );
+                } else {
+                    info!(
+                        "  {} {}/{} ({}, not found on CodSpeed)",
+                        cross_mark(),
+                        parsed.owner,
+                        parsed.name,
+                        label
+                    );
+                }
+            } else {
+                info!("  {}/{} ({})", parsed.owner, parsed.name, label);
+            }
+        }
+        None => {
+            info!("  Not inside a git repository");
+        }
+    }
+
+    Ok(())
+}

src/cli/mod.rs

@@ -4,6 +4,7 @@ pub(crate) mod run;
 mod setup;
 mod shared;
 mod show;
+mod status;
 mod update;
 mod use_mode;
 
@@ -85,7 +86,9 @@ enum Commands {
     /// Manage the CLI authentication state
     Auth(auth::AuthArgs),
     /// Pre-install the codspeed executors
-    Setup,
+    Setup(setup::SetupArgs),
+    /// Show the overall status of CodSpeed (authentication, tools, system)
+    Status,
     /// 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`
@@ -142,7 +145,8 @@ 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, setup_cache_dir).await?,
+        Commands::Status => status::run(&api_client).await?,
         Commands::Use(args) => use_mode::run(args)?,
         Commands::Show => show::run()?,
         Commands::Update => update::run().await?,
@@ -160,7 +164,7 @@ impl Cli {
             config_name: None,
             config: None,
             setup_cache_dir: None,
-            command: Commands::Setup,
+            command: Commands::Setup(setup::SetupArgs::default()),
         }
     }
 }

src/cli/run/helpers/find_repository_root.rs

@@ -25,8 +25,6 @@ fn _find_repository_root(base_dir: &Path) -> Option<PathBuf> {
         }
     }
 
-    log::warn!("Could not find repository root");
-
     None
 }
 

src/cli/setup.rs

@@ -1,9 +1,35 @@
-use crate::executor::get_all_executors;
+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<()> {
+use super::status::{check_mark, cross_mark, warn_mark};
+
+#[derive(Debug, Default, Args)]
+pub struct SetupArgs {
+    #[command(subcommand)]
+    command: Option<SetupCommands>,
+}
+
+#[derive(Debug, Subcommand)]
+enum SetupCommands {
+    /// Show the installation status of CodSpeed tools
+    Status,
+}
+
+pub async fn run(args: SetupArgs, setup_cache_dir: Option<&Path>) -> Result<()> {
+    match args.command {
+        None => setup(setup_cache_dir).await,
+        Some(SetupCommands::Status) => {
+            status();
+            Ok(())
+        }
+    }
+}
+
+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 +44,31 @@ pub async fn setup(setup_cache_dir: Option<&Path>) -> Result<()> {
     end_group!();
     Ok(())
 }
+
+pub fn status() {
+    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
+                );
+            }
+        }
+    }
+}

src/cli/status.rs

@@ -0,0 +1,42 @@
+use crate::VERSION;
+use crate::api_client::CodSpeedAPIClient;
+use crate::prelude::*;
+use crate::system::SystemInfo;
+use console::style;
+
+pub fn check_mark() -> console::StyledObject<&'static str> {
+    style("✓").green()
+}
+
+pub fn cross_mark() -> console::StyledObject<&'static str> {
+    style("✗").red()
+}
+
+pub fn warn_mark() -> console::StyledObject<&'static str> {
+    style("!").yellow()
+}
+
+pub async fn run(api_client: &CodSpeedAPIClient) -> Result<()> {
+    // Auth status
+    super::auth::status(api_client).await?;
+    info!("");
+
+    // Setup/tools status
+    super::setup::status();
+    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(())
+}

src/executor/memory/executor.rs

@@ -1,5 +1,5 @@
-use crate::binary_installer::ensure_binary_installed;
 use crate::executor::ExecutorName;
+use crate::executor::ToolStatus;
 use crate::executor::helpers::command::CommandBuilder;
 use crate::executor::helpers::env::get_base_injected_env;
 use crate::executor::helpers::get_bench_command::get_bench_command;
@@ -26,8 +26,7 @@ use std::rc::Rc;
 use tempfile::NamedTempFile;
 use tokio::time::{Duration, timeout};
 
-const MEMTRACK_COMMAND: &str = "codspeed-memtrack";
-const MEMTRACK_CODSPEED_VERSION: &str = "1.2.3";
+use super::setup::{MEMTRACK_COMMAND, get_memtrack_status, install_memtrack};
 
 pub struct MemoryExecutor;
 
@@ -73,23 +72,16 @@ impl Executor for MemoryExecutor {
         ExecutorName::Memory
     }
 
+    fn tool_status(&self) -> ToolStatus {
+        get_memtrack_status()
+    }
+
     async fn setup(
         &self,
         _system_info: &SystemInfo,
         _setup_cache_dir: Option<&Path>,
     ) -> Result<()> {
-        let get_memtrack_installer_url = || {
-            format!(
-                "https://github.com/CodSpeedHQ/codspeed/releases/download/memtrack-v{MEMTRACK_CODSPEED_VERSION}/memtrack-installer.sh"
-            )
-        };
-
-        ensure_binary_installed(
-            MEMTRACK_COMMAND,
-            MEMTRACK_CODSPEED_VERSION,
-            get_memtrack_installer_url,
-        )
-        .await
+        install_memtrack().await
     }
 
     async fn run(

src/executor/memory/mod.rs

@@ -1 +1,2 @@
 pub mod executor;
+pub(crate) mod setup;