Merge pull request #19 from Point72/tkp/link-scripts

Add an option to run packages' post-link scripts

Author: timkpaine

docs/wiki/Install.md

@@ -117,6 +117,11 @@ If the environment declares [`activation`](Manifests#activation) hooks, `create`
 also materializes them into `etc/conda/activate.d/` (recovered from the manifest
 the lock was solved from), so a subsequent [`activate`](#activate) runs them.
 
+Packages' `post-link` scripts are **not** run: they are arbitrary code shipped
+inside a package and they make an install non-hermetic. Pass `--link-scripts` to
+`create`, `unpack`, or `sync` to execute them anyway, for channels you trust and
+packages that depend on them.
+
 ### Publish, show, pull
 
 ```bash

rust/python/lib.rs

@@ -275,9 +275,10 @@ fn build<'py>(
 }
 
 /// Resolve a published lock and install it into `prefix` (no conda required).
+/// Set `link_scripts` to run each package's `post-link` script (off by default).
 /// Returns an install summary dict.
 #[pyfunction]
-#[pyo3(signature = (env, registry, prefix, *, platform = None, python = None, variant = None, label = "latest"))]
+#[pyo3(signature = (env, registry, prefix, *, platform = None, python = None, variant = None, label = "latest", link_scripts = false))]
 #[allow(clippy::too_many_arguments)]
 fn create<'py>(
     py: Python<'py>,
@@ -288,12 +289,22 @@ fn create<'py>(
     python: Option<String>,
     variant: Option<String>,
     label: &str,
+    link_scripts: bool,
 ) -> PyResult<Bound<'py, PyDict>> {
     let registry = Registry::new(SpecStore::new(), registry);
     let coords = coordinates(env, platform, python, variant);
     let label = Label::parse(label);
-    let summary =
-        block_on(py, install::create(&registry, &coords, &label, &prefix))?.map_err(err)?;
+    let summary = block_on(
+        py,
+        install::create(
+            &registry,
+            &coords,
+            &label,
+            &prefix,
+            install::LinkScripts::from(link_scripts),
+        ),
+    )?
+    .map_err(err)?;
     summary_dict(py, &summary)
 }
 
@@ -472,16 +483,18 @@ fn pack<'py>(
 
 /// Install an environment from a packed bundle into `prefix`, fully offline.
 /// `env` defaults to the bundle's environment and `platform` to the current
-/// platform. Returns an install summary dict.
+/// platform. Set `link_scripts` to run each package's `post-link` script (off by
+/// default). Returns an install summary dict.
 #[pyfunction]
-#[pyo3(signature = (pack, prefix, *, env = None, platform = None, stage_dir = None))]
+#[pyo3(signature = (pack, prefix, *, env = None, platform = None, stage_dir = None, link_scripts = false))]
 fn unpack<'py>(
     py: Python<'py>,
     pack: PathBuf,
     prefix: PathBuf,
     env: Option<String>,
     platform: Option<String>,
     stage_dir: Option<PathBuf>,
+    link_scripts: bool,
 ) -> PyResult<Bound<'py, PyDict>> {
     let summary = block_on(
         py,
@@ -491,21 +504,31 @@ fn unpack<'py>(
             platform.as_deref(),
             &prefix,
             stage_dir.as_deref(),
+            install::LinkScripts::from(link_scripts),
         ),
     )?
     .map_err(err)?;
     summary_dict(py, &summary)
 }
 
 /// Install the environment a project's `pyproject.toml` references in its
-/// `[tool.nepenthe]` stanza. `project` defaults to `./pyproject.toml`. Returns
-/// an install summary dict.
+/// `[tool.nepenthe]` stanza. `project` defaults to `./pyproject.toml`. Set
+/// `link_scripts` to run each package's `post-link` script (off by default).
+/// Returns an install summary dict.
 #[pyfunction]
-#[pyo3(signature = (project = None))]
-fn sync<'py>(py: Python<'py>, project: Option<PathBuf>) -> PyResult<Bound<'py, PyDict>> {
+#[pyo3(signature = (project = None, *, link_scripts = false))]
+fn sync<'py>(
+    py: Python<'py>,
+    project: Option<PathBuf>,
+    link_scripts: bool,
+) -> PyResult<Bound<'py, PyDict>> {
     let path = project.unwrap_or_else(|| PathBuf::from("pyproject.toml"));
     let file = project::read(&path).map_err(err)?;
-    let summary = block_on(py, project::sync(&file))?.map_err(err)?;
+    let summary = block_on(
+        py,
+        project::sync(&file, install::LinkScripts::from(link_scripts)),
+    )?
+    .map_err(err)?;
     summary_dict(py, &summary)
 }
 

rust/src/cli.rs

@@ -204,6 +204,10 @@ struct CreateArgs {
     /// Directory to install the environment into.
     #[arg(long)]
     prefix: PathBuf,
+    /// Run each package's `post-link` script (off by default — link scripts are
+    /// arbitrary code and make the install non-hermetic).
+    #[arg(long)]
+    link_scripts: bool,
 }
 
 #[derive(Args)]
@@ -375,13 +379,21 @@ struct UnpackArgs {
     /// Directory to extract the bundle into (defaults to a temporary directory).
     #[arg(long)]
     stage_dir: Option<PathBuf>,
+    /// Run each package's `post-link` script (off by default — link scripts are
+    /// arbitrary code and make the install non-hermetic).
+    #[arg(long)]
+    link_scripts: bool,
 }
 
 #[derive(Args)]
 struct SyncArgs {
     /// Path to the `pyproject.toml` to read (defaults to `./pyproject.toml`).
     #[arg(long, default_value = "pyproject.toml")]
     project: PathBuf,
+    /// Run each package's `post-link` script (off by default — link scripts are
+    /// arbitrary code and make the install non-hermetic).
+    #[arg(long)]
+    link_scripts: bool,
 }
 
 #[derive(Args)]
@@ -739,6 +751,7 @@ async fn create(args: CreateArgs) -> CliResult {
         .platform
         .clone()
         .unwrap_or_else(|| Platform::current().to_string());
+    let link_scripts = install::LinkScripts::from(args.link_scripts);
 
     let summary = if let Some(lock_path) = &args.lock {
         // No registry, no solve: install exactly the packages the lock pins,
@@ -749,7 +762,9 @@ async fn create(args: CreateArgs) -> CliResult {
             Some(env) => env.clone(),
             None => install::sole_environment(&lock)?,
         };
-        let summary = install::install_lock(&lock, &environment, &platform, &args.prefix).await?;
+        let summary =
+            install::install_lock(&lock, &environment, &platform, &args.prefix, link_scripts)
+                .await?;
         install::write_hooks_from_lock(
             &bytes,
             &environment,
@@ -778,7 +793,7 @@ async fn create(args: CreateArgs) -> CliResult {
             coords = coords.with_variant(v.clone());
         }
         let label = Label::parse(&args.label);
-        install::create(&registry, &coords, &label, &args.prefix).await?
+        install::create(&registry, &coords, &label, &args.prefix, link_scripts).await?
     };
 
     println!(
@@ -999,6 +1014,7 @@ async fn unpack(args: UnpackArgs) -> CliResult {
         args.platform.as_deref(),
         &args.prefix,
         args.stage_dir.as_deref(),
+        install::LinkScripts::from(args.link_scripts),
     )
     .await?;
     println!(
@@ -1013,7 +1029,8 @@ async fn unpack(args: UnpackArgs) -> CliResult {
 
 async fn sync(args: SyncArgs) -> CliResult {
     let project = crate::project::read(&args.project)?;
-    let summary = crate::project::sync(&project).await?;
+    let summary =
+        crate::project::sync(&project, install::LinkScripts::from(args.link_scripts)).await?;
     println!(
         "synced {} ({}) at {} — {} packages",
         summary.environment,
@@ -1223,7 +1240,14 @@ async fn shell(args: ShellArgs) -> CliResult {
         None => cache_env_prefix(&coords)?,
     };
     if !prefix.join("conda-meta").is_dir() {
-        install::create(&registry, &coords, &label, &prefix).await?;
+        install::create(
+            &registry,
+            &coords,
+            &label,
+            &prefix,
+            install::LinkScripts::Skip,
+        )
+        .await?;
     }
 
     let shell_program = args

rust/src/image.rs

@@ -426,7 +426,7 @@ pub async fn build(
 ) -> Result<ImageSummary, ImageError> {
     // Materialize the environment (self-contained: every package on disk).
     if !prefix.join("conda-meta").is_dir() {
-        install::create(registry, coords, label, prefix).await?;
+        install::create(registry, coords, label, prefix, install::LinkScripts::Skip).await?;
     }
 
     let artifact = match target {

rust/src/install.rs

@@ -330,6 +330,34 @@ pub struct InstallSummary {
     pub packages: Vec<PackageId>,
 }
 
+/// Whether a package's `post-link` / `pre-unlink` scripts run when it is linked
+/// into a prefix.
+///
+/// Skipped by default. Those scripts are arbitrary code shipped inside a
+/// package and run with the installer's privileges, and they are what makes an
+/// install non-hermetic — they can reach the network or bake host state into
+/// the prefix, so a packed bundle stops being reproducible offline. A few
+/// packages (some CUDA and MKL builds, older R builds) do real work there, so a
+/// caller that trusts the channels it installs from can opt in.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum LinkScripts {
+    /// Link files only; `post-link` / `pre-unlink` scripts are ignored.
+    #[default]
+    Skip,
+    /// Execute each package's `post-link` / `pre-unlink` scripts.
+    Run,
+}
+
+impl From<bool> for LinkScripts {
+    fn from(run: bool) -> Self {
+        if run {
+            Self::Run
+        } else {
+            Self::Skip
+        }
+    }
+}
+
 /// Install the `environment`/`platform` packages from `lock` into `prefix`,
 /// using rattler's installer (no conda required). Packages are fetched into the
 /// shared package cache and linked into the prefix.
@@ -340,9 +368,10 @@ pub async fn install_lock(
     environment: &str,
     platform: &str,
     prefix: &Path,
+    link_scripts: LinkScripts,
 ) -> Result<InstallSummary, InstallError> {
     let records = lock_records(lock, environment, platform)?;
-    install_records(records, environment, platform, prefix).await
+    install_records(records, environment, platform, prefix, link_scripts).await
 }
 
 /// Render `error` and its `source` chain as `outer: cause: root cause`.
@@ -445,6 +474,7 @@ pub async fn install_records(
     environment: &str,
     platform: &str,
     prefix: &Path,
+    link_scripts: LinkScripts,
 ) -> Result<InstallSummary, InstallError> {
     let target = Platform::from_str(platform)
         .map_err(|e| InstallError::Lock(format!("bad platform '{platform}': {e}")))?;
@@ -459,6 +489,7 @@ pub async fn install_records(
         .with_download_client(crate::net::authenticated_client().map_err(InstallError::Install)?)
         .with_max_concurrent_requests(MAX_CONCURRENT_FETCHES)
         .with_target_platform(target)
+        .with_execute_link_scripts(link_scripts == LinkScripts::Run)
         .install(prefix, records)
         .await
         .map_err(|e| InstallError::Install(error_chain(&e)))?;
@@ -489,10 +520,18 @@ pub async fn create(
     coords: &Coordinates,
     label: &Label,
     prefix: &Path,
+    link_scripts: LinkScripts,
 ) -> Result<InstallSummary, InstallError> {
     let bytes = registry.pull(coords, label)?;
     let lock = parse_lock(&bytes)?;
-    let summary = install_lock(&lock, &coords.environment, &coords.platform, prefix).await?;
+    let summary = install_lock(
+        &lock,
+        &coords.environment,
+        &coords.platform,
+        prefix,
+        link_scripts,
+    )
+    .await?;
     // Materialize the environment's activation hooks, recovered from the
     // manifest the lock was solved from: the embedded comment band if present,
     // else the registry's manifest sidecar. Best-effort: a release with no
@@ -1288,7 +1327,7 @@ mod tests {
             std::env::temp_dir().join(format!("nepenthe-install-capstone-{}", std::process::id()));
         let _ = std::fs::remove_dir_all(&prefix);
 
-        let summary = install_lock(&lock, "app", &platform, &prefix)
+        let summary = install_lock(&lock, "app", &platform, &prefix, LinkScripts::Skip)
             .await
             .expect("install should succeed");
         assert!(!summary.packages.is_empty());
@@ -1369,7 +1408,7 @@ mod tests {
         let prefix =
             std::env::temp_dir().join(format!("nepenthe-install-xplat-{}", std::process::id()));
         let _ = std::fs::remove_dir_all(&prefix);
-        let summary = install_lock(&lock, "app", &host, &prefix)
+        let summary = install_lock(&lock, "app", &host, &prefix, LinkScripts::Skip)
             .await
             .expect("install should succeed");
         assert!(!summary.packages.is_empty());

rust/src/pack.rs

@@ -27,7 +27,7 @@ use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
 use url::Url;
 
-use crate::install::{self, InstallError, InstallSummary};
+use crate::install::{self, InstallError, InstallSummary, LinkScripts};
 
 /// Bundle format version written into the manifest.
 const PACK_FORMAT: u32 = 1;
@@ -290,6 +290,7 @@ pub async fn install_pack(
     platform: Option<&str>,
     prefix: &Path,
     stage_dir: Option<&Path>,
+    link_scripts: LinkScripts,
 ) -> Result<InstallSummary, PackError> {
     let (staging, created_temp) = match stage_dir {
         Some(dir) => (dir.to_path_buf(), false),
@@ -304,7 +305,15 @@ pub async fn install_pack(
     };
     std::fs::create_dir_all(&staging)?;
 
-    let result = install_from_staging(pack_path, &staging, environment, platform, prefix).await;
+    let result = install_from_staging(
+        pack_path,
+        &staging,
+        environment,
+        platform,
+        prefix,
+        link_scripts,
+    )
+    .await;
 
     if created_temp {
         let _ = std::fs::remove_dir_all(&staging);
@@ -318,6 +327,7 @@ async fn install_from_staging(
     environment: Option<&str>,
     platform: Option<&str>,
     prefix: &Path,
+    link_scripts: LinkScripts,
 ) -> Result<InstallSummary, PackError> {
     tar::Archive::new(File::open(pack_path)?).unpack(staging)?;
 
@@ -379,7 +389,7 @@ async fn install_from_staging(
             .map_err(|()| PackError::BadUrl(path.display().to_string()))?;
     }
 
-    install::install_records(records, environment, &platform, prefix)
+    install::install_records(records, environment, &platform, prefix, link_scripts)
         .await
         .map_err(PackError::from)
 }
@@ -601,7 +611,7 @@ mod tests {
 
         // 3) install from the bundle into a fresh prefix — offline
         let prefix = base.join("env");
-        let install = install_pack(&bundle, None, None, &prefix, None)
+        let install = install_pack(&bundle, None, None, &prefix, None, LinkScripts::Skip)
             .await
             .expect("install from bundle should succeed");
         assert!(install.packages.iter().any(|p| p.name == "python"));

rust/src/project.rs

@@ -25,7 +25,7 @@ use rattler_conda_types::{ParseStrictness, Version, VersionSpec};
 use serde::Deserialize;
 
 use crate::backend::SpecStore;
-use crate::install::{self, InstallError, InstallSummary, PackageId};
+use crate::install::{self, InstallError, InstallSummary, LinkScripts, PackageId};
 use crate::name_map::{self, normalize_name};
 use crate::registry::{Coordinates, Label, Registry, RegistryError};
 
@@ -230,13 +230,17 @@ pub fn read_dependencies(pyproject: &Path) -> Result<Vec<String>, ProjectError>
 /// Install (or update) the environment referenced by a project into its prefix,
 /// resolving the version label against the registry. Performs network I/O; await
 /// inside a tokio runtime.
-pub async fn sync(project: &ProjectFile) -> Result<InstallSummary, ProjectError> {
+pub async fn sync(
+    project: &ProjectFile,
+    link_scripts: LinkScripts,
+) -> Result<InstallSummary, ProjectError> {
     let reference = &project.nepenthe;
     let summary = install::create(
         &reference.registry(),
         &reference.coordinates(),
         &reference.label(),
         &project.resolved_prefix(),
+        link_scripts,
     )
     .await?;
     Ok(summary)