feat: 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,67 @@ 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 bin_name = package_manager_bin_name(tool, resolution.package_manager_type);
+    let tool_path = package_manager_bin_path(&install_dir, bin_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" | "npx" => Some(PackageManagerType::Npm),
+        "pnpm" | "pnpx" => Some(PackageManagerType::Pnpm),
+        "yarn" | "yarnpkg" => Some(PackageManagerType::Yarn),
+        "bun" | "bunx" => Some(PackageManagerType::Bun),
+        _ => None,
+    }
+}
+
+fn package_manager_bin_name(tool: &str, package_manager_type: PackageManagerType) -> &str {
+    match (tool, package_manager_type) {
+        ("npx", PackageManagerType::Npm) => "npx",
+        ("pnpx", PackageManagerType::Pnpm) => "pnpx",
+        ("yarnpkg", PackageManagerType::Yarn) => "yarnpkg",
+        ("bunx", PackageManagerType::Bun) => "bunx",
+        (_, PackageManagerType::Npm) => "npm",
+        (_, PackageManagerType::Pnpm) => "pnpm",
+        (_, PackageManagerType::Yarn) => "yarn",
+        (_, PackageManagerType::Bun) => "bun",
+    }
+}
+
 /// 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