imapkit 0.0.0-stage → 4.0.1

package/lib/plugins/esearch.js

@@ -0,0 +1,156 @@
+'use strict';
+
+/**
+ * @help Adds ESEARCH [RFC4731] capability
+ * @help SEARCH and UID SEARCH take the RETURN (MIN MAX ALL COUNT) result options and answer with ESEARCH
+ */
+
+const { buildEsearchResponse, selectReturned } = require('../esearch');
+const { badError } = require('../commands/handlers/search');
+
+// RFC 4466 section 2.6.1: search = "SEARCH" [SP "RETURN" SP "(" [search-return-opt *(SP search-return-opt)] ")"] SP search-program
+const hasReturnOptions = attributes => {
+    const first = attributes && attributes[0];
+    return !!first && first.type === 'ATOM' && String(first.value).toUpperCase() === 'RETURN';
+};
+
+module.exports = function (server) {
+    // SEARCHRES loads ESEARCH as well, so the plugin may be called twice
+    if (server.searchReturnOptions) {
+        return;
+    }
+
+    server.registerCapability('ESEARCH');
+
+    // RFC 4731 section 3.1 result options. Other plugins add their own: `data: false` for an option that
+    // does not add data to the ESEARCH response (SAVE of SEARCHRES), `response: true` if the ESEARCH
+    // response is sent even then (UPDATE of CONTEXT=SEARCH), `hint: true` for an option that is accepted
+    // and ignored (CONTEXT), `parse(item)` for an option with an argument and `once: true` if the option
+    // must not be repeated
+    server.searchReturnOptions = new Map(['MIN', 'MAX', 'ALL', 'COUNT'].map(name => [name, { data: true }]));
+
+    // Checks of the whole list of result options, `(options, connection, parsed, names)` returns an error message
+    // for an invalid combination. `names` also holds the hint options
+    server.searchReturnChecks = [];
+
+    /**
+     * Parses a list of result options (RFC 4466 section 2.6.1: search-return-opts)
+     *
+     * @param {Array} list Parsed list of result options
+     * @param {Object} connection IMAP connection
+     * @param {Object} parsed Parsed command
+     * @return {Map} upper case option names to their parsed arguments (true for options without one)
+     * @throws {Error} BAD error for an invalid list
+     */
+    server.parseSearchReturn = (list, connection, parsed) => {
+        if (!Array.isArray(list)) {
+            throw badError('RETURN expects a parenthesized list of result options');
+        }
+
+        const options = new Map();
+        // every option name, also the hints that are left out of `options`
+        const names = new Set();
+        for (let i = 0; i < list.length; i++) {
+            const item = list[i];
+            const name = item && item.type === 'ATOM' ? String(item.value).toUpperCase() : '';
+            const spec = server.searchReturnOptions.get(name);
+            // options that the server does not support must be rejected with BAD (RFC 4466 section 2.6.1)
+            if (!spec) {
+                throw badError('Unknown SEARCH result option' + (name ? ' ' + name : ''));
+            }
+            if (spec.once && options.has(name)) {
+                throw badError('SEARCH result option ' + name + ' can be used only once');
+            }
+            names.add(name);
+            const value = spec.parse ? spec.parse(list[++i]) : true;
+            if (!spec.hint) {
+                options.set(name, value);
+            }
+        }
+
+        for (const check of server.searchReturnChecks) {
+            const error = check(options, connection, parsed, names);
+            if (error) {
+                throw badError(error);
+            }
+        }
+        return options;
+    };
+
+    // only result options without return data, like SAVE (RFC 5182 section 1), suppress the ESEARCH response
+    server.isSilentReturn = options =>
+        options.size > 0 &&
+        ![...options.keys()].some(name => {
+            const spec = server.searchReturnOptions.get(name);
+            return spec.data || spec.response;
+        });
+
+    // The result options are taken off the arguments, so the SEARCH handler only sees the search program
+    const searchWrapper = (prevHandler, connection, parsed, data, callback) => {
+        if (!hasReturnOptions(parsed.attributes)) {
+            return prevHandler(connection, parsed, data, callback);
+        }
+
+        try {
+            parsed.searchReturn = server.parseSearchReturn(parsed.attributes[1], connection, parsed);
+        } catch (E) {
+            connection.sendStatus(parsed, data, 'BAD', E.message, false, (parsed.command || '').toUpperCase() + ' FAILED');
+            return callback();
+        }
+
+        parsed.attributes = parsed.attributes.slice(2);
+        prevHandler(connection, parsed, data, callback);
+    };
+
+    // Lets a command take result options before its other arguments, parsed into `parsed.searchReturn`.
+    // ESORT uses it for SORT and UID SORT (RFC 5267 section 3)
+    server.acceptSearchReturn = command => {
+        const prevHandler = server.getCommandHandler(command);
+        server.setCommandHandler(command, (connection, parsed, data, callback) => searchWrapper(prevHandler, connection, parsed, data, callback));
+    };
+
+    server.acceptSearchReturn('SEARCH');
+    server.acceptSearchReturn('UID SEARCH');
+
+    // RFC 3501 section 5.5: only the search program can hold sequence numbers, the result options do not
+    server.connectionHandlers.push(connection => {
+        const usesSequenceNumbers = connection.usesSequenceNumbers;
+        connection.usesSequenceNumbers = function (parsed) {
+            if (hasReturnOptions(parsed.attributes)) {
+                parsed = Object.assign({}, parsed, { attributes: parsed.attributes.slice(2) });
+            }
+            return usesSequenceNumbers.call(this, parsed);
+        };
+    });
+
+    // Replaces the SEARCH response of an extended SEARCH with a single ESEARCH response (RFC 4731 section 3.1)
+    server.outputHandlers.push((connection, response, description, parsed, data, extra) => {
+        if (
+            !parsed ||
+            !parsed.searchReturn ||
+            response.tag !== '*' ||
+            response.command !== 'SEARCH' ||
+            (description !== 'SEARCH' && description !== 'UID SEARCH') ||
+            !extra ||
+            !Array.isArray(extra.list)
+        ) {
+            return;
+        }
+        response.skipResponse = true;
+
+        const options = parsed.searchReturn;
+        if (server.isSilentReturn(options)) {
+            return;
+        }
+
+        // like for SEARCH, the extra data is the search result, but `list` only holds the messages that the
+        // result options return (RFC 4731 section 3.2), for the MODSEQ of CONDSTORE
+        connection.send(
+            buildEsearchResponse(parsed.tag, description === 'UID SEARCH', extra, options),
+            'ESEARCH',
+            parsed,
+            data,
+            Object.assign({}, extra, { list: selectReturned(extra.list, options) })
+        );
+    });
+};

package/lib/plugins/esort.js

@@ -0,0 +1,60 @@
+'use strict';
+
+/**
+ * @help Adds ESORT [RFC5267] capability, loads SORT and ESEARCH as well
+ * @help SORT and UID SORT take the RETURN (MIN MAX ALL COUNT) result options and answer with ESEARCH, results are in sort order
+ */
+
+const sort = require('./sort');
+const esearch = require('./esearch');
+const { buildEsearchResponse, selectReturned } = require('../esearch');
+
+const isSort = command => command === 'SORT' || command === 'UID SORT';
+
+module.exports = function (server) {
+    if (server.esortLoaded) {
+        return;
+    }
+    server.esortLoaded = true;
+
+    sort(server);
+    esearch(server);
+
+    server.registerCapability('ESORT');
+
+    // RFC 5267 section 3: extended-sort = ["UID" SP] "SORT" search-return-opts SP sort-criteria SP search-criteria
+    server.acceptSearchReturn('SORT');
+    server.acceptSearchReturn('UID SORT');
+
+    // RFC 5267 section 4.1: the CONTEXT, UPDATE and PARTIAL result options of SORT come with CONTEXT=SORT. PARTIAL
+    // is also defined for the PARTIAL capability (RFC 9394 section 3.1)
+    server.searchReturnChecks.push((options, connection, parsed, names) => {
+        if (!isSort((parsed.command || '').toUpperCase()) || server.contextSort) {
+            return false;
+        }
+        const name = ['CONTEXT', 'UPDATE', 'PARTIAL'].find(key => names.has(key) && (key !== 'PARTIAL' || !server.partialRangeLast));
+        return !!name && name + ' is not supported for SORT';
+    });
+
+    // Replaces the SORT response of an extended SORT with an ESEARCH response (RFC 5267 section 3)
+    server.outputHandlers.push((connection, response, description, parsed, data, extra) => {
+        if (!parsed || !parsed.searchReturn || response.tag !== '*' || response.command !== 'SORT' || !isSort(description) || !extra || !extra.sorted) {
+            return;
+        }
+        response.skipResponse = true;
+
+        const options = parsed.searchReturn;
+        if (server.isSilentReturn(options)) {
+            return;
+        }
+
+        // the extra data lists the returned messages, for the MODSEQ of CONDSTORE (RFC 7162 section 3.1.10)
+        connection.send(
+            buildEsearchResponse(parsed.tag, description === 'UID SORT', extra, options, null, extra.sorted),
+            'ESEARCH',
+            parsed,
+            data,
+            Object.assign({}, extra, { list: selectReturned(extra.sorted, options) })
+        );
+    });
+};

package/lib/plugins/id.js

@@ -0,0 +1,138 @@
+'use strict';
+
+const { states } = require('../command-states');
+
+/**
+ * @help Adds ID [RFC2971] capability
+ */
+
+module.exports = function (server) {
+    // Register capability, always usable
+    server.registerCapability('ID');
+
+    // Add ID command
+    server.setCommandHandler(
+        'ID',
+        (connection, parsed, data, callback) => {
+            // keys are client supplied, so the object has no prototype
+            const clientList = Object.create(null);
+            let serverList = null;
+            let i;
+            let len;
+            let key;
+
+            // Require exactly 1 attribute (NIL or parameter list)
+            if (!parsed.attributes || parsed.attributes.length !== 1) {
+                return sendError('ID expects 1 attribute', connection, parsed, data, callback);
+            }
+            const list = parsed.attributes[0];
+            if ((list && !Array.isArray(list)) || (list && list.length % 2)) {
+                return sendError('ID expects valid parameter list', connection, parsed, data, callback);
+            }
+
+            // RFC 2971 section 3.3: at most 30 field-value pairs
+            if (list && list.length > 60) {
+                return sendError('ID allows at most 30 field-value pairs', connection, parsed, data, callback);
+            }
+
+            // Build client ID object and check validity of the values
+            if (list && list.length) {
+                for (i = 0, len = list.length; i < len; i++) {
+                    if (i % 2 === 0) {
+                        // Handle keys (always strings)
+                        if (list[i] && ['STRING', 'LITERAL'].indexOf(list[i].type) >= 0) {
+                            key = list[i].value;
+                            // RFC 2971 section 3.3: field names are at most 30 octets, case-insensitive and unique
+                            if (key.length > 30) {
+                                return sendError('ID field names can be at most 30 octets', connection, parsed, data, callback);
+                            }
+                            if (Object.keys(clientList).some(existing => existing.toLowerCase() === key.toLowerCase())) {
+                                return sendError('ID field names must not repeat', connection, parsed, data, callback);
+                            }
+                        } else {
+                            return sendError('ID expects valid parameter list', connection, parsed, data, callback);
+                        }
+                    } else {
+                        // Handle values (string or NIL)
+                        if (!list[i] || ['STRING', 'LITERAL'].indexOf(list[i].type) >= 0) {
+                            if (list[i] && list[i].value.length > 1024) {
+                                return sendError('ID values can be at most 1024 octets', connection, parsed, data, callback);
+                            }
+                            clientList[key] = (list[i] && list[i].value) || null;
+                        } else {
+                            return sendError('ID expects valid parameter list', connection, parsed, data, callback);
+                        }
+                    }
+                }
+            }
+
+            // Build response object from server options
+            if (server.options.id) {
+                serverList = [];
+                Object.keys(server.options.id).forEach(key => {
+                    serverList.push({
+                        type: 'STRING',
+                        value: key
+                    });
+                    serverList.push({
+                        type: 'STRING',
+                        value: (server.options.id[key] || '').toString()
+                    });
+                });
+            }
+
+            // Send untagged ID response
+            connection.send(
+                {
+                    tag: '*',
+                    command: 'ID',
+                    attributes: [serverList]
+                },
+                'ID',
+                parsed,
+                data,
+                clientList
+            );
+
+            // Send tagged response
+            connection.send(
+                {
+                    tag: parsed.tag,
+                    command: 'OK',
+                    attributes: [
+                        {
+                            type: 'TEXT',
+                            value: 'ID command completed'
+                        }
+                    ]
+                },
+                'ID',
+                parsed,
+                data,
+                clientList
+            );
+
+            callback();
+        },
+        { states: states.ANY }
+    );
+};
+
+function sendError(message, connection, parsed, data, callback) {
+    connection.send(
+        {
+            tag: parsed.tag,
+            command: 'BAD',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: message
+                }
+            ]
+        },
+        'INVALID COMMAND',
+        parsed,
+        data
+    );
+    return callback();
+}

package/lib/plugins/idle.js

@@ -0,0 +1,105 @@
+'use strict';
+
+const { states } = require('../command-states');
+
+/**
+ * @help Adds IDLE [RFC2177] capability
+ */
+
+module.exports = function (server) {
+    server.registerCapability('IDLE');
+
+    server.setCommandHandler(
+        'IDLE',
+        (connection, parsed, data, callback) => {
+            const idleTimer = setTimeout(
+                () => {
+                    if (connection.socket && !connection.socket.destroyed) {
+                        connection.send(
+                            {
+                                tag: '*',
+                                command: 'BYE',
+                                attributes: [
+                                    {
+                                        type: 'TEXT',
+                                        value: 'IDLE terminated'
+                                    }
+                                ]
+                            },
+                            'IDLE EXPIRED',
+                            parsed,
+                            data
+                        );
+                        connection.end();
+                    }
+                },
+                30 * 60 * 1000
+            );
+            // An idling client should not keep the process alive
+            idleTimer.unref();
+
+            const clearIdleTimer = () => clearTimeout(idleTimer);
+            const socket = connection.socket;
+            if (socket) {
+                socket.once('close', clearIdleTimer);
+            }
+
+            connection.directNotifications = true;
+
+            // Temporarily redirect client input to this function
+            connection.inputHandler = function (str) {
+                clearIdleTimer();
+                if (socket) {
+                    socket.removeListener('close', clearIdleTimer);
+                }
+
+                // Stop listening to any other user input
+                connection.inputHandler = false;
+
+                // Notifications are sent again only while a command is in progress
+                connection.directNotifications = false;
+
+                if (str.toUpperCase() === 'DONE') {
+                    connection.send(
+                        {
+                            tag: parsed.tag,
+                            command: 'OK',
+                            attributes: [
+                                {
+                                    type: 'TEXT',
+                                    value: 'IDLE terminated'
+                                }
+                            ]
+                        },
+                        'IDLE',
+                        parsed,
+                        data
+                    );
+                } else {
+                    connection.send(
+                        {
+                            tag: parsed.tag,
+                            command: 'BAD',
+                            attributes: [
+                                {
+                                    type: 'TEXT',
+                                    value: 'Invalid Idle continuation'
+                                }
+                            ]
+                        },
+                        'INVALID IDLE',
+                        parsed,
+                        data
+                    );
+                }
+            };
+
+            connection.write('+ idling\r\n');
+
+            connection.processNotifications();
+
+            return callback();
+        },
+        { states: states.AUTHENTICATED, noArguments: true }
+    );
+};

package/lib/plugins/imap4rev2.js

@@ -0,0 +1,202 @@
+'use strict';
+
+const { updateSession } = require('../utf8-session');
+const literalMinus = require('./literalminus');
+const { registerEnable, isEnabled } = require('./enable');
+
+/**
+ * @help Adds IMAP4rev2 [RFC9051] capability next to IMAP4rev1 and loads
+ * @help the extensions folded into IMAP4rev2 (RFC 9051 Appendix E).
+ * @help A session follows RFC 9051 after ENABLE IMAP4rev2, others RFC 3501
+ */
+
+// RFC 9051 Appendix A: a client that wants IMAP4rev2 when both revisions are advertised MUST issue "ENABLE IMAP4rev2".
+// The ENABLE plugin lists enabled extensions in this spelling
+const REV2 = 'IMAP4rev2';
+
+// RFC 9051 section 9 leaves these IMAP4rev1 items out of the search-key, status-att and fetch-att rules (Appendix E
+// items 12 and 18), so an IMAP4rev2 session gets BAD for them
+const REMOVED_SEARCH_KEYS = new Set(['NEW', 'OLD', 'RECENT', 'UNRECENT']);
+const REMOVED_STATUS_ITEMS = new Set(['RECENT']);
+// RFC 9051 section 6.3.11 and Appendix E item 3: STATUS DELETED is new in IMAP4rev2 (STATUS SIZE comes with STATUS=SIZE)
+const ADDED_STATUS_ITEMS = new Set(['DELETED']);
+const REMOVED_FETCH_ITEMS = new Set(['RFC822', 'RFC822.HEADER', 'RFC822.TEXT']);
+
+// RFC 9051 section 2.3.2: keywords that SHOULD be allowed in SEARCH and preserved in APPEND, COPY and MOVE
+const KEYWORDS = ['$Forwarded', '$MDNSent', '$Junk', '$NotJunk', '$Phishing'];
+
+// set by setMode() below
+const isRev2 = connection => !!connection.imap4rev2;
+
+const atomName = attr => (attr && attr.type === 'ATOM' ? String(attr.value).toUpperCase() : '');
+
+module.exports = function (server) {
+    // RFC 9051 Appendix A: advertised together with IMAP4rev1 (capability.js always lists it), so every session
+    // starts as IMAP4rev1 (section 7.2.2) and ENABLE switches it (section 6.3.1)
+    server.registerCapability('IMAP4rev2');
+
+    registerEnable(server, REV2);
+
+    // RFC 9051 section 4.3 and Appendix E item 2: non-synchronizing literals up to 4096 octets (LITERAL-). LITERAL+
+    // allows more, so it is kept if it is loaded already, and it can replace this LITERAL- when it is loaded later
+    if (!server.capabilities['LITERAL+'] && !server.capabilities['LITERAL-']) {
+        literalMinus(server);
+        server.impliedLiteralMinus = true;
+    }
+
+    // RFC 9051 section 2.3.2: a mailbox that does not allow new keywords (no "\*" in PERMANENTFLAGS) still keeps these
+    server.mailboxHandlers.push((server, mailbox) => {
+        if (!mailbox.allowPermanentFlags) {
+            KEYWORDS.forEach(keyword => server.ensureFlag(mailbox.permanentFlags, keyword));
+        }
+    });
+
+    // The session follows RFC 9051 once IMAP4rev2 is enabled
+    const setMode = connection => {
+        const rev2 = (connection.imap4rev2 = isEnabled(connection, REV2));
+        // UTF-8 in quoted strings and mailbox names (sections 4.3 and 5.1), SEARCH assumes UTF-8 (section 6.4.4)
+        updateSession(connection);
+        // message/global encapsulates a message like message/rfc822 (sections 6.4.5.1 and 7.5.2)
+        connection.messageGlobal = rev2;
+        connection.disabledSearchKeys = rev2 ? REMOVED_SEARCH_KEYS : null;
+        // literal sizes, partial ranges (parsed by imap-handler), LARGER and SMALLER are number64 (section 9, Appendix E item 1)
+        connection.number64 = connection.parserOptions.number64 = rev2;
+        connection.disabledStatusItems = rev2 ? REMOVED_STATUS_ITEMS : null;
+        // only for this session, an IMAP4rev1 session gets DELETED only from plugins that add it for everyone (QUOTA)
+        connection.addedStatusItems = rev2 ? ADDED_STATUS_ITEMS : null;
+        if (rev2) {
+            // \Recent is deprecated (section 2.3.2, Appendix E item 12), an IMAP4rev2 session does not see it
+            connection.getFlags = message => message.flags;
+        } else {
+            // back to IMAPConnection#getFlags
+            delete connection.getFlags;
+        }
+    };
+    server.connectionHandlers.push(setMode);
+    // RFC 8437 section 4.1: UNAUTHENTICATE turns ENABLEd extensions off
+    server.resetHandlers.push(setMode);
+
+    const sendBad = (connection, parsed, data, callback, text) => {
+        connection.sendStatus(parsed, data, 'BAD', text);
+        return callback();
+    };
+
+    // Wraps the handler of a command, `wrapper(prevHandler, connection, parsed, data, callback)` runs instead
+    const wrap = (command, wrapper) => {
+        const prevHandler = server.getCommandHandler(command);
+        server.setCommandHandler(command, (connection, parsed, data, callback) => wrapper(prevHandler, connection, parsed, data, callback));
+    };
+
+    // Appendix E item 17: CHECK was removed, NOOP does the same. Item 19: LSUB was deprecated and left out of the
+    // section 9 grammar, LIST (SUBSCRIBED) replaces it
+    Object.entries({ CHECK: 'NOOP', LSUB: 'LIST (SUBSCRIBED)' }).forEach(([command, replacement]) => {
+        wrap(command, (prevHandler, connection, parsed, data, callback) => {
+            if (isRev2(connection)) {
+                return sendBad(connection, parsed, data, callback, command + ' is not part of IMAP4rev2, use ' + replacement + ' (RFC 9051 Appendix E)');
+            }
+            prevHandler(connection, parsed, data, callback);
+        });
+    });
+
+    // Appendix E item 18: RFC822, RFC822.HEADER and RFC822.TEXT are not fetch-att items any more, BODY[], BODY.PEEK[HEADER]
+    // and BODY[TEXT] replace them. RFC822.SIZE stays
+    const fetchWrapper = (prevHandler, connection, parsed, data, callback) => {
+        const items = (parsed.attributes || [])[1];
+        if (isRev2(connection) && [].concat(items || []).some(item => REMOVED_FETCH_ITEMS.has(atomName(item)))) {
+            return sendBad(
+                connection,
+                parsed,
+                data,
+                callback,
+                'RFC822, RFC822.HEADER and RFC822.TEXT are not part of IMAP4rev2, use BODY[] (RFC 9051 Appendix E)'
+            );
+        }
+        prevHandler(connection, parsed, data, callback);
+    };
+    wrap('FETCH', fetchWrapper);
+    wrap('UID FETCH', fetchWrapper);
+
+    // Appendix E item 4 and section 6.4.4: SEARCH answers with ESEARCH, without result options it is RETURN (ALL).
+    // The ESEARCH plugin replaces the SEARCH response once `parsed.searchReturn` is set
+    const searchWrapper = (prevHandler, connection, parsed, data, callback) => {
+        if (isRev2(connection) && atomName((parsed.attributes || [])[0]) !== 'RETURN') {
+            parsed.searchReturn = server.parseSearchReturn([], connection, parsed);
+        }
+        prevHandler(connection, parsed, data, callback);
+    };
+    wrap('SEARCH', searchWrapper);
+    wrap('UID SEARCH', searchWrapper);
+
+    // Appendix E item 9 and section 6.3.2: SELECT and EXAMINE report CLOSED when they close the selected mailbox
+    server.closedChecks.push(isRev2);
+
+    // Untagged LIST response for the selected mailbox (section 6.3.2, Appendix E item 10), with accurate attributes.
+    // Not a "LIST ITEM" response, that ACL would hide for a mailbox the user may read but not list
+    const sendMailboxList = (connection, mailbox, parsed, data) => {
+        // the special-use attributes of SPECIAL-USE are mailbox attributes in IMAP4rev2 (section 7.3.1)
+        const attributes = mailbox.flags.concat(mailbox['special-use'] || []);
+        connection.send(
+            {
+                tag: '*',
+                command: 'LIST',
+                attributes: [
+                    attributes.map(flag => ({ type: 'ATOM', value: flag })),
+                    server.getSeparator(mailbox),
+                    // the canonical name, converted for the session in IMAPConnection#send
+                    { type: 'MAILBOX', value: mailbox.path }
+                ]
+            },
+            'SELECT LIST',
+            parsed,
+            data,
+            mailbox
+        );
+    };
+
+    server.outputHandlers.push((connection, response, description, parsed, data) => {
+        if (!parsed || !response || !isRev2(connection)) {
+            return;
+        }
+        const command = String(parsed.command || '').toUpperCase();
+        if (command !== 'SELECT' && command !== 'EXAMINE') {
+            return;
+        }
+
+        // Appendix E items 11 and 12: the RECENT response and the UNSEEN response code are deprecated
+        if (description === command + ' RECENT' || description === command + ' UNSEEN') {
+            response.skipResponse = true;
+            return;
+        }
+
+        if (description === command && response.tag === parsed.tag && response.command === 'OK' && connection.selectedMailbox) {
+            sendMailboxList(connection, connection.selectedMailbox, parsed, data);
+        }
+    });
+
+    server.outputHandlers.push((connection, response, description, parsed, data, extra) => {
+        if (description === 'ENABLED' && Array.isArray(extra) && extra.indexOf(REV2) >= 0) {
+            setMode(connection);
+        }
+    });
+};
+
+// RFC 9051 Appendix E item 2 lists the extensions that IMAP4rev2 folds in. With them the plugins advertise their own
+// capabilities, which RFC 9051 Appendix A suggests for a server that supports both revisions. AUTH=PLAIN is a MUST
+// (section 6.1.1). LITERAL- is loaded by the plugin itself, unless LITERAL+ is loaded
+module.exports.requires = [
+    'ENABLE',
+    'NAMESPACE',
+    'UNSELECT',
+    'UIDPLUS',
+    'ESEARCH',
+    'SEARCHRES',
+    'IDLE',
+    'SASL-IR',
+    'LIST-EXTENDED',
+    'LIST-STATUS',
+    'MOVE',
+    'BINARY',
+    'SPECIAL-USE',
+    'STATUS=SIZE',
+    'AUTH=PLAIN'
+];