kaish_types/kernel.rs
1//! Kernel-level execution options.
2//!
3//! `ExecuteOptions` is the input to a single kernel `execute` call. It collects
4//! the per-call knobs (variables, timeout, cancellation) so embedders don't need
5//! to manage half a dozen execute-method overloads.
6
7use std::collections::{BTreeMap, HashMap};
8use std::path::PathBuf;
9use std::time::Duration;
10
11use tokio_util::sync::CancellationToken;
12
13use crate::value::Value;
14
15/// Per-call options for `Kernel::execute_with_options`.
16///
17/// Construct with `ExecuteOptions::new()` and the chainable `with_*` builders,
18/// or via `Default`.
19///
20/// # Cancellation vs. timeout — embedder note
21///
22/// If a `cancel_token` is supplied, it is **raced** against the kernel's
23/// internal token. The kernel does NOT cancel the embedder's token on its
24/// own timeouts — it cancels its internal token and returns exit code 124.
25/// So `your_token.is_cancelled()` after the call returns reflects only
26/// whether *you* (or someone sharing your token) cancelled, not whether the
27/// kernel timed out. Distinguish via the returned `ExecResult.code`:
28/// `124` = kernel timeout, `130` = cancellation (Ctrl-C / `Kernel::cancel`).
29#[derive(Default, Clone)]
30pub struct ExecuteOptions {
31 /// Variables exported into this call's environment (per-call overlay).
32 pub vars: HashMap<String, Value>,
33 /// Per-call timeout. Overrides `KernelConfig::request_timeout`.
34 ///
35 /// `None` means no timeout (or whatever the kernel-config default is).
36 /// `Some(Duration::ZERO)` returns exit 124 immediately without spawning
37 /// anything — useful for tests and dry-run paths.
38 /// Any other `Some(d)` lets the kernel run for at most `d` before cancelling
39 /// (which kills external children with the configured grace) and returning 124.
40 pub timeout: Option<Duration>,
41 /// Optional externally-owned cancellation token, *raced* against the kernel's
42 /// internal token. Either firing cancels the request and kills any running
43 /// external children. The kernel does not store this token in its own state —
44 /// it's a per-call read-only input, so embedders are free to drop or reuse
45 /// the original token after the call returns. CancellationToken is internally
46 /// `Arc`-shared, so `clone()` it into the builder if you want to keep your
47 /// original handle.
48 pub cancel_token: Option<CancellationToken>,
49 /// Per-call working directory override.
50 ///
51 /// When `Some(path)`, the kernel runs this call as if `cd path` happened
52 /// first, then restores the prior cwd on return. Useful for embedders that
53 /// run scripts in workspace contexts (notebook cells, per-tool dirs)
54 /// without polluting the long-lived kernel's cwd.
55 pub cwd: Option<PathBuf>,
56 /// W3C `traceparent` of the embedder's active span, e.g.
57 /// `"00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01"`. When set,
58 /// the kernel's execution span parents onto it, so kaish's spans appear as
59 /// children of the embedder's trace rather than as orphan roots.
60 pub traceparent: Option<String>,
61 /// W3C `tracestate` (vendor-specific list) that rides alongside
62 /// `traceparent`. Per the W3C spec, `tracestate` is meaningless without a
63 /// `traceparent`, so the kernel ignores it unless `traceparent` is also set.
64 pub tracestate: Option<String>,
65 /// W3C baggage — cross-cutting identifiers (owner, connection, tenant, …)
66 /// the embedder wants stamped onto the trace. Propagated to every child
67 /// span. Independent of `traceparent`: baggage with no trace context starts
68 /// a fresh root that still carries the identifiers.
69 pub baggage: BTreeMap<String, String>,
70 /// Standard input for this call, consumed by the first top-level command
71 /// that reads stdin (shell semantics — a later reader sees nothing).
72 ///
73 /// Lets a non-interactive frontend feed piped input, e.g.
74 /// `printf '…' | kaish -c 'sort'`. Without it a bare top-level builtin
75 /// reading stdin has no input source and silently produces nothing. It is
76 /// `String`-typed to match `ExecContext::set_stdin`; binary stdin is fed
77 /// through files/VFS, not this knob.
78 pub stdin: Option<String>,
79}
80
81impl ExecuteOptions {
82 pub fn new() -> Self {
83 Self::default()
84 }
85
86 /// Replace the entire vars overlay with the given map.
87 pub fn with_vars(mut self, vars: HashMap<String, Value>) -> Self {
88 self.vars = vars;
89 self
90 }
91
92 /// Add a single variable to the overlay (extending; last write wins).
93 pub fn with_var(mut self, name: impl Into<String>, value: Value) -> Self {
94 self.vars.insert(name.into(), value);
95 self
96 }
97
98 pub fn with_timeout(mut self, timeout: Duration) -> Self {
99 self.timeout = Some(timeout);
100 self
101 }
102
103 pub fn with_cancel_token(mut self, token: CancellationToken) -> Self {
104 self.cancel_token = Some(token);
105 self
106 }
107
108 /// Run this call as if `cd path` had happened first; the prior cwd is
109 /// restored on return.
110 pub fn with_cwd(mut self, cwd: PathBuf) -> Self {
111 self.cwd = Some(cwd);
112 self
113 }
114
115 /// Set the W3C `traceparent` the kernel's execution span should parent onto.
116 pub fn with_traceparent(mut self, traceparent: impl Into<String>) -> Self {
117 self.traceparent = Some(traceparent.into());
118 self
119 }
120
121 /// Set the W3C `tracestate` that rides alongside `traceparent`. Ignored by
122 /// the kernel unless a `traceparent` is also present.
123 pub fn with_tracestate(mut self, tracestate: impl Into<String>) -> Self {
124 self.tracestate = Some(tracestate.into());
125 self
126 }
127
128 /// Replace the entire baggage map with the given identifiers.
129 pub fn with_baggage(mut self, baggage: BTreeMap<String, String>) -> Self {
130 self.baggage = baggage;
131 self
132 }
133
134 /// Add a single baggage identifier (extending; last write wins).
135 pub fn with_baggage_entry(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
136 self.baggage.insert(key.into(), value.into());
137 self
138 }
139
140 /// Set the standard input fed to this call's first stdin-reading command.
141 pub fn with_stdin(mut self, stdin: impl Into<String>) -> Self {
142 self.stdin = Some(stdin.into());
143 self
144 }
145}