emailengine-app 2.68.1 → 2.70.0

package/lib/email-client/imap/mailbox.js

@@ -23,7 +23,6 @@ const {
     MESSAGE_DELETED_NOTIFY,
     MESSAGE_UPDATED_NOTIFY,
     MESSAGE_MISSING_NOTIFY,
-    MAILBOX_RESET_NOTIFY,
     MAILBOX_NEW_NOTIFY,
     EMAIL_BOUNCE_NOTIFY,
     EMAIL_COMPLAINT_NOTIFY,
@@ -41,6 +40,7 @@ const {
     canUseCondstorePartialSync,
     canUseSimplePartialSync,
     canSkipSync,
+    shouldSeedLostIndex,
     FULL_SYNC_DELAY
 } = require('./sync-operations');
 
@@ -154,6 +154,8 @@ class Mailbox {
         let data = await this.connection.redis.hgetall(this.getMailboxKey());
         data = data || {};
 
+        let hasStoredState = Object.keys(data).length > 0;
+
         // Log diagnostic info if stored uidValidity is invalid or missing
         if (!validUidValidity(data.uidValidity)) {
             this.logger.warn({
@@ -162,12 +164,16 @@ class Mailbox {
                 redisKey: this.getMailboxKey(),
                 rawUidValidity: data.uidValidity,
                 rawUidValidityType: typeof data.uidValidity,
-                hasData: Object.keys(data).length > 0,
+                hasData: hasStoredState,
                 storedKeys: Object.keys(data)
             });
         }
 
         return {
+            // True when the mailbox hash held any fields at all. Redis eviction removes
+            // whole keys, so this distinguishes "state lost" from "individual fields
+            // never persisted" (e.g. uidNext on servers that omit UIDNEXT from SELECT)
+            hasStoredState,
             path: data.path || this.path,
             uidValidity: validUidValidity(data.uidValidity) ? BigInt(data.uidValidity) : false,
             highestModseq: data.highestModseq && !isNaN(data.highestModseq) ? BigInt(data.highestModseq) : false,
@@ -1934,6 +1940,16 @@ class Mailbox {
         return this.syncOps.partialSync(storedStatus);
     }
 
+    /**
+     * Silently rebuilds the message index after lost or invalidated sync state
+     * Delegates to SyncOperations
+     * @param {Object} mailboxStatus - Current mailbox status from IMAP
+     * @param {Object} [options] - Reseed options (reason, prevUidValidity)
+     */
+    async seedMailboxIndex(mailboxStatus, options) {
+        return this.syncOps.seedMailboxIndex(mailboxStatus, options);
+    }
+
     /**
      * Processes queued notification events after sync
      * Fetches full message details and sends notifications
@@ -2060,6 +2076,15 @@ class Mailbox {
         try {
             let storedStatus = await this.getStoredStatus();
 
+            // Lost-index recovery: the account has synced in a previous session but this folder
+            // has no stored state at all (e.g. Redis evicted the whole hash) while the server
+            // still has messages. Rebuild the baseline silently instead of replaying every
+            // message as a new email.
+            if (shouldSeedLostIndex(storedStatus, mailboxStatus, this.previouslyConnected)) {
+                await this.seedMailboxIndex(mailboxStatus, { reason: 'syncStateLost' });
+                return false;
+            }
+
             // Store initial UID on first sync
             if (storedStatus.uidNext === false && typeof mailboxStatus.uidNext === 'number') {
                 // update first UID
@@ -2088,19 +2113,17 @@ class Mailbox {
                 });
 
                 this.logger.debug({ msg: 'Mailbox reset', path: this.listingEntry.path });
-                await this.connection.notify(this, MAILBOX_RESET_NOTIFY, {
-                    path: this.listingEntry.path,
-                    name: this.listingEntry.name,
-                    specialUse: this.listingEntry.specialUse || false,
-                    uidValidity: validUidValidity(mailboxStatus.uidValidity) ? mailboxStatus.uidValidity.toString() : false,
-                    prevUidValidity: validUidValidity(storedStatus.uidValidity) ? storedStatus.uidValidity.toString() : false
-                });
 
                 // do not advertise messages as new
                 this.listingEntry.isNew = true;
 
-                // generates blank stored status as the Redis key was deleted
-                storedStatus = await this.getStoredStatus();
+                // Rebuild the index silently from the recreated mailbox and emit a single
+                // mailboxReset (with prev/current UIDVALIDITY) instead of replaying every message.
+                await this.seedMailboxIndex(mailboxStatus, {
+                    reason: 'uidValidityChange',
+                    prevUidValidity: validUidValidity(storedStatus.uidValidity) ? storedStatus.uidValidity.toString() : false
+                });
+                return false;
             }
 
             // Determine sync strategy using helper functions

package/lib/email-client/imap/subconnection.js

@@ -133,7 +133,6 @@ class Subconnection extends EventEmitter {
                 if (prevImapClient === this.imapClient) {
                     this.imapClient = null;
                 }
-                prevImapClient = null;
             }
         }
 
@@ -210,24 +209,32 @@ class Subconnection extends EventEmitter {
         let response = await imapClient.connect();
 
         // Process untagged EXISTS responses
-        imapClient.on('exists', async event => {
-            if (!event || !event.path) {
-                return; //?
-            }
+        imapClient.on('exists', event => {
+            try {
+                if (!event || !event.path) {
+                    return; //?
+                }
 
-            this.logger.info({ msg: 'Exists notification', account: this.account, event });
+                this.logger.info({ msg: 'Exists notification', account: this.account, event });
 
-            this.requestSync();
+                this.requestSync();
+            } catch (err) {
+                this.logger.error({ msg: 'Exists notification handling failed', account: this.account, err });
+            }
         });
 
-        imapClient.on('flags', async event => {
-            if (!event || !event.path) {
-                return; //?
-            }
+        imapClient.on('flags', event => {
+            try {
+                if (!event || !event.path) {
+                    return; //?
+                }
 
-            this.logger.info({ msg: 'Flags notification', account: this.account, event });
+                this.logger.info({ msg: 'Flags notification', account: this.account, event });
 
-            this.requestSync();
+                this.requestSync();
+            } catch (err) {
+                this.logger.error({ msg: 'Flags notification handling failed', account: this.account, err });
+            }
         });
 
         return response;

package/lib/email-client/imap/sync-operations.js

@@ -1,9 +1,9 @@
 'use strict';
 
 const crypto = require('crypto');
-const { compareExisting, calculateFetchBackoff, readEnvValue } = require('../../tools');
+const { compareExisting, calculateFetchBackoff, readEnvValue, validUidValidity } = require('../../tools');
 const config = require('@zone-eu/wild-config');
-const { DEFAULT_FETCH_BATCH_SIZE, FETCH_RETRY_MAX_TIME, FETCH_RETRY_MIN_ATTEMPTS } = require('../../consts');
+const { DEFAULT_FETCH_BATCH_SIZE, FETCH_RETRY_MAX_TIME, FETCH_RETRY_MIN_ATTEMPTS, MAILBOX_RESET_NOTIFY } = require('../../consts');
 
 // Configurable batch size for fetching messages (default: 250)
 const FETCH_BATCH_SIZE = Number(readEnvValue('EENGINE_FETCH_BATCH_SIZE') || config.service.fetchBatchSize) || DEFAULT_FETCH_BATCH_SIZE;
@@ -111,6 +111,32 @@ function canSkipSync(storedStatus, mailboxStatus) {
     return storedStatus.messages === mailboxStatus.messages && storedStatus.uidNext === mailboxStatus.uidNext && isRecentFullSync(storedStatus);
 }
 
+/**
+ * Determines whether a folder with no stored sync state should be rebuilt SILENTLY
+ * (recording existing messages without emitting messageNew) instead of replayed as new mail.
+ *
+ * This is the "lost index recovery" case: the account has already completed a previous
+ * connected session, yet this folder's mailbox hash is gone entirely while the server
+ * still reports messages. That mismatch means EmailEngine's per-mailbox state was lost
+ * (e.g. Redis evicted it) - replaying those already-synced messages as new would flood
+ * the webhook queue. A genuine first sync keeps `previouslyConnected <= 1` and is left
+ * to the normal notifyFrom-bounded path so intentional backfills still work.
+ *
+ * The decision keys on `hasStoredState` (did the hash hold ANY field), not on individual
+ * fields: Redis eviction removes whole keys, never single hash fields, while individual
+ * fields can legitimately stay absent forever - most notably `uidNext` on servers that
+ * omit UIDNEXT from the SELECT response (updateStoredStatus skips persisting falsy
+ * values), which must not re-trigger the reseed on every open.
+ *
+ * @param {Object} storedStatus - Stored mailbox status from getStoredStatus()
+ * @param {Object} mailboxStatus - Current mailbox status from IMAP
+ * @param {Number} previouslyConnected - Account-level connected-session counter (`state:count:connected`)
+ * @returns {Boolean} True if the index should be silently reseeded
+ */
+function shouldSeedLostIndex(storedStatus, mailboxStatus, previouslyConnected) {
+    return Number(previouslyConnected) > 1 && !(storedStatus && storedStatus.hasStoredState) && Number(mailboxStatus.messages) > 0;
+}
+
 /**
  * Handles the synchronization of IMAP mailboxes
  */
@@ -192,6 +218,107 @@ class SyncOperations {
         return { type: 'full', reason: 'changes_detected' };
     }
 
+    /**
+     * Rebuilds the mailbox baseline from the server's current state WITHOUT emitting
+     * messageNew notifications. Used when the stored sync state was lost (e.g. Redis evicted
+     * it) or invalidated (UIDVALIDITY change), then emits a single mailboxReset event so
+     * integrators can reconcile.
+     *
+     * Full indexer mode records every message on the server in the message index so only
+     * mail arriving afterwards is advertised as new. Fast indexer mode never maintains that
+     * index - the only baseline it needs is the stored uidNext that runFastSync compares
+     * against, so no per-message fetch is performed.
+     *
+     * @param {Object} mailboxStatus - Current mailbox status from IMAP
+     * @param {Object} [options]
+     * @param {String} [options.reason] - Why the reseed happened (included in the mailboxReset payload and logs)
+     * @param {String|Boolean} [options.prevUidValidity] - Previous UIDVALIDITY, when reseeding after a UIDVALIDITY change
+     * @returns {Number} Count of indexed messages (always 0 in fast indexer mode)
+     */
+    async seedMailboxIndex(mailboxStatus, options) {
+        options = options || {};
+        let reason = options.reason || 'syncStateLost';
+
+        let imapClient = this.connection.imapClient;
+        if (!imapClient) {
+            let err = new Error('IMAP connection not available');
+            err.code = 'IMAPConnectionClosing';
+            err.statusCode = 503;
+            throw err;
+        }
+
+        let imapIndexer = this.mailbox.imapIndexer;
+
+        let lock = await this.mailbox.getMailboxLock(null, { description: 'Seed mailbox index' });
+        this.connection.syncing = true;
+        this.mailbox.syncing = true;
+        try {
+            // Drop any stale queued notifications - we are establishing a fresh baseline
+            await this.connection.redis.del(this.mailbox.getNotificationsKey());
+
+            let indexed = 0;
+
+            if (imapIndexer === 'fast') {
+                // Fast mode detects new messages by comparing UIDs against the stored uidNext
+                // (hUpdateBigger in runFastSync), so that value is the baseline to establish.
+                // updateStoredStatus below persists it; when the server omits UIDNEXT from the
+                // SELECT response, derive the baseline from the highest UID on the server -
+                // otherwise the next runFastSync would replay every message as messageNew.
+                if (!mailboxStatus.uidNext && Number(mailboxStatus.messages) > 0) {
+                    let lastMessage = await imapClient.fetchOne('*', { uid: true });
+                    if (lastMessage && lastMessage.uid) {
+                        mailboxStatus = Object.assign({}, mailboxStatus, { uidNext: lastMessage.uid + 1 });
+                    }
+                }
+            } else {
+                let fields = { uid: true, flags: true, modseq: true, emailId: true, labels: true, internalDate: true };
+
+                // Record every message currently on the server as already-seen, without queuing notifications
+                for await (let messageData of imapClient.fetch('1:*', fields, { uid: true })) {
+                    if (!messageData || !messageData.uid) {
+                        continue;
+                    }
+                    // ignore Recent flag
+                    messageData.flags.delete('\\Recent');
+                    await this.mailbox.entryListSet(messageData);
+                    indexed++;
+                }
+            }
+
+            // Persist the current server state as the new baseline. updateStoredStatus also sets
+            // initialUidNext (via hSetNew) so future arrivals are detected normally.
+            await this.mailbox.updateStoredStatus(mailboxStatus);
+
+            this.logger.warn({
+                msg: 'Rebuilt mailbox baseline without notifications',
+                action: 'lost_index_recovery',
+                path: this.mailbox.path,
+                imapIndexer,
+                messages: imapIndexer === 'fast' ? Number(mailboxStatus.messages) || 0 : indexed,
+                reason
+            });
+
+            // Inform integrators that this folder was reset so they can reconcile if needed
+            let resetPayload = {
+                path: this.mailbox.listingEntry.path,
+                name: this.mailbox.listingEntry.name,
+                specialUse: this.mailbox.listingEntry.specialUse || false,
+                uidValidity: validUidValidity(mailboxStatus.uidValidity) ? mailboxStatus.uidValidity.toString() : false,
+                reason
+            };
+            if (typeof options.prevUidValidity !== 'undefined') {
+                resetPayload.prevUidValidity = options.prevUidValidity;
+            }
+            await this.connection.notify(this.mailbox, MAILBOX_RESET_NOTIFY, resetPayload);
+
+            return indexed;
+        } finally {
+            lock.release();
+            this.connection.syncing = false;
+            this.mailbox.syncing = false;
+        }
+    }
+
     /**
      * Fast sync mode - only tracks new messages, doesn't maintain full message list
      * More efficient for large mailboxes where we only care about new messages
@@ -782,7 +909,7 @@ class SyncOperations {
                                     currentPath: currentMailbox ? currentMailbox.path : 'none',
                                     loopId
                                 });
-                                throw new Error('Mailbox changed during sync operation');
+                                throw new Error('Mailbox changed during sync operation', { cause: err });
                             }
 
                             // Refresh mailbox status in case it changed
@@ -856,6 +983,7 @@ module.exports = {
     canUseCondstorePartialSync,
     canUseSimplePartialSync,
     canSkipSync,
+    shouldSeedLostIndex,
     FETCH_BATCH_SIZE,
     FULL_SYNC_DELAY
 };

package/lib/email-client/imap-client.js

@@ -790,69 +790,116 @@ class IMAPClient extends BaseClient {
             this.main = mainList.sort((a, b) => a.index - b.index)[0].entry;
         }
 
-        // Set up event handlers for IMAP notifications
+        // Set up event handlers for IMAP notifications. Each listener delegates to a
+        // method that wraps the whole body (including normalizePath/lookup) in
+        // try/catch, so a malformed event can never become an unhandled rejection
+        // that kills the worker.
 
         // Process untagged EXISTS responses (new messages)
-        imapClient.on('exists', async event => {
-            if (!event || !event.path || !this.mailboxes.has(normalizePath(event.path))) {
-                return; //?
-            }
-
-            let mailbox = this.mailboxes.get(normalizePath(event.path));
-            try {
-                await mailbox.onExists(event);
-            } catch (err) {
-                imapClient.log.error({ msg: 'Exists error', err });
-            }
-        });
+        imapClient.on('exists', event => this.handleExistsEvent(imapClient, event));
 
         // Handle mailbox open events
-        imapClient.on('mailboxOpen', async event => {
-            if (!event || !event.path || !this.mailboxes.has(normalizePath(event.path))) {
-                return; //?
-            }
-
-            let mailbox = this.mailboxes.get(normalizePath(event.path));
-            try {
-                await mailbox.onOpen(event);
-            } catch (err) {
-                if (err.code === 'IMAPConnectionClosing') {
-                    imapClient.log.debug({ msg: 'Open skipped, connection closing', err });
-                } else {
-                    imapClient.log.error({ msg: 'Open error', err });
-                }
-            }
-        });
+        imapClient.on('mailboxOpen', event => this.handleMailboxOpenEvent(imapClient, event));
 
         // Handle mailbox close events
-        imapClient.on('mailboxClose', async event => {
-            if (!event || !event.path || !this.mailboxes.has(normalizePath(event.path))) {
-                return; //?
-            }
+        imapClient.on('mailboxClose', event => this.handleMailboxCloseEvent(imapClient, event));
 
-            let mailbox = this.mailboxes.get(normalizePath(event.path));
-            try {
-                await mailbox.onClose(event);
-            } catch (err) {
-                imapClient.log.error({ msg: 'Close error', err });
+        // Handle flag changes
+        imapClient.on('flags', event => this.handleFlagsEvent(imapClient, event));
+
+        return response;
+    }
+
+    /**
+     * Resolves the tracked Mailbox for an IMAP event, or null when the event has no
+     * tracked path. May throw on a malformed path - callers must run it inside a
+     * try/catch (see the handle*Event methods below).
+     * @param {Object} event - IMAP event with a `path` property
+     * @returns {Mailbox|null} Tracked mailbox or null
+     */
+    resolveEventMailbox(event) {
+        if (!event || !event.path) {
+            return null;
+        }
+
+        let path = normalizePath(event.path);
+        if (!this.mailboxes.has(path)) {
+            return null;
+        }
+
+        return this.mailboxes.get(path);
+    }
+
+    /**
+     * Handles an untagged EXISTS notification (new messages in a mailbox)
+     * @param {Object} imapClient - IMAP connection that emitted the event
+     * @param {Object} event - Event payload
+     */
+    async handleExistsEvent(imapClient, event) {
+        try {
+            let mailbox = this.resolveEventMailbox(event);
+            if (!mailbox) {
+                return;
             }
-        });
+            await mailbox.onExists(event);
+        } catch (err) {
+            imapClient.log.error({ msg: 'Exists error', err });
+        }
+    }
 
-        // Handle flag changes
-        imapClient.on('flags', async event => {
-            if (!event || !event.path || !this.mailboxes.has(normalizePath(event.path))) {
-                return; //?
+    /**
+     * Handles a mailbox open notification
+     * @param {Object} imapClient - IMAP connection that emitted the event
+     * @param {Object} event - Event payload
+     */
+    async handleMailboxOpenEvent(imapClient, event) {
+        try {
+            let mailbox = this.resolveEventMailbox(event);
+            if (!mailbox) {
+                return;
+            }
+            await mailbox.onOpen(event);
+        } catch (err) {
+            if (err.code === 'IMAPConnectionClosing') {
+                imapClient.log.debug({ msg: 'Open skipped, connection closing', err });
+            } else {
+                imapClient.log.error({ msg: 'Open error', err });
             }
+        }
+    }
 
-            let mailbox = this.mailboxes.get(normalizePath(event.path));
-            try {
-                await mailbox.onFlags(event);
-            } catch (err) {
-                imapClient.log.error({ msg: 'Flags error', err });
+    /**
+     * Handles a mailbox close notification
+     * @param {Object} imapClient - IMAP connection that emitted the event
+     * @param {Object} event - Event payload
+     */
+    async handleMailboxCloseEvent(imapClient, event) {
+        try {
+            let mailbox = this.resolveEventMailbox(event);
+            if (!mailbox) {
+                return;
             }
-        });
+            await mailbox.onClose(event);
+        } catch (err) {
+            imapClient.log.error({ msg: 'Close error', err });
+        }
+    }
 
-        return response;
+    /**
+     * Handles a flag change notification
+     * @param {Object} imapClient - IMAP connection that emitted the event
+     * @param {Object} event - Event payload
+     */
+    async handleFlagsEvent(imapClient, event) {
+        try {
+            let mailbox = this.resolveEventMailbox(event);
+            if (!mailbox) {
+                return;
+            }
+            await mailbox.onFlags(event);
+        } catch (err) {
+            imapClient.log.error({ msg: 'Flags error', err });
+        }
     }
 
     /**
@@ -1599,6 +1646,12 @@ class IMAPClient extends BaseClient {
         } finally {
             this.isClosing = false;
             this.isClosed = true;
+
+            // Tear down subconnections just like close() does, otherwise their IMAP
+            // clients keep reconnecting to the now-deleted account. This runs in the
+            // finally so a mailbox or Redis error above cannot leave them alive
+            // (closeSubconnections is internally guarded and never throws).
+            this.closeSubconnections();
         }
 
         this.logger.info({ msg: 'Closed account', account: this.account });
@@ -1805,11 +1858,13 @@ class IMAPClient extends BaseClient {
 
         this.checkIMAPConnection(connectionOptions);
 
-        if (!this.mailboxes.has(normalizePath(path))) {
+        path = await this.resolvePathAlias(path);
+
+        if (!this.mailboxes.has(path)) {
             return false; //?
         }
 
-        let mailbox = this.mailboxes.get(normalizePath(path));
+        let mailbox = this.mailboxes.get(path);
 
         return await mailbox.updateMessages(search, updates, connectionOptions);
     }
@@ -1871,11 +1926,13 @@ class IMAPClient extends BaseClient {
 
         this.checkIMAPConnection(connectionOptions);
 
-        if (!this.mailboxes.has(normalizePath(source))) {
+        source = await this.resolvePathAlias(source);
+
+        if (!this.mailboxes.has(source)) {
             return false; //?
         }
 
-        let mailbox = this.mailboxes.get(normalizePath(source));
+        let mailbox = this.mailboxes.get(source);
 
         let res = await mailbox.moveMessages(search, target, connectionOptions);
 
@@ -1928,11 +1985,13 @@ class IMAPClient extends BaseClient {
 
         this.checkIMAPConnection(connectionOptions);
 
-        if (!this.mailboxes.has(normalizePath(path))) {
+        path = await this.resolvePathAlias(path);
+
+        if (!this.mailboxes.has(path)) {
             return false; //?
         }
 
-        let mailbox = this.mailboxes.get(normalizePath(path));
+        let mailbox = this.mailboxes.get(path);
         let res = await mailbox.deleteMessages(search, force, connectionOptions);
 
         // force sync target mailbox if messages were moved to trash
@@ -2059,15 +2118,8 @@ class IMAPClient extends BaseClient {
 
         this.checkIMAPConnection(connectionOptions);
 
-        let path = normalizePath(options.path);
-
         // Handle special-use folder aliases
-        if (['\\Junk', '\\Sent', '\\Trash', '\\Inbox', '\\Drafts', '\\All'].includes(path)) {
-            let resolvedPath = await this.getSpecialUseMailbox(path);
-            if (resolvedPath) {
-                path = resolvedPath.path;
-            }
-        }
+        let path = await this.resolvePathAlias(options.path);
 
         if (!this.mailboxes.has(path)) {
             return false; //?
@@ -2241,7 +2293,7 @@ class IMAPClient extends BaseClient {
                 throw error;
             } else if (err.responseStatus === 'NO') {
                 return {
-                    path,
+                    path: [].concat(path || []).join('/'),
                     created: false
                 };
             } else {
@@ -2304,7 +2356,7 @@ class IMAPClient extends BaseClient {
                         error.info = {
                             response: err.response && typeof err.response === 'string' && err.response.replace(/^[^\s]*\s*/, '')
                         };
-                        error.code = err.serverResponseCode;
+                        error.code = err.serverResponseCode || 'RenameFailed';
                         error.statusCode = 400;
                         throw error;
                     } else {
@@ -2360,6 +2412,26 @@ class IMAPClient extends BaseClient {
             .find(entry => entry.specialUse === specialUse);
     }
 
+    /**
+     * Resolves a special-use folder alias (e.g. "\Sent") to the real mailbox path.
+     * Returns the normalized input path unchanged if it is not an alias or if no
+     * mailbox with the requested special-use flag exists.
+     * @param {string} path - Mailbox path or special-use alias
+     * @returns {string} Normalized mailbox path
+     */
+    async resolvePathAlias(path) {
+        path = normalizePath(path);
+
+        if (['\\Junk', '\\Sent', '\\Trash', '\\Inbox', '\\Drafts', '\\All'].includes(path)) {
+            let resolved = await this.getSpecialUseMailbox(path);
+            if (resolved) {
+                path = normalizePath(resolved.path);
+            }
+        }
+
+        return path;
+    }
+
     /**
      * Uploads a message to a mailbox
      * @param {Object} data - Message data including path, flags, content
@@ -2390,12 +2462,18 @@ class IMAPClient extends BaseClient {
                 });
             }
 
-            // Pack response data
+            // Pack response data. ImapFlow's append() returns `destination` as the
+            // append target and `path` as the currently selected mailbox (often the
+            // idling INBOX), so prefer `destination` when building the response path
+            // and message id. Otherwise uploads to a non-selected folder would report
+            // an id that points at the selected mailbox and fails to resolve.
+            let destinationPath = uploadResponse.destination || uploadResponse.path || data.path;
+
             if (uploadResponse.uid) {
-                response.id = await this.packUid(uploadResponse.path || data.path, uploadResponse.uid);
+                response.id = await this.packUid(destinationPath, uploadResponse.uid);
             }
 
-            response.path = uploadResponse.path;
+            response.path = destinationPath;
 
             if (uploadResponse.uid) {
                 response.uid = uploadResponse.uid;
@@ -2448,12 +2526,11 @@ class IMAPClient extends BaseClient {
      * @param {Object} payload - Expunge event data
      */
     async expungeHandler(payload) {
-        if (!payload || !payload.path || !this.mailboxes.has(normalizePath(payload.path))) {
-            return; //?
-        }
-
-        let mailbox = this.mailboxes.get(normalizePath(payload.path));
         try {
+            let mailbox = this.resolveEventMailbox(payload);
+            if (!mailbox) {
+                return;
+            }
             await mailbox.onExpunge(payload);
         } catch (err) {
             this.logger.error({ msg: 'Expunge error', err });
@@ -2676,7 +2753,7 @@ class IMAPClient extends BaseClient {
         const emptyResponse = { signatures: [], signaturesSupported: false };
         let accountData = await this.accountObject.loadAccountData();
 
-        if (!accountData.oauth2.provider) {
+        if (!accountData.oauth2?.provider) {
             // Not an OAuth2 account
             return emptyResponse;
         }

package/lib/email-client/notification-handler.js

@@ -157,10 +157,7 @@ class NotificationHandler {
             }
         } catch (err) {
             if (this.logger.notifyError) {
-                this.logger.notifyError(err, event => {
-                    event.setUser(this.account);
-                    event.addMetadata('ee', { index });
-                });
+                this.logger.notifyError(err, { user: this.account, meta: { index } });
             }
             this.logger.error({
                 msg: 'Failed to resolve thread',