imapflow 1.0.89 → 1.0.92

package/.gitattributes

@@ -0,0 +1 @@
+*.js text eol=lf

package/.github/workflows/test.yml

@@ -0,0 +1,21 @@
+name: Run tests
+
+on:
+    push:
+    pull_request:
+
+jobs:
+    test:
+        strategy:
+            matrix:
+                node: [16.x, 18.x]
+                os: [ubuntu-latest]
+        runs-on: ${{ matrix.os }}
+        steps:
+            - uses: actions/checkout@v2
+            - name: Use Node.js ${{ matrix.node }}
+              uses: actions/setup-node@v1
+              with:
+                  node-version: ${{ matrix.node }}
+            - run: npm install
+            - run: npm test

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # CHANGELOG
 
+-   1.0.92 - 2022-05-03
+
+    -   Added support for IMAP BINARY extension (rfc3516)
+    -   Logging improvements
+
+-   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 the EXISTS 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

package/lib/commands/append.js

@@ -38,7 +38,17 @@ module.exports = async (connection, destination, content, flags, idate) => {
         attributes.push({ type: 'STRING', value: idate }); // force quotes as required by date-time
     }
 
-    attributes.push({ type: 'LITERAL', value: content });
+    let isLiteral8 = false;
+    if (connection.capabilities.has('BINARY') && !connection.disableBinary) {
+        if (typeof content === 'string') {
+            content = Buffer.from(content);
+        }
+        // Value is literal8 if it contains NULL bytes. The server must support the BINARY extension
+        // and if it does not then send the value as a regular literal and hope for the best
+        isLiteral8 = content.indexOf(Buffer.from([0])) >= 0;
+    }
+
+    attributes.push({ type: 'LITERAL', value: content, isLiteral8 });
 
     let map = { destination };
     if (connection.mailbox && connection.mailbox.path) {

package/lib/commands/authenticate.js

@@ -39,7 +39,7 @@ module.exports = async (connection, username, accessToken) => {
                             try {
                                 errorResponse = JSON.parse(Buffer.from(resp.attributes[0].value, 'base64').toString());
                             } catch (err) {
-                                connection.log.debug({ data: resp.attributes[0].value, err });
+                                connection.log.debug({ errorResponse: resp.attributes[0].value, err });
                             }
                         }
 

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 = connection.capabilities.has('BINARY') && !connection.disableBinary ? 'BINARY' : '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;