relay-cli 0.1.2

CLI interface for Relay 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
112
113
114
115
116
117
118
119
120

use anyhow::Result;
use serde::{Deserialize, Serialize};

use crate::{
    args::Args, parsers::parse_address, progress::Progress, records::get_agent_record,
    sign::sign_request, storage::Storage, transport::agent_base_url,
};
use relay_lib::prelude::{Address, InboxId, MetaEnvelope, PrivateEnvelope, e2e};

#[derive(Serialize)]
struct InboxSingleReq {
    pub inbox: Option<InboxId>,
    pub gid: String,
}

#[derive(Deserialize)]
struct InboxSingleResp {
    pub message: MetaEnvelope,
}

#[derive(Debug, Clone, clap::Parser)]
#[clap(about = "Read a message by its GID")]
pub struct ReadCmd {
    #[arg(value_parser = parse_address)]
    pub address: Address,

    pub gid: String,

    #[clap(short, long, default_value_t = false)]
    pub silent: bool,

    #[clap(short, long, default_value_t = false)]
    pub raw: bool,
}

impl ReadCmd {
    pub fn execute(&self, _: Args, storage: &mut Storage) -> Result<()> {
        let mut progress = Progress::new(self.silent || self.raw);

        progress.step("Fetching agent keys", "Fetched agent keys");
        let agent_record = get_agent_record(self.address.agent()).map_err(|_| {
            progress.abort("Failed fetch get agent record");
        })?;

        progress.step("Reading identity", "Read identity");
        let identity = storage.root.get_identity(&self.address).unwrap_or_else(|| {
            progress.abort("No identity found for the given address");
        });

        progress.step("Fetching message", "Fetched message");
        let request = sign_request(
            &self.address.canonical(),
            InboxSingleReq {
                inbox: self.address.inbox().cloned(),
                gid: self.gid.clone(),
            },
            &agent_record,
            &identity.signing_key(),
        )
        .map_err(|_| {
            progress.abort("Failed to sign messages request");
        })?;

        let resp = reqwest::blocking::Client::new()
            .get(agent_base_url(self.address.agent())?.join("/inbox/single")?)
            .json(&request)
            .send()
            .map_err(|_| {
                progress.abort("Failed to send inbox single message request");
            })?;

        progress.commit();

        if resp.status().as_u16() == 404 {
            progress.abort("Message not found");
        }

        if !resp.status().is_success() {
            let status = resp.status();
            progress.abort(&format!(
                "Failed to fetch message. Status: {}",
                status.as_u16()
            ));
        }
        let response = resp.json::<InboxSingleResp>()?;

        progress.step("Decrypting message", "Decrypted message");
        let payload = e2e::decrypt(
            &identity.static_secret(),
            &response.message.crypto,
            &response.message.payload.payload,
            &[],
        )
        .expect("Decryption failed");

        progress.step("Parsing message", "Parsed message");
        let private = serde_json::from_slice::<PrivateEnvelope>(&payload)
            .expect("Failed to parse private envelope");

        progress.step("Displaying message", "Displayed message");
        if private.content_type != "plain/text" && !self.raw {
            progress.abort(&format!(
                "Unsupported content type: {}. Pass `--raw` to see dump content.",
                private.content_type
            ));
        }

        if !self.silent && !self.raw {
            progress.nested_section(0, &format!("Message {}", response.message.gid));
            progress.nested(1, &format!("From {}", response.message.from));
            progress.nested(1, &format!("To {}", response.message.to));
            progress.nested(1, &format!("Sent at: {}", response.message.timestamp));
            progress.skip_line();
        }

        println!("{}", String::from_utf8_lossy(&private.message));

        Ok(())
    }
}