fix: resolve bash path for exec probes during devenv test

Two issues prevented processes with exec readiness probes from working
when pulled into the enterTest task graph (e.g. via
`after = [ "devenv:processes:postgres" ]`):

1. run_tasks_with_roots() passed an empty string as the bash path,
   causing ExecProbe to fail with "No such file or directory" when
   trying to run Command::new("").

2. After enterTest tasks completed, TasksUi::run() waited for
   processes to exit (run_foreground), blocking devenv test
   indefinitely.

Fix (1) by calling get_bash_path() in run_tasks_with_roots().
Fix (2) by adding a stop_processes flag to run_tasks_with_ui/TasksUi
so that processes started during task execution are stopped once all
tasks complete.

Closes #2713

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: domenkozar

CHANGELOG.md

@@ -15,6 +15,7 @@
 - Fixed Ghostty shell integration not working in `devenv shell` by sourcing `ghostty.bash` from the rcfile when `GHOSTTY_RESOURCES_DIR` is set.
 - Fixed TUI panic when expanding error details containing multi-byte UTF-8 characters (e.g. miette underlines) by using character-based truncation instead of byte-based slicing.
 - Fixed `devenv processes stop` removing the process from the manager state, making it impossible to start or restart afterwards.
+- Fixed process exec probes failing with "No such file or directory" during `devenv test` when a task depends on a process (e.g. `after = [ "devenv:processes:postgres" ]`), because the bash path was not resolved for the enterTest task runner ([#2713](https://github.com/cachix/devenv/issues/2713)).
 
 ### Improvements
 

devenv-tasks/src/main.rs

@@ -199,7 +199,7 @@ async fn run_tasks(shutdown: Arc<Shutdown>) -> Result<()> {
 
             // Run UI - processes events and waits for run_handle
             let ui = TasksUi::new(Arc::clone(&tasks), activity_rx, verbosity);
-            let (status, _) = ui.run(run_handle).await?;
+            let (status, _) = ui.run(run_handle, false).await?;
 
             if shutdown.last_signal().is_some() {
                 let _ = tasks.process_manager().stop_all().await;

devenv-tasks/src/ui.rs

@@ -81,11 +81,16 @@ impl TasksUi {
 
     /// Run the UI, processing activity events until task runner completes.
     ///
-    /// If processes are still running after the task runner finishes, continues
-    /// forwarding process output until all processes exit or shutdown is signaled.
+    /// If `stop_processes` is false and processes are still running after the
+    /// task runner finishes, continues forwarding process output until all
+    /// processes exit or shutdown is signaled.
+    ///
+    /// If `stop_processes` is true, any processes started during task execution
+    /// are stopped once all tasks complete, so the caller regains control.
     pub async fn run(
         mut self,
         run_handle: tokio::task::JoinHandle<Outputs>,
+        stop_processes: bool,
     ) -> Result<(TasksStatus, Outputs), Error> {
         // Print header (unless quiet mode)
         if self.verbosity != VerbosityLevel::Quiet {
@@ -102,17 +107,23 @@ impl TasksUi {
         // Phase 2: If processes are still running (e.g., devenv-tasks invoked by
         // process-compose), keep forwarding output and wait for them to exit.
         if !self.tasks.process_manager.list().await.is_empty() {
-            let cancel = self.tasks.shutdown.cancellation_token();
-            let pm = Arc::clone(&self.tasks.process_manager);
-            let fg_handle = tokio::spawn(async move { pm.run_foreground(cancel, None).await });
-
-            if let Err(e) = self
-                .consume_events_until(fg_handle)
-                .await
-                .map_err(|e| format!("Process manager panicked: {e}"))
-                .and_then(|r| r.map_err(|e| format!("Process manager error: {e}")))
-            {
-                return Err(Error::io(e));
+            if stop_processes {
+                // Stop processes so the caller regains control (e.g., enterTest
+                // tasks that pulled processes into the task graph).
+                let _ = self.tasks.process_manager.stop_all().await;
+            } else {
+                let cancel = self.tasks.shutdown.cancellation_token();
+                let pm = Arc::clone(&self.tasks.process_manager);
+                let fg_handle = tokio::spawn(async move { pm.run_foreground(cancel, None).await });
+
+                if let Err(e) = self
+                    .consume_events_until(fg_handle)
+                    .await
+                    .map_err(|e| format!("Process manager panicked: {e}"))
+                    .and_then(|r| r.map_err(|e| format!("Process manager error: {e}")))
+                {
+                    return Err(Error::io(e));
+                }
             }
         }
 

devenv/src/devenv/container.rs

@@ -99,7 +99,7 @@ impl Devenv {
             .build()
             .await?;
 
-        let (status, _outputs) = run_tasks_with_ui(tasks, verbosity, tui).await?;
+        let (status, _outputs) = run_tasks_with_ui(tasks, verbosity, tui, true).await?;
 
         if status.has_failures() {
             bail!("Failed to copy container");

devenv/src/devenv/mod.rs

@@ -972,7 +972,7 @@ impl Devenv {
             .build()
             .await?;
 
-        let (status, outputs) = run_tasks_with_ui(tasks, verbosity, tui).await?;
+        let (status, outputs) = run_tasks_with_ui(tasks, verbosity, tui, false).await?;
 
         if status.has_failures() {
             miette::bail!("Some tasks failed");
@@ -1036,6 +1036,7 @@ impl Devenv {
         verbosity: tasks::VerbosityLevel,
         tui: bool,
     ) -> Result<(tasks::TasksStatus, BTreeMap<String, String>, Vec<String>)> {
+        let bash = self.get_bash_path().await?;
         let config = tasks::Config {
             roots,
             tasks: task_configs,
@@ -1044,15 +1045,15 @@ impl Devenv {
             cache_dir: self.devenv_state_dir(),
             sudo_context: None,
             env: envs,
-            bash: String::new(),
+            bash,
             ignore_process_deps: false,
         };
 
         let tasks = Tasks::builder(config, verbosity, Arc::clone(&self.shutdown))
             .build()
             .await?;
 
-        let (status, outputs) = run_tasks_with_ui(tasks, verbosity, tui).await?;
+        let (status, outputs) = run_tasks_with_ui(tasks, verbosity, tui, true).await?;
 
         let exports = outputs.collect_env_exports();
         let messages = outputs.collect_messages();
@@ -2197,9 +2198,13 @@ async fn run_tasks_with_ui(
     tasks: Tasks,
     verbosity: tasks::VerbosityLevel,
     tui: bool,
+    stop_processes: bool,
 ) -> Result<(tasks::TasksStatus, tasks::Outputs)> {
     if tui {
         let outputs = tasks.run(false).await;
+        if stop_processes {
+            let _ = tasks.process_manager().stop_all().await;
+        }
         let status = tasks.get_completion_status().await;
         Ok((status, outputs))
     } else {
@@ -2212,7 +2217,7 @@ async fn run_tasks_with_ui(
         let run_handle = tokio::spawn(async move { tasks_clone.run(false).await });
 
         let ui = TasksUi::new(Arc::clone(&tasks), activity_rx, verbosity);
-        Ok(ui.run(run_handle).await?)
+        Ok(ui.run(run_handle, stop_processes).await?)
     }
 }
 

tests/tasks-in-test/.test.sh

@@ -29,3 +29,7 @@ test -z "${DEVENV_TEST_NOT_EXPORTED:-}"
 # enterTest-only task should have run (devenv test runs enterTest root,
 # which depends on enterShell)
 test "$DEVENV_TEST_ENTER_TEST_RAN" = "yes"
+
+# Task depending on a process with exec readiness probe should have run.
+# Regression test for https://github.com/cachix/devenv/issues/2713
+test "$DEVENV_TEST_PROCESS_WAS_READY" = "yes"

tests/tasks-in-test/devenv.nix

@@ -1,4 +1,4 @@
-{ ... }:
+{ config, ... }:
 {
   # Task that exports an env var before enterShell.
   # This tests that enterShell tasks run during `devenv test`
@@ -41,4 +41,24 @@
     exports = [ "DEVENV_TEST_ENTER_TEST_RAN" ];
     before = [ "devenv:enterTest" ];
   };
+
+  # Process with exec readiness probe. Tests that the bash path is resolved
+  # for exec probes when processes are pulled into the enterTest task graph.
+  # Regression test for https://github.com/cachix/devenv/issues/2713
+  processes.probe-test = {
+    exec = ''
+      touch ${config.devenv.state}/probe-test-ready
+      sleep 300
+    '';
+    ready.exec = "test -f ${config.devenv.state}/probe-test-ready";
+  };
+
+  tasks."test:wait-for-process" = {
+    exec = ''
+      export DEVENV_TEST_PROCESS_WAS_READY="yes"
+    '';
+    exports = [ "DEVENV_TEST_PROCESS_WAS_READY" ];
+    after = [ "devenv:processes:probe-test" ];
+    before = [ "devenv:enterTest" ];
+  };
 }