Struct WebSocketExecutor 

pub struct WebSocketExecutor { /* private fields */ }

Execute commands against a remote cli daemon over WebSocket — connection per command on the daemon’s /execute route.

The daemon runs each request IN-PROCESS (no child binary) with the envelope’s AgentArguments applied as a per-request config override (mcp_session_id is ignored server-side; the daemon’s filesystem layout and secret are never overridable). This is what lets a consumer — notably the viewer — run on a different machine than the cli: the only local requirement is network reach to the daemon’s published ws:// address.

Wire contract (one connection per execute):

• client sends TWO text messages: first the AuthEnvelope (always — {"signature": null} against a secretless daemon), then the ExecuteEnvelope, then only reads;
• the daemon sends one text message per stream item — exactly the cli’s stdout JSONL line shapes (a T JSON, or a crate::cli::Error {"type":"error",...} line) — then closes;
• dropping the stream drops the connection, which cancels the in-process run on the daemon.

Auth is the first-message preamble shared by every daemon WebSocket route (headers are never used — browser WebSocket clients can’t set them): when the daemon has a DAEMON_SECRET, the AuthEnvelope must carry the pre-derived sha256=<hex(SHA256(secret))> — set it verbatim via Self::signature — or the daemon closes the connection without a word.

Implementations

impl WebSocketExecutor

pub fn new(url: impl Into<String>) -> Self

pub fn signature(self, signature: impl Into<String>) -> Self

Attach the daemon auth signature (the pre-derived sha256=<hex(SHA256(DAEMON_SECRET))>), sent verbatim in the AuthEnvelope preamble on every connection. Without it the daemon must be running without a secret.

Trait Implementations

impl CommandExecutor for WebSocketExecutor

type Error = Error

type Stream<T> = Pin<Box<dyn Stream<Item = Result<T, Error>> + Send>> where T: Send + 'static

async fn execute<R, T>( &self, request: R, agent_arguments: Option<&AgentArguments>, ) -> Result<Self::Stream<T>, Error>

where R: CommandRequest + Send + Serialize, T: CommandResponse + Serialize + DeserializeOwned + Send + 'static,

async fn execute_one<R, T>( &self, request: R, agent_arguments: Option<&AgentArguments>, ) -> Result<T, Error>

where R: CommandRequest + Send + Serialize, T: CommandResponse + Serialize + DeserializeOwned + Send + 'static,

Convenience for unary commands: run the request and resolve the first item from the stream. Implementations should error with their own “empty stream” variant if the stream closes without producing an item.