fix: use real package name for global local packages installation (#1685)

Related to #664.

The current Vite+ will just treat the path inputed as the package name,
and because Vite+ uses package name to create directories and manage
installation, it will make Vite+ broken as it can be a bad path.

This PR fixes it by resolving the true package name by reading the
`package.json` under the entered path.

---------

Co-authored-by: MK (fengmk2) <fengmk2@gmail.com>

Author: liangmiQwQ

Cargo.lock

@@ -17,10 +17,12 @@ clap = { workspace = true, features = ["derive"] }
 clap_complete = { workspace = true, features = ["unstable-dynamic"] }
 directories = { workspace = true }
 futures = { workspace = true }
+flate2 = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 node-semver = { workspace = true }
 thiserror = { workspace = true }
+tar = { workspace = true }
 tokio = { workspace = true, features = ["full"] }
 tracing = { workspace = true }
 owo-colors = { workspace = true }

crates/vite_global_cli/Cargo.toml

@@ -671,7 +671,8 @@ async fn managed_update(
                 continue;
             }
 
-            let (package_name, _) = global::parse_package_spec(package);
+            // It is not a local package, so `parse_package_spec` there won't return `Err()`
+            let (package_name, _) = global::parse_package_spec(package).unwrap();
             if PackageMetadata::load(&package_name).await?.is_some() {
                 managed_specs.push(package.clone());
             } else {

crates/vite_global_cli/src/cli.rs

@@ -26,7 +26,7 @@ use crate::{
             },
             package_metadata::PackageMetadata,
         },
-        global::{CORE_SHIMS, parse_package_spec},
+        global::{CORE_SHIMS, is_local_package_spec, parse_package_spec},
     },
     error::Error,
 };
@@ -105,7 +105,11 @@ pub async fn install(
     let mut packages = IndexMap::<String, Package>::new();
     for package_spec in package_specs {
         // Parse package spec (e.g., "typescript", "typescript@5.0.0", "@scope/pkg")
-        let (package_name, _version_spec) = parse_package_spec(package_spec);
+
+        let (package_name, _version_spec) = match parse_package_spec(package_spec) {
+            Ok(result) => result,
+            Err(error) => return Err((Some(package_spec.clone()), error)),
+        };
         packages.insert(package_name, Package { spec: package_spec, staging_dir: None });
     }
     let packages_count = packages.len();
@@ -395,7 +399,18 @@ async fn install_one(
 /// 1. Try to use PackageMetadata for binary list
 /// 2. Fallback to scanning BinConfig files for orphaned binaries
 pub async fn uninstall(package_name: &str, dry_run: bool) -> Result<(), Error> {
-    let (package_name, _) = parse_package_spec(package_name);
+    if is_local_package_spec(package_name) {
+        // We can't resolve local packages for uninstall, follow npm's behavior
+        return Err(Error::ConfigError(
+            format!(
+                "Local path {} can't be resolved, please enter a package name instead",
+                package_name
+            )
+            .into(),
+        ));
+    }
+
+    let (package_name, _) = parse_package_spec(package_name).unwrap();
 
     // Phase 1: Try to use PackageMetadata for binary list
     let bins = if let Some(metadata) = PackageMetadata::load(&package_name).await? {
@@ -881,28 +896,28 @@ mod tests {
 
     #[test]
     fn test_parse_package_spec_simple() {
-        let (name, version) = parse_package_spec("typescript");
+        let (name, version) = parse_package_spec("typescript").unwrap();
         assert_eq!(name, "typescript");
         assert_eq!(version, None);
     }
 
     #[test]
     fn test_parse_package_spec_with_version() {
-        let (name, version) = parse_package_spec("typescript@5.0.0");
+        let (name, version) = parse_package_spec("typescript@5.0.0").unwrap();
         assert_eq!(name, "typescript");
         assert_eq!(version, Some("5.0.0".to_string()));
     }
 
     #[test]
     fn test_parse_package_spec_scoped() {
-        let (name, version) = parse_package_spec("@types/node");
+        let (name, version) = parse_package_spec("@types/node").unwrap();
         assert_eq!(name, "@types/node");
         assert_eq!(version, None);
     }
 
     #[test]
     fn test_parse_package_spec_scoped_with_version() {
-        let (name, version) = parse_package_spec("@types/node@20.0.0");
+        let (name, version) = parse_package_spec("@types/node@20.0.0").unwrap();
         assert_eq!(name, "@types/node");
         assert_eq!(version, Some("20.0.0".to_string()));
     }

crates/vite_global_cli/src/commands/global/install.rs

@@ -1,9 +1,17 @@
 //! Managed global package utilities.
 
-use std::{collections::HashMap, io::IsTerminal, process::Stdio, time::Duration};
-
+use std::{
+    collections::HashMap,
+    fs::File,
+    io::{IsTerminal, Read},
+    process::Stdio,
+    time::Duration,
+};
+
+use flate2::read::GzDecoder;
 use futures::{StreamExt, stream::FuturesUnordered};
 use indicatif::{ProgressBar, ProgressDrawTarget, ProgressStyle};
+use tar::Archive;
 use tokio::process::Command;
 use vite_path::{AbsolutePathBuf, current_dir};
 use vite_shared::format_path_prepended;
@@ -48,23 +56,34 @@ impl NpmRegistry {
     }
 
     async fn latest_package_version(&self, package_spec: &str) -> Result<String, Error> {
-        let output = Command::new(self.npm_path.as_path())
-            .args(["view", package_spec, "version", "--json"])
-            .env("PATH", format_path_prepended(self.node_bin_dir.as_path()))
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .output()
-            .await?;
-
-        if !output.status.success() {
-            let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
-            return Err(Error::ConfigError(
-                format!("npm view failed for {package_spec}: {stderr}").into(),
-            ));
-        }
+        let output = npm_view(&self.npm_path, &self.node_bin_dir, package_spec, "version").await?;
+
+        parse_npm_view_version(&output)
+    }
+}
+
+async fn npm_view(
+    npm_path: &AbsolutePathBuf,
+    node_bin_dir: &AbsolutePathBuf,
+    package_spec: &str,
+    field: &str,
+) -> Result<Vec<u8>, Error> {
+    let output = Command::new(npm_path.as_path())
+        .args(["view", package_spec, field, "--json"])
+        .env("PATH", format_path_prepended(node_bin_dir.as_path()))
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .output()
+        .await?;
 
-        parse_npm_view_version(&output.stdout)
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
+        return Err(Error::ConfigError(
+            format!("npm view failed for {package_spec}: {stderr}").into(),
+        ));
     }
+
+    Ok(output.stdout)
 }
 
 pub(crate) async fn latest_package_versions(
@@ -133,20 +152,117 @@ pub(crate) fn is_local_package_spec(spec: &str) -> bool {
 }
 
 /// Parse package spec into name and optional version.
-pub(crate) fn parse_package_spec(spec: &str) -> (String, Option<String>) {
-    if spec.starts_with('@') {
-        if let Some(idx) = spec[1..].find('@') {
-            let idx = idx + 1;
-            return (spec[..idx].to_string(), Some(spec[idx + 1..].to_string()));
+/// For local packages, read package.json from a directory or package tarball.
+///
+/// It will never return an `Err()` if it is not a local package
+pub(crate) fn parse_package_spec(spec: &str) -> Result<(String, Option<String>), Error> {
+    if is_local_package_spec(spec) {
+        let package_json = read_local_package_json(spec)?;
+        let Some(package_name) = package_json.get("name").and_then(|name| name.as_str()) else {
+            return Err(Error::ConfigError(
+                format!("Local package {spec} must have a string name in package.json").into(),
+            ));
+        };
+
+        Ok((package_name.to_string(), None))
+    } else {
+        if spec.starts_with('@') {
+            if let Some(idx) = spec[1..].find('@') {
+                let idx = idx + 1;
+                return Ok((spec[..idx].to_string(), Some(spec[idx + 1..].to_string())));
+            }
+            return Ok((spec.to_string(), None));
         }
-        return (spec.to_string(), None);
+
+        if let Some(idx) = spec.find('@') {
+            return Ok((spec[..idx].to_string(), Some(spec[idx + 1..].to_string())));
+        }
+
+        Ok((spec.to_string(), None))
     }
+}
 
-    if let Some(idx) = spec.find('@') {
-        return (spec[..idx].to_string(), Some(spec[idx + 1..].to_string()));
+fn resolve_local_package_path(spec: &str) -> Result<AbsolutePathBuf, Error> {
+    let path_spec = spec.strip_prefix("file:").unwrap_or(spec);
+    let path = std::path::Path::new(path_spec);
+    if path.is_absolute() {
+        AbsolutePathBuf::new(path.to_path_buf())
+            .ok_or_else(|| Error::ConfigError(format!("Invalid local package path {spec}").into()))
+    } else {
+        Ok(current_dir()
+            .map_err(|error| {
+                Error::ConfigError(format!("Cannot get current directory: {error}").into())
+            })?
+            .join(path))
+    }
+}
+
+fn read_local_package_json(spec: &str) -> Result<serde_json::Value, Error> {
+    let package_path = resolve_local_package_path(spec)?;
+    if package_path.as_path().is_file() && is_package_tarball(package_path.as_path()) {
+        return read_package_json_from_tarball(spec, &package_path);
+    }
+
+    let package_json_path = package_path.join("package.json");
+    let package_json_content =
+        std::fs::read_to_string(package_json_path.as_path()).map_err(|error| {
+            Error::ConfigError(
+                format!(
+                    "Failed to read package.json for local package {spec} at {}: {error}",
+                    package_json_path.as_path().display()
+                )
+                .into(),
+            )
+        })?;
+    serde_json::from_str(&package_json_content).map_err(Error::JsonError)
+}
+
+fn is_package_tarball(path: &std::path::Path) -> bool {
+    let path = path.to_string_lossy();
+    path.ends_with(".tgz") || path.ends_with(".tar.gz")
+}
+
+fn read_package_json_from_tarball(
+    spec: &str,
+    package_path: &AbsolutePathBuf,
+) -> Result<serde_json::Value, Error> {
+    let file = File::open(package_path.as_path()).map_err(|error| {
+        Error::ConfigError(
+            format!(
+                "Failed to read package tarball {spec} at {}: {error}",
+                package_path.as_path().display()
+            )
+            .into(),
+        )
+    })?;
+    let decoder = GzDecoder::new(file);
+    let mut archive = Archive::new(decoder);
+
+    for entry in archive.entries().map_err(|error| {
+        Error::ConfigError(format!("Failed to read package tarball {spec}: {error}").into())
+    })? {
+        let mut entry = entry.map_err(|error| {
+            Error::ConfigError(format!("Failed to read package tarball {spec}: {error}").into())
+        })?;
+        let path = entry.path().map_err(|error| {
+            Error::ConfigError(format!("Failed to read package tarball {spec}: {error}").into())
+        })?;
+        if path.as_ref() != std::path::Path::new("package/package.json") {
+            continue;
+        }
+
+        let mut package_json_content = String::new();
+        entry.read_to_string(&mut package_json_content).map_err(|error| {
+            Error::ConfigError(
+                format!("Failed to read package.json from package tarball {spec}: {error}").into(),
+            )
+        })?;
+        return serde_json::from_str(&package_json_content).map_err(Error::JsonError);
     }
 
-    (spec.to_string(), None)
+    Err(Error::ConfigError(
+        format!("Package tarball {spec} must contain package/package.json").into(),
+    ))
 }
 
 fn parse_npm_view_version(stdout: &[u8]) -> Result<String, Error> {

crates/vite_global_cli/src/commands/global/mod.rs

@@ -50,7 +50,10 @@ pub async fn get_outdated_packages(
     let installed = if !packages.is_empty() {
         let mut installed = Vec::new();
         for package in packages {
-            let (package_name, _) = parse_package_spec(package);
+            let Ok((package_name, _)) = parse_package_spec(package) else {
+                // Silently skip, follow npm's behavior
+                continue;
+            };
             if let Some(metadata) = PackageMetadata::load(&package_name).await? {
                 installed.push((metadata, Some(package.clone())));
             }

crates/vite_global_cli/src/commands/global/outdated.rs

@@ -1,16 +1,16 @@
 > vp install -g ./conflict-pkg # Install package with conflicting binary name (uses cwd version)
 info: Installing 1 global package with Node.js <semver>
-warn: Package './conflict-pkg' provides 'node' binary, but it conflicts with a core shim. Skipping.
-✓ Installed ./conflict-pkg <semver>
+warn: Package 'conflict-pkg' provides 'node' binary, but it conflicts with a core shim. Skipping.
+✓ Installed conflict-pkg <semver>
   Bins: conflict-cli, node
 
 > vp remove -g conflict-pkg # Cleanup
 Uninstalled conflict-pkg
 
 > vp install -g --node 20 ./conflict-pkg # Install with specific Node.js version
 info: Installing 1 global package with Node.js <semver>
-warn: Package './conflict-pkg' provides 'node' binary, but it conflicts with a core shim. Skipping.
-✓ Installed ./conflict-pkg <semver>
+warn: Package 'conflict-pkg' provides 'node' binary, but it conflicts with a core shim. Skipping.
+✓ Installed conflict-pkg <semver>
   Bins: conflict-cli, node
 
 > vp remove -g conflict-pkg # Cleanup

packages/cli/snap-tests-global/command-env-install-conflict/snap.txt

@@ -0,0 +1 @@
+console.log('The package is installed successfully');

packages/cli/snap-tests-global/command-env-install-global-local/another-package.tgz

@@ -0,0 +1,7 @@
+{
+  "name": "just-a-normal-package",
+  "version": "0.0.0",
+  "bin": {
+    "just-a-normal-package": "./bin.js"
+  }
+}