qq-cli 0.1.0

A modular Rust QQ task interface for coding agents
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

//! Message, history, collection and media dispatch after instance/session resolution.
use crate::cli::args::{Cli, Command, MessageCommand};
use crate::core::{
    error::{AppError, Result},
    output::Envelope,
};
use crate::messaging::{collection, content, export, history, message, session::Session, write};
use crate::storage::{references::References, state::Store};
use crate::transport::client::Backend;
use std::time::Instant;
pub(super) fn execute<B: Backend>(
    cli: &Cli,
    session: &Session<'_, B>,
    store: &Store,
    references: Option<&References>,
    deadline: Instant,
) -> Result<Envelope> {
    if let Command::Media {
        command:
            crate::cli::args::MediaCommand::Download {
                media_ref, output, ..
            },
    } = &cli.command
    {
        return crate::messaging::media::download(
            media_ref,
            output,
            session,
            references.ok_or_else(AppError::storage)?,
            deadline,
        );
    }
    if let (Some(request), Some(references)) = (collection::request(&cli.command), references) {
        return collection::execute_until(request, session, references, deadline);
    }
    let write_request = match &cli.command {
        Command::Message {
            command: MessageCommand::Send(args),
        } => Some((args.conversation.clone(), None, &args.content)),
        Command::Message {
            command: MessageCommand::Reply(args),
        } => {
            let locator = message::load_locator(
                references.ok_or_else(AppError::storage)?,
                &args.message_ref,
            )?;
            Some((locator.conversation.clone(), Some(locator), &args.content))
        }
        _ => None,
    };
    if let Some((conversation, reply, args)) = write_request {
        session.authorize(Some(&conversation), true)?;
        let segments = content::prepare(args, &conversation, deadline)?;
        return write::execute(
            write::Plan {
                conversation,
                reply,
                segments,
                attachments: args
                    .image
                    .iter()
                    .map(|path| write::Attachment {
                        kind: crate::messaging::attachments::Kind::Image,
                        path: path.clone(),
                    })
                    .chain(args.file.iter().map(|path| write::Attachment {
                        kind: crate::messaging::attachments::Kind::File,
                        path: path.clone(),
                    }))
                    .collect(),
            },
            args.request_id.as_deref(),
            args.dry_run,
            session,
            store,
            references,
            deadline,
        );
    }
    if let Some(references) = references {
        if let Command::Message {
            command: MessageCommand::Export(args),
        } = &cli.command
        {
            return export::execute_until(args, session, references, deadline);
        }
        if let Some((args, query, search)) = history::request(&cli.command) {
            return history::query(args, query, search, session, references, deadline)
                .map(|page| page.envelope());
        }
        if let Command::Message {
            command:
                MessageCommand::Get {
                    message_ref,
                    expand,
                },
        } = &cli.command
        {
            let locator = message::load_locator(references, message_ref)?;
            return Ok(Envelope::typed(message::get(
                message_ref,
                *expand,
                session,
                references,
                deadline,
            )?)
            .scoped(locator.scope));
        }
    }
    super::reads::execute_read_until(&cli.command, session, deadline)
}