imapflow 1.0.87 → 1.0.90

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # CHANGELOG
 
+-   1.0.90 - 2022-04-04
+
+    -   Added new configuration option `maxIdleTime`
+
+-   1.0.89 - 2022-04-04
+
+    -   Added new event type `response` that emits all command responses
+
+-   1.0.88 - 2022-03-24
+
+    -   Fixed folder name match where not all non-ascii characters triggered UTF encoding
+
 -   1.0.87 - 2022-03-21
 
     -   If LIST failed then do not suppress exception

package/lib/commands/idle.js

@@ -2,112 +2,139 @@
 
 const NOOP_INTERVAL = 2 * 60 * 1000;
 
-// Listes for changes in mailbox
-module.exports = async connection => {
-    if (connection.state !== connection.states.SELECTED) {
-        // nothing to do here
-        return;
-    }
+async function runIdle(connection) {
+    let response;
 
-    if (connection.capabilities.has('IDLE')) {
-        let response;
-
-        let preCheckWaitQueue = [];
-        try {
-            connection.idling = true;
-
-            //let idleSent = false;
-            let doneRequested = false;
-            let doneSent = false;
-            let canEnd = false;
-
-            let preCheck = () => {
-                doneRequested = true;
-                if (canEnd && !doneSent) {
-                    connection.log.debug({
-                        src: 'c',
-                        msg: `DONE`,
-                        comment: `breaking IDLE`,
-                        lockId: connection.currentLockId,
-                        path: connection.mailbox && connection.mailbox.path
-                    });
-                    connection.write('DONE');
-                    doneSent = true;
-
-                    connection.idling = false;
-                    connection.preCheck = false; // unset itself
-
-                    while (preCheckWaitQueue.length) {
-                        let { resolve } = preCheckWaitQueue.shift();
-                        resolve();
-                    }
-                }
-            };
-
-            connection.preCheck = () => {
-                let handler = new Promise((resolve, reject) => {
-                    preCheckWaitQueue.push({ resolve, reject });
-                });
+    let preCheckWaitQueue = [];
+    try {
+        connection.idling = true;
 
-                connection.log.trace({
-                    msg: 'Requesting IDLE break',
+        //let idleSent = false;
+        let doneRequested = false;
+        let doneSent = false;
+        let canEnd = false;
+
+        let preCheck = () => {
+            doneRequested = true;
+            if (canEnd && !doneSent) {
+                connection.log.debug({
+                    src: 'c',
+                    msg: `DONE`,
+                    comment: `breaking IDLE`,
                     lockId: connection.currentLockId,
-                    path: connection.mailbox && connection.mailbox.path,
-                    queued: preCheckWaitQueue.length,
-                    doneRequested,
-                    canEnd,
-                    doneSent
+                    path: connection.mailbox && connection.mailbox.path
                 });
+                connection.write('DONE');
+                doneSent = true;
 
-                preCheck();
-
-                return handler;
-            };
+                connection.idling = false;
+                connection.preCheck = false; // unset itself
 
-            response = await connection.exec('IDLE', false, {
-                onPlusTag: async () => {
-                    connection.log.debug({ msg: `Initiated IDLE, waiting for server input`, doneRequested });
-                    canEnd = true;
-                    if (doneRequested) {
-                        preCheck();
-                    }
-                },
-                onSend: () => {
-                    //idleSent = true;
-                }
-            });
-
-            // unset before response.next()
-            if (typeof connection.preCheck === 'function') {
-                connection.log.trace({
-                    msg: 'Clearing pre-check function',
-                    lockId: connection.currentLockId,
-                    path: connection.mailbox && connection.mailbox.path,
-                    queued: preCheckWaitQueue.length,
-                    doneRequested,
-                    canEnd,
-                    doneSent
-                });
-                connection.preCheck = false;
                 while (preCheckWaitQueue.length) {
                     let { resolve } = preCheckWaitQueue.shift();
                     resolve();
                 }
             }
+        };
 
-            response.next();
-            return;
-        } catch (err) {
-            connection.preCheck = false;
-            connection.idling = false;
+        connection.preCheck = () => {
+            let handler = new Promise((resolve, reject) => {
+                preCheckWaitQueue.push({ resolve, reject });
+            });
+
+            connection.log.trace({
+                msg: 'Requesting IDLE break',
+                lockId: connection.currentLockId,
+                path: connection.mailbox && connection.mailbox.path,
+                queued: preCheckWaitQueue.length,
+                doneRequested,
+                canEnd,
+                doneSent
+            });
 
-            connection.log.warn({ err, cid: connection.id });
+            preCheck();
+
+            return handler;
+        };
+
+        response = await connection.exec('IDLE', false, {
+            onPlusTag: async () => {
+                connection.log.debug({ msg: `Initiated IDLE, waiting for server input`, doneRequested });
+                canEnd = true;
+                if (doneRequested) {
+                    preCheck();
+                }
+            },
+            onSend: () => {
+                //idleSent = true;
+            }
+        });
+
+        // unset before response.next()
+        if (typeof connection.preCheck === 'function') {
+            connection.log.trace({
+                msg: 'Clearing pre-check function',
+                lockId: connection.currentLockId,
+                path: connection.mailbox && connection.mailbox.path,
+                queued: preCheckWaitQueue.length,
+                doneRequested,
+                canEnd,
+                doneSent
+            });
+            connection.preCheck = false;
             while (preCheckWaitQueue.length) {
-                let { reject } = preCheckWaitQueue.shift();
-                reject(err);
+                let { resolve } = preCheckWaitQueue.shift();
+                resolve();
             }
-            return false;
         }
+
+        response.next();
+        return;
+    } catch (err) {
+        connection.preCheck = false;
+        connection.idling = false;
+
+        connection.log.warn({ err, cid: connection.id });
+        while (preCheckWaitQueue.length) {
+            let { reject } = preCheckWaitQueue.shift();
+            reject(err);
+        }
+        return false;
+    }
+}
+
+// Listes for changes in mailbox
+module.exports = async (connection, maxIdleTime) => {
+    if (connection.state !== connection.states.SELECTED) {
+        // nothing to do here
+        return;
+    }
+
+    if (connection.capabilities.has('IDLE')) {
+        let idleTimer;
+        let stillIdling = false;
+        let runIdleLoop = async () => {
+            if (maxIdleTime) {
+                idleTimer = setTimeout(() => {
+                    if (connection.idling) {
+                        if (typeof connection.preCheck === 'function') {
+                            stillIdling = true;
+                            // request IDLE break if IDLE has been running for allowed time
+                            connection.log.trace({ msg: 'Max allowed IDLE time reached', cid: connection.id });
+                            connection.preCheck().catch(err => connection.log.warn({ err, cid: connection.id }));
+                        }
+                    }
+                }, maxIdleTime);
+            }
+            let resp = await runIdle(connection);
+            clearTimeout(idleTimer);
+            if (stillIdling) {
+                stillIdling = false;
+                return runIdleLoop();
+            }
+            return resp;
+        };
+        return runIdleLoop();
     }
 
     let idleTimer;
@@ -127,11 +154,13 @@ module.exports = async connection => {
             response.next();
         };
 
+        let noopInterval = maxIdleTime ? Math.min(NOOP_INTERVAL, maxIdleTime) : NOOP_INTERVAL;
+
         let runLoop = () => {
             idleCheck()
                 .then(() => {
                     clearTimeout(idleTimer);
-                    idleTimer = setTimeout(runLoop, NOOP_INTERVAL);
+                    idleTimer = setTimeout(runLoop, noopInterval);
                 })
                 .catch(err => {
                     clearTimeout(idleTimer);

package/lib/imap-flow.js

@@ -129,6 +129,7 @@ class ImapFlow extends EventEmitter {
      * @param {Boolean} [options.verifyOnly=false] If `true` then logs out automatically after successful authentication
      * @param {Boolean} [options.proxy] Optional proxy URL. Supports HTTP CONNECT (`http://`, `https://`) and SOCKS (`socks://`, `socks4://`, `socks5://`) proxies
      * @param {Boolean} [options.qresync=false] If true, then enables QRESYNC support. EXPUNGE notifications will include `uid` property instead of `seq`
+     * @param {Number} [options.maxIdleTime] If set, then breaks and restarts IDLE every maxIdleTime ms
      */
     constructor(options) {
         super({ captureRejections: true });
@@ -260,6 +261,8 @@ class ImapFlow extends EventEmitter {
         this.currentLock = false;
         this.locks = [];
 
+        this.maxIdleTime = options.maxIdleTime || false;
+
         this.streamer.on('error', err => {
             if (['Z_BUF_ERROR', 'ECONNRESET', 'EPIPE', 'ETIMEDOUT', 'EHOSTUNREACH'].includes(err.code)) {
                 // just close the connection, usually nothing but noise
@@ -411,6 +414,20 @@ class ImapFlow extends EventEmitter {
 
             try {
                 parsed = await parser(data.payload, { literals: data.literals });
+                if (parsed.tag && !['*', '+'].includes(parsed.tag) && parsed.command) {
+                    let payload = { response: parsed.command };
+
+                    if (
+                        parsed.attributes &&
+                        parsed.attributes[0] &&
+                        parsed.attributes[0].section &&
+                        parsed.attributes[0].section[0] &&
+                        parsed.attributes[0].section[0].type === 'ATOM'
+                    ) {
+                        payload.code = parsed.attributes[0].section[0].value;
+                    }
+                    this.emit('response', payload);
+                }
             } catch (err) {
                 // can not make sense of this
                 this.log.error({ src: 's', msg: data.payload.toString(), err, cid: this.id });
@@ -1579,7 +1596,7 @@ class ImapFlow extends EventEmitter {
      */
     async idle() {
         if (!this.idling) {
-            return await this.run('IDLE');
+            return await this.run('IDLE', this.maxIdleTime);
         }
     }
 

package/lib/tools.js

@@ -1,3 +1,5 @@
+/* eslint no-control-regex:0 */
+
 'use strict';
 
 const libmime = require('libmime');
@@ -17,7 +19,7 @@ module.exports = {
             return 'INBOX';
         }
 
-        if (!connection.enabled.has('UTF8=ACCEPT') && /[\x80-\xff]/.test(path)) {
+        if (!connection.enabled.has('UTF8=ACCEPT') && /[\x00-\x08\x0b-\x0c\x0e-\x1f\u0080-\uffff]/.test(path)) {
             try {
                 path = iconv.encode(path, 'utf-7-imap').toString();
             } catch (err) {

package/lib/types.d.ts

@@ -28,6 +28,7 @@ declare module "imapflow" {
      * @param [options.verifyOnly = false] - If `true` then logs out automatically after successful authentication
      * @param [options.proxy] - Optional proxy URL. Supports HTTP CONNECT (`http://`, `https://`) and SOCKS (`socks://`, `socks4://`, `socks5://`) proxies
      * @param [options.qresync = false] - If true, then enables QRESYNC support. EXPUNGE notifications will include `uid` property instead of `seq`
+     * @param [options.maxIdleTime] - If set, then breaks and restarts IDLE every maxIdleTime ms
      */
     class ImapFlow extends EventEmitter {
         constructor(options: {
@@ -54,6 +55,7 @@ declare module "imapflow" {
             verifyOnly?: boolean;
             proxy?: boolean;
             qresync?: boolean;
+            maxIdleTime?: number;
         });
         /**
          * Current module version as a static class property

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "imapflow",
-    "version": "1.0.87",
+    "version": "1.0.90",
     "description": "IMAP Client for Node",
     "main": "./lib/imap-flow.js",
     "scripts": {
@@ -30,9 +30,9 @@
         "@babel/eslint-plugin": "7.17.7",
         "@babel/plugin-syntax-class-properties": "7.12.13",
         "@babel/preset-env": "7.16.11",
-        "@types/node": "17.0.22",
+        "@types/node": "17.0.23",
         "braintree-jsdoc-template": "3.3.0",
-        "eslint": "8.11.0",
+        "eslint": "8.12.0",
         "eslint-config-nodemailer": "1.2.0",
         "eslint-config-prettier": "8.5.0",
         "grunt": "1.4.1",
@@ -43,14 +43,14 @@
         "tsd-jsdoc": "2.5.0"
     },
     "dependencies": {
-        "encoding-japanese": "1.0.30",
+        "encoding-japanese": "2.0.0",
         "iconv-lite": "0.6.3",
         "libbase64": "1.2.1",
         "libmime": "5.0.0",
         "libqp": "1.1.0",
         "mailsplit": "5.3.1",
         "nodemailer": "6.7.3",
-        "pino": "7.9.1",
+        "pino": "7.9.2",
         "socks": "2.6.2"
     }
 }