feat: add profile-based auth configuration

Author: art049

src/cli/auth.rs

@@ -39,10 +39,13 @@ pub async fn run(
     args: AuthArgs,
     api_client: &CodSpeedAPIClient,
     config_name: Option<&str>,
+    profile_name: &str,
 ) -> Result<()> {
     match args.command {
-        AuthCommands::Login { with_token } => login(api_client, config_name, with_token).await?,
-        AuthCommands::Status => status(api_client).await?,
+        AuthCommands::Login { with_token } => {
+            login(api_client, config_name, profile_name, with_token).await?
+        }
+        AuthCommands::Status => status(api_client, config_name, profile_name).await?,
     }
     Ok(())
 }
@@ -52,6 +55,7 @@ const LOGIN_SESSION_MAX_DURATION: Duration = Duration::from_secs(60 * 5); // 5 m
 async fn login(
     api_client: &CodSpeedAPIClient,
     config_name: Option<&str>,
+    profile_name: &str,
     with_token: bool,
 ) -> Result<()> {
     debug!("Login to CodSpeed");
@@ -119,11 +123,11 @@ async fn login(
         })?;
 
     let mut config = CodSpeedConfig::load_with_override(config_name, None)?;
-    config.auth.token = Some(token);
+    config.profile_mut(profile_name).auth.token = Some(token);
     config.persist(config_name)?;
     debug!("Token saved to configuration file");
 
-    info!("Login successful, your are now authenticated on CodSpeed");
+    info!("Login successful, your are now authenticated on CodSpeed profile `{profile_name}`");
 
     Ok(())
 }
@@ -147,9 +151,16 @@ struct AuthStatus {
     detected_repository: Option<(ParsedRepository, Option<RepositoryOverviewPayload>)>,
 }
 
-pub async fn status(api_client: &CodSpeedAPIClient) -> Result<()> {
-    let config = CodSpeedConfig::load_with_override(None, None)?;
-    let has_token = config.auth.token.is_some();
+pub async fn status(
+    api_client: &CodSpeedAPIClient,
+    config_name: Option<&str>,
+    profile_name: &str,
+) -> Result<()> {
+    let config = CodSpeedConfig::load_with_override(config_name, None)?;
+    let has_token = config
+        .profile(profile_name)
+        .and_then(|profile| profile.auth.token.as_ref())
+        .is_some();
     let parsed = detect_repository();
 
     let auth_status = if has_token {
@@ -161,7 +172,7 @@ pub async fn status(api_client: &CodSpeedAPIClient) -> Result<()> {
         }
     };
 
-    info!("{}", style("Authentication").bold());
+    info!("{} ({profile_name})", style("Authentication").bold());
     print_authentication_section(has_token, auth_status.session.as_ref());
     info!("");
 

src/cli/exec/mod.rs

@@ -1,7 +1,8 @@
 use super::ExecAndRunSharedArgs;
 use crate::api_client::CodSpeedAPIClient;
+use crate::config::ResolvedProfileConfig;
 use crate::executor;
-use crate::executor::config::{self, OrchestratorConfig, RepositoryOverride};
+use crate::executor::config::{OrchestratorConfig, RepositoryOverride};
 use crate::instruments::Instruments;
 use crate::prelude::*;
 use crate::project_config::ProjectConfig;
@@ -55,12 +56,13 @@ fn build_orchestrator_config(
     args: ExecArgs,
     target: executor::BenchmarkTarget,
     poll_results_options: PollResultsOptions,
+    resolved_profile: &ResolvedProfileConfig,
 ) -> Result<OrchestratorConfig> {
     let modes = args.shared.resolve_modes()?;
     let raw_upload_url = args
         .shared
         .upload_url
-        .unwrap_or_else(|| config::DEFAULT_UPLOAD_URL.into());
+        .unwrap_or_else(|| resolved_profile.upload_url.clone());
     let upload_url = Url::parse(&raw_upload_url)
         .map_err(|e| anyhow!("Invalid upload URL: {raw_upload_url}, {e}"))?;
 
@@ -94,6 +96,7 @@ fn build_orchestrator_config(
 pub async fn run(
     args: ExecArgs,
     api_client: &mut CodSpeedAPIClient,
+    resolved_profile: &ResolvedProfileConfig,
     project_config: Option<&ProjectConfig>,
     setup_cache_dir: Option<&Path>,
 ) -> Result<()> {
@@ -108,6 +111,7 @@ pub async fn run(
         merged_args,
         target,
         PollResultsOptions::new(false, base_run_id),
+        resolved_profile,
     )?;
 
     execute_config(config, api_client, setup_cache_dir).await

src/cli/mod.rs

@@ -1,6 +1,7 @@
 mod auth;
 pub(crate) mod exec;
 pub(crate) mod experimental;
+mod profile;
 pub(crate) mod run;
 pub(crate) mod samply;
 mod setup;
@@ -16,7 +17,7 @@ use std::path::PathBuf;
 
 use crate::{
     api_client::CodSpeedAPIClient,
-    config::CodSpeedConfig,
+    config::{CodSpeedConfig, ResolvedProfileConfig},
     executor::helpers::command::CommandBuilder,
     local_logger::{CODSPEED_U8_COLOR_CODE, init_local_logger},
     prelude::*,
@@ -41,14 +42,8 @@ fn create_styles() -> Styles {
 #[command(version, about = "The CodSpeed CLI tool", styles = create_styles())]
 pub struct Cli {
     /// The URL of the CodSpeed GraphQL API
-    #[arg(
-        long,
-        env = "CODSPEED_API_URL",
-        global = true,
-        hide = true,
-        default_value = "https://gql.codspeed.io/"
-    )]
-    pub api_url: String,
+    #[arg(long, env = "CODSPEED_API_URL", global = true, hide = true)]
+    pub api_url: Option<String>,
 
     /// The OAuth token to use for all requests
     #[arg(long, env = "CODSPEED_OAUTH_TOKEN", global = true, hide = true)]
@@ -60,6 +55,10 @@ pub struct Cli {
     #[arg(long, env = "CODSPEED_CONFIG_NAME", global = true)]
     pub config_name: Option<String>,
 
+    /// The CodSpeed profile to use
+    #[arg(long, env = "CODSPEED_PROFILE", global = true)]
+    pub profile: Option<String>,
+
     /// Path to project configuration file (codspeed.yaml)
     /// If provided, loads config from this path. Otherwise, searches for config files
     /// in the current directory and upward to the git root.
@@ -88,6 +87,8 @@ enum Commands {
     Exec(Box<exec::ExecArgs>),
     /// Manage the CLI authentication state
     Auth(auth::AuthArgs),
+    /// Manage CodSpeed profiles
+    Profile(profile::ProfileArgs),
     /// Pre-install the codspeed executors
     Setup(setup::SetupArgs),
     /// Show the overall status of CodSpeed (authentication, tools, system)
@@ -130,7 +131,8 @@ impl InternalCommands {
 
 pub async fn run() -> Result<()> {
     let cli = Cli::parse();
-    let mut api_client = build_api_client(&cli)?;
+    let resolved_profile = resolve_profile_config(&cli)?;
+    let mut api_client = build_api_client(&cli, &resolved_profile);
 
     // Discover project configuration file
     let discovered_config = DiscoveredProjectConfig::discover_and_load(
@@ -158,6 +160,7 @@ pub async fn run() -> Result<()> {
             run::run(
                 *args,
                 &mut api_client,
+                &resolved_profile,
                 discovered_config.as_ref(),
                 setup_cache_dir,
             )
@@ -168,14 +171,33 @@ pub async fn run() -> Result<()> {
             exec::run(
                 *args,
                 &mut api_client,
+                &resolved_profile,
                 discovered_config.as_ref().map(|d| &d.config),
                 setup_cache_dir,
             )
             .await?
         }
-        Commands::Auth(args) => auth::run(args, &api_client, cli.config_name.as_deref()).await?,
+        Commands::Auth(args) => {
+            auth::run(
+                args,
+                &api_client,
+                cli.config_name.as_deref(),
+                &resolved_profile.name,
+            )
+            .await?
+        }
+        Commands::Profile(args) => {
+            profile::run(args, cli.config_name.as_deref(), cli.profile.as_deref())?
+        }
         Commands::Setup(args) => setup::run(args, setup_cache_dir).await?,
-        Commands::Status => status::run(&api_client).await?,
+        Commands::Status => {
+            status::run(
+                &api_client,
+                cli.config_name.as_deref(),
+                &resolved_profile.name,
+            )
+            .await?
+        }
         Commands::Use(args) => use_mode::run(args)?,
         Commands::Show => show::run()?,
         Commands::Update => update::run().await?,
@@ -193,28 +215,35 @@ pub async fn run() -> Result<()> {
 /// Priority (most specific first):
 ///   1. `--token` / `CODSPEED_TOKEN`           — run/exec-level override
 ///   2. `--oauth-token` / `CODSPEED_OAUTH_TOKEN` and the persisted CLI
-///      token — both live on disk and are loaded together by
-///      [`CodSpeedConfig::load_with_override`].
-///
-/// The CLI config file is only read when no explicit token was passed,
-/// so an invocation like `codspeed run --token <X>` never touches the
-/// user's `~/.config/codspeed/`.
-fn build_api_client(cli: &Cli) -> Result<CodSpeedAPIClient> {
+///      token from the selected profile.
+fn resolve_profile_config(cli: &Cli) -> Result<ResolvedProfileConfig> {
+    let config = CodSpeedConfig::load_with_override(cli.config_name.as_deref(), None)?;
+    if matches!(&cli.command, Commands::Auth(_) | Commands::Profile(_)) {
+        Ok(config.resolve_profile_or_default(
+            cli.profile.as_deref(),
+            cli.oauth_token.as_deref(),
+            cli.api_url.as_deref(),
+            None,
+        ))
+    } else {
+        config.resolve_profile(
+            cli.profile.as_deref(),
+            cli.oauth_token.as_deref(),
+            cli.api_url.as_deref(),
+            None,
+        )
+    }
+}
+
+fn build_api_client(cli: &Cli, resolved_profile: &ResolvedProfileConfig) -> CodSpeedAPIClient {
     let explicit = match &cli.command {
         Commands::Run(args) => args.shared.token.clone(),
         Commands::Exec(args) => args.shared.token.clone(),
         _ => None,
     };
     let token = match explicit {
         Some(token) => Some(token),
-        None => {
-            CodSpeedConfig::load_with_override(
-                cli.config_name.as_deref(),
-                cli.oauth_token.as_deref(),
-            )?
-            .auth
-            .token
-        }
+        None => resolved_profile.auth.token.clone(),
     };
-    Ok(CodSpeedAPIClient::new(token, cli.api_url.clone()))
+    CodSpeedAPIClient::new(token, resolved_profile.api_url.clone())
 }

src/cli/profile.rs

@@ -0,0 +1,129 @@
+use crate::config::CodSpeedConfig;
+use crate::prelude::*;
+use clap::{Args, Subcommand};
+use console::style;
+
+#[derive(Debug, Args)]
+pub struct ProfileArgs {
+    #[command(subcommand)]
+    command: ProfileCommands,
+}
+
+#[derive(Debug, Subcommand)]
+enum ProfileCommands {
+    /// List configured profiles
+    List,
+    /// Show a profile
+    Show {
+        /// Profile name. Defaults to the configured default profile.
+        name: Option<String>,
+    },
+    /// Set profile URLs, creating the profile if it does not exist
+    Set {
+        /// Profile name
+        name: String,
+        /// The URL of the CodSpeed GraphQL API
+        #[arg(long)]
+        api_url: Option<String>,
+        /// The URL to use for uploading results
+        #[arg(long)]
+        upload_url: Option<String>,
+    },
+    /// Use this profile by default for future commands
+    Use {
+        /// Profile name
+        name: String,
+    },
+}
+
+pub fn run(
+    args: ProfileArgs,
+    config_name: Option<&str>,
+    selected_profile: Option<&str>,
+) -> Result<()> {
+    match args.command {
+        ProfileCommands::List => list(config_name),
+        ProfileCommands::Show { name } => show(config_name, name.as_deref().or(selected_profile)),
+        ProfileCommands::Set {
+            name,
+            api_url,
+            upload_url,
+        } => set(config_name, &name, api_url, upload_url),
+        ProfileCommands::Use { name } => use_profile(config_name, &name),
+    }
+}
+
+fn list(config_name: Option<&str>) -> Result<()> {
+    let config = CodSpeedConfig::load_with_override(config_name, None)?;
+
+    info!("{}", style("Profiles").bold());
+    for name in config.profiles.keys() {
+        let marker = if name == &config.default_profile {
+            "*"
+        } else {
+            " "
+        };
+        info!("  {marker} {name}");
+    }
+
+    Ok(())
+}
+
+fn show(config_name: Option<&str>, profile_name: Option<&str>) -> Result<()> {
+    let config = CodSpeedConfig::load_with_override(config_name, None)?;
+    let name = profile_name.unwrap_or(&config.default_profile);
+    let resolved = config.resolve_profile(Some(name), None, None, None)?;
+    let profile = config.profile(name).ok_or_else(|| {
+        anyhow!("CodSpeed profile `{name}` does not exist. Run `codspeed profile set {name}` to create it.")
+    })?;
+
+    info!("{} ({})", style("Profile").bold(), resolved.name);
+    info!("  api url: {}", resolved.api_url);
+    info!("  upload url: {}", resolved.upload_url);
+    info!(
+        "  authenticated: {}",
+        if profile.auth.token.is_some() {
+            "yes"
+        } else {
+            "no"
+        }
+    );
+
+    Ok(())
+}
+
+fn set(
+    config_name: Option<&str>,
+    profile_name: &str,
+    api_url: Option<String>,
+    upload_url: Option<String>,
+) -> Result<()> {
+    let mut config = CodSpeedConfig::load_with_override(config_name, None)?;
+    let profile = config.profile_mut(profile_name);
+
+    if let Some(api_url) = api_url {
+        profile.api_url = Some(api_url);
+    }
+    if let Some(upload_url) = upload_url {
+        profile.upload_url = Some(upload_url);
+    }
+
+    config.persist(config_name)?;
+    info!("Profile `{profile_name}` saved");
+
+    Ok(())
+}
+
+fn use_profile(config_name: Option<&str>, profile_name: &str) -> Result<()> {
+    let mut config = CodSpeedConfig::load_with_override(config_name, None)?;
+    ensure!(
+        config.profile(profile_name).is_some(),
+        "CodSpeed profile `{profile_name}` does not exist. Run `codspeed profile set {profile_name}` to create it."
+    );
+
+    config.default_profile = profile_name.to_owned();
+    config.persist(config_name)?;
+    info!("Default CodSpeed profile set to `{profile_name}`");
+
+    Ok(())
+}