Struct CommandSpec

Source

pub struct CommandSpec {
    pub program: OsString,
    pub args: Vec<OsString>,
    pub cwd: Option<PathBuf>,
    pub env: Option<HashMap<OsString, OsString>>,
}

Expand description

Specification for a command to execute.

All process execution goes through this type to ensure argv-style invocation. This prevents shell injection attacks by ensuring arguments are passed as discrete elements rather than shell strings.

§Security

CommandSpec enforces that:

Arguments are Vec<OsString>, NOT shell strings
No shell string evaluation (sh -c, cmd /C) is used
Arguments cross trust boundaries as discrete elements

§Example

use xchecker_utils::runner::CommandSpec;
use std::ffi::OsString;

let cmd = CommandSpec::new("claude")
    .arg("--print")
    .arg("--output-format")
    .arg("json")
    .cwd("/path/to/workspace");

assert_eq!(cmd.program, OsString::from("claude"));
assert_eq!(cmd.args.len(), 3);

Fields§

§program: OsString

The program to execute

§args: Vec<OsString>

Arguments as discrete elements (NOT shell strings)

§cwd: Option<PathBuf>

Optional working directory

§env: Option<HashMap<OsString, OsString>>

Optional environment overrides

Implementations§

Source §

impl CommandSpec

Source

pub fn new(program: impl Into<OsString>) -> Self

Create a new CommandSpec with the given program.

§Arguments

program - The program to execute. Can be any type that converts to OsString.

§Example

use xchecker_utils::runner::CommandSpec;

let cmd = CommandSpec::new("claude");

Source

pub fn arg(self, arg: impl Into<OsString>) -> Self

Add a single argument to the command.

Arguments are stored as discrete OsString elements, ensuring no shell interpretation occurs.

§Arguments

arg - The argument to add. Can be any type that converts to OsString.

§Example

use xchecker_utils::runner::CommandSpec;

let cmd = CommandSpec::new("claude")
    .arg("--print")
    .arg("--verbose");

Source

pub fn args<I, S>(self, args: I) -> Self
where I: IntoIterator<Item = S>, S: Into<OsString>,

Add multiple arguments to the command.

Arguments are stored as discrete OsString elements, ensuring no shell interpretation occurs.

§Arguments

args - An iterator of arguments to add.

§Example

use xchecker_utils::runner::CommandSpec;

let cmd = CommandSpec::new("claude")
    .args(["--print", "--output-format", "json"]);

Source

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

Set the working directory for the command.

§Arguments

cwd - The working directory path.

§Example

use xchecker_utils::runner::CommandSpec;

let cmd = CommandSpec::new("claude")
    .cwd("/path/to/workspace");

Source

pub fn env(self, key: impl Into<OsString>, value: impl Into<OsString>) -> Self

Set an environment variable for the command.

§Arguments

key - The environment variable name.
value - The environment variable value.

§Example

use xchecker_utils::runner::CommandSpec;

let cmd = CommandSpec::new("claude")
    .env("CLAUDE_API_KEY", "sk-...")
    .env("DEBUG", "1");

Source

pub fn envs<I, K, V>(self, envs: I) -> Self
where I: IntoIterator<Item = (K, V)>, K: Into<OsString>, V: Into<OsString>,

Set multiple environment variables for the command.

§Arguments

envs - An iterator of (key, value) pairs.

§Example

use xchecker_utils::runner::CommandSpec;

let cmd = CommandSpec::new("claude")
    .envs([("DEBUG", "1"), ("VERBOSE", "true")]);

Source

pub fn to_command(&self) -> Command

Convert this CommandSpec into a std::process::Command.

This is the primary way to execute a CommandSpec. The resulting Command uses argv-style argument passing, ensuring no shell injection is possible.

§Example

use xchecker_utils::runner::CommandSpec;

let cmd = CommandSpec::new("echo")
    .arg("hello")
    .arg("world");

let output = cmd.to_command().output().expect("failed to execute");

Source

pub fn to_tokio_command(&self) -> TokioCommand

Convert this CommandSpec into a tokio::process::Command.

This is used for async execution with timeout support.

§Example

use xchecker_utils::runner::CommandSpec;

let cmd = CommandSpec::new("echo")
    .arg("hello");

let output = cmd.to_tokio_command().output().await.expect("failed to execute");