imapflow 1.0.88 → 1.0.91

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # CHANGELOG
 
+-   1.0.91 - 2022-05-02
+
+    -   Do not throw if literal includes a null byte
+    -   Use UTF8 path names by default
+    -   Overrides '\*' range query with then EXISTIS value
+
+-   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

package/lib/commands/create.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { normalizePath, getStatusCode, getErrorText } = require('../tools.js');
+const { encodePath, normalizePath, getStatusCode, getErrorText } = require('../tools.js');
 
 // Creates a new mailbox
 module.exports = async (connection, path) => {
@@ -16,7 +16,7 @@ module.exports = async (connection, path) => {
         let map = {
             path
         };
-        response = await connection.exec('CREATE', [{ type: 'ATOM', value: path }]);
+        response = await connection.exec('CREATE', [{ type: 'ATOM', value: encodePath(connection, path) }]);
 
         let section =
             response.response.attributes &&

package/lib/commands/delete.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { normalizePath, getStatusCode, getErrorText } = require('../tools.js');
+const { encodePath, normalizePath, getStatusCode, getErrorText } = require('../tools.js');
 
 // Deletes an existing mailbox
 module.exports = async (connection, path) => {
@@ -20,7 +20,7 @@ module.exports = async (connection, path) => {
         let map = {
             path
         };
-        response = await connection.exec('DELETE', [{ type: 'ATOM', value: path }]);
+        response = await connection.exec('DELETE', [{ type: 'ATOM', value: encodePath(connection, path) }]);
         response.next();
         return map;
     } catch (err) {

package/lib/commands/fetch.js

@@ -18,6 +18,8 @@ module.exports = async (connection, range, query, options) => {
         list: []
     };
 
+    const commandKey = 'BODY';
+
     let response;
     try {
         let attributes = [{ type: 'SEQUENCE', value: (range || '*').toString() }];
@@ -27,7 +29,7 @@ module.exports = async (connection, range, query, options) => {
         let setBodyPeek = (attributes, partial) => {
             let bodyPeek = {
                 type: 'ATOM',
-                value: 'BODY.PEEK',
+                value: `${commandKey}.PEEK`,
                 section: [],
                 partial
             };
@@ -61,7 +63,7 @@ module.exports = async (connection, range, query, options) => {
                     partial.push(Number(query.source.maxLength));
                 }
             }
-            queryStructure.push({ type: 'ATOM', value: 'BODY.PEEK', section: [], partial });
+            queryStructure.push({ type: 'ATOM', value: `${commandKey}.PEEK`, section: [], partial });
         }
 
         // if possible, always request for unique email id

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/commands/list.js

@@ -1,8 +1,7 @@
 'use strict';
 
-const { normalizePath } = require('../tools.js');
+const { decodePath, encodePath, normalizePath } = require('../tools.js');
 const { specialUse } = require('../special-use');
-const iconv = require('iconv-lite');
 
 // Lists mailboxes from server
 module.exports = async (connection, reference, mailbox) => {
@@ -14,7 +13,7 @@ module.exports = async (connection, reference, mailbox) => {
         let entries = [];
 
         let runList = async (reference, mailbox) => {
-            response = await connection.exec(listCommand, [reference, mailbox], {
+            response = await connection.exec(listCommand, [encodePath(connection, reference), encodePath(connection, mailbox)], {
                 untagged: {
                     [listCommand]: async untagged => {
                         if (!untagged.attributes || !untagged.attributes.length) {
@@ -22,7 +21,8 @@ module.exports = async (connection, reference, mailbox) => {
                         }
 
                         let entry = {
-                            path: (untagged.attributes[2] && untagged.attributes[2].value) || '',
+                            path: normalizePath(connection, decodePath(connection, (untagged.attributes[2] && untagged.attributes[2].value) || '')),
+                            pathAsListed: (untagged.attributes[2] && untagged.attributes[2].value) || '',
                             flags: new Set(untagged.attributes[0].map(entry => entry.value)),
                             delimiter: untagged.attributes[1] && untagged.attributes[1].value,
                             listed: true
@@ -45,19 +45,8 @@ module.exports = async (connection, reference, mailbox) => {
                             entry.path = entry.path.slice(1);
                         }
 
-                        entry.parent = (entry.delimiter ? entry.path.split(entry.delimiter) : [entry.path]).map(folder => {
-                            if (!connection.enabled.has('UTF8=ACCEPT')) {
-                                try {
-                                    return iconv.decode(Buffer.from(folder), 'utf-7-imap').toString();
-                                } catch (err) {
-                                    return folder; // keep as is
-                                }
-                            } else {
-                                return folder; // keep as is
-                            }
-                        });
-
-                        entry.path = normalizePath(connection, entry.path);
+                        entry.parentPath = entry.delimiter && entry.path ? entry.path.substr(0, entry.path.lastIndexOf(entry.delimiter)) : '';
+                        entry.parent = entry.delimiter ? entry.path.split(entry.delimiter) : [entry.path];
                         entry.name = entry.parent.pop();
 
                         let specialUseFlag = specialUse(connection.capabilities.has('XLIST') || connection.capabilities.has('SPECIAL-USE'), entry);
@@ -80,59 +69,54 @@ module.exports = async (connection, reference, mailbox) => {
             await runList('', 'INBOX');
         }
 
-        response = await connection.exec('LSUB', [normalizePath(connection, reference || ''), normalizePath(connection, mailbox || '', true)], {
-            untagged: {
-                LSUB: async untagged => {
-                    if (!untagged.attributes || !untagged.attributes.length) {
-                        return;
-                    }
-
-                    let entry = {
-                        flags: new Set(untagged.attributes[0].map(entry => entry.value)),
-                        delimiter: untagged.attributes[1] && untagged.attributes[1].value,
-                        path: (untagged.attributes[2] && untagged.attributes[2].value) || '',
-                        subscribed: true
-                    };
+        response = await connection.exec(
+            'LSUB',
+            [encodePath(connection, normalizePath(connection, reference || '')), encodePath(connection, normalizePath(connection, mailbox || '', true))],
+            {
+                untagged: {
+                    LSUB: async untagged => {
+                        if (!untagged.attributes || !untagged.attributes.length) {
+                            return;
+                        }
 
-                    if (entry.path.toUpperCase() === 'INBOX') {
-                        entry.specialUse = '\\Inbox';
-                    }
+                        let entry = {
+                            path: normalizePath(connection, decodePath(connection, (untagged.attributes[2] && untagged.attributes[2].value) || '')),
+                            pathAsListed: (untagged.attributes[2] && untagged.attributes[2].value) || '',
+                            flags: new Set(untagged.attributes[0].map(entry => entry.value)),
+                            delimiter: untagged.attributes[1] && untagged.attributes[1].value,
+                            subscribed: true
+                        };
 
-                    if (entry.delimiter && entry.path.charAt(0) === entry.delimiter) {
-                        entry.path = entry.path.slice(1);
-                    }
+                        if (entry.path.toUpperCase() === 'INBOX') {
+                            entry.specialUse = '\\Inbox';
+                        }
 
-                    entry.parent = (entry.delimiter ? entry.path.split(entry.delimiter) : [entry.path]).map(folder => {
-                        if (!connection.enabled.has('UTF8=ACCEPT')) {
-                            try {
-                                return iconv.decode(Buffer.from(folder), 'utf-7-imap').toString();
-                            } catch (err) {
-                                return folder; // keep as is
-                            }
-                        } else {
-                            return folder; // keep as is
+                        if (entry.delimiter && entry.path.charAt(0) === entry.delimiter) {
+                            entry.path = entry.path.slice(1);
                         }
-                    });
 
-                    entry.name = entry.parent.pop();
+                        entry.parentPath = entry.delimiter && entry.path ? entry.path.substr(0, entry.path.lastIndexOf(entry.delimiter)) : '';
+                        entry.parent = entry.delimiter ? entry.path.split(entry.delimiter) : [entry.path];
+                        entry.name = entry.parent.pop();
 
-                    let existing = entries.find(existing => existing.path === entry.path);
-                    if (existing) {
-                        existing.subscribed = true;
-                        entry.flags.forEach(flag => existing.flags.add(flag));
-                    } else {
-                        // ignore non-listed folders
-                        /*
-                        let specialUseFlag = specialUse(connection.capabilities.has('XLIST') || connection.capabilities.has('SPECIAL-USE'), entry);
-                        if (specialUseFlag && !flagsSeen.has(specialUseFlag)) {
-                            entry.specialUse = specialUseFlag;
+                        let existing = entries.find(existing => existing.path === entry.path);
+                        if (existing) {
+                            existing.subscribed = true;
+                            entry.flags.forEach(flag => existing.flags.add(flag));
+                        } else {
+                            // ignore non-listed folders
+                            /*
+                            let specialUseFlag = specialUse(connection.capabilities.has('XLIST') || connection.capabilities.has('SPECIAL-USE'), entry);
+                            if (specialUseFlag && !flagsSeen.has(specialUseFlag)) {
+                                entry.specialUse = specialUseFlag;
+                            }
+                            entries.push(entry);
+                            */
                         }
-                        entries.push(entry);
-                        */
                     }
                 }
             }
-        });
+        );
         response.next();
 
         let inboxEntry = entries.find(entry => entry.specialUse === '\\Inbox');

package/lib/commands/quota.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { getStatusCode, normalizePath, getErrorText } = require('../tools.js');
+const { encodePath, getStatusCode, normalizePath, getErrorText } = require('../tools.js');
 
 // Requests quota information for a mailbox
 module.exports = async (connection, path) => {
@@ -63,7 +63,7 @@ module.exports = async (connection, path) => {
     let quotaFound = false;
     let response;
     try {
-        response = await connection.exec('GETQUOTAROOT', [{ type: 'ATOM', value: path }], {
+        response = await connection.exec('GETQUOTAROOT', [{ type: 'ATOM', value: encodePath(connection, path) }], {
             untagged: {
                 QUOTAROOT: async untagged => {
                     let quotaRoot =

package/lib/commands/rename.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { normalizePath, getStatusCode, getErrorText } = require('../tools.js');
+const { encodePath, normalizePath, getStatusCode, getErrorText } = require('../tools.js');
 
 // Renames existing mailbox
 module.exports = async (connection, path, newPath) => {
@@ -23,8 +23,8 @@ module.exports = async (connection, path, newPath) => {
             newPath
         };
         response = await connection.exec('RENAME', [
-            { type: 'ATOM', value: path },
-            { type: 'ATOM', value: newPath }
+            { type: 'ATOM', value: encodePath(connection, path) },
+            { type: 'ATOM', value: encodePath(connection, newPath) }
         ]);
         response.next();
         return map;

package/lib/commands/select.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { normalizePath, getStatusCode, getErrorText } = require('../tools.js');
+const { encodePath, normalizePath, getStatusCode, getErrorText } = require('../tools.js');
 
 // Selects a mailbox
 module.exports = async (connection, path, options) => {
@@ -47,101 +47,105 @@ module.exports = async (connection, path, options) => {
             map.qresync = true;
         }
 
-        response = await connection.exec(!options.readOnly ? 'SELECT' : 'EXAMINE', [{ type: 'ATOM', value: path }].concat(extraArgs || []), {
-            untagged: {
-                OK: async untagged => {
-                    if (!untagged.attributes || !untagged.attributes.length) {
-                        return;
-                    }
-                    let section = !untagged.attributes[0].value && untagged.attributes[0].section;
-                    if (section && section.length > 1 && section[0].type === 'ATOM' && typeof section[0].value === 'string') {
-                        let key = section[0].value.toLowerCase();
-                        let value;
-
-                        if (typeof section[1].value === 'string') {
-                            value = section[1].value;
-                        } else if (Array.isArray(section[1])) {
-                            value = section[1].map(entry => (typeof entry.value === 'string' ? entry.value : false)).filter(entry => entry);
+        response = await connection.exec(
+            !options.readOnly ? 'SELECT' : 'EXAMINE',
+            [{ type: 'ATOM', value: encodePath(connection, path) }].concat(extraArgs || []),
+            {
+                untagged: {
+                    OK: async untagged => {
+                        if (!untagged.attributes || !untagged.attributes.length) {
+                            return;
                         }
-
-                        switch (key) {
-                            case 'highestmodseq':
-                                key = 'highestModseq';
-                                if (/^[0-9]+$/.test(value)) {
-                                    value = BigInt(value);
-                                }
-                                break;
-
-                            case 'mailboxid':
-                                key = 'mailboxId';
-                                if (Array.isArray(value) && value.length) {
-                                    value = value[0];
-                                }
-                                break;
-
-                            case 'permanentflags':
-                                key = 'permanentFlags';
-                                value = new Set(value);
-                                break;
-
-                            case 'uidnext':
-                                key = 'uidNext';
-                                value = Number(value);
-                                break;
-
-                            case 'uidvalidity':
-                                key = 'uidValidity';
-                                if (/^[0-9]+$/.test(value)) {
-                                    value = BigInt(value);
-                                }
-                                break;
+                        let section = !untagged.attributes[0].value && untagged.attributes[0].section;
+                        if (section && section.length > 1 && section[0].type === 'ATOM' && typeof section[0].value === 'string') {
+                            let key = section[0].value.toLowerCase();
+                            let value;
+
+                            if (typeof section[1].value === 'string') {
+                                value = section[1].value;
+                            } else if (Array.isArray(section[1])) {
+                                value = section[1].map(entry => (typeof entry.value === 'string' ? entry.value : false)).filter(entry => entry);
+                            }
+
+                            switch (key) {
+                                case 'highestmodseq':
+                                    key = 'highestModseq';
+                                    if (/^[0-9]+$/.test(value)) {
+                                        value = BigInt(value);
+                                    }
+                                    break;
+
+                                case 'mailboxid':
+                                    key = 'mailboxId';
+                                    if (Array.isArray(value) && value.length) {
+                                        value = value[0];
+                                    }
+                                    break;
+
+                                case 'permanentflags':
+                                    key = 'permanentFlags';
+                                    value = new Set(value);
+                                    break;
+
+                                case 'uidnext':
+                                    key = 'uidNext';
+                                    value = Number(value);
+                                    break;
+
+                                case 'uidvalidity':
+                                    key = 'uidValidity';
+                                    if (/^[0-9]+$/.test(value)) {
+                                        value = BigInt(value);
+                                    }
+                                    break;
+                            }
+
+                            map[key] = value;
                         }
 
-                        map[key] = value;
-                    }
-
-                    if (section && section.length === 1 && section[0].type === 'ATOM' && typeof section[0].value === 'string') {
-                        let key = section[0].value.toLowerCase();
-                        switch (key) {
-                            case 'nomodseq':
-                                key = 'noModseq';
-                                map[key] = true;
-                                break;
+                        if (section && section.length === 1 && section[0].type === 'ATOM' && typeof section[0].value === 'string') {
+                            let key = section[0].value.toLowerCase();
+                            switch (key) {
+                                case 'nomodseq':
+                                    key = 'noModseq';
+                                    map[key] = true;
+                                    break;
+                            }
+                        }
+                    },
+                    FLAGS: async untagged => {
+                        if (!untagged.attributes || (!untagged.attributes.length && Array.isArray(untagged.attributes[0]))) {
+                            return;
+                        }
+                        let flags = untagged.attributes[0].map(flag => (typeof flag.value === 'string' ? flag.value : false)).filter(flag => flag);
+                        map.flags = new Set(flags);
+                    },
+                    EXISTS: async untagged => {
+                        let num = Number(untagged.command);
+                        if (isNaN(num)) {
+                            return false;
                         }
-                    }
-                },
-                FLAGS: async untagged => {
-                    if (!untagged.attributes || (!untagged.attributes.length && Array.isArray(untagged.attributes[0]))) {
-                        return;
-                    }
-                    let flags = untagged.attributes[0].map(flag => (typeof flag.value === 'string' ? flag.value : false)).filter(flag => flag);
-                    map.flags = new Set(flags);
-                },
-                EXISTS: async untagged => {
-                    let num = Number(untagged.command);
-                    if (isNaN(num)) {
-                        return false;
-                    }
 
-                    map.exists = num;
-                },
-                VANISHED: async untagged => {
-                    await connection.untaggedVanished(
-                        untagged,
-                        // mailbox is not yet open, so use a dummy mailbox object
-                        { path, uidNext: false, uidValidity: false }
-                    );
-                },
-                // we should only get an untagged FETCH for a SELECT/EXAMINE if QRESYNC was asked for
-                FETCH: async untagged => {
-                    await connection.untaggedFetch(
-                        untagged,
-                        // mailbox is not yet open, so use a dummy mailbox object
-                        { path, uidNext: false, uidValidity: false }
-                    );
+                        map.exists = num;
+                    },
+                    VANISHED: async untagged => {
+                        await connection.untaggedVanished(
+                            untagged,
+                            // mailbox is not yet open, so use a dummy mailbox object
+                            { path, uidNext: false, uidValidity: false }
+                        );
+                    },
+                    // we should only get an untagged FETCH for a SELECT/EXAMINE if QRESYNC was asked for
+                    FETCH: async untagged => {
+                        await connection.untaggedFetch(
+                            untagged,
+                            // mailbox is not yet open, so use a dummy mailbox object
+                            { path, uidNext: false, uidValidity: false }
+                        );
+                    }
                 }
             }
-        });
+        );
 
         let section = !response.response.attributes[0].value && response.response.attributes[0].section;
         if (section && section.length && section[0].type === 'ATOM' && typeof section[0].value === 'string') {

package/lib/commands/status.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { normalizePath } = require('../tools.js');
+const { encodePath, normalizePath } = require('../tools.js');
 
 // Requests info about a mailbox
 module.exports = async (connection, path, query) => {
@@ -11,7 +11,7 @@ module.exports = async (connection, path, query) => {
 
     path = normalizePath(connection, path);
 
-    let attributes = [{ type: 'ATOM', value: path }];
+    let attributes = [{ type: 'ATOM', value: encodePath(connection, path) }];
 
     let queryAttributes = [];
     Object.keys(query || {}).forEach(key => {

package/lib/commands/subscribe.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { normalizePath, getStatusCode, getErrorText } = require('../tools.js');
+const { encodePath, normalizePath, getStatusCode, getErrorText } = require('../tools.js');
 
 // Subscribes to a mailbox
 module.exports = async (connection, path) => {
@@ -13,7 +13,7 @@ module.exports = async (connection, path) => {
 
     let response;
     try {
-        response = await connection.exec('SUBSCRIBE', [{ type: 'ATOM', value: path }]);
+        response = await connection.exec('SUBSCRIBE', [{ type: 'ATOM', value: encodePath(connection, path) }]);
         response.next();
         return true;
     } catch (err) {

package/lib/commands/unsubscribe.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { normalizePath, getStatusCode, getErrorText } = require('../tools.js');
+const { encodePath, normalizePath, getStatusCode, getErrorText } = require('../tools.js');
 
 // Unsubscribes from a mailbox
 module.exports = async (connection, path) => {
@@ -13,7 +13,7 @@ module.exports = async (connection, path) => {
 
     let response;
     try {
-        response = await connection.exec('UNSUBSCRIBE', [{ type: 'ATOM', value: path }]);
+        response = await connection.exec('UNSUBSCRIBE', [{ type: 'ATOM', value: encodePath(connection, path) }]);
         response.next();
         return true;
     } catch (err) {

package/lib/handler/imap-formal-syntax.js

@@ -26,7 +26,7 @@ function excludeChars(source, exclude) {
 module.exports = {
     CHAR() {
         let value = expandRange(0x01, 0x7f);
-        this.CHAR = function() {
+        this.CHAR = function () {
             return value;
         };
         return value;
@@ -34,7 +34,7 @@ module.exports = {
 
     CHAR8() {
         let value = expandRange(0x01, 0xff);
-        this.CHAR8 = function() {
+        this.CHAR8 = function () {
             return value;
         };
         return value;
@@ -46,7 +46,7 @@ module.exports = {
 
     CTL() {
         let value = expandRange(0x00, 0x1f) + '\x7F';
-        this.CTL = function() {
+        this.CTL = function () {
             return value;
         };
         return value;
@@ -58,7 +58,7 @@ module.exports = {
 
     ALPHA() {
         let value = expandRange(0x41, 0x5a) + expandRange(0x61, 0x7a);
-        this.ALPHA = function() {
+        this.ALPHA = function () {
             return value;
         };
         return value;
@@ -66,7 +66,7 @@ module.exports = {
 
     DIGIT() {
         let value = expandRange(0x30, 0x39) + expandRange(0x61, 0x7a);
-        this.DIGIT = function() {
+        this.DIGIT = function () {
             return value;
         };
         return value;
@@ -74,7 +74,7 @@ module.exports = {
 
     'ATOM-CHAR'() {
         let value = excludeChars(this.CHAR(), this['atom-specials']());
-        this['ATOM-CHAR'] = function() {
+        this['ATOM-CHAR'] = function () {
             return value;
         };
         return value;
@@ -82,7 +82,7 @@ module.exports = {
 
     'ASTRING-CHAR'() {
         let value = this['ATOM-CHAR']() + this['resp-specials']();
-        this['ASTRING-CHAR'] = function() {
+        this['ASTRING-CHAR'] = function () {
             return value;
         };
         return value;
@@ -90,7 +90,7 @@ module.exports = {
 
     'TEXT-CHAR'() {
         let value = excludeChars(this.CHAR(), '\r\n');
-        this['TEXT-CHAR'] = function() {
+        this['TEXT-CHAR'] = function () {
             return value;
         };
         return value;
@@ -98,7 +98,7 @@ module.exports = {
 
     'atom-specials'() {
         let value = '(' + ')' + '{' + this.SP() + this.CTL() + this['list-wildcards']() + this['quoted-specials']() + this['resp-specials']();
-        this['atom-specials'] = function() {
+        this['atom-specials'] = function () {
             return value;
         };
         return value;
@@ -109,8 +109,8 @@ module.exports = {
     },
 
     'quoted-specials'() {
-        let value = this.DQUOTE() + '\\';
-        this['quoted-specials'] = function() {
+        let value = this.DQUOTE() + "'\\";
+        this['quoted-specials'] = function () {
             return value;
         };
         return value;
@@ -122,7 +122,7 @@ module.exports = {
 
     tag() {
         let value = excludeChars(this['ASTRING-CHAR'](), '+');
-        this.tag = function() {
+        this.tag = function () {
             return value;
         };
         return value;
@@ -130,7 +130,7 @@ module.exports = {
 
     command() {
         let value = this.ALPHA() + this.DIGIT() + '-';
-        this.command = function() {
+        this.command = function () {
             return value;
         };
         return value;

package/lib/handler/token-parser.js

@@ -189,6 +189,7 @@ class TokenParser {
                         case '{':
                             this.currentNode = this.createNode(this.currentNode, this.pos + i);
                             this.currentNode.type = 'LITERAL';
+                            this.currentNode.literalType = 'literal';
                             this.state = 'LITERAL';
                             this.currentNode.closed = false;
                             break;
@@ -385,10 +386,13 @@ class TokenParser {
                     if (this.currentNode.started) {
                         // only relevant if literals are not already parsed out from input
 
-                        //if(imapFormalSyntax['CHAR8']().indexOf(chr) < 0){
+                        // Disabled NUL check
+                        // See https://github.com/emailjs/emailjs-imap-handler/commit/f11b2822bedabe492236e8263afc630134a3c41c
+                        /*
                         if (chr === '\u0000') {
                             throw new Error('Unexpected \\x00 at position ' + (this.pos + i));
                         }
+                        */
 
                         this.currentNode.chBuffer[this.currentNode.chPos++] = chr.charCodeAt(0);
 

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 = this.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 });
@@ -1046,6 +1063,15 @@ class ImapFlow extends EventEmitter {
             range = range.toString();
         }
 
+        // special case, some servers allow this, some do not, so replace it with the last known EXISTS value
+        if (range === '*') {
+            if (!this.mailbox.exists) {
+                return false;
+            }
+            range = this.mailbox.exists.toString();
+            options.uid = false; // sequence query
+        }
+
         if (range && typeof range === 'object' && !Array.isArray(range)) {
             if (range.all && Object.keys(range) === 1) {
                 range = '1:*';
@@ -1340,9 +1366,12 @@ class ImapFlow extends EventEmitter {
     /**
      * @typedef {Object} ListResponse
      * @global
-     * @property {String} path mailbox path
+     * @property {String} path mailbox path (unicode string)
+     * @property {String} pathAsListed mailbox path as listed in the LIST/LSUB response
      * @property {String} name mailbox name (last part of path after delimiter)
      * @property {String} delimiter mailbox path delimiter, usually "." or "/"
+     * @property {Array<string>} parent An array of parent folder names. All names are in unicode
+     * @property {String} parentPath Same as `parent`, but as a complete string path (unicode string)
      * @property {Set<string>} flags a set of flags for this mailbox
      * @property {String} specialUse one of special-use flags (if applicable): "\All", "\Archive", "\Drafts", "\Flagged", "\Junk", "\Sent", "\Trash". Additionally INBOX has non-standard "\Inbox" flag set
      * @property {Boolean} listed `true` if mailbox was found from the output of LIST command
@@ -1546,7 +1575,7 @@ class ImapFlow extends EventEmitter {
     /**
      * Requests the status of the indicated mailbox. Only requested status values will be returned.
      *
-     * @param {String} path mailbox path to check for
+     * @param {String} path mailbox path to check for (unicode string)
      * @param {Object} query defines requested status items
      * @param {Boolean} query.messages if `true` request count of messages
      * @param {Boolean} query.recent if `true` request count of messages with \\Recent tag
@@ -1579,7 +1608,7 @@ class ImapFlow extends EventEmitter {
      */
     async idle() {
         if (!this.idling) {
-            return await this.run('IDLE');
+            return await this.run('IDLE', this.maxIdleTime);
         }
     }
 
@@ -1769,7 +1798,7 @@ class ImapFlow extends EventEmitter {
     /**
      * Appends a new message to a mailbox
      *
-     * @param {String} path Mailbox path to upload the message to
+     * @param {String} path Mailbox path to upload the message to (unicode string)
      * @param {string|Buffer} content RFC822 formatted email message
      * @param {string[]} [flags] an array of flags to be set for the uploaded message
      * @param {Date|string} [idate=now] internal date to be set for the message
@@ -2079,6 +2108,14 @@ class ImapFlow extends EventEmitter {
             return;
         }
 
+        if (seq === '*') {
+            if (!this.mailbox.exists) {
+                return false;
+            }
+            seq = this.mailbox.exists.toString();
+            options = Object.assign({}, options || {}, { uid: false }); // force into a sequence query
+        }
+
         let response = await this.run('FETCH', (seq || '').toString(), query, options);
 
         if (!response || !response.list || !response.list.length) {

package/lib/tools.js

@@ -9,6 +9,30 @@ const { JPDecoder } = require('./jp-decoder');
 const iconv = require('iconv-lite');
 
 module.exports = {
+    encodePath(connection, path) {
+        path = (path || '').toString();
+        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) {
+                // ignore, keep name as is
+            }
+        }
+        return path;
+    },
+
+    decodePath(connection, path) {
+        path = (path || '').toString();
+        if (!connection.enabled.has('UTF8=ACCEPT') && /[&]/.test(path)) {
+            try {
+                path = iconv.decode(Buffer.from(path), 'utf-7-imap').toString();
+            } catch (err) {
+                // ignore, keep name as is
+            }
+        }
+        return path;
+    },
+
     normalizePath(connection, path, skipNamespace) {
         if (Array.isArray(path)) {
             path = path.join((connection.namespace && connection.namespace.delimiter) || '');
@@ -19,14 +43,6 @@ module.exports = {
             return 'INBOX';
         }
 
-        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) {
-                // ignore, keep name as is
-            }
-        }
-
         // ensure namespace prefix if needed
         if (!skipNamespace && connection.namespace && connection.namespace.prefix && path.indexOf(connection.namespace.prefix) !== 0) {
             path = connection.namespace.prefix + path;
@@ -290,9 +306,10 @@ module.exports = {
                     break;
                 }
 
-                default:
-                    if (key.indexOf('body[') >= 0) {
-                        let partKey = key.replace(/^body\[|]$/g, '');
+                default: {
+                    let match = key.match(/(body)\[/i);
+                    if (match) {
+                        let partKey = key.replace(/^(body)\[|]$/gi, '');
                         partKey = partKey.replace(/\.fields.*$/g, '');
 
                         let value = getBuffer(attribute);
@@ -308,6 +325,7 @@ module.exports = {
                         break;
                     }
                     break;
+                }
             }
         }
 

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
@@ -239,7 +241,7 @@ declare module "imapflow" {
          * let status = await client.status('INBOX', {unseen: true});
          * console.log(status.unseen);
          * // 123
-         * @param path - mailbox path to check for
+         * @param path - mailbox path to check for (unicode string)
          * @param query - defines requested status items
          * @param query.messages - if `true` request count of messages
          * @param query.recent - if `true` request count of messages with \\Recent tag
@@ -340,7 +342,7 @@ declare module "imapflow" {
          * Appends a new message to a mailbox
          * @example
          * await client.append('INBOX', rawMessageBuffer, ['\\Seen'], new Date(2000, 1, 1));
-         * @param path - Mailbox path to upload the message to
+         * @param path - Mailbox path to upload the message to (unicode string)
          * @param content - RFC822 formatted email message
          * @param [flags] - an array of flags to be set for the uploaded message
          * @param [idate = now] - internal date to be set for the message
@@ -563,9 +565,12 @@ declare type QuotaResponse = {
 };
 
 /**
- * @property path - mailbox path
+ * @property path - mailbox path (unicode string)
+ * @property pathAsListed - mailbox path as listed in the LIST/LSUB response
  * @property name - mailbox name (last part of path after delimiter)
  * @property delimiter - mailbox path delimiter, usually "." or "/"
+ * @property parent - An array of parent folder names. All names are in unicode
+ * @property parentPath - Same as `parent`, but as a complete string path (unicode string)
  * @property flags - a set of flags for this mailbox
  * @property specialUse - one of special-use flags (if applicable): "\All", "\Archive", "\Drafts", "\Flagged", "\Junk", "\Sent", "\Trash". Additionally INBOX has non-standard "\Inbox" flag set
  * @property listed - `true` if mailbox was found from the output of LIST command
@@ -573,8 +578,11 @@ declare type QuotaResponse = {
  */
 declare type ListResponse = {
     path: string;
+    pathAsListed: string;
     name: string;
     delimiter: string;
+    parent: string[];
+    parentPath: string;
     flags: Set<string>;
     specialUse: string;
     listed: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "imapflow",
-    "version": "1.0.88",
+    "version": "1.0.91",
     "description": "IMAP Client for Node",
     "main": "./lib/imap-flow.js",
     "scripts": {
@@ -8,7 +8,8 @@
         "prepare": "npm run build",
         "docs": "rm -rf docs && mkdir -p docs && jsdoc lib/imap-flow.js -c jsdoc.json -R README.md --destination docs/ && cp assets/favicon.ico docs",
         "dst": "node types.js",
-        "build": "npm run docs && npm run dst"
+        "build": "npm run docs && npm run dst",
+        "st": "npm run docs && st -d docs -i index.html"
     },
     "repository": {
         "type": "git",
@@ -29,28 +30,29 @@
         "@babel/eslint-parser": "7.17.0",
         "@babel/eslint-plugin": "7.17.7",
         "@babel/plugin-syntax-class-properties": "7.12.13",
-        "@babel/preset-env": "7.16.11",
-        "@types/node": "17.0.23",
+        "@babel/preset-env": "7.17.10",
+        "@types/node": "17.0.31",
         "braintree-jsdoc-template": "3.3.0",
-        "eslint": "8.11.0",
+        "eslint": "8.14.0",
         "eslint-config-nodemailer": "1.2.0",
         "eslint-config-prettier": "8.5.0",
-        "grunt": "1.4.1",
+        "grunt": "1.5.2",
         "grunt-cli": "1.4.3",
         "grunt-contrib-nodeunit": "4.0.0",
         "grunt-eslint": "24.0.0",
         "jsdoc": "3.6.10",
+        "st": "3.0.0",
         "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",
+        "libmime": "5.1.0",
         "libqp": "1.1.0",
-        "mailsplit": "5.3.1",
-        "nodemailer": "6.7.3",
-        "pino": "7.9.2",
+        "mailsplit": "5.3.2",
+        "nodemailer": "6.7.4",
+        "pino": "7.11.0",
         "socks": "2.6.2"
     }
 }