implement

Author: liangmiQwQ

crates/vite_global_cli/src/cli.rs

@@ -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/commands/global/install.rs

@@ -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,7 @@ 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);
+    let (package_name, _) = parse_package_spec(package_name)?;
 
     // Phase 1: Try to use PackageMetadata for binary list
     let bins = if let Some(metadata) = PackageMetadata::load(&package_name).await? {
@@ -881,28 +885,35 @@ 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()));
+    }
+
+    #[test]
+    fn test_parse_package_spec_local() {
+        let (name, version) = parse_package_spec("./packages/cli").unwrap();
         assert_eq!(name, "@types/node");
         assert_eq!(version, Some("20.0.0".to_string()));
     }

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

@@ -133,20 +133,63 @@ 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, it will read the package.json and return the real package name
+///
+/// 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 path_spec = spec.strip_prefix("file:").unwrap_or(spec);
+        let path = std::path::Path::new(path_spec);
+        let package_dir = if path.is_absolute() {
+            AbsolutePathBuf::new(path.to_path_buf()).ok_or_else(|| {
+                Error::ConfigError(format!("Invalid local package path {spec}").into())
+            })?
+        } else {
+            current_dir()
+                .map_err(|error| {
+                    Error::ConfigError(format!("Cannot get current directory: {error}").into())
+                })?
+                .join(path)
+        };
+        let package_json_path = package_dir.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(),
+                )
+            })?;
+        let package_json: serde_json::Value =
+            serde_json::from_str(&package_json_content).map_err(Error::JsonError)?;
+        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_path.as_path().display()
+                )
+                .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 (spec[..idx].to_string(), Some(spec[idx + 1..].to_string()));
-    }
+        if let Some(idx) = spec.find('@') {
+            return Ok((spec[..idx].to_string(), Some(spec[idx + 1..].to_string())));
+        }
 
-    (spec.to_string(), None)
+        Ok((spec.to_string(), None))
+    }
 }
 
 fn parse_npm_view_version(stdout: &[u8]) -> Result<String, Error> {

crates/vite_global_cli/src/commands/global/outdated.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())));
             }