feat: implement codspeed use to set mode for shell session

Author: GuillaumeLagrange

src/cli/mod.rs

@@ -3,6 +3,7 @@ pub(crate) mod exec;
 pub(crate) mod run;
 mod setup;
 mod shared;
+mod use_mode;
 
 pub(crate) use shared::*;
 
@@ -83,6 +84,8 @@ enum Commands {
     Auth(auth::AuthArgs),
     /// Pre-install the codspeed executors
     Setup,
+    /// Set the codspeed mode for the rest of the shell session
+    Use(use_mode::UseArgs),
 }
 
 pub async fn run() -> Result<()> {
@@ -132,6 +135,7 @@ pub async fn run() -> Result<()> {
         }
         Commands::Auth(args) => auth::run(args, &api_client, cli.config_name.as_deref()).await?,
         Commands::Setup => setup::setup(setup_cache_dir).await?,
+        Commands::Use(args) => use_mode::run(args)?,
     }
     Ok(())
 }

src/cli/run/mod.rs

@@ -70,7 +70,7 @@ impl RunArgs {
                 repository: None,
                 provider: None,
                 working_directory: None,
-                mode: RunnerMode::Simulation,
+                mode: Some(RunnerMode::Simulation),
                 profile_folder: None,
                 skip_upload: false,
                 skip_run: false,

src/cli/shared.rs

@@ -1,7 +1,7 @@
 use crate::VERSION;
 use crate::prelude::*;
 use crate::run_environment::interfaces::RepositoryProvider;
-use crate::runner_mode::RunnerMode;
+use crate::runner_mode::{RunnerMode, load_shell_session_mode};
 use clap::Args;
 use clap::ValueEnum;
 use std::path::PathBuf;
@@ -53,8 +53,9 @@ pub struct ExecAndRunSharedArgs {
     pub working_directory: Option<String>,
 
     /// The mode to run the benchmarks in.
+    /// If not provided, the mode will be loaded from the shell session (set via `codspeed use <mode>`).
     #[arg(short, long, value_enum, env = "CODSPEED_RUNNER_MODE")]
-    pub mode: RunnerMode,
+    pub mode: Option<RunnerMode>,
 
     /// Profile folder to use for the run.
     #[arg(long)]
@@ -91,6 +92,29 @@ pub struct ExecAndRunSharedArgs {
     pub perf_run_args: PerfRunArgs,
 }
 
+impl ExecAndRunSharedArgs {
+    /// Resolves the runner mode from CLI argument, shell session, or returns an error.
+    ///
+    /// Priority:
+    /// 1. CLI argument (--mode or -m)
+    /// 2. Shell session mode (set via `codspeed use <mode>`)
+    /// 3. Error if neither is available
+    pub fn resolve_mode(&self) -> Result<RunnerMode> {
+        if let Some(mode) = &self.mode {
+            return Ok(mode.clone());
+        }
+
+        if let Some(mode) = load_shell_session_mode()? {
+            debug!("Loaded mode from shell session: {mode:?}");
+            return Ok(mode);
+        }
+
+        Err(anyhow!(
+            "No runner mode specified. Use --mode <mode> or set the mode for this shell session with `codspeed use <mode>`."
+        ))
+    }
+}
+
 #[derive(Debug, Copy, Clone, PartialEq, ValueEnum, Default)]
 pub enum UnwindingMode {
     /// Use the frame pointer for unwinding. Requires the binary to be compiled with frame pointers enabled.

src/cli/use_mode.rs

@@ -0,0 +1,31 @@
+//! Named like this because `use` is a keyword
+
+use crate::prelude::*;
+use crate::runner_mode::RunnerMode;
+use clap::Args;
+
+#[derive(Debug, Args)]
+pub struct UseArgs {
+    /// Set the CodSpeed runner mode for this shell session. If not provided, the current mode will
+    /// be displayed.
+    pub mode: Option<RunnerMode>,
+}
+
+pub fn run(args: UseArgs) -> Result<()> {
+    if let Some(mode) = &args.mode {
+        crate::runner_mode::register_shell_session_mode(mode)?;
+        debug!(
+            "Registered codspeed use mode '{:?}' for this shell session (parent PID)",
+            args.mode
+        );
+    } else {
+        let shell_session_mode = crate::runner_mode::load_shell_session_mode()?;
+
+        if let Some(mode) = shell_session_mode {
+            info!("{mode:?}");
+        } else {
+            info!("No mode set for this shell session");
+        }
+    }
+    Ok(())
+}

src/executor/config.rs

@@ -100,6 +100,7 @@ impl TryFrom<RunArgs> for Config {
     type Error = Error;
     fn try_from(args: RunArgs) -> Result<Self> {
         let instruments = Instruments::try_from(&args)?;
+        let mode = args.shared.resolve_mode()?;
         let raw_upload_url = args
             .shared
             .upload_url
@@ -116,7 +117,7 @@ impl TryFrom<RunArgs> for Config {
                 .map(|repo| RepositoryOverride::from_arg(repo, args.shared.provider))
                 .transpose()?,
             working_directory: args.shared.working_directory,
-            mode: args.shared.mode,
+            mode,
             instruments,
             perf_unwinding_mode: args.shared.perf_run_args.perf_unwinding_mode,
             enable_perf: args.shared.perf_run_args.enable_perf,
@@ -137,6 +138,7 @@ impl Config {
         args: crate::cli::exec::ExecArgs,
         command: String,
     ) -> Result<Self> {
+        let mode = args.shared.resolve_mode()?;
         let raw_upload_url = args
             .shared
             .upload_url
@@ -153,7 +155,7 @@ impl Config {
                 .map(|repo| RepositoryOverride::from_arg(repo, args.shared.provider))
                 .transpose()?,
             working_directory: args.shared.working_directory,
-            mode: args.shared.mode,
+            mode,
             instruments: Instruments { mongodb: None }, // exec doesn't support MongoDB
             perf_unwinding_mode: args.shared.perf_run_args.perf_unwinding_mode,
             enable_perf: args.shared.perf_run_args.enable_perf,
@@ -192,7 +194,7 @@ mod tests {
                 repository: None,
                 provider: None,
                 working_directory: None,
-                mode: RunnerMode::Simulation,
+                mode: Some(RunnerMode::Simulation),
                 profile_folder: None,
                 skip_upload: false,
                 skip_run: false,
@@ -231,7 +233,7 @@ mod tests {
                 repository: Some("owner/repo".into()),
                 provider: Some(RepositoryProvider::GitLab),
                 working_directory: Some("/tmp".into()),
-                mode: RunnerMode::Simulation,
+                mode: Some(RunnerMode::Simulation),
                 profile_folder: Some("./codspeed.out".into()),
                 skip_upload: true,
                 skip_run: true,
@@ -314,7 +316,7 @@ mod tests {
                 repository: None,
                 provider: None,
                 working_directory: None,
-                mode: RunnerMode::Simulation,
+                mode: Some(RunnerMode::Simulation),
                 profile_folder: None,
                 skip_upload: false,
                 skip_run: false,

src/project_config/merger.rs

@@ -52,11 +52,6 @@ impl ConfigMerger {
             }
         }
 
-        // Note: mode field has a required default value from clap, so we can't
-        // distinguish between "user set it" vs "default value". For now, we
-        // always use the CLI value. This will be addressed in a future PR
-        // when we make mode optional in CLI args.
-
         merged
     }
 
@@ -157,7 +152,7 @@ mod tests {
             repository: None,
             provider: None,
             working_directory: Some("./cli-dir".to_string()),
-            mode: RunnerMode::Walltime,
+            mode: Some(RunnerMode::Walltime),
             profile_folder: None,
             skip_upload: false,
             skip_run: false,
@@ -189,7 +184,7 @@ mod tests {
             repository: None,
             provider: None,
             working_directory: None,
-            mode: RunnerMode::Walltime,
+            mode: Some(RunnerMode::Walltime),
             profile_folder: None,
             skip_upload: false,
             skip_run: false,
@@ -211,8 +206,8 @@ mod tests {
 
         // Config working_directory should be used
         assert_eq!(merged.working_directory, Some("./config-dir".to_string()));
-        // Mode stays as CLI default (can't override due to clap default)
-        assert_eq!(merged.mode, RunnerMode::Walltime);
+        // Mode stays as CLI value
+        assert_eq!(merged.mode, Some(RunnerMode::Walltime));
     }
 
     #[test]
@@ -223,7 +218,7 @@ mod tests {
             repository: None,
             provider: None,
             working_directory: Some("./dir".to_string()),
-            mode: RunnerMode::Simulation,
+            mode: Some(RunnerMode::Simulation),
             profile_folder: None,
             skip_upload: false,
             skip_run: false,
@@ -240,7 +235,7 @@ mod tests {
 
         // Should be identical to CLI
         assert_eq!(merged.working_directory, Some("./dir".to_string()));
-        assert_eq!(merged.mode, RunnerMode::Simulation);
+        assert_eq!(merged.mode, Some(RunnerMode::Simulation));
     }
 
     #[test]

src/runner_mode.rs src/runner_mode/mod.rssrc/runner_mode.rs renamed to src/runner_mode/mod.rs

@@ -1,5 +1,11 @@
 use clap::ValueEnum;
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
+use serde::Serialize;
+
+mod shell_session;
+
+pub(crate) use shell_session::load_shell_session_mode;
+pub(crate) use shell_session::register_shell_session_mode;
 
 #[derive(ValueEnum, Clone, Debug, Serialize, Deserialize, PartialEq)]
 #[serde(rename_all = "lowercase")]

src/runner_mode/shell_session.rs

@@ -0,0 +1,77 @@
+use super::RunnerMode;
+use crate::prelude::*;
+use libc::pid_t;
+use std::path::Path;
+use std::path::PathBuf;
+use std::sync::OnceLock;
+use sysinfo::Pid;
+use sysinfo::ProcessRefreshKind;
+use sysinfo::RefreshKind;
+use sysinfo::System;
+
+static SYSTEM: OnceLock<System> = OnceLock::new();
+
+/// Get the root directory where the use mode is stored
+/// If available, uses `$XDG_RUNTIME_DIR/codspeed_use_mode`
+/// Otherwise, falls back to `std::env::temp_dir()/codspeed_use_mode`
+fn get_use_mode_root_dir() -> PathBuf {
+    let base_dir = if let Some(xdg_runtime_dir) = std::env::var_os("XDG_RUNTIME_DIR") {
+        PathBuf::from(xdg_runtime_dir)
+    } else {
+        std::env::temp_dir()
+    };
+
+    base_dir.join("codspeed_use_mode")
+}
+
+fn get_parent_pid(pid: pid_t) -> Option<pid_t> {
+    let s = SYSTEM.get_or_init(|| {
+        System::new_with_specifics(
+            RefreshKind::nothing().with_processes(ProcessRefreshKind::nothing()),
+        )
+    });
+
+    let current_pid = Pid::from_u32(pid as u32);
+
+    s.process(current_pid)
+        .and_then(|p| p.parent())
+        .map(|pid| pid.as_u32() as pid_t)
+}
+
+fn get_mode_file_path(base_dir: &Path, pid: pid_t) -> PathBuf {
+    base_dir.join(pid.to_string())
+}
+
+pub(crate) fn register_shell_session_mode(mode: &RunnerMode) -> Result<()> {
+    let use_mode_dir = get_use_mode_root_dir();
+    std::fs::create_dir_all(&use_mode_dir)?;
+
+    let Some(parent_pid) = get_parent_pid(std::process::id() as pid_t) else {
+        return Err(anyhow!("Could not determine parent PID"));
+    };
+
+    let mode_file_path = get_mode_file_path(&use_mode_dir, parent_pid);
+
+    std::fs::write(mode_file_path, serde_json::to_string(mode)?)?;
+    Ok(())
+}
+
+pub(crate) fn load_shell_session_mode() -> Result<Option<RunnerMode>> {
+    // Go up the process tree until we find a registered mode
+    let mut current_pid = std::process::id() as pid_t;
+
+    while let Some(parent_pid) = get_parent_pid(current_pid) {
+        let use_mode_dir = get_use_mode_root_dir();
+        let mode_file_path = get_mode_file_path(&use_mode_dir, parent_pid);
+
+        if mode_file_path.exists() {
+            let mode_str = std::fs::read_to_string(mode_file_path)?;
+            let mode: RunnerMode = serde_json::from_str(&mode_str)?;
+            return Ok(Some(mode));
+        }
+
+        current_pid = parent_pid;
+    }
+
+    Ok(None)
+}