feat: pixi-conda-run

Author: baszalmstra

Cargo.lock

@@ -51,6 +51,7 @@ pixi_utils = { workspace = true }
 rattler = { workspace = true }
 rattler_conda_types = { workspace = true }
 rattler_repodata_gateway = { workspace = true }
+rattler_shell = { workspace = true }
 rattler_solve = { workspace = true, features = ["libsolv_c", "resolvo"] }
 rattler_virtual_packages = { workspace = true }
 tabwriter = { workspace = true, features = ["ansi_formatting"] }

crates/pixi_conda/Cargo.toml

@@ -1,17 +1,19 @@
-use crate::create;
+use crate::{create, run};
 use clap::Subcommand;
 use pixi_config::Config;
 
 /// Pixi-conda is a tool for managing conda environments.
 #[derive(Subcommand, Debug)]
 pub enum Args {
     Create(create::Args),
+    Run(run::Args),
 }
 
 pub async fn execute(args: Args) -> miette::Result<()> {
     let config = Config::load_global();
 
     match args {
         Args::Create(args) => create::execute(config, args).await,
+        Args::Run(args) => run::execute(config, args).await,
     }
 }

crates/pixi_conda/src/cli.rs

@@ -1,3 +1,4 @@
+use std::fmt::Display;
 use std::str::FromStr;
 use thiserror::Error;
 
@@ -10,6 +11,12 @@ const INVALID_CHARACTERS: &[char] = &['/', '\\', ':', ',', ' '];
 #[derive(Debug, Clone, Eq, PartialEq, Hash, Ord, PartialOrd)]
 pub struct EnvironmentName(String);
 
+impl Display for EnvironmentName {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
 impl AsRef<str> for EnvironmentName {
     fn as_ref(&self) -> &str {
         &self.0

crates/pixi_conda/src/environment_name.rs

@@ -2,5 +2,6 @@ pub mod cli;
 mod create;
 mod environment_name;
 mod registry;
+mod run;
 
 pub use environment_name::EnvironmentName;

crates/pixi_conda/src/lib.rs

@@ -0,0 +1,114 @@
+use std::{path::PathBuf, process::Stdio};
+
+use clap::Parser;
+use miette::{IntoDiagnostic, Report};
+use pixi_config::Config;
+use rattler_conda_types::Platform;
+use rattler_shell::shell::ShellEnum;
+
+use crate::{registry::Registry, EnvironmentName};
+
+/// Run an executable in a conda environment.
+#[derive(Parser, Debug)]
+#[clap(trailing_var_arg = true, disable_help_flag = true)]
+pub struct Args {
+    #[clap(num_args = 1.., allow_hyphen_values = true, required = true)]
+    args: Vec<String>,
+
+    /// Print help
+    #[clap(long, short, action = clap::ArgAction::Help)]
+    help: Option<bool>,
+
+    /// Name of environment.
+    #[clap(
+        long,
+        short,
+        help_heading = "Target Environment Specification",
+        conflicts_with = "prefix",
+        required = true
+    )]
+    name: Option<EnvironmentName>,
+
+    /// Path to environment location (i.e. prefix).
+    #[clap(long, short, help_heading = "Target Environment Specification")]
+    prefix: Option<PathBuf>,
+}
+
+pub async fn execute(_config: Config, mut args: Args) -> miette::Result<()> {
+    // Determine the prefix to use
+    let prefix = if let Some(name) = &args.name {
+        &Registry::from_env().root().join(name.as_ref())
+    } else if let Some(prefix) = &args.prefix {
+        prefix
+    } else {
+        unreachable!("Either a name or a prefix must be provided")
+    };
+
+    // Make sure it exists
+    if !prefix.is_dir() || !prefix.join("conda-meta").is_dir() {
+        let prefix_or_name = if let Some(name) = &args.name {
+            format!("--name {name}")
+        } else if let Some(prefix) = &args.prefix {
+            format!("--prefix {}", prefix.display())
+        } else {
+            unreachable!("Either a name or a prefix must be provided")
+        };
+        miette::bail!(
+            help = format!(
+                "You can create an environment with:\n\n\tpixi-conda create {prefix_or_name} ..."
+            ),
+            "The environment at '{}' does not appear to be a valid conda environment",
+            prefix.display()
+        );
+    };
+
+    // Collect environment variables for the prefix.
+    let activation_variables = rattler_shell::activation::Activator::from_path(
+        prefix,
+        ShellEnum::default(),
+        Platform::current(),
+    )
+    .into_diagnostic()?
+    .run_activation(
+        rattler_shell::activation::ActivationVariables::from_env().into_diagnostic()?,
+        None,
+    )
+    .into_diagnostic()?;
+
+    // Spawn the process
+    let executable = args.args.remove(0);
+    let mut command = std::process::Command::new(&executable);
+
+    // Set the environment variables
+    command.envs(activation_variables);
+
+    // Add the arguments
+    command.args(args.args);
+
+    // Inherit stdin, stdout, and stderr
+    command
+        .stdin(Stdio::inherit())
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::inherit());
+
+    // Spawn the child process
+    #[cfg(target_family = "unix")]
+    command.exec();
+
+    #[cfg(target_os = "windows")]
+    {
+        let mut child = match command.spawn() {
+            Ok(child) => child,
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
+                miette::bail!("The executable '{}' could not be found", executable);
+            }
+            Err(e) => return Err(Report::from_err(e)),
+        };
+
+        // Wait for the child process to complete
+        let status = child.wait().into_diagnostic()?;
+
+        // Exit with the same status code as the child process
+        std::process::exit(status.code().unwrap_or(1));
+    }
+}