Module std.process

Process execution.

run and run_argv execute a command to completion and capture its output. start launches a Command (never through a shell) and returns a Child whose piped stdio are ordinary Stream<bytes> and Sink<bytes> values. Command.output(CaptureLimits { timeout, max_output_bytes }) captures both output streams with a runtime limit and a shared byte budget.

start and Command.output inherit the parent's environment and working directory. start_with_options and Command.output_with_options accept a SpawnOptions snapshot: Environment.Inherit(bindings) overlays inherited variables, while Environment.Clear(bindings) passes only explicit bindings, including none. Neither operation changes process-global state. Both spawn paths use the same owned Child and native lifecycle.

A Child owns its process until it is reaped. wait suspends the calling task and holds no thread while the child runs: it parks on the I/O reactor (a pidfd on Linux, a kqueue process filter on FreeBSD and macOS) or, on Windows, on the system thread pool's wait for the process handle. Any number of tasks may wait on children at once. The reaped status is kept, so a second wait returns it again and a later terminate or kill does nothing. Dropping a Child that is still running kills and reaps it.

A child's stdout and stderr streams are select sources on every native host. A losing selection leaves its data available for the next receive. Windows retains at most 64 KiB of completed output per pipe; pending reads use overlapped I/O and release their buffers after cancellation completes.

Examples

import std.encoding.utf8;
import std.process;

fn main() {
    let output = process.run_argv("printf", ["<%s>", "hello world"]).expect("printf runs");
    println(output.stdout);

    var command = process.command("cat", []);
    command.stdin = process.Stdio.Piped;
    command.stdout = process.Stdio.Piped;
    let child = process.start(command).expect("cat starts");
    let input = child.stdin().expect("stdin is piped");
    let echoed = child.stdout().expect("stdout is piped");
    input.send("ping".to_bytes()).expect("cat reads");
    input.finish();
    for chunk in echoed {
        println(utf8.decode_lossy(chunk));
    }
    println(f"{child.wait():?}");
}

import std.process;

fn main() {
    let options = process.SpawnOptions {
        environment: .Clear([process.EnvVar { name: "LANG", value: "C" }]),
        cwd: .None,
    };
    let command = process.command("tool", ["--version"]);
    let output = command.output_with_options(
        process.CaptureLimits { timeout: 5s, max_output_bytes: 4096 },
        options,
    ).expect("tool runs with only the approved binding");
    println(output.stdout);
}