chore: ci

Author: elrrrrrrr

crates/pm/src/cmd/install.rs

@@ -1,11 +1,12 @@
 use anyhow::{Context, Result};
 use std::fs;
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use std::sync::Arc;
 use std::thread;
 use tokio::sync::Semaphore;
 
 use crate::cmd::rebuild::rebuild;
+use crate::helper::global_bin::get_global_bin_dir;
 use crate::helper::lock::update_package_json;
 use crate::helper::lock::{
     PackageLock, ensure_package_lock, group_by_depth, prepare_global_package_json,
@@ -112,7 +113,7 @@ pub async fn install(ignore_scripts: bool, root_path: &Path) -> Result<()> {
     }
 }
 
-pub async fn install_global_package(npm_spec: &str, prefix: &Option<String>) -> Result<()> {
+pub async fn install_global_package(npm_spec: &str, prefix: Option<&str>) -> Result<()> {
     // Prepare global package directory and package.json
     let package_path = prepare_global_package_json(npm_spec, prefix)
         .await
@@ -129,17 +130,9 @@ pub async fn install_global_package(npm_spec: &str, prefix: &Option<String>) ->
     let package_info =
         PackageInfo::from_path(&package_path).context("Failed to create package info from path")?;
 
-    let target_bin_dir = match prefix {
-        Some(prefix) => PathBuf::from(prefix).join("bin"),
-
-        // If prefix is not set, link to the bin directory of the current executable
-        // ~/.nvm/versions/node/v20.15.0/bin/utoo -> ~/.nvm/versions/node/v20.15.0/bin
-        None => std::env::current_exe()
-            .context("Failed to get current executable path")?
-            .parent()
-            .context("Failed to get executable parent directory")?
-            .to_path_buf(),
-    };
+    // Get global bin directory using the common helper
+    let target_bin_dir =
+        get_global_bin_dir(&prefix).context("Failed to get global bin directory")?;
 
     // Link binary files to global
     log_verbose(&format!(
@@ -161,7 +154,7 @@ mod tests {
     #[tokio::test]
     async fn test_install_global_package_invalid_spec() {
         // Test installing with invalid package spec
-        let result = install_global_package("invalid-package-that-does-not-exist", &None).await;
+        let result = install_global_package("invalid-package-that-does-not-exist", None).await;
         assert!(result.is_err(), "Should fail with invalid package spec");
     }
 }

crates/pm/src/cmd/link.rs

@@ -0,0 +1,168 @@
+use crate::cmd::install::install;
+use crate::helper::global_bin::get_global_package_dir;
+use crate::helper::workspace::update_cwd_to_project;
+use crate::model::package::PackageInfo;
+use crate::util::linker::link;
+use crate::util::logger::log_verbose;
+use anyhow::{Context, Result};
+
+/// Link current package to global (equivalent to npm link without args)
+pub async fn link_current_to_global(prefix: Option<&str>) -> Result<()> {
+    let cwd = std::env::current_dir().context("Failed to get current directory")?;
+    let project_path = update_cwd_to_project(&cwd).await?;
+
+    // Create package info from path
+    let package_info = PackageInfo::from_path(&project_path).with_context(|| {
+        format!(
+            "Failed to parse package info from path: {}",
+            project_path.display()
+        )
+    })?;
+
+    // Install dependencies
+    install(false, &project_path).await.map_err(|e| {
+        anyhow::anyhow!("Failed to prepare dependencies for package to link: {}", e)
+    })?;
+
+    let global_package_path = get_global_package_dir(&prefix)?.join(package_info.name.clone());
+    // link local project to global package
+    link(&project_path, &global_package_path).with_context(|| {
+        format!(
+            "Failed to link local project to global package: {} -> {}",
+            project_path.display(),
+            global_package_path.display()
+        )
+    })?;
+    // If the package has binary files, also link them to global bin directory
+    if package_info.has_bin_files() {
+        let global_bin_dir = global_package_path.join("bin");
+        package_info
+            .link_to_target(&global_bin_dir)
+            .await
+            .with_context(|| {
+                format!(
+                    "Failed to link binary files to global bin directory: {}",
+                    global_bin_dir.display()
+                )
+            })?;
+    }
+
+    Ok(())
+}
+
+/// Link a global package to local node_modules (equivalent to npm link pkg_name)
+pub async fn link_global_to_local(package_name: &str, prefix: Option<&str>) -> Result<()> {
+    let cwd = std::env::current_dir().context("Failed to get current directory")?;
+    let project_path = update_cwd_to_project(&cwd).await?;
+
+    let global_package_path = get_global_package_dir(&prefix)?.join(package_name);
+
+    // Create package info from path
+    let package_info = PackageInfo::from_path(&global_package_path).with_context(|| {
+        format!(
+            "Failed to parse package info from path: {}",
+            global_package_path.display()
+        )
+    })?;
+
+    // Create symlink from global package to local project
+    let local_link_path = project_path.join("node_modules/").join(package_name);
+    link(&global_package_path, &local_link_path).with_context(|| {
+        format!(
+            "Failed to link global package to local: {} -> {}",
+            global_package_path.display(),
+            local_link_path.display()
+        )
+    })?;
+
+    log_verbose(&format!(
+        "link global package to local: {} -> {}",
+        global_package_path.display(),
+        project_path.display()
+    ));
+
+    // If the package has binary files, also link them to target project bin directory
+    if package_info.has_bin_files() {
+        log_verbose(&format!(
+            "Linking binary files to project bin directory: {}",
+            package_info.name
+        ));
+        let bin_dir = project_path.join("node_modules/.bin");
+        package_info
+            .link_to_target(&bin_dir)
+            .await
+            .with_context(|| {
+                format!(
+                    "Failed to link binary files to project bin directory: {}",
+                    bin_dir.display()
+                )
+            })?;
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+    use tempfile::TempDir;
+
+    // helper to write minimal package.json and lock to bypass install flow side effects
+    async fn write_minimal_project_files(path: &std::path::Path, name: &str) {
+        let pkg = format!(
+            r#"{{
+  "name": "{name}",
+  "version": "1.0.0"
+}}"#
+        );
+        fs::write(path.join("package.json"), pkg).unwrap();
+        let lock = r#"{
+  "name": "test",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {"name": "test", "version": "1.0.0"}
+  }
+}"#;
+        fs::write(path.join("package-lock.json"), lock).unwrap();
+        fs::create_dir_all(path.join("node_modules")).unwrap();
+    }
+
+    #[tokio::test]
+    async fn test_link_global_to_local_basic() {
+        let temp_dir = TempDir::new().unwrap();
+        let project = temp_dir.path().join("proj");
+        let global = temp_dir.path().join("global");
+        fs::create_dir_all(&project).unwrap();
+        fs::create_dir_all(&global).unwrap();
+
+        // minimal project files to bypass install
+        write_minimal_project_files(&project, "consumer").await;
+
+        // create fake global package dir with package.json
+        let pkg_name = "lib-a";
+        let global_pkg_dir = global.join("lib/node_modules").join(pkg_name);
+        fs::create_dir_all(&global_pkg_dir).unwrap();
+        let pkg_json = format!(
+            r#"{{
+  "name": "{pkg_name}",
+  "version": "1.0.0"
+}}"#
+        );
+        fs::write(global_pkg_dir.join("package.json"), pkg_json).unwrap();
+
+        // set cwd to project so local node_modules path is resolved
+        std::env::set_current_dir(&project).unwrap();
+
+        let prefix_str = global.to_string_lossy().to_string();
+        let result = link_global_to_local(pkg_name, Some(&prefix_str)).await;
+        assert!(result.is_ok(), "link_global_to_local should succeed");
+
+        // verify node_modules symlink
+        let local_link = project.join("node_modules").join(pkg_name);
+        assert!(local_link.exists());
+        assert!(local_link.is_symlink() || local_link.is_dir());
+    }
+}

crates/pm/src/cmd/mod.rs

@@ -3,6 +3,7 @@ pub mod config;
 pub mod deps;
 pub mod execute;
 pub mod install;
+pub mod link;
 pub mod list;
 pub mod rebuild;
 pub mod run;

crates/pm/src/constants.rs

@@ -46,4 +46,8 @@ pub mod cmd {
     pub const CONFIG_NAME: &str = "config";
     pub const CONFIG_ALIAS: &str = "cfg";
     pub const CONFIG_ABOUT: &str = "Manage configuration";
+
+    pub const LINK_NAME: &str = "link";
+    pub const LINK_ALIAS: &str = "ln";
+    pub const LINK_ABOUT: &str = "Link a package like npm link";
 }

crates/pm/src/helper/auto_update.rs

@@ -41,7 +41,7 @@ pub async fn init_auto_update() -> Result<()> {
             "New version found: {} (current version: {}), updating automatically...",
             cache.version, current_version
         ));
-        log_info(&format!("utoo i @utoo/utoo{} -g", cache.version));
+        log_info(&format!("utoo i utoo@{} -g", cache.version));
 
         execute_update(&cache.version).await?;
     }
@@ -60,7 +60,7 @@ async fn check_and_update_cache() -> Result<VersionCache> {
 
 async fn execute_update(version: &str) -> Result<()> {
     let status = Command::new("utoo")
-        .args(["i", &format!("@utoo/utoo@{version}"), "-g"])
+        .args(["i", &format!("utoo@{version}"), "-g"])
         .env("CI", "1")
         .stdout(Stdio::inherit())
         .stderr(Stdio::inherit())
@@ -77,7 +77,7 @@ async fn execute_update(version: &str) -> Result<()> {
 }
 
 async fn check_remote_version() -> Result<()> {
-    let registry_url = format!("{}/@utoo/utoo/latest", get_registry());
+    let registry_url = format!("{}/utoo/latest", get_registry());
     let client = reqwest::Client::builder()
         .timeout(std::time::Duration::from_millis(2000))
         .build()

crates/pm/src/helper/global_bin.rs

@@ -0,0 +1,71 @@
+use anyhow::{Context, Result};
+use std::path::PathBuf;
+
+// Get global bin directory based on prefix
+//
+// This function determines the global binary directory where executables should be linked.
+// It's used by both link and install commands to ensure consistent binary linking behavior.
+//
+// # Arguments
+// * `prefix` - Optional custom prefix path. If None, uses the current executable's directory.
+//
+// # Returns
+// * `PathBuf` - Path to the global bin directory
+//
+// # Examples
+//
+// ```rust
+// // Use default (current executable directory)
+// let bin_dir = get_global_bin_dir(&None)?;
+//
+// // Use custom prefix
+// let bin_dir = get_global_bin_dir(&Some("/usr/local"))?;
+// ```
+pub fn get_global_bin_dir(prefix: &Option<&str>) -> Result<PathBuf> {
+    Ok(get_global_package_dir(prefix)?.join("bin"))
+}
+
+pub fn get_global_package_dir(prefix: &Option<&str>) -> Result<PathBuf> {
+    let lib_path = match prefix {
+        Some(prefix) => PathBuf::from(prefix).join("lib/node_modules"),
+        None => std::env::current_exe()
+            .context("Failed to get current executable path")?
+            .parent()
+            .context("Failed to get executable parent directory")?
+            .to_path_buf()
+            .join("lib/node_modules"),
+    };
+    Ok(lib_path)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_get_global_bin_dir_with_prefix() {
+        let prefix: Option<&str> = Some("/usr/local");
+        let result = get_global_bin_dir(&prefix).unwrap();
+        assert_eq!(result, PathBuf::from("/usr/local/lib/node_modules/bin"));
+    }
+
+    #[test]
+    fn test_get_global_bin_dir_without_prefix() {
+        let expected = std::env::current_exe()
+            .expect("current_exe should exist")
+            .parent()
+            .expect("exe should have a parent directory")
+            .to_path_buf()
+            .join("lib/node_modules")
+            .join("bin");
+        let result = get_global_bin_dir(&None).unwrap();
+        assert_eq!(result, expected);
+    }
+
+    #[test]
+    fn test_get_global_bin_dir_with_empty_prefix() {
+        let prefix: Option<&str> = Some("");
+        let result = get_global_bin_dir(&prefix).unwrap();
+        assert_eq!(result, PathBuf::from("lib/node_modules/bin"));
+    }
+}

crates/pm/src/helper/lock.rs

@@ -174,10 +174,7 @@ pub async fn parse_package_spec(spec: &str) -> Result<(String, String, String)>
     Ok((name, resolved.version, version_spec))
 }
 
-pub async fn prepare_global_package_json(
-    npm_spec: &str,
-    prefix: &Option<String>,
-) -> Result<PathBuf> {
+pub async fn prepare_global_package_json(npm_spec: &str, prefix: Option<&str>) -> Result<PathBuf> {
     // Parse package name and version
     let (name, _version, version_spec) = parse_package_spec(npm_spec).await?;
     let lib_path = match prefix {

crates/pm/src/helper/mod.rs

@@ -2,6 +2,7 @@ pub mod auto_update;
 pub mod cli;
 pub mod compatibility;
 pub mod deps;
+pub mod global_bin;
 pub mod install_runtime;
 pub mod lock;
 pub mod package;