emailengine-app 1.14.8 → 2.60.1

package/lib/connection.js

@@ -1,1769 +0,0 @@
-'use strict';
-
-const { parentPort } = require('worker_threads');
-const { ImapFlow } = require('imapflow');
-const { Mailbox } = require('./mailbox');
-const logger = require('./logger');
-const crypto = require('crypto');
-const packageData = require('../package.json');
-const { backOff } = require('exponential-backoff');
-const msgpack = require('msgpack5')();
-const nodemailer = require('nodemailer');
-const MailComposer = require('nodemailer/lib/mail-composer');
-const util = require('util');
-const settings = require('./settings');
-const { getRawEmail, removeBcc } = require('./get-raw-email');
-
-const { normalizePath, resolveCredentials } = require('./tools');
-
-const RESYNC_DELAY = 15 * 60;
-const LIST_REFRESH_DELAY = 30 * 60 * 1000;
-const ENSURE_MAIN_TTL = 5 * 1000;
-
-const MAX_BACKOFF_DELAY = 10 * 60 * 1000; // 10 min
-
-const { AUTH_ERROR_NOTIFY, AUTH_SUCCESS_NOTIFY, CONNECT_ERROR_NOTIFY, EMAIL_SENT_NOTIFY } = require('./consts');
-
-async function metrics(logger, key, method, ...args) {
-    try {
-        parentPort.postMessage({
-            cmd: 'metrics',
-            key,
-            method,
-            args
-        });
-    } catch (err) {
-        logger.error({ msg: 'Failed to post metrics to parent', err });
-    }
-}
-
-class Connection {
-    constructor(options) {
-        this.options = options || {};
-
-        this.account = this.options.account || '';
-        this.accountObject = this.options.accountObject;
-        this.accountLogger = this.options.accountLogger;
-
-        this.emitLogs = this.options.accountLogger.enabled;
-
-        this.cid = this.getRandomId();
-
-        this.closing = false;
-        this.closed = false;
-
-        this.logger = this.getLogger();
-
-        this.imapConfig = {
-            // Set emitLogs to true if you want to get all the log entries as objects from the IMAP module
-            logger: this.mainLogger.child({
-                sub: 'imap-connection'
-            }),
-            clientInfo: {
-                name: packageData.name,
-                version: packageData.version,
-                vendor: (packageData.author && packageData.author.name) || packageData.author,
-                'support-url': (packageData.bugs && packageData.bugs.url) || packageData.bugs
-            },
-            emitLogs: this.emitLogs,
-            logRaw: this.options.logRaw
-        };
-
-        this.mailboxes = new Map();
-        this.untaggedExistsTimer = false;
-        this.redis = options.redis;
-        this.notifyQueue = options.notifyQueue;
-        this.submitQueue = options.submitQueue;
-
-        this.refreshListingTimer = false;
-        this.resyncTimer = false;
-
-        this.completedTimer = false;
-
-        this.pathCache = new Map();
-        this.idCache = new Map();
-
-        this.defaultDelimiter = '/';
-
-        this.localAddresses = [].concat(this.options.localAddress || []).concat(this.options.localAddresses || []);
-
-        this.state = 'connecting';
-    }
-
-    getAccountKey() {
-        return `iad:${this.account}`;
-    }
-
-    getMailboxListKey() {
-        return `ial:${this.account}`;
-    }
-
-    getMailboxHashKey() {
-        return `iah:${this.account}`;
-    }
-
-    getLogKey() {
-        // this format ensures that the key is deleted when user is removed
-        return `iam:${this.account}:g`;
-    }
-
-    getLoggedAccountsKey() {
-        return `iaz:logged`;
-    }
-
-    onTaskCompleted() {
-        // check if we need to re-select main mailbox
-        this.completedTimer = setTimeout(() => {
-            clearTimeout(this.completedTimer);
-            this.ensureMainMailbox().catch(err => this.logger.error(err));
-        }, ENSURE_MAIN_TTL);
-    }
-
-    async ensureMainMailbox() {
-        let mainPath = this.main ? this.main.path : 'INBOX';
-        if (this.mailbox && normalizePath(this.mailbox.path) === normalizePath(mainPath)) {
-            // already selected
-            return;
-        }
-
-        // start waiting for changes
-        await this.select(mainPath);
-    }
-
-    async packUid(mailbox, uid) {
-        if (isNaN(uid)) {
-            return false;
-        }
-
-        if (typeof uid !== 'number') {
-            uid = Number(uid);
-        }
-
-        if (typeof mailbox === 'string') {
-            if (this.mailboxes.has(normalizePath(mailbox))) {
-                mailbox = this.mailboxes.get(normalizePath(mailbox));
-            } else {
-                return false;
-            }
-        }
-
-        const storedStatus = await mailbox.getStoredStatus();
-        if (!storedStatus.uidValidity || !storedStatus.path) {
-            return false;
-        }
-
-        let uidValBuf = Buffer.alloc(8);
-        uidValBuf.writeBigUInt64BE(storedStatus.uidValidity, 0);
-        let mailboxBuf = Buffer.concat([uidValBuf, Buffer.from(storedStatus.path)]);
-
-        let mailboxId;
-        if (this.pathCache.has(mailboxBuf.toString('hex'))) {
-            mailboxId = this.pathCache.get(mailboxBuf.toString('hex'));
-        } else {
-            mailboxId = await this.redis.zGetMailboxId(this.getAccountKey(), this.getMailboxHashKey(), mailboxBuf);
-            if (isNaN(mailboxId) || typeof mailboxId !== 'number') {
-                return false;
-            }
-
-            this.pathCache.set(mailboxBuf.toString('hex'), mailboxId);
-            this.idCache.set(mailboxId, mailboxBuf);
-        }
-
-        let uidBuf = Buffer.alloc(4 + 4);
-        uidBuf.writeUInt32BE(mailboxId, 0);
-        uidBuf.writeUInt32BE(uid, 4);
-
-        let res = uidBuf.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/[=]+/g, '');
-
-        return res;
-    }
-
-    async unpackUid(id) {
-        const packed = Buffer.isBuffer(id) ? id : Buffer.from(id.replace(/-/g, '+').replace(/_/g, '/'), 'base64');
-
-        let mailboxId = packed.readUInt32BE(0);
-        let uid = packed.readUInt32BE(4);
-
-        let mailboxBuf;
-        if (this.idCache.has(mailboxId)) {
-            mailboxBuf = this.idCache.get(mailboxId);
-        } else {
-            mailboxBuf = await this.redis.zGetMailboxPathBuffer(this.getMailboxHashKey(), mailboxId);
-            if (!mailboxBuf) {
-                return false;
-            }
-
-            this.pathCache.set(mailboxBuf.toString('hex'), mailboxId);
-            this.idCache.set(mailboxId, mailboxBuf);
-        }
-
-        if (!mailboxBuf) {
-            return false;
-        }
-
-        let path = mailboxBuf.slice(8).toString();
-        return {
-            path,
-            uidValidity: mailboxBuf.readBigUInt64BE(0).toString(),
-            uid
-        };
-    }
-
-    async getMessageTextPaths(textId) {
-        let buf = Buffer.from(textId.replace(/-/g, '+').replace(/_/g, '/'), 'base64');
-        let id = buf.slice(0, 8);
-        let textParts = msgpack.decode(buf.slice(8));
-
-        let message = await this.unpackUid(id);
-        if (!message) {
-            return { message: false };
-        }
-
-        return { message, textParts };
-    }
-
-    async clearMailboxEntry(entry) {
-        this.checkIMAPConnection();
-
-        if (!entry || !entry.path) {
-            return; // ?
-        }
-
-        let mailbox;
-        if (!this.mailboxes.has(normalizePath(entry.path))) {
-            mailbox = new Mailbox(this, entry);
-        } else {
-            mailbox = this.mailboxes.get(normalizePath(entry.path));
-        }
-
-        await mailbox.clear();
-        mailbox = false;
-    }
-
-    async getCurrentListing() {
-        this.checkIMAPConnection();
-
-        let listing = await this.imapClient.list();
-
-        let inboxData = (listing || []).find(entry => /^INBOX$/i.test(entry.path));
-        if (inboxData && inboxData.delimiter) {
-            this.defaultDelimiter = inboxData.delimiter;
-        }
-
-        // ignore non-selectable folders
-        listing = listing.filter(mailbox => !mailbox.flags.has('\\Noselect'));
-
-        let hasChanges = false;
-
-        // compare listing for new / deleted / renamed folders
-        let storedListing = await this.redis.hgetallBuffer(this.getMailboxListKey());
-        storedListing = Object.keys(storedListing || {})
-            .map(path => {
-                try {
-                    return msgpack.decode(storedListing[path]);
-                } catch (err) {
-                    // should not happen
-                }
-                return false;
-            })
-            .filter(entry => entry);
-
-        // compare listings
-        for (let mailbox of listing) {
-            let existingMailbox = storedListing.find(entry => normalizePath(entry.path) === normalizePath(mailbox.path));
-            if (!existingMailbox) {
-                // found new!
-                mailbox.isNew = true;
-                hasChanges = true;
-            } else if (existingMailbox.delimiter !== mailbox.delimiter) {
-                hasChanges = true;
-            }
-        }
-
-        for (let entry of storedListing) {
-            if (!listing.some(mailbox => normalizePath(entry.path) === normalizePath(mailbox.path))) {
-                // found deleted!
-                await this.clearMailboxEntry(entry);
-                hasChanges = true;
-            }
-        }
-
-        // on changes store updated listing
-        if (hasChanges) {
-            // store
-            let listingObject = {};
-            listing.forEach(entry => {
-                let mailbox = {};
-                Object.keys(entry).forEach(key => {
-                    if (['path', 'specialUse', 'name', 'listed', 'subscribed', 'delimiter'].includes(key)) {
-                        mailbox[key] = entry[key];
-                    }
-                });
-                listingObject[normalizePath(entry.path)] = msgpack.encode(mailbox);
-            });
-
-            await this.redis.multi().del(this.getMailboxListKey()).hmset(this.getMailboxListKey(), listingObject).exec();
-        }
-
-        return listing;
-    }
-
-    async asyncPeriodicListRefresh() {
-        let accountData = await this.accountObject.loadAccountData();
-        let listing = await this.getCurrentListing();
-
-        let syncNeeded = new Set();
-        for (let entry of listing) {
-            if (
-                // previously unseen
-                !this.mailboxes.has(normalizePath(entry.path))
-            ) {
-                if (accountData.path && accountData.path !== '*') {
-                    if (accountData.path !== entry.path) {
-                        // ignore changes
-                        entry.syncDisabled = true;
-                    }
-                } else if (this.isGmail && !['\\All', '\\Junk', '\\Trash'].includes(entry.specialUse)) {
-                    // do not look for changes from this folder
-                    entry.syncDisabled = true;
-                }
-
-                let mailbox = new Mailbox(this, entry);
-                this.mailboxes.set(normalizePath(entry.path), mailbox);
-                syncNeeded.add(mailbox);
-            }
-        }
-
-        // sync new mailboxes
-        for (let mailbox of syncNeeded) {
-            await mailbox.sync();
-        }
-    }
-
-    periodicListRefresh() {
-        if (this.closing || this.closed) {
-            return false;
-        }
-        clearTimeout(this.refreshListingTimer);
-
-        this.refreshListingTimer = setTimeout(() => {
-            this.asyncPeriodicListRefresh()
-                .catch(err => {
-                    this.logger.error({ msg: 'List refresh error', err });
-                })
-                .finally(() => {
-                    this.periodicListRefresh();
-                });
-        }, LIST_REFRESH_DELAY);
-        this.refreshListingTimer.unref();
-    }
-
-    async connect() {
-        if (this.closing || this.closed) {
-            return false;
-        }
-
-        let imapClient = this.imapClient;
-
-        let accountData = await this.accountObject.loadAccountData();
-
-        // throws if connection fails
-        let response = await imapClient.connect();
-
-        let listing = await this.getCurrentListing();
-        this.periodicListRefresh();
-
-        // User might have disabled All Mail folder access and in that case we should treat it as a regular mailbox
-        this.isGmail = imapClient.capabilities.has('X-GM-EXT-1') && listing.some(entry => entry.specialUse === '\\All');
-
-        for (let entry of listing) {
-            if (accountData.path && accountData.path !== '*') {
-                if (accountData.path !== entry.path) {
-                    entry.syncDisabled = true;
-                } else {
-                    this.main = entry;
-                }
-            } else {
-                if ((this.isGmail && entry.specialUse === '\\All') || (!this.isGmail && entry.specialUse === '\\Inbox')) {
-                    // In case of gmail prefer All mail folder as the folder to actively track, otherwise INBOX
-                    // idle in this folder
-                    this.main = entry;
-                }
-
-                if (this.isGmail && !['\\All', '\\Junk', '\\Trash'].includes(entry.specialUse)) {
-                    // do not look for changes from this folder
-                    entry.syncDisabled = true;
-                }
-            }
-
-            let mailbox = new Mailbox(this, entry);
-            this.mailboxes.set(normalizePath(entry.path), mailbox);
-        }
-
-        imapClient.on('expunge', event => {
-            if (!event || !event.path || !this.mailboxes.has(normalizePath(event.path))) {
-                return; //?
-            }
-
-            let mailbox = this.mailboxes.get(normalizePath(event.path));
-            mailbox.onExpunge(event).catch(err => {
-                this.logger.error({ msg: 'Expunge error', err });
-            });
-        });
-
-        // Process untagged EXISTS responses
-        imapClient.on('exists', event => {
-            if (!event || !event.path || !this.mailboxes.has(normalizePath(event.path))) {
-                return; //?
-            }
-
-            let mailbox = this.mailboxes.get(normalizePath(event.path));
-            mailbox.onExists(event).catch(err => {
-                this.logger.error({ msg: 'Exists error', err });
-            });
-        });
-
-        imapClient.on('mailboxOpen', event => {
-            if (!event || !event.path || !this.mailboxes.has(normalizePath(event.path))) {
-                return; //?
-            }
-
-            let mailbox = this.mailboxes.get(normalizePath(event.path));
-            mailbox.onOpen(event).catch(err => {
-                this.logger.error({ msg: 'Open error', err });
-            });
-        });
-
-        imapClient.on('mailboxClose', event => {
-            if (!event || !event.path || !this.mailboxes.has(normalizePath(event.path))) {
-                return; //?
-            }
-
-            let mailbox = this.mailboxes.get(normalizePath(event.path));
-            mailbox.onClose(event).catch(err => {
-                this.logger.error({ msg: 'Close error', err });
-            });
-        });
-
-        imapClient.on('flags', event => {
-            if (!event || !event.path || !this.mailboxes.has(normalizePath(event.path))) {
-                return; //?
-            }
-
-            let mailbox = this.mailboxes.get(normalizePath(event.path));
-            mailbox.onFlags(event).catch(err => {
-                this.logger.error({ msg: 'Flags error', err });
-            });
-        });
-
-        imapClient.on('close', () => {
-            let handler = async () => {
-                for (let mailbox of this.mailboxes) {
-                    if (mailbox.selected) {
-                        // should be at most one though
-                        await mailbox.onClose();
-                    }
-                }
-
-                if (!imapClient.disabled) {
-                    await this.reconnect();
-                }
-            };
-
-            this.logger.info({ msg: 'Connection closed', account: this.account });
-            handler().catch(err => {
-                this.logger.error({ msg: 'Connection close error', err });
-            });
-        });
-
-        return response;
-    }
-
-    async reconnect(force) {
-        if (this._connecting || this.closing || (this.closed && !force)) {
-            return false;
-        }
-
-        this._connecting = true;
-        this.closed = false;
-
-        try {
-            await backOff(() => this.start(), {
-                maxDelay: MAX_BACKOFF_DELAY,
-                numOfAttempts: Infinity,
-                retry: () => !this.closing && !this.closed,
-                startingDelay: 2000
-            });
-        } finally {
-            this._connecting = false;
-        }
-
-        try {
-            await this.checkIMAPConnection();
-            await this.syncMailboxes();
-        } catch (err) {
-            // ended in an unconncted state
-            this.logger.error({ msg: 'Failed to set up connection', err });
-        }
-    }
-
-    async syncMailboxes() {
-        clearTimeout(this.untaggedExpungeTimer);
-        clearTimeout(this.resyncTimer);
-        clearTimeout(this.completedTimer);
-
-        for (let mailbox of this.mailboxes.values()) {
-            await mailbox.sync();
-        }
-
-        this.state = 'connected';
-        await this.redis.hset(this.getAccountKey(), 'state', 'connected');
-        await this.redis.hset(this.getAccountKey(), 'lastErrorState', '{}');
-
-        let mainPath = this.main ? this.main.path : 'INBOX';
-        if (this.mailbox && normalizePath(this.mailbox.path) === normalizePath(mainPath)) {
-            // already selected
-            return;
-        }
-
-        // start waiting for changes
-        await this.select(mainPath);
-
-        // schedule next sync
-        this.resyncTimer = setTimeout(() => {
-            this.syncMailboxes().catch(err => {
-                this.logger.error({ msg: 'Mailbox Sync Error', err });
-            });
-        }, this.resyncDelay);
-    }
-
-    async select(path) {
-        if (!this.mailboxes.has(normalizePath(path))) {
-            // nothing to do here, mailbox not found
-            return;
-        }
-
-        let mailbox = this.mailboxes.get(normalizePath(path));
-        await mailbox.select();
-    }
-
-    getRandomId() {
-        let rid = BigInt('0x' + crypto.randomBytes(13).toString('hex')).toString(36);
-        if (rid.length < 20) {
-            rid = '0'.repeat(20 - rid.length) + rid;
-        } else if (rid.length > 20) {
-            rid = rid.substr(0, 20);
-        }
-        return rid;
-    }
-
-    async notify(mailbox, event, data) {
-        metrics(this.logger, 'events', 'inc', {
-            event
-        });
-
-        switch (event) {
-            case 'connectError':
-            case 'authenticationError':
-                return await this.setErrorState(event, data);
-        }
-
-        let payload = {
-            account: this.account,
-            date: new Date().toISOString()
-        };
-
-        let path = (mailbox && mailbox.path) || (data && data.path);
-        if (path) {
-            payload.path = path;
-        }
-
-        if (mailbox && mailbox.listingEntry && mailbox.listingEntry.specialUse) {
-            payload.specialUse = mailbox.listingEntry.specialUse;
-        }
-
-        if (event) {
-            payload.event = event;
-        }
-
-        if (data) {
-            payload.data = data;
-        }
-
-        await this.notifyQueue.add(event, payload, {
-            removeOnComplete: true,
-            removeOnFail: true,
-            attempts: 10,
-            backoff: {
-                type: 'exponential',
-                delay: 5000
-            }
-        });
-    }
-
-    getLocalAddress() {
-        // use default
-        if (!this.localAddresses.length) {
-            return { ip: false, name: false };
-        }
-        // just one
-        if (this.localAddresses.length === 1) {
-            return this.localAddresses[0];
-        }
-        // return random from list
-        return this.localAddresses[Math.floor(Math.random() * this.localAddresses.length)];
-    }
-
-    async start() {
-        let initialState = this.state;
-        if (this.imapClient) {
-            this.imapClient.disabled = true;
-            try {
-                this.imapClient.close();
-            } catch (err) {
-                this.logger.error({ msg: 'IMAP close error', err });
-            } finally {
-                this.imapClient = null;
-            }
-        }
-
-        try {
-            let accountData = await this.accountObject.loadAccountData();
-
-            this.notifyFrom = accountData.notifyFrom;
-
-            if (!accountData.imap && !accountData.oauth2) {
-                // can not make connection
-                this.state = 'unset';
-                return;
-            }
-
-            let imapConnectionConfig;
-            if (!accountData.imap && accountData.oauth2 && accountData.oauth2.auth) {
-                // load OAuth2 tokens
-                let now = Date.now();
-                let accessToken;
-                if (accountData.oauth2.expires < new Date(now + 30 * 1000)) {
-                    // renew access token
-                    try {
-                        let oauthKeys = {
-                            clientId: await settings.get('gmailClientId'),
-                            clientSecret: await settings.get('gmailClientSecret'),
-                            redirectUrl: await settings.get('gmailRedirectUrl')
-                        };
-
-                        if (!oauthKeys.clientId || !oauthKeys.clientSecret || !oauthKeys.redirectUrl) {
-                            throw new Error('OAuth2 credentials not set up');
-                        }
-
-                        accountData = await this.accountObject.renewAccessToken(oauthKeys);
-                        accessToken = accountData.oauth2.accessToken;
-                    } catch (err) {
-                        err.authenticationFailed = true;
-                        await this.notify(false, AUTH_ERROR_NOTIFY, {
-                            response: err.message,
-                            serverResponseCode: 'OauthRenewError'
-                        });
-                        this.logger.error({
-                            account: this.account,
-                            err
-                        });
-                        this.state = AUTH_ERROR_NOTIFY;
-                        throw err;
-                    }
-                } else {
-                    accessToken = accountData.oauth2.accessToken;
-                }
-
-                imapConnectionConfig = {
-                    auth: {
-                        user: accountData.oauth2.auth.user,
-                        accessToken
-                    },
-
-                    host: 'imap.gmail.com',
-                    port: 993,
-                    secure: true,
-                    resyncDelay: 900
-                };
-            } else {
-                // deep copy of imap settings
-                imapConnectionConfig = JSON.parse(JSON.stringify(accountData.imap));
-            }
-
-            // If authentication server is set then it overrides authentication data
-            if (imapConnectionConfig.useAuthServer) {
-                try {
-                    imapConnectionConfig.auth = await resolveCredentials(this.account, 'imap');
-                } catch (err) {
-                    err.authenticationFailed = true;
-                    await this.notify(false, AUTH_ERROR_NOTIFY, {
-                        response: err.message,
-                        serverResponseCode: 'HTTPRequestError'
-                    });
-                    this.logger.error({
-                        account: this.account,
-                        err
-                    });
-                    this.state = AUTH_ERROR_NOTIFY;
-                    throw err;
-                }
-            }
-
-            if (!imapConnectionConfig.tls) {
-                imapConnectionConfig.tls = {};
-            }
-            imapConnectionConfig.tls.localAddress = this.getLocalAddress().address;
-
-            let imapConfig = Object.assign(
-                {
-                    resyncDelay: RESYNC_DELAY,
-                    id: this.cid
-                },
-                imapConnectionConfig,
-                this.imapConfig
-            );
-            this.resyncDelay = imapConfig.resyncDelay * 1000;
-
-            this.imapClient = new ImapFlow(imapConfig);
-
-            // if emitLogs option is true then separate log event is fired for every log entry
-            this.imapClient.on('log', entry => {
-                if (!entry) {
-                    return false;
-                }
-
-                if (typeof entry === 'string') {
-                    // should not happen
-                    entry = { msg: entry };
-                }
-
-                this.accountLogger.log(entry);
-            });
-
-            this.imapClient.on('error', err => {
-                this.logger.error({ msg: 'IMAP connection error', account: this.account, err });
-                this.reconnect().catch(err => {
-                    this.logger.error({ msg: 'IMAP reconnection error', account: this.account, err });
-                });
-            });
-
-            try {
-                await this.connect();
-                await this.notify(false, AUTH_SUCCESS_NOTIFY, {
-                    user: imapConfig.auth.user
-                });
-            } catch (err) {
-                if (err.authenticationFailed) {
-                    this.logger.error({ msg: 'Failed to authenticate', account: this.account, err });
-                    await this.notify(false, AUTH_ERROR_NOTIFY, {
-                        response: err.response,
-                        serverResponseCode: err.serverResponseCode
-                    });
-                    this.state = 'authenticationError';
-                } else {
-                    this.logger.error({ msg: 'Failed to connect', account: this.account, err });
-                    await this.notify(false, CONNECT_ERROR_NOTIFY, {
-                        response: err.response || err.message,
-                        serverResponseCode: err.serverResponseCode || err.code
-                    });
-                    this.state = 'connectError';
-                }
-                throw err;
-            }
-        } finally {
-            if (this.state !== initialState) {
-                // update state
-                try {
-                    await this.redis.hset(this.getAccountKey(), 'state', this.state);
-                } catch (err) {
-                    // ignore
-                }
-            }
-        }
-    }
-
-    async init() {
-        await this.reconnect();
-    }
-
-    async setErrorState(event, data) {
-        await this.redis.hmset(this.getAccountKey(), {
-            state: event,
-            lastErrorState: JSON.stringify(data)
-        });
-    }
-
-    async delete() {
-        if (this.closed || this.closing) {
-            return;
-        }
-        this.closing = true;
-
-        if (this.imapClient) {
-            this.imapClient.close();
-        }
-
-        clearTimeout(this.refreshListingTimer);
-        clearTimeout(this.untaggedExpungeTimer);
-        clearTimeout(this.resyncTimer);
-        clearTimeout(this.completedTimer);
-
-        try {
-            for (let [, mailbox] of this.mailboxes) {
-                await mailbox.clear({ skipNotify: true });
-            }
-
-            await this.redis.del(this.getMailboxListKey());
-        } finally {
-            this.closing = false;
-            this.closed = true;
-        }
-
-        this.logger.info({ msg: 'Closed account', account: this.account });
-    }
-
-    async close() {
-        this.state = 'disconnected';
-        if (this.closed || this.closing) {
-            return;
-        }
-        this.closing = true;
-
-        if (this.imapClient) {
-            this.imapClient.close();
-        }
-
-        clearTimeout(this.refreshListingTimer);
-        clearTimeout(this.untaggedExpungeTimer);
-        clearTimeout(this.resyncTimer);
-        clearTimeout(this.completedTimer);
-
-        this.closing = false;
-        this.closed = true;
-    }
-
-    isConnected() {
-        return this.imapClient && this.imapClient.usable && !this.closing && !this.closed;
-    }
-
-    currentState() {
-        if (this.state === 'connected' && !this.isConnected()) {
-            this.state = 'disconnected';
-        }
-        return this.state;
-    }
-
-    checkIMAPConnection() {
-        if (!this.isConnected()) {
-            let err = new Error('IMAP connection temporarily not available');
-            err.code = 'IMAPUnavailable';
-            err.statusCode = 503;
-            throw err;
-        }
-    }
-
-    // Mailbox level user methods
-
-    /**
-     * Fetch message text from IMAP. Resulting value is a unicode string.
-     *
-     * @param {string} textId ID of the text content
-     * @param {object} [options] Options object
-     * @param {number} [options.maxLength] If set then limits output stream to specified chars (NB! not bytes but unicode characters). Limit applies to each text type separately, so 1000 would mean you'd get a 1000 char string for plaintext and 1000 char string for html.
-     * @param {string} [options.contentType] If set then limits output for selected type only
-     * @returns {Object} Text object, where key is text type (either 'plain' or 'html') and value is a unicode string
-     */
-    async getText(textId, options) {
-        options = options || {};
-        this.checkIMAPConnection();
-
-        let { message, textParts } = await this.getMessageTextPaths(textId);
-        if (!message || !textParts || !textParts.length) {
-            return false;
-        }
-
-        if (!this.mailboxes.has(normalizePath(message.path))) {
-            return; //?
-        }
-
-        let mailbox = this.mailboxes.get(normalizePath(message.path));
-
-        let textType = (options.textType || '').toLowerCase().trim();
-
-        if (Array.isArray(textParts)) {
-            let re = /^\d+(\.\d+)*$/;
-            switch (textType) {
-                case 'plain':
-                    textParts = Array.isArray(textParts[0]) ? textParts[0].filter(entry => re.test(entry)) : false;
-                    break;
-                case 'html':
-                    textParts = Array.isArray(textParts[1]) ? textParts[1].filter(entry => re.test(entry)) : false;
-                    break;
-                default:
-                    textParts = textParts.flatMap(part => part).filter(entry => re.test(entry));
-                    break;
-            }
-        } else {
-            textParts = [];
-        }
-
-        let result = await mailbox.getText(message, textParts, options);
-
-        if (textType && textType !== '*') {
-            result = {
-                [textType]: result[textType] || '',
-                hasMore: result.hasMore
-            };
-        }
-
-        return result;
-    }
-
-    async getMessage(id, options) {
-        options = options || {};
-        this.checkIMAPConnection();
-
-        let buf = Buffer.from(id.replace(/-/g, '+').replace(/_/g, '/'), 'base64');
-        let message = await this.unpackUid(buf.slice(0, 8));
-        if (!message) {
-            return false;
-        }
-
-        if (!this.mailboxes.has(normalizePath(message.path))) {
-            return false; //?
-        }
-
-        let mailbox = this.mailboxes.get(normalizePath(message.path));
-
-        return await mailbox.getMessage(message, options);
-    }
-
-    async updateMessage(id, updates) {
-        updates = updates || {};
-        this.checkIMAPConnection();
-
-        let buf = Buffer.from(id.replace(/-/g, '+').replace(/_/g, '/'), 'base64');
-        let message = await this.unpackUid(buf.slice(0, 8));
-        if (!message) {
-            return false;
-        }
-
-        if (!this.mailboxes.has(normalizePath(message.path))) {
-            return false; //?
-        }
-
-        let mailbox = this.mailboxes.get(normalizePath(message.path));
-
-        return await mailbox.updateMessage(message, updates);
-    }
-
-    async moveMessage(id, target) {
-        target = target || {};
-
-        this.checkIMAPConnection();
-
-        let buf = Buffer.from(id.replace(/-/g, '+').replace(/_/g, '/'), 'base64');
-        let message = await this.unpackUid(buf.slice(0, 8));
-
-        if (!message) {
-            return false;
-        }
-
-        if (!this.mailboxes.has(normalizePath(message.path))) {
-            return false; //?
-        }
-
-        let mailbox = this.mailboxes.get(normalizePath(message.path));
-        return await mailbox.moveMessage(message, target);
-    }
-
-    async deleteMessage(id, force) {
-        this.checkIMAPConnection();
-
-        let buf = Buffer.from(id.replace(/-/g, '+').replace(/_/g, '/'), 'base64');
-        let message = await this.unpackUid(buf.slice(0, 8));
-        if (!message) {
-            return false;
-        }
-
-        if (!this.mailboxes.has(normalizePath(message.path))) {
-            return false; //?
-        }
-
-        let mailbox = this.mailboxes.get(normalizePath(message.path));
-
-        return await mailbox.deleteMessage(message, force);
-    }
-
-    /**
-     * Downloads an attachment from IMAP as a binary stream
-     *
-     * @param {string} attachmentId ID of the attachment
-     * @param {object} [options] Options object
-     * @param {number} [options.maxLength] If set then limits output stream to specified bytes
-     * @returns {Boolean|Stream} Attahcment stream or `false` if not found
-     */
-    async getAttachment(attachmentId, options) {
-        this.checkIMAPConnection();
-
-        let buf = Buffer.from(attachmentId.replace(/-/g, '+').replace(/_/g, '/'), 'base64');
-        let id = buf.slice(0, 8);
-        let part = buf.slice(8).toString();
-
-        let message = await this.unpackUid(id);
-        if (!message) {
-            return false;
-        }
-
-        if (!this.mailboxes.has(normalizePath(message.path))) {
-            return false; //?
-        }
-
-        let mailbox = this.mailboxes.get(normalizePath(message.path));
-
-        return mailbox.getAttachment(message, part, options);
-    }
-
-    /**
-     * Downloads raw message from IMAP as a binary stream
-     *
-     * @param {string} id ID of the message
-     * @param {object} [options] Options object
-     * @param {number} [options.maxLength] If set then limits output stream to specified bytes
-     * @returns {Boolean|Stream} Attahcment stream or `false` if not found
-     */
-    async getRawMessage(id, options) {
-        this.checkIMAPConnection();
-
-        let buf = Buffer.from(id.replace(/-/g, '+').replace(/_/g, '/'), 'base64');
-        let message = await this.unpackUid(buf.slice(0, 8));
-        if (!message) {
-            return false;
-        }
-
-        if (!this.mailboxes.has(normalizePath(message.path))) {
-            return false; //?
-        }
-
-        let mailbox = this.mailboxes.get(normalizePath(message.path));
-
-        return mailbox.getAttachment(message, false, options);
-    }
-
-    async listMessages(options) {
-        options = options || {};
-        this.checkIMAPConnection();
-
-        if (!this.mailboxes.has(normalizePath(options.path))) {
-            return false; //?
-        }
-
-        let mailbox = this.mailboxes.get(normalizePath(options.path));
-
-        return mailbox.listMessages(options);
-    }
-
-    async buildContacts() {
-        this.checkIMAPConnection();
-
-        let addresses = [];
-        let addressesMap = new Map();
-
-        for (let [, mailbox] of this.mailboxes) {
-            if ((this.isGmail && mailbox.listingEntry.specialUse !== '\\All') || ['\\Junk', '\\Trash'].includes(mailbox.listingEntry.specialUse)) {
-                // Only look into All Mail for Gmail account, ignore Junk/Trash for other account
-                continue;
-            }
-
-            let result = await mailbox.buildContacts();
-            for (let address of result) {
-                if (!address.address) {
-                    continue;
-                }
-
-                address.address = address.address.replace(/\+[^@]*@/, '@');
-
-                if (!addressesMap.has(address.address)) {
-                    addressesMap.set(
-                        address.address,
-                        new Map([
-                            ['count', 0],
-                            ['names', new Map()],
-                            [
-                                'types',
-                                new Map([
-                                    ['from', 0],
-                                    ['to', 0],
-                                    ['cc', 0]
-                                ])
-                            ]
-                        ])
-                    );
-                }
-
-                let addressMap = addressesMap.get(address.address);
-
-                addressMap.set('count', addressMap.get('count') + 1);
-
-                let typeMap = addressMap.get('types');
-                if (typeMap.has(address.type)) {
-                    typeMap.set(address.type, typeMap.get(address.type) + 1);
-                } else {
-                    typeMap.set(address.type, 1);
-                }
-
-                if (address.name) {
-                    let nameMap = addressMap.get('names');
-                    if (nameMap.has(address.name)) {
-                        nameMap.set(address.name, nameMap.get(address.name) + 1);
-                    } else {
-                        nameMap.set(address.name, 1);
-                    }
-                }
-            }
-        }
-
-        for (let [address, data] of addressesMap) {
-            let names = data.has('names') ? Object.fromEntries(data.get('names').entries()) : {};
-            let mainName = { name: '', count: -1 };
-
-            if (data.has('names')) {
-                for (let [name, count] of data.get('names')) {
-                    if (name && count > mainName.count) {
-                        mainName = {
-                            name,
-                            count
-                        };
-                    }
-                }
-            }
-
-            addresses.push({
-                address,
-                name: mainName.name,
-                count: data.get('count'),
-                names,
-                types: data.has('types') ? Object.fromEntries(data.get('types').entries()) : {}
-            });
-        }
-
-        addresses.sort((a, b) => b.count - a.count);
-        return { addresses };
-    }
-
-    async deleteMailbox(path) {
-        this.checkIMAPConnection();
-
-        let result = {
-            path,
-            deleted: false // set to true if mailbox is actually deleted
-        };
-        try {
-            let lock = await this.imapClient.getMailboxLock(path);
-
-            try {
-                await this.imapClient.mailboxClose();
-                try {
-                    await this.imapClient.mailboxDelete(path);
-                    result.deleted = true;
-                } catch (err) {
-                    // kind of ignore
-                }
-            } finally {
-                lock.release();
-            }
-        } catch (err) {
-            this.logger.debug({ msg: 'Mailbox select error', path, err });
-        }
-
-        if (this.mailboxes.has(normalizePath(path))) {
-            let mailbox = this.mailboxes.get(normalizePath(path));
-            await mailbox.clear();
-        }
-
-        return result;
-    }
-
-    async createMailbox(path) {
-        this.checkIMAPConnection();
-        let result = await this.imapClient.mailboxCreate(path);
-        if (result) {
-            result.created = !!result.created;
-        }
-
-        let accountData = await this.accountObject.loadAccountData();
-
-        setImmediate(() => {
-            this.getCurrentListing()
-                .then(listing => {
-                    let syncNeeded = new Set();
-                    for (let entry of listing) {
-                        if (
-                            // previously unseen
-                            !this.mailboxes.has(normalizePath(entry.path))
-                        ) {
-                            if (accountData.path && accountData.path !== '*') {
-                                if (accountData.path !== entry.path) {
-                                    // ignore changes
-                                    entry.syncDisabled = true;
-                                }
-                            } else if (this.isGmail && !['\\All', '\\Junk', '\\Trash'].includes(entry.specialUse)) {
-                                // do not look for changes from this folder
-                                entry.syncDisabled = true;
-                            }
-
-                            let mailbox = new Mailbox(this, entry);
-                            this.mailboxes.set(normalizePath(entry.path), mailbox);
-                            syncNeeded.add(mailbox);
-                        }
-                    }
-
-                    let runSyncs = async () => {
-                        // sync new mailboxes
-                        for (let mailbox of syncNeeded) {
-                            await mailbox.sync();
-                        }
-                    };
-
-                    return runSyncs();
-                })
-                .catch(err => {
-                    this.logger.error({ msg: 'List refresh error', err });
-                });
-        });
-
-        return result;
-    }
-
-    async getSpecialUseMailbox(specialUse) {
-        let storedListing = await this.redis.hgetallBuffer(this.getMailboxListKey());
-        return Object.keys(storedListing || {})
-            .map(path => {
-                try {
-                    return msgpack.decode(storedListing[path]);
-                } catch (err) {
-                    // should not happen
-                }
-                return false;
-            })
-            .filter(entry => entry)
-            .find(entry => entry.specialUse === specialUse);
-    }
-
-    async submitMessage(data) {
-        let accountData = await this.accountObject.loadAccountData();
-        if (!accountData.smtp && !accountData.oauth2) {
-            // can not make connection
-            let err = new Error('SMTP configuration not found');
-            err.code = 'SMTPUnavailable';
-            err.statusCode = 404;
-            throw err;
-        }
-
-        let smtpConnectionConfig;
-        if (!accountData.smtp && accountData.oauth2 && accountData.oauth2.auth) {
-            // load OAuth2 tokens
-            let now = Date.now();
-            let accessToken;
-            if (accountData.oauth2.expires < now + 30 * 1000) {
-                // renew access token
-                try {
-                    let oauthKeys = {
-                        clientId: await settings.get('gmailClientId'),
-                        clientSecret: await settings.get('gmailClientSecret'),
-                        redirectUrl: await settings.get('gmailRedirectUrl')
-                    };
-
-                    if (!oauthKeys.clientId || !oauthKeys.clientSecret || !oauthKeys.redirectUrl) {
-                        throw new Error('OAuth2 credentials not set up');
-                    }
-
-                    accountData = await this.accountObject.renewAccessToken(oauthKeys);
-                    accessToken = accountData.oauth2.accessToken;
-                } catch (err) {
-                    err.authenticationFailed = true;
-                    await this.notify(false, AUTH_ERROR_NOTIFY, {
-                        response: err.message,
-                        serverResponseCode: 'OauthRenewError'
-                    });
-                    this.logger.error({
-                        account: this.account,
-                        err
-                    });
-                    this.state = AUTH_ERROR_NOTIFY;
-                    throw err;
-                }
-            } else {
-                accessToken = accountData.oauth2.accessToken;
-            }
-
-            smtpConnectionConfig = {
-                auth: {
-                    user: accountData.oauth2.auth.user,
-                    accessToken
-                },
-
-                host: 'smtp.gmail.com',
-                port: 465,
-                secure: true,
-                resyncDelay: 900
-            };
-        } else {
-            // deep copy of imap settings
-            smtpConnectionConfig = JSON.parse(JSON.stringify(accountData.smtp));
-        }
-
-        let { raw, hasBcc, envelope, messageId, queueId, reference } = data;
-
-        let smtpAuth = smtpConnectionConfig.auth;
-        // If authentication server is set then it overrides authentication data
-        if (smtpConnectionConfig.useAuthServer) {
-            try {
-                smtpAuth = await resolveCredentials(this.account, 'smtp');
-            } catch (err) {
-                err.authenticationFailed = true;
-                this.logger.error({
-                    account: this.account,
-                    err
-                });
-                throw err;
-            }
-        }
-
-        let { address, name } = this.getLocalAddress();
-
-        let smtpLogger = {};
-        let smtpSettings = Object.assign(
-            {
-                name,
-                localAddress: address,
-                transactionLog: true,
-                logger: smtpLogger
-            },
-            smtpConnectionConfig
-        );
-
-        if (smtpAuth) {
-            smtpSettings.auth = {
-                user: smtpAuth.user
-            };
-
-            if (smtpAuth.accessToken) {
-                smtpSettings.auth.type = 'OAuth2';
-                smtpSettings.auth.accessToken = smtpAuth.accessToken;
-            } else {
-                smtpSettings.auth.pass = smtpAuth.pass;
-            }
-        }
-
-        for (let level of ['trace', 'debug', 'info', 'warn', 'error', 'fatal']) {
-            smtpLogger[level] = (data, message, ...args) => {
-                if (args && args.length) {
-                    message = util.format(message, ...args);
-                }
-                data.msg = message;
-                data.sub = 'nodemailer';
-                if (typeof this.logger[level] === 'function') {
-                    this.logger[level](data);
-                } else {
-                    this.logger.debug(data);
-                }
-            };
-        }
-
-        const transporter = nodemailer.createTransport(smtpSettings);
-        try {
-            const info = await transporter.sendMail({
-                envelope,
-                messageId,
-                // make sure that Bcc line is removed from the version sent to SMTP
-                raw: !hasBcc ? raw : await removeBcc(raw)
-            });
-
-            if (
-                !this.isGmail &&
-                // if account settings do not have a copy value or it is set to true
-                (!Object.prototype.hasOwnProperty.call(accountData, 'copy') || accountData.copy)
-            ) {
-                // Upload message to Sent Mail folder. Gmail does this automatically.
-                try {
-                    this.checkIMAPConnection();
-                    let sentMailbox = await this.getSpecialUseMailbox('\\Sent');
-                    if (sentMailbox) {
-                        if (raw.buffer) {
-                            // convert from a Uint8Array to a Buffer
-                            raw = Buffer.from(raw);
-                        }
-
-                        await this.imapClient.append(sentMailbox.path, raw, ['\\Seen']);
-
-                        if (this.imapClient.mailbox && !this.imapClient.idling) {
-                            // force back to IDLE
-                            this.imapClient.idle().catch(err => {
-                                this.logger.error({ msg: 'IDLE error', err });
-                            });
-                        }
-                    }
-                } catch (err) {
-                    this.logger.error({ msg: 'Failed to upload Sent mail', queueId, messageId, err });
-                }
-            }
-
-            // Add \Answered flag to referenced message if needed
-            if (reference && reference.update) {
-                try {
-                    this.checkIMAPConnection();
-                    await this.updateMessage(reference.message, {
-                        flags: {
-                            add: ['\\Answered']
-                        }
-                    });
-                } catch (err) {
-                    this.logger.error({ msg: 'Failed to update reference flags', queueId, messageId, reference, err });
-                }
-            }
-
-            await this.notify(false, EMAIL_SENT_NOTIFY, {
-                messageId: info.messageId,
-                response: info.response,
-                queueId,
-                envelope
-            });
-
-            return {
-                response: info.response,
-                messageId: info.messageId
-            };
-        } catch (err) {
-            err.code = 'SubmitFail';
-            err.statusCode = 502;
-            throw err;
-        }
-    }
-
-    async queueMessage(data) {
-        let accountData = await this.accountObject.loadAccountData();
-        if (!accountData.smtp && !accountData.oauth2) {
-            // can not make connection
-            let err = new Error('SMTP configuration not found');
-            err.code = 'SMTPUnavailable';
-            err.statusCode = 404;
-            throw err;
-        }
-
-        // normal message
-        data.disableFileAccess = true;
-        data.disableUrlAccess = true;
-
-        // convert data uri images to attachments
-        data.attachDataUrls = true;
-
-        // Resolve reference and update reference/in-reply-to headers
-        if (data.reference && data.reference.message) {
-            let referencedMessage;
-            try {
-                this.checkIMAPConnection();
-                referencedMessage = await this.getMessage(data.reference.message, {
-                    fields: {
-                        uid: true,
-                        flags: true,
-                        envelope: true,
-                        headers: ['references']
-                    }
-                });
-                if (!referencedMessage) {
-                    throw new Error('Referenced message was not found');
-                }
-            } catch (err) {
-                this.logger.error({ msg: 'Failed to get referenced message', reference: data.reference.message, err });
-            }
-
-            if (referencedMessage) {
-                let references = []
-                    .concat(referencedMessage.messageId || [])
-                    .concat(referencedMessage.inReplyTo || [])
-                    .concat((referencedMessage.headers && referencedMessage.headers.references) || [])
-                    .flatMap(line => line.split(/\s+/))
-                    .map(ref => ref.trim())
-                    .filter(ref => ref)
-                    .map(ref => {
-                        if (!/^</.test(ref)) {
-                            ref = '<' + ref;
-                        }
-                        if (!/>$/.test(ref)) {
-                            ref = ref + '>';
-                        }
-                        return ref;
-                    });
-
-                references = Array.from(new Set(references));
-                if (references.length) {
-                    if (!data.headers) {
-                        data.headers = {};
-                    }
-                    data.headers.references = references.join(' ');
-                }
-
-                if (data.reference.action === 'reply' && referencedMessage.messageId) {
-                    data.headers['in-reply-to'] = referencedMessage.messageId;
-                }
-
-                if (!referencedMessage.flags || !referencedMessage.flags.includes('\\Answered')) {
-                    data.reference.update = true;
-                }
-
-                if (!data.subject && referencedMessage.subject) {
-                    let subject = referencedMessage.subject;
-                    let prefix;
-                    switch (data.reference.action) {
-                        case 'reply':
-                            if (!/^Re:/i.test(subject)) {
-                                prefix = 'Re';
-                            }
-                            break;
-                        case 'forward':
-                            if (!/^Fwd:/i.test(subject)) {
-                                prefix = 'Fwd';
-                            }
-                            break;
-                    }
-                    data.subject = `${prefix ? prefix + ': ' : ''}${subject}`;
-                }
-            }
-        }
-
-        const { raw, hasBcc, envelope, messageId, sendAt } = await getRawEmail(data);
-
-        let now = new Date();
-
-        //queue for later
-        let qId = crypto.randomBytes(8).toString('hex');
-        let msgEntry = msgpack.encode({
-            qId,
-            hasBcc,
-            envelope,
-            messageId,
-            reference: data.reference || {},
-            sendAt: (sendAt && sendAt.getTime()) || false,
-            created: now.getTime(),
-            raw
-        });
-
-        await this.redis.hsetBuffer(`iaq:${this.account}`, qId, msgEntry);
-
-        let job;
-        if (sendAt && sendAt > now) {
-            job = await this.submitQueue.add(
-                'delayed',
-                { account: this.account, qId, messageId, created: now.getTime() },
-                {
-                    removeOnComplete: true,
-                    removeOnFail: true,
-                    attempts: 10,
-                    backoff: {
-                        type: 'exponential',
-                        delay: 5000
-                    },
-                    delay: sendAt.getTime() - now.getTime()
-                }
-            );
-        } else {
-            job = await this.submitQueue.add(
-                'queued',
-                { account: this.account, qId, messageId, created: now.getTime() },
-                {
-                    removeOnComplete: true,
-                    removeOnFail: true,
-                    attempts: 10,
-                    backoff: {
-                        type: 'exponential',
-                        delay: 5000
-                    }
-                }
-            );
-        }
-
-        this.logger.info({ msg: 'Message queued for delivery', envelope, messageId, sendAt: (sendAt || now).toISOString(), queueId: qId, job: job.id });
-
-        return {
-            response: 'Queued for delivery',
-            messageId,
-            sendAt: (sendAt || now).toISOString(),
-            queueId: qId
-        };
-    }
-
-    async uploadMessage(data) {
-        this.checkIMAPConnection();
-
-        let accountData = await this.accountObject.loadAccountData();
-        if (!accountData.smtp) {
-            // can not make connection
-            let err = new Error('SMTP configuration not found');
-            err.code = 'SMTPUnavailable';
-            err.statusCode = 404;
-            throw err;
-        }
-
-        data.disableFileAccess = true;
-        data.disableUrlAccess = true;
-
-        // convert data uri images to attachments
-        data.attachDataUrls = true;
-
-        // Resolve reference and update reference/in-reply-to headers
-        if (data.reference && data.reference.message) {
-            let referencedMessage = await this.getMessage(data.reference.message, {
-                fields: {
-                    uid: true,
-                    flags: true,
-                    envelope: true,
-                    headers: ['references']
-                }
-            });
-
-            if (!referencedMessage) {
-                let err = new Error('Referenced message was not found');
-                err.code = 'MessageNotFound';
-                err.statusCode = 404;
-                throw err;
-            }
-
-            let references = []
-                .concat(referencedMessage.messageId || [])
-                .concat(referencedMessage.inReplyTo || [])
-                .concat((referencedMessage.headers && referencedMessage.headers.references) || [])
-                .flatMap(line => line.split(/\s+/))
-                .map(ref => ref.trim())
-                .filter(ref => ref)
-                .map(ref => {
-                    if (!/^</.test(ref)) {
-                        ref = '<' + ref;
-                    }
-                    if (!/>$/.test(ref)) {
-                        ref = ref + '>';
-                    }
-                    return ref;
-                });
-
-            references = Array.from(new Set(references));
-            if (references.length) {
-                if (!data.headers) {
-                    data.headers = {};
-                }
-                data.headers.references = references.join(' ');
-            }
-
-            if (data.reference.action === 'reply' && referencedMessage.messageId) {
-                data.headers['in-reply-to'] = referencedMessage.messageId;
-            }
-
-            if (!referencedMessage.flags || !referencedMessage.flags.includes('\\Answered')) {
-                try {
-                    await this.updateMessage(data.reference.message, {
-                        flags: {
-                            add: ['\\Answered']
-                        }
-                    });
-                } catch (err) {
-                    this.logger.error(err);
-                }
-            }
-
-            if (!data.subject && referencedMessage.subject) {
-                let subject = referencedMessage.subject;
-                let prefix;
-                switch (data.reference.action) {
-                    case 'reply':
-                        if (!/^Re:/i.test(subject)) {
-                            prefix = 'Re';
-                        }
-                        break;
-                    case 'forward':
-                        if (!/^Fwd:/i.test(subject)) {
-                            prefix = 'Fwd';
-                        }
-                        break;
-                }
-                data.subject = `${prefix ? prefix + ': ' : ''}${subject}`;
-            }
-        }
-
-        const mail = new MailComposer(data);
-        let raw = await mail.compile().build();
-
-        // Upload message to selected folder
-        try {
-            let lock = await this.imapClient.getMailboxLock(data.path);
-            let response = {};
-
-            try {
-                let uploadResponse = await this.imapClient.append(data.path, raw, data.flags);
-
-                response.path = uploadResponse.path;
-
-                if (uploadResponse.uid) {
-                    response.uid = uploadResponse.uid;
-                }
-
-                if (uploadResponse.uidValidity) {
-                    response.uidValidity = uploadResponse.uidValidity.toString();
-                }
-
-                if (uploadResponse.seq) {
-                    response.seq = uploadResponse.seq;
-                }
-
-                if (response.uid) {
-                    response.id = await this.packUid(response.path, response.uid);
-                }
-            } finally {
-                lock.release();
-            }
-
-            return response;
-        } catch (err) {
-            err.code = 'UploadFail';
-            err.statusCode = 502;
-            throw err;
-        }
-    }
-
-    getLogger() {
-        this.mainLogger =
-            this.options.logger ||
-            logger.child({
-                component: 'imap-client',
-                account: this.account,
-                cid: this.cid
-            });
-
-        let synteticLogger = {};
-        let levels = ['trace', 'debug', 'info', 'warn', 'error', 'fatal'];
-        for (let level of levels) {
-            synteticLogger[level] = (...args) => {
-                this.mainLogger[level](...args);
-
-                if (this.emitLogs && args && args[0] && typeof args[0] === 'object') {
-                    let entry = Object.assign({ level, t: Date.now(), cid: this.cid }, args[0]);
-                    if (entry.err && typeof entry.err === 'object') {
-                        let err = entry.err;
-                        entry.err = {
-                            stack: err.stack
-                        };
-                        // enumerable error fields
-                        Object.keys(err).forEach(key => {
-                            entry.err[key] = err[key];
-                        });
-                    }
-
-                    this.accountLogger.log(entry);
-                }
-            };
-        }
-        return synteticLogger;
-    }
-}
-
-module.exports.Connection = Connection;