+windows

Author: mxcl

.envrc

@@ -0,0 +1 @@
+source ~/.cargo/env

.github/workflows/ci.yml

@@ -35,7 +35,7 @@ jobs:
   clippy:
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest]
+        os: [ubuntu-latest, macos-latest, windows-latest]
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4
@@ -63,7 +63,7 @@ jobs:
     needs: fmt
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest]
+        os: [ubuntu-latest, macos-latest, windows-latest]
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4

README.md

@@ -55,6 +55,7 @@ Python 2.7.18
 - `x86_64` & `arm64`
 
 > [!TIP]
+>
 > We have gone to good lengths to make `pkgx` (and the packages it installs)
 > work with almost nothing else installed, making it ideal for tiny containers.
 

crates/cli/src/execve.rs

@@ -1,13 +1,19 @@
+#[cfg(unix)]
 use nix::unistd::execve as nix_execve;
+#[cfg(unix)]
 use std::ffi::CString;
+
 use std::{collections::HashMap, error::Error};
+use libpkgx::env::PlatformCaseAwareEnvKey;
 
+#[cfg(unix)]
 pub fn execve(
     cmd: String,
     mut args: Vec<String>,
-    env: HashMap<String, String>,
+    env: HashMap<PlatformCaseAwareEnvKey, String>,
 ) -> Result<(), Box<dyn Error>> {
     // Convert the command to a CString
+
     let c_command = CString::new(cmd.clone())
         .map_err(|e| format!("Failed to convert command to CString: {}", e))?;
 
@@ -47,3 +53,21 @@ pub fn execve(
 
     Ok(())
 }
+
+#[cfg(windows)]
+use std::process::{exit, Command};
+
+#[cfg(windows)]
+pub fn execve(
+    cmd: String,
+    args: Vec<String>,
+    env: HashMap<PlatformCaseAwareEnvKey, String>,
+) -> Result<(), Box<dyn Error>> {
+    let status = Command::new(cmd)
+        .args(args)
+        .envs(env.iter().map(|(k, v)| (&k.0, v)))
+        .spawn()?
+        .wait()?;
+
+    exit(status.code().unwrap_or(1));
+}

crates/cli/src/main.rs

@@ -9,7 +9,7 @@ use std::{collections::HashMap, error::Error, fmt::Write, sync::Arc, time::Durat
 use execve::execve;
 use indicatif::{ProgressBar, ProgressState, ProgressStyle};
 use libpkgx::{
-    config::Config, env, hydrate::hydrate, install_multi, pantry_db, resolve::resolve, sync,
+    config::Config, env::{self, construct_platform_case_aware_env_key}, hydrate::hydrate, install_multi, pantry_db, resolve::resolve, sync,
     types::PackageReq, utils,
 };
 use regex::Regex;
@@ -195,9 +195,13 @@ async fn main() -> Result<(), Box<dyn Error>> {
                 paths.append(&mut pkgpaths.clone());
             }
             if let Ok(syspaths) = std::env::var("PATH") {
+                #[cfg(windows)]
+                let sep = ";";
+                #[cfg(not(windows))]
+                let sep = ":";
                 paths.extend(
                     syspaths
-                        .split(':')
+                        .split(sep)
                         .map(|x| x.to_string())
                         .collect::<Vec<String>>(),
                 );
@@ -223,7 +227,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
         }
 
         // fork bomb protection
-        env.insert("PKGX_LVL".to_string(), pkgx_lvl.to_string());
+        env.insert(construct_platform_case_aware_env_key("PKGX_LVL".to_string()), pkgx_lvl.to_string());
 
         clear_progress_bar();
 
@@ -232,7 +236,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
         clear_progress_bar();
 
         if !flags.json {
-            let env = env.iter().map(|(k, v)| (k.clone(), v.join(":"))).collect();
+            let env = env.iter().map(|(k, v)| (construct_platform_case_aware_env_key(k.clone()), v.join(":"))).collect();
             let env = env::mix_runtime(&env, &installations, &conn)?;
             for (key, value) in env {
                 println!(

crates/lib/src/env.rs

@@ -5,8 +5,66 @@ use std::{
     str::FromStr,
 };
 
+#[cfg(windows)]
+use std::{ hash::{Hash, Hasher}, fmt};
+
+#[cfg(windows)]
+#[derive(Clone)]
+pub struct CaseInsensitiveKey(pub String);
+
+#[cfg(windows)]
+impl PartialEq for CaseInsensitiveKey {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.eq_ignore_ascii_case(&other.0)
+    }
+}
+
+#[cfg(windows)]
+impl fmt::Display for CaseInsensitiveKey {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+#[cfg(windows)]
+impl Eq for CaseInsensitiveKey {}
+
+#[cfg(windows)]
+impl Hash for CaseInsensitiveKey {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.0.to_lowercase().hash(state);
+    }
+}
+
+#[cfg(windows)]
+impl fmt::Debug for CaseInsensitiveKey {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self.0)
+    }
+}
+
+#[cfg(windows)]
+pub type PlatformCaseAwareEnvKey = CaseInsensitiveKey;
+#[cfg(not(windows))]
+pub type PlatformCaseAwareEnvKey = String;
+
+#[cfg(windows)]
+pub fn construct_platform_case_aware_env_key(key: String) -> PlatformCaseAwareEnvKey {
+    CaseInsensitiveKey(key)
+}
+
+#[cfg(not(windows))]
+pub fn construct_platform_case_aware_env_key(key: String) -> PlatformCaseAwareEnvKey {
+    key
+}
+
 use crate::types::Installation;
 
+#[cfg(not(windows))]
+const SEP: &str = ":";
+#[cfg(windows)]
+const SEP: &str = ";";
+
 pub fn map(installations: &Vec<Installation>) -> HashMap<String, Vec<String>> {
     let mut vars: HashMap<EnvKey, OrderedSet<PathBuf>> = HashMap::new();
 
@@ -42,7 +100,9 @@ pub fn map(installations: &Vec<Installation>) -> HashMap<String, Vec<String>> {
             .unwrap()
             .add(PathBuf::from_str("/usr/share/man").unwrap());
     }
+
     // https://github.com/pkgxdev/libpkgx/issues/70
+    #[cfg(unix)]
     if vars.contains_key(&EnvKey::XdgDataDirs) {
         let set = vars.get_mut(&EnvKey::XdgDataDirs).unwrap();
         set.add(PathBuf::from_str("/usr/local/share").unwrap());
@@ -71,17 +131,25 @@ enum EnvKey {
     Path,
     Manpath,
     PkgConfigPath,
+    #[cfg(unix)]
     LibraryPath,
+    #[cfg(unix)]
     LdLibraryPath,
+    #[cfg(unix)]
     Cpath,
     XdgDataDirs,
     CmakePrefixPath,
     #[cfg(target_os = "macos")]
     DyldFallbackLibraryPath,
     SslCertFile,
+    #[cfg(unix)]
     Ldflags,
     PkgxDir,
     AclocalPath,
+    #[cfg(windows)]
+    Lib,
+    #[cfg(windows)]
+    Include,
 }
 
 struct OrderedSet<T: Eq + std::hash::Hash + Clone> {
@@ -111,44 +179,58 @@ fn suffixes(key: &EnvKey) -> Option<Vec<&'static str>> {
         EnvKey::PkgConfigPath => Some(vec!["share/pkgconfig", "lib/pkgconfig"]),
         EnvKey::XdgDataDirs => Some(vec!["share"]),
         EnvKey::AclocalPath => Some(vec!["share/aclocal"]),
+        #[cfg(unix)]
         EnvKey::LibraryPath | EnvKey::LdLibraryPath => Some(vec!["lib", "lib64"]),
         #[cfg(target_os = "macos")]
         EnvKey::DyldFallbackLibraryPath => Some(vec!["lib", "lib64"]),
+        #[cfg(unix)]
         EnvKey::Cpath => Some(vec!["include"]),
-        EnvKey::CmakePrefixPath | EnvKey::SslCertFile | EnvKey::Ldflags | EnvKey::PkgxDir => None,
+        EnvKey::CmakePrefixPath | EnvKey::SslCertFile | EnvKey::PkgxDir => None,
+        #[cfg(unix)]
+        EnvKey::Ldflags => None,
+        #[cfg(windows)]
+        EnvKey::Lib => Some(vec!["lib"]),
+        #[cfg(windows)]
+        EnvKey::Include => Some(vec!["include"]),
     }
 }
 
-pub fn mix(input: HashMap<String, Vec<String>>) -> HashMap<String, String> {
-    let mut rv = HashMap::from_iter(std::env::vars());
+pub fn mix(input: HashMap<String, Vec<String>>) -> HashMap<PlatformCaseAwareEnvKey, String> {
+    let mut rv: HashMap<PlatformCaseAwareEnvKey, String> = HashMap::new();
+
+    for (key, value) in std::env::vars() {
+        rv.insert(construct_platform_case_aware_env_key(key), value);
+    }
 
     for (key, value) in input.iter() {
+        let key = &construct_platform_case_aware_env_key(key.clone());
         if let Some(values) = rv.get(key) {
-            rv.insert(key.clone(), format!("{}:{}", value.join(":"), values));
+            rv.insert(key.clone(), format!("{}{}{}", value.join(SEP), SEP, values));
         } else {
-            rv.insert(key.clone(), value.join(":"));
+            rv.insert(key.clone(), value.join(SEP));
         }
     }
 
     rv
 }
 
 pub fn mix_runtime(
-    input: &HashMap<String, String>,
+    input: &HashMap<PlatformCaseAwareEnvKey, String>,
     installations: &Vec<Installation>,
     conn: &Connection,
-) -> Result<HashMap<String, String>, Box<dyn Error>> {
-    let mut output: HashMap<String, String> = input
+) -> Result<HashMap<PlatformCaseAwareEnvKey, String>, Box<dyn Error>> {
+    let mut output: HashMap<PlatformCaseAwareEnvKey, String> = input
         .iter()
-        .map(|(k, v)| (k.clone(), format!("{}:${}", v, k)))
+        .map(|(k, v)| (k.clone(), format!("{}{}${}", v, SEP, k)))
         .collect();
 
     for installation in installations.clone() {
         let runtime_env =
             crate::pantry_db::runtime_env_for_project(&installation.pkg.project, conn)?;
         for (key, runtime_value) in runtime_env {
             let runtime_value = expand_moustaches(&runtime_value, &installation, installations);
-            let new_value = if let Some(curr_value) = output.get(&key) {
+            let insert_key = construct_platform_case_aware_env_key(key.clone());
+            let new_value = if let Some(curr_value) = output.get(&insert_key) {
                 if runtime_value.contains(&format!("${}", key)) {
                     runtime_value.replace(&format!("${}", key), curr_value)
                 } else {
@@ -161,7 +243,7 @@ pub fn mix_runtime(
             } else {
                 format!("${{{}:-{}}}", key, runtime_value)
             };
-            output.insert(key, new_value);
+            output.insert(insert_key, new_value);
         }
     }
 

crates/lib/src/install.rs

@@ -1,6 +1,9 @@
 use async_compression::tokio::bufread::XzDecoder;
 use fs2::FileExt;
-use std::{error::Error, fs::OpenOptions, path::PathBuf};
+use std::{
+    error::Error,
+    fs::{self, OpenOptions},
+};
 use tempfile::tempdir_in;
 use tokio::task;
 use tokio_tar::Archive;
@@ -38,14 +41,23 @@ where
 {
     let shelf = config.pkgx_dir.join(&pkg.project);
     fs::create_dir_all(&shelf)?;
-    let shelf = OpenOptions::new()
+
+    #[cfg(windows)]
+    let lockfile = OpenOptions::new()
+        .read(true)
+        .write(true)
+        .create(true)
+        .truncate(true)
+        .open(shelf.join("lockfile"))?;
+    #[cfg(not(windows))]
+    let lockfile = OpenOptions::new()
         .read(true) // Open the directory in read-only mode
         .open(shelf.clone())?;
 
     task::spawn_blocking({
-        let shelf = shelf.try_clone()?;
+        let lockfile = lockfile.try_clone()?;
         move || {
-            shelf
+            lockfile
                 .lock_exclusive()
                 .expect("unexpected error: install locking failed");
         }
@@ -57,7 +69,7 @@ where
     // did another instance of pkgx install us while we waited for the lock?
     // if so, we’re good: eject
     if dst_path.is_dir() {
-        FileExt::unlock(&shelf)?;
+        FileExt::unlock(&lockfile)?;
         return Ok(Installation {
             path: dst_path,
             pkg: pkg.clone(),
@@ -110,19 +122,22 @@ where
         pkg: pkg.clone(),
     };
 
+    #[cfg(not(windows))]
     symlink(&installation, config).await?;
+    // ^^ you need admin privs to symlink on windows (wtf)
 
-    FileExt::unlock(&shelf)?;
+    FileExt::unlock(&lockfile)?;
 
     Ok(installation)
 }
 
-use libsemverator::range::Range as VersionReq;
-use libsemverator::semver::Semver as Version;
-use std::collections::VecDeque;
-use std::fs;
-use std::path::Path;
+#[cfg(not(windows))]
+use {
+    libsemverator::range::Range as VersionReq, libsemverator::semver::Semver as Version,
+    std::collections::VecDeque, std::path::Path, std::path::PathBuf,
+};
 
+#[cfg(not(windows))]
 async fn symlink(installation: &Installation, config: &Config) -> Result<(), Box<dyn Error>> {
     let mut versions: VecDeque<(Version, PathBuf)> = cellar::ls(&installation.pkg.project, config)
         .await?
@@ -183,6 +198,7 @@ async fn symlink(installation: &Installation, config: &Config) -> Result<(), Box
     Ok(())
 }
 
+#[cfg(not(windows))]
 async fn make_symlink(
     shelf: &Path,
     symname: &str,
@@ -203,9 +219,10 @@ async fn make_symlink(
         .file_name()
         .ok_or_else(|| anyhow::anyhow!("Could not get the base name of the installation path"))?;
 
-    match std::os::unix::fs::symlink(target, &symlink_path) {
-        Ok(_) => Ok(()),
-        Err(err) if err.kind() == std::io::ErrorKind::AlreadyExists => Ok(()),
-        Err(err) => Err(err.into()),
-    }
+    #[cfg(not(windows))]
+    std::os::unix::fs::symlink(target, &symlink_path)?;
+    #[cfg(windows)]
+    std::os::windows::fs::symlink_dir(target, symlink_path)?;
+
+    Ok(())
 }