feat: add pipefail handling and set command (#163)

Author: wolfv

src/shell/commands/mod.rs

@@ -12,6 +12,7 @@ mod head;
 mod mkdir;
 mod pwd;
 mod rm;
+mod set;
 mod shopt;
 mod sleep;
 mod unset;
@@ -77,6 +78,10 @@ pub fn builtin_commands() -> HashMap<String, Rc<dyn ShellCommand>> {
       "rm".to_string(),
       Rc::new(rm::RmCommand) as Rc<dyn ShellCommand>,
     ),
+    (
+      "set".to_string(),
+      Rc::new(set::SetCommand) as Rc<dyn ShellCommand>,
+    ),
     (
       "shopt".to_string(),
       Rc::new(shopt::ShoptCommand) as Rc<dyn ShellCommand>,

src/shell/commands/set.rs

@@ -0,0 +1,63 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+
+use futures::future::LocalBoxFuture;
+
+use crate::shell::types::EnvChange;
+use crate::shell::types::ExecuteResult;
+use crate::shell::types::ShellOptions;
+
+use super::ShellCommand;
+use super::ShellCommandContext;
+
+pub struct SetCommand;
+
+impl ShellCommand for SetCommand {
+  fn execute(
+    &self,
+    mut context: ShellCommandContext,
+  ) -> LocalBoxFuture<'static, ExecuteResult> {
+    let result = execute_set(&mut context);
+    Box::pin(futures::future::ready(result))
+  }
+}
+
+fn execute_set(context: &mut ShellCommandContext) -> ExecuteResult {
+  let mut changes = Vec::new();
+  let args: Vec<String> = context
+    .args
+    .iter()
+    .filter_map(|a| a.to_str().map(|s| s.to_string()))
+    .collect();
+
+  let mut i = 0;
+  while i < args.len() {
+    let arg = &args[i];
+    if arg == "-o" || arg == "+o" {
+      let enable = arg == "-o";
+      if i + 1 < args.len() {
+        let option_name = &args[i + 1];
+        match option_name.as_str() {
+          "pipefail" => {
+            changes.push(EnvChange::SetOption(ShellOptions::PIPEFAIL, enable));
+          }
+          _ => {
+            let _ = context
+              .stderr
+              .write_line(&format!("set: unknown option: {}", option_name));
+            return ExecuteResult::from_exit_code(1);
+          }
+        }
+        i += 2;
+      } else {
+        // No option name provided - in bash this would list options
+        // For now, just return success
+        i += 1;
+      }
+    } else {
+      // Unknown argument
+      i += 1;
+    }
+  }
+
+  ExecuteResult::Continue(0, changes, Vec::new())
+}

src/shell/commands/shopt.rs

@@ -67,7 +67,7 @@ impl ShellCommand for ShoptCommand {
 
           let changes: Vec<EnvChange> = options_to_change
             .into_iter()
-            .map(|opt| EnvChange::SetShellOption(opt, enabled))
+            .map(|opt| EnvChange::SetOption(opt, enabled))
             .collect();
 
           ExecuteResult::Continue(0, changes, Vec::new())
@@ -77,7 +77,7 @@ impl ShellCommand for ShoptCommand {
           let current_options = context.state.shell_options();
 
           if options_to_change.is_empty() {
-            // print all options
+            // print all options (alphabetical order)
             let _ = context.stdout.write_line(&format!(
               "failglob\t{}",
               if current_options.contains(ShellOptions::FAILGLOB) {

src/shell/execute.rs

@@ -576,20 +576,33 @@ async fn execute_pipe_sequence(
   let output_handle = tokio::task::spawn_blocking(|| {
     last_output.unwrap().pipe_to_sender(stdout).unwrap();
   });
-  let mut results = futures::future::join_all(wait_tasks).await;
+  let results = futures::future::join_all(wait_tasks).await;
   output_handle.await.unwrap();
-  let last_result = results.pop().unwrap();
-  let all_handles = results.into_iter().flat_map(|r| r.into_handles());
-  match last_result {
-    ExecuteResult::Exit(code, mut handles) => {
-      handles.extend(all_handles);
-      ExecuteResult::Continue(code, Vec::new(), handles)
-    }
-    ExecuteResult::Continue(code, _, mut handles) => {
-      handles.extend(all_handles);
-      ExecuteResult::Continue(code, Vec::new(), handles)
+
+  // Determine exit code based on pipefail option
+  let exit_code = if state.shell_options().contains(ShellOptions::PIPEFAIL) {
+    // With pipefail: return the rightmost non-zero exit code, or 0 if all succeeded
+    results
+      .iter()
+      .rev()
+      .find_map(|r| {
+        let code = match r {
+          ExecuteResult::Exit(c, _) => *c,
+          ExecuteResult::Continue(c, _, _) => *c,
+        };
+        if code != 0 { Some(code) } else { None }
+      })
+      .unwrap_or(0)
+  } else {
+    // Without pipefail: return the last command's exit code
+    match results.last().unwrap() {
+      ExecuteResult::Exit(code, _) => *code,
+      ExecuteResult::Continue(code, _, _) => *code,
     }
-  }
+  };
+
+  let all_handles = results.into_iter().flat_map(|r| r.into_handles());
+  ExecuteResult::Continue(exit_code, Vec::new(), all_handles.collect())
 }
 
 async fn execute_subshell(

src/shell/types.rs

@@ -25,7 +25,7 @@ use super::commands::ShellCommand;
 use super::commands::builtin_commands;
 
 bitflags! {
-  /// Shell options that can be set via `shopt`.
+  /// Shell options that can be set via `shopt` or `set -o`.
   #[derive(Debug, Clone, Copy, PartialEq, Eq)]
   pub struct ShellOptions: u32 {
     /// When set, a glob pattern that matches no files expands to nothing
@@ -35,6 +35,9 @@ bitflags! {
     /// This is the default for deno_task_shell (differs from bash).
     /// When unset, unmatched globs are passed through literally (bash default).
     const FAILGLOB = 1 << 1;
+    /// When set, pipeline exit code is the rightmost non-zero exit code.
+    /// Set via `set -o pipefail`.
+    const PIPEFAIL = 1 << 2;
   }
 }
 
@@ -79,7 +82,7 @@ pub struct ShellState {
   kill_signal: KillSignal,
   process_tracker: ChildProcessTracker,
   tree_exit_code_cell: TreeExitCodeCell,
-  /// Shell options set via `shopt`.
+  /// Shell options set via `shopt` or `set -o`.
   shell_options: ShellOptions,
 }
 
@@ -163,7 +166,7 @@ impl ShellState {
       EnvChange::Cd(new_dir) => {
         self.set_cwd(new_dir.clone());
       }
-      EnvChange::SetShellOption(option, enabled) => {
+      EnvChange::SetOption(option, enabled) => {
         self.set_shell_option(*option, *enabled);
       }
     }
@@ -262,8 +265,8 @@ pub enum EnvChange {
   // `unset ENV_VAR`
   UnsetVar(OsString),
   Cd(PathBuf),
-  // `shopt -s/-u option`
-  SetShellOption(ShellOptions, bool),
+  // `shopt -s/-u option` or `set -o option`
+  SetOption(ShellOptions, bool),
 }
 
 pub type FutureExecuteResult = LocalBoxFuture<'static, ExecuteResult>;

tests/integration_test.rs

@@ -1827,3 +1827,61 @@ async fn shopt_failglob() {
     .run()
     .await;
 }
+
+#[tokio::test]
+async fn pipefail_option() {
+  // Without pipefail: exit code is from last command (0)
+  TestBuilder::new()
+    .command("sh -c 'exit 1' | true")
+    .assert_exit_code(0)
+    .run()
+    .await;
+
+  // With pipefail: exit code is rightmost non-zero (1)
+  TestBuilder::new()
+    .command("set -o pipefail && sh -c 'exit 1' | true")
+    .assert_exit_code(1)
+    .run()
+    .await;
+
+  // Multiple failures - should return rightmost non-zero
+  TestBuilder::new()
+    .command("set -o pipefail && sh -c 'exit 2' | sh -c 'exit 3' | true")
+    .assert_exit_code(3)
+    .run()
+    .await;
+
+  // All succeed - should return 0
+  TestBuilder::new()
+    .command("set -o pipefail && true | true | true")
+    .assert_exit_code(0)
+    .run()
+    .await;
+
+  // Disable pipefail with +o
+  TestBuilder::new()
+    .command("set -o pipefail && set +o pipefail && sh -c 'exit 1' | true")
+    .assert_exit_code(0)
+    .run()
+    .await;
+
+  // invalid option name
+  TestBuilder::new()
+    .command("set -o invalidopt")
+    .assert_stderr("set: unknown option: invalidopt\n")
+    .assert_exit_code(1)
+    .run()
+    .await;
+}
+
+#[tokio::test]
+#[cfg(unix)]
+async fn pipefail_with_sigpipe() {
+  // With pipefail and SIGPIPE: should return 141 (128 + 13)
+  TestBuilder::new()
+    .command("set -o pipefail && yes | head -n 1")
+    .assert_stdout("y\n")
+    .assert_exit_code(141)
+    .run()
+    .await;
+}