Pass host env to spawn_future

Author: ranfdev

src/fakers/host_env.rs

@@ -38,6 +38,46 @@ pub async fn resolve_host_env_via_runner(
     }
 }
 
+/// Resolve all host environment variables via a `CommandRunner` as `KEY=VALUE` entries.
+///
+/// This is useful when spawning processes that need the host `PATH` and other vars, e.g. VTE.
+pub async fn resolve_host_env_list_via_runner(runner: &CommandRunner) -> io::Result<Vec<String>> {
+    // Prefer NUL-separated output to preserve values containing newlines.
+    let mut cmd = Command::new("env");
+    cmd.arg("-0");
+
+    if let Ok(output) = runner.output(cmd).await {
+        if output.status.success() {
+            let vars = output
+                .stdout
+                .split(|b| *b == 0)
+                .filter_map(|entry| {
+                    if entry.is_empty() {
+                        return None;
+                    }
+                    let s = String::from_utf8_lossy(entry).to_string();
+                    if s.contains('=') { Some(s) } else { None }
+                })
+                .collect::<Vec<_>>();
+            if !vars.is_empty() {
+                return Ok(vars);
+            }
+        }
+    }
+
+    // Fallback: newline-separated output.
+    let output = runner.output(Command::new("env")).await?;
+    if !output.status.success() {
+        return Err(io::Error::other("failed to resolve host environment via `env`"));
+    }
+
+    Ok(String::from_utf8_lossy(&output.stdout)
+        .lines()
+        .filter(|line| line.contains('='))
+        .map(ToString::to_string)
+        .collect())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -60,4 +100,16 @@ mod tests {
         let res = block_on(resolve_host_env_via_runner(&runner, "HOME")).unwrap();
         assert_eq!(res, None);
     }
+
+    #[test]
+    fn test_resolve_host_env_list_with_null_runner_nul_separated() {
+        let mut builder = NullCommandRunnerBuilder::new();
+        let mut cmd = Command::new("env");
+        cmd.arg("-0");
+        builder.cmd_full(cmd, || Ok("HOME=/fake/home\0PATH=/nix/store/bin\0".to_string()));
+        let runner = builder.build();
+
+        let res = block_on(resolve_host_env_list_via_runner(&runner)).unwrap();
+        assert_eq!(res, vec!["HOME=/fake/home", "PATH=/nix/store/bin"]);
+    }
 }

src/fakers/mod.rs

@@ -5,5 +5,5 @@ mod output_tracker;
 
 pub use command::{Command, FdMode};
 pub use command_runner::{Child, CommandRunner, CommandRunnerEvent, NullCommandRunnerBuilder};
-pub use host_env::resolve_host_env_via_runner;
+pub use host_env::{resolve_host_env_list_via_runner, resolve_host_env_via_runner};
 pub use output_tracker::OutputTracker;

src/widgets/integrated_terminal.rs

@@ -6,6 +6,7 @@ use gtk::{
 };
 use vte4::prelude::*;
 
+use crate::fakers::resolve_host_env_list_via_runner;
 use crate::i18n::gettext;
 use crate::gtk_utils::ColorPalette;
 use crate::models::Container;
@@ -159,27 +160,42 @@ impl IntegratedTerminal {
         }
 
         imp.reload_button.set_visible(false);
-        let root_store = self.container().root_store();
-
-        // Prepare the shell command via the Distrobox backend (uses injected factory)
-        let name = self.container().name();
-        let enter_cmd = root_store.distrobox().enter_cmd(&name);
-        let shell = root_store.command_runner().wrap_command(enter_cmd).to_vec();
-
-        let fut = imp.terminal.spawn_future(
-            vte4::PtyFlags::DEFAULT,
-            None,
-            &shell.iter().filter_map(|s| s.to_str()).collect::<Vec<_>>(),
-            &[],
-            glib::SpawnFlags::DEFAULT,
-            || {},
-            10,
-        );
-
         glib::MainContext::default().spawn_local(clone!(
             #[weak(rename_to=this)]
             self,
             async move {
+                let root_store = this.container().root_store();
+
+                // Prepare the shell command via the Distrobox backend (uses injected factory)
+                let name = this.container().name();
+                let enter_cmd = root_store.distrobox().enter_cmd(&name);
+                let command_runner = root_store.command_runner();
+                let shell = command_runner.wrap_command(enter_cmd).to_vec();
+                let shell_args = shell
+                    .iter()
+                    .filter_map(|s| s.to_str())
+                    .collect::<Vec<_>>();
+
+                let host_env = match resolve_host_env_list_via_runner(&command_runner).await {
+                    Ok(env) => env,
+                    Err(err) => {
+                        eprintln!("Failed to resolve host env for terminal: {}", err);
+                        Vec::new()
+                    }
+                };
+                let host_env_refs = host_env.iter().map(String::as_str).collect::<Vec<_>>();
+
+                dbg!(&host_env_refs);
+                let fut = this.imp().terminal.spawn_future(
+                    vte4::PtyFlags::DEFAULT,
+                    None,
+                    &shell_args,
+                    &host_env_refs,
+                    glib::SpawnFlags::DEFAULT,
+                    || {},
+                    10,
+                );
+
                 match fut.await {
                     Ok(pid) => {
                         this.imp().terminal_pid.set(Some(pid));