prepare v0.7.1

Those commits have been stashed then applied due to merge issue:

add ability to sync specific folders f7585eb
add expunge command 1c0b7fb
update readme links to documentation e1c8cf5
fix other doc typos 9c27165
reword title of the project 1eaac7d
reword title of the project bis a7419d6
fix broken links in changelog 26b0311
prepare v0.7.1 2b5e58e

src/config/config.rs

@@ -31,14 +31,22 @@ pub struct DeserializedConfig {
 
     pub email_listing_page_size: Option<usize>,
     pub email_reading_headers: Option<Vec<String>>,
-    #[serde(default, with = "EmailTextPlainFormatOptionDef", skip_serializing_if = "Option::is_none")]
+    #[serde(
+        default,
+        with = "EmailTextPlainFormatOptionDef",
+        skip_serializing_if = "Option::is_none"
+    )]
     pub email_reading_format: Option<EmailTextPlainFormat>,
     pub email_reading_verify_cmd: Option<String>,
     pub email_reading_decrypt_cmd: Option<String>,
     pub email_writing_headers: Option<Vec<String>>,
     pub email_writing_sign_cmd: Option<String>,
     pub email_writing_encrypt_cmd: Option<String>,
-    #[serde(default, with = "EmailHooksOptionDef", skip_serializing_if = "Option::is_none")]
+    #[serde(
+        default,
+        with = "EmailHooksOptionDef",
+        skip_serializing_if = "Option::is_none"
+    )]
     pub email_hooks: Option<EmailHooks>,
 
     #[serde(flatten)]
@@ -115,12 +123,10 @@ impl DeserializedConfig {
 
 #[cfg(test)]
 mod tests {
-    use himalaya_lib::{EmailSender, SendmailConfig, SmtpConfig};
+    use himalaya_lib::{EmailSender, MaildirConfig, SendmailConfig, SmtpConfig};
 
     #[cfg(feature = "imap-backend")]
     use himalaya_lib::ImapConfig;
-    #[cfg(feature = "maildir-backend")]
-    use himalaya_lib::MaildirConfig;
     #[cfg(feature = "notmuch-backend")]
     use himalaya_lib::NotmuchConfig;
 
@@ -131,7 +137,6 @@ mod tests {
 
     #[cfg(feature = "imap-backend")]
     use crate::account::DeserializedImapAccountConfig;
-    #[cfg(feature = "maildir-backend")]
     use crate::account::DeserializedMaildirAccountConfig;
     #[cfg(feature = "notmuch-backend")]
     use crate::account::DeserializedNotmuchAccountConfig;

src/config/prelude.rs

@@ -1,13 +1,13 @@
-use himalaya_lib::{EmailHooks, EmailSender, EmailTextPlainFormat, SendmailConfig, SmtpConfig};
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 
+use himalaya_lib::{
+    EmailHooks, EmailSender, EmailTextPlainFormat, MaildirConfig, SendmailConfig, SmtpConfig,
+};
+
 #[cfg(feature = "imap-backend")]
 use himalaya_lib::ImapConfig;
 
-#[cfg(feature = "maildir-backend")]
-use himalaya_lib::MaildirConfig;
-
 #[cfg(feature = "notmuch-backend")]
 use himalaya_lib::NotmuchConfig;
 
@@ -56,7 +56,6 @@ pub struct ImapConfigDef {
     pub watch_cmds: Option<Vec<String>>,
 }
 
-#[cfg(feature = "maildir-backend")]
 #[derive(Debug, Default, Clone, Eq, PartialEq, Deserialize, Serialize)]
 #[serde(remote = "MaildirConfig")]
 pub struct MaildirConfigDef {

src/config/wizard/maildir.rs

@@ -7,7 +7,6 @@ use dialoguer::Input;
 use dirs::home_dir;
 use himalaya_lib::MaildirConfig;
 
-#[cfg(feature = "maildir-backend")]
 pub(crate) fn configure(base: DeserializedBaseAccountConfig) -> Result<DeserializedAccountConfig> {
     let input = if let Some(home) = home_dir() {
         Input::with_theme(&*THEME)

src/config/wizard/mod.rs

@@ -1,6 +1,5 @@
 #[cfg(feature = "imap-backend")]
 mod imap;
-#[cfg(feature = "maildir-backend")]
 mod maildir;
 #[cfg(feature = "notmuch-backend")]
 mod notmuch;
@@ -18,10 +17,9 @@ use once_cell::sync::Lazy;
 use std::{fs, process};
 
 const BACKENDS: &[&str] = &[
+    "Maildir",
     #[cfg(feature = "imap-backend")]
     "IMAP",
-    #[cfg(feature = "maildir-backend")]
-    "Maildir",
     #[cfg(feature = "notmuch-backend")]
     "Notmuch",
 ];
@@ -102,10 +100,9 @@ pub(crate) fn wizard() -> Result<DeserializedConfig> {
 
     match default {
         Some(DeserializedAccountConfig::None(default)) => default.default = Some(true),
+        Some(DeserializedAccountConfig::Maildir(default)) => default.base.default = Some(true),
         #[cfg(feature = "imap-backend")]
         Some(DeserializedAccountConfig::Imap(default)) => default.base.default = Some(true),
-        #[cfg(feature = "maildir-backend")]
-        Some(DeserializedAccountConfig::Maildir(default)) => default.base.default = Some(true),
         #[cfg(feature = "notmuch-backend")]
         Some(DeserializedAccountConfig::Notmuch(default)) => default.base.default = Some(true),
         _ => {}
@@ -141,10 +138,9 @@ fn configure_account() -> Result<Option<DeserializedAccountConfig>> {
         .interact_opt()?;
 
     match backend {
+        Some(idx) if BACKENDS[idx] == "Maildir" => Ok(Some(maildir::configure(base)?)),
         #[cfg(feature = "imap-backend")]
         Some(idx) if BACKENDS[idx] == "IMAP" => Ok(Some(imap::configure(base)?)),
-        #[cfg(feature = "maildir-backend")]
-        Some(idx) if BACKENDS[idx] == "Maildir" => Ok(Some(maildir::configure(base)?)),
         #[cfg(feature = "notmuch-backend")]
         Some(idx) if BACKENDS[idx] == "Notmuch" => Ok(Some(notmuch::configure(base)?)),
         _ => Ok(None),

src/domain/account/accounts.rs

@@ -40,14 +40,13 @@ impl From<Iter<'_, String, DeserializedAccountConfig>> for Accounts {
     fn from(map: Iter<'_, String, DeserializedAccountConfig>) -> Self {
         let mut accounts: Vec<_> = map
             .map(|(name, account)| match account {
+                DeserializedAccountConfig::Maildir(config) => {
+                    Account::new(name, "maildir", config.base.default.unwrap_or_default())
+                }
                 #[cfg(feature = "imap-backend")]
                 DeserializedAccountConfig::Imap(config) => {
                     Account::new(name, "imap", config.base.default.unwrap_or_default())
                 }
-                #[cfg(feature = "maildir-backend")]
-                DeserializedAccountConfig::Maildir(config) => {
-                    Account::new(name, "maildir", config.base.default.unwrap_or_default())
-                }
                 #[cfg(feature = "notmuch-backend")]
                 DeserializedAccountConfig::Notmuch(config) => {
                     Account::new(name, "notmuch", config.base.default.unwrap_or_default())

src/domain/account/config.rs

@@ -3,14 +3,13 @@
 //! This module contains the raw deserialized representation of an
 //! account in the accounts section of the user configuration file.
 
-use himalaya_lib::{AccountConfig, BackendConfig, EmailHooks, EmailSender, EmailTextPlainFormat};
+use himalaya_lib::{
+    AccountConfig, BackendConfig, EmailHooks, EmailSender, EmailTextPlainFormat, MaildirConfig,
+};
 
 #[cfg(feature = "imap-backend")]
 use himalaya_lib::ImapConfig;
 
-#[cfg(feature = "maildir-backend")]
-use himalaya_lib::MaildirConfig;
-
 #[cfg(feature = "notmuch-backend")]
 use himalaya_lib::NotmuchConfig;
 
@@ -24,10 +23,9 @@ use crate::config::{prelude::*, DeserializedConfig};
 #[serde(tag = "backend", rename_all = "snake_case")]
 pub enum DeserializedAccountConfig {
     None(DeserializedBaseAccountConfig),
+    Maildir(DeserializedMaildirAccountConfig),
     #[cfg(feature = "imap-backend")]
     Imap(DeserializedImapAccountConfig),
-    #[cfg(feature = "maildir-backend")]
-    Maildir(DeserializedMaildirAccountConfig),
     #[cfg(feature = "notmuch-backend")]
     Notmuch(DeserializedNotmuchAccountConfig),
 }
@@ -43,16 +41,15 @@ impl DeserializedAccountConfig {
                 config.to_account_config(name, global_config),
                 BackendConfig::None,
             ),
+            DeserializedAccountConfig::Maildir(config) => (
+                config.base.to_account_config(name, global_config),
+                BackendConfig::Maildir(config.backend.clone()),
+            ),
             #[cfg(feature = "imap-backend")]
             DeserializedAccountConfig::Imap(config) => (
                 config.base.to_account_config(name, global_config),
                 BackendConfig::Imap(config.backend.clone()),
             ),
-            #[cfg(feature = "maildir-backend")]
-            DeserializedAccountConfig::Maildir(config) => (
-                config.base.to_account_config(name, global_config),
-                BackendConfig::Maildir(config.backend.clone()),
-            ),
             #[cfg(feature = "notmuch-backend")]
             DeserializedAccountConfig::Notmuch(config) => (
                 config.base.to_account_config(name, global_config),
@@ -64,10 +61,9 @@ impl DeserializedAccountConfig {
     pub fn is_default(&self) -> bool {
         match self {
             DeserializedAccountConfig::None(config) => config.default.unwrap_or_default(),
+            DeserializedAccountConfig::Maildir(config) => config.base.default.unwrap_or_default(),
             #[cfg(feature = "imap-backend")]
             DeserializedAccountConfig::Imap(config) => config.base.default.unwrap_or_default(),
-            #[cfg(feature = "maildir-backend")]
-            DeserializedAccountConfig::Maildir(config) => config.base.default.unwrap_or_default(),
             #[cfg(feature = "notmuch-backend")]
             DeserializedAccountConfig::Notmuch(config) => config.base.default.unwrap_or_default(),
         }
@@ -89,7 +85,11 @@ pub struct DeserializedBaseAccountConfig {
 
     pub email_listing_page_size: Option<usize>,
     pub email_reading_headers: Option<Vec<String>>,
-    #[serde(default, with = "EmailTextPlainFormatOptionDef", skip_serializing_if = "Option::is_none")]
+    #[serde(
+        default,
+        with = "EmailTextPlainFormatOptionDef",
+        skip_serializing_if = "Option::is_none"
+    )]
     pub email_reading_format: Option<EmailTextPlainFormat>,
     pub email_reading_verify_cmd: Option<String>,
     pub email_reading_decrypt_cmd: Option<String>,
@@ -98,7 +98,11 @@ pub struct DeserializedBaseAccountConfig {
     pub email_writing_encrypt_cmd: Option<String>,
     #[serde(flatten, with = "EmailSenderDef")]
     pub email_sender: EmailSender,
-    #[serde(default, with = "EmailHooksOptionDef", skip_serializing_if = "Option::is_none")]
+    #[serde(
+        default,
+        with = "EmailHooksOptionDef",
+        skip_serializing_if = "Option::is_none"
+    )]
     pub email_hooks: Option<EmailHooks>,
 
     #[serde(default)]
@@ -237,7 +241,6 @@ pub struct DeserializedImapAccountConfig {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize)]
-#[cfg(feature = "maildir-backend")]
 pub struct DeserializedMaildirAccountConfig {
     #[serde(flatten)]
     pub base: DeserializedBaseAccountConfig,

src/domain/account/handlers.rs

@@ -43,12 +43,16 @@ pub fn sync<P: Printer>(
     account_config: &AccountConfig,
     printer: &mut P,
     backend: &dyn Backend,
+    folder: &Option<String>,
     dry_run: bool,
 ) -> Result<()> {
     info!("entering the sync accounts handler");
     trace!("dry run: {}", dry_run);
 
-    let sync_builder = BackendSyncBuilder::new(account_config);
+    let mut sync_builder = BackendSyncBuilder::new(account_config);
+    if let Some(folder) = folder {
+        sync_builder = sync_builder.only_folder(folder);
+    }
 
     if dry_run {
         let report = sync_builder.dry_run(true).sync(backend)?;

src/domain/folder/args.rs

@@ -5,26 +5,37 @@
 
 use anyhow::Result;
 use clap::{self, Arg, ArgMatches, Command};
-use log::debug;
+use log::{debug, info};
 
 use crate::ui::table;
 
 const ARG_SOURCE: &str = "source";
 const ARG_TARGET: &str = "target";
+const CMD_EXPUNGE: &str = "expunge";
 const CMD_FOLDERS: &str = "folders";
+const CMD_LIST: &str = "list";
 
 /// Represents the folder commands.
 #[derive(Debug, PartialEq, Eq)]
 pub enum Cmd {
     List(table::args::MaxTableWidth),
+    Expunge,
 }
 
 /// Represents the folder command matcher.
 pub fn matches(m: &ArgMatches) -> Result<Option<Cmd>> {
     let cmd = if let Some(m) = m.subcommand_matches(CMD_FOLDERS) {
-        debug!("folders command matched");
-        let max_table_width = table::args::parse_max_width(m);
-        Some(Cmd::List(max_table_width))
+        if let Some(_) = m.subcommand_matches(CMD_EXPUNGE) {
+            info!("expunge folder subcommand matched");
+            Some(Cmd::Expunge)
+        } else if let Some(m) = m.subcommand_matches(CMD_LIST) {
+            debug!("list folders command matched");
+            let max_table_width = table::args::parse_max_width(m);
+            Some(Cmd::List(max_table_width))
+        } else {
+            info!("no folder subcommand matched, falling back to subcommand list");
+            Some(Cmd::List(None))
+        }
     } else {
         None
     };
@@ -35,8 +46,13 @@ pub fn matches(m: &ArgMatches) -> Result<Option<Cmd>> {
 /// Represents the folder subcommand.
 pub fn subcmd() -> Command {
     Command::new(CMD_FOLDERS)
-        .about("Lists folders")
-        .arg(table::args::max_width())
+        .about("Manage folders")
+        .subcommands([
+            Command::new(CMD_EXPUNGE).about("Delete emails marked for deletion"),
+            Command::new(CMD_LIST)
+                .about("List folders")
+                .arg(table::args::max_width()),
+        ])
 }
 
 /// Represents the source folder argument.
@@ -46,12 +62,11 @@ pub fn source_arg() -> Arg {
         .short('f')
         .help("Specifies the source folder")
         .value_name("SOURCE")
-        .default_value("inbox")
 }
 
 /// Represents the source folder argument parser.
-pub fn parse_source_arg(matches: &ArgMatches) -> &str {
-    matches.get_one::<String>(ARG_SOURCE).unwrap().as_str()
+pub fn parse_source_arg(matches: &ArgMatches) -> Option<&str> {
+    matches.get_one::<String>(ARG_SOURCE).map(String::as_str)
 }
 
 /// Represents the target folder argument.
@@ -82,7 +97,7 @@ mod tests {
 
         let arg = Command::new("himalaya")
             .subcommand(subcmd())
-            .get_matches_from(&["himalaya", "folders", "--max-width", "20"]);
+            .get_matches_from(&["himalaya", "folders", "list", "--max-width", "20"]);
         assert_eq!(Some(Cmd::List(Some(20))), matches(&arg).unwrap());
     }
 
@@ -97,10 +112,7 @@ mod tests {
         }
 
         let app = get_matches_from![];
-        assert_eq!(
-            Some("inbox"),
-            app.get_one::<String>(ARG_SOURCE).map(String::as_str)
-        );
+        assert_eq!(None, app.get_one::<String>(ARG_SOURCE).map(String::as_str));
 
         let app = get_matches_from!["-f", "SOURCE"];
         assert_eq!(

src/domain/folder/handlers.rs

@@ -7,6 +7,15 @@ use himalaya_lib::{AccountConfig, Backend};
 
 use crate::printer::{PrintTableOpts, Printer};
 
+pub fn expunge<P: Printer, B: Backend + ?Sized>(
+    folder: &str,
+    printer: &mut P,
+    backend: &mut B,
+) -> Result<()> {
+    backend.expunge_folder(folder)?;
+    printer.print(format!("Folder {folder} successfully expunged!"))
+}
+
 pub fn list<P: Printer, B: Backend + ?Sized>(
     max_width: Option<usize>,
     config: &AccountConfig,
@@ -123,6 +132,9 @@ mod tests {
                     },
                 ]))
             }
+            fn expunge_folder(&self, _: &str) -> backend::Result<()> {
+                unimplemented!();
+            }
             fn purge_folder(&self, _: &str) -> backend::Result<()> {
                 unimplemented!();
             }

src/main.rs

@@ -10,7 +10,9 @@ use himalaya::{
     printer::StdoutPrinter,
     tpl,
 };
-use himalaya_lib::{BackendBuilder, BackendConfig, ImapBackend, SenderBuilder};
+use himalaya_lib::{
+    BackendBuilder, BackendConfig, ImapBackend, SenderBuilder, DEFAULT_INBOX_FOLDER,
+};
 
 #[cfg(feature = "imap-backend")]
 use himalaya::imap;
@@ -87,11 +89,13 @@ fn main() -> Result<()> {
     // inits config
     let config = DeserializedConfig::from_opt_path(config::args::parse_arg(&m))?;
     let (account_config, backend_config) = config.to_configs(account::args::parse_arg(&m))?;
-    let folder = account_config.folder_alias(folder::args::parse_source_arg(&m))?;
+    let folder = folder::args::parse_source_arg(&m);
 
     // checks IMAP commands
     #[cfg(feature = "imap-backend")]
     if let BackendConfig::Imap(imap_config) = &backend_config {
+        let folder = account_config.folder_alias(folder.unwrap_or(DEFAULT_INBOX_FOLDER))?;
+
         // FIXME: find a way to downcast `backend` instead of
         // recreating an instance.
         match imap::args::matches(&m)? {
@@ -120,11 +124,21 @@ fn main() -> Result<()> {
             return account::handlers::list(max_width, &account_config, &config, &mut printer);
         }
         Some(account::args::Cmd::Sync(dry_run)) => {
+            let folder = match folder {
+                Some(folder) => Some(account_config.folder_alias(folder)?),
+                None => None,
+            };
             let backend = BackendBuilder::new()
-                .sessions_pool_size(16)
+                .sessions_pool_size(8)
                 .disable_cache(true)
                 .build(&account_config, &backend_config)?;
-            account::handlers::sync(&account_config, &mut printer, backend.as_ref(), dry_run)?;
+            account::handlers::sync(
+                &account_config,
+                &mut printer,
+                backend.as_ref(),
+                &folder,
+                dry_run,
+            )?;
             backend.close()?;
             return Ok(());
         }
@@ -133,6 +147,13 @@ fn main() -> Result<()> {
 
     // checks folder commands
     match folder::args::matches(&m)? {
+        Some(folder::args::Cmd::Expunge) => {
+            let folder = account_config.folder_alias(folder.unwrap_or(DEFAULT_INBOX_FOLDER))?;
+            let mut backend = BackendBuilder::new()
+                .disable_cache(disable_cache)
+                .build(&account_config, &backend_config)?;
+            return folder::handlers::expunge(&folder, &mut printer, backend.as_mut());
+        }
         Some(folder::args::Cmd::List(max_width)) => {
             let mut backend = BackendBuilder::new()
                 .disable_cache(disable_cache)
@@ -150,6 +171,7 @@ fn main() -> Result<()> {
     // checks email commands
     match email::args::matches(&m)? {
         Some(email::args::Cmd::Attachments(ids)) => {
+            let folder = account_config.folder_alias(folder.unwrap_or(DEFAULT_INBOX_FOLDER))?;
             let mut backend = BackendBuilder::new()
                 .disable_cache(disable_cache)
                 .build(&account_config, &backend_config)?;
@@ -162,6 +184,7 @@ fn main() -> Result<()> {
             );
         }
         Some(email::args::Cmd::Copy(ids, to_folder)) => {
+            let folder = account_config.folder_alias(folder.unwrap_or(DEFAULT_INBOX_FOLDER))?;
             let mut backend = BackendBuilder::new()
                 .disable_cache(disable_cache)
                 .build(&account_config, &backend_config)?;
@@ -175,6 +198,7 @@ fn main() -> Result<()> {
             );
         }
         Some(email::args::Cmd::Delete(ids)) => {
+            let folder = account_config.folder_alias(folder.unwrap_or(DEFAULT_INBOX_FOLDER))?;
             let mut backend = BackendBuilder::new()
                 .disable_cache(disable_cache)
                 .build(&account_config, &backend_config)?;
@@ -187,6 +211,7 @@ fn main() -> Result<()> {
             );
         }
         Some(email::args::Cmd::Forward(id, headers, body)) => {
+            let folder = account_config.folder_alias(folder.unwrap_or(DEFAULT_INBOX_FOLDER))?;
             let mut backend = BackendBuilder::new()
                 .disable_cache(disable_cache)
                 .build(&account_config, &backend_config)?;
@@ -202,6 +227,7 @@ fn main() -> Result<()> {
             );
         }
         Some(email::args::Cmd::List(max_width, page_size, page)) => {
+            let folder = account_config.folder_alias(folder.unwrap_or(DEFAULT_INBOX_FOLDER))?;
             let mut backend = BackendBuilder::new()
                 .disable_cache(disable_cache)
                 .build(&account_config, &backend_config)?;
@@ -216,6 +242,7 @@ fn main() -> Result<()> {
             );
         }
         Some(email::args::Cmd::Move(ids, to_folder)) => {
+            let folder = account_config.folder_alias(folder.unwrap_or(DEFAULT_INBOX_FOLDER))?;
             let mut backend = BackendBuilder::new()
                 .disable_cache(disable_cache)
                 .build(&account_config, &backend_config)?;
@@ -229,6 +256,7 @@ fn main() -> Result<()> {
             );
         }
         Some(email::args::Cmd::Read(ids, text_mime, sanitize, raw, headers)) => {
+            let folder = account_config.folder_alias(folder.unwrap_or(DEFAULT_INBOX_FOLDER))?;
             let mut backend = BackendBuilder::new()
                 .disable_cache(disable_cache)
                 .build(&account_config, &backend_config)?;
@@ -245,6 +273,7 @@ fn main() -> Result<()> {
             );
         }
         Some(email::args::Cmd::Reply(id, all, headers, body)) => {
+            let folder = account_config.folder_alias(folder.unwrap_or(DEFAULT_INBOX_FOLDER))?;
             let mut backend = BackendBuilder::new()
                 .disable_cache(disable_cache)
                 .build(&account_config, &backend_config)?;
@@ -261,6 +290,7 @@ fn main() -> Result<()> {
             );
         }
         Some(email::args::Cmd::Save(raw_email)) => {
+            let folder = account_config.folder_alias(folder.unwrap_or(DEFAULT_INBOX_FOLDER))?;
             let mut backend = BackendBuilder::new()
                 .disable_cache(disable_cache)
                 .build(&account_config, &backend_config)?;
@@ -273,6 +303,7 @@ fn main() -> Result<()> {
             );
         }
         Some(email::args::Cmd::Search(query, max_width, page_size, page)) => {
+            let folder = account_config.folder_alias(folder.unwrap_or(DEFAULT_INBOX_FOLDER))?;
             let mut backend = BackendBuilder::new()
                 .disable_cache(disable_cache)
                 .build(&account_config, &backend_config)?;
@@ -288,6 +319,7 @@ fn main() -> Result<()> {
             );
         }
         Some(email::args::Cmd::Sort(criteria, query, max_width, page_size, page)) => {
+            let folder = account_config.folder_alias(folder.unwrap_or(DEFAULT_INBOX_FOLDER))?;
             let mut backend = BackendBuilder::new()
                 .disable_cache(disable_cache)
                 .build(&account_config, &backend_config)?;
@@ -317,18 +349,21 @@ fn main() -> Result<()> {
         }
         Some(email::args::Cmd::Flag(m)) => match m {
             Some(flag::args::Cmd::Set(ids, ref flags)) => {
+                let folder = account_config.folder_alias(folder.unwrap_or(DEFAULT_INBOX_FOLDER))?;
                 let mut backend = BackendBuilder::new()
                     .disable_cache(disable_cache)
                     .build(&account_config, &backend_config)?;
                 return flag::handlers::set(&mut printer, backend.as_mut(), &folder, ids, flags);
             }
             Some(flag::args::Cmd::Add(ids, ref flags)) => {
+                let folder = account_config.folder_alias(folder.unwrap_or(DEFAULT_INBOX_FOLDER))?;
                 let mut backend = BackendBuilder::new()
                     .disable_cache(disable_cache)
                     .build(&account_config, &backend_config)?;
                 return flag::handlers::add(&mut printer, backend.as_mut(), &folder, ids, flags);
             }
             Some(flag::args::Cmd::Remove(ids, ref flags)) => {
+                let folder = account_config.folder_alias(folder.unwrap_or(DEFAULT_INBOX_FOLDER))?;
                 let mut backend = BackendBuilder::new()
                     .disable_cache(disable_cache)
                     .build(&account_config, &backend_config)?;
@@ -338,6 +373,7 @@ fn main() -> Result<()> {
         },
         Some(email::args::Cmd::Tpl(m)) => match m {
             Some(tpl::args::Cmd::Forward(id, headers, body)) => {
+                let folder = account_config.folder_alias(folder.unwrap_or(DEFAULT_INBOX_FOLDER))?;
                 let mut backend = BackendBuilder::new()
                     .disable_cache(disable_cache)
                     .build(&account_config, &backend_config)?;
@@ -355,6 +391,7 @@ fn main() -> Result<()> {
                 return tpl::handlers::write(&account_config, &mut printer, headers, body);
             }
             Some(tpl::args::Cmd::Reply(id, all, headers, body)) => {
+                let folder = account_config.folder_alias(folder.unwrap_or(DEFAULT_INBOX_FOLDER))?;
                 let mut backend = BackendBuilder::new()
                     .disable_cache(disable_cache)
                     .build(&account_config, &backend_config)?;
@@ -370,6 +407,7 @@ fn main() -> Result<()> {
                 );
             }
             Some(tpl::args::Cmd::Save(tpl)) => {
+                let folder = account_config.folder_alias(folder.unwrap_or(DEFAULT_INBOX_FOLDER))?;
                 let mut backend = BackendBuilder::new()
                     .disable_cache(disable_cache)
                     .build(&account_config, &backend_config)?;
@@ -382,6 +420,7 @@ fn main() -> Result<()> {
                 );
             }
             Some(tpl::args::Cmd::Send(tpl)) => {
+                let folder = account_config.folder_alias(folder.unwrap_or(DEFAULT_INBOX_FOLDER))?;
                 let mut backend = BackendBuilder::new()
                     .disable_cache(disable_cache)
                     .build(&account_config, &backend_config)?;