Skip to main content

objectiveai_sdk/cli/command/channels/logs/
mod.rs

1//! `channels logs` — the per-channel append-only message log. Leaves:
2//!
3//! - `request` — publisher→owner write.
4//! - `reply` — owner→publisher write.
5//! - `list --all | --pending` — envelope listing (no content).
6//! - `open --entry-id <id>` — reveal one entry's content.
7//! - `subscribe` — long-poll for new entries / channel close.
8
9use crate::cli::command::CommandRequest;
10
11pub mod list;
12pub mod open;
13pub mod reply;
14pub mod request;
15pub mod subscribe;
16
17#[derive(clap::Subcommand)]
18pub enum Command {
19    /// Publisher→owner write.
20    Request(request::Command),
21    /// Owner→publisher write.
22    Reply(reply::Command),
23    /// List the channel log as envelopes (`--all` / `--pending`).
24    List(list::Command),
25    /// Reveal one entry's content by `--entry-id`.
26    Open(open::Command),
27    /// Long-poll for new entries / channel close.
28    Subscribe(subscribe::Command),
29}
30
31#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
32#[serde(untagged)]
33#[schemars(rename = "cli.command.channels.logs.Request")]
34pub enum Request {
35    #[schemars(title = "Request")]
36    Request(request::Request),
37    #[schemars(title = "RequestRequestSchema")]
38    RequestRequestSchema(request::request_schema::Request),
39    #[schemars(title = "RequestResponseSchema")]
40    RequestResponseSchema(request::response_schema::Request),
41    #[schemars(title = "Reply")]
42    Reply(reply::Request),
43    #[schemars(title = "ReplyRequestSchema")]
44    ReplyRequestSchema(reply::request_schema::Request),
45    #[schemars(title = "ReplyResponseSchema")]
46    ReplyResponseSchema(reply::response_schema::Request),
47    #[schemars(title = "List")]
48    List(list::Request),
49    #[schemars(title = "ListRequestSchema")]
50    ListRequestSchema(list::request_schema::Request),
51    #[schemars(title = "ListResponseSchema")]
52    ListResponseSchema(list::response_schema::Request),
53    #[schemars(title = "Open")]
54    Open(open::Request),
55    #[schemars(title = "OpenRequestSchema")]
56    OpenRequestSchema(open::request_schema::Request),
57    #[schemars(title = "OpenResponseSchema")]
58    OpenResponseSchema(open::response_schema::Request),
59    #[schemars(title = "Subscribe")]
60    Subscribe(subscribe::Request),
61    #[schemars(title = "SubscribeRequestSchema")]
62    SubscribeRequestSchema(subscribe::request_schema::Request),
63    #[schemars(title = "SubscribeResponseSchema")]
64    SubscribeResponseSchema(subscribe::response_schema::Request),
65}
66
67// Exempt from json-schema coverage: tier aggregate (see the root
68// `ResponseItem` in command.rs - TS7056).
69#[objectiveai_sdk_macros::json_schema_ignore]
70#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
71#[schemars(rename = "cli.command.channels.logs.ResponseItem")]
72#[serde(untagged)]
73pub enum ResponseItem {
74    #[schemars(title = "Request")]
75    Request(request::Response),
76    #[schemars(title = "RequestRequestSchema")]
77    RequestRequestSchema(request::request_schema::Response),
78    #[schemars(title = "RequestResponseSchema")]
79    RequestResponseSchema(request::response_schema::Response),
80    #[schemars(title = "Reply")]
81    Reply(reply::Response),
82    #[schemars(title = "ReplyRequestSchema")]
83    ReplyRequestSchema(reply::request_schema::Response),
84    #[schemars(title = "ReplyResponseSchema")]
85    ReplyResponseSchema(reply::response_schema::Response),
86    #[schemars(title = "List")]
87    List(list::Response),
88    #[schemars(title = "ListRequestSchema")]
89    ListRequestSchema(list::request_schema::Response),
90    #[schemars(title = "ListResponseSchema")]
91    ListResponseSchema(list::response_schema::Response),
92    #[schemars(title = "Open")]
93    Open(open::Response),
94    #[schemars(title = "OpenRequestSchema")]
95    OpenRequestSchema(open::request_schema::Response),
96    #[schemars(title = "OpenResponseSchema")]
97    OpenResponseSchema(open::response_schema::Response),
98    #[schemars(title = "Subscribe")]
99    Subscribe(subscribe::ResponseItem),
100    #[schemars(title = "SubscribeRequestSchema")]
101    SubscribeRequestSchema(subscribe::request_schema::Response),
102    #[schemars(title = "SubscribeResponseSchema")]
103    SubscribeResponseSchema(subscribe::response_schema::Response),
104}
105
106#[cfg(feature = "mcp")]
107impl crate::cli::command::CommandResponse for ResponseItem {
108    fn into_mcp(self) -> crate::cli::command::McpResponseItem {
109        match self {
110            ResponseItem::Request(v) => v.into_mcp(),
111            ResponseItem::RequestRequestSchema(v) => v.into_mcp(),
112            ResponseItem::RequestResponseSchema(v) => v.into_mcp(),
113            ResponseItem::Reply(v) => v.into_mcp(),
114            ResponseItem::ReplyRequestSchema(v) => v.into_mcp(),
115            ResponseItem::ReplyResponseSchema(v) => v.into_mcp(),
116            ResponseItem::List(v) => v.into_mcp(),
117            ResponseItem::ListRequestSchema(v) => v.into_mcp(),
118            ResponseItem::ListResponseSchema(v) => v.into_mcp(),
119            ResponseItem::Open(v) => v.into_mcp(),
120            ResponseItem::OpenRequestSchema(v) => v.into_mcp(),
121            ResponseItem::OpenResponseSchema(v) => v.into_mcp(),
122            ResponseItem::Subscribe(v) => v.into_mcp(),
123            ResponseItem::SubscribeRequestSchema(v) => v.into_mcp(),
124            ResponseItem::SubscribeResponseSchema(v) => v.into_mcp(),
125        }
126    }
127}
128
129impl TryFrom<Command> for Request {
130    type Error = crate::cli::command::FromArgsError;
131    fn try_from(command: Command) -> Result<Self, Self::Error> {
132        match command {
133            Command::Request(cmd) => match cmd.schema {
134                None => Ok(Request::Request(request::Request::try_from(cmd.args)?)),
135                Some(request::Schema::RequestSchema(args)) => Ok(
136                    Request::RequestRequestSchema(request::request_schema::Request::try_from(args)?),
137                ),
138                Some(request::Schema::ResponseSchema(args)) => Ok(
139                    Request::RequestResponseSchema(request::response_schema::Request::try_from(args)?),
140                ),
141            },
142            Command::Reply(cmd) => match cmd.schema {
143                None => Ok(Request::Reply(reply::Request::try_from(cmd.args)?)),
144                Some(reply::Schema::RequestSchema(args)) => Ok(
145                    Request::ReplyRequestSchema(reply::request_schema::Request::try_from(args)?),
146                ),
147                Some(reply::Schema::ResponseSchema(args)) => Ok(
148                    Request::ReplyResponseSchema(reply::response_schema::Request::try_from(args)?),
149                ),
150            },
151            Command::List(cmd) => match cmd.schema {
152                None => Ok(Request::List(list::Request::try_from(cmd.args)?)),
153                Some(list::Schema::RequestSchema(args)) => Ok(
154                    Request::ListRequestSchema(list::request_schema::Request::try_from(args)?),
155                ),
156                Some(list::Schema::ResponseSchema(args)) => Ok(
157                    Request::ListResponseSchema(list::response_schema::Request::try_from(args)?),
158                ),
159            },
160            Command::Open(cmd) => match cmd.schema {
161                None => Ok(Request::Open(open::Request::try_from(cmd.args)?)),
162                Some(open::Schema::RequestSchema(args)) => Ok(
163                    Request::OpenRequestSchema(open::request_schema::Request::try_from(args)?),
164                ),
165                Some(open::Schema::ResponseSchema(args)) => Ok(
166                    Request::OpenResponseSchema(open::response_schema::Request::try_from(args)?),
167                ),
168            },
169            Command::Subscribe(cmd) => match cmd.schema {
170                None => Ok(Request::Subscribe(subscribe::Request::try_from(cmd.args)?)),
171                Some(subscribe::Schema::RequestSchema(args)) => Ok(
172                    Request::SubscribeRequestSchema(subscribe::request_schema::Request::try_from(args)?),
173                ),
174                Some(subscribe::Schema::ResponseSchema(args)) => Ok(
175                    Request::SubscribeResponseSchema(subscribe::response_schema::Request::try_from(args)?),
176                ),
177            },
178        }
179    }
180}
181
182impl CommandRequest for Request {
183    fn request_base(&self) -> &crate::cli::command::RequestBase {
184        match self {
185            Request::Request(inner) => inner.request_base(),
186            Request::RequestRequestSchema(inner) => inner.request_base(),
187            Request::RequestResponseSchema(inner) => inner.request_base(),
188            Request::Reply(inner) => inner.request_base(),
189            Request::ReplyRequestSchema(inner) => inner.request_base(),
190            Request::ReplyResponseSchema(inner) => inner.request_base(),
191            Request::List(inner) => inner.request_base(),
192            Request::ListRequestSchema(inner) => inner.request_base(),
193            Request::ListResponseSchema(inner) => inner.request_base(),
194            Request::Open(inner) => inner.request_base(),
195            Request::OpenRequestSchema(inner) => inner.request_base(),
196            Request::OpenResponseSchema(inner) => inner.request_base(),
197            Request::Subscribe(inner) => inner.request_base(),
198            Request::SubscribeRequestSchema(inner) => inner.request_base(),
199            Request::SubscribeResponseSchema(inner) => inner.request_base(),
200        }
201    }
202
203    fn request_base_mut(&mut self) -> Option<&mut crate::cli::command::RequestBase> {
204        match self {
205            Request::Request(inner) => inner.request_base_mut(),
206            Request::RequestRequestSchema(inner) => inner.request_base_mut(),
207            Request::RequestResponseSchema(inner) => inner.request_base_mut(),
208            Request::Reply(inner) => inner.request_base_mut(),
209            Request::ReplyRequestSchema(inner) => inner.request_base_mut(),
210            Request::ReplyResponseSchema(inner) => inner.request_base_mut(),
211            Request::List(inner) => inner.request_base_mut(),
212            Request::ListRequestSchema(inner) => inner.request_base_mut(),
213            Request::ListResponseSchema(inner) => inner.request_base_mut(),
214            Request::Open(inner) => inner.request_base_mut(),
215            Request::OpenRequestSchema(inner) => inner.request_base_mut(),
216            Request::OpenResponseSchema(inner) => inner.request_base_mut(),
217            Request::Subscribe(inner) => inner.request_base_mut(),
218            Request::SubscribeRequestSchema(inner) => inner.request_base_mut(),
219            Request::SubscribeResponseSchema(inner) => inner.request_base_mut(),
220        }
221    }
222}
223
224#[cfg(feature = "cli-executor")]
225pub async fn execute<E: crate::cli::command::CommandExecutor>(
226    executor: &E,
227    request: Request,
228    identity: Option<&crate::identity::Identity>,
229) -> Result<
230    std::pin::Pin<Box<dyn futures::Stream<Item = Result<ResponseItem, E::Error>> + Send>>,
231    E::Error,
232> {
233    use futures::StreamExt;
234    let stream: std::pin::Pin<
235        Box<dyn futures::Stream<Item = Result<ResponseItem, E::Error>> + Send>,
236    > = match request {
237        Request::Request(req) => {
238            let value = request::execute(executor, req, identity).await?;
239            Box::pin(crate::cli::command::StreamOnce::new(Ok(ResponseItem::Request(value))))
240        }
241        Request::RequestRequestSchema(req) => {
242            let value = request::request_schema::execute(executor, req, identity).await?;
243            Box::pin(crate::cli::command::StreamOnce::new(Ok(ResponseItem::RequestRequestSchema(value))))
244        }
245        Request::RequestResponseSchema(req) => {
246            let value = request::response_schema::execute(executor, req, identity).await?;
247            Box::pin(crate::cli::command::StreamOnce::new(Ok(ResponseItem::RequestResponseSchema(value))))
248        }
249        Request::Reply(req) => {
250            let value = reply::execute(executor, req, identity).await?;
251            Box::pin(crate::cli::command::StreamOnce::new(Ok(ResponseItem::Reply(value))))
252        }
253        Request::ReplyRequestSchema(req) => {
254            let value = reply::request_schema::execute(executor, req, identity).await?;
255            Box::pin(crate::cli::command::StreamOnce::new(Ok(ResponseItem::ReplyRequestSchema(value))))
256        }
257        Request::ReplyResponseSchema(req) => {
258            let value = reply::response_schema::execute(executor, req, identity).await?;
259            Box::pin(crate::cli::command::StreamOnce::new(Ok(ResponseItem::ReplyResponseSchema(value))))
260        }
261        Request::List(req) => {
262            let value = list::execute(executor, req, identity).await?;
263            Box::pin(crate::cli::command::StreamOnce::new(Ok(ResponseItem::List(value))))
264        }
265        Request::ListRequestSchema(req) => {
266            let value = list::request_schema::execute(executor, req, identity).await?;
267            Box::pin(crate::cli::command::StreamOnce::new(Ok(ResponseItem::ListRequestSchema(value))))
268        }
269        Request::ListResponseSchema(req) => {
270            let value = list::response_schema::execute(executor, req, identity).await?;
271            Box::pin(crate::cli::command::StreamOnce::new(Ok(ResponseItem::ListResponseSchema(value))))
272        }
273        Request::Open(req) => {
274            let value = open::execute(executor, req, identity).await?;
275            Box::pin(crate::cli::command::StreamOnce::new(Ok(ResponseItem::Open(value))))
276        }
277        Request::OpenRequestSchema(req) => {
278            let value = open::request_schema::execute(executor, req, identity).await?;
279            Box::pin(crate::cli::command::StreamOnce::new(Ok(ResponseItem::OpenRequestSchema(value))))
280        }
281        Request::OpenResponseSchema(req) => {
282            let value = open::response_schema::execute(executor, req, identity).await?;
283            Box::pin(crate::cli::command::StreamOnce::new(Ok(ResponseItem::OpenResponseSchema(value))))
284        }
285        Request::Subscribe(req) => {
286            let inner = subscribe::execute(executor, req, identity).await?;
287            Box::pin(inner.map(|r| r.map(ResponseItem::Subscribe)))
288        }
289        Request::SubscribeRequestSchema(req) => {
290            let value = subscribe::request_schema::execute(executor, req, identity).await?;
291            Box::pin(crate::cli::command::StreamOnce::new(Ok(ResponseItem::SubscribeRequestSchema(value))))
292        }
293        Request::SubscribeResponseSchema(req) => {
294            let value = subscribe::response_schema::execute(executor, req, identity).await?;
295            Box::pin(crate::cli::command::StreamOnce::new(Ok(ResponseItem::SubscribeResponseSchema(value))))
296        }
297    };
298    Ok(stream)
299}
300
301#[cfg(feature = "cli-executor")]
302pub async fn execute_transform<E: crate::cli::command::CommandExecutor>(
303    executor: &E,
304    request: Request,
305    transform: crate::cli::command::Transform,
306    identity: Option<&crate::identity::Identity>,
307) -> Result<
308    std::pin::Pin<Box<dyn futures::Stream<Item = Result<serde_json::Value, E::Error>> + Send>>,
309    E::Error,
310> {
311    let stream: std::pin::Pin<
312        Box<dyn futures::Stream<Item = Result<serde_json::Value, E::Error>> + Send>,
313    > = match request {
314        Request::Request(req) => {
315            let value = request::execute_transform(executor, req, transform, identity).await?;
316            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
317        }
318        Request::RequestRequestSchema(req) => {
319            let value = request::request_schema::execute_transform(executor, req, transform, identity).await?;
320            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
321        }
322        Request::RequestResponseSchema(req) => {
323            let value = request::response_schema::execute_transform(executor, req, transform, identity).await?;
324            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
325        }
326        Request::Reply(req) => {
327            let value = reply::execute_transform(executor, req, transform, identity).await?;
328            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
329        }
330        Request::ReplyRequestSchema(req) => {
331            let value = reply::request_schema::execute_transform(executor, req, transform, identity).await?;
332            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
333        }
334        Request::ReplyResponseSchema(req) => {
335            let value = reply::response_schema::execute_transform(executor, req, transform, identity).await?;
336            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
337        }
338        Request::List(req) => {
339            let value = list::execute_transform(executor, req, transform, identity).await?;
340            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
341        }
342        Request::ListRequestSchema(req) => {
343            let value = list::request_schema::execute_transform(executor, req, transform, identity).await?;
344            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
345        }
346        Request::ListResponseSchema(req) => {
347            let value = list::response_schema::execute_transform(executor, req, transform, identity).await?;
348            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
349        }
350        Request::Open(req) => {
351            let value = open::execute_transform(executor, req, transform, identity).await?;
352            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
353        }
354        Request::OpenRequestSchema(req) => {
355            let value = open::request_schema::execute_transform(executor, req, transform, identity).await?;
356            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
357        }
358        Request::OpenResponseSchema(req) => {
359            let value = open::response_schema::execute_transform(executor, req, transform, identity).await?;
360            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
361        }
362        Request::Subscribe(req) => {
363            let inner = subscribe::execute_transform(executor, req, transform, identity).await?;
364            Box::pin(inner)
365        }
366        Request::SubscribeRequestSchema(req) => {
367            let value = subscribe::request_schema::execute_transform(executor, req, transform, identity).await?;
368            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
369        }
370        Request::SubscribeResponseSchema(req) => {
371            let value = subscribe::response_schema::execute_transform(executor, req, transform, identity).await?;
372            Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
373        }
374    };
375    Ok(stream)
376}
377
378/// `/listen` mirror of [`Request`]. See [`crate::daemon::command_listener`].
379#[cfg(all(feature = "cli", feature = "daemon"))]
380pub enum ListenerExecution {
381    Request(request::ListenerExecution),
382    RequestRequestSchema(request::request_schema::ListenerExecution),
383    RequestResponseSchema(request::response_schema::ListenerExecution),
384    Reply(reply::ListenerExecution),
385    ReplyRequestSchema(reply::request_schema::ListenerExecution),
386    ReplyResponseSchema(reply::response_schema::ListenerExecution),
387    List(list::ListenerExecution),
388    ListRequestSchema(list::request_schema::ListenerExecution),
389    ListResponseSchema(list::response_schema::ListenerExecution),
390    Open(open::ListenerExecution),
391    OpenRequestSchema(open::request_schema::ListenerExecution),
392    OpenResponseSchema(open::response_schema::ListenerExecution),
393    Subscribe(subscribe::ListenerExecution),
394    SubscribeRequestSchema(subscribe::request_schema::ListenerExecution),
395    SubscribeResponseSchema(subscribe::response_schema::ListenerExecution),
396}