feat: disable cache if exit with non-zero (#102)

# Enhanced Task Caching with Cache Update Status Tracking

### TL;DR

Added detailed cache update status tracking to the task execution system to provide better visibility into caching operations.

### What changed?

- Added new enums to track cache update status:
  - `CacheUpdateStatus`: Tracks whether the cache was updated or not
  - `CacheNotUpdatedReason`: Provides specific reasons why a cache wasn't updated (cache hit, disabled caching, non-zero exit status)
- Modified the `ExecutionEventKind::Finish` event to include the new `cache_update_status` field
- Updated execution logic to properly set cache update status in different scenarios:
  - When replaying from cache
  - When caching is disabled
  - When execution fails with non-zero status
  - When cache is successfully updated

### How to test?

Run tasks with different caching scenarios and verify the correct cache update status is reported:
1. Run a cached task to see `CacheHit` status
2. Run a task with caching disabled to see `CacheDisabled` status
3. Run a failing task to see `NonZeroExitStatus` status
4. Run a successful task with caching enabled to see `Updated` status

### Why make this change?

This change provides more detailed information about cache operations, making it easier to understand why a task's cache was or wasn't updated. This visibility helps with debugging cache-related issues and provides better insights into the task execution system's behavior.

Author: branchseer

crates/vite_task/src/session/event.rs

@@ -19,6 +19,24 @@ pub enum CacheDisabledReason {
     CycleDetected,
 }
 
+#[derive(Debug)]
+pub enum CacheNotUpdatedReason {
+    /// Cache was hit - task was replayed from cache, no update needed
+    CacheHit,
+    /// Caching was disabled for this task
+    CacheDisabled,
+    /// Execution exited with non-zero status
+    NonZeroExitStatus,
+}
+
+#[derive(Debug)]
+pub enum CacheUpdateStatus {
+    /// Cache was successfully updated with new fingerprint and outputs
+    Updated,
+    /// Cache was not updated (with reason)
+    NotUpdated(CacheNotUpdatedReason),
+}
+
 #[derive(Debug)]
 pub enum CacheStatus {
     Disabled(CacheDisabledReason),
@@ -50,5 +68,5 @@ pub enum ExecutionEventKind {
     Start { display: Option<ExecutionItemDisplay>, cache_status: CacheStatus },
     Output { kind: OutputKind, content: BString },
     Error { message: String },
-    Finish { status: Option<i32> },
+    Finish { status: Option<i32>, cache_update_status: CacheUpdateStatus },
 }

crates/vite_task/src/session/execute/mod.rs

@@ -18,8 +18,8 @@ use self::{
 use super::{
     cache::{CommandCacheValue, ExecutionCache},
     event::{
-        CacheDisabledReason, CacheStatus, ExecutionEvent, ExecutionEventKind, ExecutionId,
-        ExecutionItemDisplay, OutputKind,
+        CacheDisabledReason, CacheNotUpdatedReason, CacheStatus, CacheUpdateStatus, ExecutionEvent,
+        ExecutionEventKind, ExecutionId, ExecutionItemDisplay, OutputKind,
     },
     reporter::{ExitStatus, Reporter},
 };
@@ -153,10 +153,15 @@ impl ExecutionContext<'_> {
                     },
                 });
 
-                // Emit Finish WITHOUT cache_status (already in Start event)
+                // Emit Finish with CacheDisabled status (in-process executions don't cache)
                 self.event_handler.handle_event(ExecutionEvent {
                     execution_id,
-                    kind: ExecutionEventKind::Finish { status: Some(0) },
+                    kind: ExecutionEventKind::Finish {
+                        status: Some(0),
+                        cache_update_status: CacheUpdateStatus::NotUpdated(
+                            CacheNotUpdatedReason::CacheDisabled,
+                        ),
+                    },
                 });
             }
             LeafExecutionKind::Spawn(spawn_execution) => {
@@ -228,10 +233,15 @@ impl ExecutionContext<'_> {
                     },
                 });
             }
-            // Emit Finish without cache_status (status already in Start event)
+            // Emit Finish with CacheHit status (no cache update needed)
             self.event_handler.handle_event(ExecutionEvent {
                 execution_id,
-                kind: ExecutionEventKind::Finish { status: Some(0) },
+                kind: ExecutionEventKind::Finish {
+                    status: Some(0),
+                    cache_update_status: CacheUpdateStatus::NotUpdated(
+                        CacheNotUpdatedReason::CacheHit,
+                    ),
+                },
             });
             return Ok(());
         }
@@ -276,51 +286,62 @@ impl ExecutionContext<'_> {
             }
         };
 
-        // 5. Update cache if successful
-        //    Only update cache if: (a) tracking was enabled, and (b) execution succeeded
-        if let Some((track_result, cache_metadata)) = track_result_with_cache_metadata
-            && result.exit_status.success()
+        // 5. Update cache if successful and determine cache update status
+        let cache_update_status = if let Some((track_result, cache_metadata)) =
+            track_result_with_cache_metadata
         {
-            let fingerprint_ignores =
-                cache_metadata.spawn_fingerprint.fingerprint_ignores().map(|v| v.as_slice());
-            match PostRunFingerprint::create(
-                &track_result.path_reads,
-                &*self.cache_base_path,
-                fingerprint_ignores,
-            ) {
-                Ok(post_run_fingerprint) => {
-                    let cache_value = CommandCacheValue {
-                        post_run_fingerprint,
-                        std_outputs: track_result.std_outputs.clone().into(),
-                        duration: result.duration,
-                    };
-                    if let Err(err) = self.cache.update(cache_metadata, cache_value).await {
+            if result.exit_status.success() {
+                // Execution succeeded, attempt cache update
+                let fingerprint_ignores =
+                    cache_metadata.spawn_fingerprint.fingerprint_ignores().map(|v| v.as_slice());
+                match PostRunFingerprint::create(
+                    &track_result.path_reads,
+                    &*self.cache_base_path,
+                    fingerprint_ignores,
+                ) {
+                    Ok(post_run_fingerprint) => {
+                        let cache_value = CommandCacheValue {
+                            post_run_fingerprint,
+                            std_outputs: track_result.std_outputs.clone().into(),
+                            duration: result.duration,
+                        };
+                        if let Err(err) = self.cache.update(cache_metadata, cache_value).await {
+                            self.event_handler.handle_event(ExecutionEvent {
+                                execution_id,
+                                kind: ExecutionEventKind::Error {
+                                    message: format!("Failed to update cache: {err}"),
+                                },
+                            });
+                            return Err(ExecutionAborted);
+                        }
+                        CacheUpdateStatus::Updated
+                    }
+                    Err(err) => {
                         self.event_handler.handle_event(ExecutionEvent {
                             execution_id,
                             kind: ExecutionEventKind::Error {
-                                message: format!("Failed to update cache: {err}"),
+                                message: format!("Failed to create post-run fingerprint: {err}"),
                             },
                         });
                         return Err(ExecutionAborted);
                     }
                 }
-                Err(err) => {
-                    self.event_handler.handle_event(ExecutionEvent {
-                        execution_id,
-                        kind: ExecutionEventKind::Error {
-                            message: format!("Failed to create post-run fingerprint: {err}"),
-                        },
-                    });
-                    return Err(ExecutionAborted);
-                }
+            } else {
+                // Execution failed with non-zero exit status, don't update cache
+                CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::NonZeroExitStatus)
             }
-        }
+        } else {
+            // Caching was disabled for this task
+            CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::CacheDisabled)
+        };
 
-        // 6. Emit finish WITHOUT cache_status
-        //    Cache status was already emitted in Start event
+        // 6. Emit finish with cache_update_status
         self.event_handler.handle_event(ExecutionEvent {
             execution_id,
-            kind: ExecutionEventKind::Finish { status: result.exit_status.code() },
+            kind: ExecutionEventKind::Finish {
+                status: result.exit_status.code(),
+                cache_update_status,
+            },
         });
 
         Ok(())

crates/vite_task/src/session/reporter.rs

@@ -486,7 +486,7 @@ impl<W: Write> Reporter for LabeledReporter<W> {
             ExecutionEventKind::Error { message } => {
                 self.handle_error(event.execution_id, message);
             }
-            ExecutionEventKind::Finish { status } => {
+            ExecutionEventKind::Finish { status, cache_update_status: _ } => {
                 self.handle_finish(event.execution_id, status);
             }
         }

crates/vite_task_bin/tests/e2e_snapshots/fixtures/builtin-non-zero-exit/bad.js

@@ -0,0 +1 @@
+debugger;

crates/vite_task_bin/tests/e2e_snapshots/fixtures/builtin-non-zero-exit/package.json

@@ -0,0 +1,3 @@
+{
+  "name": "builtin-non-zero-exit-test"
+}

crates/vite_task_bin/tests/e2e_snapshots/fixtures/builtin-non-zero-exit/snapshots.toml

@@ -0,0 +1,6 @@
+[[e2e]]
+name = "builtin command with non-zero exit does not show cache not updated"
+steps = [
+  "vite lint -D no-debugger",
+  "vite lint -D no-debugger",
+]

crates/vite_task_bin/tests/e2e_snapshots/fixtures/builtin-non-zero-exit/snapshots/builtin command with non-zero exit does not show cache not updated.snap

@@ -0,0 +1,29 @@
+---
+source: crates/vite_task_bin/tests/e2e_snapshots/main.rs
+expression: e2e_outputs
+input_file: crates/vite_task_bin/tests/e2e_snapshots/fixtures/builtin-non-zero-exit
+---
+[1]> vite lint -D no-debugger
+
+  x eslint(no-debugger): `debugger` statement is not allowed
+   ,-[bad.js:1:1]
+ 1 | debugger;
+   : ^^^^^^^^^
+   `----
+  help: Remove the debugger statement
+
+Found 0 warnings and 1 error.
+Finished in <duration> on 1 file with 90 rules using <n> threads.
+
+
+[1]> vite lint -D no-debugger
+
+  x eslint(no-debugger): `debugger` statement is not allowed
+   ,-[bad.js:1:1]
+ 1 | debugger;
+   : ^^^^^^^^^
+   `----
+  help: Remove the debugger statement
+
+Found 0 warnings and 1 error.
+Finished in <duration> on 1 file with 90 rules using <n> threads.