mu-wizard

muw (30787B)

---

 #!/bin/sh -e
 
 parser_definition() {
     setup REST help:usage -- "usage: ${0##*/} [cmd] [option...]"
     msg -- '' 'mu-wizard, a helper script for configuring mu4e accounts' ''
     msg -- 'Commands:'
     cmd_a add    -- "Add and autoconfigure an email address"
     cmd_a delete -- "Pick an account to delete"
     cmd_a list   -- "List configured accounts"
     cmd_a purge  -- "Purge all configuration"
     cmd_a sync   -- "Sync mail for accounts"
     cmd mu-init  -- "Run 'mu init' with the configured accounts"
     cmd data     -- "Output system data directory and exit"
     msg -- '' "Run '${0##*/} COMMAND --help' to see help information for the"
     msg -- "given command."
     global_options
     msg -- 'Note:'
     msg -- 'Once at least one account is added, you can run'
     msg -- "'${0##*/} sync' to begin downloading your mail."
 }
 
 cmd_a() {
     # Grab the first character of the subcommand, and add it to the option
     # parser as a subcommand.
     cmd "${1%"${1#?}"}" hidden:1; cmd "$@"
 }
 
 parser_definition_add() {
     setup REST help:usage -- "usage: ${0##*/} add [option...]"
     msg -- '' 'Add and autoconfigure an email address' ''
     msg -- 'Options:'
     flag nocheck    -c --disable-checks    -- "Disable checking domains.csv for acquiring domain information"
     flag nooverride -o --disable-overrides -- "Disable checking override files for acquiring domain information"
     msg -- '' 'Any information not provided below, will be asked interactively.'
     msg -- 'Account options:'
     param fulladdr -a --address var:EMAIL  -- "Email address for account generation"
     option maxmes  -m --max-messages var:COUNT on:0 -- \
         "Maximum message COUNT to be kept offline, leave" "empty for unlimited."
     param realname -r --real-name var:NAME -- "Your full name to be identified with the account"
     param title    -t --title var:TITLE    -- "Unique account title"
     option login   -l --login var:USERNAME -- "Use your full address if empty or USERNAME for" \
                                               "your login name"
     msg -- '' "Domain options: (setting either of these implies '-c -o')"
     param imap     -i --imap var:SERVER    -- "IMAP server address"
     param iport    -I --imap-port var:PORT -- "IMAP server port"
     param smtp     -s --smtp var:SERVER    -- "SMTP server address"
     param sport    -S --smtp-port var:PORT -- "SMTP server port"
     global_options
 }
 
 parser_definition_delete() {
     setup REST help:usage -- "usage: ${0##*/} delete [option...] [account...]"
     msg -- '' 'Delete account' ''
     flag noconfirm -y -- "Don't confirm account deletion"
     global_options
 }
 
 parser_definition_list() {
     global_options "usage: ${0##*/} list" "List configured accounts"
 }
 parser_definition_data() {
     global_options "usage: ${0##*/} data" "Output system data directory"
 }
 parser_definition_sync() {
     global_options "usage: ${0##*/} sync [account...]" "Sync mail for accounts"
 }
 parser_definition_mu() {
     setup REST help:usage -- "usage: ${0##*/} mu-init"
     msg -- '' 'Initiate/reinitate mu database' ''
     msg -- 'Options:'
     flag index -i -- "Index the mail directory after initiating the database"
     global_options
 }
 
 parser_definition_purge() {
     setup REST help:usage -- "usage: ${0##*/} purge [option...]"
     msg -- '' 'Purge all configuration' ''
     msg -- 'Options:'
     flag noconfirm  -y -- "Don't confirm configuration purge"
     flag keep_isync -i -- "Keep isync configuration"
     flag keep_msmtp -m -- "Keep msmtp configuration"
     global_options
 }
 
 global_options() {
     [ "$1" ] && setup REST help:usage -- "$1" '' "$2"
     msg -- '' 'Global options:'
     disp :version -v --version -- "Display version information"
     disp :usage  -h --help    -- "Print this help message"
     msg -- ''
 }
 
 # shellcheck shell=sh disable=SC2016
 # [getoptions] License: Creative Commons Zero v1.0 Universal
 getoptions() {
     _error='' _on=1 _off='' _export='' _plus='' _mode='' _alt='' _rest=''
     _flags='' _nflags='' _opts='' _help='' _abbr='' _cmds='' _init=@empty IFS=' '
 
     _0() { echo "$@"; }
     for i in 1 2 3 4 5; do eval "_$i() { _$((${i-}-1)) \"   \$@\"; }"; done
 
     quote() {
         q="$2'" r=''
         while [ "$q" ]; do r="$r${q%%\'*}'\''" && q=${q#*\'}; done
         q="'${r%????}'" && q=${q#\'\'} && q=${q%\'\'}
         eval "$1=\${q:-\"''\"}"
     }
     code() {
         [ "${1#:}" = "$1" ] && c=3 || c=4
         eval "[ ! \${$c:+x} ] || $2 \"\$$c\""
     }
     kv() { eval "${2-}${1%%:*}=\${1#*:}"; }
     loop() { [ $# -gt 1 ] && [ "$2" != -- ]; }
 
     invoke() { eval '"_$@"'; }
     prehook() { invoke "$@"; }
     for i in setup flag param option disp msg; do
         eval "$i() { prehook $i \"\$@\"; }"
     done
 
     args() {
         on=$_on off=$_off export=$_export init=$_init _hasarg=$1 && shift
         while loop "$@" && shift; do
             case $1 in
                 -?) [ "$_hasarg" ] && _opts="$_opts${1#-}" || _flags="$_flags${1#-}" ;;
                 +?) _plus=1 _nflags="$_nflags${1#+}" ;;
                 [!-+]*) kv "$1"
             esac
         done
     }
     defvar() {
         case $init in
             @none) : ;;
             @export) code "$1" _0 "export $1" ;;
             @empty) code "$1" _0 "${export:+export }$1=''" ;;
             @unset) code "$1" _0 "unset $1 ||:" "unset OPTARG ||:; ${1#:}" ;;
             *)
                 case $init in @*) eval "init=\"=\${${init#@}}\""; esac
                 case $init in [!=]*) _0 "$init"; return 0; esac
                 quote init "${init#=}"
                 code "$1" _0 "${export:+export }$1=$init" "OPTARG=$init; ${1#:}"
         esac
     }
     _setup() {
         [ "${1#-}" ] && _rest=$1
         while loop "$@" && shift; do kv "$1" _; done
     }
     _flag() { args '' "$@"; defvar "$@"; }
     _param() { args 1 "$@"; defvar "$@"; }
     _option() { args 1 "$@"; defvar "$@"; }
     _disp() { args '' "$@"; }
     _msg() { args '' _ "$@"; }
 
     cmd() { _mode=@ _cmds="$_cmds${_cmds:+|}'$1'"; }
     "$@"
     cmd() { :; }
     _0 "${_rest:?}=''"
 
     _0 "$2() {"
     _1 'OPTIND=$(($#+1))'
     _1 'while OPTARG= && [ $# -gt 0 ]; do'
     [ "$_abbr" ] && getoptions_abbr "$@"
 
     args() {
         sw='' validate='' pattern='' counter='' on=$_on off=$_off export=$_export
         while loop "$@" && shift; do
             case $1 in
                 --\{no-\}*) i=${1#--?no-?}; sw="$sw${sw:+|}'--$i'|'--no-$i'" ;;
                 --with\{out\}-*) i=${1#--with?out?-}; sw="$sw${sw:+|}'--with-$i'|'--without-$i'" ;;
                 [-+]? | --*) sw="$sw${sw:+|}'$1'" ;;
                 *) kv "$1"
             esac
         done
         quote on "$on"
         quote off "$off"
     }
     setup() { :; }
     _flag() {
         args "$@"
         [ "$counter" ] && on=1 off=-1 v="\$((\${$1:-0}+\$OPTARG))" || v=''
         _3 "$sw)"
         _4 '[ "${OPTARG:-}" ] && OPTARG=${OPTARG#*\=} && set "noarg" "$1" && break'
         _4 "eval '[ \${OPTARG+x} ] &&:' && OPTARG=$on || OPTARG=$off"
         valid "$1" "${v:-\$OPTARG}"
         _4 ';;'
     }
     _param() {
         args "$@"
         _3 "$sw)"
         _4 '[ $# -le 1 ] && set "required" "$1" && break'
         _4 'OPTARG=$2'
         valid "$1" '$OPTARG'
         _4 'shift ;;'
     }
     _option() {
         args "$@"
         _3 "$sw)"
         _4 'set -- "$1" "$@"'
         _4 '[ ${OPTARG+x} ] && {'
         _5 'case $1 in --no-*|--without-*) set "noarg" "${1%%\=*}"; break; esac'
         _5 '[ "${OPTARG:-}" ] && { shift; OPTARG=$2; } ||' "OPTARG=$on"
         _4 "} || OPTARG=$off"
         valid "$1" '$OPTARG'
         _4 'shift ;;'
     }
     valid() {
         set -- "$validate" "$pattern" "$1" "$2"
         [ "$1" ] && _4 "$1 || { set -- ${1%% *}:\$? \"\$1\" $1; break; }"
         [ "$2" ] && {
             _4 "case \$OPTARG in $2) ;;"
             _5 '*) set "pattern:'"$2"'" "$1"; break'
             _4 "esac"
         }
         code "$3" _4 "${export:+export }$3=\"$4\"" "${3#:}"
     }
     _disp() {
         args "$@"
         _3 "$sw)"
         code "$1" _4 "echo \"\${$1}\"" "${1#:}"
         _4 'exit 0 ;;'
     }
     _msg() { :; }
 
     [ "$_alt" ] && _2 'case $1 in -[!-]?*) set -- "-$@"; esac'
     _2 'case $1 in'
     _wa() { _4 "eval 'set -- $1' \${1+'\"\$@\"'}"; }
     _op() {
         _3 "$1) OPTARG=\$1; shift"
         _wa '"${OPTARG%"${OPTARG#??}"}" '"$2"'"${OPTARG#??}"'
         _4 "$3"
     }
     _3 '--?*=*) OPTARG=$1; shift'
     _wa '"${OPTARG%%\=*}" "${OPTARG#*\=}"'
     _4 ';;'
     _3 '--no-*|--without-*) unset OPTARG ;;'
     [ "$_alt" ] || {
         [ "$_opts" ] && _op "-[$_opts]?*" '' ';;'
         [ ! "$_flags" ] || _op "-[$_flags]?*" - 'OPTARG= ;;'
     }
     [ "$_plus" ] && {
         [ "$_nflags" ] && _op "+[$_nflags]?*" + 'unset OPTARG ;;'
         _3 '+*) unset OPTARG ;;'
     }
     _2 'esac'
     _2 'case $1 in'
     "$@"
     rest() {
         _4 'while [ $# -gt 0 ]; do'
         _5 "$_rest=\"\${$_rest}" '\"\${$(($OPTIND-$#))}\""'
         _5 'shift'
         _4 'done'
         _4 'break ;;'
     }
     _3 '--)'
     [ "$_mode" = @ ] || _4 'shift'
     rest
     _3 "[-${_plus:++}]?*)"
     case $_mode in [=#]) rest ;; *) _4 'set "unknown" "$1"; break ;;'; esac
     _3 '*)'
     case $_mode in
         @)
         _4 "case \$1 in ${_cmds:-*}) ;;"
         _5 '*) set "notcmd" "$1"; break'
         _4 'esac'
         rest ;;
         [+#]) rest ;;
         *) _4 "$_rest=\"\${$_rest}" '\"\${$(($OPTIND-$#))}\""'
     esac
     _2 'esac'
     _2 'shift'
     _1 'done'
     _1 '[ $# -eq 0 ] && { OPTIND=1; unset OPTARG; return 0; }'
     _1 'case $1 in'
     _2 'unknown) set "Unrecognized option: $2" "$@" ;;'
     _2 'noarg) set "Does not allow an argument: $2" "$@" ;;'
     _2 'required) set "Requires an argument: $2" "$@" ;;'
     _2 'pattern:*) set "Does not match the pattern (${1#*:}): $2" "$@" ;;'
     _2 'notcmd) set "Not a command: $2" "$@" ;;'
     _2 '*) set "Validation error ($1): $2" "$@"'
     _1 'esac'
     [ "$_error" ] && _1 "$_error" '"$@" >&2 || exit $?'
     _1 'echo "$1" >&2'
     _1 'exit 1'
     _0 '}'
 
     [ ! "$_help" ] || eval "shift 2; getoptions_help $1 $_help" ${3+'"$@"'}
 }
 # [getoptions_help] License: Creative Commons Zero v1.0 Universal
 getoptions_help() {
     _width='30,12' _plus='' _leading='  '
 
     pad() { p=$2; while [ ${#p} -lt "$3" ]; do p="$p "; done; eval "$1=\$p"; }
     kv() { eval "${2-}${1%%:*}=\${1#*:}"; }
     sw() { pad sw "$sw${sw:+, }" "$1"; sw="$sw$2"; }
 
     args() {
         _type=$1 var=${2%% *} sw='' label='' hidden='' && shift 2
         while [ $# -gt 0 ] && i=$1 && shift && [ "$i" != -- ]; do
             case $i in
                 --*) sw $((${_plus:+4}+4)) "$i" ;;
                 -?) sw 0 "$i" ;;
                 +?) [ ! "$_plus" ] || sw 4 "$i" ;;
                 *) [ "$_type" = setup ] && kv "$i" _; kv "$i"
             esac
         done
         [ "$hidden" ] && return 0 || len=${_width%,*}
 
         [ "$label" ] || case $_type in
             setup | msg) label='' len=0 ;;
             flag | disp) label="$sw " ;;
             param) label="$sw $var " ;;
             option) label="${sw}[=$var] "
         esac
         [ "$_type" = cmd ] && label=${label:-$var } len=${_width#*,}
         pad label "${label:+$_leading}$label" "$len"
         [ ${#label} -le "$len" ] && [ $# -gt 0 ] && label="$label$1" && shift
         echo "$label"
         pad label '' "$len"
         for i; do echo "$label$i"; done
     }
 
     for i in setup flag param option disp 'msg -' cmd; do
         eval "${i% *}() { args $i \"\$@\"; }"
     done
 
     echo "$2() {"
     echo "cat<<'GETOPTIONSHERE'"
     "$@"
     echo "GETOPTIONSHERE"
     echo "}"
 }
 
 out() { printf '%s\n' "$@" >&2 ;}
 warn() { printf '\033[1;33mWARNING\033[m %s\n' "$@" >&2 ;}
 info() { printf '\033[1;36mINFO\033[m %s\n' "$@" >&2 ;}
 err() { printf '\033[1mERROR \033[m%s\n' "$@" >&2 ;}
 die() { err "$@"; exit 1 ;}
 version() { printf 'mu-wizard version: %s\n' @VERSION@ ;}
 
 notify() {
     case ${notify_method##*/} in
         notify-send) "$notify_method" -i mail-unread -a "mu-wizard" "$@" ;;
         herbe)       "$notify_method" "$@" ;;
         null) info "No notification method found, disabling notifications"; notify_method=disabled ;;
         disabled) ;;
         *) warn "Notification method '$notify_method' unknown"; notify_method=disabled
     esac
 }
 prompt() {
     # The first argument is used as the prompt, and will print as 'prompt: '.
     # Any other arguments will be printed before prompt if they exist.
     prompt=$1 ans=
     [ "$2" ] && { shift 1; out "$@" ;}
     printf '%s: ' "$prompt" >&2
     read -r ans || return
     printf %s "$ans"
 }
 prompt_required() {
     promptout=''; promptout=$(prompt "$@")
     until [ "$promptout" ]; do
         out "This is required."
         promptout=$(prompt "$@")
     done
     printf %s "$promptout"
 }
 prompt_noecho() {
     # This is the same with the prompt() function except that it doesn't echo
     # the user input to the terminal. It can be used to ask for passwords and
     # other secret information.
     stty=$(stty -g); stty -echo
     prompt "$@"; printf '\n' >&2
     stty "$stty"
 }
 
 getbut() {
     # This function can be used to get a single button input. No arguments
     # necessary.
     stty=$(stty -g); stty -icanon -echo
     dd bs=1 count=1 2>/dev/null
     stty "$stty"
 }
 
 yesno() {
     # Function to ask the user yes/no questions. Returns 0 if the button
     # received is Y/y, Returns 1 if the button received is N/n, and returns
     # 2 if any other button is received. If the noconfirm option is set from
     # the options, do not ask anything.
     #
     # The 'noconfirm' variable is declared and assigned by the option parser.
     # shellcheck disable=2154
     [ "$noconfirm" ] && return 0
     printf '%s\n' "$@"; printf 'y/n: '
     ans=$(getbut)
     printf '%s\n' "$ans" >&2
     case "$ans" in Y|y) return 0;; N|n) return 1; esac; return 2
 }
 
 delete() {
     rm -f "$accountdir/$1.el"
     sed_i "/^IMAPStore $1-remote\$/,/^# End profile\$/d" "$HOME/.mbsyncrc"
     sed_i "/^account $1\$/,/^# End profile\$/d"          "$config_home/msmtp/config"
     rm -f /tmp/mbsync-boxes
 }
 
 in_profiles() {
     # Check whether the title is already a profile.
     while read -r profile; do
         [ "$profile" = "$1" ] && return 0
     done <<EOF
 $(get_profiles)
 EOF
     return 1
 }
 
 sed_i() {
     # POSIX compliant 'sed -i' like function. This can be only used for a single
     # file, and the filename should always come first.
     script='' sedf='--' optesc='' suffix=tmp.$$
 
     while getopts nre:Ef: flag; do
         case $flag in
             E|r|n) sedf="-${sedf##*-}$flag" optesc=-- ;;
             e) script=$(printf '%s\n%s\n' "$script" "$OPTARG") ;;
             f) script=$(printf '%s\n%s\n' "$script" "$(cat "$OPTARG")") ;;
             *) return 1
         esac
     done
 
     shift "$((OPTIND - 1))"
 
     [ "$script" ] || { script=$1; shift ;}
 
     for file; do
         # Create traps for removing temporary files on failure
         trap 'rm -f "$file.$suffix"' EXIT
         trap 'rm -f "$file.$suffix"; exit 1' INT
 
         # Save the edited stream in the temporary file
         sed "$sedf" $optesc "$script" "$file" > "$file.$suffix"
 
         # Pipe back the contents of the temporary file so that we don't have any
         # permission related issues.
         cat "$file.$suffix" > "$file"
 
         # Remove the temporary file.
         rm -f "$file.$suffix"
 
         # Restore the trap
         trap - INT EXIT
     done
 }
 
 get_profiles() {
     # Function to get all available profiles
     eval=$1
     set --
     for profile in "$accountdir/"*.el; do
         profile=${profile##*/}
         set -- "$@" "${profile%.el}"
     done
     if [ "$eval" ]; then
         printf "'%s' " "$@"
     else
         printf '%s\n' "$@"
     fi
 }
 
 msmtp_header() {
     mkdir -p "$config_home/msmtp" \
              "${XDG_CACHE_HOME:=$HOME/.cache}/msmtp"
     cat <<EOF > "$config_home/msmtp/config"
 defaults
 auth on
 tls on
 tls_trust_file $cacert
 logfile $XDG_CACHE_HOME/msmtp/msmtp.log
 EOF
 }
 
 pm_ask() {
     case ${pass_prog##*/} in
         pass) pass insert "$pmt"
               password_command="pass show $pmt" ;;
         pash) trap 'delete $title; rm -f _' EXIT INT
               sed 's/yn "Gen/false "Gen/g' "$(command -v pash)" >_
               sh _ add "$pmt"
               rm -f _; trap 'delete $title' EXIT INT
               password_command="pash show $pmt" ;;
         pm)   pass=$(prompt_noecho "Enter your password")
               pass2=$(prompt_noecho "Enter your password again")
               if [ "$pass" = "$pass2" ]; then
                   pm add "$pmt" <<EOF
 $pass
 EOF
                   password_command="pm show $pmt"
               else
                   err "Passwords don't match"
                   return 1
               fi
     esac
 }
 
 pm_del() {
     case ${pass_prog##*/} in
         pass) pass rm -f "$pmt" ;;
         pash) yes | pash del "$pmt" ;;
         pm)   pm del "$pmt"
     esac >/dev/null 2>&1 ||:
 }
 
 test_connection() {
     mkdir -p "$MAILDIR/$title"
 
     # Since we are "Flattening" the inbox structure by replacing '/' with '.',
     # we need to also replace it in the 'mbsync -l' output by hand. See the
     # Flatten section on mbsync(1).
     { mbsync -l "$title" || {
           err "Log-on not successful." \
           "It seems that either you have inputted the wrong password or server" \
           "settings, or there are requirements for your account out of the" \
           "control of mu-wizard."
           delete "$title"
           kill 0
     } } | sed 's|/|.|g' > /tmp/mbsync-boxes
 
     while read -r dir; do mkdir -p "$MAILDIR/$title/${dir#/}"; done < /tmp/mbsync-boxes
 
     drafts=$(grep -i drafts /tmp/mbsync-boxes | sed 1q)
     trash=$(grep  -i trash  /tmp/mbsync-boxes | sed 1q)
     inbox=$(grep  -i inbox  /tmp/mbsync-boxes | sed 1q)
     sent=$(grep   -i sent   /tmp/mbsync-boxes | sed 1q)
 
     rm -f /tmp/mbsync-boxes
 }
 
 get_domains() {
     if [ -f "$confdir/domains.csv" ]; then
         { [ -f "$sharedir/domains.csv" ] && cat "$sharedir/domains.csv"
           cat "$confdir/domains.csv" ;} | sort -uo "$confdir/domains.csv"
     else
         if [ -f "$sharedir/domains.csv" ]; then
             cat "$sharedir/domains.csv"; fi > "$confdir/domains.csv"
     fi
 }
 
 set_mbsync() {
     cat <<EOF >> "$HOME/.mbsyncrc"
 IMAPStore $title-remote
 Host $imap
 Port $iport
 User $login
 PassCmd "$password_command"
 AuthMechs LOGIN
 SSLType $ssltype
 CertificateFile $cacert
 
 MaildirStore $title-local
 Subfolders Verbatim
 Path ~/.local/share/mail/$title/
 Inbox ~/.local/share/mail/$title/INBOX
 Flatten .
 
 Channel $title
 Expunge Both
 $isync_far  :$title-remote:
 $isync_near :$title-local:
 Patterns * !"[Gmail]/All Mail"
 Create Both
 SyncState *
 MaxMessages ${maxmes:-0}
 ExpireUnread no
 # End profile
 
 EOF
 }
 
 set_msmtp() {
     # 'A && B || C' is intentional behaviour here. We want all of these checks
     # to pass.
     # shellcheck disable=2015
     [ -f "$config_home/msmtp/config" ] &&
     [ -s "$config_home/msmtp/config" ] || msmtp_header
 
     cat <<EOF >> "$config_home/msmtp/config"
 account $title
 host $smtp
 port $sport
 from $fulladdr
 user $login
 passwordeval "$password_command"
 $starttlsoff
 # End profile
 
 EOF
 }
 
 set_accountlisp() {
     cat <<EOF > "$accountdir/$title.el"
 (add-to-list 'mu4e-contexts
 (make-mu4e-context
   :name "$title"
   :match-func (lambda (msg)
                 (when msg
                   (mu4e-message-contact-field-matches msg
                      :to "$fulladdr")))
   :vars '((user-mail-address                . "$fulladdr")
           (message-sendmail-extra-arguments . ("-a" "$title"))
           (mu4e-sent-messages-behavior      . $msg_behavior)
           (mu4e-drafts-folder               . "/$title/${drafts:=Drafts}")
           (mu4e-trash-folder                . "/$title/${trash:=Trash}")
           (mu4e-sent-folder                 . "/$title/${sent:=Sent}")
           (mu4e-maildir-shortcuts           . (("/$title/${inbox:-INBOX}" . ?i)
                                                ("/$title/$drafts"         . ?d)
                                                ("/$title/${sent:-Sent}" . ?s)))
           (user-full-name                   . "$realname"))))
 EOF
 
 }
 
 get_information() {
 
     # Try to find a CA Certificate file. We want to prioritise the '$MUW_CACERT'
     # variable here.
     if [ "$MUW_CACERT" ]; then
         cacert=$MUW_CACERT
     else
         for file in /etc/ssl/certs/ca-certificates.crt /etc/pki/tls/certs/ca-bundle.crt \
                 /etc/certificates/cert.pem /etc/ssl/ca-bundle.pem /etc/ssl/cert.pem \
                 /etc/pki/tls/cacert.pem /usr/share/ca-certificates; do
             [ -r "$file" ] || continue
             cacert=$file; break
         done
     fi
 
     # If no certificate file was found, exit and notify the user.
     [ -r "$cacert" ] ||
         die "No proper CA Certificate file could be found. There are numerous ways of" \
             "obtaining it, and those can differ for each distro. You can see the" \
             "CA CERTIFICATES section on the muw-add(1) manual page to learn more."
 
     : "${fulladdr:=$(prompt_required Email \
              "Insert the email address that you want to configure for mu4e")}"
 
     # Check the override directory for possible alterations of the
     # configuration. If the override is found on the configuration dirctory, it
     # will be used instead.
     [ "$nooverride" ] ||
     for file in "$confdir/overrides/"* "$sharedir/overrides/"*; do
         [ -f "$sharedir/overrides/${fulladdr##*@}" ] && {
             domain=${fulladdr##*@}
             # shellcheck disable=1090
             . "$sharedir/overrides/$domain"
             break
         }
     done
 
     [ "$nocheck" ] || [ "$domain" ] ||
     while IFS=, read -r domain imap iport smtp sport; do
         case "$domain" in "${fulladdr##*@}") break; esac
     done < "$confdir/domains.csv"
 
     if [ "$domain" = "${fulladdr##*@}" ]; then
         out "Your domain information was found!'" \
             "The following information will be used:" ""\
             "Domain: $domain" \
             "IMAP:   $imap:$iport" \
             "SMTP:   $smtp:$sport"
     else
         : "${imap:="$(prompt Server "Insert the IMAP server for your email provider" \
             '(excluding the port number)')"}"
 
         : "${iport:=$(prompt Port \
             "What is your server's IMAP port number? (Usually 993)")}"
 
         : "${smtp:=$(prompt Server "Insert the SMTP server for your email provider" \
             "(excluding the port number)")}"
 
         : "${sport:=$(prompt Port \
             "What is your server's SMTP port number? (Usually 587)")}"
     fi
 
 
     : "${realname:=$(prompt "Real name" \
         "Enter your full name you want to be identified on this account.")}"
 
     : "${title:=$(prompt_required "Account name" \
         "Enter a short, one-word identifier for this email account that will" \
         "distinguish them from any other accounts you add")}"
 
     while in_profiles "$title"; do
         out "The title '$title' is already used."
         title=$(prompt_required "Account name" \
         "Enter a short, one-word identifier for this email account that will" \
         "distinguish them from any other accounts you add")
     done
 
     : "${login:=$(prompt "Login" \
         "If your account has a special username different from your address," \
         "insert it now. Otherwise leave this blank.")}"
 
     # If login is unspecified, use the full address
     [ "${login:-1}" = 1 ] && login="$fulladdr"
 
     : "${maxmes=$(prompt "Maximum messages" \
         "If you want to limit the number of messages kept offline to a number," \
         "enter it below. Otherwise leave this blank.")}"
 
     case "$sport" in 465) starttlsoff="tls_starttls off"; esac
 }
 
 prepare() {
     # Make the initial checks to make sure we have the necessary programs to
     # actually run mu-wizard.
     pass_prog=${MUW_PWM:-$(command -v pass || command -v pash || command -v pm)} ||
         die "No applicable password manager found."
     command -v mbsync >/dev/null || die "mbsync must be installed for mu-wizard to work."
 
     # Set some variables that are used throughout the script.
     sharedir=/usr/share/mu-wizard
     ssltype=IMAPS
     msg_behavior=sent
 
     # Create configuration and cache directories.
     mkdir -p "${config_home:=${XDG_CONFIG_HOME:-$HOME/.config}}" \
              "${confdir:=$config_home/mu4e}" \
              "${cac_dir:=${XDG_CACHE_HOME:-$HOME/.cache}}" \
              "${accountdir:=$confdir/accounts}" \
              "${MAILDIR:=${XDG_DATA_HOME:-$HOME/.local/share}/mail}"
 
     export MAILDIR
 
     # isync > 1.4.0 depracates the terms Master/Slave, and replaces them with
     # Far/Near. Check the version by looking at 'mbsync --version' output and
     # use the newer syntax if available.
     isync_version=$(mbsync --version)
     isync_version=${isync_version##* } isync_version=${isync_version%.*}
     if [ "${isync_version%%.*}" -gt 1 ] || [ "${isync_version#*.}" -ge 4 ]; then
         isync_far=Far isync_near=Near
     else
         isync_far=Master isync_near=Slave
     fi
 
     # Set notification program, we support both libnotify, which is the most
     # common one out there, and also herbe, which does not depend on dbus. We
     # try 'notify-send' first, because its interface is more convenient.
     notify_method=${MUW_NOTIFY:-$(
                     command -v notify-send ||
                     command -v herbe)} ||
                     notify_method=null
 }
 
 main() {
     prepare
 
     eval "$(getoptions parser_definition parse)"
     parse "$@"; eval set -- "$REST"
     action=$1;  shift
 
     case $action in
         a|add)
             eval "$(getoptions parser_definition_add parse)"
             parse "$@"; eval set -- "$REST"
 
             # If any domain information is provided, disable checking domains.csv and
             # overrides.
             test -n "$imap" -o -n "$iport" -o -n "$smtp" -o -n "$sport" &&
                 nocheck=1 nooverride=1
             get_domains
             get_information
             trap 'delete $title' INT EXIT
             pmt="muw/$fulladdr"
             while :; do pm_del; pm_ask && break; done
             set_mbsync
             test_connection
             set_msmtp
             set_accountlisp
             [ -f "$confdir/mu4e-config.el" ] || cp "$sharedir/mu4e-config.el" "$confdir/mu4e-config.el"
 
             # We add user's personal domain information to the config directory,
             # so even if the user doesn't want to share the information in a git
             # repository, they can have it themselves when they may need it.
 
             printf '%s,%s,%s,%s,%s' "${fulladdr##*@}" "$imap" "$iport" "$smtp" "$sport" |
                 sort -uo "$confdir/domains.csv" "$confdir/domains.csv" -
             trap - INT EXIT
             out "All done. You can now run '${0##*/} sync $title' in order to sync this account."
             out "You can also run '${0##*/} mu-init' to easily initialise the database."
             ;;
         l|list)
             eval "$(getoptions parser_definition_list parse)"
             parse "$@"; eval set -- "$REST"
             get_profiles
             ;;
         d|delete)
             eval "$(getoptions parser_definition_delete parse)"
             parse "$@"; eval set -- "$REST"
             [ "$1" ] || {
                 get_profiles
                 set -- "$(prompt Profile "Pick a profile to be deleted")"
             }
             for title; do
                 in_profiles "$title" || die "Profile '$title' doesn't exist."
                 yesno "Are you sure you want to delete '$title'?" || exit 1
                 delete "$title"
             done
             ;;
         p|purge)
             eval "$(getoptions parser_definition_purge parse)"
             parse "$@"; eval set -- "$REST"
             yesno "Are you sure you want to delete all account data?" || exit 1
             rm -rf "$HOME/.mbsyncrc" "$confdir" "$config_home/msmtp"
             ;;
         s|sync)
             lastsync=''
             syncfile=$cac_dir/muw-lastsync
             mu_format="$(printf 'f\ts')"
             eval "$(getoptions parser_definition_sync parse)"
             parse "$@"; eval set -- "$REST"
             pgrep -x mbsync >/dev/null && die "mbsync is already running."
             [ "$1" ] || eval set -- "$(get_profiles eval)"
             for acc; do in_profiles "$acc" || die "Invalid account: '$acc'"; done
             for acc; do mbsync "${acc##*/}" & done; wait
             for acc; do
                 newcount=$(
                     if [ -f "$syncfile" ]; then
                         find "$MAILDIR/$acc/"*/new -type f -newer "$syncfile"
                     else
                         find "$MAILDIR/$acc/"*/new -type f
                     fi | wc -l
                 )
                 [ "$newcount" -gt 0 ] &&
                     notify "mu-wizard" "$newcount new mail in '$acc' account."
             done
 
             [ -f "$syncfile" ] &&
                 lastsync=d:$(date -r "$syncfile" "+%Y-%m-%dT%H:%M..")
 
             touch "$syncfile"
 
             # Update mu index, first try using Emacs and fallback to using mu itself
             emacsclient -e "(mu4e-update-index)" >/dev/null 2>&1 || mu index
 
             # Send notification for new unread mails. Here is an explanation of
             # what this does:
             #
             # --skip-dups           - Skip duplicates
             # 'g:u'                 - Find unread email
             # '$lastsync'           - Received after the last synchronization
             # -s date --reverse     - Reverse the emails by date
             # -f "$format" - Get 'from' and 'subject' fields, tab seperated
             mu find --skip-dups g:u "$lastsync" -s d --reverse -f "$mu_format" 2>/dev/null |
                 while IFS=$(printf '\t') read -r from subject; do
 
                     # Only display the name, not the email address. Remove
                     # trailing whitespace, and quotation marks if there are any.
                     from=${from%%\<*} from=${from%"${from##*[!\ ]}"}
                     from=${from#\"} from=${from%\"}
 
                     notify "$from" "$subject"
                 done
             ;;
         mu-init)
             eval "$(getoptions parser_definition_mu parse)"
             parse "$@"; set --
             for account in "$accountdir/"*.el; do
                 [ -f "$account" ] || continue
                 set -- "$@" "--my-address=$(sed -n 's|"[^"]*$||;/user-mail-address/{s|^.*"||p;q}' "$account")"
             done
             [ "$1" ] || die "No address could be found, did you add any accounts?"
             mu init -m "$MAILDIR" "$@"
 
             # The 'index' variable is declared and assigned by the parser
             # shellcheck disable=2154
             [ -z "$index" ] || mu index
             ;;
         data)
             eval "$(getoptions parser_definition_data parse)"
             parse "$@"; eval set -- "$REST"
             printf '%s\n' "$sharedir"
     esac
 }
 
 main "$@"