Struct RuntimeCommandSpec 

pub struct RuntimeCommandSpec {
    pub spec: CommandSpec,
    pub handler: CommandHandler,
    pub streaming_handler: Option<StreamingCommandHandler>,
}

Executable leaf command.

RuntimeCommandSpec pairs a CommandSpec with async business logic. This split keeps metadata inspectable for help/search/schema generation before the handler ever runs.

Use RuntimeCommandSpec::new_streaming for commands that emit incremental NDJSON progress events (e.g. long-running deployments with --follow).

Fields

spec: CommandSpec

Declarative command metadata.

handler: CommandHandler

Async command implementation.

streaming_handler: Option<StreamingCommandHandler>

Optional streaming handler. When set, the engine writes NDJSON events to stdout as they arrive instead of collecting a single envelope.

Implementations

impl RuntimeCommandSpec

pub fn new<F, Fut, Output>(spec: CommandSpec, handler: F) -> Self

where F: Fn(CredentialResolver, ValueMap) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<Output>> + Send + 'static, Output: Into<CommandResult> + Send + 'static,

Creates a runtime command with the common handler shape.

The handler receives a lazy CredentialResolver and the effective args. Call resolver.resolve().await? only when the command actually needs a credential; commands that ignore it never trigger an auth flow. The handler returns CommandResult, where data must be JSON-serializable.

pub fn new_with_context<F, Fut, Output>(spec: CommandSpec, handler: F) -> Self

where F: Fn(CommandContext) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<Output>> + Send + 'static, Output: Into<CommandResult> + Send + 'static,

Creates a runtime command with the full invocation context.

pub fn new_streaming<F, Fut>(spec: CommandSpec, handler: F) -> Self

where F: Fn(CommandContext, StreamSender) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<()>> + Send + 'static,

Creates a streaming command that emits NDJSON events to stdout.

The handler receives context and a StreamSender. It should call sender.send(event).await for each progress event, then return Ok(()). The engine writes each event as a JSON line; stdout is flushed after each.

pub fn new_typed<T, F, Fut, Output>(spec: CommandSpec, handler: F) -> Self

where T: FromArgMatches + Send + 'static, F: Fn(CredentialResolver, T) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<Output>> + Send + 'static, Output: Into<CommandResult> + Send + 'static,

Creates a runtime command with typed argument deserialization.

The handler receives a lazy CredentialResolver and the deserialized args struct. Use with CommandSpec::from_args::<T>() to get end-to-end type safety from argument definition through handler consumption.

If the handler also needs the command path, middleware, or user-supplied args, use RuntimeCommandSpec::new_with_context with CommandContext::typed_args instead.

Trait Implementations

impl Clone for RuntimeCommandSpec

fn clone(&self) -> RuntimeCommandSpec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RuntimeCommandSpec

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

Formats the value using the given formatter.