fix: track FindFirstFile/FindNextFile on Windows for cache invalidation

When oxlint scans a directory, it uses FindFirstFile/FindNextFile Win32
APIs to enumerate files. Without intercepting these calls, fspy wouldn't
see READ_DIR accesses, causing the cache to miss file additions.

This fix:
- Adds detours for FindFirstFileW and FindFirstFileExW
- Uses GetCurrentDirectoryW for relative patterns like "*"
- Fixes fingerprint.rs to handle paths with trailing backslash

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: branchseer

.gitignore

@@ -5,3 +5,4 @@ dist
 *.tsbuildinfo
 .DS_Store
 /.vscode/settings.json
+*.snap.new

crates/fspy/tests/oxlint.rs

@@ -0,0 +1,80 @@
+mod test_utils;
+
+use std::env::vars_os;
+
+use fspy::{AccessMode, PathAccessIterable};
+use test_log::test;
+
+/// Find the oxlint executable in test_bins
+fn find_oxlint() -> std::path::PathBuf {
+    let test_bins_dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .unwrap()
+        .join("vite_task_bin")
+        .join("test_bins")
+        .join("node_modules")
+        .join(".bin");
+
+    which::which_in("oxlint", Some(&test_bins_dir), std::env::current_dir().unwrap())
+        .expect("oxlint not found in test_bins/node_modules/.bin")
+}
+
+async fn track_oxlint(dir: &std::path::Path, args: &[&str]) -> anyhow::Result<PathAccessIterable> {
+    let oxlint_path = find_oxlint();
+    let mut command = fspy::Command::new(&oxlint_path);
+    command.args(args).envs(vars_os()).current_dir(dir);
+
+    let child = command.spawn().await?;
+    let termination = child.wait_handle.await?;
+    // oxlint may return non-zero if it finds lint errors, that's OK
+    Ok(termination.path_accesses)
+}
+
+#[test(tokio::test)]
+async fn oxlint_reads_js_file() -> anyhow::Result<()> {
+    let tmpdir = tempfile::tempdir()?;
+    let js_file = tmpdir.path().join("test.js");
+    std::fs::write(&js_file, "console.log('hello');")?;
+
+    let accesses = track_oxlint(tmpdir.path(), &[]).await?;
+
+    // Check that oxlint read the JS file
+    test_utils::assert_contains(&accesses, &js_file, AccessMode::READ);
+
+    Ok(())
+}
+
+#[test(tokio::test)]
+async fn oxlint_reads_directory() -> anyhow::Result<()> {
+    let tmpdir = tempfile::tempdir()?;
+    let js_file = tmpdir.path().join("test.js");
+    std::fs::write(&js_file, "console.log('hello');")?;
+
+    let accesses = track_oxlint(tmpdir.path(), &[]).await?;
+
+    // Check that oxlint read the directory to find JS files
+    // This is the key check - if READ_DIR is not tracked, cache won't detect new files
+    test_utils::assert_contains(&accesses, tmpdir.path(), AccessMode::READ_DIR);
+
+    Ok(())
+}
+
+#[test(tokio::test)]
+async fn oxlint_empty_directory_reads_dir() -> anyhow::Result<()> {
+    let tmpdir = tempfile::tempdir()?;
+    // No files in directory
+
+    let accesses = track_oxlint(tmpdir.path(), &[]).await?;
+
+    // Even with no JS files, oxlint should read the directory to discover files
+    // Print all accesses for debugging
+    println!("All accesses in empty directory:");
+    for access in accesses.iter() {
+        println!("  {:?}", access);
+    }
+
+    // This assertion may fail - that would indicate the bug
+    test_utils::assert_contains(&accesses, tmpdir.path(), AccessMode::READ_DIR);
+
+    Ok(())
+}

crates/fspy_preload_windows/Cargo.toml

@@ -14,7 +14,7 @@ fspy_shared = { workspace = true }
 ntapi = { workspace = true }
 smallvec = { workspace = true }
 widestring = { workspace = true }
-winapi = { workspace = true, features = ["winerror", "winbase", "namedpipeapi", "memoryapi", "std"] }
+winapi = { workspace = true, features = ["winerror", "winbase", "namedpipeapi", "memoryapi", "std", "processenv"] }
 winsafe = { workspace = true }
 
 [target.'cfg(target_os = "windows")'.dev-dependencies]

crates/fspy_preload_windows/src/windows/detours/find_file.rs

@@ -0,0 +1,149 @@
+//! Detours for FindFirstFile/FindNextFile APIs to track directory reads.
+//!
+//! These Win32 APIs are commonly used for directory enumeration and need to be
+//! intercepted to track READ_DIR accesses.
+
+#![allow(non_snake_case)] // Windows API parameter naming convention
+
+use fspy_shared::ipc::{AccessMode, NativeStr, PathAccess};
+use smallvec::SmallVec;
+use widestring::U16CStr;
+use winapi::{
+    shared::{
+        minwindef::{DWORD, LPVOID, MAX_PATH},
+        ntdef::HANDLE,
+    },
+    um::{
+        fileapi::FindFirstFileExW,
+        minwinbase::{FINDEX_INFO_LEVELS, FINDEX_SEARCH_OPS, LPWIN32_FIND_DATAW},
+        processenv::GetCurrentDirectoryW,
+        winnt::LPCWSTR,
+    },
+};
+
+use crate::windows::{
+    client::global_client,
+    detour::{Detour, DetourAny},
+};
+
+/// Get the current directory as a wide string
+fn get_current_directory() -> SmallVec<u16, MAX_PATH> {
+    let mut buffer = SmallVec::<u16, MAX_PATH>::new();
+    buffer.resize(MAX_PATH, 0);
+
+    let len = unsafe { GetCurrentDirectoryW(buffer.len() as DWORD, buffer.as_mut_ptr()) };
+    if len == 0 {
+        // Failed to get current directory, return empty
+        return SmallVec::new();
+    }
+
+    let len = len as usize;
+    if len > buffer.len() {
+        // Buffer too small, allocate more
+        buffer.resize(len, 0);
+        let len = unsafe { GetCurrentDirectoryW(buffer.len() as DWORD, buffer.as_mut_ptr()) };
+        if len == 0 {
+            return SmallVec::new();
+        }
+        buffer.truncate(len as usize);
+    } else {
+        buffer.truncate(len);
+    }
+
+    buffer
+}
+
+/// Extract the directory path from a search pattern like "C:\foo\*" -> "C:\foo"
+/// For patterns without a directory separator (like "*"), returns the current directory
+fn extract_directory_from_pattern(pattern: &U16CStr) -> SmallVec<u16, MAX_PATH> {
+    let slice = pattern.as_slice();
+
+    // Find the last backslash or forward slash
+    if let Some(last_sep_pos) = slice.iter().rposition(|&c| c == b'\\' as u16 || c == b'/' as u16) {
+        // Return the directory part (without trailing separator)
+        slice[..last_sep_pos].iter().cloned().collect()
+    } else {
+        // No separator found - pattern is in current directory (e.g., "*" or "*.js")
+        // Return the current directory
+        get_current_directory()
+    }
+}
+
+static DETOUR_FIND_FIRST_FILE_EX_W: Detour<
+    unsafe extern "system" fn(
+        lpFileName: LPCWSTR,
+        fInfoLevelId: FINDEX_INFO_LEVELS,
+        lpFindFileData: LPVOID,
+        fSearchOp: FINDEX_SEARCH_OPS,
+        lpSearchFilter: LPVOID,
+        dwAdditionalFlags: DWORD,
+    ) -> HANDLE,
+> = unsafe {
+    Detour::new(c"FindFirstFileExW", FindFirstFileExW, {
+        unsafe extern "system" fn new_find_first_file_ex_w(
+            lpFileName: LPCWSTR,
+            fInfoLevelId: FINDEX_INFO_LEVELS,
+            lpFindFileData: LPVOID,
+            fSearchOp: FINDEX_SEARCH_OPS,
+            lpSearchFilter: LPVOID,
+            dwAdditionalFlags: DWORD,
+        ) -> HANDLE {
+            // Track the directory access before calling the real function
+            if !lpFileName.is_null() {
+                let pattern = unsafe { U16CStr::from_ptr_str(lpFileName) };
+                let dir_path = extract_directory_from_pattern(pattern);
+                let client = unsafe { global_client() };
+                let path_access = PathAccess {
+                    mode: AccessMode::READ_DIR,
+                    path: NativeStr::from_wide(&dir_path),
+                };
+                client.send(path_access);
+            }
+
+            // Call the original function
+            unsafe {
+                (DETOUR_FIND_FIRST_FILE_EX_W.real())(
+                    lpFileName,
+                    fInfoLevelId,
+                    lpFindFileData,
+                    fSearchOp,
+                    lpSearchFilter,
+                    dwAdditionalFlags,
+                )
+            }
+        }
+        new_find_first_file_ex_w
+    })
+};
+
+// FindFirstFileW is typically a wrapper around FindFirstFileExW, but let's intercept it too
+// in case some applications call it directly
+static DETOUR_FIND_FIRST_FILE_W: Detour<
+    unsafe extern "system" fn(lpFileName: LPCWSTR, lpFindFileData: LPWIN32_FIND_DATAW) -> HANDLE,
+> = unsafe {
+    Detour::new(c"FindFirstFileW", winapi::um::fileapi::FindFirstFileW, {
+        unsafe extern "system" fn new_find_first_file_w(
+            lpFileName: LPCWSTR,
+            lpFindFileData: LPWIN32_FIND_DATAW,
+        ) -> HANDLE {
+            // Track the directory access before calling the real function
+            if !lpFileName.is_null() {
+                let pattern = unsafe { U16CStr::from_ptr_str(lpFileName) };
+                let dir_path = extract_directory_from_pattern(pattern);
+                let client = unsafe { global_client() };
+                let path_access = PathAccess {
+                    mode: AccessMode::READ_DIR,
+                    path: NativeStr::from_wide(&dir_path),
+                };
+                client.send(path_access);
+            }
+
+            // Call the original function
+            unsafe { (DETOUR_FIND_FIRST_FILE_W.real())(lpFileName, lpFindFileData) }
+        }
+        new_find_first_file_w
+    })
+};
+
+pub const DETOURS: &[DetourAny] =
+    &[DETOUR_FIND_FIRST_FILE_EX_W.as_any(), DETOUR_FIND_FIRST_FILE_W.as_any()];

crates/fspy_preload_windows/src/windows/detours/mod.rs

@@ -1,4 +1,5 @@
 mod create_process;
+mod find_file;
 mod nt;
 
 use constcat::concat_slices;
@@ -7,5 +8,6 @@ use super::detour::DetourAny;
 
 pub const DETOURS: &[DetourAny] = concat_slices!([DetourAny]:
     create_process::DETOURS,
+    find_file::DETOURS,
     nt::DETOURS,
 );

crates/vite_task/src/session/execute/fingerprint.rs

@@ -169,6 +169,11 @@ pub fn fingerprint_path(
                     // This might be a directory - try reading it as such
                     return process_directory(std_path, path_read);
                 }
+                // On Windows, paths with trailing backslash (from joining empty path)
+                // fail with NotFound (error code 3). Try as directory in this case.
+                if err.raw_os_error() == Some(3) && std_path.to_string_lossy().ends_with('\\') {
+                    return process_directory(std_path, path_read);
+                }
             }
             if err.kind() != io::ErrorKind::NotFound {
                 tracing::trace!(