Struct Command 

pub struct Command {
    pub program: PathBuf,
    pub args: Vec<String>,
    pub env: Vec<(String, String)>,
    pub cwd: PathBuf,
    pub run_id: String,
    pub stdin: Stdin,
    pub stderr: Stderr,
    pub timeout: Option<Duration>,
}

What to spawn. Named fields rather than six positional arguments, so a call site says which string is the program and which is the run id, and a new knob is a field with a default instead of a break.

Fields

program: PathBuf

args: Vec<String>

env: Vec<(String, String)>

Extra environment for the child, applied over the inherited one.

cwd: PathBuf

run_id: String

The caller’s correlation id, echoed on every Event.

stdin: Stdin

stderr: Stderr

timeout: Option<Duration>

Give up after this long. None (the default) waits indefinitely — the right answer for an agent run a user is watching and can stop, and the wrong one for anything unattended.

Implementations

impl Command

pub fn new(program: impl Into<PathBuf>) -> Command

A run of program, in the current directory, with stdin closed.

The program is the only thing a spawn cannot default, so it is the only argument. Everything else is a named method — three bare strings in a row read as “which one was the cwd again?”.

pub fn cwd(self, cwd: impl Into<PathBuf>) -> Command

Where the child runs. Defaults to the current directory.

pub fn run_id(self, run_id: impl Into<String>) -> Command

A correlation id echoed on every Event, for a caller multiplexing several runs through one callback. Defaults to empty — with one run the handle already identifies it.

pub fn args<I, S>(self, args: I) -> Command

where I: IntoIterator<Item = S>, S: Into<String>,

.args(["--stdio"]) — anything string-like, borrowed or owned.

pub fn env<I, K, V>(self, env: I) -> Command

where I: IntoIterator<Item = (K, V)>, K: Into<String>, V: Into<String>,

.env([("RUST_LOG", "info")]) — applied over the inherited environment.

pub fn stdin(self, stdin: Stdin) -> Command

What the child’s stdin is connected to. stdout and stderr are always piped — streaming them is what this crate is for — and arrive as Event::Stdout / Event::Stderr.

pub fn stderr(self, stderr: Stderr) -> Command

Whether the child’s stderr is streamed or thrown away.

pub fn timeout(self, timeout: Duration) -> Command

Stop the child if it is still running after timeout, the same way ProcessHandle::cancel would — so it exits cancelled: true rather than hanging a caller that has nobody to press stop.

pub fn start(self) -> Result<(ProcessHandle, Receiver<Event>), StreamError>

Run it, reading events off a channel.

The channel closes on its own when the run ends: the forwarding closure is the only owner of the Sender, and it drops with the reader threads.

pub fn stream<F>(self, callback: F) -> Result<ProcessHandle, StreamError>

where F: FnMut(Event) + Send + Sync + Clone + 'static,

Run it, pushing each event to callback as it happens — for a caller forwarding straight onto a sink rather than looping.

Trait Implementations

impl Clone for Command

fn clone(&self) -> Command

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Command

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl ResolveCli for Command

fn resolve_cli(self) -> Self

Resolve a bare program name to its absolute path, and put that program’s own directory at the front of PATH.