Merge remote-tracking branch 'origin/main' into feat/publish-support

Author: ubugeeei

CLAUDE.md

@@ -106,6 +106,12 @@ All user-facing output must go through shared output modules instead of raw prin
 - Run `cargo test` to execute all tests
 - You never need to run `pnpm install` in the test fixtures dir, vite-plus should able to load and parse the workspace without `pnpm install`.
 
+### Environment Variables in Tests
+
+- **Prefer `EnvConfig::test_scope()`**: For tests needing custom config values (VP_HOME, npm registry, etc.), use thread-local `EnvConfig::test_scope()` or `EnvConfig::test_guard()` from `vite_shared` — no `unsafe`, no `#[serial]`, full parallelism
+- **`#[serial]` required for `std::env::set_var`/`remove_var`**: Any test that directly modifies process env vars (PATH, VP_SHIM_TOOL, etc.) MUST have `#[serial_test::serial]` to prevent concurrent access races
+- **Clean up ALL related env vars**: When clearing env vars before a test, clear ALL vars that the function under test reads — not just the one being tested
+
 ## Build
 
 - Run `pnpm bootstrap-cli` from the project root to build all packages and install the global CLI

Cargo.lock

@@ -57,8 +57,18 @@ _clap_complete_vp() {
     fi
     _clap_trim_completions
 }
+
+_clap_complete_vpr() {
+    local COMP_WORDS=("vp" "run" "${COMP_WORDS[@]:1}")
+    local COMP_CWORD=$((COMP_CWORD + 1))
+    local COMP_LINE="vp run ${COMP_LINE#vpr}"
+    _clap_complete_vp
+}
+
 if [[ "${BASH_VERSINFO[0]}" -eq 4 && "${BASH_VERSINFO[1]}" -ge 4 || "${BASH_VERSINFO[0]}" -gt 4 ]]; then
     complete -o nospace -o bashdefault -o nosort -F _clap_complete_vp vp
+    complete -o nospace -o bashdefault -o nosort -F _clap_complete_vpr vpr
 else
     complete -o nospace -o bashdefault -F _clap_complete_vp vp
+    complete -o nospace -o bashdefault -F _clap_complete_vpr vpr
 fi

crates/vite_global_cli/completion-register.bash

@@ -1625,11 +1625,7 @@ fn should_force_global_delegate(command: &str, args: &[String]) -> bool {
 /// Delegates to the local vite-plus CLI to run `vp run` without arguments,
 /// which returns a list of available tasks in the format "task_name: description".
 fn run_tasks_completions(current: &OsStr) -> Vec<clap_complete::CompletionCandidate> {
-    let Some(cwd) = std::env::current_dir()
-        .ok()
-        .and_then(AbsolutePathBuf::new)
-        .filter(|p| commands::has_vite_plus_dependency(p))
-    else {
+    let Ok(cwd) = vite_path::current_dir() else {
         return vec![];
     };
 

crates/vite_global_cli/src/cli.rs

@@ -449,6 +449,13 @@ if [ -n "$BASH_VERSION" ] && type complete >/dev/null 2>&1; then
     eval "$(VP_COMPLETE=bash command vp)"
 elif [ -n "$ZSH_VERSION" ] && type compdef >/dev/null 2>&1; then
     eval "$(VP_COMPLETE=zsh command vp)"
+    _vpr_complete() {
+        local -a orig=("${words[@]}")
+        words=("vp" "run" "${orig[@]:1}")
+        CURRENT=$((CURRENT + 1))
+        ${=_comps[vp]}
+    }
+    compdef _vpr_complete vpr
 fi
 "#
     .replace("__VP_BIN__", &bin_path_ref);
@@ -478,6 +485,13 @@ end
 
 # Dynamic shell completion for fish
 VP_COMPLETE=fish command vp | source
+
+function __vpr_complete
+    set -l tokens (commandline --current-process --tokenize --cut-at-cursor)
+    set -l current (commandline --current-token)
+    VP_COMPLETE=fish command vp -- vp run $tokens[2..] $current
+end
+complete -c vpr --keep-order --exclusive --arguments "(__vpr_complete)"
 "#
     .replace("__VP_BIN__", &bin_path_ref);
     let env_fish_file = vite_plus_home.join("env.fish");
@@ -518,6 +532,27 @@ function vp {
 $env:VP_COMPLETE = "powershell"
 & (Join-Path $__vp_bin "vp.exe") | Out-String | Invoke-Expression
 Remove-Item Env:\VP_COMPLETE -ErrorAction SilentlyContinue
+
+$__vpr_comp = {
+    param($wordToComplete, $commandAst, $cursorPosition)
+    $prev = $env:VP_COMPLETE
+    $env:VP_COMPLETE = "powershell"
+    $commandLine = $commandAst.Extent.Text
+    $args = $commandLine.Substring(0, [math]::Min($cursorPosition, $commandLine.Length))
+    $args = $args -replace '^(vpr\.exe|vpr)\b', 'vp run'
+    if ($wordToComplete -eq "") { $args += " ''" }
+    $results = Invoke-Expression @"
+& (Join-Path $__vp_bin 'vp.exe') -- $args
+"@;
+    if ($prev) { $env:VP_COMPLETE = $prev } else { Remove-Item Env:\VP_COMPLETE }
+    $results | ForEach-Object {
+        $split = $_.Split("`t")
+        $cmd = $split[0];
+        if ($split.Length -eq 2) { $help = $split[1] } else { $help = $split[0] }
+        [System.Management.Automation.CompletionResult]::new($cmd, $cmd, 'ParameterValue', $help)
+    }
+}
+Register-ArgumentCompleter -Native -CommandName vpr -ScriptBlock $__vpr_comp
 "#;
 
     // For PowerShell, use the actual absolute path (not $HOME-relative)
@@ -866,7 +901,6 @@ mod tests {
         let fish_content = tokio::fs::read_to_string(home.join("env.fish")).await.unwrap();
         let ps1_content = tokio::fs::read_to_string(home.join("env.ps1")).await.unwrap();
 
-        // Verify completion env is set
         assert!(
             env_content.contains("VP_COMPLETE=bash") && env_content.contains("VP_COMPLETE=zsh"),
             "env file should contain completion for bash and zsh"
@@ -879,5 +913,15 @@ mod tests {
             ps1_content.contains("VP_COMPLETE = \"powershell\""),
             "env.ps1 file should contain completion for PowerShell"
         );
+
+        assert!(
+            env_content.contains("compdef _vpr_complete vpr"),
+            "env should have vpr completion for zsh"
+        );
+        assert!(fish_content.contains("complete -c vpr"), "env.fish should have vpr completion");
+        assert!(
+            ps1_content.contains("Register-ArgumentCompleter -Native -CommandName vpr"),
+            "env.ps1 should have vpr completion"
+        );
     }
 }

crates/vite_global_cli/src/commands/env/setup.rs

@@ -217,10 +217,18 @@ mod tests {
         assert!(!is_potential_package_binary("another-fake-tool"));
     }
 
+    /// Clear both shim env vars to isolate tests.
+    /// SAFETY: caller must be `#[serial]` since this mutates process-global state.
+    unsafe fn clear_shim_env_vars() {
+        unsafe {
+            std::env::remove_var(SHIM_TOOL_ENV_VAR);
+            std::env::remove_var(LEGACY_SHIM_TOOL_ENV_VAR);
+        }
+    }
+
     #[test]
     #[serial]
     fn test_detect_shim_tool_from_env_var() {
-        // SAFETY: We're in a test at startup, no other threads
         unsafe {
             std::env::set_var(SHIM_TOOL_ENV_VAR, "node");
             std::env::remove_var(LEGACY_SHIM_TOOL_ENV_VAR);
@@ -236,7 +244,6 @@ mod tests {
     fn test_detect_shim_tool_from_legacy_env_var() {
         // When only VITE_PLUS_SHIM_TOOL is set (older trampoline), it should
         // fall back to reading the legacy env var.
-        // SAFETY: We're in a test at startup, no other threads
         unsafe {
             std::env::remove_var(SHIM_TOOL_ENV_VAR);
             std::env::set_var(LEGACY_SHIM_TOOL_ENV_VAR, "npm");
@@ -247,43 +254,28 @@ mod tests {
         assert!(std::env::var(LEGACY_SHIM_TOOL_ENV_VAR).is_err());
     }
 
+    /// Tests that argv0-based tool detection works for a given tool name,
+    /// including full path and .exe extension variants.
+    fn assert_detect_shim_tool_from_argv0(tool: &str) {
+        unsafe { clear_shim_env_vars() };
+
+        assert_eq!(detect_shim_tool(tool), Some(tool.to_string()));
+        assert_eq!(
+            detect_shim_tool(&vite_str::format!("/home/user/.vite-plus/bin/{tool}")),
+            Some(tool.to_string()),
+        );
+        assert_eq!(detect_shim_tool(&vite_str::format!("{tool}.exe")), Some(tool.to_string()),);
+    }
+
     #[test]
     #[serial]
     fn test_detect_shim_tool_vpx() {
-        // vpx should be detected via the argv0 check, before the env var check
-        // and before is_shim_tool (which would incorrectly match it as a package binary)
-        // SAFETY: We're in a test
-        unsafe {
-            std::env::remove_var(SHIM_TOOL_ENV_VAR);
-        }
-        let result = detect_shim_tool("vpx");
-        assert_eq!(result, Some("vpx".to_string()));
-
-        // Also works with full path
-        let result = detect_shim_tool("/home/user/.vite-plus/bin/vpx");
-        assert_eq!(result, Some("vpx".to_string()));
-
-        // Also works with .exe extension (Windows)
-        let result = detect_shim_tool("vpx.exe");
-        assert_eq!(result, Some("vpx".to_string()));
+        assert_detect_shim_tool_from_argv0("vpx");
     }
 
     #[test]
+    #[serial]
     fn test_detect_shim_tool_vpr() {
-        // vpr should be detected via the argv0 check, same pattern as vpx
-        // SAFETY: We're in a test
-        unsafe {
-            std::env::remove_var(SHIM_TOOL_ENV_VAR);
-        }
-        let result = detect_shim_tool("vpr");
-        assert_eq!(result, Some("vpr".to_string()));
-
-        // Also works with full path
-        let result = detect_shim_tool("/home/user/.vite-plus/bin/vpr");
-        assert_eq!(result, Some("vpr".to_string()));
-
-        // Also works with .exe extension (Windows)
-        let result = detect_shim_tool("vpr.exe");
-        assert_eq!(result, Some("vpr".to_string()));
+        assert_detect_shim_tool_from_argv0("vpr");
     }
 }

crates/vite_global_cli/src/shim/mod.rs

@@ -23,5 +23,8 @@ which = { workspace = true }
 [target.'cfg(not(target_os = "windows"))'.dependencies]
 rustls = { workspace = true }
 
+[dev-dependencies]
+serial_test = { workspace = true }
+
 [lints]
 workspace = true

crates/vite_shared/Cargo.toml

@@ -64,6 +64,7 @@ mod tests {
     }
 
     #[test]
+    #[serial_test::serial]
     fn test_get_vite_plus_without_home() {
         use std::path::PathBuf;
 

crates/vite_shared/src/home.rs

@@ -142,7 +142,7 @@ mod tests {
     }
 
     #[test]
-    #[ignore]
+    #[serial_test::serial]
     fn test_format_path_prepended_always_prepends() {
         // Even if the directory exists somewhere in PATH, it should be prepended
         let test_dir = "/test/node/bin";

crates/vite_shared/src/path_env.rs

@@ -38,7 +38,7 @@ import {
   ModuleKind,
 } from 'typescript';
 
-import { generateLicenseFile } from '../../scripts/generate-license.ts';
+import { generateLicenseFile } from '../../scripts/generate-license.js';
 import corePkg from '../core/package.json' with { type: 'json' };
 import testPkg from '../test/package.json' with { type: 'json' };
 
@@ -115,7 +115,7 @@ async function buildNapiBinding() {
   });
 
   const outputs = await task;
-  const viteConfig = await import('../../vite.config');
+  const viteConfig = await import('../../vite.config.js');
   for (const output of outputs) {
     if (output.kind !== 'node') {
       const { code, errors } = await format(output.path, await readFile(output.path, 'utf8'), {