From 31cce2b7ed75c109fa35909b3dfc0aa639c9e981 Mon Sep 17 00:00:00 2001
From: Joseph Hunkeler <jhunkeler@gmail.com>
Date: Thu, 4 Jun 2026 10:17:27 -0400
Subject: Add conda_capable, conda_capable functions

* Add struct CondaCapabilities
---
 src/lib/core/conda.c         | 69 ++++++++++++++++++++++++++++++++++++++++++++
 src/lib/core/include/conda.h | 39 +++++++++++++++++++++++++
 2 files changed, 108 insertions(+)

(limited to 'src/lib')

diff --git a/src/lib/core/conda.c b/src/lib/core/conda.c
index 5c7779f..8548658 100644
--- a/src/lib/core/conda.c
+++ b/src/lib/core/conda.c
@@ -749,3 +749,72 @@ int conda_env_exists(const char *root, const char *name) {
     snprintf(path, sizeof(path), "%s/envs/%s", root, name);
     return access(path, F_OK) == 0;
 }
+
+void conda_capable_free(struct CondaCapabilities *ccap) {
+    guard_free(ccap->conda_version);
+    guard_free(ccap->mamba_version);
+    memset(ccap, 0, sizeof(*ccap));
+}
+
+int conda_capable(struct CondaCapabilities *ccap) {
+    struct CondaCapabilities *cc = ccap;
+    memset(cc, 0, sizeof(*cc));
+
+    if (find_program("conda")) {
+        cc->available = true;
+    }
+
+    if (cc->available) {
+        int status = 0;
+        char *conda_version = shell_output("python3 -c 'import conda; print(conda._version.__version__)'", &status);
+        if (status) {
+            SYSERROR("conda version detection failed");
+            guard_free(conda_version);
+            return -1;
+        }
+        if (!conda_version) {
+            SYSERROR("unable to allocate conda_version_raw");
+            return -1;
+        }
+        strip(conda_version);
+
+        char *mamba_version = shell_output("python3 -c 'import libmambapy; print(libmambapy.version.__version__)'", &status);
+        if (status) {
+            SYSERROR("mamba version detection failed");
+            guard_free(conda_version);
+            guard_free(mamba_version);
+            return -1;
+        }
+        if (!mamba_version) {
+            SYSERROR("unable to allocate mamba_version");
+            guard_free(conda_version);
+            guard_free(mamba_version);
+            return -1;
+        }
+        strip(mamba_version);
+
+        cc->conda_version = strdup(conda_version);
+        cc->mamba_version = strdup(mamba_version);
+        if (version_compare(GT | EQ, cc->conda_version, "25.3.0")) {
+            cc->require_explicit_export_format = true;
+            cc->require_boa = false;
+        } else {
+            cc->require_explicit_export_format = false;
+            cc->require_manual_activation_shim = true;
+            cc->require_boa = true;
+            cc->require_libmamba_solver = true;
+        }
+
+        struct Process proc = {0};
+        safe_strncpy(proc.f_stderr, "/dev/null", sizeof(proc.f_stderr));
+        if (shell(&proc, "mamba install --use-local --dry-run conda")) {
+            cc->missing_use_local = true;
+        }
+
+        cc->usable = true;
+
+        guard_free(mamba_version);
+        guard_free(conda_version);
+    }
+    return 0;
+}
\ No newline at end of file
diff --git a/src/lib/core/include/conda.h b/src/lib/core/include/conda.h
index a7108ec..66d5b57 100644
--- a/src/lib/core/include/conda.h
+++ b/src/lib/core/include/conda.h
@@ -26,6 +26,45 @@
 #define PKG_INDEX_PROVIDES_E_MANAGER_EXEC (PKG_INDEX_PROVIDES_ERROR_MESSAGE_OFFSET + 5)
 #define PKG_INDEX_PROVIDES_FAILED(ECODE) ((ECODE) <= PKG_INDEX_PROVIDES_ERROR_MESSAGE_OFFSET)
 
+/**
+ * @struct CondaCapabilities
+ * @brief Collection of feature flags to support older, newer, and transitional versions of conda/mamba.
+ * @see implementation in `conda_capable`
+ */
+struct CondaCapabilities {
+    /// Currently installed version of Conda
+    char *conda_version;
+    /// Currently installed version of Mamba
+    char *mamba_version;
+    /// Is conda available in the runtime environment?
+    bool available;
+    /// Can conda execute?
+    bool usable;
+    /// Do we need to pass extra arguments to "conda env export"?
+    bool require_explicit_export_format;
+    /// Do we need to inject our own shim to make Conda available?
+    bool require_manual_activation_shim;
+    /// Does this version of Conda support building with boa?
+    bool require_boa;
+    /// Does this version of Conda need to be configured to use libmamba?
+    bool require_libmamba_solver;
+    /// Does "mamba install --use-local" work on this version of mamba?
+    bool missing_use_local;
+};
+
+/**
+ * Check for the existence of "Conda" and set flags based on the availability of features
+ * @param ccap a pointer to an empty `struct CondaCapabilities`
+ * @return 0 on success
+ */
+int conda_capable(struct CondaCapabilities *ccap);
+
+/**
+ * Free memory allocated by `conda_capable`
+ * @param ccap a pointer to a populated `struct CondaCapabilities`
+ */
+void conda_capable_free(struct CondaCapabilities *ccap);
+
 struct MicromambaInfo {
     char *micromamba_prefix;    //!< Path to write micromamba binary
     char *conda_prefix;         //!< Path to install conda base tree
-- 
cgit 


From 34fd2f24666eda37e44a1ea76d3d742d5210f7f2 Mon Sep 17 00:00:00 2001
From: Joseph Hunkeler <jhunkeler@gmail.com>
Date: Thu, 4 Jun 2026 10:20:07 -0400
Subject: String handling

---
 src/lib/delivery/delivery.c | 37 ++++++++++++++++++-------------------
 1 file changed, 18 insertions(+), 19 deletions(-)

(limited to 'src/lib')

diff --git a/src/lib/delivery/delivery.c b/src/lib/delivery/delivery.c
index dc9e2ce..60d826b 100644
--- a/src/lib/delivery/delivery.c
+++ b/src/lib/delivery/delivery.c
@@ -308,37 +308,38 @@ int delivery_format_str(struct Delivery *ctx, char **dest, size_t maxlen, const
             i++;
             switch (fmt[i]) {
                 case 'n':   // name
-                    strncat(*dest, ctx->meta.name, maxlen - 1);
+                    safe_strncat(*dest, ctx->meta.name, maxlen);
                     break;
                 case 'c':   // codename
-                    strncat(*dest, ctx->meta.codename, maxlen - 1);
+                    safe_strncat(*dest, ctx->meta.codename, maxlen);
                     break;
                 case 'm':   // mission
-                    strncat(*dest, ctx->meta.mission, maxlen - 1);
+                    safe_strncat(*dest, ctx->meta.mission, maxlen);
                     break;
                 case 'r':   // revision
                     snprintf(*dest + strlen(*dest), maxlen - strlen(*dest), "%d", ctx->meta.rc);
                     break;
                 case 'R':   // "final"-aware revision
-                    if (ctx->meta.final)
-                        strncat(*dest, "final", maxlen);
-                    else
+                    if (ctx->meta.final) {
+                        safe_strncat(*dest, "final", maxlen);
+                    } else {
                         snprintf(*dest + strlen(*dest), maxlen - strlen(*dest), "%d", ctx->meta.rc);
+                    }
                     break;
                 case 'v':   // version
-                    strncat(*dest, ctx->meta.version, maxlen - 1);
+                    safe_strncat(*dest, ctx->meta.version, maxlen);
                     break;
                 case 'P':   // python version
-                    strncat(*dest, ctx->meta.python, maxlen - 1);
+                    safe_strncat(*dest, ctx->meta.python, maxlen);
                     break;
                 case 'p':   // python version major/minor
-                    strncat(*dest, ctx->meta.python_compact, maxlen - 1);
+                    safe_strncat(*dest, ctx->meta.python_compact, maxlen);
                     break;
                 case 'a':   // system architecture name
-                    strncat(*dest, ctx->system.arch, maxlen - 1);
+                    safe_strncat(*dest, ctx->system.arch, maxlen);
                     break;
                 case 'o':   // system platform (OS) name
-                    strncat(*dest, ctx->system.platform[DELIVERY_PLATFORM_RELEASE], maxlen - 1);
+                    safe_strncat(*dest, ctx->system.platform[DELIVERY_PLATFORM_RELEASE], maxlen);
                     break;
                 case 't':   // unix epoch
                     snprintf(*dest + strlen(*dest), maxlen - strlen(*dest), "%ld", ctx->info.time_now);
@@ -363,11 +364,11 @@ void delivery_defer_packages(struct Delivery *ctx, int type) {
     if (DEFER_CONDA == type) {
         dataptr = ctx->conda.conda_packages;
         deferred = ctx->conda.conda_packages_defer;
-        strncpy(mode, "conda", sizeof(mode) - 1);
+        safe_strncpy(mode, "conda", sizeof(mode));
     } else if (DEFER_PIP == type) {
         dataptr = ctx->conda.pip_packages;
         deferred = ctx->conda.pip_packages_defer;
-        strncpy(mode, "pip", sizeof(mode) - 1);
+        safe_strncpy(mode, "pip", sizeof(mode));
     } else {
         SYSERROR("BUG: type %d does not map to a supported package manager!", type);
         exit(1);
@@ -397,11 +398,10 @@ void delivery_defer_packages(struct Delivery *ctx, int type) {
             while (*spec_end != '\0' && !isalnum(*spec_end)) {
                 spec_end++;
             }
-            strncpy(package_name, name, spec_begin - name);
-            package_name[spec_begin - name] = '\0';
+            size_t spec_len = spec_begin - name;
+            safe_strncpy(package_name, name, spec_len ? spec_len + 1 : sizeof(package_name));
         } else {
-            strncpy(package_name, name, sizeof(package_name) - 1);
-            package_name[sizeof(package_name) - 1] = '\0';
+            safe_strncpy(package_name, name, sizeof(package_name));
         }
         remove_extras(package_name);
 
@@ -412,8 +412,7 @@ void delivery_defer_packages(struct Delivery *ctx, int type) {
             struct Test *test = ctx->tests->test[x];
             char nametmp[STASIS_NAME_MAX] = {0};
 
-            strncpy(nametmp, package_name, sizeof(nametmp) - 1);
-            nametmp[sizeof(nametmp) - 1] = '\0';
+            safe_strncpy(nametmp, package_name, sizeof(nametmp));
 
             // Is the [test:NAME] in the package name?
             if (!strcmp(nametmp, test->name)) {
-- 
cgit 


From 3092f60b8cd8b5be17a33b5c5e9da9998f97a6fa Mon Sep 17 00:00:00 2001
From: Joseph Hunkeler <jhunkeler@gmail.com>
Date: Thu, 4 Jun 2026 10:21:12 -0400
Subject: Hook CondaCapabilities up to the delivery context

---
 src/lib/delivery/delivery.c         | 2 ++
 src/lib/delivery/include/delivery.h | 2 ++
 2 files changed, 4 insertions(+)

(limited to 'src/lib')

diff --git a/src/lib/delivery/delivery.c b/src/lib/delivery/delivery.c
index 60d826b..f87f47c 100644
--- a/src/lib/delivery/delivery.c
+++ b/src/lib/delivery/delivery.c
@@ -236,6 +236,8 @@ void delivery_free(struct Delivery *ctx) {
     guard_free(ctx->info.build_number);
     guard_free(ctx->info.release_name);
     guard_free(ctx->info.time_info);
+
+    conda_capable_free(&ctx->conda.capabilities);
     guard_free(ctx->conda.installer_baseurl);
     guard_free(ctx->conda.installer_name);
     guard_free(ctx->conda.installer_version);
diff --git a/src/lib/delivery/include/delivery.h b/src/lib/delivery/include/delivery.h
index 3103a86..60255fe 100644
--- a/src/lib/delivery/include/delivery.h
+++ b/src/lib/delivery/include/delivery.h
@@ -10,6 +10,7 @@
 #include "environment.h"
 #include "ini.h"
 #include "multiprocessing.h"
+#include "conda.h"
 
 #define DELIVERY_PLATFORM_MAX 4
 #define DELIVERY_PLATFORM_MAXLEN 65
@@ -157,6 +158,7 @@ struct Delivery {
         struct StrList *pip_packages_defer;     ///< Python packages to be built for delivery
         struct StrList *pip_packages_purge;     ///< Python packages to remove from a delivery (for: based_on)
         struct StrList *wheels_packages;        ///< Wheel packages built for delivery
+        struct CondaCapabilities capabilities; ///< Capability information
     } conda;
 
     /*! \struct Runtime
-- 
cgit 


From 03343d3d294457caa673135e738e7d1d3101e94c Mon Sep 17 00:00:00 2001
From: Joseph Hunkeler <jhunkeler@gmail.com>
Date: Thu, 4 Jun 2026 10:22:11 -0400
Subject: Add CondaCapabilities as argument to conda_setup_headless

---
 src/lib/core/conda.c         | 2 +-
 src/lib/core/include/conda.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/lib')

diff --git a/src/lib/core/conda.c b/src/lib/core/conda.c
index 8548658..17aea02 100644
--- a/src/lib/core/conda.c
+++ b/src/lib/core/conda.c
@@ -561,7 +561,7 @@ int conda_check_required() {
     return 0;
 }
 
-int conda_setup_headless() {
+int conda_setup_headless(struct CondaCapabilities *cc) {
     if (globals.verbose) {
         conda_exec("config --system --set quiet false");
     } else {
diff --git a/src/lib/core/include/conda.h b/src/lib/core/include/conda.h
index 66d5b57..f0ba1e4 100644
--- a/src/lib/core/include/conda.h
+++ b/src/lib/core/include/conda.h
@@ -156,7 +156,7 @@ int conda_activate(const char *root, const char *env_name);
 /**
  * Configure the active conda installation for headless operation
  */
-int conda_setup_headless();
+int conda_setup_headless(struct CondaCapabilities *cc);
 
 /**
  * Creates a Conda environment from a YAML config
-- 
cgit 


From bdcf35cfa3d73645cf0658b318787a80a3004257 Mon Sep 17 00:00:00 2001
From: Joseph Hunkeler <jhunkeler@gmail.com>
Date: Thu, 4 Jun 2026 10:24:28 -0400
Subject: delivery_conda_enable populates CondaCapabilities members

---
 src/lib/delivery/delivery_conda.c | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

(limited to 'src/lib')

diff --git a/src/lib/delivery/delivery_conda.c b/src/lib/delivery/delivery_conda.c
index 117e6c9..e1a07f1 100644
--- a/src/lib/delivery/delivery_conda.c
+++ b/src/lib/delivery/delivery_conda.c
@@ -120,7 +120,17 @@ void delivery_conda_enable(struct Delivery *ctx, char *conda_install_dir) {
         exit(1);
     }
 
-    if (conda_setup_headless()) {
+    if (conda_capable(&ctx->conda.capabilities)) {
+        SYSERROR("Conda capability check failed");
+        exit(1);
+    }
+
+    if (!ctx->conda.capabilities.usable) {
+        SYSERROR("Conda is broken");
+        exit(1);
+    }
+
+    if (conda_setup_headless(&ctx->conda.capabilities)) {
         // no COE check. this call must succeed.
         exit(1);
     }
-- 
cgit 


From a7c5906c203d1a1356aef7bf628499ad2345f43a Mon Sep 17 00:00:00 2001
From: Joseph Hunkeler <jhunkeler@gmail.com>
Date: Thu, 4 Jun 2026 13:20:31 -0400
Subject: shell: throw warning if temporary script's permissions cannot be
 modified

---
 src/lib/core/system.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'src/lib')

diff --git a/src/lib/core/system.c b/src/lib/core/system.c
index 4f1ece6..542f9fd 100644
--- a/src/lib/core/system.c
+++ b/src/lib/core/system.c
@@ -37,7 +37,9 @@ int shell(struct Process *proc, char *args) {
     // Set the script's permissions so that only the calling user can use it
     // This should help prevent eavesdropping if keys are applied in plain-text
     // somewhere.
-    chmod(t_name, 0700);
+    if (chmod(t_name, 0700)) {
+        SYSWARN("unable to change script permissions: %s, %s", t_name, strerror(errno));
+    }
 
     pid_t pid = fork();
     if (pid == -1) {
-- 
cgit 


From da57037c0fbbe0619bc40ea990dba7f1f6d316a8 Mon Sep 17 00:00:00 2001
From: Joseph Hunkeler <jhunkeler@gmail.com>
Date: Thu, 4 Jun 2026 13:34:58 -0400
Subject: delivery_conda_enable: always pin conda's version to the same version
 provided by the installer

* Some commands upgrade conda whether it is configured to allow the behavior or not
---
 src/lib/delivery/delivery_conda.c | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

(limited to 'src/lib')

diff --git a/src/lib/delivery/delivery_conda.c b/src/lib/delivery/delivery_conda.c
index e1a07f1..3938842 100644
--- a/src/lib/delivery/delivery_conda.c
+++ b/src/lib/delivery/delivery_conda.c
@@ -120,6 +120,30 @@ void delivery_conda_enable(struct Delivery *ctx, char *conda_install_dir) {
         exit(1);
     }
 
+    char pinned[PATH_MAX];
+    snprintf(pinned, sizeof(pinned), "%s/conda-meta/pinned", conda_install_dir);
+    touch(pinned);
+    if (errno == ENOENT) {
+        errno = 0;
+    }
+
+    char *conda_version = strdup(ctx->conda.installer_version);
+    if (conda_version) {
+        char *rev = strpbrk(conda_version, "-");
+        if (rev) {
+            *rev = '\0';
+        }
+
+        FILE *pinned_fp = fopen(pinned, "w+");
+        if (!pinned_fp) {
+            SYSERROR("unable to open conda-meta/pinned file for writing: %s", strerror(errno));
+            exit(1);
+        }
+        fprintf(pinned_fp, "conda=%s\n", conda_version);
+        fclose(pinned_fp);
+        guard_free(conda_version);
+    }
+
     if (conda_capable(&ctx->conda.capabilities)) {
         SYSERROR("Conda capability check failed");
         exit(1);
-- 
cgit 


From 6e5e7a9af59f149d1c26c0a79880cb6b89e0b674 Mon Sep 17 00:00:00 2001
From: Joseph Hunkeler <jhunkeler@gmail.com>
Date: Thu, 4 Jun 2026 13:36:30 -0400
Subject: Add recipe_get_build_system

* Rename RECIPE_TYPE_* to RECIPE_STYLE_*
* Add defines for RECIPE_BUILD_* that denote which build system should be used to build the recipe
---
 src/lib/core/include/recipe.h | 28 ++++++++++++++++++----------
 src/lib/core/recipe.c         | 32 +++++++++++++++++++++++++-------
 2 files changed, 43 insertions(+), 17 deletions(-)

(limited to 'src/lib')

diff --git a/src/lib/core/include/recipe.h b/src/lib/core/include/recipe.h
index 4dea248..ddcbabf 100644
--- a/src/lib/core/include/recipe.h
+++ b/src/lib/core/include/recipe.h
@@ -6,13 +6,20 @@
 #include "utils.h"
 
 //! Unable to determine recipe repo type
-#define RECIPE_TYPE_UNKNOWN 0
+#define RECIPE_STYLE_UNKNOWN 0
 //! Recipe repo is from conda-forge
-#define RECIPE_TYPE_CONDA_FORGE 1
+#define RECIPE_STYLE_CONDA_FORGE 1
 //! Recipe repo is from astroconda
-#define RECIPE_TYPE_ASTROCONDA 2
+#define RECIPE_STYLE_ASTROCONDA 2
 //! Recipe repo provides the required build configurations but doesn't match conda-forge or astroconda's signature
-#define RECIPE_TYPE_GENERIC 3
+#define RECIPE_STYLE_GENERIC 3
+
+//! Unable to determine required build system
+#define RECIPE_BUILD_UNKNOWN 0
+//! Build uses meta.yaml
+#define RECIPE_BUILD_CONDA_BUILD 1
+//! Build uses recipe.yaml
+#define RECIPE_BUILD_RATTLER 2
 
 /**
  * Download a Conda package recipe
@@ -46,18 +53,18 @@ int recipe_clone(char *recipe_dir, char *url, char *gitref, char **result);
  * }
  *
  * int recipe_type;
- * recipe_type = recipe_get_type(recipe);
+ * recipe_type = recipe_get_style(recipe);
  * switch (recipe_type) {
- *     case RECIPE_TYPE_CONDA_FORGE:
+ *     case RECIPE_STYLE_CONDA_FORGE:
  *         // do something specific for conda-forge directory structure
  *         break;
- *     case RECIPE_TYPE_ASTROCONDA:
+ *     case RECIPE_STYLE_ASTROCONDA:
  *         // do something specific for astroconda directory structure
  *         break;
- *     case RECIPE_TYPE_GENERIC:
+ *     case RECIPE_STYLE_GENERIC:
  *         // do something specific for a directory containing a meta.yaml config
  *         break;
- *     case RECIPE_TYPE_UNKNOWN:
+ *     case RECIPE_STYLE_UNKNOWN:
  *     default:
  *         // the structure is foreign or the path doesn't contain a conda recipe
  *         break;
@@ -67,6 +74,7 @@ int recipe_clone(char *recipe_dir, char *url, char *gitref, char **result);
  * @param repopath path to git repository containing conda recipe(s)
  * @return One of RECIPE_TYPE_UNKNOWN, RECIPE_TYPE_CONDA_FORGE, RECIPE_TYPE_ASTROCONDA, RECIPE_TYPE_GENERIC
  */
-int recipe_get_type(char *repopath);
+int recipe_get_style(char *repopath);
+int recipe_get_build_system(const char *repopath, int style);
 
 #endif //STASIS_RECIPE_H
diff --git a/src/lib/core/recipe.c b/src/lib/core/recipe.c
index 8cc8e21..2e18492 100644
--- a/src/lib/core/recipe.c
+++ b/src/lib/core/recipe.c
@@ -34,8 +34,26 @@ int recipe_clone(char *recipe_dir, char *url, char *gitref, char **result) {
     return git_clone(&proc, url, destdir, gitref);
 }
 
+int recipe_get_build_system(const char *repopath, const int style) {
+    char filename[PATH_MAX] = {0};
+    safe_strncat(filename, repopath, sizeof(filename));
 
-int recipe_get_type(char *repopath) {
+    if (style == RECIPE_STYLE_CONDA_FORGE) {
+        safe_strncat(filename, "/recipe/recipe.yaml", sizeof(filename));
+        if (!access(filename, F_OK)) {
+            return RECIPE_BUILD_RATTLER;
+        }
+        return RECIPE_BUILD_CONDA_BUILD;
+    }
+
+    if (style == RECIPE_STYLE_ASTROCONDA || style == RECIPE_STYLE_GENERIC) {
+        return RECIPE_BUILD_CONDA_BUILD;
+    }
+
+    return RECIPE_BUILD_UNKNOWN;
+}
+
+int recipe_get_style(char *repopath) {
     // conda-forge is a collection of repositories
     // "conda-forge.yml" is guaranteed to exist
     const char *marker[] = {
@@ -44,10 +62,10 @@ int recipe_get_type(char *repopath) {
             "meta.yaml",
             NULL
     };
-    const int type[] = {
-            RECIPE_TYPE_CONDA_FORGE,
-            RECIPE_TYPE_ASTROCONDA,
-            RECIPE_TYPE_GENERIC
+    const int style[] = {
+            RECIPE_STYLE_CONDA_FORGE,
+            RECIPE_STYLE_ASTROCONDA,
+            RECIPE_STYLE_GENERIC
     };
 
     for (size_t i = 0; marker[i] != NULL; i++) {
@@ -55,9 +73,9 @@ int recipe_get_type(char *repopath) {
         snprintf(path, sizeof(path), "%s/%s", repopath, marker[i]);
         int result = access(path, F_OK);
         if (!result) {
-            return type[i];
+            return style[i];
         }
     }
 
-    return RECIPE_TYPE_UNKNOWN;
+    return RECIPE_STYLE_UNKNOWN;
 }
\ No newline at end of file
-- 
cgit 


From 262e90248d6ff9393468ed3baef7440de3b59d4d Mon Sep 17 00:00:00 2001
From: Joseph Hunkeler <jhunkeler@gmail.com>
Date: Thu, 11 Jun 2026 13:01:52 -0400
Subject: Disallow extraneous conda and pip version specs

* STASIS wants equals-to, or nothing (latest).
* The use of URLs with '@' is what we need to avoid
* Tell the user the expected format on error
---
 src/lib/delivery/delivery_populate.c | 48 ++++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

(limited to 'src/lib')

diff --git a/src/lib/delivery/delivery_populate.c b/src/lib/delivery/delivery_populate.c
index 5ce11d7..314ef46 100644
--- a/src/lib/delivery/delivery_populate.c
+++ b/src/lib/delivery/delivery_populate.c
@@ -199,6 +199,44 @@ static void normalize_ini_list(struct INIFILE **inip, struct StrList **listp, ch
     (*listp) = list;
 }
 
+static int check_package_spec_list(struct StrList *list, const char *ini_section, const char *ini_key) {
+    if (!list) {
+        // empty lists are OK
+        return 0;
+    }
+    for (size_t i = 0; i < strlist_count(list); i++) {
+        const char *item = strlist_item(list, i);
+        if (!item) {
+            continue;
+        }
+        const char *invalid_chars = "@:/<>!~";
+        const char *invalid_spec = strpbrk(item, invalid_chars);
+        if (invalid_spec) {
+            SYSERROR("Invalid version specification detected at %s:%s[%zu], \"%s\"", ini_section, ini_key, i, item);
+            SYSERROR("Package specification may not contain the operator '%c' (or any of \"%s\")", *invalid_spec, invalid_chars);
+            SYSERROR("");
+            SYSERROR("%s:%s supports:", ini_section, ini_key);
+            SYSERROR("    {package}[=={version|tag|branch|ref}]");
+            SYSERROR("");
+            char *reported_name = strdup(item);
+            if (!reported_name) {
+                SYSERROR("unable to allocate memory for reported_name");
+                return -1;
+            }
+            const char *reported_name_end = reported_name;
+            while (!ispunct(*reported_name_end)) {
+                reported_name_end++;
+            }
+            reported_name[reported_name_end - reported_name] = '\0';
+            SYSERROR("Set test:%s.repository to point to a valid Git repository URL to enable [tag|branch|ref]", reported_name);
+
+            guard_free(reported_name);
+            return -1;
+        }
+    }
+    return 0;
+}
+
 int populate_delivery_ini(struct Delivery *ctx, int render_mode) {
     struct INIFILE *ini = ctx->_stasis_ini_fp.delivery;
     struct INIData *rtdata;
@@ -235,12 +273,22 @@ int populate_delivery_ini(struct Delivery *ctx, int render_mode) {
     ctx->conda.installer_platform = ini_getval_str(ini, "conda", "installer_platform", render_mode, &err);
     ctx->conda.installer_arch = ini_getval_str(ini, "conda", "installer_arch", render_mode, &err);
     ctx->conda.installer_baseurl = ini_getval_str(ini, "conda", "installer_baseurl", render_mode, &err);
+
     ctx->conda.conda_packages = ini_getval_strlist(ini, "conda", "conda_packages", LINE_SEP, render_mode, &err);
     normalize_ini_list(&ini, &ctx->conda.conda_packages, "conda", "conda_packages", render_mode);
+    if (check_package_spec_list(ctx->conda.conda_packages, "conda", "conda_packages")) {
+        return -1;
+    }
+
     ctx->conda.conda_packages_purge = ini_getval_strlist(ini, "conda", "conda_packages_purge", LINE_SEP, render_mode, &err);
     normalize_ini_list(&ini, &ctx->conda.conda_packages_purge, "conda", "conda_package_purge", render_mode);
+
     ctx->conda.pip_packages = ini_getval_strlist(ini, "conda", "pip_packages", LINE_SEP, render_mode, &err);
     normalize_ini_list(&ini, &ctx->conda.pip_packages, "conda", "pip_packages", render_mode);
+    if (check_package_spec_list(ctx->conda.pip_packages, "conda", "pip_packages")) {
+        return -1;
+    }
+
     ctx->conda.pip_packages_purge = ini_getval_strlist(ini, "conda", "pip_packages_purge", LINE_SEP, render_mode, &err);
     normalize_ini_list(&ini, &ctx->conda.pip_packages_purge, "conda", "pip_packages_purge", render_mode);
 
-- 
cgit 


From 8e8406c1cc1f03e6d37a0997fc4107e340f8fb0e Mon Sep 17 00:00:00 2001
From: Joseph Hunkeler <jhunkeler@gmail.com>
Date: Thu, 11 Jun 2026 13:09:08 -0400
Subject: Add STASIS_ALWAYS_BUILD_FOR_HOST environment variable trigger

---
 src/lib/delivery/delivery.c | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'src/lib')

diff --git a/src/lib/delivery/delivery.c b/src/lib/delivery/delivery.c
index f87f47c..d256681 100644
--- a/src/lib/delivery/delivery.c
+++ b/src/lib/delivery/delivery.c
@@ -480,6 +480,10 @@ void delivery_defer_packages(struct Delivery *ctx, int type) {
             }
         }
 
+        if (getenv("STASIS_ALWAYS_BUILD_FOR_HOST")) {
+            build_for_host = 1;
+        }
+
         if (build_for_host) {
             printf("BUILD FOR HOST\n");
             strlist_append(&deferred, name);
-- 
cgit 


From 5c15c56a7e36c26d4e095d30a146e758890424b4 Mon Sep 17 00:00:00 2001
From: Joseph Hunkeler <jhunkeler@gmail.com>
Date: Thu, 11 Jun 2026 13:19:43 -0400
Subject: Set mamba-related environment variables

---
 src/lib/delivery/delivery_conda.c | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'src/lib')

diff --git a/src/lib/delivery/delivery_conda.c b/src/lib/delivery/delivery_conda.c
index 3938842..e879d1d 100644
--- a/src/lib/delivery/delivery_conda.c
+++ b/src/lib/delivery/delivery_conda.c
@@ -104,6 +104,7 @@ void delivery_install_conda(char *install_script, char *conda_install_dir) {
 }
 
 void delivery_conda_enable(struct Delivery *ctx, char *conda_install_dir) {
+    setenv("MAMBA_ROOT_PREFIX", ctx->storage.conda_install_prefix, 1);
     if (conda_activate(conda_install_dir, "base")) {
         SYSERROR("conda activation failed");
         exit(1);
@@ -115,6 +116,7 @@ void delivery_conda_enable(struct Delivery *ctx, char *conda_install_dir) {
     char rcpath[PATH_MAX];
     snprintf(rcpath, sizeof(rcpath), "%s/%s", conda_install_dir, ".condarc");
     setenv("CONDARC", rcpath, 1);
+    setenv("MAMBARC", rcpath, 1);
     if (runtime_replace(&ctx->runtime.environ, __environ)) {
         SYSERROR("unable to replace runtime environment after activating conda");
         exit(1);
-- 
cgit 


From afbb6f8118245a091e1e023fb5d5979a6a914e8a Mon Sep 17 00:00:00 2001
From: Joseph Hunkeler <jhunkeler@gmail.com>
Date: Fri, 12 Jun 2026 01:42:52 -0400
Subject: Separate the recipe style and build system.

* Add "support" for rattler. Very loosely.
---
 src/lib/delivery/delivery_build.c | 67 ++++++++++++++++++++++++++-------------
 1 file changed, 45 insertions(+), 22 deletions(-)

(limited to 'src/lib')

diff --git a/src/lib/delivery/delivery_build.c b/src/lib/delivery/delivery_build.c
index d8674e0..9ef5d92 100644
--- a/src/lib/delivery/delivery_build.c
+++ b/src/lib/delivery/delivery_build.c
@@ -16,11 +16,13 @@ int delivery_build_recipes(struct Delivery *ctx) {
                 SYSERROR("BUG: recipe_clone() succeeded but recipe_dir is NULL: %s", strerror(errno));
                 return -1;
             }
-            int recipe_type = recipe_get_type(recipe_dir);
+            const int recipe_style = recipe_get_style(recipe_dir);
+            const int recipe_build_system = recipe_get_build_system(recipe_dir, recipe_style);
+
             if(!pushd(recipe_dir)) {
-                if (RECIPE_TYPE_ASTROCONDA == recipe_type) {
+                if (RECIPE_STYLE_ASTROCONDA == recipe_style) {
                     pushd(path_basename(ctx->tests->test[i]->repository));
-                } else if (RECIPE_TYPE_CONDA_FORGE == recipe_type) {
+                } else if (RECIPE_STYLE_CONDA_FORGE == recipe_style) {
                     pushd("recipe");
                 }
 
@@ -56,23 +58,28 @@ int delivery_build_recipes(struct Delivery *ctx) {
                 snprintf(recipe_buildno, sizeof(recipe_buildno), "  number: 0");
 
                 unsigned flags = REPLACE_TRUNCATE_AFTER_MATCH;
-                //file_replace_text("meta.yaml", "{% set version = ", recipe_version);
-                if (ctx->meta.final) { // remove this. i.e. statis cannot deploy a release to conda-forge
-                    snprintf(recipe_version, sizeof(recipe_version), "{%% set version = \"%s\" %%}", ctx->tests->test[i]->version);
-                    // TODO: replace sha256 of tagged archive
-                    // TODO: leave the recipe unchanged otherwise. in theory this should produce the same conda package hash as conda forge.
-                    // For now, remove the sha256 requirement
-                    file_replace_text("meta.yaml", "sha256:", "\n", flags);
-                } else {
-                    file_replace_text("meta.yaml", "{% set version = ", recipe_version, flags);
-                    file_replace_text("meta.yaml", "  url:", recipe_git_url, flags);
-                    //file_replace_text("meta.yaml", "sha256:", recipe_git_rev);
-                    file_replace_text("meta.yaml", "  sha256:", "\n", flags);
-                    file_replace_text("meta.yaml", "  number:", recipe_buildno, flags);
+                if (recipe_build_system == RECIPE_BUILD_CONDA_BUILD) {
+                    if (ctx->meta.final) { // remove this. i.e. statis cannot deploy a release to conda-forge
+                        snprintf(recipe_version, sizeof(recipe_version), "{%% set version = \"%s\" %%}", ctx->tests->test[i]->version);
+                        // TODO: replace sha256 of tagged archive
+                        // TODO: leave the recipe unchanged otherwise. in theory this should produce the same conda package hash as conda forge.
+                        // For now, remove the sha256 requirement
+                        file_replace_text("meta.yaml", "sha256:", "\n", flags);
+                    } else {
+                        file_replace_text("meta.yaml", "{% set version = ", recipe_version, flags);
+                        file_replace_text("meta.yaml", "  url:", recipe_git_url, flags);
+                        file_replace_text("meta.yaml", "  sha256:", "\n", flags);
+                        file_replace_text("meta.yaml", "  number:", recipe_buildno, flags);
+                    }
+                } else if (recipe_build_system == RECIPE_BUILD_RATTLER) {
+                    file_replace_text("recipe.yaml", "  version:", ctx->tests->test[i]->version, flags);
+                    file_replace_text("recipe.yaml", "  url:", recipe_git_url, flags);
+                    file_replace_text("recipe.yaml", "  sha256:", "\n", flags);
+                    file_replace_text("recipe.yaml", "  number:", recipe_buildno, flags);
                 }
 
                 char command[PATH_MAX];
-                if (RECIPE_TYPE_CONDA_FORGE == recipe_type) {
+                if (RECIPE_STYLE_CONDA_FORGE == recipe_style) {
                     char arch[STASIS_NAME_MAX] = {0};
                     char platform[STASIS_NAME_MAX] = {0};
 
@@ -92,18 +99,34 @@ int delivery_build_recipes(struct Delivery *ctx) {
                     }
                     tolower_s(arch);
 
-                    snprintf(command, sizeof(command), "mambabuild --python=%s -m ../.ci_support/%s_%s_.yaml .",
-                            ctx->meta.python, platform, arch);
+                    // default build tool is "conda build" aka "build"
+                    char tool[STASIS_NAME_MAX] = "build";
+                    if (recipe_build_system == RECIPE_BUILD_CONDA_BUILD) {
+                        if (strlist_contains(globals.conda_packages, "boa", NULL)) {
+                            safe_strncpy(tool, "mambabuild", sizeof(tool));
+                        }
+                    } else if (recipe_build_system == RECIPE_BUILD_RATTLER) {
+                        snprintf(tool, sizeof(tool), "rattler-build");
+                    }
+                    snprintf(command, sizeof(command), "%s --python=%s -m ../.ci_support/%s_%s_.yaml .",
+                            tool, ctx->meta.python, platform, arch);
+                } else {
+                    snprintf(command, sizeof(command), "build --python=%s .", ctx->meta.python);
+                }
+
+                int status = 0;
+                if (recipe_build_system == RECIPE_BUILD_RATTLER) {
+                    // rattler-build is a standalone program, not a conda sub-command
+                    status = system(command);
                 } else {
-                    snprintf(command, sizeof(command), "mambabuild --python=%s .", ctx->meta.python);
+                    status = conda_exec(command);
                 }
-                int status = conda_exec(command);
                 if (status) {
                     guard_free(recipe_dir);
                     return -1;
                 }
 
-                if (RECIPE_TYPE_GENERIC != recipe_type) {
+                if (RECIPE_STYLE_GENERIC != recipe_style) {
                     popd();
                 }
                 popd();
-- 
cgit 


From d0f42f51818576c90a2fcce29adb54f39e952af0 Mon Sep 17 00:00:00 2001
From: Joseph Hunkeler <jhunkeler@gmail.com>
Date: Fri, 12 Jun 2026 01:47:00 -0400
Subject: Add support for modern versions of conda and mamba

* Boa is dead, but we can still use it if conda is old enough
* Also because boa is dead we purge it from the list if the conda version is too new
* Initial environment activation changed as well, but still compatible with older versions of conda
---
 src/lib/core/conda.c | 76 +++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 54 insertions(+), 22 deletions(-)

(limited to 'src/lib')

diff --git a/src/lib/core/conda.c b/src/lib/core/conda.c
index 17aea02..219afe2 100644
--- a/src/lib/core/conda.c
+++ b/src/lib/core/conda.c
@@ -326,14 +326,22 @@ int conda_exec(const char *args) {
     };
     char conda_as[10] = {0};
 
+    const char *last_mamba_command = NULL;
     safe_strncpy(conda_as, "conda", sizeof(conda_as));
     for (size_t i = 0; mamba_commands[i] != NULL; i++) {
         if (startswith(args, mamba_commands[i])) {
+            last_mamba_command = mamba_commands[i];
             safe_strncpy(conda_as, "mamba", sizeof(conda_as));
             break;
         }
     }
 
+    const int boa_present = find_program("boa") != NULL;
+    if (!boa_present) {
+        if (last_mamba_command && !strcmp(last_mamba_command, "build")) {
+            safe_strncpy(conda_as, "conda", sizeof(conda_as));
+        }
+    }
 
     const char *command_fmt = "%s %s";
     const int len = snprintf(NULL, 0, command_fmt, conda_as, args);
@@ -416,15 +424,12 @@ static int env0_to_runtime(const char *logfile) {
 
 int conda_activate(const char *root, const char *env_name) {
     const char *init_script_conda = "/etc/profile.d/conda.sh";
-    const char *init_script_mamba = "/etc/profile.d/mamba.sh";
     char path_conda[PATH_MAX] = {0};
-    char path_mamba[PATH_MAX] = {0};
     char logfile[PATH_MAX] = {0};
     struct Process proc = {0};
 
     // Where to find conda's init scripts
     snprintf(path_conda, sizeof(path_conda), "%s%s", root, init_script_conda);
-    snprintf(path_mamba, sizeof(path_mamba), "%s%s", root, init_script_mamba);
 
     // Set the path to our stdout log
     // Emulate mktemp()'s behavior. Give us a unique file name, but don't use
@@ -448,12 +453,6 @@ int conda_activate(const char *root, const char *env_name) {
         return -1;
     }
 
-    if (access(path_mamba, F_OK) < 0) {
-        SYSERROR("mamba is missing: %s, %s", path_mamba, strerror(errno));
-        remove(logfile);
-        return -1;
-    }
-
     // Fully activate conda and record its effect on the runtime environment
     char command[PATH_MAX * 3];
     const char *conda_shlvl_str = getenv("CONDA_SHLVL");
@@ -475,20 +474,19 @@ int conda_activate(const char *root, const char *env_name) {
     snprintf(command, sizeof(command),
         "set -a\n"
         "source %s\n"
-        "__conda_exe() (\n"
-        "    \"$CONDA_PYTHON_EXE\" \"$CONDA_EXE\" $_CE_M $_CE_CONDA \"$@\"\n"
-        ")\n\n"
-        "export -f __conda_exe\n"
-        "source %s\n"
-        "__mamba_exe() (\n"
-        "    \\local MAMBA_CONDA_EXE_BACKUP=$CONDA_EXE\n"
-        "    \\local MAMBA_EXE=$(\\dirname \"${CONDA_EXE}\")/mamba\n"
-        "    \"$CONDA_PYTHON_EXE\" \"$MAMBA_EXE\" $_CE_M $_CE_CONDA \"$@\"\n"
-        ")\n\n"
-        "export -f __mamba_exe\n"
+        "tempfile=$(mktemp)\n"
+        "chmod 600 \"${tempfile}\"\n"
+        "%s/bin/mamba shell init --shell bash --dry-run 2>/dev/null\\\n"
+        "| (ignore=1; \\\n"
+        "    while read line; do \\\n"
+        "        if [[ \"$line\" == \"#\"* ]]; then ignore=0; fi; \\\n"
+        "        if (( ignore == 0 )); then echo $line; fi; \\\n"
+        "    done) 1> \"${tempfile}\"\n"
+        "source \"${tempfile}\"\n"
+        "rm -f \"${tempfile}\"\n"
         "%s\n"
         "conda activate %s 1>&2\n"
-        "env -0\n", path_conda, path_mamba, conda_shlvl ? "conda deactivate" : ":", env_name);
+        "env -0\n", path_conda, root, conda_shlvl ? "conda deactivate" : ":", env_name);
 
     int retval = shell(&proc, command);
     if (retval) {
@@ -582,6 +580,29 @@ int conda_setup_headless(struct CondaCapabilities *cc) {
     size_t total = 0;
     const char *cmd_fmt = "'%s'";
     if (globals.conda_packages && strlist_count(globals.conda_packages)) {
+        // Push or pop build packages based on capabilities
+        size_t boa_index = 0;
+        const int boa_requested = strlist_contains(globals.conda_packages, "boa", &boa_index);
+        if (boa_requested && !cc->require_boa) {
+            SYSWARN("Removing boa from global package list due to incompatible conda version (too new): %s", cc->conda_version);
+            strlist_remove(globals.conda_packages, boa_index);
+        } else if (!boa_requested && cc->require_boa) {
+            SYSWARN("Adding boa to global package list");
+            strlist_append(&globals.conda_packages, "boa");
+        }
+
+        if (cc->require_boa) {
+            if (!boa_requested) {
+                SYSWARN("Adding boa to global package list");
+                strlist_append(&globals.conda_packages, "boa");
+            }
+        } else {
+            if (boa_requested) {
+                SYSWARN("Removing boa from global package list due to incompatible conda version (too new): %s", cc->conda_version);
+                strlist_remove(globals.conda_packages, boa_index);
+            }
+        }
+
         memset(cmd, 0, sizeof(cmd));
         safe_strncpy(cmd, "install ", sizeof(cmd));
 
@@ -719,7 +740,18 @@ int conda_env_remove(char *name) {
 
 int conda_env_export(char *name, char *output_dir, char *output_filename) {
     char env_command[PATH_MAX];
-    snprintf(env_command, sizeof(env_command), "env export -n %s -f %s/%s.yml", name, output_dir, output_filename);
+    int vr = 0;
+    const char *env_format = NULL;
+    char *version = shell_output("conda --version", &vr);
+    if (version) {
+        const size_t v_offset = strlen("conda ");
+        if (version_compare(GT, version + v_offset, "25.1.0")) {
+            env_format = "--format=yml";
+        }
+        guard_free(version);
+    }
+
+    snprintf(env_command, sizeof(env_command), "env export %s -n %s -f %s/%s.yml", env_format ? env_format : "", name, output_dir, output_filename);
     return conda_exec(env_command);
 }
 
-- 
cgit 


From f6ddfbec1a3575c3403a896023c55bd58c8f6dc6 Mon Sep 17 00:00:00 2001
From: Joseph Hunkeler <jhunkeler@gmail.com>
Date: Fri, 12 Jun 2026 13:46:41 -0400
Subject: Add python_importlib_metadata_version function

* Use it for conda and libmamapy version detection
---
 src/lib/core/conda.c         | 46 +++++++++++++++++++++++++++-----------------
 src/lib/core/include/conda.h | 18 +++++++++++++++++
 2 files changed, 46 insertions(+), 18 deletions(-)

(limited to 'src/lib')

diff --git a/src/lib/core/conda.c b/src/lib/core/conda.c
index 219afe2..5624f59 100644
--- a/src/lib/core/conda.c
+++ b/src/lib/core/conda.c
@@ -194,6 +194,31 @@ int pip_exec(const char *args) {
     return result;
 }
 
+char *python_importlib_metadata_version(const char *package_name) {
+    int status = 0;
+    char cmd[PATH_MAX] = {0};
+
+    if (strpbrk(package_name, "\\/*{}()|;&\"'\r\n")) {
+        SYSERROR("package name is invalid: '%s'", package_name);
+        return NULL;
+    }
+    snprintf(cmd, sizeof(cmd), "python3 -c 'from importlib.metadata import version; print(version(r\x22%s\x22))'", package_name);
+
+    char *version = shell_output(cmd, &status);
+    if (status) {
+        SYSERROR("version detection failed");
+        guard_free(version);
+        return NULL;
+    }
+    if (!version) {
+        SYSERROR("unable to allocate version");
+        return NULL;
+    }
+    strip(version);
+    return version;
+}
+
+
 static const char *PKG_ERROR_STR[] = {
     "success",
     "[internal] unhandled package manager mode",
@@ -797,33 +822,18 @@ int conda_capable(struct CondaCapabilities *ccap) {
     }
 
     if (cc->available) {
-        int status = 0;
-        char *conda_version = shell_output("python3 -c 'import conda; print(conda._version.__version__)'", &status);
-        if (status) {
-            SYSERROR("conda version detection failed");
-            guard_free(conda_version);
-            return -1;
-        }
+        char *conda_version = python_importlib_metadata_version("conda");
         if (!conda_version) {
-            SYSERROR("unable to allocate conda_version_raw");
+            SYSERROR("conda version detection failed");
             return -1;
         }
-        strip(conda_version);
 
-        char *mamba_version = shell_output("python3 -c 'import libmambapy; print(libmambapy.version.__version__)'", &status);
-        if (status) {
-            SYSERROR("mamba version detection failed");
-            guard_free(conda_version);
-            guard_free(mamba_version);
-            return -1;
-        }
+        char *mamba_version = python_importlib_metadata_version("libmambapy");
         if (!mamba_version) {
             SYSERROR("unable to allocate mamba_version");
             guard_free(conda_version);
-            guard_free(mamba_version);
             return -1;
         }
-        strip(mamba_version);
 
         cc->conda_version = strdup(conda_version);
         cc->mamba_version = strdup(mamba_version);
diff --git a/src/lib/core/include/conda.h b/src/lib/core/include/conda.h
index f0ba1e4..3e79b69 100644
--- a/src/lib/core/include/conda.h
+++ b/src/lib/core/include/conda.h
@@ -121,6 +121,24 @@ int python_exec(const char *args);
  */
 int pip_exec(const char *args);
 
+/**
+ * Use importlib to resolve the version of an installed package
+ *
+ * ```c
+ * char *numpy_version = python_importlib_metadata_version("numpy");
+ * if (!numpy_version) {
+ *     fprintf(stderr, "failed to get numpy version\n");
+ *     exit(1);
+ * }
+ *
+ * printf("numpy version: %s\n", numpy_version);
+ * free(numpy_version);
+ * ```
+ * @param package_name of installed python package
+ * @return
+ */
+char *python_importlib_metadata_version(const char *package_name);
+
 /**
  * Execute conda (or if possible, mamba)
  * Conda/Mamba is determined by PATH
-- 
cgit 


From 838d2e068624bebc5461e37c1d2e7ee1f6e14c8b Mon Sep 17 00:00:00 2001
From: Joseph Hunkeler <jhunkeler@gmail.com>
Date: Fri, 12 Jun 2026 13:47:26 -0400
Subject: Remove redundant code left behind from development

---
 src/lib/core/conda.c | 11 -----------
 1 file changed, 11 deletions(-)

(limited to 'src/lib')

diff --git a/src/lib/core/conda.c b/src/lib/core/conda.c
index 5624f59..a95b420 100644
--- a/src/lib/core/conda.c
+++ b/src/lib/core/conda.c
@@ -616,17 +616,6 @@ int conda_setup_headless(struct CondaCapabilities *cc) {
             strlist_append(&globals.conda_packages, "boa");
         }
 
-        if (cc->require_boa) {
-            if (!boa_requested) {
-                SYSWARN("Adding boa to global package list");
-                strlist_append(&globals.conda_packages, "boa");
-            }
-        } else {
-            if (boa_requested) {
-                SYSWARN("Removing boa from global package list due to incompatible conda version (too new): %s", cc->conda_version);
-                strlist_remove(globals.conda_packages, boa_index);
-            }
-        }
 
         memset(cmd, 0, sizeof(cmd));
         safe_strncpy(cmd, "install ", sizeof(cmd));
-- 
cgit 


From 4798135aec35ef84baa43dcc38a3681e490c6c78 Mon Sep 17 00:00:00 2001
From: Joseph Hunkeler <jhunkeler@gmail.com>
Date: Tue, 16 Jun 2026 11:37:28 -0400
Subject: Store conda installation prefix in capabilities structure

---
 src/lib/core/conda.c              | 3 ++-
 src/lib/core/include/conda.h      | 5 ++++-
 src/lib/delivery/delivery_conda.c | 2 +-
 3 files changed, 7 insertions(+), 3 deletions(-)

(limited to 'src/lib')

diff --git a/src/lib/core/conda.c b/src/lib/core/conda.c
index a95b420..b1d4cc2 100644
--- a/src/lib/core/conda.c
+++ b/src/lib/core/conda.c
@@ -802,7 +802,7 @@ void conda_capable_free(struct CondaCapabilities *ccap) {
     memset(ccap, 0, sizeof(*ccap));
 }
 
-int conda_capable(struct CondaCapabilities *ccap) {
+int conda_capable(struct CondaCapabilities *ccap, const char *root) {
     struct CondaCapabilities *cc = ccap;
     memset(cc, 0, sizeof(*cc));
 
@@ -824,6 +824,7 @@ int conda_capable(struct CondaCapabilities *ccap) {
             return -1;
         }
 
+        cc->prefix = root;
         cc->conda_version = strdup(conda_version);
         cc->mamba_version = strdup(mamba_version);
         if (version_compare(GT | EQ, cc->conda_version, "25.3.0")) {
diff --git a/src/lib/core/include/conda.h b/src/lib/core/include/conda.h
index 3e79b69..9a6178b 100644
--- a/src/lib/core/include/conda.h
+++ b/src/lib/core/include/conda.h
@@ -32,6 +32,8 @@
  * @see implementation in `conda_capable`
  */
 struct CondaCapabilities {
+    /// Conda installation prefix
+    const char *prefix;
     /// Currently installed version of Conda
     char *conda_version;
     /// Currently installed version of Mamba
@@ -55,9 +57,10 @@ struct CondaCapabilities {
 /**
  * Check for the existence of "Conda" and set flags based on the availability of features
  * @param ccap a pointer to an empty `struct CondaCapabilities`
+ * @param root conda installation root directory
  * @return 0 on success
  */
-int conda_capable(struct CondaCapabilities *ccap);
+int conda_capable(struct CondaCapabilities *ccap, const char *root);
 
 /**
  * Free memory allocated by `conda_capable`
diff --git a/src/lib/delivery/delivery_conda.c b/src/lib/delivery/delivery_conda.c
index e879d1d..12eddb7 100644
--- a/src/lib/delivery/delivery_conda.c
+++ b/src/lib/delivery/delivery_conda.c
@@ -146,7 +146,7 @@ void delivery_conda_enable(struct Delivery *ctx, char *conda_install_dir) {
         guard_free(conda_version);
     }
 
-    if (conda_capable(&ctx->conda.capabilities)) {
+    if (conda_capable(&ctx->conda.capabilities, ctx->storage.conda_install_prefix)) {
         SYSERROR("Conda capability check failed");
         exit(1);
     }
-- 
cgit 


From 9863a96a91b853d70cc1972db1c36df65c6cfecf Mon Sep 17 00:00:00 2001
From: Joseph Hunkeler <jhunkeler@gmail.com>
Date: Tue, 16 Jun 2026 11:39:00 -0400
Subject: Ensure .condrc exists and conda knows where to find it

---
 src/lib/core/conda.c | 13 +++++++++++++
 1 file changed, 13 insertions(+)

(limited to 'src/lib')

diff --git a/src/lib/core/conda.c b/src/lib/core/conda.c
index b1d4cc2..8d2753d 100644
--- a/src/lib/core/conda.c
+++ b/src/lib/core/conda.c
@@ -585,6 +585,19 @@ int conda_check_required() {
 }
 
 int conda_setup_headless(struct CondaCapabilities *cc) {
+    mkdirs(cc->prefix, 0755);
+
+    char rcpath[PATH_MAX];
+    snprintf(rcpath, sizeof(rcpath), "%s/.condarc", cc->prefix);
+    touch(rcpath);
+    if (errno == ENOENT) {
+        errno = 0;
+    }
+
+    setenv("CONDARC", rcpath, 1);
+    setenv("MAMBARC", rcpath, 1);
+    setenv("MAMBA_ROOT_PREFIX", cc->prefix, 1);
+
     if (globals.verbose) {
         conda_exec("config --system --set quiet false");
     } else {
-- 
cgit 


From f9c7645c6491a8f38b957d52df934911e0a51472 Mon Sep 17 00:00:00 2001
From: Joseph Hunkeler <jhunkeler@gmail.com>
Date: Tue, 16 Jun 2026 11:39:20 -0400
Subject: Ignore stderr from installation dry-run

---
 src/lib/core/conda.c | 1 +
 1 file changed, 1 insertion(+)

(limited to 'src/lib')

diff --git a/src/lib/core/conda.c b/src/lib/core/conda.c
index 8d2753d..1c6bd99 100644
--- a/src/lib/core/conda.c
+++ b/src/lib/core/conda.c
@@ -852,6 +852,7 @@ int conda_capable(struct CondaCapabilities *ccap, const char *root) {
 
         struct Process proc = {0};
         safe_strncpy(proc.f_stderr, "/dev/null", sizeof(proc.f_stderr));
+        safe_strncpy(proc.f_stdout, "/dev/null", sizeof(proc.f_stdout));
         if (shell(&proc, "mamba install --use-local --dry-run conda")) {
             cc->missing_use_local = true;
         }
-- 
cgit 


From b95f5a2fed749f7fe5154927620457385b0292f8 Mon Sep 17 00:00:00 2001
From: Joseph Hunkeler <jhunkeler@gmail.com>
Date: Tue, 16 Jun 2026 11:40:41 -0400
Subject: Passing the conda installation directory to delivery_conda_enable
 isn't necessary

* The delivery context already provides this path
---
 src/lib/delivery/delivery_conda.c   | 15 ++++++++-------
 src/lib/delivery/include/delivery.h |  3 +--
 2 files changed, 9 insertions(+), 9 deletions(-)

(limited to 'src/lib')

diff --git a/src/lib/delivery/delivery_conda.c b/src/lib/delivery/delivery_conda.c
index 12eddb7..4f2920e 100644
--- a/src/lib/delivery/delivery_conda.c
+++ b/src/lib/delivery/delivery_conda.c
@@ -103,18 +103,14 @@ void delivery_install_conda(char *install_script, char *conda_install_dir) {
     }
 }
 
-void delivery_conda_enable(struct Delivery *ctx, char *conda_install_dir) {
+void delivery_conda_enable(struct Delivery *ctx) {
     setenv("MAMBA_ROOT_PREFIX", ctx->storage.conda_install_prefix, 1);
-    if (conda_activate(conda_install_dir, "base")) {
-        SYSERROR("conda activation failed");
-        exit(1);
-    }
 
     // Setting the CONDARC environment variable appears to be the only consistent
     // way to make sure the file is used. Not setting this variable leads to strange
     // behavior, especially if a conda environment is already active when STASIS is loaded.
     char rcpath[PATH_MAX];
-    snprintf(rcpath, sizeof(rcpath), "%s/%s", conda_install_dir, ".condarc");
+    snprintf(rcpath, sizeof(rcpath), "%s/%s", ctx->storage.conda_install_prefix, ".condarc");
     setenv("CONDARC", rcpath, 1);
     setenv("MAMBARC", rcpath, 1);
     if (runtime_replace(&ctx->runtime.environ, __environ)) {
@@ -122,8 +118,13 @@ void delivery_conda_enable(struct Delivery *ctx, char *conda_install_dir) {
         exit(1);
     }
 
+    if (conda_activate(ctx->storage.conda_install_prefix, "base")) {
+        SYSERROR("conda activation failed");
+        exit(1);
+    }
+
     char pinned[PATH_MAX];
-    snprintf(pinned, sizeof(pinned), "%s/conda-meta/pinned", conda_install_dir);
+    snprintf(pinned, sizeof(pinned), "%s/conda-meta/pinned", ctx->storage.conda_install_prefix);
     touch(pinned);
     if (errno == ENOENT) {
         errno = 0;
diff --git a/src/lib/delivery/include/delivery.h b/src/lib/delivery/include/delivery.h
index 60255fe..7d846ab 100644
--- a/src/lib/delivery/include/delivery.h
+++ b/src/lib/delivery/include/delivery.h
@@ -356,9 +356,8 @@ void delivery_defer_packages(struct Delivery *ctx, int type);
 /**
  * Configure and activate a Conda installation based on Delivery context
  * @param ctx pointer to Delivery context
- * @param conda_install_dir path to Conda installation
  */
-void delivery_conda_enable(struct Delivery *ctx, char *conda_install_dir);
+void delivery_conda_enable(struct Delivery *ctx);
 
 /**
  * Install Conda
-- 
cgit 


From d8154024dd0e3baac34c29cad37aaf79c03e9069 Mon Sep 17 00:00:00 2001
From: Joseph Hunkeler <jhunkeler@gmail.com>
Date: Mon, 22 Jun 2026 00:25:32 -0400
Subject: Rewrite debug_hexdump

---
 src/lib/core/include/utils.h |  2 +-
 src/lib/core/utils.c         | 78 ++++++++++++++++++--------------------------
 2 files changed, 33 insertions(+), 47 deletions(-)

(limited to 'src/lib')

diff --git a/src/lib/core/include/utils.h b/src/lib/core/include/utils.h
index 3f0fe9f..e75995a 100644
--- a/src/lib/core/include/utils.h
+++ b/src/lib/core/include/utils.h
@@ -429,7 +429,7 @@ int gen_file_extension_str(char *filename, size_t maxlen, const char *extension)
  */
 char *remove_extras(char *s);
 
-void debug_hexdump(char *data, int len);
+void debug_hexdump(char *data, size_t len);
 
 /**
  * Realloc helper
diff --git a/src/lib/core/utils.c b/src/lib/core/utils.c
index 31208ad..d745c51 100644
--- a/src/lib/core/utils.c
+++ b/src/lib/core/utils.c
@@ -946,57 +946,43 @@ int gen_file_extension_str(char *filename, const size_t maxlen, const char *exte
     return replace_text(ext_orig, ext_orig, extension, 0);
 }
 
-#define DEBUG_HEXDUMP_FMT_BYTES 6
-#define DEBUG_HEXDUMP_ADDR_MAXLEN 20
-#define DEBUG_HEXDUMP_BYTES_MAXLEN (16 * 3 + 2)
-#define DEBUG_HEXDUMP_ASCII_MAXLEN (16 + 1)
-#define DEBUG_HEXDUMP_OUTPUT_MAXLEN (DEBUG_HEXDUMP_FMT_BYTES + DEBUG_HEXDUMP_ADDR_MAXLEN + DEBUG_HEXDUMP_BYTES_MAXLEN + DEBUG_HEXDUMP_ASCII_MAXLEN + 1)
-
-void debug_hexdump(char *data, int len) {
-    int count = 0;
-    char addr[DEBUG_HEXDUMP_ADDR_MAXLEN] = {0};
-    char bytes[DEBUG_HEXDUMP_BYTES_MAXLEN] = {0};
-    char ascii[DEBUG_HEXDUMP_ASCII_MAXLEN] = {0};
-    char output[DEBUG_HEXDUMP_OUTPUT_MAXLEN] = {0};
+void debug_hexdump(char *data, const size_t len) {
+    if (!data) {
+        SYSWARN("DATA NULL\n");
+        return;
+    }
+    if (len <= 0) {
+        SYSWARN("ZERO LENGTH\n");
+        return;
+    }
+    const size_t window = 16;
+    size_t avail = len;
+    const size_t chunk = avail / window ? window : avail;
     char *start = data;
-    char *end = data + len;
-
-    char *pos = start;
-    while (pos != end) {
-        if (count == 0) {
-            snprintf(addr + strlen(addr), sizeof(addr) - strlen(addr), "%p", pos);
+    while (avail > 0) {
+        const size_t need = chunk > avail ? avail : chunk;
+        char *p = start;
+        printf("%p | ", p);
+        size_t j = 0;
+        for (j = 0; j < need; j++) {
+            printf("%02x ", p[j]);
         }
-        if (count == 8) {
-            safe_strncat(bytes, " ", sizeof(bytes));
+        const size_t padding = window - j;
+        for (size_t i = 0; i < padding; i++) {
+            printf("00 ");
         }
-        if (count > 15) {
-            snprintf(output, sizeof(output), "%s | %s | %s", addr, bytes, ascii);
-            puts(output);
-            memset(output, 0, sizeof(output));
-            memset(addr, 0, sizeof(addr));
-            memset(bytes, 0, sizeof(bytes));
-            memset(ascii, 0, sizeof(ascii));
-            count = 0;
-            continue;
+        printf("| ");
+        for (j = 0; j < need; j++) {
+            char *c = p + j;
+            printf("%c", isprint(*c) ? *c : '.');
         }
-
-        snprintf(bytes + strlen(bytes), sizeof(bytes) - strlen(bytes), "%02X ", (unsigned char) *pos);
-        snprintf(ascii + strlen(ascii), sizeof(ascii) - strlen(ascii), "%c", isprint(*pos) ? *pos : '.');
-
-        pos++;
-        count++;
-    }
-
-    if (count <= 8) {
-        // Add group padding
-        safe_strncat(bytes, " ", sizeof(bytes));
-    }
-    const int padding = 16 - count;
-    for (int i = 0; i < padding; i++) {
-        safe_strncat(bytes, "   ", sizeof(bytes));
+        for (size_t i = 0; i < padding; i++) {
+            printf(".");
+        }
+        printf(" |\n");
+        avail -= need;
+        start += need;
     }
-    snprintf(output, sizeof(output), "%s | %s | %s", addr, bytes, ascii);
-    puts(output);
 }
 
 int grow(const size_t size_new, size_t *size_orig, char **data) {
-- 
cgit 


From ff9bb3ce64346a479df9c7912c994f889cfbaeb9 Mon Sep 17 00:00:00 2001
From: Joseph Hunkeler <jhunkeler@gmail.com>
Date: Mon, 22 Jun 2026 00:36:34 -0400
Subject: pkg_index_provides

* Modern mamba returns zero on error, and prints its error messages to stdout. FANTASTIC.
* The error detection seems to still handle the previous behavior as well with older versions.
* And now we print the contents of stdout and stderr on a non-zero exit from the package manager
---
 src/lib/core/conda.c | 103 ++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 74 insertions(+), 29 deletions(-)

(limited to 'src/lib')

diff --git a/src/lib/core/conda.c b/src/lib/core/conda.c
index 1c6bd99..bf27d21 100644
--- a/src/lib/core/conda.c
+++ b/src/lib/core/conda.c
@@ -252,21 +252,30 @@ int pkg_index_provides(int mode, const char *index, const char *spec, const char
         SYSERROR("Unable to create log directory: %s", logdir ? logdir : "NULL");
         return -1;
     }
-    const char logfile_template[] = "STASIS-package_exists.XXXXXX";
-    char logfile[PATH_MAX] = {0};
-    snprintf(logfile, sizeof(logfile), "%s/%s", logdir, logfile_template);
 
-    int logfd = mkstemp(logfile);
-    if (logfd < 0) {
-        SYSERROR("unable to create log file: %s", logfile);
-        remove(logfile);  // fail harmlessly if not present
-        return PKG_INDEX_PROVIDES_E_INTERNAL_LOG_HANDLE;
+    const int stdout_stream = 0;
+    const int stderr_stream = 1;
+    const int stdout_st = 0;
+    //const int stderr_st = 1;
+    char logfile[2][PATH_MAX] = {0};
+    int logfile_fd[2] = {-1, -1};
+    struct stat logfile_st[2] = {0};
+
+    for (size_t i = 0; i < sizeof(logfile) / sizeof(logfile[0]); i++) {
+        const char logfile_template[] = "STASIS-package_exists.XXXXXX";
+        snprintf(logfile[i], sizeof(logfile[i]), "%s/%s", logdir, logfile_template);
+        logfile_fd[i] = mkstemp(logfile[i]);
+        if (logfile_fd[i] < 0) {
+            SYSERROR("unable to create log file: %s", logfile[i]);
+            remove(logfile[i]);  // fail harmlessly if not present
+            return PKG_INDEX_PROVIDES_E_INTERNAL_LOG_HANDLE;
+        }
     }
 
     int status = 0;
     struct Process proc = {0};
-    proc.redirect_stderr = 1;
-    snprintf(proc.f_stdout, sizeof(proc.f_stdout), "%s", logfile);
+    snprintf(proc.f_stdout, sizeof(proc.f_stdout), "%s", logfile[stdout_stream]);
+    snprintf(proc.f_stderr, sizeof(proc.f_stderr), "%s", logfile[stderr_stream]);
 
     if (mode == PKG_USE_PIP) {
         // Do an installation in dry-run mode to see if the package exists in the given index.
@@ -293,26 +302,40 @@ int pkg_index_provides(int mode, const char *index, const char *spec, const char
     SYSDEBUG("Executing: %s", cmd);
     status = shell(&proc, cmd);
 
-    SYSDEBUG("Log file: %s", logfile);
-    if (status != 0) {
-        FILE *fp = fdopen(logfd, "r");
-        if (!fp) {
-            remove(logfile);
+    // Populate stat data for log files
+    for (size_t i = 0; i < sizeof(logfile) / sizeof(logfile[0]); i++) {
+        if (stat(logfile[i], &logfile_st[i])) {
+            SYSERROR("Unable to stat %s", logfile[i]);
             return -1;
         }
+    }
+
+    if (status != 0) {
+        SYSERROR("Command exited non-zero (%d)", status);
+        for (size_t i = 0; i < sizeof(logfile) / sizeof(logfile[0]); i++) {
+            const char *stream_name = i == 0 ? "stdout" : "stderr";
+            if (!logfile_st[i].st_size) {
+                continue;
+            }
+            SYSDEBUG("(%s): %s", stream_name, logfile[i]);
+            FILE *fp = fdopen(logfile_fd[i], "r");
+            if (!fp) {
+                remove(logfile[i]);
+                return -1;
+            }
 
-        fflush(stdout);
-        fflush(stderr);
+            fflush(stdout);
+            fflush(stderr);
 
-        char line[STASIS_BUFSIZ] = {0};
-        while (fgets(line, sizeof(line) - 1, fp) != NULL) {
-            SYSDEBUG("%s", strip(line));
-        }
+            char line[STASIS_BUFSIZ] = {0};
+            while (fgets(line, sizeof(line) - 1, fp) != NULL) {
+                SYSINFO("(%s): %s", stream_name, strip(line));
+            }
 
-        fflush(stderr);
-        fclose(fp);
+            fflush(stderr);
+            fclose(fp);
+        }
     }
-    remove(logfile);
 
     if (WTERMSIG(proc.returncode)) {
         // This gets its own return value because if the external program
@@ -320,18 +343,40 @@ int pkg_index_provides(int mode, const char *index, const char *spec, const char
         return PKG_INDEX_PROVIDES_E_MANAGER_SIGNALED;
     }
 
+    int final = PKG_FOUND;
     if (status < 0) {
-        return PKG_INDEX_PROVIDES_E_MANAGER_EXEC;
+        final = PKG_INDEX_PROVIDES_E_MANAGER_EXEC;
     } else if (WEXITSTATUS(proc.returncode) > 1) {
         // Pip and conda both return 2 on argument parsing errors
-        return PKG_INDEX_PROVIDES_E_MANAGER_RUNTIME;
+        final = PKG_INDEX_PROVIDES_E_MANAGER_RUNTIME;
+    } else if (logfile_st[stdout_st].st_size > 1 && WEXITSTATUS(proc.returncode) == 0) {
+        // modern mamba return zero when a package not found.
+        // even more ridiculous; the error messages are written to stdout, not stderr
+        struct StrList *output = strlist_init();
+        if (!output) {
+            SYSERROR("unable to allocate memory for stdout log list");
+            return -1;
+        }
+        if (strlist_append_file(output, logfile[stdout_stream], NULL)) {
+            strlist_free(&output);
+            SYSERROR("unable to append stdout log to list: %s", logfile[stdout_stream]);
+            return -1;
+        }
+        if (strlist_contains(output, "No entries", NULL)) {
+            final = PKG_NOT_FOUND;
+        }
+        strlist_free(&output);
     } else if (WEXITSTATUS(proc.returncode) == 1) {
         // Pip and conda both return 1 when a package is not found.
         // Unfortunately this applies to botched version specs, too.
-        return PKG_NOT_FOUND;
-    } else {
-        return PKG_FOUND;
+        final = PKG_NOT_FOUND;
+    }
+
+    // Remove log files
+    for (size_t i = 0; i < sizeof(logfile) / sizeof(logfile[0]); i++) {
+        remove(logfile[stdout_stream]);
     }
+    return final;
 }
 
 int conda_exec(const char *args) {
-- 
cgit 


From 2fbd9e5cf2bd5d2bfe635007a0c458a58de2856e Mon Sep 17 00:00:00 2001
From: Joseph Hunkeler <jhunkeler@gmail.com>
Date: Tue, 23 Jun 2026 10:36:20 -0400
Subject: Fix zstd file magic

---
 src/lib/core/utils.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/lib')

diff --git a/src/lib/core/utils.c b/src/lib/core/utils.c
index d745c51..462604d 100644
--- a/src/lib/core/utils.c
+++ b/src/lib/core/utils.c
@@ -1281,7 +1281,7 @@ int is_file_compressed(const char *filename) {
         {(unsigned char *) "PK\03\04", 3},                  // zip
         {(unsigned char *) "PK\05\06", 3},                  // zip (empty)
         {(unsigned char *) "PK\07\08", 3},                  // zip (spanned)
-        {(unsigned char *) "\xfd\x2f\xb5\x28", 4}           // zstd
+        {(unsigned char *) "\x28\xb5\x2f\xfd", 4}           // zstd
     };
     unsigned char buf[8] = {0}; // unsigned long
     size_t bytes_read = 0;
-- 
cgit