improve code

Author: branchseer

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

@@ -1,7 +1,7 @@
 pub mod fingerprint;
 pub mod spawn;
 
-use std::{process::ExitCode, sync::Arc};
+use std::sync::Arc;
 
 use futures_util::FutureExt;
 use petgraph::{algo::toposort, graph::DiGraph};
@@ -21,7 +21,7 @@ use super::{
         CacheDisabledReason, CacheStatus, ExecutionEvent, ExecutionEventKind, ExecutionId,
         ExecutionItemDisplay, OutputKind,
     },
-    reporter::Reporter,
+    reporter::{ExitStatus, Reporter},
 };
 use crate::{Session, session::execute::spawn::SpawnTrackResult};
 
@@ -330,12 +330,15 @@ impl ExecutionContext<'_> {
 impl<'a, CustomSubcommand> Session<'a, CustomSubcommand> {
     /// Execute an execution plan, reporting events to the provided reporter.
     ///
-    /// Returns Ok(()) on success, or Err(ExitCode) on failure.
+    /// Returns Err(ExitStatus) to suggest the caller to abort and exit the process with the given exit status.
+    ///
+    /// The return type isn't just ExitStatus because we want to distinguish between normal successful execution,
+    /// and execution that failed and needs to exit with a specific code which can be zero.
     pub async fn execute(
         &self,
         plan: ExecutionPlan,
         mut reporter: Box<dyn Reporter>,
-    ) -> Result<(), ExitCode> {
+    ) -> Result<(), ExitStatus> {
         let mut execution_context = ExecutionContext {
             event_handler: &mut *reporter,
             current_execution_id: ExecutionId::zero(),

crates/vite_task/src/session/reporter.rs

@@ -3,7 +3,6 @@
 use std::{
     collections::HashSet,
     io::Write,
-    process::ExitCode,
     sync::{Arc, LazyLock},
     time::Duration,
 };
@@ -29,14 +28,23 @@ impl<T: owo_colors::OwoColorize> ColorizeExt for T {
     }
 }
 
+/// Exit status code for task execution
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct ExitStatus(pub u8);
+
+impl ExitStatus {
+    pub const FAILURE: Self = Self(1);
+    pub const SUCCESS: Self = Self(0);
+}
+
 /// Trait for handling execution events and reporting results
 pub trait Reporter {
     /// Handle an execution event (start, output, error, finish)
     fn handle_event(&mut self, event: ExecutionEvent);
 
     /// Called after execution completes (whether successful or not)
-    /// Returns Ok(()) on success, or Err(ExitCode) on failure
-    fn post_execution(self: Box<Self>) -> Result<(), ExitCode>;
+    /// Returns Ok(()) on success, or Err(ExitStatus) on failure
+    fn post_execution(self: Box<Self>) -> Result<(), ExitStatus>;
 }
 
 const COMMAND_STYLE: Style = Style::new().cyan();
@@ -487,7 +495,7 @@ impl<W: Write> Reporter for LabeledReporter<W> {
         }
     }
 
-    fn post_execution(mut self: Box<Self>) -> Result<(), ExitCode> {
+    fn post_execution(mut self: Box<Self>) -> Result<(), ExitStatus> {
         // Check if execution was aborted due to error
         if let Some(error_msg) = &self.first_error {
             // Print separator
@@ -514,7 +522,7 @@ impl<W: Write> Reporter for LabeledReporter<W> {
                     .style(Style::new().bright_black())
             );
 
-            return Err(ExitCode::FAILURE);
+            return Err(ExitStatus::FAILURE);
         }
 
         // No errors - print summary if not hidden
@@ -538,14 +546,13 @@ impl<W: Write> Reporter for LabeledReporter<W> {
             .filter(|&status| status != 0)
             .collect();
 
-        match failed_exit_codes.len() {
-            0 => Ok(()),
-            1 => {
+        match failed_exit_codes.as_slice() {
+            [] => Ok(()),
+            [code] => {
                 // Return the single failed task's exit code (clamped to u8 range)
-                let code = failed_exit_codes[0];
-                Err(ExitCode::from(code.clamp(1, 255) as u8))
+                Err(ExitStatus((*code).clamp(1, 255) as u8))
             }
-            _ => Err(ExitCode::FAILURE),
+            _ => Err(ExitStatus::FAILURE),
         }
     }
 }

crates/vite_task_bin/src/main.rs

@@ -1,21 +1,24 @@
 use std::{env, process::ExitCode, sync::Arc};
 
 use vite_path::{AbsolutePath, current_dir};
-use vite_task::{CLIArgs, Session, session::reporter::LabeledReporter};
+use vite_task::{
+    CLIArgs, Session,
+    session::reporter::{ExitStatus, LabeledReporter},
+};
 use vite_task_bin::{CustomTaskSubcommand, NonTaskSubcommand, OwnedSessionCallbacks};
 
 #[tokio::main]
 async fn main() -> ExitCode {
     match run().await {
-        Ok(exit_code) => exit_code,
+        Ok(exit_status) => exit_status.0.into(),
         Err(err) => {
             eprintln!("Error: {err}");
             ExitCode::FAILURE
         }
     }
 }
 
-async fn run() -> anyhow::Result<ExitCode> {
+async fn run() -> anyhow::Result<ExitStatus> {
     let cwd: Arc<AbsolutePath> = current_dir()?.into();
     // Parse the CLI arguments and see if they are for vite-task or not
     let args = match CLIArgs::<CustomTaskSubcommand, NonTaskSubcommand>::try_parse_from(env::args())
@@ -30,7 +33,7 @@ async fn run() -> anyhow::Result<ExitCode> {
         CLIArgs::NonTask(NonTaskSubcommand::Version) => {
             // Non-task subcommands are not handled by vite-task's session.
             println!("{}", env!("CARGO_PKG_VERSION"));
-            return Ok(ExitCode::SUCCESS);
+            return Ok(ExitStatus::SUCCESS);
         }
     };
 
@@ -40,5 +43,5 @@ async fn run() -> anyhow::Result<ExitCode> {
 
     // Create reporter and execute
     let reporter = LabeledReporter::new(std::io::stdout(), session.workspace_path());
-    Ok(session.execute(plan, Box::new(reporter)).await.err().unwrap_or(ExitCode::SUCCESS))
+    Ok(session.execute(plan, Box::new(reporter)).await.err().unwrap_or(ExitStatus::SUCCESS))
 }