Merge pull request #6 from AstraBert/fix/windows-compat

fix: windows compatibility

Author: AstraBert

.github/workflows/test.yaml

@@ -38,3 +38,28 @@ jobs:
 
       - name: Run tests
         run: jake test
+
+  test-windows:
+    name: Test on windows-latest
+    runs-on: windows-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Cache cargo registry
+        uses: actions/cache@v4
+        with:
+          path: |
+            ${{ runner.os == 'Windows' && '~\\.cargo\\registry' || '~/.cargo/registry' }}
+            ${{ runner.os == 'Windows' && '~\\.cargo\\git' || '~/.cargo/git' }}
+            target
+          key: ${{ runner.os }}-cargo-test-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-
+
+      - name: Run tests
+        run: cargo test

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "aggit"
-version = "0.2.0-alpha"
+version = "0.3.0-alpha"
 edition = "2024"
 license-file = "LICENSE"
 readme = "README.md"

Cargo.toml

@@ -11,14 +11,9 @@ S3-backed, git-versioned object storage for agents.
 ## Installation
 
 ```bash
-cargo install aggit@0.2.0-alpha
+cargo install aggit@0.3.0-alpha
 ```
 
-
-> [!NOTE]
->
-> `aggit` is not yet compatible with Windows.
-
 ### As an Agent Skill
 
 You can use `aggit` as an agent skill, downloading it with the `skills` CLI tool:

README.md

@@ -9,11 +9,9 @@ use flate2::{
 use ignore::WalkBuilder;
 use serde::{Deserialize, Serialize};
 use sha1_checked::{Digest, Sha1};
-use std::{
-    collections::HashMap,
-    fs::Permissions,
-    os::unix::fs::{MetadataExt, PermissionsExt},
-};
+use std::collections::HashMap;
+#[cfg(unix)]
+use std::os::unix::fs::{MetadataExt, PermissionsExt};
 use std::{collections::HashSet, time::SystemTime};
 use std::{fmt, fs, path::PathBuf, str::FromStr};
 use std::{
@@ -626,18 +624,69 @@ pub fn add(paths: Vec<String>) -> anyhow::Result<()> {
             .try_into()
             .map_err(|_| anyhow::anyhow!("SHA1 hash must be 20 bytes"))?;
         let entry = IndexEntry {
+            sha1: sha1_bytes,
+            flags,
+            size: st.len() as u32,
+
+            #[cfg(unix)]
             ctime_s: st.ctime() as u32,
+            #[cfg(not(unix))]
+            ctime_s: st
+                .created()
+                .ok()
+                .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
+                .map(|d| d.as_secs() as u32)
+                .unwrap_or(0),
+
+            #[cfg(unix)]
             ctime_n: st.ctime_nsec() as u32,
-            mtime_n: st.mtime() as u32,
-            mtime_s: st.mtime_nsec() as u32,
+            #[cfg(not(unix))]
+            ctime_n: 0,
+
+            #[cfg(unix)]
+            mtime_s: st.mtime() as u32,
+            #[cfg(not(unix))]
+            mtime_s: st
+                .modified()
+                .ok()
+                .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
+                .map(|d| d.as_secs() as u32)
+                .unwrap_or(0),
+
+            #[cfg(unix)]
+            mtime_n: st.mtime_nsec() as u32,
+            #[cfg(not(unix))]
+            mtime_n: 0,
+
+            #[cfg(unix)]
             dev: st.dev() as u32,
+            #[cfg(not(unix))]
+            dev: 0,
+
+            #[cfg(unix)]
             ino: st.ino() as u32,
-            size: st.size() as u32,
-            gid: st.gid(),
-            uid: st.uid(),
+            #[cfg(not(unix))]
+            ino: 0,
+
+            #[cfg(unix)]
             mode: st.mode(),
-            flags,
-            sha1: sha1_bytes,
+            #[cfg(not(unix))]
+            mode: if st.permissions().readonly() {
+                0o100444
+            } else {
+                0o100644
+            },
+
+            #[cfg(unix)]
+            uid: st.uid(),
+            #[cfg(not(unix))]
+            uid: 0,
+
+            #[cfg(unix)]
+            gid: st.gid(),
+            #[cfg(not(unix))]
+            gid: 0,
+
             path,
         };
         entries.push(entry);
@@ -1005,7 +1054,16 @@ pub fn restore_working_tree(commit_hash: String) -> anyhow::Result<()> {
                 fs::create_dir_all(par)?;
             }
             fs::write(path, &file_data)?;
-            fs::set_permissions(path, Permissions::from_mode(*mode))?;
+            #[cfg(unix)]
+            fs::set_permissions(&path, fs::Permissions::from_mode(*mode))?;
+
+            #[cfg(not(unix))]
+            {
+                let mut perms = fs::metadata(&path)?.permissions();
+                let readonly = (*mode & 0o200) == 0; // owner write bit unset = readonly
+                perms.set_readonly(readonly);
+                fs::set_permissions(&path, perms)?;
+            }
         }
     }
 
@@ -1017,21 +1075,63 @@ pub fn restore_working_tree(commit_hash: String) -> anyhow::Result<()> {
             if flags >= (1 << 12) {
                 return Err(anyhow!("Invalid flags"));
             }
-            let meta = fs::metadata(path)?; // stat the just-written file
+            let st = fs::metadata(path)?; // stat the just-written file
             Ok(IndexEntry {
                 mode: *mode,
                 path: path.clone(),
                 sha1: hex::decode(sha1)?.try_into().unwrap(),
-                ctime_s: meta.ctime() as u32,
-                ctime_n: meta.ctime_nsec() as u32,
-                mtime_s: meta.mtime() as u32,
-                mtime_n: meta.mtime_nsec() as u32,
-                size: meta.size() as u32,
-                ino: meta.ino() as u32,
-                dev: meta.dev() as u32,
-                uid: meta.uid(),
-                gid: meta.gid(),
+                size: st.len() as u32,
                 flags,
+
+                #[cfg(unix)]
+                ctime_s: st.ctime() as u32,
+                #[cfg(not(unix))]
+                ctime_s: st
+                    .created()
+                    .ok()
+                    .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
+                    .map(|d| d.as_secs() as u32)
+                    .unwrap_or(0),
+
+                #[cfg(unix)]
+                ctime_n: st.ctime_nsec() as u32,
+                #[cfg(not(unix))]
+                ctime_n: 0,
+
+                #[cfg(unix)]
+                mtime_s: st.mtime() as u32,
+                #[cfg(not(unix))]
+                mtime_s: st
+                    .modified()
+                    .ok()
+                    .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
+                    .map(|d| d.as_secs() as u32)
+                    .unwrap_or(0),
+
+                #[cfg(unix)]
+                mtime_n: st.mtime_nsec() as u32,
+                #[cfg(not(unix))]
+                mtime_n: 0,
+
+                #[cfg(unix)]
+                dev: st.dev() as u32,
+                #[cfg(not(unix))]
+                dev: 0,
+
+                #[cfg(unix)]
+                ino: st.ino() as u32,
+                #[cfg(not(unix))]
+                ino: 0,
+
+                #[cfg(unix)]
+                uid: st.uid(),
+                #[cfg(not(unix))]
+                uid: 0,
+
+                #[cfg(unix)]
+                gid: st.gid(),
+                #[cfg(not(unix))]
+                gid: 0,
             })
         })
         .collect::<anyhow::Result<Vec<_>>>()?;
@@ -1210,6 +1310,7 @@ mod tests {
     }
 
     #[test]
+    #[serial_test::serial]
     fn test_read_object_roundtrip() {
         let data = b"roundtrip data".to_vec();
         let hash = hash_object(&mut data.clone(), ObjectType::Blob, true).unwrap();

src/gitops/mod.rs

@@ -135,4 +135,3 @@ mod tests {
         cleanup_aggit_dir();
     }
 }
-