Build on windows

Author: mxcl

.envrc

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

.github/workflows/ci.yml

@@ -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

crates/cli/src/execve.rs

@@ -1,7 +1,11 @@
+#[cfg(unix)]
 use nix::unistd::execve as nix_execve;
+#[cfg(unix)]
 use std::ffi::CString;
+
 use std::{collections::HashMap, error::Error};
 
+#[cfg(unix)]
 pub fn execve(
     cmd: String,
     mut args: Vec<String>,
@@ -47,3 +51,22 @@ pub fn execve(
 
     Ok(())
 }
+
+#[cfg(windows)]
+use std::process::{exit, Command};
+
+#[cfg(windows)]
+pub fn execve(
+    cmd: String,
+    args: Vec<String>,
+    env: HashMap<String, String>,
+) -> Result<(), Box<dyn Error>> {
+    Command::new(cmd)
+        .args(args)
+        .envs(env)
+        .spawn()
+        .expect("Failed to execute process");
+
+    // If you want behavior similar to `execve`, exit the current process
+    exit(0);
+}

crates/lib/src/install.rs

@@ -13,6 +13,9 @@ use tokio_util::compat::FuturesAsyncReadCompatExt;
 // futures::io::AsyncRead.
 use futures::stream::TryStreamExt;
 
+#[cfg(windows)]
+use std::os::windows::fs::symlink_dir;
+
 use crate::{
     cellar,
     client::build_client,
@@ -38,14 +41,22 @@ 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)
+        .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 +68,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(),
@@ -112,7 +123,7 @@ where
 
     symlink(&installation, config).await?;
 
-    FileExt::unlock(&shelf)?;
+    FileExt::unlock(&lockfile)?;
 
     Ok(installation)
 }
@@ -203,9 +214,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)]
+    symlink_dir(target, symlink_path)?;
+
+    Ok(())
 }

crates/lib/src/pantry.rs

@@ -285,9 +285,10 @@ impl<'de> Deserialize<'de> for Provides {
             ProvidesHelper::Map(map) => {
                 #[cfg(target_os = "macos")]
                 let key = "darwin";
-
                 #[cfg(target_os = "linux")]
                 let key = "linux";
+                #[cfg(windows)]
+                let key = "windows";
 
                 if let Some(values) = map.get(key) {
                     Ok(Provides(values.clone()))

crates/lib/src/sync.rs

@@ -52,19 +52,23 @@ async fn replace(config: &Config, conn: &mut Connection) -> Result<(), Box<dyn E
         config.dist_url,
         env!("PKGX_PANTRY_TARBALL_FILENAME")
     );
-    let dest = &config.pantry_dir;
 
-    std::fs::create_dir_all(dest)?;
-    let dir = OpenOptions::new()
-        .read(true) // Open in read-only mode; no need to write.
-        .open(dest)?;
-    dir.lock_exclusive()?;
+    std::fs::create_dir_all(&config.pantry_dir)?;
+    #[cfg(not(windows))]
+    let lockfile = OpenOptions::new().read(true).open(&config.pantry_dir)?;
+    #[cfg(windows)]
+    let lockfile = OpenOptions::new()
+        .read(true)
+        .create(true)
+        .write(true)
+        .open(config.pantry_dir.join("lockfile"))?;
+    lockfile.lock_exclusive()?;
 
-    download_and_extract_pantry(&url, dest).await?;
+    download_and_extract_pantry(&url, &config.pantry_dir).await?;
 
     pantry_db::cache(config, conn)?;
 
-    FileExt::unlock(&dir)?;
+    FileExt::unlock(&lockfile)?;
 
     Ok(())
 }

crates/lib/src/types.rs

@@ -87,6 +87,7 @@ impl Serialize for Installation {
 pub enum Host {
     Darwin,
     Linux,
+    Windows,
 }
 
 // These are only used per build at present
@@ -101,8 +102,8 @@ pub fn host() -> (Host, Arch) {
     let host = Host::Darwin;
     #[cfg(target_os = "linux")]
     let host = Host::Linux;
-    #[cfg(not(any(target_os = "macos", target_os = "linux")))]
-    panic!("Unsupported platform");
+    #[cfg(windows)]
+    let host = Host::Windows;
 
     #[cfg(target_arch = "aarch64")]
     let arch = Arch::Arm64;
@@ -119,6 +120,7 @@ impl fmt::Display for Host {
         let os_str = match self {
             Host::Linux => "linux",
             Host::Darwin => "darwin",
+            Host::Windows => "windows",
         };
         write!(f, "{}", os_str)
     }

crates/lib/src/utils.rs

@@ -1,4 +1,6 @@
-use std::{error::Error, os::unix::fs::PermissionsExt, path::Path};
+#[cfg(not(windows))]
+use std::os::unix::fs::PermissionsExt;
+use std::{error::Error, path::Path};
 
 pub async fn find_program(arg: &str, paths: &Vec<String>) -> Result<String, Box<dyn Error>> {
     if arg.starts_with("/") {
@@ -13,9 +15,21 @@ pub async fn find_program(arg: &str, paths: &Vec<String>) -> Result<String, Box<
     }
     for path in paths {
         let full_path = Path::new(&path).join(arg);
-        if let Ok(metadata) = full_path.metadata() {
-            if full_path.is_file() && (metadata.permissions().mode() & 0o111 != 0) {
-                return Ok(full_path.to_str().unwrap().to_string());
+        if full_path.is_file() {
+            #[cfg(unix)]
+            if let Ok(metadata) = full_path.metadata() {
+                if metadata.permissions().mode() & 0o111 != 0 {
+                    return Ok(full_path.to_str().unwrap().to_string());
+                }
+            }
+            #[cfg(windows)]
+            if let Some(ext) = full_path.extension() {
+                match ext.to_str() {
+                    Some("exe") | Some("bat") | Some("cmd") => {
+                        return Ok(full_path.to_str().unwrap().to_string())
+                    }
+                    _ => {}
+                }
             }
         }
     }