fix: respect packageManager in pm shims

Author: fengmk2

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

@@ -6,6 +6,10 @@ use std::process::ExitStatus;
 
 use owo_colors::OwoColorize;
 use serde::Serialize;
+use vite_install::package_manager::{
+    package_manager_bin_path, package_manager_install_dir,
+    resolve_package_manager_from_package_json,
+};
 use vite_path::AbsolutePathBuf;
 
 use super::config::resolve_version;
@@ -20,6 +24,8 @@ struct CurrentEnvInfo {
     project_root: Option<String>,
     node_path: String,
     tool_paths: ToolPaths,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    package_manager: Option<PackageManagerInfo>,
 }
 
 #[derive(Serialize)]
@@ -29,6 +35,16 @@ struct ToolPaths {
     npx: String,
 }
 
+#[derive(Clone, Serialize)]
+struct PackageManagerInfo {
+    name: String,
+    version: String,
+    source: String,
+    source_path: String,
+    project_root: String,
+    bin_path: String,
+}
+
 fn accent(text: &str) -> String {
     if help::should_style_help() { text.bright_blue().to_string() } else { text.to_string() }
 }
@@ -45,6 +61,7 @@ fn print_rows(title: &str, rows: &[(&str, String)]) {
 /// Execute the current command.
 pub async fn execute(cwd: AbsolutePathBuf, json: bool) -> Result<ExitStatus, Error> {
     let resolution = resolve_version(&cwd).await?;
+    let package_manager = resolve_package_manager_info(&cwd);
 
     // Get the home directory for this version
     let home_dir =
@@ -77,6 +94,7 @@ pub async fn execute(cwd: AbsolutePathBuf, json: bool) -> Result<ExitStatus, Err
                 npm: npm_path.as_path().display().to_string(),
                 npx: npx_path.as_path().display().to_string(),
             },
+            package_manager: package_manager.clone(),
         };
 
         let json_str = serde_json::to_string_pretty(&info)?;
@@ -101,7 +119,37 @@ pub async fn execute(cwd: AbsolutePathBuf, json: bool) -> Result<ExitStatus, Err
                 ("npx", npx_path.as_path().display().to_string()),
             ],
         );
+        if let Some(package_manager) = package_manager {
+            println!();
+            print_rows(
+                "Package Manager",
+                &[
+                    ("Name", package_manager.name),
+                    ("Version", package_manager.version),
+                    ("Source", package_manager.source),
+                    ("Source Path", package_manager.source_path),
+                    ("Project Root", package_manager.project_root),
+                    ("Bin Path", package_manager.bin_path),
+                ],
+            );
+        }
     }
 
     Ok(ExitStatus::default())
 }
+
+fn resolve_package_manager_info(cwd: &AbsolutePathBuf) -> Option<PackageManagerInfo> {
+    let resolution = resolve_package_manager_from_package_json(cwd).ok()??;
+    let install_dir =
+        package_manager_install_dir(resolution.package_manager_type, &resolution.version)?;
+    let name = resolution.package_manager_type.to_string();
+    let bin_path = package_manager_bin_path(&install_dir, &name);
+    Some(PackageManagerInfo {
+        name,
+        version: resolution.version.to_string(),
+        source: resolution.source.to_string(),
+        source_path: resolution.source_path.as_path().display().to_string(),
+        project_root: resolution.project_root.as_path().display().to_string(),
+        bin_path: bin_path.as_path().display().to_string(),
+    })
+}

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

@@ -10,6 +10,10 @@ use std::process::ExitStatus;
 
 use chrono::Local;
 use owo_colors::OwoColorize;
+use vite_install::package_manager::{
+    PackageManagerType, package_manager_bin_path, package_manager_install_dir,
+    resolve_package_manager_from_package_json,
+};
 use vite_path::{AbsolutePath, AbsolutePathBuf};
 use vite_shared::output;
 
@@ -27,6 +31,10 @@ const LABEL_WIDTH: usize = 10;
 
 /// Execute the which command.
 pub async fn execute(cwd: AbsolutePathBuf, tool: &str) -> Result<ExitStatus, Error> {
+    if let Some(status) = execute_package_manager_tool(&cwd, tool)? {
+        return Ok(status);
+    }
+
     // Check if this is a core tool
     if CORE_TOOLS.contains(&tool) {
         return execute_core_tool(cwd, tool).await;
@@ -44,6 +52,53 @@ pub async fn execute(cwd: AbsolutePathBuf, tool: &str) -> Result<ExitStatus, Err
     Ok(exit_status(1))
 }
 
+fn execute_package_manager_tool(
+    cwd: &AbsolutePath,
+    tool: &str,
+) -> Result<Option<ExitStatus>, Error> {
+    let Some(expected_type) = package_manager_type_for_tool(tool) else {
+        return Ok(None);
+    };
+    let Some(resolution) = resolve_package_manager_from_package_json(cwd)? else {
+        return Ok(None);
+    };
+    if resolution.package_manager_type != expected_type {
+        return Ok(None);
+    }
+
+    let Some(install_dir) =
+        package_manager_install_dir(resolution.package_manager_type, &resolution.version)
+    else {
+        return Ok(None);
+    };
+    let name = resolution.package_manager_type.to_string();
+    let tool_path = package_manager_bin_path(&install_dir, &name);
+
+    println!("{}", tool_path.as_path().display());
+    println!(
+        "  {:<LABEL_WIDTH$}  {}",
+        "Package:".dimmed(),
+        format!("{}@{}", name, resolution.version).bright_blue()
+    );
+    println!(
+        "  {:<LABEL_WIDTH$}  {}",
+        "Source:".dimmed(),
+        resolution.source_path.as_path().display().to_string().dimmed()
+    );
+
+    Ok(Some(ExitStatus::default()))
+}
+
+fn package_manager_type_for_tool(tool: &str) -> Option<PackageManagerType> {
+    match tool {
+        "npm" => Some(PackageManagerType::Npm),
+        "pnpm" => Some(PackageManagerType::Pnpm),
+        "yarn" => Some(PackageManagerType::Yarn),
+        "bun" => Some(PackageManagerType::Bun),
+        _ => None,
+    }
+}
+
 /// Execute which for a core tool (node, npm, npx).
 async fn execute_core_tool(cwd: AbsolutePathBuf, tool: &str) -> Result<ExitStatus, Error> {
     // Resolve version for current directory

crates/vite_global_cli/src/shim/dispatch.rs

@@ -5,18 +5,25 @@
 //! 2. Node.js installation (if needed)
 //! 3. Tool execution (core tools and package binaries)
 
+use vite_install::package_manager::{
+    PackageManagerType, download_package_manager, package_manager_bin_path,
+    resolve_package_manager_from_package_json,
+};
 use vite_path::{AbsolutePath, AbsolutePathBuf, current_dir};
 use vite_shared::{PrependOptions, env_vars, output, prepend_to_path_env};
 
 use super::{
     cache::{self, ResolveCache, ResolveCacheEntry},
     exec, is_core_shim_tool,
 };
-use crate::commands::env::{
-    bin_config::{BinConfig, BinSource},
-    config::{self, ShimMode},
-    global_install::CORE_SHIMS,
-    package_metadata::PackageMetadata,
+use crate::{
+    commands::env::{
+        bin_config::{BinConfig, BinSource},
+        config::{self, ShimMode},
+        global_install::CORE_SHIMS,
+        package_metadata::PackageMetadata,
+    },
+    error::Error,
 };
 
 /// Environment variable used to prevent infinite recursion in shim dispatch.
@@ -33,6 +40,25 @@ fn is_package_manager_tool(tool: &str) -> bool {
     PACKAGE_MANAGER_TOOLS.contains(&tool)
 }
 
+fn package_manager_type_for_tool(tool: &str) -> Option<PackageManagerType> {
+    match tool {
+        "npm" => Some(PackageManagerType::Npm),
+        "pnpm" => Some(PackageManagerType::Pnpm),
+        "yarn" => Some(PackageManagerType::Yarn),
+        "bun" => Some(PackageManagerType::Bun),
+        _ => None,
+    }
+}
+
+fn package_manager_bin_name(tool: &str, package_manager_type: PackageManagerType) -> &str {
+    match (tool, package_manager_type) {
+        (_, PackageManagerType::Npm) => "npm",
+        (_, PackageManagerType::Pnpm) => "pnpm",
+        (_, PackageManagerType::Yarn) => "yarn",
+        (_, PackageManagerType::Bun) => "bun",
+    }
+}
+
 /// Parsed npm global command (install or uninstall).
 struct NpmGlobalCommand {
     /// Package names/specs extracted from args (e.g., ["codex", "typescript@5"])
@@ -654,6 +680,37 @@ fn resolve_npm_prefix(
     get_npm_global_prefix(npm_path, node_dir)
 }
 
+/// Resolve a matching package-manager binary from the current project's explicit
+/// `packageManager` field.
+///
+/// The match is intentionally strict to avoid translating commands: `npm` only uses
+/// `npm@...`, `pnpm` only uses `pnpm@...`, etc.
+async fn resolve_matching_package_manager_tool(
+    cwd: &AbsolutePath,
+    tool: &str,
+) -> Result<Option<AbsolutePathBuf>, Error> {
+    let Some(expected_type) = package_manager_type_for_tool(tool) else {
+        return Ok(None);
+    };
+
+    let Some(resolution) = resolve_package_manager_from_package_json(cwd)? else {
+        return Ok(None);
+    };
+
+    if resolution.package_manager_type != expected_type {
+        return Ok(None);
+    }
+
+    let (install_dir, _, _) = download_package_manager(
+        resolution.package_manager_type,
+        &resolution.version,
+        resolution.hash.as_deref(),
+    )
+    .await?;
+    let bin_name = package_manager_bin_name(tool, resolution.package_manager_type);
+    Ok(Some(package_manager_bin_path(&install_dir, bin_name)))
+}
+
 /// Main shim dispatch entry point.
 ///
 /// Called when the binary is invoked as node, npm, npx, or a package binary.
@@ -757,24 +814,58 @@ pub async fn dispatch(tool: &str, args: &[String]) -> i32 {
         return 1;
     }
 
-    // Locate tool binary
-    let tool_path = match locate_tool(&resolution.version, tool) {
+    // Locate the Node binary for PATH preparation. Package-manager shims can use
+    // their own declared version, but JS-based package managers still need the
+    // project-resolved Node.js runtime to execute.
+    let node_path = match locate_tool(&resolution.version, "node") {
         Ok(p) => p,
         Err(e) => {
-            eprintln!("vp: Tool '{tool}' not found: {e}");
+            eprintln!("vp: Node not found: {e}");
             return 1;
         }
     };
 
-    // Save original PATH before we modify it — needed for npm global install check.
+    // Locate tool binary. If the current project explicitly pins the invoked
+    // package manager in `packageManager`, prefer that managed package-manager
+    // binary over the tool bundled with Node.js.
+    let package_manager_tool_path = match resolve_matching_package_manager_tool(&cwd, tool).await {
+        Ok(path) => path,
+        Err(e) => {
+            eprintln!("vp: Failed to resolve package manager for '{tool}': {e}");
+            return 1;
+        }
+    };
+    let tool_path = match package_manager_tool_path {
+        Some(path) => path,
+        None => match locate_tool(&resolution.version, tool) {
+            Ok(p) => p,
+            Err(e) => {
+                eprintln!("vp: Tool '{tool}' not found: {e}");
+                return 1;
+            }
+        },
+    };
+
+    if !tool_path.as_path().exists() {
+        eprintln!("vp: Tool '{tool}' not found: {}", tool_path.as_path().display());
+        return 1;
+    }
+
+    // Save original PATH before we modify it - needed for npm global install check.
     // Only captured for npm to avoid unnecessary work on node/npx hot path.
     let original_path = if tool == "npm" { std::env::var_os("PATH") } else { None };
 
-    // Prepare environment for recursive invocations
-    // Prepend real node bin dir to PATH so child processes use the correct version
-    let node_bin_dir = tool_path.parent().expect("Tool has no parent directory");
-    // Use dedupe_anywhere=false to only check if it's first in PATH (original behavior)
+    // Prepare environment for recursive invocations. Keep the project Node.js
+    // bin dir available for JS package-manager shims, and when a package-manager
+    // version was selected from `packageManager`, put that PM bin dir first so
+    // nested invocations see the same PM version while recursion prevention is set.
+    let node_bin_dir = node_path.parent().expect("Node has no parent directory");
     let _ = prepend_to_path_env(node_bin_dir, PrependOptions::default());
+    if let Some(pm_bin_dir) = tool_path.parent()
+        && pm_bin_dir != node_bin_dir
+    {
+        let _ = prepend_to_path_env(pm_bin_dir, PrependOptions::default());
+    }
 
     // Optional debug env vars
     if std::env::var(env_vars::VP_DEBUG_SHIM).is_ok() {
@@ -842,6 +933,55 @@ pub async fn dispatch(tool: &str, args: &[String]) -> i32 {
 /// Finds the package that provides this binary and executes it with the
 /// Node.js version that was used to install the package.
 async fn dispatch_package_binary(tool: &str, args: &[String]) -> i32 {
+    if package_manager_type_for_tool(tool).is_some() {
+        let cwd = match current_dir() {
+            Ok(path) => path,
+            Err(e) => {
+                eprintln!("vp: Failed to get current directory: {e}");
+                return 1;
+            }
+        };
+
+        match resolve_matching_package_manager_tool(&cwd, tool).await {
+            Ok(Some(tool_path)) => {
+                let node_version = match resolve_with_cache(&cwd).await {
+                    Ok(resolution) => resolution.version,
+                    Err(_) => match find_package_for_binary(tool).await {
+                        Ok(Some(metadata)) => metadata.platform.node,
+                        _ => String::new(),
+                    },
+                };
+
+                if !node_version.is_empty() {
+                    if let Err(e) = ensure_installed(&node_version).await {
+                        eprintln!("vp: Failed to install Node {}: {e}", node_version);
+                        return 1;
+                    }
+                    if let Ok(node_path) = locate_tool(&node_version, "node")
+                        && let Some(node_bin_dir) = node_path.parent()
+                    {
+                        let _ = prepend_to_path_env(node_bin_dir, PrependOptions::default());
+                    }
+                }
+
+                if let Some(pm_bin_dir) = tool_path.parent() {
+                    let _ = prepend_to_path_env(pm_bin_dir, PrependOptions::default());
+                }
+
+                // SAFETY: Setting env vars at this point before exec is safe
+                unsafe {
+                    std::env::set_var(RECURSION_ENV_VAR, "1");
+                }
+                return exec::exec_tool(&tool_path, args);
+            }
+            Ok(None) => {}
+            Err(e) => {
+                eprintln!("vp: Failed to resolve package manager for '{tool}': {e}");
+                return 1;
+            }
+        }
+    }
+
     // Find which package provides this binary
     let package_metadata = match find_package_for_binary(tool).await {
         Ok(Some(metadata)) => metadata,