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
121
122
123
124
125
126
127
128
129
130
131
132

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

use crate::{
    args::Args,
    parsers::parse_address,
    progress::Progress,
    records::{get_agent_record, get_user_record},
    sign::sign_request,
    storage::Storage,
    transport::agent_base_url,
};
use relay_lib::{
    core::{Uuid, Version, chrono::Utc},
    prelude::{Address, MetaEnvelope, PrivateEnvelope, e2e, sign},
};

#[derive(Serialize)]
struct SendReq {
    pub envelope: MetaEnvelope,
}

#[derive(Debug, Clone, clap::Parser)]
#[clap(about = "Send a message to a user")]
pub struct SendCmd {
    #[clap(value_parser = parse_address)]
    pub address: Address,

    #[clap(short, long, value_parser = parse_address)]
    pub to: Address,

    #[clap(short, long)]
    pub message: Option<String>,
}

impl SendCmd {
    pub fn execute(&self, _: Args, storage: &mut Storage) -> Result<()> {
        let mut progress = Progress::new(false);

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

        progress.step("Fetching recipient keys", "Fetched recipient keys");
        let recipient = get_user_record(self.to.agent(), self.to.user().clone()).map_err(|_| {
            progress.abort("Failed to fetch recipient user record");
        })?;

        progress.step("Reading identity", "Read identity");
        let identity = match storage.root.get_identity(&self.address) {
            Some(id) => id.clone(),
            None => {
                println!("No identity found for address: {}", self.address);
                return Ok(());
            }
        };

        progress.step("Composing message", "Composed message");
        let message = match self.message.clone() {
            Some(msg) => msg,
            None => {
                progress.pause();
                let message = edit::edit(
                    "\n# Please write your message here.\n# Lines starting with '#' will be ignored\n",
                )?;
                progress.resume();
                message
                    .trim()
                    .split('\n')
                    .filter(|line| !line.starts_with('#'))
                    .collect::<Vec<&str>>()
                    .join("\n")
            }
        };

        let private = PrivateEnvelope {
            content_type: "plain/text".to_string(),
            message: message.as_bytes().to_vec(),
        };

        progress.step("Encrypting message", "Encrypted message");
        let rng = relay_lib::crypto::OsRng;
        let payload = serde_json::to_vec(&private).expect("Failed to serialize payload");
        let (meta, ciphertext) =
            e2e::encrypt(rng, &recipient, &payload, &[]).context("encrypting")?;

        progress.step("Signing message", "Signed message");
        let signed = sign::sign(&ciphertext, &identity.signing_key());

        let envelope = MetaEnvelope {
            gid: Uuid::new_v4(),
            version: Version::parse("0.0.1").unwrap(),
            from: self.address.clone(),
            to: self.to.clone(),
            timestamp: Utc::now(),
            crypto: meta,
            payload: signed,
        };

        progress.step("Sending message", "Sent message");
        let request = sign_request(
            &self.address.canonical(),
            SendReq { envelope },
            &agent,
            &identity.signing_key(),
        )?;

        let resp = reqwest::blocking::Client::new()
            .post(agent_base_url(self.address.agent())?.join("/send/user")?)
            .json(&request)
            .send()
            .context("Failed to send messages request")?;

        progress.commit();

        if resp.status().as_u16() == 404 {
            progress.abort("Inbox not found on the Agent.");
        }

        if !resp.status().is_success() {
            let status = resp.status();
            progress.abort(&format!("Failed to send message. Status: {}", status));
        }

        progress.arrow(&format!(
            "Message successfully sent to `{}`",
            self.to.canonical()
        ));
        Ok(())
    }
}