Struct Command 

pub struct Command { /* private fields */ }

A description of a child process to launch: program, arguments, working directory, environment, stdin source, and an optional timeout.

A single builder for everything a run needs. Build it, then either drive it to completion with a helper (output_string, run, …) or start it via a ProcessRunner for streaming/shared groups.

Implementations

impl Command

pub fn new(program: impl AsRef<OsStr>) -> Self

Start a command for program (resolved on PATH).

pub fn arg(self, arg: impl AsRef<OsStr>) -> Self

Append a single argument.

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

where I: IntoIterator<Item = S>, S: AsRef<OsStr>,

Append several arguments.

pub fn current_dir(self, dir: impl AsRef<Path>) -> Self

Set the working directory.

pub fn env(self, key: impl AsRef<OsStr>, value: impl AsRef<OsStr>) -> Self

Set (or, with a None value, remove) an environment variable.

pub fn env_remove(self, key: impl AsRef<OsStr>) -> Self

Remove an environment variable inherited from the parent.

pub fn env_clear(self) -> Self

Clear all inherited environment variables before applying any set here.

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

Provide standard input for the child (see Stdin).

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

Kill the run if it exceeds timeout.

pub fn keep_stdin_open(self) -> Self

Leave stdin open after start so the child can be driven interactively via RunningProcess::standard_input. Has no effect on the bulk run helpers (they always close stdin).

pub fn on_stdout_line<F>(self, handler: F) -> Self

where F: Fn(&str) + Send + Sync + 'static,

Invoke handler for each decoded stdout line as it is read (in addition to capture/streaming). Runs on the pump task; keep it cheap and panic-free.

pub fn on_stderr_line<F>(self, handler: F) -> Self

where F: Fn(&str) + Send + Sync + 'static,

Invoke handler for each decoded stderr line as it is read.

pub fn output_buffer(self, policy: OutputBufferPolicy) -> Self

Cap the in-memory backlog of captured output lines (see OutputBufferPolicy). The pump still drains the pipe; only retention is bounded.

pub fn stdout_encoding(self, encoding: &'static Encoding) -> Self

Decode stdout with encoding instead of UTF-8 (e.g. encoding_rs::SHIFT_JIS).

pub fn stderr_encoding(self, encoding: &'static Encoding) -> Self

Decode stderr with encoding instead of UTF-8.

pub fn encoding(self, encoding: &'static Encoding) -> Self

Decode both stdout and stderr with encoding.

pub fn program(&self) -> &OsStr

The program to launch.

pub fn arguments(&self) -> &[OsString]

The arguments, in order.

pub fn working_dir(&self) -> Option<&Path>

The working-directory override, if one was set.

pub fn env_overrides(&self) -> &[(OsString, Option<OsString>)]

The environment overrides, in order (a None value removes the variable).

pub fn stdin_source(&self) -> Option<&Stdin>

The configured stdin source, if any.

pub fn configured_timeout(&self) -> Option<Duration>

The configured timeout, if any.

pub fn to_tokio_command(&self) -> Command

Build a tokio::process::Command with this command’s program, args, working dir, and environment — stdio wired for capture. Use it to feed the low-level ProcessGroup::spawn escape hatch directly (which returns a raw tokio::process::Child).

pub async fn start(&self) -> Result<RunningProcess>

Start the command and return a live RunningProcess backed by a fresh private group. Use this for streaming stdout (RunningProcess::stdout_lines) or inspecting the process while it runs; keep the handle in scope, as dropping it tears the tree down.

pub async fn output_string(&self) -> Result<ProcessResult<String>>

Run to completion and capture stdout as text, stderr, and the exit code. A non-zero exit is reported, not raised — call ProcessResult::ensure_success to turn it into an error.

pub async fn output_bytes(&self) -> Result<ProcessResult<Vec<u8>>>

Run to completion and capture stdout as raw bytes (plus stderr/exit code).

pub async fn exit_code(&self) -> Result<i32>

Run to completion and return just the exit code (output is discarded). A run that yields no code surfaces as an error — a timeout as Error::Timeout, a signal-kill as an IO error — consistent with ProcessRunnerExt::exit_code and CliClient::code.

pub async fn run(&self) -> Result<String>

Run to completion, requiring a zero exit, and return trimmed stdout.

pub async fn first_line<F>(&self, predicate: F) -> Result<Option<String>>

where F: Fn(&str) -> bool,

Return the first stdout line matching predicate (or the first line when the predicate is trivial), then tear the process down.

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

Formats the value using the given formatter.