imapflow 1.0.193 → 1.0.195

package/lib/imap-flow.js

@@ -369,7 +369,8 @@ class ImapFlow extends EventEmitter {
         this.streamer.on('error', err => {
             if (['Z_BUF_ERROR', 'ECONNRESET', 'EPIPE', 'ETIMEDOUT', 'EHOSTUNREACH'].includes(err.code)) {
                 // just close the connection, usually nothing but noise
-                return setImmediate(() => this.close());
+                this.closeAfter();
+                return;
             }
 
             this.log.error({ err, cid: this.id });
@@ -386,7 +387,7 @@ class ImapFlow extends EventEmitter {
         }
         err._connId = err._connId || this.id;
 
-        setImmediate(() => this.close());
+        this.closeAfter();
         this.emit('error', err);
     }
 
@@ -494,7 +495,7 @@ class ImapFlow extends EventEmitter {
 
         let options = data.options || {};
 
-        this.log.debug({ src: 's', msg: logCompiled.toString(), cid: this.id, comment: options.comment });
+        this.log.debug({ src: 'c', msg: logCompiled.toString(), cid: this.id, comment: options.comment });
 
         this.write(this.commandParts.shift());
 
@@ -571,6 +572,7 @@ class ImapFlow extends EventEmitter {
 
     async reader() {
         let data;
+        let processedCount = 0;
         while ((data = this.streamer.read()) !== null) {
             let parsed;
 
@@ -736,6 +738,12 @@ class ImapFlow extends EventEmitter {
             }
 
             data.next();
+
+            // Yield to event loop every 10 processed messages to prevent CPU blocking
+            processedCount++;
+            if (processedCount % 10 === 0) {
+                await new Promise(resolve => setImmediate(resolve));
+            }
         }
     }
 
@@ -764,16 +772,8 @@ class ImapFlow extends EventEmitter {
                 this.log.error({ err, cid: this.id });
                 this.emitError(err);
             });
-        this._socketClose =
-            this._socketClose ||
-            (() => {
-                this.close();
-            });
-        this._socketEnd =
-            this._socketEnd ||
-            (() => {
-                this.close();
-            });
+        this._socketClose = this._socketClose || (() => this.close());
+        this._socketEnd = this._socketEnd || (() => this.close());
 
         /**
          * Socket timeout event handler.
@@ -892,11 +892,17 @@ class ImapFlow extends EventEmitter {
             return; // was not able to negotiate compression
         }
 
-        // create deflate/inflate streams
+        // create deflate/inflate streams with rate limiting options
         this._deflate = zlib.createDeflateRaw({
-            windowBits: 15
+            windowBits: 15,
+            level: zlib.constants.Z_DEFAULT_COMPRESSION, // Use default compression level (6)
+            memLevel: 8, // Memory usage level (8 is default)
+            strategy: zlib.constants.Z_DEFAULT_STRATEGY,
+            chunkSize: 16 * 1024 // Process in 16KB chunks to prevent CPU blocking
+        });
+        this._inflate = zlib.createInflateRaw({
+            chunkSize: 16 * 1024 // Process in 16KB chunks to prevent CPU blocking
         });
-        this._inflate = zlib.createInflateRaw();
 
         // route incoming socket via inflate stream
         this.socket.unpipe(this.streamer);
@@ -906,8 +912,10 @@ class ImapFlow extends EventEmitter {
             this.streamer.emit('error', err);
         });
 
-        // route outgoing socket via deflate stream
-        this.writeSocket = new PassThrough();
+        // route outgoing socket via deflate stream with rate limiting
+        this.writeSocket = new PassThrough({
+            highWaterMark: 64 * 1024 // 64KB buffer limit to prevent excessive memory usage
+        });
 
         this.writeSocket.destroySoon = () => {
             try {
@@ -928,22 +936,34 @@ class ImapFlow extends EventEmitter {
         // we need to force flush deflated data to socket so we can't
         // use normal pipes for this.writeSocket -> this._deflate -> this.socket
         let reading = false;
-        let readNext = () => {
-            reading = true;
+        let processedChunks = 0;
+        let readNext = async () => {
+            try {
+                reading = true;
+                processedChunks = 0;
+
+                let chunk;
+                while ((chunk = this.writeSocket.read()) !== null) {
+                    if (this._deflate && this._deflate.write(chunk) === false) {
+                        return this._deflate.once('drain', readNext);
+                    }
 
-            let chunk;
-            while ((chunk = this.writeSocket.read()) !== null) {
-                if (this._deflate && this._deflate.write(chunk) === false) {
-                    return this._deflate.once('drain', readNext);
+                    // Yield to event loop every 100 chunks to prevent CPU blocking
+                    processedChunks++;
+                    if (processedChunks % 100 === 0) {
+                        await new Promise(resolve => setImmediate(resolve));
+                    }
                 }
-            }
 
-            // flush data to socket
-            if (this._deflate) {
-                this._deflate.flush();
-            }
+                // flush data to socket
+                if (this._deflate) {
+                    this._deflate.flush();
+                }
 
-            reading = false;
+                reading = false;
+            } catch (ex) {
+                this.emitError(ex);
+            }
         };
 
         this.writeSocket.on('readable', () => {
@@ -1024,7 +1044,7 @@ class ImapFlow extends EventEmitter {
                     // don't care anymore
                     return;
                 }
-                setImmediate(() => this.close());
+                this.closeAfter();
                 this.upgrading = false;
                 err.tlsFailed = true;
                 reject(err);
@@ -1034,7 +1054,7 @@ class ImapFlow extends EventEmitter {
                 if (!this.upgrading) {
                     return;
                 }
-                setImmediate(() => this.close());
+                this.closeAfter();
                 let err = new Error('Failed to upgrade connection in required time');
                 err.tlsFailed = true;
                 err.code = 'UPGRADE_TIMEOUT';
@@ -1043,30 +1063,34 @@ class ImapFlow extends EventEmitter {
 
             this.upgrading = true;
             this.socket = tls.connect(opts, () => {
-                clearTimeout(this.upgradeTimeout);
-                if (this.isClosed) {
-                    // not sure if this is possible?
-                    return this.close();
-                }
+                try {
+                    clearTimeout(this.upgradeTimeout);
+                    if (this.isClosed) {
+                        // not sure if this is possible?
+                        return this.close();
+                    }
 
-                this.secureConnection = true;
-                this.upgrading = false;
-                this.streamer.secureConnection = true;
-                this.socket.pipe(this.streamer);
-                this.tls = typeof this.socket.getCipher === 'function' ? this.socket.getCipher() : false;
-                if (this.tls) {
-                    this.tls.authorized = this.socket.authorized;
-                    this.log.info({
-                        src: 'tls',
-                        msg: 'Established TLS session',
-                        cid: this.id,
-                        authorized: this.tls.authorized,
-                        algo: this.tls.standardName || this.tls.name,
-                        version: this.tls.version
-                    });
-                }
+                    this.secureConnection = true;
+                    this.upgrading = false;
+                    this.streamer.secureConnection = true;
+                    this.socket.pipe(this.streamer);
+                    this.tls = typeof this.socket.getCipher === 'function' ? this.socket.getCipher() : false;
+                    if (this.tls) {
+                        this.tls.authorized = this.socket.authorized;
+                        this.log.info({
+                            src: 'tls',
+                            msg: 'Established TLS session',
+                            cid: this.id,
+                            authorized: this.tls.authorized,
+                            algo: this.tls.standardName || this.tls.name,
+                            version: this.tls.version
+                        });
+                    }
 
-                return resolve(true);
+                    return resolve(true);
+                } catch (ex) {
+                    this.emitError(ex);
+                }
             });
 
             this.writeSocket = this.socket;
@@ -1214,7 +1238,7 @@ class ImapFlow extends EventEmitter {
                     return reject(err);
                 }
 
-                setImmediate(() => this.close());
+                this.closeAfter();
             });
     }
 
@@ -1517,55 +1541,62 @@ class ImapFlow extends EventEmitter {
                     connectionTimeout: this.options.connectionTimeout || CONNECT_TIMEOUT
                 };
                 this.log.error({ err, cid: this.id });
-                setImmediate(() => this.close());
+                this.closeAfter();
                 reject(err);
             }, this.options.connectionTimeout || CONNECT_TIMEOUT);
 
             let onConnect = () => {
-                clearTimeout(this.connectTimeout);
-                this.socket.setKeepAlive(true, 5 * 1000);
-                this.socket.setTimeout(this.options.socketTimeout || SOCKET_TIMEOUT);
-
-                this.greetingTimeout = setTimeout(() => {
-                    let err = new Error(`Failed to receive greeting from server in required time${!this.secureConnection ? '. Maybe should use TLS?' : ''}`);
-                    err.code = 'GREETING_TIMEOUT';
-                    err.details = {
-                        greetingTimeout: this.options.greetingTimeout || GREETING_TIMEOUT
+                try {
+                    clearTimeout(this.connectTimeout);
+                    this.socket.setKeepAlive(true, 5 * 1000);
+                    this.socket.setTimeout(this.options.socketTimeout || SOCKET_TIMEOUT);
+
+                    this.greetingTimeout = setTimeout(() => {
+                        let err = new Error(
+                            `Failed to receive greeting from server in required time${!this.secureConnection ? '. Maybe should use TLS?' : ''}`
+                        );
+                        err.code = 'GREETING_TIMEOUT';
+                        err.details = {
+                            greetingTimeout: this.options.greetingTimeout || GREETING_TIMEOUT
+                        };
+                        this.log.error({ err, cid: this.id });
+                        this.closeAfter();
+                        reject(err);
+                    }, this.options.greetingTimeout || GREETING_TIMEOUT);
+
+                    this.tls = typeof this.socket.getCipher === 'function' ? this.socket.getCipher() : false;
+
+                    let logInfo = {
+                        src: 'connection',
+                        msg: `Established ${this.tls ? 'secure ' : ''}TCP connection`,
+                        cid: this.id,
+                        secure: !!this.tls,
+                        host: this.host,
+                        servername: this.servername,
+                        port: this.socket.remotePort,
+                        address: this.socket.remoteAddress,
+                        localAddress: this.socket.localAddress,
+                        localPort: this.socket.localPort
                     };
-                    this.log.error({ err, cid: this.id });
-                    setImmediate(() => this.close());
-                    reject(err);
-                }, this.options.greetingTimeout || GREETING_TIMEOUT);
-
-                this.tls = typeof this.socket.getCipher === 'function' ? this.socket.getCipher() : false;
-
-                let logInfo = {
-                    src: 'connection',
-                    msg: `Established ${this.tls ? 'secure ' : ''}TCP connection`,
-                    cid: this.id,
-                    secure: !!this.tls,
-                    host: this.host,
-                    servername: this.servername,
-                    port: this.socket.remotePort,
-                    address: this.socket.remoteAddress,
-                    localAddress: this.socket.localAddress,
-                    localPort: this.socket.localPort
-                };
 
-                if (this.tls) {
-                    logInfo.authorized = this.tls.authorized = this.socket.authorized;
-                    logInfo.algo = this.tls.standardName || this.tls.name;
-                    logInfo.version = this.tls.version;
-                }
+                    if (this.tls) {
+                        logInfo.authorized = this.tls.authorized = this.socket.authorized;
+                        logInfo.algo = this.tls.standardName || this.tls.name;
+                        logInfo.version = this.tls.version;
+                    }
 
-                this.log.info(logInfo);
+                    this.log.info(logInfo);
 
-                this.setSocketHandlers();
-                this.socket.pipe(this.streamer);
+                    this.setSocketHandlers();
+                    this.socket.pipe(this.streamer);
 
-                // executed by initial "* OK"
-                this.initialResolve = resolve;
-                this.initialReject = reject;
+                    // executed by initial "* OK"
+                    this.initialResolve = resolve;
+                    this.initialReject = reject;
+                } catch (ex) {
+                    // connect failed
+                    reject(ex);
+                }
             };
 
             if (socket) {
@@ -1588,7 +1619,7 @@ class ImapFlow extends EventEmitter {
             this.socket.on('error', err => {
                 clearTimeout(this.connectTimeout);
                 clearTimeout(this.greetingTimeout);
-                setImmediate(() => this.close());
+                this.closeAfter();
                 this.log.error({ err, cid: this.id });
                 reject(err);
             });
@@ -1611,6 +1642,15 @@ class ImapFlow extends EventEmitter {
         return await this.run('LOGOUT');
     }
 
+    /**
+     * Close the TCP connection.
+     * Unlike `close()`, return immediately from this function, allowing the
+     * caller function to proceed, and run `close()` function afterwards.
+     */
+    closeAfter() {
+        setImmediate(() => this.close());
+    }
+
     /**
      * Closes TCP connection without notifying the server.
      *
@@ -1621,101 +1661,114 @@ class ImapFlow extends EventEmitter {
      * client.close();
      */
     close() {
-        // clear pending timers
-        clearTimeout(this.idleStartTimer);
-        clearTimeout(this.upgradeTimeout);
-        clearTimeout(this.connectTimeout);
-        clearTimeout(this.greetingTimeout);
-
-        this.usable = false;
-        this.idling = false;
-
-        if (typeof this.initialReject === 'function' && !this.options.verifyOnly) {
+        try {
+            // clear pending timers
+            clearTimeout(this.idleStartTimer);
+            clearTimeout(this.upgradeTimeout);
+            clearTimeout(this.connectTimeout);
             clearTimeout(this.greetingTimeout);
-            let reject = this.initialReject;
-            this.initialResolve = false;
-            this.initialReject = false;
-            let err = new Error('Unexpected close');
-            err.code = `ClosedAfterConnect${this.secureConnection ? 'TLS' : 'Text'}`;
-            // still has to go through the logic below
-            setImmediate(() => reject(err));
-        }
 
-        if (typeof this.preCheck === 'function') {
-            this.preCheck().catch(err => this.log.warn({ err, cid: this.id }));
-        }
+            this.usable = false;
+            this.idling = false;
 
-        // reject command that is currently processed
-        if (this.currentRequest && this.requestTagMap.has(this.currentRequest.tag)) {
-            let request = this.requestTagMap.get(this.currentRequest.tag);
-            if (request) {
-                this.requestTagMap.delete(request.tag);
-                const error = new Error('Connection not available');
-                error.code = 'NoConnection';
-                request.reject(error);
+            if (typeof this.initialReject === 'function' && !this.options.verifyOnly) {
+                clearTimeout(this.greetingTimeout);
+                let reject = this.initialReject;
+                this.initialResolve = false;
+                this.initialReject = false;
+                let err = new Error('Unexpected close');
+                err.code = `ClosedAfterConnect${this.secureConnection ? 'TLS' : 'Text'}`;
+                // still has to go through the logic below
+                setImmediate(() => reject(err));
+            }
+
+            if (typeof this.preCheck === 'function') {
+                this.preCheck().catch(err => this.log.warn({ err, cid: this.id }));
             }
-            this.currentRequest = false;
-        }
 
-        // reject all other pending commands
-        while (this.requestQueue.length) {
-            let req = this.requestQueue.shift();
-            if (req && this.requestTagMap.has(req.tag)) {
-                let request = this.requestTagMap.get(req.tag);
+            // reject command that is currently processed
+            if (this.currentRequest && this.requestTagMap.has(this.currentRequest.tag)) {
+                let request = this.requestTagMap.get(this.currentRequest.tag);
                 if (request) {
                     this.requestTagMap.delete(request.tag);
                     const error = new Error('Connection not available');
                     error.code = 'NoConnection';
                     request.reject(error);
                 }
+                this.currentRequest = false;
+            }
+
+            // reject all other pending commands
+            while (this.requestQueue.length) {
+                let req = this.requestQueue.shift();
+                if (req && this.requestTagMap.has(req.tag)) {
+                    let request = this.requestTagMap.get(req.tag);
+                    if (request) {
+                        this.requestTagMap.delete(request.tag);
+                        const error = new Error('Connection not available');
+                        error.code = 'NoConnection';
+                        request.reject(error);
+                    }
+                }
             }
-        }
 
-        this.state = this.states.LOGOUT;
-        if (this.isClosed) {
-            return;
-        }
-        this.isClosed = true;
+            // cleanup compression streams if they exist
+            if (this._inflate) {
+                try {
+                    this._inflate.unpipe();
+                    this._inflate.destroy();
+                    this._inflate = null;
+                } catch (err) {
+                    this.log.error({ err, info: 'Failed to destroy inflate stream', cid: this.id });
+                }
+            }
 
-        if (this.writeSocket && !this.writeSocket.destroyed) {
-            try {
-                this.writeSocket.destroy();
-            } catch (err) {
-                this.log.error({ err, cid: this.id });
+            if (this._deflate) {
+                try {
+                    this._deflate.unpipe();
+                    this._deflate.destroy();
+                    this._deflate = null;
+                } catch (err) {
+                    this.log.error({ err, info: 'Failed to destroy deflate stream', cid: this.id });
+                }
             }
-        }
 
-        // cleanup compression streams if they exist
-        if (this._inflate) {
-            try {
-                this._inflate.unpipe();
-                this._inflate.destroy();
-                this._inflate = null;
-            } catch (err) {
-                this.log.error({ err, info: 'Failed to destroy inflate stream', cid: this.id });
+            this.state = this.states.LOGOUT;
+            if (this.isClosed) {
+                return;
             }
-        }
 
-        if (this._deflate) {
-            try {
-                this._deflate.unpipe();
-                this._deflate.destroy();
-                this._deflate = null;
-            } catch (err) {
-                this.log.error({ err, info: 'Failed to destroy deflate stream', cid: this.id });
+            if (this.socket && !this.socket.destroyed && this.writeSocket !== this.socket) {
+                try {
+                    this.socket.destroy();
+                } catch (err) {
+                    this.log.error({ err, cid: this.id });
+                }
             }
-        }
+            this.isClosed = true;
 
-        if (this.socket && !this.socket.destroyed && this.writeSocket !== this.socket) {
-            try {
-                this.socket.destroy();
-            } catch (err) {
-                this.log.error({ err, cid: this.id });
+            if (this.writeSocket && !this.writeSocket.destroyed) {
+                try {
+                    this.writeSocket.destroy();
+                } catch (err) {
+                    this.log.error({ err, cid: this.id });
+                }
+            }
+
+            if (this.socket && !this.socket.destroyed && this.writeSocket !== this.socket) {
+                try {
+                    this.socket.destroy();
+                } catch (err) {
+                    this.log.error({ err, cid: this.id });
+                }
             }
-        }
 
-        this.log.trace({ msg: 'Connection closed', cid: this.id });
-        this.emit('close');
+            this.log.trace({ msg: 'Connection closed', cid: this.id });
+            this.emit('close');
+        } catch (ex) {
+            // close failed
+            this.log.error(ex);
+        }
     }
 
     /**
@@ -2973,7 +3026,18 @@ class ImapFlow extends EventEmitter {
         };
 
         setImmediate(() => {
-            if (!writeChunk(chunk)) {
+            let writeResult;
+            try {
+                writeResult = writeChunk(chunk);
+            } catch (err) {
+                stream.emit('error', err);
+                if (!fetchAborted && stream && !stream.destroyed) {
+                    stream.end();
+                }
+                return;
+            }
+
+            if (!writeResult) {
                 // Initial chunk filled the buffer, wait for drain
                 stream.once('drain', () => {
                     if (!fetchAborted) {
@@ -3172,126 +3236,133 @@ class ImapFlow extends EventEmitter {
         return result;
     }
 
-    async processLocks(force) {
-        if (!force) {
-            // Atomic test-and-set to prevent race condition
-            const wasProcessing = this.processingLock;
-            this.processingLock = true;
-
-            if (wasProcessing) {
-                // Another processor is already running, reset and exit
-                this.processingLock = wasProcessing;
-                this.log.trace({
-                    msg: 'Mailbox locking queued',
-                    path: this.mailbox && this.mailbox.path,
-                    pending: this.locks.length,
-                    idling: this.idling,
-                    activeLock: this.currentLock
-                        ? {
-                              lockId: this.currentLock.lockId,
-                              ...(this.currentLock.options?.description && { description: this.currentLock.options?.description })
-                          }
-                        : null
-                });
-                return;
-            }
-        } else {
-            this.processingLock = true;
+    async processLocks() {
+        // Atomic test-and-set to prevent race condition
+        const wasProcessing = this.processingLock;
+        if (wasProcessing) {
+            // Another processor is already running, just exit
+            this.log.trace({
+                msg: 'Mailbox locking queued',
+                path: this.mailbox && this.mailbox.path,
+                pending: this.locks.length,
+                idling: this.idling,
+                activeLock: this.currentLock
+                    ? {
+                          lockId: this.currentLock.lockId,
+                          ...(this.currentLock.options?.description && { description: this.currentLock.options?.description })
+                      }
+                    : null
+            });
+            return;
         }
+        this.processingLock = true;
 
         try {
-            if (!this.locks.length) {
-                this.log.trace({
-                    msg: 'Mailbox locking queue processed',
-                    idling: this.idling
-                });
-                return;
-            }
-
-            const release = () => {
-                if (this.currentLock) {
+            // Process all locks in queue until empty
+            let processedCount = 0;
+            while (this.locks.length > 0) {
+                if (!this.locks.length) {
                     this.log.trace({
-                        msg: 'Mailbox lock released',
-                        lockId: this.currentLock.lockId,
-                        path: this.mailbox && this.mailbox.path,
-                        pending: this.locks.length,
+                        msg: 'Mailbox locking queue processed',
                         idling: this.idling
                     });
-                    this.currentLock = false;
+                    return;
                 }
-                this.processLocks(true).catch(err => this.log.error({ err, cid: this.id }));
-            };
 
-            const lock = this.locks.shift();
-            const { resolve, reject, path, options, lockId } = lock;
-
-            if (!this.usable || !this.socket || this.socket.destroyed) {
-                this.log.trace({ msg: 'Failed to acquire mailbox lock', path, lockId, idling: this.idling });
-                // reject all
-                let error = new Error('Connection not available');
-                error.code = 'NoConnection';
-                reject(error);
-                // Process remaining locks
-                await this.processLocks(true);
-                return;
-            }
+                // Yield to event loop periodically to prevent CPU blocking
+                processedCount++;
+                if (processedCount % 5 === 0) {
+                    await new Promise(resolve => setImmediate(resolve));
+                }
 
-            if (this.mailbox && this.mailbox.path === path && !!this.mailbox.readOnly === !!options.readOnly) {
-                // nothing to do here, already selected
-                this.log.trace({
-                    msg: 'Mailbox lock acquired [existing]',
-                    path,
-                    lockId,
-                    idling: this.idling,
-                    ...(options.description && { description: options.description })
-                });
-                this.currentLock = lock;
-                return resolve({ path, release });
-            } else {
-                try {
-                    // Try to open. Throws if mailbox does not exists or can't open
-                    await this.mailboxOpen(path, options);
+                const release = () => {
+                    if (this.currentLock) {
+                        this.log.trace({
+                            msg: 'Mailbox lock released',
+                            lockId: this.currentLock.lockId,
+                            path: this.mailbox && this.mailbox.path,
+                            pending: this.locks.length,
+                            idling: this.idling
+                        });
+                        this.currentLock = false;
+                    }
+                    // Use setImmediate to avoid stack overflow
+                    setImmediate(() => {
+                        this.processLocks().catch(err => this.log.error({ err, cid: this.id }));
+                    });
+                };
+
+                const lock = this.locks.shift();
+                const { resolve, reject, path, options, lockId } = lock;
+
+                if (!this.usable || !this.socket || this.socket.destroyed) {
+                    this.log.trace({ msg: 'Failed to acquire mailbox lock', path, lockId, idling: this.idling });
+                    let error = new Error('Connection not available');
+                    error.code = 'NoConnection';
+                    reject(error);
+                    continue; // Process next lock in queue
+                }
+
+                if (this.mailbox && this.mailbox.path === path && !!this.mailbox.readOnly === !!options.readOnly) {
+                    // nothing to do here, already selected
                     this.log.trace({
-                        msg: 'Mailbox lock acquired [selected]',
+                        msg: 'Mailbox lock acquired [existing]',
                         path,
                         lockId,
                         idling: this.idling,
                         ...(options.description && { description: options.description })
                     });
                     this.currentLock = lock;
-                    return resolve({ path, release });
-                } catch (err) {
-                    if (err.responseStatus === 'NO') {
-                        try {
-                            let folders = await this.run('LIST', '', path, { listOnly: true });
-                            if (!folders || !folders.length) {
-                                err.mailboxMissing = true;
+                    resolve({ path, release });
+                    break; // Wait for this lock to be released
+                } else {
+                    try {
+                        // Try to open. Throws if mailbox does not exists or can't open
+                        await this.mailboxOpen(path, options);
+                        this.log.trace({
+                            msg: 'Mailbox lock acquired [selected]',
+                            path,
+                            lockId,
+                            idling: this.idling,
+                            ...(options.description && { description: options.description })
+                        });
+                        this.currentLock = lock;
+                        resolve({ path, release });
+                        break; // Wait for this lock to be released
+                    } catch (err) {
+                        if (err.responseStatus === 'NO') {
+                            try {
+                                let folders = await this.run('LIST', '', path, { listOnly: true });
+                                if (!folders || !folders.length) {
+                                    err.mailboxMissing = true;
+                                }
+                            } catch (E) {
+                                this.log.trace({ msg: 'Failed to verify failed mailbox', path, err: E });
                             }
-                        } catch (E) {
-                            this.log.trace({ msg: 'Failed to verify failed mailbox', path, err: E });
                         }
-                    }
 
-                    this.log.trace({
-                        msg: 'Failed to acquire mailbox lock',
-                        path,
-                        lockId,
-                        idling: this.idling,
-                        ...(options.description && { description: options.description }),
-                        err
-                    });
-                    reject(err);
-                    // Process remaining locks
-                    await this.processLocks(true);
+                        this.log.trace({
+                            msg: 'Failed to acquire mailbox lock',
+                            path,
+                            lockId,
+                            idling: this.idling,
+                            ...(options.description && { description: options.description }),
+                            err
+                        });
+                        reject(err);
+                        // Continue to next lock in queue
+                    }
                 }
             }
         } finally {
             this.processingLock = false;
 
             // Check if new locks were added while we were processing
-            if (this.locks.length && !this.processingLock) {
-                // Recursively process any new locks that were added
-                this.processLocks(true).catch(err => this.log.error({ err, cid: this.id }));
+            if (this.locks.length && !this.currentLock) {
+                // Process any remaining locks
+                setImmediate(() => {
+                    this.processLocks().catch(err => this.log.error({ err, cid: this.id }));
+                });
             }
         }
     }