fix: terminate pane sessions on close

7 files changed, 239 insertions, 8 deletions

diff --git a/src/app/mod.rs b/src/app/mod.rs
index db1cf9e8..82c3777a 100644
--- a/src/app/mod.rs
+++ b/src/app/mod.rs
@@ -1100,7 +1100,7 @@ impl App {
                         data: crate::api::schema::EventData::WorkspaceClosed { workspace_id },
                     });
                 } else {
-                    ws.remove_pane(pane_id);
+                    ws.close_pane(pane_id);
                     self.emit_event(crate::api::schema::EventEnvelope {
                         event: crate::api::schema::EventKind::PaneClosed,
                         data: crate::api::schema::EventData::PaneClosed {
diff --git a/src/pane.rs b/src/pane.rs
index 7a5a75dd..c6b8e175 100644
--- a/src/pane.rs
+++ b/src/pane.rs
@@ -160,7 +160,74 @@ fn recent_text_from_parser(parser: &mut vt100::Parser<PtyResponses>, lines: usiz
     }
 }
 
+fn wait_for_processes_to_exit(pids: &[u32], timeout: std::time::Duration) -> bool {
+    let deadline = std::time::Instant::now() + timeout;
+    loop {
+        if pids
+            .iter()
+            .all(|pid| !crate::platform::process_exists(*pid))
+        {
+            return true;
+        }
+        if std::time::Instant::now() >= deadline {
+            return false;
+        }
+        std::thread::sleep(std::time::Duration::from_millis(20));
+    }
+}
+
+fn shutdown_pane_processes(pane_id: PaneId, child_pid: u32) {
+    if child_pid == 0 {
+        return;
+    }
+
+    let mut pids = crate::platform::session_processes(child_pid);
+    if pids.is_empty() {
+        pids.push(child_pid);
+    }
+    pids.sort_unstable();
+    pids.dedup();
+
+    for (signal, grace) in [
+        (
+            crate::platform::Signal::Hangup,
+            std::time::Duration::from_millis(250),
+        ),
+        (
+            crate::platform::Signal::Terminate,
+            std::time::Duration::from_millis(250),
+        ),
+        (
+            crate::platform::Signal::Kill,
+            std::time::Duration::from_millis(250),
+        ),
+    ] {
+        crate::platform::signal_processes(&pids, signal);
+        if wait_for_processes_to_exit(&pids, grace) {
+            info!(
+                pane = pane_id.raw(),
+                pid = child_pid,
+                ?signal,
+                "pane session terminated"
+            );
+            return;
+        }
+    }
+
+    warn!(
+        pane = pane_id.raw(),
+        pid = child_pid,
+        pids = ?pids,
+        "pane session still alive after forced shutdown"
+    );
+}
+
 impl PaneRuntime {
+    pub fn shutdown(self, pane_id: PaneId) {
+        self.detect_handle.abort();
+        shutdown_pane_processes(pane_id, self.child_pid.load(Ordering::Acquire));
+    }
+
     pub fn spawn(
         pane_id: PaneId,
         rows: u16,
diff --git a/src/platform/fallback.rs b/src/platform/fallback.rs
index 7bcd23c5..4bf78352 100644
--- a/src/platform/fallback.rs
+++ b/src/platform/fallback.rs
@@ -1,6 +1,6 @@
 use std::path::PathBuf;
 
-use super::ForegroundJob;
+use super::{ForegroundJob, Signal};
 
 /// Unsupported platform stub.
 pub fn foreground_job(_child_pid: u32) -> Option<ForegroundJob> {
@@ -11,3 +11,16 @@ pub fn foreground_job(_child_pid: u32) -> Option<ForegroundJob> {
 pub fn process_cwd(_pid: u32) -> Option<PathBuf> {
     None
 }
+
+/// Unsupported platform stub.
+pub fn session_processes(_child_pid: u32) -> Vec<u32> {
+    Vec::new()
+}
+
+/// Unsupported platform stub.
+pub fn signal_processes(_pids: &[u32], _signal: Signal) {}
+
+/// Unsupported platform stub.
+pub fn process_exists(_pid: u32) -> bool {
+    false
+}
diff --git a/src/platform/linux.rs b/src/platform/linux.rs
index 10695e92..b6fc0272 100644
--- a/src/platform/linux.rs
+++ b/src/platform/linux.rs
@@ -1,6 +1,6 @@
 use std::path::PathBuf;
 
-use super::{ForegroundJob, ForegroundProcess};
+use super::{ForegroundJob, ForegroundProcess, Signal};
 
 /// Collect the foreground terminal job for a given child PID.
 pub fn foreground_job(child_pid: u32) -> Option<ForegroundJob> {
@@ -87,3 +87,64 @@ pub fn process_cwd(pid: u32) -> Option<PathBuf> {
     }
     std::fs::read_link(format!("/proc/{pid}/cwd")).ok()
 }
+
+pub fn session_processes(child_pid: u32) -> Vec<u32> {
+    let Some(session_id) = process_session_id(child_pid) else {
+        return Vec::new();
+    };
+
+    let mut pids = Vec::new();
+    for entry in std::fs::read_dir("/proc").into_iter().flatten().flatten() {
+        let file_name = entry.file_name();
+        let Some(pid_str) = file_name.to_str() else {
+            continue;
+        };
+        if !pid_str.bytes().all(|b| b.is_ascii_digit()) {
+            continue;
+        }
+
+        let Ok(pid) = pid_str.parse::<u32>() else {
+            continue;
+        };
+        if process_session_id(pid) == Some(session_id) {
+            pids.push(pid);
+        }
+    }
+    pids
+}
+
+pub fn signal_processes(pids: &[u32], signal: Signal) {
+    let sig = match signal {
+        Signal::Hangup => libc::SIGHUP,
+        Signal::Terminate => libc::SIGTERM,
+        Signal::Kill => libc::SIGKILL,
+    };
+
+    for &pid in pids {
+        if pid == 0 {
+            continue;
+        }
+        unsafe {
+            libc::kill(pid as i32, sig);
+        }
+    }
+}
+
+pub fn process_exists(pid: u32) -> bool {
+    if pid == 0 {
+        return false;
+    }
+    let result = unsafe { libc::kill(pid as i32, 0) };
+    if result == 0 {
+        true
+    } else {
+        std::io::Error::last_os_error().raw_os_error() == Some(libc::EPERM)
+    }
+}
+
+fn process_session_id(pid: u32) -> Option<i32> {
+    let stat = std::fs::read_to_string(format!("/proc/{pid}/stat")).ok()?;
+    let rest = stat.get(stat.rfind(')')? + 2..)?;
+    let fields: Vec<&str> = rest.split_whitespace().collect();
+    fields.get(3)?.parse().ok()
+}
diff --git a/src/platform/macos.rs b/src/platform/macos.rs
index e2f368f8..82de0c5b 100644
--- a/src/platform/macos.rs
+++ b/src/platform/macos.rs
@@ -2,7 +2,7 @@ use std::ffi::OsStr;
 use std::os::unix::ffi::OsStrExt;
 use std::path::{Path, PathBuf};
 
-use super::{ForegroundJob, ForegroundProcess};
+use super::{ForegroundJob, ForegroundProcess, Signal};
 
 /// Collect the foreground terminal job for a given child PID.
 pub fn foreground_job(child_pid: u32) -> Option<ForegroundJob> {
@@ -284,3 +284,62 @@ pub fn process_cwd(pid: u32) -> Option<PathBuf> {
     }
     Some(PathBuf::from(OsStr::from_bytes(&vip_path[..nul])))
 }
+
+pub fn session_processes(child_pid: u32) -> Vec<u32> {
+    if child_pid == 0 {
+        return Vec::new();
+    }
+
+    let target_session = unsafe { libc::getsid(child_pid as libc::c_int) };
+    if target_session <= 0 {
+        return Vec::new();
+    }
+
+    let mut pids = vec![0i32; 4096];
+    let bytes = unsafe {
+        libc::proc_listallpids(
+            pids.as_mut_ptr() as *mut libc::c_void,
+            (pids.len() * std::mem::size_of::<i32>()) as libc::c_int,
+        )
+    };
+    if bytes <= 0 {
+        return Vec::new();
+    }
+
+    let count = (bytes as usize) / std::mem::size_of::<i32>();
+    pids.into_iter()
+        .take(count)
+        .filter(|pid| *pid > 0)
+        .filter(|pid| unsafe { libc::getsid(*pid) } == target_session)
+        .map(|pid| pid as u32)
+        .collect()
+}
+
+pub fn signal_processes(pids: &[u32], signal: Signal) {
+    let sig = match signal {
+        Signal::Hangup => libc::SIGHUP,
+        Signal::Terminate => libc::SIGTERM,
+        Signal::Kill => libc::SIGKILL,
+    };
+
+    for &pid in pids {
+        if pid == 0 {
+            continue;
+        }
+        unsafe {
+            libc::kill(pid as libc::c_int, sig);
+        }
+    }
+}
+
+pub fn process_exists(pid: u32) -> bool {
+    if pid == 0 {
+        return false;
+    }
+    let result = unsafe { libc::kill(pid as libc::c_int, 0) };
+    if result == 0 {
+        true
+    } else {
+        std::io::Error::last_os_error().raw_os_error() == Some(libc::EPERM)
+    }
+}
diff --git a/src/platform/mod.rs b/src/platform/mod.rs
index ade86249..8023cd11 100644
--- a/src/platform/mod.rs
+++ b/src/platform/mod.rs
@@ -17,6 +17,13 @@ pub struct ForegroundJob {
     pub processes: Vec<ForegroundProcess>,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Signal {
+    Hangup,
+    Terminate,
+    Kill,
+}
+
 #[cfg(target_os = "linux")]
 mod linux;
 #[cfg(target_os = "linux")]
diff --git a/src/workspace.rs b/src/workspace.rs
index 63e98912..39ee19a0 100644
--- a/src/workspace.rs
+++ b/src/workspace.rs
@@ -35,6 +35,15 @@ pub struct Workspace {
     pub(crate) render_dirty: Arc<AtomicBool>,
 }
 
+impl Drop for Workspace {
+    fn drop(&mut self) {
+        let runtimes = std::mem::take(&mut self.runtimes);
+        for (pane_id, runtime) in runtimes {
+            runtime.shutdown(pane_id);
+        }
+    }
+}
+
 impl Workspace {
     pub fn new(
         initial_cwd: PathBuf,
@@ -111,12 +120,27 @@ impl Workspace {
     /// Close the focused pane. Returns the removed pane id, or None if last pane.
     pub fn close_focused(&mut self) -> Option<PaneId> {
         let pane_id = self.layout.focused();
-        self.remove_pane(pane_id)
+        self.close_pane(pane_id)
+    }
+
+    /// Close a specific pane and terminate everything running inside it.
+    /// Returns None if it's the last pane and the whole workspace should close.
+    pub fn close_pane(&mut self, pane_id: PaneId) -> Option<PaneId> {
+        let (removed, runtime) = self.detach_pane(pane_id)?;
+        if let Some(runtime) = runtime {
+            runtime.shutdown(pane_id);
+        }
+        Some(removed)
     }
 
-    /// Remove a specific pane from this workspace.
+    /// Remove a specific pane from this workspace without terminating its runtime.
+    /// Used when the pane process has already exited and we are only cleaning up state.
     /// Returns None if it's the last pane and the whole workspace should close.
     pub fn remove_pane(&mut self, pane_id: PaneId) -> Option<PaneId> {
+        self.detach_pane(pane_id).map(|(removed, _)| removed)
+    }
+
+    fn detach_pane(&mut self, pane_id: PaneId) -> Option<(PaneId, Option<PaneRuntime>)> {
         if self.layout.pane_count() <= 1 {
             return None;
         }
@@ -141,12 +165,12 @@ impl Workspace {
             self.next_public_pane_number = self.public_pane_numbers.len() + 1;
         }
         self.panes.remove(&pane_id);
-        self.runtimes.remove(&pane_id);
+        let runtime = self.runtimes.remove(&pane_id);
         self.zoomed = false;
         if let Some(next_root) = next_root {
             self.root_pane = next_root;
         }
-        Some(pane_id)
+        Some((pane_id, runtime))
     }
 
     fn promoted_root_if_needed(&self, closing: PaneId) -> Option<PaneId> {