fix: Audit 07/01 (#2038)

* Fix preloading.

* Fix dupes.

* Fix node pm.

* Fix ci panic.

* Bump version.

* Fix proto.

Author: milesj

.yarn/versions/d0a6b463.yml

@@ -0,0 +1,9 @@
+releases:
+  "@moonrepo/cli": patch
+  "@moonrepo/core-linux-arm64-gnu": patch
+  "@moonrepo/core-linux-arm64-musl": patch
+  "@moonrepo/core-linux-x64-gnu": patch
+  "@moonrepo/core-linux-x64-musl": patch
+  "@moonrepo/core-macos-arm64": patch
+  "@moonrepo/core-macos-x64": patch
+  "@moonrepo/core-windows-x64-msvc": patch

CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## Unreleased
+
+#### 🚀 Updates
+
+- More plugin pre-loading improvements.
+
+#### 🐞 Fixes
+
+- Potential fix for duplicate nodes in the action graph.
+- Potential fix for the node platform panicing for a missing package manager.
+- Potential fix for a fs rename error when installing proto.
+- Fixed a panic that would occur during `moon ci` job calculation.
+
 ## 1.38.1
 
 #### 🚀 Updates

crates/action-graph/src/action_graph_builder.rs

@@ -22,17 +22,18 @@ use petgraph::prelude::*;
 use rustc_hash::{FxHashMap, FxHashSet};
 use std::mem;
 use std::sync::Arc;
+use tokio::sync::RwLock;
 use tracing::{debug, instrument, trace};
 
 macro_rules! insert_node_or_exit {
     ($builder:ident, $node:expr) => {{
         let node = $node;
 
-        match $builder.get_index_from_node(&node) {
+        match $builder.get_index_from_node(&node).await {
             Some(index) => {
                 return Ok(Some(index));
             }
-            None => $builder.insert_node(node),
+            None => $builder.insert_node(node).await,
         }
     }};
 }
@@ -78,7 +79,7 @@ pub struct ActionGraphBuilder<'query> {
     all_query: Option<Criteria<'query>>,
     app_context: Arc<AppContext>,
     graph: DiGraph<ActionNode, ()>,
-    nodes: FxHashMap<ActionNode, NodeIndex>,
+    nodes: RwLock<FxHashMap<ActionNode, NodeIndex>>,
     options: ActionGraphBuilderOptions,
     platform_manager: Option<PlatformManager>,
     workspace_graph: Arc<WorkspaceGraph>,
@@ -106,7 +107,7 @@ impl<'query> ActionGraphBuilder<'query> {
             all_query: None,
             app_context,
             graph: DiGraph::new(),
-            nodes: FxHashMap::default(),
+            nodes: RwLock::new(FxHashMap::default()),
             options,
             passthrough_targets: FxHashSet::default(),
             platform_manager: None,
@@ -269,10 +270,10 @@ impl<'query> ActionGraphBuilder<'query> {
             return Ok(None);
         };
 
-        let mut edges = vec![
+        let mut edges = FxHashSet::from_iter([
             self.sync_workspace().await?,
             self.setup_toolchain_legacy(runtime).await?,
-        ];
+        ]);
 
         let platform_manager = match &self.platform_manager {
             Some(manager) => manager,
@@ -312,7 +313,7 @@ impl<'query> ActionGraphBuilder<'query> {
             );
         }
 
-        edges.push(self.setup_toolchain_legacy(&new_runtime).await?);
+        edges.insert(self.setup_toolchain_legacy(&new_runtime).await?);
 
         let index = insert_node_or_exit!(
             self,
@@ -329,7 +330,7 @@ impl<'query> ActionGraphBuilder<'query> {
             }
         );
 
-        self.link_optional_requirements(index, edges);
+        self.link_optional_requirements(index, edges.into_iter().collect());
 
         Ok(Some(index))
     }
@@ -833,7 +834,7 @@ impl<'query> ActionGraphBuilder<'query> {
         });
 
         // Check if the node exists to avoid all the overhead below
-        if let Some(index) = self.get_index_from_node(&node) {
+        if let Some(index) = self.get_index_from_node(&node).await {
             return Ok(Some(index));
         }
 
@@ -851,7 +852,7 @@ impl<'query> ActionGraphBuilder<'query> {
         }
 
         // Insert and then link edges
-        let index = self.insert_node(node);
+        let index = self.insert_node(node).await;
 
         if !task.deps.is_empty() {
             child_reqs.skip_affected = true;
@@ -1037,8 +1038,8 @@ impl<'query> ActionGraphBuilder<'query> {
 
     // PRIVATE
 
-    fn get_index_from_node(&self, node: &ActionNode) -> Option<NodeIndex> {
-        self.nodes.get(node).cloned()
+    async fn get_index_from_node(&self, node: &ActionNode) -> Option<NodeIndex> {
+        self.nodes.read().await.get(node).cloned()
     }
 
     fn link_first_requirement(&mut self, index: NodeIndex, edges: Vec<Option<NodeIndex>>) {
@@ -1069,11 +1070,13 @@ impl<'query> ActionGraphBuilder<'query> {
         }
     }
 
-    fn insert_node(&mut self, node: ActionNode) -> NodeIndex {
+    async fn insert_node(&mut self, node: ActionNode) -> NodeIndex {
+        let mut nodes = self.nodes.write().await;
+
         let label = node.label();
         let index = self.graph.add_node(node.clone());
 
-        self.nodes.insert(node, index);
+        nodes.insert(node, index);
 
         debug!(
             index = index.index(),

crates/app/src/commands/ci.rs

@@ -179,23 +179,37 @@ fn distribute_targets_across_jobs(
     let job_index = args.job.unwrap_or_default();
     let job_total = args.job_total.unwrap_or_default();
     let batch_size = targets.len().div_ceil(job_total);
-    let batched_targets;
 
     console.print_header("Distributing targets across jobs")?;
     console.write_line(format!("Job index: {job_index}"))?;
     console.write_line(format!("Job total: {job_total}"))?;
     console.write_line(format!("Batch size: {batch_size}"))?;
-    console.write_line("Batched targets:")?;
 
+    let (start, stop) =
+    // beginning
     if job_index == 0 {
-        batched_targets = targets[0..batch_size].to_vec();
-    } else if job_index == job_total - 1 {
-        batched_targets = targets[(batch_size * job_index)..].to_vec();
-    } else {
-        batched_targets =
-            targets[(batch_size * job_index)..(batch_size * (job_index + 1))].to_vec();
+        (0, batch_size)
+    }
+    // end
+    else if job_index == job_total - 1 {
+        ((batch_size * job_index), targets.len())
+    }
+    // middle
+    else {
+        ((batch_size * job_index), (batch_size * (job_index + 1)))
+    };
+
+    let mut batched_targets = vec![];
+
+    if targets.get(start).is_some() {
+        if targets.get(stop).is_some() {
+            batched_targets = targets[start..stop].to_vec();
+        } else {
+            batched_targets = targets[start..].to_vec();
+        }
     }
 
+    console.write_line("Batched targets:")?;
     console.print_targets(&batched_targets)?;
     console.print_footer()?;
 

crates/app/src/systems/analyze.rs

@@ -117,14 +117,23 @@ pub async fn install_proto(
     let result = download_release(
         &target_triple,
         PROTO_CLI_VERSION,
-        &proto_env.store.temp_dir,
+        proto_env.store.temp_dir.join("proto"),
         |_, _| {},
     )
     .await?;
 
     debug!("Unpacking archive and installing proto");
 
-    install_release(result, &install_dir, &proto_env.store.temp_dir, false)?;
+    install_release(
+        result,
+        install_dir,
+        proto_env
+            .store
+            .temp_dir
+            .join("proto")
+            .join(PROTO_CLI_VERSION),
+        false,
+    )?;
 
     debug!("Successfully installed proto!");
 

crates/config/src/toolchain_config.rs

@@ -239,6 +239,12 @@ impl ToolchainConfig {
             return true;
         }
 
+        for config in self.plugins.values() {
+            if config.version.is_some() {
+                return true;
+            }
+        }
+
         false
     }
 

crates/toolchain-plugin/src/toolchain_plugin.rs

@@ -3,7 +3,7 @@ use moon_feature_flags::glob_walk;
 use moon_pdk_api::*;
 use moon_plugin::{Plugin, PluginContainer, PluginId, PluginRegistration, PluginType};
 use proto_core::flow::install::InstallOptions;
-use proto_core::{PluginLocator, Tool, ToolSpec, UnresolvedVersionSpec};
+use proto_core::{PluginLocator, Tool, ToolSpec, UnresolvedVersionSpec, locate_tool};
 use starbase_utils::glob::GlobSet;
 use std::fmt;
 use std::ops::Deref;
@@ -433,10 +433,14 @@ impl ToolchainPlugin {
 
             // Pre-load the tool plugin so that task executions
             // avoid network race conditions and collisions
-            if let (Ok(loader), Some(locator)) =
-                (tool.proto.get_plugin_loader(), tool.locator.as_ref())
-            {
-                let _ = loader.load_plugin(&tool.id, locator).await;
+            if let Ok(loader) = tool.proto.get_plugin_loader() {
+                if let Some(locator) = tool
+                    .locator
+                    .clone()
+                    .or_else(|| locate_tool(&tool.id, &tool.proto).ok())
+                {
+                    let _ = loader.load_plugin(&tool.id, &locator).await;
+                }
             }
         }
 

legacy/node/tool/src/node_tool.rs

@@ -107,6 +107,13 @@ impl NodeTool {
             }
         };
 
+        // Temp fix
+        if node.bun.is_none() && node.npm.is_none() && node.pnpm.is_none() && node.yarn.is_none() {
+            node.npm = Some(
+                NpmTool::new(Arc::clone(&proto_env), Arc::clone(&console), &config.npm).await?,
+            );
+        }
+
         Ok(node)
     }