fix: Audit 06/01 (#2550)

* Updates.

* Polish.

* Add caching.

* Update.

* Rework.

* Fix cache strategy.

* Rework pid.

* Fix tests.

* Reenable locks.

* Rework loader.

* Update deps.

* Fixes.

* Add client cache.

* Start daemon earlier.

* Skip connect for non pipeline.

* Better server stuff.

* Polish.

* Debug docker.

* Fixes.

* Fixes.

Author: milesj

.github/workflows/rust.yml

@@ -143,7 +143,7 @@ jobs:
         if: ${{ vars.ENABLE_SCCACHE == 'true' }}
       # Fixes issues where proto can't find a version because nothing is pinned globally
       - run: cp .prototools ~/.proto/.prototools
-      - run: bash ./scripts/ci/warmPluginsCache.sh
+      # - run: bash ./scripts/ci/warmPluginsCache.sh
       - name: Build plugins
         run: just build-wasm
       - name: Run tests

CHANGELOG.md

@@ -4,9 +4,19 @@
 
 #### 🚀 Updates
 
+- Added in-memory caching to certain toolchain operations, primarily around locating executables.
+- Improved daemon startup performance by loading the workspace graph in the background after the
+  server is ready.
 - Updated plugin distribution to use ghcr.io instead of raw URLs, which should improve reliability
   and performance of plugin downloads.
 
+#### 🐞 Fixes
+
+- Reworked the daemon connect/ready logic to possibly fix some Windows connection issues.
+- Fixed an issue where the task dependency `cacheStrategy` inferrence was not working correctly
+  based on what experiments are enabled.
+- Fixed an issue where locks created at `.moon/cache/locks` would not be cleaned up.
+
 #### ⚙️ Internal
 
 - Updated proto to [v0.57.4](https://github.com/moonrepo/proto/releases/tag/v0.57.4) from 0.57.3.

Cargo.lock

@@ -21,7 +21,7 @@ pub async fn restart(session: MoonSession) -> AppResult {
 
     connector.stop_daemon().await?;
 
-    let pid = connector.start_daemon().await?;
+    let pid = connector.start_daemon(true).await?.unwrap_or_default();
     let message = format!("Daemon has been restarted with process ID {pid}");
 
     session.console.render(element! {

crates/app/src/commands/daemon/restart.rs

@@ -7,7 +7,9 @@ pub async fn server(session: MoonSession) -> AppResult {
     start_daemon_server(
         DaemonState {
             app_context: session.get_app_context().await?,
-            workspace_graph: session.get_workspace_graph().await?,
+            // Loaded in the background within the workspace watcher,
+            // otherwise it causes this command to block for too long
+            workspace_graph: Default::default(),
         },
         vec![Box::new(WorkspaceWatcher::new(session))],
     )

crates/app/src/commands/daemon/server.rs

@@ -16,7 +16,11 @@ pub async fn start(session: MoonSession) -> AppResult {
         return Ok(None);
     }
 
-    let pid = session.get_daemon_connector()?.start_daemon().await?;
+    let pid = session
+        .get_daemon_connector()?
+        .start_daemon(true)
+        .await?
+        .unwrap_or_default();
 
     session.console.render(element! {
         Container {

crates/app/src/commands/daemon/start.rs

@@ -20,7 +20,19 @@ pub async fn status(session: MoonSession) -> AppResult {
         return Ok(None);
     }
 
-    let status = connector.connect().await?.status().await?;
+    let Some(mut client) = connector.connect().await? else {
+        session.console.render(element! {
+            Container {
+                Notice(variant: Variant::Caution) {
+                    StyledText(content: "Unable to connect to the daemon")
+                }
+            }
+        })?;
+
+        return Ok(None);
+    };
+
+    let status = client.status().await?;
 
     session.console.render(element! {
         Container {

crates/app/src/commands/daemon/status.rs

@@ -7,7 +7,7 @@ use moon_api::Launchpad;
 use moon_app_context::AppContext;
 use moon_cache::CacheEngine;
 use moon_codegen::CodeGenerator;
-use moon_common::is_formatted_output;
+use moon_common::{is_docker, is_formatted_output, is_remote};
 use moon_config::{ExtensionsConfig, InheritedTasksManager, ToolchainsConfig, WorkspaceConfig};
 use moon_config_loader::ConfigLoader;
 use moon_console::{Console, MoonReporter, create_console_theme};
@@ -46,6 +46,7 @@ pub struct MoonSession {
 
     // Lazy components
     pub(crate) cache_engine: OnceLock<Arc<CacheEngine>>,
+    // pub(crate) daemon_client: OnceCell<Option<DaemonClient>>,
     pub(crate) extension_registry: OnceCell<Arc<ExtensionRegistry>>,
     pub(crate) project_graph: OnceLock<Arc<ProjectGraph>>,
     pub(crate) task_graph: OnceLock<Arc<TaskGraph>>,
@@ -75,6 +76,7 @@ impl MoonSession {
             config_dir: PathBuf::new(),
             config_loader: ConfigLoader::default(),
             console: Console::new(cli.quiet || is_formatted_output()),
+            // daemon_client: OnceCell::new(),
             extensions_config: Arc::new(ExtensionsConfig::default()),
             extension_registry: OnceCell::new(),
             moon_env: Arc::new(MoonEnvironment::default()),
@@ -126,13 +128,18 @@ impl MoonSession {
     }
 
     pub async fn connect_to_daemon(&self) -> miette::Result<Option<DaemonClient>> {
-        if !self.workspace_config.daemon {
+        if !self.is_daemon_allowed() {
             return Ok(None);
         }
 
-        let client = self.get_daemon_connector()?.connect().await?;
+        // let client = self
+        //     .daemon_client
+        //     .get_or_try_init(async move || self.get_daemon_connector()?.connect().await)
+        //     .await?;
 
-        Ok(Some(client))
+        // Ok(client.clone())
+
+        self.get_daemon_connector()?.connect().await
     }
 
     pub async fn create_workspace_graph_context(&self) -> miette::Result<WorkspaceBuilderContext> {
@@ -271,6 +278,21 @@ impl MoonSession {
             .map(Arc::clone)
     }
 
+    pub fn is_daemon_allowed(&self) -> bool {
+        self.workspace_config.daemon && self.is_pipeline_command() && !is_docker()
+    }
+
+    pub fn is_pipeline_command(&self) -> bool {
+        matches!(
+            self.cli.command,
+            Commands::Ci(_)
+                | Commands::Check(_)
+                | Commands::Exec(_)
+                | Commands::Run(_)
+                | Commands::Sync { .. }
+        )
+    }
+
     pub fn is_telemetry_enabled(&self) -> bool {
         self.workspace_config.telemetry
     }
@@ -389,39 +411,37 @@ impl AppSession for MoonSession {
 
         analyze::extract_repo_info(&vcs).await?;
 
-        // Preload
+        // Preload components
         if self.requires_workspace_configured() {
             let _ = self.get_cache_engine()?;
         }
 
+        // Start the daemon in the background
+        if self.is_daemon_allowed() {
+            self.get_daemon_connector()?.start_daemon(false).await?;
+        }
+
         Ok(None)
     }
 
     async fn execute(&mut self) -> AppResult {
-        let is_exec_command = matches!(
-            self.cli.command,
-            Commands::Ci(_)
-                | Commands::Check(_)
-                | Commands::Exec(_)
-                | Commands::Run(_)
-                | Commands::Sync { .. }
-        );
-
         // Check for a new version and log to the console
-        if self.is_telemetry_enabled() && is_exec_command {
+        if self.is_telemetry_enabled() && self.is_pipeline_command() {
             execute::check_for_new_version(&self, &self.toolchains_config.moon.manifest_url)
                 .await?;
         }
 
-        // Start the daemon in the background
-        if self.workspace_config.daemon && is_exec_command {
-            self.get_daemon_connector()?.start_daemon().await?;
-        }
-
         Ok(None)
     }
 
     async fn shutdown(&mut self) -> AppResult {
+        // Stop the daemon if it's running
+        if is_remote()
+            && let Ok(Some(mut daemon)) = self.connect_to_daemon().await
+        {
+            daemon.stop().await?;
+        }
+
         // Ensure all child processes have finished running
         ProcessRegistry::instance()
             .wait_for_running_to_shutdown()

crates/app/src/session.rs

@@ -42,6 +42,10 @@ impl WorkspaceWatcher {
 
 #[async_trait]
 impl FileWatcher<AtomicDaemonState> for WorkspaceWatcher {
+    async fn on_init(&mut self, _state: AtomicDaemonState) -> miette::Result<()> {
+        Ok(())
+    }
+
     async fn on_file_event(
         &mut self,
         state: AtomicDaemonState,
@@ -51,8 +55,8 @@ impl FileWatcher<AtomicDaemonState> for WorkspaceWatcher {
             return Ok(());
         }
 
-        // Handle root `.prototools` changes
-        if event.path.as_str() == ".prototools" {
+        // Handle `.prototools` changes
+        if event.path.ends_with(".prototools") {
             self.reset_proto(&state).await?;
 
             return Ok(());

crates/app/src/watchers/workspace_watcher.rs

@@ -120,7 +120,8 @@ impl CacheEngine {
             bytes_saved: 0,
         };
 
-        let mut dirs = vec![&self.hash.hashes_dir, &self.hash.outputs_dir];
+        let locks_dir = self.cache_dir.join("locks");
+        let mut dirs = vec![&self.hash.hashes_dir, &self.hash.outputs_dir, &locks_dir];
 
         if all {
             dirs.push(&self.state.states_dir);
@@ -156,7 +157,8 @@ impl CacheEngine {
             name.push_str(".lock");
         }
 
-        let guard = fs::lock_file(self.cache_dir.join("locks").join(name))?;
+        let mut guard = fs::lock_file(self.cache_dir.join("locks").join(name))?;
+        guard.remove_on_unlock();
 
         Ok(guard)
     }