feat: add exec subcommand and refactor run subcommand

Refactor aims to extract common behavior between exec and run.
It mostly moves out the run::Config into the executor module, as well
as moving the run_environment module to the root of the repo.

The main aim is to offload the overloaded run module that has outgrown
its initial purpose of a clap subcommand.

Author: GuillaumeLagrange

src/app.rs

@@ -4,6 +4,7 @@ use crate::{
     api_client::CodSpeedAPIClient,
     auth,
     config::CodSpeedConfig,
+    exec,
     local_logger::{CODSPEED_U8_COLOR_CODE, init_local_logger},
     prelude::*,
     run, setup,
@@ -59,8 +60,11 @@ pub struct Cli {
 
 #[derive(Subcommand, Debug)]
 enum Commands {
-    /// Run the bench command and upload the results to CodSpeed
+    /// Run a benchmark program that already contains the CodSpeed instrumentation and upload the results to CodSpeed
     Run(Box<run::RunArgs>),
+    /// Run a command after adding CodSpeed instrumentation to it and upload the results to
+    /// CodSpeed
+    Exec(Box<exec::ExecArgs>),
     /// Manage the CLI authentication state
     Auth(auth::AuthArgs),
     /// Pre-install the codspeed executors
@@ -80,7 +84,7 @@ pub async fn run() -> Result<()> {
     let setup_cache_dir = setup_cache_dir.as_deref();
 
     match cli.command {
-        Commands::Run(_) => {} // Run is responsible for its own logger initialization
+        Commands::Run(_) | Commands::Exec(_) => {} // Run and Exec are responsible for their own logger initialization
         _ => {
             init_local_logger()?;
         }
@@ -90,6 +94,9 @@ pub async fn run() -> Result<()> {
         Commands::Run(args) => {
             run::run(*args, &api_client, &codspeed_config, setup_cache_dir).await?
         }
+        Commands::Exec(args) => {
+            exec::run(*args, &api_client, &codspeed_config, setup_cache_dir).await?
+        }
         Commands::Auth(args) => auth::run(args, &api_client, cli.config_name.as_deref()).await?,
         Commands::Setup => setup::setup(setup_cache_dir).await?,
     }

src/exec/mod.rs

@@ -0,0 +1,72 @@
+use crate::api_client::CodSpeedAPIClient;
+use crate::config::CodSpeedConfig;
+use crate::prelude::*;
+use clap::Args;
+use std::path::Path;
+
+mod run_with_harness;
+use run_with_harness::wrap_command_with_harness;
+
+#[derive(Args, Debug)]
+pub struct ExecArgs {
+    #[command(flatten)]
+    pub shared: crate::run::ExecAndRunSharedArgs,
+
+    /// Optional benchmark name (defaults to command filename)
+    #[arg(long)]
+    pub name: Option<String>,
+
+    /// The command to execute with the exec harness
+    pub command: Vec<String>,
+}
+
+pub async fn run(
+    args: ExecArgs,
+    api_client: &CodSpeedAPIClient,
+    codspeed_config: &CodSpeedConfig,
+    setup_cache_dir: Option<&Path>,
+) -> Result<()> {
+    // Wrap the user's command with exec-harness BEFORE creating config
+    let wrapped_command = wrap_command_with_harness(&args.command, args.name.as_deref())?;
+
+    info!("Executing: {}", wrapped_command.join(" "));
+
+    // Convert ExecArgs to executor::Config using shared args
+    let config = crate::executor::Config {
+        upload_url: args
+            .shared
+            .upload_url
+            .as_ref()
+            .map(|url| url.parse())
+            .transpose()
+            .map_err(|e| anyhow!("Invalid upload URL: {e}"))?
+            .unwrap_or_else(|| {
+                "https://api.codspeed.io/upload"
+                    .parse()
+                    .expect("Default URL should be valid")
+            }),
+        token: args.shared.token,
+        repository_override: args
+            .shared
+            .repository
+            .map(|repo| {
+                crate::executor::config::RepositoryOverride::from_arg(repo, args.shared.provider)
+            })
+            .transpose()?,
+        working_directory: args.shared.working_directory,
+        command: wrapped_command.join(" "), // Use wrapped command
+        mode: args.shared.mode,
+        instruments: crate::instruments::Instruments { mongodb: None }, // exec doesn't support MongoDB
+        enable_perf: args.shared.perf_run_args.enable_perf,
+        perf_unwinding_mode: args.shared.perf_run_args.perf_unwinding_mode,
+        profile_folder: args.shared.profile_folder,
+        skip_upload: args.shared.skip_upload,
+        skip_run: args.shared.skip_run,
+        skip_setup: args.shared.skip_setup,
+        allow_empty: args.shared.allow_empty,
+    };
+
+    // Delegate to shared execution logic
+    crate::executor::execute_benchmarks(config, api_client, codspeed_config, setup_cache_dir, false)
+        .await
+}

src/exec/run_with_harness.rs

@@ -0,0 +1,105 @@
+use crate::prelude::*;
+use std::path::PathBuf;
+
+/// Find the exec-harness binary in the standard locations
+fn find_harness_binary() -> Result<PathBuf> {
+    // Try common locations where the harness might be installed
+    let mut possible_paths = Vec::new();
+
+    // Look in the same directory as the runner binary
+    if let Ok(current_exe) = std::env::current_exe() {
+        if let Some(parent) = current_exe.parent() {
+            possible_paths.push(parent.join("exec-harness"));
+        }
+
+        // Look in cargo target directory (for development)
+        for ancestor in current_exe.ancestors() {
+            if ancestor.ends_with("target") {
+                possible_paths.push(ancestor.join("release").join("exec-harness"));
+                possible_paths.push(ancestor.join("debug").join("exec-harness"));
+                break;
+            }
+        }
+    }
+
+    for path in &possible_paths {
+        if path.exists() && path.is_file() {
+            debug!("Found exec-harness at: {path:?}");
+            return Ok(path.clone());
+        }
+    }
+
+    bail!(
+        "exec-harness binary not found. Please ensure it's built and in the same directory as the runner.\nSearched paths: {possible_paths:?}"
+    )
+}
+
+/// Wraps the user's command with the exec-harness binary
+pub fn wrap_command_with_harness(
+    user_command: &[String],
+    benchmark_name: Option<&str>,
+) -> Result<Vec<String>> {
+    if user_command.is_empty() {
+        bail!("Cannot wrap empty command");
+    }
+
+    let harness_path = find_harness_binary()?;
+    let harness_path_str = harness_path
+        .to_str()
+        .context("exec-harness path contains invalid UTF-8")?;
+
+    let mut wrapped_command = vec![harness_path_str.to_string()];
+
+    // Add --name if provided
+    if let Some(name) = benchmark_name {
+        wrapped_command.push("--name".to_string());
+        wrapped_command.push(name.to_string());
+    }
+
+    // Add -- separator (optional but clearer)
+    wrapped_command.push("--".to_string());
+
+    // Add the user's command
+    wrapped_command.extend_from_slice(user_command);
+
+    debug!("Wrapped command: {wrapped_command:?}");
+    Ok(wrapped_command)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_wrap_command_without_name() {
+        let command = vec!["./my_binary".to_string(), "arg1".to_string()];
+        let wrapped = wrap_command_with_harness(&command, None);
+
+        // We can't test the exact path, but we can verify the structure
+        if let Ok(wrapped) = wrapped {
+            assert!(wrapped[0].contains("exec-harness"));
+            assert_eq!(wrapped[wrapped.len() - 2], "./my_binary");
+            assert_eq!(wrapped[wrapped.len() - 1], "arg1");
+        }
+    }
+
+    #[test]
+    fn test_wrap_command_with_name() {
+        let command = vec!["./my_binary".to_string()];
+        let wrapped = wrap_command_with_harness(&command, Some("custom_name"));
+
+        if let Ok(wrapped) = wrapped {
+            assert!(wrapped[0].contains("exec-harness"));
+            assert!(wrapped.contains(&"--name".to_string()));
+            assert!(wrapped.contains(&"custom_name".to_string()));
+            assert_eq!(wrapped[wrapped.len() - 1], "./my_binary");
+        }
+    }
+
+    #[test]
+    fn test_wrap_empty_command() {
+        let command: Vec<String> = vec![];
+        let wrapped = wrap_command_with_harness(&command, None);
+        assert!(wrapped.is_err());
+    }
+}