Struct ShellProc 

pub struct ShellProc {
    pub conn_name: String,
    cmd: Box<dyn ConnInterface>,
    close_once: AtomicBool,
    done_tx: Option<Sender<i32>>,
    done_rx: Option<Receiver<i32>>,
    exit_code: Mutex<Option<i32>>,
}

A running shell process wrapping a ConnInterface. Port of Go’s shellexec.ShellProc.

Fields

conn_name: String

Connection name (“local”, “wsl://distro”, “user@host”).

cmd: Box<dyn ConnInterface>

The underlying PTY/process connection.

close_once: AtomicBool

Ensures close is called only once.

done_tx: Option<Sender<i32>>

Signaled when the process exits. The i32 is the exit code.

done_rx: Option<Receiver<i32>>

Receiver for wait completion.

exit_code: Mutex<Option<i32>>

Exit code after wait completes.

Implementations

impl ShellProc

pub fn new(conn_name: String, cmd: Box<dyn ConnInterface>) -> Self

Create a new ShellProc wrapping a ConnInterface.

pub fn start(&mut self) -> Result<()>

Start the process.

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

Write data to the process stdin/PTY.

pub fn read(&self, buf: &mut [u8]) -> Result<usize>

Read data from the process stdout/PTY.

pub fn set_size(&self, rows: i64, cols: i64) -> Result<()>

Resize the terminal.

pub fn close(&self) -> Result<()>

Close the process. Idempotent via AtomicBool.

pub fn kill(&self) -> Result<()>

Kill the process immediately.

pub fn wait_and_signal(&mut self) -> i32

Wait for process exit and signal done channel. This should be called from a dedicated task.

pub fn take_done_rx(&mut self) -> Option<Receiver<i32>>

Take the done receiver (can only be called once). Used by the block controller to await process completion.

pub fn get_exit_code(&self) -> Option<i32>

Get the exit code (only valid after wait completes).