--wip-- [skip ci]

GuillaumeLagrange · GuillaumeLagrange · commit 1a13f5c3013b · 2026-03-18T23:23:06.000+01:00
diff --git a/src/api_client.rs b/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
diff --git a/src/cli/auth.rs b/src/cli/auth.rs
@@ -1,10 +1,16 @@
 use std::time::Duration;
 
-use crate::{api_client::CodSpeedAPIClient, config::CodSpeedConfig, prelude::*};
+use crate::api_client::{CodSpeedAPIClient, GetRepositoryVars};
+use crate::cli::run::helpers::{find_repository_root, parse_repository_from_remote, ParsedRepository};
+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 +21,8 @@ pub struct AuthArgs {
 enum AuthCommands {
     /// Login to CodSpeed
     Login,
+    /// Show the authentication status
+    Status,
 }
 
 pub async fn run(
@@ -24,6 +32,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 +89,86 @@ 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(())
+}
diff --git a/src/cli/mod.rs b/src/cli/mod.rs
@@ -4,6 +4,7 @@ pub(crate) mod run;
 mod setup;
 mod shared;
 mod show;
+mod status;
 mod use_mode;
 
 pub(crate) use shared::*;
@@ -84,7 +85,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`
@@ -137,7 +140,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()?,
     }
@@ -154,7 +158,7 @@ impl Cli {
             config_name: None,
             config: None,
             setup_cache_dir: None,
-            command: Commands::Setup,
+            command: Commands::Setup(setup::SetupArgs::default()),
         }
     }
 }
diff --git a/src/cli/run/helpers/find_repository_root.rs b/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
 }
 
diff --git a/src/cli/run/helpers/parse_git_remote.rs b/src/cli/run/helpers/parse_git_remote.rs
@@ -1,6 +1,8 @@
 use std::sync::LazyLock;
 
-use anyhow::{Result, anyhow};
+use anyhow::{Result, anyhow, bail};
+
+use crate::run_environment::RepositoryProvider;
 
 static REMOTE_REGEX: LazyLock<regex::Regex> = LazyLock::new(|| {
     regex::Regex::new(
@@ -16,6 +18,34 @@ pub struct GitRemote {
     pub repository: String,
 }
 
+/// Parsed repository info including the CodSpeed provider
+#[derive(Debug)]
+pub struct ParsedRepository {
+    pub provider: RepositoryProvider,
+    pub owner: String,
+    pub name: String,
+}
+
+/// Parse a git remote URL and extract the provider, owner, and repository name
+pub fn parse_repository_from_remote(remote_url: &str) -> Result<ParsedRepository> {
+    let GitRemote {
+        domain,
+        owner,
+        repository,
+    } = parse_git_remote(remote_url)?;
+    let provider = match domain.as_str() {
+        "github.com" => RepositoryProvider::GitHub,
+        "gitlab.com" => RepositoryProvider::GitLab,
+        domain => bail!("Repository provider {domain} is not supported by CodSpeed"),
+    };
+
+    Ok(ParsedRepository {
+        provider,
+        owner,
+        name: repository,
+    })
+}
+
 pub fn parse_git_remote(remote: &str) -> Result<GitRemote> {
     let captures = REMOTE_REGEX.captures(remote).ok_or_else(|| {
         anyhow!("Could not extract owner and repository from remote url: {remote}")
@@ -98,4 +128,43 @@ mod tests {
         }
         "###);
     }
+
+    #[test]
+    fn test_parse_repository_from_remote() {
+        use crate::run_environment::RepositoryProvider;
+
+        let remote_urls = [
+            (
+                "git@github.com:CodSpeedHQ/codspeed.git",
+                RepositoryProvider::GitHub,
+                "CodSpeedHQ",
+                "codspeed",
+            ),
+            (
+                "https://github.com/CodSpeedHQ/codspeed.git",
+                RepositoryProvider::GitHub,
+                "CodSpeedHQ",
+                "codspeed",
+            ),
+            (
+                "git@gitlab.com:codspeed/runner.git",
+                RepositoryProvider::GitLab,
+                "codspeed",
+                "runner",
+            ),
+            (
+                "https://gitlab.com/codspeed/runner.git",
+                RepositoryProvider::GitLab,
+                "codspeed",
+                "runner",
+            ),
+        ];
+        for (remote_url, expected_provider, expected_owner, expected_name) in remote_urls.into_iter()
+        {
+            let parsed = parse_repository_from_remote(remote_url).unwrap();
+            assert_eq!(parsed.provider, expected_provider);
+            assert_eq!(parsed.owner, expected_owner);
+            assert_eq!(parsed.name, expected_name);
+        }
+    }
 }
diff --git a/src/cli/setup.rs b/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
+                );
+            }
+        }
+    }
+}
diff --git a/src/cli/status.rs b/src/cli/status.rs
diff --git a/src/queries/CurrentUser.gql b/src/queries/CurrentUser.gql
diff --git a/src/run_environment/local/provider.rs b/src/run_environment/local/provider.rs

Original file line number	Diff line number	Diff line change
`@@ -25,8 +25,6 @@ fn _find_repository_root(base_dir: &Path) -> Option<PathBuf> {`
`25`	`25`	`}`
`26`	`26`	`}`
`27`	`27`
`28`		`- log::warn!("Could not find repository root");`
`29`		`-`
`30`	`28`	`None`
`31`	`29`	`}`
`32`	`30`