Merge pull request #75 from jhunkeler/delivery-lib

Move delivery_*.c sources into their own library

54 files changed, 3058 insertions, 25 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index bfee276..2e7d87a 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,7 +1,3 @@
-include_directories(${CMAKE_BINARY_DIR}/include)
-include_directories(${CMAKE_SOURCE_DIR}/include)
-include_directories(${PROJECT_BINARY_DIR})
-
 add_subdirectory(lib)
 add_subdirectory(cli)
 
diff --git a/src/cli/stasis/CMakeLists.txt b/src/cli/stasis/CMakeLists.txt
index ff7fd88..1996c4c 100644
--- a/src/cli/stasis/CMakeLists.txt
+++ b/src/cli/stasis/CMakeLists.txt
@@ -1,4 +1,3 @@
-include_directories(${CMAKE_SOURCE_DIR})
 add_executable(stasis
         stasis_main.c
         args.c
@@ -6,7 +5,15 @@ add_executable(stasis
         system_requirements.c
         tpl.c
 )
-target_link_libraries(stasis PRIVATE stasis_core)
+target_link_libraries(stasis PRIVATE
+        stasis_core
+        stasis_delivery
+)
+target_include_directories(stasis PRIVATE
+        ${core_INCLUDE}
+        ${delivery_INCLUDE}
+        ${CMAKE_CURRENT_SOURCE_DIR}/include
+)
 target_link_libraries(stasis PUBLIC LibXml2::LibXml2)
 
 install(TARGETS stasis RUNTIME)
diff --git a/src/cli/stasis/args.h b/src/cli/stasis/include/args.h
index 5bad752..5bad752 100644
--- a/src/cli/stasis/args.h
+++ b/src/cli/stasis/include/args.h
diff --git a/src/cli/stasis/callbacks.h b/src/cli/stasis/include/callbacks.h
index 369ce56..369ce56 100644
--- a/src/cli/stasis/callbacks.h
+++ b/src/cli/stasis/include/callbacks.h
diff --git a/src/cli/stasis/system_requirements.h b/src/cli/stasis/include/system_requirements.h
index ddc2705..ddc2705 100644
--- a/src/cli/stasis/system_requirements.h
+++ b/src/cli/stasis/include/system_requirements.h
diff --git a/src/cli/stasis/tpl.h b/src/cli/stasis/include/tpl.h
index 398f0fe..398f0fe 100644
--- a/src/cli/stasis/tpl.h
+++ b/src/cli/stasis/include/tpl.h
diff --git a/src/cli/stasis_indexer/CMakeLists.txt b/src/cli/stasis_indexer/CMakeLists.txt
index 1d4c658..8c00ce4 100644
--- a/src/cli/stasis_indexer/CMakeLists.txt
+++ b/src/cli/stasis_indexer/CMakeLists.txt
@@ -5,11 +5,16 @@ add_executable(stasis_indexer
         helpers.c
         junitxml_report.c
         website.c
-        website.h
         readmes.c
-        readmes.h
 )
-target_include_directories(stasis_indexer PRIVATE ${CMAKE_SOURCE_DIR})
-target_link_libraries(stasis_indexer PRIVATE stasis_core)
+target_include_directories(stasis_indexer PRIVATE
+        ${core_INCLUDE}
+        ${delivery_INCLUDE}
+        ${CMAKE_CURRENT_SOURCE_DIR}/include
+)
+target_link_libraries(stasis_indexer PRIVATE
+        stasis_core
+        stasis_delivery
+)
 
 install(TARGETS stasis_indexer RUNTIME)
diff --git a/src/cli/stasis_indexer/args.h b/src/cli/stasis_indexer/include/args.h
index 543aa4b..543aa4b 100644
--- a/src/cli/stasis_indexer/args.h
+++ b/src/cli/stasis_indexer/include/args.h
diff --git a/src/cli/stasis_indexer/callbacks.h b/src/cli/stasis_indexer/include/callbacks.h
index 7d95cbb..7d95cbb 100644
--- a/src/cli/stasis_indexer/callbacks.h
+++ b/src/cli/stasis_indexer/include/callbacks.h
diff --git a/src/cli/stasis_indexer/helpers.h b/src/cli/stasis_indexer/include/helpers.h
index d493f75..d493f75 100644
--- a/src/cli/stasis_indexer/helpers.h
+++ b/src/cli/stasis_indexer/include/helpers.h
diff --git a/src/cli/stasis_indexer/junitxml_report.h b/src/cli/stasis_indexer/include/junitxml_report.h
index 6d2a248..6d2a248 100644
--- a/src/cli/stasis_indexer/junitxml_report.h
+++ b/src/cli/stasis_indexer/include/junitxml_report.h
diff --git a/src/cli/stasis_indexer/readmes.h b/src/cli/stasis_indexer/include/readmes.h
index d4fa7ac..d4fa7ac 100644
--- a/src/cli/stasis_indexer/readmes.h
+++ b/src/cli/stasis_indexer/include/readmes.h
diff --git a/src/cli/stasis_indexer/website.h b/src/cli/stasis_indexer/include/website.h
index e67d58b..e67d58b 100644
--- a/src/cli/stasis_indexer/website.h
+++ b/src/cli/stasis_indexer/include/website.h
diff --git a/src/lib/CMakeLists.txt b/src/lib/CMakeLists.txt
index 82bfe4a..187ddb2 100644
--- a/src/lib/CMakeLists.txt
+++ b/src/lib/CMakeLists.txt
@@ -1 +1,2 @@
-add_subdirectory(core)
\ No newline at end of file
+add_subdirectory(core)
+add_subdirectory(delivery)
\ No newline at end of file
diff --git a/src/lib/core/CMakeLists.txt b/src/lib/core/CMakeLists.txt
index c569187..e3e3d4b 100644
--- a/src/lib/core/CMakeLists.txt
+++ b/src/lib/core/CMakeLists.txt
@@ -1,5 +1,3 @@
-include_directories(${PROJECT_BINARY_DIR})
-
 add_library(stasis_core STATIC
         globals.c
         str.c
@@ -10,17 +8,6 @@ add_library(stasis_core STATIC
         utils.c
         system.c
         download.c
-        delivery_postprocess.c
-        delivery_conda.c
-        delivery_docker.c
-        delivery_install.c
-        delivery_artifactory.c
-        delivery_test.c
-        delivery_build.c
-        delivery_show.c
-        delivery_populate.c
-        delivery_init.c
-        delivery.c
         recipe.c
         relocation.c
         wheel.c
@@ -35,4 +22,8 @@ add_library(stasis_core STATIC
         envctl.c
         multiprocessing.c
 )
-
+target_include_directories(stasis_core PRIVATE
+        ${core_INCLUDE}
+        ${delivery_INCLUDE}
+        ${CMAKE_CURRENT_SOURCE_DIR}/include
+)
diff --git a/src/lib/core/include/artifactory.h b/src/lib/core/include/artifactory.h
new file mode 100644
index 0000000..e580886
--- /dev/null
+++ b/src/lib/core/include/artifactory.h
@@ -0,0 +1,362 @@
+//! @file artifactory.h
+#ifndef STASIS_ARTIFACTORY_H
+#define STASIS_ARTIFACTORY_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "core.h"
+#include "download.h"
+
+//! JFrog Artifactory Authentication struct
+struct JFRT_Auth {
+    bool insecure_tls; //!< Disable TLS
+    char *access_token; //!< Generated access token
+    char *password; //!< Password
+    char *client_cert_key_path; //!< Path to where SSL key is stored
+    char *client_cert_path; //!< Path to where SSL cert is stored
+    char *ssh_key_path; //!< Path to SSH private key
+    char *ssh_passphrase; //!< Passphrase for SSH private key
+    char *user; //!< Account to authenticate as
+    char *server_id; //!< Artifactory server identification (unused)
+    char *url; //!< Artifactory server address
+};
+
+//! JFrog Artifactory Upload struct
+struct JFRT_Upload {
+    bool quiet; //!< Enable quiet mode
+    char *project; //!< Destination project name
+    bool ant; //!< Enable Ant style regex
+    bool archive; //!< Generate a ZIP archive of the uploaded file(s)
+    char *build_name; //!< Build name
+    char *build_number; //!< Build number
+    bool deb; //!< Is Debian package?
+    bool detailed_summary; //!< Enable upload summary
+    bool dry_run; //!< Enable dry run (no-op)
+    char *exclusions; //!< Exclude patterns (separated by semicolons)
+    bool explode; //!< If uploaded file is an archive, extract it at the destination
+    bool fail_no_op; //!< Exit 2 when no file are affected
+    bool flat; //!< Upload with exact file system structure
+    bool include_dirs; //!< Enable to upload empty directories
+    char *module; //!< Build-info module name (optional)
+    bool recursive; //!< Upload files recursively
+    bool regexp; //!< Use regular expressions instead of wildcards
+    int retries; //!< Number of retries before giving up
+    int retry_wait_time; //!< Seconds between retries
+    char *spec; //!< Path to JSON upload spec
+    char *spec_vars;
+    bool symlinks; //!< Preserve symbolic links
+    bool sync_deletes; //!< Destination is replaced by uploaded files
+    char *target_props; //!< Properties (separated by semicolons)
+    int threads; //!< Thread count
+    bool workaround_parent_only; //!< Change directory to local parent directory before uploading files
+};
+
+struct JFRT_Download {
+    char *archive_entries;
+    char *build;
+    char *build_name;
+    char *build_number;
+    char *bundle;
+    bool detailed_summary;
+    bool dry_run;
+    char *exclude_artifacts;
+    char *exclude_props;
+    char *exclusions;
+    bool explode;
+    bool fail_no_op;
+    bool flat;
+    char *gpg_key;
+    char *include_deps;
+    char *include_dirs;
+    int limit;
+    int min_split;
+    char *module;
+    int offset;
+    char *project;
+    char *props;
+    bool quiet;
+    bool recursive;
+    int retries;
+    int retry_wait_time;
+    bool skip_checksum;
+    char *sort_by;
+    char *sort_order;
+    char *spec;
+    char *spec_vars;
+    int split_count;
+    bool sync_deletes;
+    int threads;
+    bool validate_symlinks;
+};
+
+struct JFRT_Search {
+    char *bundle;
+    bool count;
+    char *sort_by;
+    char *sort_order;
+    int limit;
+    int offset;
+    char *spec;
+    char *spec_vars;
+    char *props;
+    bool recursive;
+    char *build;
+    bool fail_no_op;
+    char *exclusions;
+    char *exclude_artifacts;
+    char *exclude_patterns;
+    char *exclude_props;
+    char *archive_entries;
+    char *include;
+    char *include_deps;
+    char *include_dirs;
+    char *project;
+    char *transitive;
+};
+
+/**
+ * Download the JFrog CLI tool from jfrog.com
+ * ```c
+ * if (artifactory_download_cli(".",
+ *         "https://releases.jfrog.io/artifactory",
+ *         "jfrog-cli",
+ *         "v2-jf",
+ *         "[RELEASE]",
+ *         "Linux",
+ *         "x86_64",
+ *         "jf") {
+ *     remove("./jf");
+ *     fprintf(stderr, "Failed to download JFrog CLI\n");
+ *     exit(1);
+ * }
+ *
+ * ```
+ *
+ * @param dest Directory path
+ * @param jfrog_artifactory_base_url jfrog.com base URL
+ * @param jfrog_artifactory_product jfrog.com project (jfrog-cli)
+ * @param cli_major_ver Version series (v1, v2-jf, vX-jf)
+ * @param version Version to download. "[RELEASE]" will download the latest version available
+ * @param os Operating system name
+ * @param arch System CPU architecture
+ * @param remote_filename File to download (jf)
+ * @return
+ */
+int artifactory_download_cli(char *dest,
+                             char *jfrog_artifactory_base_url,
+                             char *jfrog_artifactory_product,
+                             char *cli_major_ver,
+                             char *version,
+                             char *os,
+                             char *arch,
+                             char *remote_filename);
+
+/**
+ * JFrog CLI binding. Executes the "jf" tool with arguments.
+ *
+ * ```c
+ * struct JFRT_Auth auth_ctx;
+ * auth_ctx.user = strdup("myuser");
+ * auth_ctx.password = strdup("mypassword");
+ * auth_ctx.url = strdup("https://myserver.tld/artifactory");
+ * jfrt_auth_init(&auth_ctx);
+ *
+ * if (jfrog_cli(&auth_ctx, "rt", "ping", NULL) {
+ *     fprintf(stderr, "Failed to ping artifactory server: %s\n", auth_ctx.url);
+ *     exit(1);
+ * }
+ * ```
+ *
+ * @param auth JFRT_Auth structure
+ * @param subsystem "jf" tool subsystem (i.e. "rt")
+ * @param task "jf" tool task "upload", "download", etc
+ * @param args Command line arguments to pass to "jf" tool
+ * @return exit code from "jf"
+ */
+int jfrog_cli(struct JFRT_Auth *auth, const char *subsystem, const char *task, char *args);
+
+/**
+ * Issue an Artifactory server ping
+ *
+ * ```c
+ * struct JFRT_Auth auth_ctx;
+ * auth_ctx.user = strdup("myuser");
+ * auth_ctx.password = strdup("mypassword");
+ * auth_ctx.url = strdup("https://myserver.tld/artifactory");
+ * jfrt_auth_init(&auth_ctx);
+ *
+ * if (jfrog_cli_ping(&auth_ctx)) {
+ *     fprintf(stderr, "Failed to ping artifactory server: %s\n", auth_ctx.url);
+ *     exit(1);
+ * }
+ * ```
+ *
+ * @param auth JFRT_Auth structure
+ * @return exit code from "jf"
+ */
+int jfrog_cli_rt_ping(struct JFRT_Auth *auth);
+
+/**
+ * Upload files to an Artifactory repository
+ *
+ * ```c
+ * struct JFRT_Auth auth_ctx;
+ * auth_ctx.user = strdup("myuser");
+ * auth_ctx.password = strdup("mypassword");
+ * auth_ctx.url = strdup("https://myserver.tld/artifactory");
+ * jfrt_auth_init(&auth_ctx);
+ *
+ * struct JFRT_Upload upload_ctx;
+ * jfrt_upload_init(&upload_ctx);
+ *
+ * if (jfrt_cli_rt_upload(&auth_ctx, &upload_ctx,
+ *     "local/files_*.ext", "repo_name/ext_files/")) {
+ *     fprintf(stderr, "Upload failed\n");
+ *     exit(1);
+ * }
+ * ```
+ *
+ * @param auth JFRT_Auth structure
+ * @param ctx JFRT_Upload structure
+ * @param src local pattern to upload
+ * @param repo_path remote Artifactory destination path
+ * @return exit code from "jf"
+ */
+int jfrog_cli_rt_upload(struct JFRT_Auth *auth, struct JFRT_Upload *ctx, char *src, char *repo_path);
+
+/**
+ * Download a file from an Artifactory repository
+ *
+ * ```c
+ * struct JFRT_Auth auth_ctx;
+ * auth_ctx.user = strdup("myuser");
+ * auth_ctx.password = strdup("mypassword");
+ * auth_ctx.url = strdup("https://myserver.tld/artifactory");
+ * jfrt_auth_init(&auth_ctx);
+ *
+ * struct JFRT_Download download_ctx;
+ * memset(download_ctx, 0, sizeof(download_ctx));
+ *
+ * if (jfrt_cli_rt_download(&auth_ctx, &download_ctx,
+ *     "repo_name/ext_files/", "local/files_*.ext")) {
+ *     fprintf(stderr, "Upload failed\n");
+ *     exit(1);
+ * }
+ * ```
+ *
+ * @param auth JFRT_Auth structure
+ * @param ctx  JFRT_Download structure
+ * @param repo_path Remote repository w/ file pattern
+ * @param dest Local destination path
+ * @return exit code from "jf"
+ */
+int jfrog_cli_rt_download(struct JFRT_Auth *auth, struct JFRT_Download *ctx, char *repo_path, char *dest);
+
+/**
+ * Search for files in an Artifactory repository
+ *
+ * @param auth JFRT_Auth structure
+ * @param ctx  JFRT_Search structure
+ * @param repo_path Remote repository w/ file pattern
+ * @param dest Local destination path
+ * @return exit code from "jf"
+ */
+int jfrog_cli_rt_search(struct JFRT_Auth *auth, struct JFRT_Search *ctx, char *repo_path, char *pattern);
+
+/**
+ * Collect runtime data for Artifactory build object.
+ *
+ * ```c
+ * struct JFRT_Auth auth_ctx;
+ * auth_ctx.user = strdup("myuser");
+ * auth_ctx.password = strdup("mypassword");
+ * auth_ctx.url = strdup("https://myserver.tld/artifactory");
+ * jfrt_auth_init(&auth_ctx);
+ *
+ * if (jfrog_cli_rt_build_collect_env(&auth_ctx, "mybuildname", "1.2.3+gabcdef")) {
+ *     fprintf(stderr, "Failed to collect runtime data for Artifactory build object\n");
+ *     exit(1);
+ * }
+ * ```
+ *
+ * @param auth JFRT_Auth structure
+ * @param build_name Artifactory build name
+ * @param build_number Artifactory build number
+ * @return exit code from "jf"
+ */
+int jfrog_cli_rt_build_collect_env(struct JFRT_Auth *auth, char *build_name, char *build_number);
+
+/**
+ * Publish build object to Artifactory server
+ *
+ * ```c
+ * struct JFRT_Auth auth_ctx;
+ * auth_ctx.user = strdup("myuser");
+ * auth_ctx.password = strdup("mypassword");
+ * auth_ctx.url = strdup("https://myserver.tld/artifactory");
+ * jfrt_auth_init(&auth_ctx);
+ *
+ * if (jfrog_cli_rt_build_collect_env(&auth_ctx, "mybuildname", "1.2.3+gabcdef")) {
+ *     fprintf(stderr, "Failed to collect runtime data for Artifactory build object\n");
+ *     exit(1);
+ * }
+ *
+ * if (jfrog_cli_rt_build_publish(&auth_ctx, "mybuildname", "1.2.3+gabcdef")) {
+ *     fprintf(stderr, "Failed to publish Artifactory build object\n");
+ *     exit(1);
+ * }
+ * ```
+ *
+ * @param auth JFRT_Auth structure
+ * @param build_name Artifactory build name
+ * @param build_number Artifactory build number
+ * @return exit code from "jf"
+ */
+int jfrog_cli_rt_build_publish(struct JFRT_Auth *auth, char *build_name, char *build_number);
+
+/**
+ * Configure JFrog CLI authentication according to STASIS specs
+ *
+ * This function will use the STASIS_JF_* environment variables to configure the authentication
+ * context. With this in mind, if an STASIS_JF_* environment variable is not defined, the original value of
+ * the structure member will be used instead.
+ *
+ * Use STASIS_JF_* variables to configure context
+ *
+ * ```c
+ * struct JFRT_Auth auth_ctx;
+ * jfrt_auth_init(&ctx);
+ * ```
+ *
+ * Use your own input, but let the environment take over when variables are defined
+ *
+ * ```c
+ * struct JFRT_Auth auth_ctx;
+ * auth_ctx.user = strdup("myuser");
+ * auth_ctx.password = strdup("mypassword");
+ * auth_ctx.url = strdup("https://myserver.tld/artifactory");
+ * jfrt_auth_init(&auth_ctx);
+ * ```
+ *
+ * Use your own input without STASIS's help. Purely an illustrative example.
+ *
+ * ```c
+ * struct JFRT_Auth auth_ctx;
+ * memset(auth_ctx, 0, sizeof(auth_ctx));
+ * auth_ctx.user = strdup("myuser");
+ * auth_ctx.password = strdup("mypassword");
+ * auth_ctx.url = strdup("https://myserver.tld/artifactory");
+ * ```
+ *
+ * @param auth_ctx
+ * @return
+ */
+int jfrt_auth_init(struct JFRT_Auth *auth_ctx);
+
+/**
+ * Zero-out and apply likely defaults to a JFRT_Upload structure
+ * @param ctx JFRT_Upload structure
+ */
+void jfrt_upload_init(struct JFRT_Upload *ctx);
+
+#endif //STASIS_ARTIFACTORY_H
\ No newline at end of file
diff --git a/src/lib/core/include/conda.h b/src/lib/core/include/conda.h
new file mode 100644
index 0000000..b8d0caa
--- /dev/null
+++ b/src/lib/core/include/conda.h
@@ -0,0 +1,234 @@
+//! @file conda.h
+#ifndef STASIS_CONDA_H
+#define STASIS_CONDA_H
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/utsname.h>
+#include "core.h"
+#include "download.h"
+
+#define CONDA_INSTALL_PREFIX "conda"
+#define PYPI_INDEX_DEFAULT "https://pypi.org/simple"
+
+#define PKG_USE_PIP 0
+#define PKG_USE_CONDA 1
+
+#define PKG_NOT_FOUND 0
+#define PKG_FOUND 1
+
+#define PKG_INDEX_PROVIDES_ERROR_MESSAGE_OFFSET (-10)
+#define PKG_E_SUCCESS (PKG_INDEX_PROVIDES_ERROR_MESSAGE_OFFSET + 0)
+#define PKG_INDEX_PROVIDES_E_INTERNAL_MODE_UNKNOWN (PKG_INDEX_PROVIDES_ERROR_MESSAGE_OFFSET + 1)
+#define PKG_INDEX_PROVIDES_E_INTERNAL_LOG_HANDLE (PKG_INDEX_PROVIDES_ERROR_MESSAGE_OFFSET + 2)
+#define PKG_INDEX_PROVIDES_E_MANAGER_RUNTIME (PKG_INDEX_PROVIDES_ERROR_MESSAGE_OFFSET + 3)
+#define PKG_INDEX_PROVIDES_E_MANAGER_SIGNALED (PKG_INDEX_PROVIDES_ERROR_MESSAGE_OFFSET + 4)
+#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 MicromambaInfo {
+    char *micromamba_prefix;    //!< Path to write micromamba binary
+    char *conda_prefix;         //!< Path to install conda base tree
+};
+
+/**
+ * Execute micromamba
+ * @param info MicromambaInfo data structure (must be populated before use)
+ * @param command printf-style formatter string
+ * @param ... variadic arguments
+ * @return exit code
+ */
+int micromamba(struct MicromambaInfo *info, char *command, ...);
+
+/**
+ * Execute Python
+ * Python interpreter is determined by PATH
+ *
+ * ```c
+ * if (python_exec("-c 'printf(\"Hello world\")'")) {
+ *     fprintf(stderr, "Hello world failed\n");
+ *     exit(1);
+ * }
+ * ```
+ *
+ * @param args arguments to pass to interpreter
+ * @return exit code from python interpreter
+ */
+int python_exec(const char *args);
+
+/**
+ * Execute Pip
+ * Pip is determined by PATH
+ *
+ * ```c
+ * if (pip_exec("freeze")) {
+ *     fprintf(stderr, "pip freeze failed\n");
+ *     exit(1);
+ * }
+ * ```
+ *
+ * @param args arguments to pass to Pip
+ * @return exit code from Pip
+ */
+int pip_exec(const char *args);
+
+/**
+ * Execute conda (or if possible, mamba)
+ * Conda/Mamba is determined by PATH
+ *
+ * ```c
+ * if (conda_exec("env list")) {
+ *     fprintf(stderr, "Failed to list conda environments\n");
+ *     exit(1);
+ * }
+ * ```
+ *
+ * @param args arguments to pass to Conda
+ * @return exit code from Conda
+ */
+int conda_exec(const char *args);
+
+/**
+ * Configure the runtime environment to use Conda/Mamba
+ *
+ * ```c
+ * if (conda_activate("/path/to/conda/installation", "base")) {
+ *     fprintf(stderr, "Failed to activate conda's base environment\n");
+ *     exit(1);
+ * }
+ * ```
+ *
+ * @param root directory where conda is installed
+ * @param env_name the conda environment to activate
+ * @return 0 on success, -1 on error
+ */
+int conda_activate(const char *root, const char *env_name);
+
+/**
+ * Configure the active conda installation for headless operation
+ */
+int conda_setup_headless();
+
+/**
+ * Creates a Conda environment from a YAML config
+ *
+ * ```c
+ * if (conda_env_create_from_uri("myenv", "https://myserver.tld/environment.yml")) {
+ *     fprintf(stderr, "Environment creation failed\n");
+ *     exit(1);
+ * }
+ * ```
+ *
+ * @param name Name of new environment to create
+ * @param uri /path/to/environment.yml
+ * @param uri file:///path/to/environment.yml
+ * @param uri http://myserver.tld/environment.yml
+ * @param uri https://myserver.tld/environment.yml
+ * @param uri ftp://myserver.tld/environment.yml
+ * @return exit code from "conda"
+ */
+int conda_env_create_from_uri(char *name, char *uri);
+
+/**
+ * Create a Conda environment using generic package specs
+ *
+ * ```c
+ * // Create a basic environment without any conda packages
+ * if (conda_env_create("myenv", "3.11", NULL)) {
+ *     fprintf(stderr, "Environment creation failed\n");
+ *     exit(1);
+ * }
+ *
+ * // Create a basic environment and install conda packages
+ * if (conda_env_create("myenv", "3.11", "hstcal fitsverify")) {
+ *     fprintf(stderr, "Environment creation failed\n");
+ *     exit(1);
+ * }
+ * ```
+ *
+ * @param name Environment name
+ * @param python_version Desired version of Python
+ * @param packages Packages to install (or NULL)
+ * @return exit code from "conda"
+ */
+int conda_env_create(char *name, char *python_version, char *packages);
+
+/**
+ * Remove a Conda environment
+ *
+ * ```c
+ * if (conda_env_remove("myenv")) {
+ *     fprintf(stderr, "Unable to remove conda environment\n");
+ *     exit(1);
+ * }
+ * ```
+ *
+ * @param name Environment name
+ * @return exit code from "conda"
+ */
+int conda_env_remove(char *name);
+
+/**
+ * Export a Conda environment in YAML format
+ *
+ * ```c
+ * if (conda_env_export("myenv", "./", "myenv.yml")) {
+ *     fprintf(stderr, "Unable to export environment\n");
+ *     exit(1);
+ * }
+ * ```
+ *
+ * @param name Environment name to export
+ * @param output_dir Destination directory
+ * @param output_filename Destination file name
+ * @return exit code from "conda"
+ */
+int conda_env_export(char *name, char *output_dir, char *output_filename);
+
+/**
+ * Run "conda index" on a local conda channel
+ *
+ * ```c
+ * if (conda_index("/path/to/channel")) {
+ *     fprintf(stderr, "Unable to index requested path\n");
+ *     exit(1);
+ * }
+ * ```
+ *
+ * @param path Top-level directory of conda channel
+ * @return exit code from "conda"
+ */
+int conda_index(const char *path);
+
+/**
+ * Determine whether a package index contains a package
+ *
+ * ```c
+ * int result = pkg_index_provides(USE_PIP, NULL, "numpy>1.26");
+ * if (PKG_INDEX_PROVIDES_FAILED(result)) {
+ *     fprintf(stderr, "failed: %s\n", pkg_index_provides_strerror(result));
+ *     exit(1);
+ * } else if (result == PKG_NOT_FOUND) {
+ *     // package does not exist upstream
+ * } else {
+ *     // package exists upstream
+ * }
+ * ```
+ *
+ * @param mode USE_PIP
+ * @param mode USE_CONDA
+ * @param index a file system path or url pointing to a simple index or conda channel
+ * @param spec a pip package specification (e.g. `name==1.2.3`)
+ * @param spec a conda package specification (e.g. `name=1.2.3`)
+ * @return PKG_NOT_FOUND, if not found
+ * @return PKG_FOUND, if found
+ * @return PKG_E_INDEX_PROVIDES_{ERROR}, on error (see conda.h)
+ */
+int pkg_index_provides(int mode, const char *index, const char *spec);
+const char *pkg_index_provides_strerror(int code);
+
+char *conda_get_active_environment();
+
+int conda_env_exists(const char *root, const char *name);
+
+#endif //STASIS_CONDA_H
diff --git a/src/lib/core/include/copy.h b/src/lib/core/include/copy.h
new file mode 100644
index 0000000..0f92ddd
--- /dev/null
+++ b/src/lib/core/include/copy.h
@@ -0,0 +1,35 @@
+//! @file copy.h
+#ifndef STASIS_COPY_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dirent.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include "core.h"
+
+#define CT_OWNER 1 << 1
+#define CT_PERM 1 << 2
+
+/**
+ * Copy a single file
+ *
+ * ```c
+ * if (copy2("/source/path/example.txt", "/destination/path/example.txt", CT_PERM | CT_OWNER)) {
+ *     fprintf(stderr, "Unable to copy file\n");
+ *     exit(1);
+ * }
+ * ```
+ *
+ *
+ * @param src source file path
+ * @param dest destination file path
+ * @param op CT_OWNER (preserve ownership)
+ * @param op CT_PERM (preserve permission bits)
+ * @return 0 on success, -1 on error
+ */
+int copy2(const char *src, const char *dest, unsigned op);
+
+#endif // STASIS_COPY_H
\ No newline at end of file
diff --git a/src/lib/core/include/core.h b/src/lib/core/include/core.h
new file mode 100644
index 0000000..362ac8d
--- /dev/null
+++ b/src/lib/core/include/core.h
@@ -0,0 +1,85 @@
+//! @file core.h
+#ifndef STASIS_CORE_H
+#define STASIS_CORE_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include <limits.h>
+#include <unistd.h>
+#include <time.h>
+#include <sys/statvfs.h>
+
+#define SYSERROR(MSG, ...) do { \
+    fprintf(stderr, "%s:%s:%d:%s - ", path_basename(__FILE__), __FUNCTION__, __LINE__, (errno > 0) ? strerror(errno) : "info"); \
+    fprintf(stderr, MSG LINE_SEP, __VA_ARGS__); \
+} while (0)
+#define STASIS_BUFSIZ 8192
+#define STASIS_NAME_MAX 255
+#define STASIS_DIRSTACK_MAX 1024
+#define STASIS_TIME_STR_MAX 128
+#define HTTP_ERROR(X) X >= 400
+
+#include "config.h"
+#include "core_mem.h"
+
+#define COE_CHECK_ABORT(COND, MSG) \
+    do {\
+        if (!globals.continue_on_error && COND) { \
+            msg(STASIS_MSG_ERROR, MSG ": Aborting execution (--continue-on-error/-C is not enabled)\n"); \
+            exit(1);                       \
+        } \
+    } while (0)
+
+struct STASIS_GLOBAL {
+    bool verbose; //!< Enable verbose output
+    bool always_update_base_environment; //!< Update base environment immediately after activation
+    bool continue_on_error; //!< Do not stop on test failures
+    bool conda_fresh_start; //!< Always install a new copy of Conda
+    bool enable_docker; //!< Enable docker image builds
+    bool enable_artifactory; //!< Enable artifactory uploads
+    bool enable_artifactory_build_info; //!< Enable build info (best disabled for pure test runs)
+    bool enable_artifactory_upload; //!< Enable artifactory file upload (dry-run when false)
+    bool enable_testing; //!< Enable package testing
+    bool enable_overwrite; //!< Enable release file clobbering
+    bool enable_rewrite_spec_stage_2; //!< Enable automatic @STR@ replacement in output files
+    bool enable_parallel; //!< Enable testing in parallel
+    long cpu_limit; //!< Limit parallel processing to n cores (default: max - 1)
+    long parallel_fail_fast; //!< Fail immediately on error
+    int pool_status_interval; //!< Report "Task is running" every n seconds
+    struct StrList *conda_packages; //!< Conda packages to install after initial activation
+    struct StrList *pip_packages; //!< Pip packages to install after initial activation
+    char *tmpdir; //!< Path to temporary storage directory
+    char *conda_install_prefix; //!< Path to install conda
+    char *sysconfdir; //!< Path where STASIS reads its configuration files (mission directory, etc)
+    struct {
+        char *tox_posargs;
+        char *conda_reactivate;
+    } workaround;
+    struct Jfrog {
+        char *jfrog_artifactory_base_url;
+        char *jfrog_artifactory_product;
+        char *cli_major_ver;
+        char *version;
+        char *os;
+        char *arch;
+        char *remote_filename;
+        char *repo;
+        char *url;
+    } jfrog;
+    struct EnvCtl *envctl;
+};
+extern struct STASIS_GLOBAL globals;
+
+extern const char *VERSION;
+extern const char *AUTHOR;
+extern const char *BANNER;
+
+
+/**
+ * Free memory allocated in global configuration structure
+ */
+void globals_free();
+
+#endif //STASIS_CORE_H
diff --git a/src/lib/core/include/core_mem.h b/src/lib/core/include/core_mem.h
new file mode 100644
index 0000000..bd50e9d
--- /dev/null
+++ b/src/lib/core/include/core_mem.h
@@ -0,0 +1,18 @@
+//! @file core_mem.h
+#ifndef STASIS_CORE_MEM_H
+#define STASIS_CORE_MEM_H
+
+#include "environment.h"
+#include "strlist.h"
+
+#define guard_runtime_free(X) do { if (X) { runtime_free(X); X = NULL; } } while (0)
+#define guard_strlist_free(X) do { if ((*X)) { strlist_free(X); (*X) = NULL; } } while (0)
+#define guard_free(X) do { if (X) { free(X); X = NULL; } } while (0)
+#define GENERIC_ARRAY_FREE(ARR) do { \
+    for (size_t ARR_I = 0; ARR && ARR[ARR_I] != NULL; ARR_I++) { \
+        guard_free(ARR[ARR_I]); \
+    } \
+    guard_free(ARR); \
+} while (0)
+
+#endif //STASIS_CORE_MEM_H
diff --git a/src/lib/core/include/docker.h b/src/lib/core/include/docker.h
new file mode 100644
index 0000000..7585d86
--- /dev/null
+++ b/src/lib/core/include/docker.h
@@ -0,0 +1,92 @@
+//! @file docker.h
+#ifndef STASIS_DOCKER_H
+#define STASIS_DOCKER_H
+
+#include "core.h"
+
+//! Flag to squelch output from docker_exec()
+#define STASIS_DOCKER_QUIET 1 << 1
+
+//! Flag for older style docker build
+#define STASIS_DOCKER_BUILD 1 << 1
+//! Flag for docker buildx
+#define STASIS_DOCKER_BUILD_X 1 << 2
+
+//! Compress "docker save"ed images with a compression program
+#define STASIS_DOCKER_IMAGE_COMPRESSION "zstd"
+
+struct DockerCapabilities {
+    int podman;  //!< Is "docker" really podman?
+    int build;  //!< Is a build plugin available?
+    int available;  //!< Is a "docker" program available?
+    int usable;  //!< Is docker in a usable state for the current user?
+};
+
+/**
+ * Determine the state of docker on the system
+ *
+ * ```c
+ * struct DockerCapabilities docker_is;
+ * if (!docker_capable(&docker_is)) {
+ *     fprintf(stderr, "%s is %savailable, and %susable\n",
+ *         docker_is.podman ? "Podman" : "Docker",
+ *         docker_is.available ? "" : "not ",
+ *         docker_is.usable ? "" : "not ");
+ *     exit(1);
+ * }
+ * ```
+ *
+ * @param result DockerCapabilities struct
+ * @return 1 on success, 0 on error
+ */
+int docker_capable(struct DockerCapabilities *result);
+
+/**
+ * Execute a docker command
+ *
+ * Use the `STASIS_DOCKER_QUIET` flag to suppress all output from stdout and stderr.
+ *
+ * ```c
+ * if (docker_exec("run --rm -t ubuntu:latest /bin/bash -c 'echo Hello world'", 0)) {
+ *     fprintf(stderr, "Docker hello world failed\n");
+ *     exit(1);
+ * }
+ * ```
+ *
+ * @param args arguments to pass to docker
+ * @param flags
+ * @return exit code from "docker"
+ */
+int docker_exec(const char *args, unsigned flags);
+
+/**
+ * Build a docker image
+ *
+ * ```c
+ * struct DockerCapabilities docker_is;
+ * docker_capable(&docker_is);
+ *
+ * if (docker_is.usable) {
+ *     printf("Building docker image\n");
+ *     if (docker_build("path/to/Dockerfile/dir")) {
+ *         fprintf("Docker build failed\n");
+ *         exit(1);
+ *     }
+ * } else {
+ *     fprintf(stderr, "No usable docker installation available\n");
+ * }
+ * ```
+ *
+ * @param dirpath
+ * @param args
+ * @param engine
+ * @return
+ */
+int docker_build(const char *dirpath, const char *args, int engine);
+int docker_script(const char *image, char *data, unsigned flags);
+int docker_save(const char *image, const char *destdir, const char *compression_program);
+void docker_sanitize_tag(char *str);
+int docker_validate_compression_program(char *prog);
+
+
+#endif //STASIS_DOCKER_H
diff --git a/src/lib/core/include/download.h b/src/lib/core/include/download.h
new file mode 100644
index 0000000..0b6311e
--- /dev/null
+++ b/src/lib/core/include/download.h
@@ -0,0 +1,12 @@
+//! @file download.h
+#ifndef STASIS_DOWNLOAD_H
+#define STASIS_DOWNLOAD_H
+
+#include <stdlib.h>
+#include <string.h>
+#include <curl/curl.h>
+
+size_t download_writer(void *fp, size_t size, size_t nmemb, void *stream);
+long download(char *url, const char *filename, char **errmsg);
+
+#endif //STASIS_DOWNLOAD_H
diff --git a/src/lib/core/include/envctl.h b/src/lib/core/include/envctl.h
new file mode 100644
index 0000000..659cae3
--- /dev/null
+++ b/src/lib/core/include/envctl.h
@@ -0,0 +1,39 @@
+//! @file envctl.h
+#ifndef STASIS_ENVCTL_H
+#define STASIS_ENVCTL_H
+
+#include <stdlib.h>
+#include "core.h"
+
+#define STASIS_ENVCTL_PASSTHRU 0
+#define STASIS_ENVCTL_REQUIRED 1 << 1
+#define STASIS_ENVCTL_REDACT 1 << 2
+#define STASIS_ENVCTL_DEFAULT_ALLOC 100
+
+#define STASIS_ENVCTL_RET_FAIL (-1)
+#define STASIS_ENVCTL_RET_SUCCESS 1
+#define STASIS_ENVCTL_RET_IGNORE 2
+typedef int (envctl_except_fn)(const void *, const void *);
+
+struct EnvCtl_Item {
+    unsigned flags; //<! One or more STASIS_ENVCTL_* flags
+    const char *name; //<! Environment variable name
+    envctl_except_fn *callback;
+};
+
+struct EnvCtl {
+    size_t num_alloc;
+    size_t num_used;
+    struct EnvCtl_Item **item;
+};
+
+struct EnvCtl *envctl_init();
+int envctl_register(struct EnvCtl **envctl, unsigned flags, envctl_except_fn *callback, const char *name);
+unsigned envctl_get_flags(const struct EnvCtl *envctl, const char *name);
+unsigned envctl_check_required(unsigned flags);
+unsigned envctl_check_redact(unsigned flags);
+int envctl_check_present(const struct EnvCtl_Item *item, const char *name);
+void envctl_do_required(const struct EnvCtl *envctl, int verbose);
+void envctl_free(struct EnvCtl **envctl);
+
+#endif // STASIS_ENVCTL_H
\ No newline at end of file
diff --git a/src/lib/core/include/environment.h b/src/lib/core/include/environment.h
new file mode 100644
index 0000000..34bc600
--- /dev/null
+++ b/src/lib/core/include/environment.h
@@ -0,0 +1,23 @@
+/**
+ * @file environment.h
+ */
+#ifndef STASIS_ENVIRONMENT_H
+#define STASIS_ENVIRONMENT_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <dirent.h>
+#include "environment.h"
+
+typedef struct StrList RuntimeEnv;
+
+ssize_t runtime_contains(RuntimeEnv *env, const char *key);
+RuntimeEnv *runtime_copy(char **env);
+int runtime_replace(RuntimeEnv **dest, char **src);
+char *runtime_get(RuntimeEnv *env, const char *key);
+void runtime_set(RuntimeEnv *env, const char *_key, char *_value);
+char *runtime_expand_var(RuntimeEnv *env, char *input);
+void runtime_export(RuntimeEnv *env, char **keys);
+void runtime_apply(RuntimeEnv *env);
+void runtime_free(RuntimeEnv *env);
+#endif //STASIS_ENVIRONMENT_H
diff --git a/src/lib/core/include/github.h b/src/lib/core/include/github.h
new file mode 100644
index 0000000..f9b47a3
--- /dev/null
+++ b/src/lib/core/include/github.h
@@ -0,0 +1,11 @@
+//! @file github.h
+#ifndef STASIS_GITHUB_H
+#define STASIS_GITHUB_H
+
+#include <curl/curl.h>
+
+#define STASIS_GITHUB_API_VERSION "2022-11-28"
+
+int get_github_release_notes(const char *api_token, const char *repo, const char *tag, const char *target_commitish, char **output);
+
+#endif //STASIS_GITHUB_H
\ No newline at end of file
diff --git a/src/lib/core/include/ini.h b/src/lib/core/include/ini.h
new file mode 100644
index 0000000..557f157
--- /dev/null
+++ b/src/lib/core/include/ini.h
@@ -0,0 +1,260 @@
+/// @file ini.h
+
+#ifndef STASIS_INI_H
+#define STASIS_INI_H
+#include <stdio.h>
+#include <stddef.h>
+#include <stdbool.h>
+#include "template.h"
+
+#define INI_WRITE_RAW 0             ///< Dump INI data. Contents are not modified.
+#define INI_WRITE_PRESERVE 1        ///< Dump INI data. Template strings are
+#define INI_READ_RAW 0             ///< Dump INI data. Contents are not modified.
+#define INI_READ_RENDER 1        ///< Dump INI data. Template strings are
+#define INI_SETVAL_APPEND 0
+#define INI_SETVAL_REPLACE 1
+#define INI_SEARCH_EXACT 0
+#define INI_SEARCH_BEGINS 1
+#define INI_SEARCH_SUBSTR 2
+                                    ///< expanded to preserve runtime state.
+
+#define INIVAL_TYPE_CHAR 1          ///< Byte
+#define INIVAL_TYPE_UCHAR 2         ///< Unsigned byte
+#define INIVAL_TYPE_SHORT 3         ///< Short integer
+#define INIVAL_TYPE_USHORT 4        ///< Unsigned short integer
+#define INIVAL_TYPE_INT 5           ///< Integer
+#define INIVAL_TYPE_UINT 6          ///< Unsigned integer
+#define INIVAL_TYPE_LONG 7          ///< Long integer
+#define INIVAL_TYPE_ULONG 8         ///< Unsigned long integer
+#define INIVAL_TYPE_LLONG 9         ///< Long long integer
+#define INIVAL_TYPE_ULLONG 10       ///< Unsigned long long integer
+#define INIVAL_TYPE_DOUBLE 11       ///< Double precision float
+#define INIVAL_TYPE_FLOAT 12        ///< Single precision float
+#define INIVAL_TYPE_STR 13          ///< String
+#define INIVAL_TYPE_STR_ARRAY 14    ///< String Array
+#define INIVAL_TYPE_BOOL 15         ///< Boolean
+
+#define INIVAL_TO_LIST 1 << 1
+
+/*! \union INIVal
+ * \brief Consolidate possible value types
+ */
+union INIVal {
+    char as_char;                    ///< Byte
+    unsigned char as_uchar;          ///< Unsigned byte
+    short as_short;                  ///< Short integer
+    unsigned short as_ushort;        ///< Unsigned short integer
+    int as_int;                      ///< Integer
+    unsigned as_uint;                ///< Unsigned integer
+    long as_long;                    ///< Long integer
+    unsigned long as_ulong;          ///< Unsigned long integer
+    long long as_llong;              ///< Long long integer
+    unsigned long long as_ullong;    ///< Unsigned long long integer
+    double as_double;                ///< Double precision float
+    float as_float;                  ///< Single precision float
+    char *as_char_p;                 ///< String
+    char **as_char_array_p;          ///< String Array
+    bool as_bool;                    ///< Boolean
+};
+
+
+/*! \struct INIData
+ * \brief A structure to describe an INI data record
+ */
+struct INIData {
+    char *key;                       ///< INI variable name
+    char *value;                     ///< INI variable value
+    unsigned type_hint;
+};
+
+/*! \struct INISection
+ * \brief A structure to describe an INI section
+ */
+struct INISection {
+    size_t data_count;               ///< Total INIData records
+    char *key;                       ///< INI section name
+    struct INIData **data;           ///< Array of INIData records
+};
+
+/*! \struct INIFILE
+ * \brief A structure to describe an INI configuration file
+ */
+struct INIFILE {
+    size_t section_count;            ///< Total INISection records
+    struct INISection **section;     ///< Array of INISection records
+};
+
+/**
+ * Open and parse and INI configuration file
+ *
+ * ~~~.c
+ * #include "ini.h"
+ * int main(int argc, char *argv[]) {
+ *     const char *filename = "example.ini"
+ *     struct INIFILE *ini;
+ *     ini = ini_open(filename);
+ *     if (!ini) {
+ *         perror(filename);
+ *         exit(1);
+ *     }
+ * }
+ * ~~~
+ *
+ * @param filename path to INI file
+ * @return pointer to INIFILE
+ */
+struct INIFILE *ini_open(const char *filename);
+
+/**
+ *
+ * @param ini
+ * @param value
+ * @return
+ */
+struct INISection *ini_section_search(struct INIFILE **ini, unsigned mode, const char *value);
+
+/**
+ *
+ * @param ini
+ * @param key
+ * @return
+ */
+int ini_section_create(struct INIFILE **ini, char *key);
+
+/**
+ * 
+ * @param ini 
+ * @param section 
+ * @param key 
+ * @return 
+ */
+int ini_has_key(struct INIFILE *ini, const char *section, const char *key);
+
+/**
+ * Assign value to a section key
+ * @param ini
+ * @param type INI_SETVAL_APPEND or INI_SETVAL_REPLACE
+ * @param section_name
+ * @param key
+ * @param value
+ * @return
+ */
+int ini_setval(struct INIFILE **ini, unsigned type, char *section_name, char *key, char *value);
+
+/**
+ * Retrieve all data records in an INI section
+ *
+ * `example.ini`
+ * ~~~.ini
+ * [example]
+ * key_1 = a string
+ * key_2 = 100
+ * ~~~
+ *
+ * `example.c`
+ * ~~~.c
+ * #include "ini.h"
+ * int main(int argc, char *argv[]) {
+ *     const char *filename = "example.ini"
+ *     struct INIData *data;
+ *     struct INIFILE *ini;
+ *     ini = ini_open(filename);
+ *     if (!ini) {
+ *         perror(filename);
+ *         exit(1);
+ *     }
+ *     // Read all records in "example" section
+ *     for (size_t i = 0; ((data = ini_getall(&ini, "example") != NULL); i++) {
+ *         printf("key=%s, value=%s\n", data->key, data->value);
+ *     }
+ * }
+ * ~~~
+ *
+ * @param ini pointer to INIFILE
+ * @param section_name to read
+ * @return pointer to INIData
+ */
+struct INIData *ini_getall(struct INIFILE *ini, char *section_name);
+
+/**
+ * Retrieve a single record from a section key
+ *
+ * `example.ini`
+ * ~~~.ini
+ * [example]
+ * key_1 = a string
+ * key_2 = 100
+ * ~~~
+ *
+ * `example.c`
+ * ~~~.c
+ * #include "ini.h"
+ * int main(int argc, char *argv[]) {
+ *     const char *filename = "example.ini"
+ *     union INIVal *data;
+ *     struct INIFILE *ini;
+ *     ini = ini_open(filename);
+ *     if (!ini) {
+ *         perror(filename);
+ *         exit(1);
+ *     }
+ *     data = ini_getval(&ini, "example", "key_1", INIVAL_TYPE_STR);
+ *     puts(data.as_char_p);
+ *     data = ini_getval(&ini, "example", "key_2", INIVAL_TYPE_INT);
+ *     printf("%d\n", data.as_int);
+ * }
+ * ~~~
+ *
+ * @param ini pointer to INIFILE
+ * @param section_name to read
+ * @param key to return
+ * @param type INIVAL_TYPE_INT
+ * @param type INIVAL_TYPE_UINT
+ * @param type INIVAL_TYPE_LONG
+ * @param type INIVAL_TYPE_ULONG
+ * @param type INIVAL_TYPE_LLONG
+ * @param type INIVAL_TYPE_ULLONG
+ * @param type INIVAL_TYPE_DOUBLE
+ * @param type INIVAL_TYPE_FLOAT
+ * @param type INIVAL_TYPE_STR
+ * @param type INIVAL_TYPE_STR_ARRAY
+ * @param type INIVAL_TYPE_BOOL
+ * @param result pointer to INIVal
+ * @return 0 on success
+ * @return Non-zero on error
+ */
+int ini_getval(struct INIFILE *ini, char *section_name, char *key, int type, int flags, union INIVal *result);
+
+/**
+ * Write INIFILE sections and data to a file stream
+ * @param ini pointer to INIFILE
+ * @param file pointer to address of file stream
+ * @return 0 on success, -1 on error
+ */
+int ini_write(struct INIFILE *ini, FILE **stream, unsigned mode);
+
+/**
+ * Free memory allocated by ini_open()
+ * @param ini
+ */
+void ini_free(struct INIFILE **ini);
+
+int ini_getval_int(struct INIFILE *ini, char *section_name, char *key, int flags, int *state);
+unsigned int ini_getval_uint(struct INIFILE *ini, char *section_name, char *key, int flags, int *state);
+long ini_getval_long(struct INIFILE *ini, char *section_name, char *key, int flags, int *state);
+unsigned long ini_getval_ulong(struct INIFILE *ini, char *section_name, char *key, int flags, int *state);
+long long ini_getval_llong(struct INIFILE *ini, char *section_name, char *key, int flags, int *state);
+unsigned long long ini_getval_ullong(struct INIFILE *ini, char *section_name, char *key, int flags, int *state);
+float ini_getval_float(struct INIFILE *ini, char *section_name, char *key, int flags, int *state);
+double ini_getval_double(struct INIFILE *ini, char *section_name, char *key, int flags, int *state);
+bool ini_getval_bool(struct INIFILE *ini, char *section_name, char *key, int flags, int *state);
+short ini_getval_short(struct INIFILE *ini, char *section_name, char *key, int flags, int *state);
+unsigned short ini_getval_ushort(struct INIFILE *ini, char *section_name, char *key, int flags, int *state);
+char ini_getval_char(struct INIFILE *ini, char *section_name, char *key, int flags, int *state);
+unsigned char ini_getval_uchar(struct INIFILE *ini, char *section_name, char *key, int flags, int *state);
+char *ini_getval_char_p(struct INIFILE *ini, char *section_name, char *key, int flags, int *state);
+char *ini_getval_str(struct INIFILE *ini, char *section_name, char *key, int flags, int *state);
+char *ini_getval_char_array_p(struct INIFILE *ini, char *section_name, char *key, int flags, int *state);
+char *ini_getval_str_array(struct INIFILE *ini, char *section_name, char *key, int flags, int *state);
+struct StrList *ini_getval_strlist(struct INIFILE *ini, char *section_name, char *key, char *tok, int flags, int *state);
+#endif //STASIS_INI_H
diff --git a/src/lib/core/include/junitxml.h b/src/lib/core/include/junitxml.h
new file mode 100644
index 0000000..777ee27
--- /dev/null
+++ b/src/lib/core/include/junitxml.h
@@ -0,0 +1,135 @@
+/// @file junitxml.h
+#ifndef STASIS_JUNITXML_H
+#define STASIS_JUNITXML_H
+#include <libxml/xmlreader.h>
+
+#define JUNIT_RESULT_STATE_NONE 0
+#define JUNIT_RESULT_STATE_FAILURE 1
+#define JUNIT_RESULT_STATE_SKIPPED 2
+#define JUNIT_RESULT_STATE_ERROR 3
+
+/**
+ * Represents a failed test case
+ */
+struct JUNIT_Failure {
+    /// Error text
+    char *message;
+};
+
+/**
+ * Represents a test case error
+ */
+struct JUNIT_Error {
+    /// Error text
+    char *message;
+};
+
+/**
+ * Represents a skipped test case
+ */
+struct JUNIT_Skipped {
+    /// Type of skip event
+    char *type;
+    /// Reason text
+    char *message;
+};
+
+/**
+ * Represents a junit test case
+ */
+struct JUNIT_Testcase {
+    /// Class name
+    char *classname;
+    /// Name of test
+    char *name;
+    /// Test duration in fractional seconds
+    float time;
+    /// Standard output message
+    char *message;
+    /// Result type
+    int tc_result_state_type;
+    /// Type container for result (there can only be one)
+    union tc_state_ptr {
+        struct JUNIT_Failure *failure;
+        struct JUNIT_Skipped *skipped;
+        struct JUNIT_Error *error;
+    } result_state; ///< Result data
+};
+
+/**
+ * Represents a junit test suite
+ */
+struct JUNIT_Testsuite {
+    /// Test suite name
+    char *name;
+    /// Total number of test terminated due to an error
+    int errors;
+    /// Total number of failed tests
+    int failures;
+    /// Total number of skipped tests
+    int skipped;
+    /// Total number of tests
+    int tests;
+    /// Total duration in fractional seconds
+    float time;
+    /// Timestamp
+    char *timestamp;
+    /// Test runner host name
+    char *hostname;
+    /// Array of test cases
+    struct JUNIT_Testcase **testcase;
+    /// Total number of test cases in use
+    size_t _tc_inuse;
+    /// Total number of test cases allocated
+    size_t _tc_alloc;
+};
+
+/**
+ * Extract information from a junit XML file
+ *
+ * ~~~{.c}
+ * struct JUNIT_Testsuite *testsuite;
+ * const char *filename = "/path/to/result.xml";
+ *
+ * testsuite = junitxml_testsuite_read(filename);
+ * if (testsuite) {
+ *     // Did any test cases fail?
+ *     if (testsuite->failures) {
+ *         printf("Test suite '%s' has %d failure(s)\n", testsuite->name, testsuite->failures
+ *         // Scan test cases for failure data
+ *         for (size_t i = 0; i < testsuite->_tc_inuse; i++) {
+ *             // Check result state (one of)
+ *             //   JUNIT_RESULT_STATE_FAILURE
+ *             //   JUNIT_RESULT_STATE_ERROR
+ *             //   JUNIT_RESULT_STATE_SKIPPED
+ *             struct JUNIT_Testcase *testcase = testsuite->testcase[i];
+ *             if (testcase->tc_result_state_type) {
+ *                 if (testcase->tc_result_state_type == JUNIT_RESULT_STATE_FAILURE) {
+ *                     // Display information from failed test case
+ *                     printf("[FAILED] %s::%s\nOutput:\n%s\n",
+ *                         testcase->classname,
+ *                         testcase->name,
+ *                         testcase->result_state.failure->message);
+ *                 }
+ *             }
+ *         }
+ *     }
+ *     // Release test suite resources
+ *     junitxml_testsuite_free(&testsuite);
+ * } else {
+ *     // handle error
+ * }
+ * ~~~
+ *
+ * @param filename path to junit XML file
+ * @return pointer to JUNIT_Testsuite
+ */
+struct JUNIT_Testsuite *junitxml_testsuite_read(const char *filename);
+
+/**
+ * Free memory allocated by junitxml_testsuite_read
+ * @param testsuite pointer to JUNIT_Testsuite
+ */
+void junitxml_testsuite_free(struct JUNIT_Testsuite **testsuite);
+
+#endif //STASIS_JUNITXML_H
diff --git a/src/lib/core/include/multiprocessing.h b/src/lib/core/include/multiprocessing.h
new file mode 100644
index 0000000..ec7c1ad
--- /dev/null
+++ b/src/lib/core/include/multiprocessing.h
@@ -0,0 +1,134 @@
+/// @file multiprocessing.h
+#ifndef STASIS_MULTIPROCESSING_H
+#define STASIS_MULTIPROCESSING_H
+
+#include "core.h"
+#include <signal.h>
+#include <sys/wait.h>
+#include <semaphore.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+
+struct MultiProcessingTask {
+    pid_t pid; ///< Program PID
+    pid_t parent_pid; ///< Program PID (parent process)
+    int status; ///< Child process exit status
+    int signaled_by; ///< Last signal received, if any
+    time_t _now; ///< Current time
+    time_t _seconds; ///< Time elapsed (used by MultiprocessingPool.status_interval)
+    char ident[255]; ///< Identity of the pool task
+    char *cmd; ///< Shell command(s) to be executed
+    size_t cmd_len; ///< Length of command string (for mmap/munmap)
+    char working_dir[PATH_MAX]; ///< Path to directory `cmd` should be executed in
+    char log_file[PATH_MAX]; ///< Full path to stdout/stderr log file
+    char parent_script[PATH_MAX]; ///< Path to temporary script executing the task
+    struct {
+        struct timespec t_start;
+        struct timespec t_stop;
+    } time_data; ///< Wall-time counters
+};
+
+struct MultiProcessingPool {
+    struct MultiProcessingTask *task; ///< Array of tasks to execute
+    size_t num_used; ///< Number of tasks populated in the task array
+    size_t num_alloc; ///< Number of tasks allocated by the task array
+    char ident[255]; ///< Identity of task pool
+    char log_root[PATH_MAX]; ///< Base directory to store stderr/stdout log files
+    int status_interval; ///< Report a pooled task is "running" every n seconds
+};
+
+/// A multiprocessing task's initial state (i.e. "FAIL")
+#define MP_POOL_TASK_STATUS_INITIAL (-1)
+
+/// Maximum number of multiprocessing tasks STASIS can execute
+#define MP_POOL_TASK_MAX 1000
+
+/// Value signifies a process is unused or finished executing
+#define MP_POOL_PID_UNUSED 0
+
+/// Option flags for mp_pool_join()
+#define MP_POOL_FAIL_FAST 1 << 1
+
+/**
+ * Create a multiprocessing pool
+ *
+ * ```c
+ * #include "multiprocessing.h"
+ * #include "utils.h" // for get_cpu_count()
+ *
+ * int main(int argc, char *argv[]) {
+ *     struct MultiProcessingPool *mp;
+ *     mp = mp_pool_init("mypool", "/tmp/mypool_logs");
+ *     if (mp) {
+ *         char *commands[] = {
+ *             "/bin/echo hello world",
+ *             "/bin/echo world hello",
+ *             NULL
+ *         }
+ *         for (size_t i = 0; commands[i] != NULL); i++) {
+ *             struct MultiProcessingTask *task;
+ *             char task_name[100];
+ *
+ *             sprintf(task_name, "mytask%zu", i);
+ *             task = mp_task(mp, task_name, commands[i]);
+ *             if (!task) {
+ *                 // handle task creation error
+ *             }
+ *         }
+ *         if (mp_pool_join(mp, get_cpu_count(), MP_POOL_FAIL_FAST)) {
+ *             // handle pool execution error
+ *         }
+ *         mp_pool_free(&mp);
+ *     } else {
+ *         // handle pool initialization error
+ *     }
+ * }
+ * ```
+ *
+ * @param ident a name to identify the pool
+ * @param log_root the path to store program output
+ * @return pointer to initialized MultiProcessingPool
+ * @return NULL on error
+ */
+struct MultiProcessingPool *mp_pool_init(const char *ident, const char *log_root);
+
+/**
+ * Create a multiprocessing pool task
+ *
+ * @param pool a pointer to MultiProcessingPool
+ * @param ident a name to identify the task
+ * @param cmd a command to execute
+ * @return pointer to MultiProcessingTask structure
+ * @return NULL on error
+ */
+struct MultiProcessingTask *mp_pool_task(struct MultiProcessingPool *pool, const char *ident, char *working_dir, char *cmd);
+
+/**
+ * Execute all tasks in a pool
+ *
+ * @param pool a pointer to MultiProcessingPool
+ * @param jobs the number of processes to spawn at once (for serial execution use `1`)
+ * @param flags option to be OR'd (MP_POOL_FAIL_FAST)
+ * @return 0 on success
+ * @return >0 on failure
+ * @return <0 on error
+ */
+int mp_pool_join(struct MultiProcessingPool *pool, size_t jobs, size_t flags);
+
+/**
+ * Show summary of pool tasks
+ *
+ * @param pool a pointer to MultiProcessingPool
+ */
+void mp_pool_show_summary(struct MultiProcessingPool *pool);
+
+/**
+ * Release resources allocated by mp_pool_init()
+ *
+ * @param a pointer to MultiProcessingPool
+ */
+void mp_pool_free(struct MultiProcessingPool **pool);
+
+
+#endif //STASIS_MULTIPROCESSING_H
diff --git a/src/lib/core/include/os_darwin.h b/src/lib/core/include/os_darwin.h
new file mode 100644
index 0000000..e8513ff
--- /dev/null
+++ b/src/lib/core/include/os_darwin.h
@@ -0,0 +1,26 @@
+#ifndef STASIS_OS_DARWIN_H
+#define STASIS_OS_DARWIN_H
+
+#include <sys/mount.h>
+
+#ifndef __DARWIN_64_BIT_INO_T
+#define statvfs statfs
+
+#ifndef ST_RDONLY
+#define ST_RDONLY MNT_RDONLY
+#endif
+
+#define ST_NOEXEC MNT_NOEXEC
+#define f_flag f_flags
+#endif // __DARWIN_64_BIT_INO_T
+
+#include <limits.h>
+
+#ifndef PATH_MAX
+#include <sys/syslimits.h>
+#endif
+
+extern char **environ;
+#define __environ environ
+
+#endif
diff --git a/src/lib/core/include/os_linux.h b/src/lib/core/include/os_linux.h
new file mode 100644
index 0000000..d418090
--- /dev/null
+++ b/src/lib/core/include/os_linux.h
@@ -0,0 +1,10 @@
+#ifndef STASIS_OS_LINUX_H
+#define STASIS_OS_LINUX_H
+
+#include <limits.h>
+
+#ifndef PATH_MAX
+#include <linux/limits.h>
+#endif
+
+#endif
diff --git a/src/lib/core/include/package.h b/src/lib/core/include/package.h
new file mode 100644
index 0000000..eff1874
--- /dev/null
+++ b/src/lib/core/include/package.h
@@ -0,0 +1,30 @@
+#ifndef STASIS_PACKAGE_H
+#define STASIS_PACKAGE_H
+
+struct Package {
+    struct {
+        const char *name;
+        const char *version_spec;
+        const char *version;
+    } meta;
+    struct {
+        const char *uri;
+        unsigned handler;
+    } source;
+    struct {
+        struct Test *test;
+        size_t pass;
+        size_t fail;
+        size_t skip;
+    };
+    unsigned state;
+};
+
+struct Package *stasis_package_init(void);
+void stasis_package_set_name(struct Package *pkg, const char *name);
+void stasis_package_set_version(struct Package *pkg, const char *version);
+void stasis_package_set_version_spec(struct Package *pkg, const char *version_spec);
+void stasis_package_set_uri(struct Package *pkg, const char *uri);
+void stasis_package_set_handler(struct Package *pkg, unsigned handler);
+
+#endif //STASIS_PACKAGE_H
diff --git a/src/lib/core/include/recipe.h b/src/lib/core/include/recipe.h
new file mode 100644
index 0000000..4dea248
--- /dev/null
+++ b/src/lib/core/include/recipe.h
@@ -0,0 +1,72 @@
+//! @file recipe.h
+#ifndef STASIS_RECIPE_H
+#define STASIS_RECIPE_H
+
+#include "str.h"
+#include "utils.h"
+
+//! Unable to determine recipe repo type
+#define RECIPE_TYPE_UNKNOWN 0
+//! Recipe repo is from conda-forge
+#define RECIPE_TYPE_CONDA_FORGE 1
+//! Recipe repo is from astroconda
+#define RECIPE_TYPE_ASTROCONDA 2
+//! Recipe repo provides the required build configurations but doesn't match conda-forge or astroconda's signature
+#define RECIPE_TYPE_GENERIC 3
+
+/**
+ * Download a Conda package recipe
+ *
+ * ```c
+ * char *recipe = NULL;
+ *
+ * if (recipe_clone("base/dir", "https://github.com/example/repo", "branch", &recipe)) {
+ *     fprintf(stderr, "Failed to clone conda recipe\n");
+ *     exit(1);
+ * } else {
+ *     chdir(recipe);
+ * }
+ * ```
+ *
+ * @param recipe_dir path to store repository
+ * @param url remote address of git repository
+ * @param gitref branch/tag/commit
+ * @param result absolute path to downloaded repository
+ * @return exit code from "git", -1 on error
+ */
+int recipe_clone(char *recipe_dir, char *url, char *gitref, char **result);
+
+/**
+ * Determine the layout/type of repository path
+ *
+ * ```c
+ * if (recipe_clone("base/dir", "https://github.com/example/repo", "branch", &recipe)) {
+ *     fprintf(stderr, "Failed to clone conda recipe\n");
+ *     exit(1);
+ * }
+ *
+ * int recipe_type;
+ * recipe_type = recipe_get_type(recipe);
+ * switch (recipe_type) {
+ *     case RECIPE_TYPE_CONDA_FORGE:
+ *         // do something specific for conda-forge directory structure
+ *         break;
+ *     case RECIPE_TYPE_ASTROCONDA:
+ *         // do something specific for astroconda directory structure
+ *         break;
+ *     case RECIPE_TYPE_GENERIC:
+ *         // do something specific for a directory containing a meta.yaml config
+ *         break;
+ *     case RECIPE_TYPE_UNKNOWN:
+ *     default:
+ *         // the structure is foreign or the path doesn't contain a conda recipe
+ *         break;
+ * }
+ * ```
+ *
+ * @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);
+
+#endif //STASIS_RECIPE_H
diff --git a/src/lib/core/include/relocation.h b/src/lib/core/include/relocation.h
new file mode 100644
index 0000000..9a1f0f4
--- /dev/null
+++ b/src/lib/core/include/relocation.h
@@ -0,0 +1,24 @@
+/**
+ * @file relocation.h
+ */
+#ifndef STASIS_RELOCATION_H
+#define STASIS_RELOCATION_H
+
+#include "config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#if defined(STASIS_OS_DARWIN)
+#include <limits.h>
+# else
+#include <linux/limits.h>
+#endif
+#include <unistd.h>
+
+#define REPLACE_TRUNCATE_AFTER_MATCH 1
+
+int replace_text(char *original, const char *target, const char *replacement, unsigned flags);
+int file_replace_text(const char* filename, const char* target, const char* replacement, unsigned flags);
+
+#endif //STASIS_RELOCATION_H
diff --git a/src/lib/core/include/rules.h b/src/lib/core/include/rules.h
new file mode 100644
index 0000000..666d331
--- /dev/null
+++ b/src/lib/core/include/rules.h
@@ -0,0 +1,11 @@
+//
+// Created by jhunk on 12/18/23.
+//
+
+#ifndef STASIS_RULES_H
+#define STASIS_RULES_H
+
+#include "core.h"
+
+
+#endif //STASIS_RULES_H
diff --git a/src/lib/core/include/str.h b/src/lib/core/include/str.h
new file mode 100644
index 0000000..bb96db0
--- /dev/null
+++ b/src/lib/core/include/str.h
@@ -0,0 +1,313 @@
+/**
+ * @file str.h
+ */
+#ifndef STASIS_STR_H
+#define STASIS_STR_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include "relocation.h"
+#include "core.h"
+
+#define STASIS_SORT_ALPHA 1 << 0
+#define STASIS_SORT_NUMERIC 1 << 1
+#define STASIS_SORT_LEN_ASCENDING 1 << 2
+#define STASIS_SORT_LEN_DESCENDING 1 << 3
+
+/**
+ * Determine how many times the character `ch` appears in `sptr` string
+ * @param sptr string to scan
+ * @param ch character to find
+ * @return count of characters found
+ */
+int num_chars(const char *sptr, int ch);
+
+/**
+ * Scan for `pattern` string at the beginning of `sptr`
+ *
+ * @param sptr string to scan
+ * @param pattern string to search for
+ * @return 1 = found, 0 = not found / error
+ */
+int startswith(const char *sptr, const char *pattern);
+
+/**
+ * Scan for `pattern` string at the end of `sptr`
+ *
+ * @param sptr string to scan
+ * @param pattern string to search for
+ * @return 1 = found, 0 = not found / error
+ */
+int endswith(const char *sptr, const char *pattern);
+
+/**
+ * Deletes any characters matching `chars` from `sptr` string
+ *
+ * @param sptr string to be modified in-place
+ * @param chars a string containing characters (e.g. " \n" would delete whitespace and line feeds)
+ */
+void strchrdel(char *sptr, const char *chars);
+
+/**
+ * Split a string by every delimiter in `delim` string.
+ *
+ * Callee should free memory using `GENERIC_ARRAY_FREE()`
+ *
+ * @param sptr string to split
+ * @param delim characters to split on
+ * @return success=parts of string, failure=NULL
+ */
+char** split(char *sptr, const char* delim, size_t max);
+
+/**
+ * Create new a string from an array of strings
+ *
+ * ~~~{.c}
+ * char *array[] = {
+ *     "this",
+ *     "is",
+ *     "a",
+ *     "test",
+ *     NULL,
+ * }
+ *
+ * char *test = join(array, " ");    // "this is a test"
+ * char *test2 = join(array, "_");   // "this_is_a_test"
+ * char *test3 = join(array, ", ");  // "this, is, a, test"
+ *
+ * free(test);
+ * free(test2);
+ * free(test3);
+ * ~~~
+ *
+ * @param arr
+ * @param separator characters to insert between elements in string
+ * @return new joined string
+ */
+char *join(char **arr, const char *separator);
+
+/**
+ * Join two or more strings by a `separator` string
+ * @param separator
+ * @param ...
+ * @return string
+ */
+char *join_ex(char *separator, ...);
+
+/**
+ * Extract the string encapsulated by characters listed in `delims`
+ *
+ * ~~~{.c}
+ * char *str = "this is [some data] in a string";
+ * char *data = substring_between(string, "[]");
+ * // data = "some data";
+ * ~~~
+ *
+ * @param sptr string to parse
+ * @param delims two characters surrounding a string
+ * @return success=text between delimiters, failure=NULL
+ */
+char *substring_between(char *sptr, const char *delims);
+
+/**
+ * Sort an array of strings
+ * @param arr a NULL terminated array of strings
+ * @param sort_mode
+ *     - STASIS_SORT_LEN_DESCENDING
+ *     - STASIS_SORT_LEN_ASCENDING
+ *     - STASIS_SORT_ALPHA
+ *     - STASIS_SORT_NUMERIC
+ */
+void strsort(char **arr, unsigned int sort_mode);
+
+/**
+ * Determine whether the input character is a relational operator
+ * Note: `~` is non-standard
+ * @param ch
+ * @return 0=no, 1=yes
+ */
+int isrelational(char ch);
+
+/**
+ * Print characters in `s`, `len` times
+ * @param s
+ * @param len
+ */
+void print_banner(const char *s, int len);
+
+/**
+ * Search for string in an array of strings
+ * @param arr array of strings
+ * @param str string to search for
+ * @return yes=`pointer to string`, no=`NULL`, failure=`NULL`
+ */
+char *strstr_array(char **arr, const char *str);
+
+/**
+ * Remove duplicate strings from an array of strings
+ * @param arr
+ * @return success=array of unique strings, failure=NULL
+ */
+char **strdeldup(char **arr);
+
+/** Remove leading whitespace from a string
+ *
+ * ~~~{.c}
+ * char input[100];
+ *
+ * strcpy(input, "          I had leading spaces");
+ * lstrip(input);
+ * // input is now "I had leading spaces"
+ * ~~~
+ * @param sptr pointer to string
+ * @return pointer to first non-whitespace character in string
+ */
+char *lstrip(char *sptr);
+
+/**
+ * Strips trailing whitespace from a given string
+ *
+ * ~~~{.c}
+ * char input[100];
+ *
+ * strcpy(input, "I had trailing spaces          ");
+ * strip(input);
+ * // input is now "I had trailing spaces"
+ * ~~~
+ *
+ * @param sptr input string
+ * @return truncated string
+ */
+char *strip(char *sptr);
+
+/**
+ * Check if a given string is "visibly" empty
+ *
+ * ~~~{.c}
+ * char visibly[100];
+ *
+ * strcpy(visibly, "\t     \t\n");
+ * if (isempty(visibly)) {
+ *     printf("string is 'empty'\n");
+ * } else {
+ *     printf("string is not 'empty'\n");
+ * }
+ * ~~~
+ *
+ * @param sptr pointer to string
+ * @return 0=not empty, 1=empty
+ */
+int isempty(char *sptr);
+
+/**
+ * Determine if a string is encapsulated by quotes
+ * @param sptr pointer to string
+ * @return 0=not quoted, 1=quoted
+ */
+int isquoted(char *sptr);
+
+/**
+ * Collapse whitespace in `s`. The string is modified in place.
+ * @param s
+ * @return pointer to `s`
+ */
+char *normalize_space(char *s);
+
+/**
+ * Duplicate an array of strings
+ *
+ * ~~~{.c}
+ * char **array_orig = calloc(10, sizeof(*orig));
+ * orig[0] = strdup("one");
+ * orig[1] = strdup("two");
+ * orig[2] = strdup("three");
+ * // ...
+ * char **array_orig_copy = strdup_array(orig);
+ *
+ * for (size_t i = 0; array_orig_copy[i] != NULL; i++) {
+ *     printf("array_orig[%zu] = '%s'\narray_orig_copy[%zu] = '%s'\n\n",
+ *            i, array_orig[i],
+ *            i, array_orig_copy[i]);
+ *     free(array_orig_copy[i]);
+ *     free(array_orig[i]);
+ * }
+ * free(array_orig_copy);
+ * free(array_orig);
+ *
+ * ~~~
+ *
+ * @param array
+ * @return
+ */
+char **strdup_array(char **array);
+
+/**
+ * Compare an array of strings
+ *
+ * ~~~{.c}
+ * const char *a[] = {
+ *     "I",
+ *     "like",
+ *     "computers."
+ * };
+ * const char *b[] = {
+ *     "I",
+ *     "like",
+ *     "cars."
+ * };
+ * if (!strcmp_array(a, b)) {
+ *     printf("a and b are not equal\n");
+ * } else {
+ *     printf("a and b are equal\n");
+ * }
+ * ~~~
+ *
+ * @param a pointer to array
+ * @param b poitner to array
+ * @return 0 on identical, non-zero for different
+ */
+int strcmp_array(const char **a, const char **b);
+
+/**
+ * Determine whether a string is comprised of digits
+ * @param s
+ * @return 0=no, 1=yes
+ */
+int isdigit_s(const char *s);
+
+/**
+ * Convert input string to lowercase
+ *
+ * ~~~{.c}
+ * char *str = strdup("HELLO WORLD!");
+ * tolower_s(str);
+ * // str is "hello world!"
+ * ~~~
+ *
+ * @param s input string
+ * @return pointer to input string
+ */
+char *tolower_s(char *s);
+
+/**
+ * Return a copy of the input string with "." characters removed
+ *
+ * ~~~{.c}
+ * char *version = strdup("1.2.3");
+ * char *version_short = to_short_version(str);
+ * // version_short is "123"
+ * free(version_short);
+ *
+ * ~~~
+ *
+ * @param s input string
+ * @return pointer to new string
+ */
+char *to_short_version(const char *s);
+
+void unindent(char *s);
+
+#endif //STASIS_STR_H
diff --git a/src/lib/core/include/strlist.h b/src/lib/core/include/strlist.h
new file mode 100644
index 0000000..cdbfc01
--- /dev/null
+++ b/src/lib/core/include/strlist.h
@@ -0,0 +1,60 @@
+/**
+ * String array convenience functions
+ * @file strlist.h
+ */
+#ifndef STASIS_STRLIST_H
+#define STASIS_STRLIST_H
+
+typedef int (ReaderFn)(size_t line, char **);
+
+#include <stdlib.h>
+#include "core.h"
+#include "utils.h"
+#include "str.h"
+
+
+struct StrList {
+    size_t num_alloc;
+    size_t num_inuse;
+    char **data;
+};
+
+struct StrList *strlist_init();
+void strlist_remove(struct StrList *pStrList, size_t index);
+long double strlist_item_as_long_double(struct StrList *pStrList, size_t index);
+double strlist_item_as_double(struct StrList *pStrList, size_t index);
+float strlist_item_as_float(struct StrList *pStrList, size_t index);
+unsigned long long strlist_item_as_ulong_long(struct StrList *pStrList, size_t index);
+long long strlist_item_as_long_long(struct StrList *pStrList, size_t index);
+unsigned long strlist_item_as_ulong(struct StrList *pStrList, size_t index);
+long strlist_item_as_long(struct StrList *pStrList, size_t index);
+unsigned int strlist_item_as_uint(struct StrList *pStrList, size_t index);
+int strlist_item_as_int(struct StrList *pStrList, size_t index);
+unsigned short strlist_item_as_ushort(struct StrList *pStrList, size_t index);
+short strlist_item_as_short(struct StrList *pStrList, size_t index);
+unsigned char strlist_item_as_uchar(struct StrList *pStrList, size_t index);
+char strlist_item_as_char(struct StrList *pStrList, size_t index);
+char *strlist_item_as_str(struct StrList *pStrList, size_t index);
+char *strlist_item(struct StrList *pStrList, size_t index);
+void strlist_set(struct StrList **pStrList, size_t index, char *value);
+size_t strlist_count(struct StrList *pStrList);
+void strlist_reverse(struct StrList *pStrList);
+void strlist_sort(struct StrList *pStrList, unsigned int mode);
+int strlist_append_file(struct StrList *pStrList, char *path, ReaderFn *readerFn);
+void strlist_append_strlist(struct StrList *pStrList1, struct StrList *pStrList2);
+void strlist_append(struct StrList **pStrList, char *str);
+void strlist_append_array(struct StrList *pStrList, char **arr);
+void strlist_append_tokenize(struct StrList *pStrList, char *str, char *delim);
+struct StrList *strlist_copy(struct StrList *pStrList);
+int strlist_cmp(struct StrList *a, struct StrList *b);
+void strlist_free(struct StrList **pStrList);
+
+#define STRLIST_E_SUCCESS 0
+#define STRLIST_E_OUT_OF_RANGE 1
+#define STRLIST_E_INVALID_VALUE 2
+#define STRLIST_E_UNKNOWN 3
+extern int strlist_errno;
+const char *strlist_get_error(int flag);
+
+
+#endif //STASIS_STRLIST_H
diff --git a/src/lib/core/include/system.h b/src/lib/core/include/system.h
new file mode 100644
index 0000000..7019b92
--- /dev/null
+++ b/src/lib/core/include/system.h
@@ -0,0 +1,34 @@
+/**
+ * System functions
+ * @file system.h
+ */
+#ifndef STASIS_SYSTEM_H
+#define STASIS_SYSTEM_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <limits.h>
+#include <sys/wait.h>
+#include <sys/stat.h>
+
+#define STASIS_SHELL_SAFE_RESTRICT ";&|()"
+
+struct Process {
+    // Write stdout stream to file
+    char f_stdout[PATH_MAX];
+    // Write stderr stream to file
+    char f_stderr[PATH_MAX];
+    // Combine stderr and stdout (into stdout stream)
+    int redirect_stderr;
+    // Exit code from program
+    int returncode;
+};
+
+int shell(struct Process *proc, char *args);
+int shell_safe(struct Process *proc, char *args);
+char *shell_output(const char *command, int *status);
+
+#endif //STASIS_SYSTEM_H
diff --git a/src/lib/core/include/template.h b/src/lib/core/include/template.h
new file mode 100644
index 0000000..e3d83fb
--- /dev/null
+++ b/src/lib/core/include/template.h
@@ -0,0 +1,81 @@
+//! @file template.h
+#ifndef STASIS_TEMPLATE_H
+#define STASIS_TEMPLATE_H
+
+#include "core.h"
+
+/**
+ * Map a text value to a pointer in memory
+ *
+ * @param key in-text variable name
+ * @param ptr pointer to string
+ */
+void tpl_register(char *key, char **ptr);
+
+/**
+ * Free the template engine
+ */
+void tpl_free();
+
+/**
+ * Retrieve the value of a key mapped by the template engine
+ * @param key string registered by `tpl_register`
+ * @return a pointer to value, or NULL if the key is not present
+ */
+char *tpl_getval(char *key);
+
+/**
+ * Replaces occurrences of all registered key value pairs in `str`
+ * @param str the text data to render
+ * @return a rendered copy of `str`, or NULL.
+ * The caller is responsible for free()ing memory allocated by this function
+ */
+char *tpl_render(char *str);
+
+/**
+ * Write tpl_render() output to a file
+ * @param str the text to render
+ * @param filename the output file name
+ * @return 0 on success, <0 on error
+ */
+int tpl_render_to_file(char *str, const char *filename);
+
+typedef int tplfunc(void *frame, void *data_out);
+
+struct tplfunc_frame {
+    char *key;                 ///< Name of the function
+    tplfunc *func;             ///< Pointer to the function
+    void *data_in;             ///< Pointer to internal data (can be NULL)
+    int argc;                  ///< Maximum number of arguments to accept
+    union {
+        char **t_char_refptr;  ///< &pointer
+        char *t_char_ptr;      ///< pointer
+        void *t_void_ptr;      ///< pointer to void
+        int *t_int_ptr;        ///< pointer to int
+        unsigned *t_uint_ptr;  ///< pointer to unsigned int
+        float *t_float_ptr;    ///< pointer to float
+        double *t_double_ptr;  ///< pointer to double
+        char t_char;           ///< type of char
+        int t_int;             ///< type of int
+        unsigned t_uint;       ///< type of unsigned int
+        float t_float;         ///< type of float
+        double t_double;       ///< type of double
+    } argv[10]; // accept up to 10 arguments
+};
+
+/**
+ * Register a template function
+ * @param key function name to expose to "func:" interface
+ * @param tplfunc_ptr pointer to function of type tplfunc
+ * @param argc number of function arguments to accept
+ */
+void tpl_register_func(char *key, void *tplfunc_ptr, int argc, void *data_in);
+
+/**
+ * Get the function frame associated with a template function
+ * @param key function name
+ * @return tplfunc_frame structure
+ */
+struct tplfunc_frame *tpl_getfunc(char *key);
+
+#endif //STASIS_TEMPLATE_H
diff --git a/src/lib/core/include/template_func_proto.h b/src/lib/core/include/template_func_proto.h
new file mode 100644
index 0000000..286ccfb
--- /dev/null
+++ b/src/lib/core/include/template_func_proto.h
@@ -0,0 +1,13 @@
+//! @file template_func_proto.h
+#ifndef TEMPLATE_FUNC_PROTO_H
+#define TEMPLATE_FUNC_PROTO_H
+
+#include "template.h"
+
+int get_github_release_notes_tplfunc_entrypoint(void *frame, void *data_out);
+int get_github_release_notes_auto_tplfunc_entrypoint(void *frame, void *data_out);
+int get_junitxml_file_entrypoint(void *frame, void *data_out);
+int get_basetemp_dir_entrypoint(void *frame, void *data_out);
+int tox_run_entrypoint(void *frame, void *data_out);
+
+#endif //TEMPLATE_FUNC_PROTO_H
\ No newline at end of file
diff --git a/src/lib/core/include/utils.h b/src/lib/core/include/utils.h
new file mode 100644
index 0000000..87f28cc
--- /dev/null
+++ b/src/lib/core/include/utils.h
@@ -0,0 +1,416 @@
+//! @file utils.h
+#ifndef STASIS_UTILS_H
+#define STASIS_UTILS_H
+#include <stdio.h>
+#include <stdlib.h>
+#include <dirent.h>
+#include <string.h>
+#include <unistd.h>
+#include <limits.h>
+#include <errno.h>
+#include "core.h"
+#include "copy.h"
+#include "system.h"
+#include "strlist.h"
+#include "utils.h"
+#include "ini.h"
+
+#if defined(STASIS_OS_WINDOWS)
+#define PATH_ENV_VAR "path"
+#define DIR_SEP "\\"
+#define PATH_SEP ";"
+#define LINE_SEP "\r\n"
+#else
+#define PATH_ENV_VAR "PATH"
+#define DIR_SEP "/"
+#define PATH_SEP ":"
+#define LINE_SEP "\n"
+#endif
+
+#define STASIS_XML_PRETTY_PRINT_PROG "xmllint"
+#define STASIS_XML_PRETTY_PRINT_ARGS "--format"
+
+/**
+ * Change directory. Push path on directory stack.
+ *
+ * ```c
+ * pushd("/somepath");
+ *
+ * FILE fp = fopen("somefile", "w"); // i.e. /somepath/somefile
+ * fprintf(fp, "Hello world.\n");
+ * fclose(fp);
+ *
+ * popd();
+ * ```
+ *
+ * @param path of directory
+ * @return 0 on success, -1 on error
+ */
+int pushd(const char *path);
+
+/**
+ * Return from directory. Pop last path from directory stack.
+ *
+ * @see pushd
+ * @return 0 on success, -1 if stack is empty
+ */
+int popd(void);
+
+/**
+ * Expand "~" to the user's home directory
+ *
+ * ```c
+ * char *home = expandpath("~");             // == /home/username
+ * char *config = expandpath("~/.config");   // == /home/username/.config
+ * char *nope = expandpath("/tmp/test");     // == /tmp/test
+ * char *nada = expandpath("/~/broken");     // == /~/broken
+ *
+ * free(home);
+ * free(config);
+ * free(nope);
+ * free(nada);
+ * ```
+ *
+ * @param _path (Must start with a `~`)
+ * @return success=expanded path or original path, failure=NULL
+ */
+char *expandpath(const char *_path);
+
+/**
+ * Remove a directory tree recursively
+ *
+ * ```c
+ * mkdirs("a/b/c");
+ * rmtree("a");
+ * // a/b/c is removed
+ * ```
+ *
+ * @param _path
+ * @return 0 on success, -1 on error
+ */
+int rmtree(char *_path);
+
+
+char **file_readlines(const char *filename, size_t start, size_t limit, ReaderFn *readerFn);
+
+/**
+ * Strip directory from file name
+ * Note: Caller is responsible for freeing memory
+ *
+ * @param _path
+ * @return success=file name, failure=NULL
+ */
+char *path_basename(char *path);
+
+/**
+ * Return parent directory of file, or the parent of a directory
+ *
+ * @param path
+ * @return success=directory, failure=empty string
+ */
+char *path_dirname(char *path);
+
+/**
+ * Scan PATH directories for a named program
+ * @param name program name
+ * @return path to program, or NULL on error
+ */
+char *find_program(const char *name);
+
+/**
+ * Create an empty file, or update modified timestamp on an existing file
+ * @param filename file to touch
+ * @return 0 on success, 1 on error
+ */
+int touch(const char *filename);
+
+/**
+ * Clone a git repository
+ *
+ * ```c
+ * struct Process proc;
+ * memset(proc, 0, sizeof(proc));
+ *
+ * if (git_clone(&proc, "https://github.com/myuser/myrepo", "./repos", "unstable_branch")) {
+ *     fprintf(stderr, "Failed to clone repository\n");
+ *     exit(1);
+ * }
+ *
+ * if (pushd("./repos/myrepo")) {
+ *     fprintf(stderr, "Unable to enter repository directory\n");
+ * } else {
+ *     // do something with repository
+ *     popd();
+ * }
+ * ```
+ *
+ * @see pushd
+ *
+ * @param proc Process struct
+ * @param url URL (or file system path) of repoistory to clone
+ * @param destdir destination directory
+ * @param gitref commit/branch/tag of checkout (NULL will use HEAD of default branch for repo)
+ * @return exit code from "git"
+ */
+int git_clone(struct Process *proc, char *url, char *destdir, char *gitref);
+
+/**
+ * Git describe wrapper
+ * @param path to repository
+ * @return output from "git describe", or NULL on error
+ */
+char *git_describe(const char *path);
+
+/**
+ * Git rev-parse wrapper
+ * @param path to repository
+ * @param args to pass to git rev-parse
+ * @return output from "git rev-parse", or NULL on error
+ */
+char *git_rev_parse(const char *path, char *args);
+
+/**
+ * Helper function to initialize simple STASIS internal path strings
+ *
+ * ```c
+ * char *mypath = NULL;
+ *
+ * if (path_store(&mypath, PATH_MAX, "/some", "path")) {
+ *     fprintf(stderr, "Unable to allocate memory for path elements\n");
+ *     exit(1);
+ * }
+ * // mypath is allocated to size PATH_MAX and contains the string: /some/path
+ * // base+path will truncate at maxlen - 1
+ * ```
+ *
+ * @param destptr address of destination string pointer
+ * @param maxlen maximum length of the path
+ * @param base path
+ * @param path to append to base
+ * @return 0 on success, -1 on error
+ */
+int path_store(char **destptr, size_t maxlen, const char *base, const char *path);
+
+#if defined(STASIS_DUMB_TERMINAL)
+#define STASIS_COLOR_RED ""
+#define STASIS_COLOR_GREEN ""
+#define STASIS_COLOR_YELLOW ""
+#define STASIS_COLOR_BLUE ""
+#define STASIS_COLOR_WHITE ""
+#define STASIS_COLOR_RESET ""
+#else
+//! Set output color to red
+#define STASIS_COLOR_RED "\e[1;91m"
+//! Set output color to green
+#define STASIS_COLOR_GREEN "\e[1;92m"
+//! Set output color to yellow
+#define STASIS_COLOR_YELLOW "\e[1;93m"
+//! Set output color to blue
+#define STASIS_COLOR_BLUE "\e[1;94m"
+//! Set output color to white
+#define STASIS_COLOR_WHITE "\e[1;97m"
+//! Reset output color to terminal default
+#define STASIS_COLOR_RESET "\e[0;37m\e[0m"
+#endif
+
+#define STASIS_MSG_SUCCESS 0
+//! Suppress printing of the message text
+#define STASIS_MSG_NOP 1 << 0
+//! The message is an error
+#define STASIS_MSG_ERROR 1 << 1
+//! The message is a warning
+#define STASIS_MSG_WARN 1 << 2
+//! The message will be indented once
+#define STASIS_MSG_L1 1 << 3
+//! The message will be indented twice
+#define STASIS_MSG_L2 1 << 4
+//! The message will be indented thrice
+#define STASIS_MSG_L3 1 << 5
+//! The message will only be printed in verbose mode
+#define STASIS_MSG_RESTRICT 1 << 6
+
+void msg(unsigned type, char *fmt, ...);
+
+// Enter an interactive shell that ends the program on-exit
+void debug_shell();
+
+/**
+ * Creates a temporary file returning an open file pointer via @a fp, and the
+ * path to the file. The caller is responsible for closing @a fp and
+ * free()ing the returned file path.
+ *
+ * ```c
+ * FILE *fp = NULL;
+ * char *tempfile = xmkstemp(&fp, "r+");
+ * if (!fp || !tempfile) {
+ *     fprintf(stderr, "Failed to generate temporary file for read/write\n");
+ *     exit(1);
+ * }
+ * ```
+ *
+ * @param fp pointer to FILE (to be initialized)
+ * @param mode fopen() style file mode string
+ * @return system path to the temporary file
+ * @return NULL on failure
+ */
+char *xmkstemp(FILE **fp, const char *mode);
+
+/**
+ * Is the path an empty directory structure?
+ *
+ * ```c
+ * if (isempty_dir("/some/path")) {
+ *     fprintf(stderr, "The directory is is empty!\n");
+ * } else {
+ *     printf("The directory contains dirs/files\n");
+ * }
+ * ```
+ *
+ * @param path directory
+ * @return 0 = no, 1 = yes
+ */
+int isempty_dir(const char *path);
+
+/**
+ * Rewrite an XML file with a pretty printer command
+ * @param filename path to modify
+ * @param pretty_print_prog program to call
+ * @param pretty_print_args arguments to pass to program
+ * @return 0 on success, -1 on error
+ */
+int xml_pretty_print_in_place(const char *filename, const char *pretty_print_prog, const char *pretty_print_args);
+
+/**
+ * Applies STASIS fixups to a tox ini config
+ * @param filename path to tox.ini
+ * @param result path to processed configuration
+ * @return 0 on success, -1 on error
+ */
+int fix_tox_conf(const char *filename, char **result);
+
+char *collapse_whitespace(char **s);
+
+/**
+ * Write ***REDACTED*** in dest for each occurrence of to_redacted token present in src
+ *
+ * ```c
+ * char command[PATH_MAX] = {0};
+ * char command_redacted[PATH_MAX] = {0};
+ * const char *password = "abc123";
+ * const char *host = "myhostname";
+ * const char *to_redact_case1[] = {password, host, NULL};
+ * const char *to_redact_case2[] = {password, "--host", NULL};
+ * const char *to_redact_case3[] = {password, "--host", host, NULL};
+ *
+ * sprintf(command, "echo %s | program --host=%s -", password, host);
+ *
+ * // CASE 1
+ * redact_sensitive(to_redact_case1, command, command_redacted, sizeof(command_redacted) - 1);
+ * printf("executing: %s\n", command_redacted);
+ * // User sees:
+ * // executing: echo ***REDACTED*** | program --host=***REDACTED*** -
+ * system(command);
+ *
+ * // CASE 2 remove an entire argument
+ * redact_sensitive(to_redact_case2, command, command_redacted, sizeof(command_redacted) - 1);
+ * printf("executing: %s\n", command_redacted);
+ * // User sees:
+ * // executing: echo ***REDACTED*** | program ***REDACTED*** -
+ * system(command);
+ *
+ * // CASE 3 remove it all (noisy)
+ * redact_sensitive(to_redact_case3, command, command_redacted, sizeof(command_redacted) - 1);
+ * printf("executing: %s\n", command_redacted);
+ * // User sees:
+ * // executing: echo ***REDACTED*** | program ***REDACTED***=***REDACTED*** -
+ * system(command);
+ * ```
+ *
+ * @param to_redact array of tokens to redact
+ * @param src input string
+ * @param dest output string
+ * @param maxlen maximum length of dest byte array
+ * @return 0 on success, -1 on error
+ */
+int redact_sensitive(const char **to_redact, size_t to_redact_size, char *src, char *dest, size_t maxlen);
+
+/**
+ * Given a directory path, return a list of files
+ *
+ * ~~~{.c}
+ * struct StrList *files;
+ *
+ * basepath = ".";
+ * files = listdir(basepath);
+ * for (size_t i = 0; i < strlist_count(files); i++) {
+ *     char *filename = strlist_item(files, i);
+ *     printf("%s/%s\n", basepath, filename);
+ * }
+ * guard_strlist_free(&files);
+ * ~~~
+ *
+ * @param path of a directory
+ * @return a StrList containing file names
+ */
+struct StrList *listdir(const char *path);
+
+/**
+ * Get CPU count
+ * @return CPU count on success, zero on error
+ */
+long get_cpu_count();
+
+/**
+ * Create all leafs in directory path
+ * @param _path directory path to create
+ * @param mode mode_t permissions
+ * @return
+ */
+int mkdirs(const char *_path, mode_t mode);
+
+/**
+ * Return pointer to a (possible) version specifier
+ *
+ * ```c
+ * char s[] = "abc==1.2.3";
+ * char *spec_begin = find_version_spec(s);
+ * // spec_begin is "==1.2.3"
+ *
+ * char package_name[255];
+ * char s[] = "abc";
+ * char *spec_pos = find_version_spec(s);
+ * if (spec_pos) {
+ *     strncpy(package_name, spec_pos - s);
+ *     // use spec
+ * } else {
+ *     // spec not found
+ * }
+ *
+ * @param str a pointer to a buffer containing a package spec (i.e. abc==1.2.3, abc>=1.2.3, abc)
+ * @return a pointer to the first occurrence of a version spec character
+ * @return NULL if not found
+ */
+char *find_version_spec(char *package_name);
+
+// mode flags for env_manipulate_pathstr
+#define PM_APPEND 1 << 0
+#define PM_PREPEND 1 << 1
+#define PM_ONCE  1 << 2
+
+/**
+* Add paths to the head or tail of an environment variable.
+*
+* @param key environment variable to manipulate
+* @param path to insert (does not need to exist)
+* @param mode PM_APPEND `$path:$PATH`
+* @param mode PM_PREPEND `$PATH:path`
+* @param mode PM_ONCE do not manipulate if `path` is present in PATH variable
+*/
+int env_manipulate_pathstr(const char *key, char *path, int mode);
+
+/**
+* Append or replace a file extension
+*/
+int gen_file_extension_str(char *filename, const char *extension);
+
+#endif //STASIS_UTILS_H
diff --git a/src/lib/core/include/wheel.h b/src/lib/core/include/wheel.h
new file mode 100644
index 0000000..1a689e9
--- /dev/null
+++ b/src/lib/core/include/wheel.h
@@ -0,0 +1,36 @@
+//! @file wheel.h
+#ifndef STASIS_WHEEL_H
+#define STASIS_WHEEL_H
+
+#include <dirent.h>
+#include <string.h>
+#include <stdio.h>
+#include "str.h"
+#define WHEEL_MATCH_EXACT 0 ///< Match when all patterns are present
+#define WHEEL_MATCH_ANY 1 ///< Match when any patterns are present
+
+struct Wheel {
+    char *distribution; ///< Package name
+    char *version; ///< Package version
+    char *build_tag; ///< Package build tag (optional)
+    char *python_tag; ///< Package Python tag (pyXY)
+    char *abi_tag; ///< Package ABI tag (cpXY, abiX, none)
+    char *platform_tag; ///< Package platform tag (linux_x86_64, any)
+    char *path_name; ///< Path to package on-disk
+    char *file_name; ///< Name of package on-disk
+};
+
+/**
+ * Extract metadata from a Python Wheel file name
+ *
+ * @param basepath directory containing a wheel file
+ * @param name of wheel file
+ * @param to_match a NULL terminated array of patterns (i.e. platform, arch, version, etc)
+ * @param match_mode WHEEL_MATCH_EXACT
+ * @param match_mode WHEEL_MATCH ANY
+ * @return pointer to populated Wheel on success
+ * @return NULL on error
+ */
+struct Wheel *get_wheel_info(const char *basepath, const char *name, char *to_match[], unsigned match_mode);
+void wheel_free(struct Wheel **wheel);
+#endif //STASIS_WHEEL_H
diff --git a/src/lib/delivery/CMakeLists.txt b/src/lib/delivery/CMakeLists.txt
new file mode 100644
index 0000000..78ed20f
--- /dev/null
+++ b/src/lib/delivery/CMakeLists.txt
@@ -0,0 +1,19 @@
+add_library(stasis_delivery STATIC
+        delivery_postprocess.c
+        delivery_conda.c
+        delivery_docker.c
+        delivery_install.c
+        delivery_artifactory.c
+        delivery_test.c
+        delivery_build.c
+        delivery_show.c
+        delivery_populate.c
+        delivery_init.c
+        delivery.c
+)
+target_include_directories(stasis_delivery PRIVATE
+        ${core_INCLUDE}
+        ${delivery_INCLUDE}
+        ${CMAKE_CURRENT_SOURCE_DIR}/include
+)
+target_link_libraries(stasis_delivery stasis_core)
\ No newline at end of file
diff --git a/src/lib/core/delivery.c b/src/lib/delivery/delivery.c
index aa3e51a..aa3e51a 100644
--- a/src/lib/core/delivery.c
+++ b/src/lib/delivery/delivery.c
diff --git a/src/lib/core/delivery_artifactory.c b/src/lib/delivery/delivery_artifactory.c
index 9ad5829..9ad5829 100644
--- a/src/lib/core/delivery_artifactory.c
+++ b/src/lib/delivery/delivery_artifactory.c
diff --git a/src/lib/core/delivery_build.c b/src/lib/delivery/delivery_build.c
index fa19f95..fa19f95 100644
--- a/src/lib/core/delivery_build.c
+++ b/src/lib/delivery/delivery_build.c
diff --git a/src/lib/core/delivery_conda.c b/src/lib/delivery/delivery_conda.c
index 8974ae8..8974ae8 100644
--- a/src/lib/core/delivery_conda.c
+++ b/src/lib/delivery/delivery_conda.c
diff --git a/src/lib/core/delivery_docker.c b/src/lib/delivery/delivery_docker.c
index 57015ad..57015ad 100644
--- a/src/lib/core/delivery_docker.c
+++ b/src/lib/delivery/delivery_docker.c
diff --git a/src/lib/core/delivery_init.c b/src/lib/delivery/delivery_init.c
index 2fced03..2fced03 100644
--- a/src/lib/core/delivery_init.c
+++ b/src/lib/delivery/delivery_init.c
diff --git a/src/lib/core/delivery_install.c b/src/lib/delivery/delivery_install.c
index a348346..a348346 100644
--- a/src/lib/core/delivery_install.c
+++ b/src/lib/delivery/delivery_install.c
diff --git a/src/lib/core/delivery_populate.c b/src/lib/delivery/delivery_populate.c
index c699545..c699545 100644
--- a/src/lib/core/delivery_populate.c
+++ b/src/lib/delivery/delivery_populate.c
diff --git a/src/lib/core/delivery_postprocess.c b/src/lib/delivery/delivery_postprocess.c
index 40ac43f..40ac43f 100644
--- a/src/lib/core/delivery_postprocess.c
+++ b/src/lib/delivery/delivery_postprocess.c
diff --git a/src/lib/core/delivery_show.c b/src/lib/delivery/delivery_show.c
index adfa1be..adfa1be 100644
--- a/src/lib/core/delivery_show.c
+++ b/src/lib/delivery/delivery_show.c
diff --git a/src/lib/core/delivery_test.c b/src/lib/delivery/delivery_test.c
index e80e0ec..e80e0ec 100644
--- a/src/lib/core/delivery_test.c
+++ b/src/lib/delivery/delivery_test.c
diff --git a/src/lib/delivery/include/delivery.h b/src/lib/delivery/include/delivery.h
new file mode 100644
index 0000000..a3843f5
--- /dev/null
+++ b/src/lib/delivery/include/delivery.h
@@ -0,0 +1,448 @@
+/// @file delivery.h
+
+#ifndef STASIS_DELIVERY_H
+#define STASIS_DELIVERY_H
+
+#include <string.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <sys/utsname.h>
+#include <fnmatch.h>
+#include <sys/statvfs.h>
+#include "artifactory.h"
+#include "conda.h"
+#include "copy.h"
+#include "core.h"
+#include "docker.h"
+#include "environment.h"
+#include "ini.h"
+#include "multiprocessing.h"
+#include "recipe.h"
+#include "wheel.h"
+
+#define DELIVERY_PLATFORM_MAX 4
+#define DELIVERY_PLATFORM_MAXLEN 65
+#define DELIVERY_PLATFORM 0
+#define DELIVERY_PLATFORM_CONDA_SUBDIR 1
+#define DELIVERY_PLATFORM_CONDA_INSTALLER 2
+#define DELIVERY_PLATFORM_RELEASE 3
+
+#define DELIVERY_REWRITE_SPEC_STAGE_1 0
+#define DELIVERY_REWRITE_SPEC_STAGE_2 1
+
+#define INSTALL_PKG_CONDA 1 << 1            ///< Toggle conda package installation
+#define INSTALL_PKG_CONDA_DEFERRED 1 << 2   ///< Toggle deferred conda package installation
+#define INSTALL_PKG_PIP 1 << 3              ///< Toggle pip package installation
+#define INSTALL_PKG_PIP_DEFERRED 1 << 4     ///< Toggle deferred package installation from source
+
+#define DEFER_CONDA 0                       ///< Build conda packages
+#define DEFER_PIP 1                         ///< Build python packages
+
+struct Content {
+    unsigned type;
+    char *filename;
+    char *data;
+};
+
+/*! \struct Delivery
+ *  \brief A structure describing a full delivery object
+ */
+struct Delivery {
+    /*! \struct STASIS_INI_FP
+     * \brief Container for INIFILE handles
+    */
+    struct STASIS_INI_FP {
+        struct INIFILE *delivery;
+        struct INIFILE *cfg;
+        struct INIFILE *mission;
+        char *delivery_path;
+        char *cfg_path;
+        char *mission_path;
+    } _stasis_ini_fp;
+
+    /*! \struct System
+     * \brief System information
+    */
+    struct System {
+        char *arch;
+        ///< System CPU architecture ident
+        char **platform;
+        ///< System platform name
+    } system;
+    /*! \struct Storage
+     * \brief Storage paths
+     */
+    struct Storage {
+        char *root;                     ///< Top-level storage area
+        char *tmpdir;                   ///< Temporary storage area (within root)
+        char *output_dir;               ///< Base path to where all artifacts are stored
+        char *delivery_dir;             ///< Delivery artifact output directory
+        char *cfgdump_dir;              ///< Base path to where input configuration dumps are stored
+        char *tools_dir;                ///< Tools storage
+        char *mission_dir;              ///< Mission data storage
+        char *package_dir;              ///< Base path to where all packages are stored
+        char *results_dir;              ///< Base path to where test results are stored
+        char *meta_dir;                 ///< Base path to where metadata records are stored
+        char *conda_install_prefix;     ///< Path to install Conda
+        char *conda_artifact_dir;       ///< Base path to store compiled conda packages
+        char *conda_staging_dir;        ///< Base path to copy compiled conda packages
+        char *conda_staging_url;        ///< URL to access compiled conda packages
+        char *docker_artifact_dir;      ///< Base path to store saved docker images
+        char *wheel_artifact_dir;       ///< Base path to store compiled wheel packages (Unused)
+        char *wheel_staging_dir;        ///< Base path to copy compiled wheel packages (Unused)
+        char *wheel_staging_url;        ///< URL to access compiled wheel packages (Unused)
+        char *build_dir;                ///< Base path to store source code and recipes
+        char *build_recipes_dir;        ///< Path to store conda recipes
+        char *build_sources_dir;        ///< Path to store source code
+        char *build_testing_dir;        ///< Path to store test data (Unused)
+        char *build_docker_dir;         ///< Path to store docker build script
+    } storage;
+
+    /*! \struct Meta
+     * \brief Metadata related to the delivery
+     */
+    struct Meta {
+        char *name;                ///< delivery name
+        char *version;             ///< delivery version
+        int rc;                    ///< build iteration
+        char *python;              ///< version of python to use
+        char *python_compact;      ///< shortened python identifier
+        char *based_on;            ///< URL to previous final configuration
+        char *mission;             ///< hst, jwst, roman
+        char *codename;            ///< HST uses codenames
+        bool final;                ///< is this a final release?
+    } meta;
+
+    /*! \struct Info
+     * \brief Release information (name & datetime)
+     */
+    struct Info {
+        char *release_name;            ///< The fully combined release string
+        char *build_name;
+        char *build_number;
+        struct tm *time_info;          ///< Delivery time structure
+        time_t time_now;               ///< Time stamp for when STASIS execution started
+        char *time_str_epoch;          ///< String representation of Unix epoch
+    } info;
+
+    /*! \struct Conda
+     * \brief Conda configuration
+     *
+     * This includes lists describing packages to be delivered
+     */
+    struct Conda {
+        char *installer_baseurl;                ///< URL describing where Conda will be downloaded from
+        char *installer_name;                   ///< Name of installer (Miniconda3, Miniforge3, etc)
+        char *installer_version;                ///< Version of installer
+        char *installer_platform;               ///< Platform/OS target of installer
+        char *installer_arch;                   ///< CPU architecture target of installer
+        char *installer_path;                   ///< Absolute path of installer on-disk
+        char *tool_version;                     ///< Installed version of conda
+        char *tool_build_version;               ///< Installed version of "build" package
+        struct StrList *conda_packages;         ///< Conda packages to deliver
+        struct StrList *conda_packages_defer;   ///< Conda recipes to be built for delivery
+        struct StrList *pip_packages;           ///< Python packages to install (pip)
+        struct StrList *pip_packages_defer;     ///< Python packages to be built for delivery
+        struct StrList *wheels_packages;        ///< Wheel packages built for delivery
+    } conda;
+
+    /*! \struct Runtime
+     *  \brief Global runtime variables
+     */
+    struct Runtime {
+        RuntimeEnv *environ;        ///< Environment variables
+    } runtime;
+
+    /*! \struct Test
+     * \brief Test information
+     */
+    struct Test {
+        char *name;                     ///< Name of package
+        char *version;                  ///< Version of package
+        char *repository;               ///< Git repository of package
+        char *script_setup;             ///< Commands to execute before the main script
+        char *script;                   ///< Commands to execute
+        bool disable;                   ///< Toggle a test block
+        bool parallel;                  ///< Toggle parallel or serial execution
+        char *build_recipe;             ///< Conda recipe to build (optional)
+        char *repository_info_ref;      ///< Git commit hash
+        char *repository_info_tag;      ///< Git tag (first parent)
+        struct StrList *repository_remove_tags;   ///< Git tags to remove (to fix duplicate commit tags)
+        struct Runtime runtime;         ///< Environment variables specific to the test context
+    } tests[1000]; ///< An array of tests
+
+    struct Deploy {
+        struct JFRT_Auth jfrog_auth;
+
+        struct JFrog {
+            struct StrList *files;
+            struct JFRT_Upload upload_ctx;
+            char *repo;
+            char *dest;
+        } jfrog[1000];
+
+        struct Docker {
+            struct DockerCapabilities capabilities;
+            char *image_compression;
+            char *dockerfile;
+            char *registry;
+            char *test_script;
+            struct StrList *build_args;
+            struct StrList *tags;
+        } docker;
+    } deploy;
+
+    struct Rule {
+        struct INIFILE *_handle;
+        bool enable_final;          ///< true=allow rc value replacement, false=keep rc value even if final release
+        char *release_fmt;          ///< Release format string
+        char *build_name_fmt;       ///< Build name format string
+        char *build_number_fmt;     ///< Build number format string
+        struct Content content[1000];
+    } rules;
+};
+
+/**
+ * Initializes a Deliver structure
+ * @param ctx pointer to Delivery context
+ * @param render_mode INI_READ_RAW or INI_READ_RENDER
+ * @return `0` on success
+ * @return Non-zero on error
+ */
+int delivery_init(struct Delivery *ctx, int render_mode);
+
+/**
+ * Free memory allocated by delivery_init()
+ * @param ctx pointer to Delivery context
+ */
+void delivery_free(struct Delivery *ctx);
+
+/**
+ * Print Delivery metadata
+ * @param ctx pointer to Delivery context
+ */
+void delivery_meta_show(struct Delivery *ctx);
+
+/**
+ * Print Delivery conda configuration
+ * @param ctx pointer to Delivery context
+ */
+void delivery_conda_show(struct Delivery *ctx);
+
+/**
+ * Print Delivery tests
+ * @param ctx pointer to Delivery context
+ */
+void delivery_tests_show(struct Delivery *ctx);
+
+/**
+ * Print Delivery initial runtime environment
+ * @param ctx  pointner to Delivery context
+ */
+void delivery_runtime_show(struct Delivery *ctx);
+
+/**
+ * Build Conda recipes associated with the Delivery
+ * @param ctx pointer to Delivery context
+ * @return 0 on success
+ * @return Non-zero on error
+ */
+int delivery_build_recipes(struct Delivery *ctx);
+
+/**
+ * Produce a list of wheels built for the Delivery (Unused)
+ * @param ctx pointer to Delivery context
+ * @return pointer to StrList
+ * @return NULL on error
+ */
+struct StrList *delivery_build_wheels(struct Delivery *ctx);
+
+/**
+ * Copy wheel packages to artifact storage
+ * @param ctx pointer to Delivery context
+ * @return 0 on success
+ * @return Non-zero on error
+ */
+int delivery_index_wheel_artifacts(struct Delivery *ctx);
+
+/**
+ * Generate a header block that is applied to delivery artifacts
+ * @param ctx pointer to Delivery context
+ * @return header on success
+ * @return NULL on error
+ */
+char *delivery_get_release_header(struct Delivery *ctx);
+
+/**
+ * Finalizes a delivery artifact for distribution
+ * @param ctx poitner to Delivery context
+ * @param filename path to delivery artifact (Conda YAML file)
+ * @param stage DELIVERY_REWRITE_SPEC_STAGE_1 - Replacements for build
+ * @param stage DELIVERY_REWRITE_SPEC_STAGE_2 - Replacements for export
+ */
+void delivery_rewrite_spec(struct Delivery *ctx, char *filename, unsigned stage);
+
+/**
+ * Copy compiled wheels to artifact storage
+ * @param ctx pointer to Delivery context
+ * @return 0 on success
+ * @return Non-zero on error
+ */
+int delivery_copy_wheel_artifacts(struct Delivery *ctx);
+
+/**
+ * Copy built Conda packages to artifact storage
+ * @param ctx poitner to Delivery context
+ * @return 0 on success
+ * @return Non-zero on error
+ */
+int delivery_copy_conda_artifacts(struct Delivery *ctx);
+
+/**
+ * Retrieve Conda installer
+ * @param ctx pointer to Delivery context
+ * @param installer_url URL to installation script
+ */
+int delivery_get_conda_installer(struct Delivery *ctx, char *installer_url);
+
+/**
+ * Generate URL based on Delivery context
+ * @param ctx pointer to Delivery context
+ * @param result pointer to char
+ * @return in result
+ */
+void delivery_get_conda_installer_url(struct Delivery *ctx, char *result);
+
+/**
+ * Install packages based on Delivery context
+ * @param ctx pointer to Delivery context
+ * @param conda_install_dir path to install Conda
+ * @param env_name name of Conda environment to create
+ * @param type INSTALL_PKG_CONDA
+ * @param type INSTALL_PKG_CONDA_DEFERRED
+ * @param type INSTALL_PKG_PIP
+ * @param type INSTALL_PKG_PIP_DEFERRED
+ * @param manifest pointer to array of StrList (package list(s))
+ */
+int delivery_install_packages(struct Delivery *ctx, char *conda_install_dir, char *env_name, int type, struct StrList *manifest[]);
+
+/**
+ * Update "conda index" on Conda artifact storage
+ * @param ctx pointer to Delivery context
+ * @return 0 on success
+ * @return Non-zero on error
+ */
+int delivery_index_conda_artifacts(struct Delivery *ctx);
+
+/**
+ * Execute Delivery test array
+ * @param ctx pointer to Delivery context
+ */
+void delivery_tests_run(struct Delivery *ctx);
+
+/**
+ * Determine which packages are to be installed directly from conda or pip,
+ * and which packages need to be built locally
+ * @param ctx pointer to Delivery context
+ * @param type DEFER_CONDA (filter conda packages)
+ * @param type DEFER_PIP (filter python packages)
+ */
+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);
+
+/**
+ * Install Conda
+ * @param install_script path to Conda installation script
+ * @param conda_install_dir path to install Conda
+ */
+void delivery_install_conda(char *install_script, char *conda_install_dir);
+
+/**
+ * Generate a formatted release string
+ *
+ * Formatters:
+ *
+ * - `%%n` = Delivery Name
+ * - `%%c` = Delivery Codename (HST mission, only)
+ * - `%%m` = Mission
+ * - `%%R` = Delivery Revision number (or "final")
+ * - `%%r` = Delivery Revision number
+ * - `%%v` = Delivery Version
+ * - `%%P` = Python version (i.e. 3.9.1)
+ * - `%%p` = Compact Python version (i.e. 3.9.1 -> 39)
+ * - `%%a` = System architecture name
+ * - `%%o` = System platform name
+ * - `%%t` = Delivery timestamp (Unix Epoch)
+ *
+ * @param ctx pointer to Delivery context
+ * @param dest NULL pointer to string, or initialized string
+ * @param fmt release format string
+ * @return 0 on success, -1 on error
+ */
+int delivery_format_str(struct Delivery *ctx, char **dest, const char *fmt);
+
+// helper function
+int delivery_gather_tool_versions(struct Delivery *ctx);
+
+// helper function
+int delivery_init_tmpdir(struct Delivery *ctx);
+
+void delivery_init_dirs_stage1(struct Delivery *ctx);
+
+void delivery_init_dirs_stage2(struct Delivery *ctx);
+
+int delivery_init_platform(struct Delivery *ctx);
+
+int delivery_init_artifactory(struct Delivery *ctx);
+
+int delivery_artifact_upload(struct Delivery *ctx);
+
+int delivery_mission_render_files(struct Delivery *ctx);
+
+int delivery_docker(struct Delivery *ctx);
+
+int delivery_fixup_test_results(struct Delivery *ctx);
+
+int bootstrap_build_info(struct Delivery *ctx);
+
+int delivery_dump_metadata(struct Delivery *ctx);
+
+int populate_info(struct Delivery *ctx);
+
+int populate_delivery_cfg(struct Delivery *ctx, int render_mode);
+
+int populate_delivery_ini(struct Delivery *ctx, int render_mode);
+
+int populate_mission_ini(struct Delivery **ctx, int render_mode);
+
+void validate_delivery_ini(struct INIFILE *ini);
+
+int filter_repo_tags(char *repo, struct StrList *patterns);
+
+#define DELIVERY_NOT_FOUND 0
+#define DELIVERY_FOUND 1
+/**
+ * Determine whether a release on-disk matches the release name in use
+ * @param ctx Delivery context
+ * @return 0=no, 1=yes
+ */
+int delivery_exists(struct Delivery *ctx);
+
+int delivery_overlay_packages_from_env(struct Delivery *ctx, const char *env_name);
+
+/**
+ * Retrieve remote deliveries associated with the current version series
+ * @param ctx Delivery context
+ * @return -1 on error
+ * @return 1 on failure
+ * @return 0 on success
+ */
+int delivery_series_sync(struct Delivery *ctx);
+
+#endif //STASIS_DELIVERY_H