refactor(installer): replace raw FFI with winreg crate for registry access

The zero-dependency pattern made sense for vite_trampoline (copied 5-10
times as shim files) but not for a single downloadable installer where
readability matters more. Switch from 225 lines of unsafe raw Win32 FFI
to ~80 lines of safe Rust using the winreg crate (~50-100 KB after LTO).

WM_SETTINGCHANGE broadcast still uses a single raw FFI call since
winreg doesn't wrap SendMessageTimeoutW.

Author: fengmk2

Cargo.lock

@@ -207,6 +207,7 @@ vite_workspace = { git = "https://github.com/voidzero-dev/vite-task.git", rev =
 walkdir = "2.5.0"
 wax = "0.6.0"
 which = "8.0.0"
+winreg = "0.56.0"
 xxhash-rust = "0.8.15"
 zip = "7.2"
 

Cargo.toml

@@ -22,5 +22,8 @@ vite_path = { workspace = true }
 vite_setup = { workspace = true }
 vite_shared = { workspace = true }
 
+[target.'cfg(windows)'.dependencies]
+winreg = { workspace = true }
+
 [lints]
 workspace = true

crates/vite_installer/Cargo.toml

@@ -5,192 +5,40 @@
 
 use std::io;
 
-/// Raw Win32 FFI declarations for registry and environment broadcast.
-///
-/// We declare these inline to avoid pulling in the `windows-sys` crate,
-/// following the same zero-dependency pattern as `vite_trampoline`.
-mod ffi {
-    #![allow(non_snake_case, clippy::upper_case_acronyms)]
-
-    pub type HKEY = isize;
-    pub type DWORD = u32;
-    pub type LONG = i32;
-    pub type LPCWSTR = *const u16;
-    pub type HWND = isize;
-    pub type WPARAM = usize;
-    pub type LPARAM = isize;
-    pub type UINT = u32;
+use winreg::{
+    RegKey,
+    enums::{HKEY_CURRENT_USER, KEY_READ, KEY_WRITE, REG_EXPAND_SZ},
+};
 
-    pub const HKEY_CURRENT_USER: HKEY = -2_147_483_647;
-    pub const KEY_READ: DWORD = 0x0002_0019;
-    pub const KEY_WRITE: DWORD = 0x0002_0006;
-    pub const REG_EXPAND_SZ: DWORD = 2;
-    pub const ERROR_SUCCESS: LONG = 0;
-    pub const ERROR_FILE_NOT_FOUND: LONG = 2;
-    pub const HWND_BROADCAST: HWND = 0xFFFF;
-    pub const WM_SETTINGCHANGE: UINT = 0x001A;
-    pub const SMTO_ABORTIFHUNG: UINT = 0x0002;
+/// Broadcast `WM_SETTINGCHANGE` so other processes pick up the PATH change.
+fn broadcast_settings_change() {
+    const HWND_BROADCAST: isize = 0xFFFF;
+    const WM_SETTINGCHANGE: u32 = 0x001A;
+    const SMTO_ABORTIFHUNG: u32 = 0x0002;
 
     unsafe extern "system" {
-        pub fn RegOpenKeyExW(
-            hKey: HKEY,
-            lpSubKey: LPCWSTR,
-            ulOptions: DWORD,
-            samDesired: DWORD,
-            phkResult: *mut HKEY,
-        ) -> LONG;
-
-        pub fn RegQueryValueExW(
-            hKey: HKEY,
-            lpValueName: LPCWSTR,
-            lpReserved: *mut DWORD,
-            lpType: *mut DWORD,
-            lpData: *mut u8,
-            lpcbData: *mut DWORD,
-        ) -> LONG;
-
-        pub fn RegSetValueExW(
-            hKey: HKEY,
-            lpValueName: LPCWSTR,
-            Reserved: DWORD,
-            dwType: DWORD,
-            lpData: *const u8,
-            cbData: DWORD,
-        ) -> LONG;
-
-        pub fn RegCloseKey(hKey: HKEY) -> LONG;
-
-        pub fn SendMessageTimeoutW(
-            hWnd: HWND,
-            Msg: UINT,
-            wParam: WPARAM,
-            lParam: LPARAM,
-            fuFlags: UINT,
-            uTimeout: UINT,
+        fn SendMessageTimeoutW(
+            hWnd: isize,
+            Msg: u32,
+            wParam: usize,
+            lParam: isize,
+            fuFlags: u32,
+            uTimeout: u32,
             lpdwResult: *mut usize,
         ) -> isize;
     }
-}
-
-/// Encode a Rust string as a null-terminated wide (UTF-16) string.
-fn to_wide(s: &str) -> Vec<u16> {
-    s.encode_utf16().chain(std::iter::once(0)).collect()
-}
-
-/// Read the current User PATH from the registry.
-fn read_user_path() -> io::Result<String> {
-    let sub_key = to_wide("Environment");
-    let value_name = to_wide("Path");
-
-    let mut hkey: ffi::HKEY = 0;
-    let result = unsafe {
-        ffi::RegOpenKeyExW(ffi::HKEY_CURRENT_USER, sub_key.as_ptr(), 0, ffi::KEY_READ, &mut hkey)
-    };
-
-    if result == ffi::ERROR_FILE_NOT_FOUND {
-        return Ok(String::new());
-    }
-    if result != ffi::ERROR_SUCCESS {
-        return Err(io::Error::from_raw_os_error(result));
-    }
-
-    // Query the size first
-    let mut data_type: ffi::DWORD = 0;
-    let mut data_size: ffi::DWORD = 0;
-    let result = unsafe {
-        ffi::RegQueryValueExW(
-            hkey,
-            value_name.as_ptr(),
-            std::ptr::null_mut(),
-            &mut data_type,
-            std::ptr::null_mut(),
-            &mut data_size,
-        )
-    };
-
-    if result == ffi::ERROR_FILE_NOT_FOUND {
-        unsafe { ffi::RegCloseKey(hkey) };
-        return Ok(String::new());
-    }
-    if result != ffi::ERROR_SUCCESS {
-        unsafe { ffi::RegCloseKey(hkey) };
-        return Err(io::Error::from_raw_os_error(result));
-    }
-
-    // Read the data
-    let mut buf = vec![0u8; data_size as usize];
-    let result = unsafe {
-        ffi::RegQueryValueExW(
-            hkey,
-            value_name.as_ptr(),
-            std::ptr::null_mut(),
-            &mut data_type,
-            buf.as_mut_ptr(),
-            &mut data_size,
-        )
-    };
-
-    unsafe { ffi::RegCloseKey(hkey) };
 
-    if result != ffi::ERROR_SUCCESS {
-        return Err(io::Error::from_raw_os_error(result));
-    }
-
-    // Convert UTF-16 to String (strip trailing null)
-    let wide: Vec<u16> = buf.chunks_exact(2).map(|c| u16::from_le_bytes([c[0], c[1]])).collect();
-    let s = String::from_utf16_lossy(&wide);
-    Ok(s.trim_end_matches('\0').to_string())
-}
-
-/// Write the User PATH to the registry.
-fn write_user_path(path: &str) -> io::Result<()> {
-    let sub_key = to_wide("Environment");
-    let value_name = to_wide("Path");
-    let wide_path = to_wide(path);
-
-    let mut hkey: ffi::HKEY = 0;
-    let result = unsafe {
-        ffi::RegOpenKeyExW(ffi::HKEY_CURRENT_USER, sub_key.as_ptr(), 0, ffi::KEY_WRITE, &mut hkey)
-    };
-
-    if result != ffi::ERROR_SUCCESS {
-        return Err(io::Error::from_raw_os_error(result));
-    }
-
-    let byte_len = (wide_path.len() * 2) as ffi::DWORD;
-    let result = unsafe {
-        ffi::RegSetValueExW(
-            hkey,
-            value_name.as_ptr(),
-            0,
-            ffi::REG_EXPAND_SZ,
-            wide_path.as_ptr().cast::<u8>(),
-            byte_len,
-        )
-    };
-
-    unsafe { ffi::RegCloseKey(hkey) };
-
-    if result != ffi::ERROR_SUCCESS {
-        return Err(io::Error::from_raw_os_error(result));
-    }
-
-    Ok(())
-}
-
-/// Broadcast `WM_SETTINGCHANGE` so other processes pick up the PATH change.
-fn broadcast_settings_change() {
-    let env_wide = to_wide("Environment");
-    let mut _result: usize = 0;
+    let env_wide: Vec<u16> = "Environment".encode_utf16().chain(std::iter::once(0)).collect();
+    let mut result: usize = 0;
     unsafe {
-        ffi::SendMessageTimeoutW(
-            ffi::HWND_BROADCAST,
-            ffi::WM_SETTINGCHANGE,
+        SendMessageTimeoutW(
+            HWND_BROADCAST,
+            WM_SETTINGCHANGE,
             0,
-            env_wide.as_ptr() as ffi::LPARAM,
-            ffi::SMTO_ABORTIFHUNG,
+            env_wide.as_ptr() as isize,
+            SMTO_ABORTIFHUNG,
             5000,
-            &mut _result,
+            &mut result,
         );
     }
 }
@@ -201,25 +49,36 @@ fn broadcast_settings_change() {
 /// (case-insensitive, with/without trailing backslash), and prepends if not.
 /// Broadcasts `WM_SETTINGCHANGE` so new terminal sessions see the change.
 pub fn add_to_user_path(bin_dir: &str) -> io::Result<()> {
-    let current = read_user_path()?;
+    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
+    let env = hkcu.open_subkey_with_flags("Environment", KEY_READ | KEY_WRITE)?;
+
+    let current: String = env.get_value("Path").unwrap_or_default();
     let bin_dir_normalized = bin_dir.trim_end_matches('\\');
 
-    // Check if already in PATH (case-insensitive, handle trailing backslash)
-    let already_present = current.split(';').any(|entry| {
-        let entry_normalized = entry.trim_end_matches('\\');
-        entry_normalized.eq_ignore_ascii_case(bin_dir_normalized)
-    });
+    let already_present = current
+        .split(';')
+        .any(|entry| entry.trim_end_matches('\\').eq_ignore_ascii_case(bin_dir_normalized));
 
     if already_present {
         return Ok(());
     }
 
-    // Prepend to PATH
     let new_path =
         if current.is_empty() { bin_dir.to_string() } else { format!("{bin_dir};{current}") };
 
-    write_user_path(&new_path)?;
-    broadcast_settings_change();
+    // Write as REG_EXPAND_SZ to support %VARIABLE% expansion in PATH entries
+    env.set_raw_value(
+        "Path",
+        &winreg::RegValue {
+            vtype: REG_EXPAND_SZ,
+            bytes: new_path
+                .encode_utf16()
+                .chain(std::iter::once(0))
+                .flat_map(|c| c.to_le_bytes())
+                .collect(),
+        },
+    )?;
 
+    broadcast_settings_change();
     Ok(())
 }

crates/vite_installer/src/windows_path.rs

@@ -303,12 +303,16 @@ On failure before the **Activate** phase, the version directory is cleaned up an
 
 ### PATH Modification via Registry
 
-Same approach as rustup and `install.ps1`, using raw Win32 FFI (no external crate) following the same zero-dependency pattern as `vite_trampoline`:
+Same approach as rustup and `install.ps1`, using the `winreg` crate for registry access:
 
-1. Read current `HKCU\Environment\Path` via `RegQueryValueExW`
-2. Check if bin dir is already present (case-insensitive, handles trailing backslash)
-3. Prepend `%VP_HOME%\bin` if not present, write back via `RegSetValueExW` as `REG_EXPAND_SZ`
-4. Broadcast `WM_SETTINGCHANGE` via `SendMessageTimeoutW` so other processes pick up the change
+```rust
+let hkcu = RegKey::predef(HKEY_CURRENT_USER);
+let env = hkcu.open_subkey_with_flags("Environment", KEY_READ | KEY_WRITE)?;
+let current: String = env.get_value("Path").unwrap_or_default();
+// ... check if already present (case-insensitive, handles trailing backslash)
+// ... prepend bin_dir, write back as REG_EXPAND_SZ
+// ... broadcast WM_SETTINGCHANGE via SendMessageTimeoutW (raw FFI, single call)
+```
 
 See `crates/vite_installer/src/windows_path.rs` for the full implementation.
 
@@ -461,10 +465,9 @@ Key dependencies and their approximate contribution:
 | `indicatif`                       | Progress bars          | ~100 KB     |
 | `sha2`                            | Integrity verification | ~50 KB      |
 | `serde_json`                      | Registry JSON parsing  | ~200 KB     |
+| `winreg` + `windows-sys`          | Windows registry       | ~50-100 KB  |
 | Rust std + overhead               |                        | ~500 KB     |
 
-Note: Windows registry access uses raw FFI (~0 KB overhead) instead of the `winreg` crate, following the same zero-dependency pattern as `vite_trampoline`.
-
 Use `opt-level = "z"` (optimize for size) in package profile override, matching the trampoline approach.
 
 ## Alternatives Considered
@@ -490,12 +493,12 @@ Like rustup, make `vp.exe` detect when called as `vp-setup.exe` and switch to in
 
 Embed the PowerShell script in a self-extracting exe. Fragile, still requires PowerShell runtime.
 
-### 4. Use `winreg` Crate vs Raw FFI for PATH (Decision: Raw FFI)
+### 4. Use `winreg` Crate vs Raw FFI for PATH (Decision: `winreg`)
 
-- `winreg` crate: Higher-level API, adds ~50 KB dependency
-- Raw Win32 FFI: Zero external dependencies, matches `vite_trampoline` pattern, slightly more code
+- `winreg` crate: Higher-level safe API, ~50-100 KB after LTO, significantly less code (~80 lines vs ~225 lines)
+- Raw Win32 FFI: Zero dependencies but 225 lines of unsafe code with manual UTF-16 encoding and registry choreography
 - PowerShell subprocess: Proven in `install.ps1` but adds process spawn overhead and PowerShell dependency
-- Decision: Use raw FFI for direct registry access — keeps the installer dependency-free for Win32 operations, consistent with the trampoline's approach
+- Decision: Use `winreg` for registry access — the zero-dependency pattern makes sense for `vite_trampoline` (copied 5-10 times as shims) but not for a single downloadable installer where readability matters more. `WM_SETTINGCHANGE` broadcast still uses a single raw FFI call since `winreg` doesn't wrap it.
 
 ## Implementation Phases