Merge branch 'worktree-issue-2615' of github.com:moonrepo/moon into worktree-issue-2615

* 'worktree-issue-2615' of github.com:moonrepo/moon:
  fix: Propagate a failing task's exit code instead of collapsing it to 1

Author: milesj

crates/app/src/helpers.rs

@@ -10,12 +10,39 @@ use moon_action_pipeline::ActionPipeline;
 use moon_common::Id;
 use moon_console::ui::{OwnedOrShared, Progress, ProgressDisplay, ProgressReporter};
 use moon_console::{Console, ConsoleError, Level};
+use moon_process::ProcessError;
 use serde::Serialize;
 use starbase_utils::{fs, json, toml, yaml};
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
+/// Walk an error chain and return the underlying process exit code, if the
+/// failure originated from a task/process that exited with a non-zero status.
+/// Signals, aborts, and codes that can't be represented as a `u8` yield `None`,
+/// so the caller can fall back to a generic exit code. This lets the pipeline's
+/// bubbled-up error propagate the task's real exit code, which `starbase` would
+/// otherwise collapse to 1.
+pub fn extract_task_exit_code(report: &miette::Report) -> Option<u8> {
+    report
+        .chain()
+        .find_map(|error| {
+            // The process error is usually boxed within its parent (e.g.
+            // `TaskRunnerError` wraps `Box<ProcessError>`), which surfaces as a
+            // `Box<ProcessError>` in the chain, so check both shapes.
+            error
+                .downcast_ref::<ProcessError>()
+                .or_else(|| {
+                    error
+                        .downcast_ref::<Box<ProcessError>>()
+                        .map(|boxed| boxed.as_ref())
+                })
+                .and_then(ProcessError::get_exit_code)
+        })
+        .and_then(|code| u8::try_from(code).ok())
+        .filter(|code| *code != 0)
+}
+
 pub fn serialize_config_based_on_extension(
     plugin_id: &Id,
     path: &Path,

crates/app/src/lib.rs

@@ -13,4 +13,5 @@ pub mod watchers;
 
 pub use app::*;
 pub use app_error::*;
+pub use helpers::extract_task_exit_code;
 pub use session::*;

crates/app/tests/helpers_test.rs

@@ -0,0 +1,78 @@
+use miette::Diagnostic;
+use moon_app::extract_task_exit_code;
+use moon_process::ProcessError;
+use thiserror::Error;
+
+// Mirrors how `TaskRunnerError::RunFailed` wraps `Box<ProcessError>`, which
+// surfaces the process error as a `Box<ProcessError>` in the error chain.
+#[derive(Debug, Diagnostic, Error)]
+#[error("task failed to run")]
+struct WrappedError {
+    #[source]
+    error: Box<ProcessError>,
+}
+
+fn exit_nonzero(code: Option<i32>) -> ProcessError {
+    ProcessError::ExitNonZero {
+        bin: "bash".into(),
+        status: "exit code".into(),
+        code,
+    }
+}
+
+fn wrapped(code: Option<i32>) -> miette::Report {
+    WrappedError {
+        error: Box::new(exit_nonzero(code)),
+    }
+    .into()
+}
+
+mod extract_task_exit_code {
+    use super::*;
+
+    #[test]
+    fn extracts_from_boxed_process_error() {
+        assert_eq!(extract_task_exit_code(&wrapped(Some(80))), Some(80));
+    }
+
+    #[test]
+    fn extracts_from_bare_process_error() {
+        let report: miette::Report = exit_nonzero(Some(2)).into();
+
+        assert_eq!(extract_task_exit_code(&report), Some(2));
+    }
+
+    #[test]
+    fn propagates_codes_above_127() {
+        assert_eq!(extract_task_exit_code(&wrapped(Some(200))), Some(200));
+    }
+
+    #[test]
+    fn none_for_signal_without_code() {
+        assert_eq!(extract_task_exit_code(&wrapped(None)), None);
+    }
+
+    #[test]
+    fn none_for_injected_abort_code() {
+        // Aborts before a process spawns are recorded with an exit code of -1
+        assert_eq!(extract_task_exit_code(&wrapped(Some(-1))), None);
+    }
+
+    #[test]
+    fn none_for_zero_code() {
+        assert_eq!(extract_task_exit_code(&wrapped(Some(0))), None);
+    }
+
+    #[test]
+    fn none_for_out_of_u8_range() {
+        // e.g. large Windows exit codes that can't map to a u8
+        assert_eq!(extract_task_exit_code(&wrapped(Some(300))), None);
+    }
+
+    #[test]
+    fn none_for_non_process_error() {
+        let report = miette::miette!("something else went wrong");
+
+        assert_eq!(extract_task_exit_code(&report), None);
+    }
+}