fix: add Windows support by guarding Unix-specific file permission APIs (jdx#349)

jdx · claude · web-flow · commit b6bf1fc7e83e · 2025-10-05T17:30:59.000Z
## Summary The v1.17.0 release workflow failed on Windows builds because Unix-specific file permission APIs were used without platform guards. ## Problem The Windows build was failing with errors like: ``` error[E0433]: failed to resolve: could not find `unix` in `os` ``` This occurred in two files: - `src/cli/migrate/pre_commit.rs:1707` - `use std::os::unix::fs::PermissionsExt` - `src/cli/util/check_executables_have_shebangs.rs:3` - `use std::os::unix::fs::PermissionsExt` ## Solution Added proper `#[cfg(unix)]` guards around all Unix-specific code: 1. **check_executables_have_shebangs.rs**: - Guarded `PermissionsExt` import with `#[cfg(unix)]` - Split `is_executable()` implementation: Unix checks execute bits, Windows returns false - Marked Unix-specific tests with `#[cfg(unix)]` 2. **pre_commit.rs**: - Wrapped entire `make_scripts_executable()` Unix implementation in `#[cfg(unix)]` block - Added Windows no-op implementation (Windows uses file associations, not execute bits) ## Behavior - **Unix/Linux/macOS**: No change in behavior - still checks/sets execute permissions - **Windows**: Functions compile and run but don't check/set Unix permissions (which don't exist on Windows) ## Test Plan - [x] Compiles successfully on macOS (tested locally) - [x] Will verify Windows builds pass in CI Fixes the Windows build failures in https://github.com/jdx/hk/actions/runs/18261671379 🤖 Generated with [Claude Code](https://claude.com/claude-code)  --- > [!NOTE] > Guards Unix-only permission code for Windows, enables staged rename detection in git status, and adds tests for renamed files. > > - **Compatibility (Windows)** > - Wrap Unix-specific permission logic with `#[cfg(unix)]` and provide Windows no-ops in `src/cli/migrate/pre_commit.rs::make_scripts_executable` and `src/cli/util/check_executables_have_shebangs.rs`. > - Gate `PermissionsExt` imports and Unix-specific tests with `#[cfg(unix)]`; on Windows `is_executable` returns `false`. > - **Git status improvements** > - Enable rename detection with libgit2 via `status_options.renames_head_to_index(true)` and shell fallback by removing `--no-renames` from `git status --porcelain`. > - **Tests** > - Add `test/staged_renamed_files.bats` to assert `git.staged_renamed_files` detection (single and multiple renames). > > <sup>Written by [Cursor Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit 9a7c15e. This will update automatically on new commits. Configure [here](https://cursor.com/dashboard?tab=bugbot).</sup>  --------- Co-authored-by: Claude <noreply@anthropic.com>
diff --git a/src/cli/migrate/pre_commit.rs b/src/cli/migrate/pre_commit.rs
@@ -1704,46 +1704,56 @@ impl PreCommit {
 
     /// Make Python scripts and other executable files in the vendor directory executable
     fn make_scripts_executable(vendor_path: &Path) -> Result<()> {
-        use std::os::unix::fs::PermissionsExt;
-
-        // Find all Python files and shell scripts
-        if let Ok(entries) = std::fs::read_dir(vendor_path) {
-            for entry in entries.flatten() {
-                let path = entry.path();
-                if path.is_file() {
-                    if let Some(ext) = path.extension() {
-                        if ext == "py" || ext == "sh" {
-                            // Make executable
-                            if let Ok(metadata) = std::fs::metadata(&path) {
-                                let mut perms = metadata.permissions();
-                                perms.set_mode(perms.mode() | 0o111); // Add execute permission
-                                let _ = std::fs::set_permissions(&path, perms);
-                            }
-                        }
-                    }
-                }
-            }
-        }
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::PermissionsExt;
 
-        // Also check pre_commit_hooks subdirectory if it exists
-        let hooks_dir = vendor_path.join("pre_commit_hooks");
-        if hooks_dir.exists() {
-            if let Ok(entries) = std::fs::read_dir(&hooks_dir) {
+            // Find all Python files and shell scripts
+            if let Ok(entries) = std::fs::read_dir(vendor_path) {
                 for entry in entries.flatten() {
                     let path = entry.path();
                     if path.is_file() {
                         if let Some(ext) = path.extension() {
-                            if ext == "py" {
+                            if ext == "py" || ext == "sh" {
+                                // Make executable
                                 if let Ok(metadata) = std::fs::metadata(&path) {
                                     let mut perms = metadata.permissions();
-                                    perms.set_mode(perms.mode() | 0o111);
+                                    perms.set_mode(perms.mode() | 0o111); // Add execute permission
                                     let _ = std::fs::set_permissions(&path, perms);
                                 }
                             }
                         }
                     }
                 }
             }
+
+            // Also check pre_commit_hooks subdirectory if it exists
+            let hooks_dir = vendor_path.join("pre_commit_hooks");
+            if hooks_dir.exists() {
+                if let Ok(entries) = std::fs::read_dir(&hooks_dir) {
+                    for entry in entries.flatten() {
+                        let path = entry.path();
+                        if path.is_file() {
+                            if let Some(ext) = path.extension() {
+                                if ext == "py" {
+                                    if let Ok(metadata) = std::fs::metadata(&path) {
+                                        let mut perms = metadata.permissions();
+                                        perms.set_mode(perms.mode() | 0o111);
+                                        let _ = std::fs::set_permissions(&path, perms);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        #[cfg(not(unix))]
+        {
+            // On Windows, executable permissions are not managed the same way.
+            // Files with .py, .sh extensions are typically executed through their interpreters.
+            let _ = vendor_path; // Suppress unused variable warning
         }
 
         Ok(())
diff --git a/src/cli/util/check_executables_have_shebangs.rs b/src/cli/util/check_executables_have_shebangs.rs
@@ -1,5 +1,6 @@
 use crate::Result;
 use std::fs;
+#[cfg(unix)]
 use std::os::unix::fs::PermissionsExt;
 use std::path::PathBuf;
 
@@ -37,10 +38,19 @@ fn is_executable(path: &PathBuf) -> Result<bool> {
         return Ok(false);
     }
 
-    let permissions = metadata.permissions();
+    #[cfg(unix)]
+    {
+        let permissions = metadata.permissions();
+        // Check if any execute bit is set
+        Ok(permissions.mode() & 0o111 != 0)
+    }
 
-    // Check if any execute bit is set
-    Ok(permissions.mode() & 0o111 != 0)
+    #[cfg(not(unix))]
+    {
+        // On Windows, we can't reliably check execute permissions via file attributes.
+        // Return false so we don't incorrectly flag files.
+        Ok(false)
+    }
 }
 
 fn has_shebang(path: &PathBuf) -> Result<bool> {
@@ -59,6 +69,7 @@ fn has_shebang(path: &PathBuf) -> Result<bool> {
 mod tests {
     use super::*;
     use std::fs;
+    #[cfg(unix)]
     use std::os::unix::fs::PermissionsExt;
     use tempfile::NamedTempFile;
 
@@ -100,6 +111,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(unix)]
     fn test_is_executable() {
         let file = NamedTempFile::new().unwrap();
         fs::write(file.path(), b"#!/bin/bash\necho hello").unwrap();
@@ -114,6 +126,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(unix)]
     fn test_not_executable() {
         let file = NamedTempFile::new().unwrap();
         fs::write(file.path(), b"#!/bin/bash\necho hello").unwrap();
