feat(cli): add profile system with versioned config

Introduce named profiles in the CodSpeed CLI config. Each profile carries
its own auth token plus optional api-url/upload-url overrides. Profile
selection at runtime follows: `--profile` / `CODSPEED_PROFILE` env var,
then a per-shell-session selection registered by `codspeed profile use`
(parent-PID keyed file under `$XDG_RUNTIME_DIR/codspeed_profile`, mirroring
how `codspeed use <mode>` works), then the built-in `default` profile.
There is no globally persisted default profile.

The on-disk config gains a `version: 1` schema field. A private
`RawConfig` deserialisation type and a `migrate` function are the only
place legacy YAML shapes are mentioned; when migration is needed the
canonical form is rewritten to disk immediately so the rest of the app
only ever sees the clean shape. Today this folds the legacy top-level
`auth.token` into `profiles.default`.

`CodSpeedConfig` is split: a private `PersistedConfig` is the on-disk
shape (version + profiles), and `CodSpeedConfig` wraps it with the
runtime-resolved auth/URLs/selected_profile. `persist` writes only the
persisted half, so runtime overrides (e.g. `CODSPEED_OAUTH_TOKEN`) can
never leak to disk.

The parent-PID shell-session machinery used by `codspeed use <mode>` is
extracted into a generic `shell_session_store` module so profile and
runner-mode share the same implementation. `src/runner_mode/` is
flattened into `src/runner_mode.rs` now that the sub-file is gone.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: art049

src/cli/auth.rs

@@ -39,10 +39,13 @@ pub async fn run(
     args: AuthArgs,
     api_client: &CodSpeedAPIClient,
     config_name: Option<&str>,
+    config: CodSpeedConfig,
 ) -> 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, config, with_token).await?
+        }
+        AuthCommands::Status => status(api_client, &config).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>,
+    mut config: CodSpeedConfig,
     with_token: bool,
 ) -> Result<()> {
     debug!("Login to CodSpeed");
@@ -118,12 +122,15 @@ async fn login(
             SessionError::Other(err) => err,
         })?;
 
-    let mut config = CodSpeedConfig::load_with_override(config_name, None)?;
-    config.auth.token = Some(token);
+    let selected = config.selected_profile_name().to_owned();
+    config.profile_mut(&selected).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, you are now authenticated on CodSpeed (profile: {})",
+        config.selected_profile_name()
+    );
 
     Ok(())
 }
@@ -147,8 +154,7 @@ struct AuthStatus {
     detected_repository: Option<(ParsedRepository, Option<RepositoryOverviewPayload>)>,
 }
 
-pub async fn status(api_client: &CodSpeedAPIClient) -> Result<()> {
-    let config = CodSpeedConfig::load_with_override(None, None)?;
+pub async fn status(api_client: &CodSpeedAPIClient, config: &CodSpeedConfig) -> Result<()> {
     let has_token = config.auth.token.is_some();
     let parsed = detect_repository();
 
@@ -161,7 +167,11 @@ pub async fn status(api_client: &CodSpeedAPIClient) -> Result<()> {
         }
     };
 
-    info!("{}", style("Authentication").bold());
+    info!(
+        "{} (profile: {})",
+        style("Authentication").bold(),
+        config.selected_profile_name()
+    );
     print_authentication_section(has_token, auth_status.session.as_ref());
     info!("");
 

src/cli/exec/mod.rs

@@ -1,7 +1,7 @@
 use super::ExecAndRunSharedArgs;
 use crate::api_client::CodSpeedAPIClient;
 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;
@@ -60,7 +60,7 @@ fn build_orchestrator_config(
     let raw_upload_url = args
         .shared
         .upload_url
-        .unwrap_or_else(|| config::DEFAULT_UPLOAD_URL.into());
+        .unwrap_or_else(|| crate::config::DEFAULT_UPLOAD_URL.into());
     let upload_url = Url::parse(&raw_upload_url)
         .map_err(|e| anyhow!("Invalid upload URL: {raw_upload_url}, {e}"))?;
 

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;
@@ -41,25 +42,23 @@ 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)]
     pub oauth_token: Option<String>,
 
-    /// The configuration name to use
-    /// If provided, the configuration will be loaded from ~/.config/codspeed/{config-name}.yaml
-    /// Otherwise, loads from ~/.config/codspeed/config.yaml
-    #[arg(long, env = "CODSPEED_CONFIG_NAME", global = true)]
+    /// [deprecated] Load configuration from `~/.config/codspeed/{config-name}.yaml`
+    /// instead of the default `config.yaml`. Prefer `--profile` instead.
+    #[arg(long, env = "CODSPEED_CONFIG_NAME", global = true, hide = true)]
+    #[deprecated(note = "use `--profile` / `CODSPEED_PROFILE` instead")]
     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 codspeed_config = load_config(&cli)?;
+    let mut api_client = build_api_client(&cli, &codspeed_config);
 
     // Discover project configuration file
     let discovered_config = DiscoveredProjectConfig::discover_and_load(
@@ -154,28 +156,45 @@ pub async fn run() -> Result<()> {
 
     match cli.command {
         Commands::Run(args) => {
+            let mut args = *args;
+            args.shared
+                .upload_url
+                .get_or_insert_with(|| codspeed_config.upload_url.clone());
             args.shared.experimental.warn_if_active();
             run::run(
-                *args,
+                args,
                 &mut api_client,
                 discovered_config.as_ref(),
                 setup_cache_dir,
             )
             .await?
         }
         Commands::Exec(args) => {
+            let mut args = *args;
+            args.shared
+                .upload_url
+                .get_or_insert_with(|| codspeed_config.upload_url.clone());
             args.shared.experimental.warn_if_active();
             exec::run(
-                *args,
+                args,
                 &mut api_client,
                 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) => {
+            #[allow(deprecated)]
+            let config_name = cli.config_name.as_deref();
+            auth::run(args, &api_client, config_name, codspeed_config).await?
+        }
+        Commands::Profile(args) => {
+            #[allow(deprecated)]
+            let config_name = cli.config_name.as_deref();
+            profile::run(args, config_name, 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, &codspeed_config).await?,
         Commands::Use(args) => use_mode::run(args)?,
         Commands::Show => show::run()?,
         Commands::Update => update::run().await?,
@@ -184,6 +203,32 @@ pub async fn run() -> Result<()> {
     Ok(())
 }
 
+/// Load the CodSpeed config for this invocation, resolving the active
+/// profile (CLI `--profile` / `CODSPEED_PROFILE` / shell-session / built-in
+/// `default`) and applying CLI overrides for the OAuth token and api URL.
+///
+/// `auth` and `profile` subcommands are allowed to run against a config
+/// where the selected profile does not yet exist (e.g. first-time setup).
+fn load_config(cli: &Cli) -> Result<CodSpeedConfig> {
+    // The field carries a `#[deprecated]` marker but we still need to
+    // honour it during the deprecation window.
+    #[allow(deprecated)]
+    let config_name = cli.config_name.as_deref();
+    if config_name.is_some() {
+        warn!(
+            "`--config-name` / `CODSPEED_CONFIG_NAME` is deprecated; use `--profile` / `CODSPEED_PROFILE` instead."
+        );
+    }
+    CodSpeedConfig::load_with_profile(
+        config_name,
+        cli.profile.as_deref(),
+        cli.oauth_token.as_deref(),
+        cli.api_url.as_deref(),
+        None,
+        matches!(&cli.command, Commands::Auth(_) | Commands::Profile(_)),
+    )
+}
+
 /// Build the api client for this invocation, resolving the auth token
 /// from the most specific source available. This is the single source
 /// of truth for token resolution; the result lives on the returned
@@ -193,28 +238,16 @@ 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 build_api_client(cli: &Cli, config: &CodSpeedConfig) -> 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 => config.auth.token.clone(),
     };
-    Ok(CodSpeedAPIClient::new(token, cli.api_url.clone()))
+    CodSpeedAPIClient::new(token, config.api_url.clone())
 }

src/cli/profile.rs

@@ -0,0 +1,129 @@
+use crate::config::{CodSpeedConfig, load_shell_session_profile, register_shell_session_profile};
+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>,
+    },
+    /// Set the active profile for the current shell session
+    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)?;
+    let active = load_shell_session_profile()?;
+
+    info!("{}", style("Profiles").bold());
+    for name in config.profiles().keys() {
+        let marker = if Some(name) == active.as_ref() {
+            "*"
+        } else {
+            " "
+        };
+        info!("  {marker} {name}");
+    }
+
+    Ok(())
+}
+
+fn show(config_name: Option<&str>, profile_name: Option<&str>) -> Result<()> {
+    let config =
+        CodSpeedConfig::load_with_profile(config_name, profile_name, None, None, None, false)?;
+
+    info!(
+        "{} ({})",
+        style("Profile").bold(),
+        config.selected_profile_name()
+    );
+    info!("  api url: {}", config.api_url);
+    info!("  upload url: {}", config.upload_url);
+    info!(
+        "  authenticated: {}",
+        if config.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 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."
+    );
+
+    register_shell_session_profile(profile_name)?;
+    info!("Active CodSpeed profile set to `{profile_name}` for this shell session");
+
+    Ok(())
+}