devenv: fix execing into a shell with devenv shell

The recent async-ification broke interactive shells here: something to
do with tokio's Command differences.

Switching to exec here to maximize compatibility with interactive shells.

Author: sandydoo

devenv-run-tests/src/main.rs

@@ -207,7 +207,7 @@ async fn run_tests_in_directory(args: &Args) -> Result<Vec<TestResult>> {
             if PathBuf::from(setup_script).exists() {
                 eprintln!("    Running {setup_script}");
                 let output = devenv
-                    .exec_in_shell(format!("./{setup_script}"), &[])
+                    .run_in_shell(format!("./{setup_script}"), &[])
                     .await?;
                 if !output.status.success() {
                     return Err(miette::miette!(

devenv/src/devenv.rs

@@ -380,21 +380,42 @@ impl Devenv {
         Ok(shell_cmd)
     }
 
-    /// Exec into the shell.
-    /// This method does not return after calling `exec`.
-    pub async fn shell(self) -> Result<()> {
-        let shell_cmd = self.prepare_shell(&None, &[]).await?;
+    /// Launch an interactive shell (uses exec, never returns).
+    pub async fn shell(&self) -> Result<()> {
+        self.exec_in_shell(None, &[]).await
+    }
+
+    /// Execute a command by replacing the current process using exec.
+    ///
+    /// This method accepts `Option<String>` for the command to support both:
+    /// - Interactive shell: `exec_in_shell(None, &[])`
+    /// - Command execution: `exec_in_shell(Some(cmd), args)`
+    ///
+    /// **Important**: This function never returns `Ok(())` on success because `exec()`
+    /// replaces the current process. The `Result<()>` return type only represents
+    /// potential errors during setup or if `exec()` fails to start the new process.
+    /// On successful exec, this function never returns.
+    pub async fn exec_in_shell(&self, cmd: Option<String>, args: &[String]) -> Result<()> {
+        let shell_cmd = self.prepare_shell(&cmd, args).await?;
         info!(devenv.is_user_message = true, "Entering shell");
         let err = shell_cmd.into_std().exec();
-        bail!("Failed to execute shell: {}", err);
+
+        let cmd_context = match &cmd {
+            Some(c) => format!("command '{}'", c),
+            None => "interactive shell".to_string(),
+        };
+        bail!("Failed to exec into shell with {}: {}", cmd_context, err);
     }
 
-    pub async fn exec_in_shell(&self, cmd: String, args: &[String]) -> Result<Output> {
+    /// Run a command and return the output.
+    ///
+    /// This method accepts `String` (not `Option<String>`) because it's specifically
+    /// designed for running commands and capturing their output. Unlike `exec_in_shell`,
+    /// this method always requires a command and uses `spawn` + `wait_with_output`
+    /// to return control to the caller with the command's output.
+    pub async fn run_in_shell(&self, cmd: String, args: &[String]) -> Result<Output> {
         let mut shell_cmd = self.prepare_shell(&Some(cmd), args).await?;
-        let span = info_span!(
-            "executing_in_shell",
-            devenv.user_message = "Executing in shell"
-        );
+        let span = info_span!("running_in_shell", devenv.user_message = "Running in shell");
         // Note that tokio's `output()` always configures stdout/stderr as pipes.
         // Use `spawn` + `wait_with_output` instead.
         let proc = shell_cmd

devenv/src/main.rs

@@ -4,11 +4,7 @@ use devenv::{
     config, log, Devenv,
 };
 use miette::{IntoDiagnostic, Result, WrapErr};
-use std::env;
-use std::{
-    os::unix::process::CommandExt,
-    process::{self, Command},
-};
+use std::{env, os::unix::process::CommandExt, process::Command};
 use tempfile::TempDir;
 use tracing::{info, warn};
 
@@ -100,13 +96,7 @@ async fn main() -> Result<()> {
 
     match command {
         Commands::Shell { cmd, ref args } => match cmd {
-            Some(cmd) => {
-                let output = devenv.exec_in_shell(cmd, args).await?;
-                if !output.status.success() {
-                    process::exit(output.status.code().unwrap_or(1));
-                }
-                Ok(())
-            }
+            Some(cmd) => devenv.exec_in_shell(Some(cmd), args).await,
             None => devenv.shell().await,
         },
         Commands::Test { .. } => devenv.test().await,