fix(task): use shared memory for fspy ipc (#234)

Implemented a shared memory IPC channel for fspy to improve performance and reliability when tracking file system accesses.

The channel implementation is cross-platform. In this PR it's only adopted in macOS/Linux version of `fspy`​. Windows version of `fspy`​ will switch to it in a separate PR.

### Why make this change?

The previous IPC implementation uses **file descriptor inheritance** to pass down the IPC channel. It has the risk of descriptors being closed in the child processes. Some defensive logic was implemented to handle it, including:

- Increase the fd number to avoid Node.js closing small fds: https://github.com/voidzero-dev/vite-plus/blob/540f597f50d049d444a09356da7c929b6da10b22/crates/fspy/src/unix/mod.rs#L156
- Intercept `posix_spawn`​  to avoid being closed by `POSIX_SPAWN_CLOEXEC_DEFAULT`​: https://github.com/voidzero-dev/vite-plus/blob/540f597f50d049d444a09356da7c929b6da10b22/crates/fspy_preload_unix/src/client/mod.rs#L208

It apparently missed some cases, and the IPC fd still got closed, leading to `bad descriptor`​ error in https://github.com/voidzero-dev/vibe-dashboard/actions/runs/18532354385/job/52818262992.

### What changed?

- Created a new shared memory-based IPC channel implementation for fspy that replaces the previous Unix socket approach.
    - The shared memory is looked up **based on names instead of descriptors**, making it impossible to be unexpectedly closed in child processes.
    - Proper file locking is added to ensure safe access to shared memory
    - Writing to the IPC channel **becomes much faster as it now only does some atomic memory operations** and doesn't trigger any syscalls.
- Modified the semantics of fs access tracking:
    - The previous implementation automatically waits for the root target process and all its descendants to exit due to the nature of file descriptor inheritance.
    - The new implementation requires waiting `accesses_future` after the root target process has exited. If descendants are spawned after the root target process has exited, their fs accesses will be missed.

<!-- CURSOR_SUMMARY -->

---

> [!NOTE]
> Replaces Unix fspy IPC with a lock-backed shared-memory channel and updates payloads, readers, and callers; adds test utils and adjusts env/TLS dependencies.
>
> - **IPC (core)**:
>     - Introduces shared-memory IPC (`fspy_shared::ipc::channel`) with `Sender`/`Receiver` and lock-guarded `ShmReader`/`ShmWriter` for zero-syscall writes.
> - **fspy (Unix/macOS)**:
>     - Switches from FD/Unix-socket IPC to shared memory; payload now carries `ChannelConf` instead of an FD.
>     - Refactors `SpyInner::init_in`, fixture handling, and path injection; reads frames via shared memory; lazy-locks receiver after child exit.
> - **Preload (Unix)**:
>     - Client sends `PathAccess` via shared memory; removes POSIX spawn FD-inheritance handling; minor argv handling fix.
> - **Windows**:
>     - Keeps pipe IPC; small fix to `NativeStr` construction and a temporary task to avoid blocking.
> - **API/Semantics & Callers**:
>     - `accesses_future` must be awaited after child exit; updates examples, tests, e2e, and `vite_task` execution flow accordingly.
>     - Adds `fspy_test_utils` crate for cross-process test helpers.
> - **Shared types**:
>     - Enhances `NativeStr`/`NativeString` for zero-copy (ANSI/wide) and cross-platform encoding; updates spawn payload/env usage.
> - **Dependencies**:
>     - Adds `shared_memory`, `memmap2`, `uuid`, `tracing`; tweaks `nix` features; switches `reqwest` to `native-tls-vendored` (adds `openssl-src`).
> - **Misc**:
>     - Cleans up obsolete files and adjusts test steps (platform filters).
>
> <sup>Written by [Cursor Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit 8f35015. This will update automatically on new commits. Configure [here](https://cursor.com/dashboard?tab=bugbot).</sup>

<!-- /CURSOR_SUMMARY -->

Author: wan9chi

Cargo.lock

@@ -73,6 +73,7 @@ fspy_preload_windows = { path = "crates/fspy_preload_windows", artifact = "cdyli
 fspy_seccomp_unotify = { path = "crates/fspy_seccomp_unotify" }
 fspy_shared = { path = "crates/fspy_shared" }
 fspy_shared_unix = { path = "crates/fspy_shared_unix" }
+fspy_test_utils = { path = "crates/fspy_test_utils" }
 futures = "0.3.31"
 futures-core = "0.3.31"
 futures-util = "0.3.31"
@@ -109,6 +110,7 @@ serde_yml = "0.0.12"
 serial_test = "3.2.0"
 sha1 = "0.10.6"
 sha2 = "0.10.9"
+shared_memory = "0.12.4"
 shell-escape = "0.1.5"
 slab = "0.4.9"
 smallvec = { version = "2.0.0-alpha.11", features = ["std"] }

Cargo.toml

@@ -4,8 +4,8 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-vite_task = { workspace = true }
 vite_path = { workspace = true }
+vite_task = { workspace = true }
 
 [dev-dependencies]
 criterion = { workspace = true }

bench/Cargo.toml

@@ -9,6 +9,7 @@ allocator-api2 = { workspace = true, features = ["alloc"] }
 bincode = { workspace = true }
 bstr = { workspace = true, default-features = false }
 bumpalo = { workspace = true }
+const_format = { workspace = true, features = ["fmt"] }
 fspy_shared = { workspace = true }
 futures-util = { workspace = true }
 libc = { workspace = true }
@@ -18,6 +19,7 @@ slab = { workspace = true }
 tempfile = { workspace = true }
 tokio = { workspace = true, features = ["net", "process", "io-util", "sync"] }
 which = { workspace = true }
+xxhash-rust = { workspace = true }
 
 [target.'cfg(target_os = "linux")'.dependencies]
 arrayvec = { workspace = true }
@@ -39,10 +41,6 @@ passfd = { git = "https://github.com/polachok/passfd", features = ["async"] }
 [target.'cfg(target_os = "macos")'.dependencies]
 phf = { workspace = true }
 
-[target.'cfg(any(target_os = "macos", windows))'.dependencies]
-const_format = { workspace = true, features = ["fmt"] }
-xxhash-rust = { workspace = true }
-
 [target.'cfg(target_os = "windows")'.dependencies]
 fspy_detours_sys = { workspace = true }
 fspy_preload_windows = { workspace = true }

crates/fspy/Cargo.toml

@@ -23,6 +23,8 @@ async fn main() -> io::Result<()> {
 
     let TrackedChild { mut tokio_child, accesses_future } = command.spawn().await?;
 
+    let output = tokio_child.wait().await?;
+
     let accesses = accesses_future.await?;
 
     let mut path_count = 0usize;
@@ -47,7 +49,6 @@ async fn main() -> io::Result<()> {
     }
     csv_writer.flush().await?;
 
-    let output = tokio_child.wait().await?;
     eprintln!("\nfspy: {path_count} paths accessed. {output}");
     Ok(())
 }

crates/fspy/examples/cli.rs

@@ -26,6 +26,7 @@ macro_rules! fixture {
 pub use fixture;
 
 impl Fixture {
+    #[cfg(not(target_os = "linux"))]
     pub const fn new(name: &'static str, content: &'static [u8], hash: &'static str) -> Self {
         Self { name, content, hash }
     }

crates/fspy/src/fixture.rs

@@ -1,9 +1,7 @@
 #![cfg_attr(target_os = "windows", feature(windows_process_extensions_main_thread_handle))]
 #![feature(once_cell_try)]
 
-// Windows and macOS both need to persist the injected DLL/shared library somewhere in the filesystem.
-// Linux doesn't need this. Instead we use `memfd_create` to create an in-memory shared library.
-#[cfg(not(target_os = "linux"))]
+// Persist the injected DLL/shared library somewhere in the filesystem.
 mod fixture;
 
 #[cfg(unix)]
@@ -17,9 +15,7 @@ mod os_impl;
 mod arena;
 mod command;
 
-#[cfg(not(target_os = "linux"))]
-use std::{env::temp_dir, fs::create_dir};
-use std::{ffi::OsStr, io, sync::OnceLock};
+use std::{env::temp_dir, ffi::OsStr, fs::create_dir, io, sync::OnceLock};
 
 pub use command::Command;
 pub use fspy_shared::ipc::{AccessMode, PathAccess};
@@ -30,23 +26,19 @@ use tokio::process::Child;
 
 pub struct TrackedChild {
     pub tokio_child: Child,
-    pub accesses_future: BoxFuture<'static, io::Result<os_impl::PathAccessIterable>>,
+    /// This future lazily locks the IPC channel when it's polled.
+    /// Do not `await` it until the child process has exited.
+    pub accesses_future: BoxFuture<'static, io::Result<PathAccessIterable>>,
 }
 
 pub struct Spy(SpyInner);
 impl Spy {
-    #[cfg(not(target_os = "linux"))]
     pub fn new() -> io::Result<Self> {
         let tmp_dir = temp_dir().join("fspy");
         let _ = create_dir(&tmp_dir);
         Ok(Self(SpyInner::init_in(&tmp_dir)?))
     }
 
-    #[cfg(target_os = "linux")]
-    pub fn new() -> io::Result<Self> {
-        Ok(Self(SpyInner::init()?))
-    }
-
     pub fn global() -> io::Result<&'static Self> {
         static GLOBAL_SPY: OnceLock<Spy> = OnceLock::new();
         GLOBAL_SPY.get_or_try_init(Self::new)