fix(cli): expose configured package manager to direct commands

Prepend the managed package manager bin from an explicit packageManager field to direct built-in command environments so tools spawned by vp test can find the configured package manager without relying on the user's shell PATH.

Keep the behavior limited to explicit packageManager metadata and avoid lockfile inference or package.json mutation.

Author: jong-kyung

packages/cli/binding/src/cli/mod.rs

@@ -60,6 +60,7 @@ async fn execute_direct_subcommand(
             .map(|(k, v)| (Arc::from(k.as_os_str()), Arc::from(v.as_os_str())))
             .collect(),
     );
+    let envs = envs_with_explicit_package_manager_path(cwd, envs).await?;
 
     let status = match subcommand {
         SynthesizableSubcommand::Check {
@@ -113,6 +114,57 @@ async fn execute_direct_subcommand(
     Ok(status)
 }
 
+fn is_path_env_key(key: &OsStr) -> bool {
+    if cfg!(windows) { key.eq_ignore_ascii_case("PATH") } else { key == "PATH" }
+}
+
+fn prepend_to_env_path(
+    envs: &Arc<FxHashMap<Arc<OsStr>, Arc<OsStr>>>,
+    bin_prefix: &AbsolutePath,
+) -> Result<Arc<FxHashMap<Arc<OsStr>, Arc<OsStr>>>, Error> {
+    let path_key = envs
+        .keys()
+        .find(|key| is_path_env_key(key.as_ref()))
+        .cloned()
+        .unwrap_or_else(|| Arc::from(OsStr::new("PATH")));
+    let current_path =
+        envs.get(&path_key).map_or_else(Default::default, |path| path.to_os_string());
+    let paths = env::split_paths(&current_path).collect::<Vec<_>>();
+
+    if paths.first().is_some_and(|path| path == bin_prefix.as_path()) {
+        return Ok(Arc::clone(envs));
+    }
+
+    let new_path = env::join_paths(
+        std::iter::once(bin_prefix.as_path().to_path_buf()).chain(paths.into_iter()),
+    )
+    .map_err(|error| Error::Anyhow(anyhow::Error::new(error)))?;
+
+    let mut envs = FxHashMap::clone(envs);
+    envs.insert(path_key, Arc::from(new_path.as_os_str()));
+    Ok(Arc::new(envs))
+}
+
+async fn envs_with_explicit_package_manager_path(
+    cwd: &AbsolutePath,
+    envs: Arc<FxHashMap<Arc<OsStr>, Arc<OsStr>>>,
+) -> Result<Arc<FxHashMap<Arc<OsStr>, Arc<OsStr>>>, Error> {
+    let Some(resolution) =
+        vite_install::package_manager::resolve_package_manager_from_package_json(cwd)?
+    else {
+        return Ok(envs);
+    };
+
+    let (install_dir, _, _) = vite_install::download_package_manager(
+        resolution.package_manager_type,
+        &resolution.version,
+        resolution.hash.as_deref(),
+    )
+    .await?;
+
+    prepend_to_env_path(&envs, &install_dir.join("bin"))
+}
+
 /// Execute a vite-task command (run, cache) through Session.
 async fn execute_vite_task_command(
     command: vite_task::Command,
@@ -224,10 +276,80 @@ async fn execute_pm_command(
 
 #[cfg(test)]
 mod tests {
-    use std::path::PathBuf;
+    use std::{
+        ffi::OsStr,
+        fs,
+        path::PathBuf,
+        sync::Arc,
+        time::{SystemTime, UNIX_EPOCH},
+    };
 
+    use rustc_hash::FxHashMap;
+    use vite_path::AbsolutePathBuf;
     use vite_task::config::UserRunConfig;
 
+    use super::{envs_with_explicit_package_manager_path, prepend_to_env_path};
+
+    fn envs_with_path(path: &std::ffi::OsStr) -> Arc<FxHashMap<Arc<OsStr>, Arc<OsStr>>> {
+        Arc::new(FxHashMap::from_iter([(Arc::from(OsStr::new("PATH")), Arc::from(path))]))
+    }
+
+    #[test]
+    fn prepends_package_manager_bin_to_env_path() {
+        let cwd = std::env::current_dir().expect("current_dir should exist");
+        let old_bin = cwd.join("old-bin");
+        let pm_bin = AbsolutePathBuf::new(cwd.join("pm-bin")).expect("pm bin should be absolute");
+        let original_path = std::env::join_paths([old_bin.as_path()]).expect("valid PATH");
+        let envs = envs_with_path(original_path.as_os_str());
+
+        let updated = prepend_to_env_path(&envs, &pm_bin).expect("PATH should update");
+        let path_value = updated.get(OsStr::new("PATH")).expect("PATH should exist");
+        let paths = std::env::split_paths(path_value).collect::<Vec<_>>();
+
+        assert_eq!(paths.first().map(std::path::PathBuf::as_path), Some(pm_bin.as_path()));
+        assert_eq!(paths.get(1).map(std::path::PathBuf::as_path), Some(old_bin.as_path()));
+    }
+
+    #[test]
+    fn does_not_duplicate_package_manager_bin_when_already_first() {
+        let cwd = std::env::current_dir().expect("current_dir should exist");
+        let pm_bin = AbsolutePathBuf::new(cwd.join("pm-bin")).expect("pm bin should be absolute");
+        let original_path = std::env::join_paths([pm_bin.as_path()]).expect("valid PATH");
+        let envs = envs_with_path(original_path.as_os_str());
+
+        let updated = prepend_to_env_path(&envs, &pm_bin).expect("PATH should update");
+        let path_value = updated.get(OsStr::new("PATH")).expect("PATH should exist");
+        let paths = std::env::split_paths(path_value).collect::<Vec<_>>();
+
+        assert_eq!(paths, vec![pm_bin.as_path().to_path_buf()]);
+    }
+
+    #[tokio::test]
+    async fn ignores_lockfile_without_explicit_package_manager() {
+        let suffix =
+            SystemTime::now().duration_since(UNIX_EPOCH).expect("time should be valid").as_nanos();
+        let temp_dir = std::env::temp_dir().join(format!("vite-plus-no-pm-{suffix}"));
+        fs::create_dir_all(&temp_dir).expect("temp dir should be created");
+        fs::write(temp_dir.join("package.json"), r#"{"name":"fixture"}"#)
+            .expect("package.json should be written");
+        fs::write(temp_dir.join("pnpm-lock.yaml"), "lockfileVersion: '9.0'\n")
+            .expect("lockfile should be written");
+        let cwd = AbsolutePathBuf::new(temp_dir.clone()).expect("temp dir should be absolute");
+        let original_path = std::env::join_paths([temp_dir.join("old-bin")]).expect("valid PATH");
+        let envs = envs_with_path(original_path.as_os_str());
+
+        let updated = envs_with_explicit_package_manager_path(&cwd, Arc::clone(&envs))
+            .await
+            .expect("missing packageManager should not error");
+
+        assert_eq!(updated.get(OsStr::new("PATH")), envs.get(OsStr::new("PATH")));
+        assert_eq!(
+            fs::read_to_string(temp_dir.join("package.json")).expect("package.json should exist"),
+            r#"{"name":"fixture"}"#
+        );
+        fs::remove_dir_all(temp_dir).expect("temp dir should be removed");
+    }
+
     #[test]
     fn run_config_types_in_sync() {
         // Remove \r for cross-platform consistency