imapflow 1.0.188 → 1.0.190

package/lib/imap-flow.js

@@ -242,6 +242,13 @@ class ImapFlow extends EventEmitter {
             this.options.clientInfo || {}
         );
 
+        // remove diacritics
+        for (let key of Object.keys(this.clientInfo)) {
+            if (typeof this.clientInfo[key] === 'string') {
+                this.clientInfo[key] = this.clientInfo[key].normalize('NFD').replace(/\p{Diacritic}/gu, '');
+            }
+        }
+
         /**
          * Server identification info. Available after successful `connect()`.
          * If server does not provide identification info then this value is `null`.
@@ -408,7 +415,8 @@ class ImapFlow extends EventEmitter {
         }
 
         if (this.writeSocket.destroyed) {
-            this.socket.emit('error', 'Write socket destroyed');
+            this.log.error({ msg: 'Write socket destroyed', cid: this.id });
+            this.close();
             return;
         }
 
@@ -509,6 +517,12 @@ class ImapFlow extends EventEmitter {
     }
 
     async exec(command, attributes, options) {
+        if (this.state === this.states.LOGOUT || this.isClosed) {
+            const error = new Error('Connection not available');
+            error.code = 'NoConnection';
+            throw error;
+        }
+
         if (!this.socket || this.socket.destroyed) {
             let error = new Error('Connection closed');
             error.code = 'EConnectionClosed';
@@ -758,15 +772,29 @@ class ImapFlow extends EventEmitter {
                 this.close();
             });
 
+        /**
+         * Socket timeout event handler.
+         *
+         * When a socket timeout occurs during IDLE, the handler attempts to recover the connection
+         * by sending a NOOP command and then returning to IDLE state.
+         *
+         * @fires ImapFlow#error Emits error event unless the current command is IDLE
+         */
         this._socketTimeout =
             this._socketTimeout ||
             (() => {
+                const err = new Error('Socket timeout');
+                err.code = 'ETIMEOUT';
+
                 if (this.idling) {
+                    // Attempt to recover IDLE connections
                     this.run('NOOP')
                         .then(() => this.idle())
-                        .catch(this._socketError);
+                        .catch(this._socketError); // Natural circuit breaker
                 } else {
+                    // Close immediately for non-IDLE operations
                     this.log.debug({ msg: 'Socket timeout', cid: this.id });
+                    this.emit('error', err);
                     this.close();
                 }
             });
@@ -785,6 +813,10 @@ class ImapFlow extends EventEmitter {
         if (this._socketError) {
             this.socket.removeListener('error', this._socketError);
             this.socket.removeListener('tlsClientError', this._socketError);
+            this.writeSocket.removeListener('error', this._socketError);
+        }
+        if (this._socketTimeout) {
+            this.socket.removeListener('timeout', this._socketTimeout);
         }
         if (this._socketClose) {
             this.socket.removeListener('close', this._socketClose);
@@ -1131,7 +1163,11 @@ class ImapFlow extends EventEmitter {
                     return reject(err);
                 }
 
-                setImmediate(() => this.close());
+                // ALWAYS emit the error so users can handle it
+                setImmediate(() => {
+                    this.emit('error', err);
+                    this.close();
+                });
             });
     }
 
@@ -2787,6 +2823,7 @@ class ImapFlow extends EventEmitter {
 
         let stream;
         let output;
+        let fetchAborted = false;
 
         switch (meta.encoding) {
             case 'base64':
@@ -2834,31 +2871,105 @@ class ImapFlow extends EventEmitter {
         });
         output = output.pipe(limiter);
 
+        // Cleanup function
+        const cleanup = () => {
+            fetchAborted = true;
+            if (stream && !stream.destroyed) {
+                stream.destroy();
+            }
+        };
+
+        // Listen for stream destruction
+        output.once('error', cleanup);
+        output.once('close', cleanup);
+
         let writeChunk = chunk => {
-            if (limiter.limited) {
+            if (limiter.limited || fetchAborted || stream.destroyed) {
                 return true;
             }
             return stream.write(chunk);
         };
 
         let fetchAllParts = async () => {
-            while (hasMore && !limiter.limited) {
+            while (hasMore && !limiter.limited && !fetchAborted) {
                 let { chunk } = await getNextPart();
-                if (!chunk) {
+                if (!chunk || fetchAborted) {
                     break;
                 }
 
+                // Handle backpressure
                 if (writeChunk(chunk) === false) {
-                    await new Promise(resolve => stream.once('drain', resolve));
+                    // Wait for drain event before continuing
+                    try {
+                        await new Promise((resolve, reject) => {
+                            let resolved = false;
+
+                            const finish = err => {
+                                if (resolved) return;
+                                resolved = true;
+
+                                // Remove all listeners
+                                stream.removeAllListeners('drain');
+                                stream.removeAllListeners('error');
+                                stream.removeAllListeners('close');
+
+                                if (err) {
+                                    reject(err);
+                                } else {
+                                    resolve();
+                                }
+                            };
+
+                            stream.once('drain', () => finish());
+                            stream.once('error', err => finish(err));
+                            stream.once('close', () => finish());
+                        });
+                    } catch (err) {
+                        // Re-throw only if not aborted
+                        if (!fetchAborted) {
+                            throw err;
+                        }
+                    }
+
+                    // Check if we should abort after waiting
+                    if (fetchAborted) {
+                        break;
+                    }
                 }
             }
         };
 
         setImmediate(() => {
-            writeChunk(chunk);
-            fetchAllParts()
-                .catch(err => stream.emit('error', err))
-                .finally(() => stream.end());
+            if (!writeChunk(chunk)) {
+                // Initial chunk filled the buffer, wait for drain
+                stream.once('drain', () => {
+                    if (!fetchAborted) {
+                        fetchAllParts()
+                            .catch(err => {
+                                if (!fetchAborted && stream && !stream.destroyed) {
+                                    stream.emit('error', err);
+                                }
+                            })
+                            .finally(() => {
+                                if (!fetchAborted && stream && !stream.destroyed) {
+                                    stream.end();
+                                }
+                            });
+                    }
+                });
+            } else {
+                fetchAllParts()
+                    .catch(err => {
+                        if (!fetchAborted && stream && !stream.destroyed) {
+                            stream.emit('error', err);
+                        }
+                    })
+                    .finally(() => {
+                        if (!fetchAborted && stream && !stream.destroyed) {
+                            stream.end();
+                        }
+                    });
+            }
         });
 
         return {
@@ -3029,76 +3140,73 @@ class ImapFlow extends EventEmitter {
     }
 
     async processLocks(force) {
-        if (!force && this.processingLock) {
-            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;
-        }
-
-        if (!this.locks.length) {
-            this.processingLock = false;
-            this.log.trace({
-                msg: 'Mailbox locking queue processed',
-                idling: this.idling
-            });
-            return;
-        }
-
-        this.processingLock = true;
-
-        const release = () => {
-            if (this.currentLock) {
+        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 lock released',
-                    lockId: this.currentLock.lockId,
+                    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;
+        }
+
+        try {
+            if (!this.locks.length) {
+                this.log.trace({
+                    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;
+            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;
+                }
+                this.processLocks(true).catch(err => this.log.error({ err, cid: this.id }));
+            };
 
-        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);
-            return await this.processLocks(true);
-        }
+            const lock = this.locks.shift();
+            const { resolve, reject, path, options, lockId } = lock;
 
-        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);
+            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;
+            }
+
+            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,
@@ -3106,28 +3214,51 @@ class ImapFlow extends EventEmitter {
                 });
                 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;
+            } 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;
+                    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;
+                            }
+                        } 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);
                 }
+            }
+        } finally {
+            this.processingLock = false;
 
-                this.log.trace({
-                    msg: 'Failed to acquire mailbox lock',
-                    path,
-                    lockId,
-                    idling: this.idling,
-                    ...(options.description && { description: options.description }),
-                    err
-                });
-                reject(err);
-                await this.processLocks(true);
+            // 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 }));
             }
         }
     }