Logo ProcessKit API Reference

CommandVerbs Type

Default-runner convenience verbs on `Command`, callable from F# and C# as `command.StartAsync()` / `command.RunAsync()` etc. They use a shared `JobRunner`; for a custom or injected runner, go through `Runner.*` or call the runner directly. The `cancellationToken` is optional and defaults to `CancellationToken.None`.

Static members

Static member Description

CommandVerbs.ExitCodeAsync(command, ?cancellationToken)

Full Usage: CommandVerbs.ExitCodeAsync(command, ?cancellationToken)

Parameters:
Returns: Task<Result<int, ProcessError>>

The exit code; a signal kill or timeout errors instead of inventing a sentinel code.

command : Command
?cancellationToken : CancellationToken
Returns: Task<Result<int, ProcessError>>

CommandVerbs.FirstLineAsync(command, predicate, ?cancellationToken)

Full Usage: CommandVerbs.FirstLineAsync(command, predicate, ?cancellationToken)

Parameters:
Returns: Task<Result<string option, ProcessError>>

The first stdout line satisfying `predicate`, or `None` if stdout closes without a match.

command : Command
predicate : Func<string, bool>
?cancellationToken : CancellationToken
Returns: Task<Result<string option, ProcessError>>

CommandVerbs.OutputBytesAsync(command, ?cancellationToken)

Full Usage: CommandVerbs.OutputBytesAsync(command, ?cancellationToken)

Parameters:
Returns: Task<Result<ProcessResult<byte[]>, ProcessError>>

Run to completion, capturing stdout as raw bytes.

command : Command
?cancellationToken : CancellationToken
Returns: Task<Result<ProcessResult<byte[]>, ProcessError>>

CommandVerbs.OutputJsonAsync(command, ?options, ?cancellationToken)

Full Usage: CommandVerbs.OutputJsonAsync(command, ?options, ?cancellationToken)

Parameters:
Returns: Task<Result<'T, ProcessError>>
Type parameters: 'T

Require a zero/accepted exit and deserialize the trimmed stdout as JSON into a `'T` via `System.Text.Json` (`options` omitted uses the BCL defaults); invalid JSON becomes `ProcessError.Parse`, just like `ParseAsync`. Give an explicit type argument, e.g. `cmd.OutputJsonAsync<MyRecord>()` — there is no parser argument to infer `'T` from. **Trimming / AOT:** deserializes via reflection-based `System.Text.Json` (`JsonSerializer.Deserialize(string, Type, JsonSerializerOptions)`), so it is not trim-/AOT-safe — pass `options` with a source-generated `JsonSerializerContext`/`JsonTypeInfo<'T>` resolver, or avoid this verb, in a trimmed/NativeAOT app.

command : Command
?options : JsonSerializerOptions
?cancellationToken : CancellationToken
Returns: Task<Result<'T, ProcessError>>

CommandVerbs.OutputStringAsync(command, ?cancellationToken)

Full Usage: CommandVerbs.OutputStringAsync(command, ?cancellationToken)

Parameters:
Returns: Task<Result<ProcessResult<string>, ProcessError>>

Run to completion, capturing stdout as decoded text (a non-zero exit is data).

command : Command
?cancellationToken : CancellationToken
Returns: Task<Result<ProcessResult<string>, ProcessError>>

CommandVerbs.ParseAsync(command, parser, ?cancellationToken)

Full Usage: CommandVerbs.ParseAsync(command, parser, ?cancellationToken)

Parameters:
Returns: Task<Result<'T, ProcessError>>
Type parameters: 'T

Require a zero/accepted exit and parse the trimmed stdout into a `'T`; a thrown parser error becomes `ProcessError.Parse`.

command : Command
parser : Func<string, 'T>
?cancellationToken : CancellationToken
Returns: Task<Result<'T, ProcessError>>

CommandVerbs.ProbeAsync(command, ?cancellationToken)

Full Usage: CommandVerbs.ProbeAsync(command, ?cancellationToken)

Parameters:
Returns: Task<Result<bool, ProcessError>>

Read the exit code as a yes/no answer: 0 -> true, 1 -> false, anything else errors.

command : Command
?cancellationToken : CancellationToken
Returns: Task<Result<bool, ProcessError>>

CommandVerbs.RunAsync(command, ?cancellationToken)

Full Usage: CommandVerbs.RunAsync(command, ?cancellationToken)

Parameters:
Returns: Task<Result<string, ProcessError>>

Require a zero exit and return stdout, trailing whitespace trimmed.

command : Command
?cancellationToken : CancellationToken
Returns: Task<Result<string, ProcessError>>

CommandVerbs.RunUnitAsync(command, ?cancellationToken)

Full Usage: CommandVerbs.RunUnitAsync(command, ?cancellationToken)

Parameters:
Returns: Task<Result<unit, ProcessError>>

Require a zero exit, discarding the captured output.

command : Command
?cancellationToken : CancellationToken
Returns: Task<Result<unit, ProcessError>>

CommandVerbs.StartAsync(command, ?cancellationToken)

Full Usage: CommandVerbs.StartAsync(command, ?cancellationToken)

Parameters:
Returns: Task<Result<RunningProcess, ProcessError>>

Start the command and return a live `RunningProcess`.

command : Command
?cancellationToken : CancellationToken
Returns: Task<Result<RunningProcess, ProcessError>>

CommandVerbs.TryParseAsync(command, parser, ?cancellationToken)

Full Usage: CommandVerbs.TryParseAsync(command, parser, ?cancellationToken)

Parameters:
Returns: Task<Result<'T, ProcessError>>
Type parameters: 'T

Like `ParseAsync`, but with the standard .NET try-parse shape: pass a BCL parser like `int.TryParse` with an explicit type argument (`TryParseAsync<int>(int.TryParse)` — needed because BCL `TryParse` is overloaded). A `false` return becomes `ProcessError.Parse`. (F# can use the `Result`-returning `Runner.tryParse`.)

command : Command
parser : TryParser<'T>
?cancellationToken : CancellationToken
Returns: Task<Result<'T, ProcessError>>

Type something to start searching.