Struct NativeProcess 

pub struct NativeProcess { /* private fields */ }

A cross-platform child process with optional output capture.

NativeProcess wraps std::process::Command with the crate’s process-tree containment, capture draining, timeout, and terminal-control behavior. Methods are synchronous and are safe to call from ordinary blocking code.

Implementations

impl NativeProcess

pub fn new(config: ProcessConfig) -> Self

Create a process wrapper from a ProcessConfig.

The child is not spawned until Self::start is called. Process observation is off by default: no lifecycle events are emitted unless Self::with_observer is used instead.

pub fn with_observer( config: ProcessConfig, observer: ObserverConfig, ) -> (Self, ObserverSubscriber)

Create a process wrapper with process observation enabled (Phase 1 of #221).

Returns the wrapper paired with an ObserverSubscriber that receives a started event when Self::start spawns the child and exactly one exited event when the child is reaped — for the categories the config requests that are actually Supported (only Lifecycle in Phase 1; see ObserverCapabilities::negotiate).

The emitter never blocks on a slow or dropped subscriber.

pub fn start(&self) -> Result<(), ProcessError>

Spawn the configured child process.

Returns ProcessError::AlreadyStarted if the same wrapper already owns a running child.

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

Write bytes to the child’s stdin and then close stdin.

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

Write to the child’s stdin without closing it afterwards, so the caller can issue additional writes. Used by interactive pipe-backed sessions (#130 milestone 3) where the daemon keeps stdin open across multiple client input frames.

pub fn close_stdin(&self) -> Result<(), ProcessError>

Explicitly close the child’s stdin (signals EOF to the child). Idempotent: returns Ok if stdin was already closed.

pub fn poll(&self) -> Result<Option<i32>, ProcessError>

Check whether the child has exited without blocking.

Returns Ok(None) while the process is still running.

pub fn wait(&self, timeout: Option<Duration>) -> Result<i32, ProcessError>

Wait for the child to exit.

When timeout is Some, returns ProcessError::Timeout if the child does not exit before the duration elapses.

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

Forcefully terminate the child process.

pub fn terminate(&self) -> Result<(), ProcessError>

Terminate the child process.

This currently uses the same hard-kill path as Self::kill.

pub fn terminate_group_soft(&self) -> Result<(), ProcessError>

Send the OS-appropriate soft termination signal to the child’s process group (POSIX: SIGTERM to -pid; Windows: no soft path implemented yet — returns Ok without doing anything so callers can run the same code on both platforms and rely on the post- grace hard kill).

Requires ProcessConfig.create_process_group=true on POSIX so that -pid resolves to the child’s own group. With the default create_process_group=false, the kill would walk back to the caller’s group; the method silently no-ops in that case to avoid signaling the wrong tree.

Used by the daemon-side pipe sessions (#130 M4 follow-up) so that TerminationOutcome::SoftExit becomes meaningful on POSIX.

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

Close the process wrapper by terminating the child when it is running.

pub fn pid(&self) -> Option<u32>

Return the child process id when the wrapper currently owns a child.

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

Return the cached exit code when the child has exited.

pub fn has_pending_stream(&self, stream: StreamKind) -> bool

Return whether captured output is queued for one stream.

pub fn has_pending_combined(&self) -> bool

Return whether captured combined output is queued.

pub fn drain_stream(&self, stream: StreamKind) -> Vec<Vec<u8>>

Drain and return all queued output for one stream.

pub fn drain_combined(&self) -> Vec<StreamEvent>

Drain and return all queued combined output events.

pub fn read_stream( &self, stream: StreamKind, timeout: Option<Duration>, ) -> ReadStatus<Vec<u8>>

Read the next captured chunk from one stream.

Returns ReadStatus::Timeout when timeout elapses before output or EOF is observed.

pub fn read_combined( &self, timeout: Option<Duration>, ) -> ReadStatus<StreamEvent>

Read the next captured combined stream event.

pub fn captured_stdout(&self) -> Vec<Vec<u8>>

Return the retained stdout history.

pub fn captured_stderr(&self) -> Vec<Vec<u8>>

Return the retained stderr history.

pub fn captured_combined(&self) -> Vec<StreamEvent>

Return the retained combined stdout/stderr event history.

pub fn captured_stream_bytes(&self, stream: StreamKind) -> usize

Return the retained byte count for one captured stream.

pub fn captured_combined_bytes(&self) -> usize

Return the retained byte count for combined captured output.

pub fn clear_captured_stream(&self, stream: StreamKind) -> usize

Clear retained output history for one stream and return freed bytes.

pub fn clear_captured_combined(&self) -> usize

Clear retained combined output history and return freed bytes.