`8ca272f`

fix: auto-close terminal when shell exits

Detect when the shell process exits (via EOF or error on PTY read)
and automatically hide the terminal panel. Typing 'exit' now cleanly
closes the integrated terminal instead of leaving it in a broken state.

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 4 months ago

SHA: 8ca272f95a793a02b9849f9c388876b8a04c9476
Parents: 99a0358
Tree: 7b075b6

2 changed files

Status	File	+	-
M	`src/terminal/panel.rs`	9	1
M	`src/terminal/pty.rs`	24	2

src/terminal/panel.rsmodified

          Ok(())
+     }
 -    /// Poll for and process PTY output. Returns true if data was received.
 +    /// Poll for and process PTY output. Returns true if data was received or terminal closed.
      pub fn poll(&mut self) -> bool {
          let mut had_data = false;
          if let Some(ref mut pty) = self.pty {
 +            // Check if shell has exited
 +            if !pty.is_alive() {
 +                // Shell exited - close terminal and clean up
 +                self.visible = false;
 +                self.pty = None;
 +                return true; // Trigger render to hide terminal
 +            }
++
              if let Some(data) = pty.read() {
                  self.screen.process(&data);
                  had_data = true;

src/terminal/pty.rsmodified

  use anyhow::Result;
  use portable_pty::{native_pty_system, CommandBuilder, PtyPair, PtySize};
  use std::io::{Read, Write};
 +use std::sync::atomic::{AtomicBool, Ordering};
  use std::sync::mpsc::{self, Receiver, Sender};
 +use std::sync::Arc;
  use std::thread;
  /// Manages a PTY connection to a shell process
      writer: Box<dyn Write + Send>,
      output_rx: Receiver<Vec<u8>>,
      _output_thread: thread::JoinHandle<()>,
 +    /// Flag indicating the shell has exited
 +    shell_exited: Arc<AtomicBool>,
+ }
  impl Pty {
          let mut reader = pair.master.try_clone_reader()?;
          let (output_tx, output_rx): (Sender<Vec<u8>>, Receiver<Vec<u8>>) = mpsc::channel();
 +        // Flag to signal when shell exits
 +        let shell_exited = Arc::new(AtomicBool::new(false));
 +        let shell_exited_clone = Arc::clone(&shell_exited);
++
          let output_thread = thread::spawn(move || {
              let mut buf = [0u8; 4096];
              loop {
                  match reader.read(&mut buf) {
 -                    Ok(0) => break, // EOF
 +                    Ok(0) => {
 +                        // EOF - shell exited
 +                        shell_exited_clone.store(true, Ordering::SeqCst);
 +                        break;
 +                    }
                      Ok(n) => {
                          if output_tx.send(buf[..n].to_vec()).is_err() {
                              break; // Receiver dropped
+                         }
+                     }
 -                    Err(_) => break,
 +                    Err(_) => {
 +                        // Error - likely shell exited
 +                        shell_exited_clone.store(true, Ordering::SeqCst);
 +                        break;
 +                    }
+                 }
+             }
          });
              writer,
              output_rx,
              _output_thread: output_thread,
 +            shell_exited,
          })
+     }
          })?;
          Ok(())
+     }
++
 +    /// Check if the shell is still alive
 +    pub fn is_alive(&self) -> bool {
 +        !self.shell_exited.load(Ordering::SeqCst)
 +    }
+ }