simplemailclient 0.2.0

A simple terminal mail client (SMTP send, IMAP fetch) with a TUI.
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use std::fs;
use std::path::PathBuf;
use serde::{Deserialize, Serialize};
use anyhow::{Context, Result};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SmtpConfig {
    pub host: String,
    pub port: u16,
    pub username: String,
    pub password: String,
    pub tls: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ImapConfig {
    pub host: String,
    pub port: u16,
    pub username: String,
    pub password: String,
    pub tls: bool,
    pub inbox_folder: String,
    /// Server folder to move deleted messages into.
    /// Gmail users: set to "[Gmail]/Trash".  Others: "Trash" or "Deleted".
    #[serde(default = "default_trash_folder")]
    pub trash_folder: String,
}

fn default_trash_folder() -> String {
    "Trash".to_string()
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Keybinds {
    pub quit: String,
    pub compose: String,
    pub reply: String,
    pub delete: String,
    pub star: String,
    pub sync: String,
    pub next_folder: String,
    pub prev_folder: String,
}

impl Default for Keybinds {
    fn default() -> Self {
        Self {
            quit: "q".into(),
            compose: "c".into(),
            reply: "r".into(),
            delete: "d".into(),
            star: "s".into(),
            sync: "S".into(),
            next_folder: "Tab".into(),
            prev_folder: "BackTab".into(),
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Config {
    pub identity: String,
    pub display_name: Option<String>,
    /// Domain appended to bare usernames — defaults to "gmail.com"
    #[serde(default = "default_domain")]
    pub domain: String,
    pub smtp: SmtpConfig,
    pub imap: ImapConfig,
    #[serde(default)]
    pub keybinds: Keybinds,
}

fn default_domain() -> String {
    "gmail.com".to_string()
}

impl Config {
    /// Resolve a bare username or full address to a full address.
    /// "hanzo"          → "hanzo@gmail.com"
    /// "hanzo@other.io" → "hanzo@other.io"  (left alone)
    pub fn resolve_address(&self, input: &str) -> String {
        if input.contains('@') {
            input.to_string()
        } else {
            format!("{}@{}", input, self.domain)
        }
    }

    pub fn config_path() -> PathBuf {
        dirs::config_dir()
            .unwrap_or_else(|| PathBuf::from("."))
            .join("mail-rs")
            .join("config.toml")
    }

    pub fn load() -> Result<Self> {
        let path = Self::config_path();

        if !path.exists() {
            // Write a starter config and bail with instructions
            let example = Self::example_toml();
            if let Some(parent) = path.parent() {
                fs::create_dir_all(parent)?;
            }
            fs::write(&path, &example)?;
            eprintln!("No config found. A starter config has been written to:");
            eprintln!("  {}", path.display());
            eprintln!();
            eprintln!("Edit it with your SMTP/IMAP credentials, then re-run mailrs.");
            std::process::exit(0);
        }

        let raw = fs::read_to_string(&path)
            .with_context(|| format!("Cannot read {}", path.display()))?;
        toml::from_str(&raw)
            .with_context(|| format!("Invalid TOML in {}", path.display()))
    }

    fn example_toml() -> String {
        r#"# mail-rs configuration
# ~/.config/mail-rs/config.toml

identity     = "you@gmail.com"
display_name = "Your Name"    # optional
domain       = "gmail.com"    # bare usernames expand to this: mailrs send hanzo → hanzo@gmail.com

[smtp]
host     = "smtp.gmail.com"
port     = 587
username = "you@gmail.com"
password = "your-app-password"   # use a Gmail App Password, not your real password
tls      = true

[imap]
host          = "imap.gmail.com"
port          = 993
username      = "you@gmail.com"
password      = "your-app-password"
tls           = true
inbox_folder  = "INBOX"
trash_folder  = "[Gmail]/Trash"  # Gmail; other providers may use "Trash" or "Deleted"

[keybinds]
quit         = "q"
compose      = "c"
reply        = "r"
delete       = "d"
star         = "s"
sync         = "S"
next_folder  = "Tab"
prev_folder  = "BackTab"
"#
        .to_string()
    }
}