Struct PtyHandle 

pub struct PtyHandle { /* private fields */ }

Handle to one pane’s PTY. The master side is held inside an Arc<Mutex<...>> so the reader thread and the writer thread (or send_keys caller) can share it. The child process handle is retained so Drop can explicitly kill() it — without this, dropping the master Arc doesn’t kill the shell (the reader thread holds a cloned master fd that keeps the slave open), shells accumulate as orphans, and every subsequent fork copies a bloated address space.

Implementations

impl PtyHandle

pub fn spawn( shell: &str, args: &[String], cwd: Option<&str>, env: &[(String, String)], size: PtySize, on_bytes: Box<dyn FnMut(&[u8]) + Send>, on_exit: Box<dyn FnOnce(Option<i32>) + Send>, ) -> Result<Self>

Spawn a child process attached to a freshly minted PTY pair. The caller provides a sink for child bytes — typically a Box<dyn FnMut(&[u8]) + Send> that feeds into a vte parser or appends to a scrollback grid. The reader thread loops on master.try_clone_reader() until EOF, calling the sink on each read.

on_exit is the typed end-of-stream notification: when the reader loop ends (PTY EOF because the child exited, or a read error), the reader thread reaps the child to capture its exit code, then calls on_exit(code) exactly once. code is None only when the child was already reaped elsewhere (the explicit-kill path, where Drop took the child first) or wait() failed. This is the single edge that lets the multiplexer mark the pane exited and disconnect its byte-stream subscribers; without it a reader thread that hit EOF would just end silently and every subscriber would block forever.

pub fn write(&self, bytes: &[u8]) -> Result<()>

Send bytes to the child’s stdin.

pub fn resize(&self, size: PtySize) -> Result<()>

Resize the PTY winsize. Causes SIGWINCH delivery to the child.

pub fn bytes_consumed(&self) -> u64

Total bytes consumed by the pane’s parser since spawn.

Trait Implementations

impl Drop for PtyHandle

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.