feat(ipc): runner ↔ tool IPC channel with disableCache

Add the runner-aware IPC protocol, embedded Node client addon, execution-time server lifecycle, and disableCache handling.

The protocol ships with the single disableCache verb; getEnv/getEnvs land with env tracking (#430) and ignoreInput/ignoreOutput with auto output tracking (#431), each alongside the runner logic that consumes them.

Co-Authored-By: OpenAI <codex@openai.com>

Author: wan9chi

Cargo.lock

@@ -37,7 +37,7 @@ use wincode::{
 /// **Not portable across platforms.** The binary representation is platform-specific.
 /// Deserializing a `NativeStr` serialized on a different platform leads to unspecified
 /// behavior (garbage data), but is not unsafe. Designed for same-platform IPC only.
-#[derive(TransparentWrapper, PartialEq, Eq, Hash)]
+#[derive(TransparentWrapper, PartialEq, Eq)]
 #[repr(transparent)]
 pub struct NativeStr {
     // On unix, this is the raw bytes of the OsStr.

crates/native_str/src/lib.rs

@@ -7,9 +7,6 @@ publish = false
 rust-version.workspace = true
 
 [dependencies]
-native_str = { workspace = true }
-rustc-hash = { workspace = true }
-vite_path = { workspace = true }
 vite_task_ipc_shared = { workspace = true }
 wincode = { workspace = true, features = ["derive"] }
 

crates/vite_task_bin/tests/e2e_snapshots/fixtures/vite_dev_disable_cache/dev.mjs

@@ -1,14 +1,10 @@
 use std::{
     cell::RefCell,
     ffi::OsStr,
-    io::{self, Read, Write},
-    sync::Arc,
+    io::{self, Write},
 };
 
-use native_str::NativeStr;
-use rustc_hash::FxHashMap;
-use vite_path::{self, AbsolutePath};
-use vite_task_ipc_shared::{GetEnvResponse, GetEnvsResponse, IPC_ENV_NAME, Request};
+use vite_task_ipc_shared::{IPC_ENV_NAME, Request};
 
 #[cfg(unix)]
 type Stream = std::os::unix::net::UnixStream;
@@ -17,7 +13,6 @@ type Stream = std::fs::File;
 
 pub struct Client {
     stream: RefCell<Stream>,
-    scratch: RefCell<Vec<u8>>,
 }
 
 impl Client {
@@ -43,104 +38,22 @@ impl Client {
     }
 
     const fn from_stream(stream: Stream) -> Self {
-        Self { stream: RefCell::new(stream), scratch: RefCell::new(Vec::new()) }
+        Self { stream: RefCell::new(stream) }
     }
 
-    /// `path` can be a file or a directory; for a directory, all files inside
-    /// it are ignored. Relative paths are resolved against the current working
-    /// directory before being sent to the runner.
-    ///
     /// Fire-and-forget: the call returns once the request is flushed to the
     /// kernel pipe buffer; the runner processes it during its drain phase
     /// after this process exits. See the `Request` type in the IPC protocol
     /// crate for why this is safe.
     ///
     /// # Errors
     ///
-    /// Returns an error if the request fails to send, or (for a relative
-    /// `path`) if the current working directory cannot be read.
-    pub fn ignore_input(&self, path: &OsStr) -> io::Result<()> {
-        let ns = resolve_path(path)?;
-        self.send(&Request::IgnoreInput(&ns))
-    }
-
-    /// `path` can be a file or a directory; for a directory, all files inside
-    /// it are ignored. Relative paths are resolved against the current working
-    /// directory before being sent to the runner.
-    ///
-    /// Fire-and-forget — see [`Self::ignore_input`].
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the request fails to send, or (for a relative
-    /// `path`) if the current working directory cannot be read.
-    pub fn ignore_output(&self, path: &OsStr) -> io::Result<()> {
-        let ns = resolve_path(path)?;
-        self.send(&Request::IgnoreOutput(&ns))
-    }
-
-    /// Fire-and-forget — see [`Self::ignore_input`].
-    ///
-    /// # Errors
-    ///
     /// Returns an error if the request fails to send.
     pub fn disable_cache(&self) -> io::Result<()> {
         self.send(&Request::DisableCache)
     }
 
-    /// Requests an env value from the runner. Returns `None` if the runner reports
-    /// the env is not available.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the request or response fails.
-    pub fn get_env(&self, name: &OsStr, tracked: bool) -> io::Result<Option<Arc<OsStr>>> {
-        let name = Box::<NativeStr>::from(name);
-
-        self.send(&Request::GetEnv { name: &name, tracked })?;
-        self.recv_with(|bytes| {
-            let response: GetEnvResponse<'_> = wincode::deserialize_exact(bytes)
-                .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))?;
-            Ok(response
-                .env_value
-                .map(|env_value| Arc::<OsStr>::from(env_value.to_cow_os_str().as_ref())))
-        })
-    }
-
-    /// Requests every env whose name matches `pattern` from the runner. The
-    /// returned map is keyed by env name with its value.
-    ///
-    /// Unlike [`Self::get_env`], this always round-trips to the server — the
-    /// client has no way to know in advance which names the pattern matches.
-    /// Env names that aren't valid UTF-8 are silently dropped at the server.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the request or response fails, or if the server
-    /// rejected the pattern as an invalid glob.
-    pub fn get_envs(
-        &self,
-        pattern: &str,
-        tracked: bool,
-    ) -> io::Result<FxHashMap<Arc<OsStr>, Arc<OsStr>>> {
-        self.send(&Request::GetEnvs { pattern, tracked })?;
-        self.recv_with(|bytes| {
-            let response: GetEnvsResponse<'_> = wincode::deserialize_exact(bytes)
-                .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))?;
-            Ok(response
-                .entries
-                .iter()
-                .map(|(name, value)| {
-                    (
-                        Arc::<OsStr>::from(name.to_cow_os_str().as_ref()),
-                        Arc::<OsStr>::from(value.to_cow_os_str().as_ref()),
-                    )
-                })
-                .collect())
-        })
-    }
-
-    fn send(&self, request: &Request<'_>) -> io::Result<()> {
+    fn send(&self, request: &Request) -> io::Result<()> {
         let bytes = wincode::serialize(request)
             .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))?;
         let len = u32::try_from(bytes.len())
@@ -151,18 +64,6 @@ impl Client {
         stream.flush()?;
         Ok(())
     }
-
-    fn recv_with<T>(&self, extract: impl FnOnce(&[u8]) -> io::Result<T>) -> io::Result<T> {
-        let mut stream = self.stream.borrow_mut();
-        let mut scratch = self.scratch.borrow_mut();
-        let mut len_bytes = [0u8; 4];
-        stream.read_exact(&mut len_bytes)?;
-        let len = u32::from_le_bytes(len_bytes) as usize;
-        scratch.clear();
-        scratch.resize(len, 0);
-        stream.read_exact(&mut scratch)?;
-        extract(&scratch)
-    }
 }
 
 #[cfg(unix)]
@@ -216,49 +117,3 @@ fn connect(name: &OsStr) -> io::Result<Stream> {
         }
     }
 }
-
-#[expect(
-    clippy::disallowed_types,
-    reason = "std::path::PathBuf is needed to round-trip through std::fs::canonicalize on Windows below"
-)]
-fn resolve_path(path: &OsStr) -> io::Result<Box<NativeStr>> {
-    let absolute: std::path::PathBuf = if let Some(abs) = AbsolutePath::new(path) {
-        abs.as_path().to_path_buf()
-    } else {
-        let mut buf = vite_path::current_dir()?;
-        buf.push(path);
-        buf.as_path().to_path_buf()
-    };
-
-    // On Windows, canonicalize so the path uses the exact on-disk casing
-    // and resolves substitute drives / junctions the same way `fspy`'s
-    // `GetFinalPathNameByHandleW`-reported paths do. Without this, an
-    // `ignoreInput("cache_like")` whose `current_dir()` prefix differs in
-    // case or symlink shape from the fspy-reported reads won't filter
-    // them out, and the runner sees a read/write overlap. Strip the
-    // `\\?\` namespace prefix because `fspy_shared::NativePath::
-    // strip_path_prefix` does the same on the runner side; if the
-    // canonical form starts with `\\?\UNC\`, fall back to the
-    // non-canonical form so we don't accidentally rewrite a UNC path
-    // (where dropping `\\?\` would change meaning).
-    #[cfg(windows)]
-    let absolute = std::fs::canonicalize(&absolute).map_or(absolute, |canonical| {
-        use std::{
-            ffi::OsString,
-            os::windows::ffi::{OsStrExt, OsStringExt},
-        };
-        let wide: Vec<u16> = canonical.as_os_str().encode_wide().collect();
-        let unc_prefix: Vec<u16> = r"\\?\UNC\".encode_utf16().collect();
-        let nt_prefix: Vec<u16> = r"\\?\".encode_utf16().collect();
-        if wide.starts_with(&unc_prefix) {
-            // UNC path — keep canonical form (still has \\?\UNC\ for fspy parity).
-            canonical
-        } else if let Some(rest) = wide.strip_prefix(nt_prefix.as_slice()) {
-            std::path::PathBuf::from(OsString::from_wide(rest))
-        } else {
-            canonical
-        }
-    });
-
-    Ok(Box::<NativeStr>::from(absolute.as_os_str()))
-}