feat: redirect command stdout and stderr to logs

Author: helton

src/runner.rs

@@ -1,8 +1,8 @@
-use crate::packages::Package;
-use log::{debug, error, warn};
-use std::io::{stdin, IsTerminal, Read, Write};
+use log::{debug, error, info, warn};
+use std::io::{stdin, IsTerminal, Read, Write, BufRead, BufReader};
 use std::path::Path;
 use std::process::{Command, Stdio};
+use crate::packages::Package;
 
 fn run_command(command: &str, stdin_buffer: Option<Vec<u8>>) -> bool {
     debug!("Running command: {}", command);
@@ -13,8 +13,8 @@ fn run_command(command: &str, stdin_buffer: Option<Vec<u8>>) -> bool {
 
     let mut child = Command::new(cmd)
         .args(args)
-        .stdout(Stdio::inherit()) // Inherit stdout
-        .stderr(Stdio::inherit()) // Inherit stderr
+        .stdout(Stdio::piped()) // Redirect stdout to a pipe
+        .stderr(Stdio::piped()) // Redirect stderr to a pipe
         .stdin(Stdio::piped()) // Set stdin to piped to write the buffer later
         .spawn() // Spawn the command
         .expect("Failed to spawn command");
@@ -27,8 +27,37 @@ fn run_command(command: &str, stdin_buffer: Option<Vec<u8>>) -> bool {
             .expect("Failed to write to stdin");
     }
 
-    // Wait for the command to complete and check the status
-    match child.wait() {
+    // Function to log output from a pipe
+    fn log_output<R: BufRead>(reader: R, log_fn: impl Fn(&str)) {
+        for line in reader.lines() {
+            match line {
+                Ok(line) => log_fn(&line),
+                Err(e) => error!("Failed to read line from output: {}", e),
+            }
+        }
+    }
+
+    // Read the child's stdout and stderr in separate threads and log them
+    let stdout = child.stdout.take().expect("Failed to open stdout");
+    let stderr = child.stderr.take().expect("Failed to open stderr");
+
+    let stdout_thread = std::thread::spawn(move || {
+        log_output(BufReader::new(stdout), |line| info!("{}", line));
+    });
+
+    let stderr_thread = std::thread::spawn(move || {
+        log_output(BufReader::new(stderr), |line| error!("{}", line));
+    });
+
+    // Wait for the command to complete
+    let status = child.wait();
+
+    // Wait for the logging threads to finish
+    let _ = stdout_thread.join();
+    let _ = stderr_thread.join();
+
+    // Check the command status
+    match status {
         Ok(status) => status.success(),
         Err(e) => {
             error!("Command failed to complete: {}", e);