fix(dev): stabilize local path global installs

Author: Salnika

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

@@ -3,6 +3,7 @@
 use std::{
     collections::HashSet,
     io::{Read, Write},
+    path::Path,
     process::Stdio,
 };
 
@@ -113,6 +114,8 @@ pub async fn install(
 
     let binary_infos = extract_binaries(&package_json);
 
+    materialize_symlinked_package_dir(&node_modules_dir).await?;
+
     // Detect which binaries are JavaScript files
     let mut bin_names = Vec::new();
     let mut js_bins = HashSet::new();
@@ -142,7 +145,7 @@ pub async fn install(
             let packages_to_remove: HashSet<_> =
                 conflicts.iter().map(|(_, pkg)| pkg.clone()).collect();
             for pkg in packages_to_remove {
-                output::raw(&format!("Uninstalling {} (conflicts with {})...", pkg, package_name));
+                output::raw(&format!("Uninstalling {} (conflicts with {})...", pkg, package_spec));
                 // Use Box::pin to avoid recursive async type issues
                 Box::pin(uninstall(&pkg, false)).await?;
             }
@@ -153,7 +156,7 @@ pub async fn install(
             return Err(Error::BinaryConflict {
                 bin_name: conflicts[0].0.clone(),
                 existing_package: conflicts[0].1.clone(),
-                new_package: package_name.clone(),
+                new_package: package_spec.to_string(),
             });
         }
     }
@@ -188,7 +191,7 @@ pub async fn install(
     // 8. Create shims for binaries and save per-binary configs
     let bin_dir = get_bin_dir()?;
     for bin_name in &bin_names {
-        create_package_shim(&bin_dir, bin_name, &package_name).await?;
+        create_package_shim(&bin_dir, bin_name, package_spec).await?;
 
         // Write per-binary config
         let bin_config = BinConfig::new(
@@ -200,7 +203,7 @@ pub async fn install(
         bin_config.save().await?;
     }
 
-    output::raw(&format!("Installed {} v{}", package_name, installed_version));
+    output::raw(&format!("Installed {} v{}", package_spec, installed_version));
     if !bin_names.is_empty() {
         output::raw(&format!("Binaries: {}", bin_names.join(", ")));
     }
@@ -269,6 +272,10 @@ pub async fn uninstall(package_name: &str, dry_run: bool) -> Result<(), Error> {
 
 /// Parse package spec into name and optional version.
 fn parse_package_spec(spec: &str) -> (String, Option<String>) {
+    if is_local_path(spec) {
+        return (resolve_local_package_name(spec).unwrap_or_else(|| spec.to_string()), None);
+    }
+
     // Handle scoped packages: @scope/name@version
     if spec.starts_with('@') {
         // Find the second @ for version
@@ -287,6 +294,89 @@ fn parse_package_spec(spec: &str) -> (String, Option<String>) {
     (spec.to_string(), None)
 }
 
+fn is_local_path(spec: &str) -> bool {
+    spec == "."
+        || spec == ".."
+        || spec.starts_with("./")
+        || spec.starts_with("../")
+        || spec.starts_with('/')
+        || (cfg!(windows)
+            && spec.len() >= 3
+            && spec.as_bytes()[1] == b':'
+            && (spec.as_bytes()[2] == b'\\' || spec.as_bytes()[2] == b'/'))
+}
+
+fn resolve_local_package_name(spec: &str) -> Option<String> {
+    let pkg_json_path = current_dir().ok()?.join(spec).join("package.json");
+    let content = std::fs::read_to_string(pkg_json_path.as_path()).ok()?;
+    let json: serde_json::Value = serde_json::from_str(&content).ok()?;
+    json.get("name").and_then(|name| name.as_str()).map(str::to_string)
+}
+
+async fn materialize_symlinked_package_dir(node_modules_dir: &AbsolutePath) -> Result<(), Error> {
+    let metadata = tokio::fs::symlink_metadata(node_modules_dir.as_path()).await?;
+    if !metadata.file_type().is_symlink() {
+        return Ok(());
+    }
+
+    let symlink_target = tokio::fs::read_link(node_modules_dir.as_path()).await?;
+    let resolved_target = if symlink_target.is_absolute() {
+        symlink_target
+    } else {
+        node_modules_dir
+            .parent()
+            .expect("package dir should have a parent")
+            .as_path()
+            .join(&symlink_target)
+    };
+
+    let package_dir_name =
+        node_modules_dir.as_path().file_name().and_then(|name| name.to_str()).unwrap_or("package");
+    let temp_dir = node_modules_dir.parent().expect("package dir should have a parent").as_path().join(
+        format!(".{package_dir_name}-materialized"),
+    );
+
+    if temp_dir.as_path().exists() {
+        std::fs::remove_dir_all(&temp_dir)?;
+    }
+
+    copy_dir_recursive(&resolved_target, &temp_dir)?;
+    tokio::fs::remove_file(node_modules_dir.as_path()).await?;
+    tokio::fs::rename(&temp_dir, node_modules_dir.as_path()).await?;
+
+    Ok(())
+}
+
+fn copy_dir_recursive(source: &Path, destination: &Path) -> Result<(), Error> {
+    std::fs::create_dir_all(destination)?;
+
+    for entry in std::fs::read_dir(source)? {
+        let entry = entry?;
+        let source_path = entry.path();
+        let destination_path = destination.join(entry.file_name());
+        let file_type = entry.file_type()?;
+
+        if file_type.is_dir() {
+            copy_dir_recursive(&source_path, &destination_path)?;
+            continue;
+        }
+
+        if file_type.is_symlink() {
+            let resolved_path = std::fs::canonicalize(&source_path)?;
+            if resolved_path.is_dir() {
+                copy_dir_recursive(&resolved_path, &destination_path)?;
+            } else {
+                std::fs::copy(&resolved_path, &destination_path)?;
+            }
+            continue;
+        }
+
+        std::fs::copy(&source_path, &destination_path)?;
+    }
+
+    Ok(())
+}
+
 /// Binary info extracted from package.json.
 struct BinaryInfo {
     /// Binary name (the command users will run)
@@ -372,13 +462,13 @@ pub(crate) const CORE_SHIMS: &[&str] = &["node", "npm", "npx", "vp"];
 async fn create_package_shim(
     bin_dir: &vite_path::AbsolutePath,
     bin_name: &str,
-    package_name: &str,
+    package_display_name: &str,
 ) -> Result<(), Error> {
     // Check for conflicts with core shims
     if CORE_SHIMS.contains(&bin_name) {
         output::warn(&format!(
             "Package '{}' provides '{}' binary, but it conflicts with a core shim. Skipping.",
-            package_name, bin_name
+            package_display_name, bin_name
         ));
         return Ok(());
     }
@@ -729,6 +819,55 @@ mod tests {
         assert_eq!(version, Some("20.0.0".to_string()));
     }
 
+    #[test]
+    fn test_parse_package_spec_local_path_uses_package_name() {
+        use tempfile::TempDir;
+
+        let temp_dir = TempDir::new().unwrap();
+        let package_dir = temp_dir.path().join("local-pkg");
+        std::fs::create_dir_all(&package_dir).unwrap();
+        std::fs::write(
+            package_dir.join("package.json"),
+            r#"{"name":"resolved-local-pkg","version":"1.0.0"}"#,
+        )
+        .unwrap();
+
+        let (name, version) = parse_package_spec(package_dir.to_str().unwrap());
+        assert_eq!(name, "resolved-local-pkg");
+        assert_eq!(version, None);
+    }
+
+    #[test]
+    #[cfg(unix)]
+    fn test_materialize_symlinked_package_dir() {
+        use tempfile::TempDir;
+        use vite_path::AbsolutePathBuf;
+
+        let temp_dir = TempDir::new().unwrap();
+        let source_dir = temp_dir.path().join("source-pkg");
+        std::fs::create_dir_all(&source_dir).unwrap();
+        std::fs::write(
+            source_dir.join("package.json"),
+            r#"{"name":"materialized-pkg","version":"1.0.0"}"#,
+        )
+        .unwrap();
+        std::fs::write(source_dir.join("cli.js"), "console.log('ok')").unwrap();
+
+        let node_modules_parent = temp_dir.path().join("prefix/lib/node_modules");
+        std::fs::create_dir_all(&node_modules_parent).unwrap();
+        let symlink_path = node_modules_parent.join("materialized-pkg");
+        std::os::unix::fs::symlink(&source_dir, &symlink_path).unwrap();
+
+        let symlink_path = AbsolutePathBuf::new(symlink_path).unwrap();
+        let runtime = tokio::runtime::Runtime::new().unwrap();
+        runtime.block_on(materialize_symlinked_package_dir(&symlink_path)).unwrap();
+
+        let metadata = std::fs::symlink_metadata(symlink_path.as_path()).unwrap();
+        assert!(!metadata.file_type().is_symlink());
+        assert!(symlink_path.as_path().join("package.json").exists());
+        assert!(symlink_path.as_path().join("cli.js").exists());
+    }
+
     #[test]
     fn test_is_javascript_binary_with_js_extension() {
         use tempfile::TempDir;

packages/cli/snap-tests-global/npm-global-install-already-linked/snap.txt

@@ -14,7 +14,7 @@ npm-global-linked-cli works
 > npm install -g ./npm-global-linked-pkg # Should NOT show hint (binary already exists)
 
 added 1 package in <variable>ms
-Skipped 'npm-global-linked-cli': managed by `vp install -g ./npm-global-linked-pkg`. Run `vp uninstall -g ./npm-global-linked-pkg` to remove it first.
+Skipped 'npm-global-linked-cli': managed by `vp install -g npm-global-linked-pkg`. Run `vp uninstall -g npm-global-linked-pkg` to remove it first.
 
 > vp remove -g npm-global-linked-pkg # Cleanup
 Uninstalled npm-global-linked-pkg

packages/cli/snap-tests-global/npm-global-uninstall-vp-managed/snap.txt

@@ -8,7 +8,7 @@ Binaries: npm-global-vp-managed-cli
 > npm install -g ./npm-global-vp-managed-pkg # npm install (should warn about conflict)
 
 added 1 package in <variable>ms
-Skipped 'npm-global-vp-managed-cli': managed by `vp install -g ./npm-global-vp-managed-pkg`. Run `vp uninstall -g ./npm-global-vp-managed-pkg` to remove it first.
+Skipped 'npm-global-vp-managed-cli': managed by `vp install -g npm-global-vp-managed-pkg`. Run `vp uninstall -g npm-global-vp-managed-pkg` to remove it first.
 
 > npm uninstall -g npm-global-vp-managed-pkg # npm uninstall should NOT remove the vp-managed shim