Handle logs coming in from forked process (#762)

Author: HalFrgrd

README.md

@@ -38,17 +38,18 @@ Flyline is similar to [ble.sh](https://github.com/akinomyoga/ble.sh) but is writ
 
 # Installation
 
+> [!IMPORTANT]
+> After installing, run `flyline run-tutorial` and if you don't like the mouse capturing: `flyline mouse --mode disabled`
+
 ### Quick install: `install.sh`
 
 > [!TIP]
 > Run the following command to download flyline and update your `.bashrc` to load the latest version. No need for `sudo`!
+
 ```bash
 curl -sSfL https://github.com/HalFrgrd/flyline/releases/latest/download/install.sh | sh
 ```
-
-
-> [!IMPORTANT]
-> On macOS you must first install a version of bash that supports custom builtins: `brew install bash`
+On macOS you must first install a version of Bash that supports custom builtins: `brew install bash`
 
 ### Download from releases
 

src/app/tab_completion.rs

@@ -1241,6 +1241,8 @@ impl App<'_> {
 
         if pid == 0 {
             // Child process
+            crate::logging::disable_streaming();
+            crate::logging::clear_logs();
             unsafe {
                 libc::setsid();
                 // Reset common signals to default so the child process terminates cleanly and instantly on signals.
@@ -1274,7 +1276,10 @@ impl App<'_> {
             );
             let elapsed = thread_start.elapsed();
 
-            let data = result.map(|r| (r, elapsed));
+            log::info!("Child process completed");
+            let child_logs = crate::logging::take_logs();
+
+            let data = (result.map(|r| (r, elapsed)), child_logs);
             if let Ok(serialized) = serde_json::to_vec(&data) {
                 let mut file = unsafe { std::fs::File::from_raw_fd(write_fd) };
                 use std::io::Write;
@@ -1289,8 +1294,6 @@ impl App<'_> {
                 }
             }
 
-            log::info!("Child process completed");
-
             // Use _exit to avoid running atexit handlers in the child process.
             unsafe {
                 libc::_exit(0);
@@ -1307,18 +1310,33 @@ impl App<'_> {
                 .spawn(move || {
                     let mut file = unsafe { std::fs::File::from_raw_fd(read_fd) };
                     let mut len_buf = [0u8; 8];
-                    let res = if std::io::Read::read_exact(&mut file, &mut len_buf).is_err() {
+                    let payload: Option<(
+                        Option<(ActiveSuggestionsBuilder, std::time::Duration)>,
+                        Vec<String>,
+                    )> = if std::io::Read::read_exact(&mut file, &mut len_buf).is_err() {
                         None
                     } else {
                         let len = u64::from_ne_bytes(len_buf);
                         let mut data_buf = vec![0u8; len as usize];
                         if std::io::Read::read_exact(&mut file, &mut data_buf).is_ok() {
-                            serde_json::from_slice(&data_buf).ok().flatten()
+                            serde_json::from_slice(&data_buf).ok()
                         } else {
                             None
                         }
                     };
-                    let _ = tx.send(res);
+
+                    let (completion_res, child_logs) = if let Some((res, logs)) = payload {
+                        (res, logs)
+                    } else {
+                        (None, vec![])
+                    };
+
+                    // Replay child logs inside the parent process
+                    for log_line in child_logs {
+                        crate::logging::log_raw_entry(log_line);
+                    }
+
+                    let _ = tx.send(completion_res);
 
                     // Reap the child process to prevent zombie processes
                     unsafe {

src/app/ui.rs

@@ -446,7 +446,9 @@ impl<'a> App<'a> {
                     content.newline();
                 }
 
-                if !self.mouse_state.is_enabled() {
+                if !self.mouse_state.is_enabled()
+                    && self.settings.mouse_mode != crate::settings::MouseMode::Disabled
+                {
                     let red = Style::default().fg(Color::Red).slow_blink();
                     let escape_hint = TaggedLine::from(vec![TaggedSpan::new(
                         Span::styled("Press Escape to re-enable mouse mode.", red),

src/logging.rs

@@ -147,6 +147,41 @@ pub fn dump_logs_stdout() -> Result<()> {
     Ok(())
 }
 
+/// Clear all in-memory logs.
+pub fn clear_logs() {
+    if let Some(logger) = LOGGER.get() {
+        let mut entries = logger.entries.lock().unwrap();
+        entries.clear();
+    }
+}
+
+/// Disable direct file/terminal log streaming (used in child processes to prevent double-logging).
+pub fn disable_streaming() {
+    if let Some(logger) = LOGGER.get() {
+        let mut stream_writer = logger.stream_writer.lock().unwrap();
+        *stream_writer = None;
+    }
+    TERMINAL_STREAMING.store(false, Ordering::Relaxed);
+}
+
+/// Retrieve all in-memory log entries and clear the buffer.
+pub fn take_logs() -> Vec<String> {
+    if let Some(logger) = LOGGER.get() {
+        let mut entries = logger.entries.lock().unwrap();
+        std::mem::take(&mut *entries).into()
+    } else {
+        vec![]
+    }
+}
+
+/// Write a pre-formatted raw log entry directly into the log buffers/streams.
+pub fn log_raw_entry(entry: String) {
+    if let Some(logger) = LOGGER.get() {
+        logger.write_stream_entry(&entry);
+        logger.push(entry);
+    }
+}
+
 /// Print all in-memory log entries to stderr (used for diagnostic error paths).
 pub fn print_logs_stderr() {
     if let Some(logger) = LOGGER.get() {