refactor(pm): tokio fs (#2219)

* refactor: tokio fs

* fix: ci

Author: elrrrrrrr

crates/pm/src/cmd/config.rs

@@ -10,14 +10,18 @@ fn parse_key_val(s: &str) -> Result<(String, String)> {
     Ok((s[..pos].to_string(), s[pos + 1..].to_string()))
 }
 
-pub fn handle_config_set(key: String, value: String, global: bool) -> Result<()> {
-    let mut config = Config::load(global)?;
+pub async fn handle_config_set(key: String, value: String, global: bool) -> Result<()> {
+    let mut config = Config::load(global).await?;
     config.set(&key, value, global)?;
     println!("Successfully set {key} (global: {global})");
     Ok(())
 }
 
-pub fn handle_config_get(key: String, global: bool, override_values: Vec<String>) -> Result<()> {
+pub async fn handle_config_get(
+    key: String,
+    global: bool,
+    override_values: Vec<String>,
+) -> Result<()> {
     let overrides: HashMap<String, String> = override_values
         .iter()
         .filter_map(|arg| arg.strip_prefix("--").and_then(|s| parse_key_val(s).ok()))
@@ -26,7 +30,7 @@ pub fn handle_config_get(key: String, global: bool, override_values: Vec<String>
     if let Some(value) = overrides.get(&key) {
         println!("{value}");
     } else {
-        let config = Config::load(global)?;
+        let config = Config::load(global).await?;
         match config.get(&key)? {
             Some(value) => println!("{value}"),
             None => {
@@ -38,8 +42,8 @@ pub fn handle_config_get(key: String, global: bool, override_values: Vec<String>
     Ok(())
 }
 
-pub fn handle_config_list(global: bool) -> Result<()> {
-    let config = Config::load(global)?;
+pub async fn handle_config_list(global: bool) -> Result<()> {
+    let config = Config::load(global).await?;
     let config_path = if global {
         config.get_global_config_path()?
     } else {

crates/pm/src/cmd/link.rs

@@ -12,12 +12,14 @@ pub async fn link_current_to_global(prefix: Option<&str>) -> Result<()> {
     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()
-        )
-    })?;
+    let package_info = PackageInfo::from_path(&project_path)
+        .await
+        .with_context(|| {
+            format!(
+                "Failed to parse package info from path: {}",
+                project_path.display()
+            )
+        })?;
 
     // Install dependencies
     install(false, &project_path).await.map_err(|e| {
@@ -26,13 +28,15 @@ pub async fn link_current_to_global(prefix: Option<&str>) -> Result<()> {
 
     let global_package_path = get_global_package_dir(prefix)?.join(&package_info.name);
     // 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()
-        )
-    })?;
+    link(&project_path, &global_package_path)
+        .await
+        .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");
@@ -58,22 +62,26 @@ pub async fn link_global_to_local(package_name: &str, prefix: Option<&str>) -> R
     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()
-        )
-    })?;
+    let package_info = PackageInfo::from_path(&global_package_path)
+        .await
+        .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()
-        )
-    })?;
+    link(&global_package_path, &local_link_path)
+        .await
+        .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: {} -> {}",

crates/pm/src/cmd/list.rs

@@ -13,7 +13,7 @@ pub async fn list_dependencies(cwd: &Path, package_name: &str) -> Result<()> {
 
     // Find package-lock.json file
     let lock_file_path = cwd.join("package-lock.json");
-    if !lock_file_path.exists() {
+    if !tokio::fs::try_exists(&lock_file_path).await? {
         return Err(anyhow::anyhow!(
             "package-lock.json not found in current directory"
         ));

crates/pm/src/cmd/rebuild.rs

@@ -4,6 +4,7 @@ use std::path::Path;
 
 pub async fn rebuild(root_path: &Path) -> Result<()> {
     let packages = PackageService::collect_packages(root_path)
+        .await
         .map_err(|e| anyhow::anyhow!("Failed to collect packages: {}", e))?;
 
     let execution_queues = PackageService::create_execution_queues(packages)

crates/pm/src/cmd/run.rs

@@ -52,9 +52,9 @@ pub async fn run_script(
             workspace_name,
             workspace_dir.display()
         ));
-        load_package_json_from_path(&workspace_dir)?
+        load_package_json_from_path(&workspace_dir).await?
     } else {
-        load_package_json_from_path(&updated_cwd)?
+        load_package_json_from_path(&updated_cwd).await?
     };
 
     let (scope, name, fullname) =
@@ -141,7 +141,7 @@ async fn need_run(cwd: &Path, workspace_name: &str, script_name: &str) -> Result
     };
 
     // Load package.json from workspace
-    let pkg = match load_package_json_from_path(&workspace_dir) {
+    let pkg = match load_package_json_from_path(&workspace_dir).await {
         Ok(pkg) => pkg,
         Err(_) => {
             log_info(&format!(

crates/pm/src/helper/auto_update.rs

@@ -137,7 +137,7 @@ async fn execute_update(version: &str) -> Result<()> {
 
 /// Fast remote version check - short timeout, quick failure
 async fn check_remote_version_fast() -> Result<VersionCache> {
-    let registry_url = format!("{}/utoo/latest", get_registry());
+    let registry_url = format!("{}/utoo/latest", get_registry().await);
     let client = reqwest::Client::builder()
         .timeout(std::time::Duration::from_millis(1000)) // 1 second timeout
         .build()
@@ -306,8 +306,8 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_save_and_read_version_cache() -> Result<()> {
+    #[tokio::test]
+    async fn test_save_and_read_version_cache() -> Result<()> {
         let temp_dir = tempfile::tempdir()?;
         let cache_path = temp_dir.path().join(".utoo").join("remote-version.json");
 
@@ -318,15 +318,15 @@ mod tests {
 
         // Create directory structure
         if let Some(parent) = cache_path.parent() {
-            std::fs::create_dir_all(parent)?;
+            tokio::fs::create_dir_all(parent).await?;
         }
 
         // Test serialization and file writing manually (without using global HOME)
         let content = serde_json::to_string(&cache)?;
-        std::fs::write(&cache_path, &content)?;
+        tokio::fs::write(&cache_path, &content).await?;
 
         // Test reading and deserialization
-        let read_content = std::fs::read_to_string(cache_path)?;
+        let read_content = tokio::fs::read_to_string(cache_path).await?;
         let loaded_cache: VersionCache = serde_json::from_str(&read_content)?;
 
         assert_eq!(loaded_cache.version, cache.version);

crates/pm/src/helper/lock.rs

@@ -75,11 +75,17 @@ fn deps_fields_equal(pkg_field: Option<&Value>, lock_field: Option<&Value>) -> b
 
 pub async fn ensure_package_lock(root_path: &Path) -> Result<()> {
     // check package.json exists in cwd
-    if fs::metadata(root_path.join("package.json")).is_err() {
+    if tokio::fs::metadata(root_path.join("package.json"))
+        .await
+        .is_err()
+    {
         return Err(anyhow!("package.json not found"));
     }
     // check package-lock.json exists in cwd
-    if fs::metadata(root_path.join("package-lock.json")).is_err() {
+    if tokio::fs::metadata(root_path.join("package-lock.json"))
+        .await
+        .is_err()
+    {
         log_info("Resolving dependencies");
         build_deps(root_path).await?;
         Ok(())
@@ -124,7 +130,8 @@ pub async fn update_package_json(
 
     // 3. Read package.json once
     let package_json_path = target_dir.join("package.json");
-    let mut package_json: Value = serde_json::from_reader(fs::File::open(&package_json_path)?)?;
+    let package_json_content = tokio::fs::read_to_string(&package_json_path).await?;
+    let mut package_json: Value = serde_json::from_str(&package_json_content)?;
 
     let dep_field = match save_type {
         SaveType::Dev => "devDependencies",
@@ -161,10 +168,11 @@ pub async fn update_package_json(
     }
 
     // 6. Write back to package.json once
-    fs::write(
+    tokio::fs::write(
         &package_json_path,
         serde_json::to_string_pretty(&package_json)?,
-    )?;
+    )
+    .await?;
 
     Ok(())
 }
@@ -212,7 +220,7 @@ pub async fn prepare_global_package_json(npm_spec: &str, prefix: Option<&str>) -
     let cache_flag_path = cache_dir.join(format!("{}/{}/_resolved", name, resolved.version));
 
     // Download if not cached
-    if !cache_flag_path.exists() {
+    if !tokio::fs::try_exists(&cache_flag_path).await? {
         log_verbose(&format!(
             "Downloading {} to {}",
             tarball_url,
@@ -227,7 +235,7 @@ pub async fn prepare_global_package_json(npm_spec: &str, prefix: Option<&str>) -
         // so we need to copy the file to the package directory to avoid effect other packages
         if resolved.manifest.get("hasInstallScript") == Some(&json!(true)) {
             let has_install_script_flag_path = cache_path.join("_hasInstallScript");
-            fs::write(has_install_script_flag_path, "")?;
+            tokio::fs::write(has_install_script_flag_path, "").await?;
         }
     }
 
@@ -243,7 +251,8 @@ pub async fn prepare_global_package_json(npm_spec: &str, prefix: Option<&str>) -
 
     // Remove devDependencies from package.json
     let package_json_path = package_path.join("package.json");
-    let mut package_json: Value = serde_json::from_reader(fs::File::open(&package_json_path)?)?;
+    let package_json_content = tokio::fs::read_to_string(&package_json_path).await?;
+    let mut package_json: Value = serde_json::from_str(&package_json_content)?;
 
     // Remove specified dependency fields and scripts.prepare
     let package_obj = package_json.as_object_mut().unwrap();
@@ -258,10 +267,11 @@ pub async fn prepare_global_package_json(npm_spec: &str, prefix: Option<&str>) -
     }
 
     // Write back the modified package.json
-    fs::write(
+    tokio::fs::write(
         &package_json_path,
         serde_json::to_string_pretty(&package_json)?,
-    )?;
+    )
+    .await?;
 
     log_verbose(&format!("package_path: {}", package_path.to_string_lossy()));
     Ok(package_path)
@@ -290,8 +300,8 @@ pub struct InvalidDependency {
 }
 
 pub async fn is_pkg_lock_outdated(root_path: &Path) -> Result<bool> {
-    let pkg_file = load_package_json_from_path(root_path)?;
-    let lock_file = load_package_lock_json_from_path(root_path)?;
+    let pkg_file = load_package_json_from_path(root_path).await?;
+    let lock_file = load_package_lock_json_from_path(root_path).await?;
 
     // get packages in package-lock.json
     let packages = lock_file
@@ -323,7 +333,7 @@ pub async fn is_pkg_lock_outdated(root_path: &Path) -> Result<bool> {
         };
 
         // check dependencies whether changed
-        for (dep_field, _is_optional) in get_dep_types() {
+        for (dep_field, _is_optional) in get_dep_types().await {
             if !deps_fields_equal(pkg.get(dep_field), lock.get(dep_field)) {
                 let name = if path.is_empty() { "root" } else { &path };
                 log_warning(&format!(
@@ -353,7 +363,7 @@ pub async fn validate_deps(
 
     if let Some(packages) = pkgs_in_pkg_lock.as_object() {
         for (pkg_path, pkg_info) in packages {
-            for (dep_field, is_optional) in get_dep_types() {
+            for (dep_field, is_optional) in get_dep_types().await {
                 if let Some(dependencies) = pkg_info.get(dep_field).and_then(|d| d.as_object()) {
                     for (dep_name, req_version) in dependencies {
                         let req_version_str = req_version.as_str().unwrap_or_default();
@@ -474,8 +484,8 @@ pub async fn validate_deps(
     Ok(invalid_deps)
 }
 
-fn get_dep_types() -> Vec<(&'static str, bool)> {
-    let legacy_peer_deps = get_legacy_peer_deps();
+async fn get_dep_types() -> Vec<(&'static str, bool)> {
+    let legacy_peer_deps = get_legacy_peer_deps().await;
 
     if legacy_peer_deps {
         vec![

crates/pm/src/helper/ruborist.rs

@@ -30,7 +30,7 @@ use once_cell::sync::Lazy;
 static CONCURRENCY_LIMITER: Lazy<Arc<Semaphore>> = Lazy::new(|| Arc::new(Semaphore::new(100)));
 
 pub async fn build_deps(root: Arc<Node>) -> Result<()> {
-    let legacy_peer_deps = get_legacy_peer_deps();
+    let legacy_peer_deps = get_legacy_peer_deps().await;
     log_verbose(&format!(
         "going to build deps for {root}, legacy_peer_deps: {legacy_peer_deps}"
     ));
@@ -353,7 +353,7 @@ impl Ruborist {
 
     async fn init_tree(&mut self) -> Result<Arc<Node>> {
         // load package.json
-        let pkg = load_package_json_from_path(&self.path)?;
+        let pkg = load_package_json_from_path(&self.path).await?;
 
         // create root node
         let root = Node::new_root(
@@ -367,7 +367,7 @@ impl Ruborist {
         self.init_workspaces(root.clone()).await?;
 
         // collect deps type
-        let legacy_peer_deps = get_legacy_peer_deps();
+        let legacy_peer_deps = get_legacy_peer_deps().await;
         let dep_types = if legacy_peer_deps {
             vec![
                 ("dependencies", EdgeType::Prod),
@@ -465,7 +465,7 @@ impl Ruborist {
             ));
 
             // Process workspace dependencies
-            let legacy_peer_deps = get_legacy_peer_deps();
+            let legacy_peer_deps = get_legacy_peer_deps().await;
             let dep_types = if legacy_peer_deps {
                 vec![
                     ("devDependencies", EdgeType::Dev),