imapkit 0.0.0-stage → 4.0.1

package/lib/plugins/list-extended.js

@@ -0,0 +1,258 @@
+'use strict';
+
+const { isDeepStrictEqual } = require('util');
+const { getListExtensions } = require('../list-extensions');
+
+/**
+ * @help Adds LIST-EXTENDED [RFC5258] capability: selection options
+ * @help SUBSCRIBED, REMOTE and RECURSIVEMATCH, return options SUBSCRIBED
+ * @help and CHILDREN, multiple mailbox patterns and CHILDINFO.
+ * @help \Noselect mailboxes are listed as \NonExistent
+ */
+
+const { isAstring } = require('../arguments');
+
+/**
+ * Checks if a LIST command uses the extended syntax (RFC 5258 section 1): selection options before
+ * the reference, a list of patterns, or more than 2 arguments (return options)
+ *
+ * @param {Array} args Command arguments
+ * @return {Boolean} true for an extended LIST command
+ */
+const isExtended = args => Array.isArray(args[0]) || Array.isArray(args[1]) || args.length > 2;
+
+module.exports = function (server) {
+    const extensions = getListExtensions(server);
+    if (extensions.enabled) {
+        // already loaded by LIST-STATUS
+        return;
+    }
+    extensions.enabled = true;
+
+    server.registerCapability('LIST-EXTENDED');
+
+    // RFC 5258 section 3.1. There are no remote mailboxes, so REMOTE changes nothing
+    extensions.selectionOptions.SUBSCRIBED = {
+        type: 'base',
+        returnOption: 'SUBSCRIBED',
+        includeNonExistent: true,
+        match: folder => !!folder.subscribed
+    };
+    extensions.selectionOptions.REMOTE = { type: 'independent' };
+    extensions.selectionOptions.RECURSIVEMATCH = { type: 'modifier' };
+
+    // RFC 5258 section 3.2. Children attributes are always returned, so CHILDREN needs no handling
+    extensions.returnOptions.SUBSCRIBED = {};
+    extensions.returnOptions.CHILDREN = {};
+
+    /**
+     * Parses selection or return options (RFC 5258 section 6, option-extension = tag [SP option-value])
+     *
+     * @param {Array} list Parsed option list
+     * @param {Object} registry Known options
+     * @param {String} kind "selection" or "return", for error messages
+     * @param {Object} connection IMAPConnection instance
+     * @return {Map} option name to value (true for options without a value)
+     */
+    const parseOptions = (list, registry, kind, connection) => {
+        const options = new Map();
+        for (let i = 0; i < list.length; i++) {
+            const item = list[i];
+            if (!item || item.type !== 'ATOM') {
+                throw new Error('Invalid ' + kind + ' option');
+            }
+            const name = item.value.toUpperCase();
+            const option = registry[name];
+            if (!option) {
+                // RFC 5258 section 3: "A server MUST respond to options it does not recognize with a BAD response"
+                throw new Error('Unknown ' + kind + ' option ' + name);
+            }
+
+            let value = true;
+            if (option.parse) {
+                if (!Array.isArray(list[i + 1])) {
+                    throw new Error(name + ' ' + kind + ' option requires a value');
+                }
+                value = option.parse(list[++i], connection);
+            } else if (Array.isArray(list[i + 1])) {
+                throw new Error(name + ' ' + kind + ' option takes no value');
+            }
+
+            // RFC 5258 section 3: a repeated option counts once, so it can not have different values
+            if (options.has(name) && !isDeepStrictEqual(options.get(name), value)) {
+                throw new Error(name + ' ' + kind + ' option is repeated with a different value');
+            }
+            options.set(name, value);
+        }
+        return options;
+    };
+
+    /**
+     * Parses the arguments of an extended LIST command:
+     * list = "LIST" [SP list-select-opts] SP mailbox SP mbox-or-pat [SP list-return-opts]
+     *
+     * @param {Array} args Command arguments
+     * @param {Object} connection IMAPConnection instance
+     * @return {Object} `{ selection, reference, patterns, returns }`
+     */
+    const parseArguments = (args, connection) => {
+        let selection = new Map();
+        let returns = new Map();
+        let pos = 0;
+
+        if (Array.isArray(args[0])) {
+            selection = parseOptions(args[0], extensions.selectionOptions, 'selection', connection);
+            pos++;
+        }
+
+        const reference = args[pos];
+        let patterns = args[pos + 1];
+        const rest = args.slice(pos + 2);
+
+        if (!isAstring(reference)) {
+            throw new Error('LIST expects a reference name');
+        }
+
+        // patterns = "(" list-mailbox *(SP list-mailbox) ")"
+        patterns = Array.isArray(patterns) ? patterns : [patterns];
+        if (!patterns.length || !patterns.every(isAstring)) {
+            throw new Error('LIST expects a mailbox pattern or a list of patterns');
+        }
+
+        // list-return-opts = "RETURN" SP "(" [return-option *(SP return-option)] ")"
+        if (rest.length) {
+            if (rest.length !== 2 || !rest[0] || rest[0].type !== 'ATOM' || rest[0].value.toUpperCase() !== 'RETURN' || !Array.isArray(rest[1])) {
+                throw new Error('LIST expects RETURN and a list of return options after the patterns');
+            }
+            returns = parseOptions(rest[1], extensions.returnOptions, 'return', connection);
+        }
+
+        // RFC 5258 section 3.1: RECURSIVEMATCH (any list-select-mod-opt) needs a list-select-base-opt
+        const types = [...selection.keys()].map(name => extensions.selectionOptions[name].type);
+        if (types.includes('modifier') && !types.includes('base')) {
+            throw new Error('RECURSIVEMATCH must be used together with a selection option like SUBSCRIBED');
+        }
+
+        // a selection option implies its return option, eg. SUBSCRIBED
+        selection.forEach((value, name) => {
+            const implied = extensions.selectionOptions[name].returnOption;
+            if (implied && !returns.has(implied)) {
+                returns.set(implied, true);
+            }
+        });
+
+        return {
+            selection,
+            reference: reference.value,
+            // RFC 5258 section 3: an empty pattern is ignored in an extended LIST command
+            patterns: patterns.map(pattern => pattern.value).filter(pattern => pattern),
+            returns
+        };
+    };
+
+    const exists = folder => folder.flags.indexOf('\\Noselect') < 0;
+
+    /**
+     * Mailbox attributes for an extended LIST response. \NonExistent replaces \Noselect (RFC 5258
+     * section 3, \NonExistent implies \Noselect), children attributes are computed (RFC 5258 section 4),
+     * \Subscribed is only listed with the SUBSCRIBED return option (RFC 5258 section 3.2)
+     */
+    const getAttributes = (folder, isExisting, hasChildren, returns) =>
+        server
+            .listAttributes(folder, { exists: isExisting, subscribed: returns.has('SUBSCRIBED') && folder.subscribed, hasChildren })
+            .map(flag => ({ type: 'ATOM', value: flag }));
+
+    const listHandler = server.getCommandHandler('LIST');
+
+    server.setCommandHandler('LIST', (connection, parsed, data, callback) => {
+        const args = parsed.attributes || [];
+        if (!isExtended(args)) {
+            // RFC 3501 LIST
+            return listHandler(connection, parsed, data, callback);
+        }
+
+        let request;
+        try {
+            request = parseArguments(args, connection);
+        } catch (err) {
+            connection.sendStatus(parsed, data, 'BAD', err.message, false, 'INVALID COMMAND');
+            return callback();
+        }
+
+        const selection = [...request.selection.keys()].map(name => ({ name, ...extensions.selectionOptions[name] }));
+        const filters = selection.filter(option => option.match);
+        const includeNonExistent = selection.some(option => option.includeNonExistent);
+        const recursive = request.selection.has('RECURSIVEMATCH');
+        // RFC 5258 section 6: CHILDINFO lists the list-select-base-opt options, always quoted
+        const childInfo = selection.filter(option => option.type === 'base').map(option => ({ type: 'STRING', value: option.name }));
+
+        // does a mailbox satisfy the selection criteria. Without options that means an existing mailbox
+        const matches = folder => (includeNonExistent || exists(folder)) && filters.every(option => option.match(folder, connection));
+
+        // RFC 5258 section 3.1: SUBSCRIBED lists subscribed names, also the ones that are not mailboxes
+        let folders = server.folderCache;
+        if (includeNonExistent) {
+            folders = Object.assign(Object.create(null), folders, server.getSubscriptionTree());
+        }
+
+        // RFC 5258 section 3: a mailbox that matches several patterns is listed once
+        const candidates = new Set();
+        request.patterns.forEach(pattern => {
+            server.matchFolders(request.reference, pattern, path => connection.exportMailboxName(path), folders).forEach(folder => candidates.add(folder));
+        });
+
+        candidates.forEach(folder => {
+            const isExisting = exists(folder);
+            const isMatch = matches(folder);
+            const descendants = server.getDescendants(folder.path, folders);
+            const hasChildren = descendants.some(exists);
+
+            let hasChildInfo = false;
+            if (recursive) {
+                // RFC 5258 section 3.5: a matching mailbox gets CHILDINFO if a descendant matches as well.
+                // A mailbox that does not match is only listed for a matching descendant that is not
+                // listed itself (redundant CHILDINFO SHOULD be suppressed)
+                hasChildInfo = descendants.some(descendant => matches(descendant) && (isMatch || !candidates.has(descendant)));
+            }
+
+            // RFC 5258 section 3.5: without selection filters a mailbox that does not exist but has
+            // existing descendants is listed as "\NonExistent \HasChildren"
+            const listed = isMatch || hasChildInfo || (!filters.length && !isExisting && hasChildren);
+            if (!listed) {
+                return;
+            }
+
+            const attributes = [
+                getAttributes(folder, isExisting, hasChildren, request.returns),
+                server.getSeparator(folder),
+                connection.exportMailboxName(folder.path)
+            ];
+            if (hasChildInfo) {
+                // mbox-list-extended = "(" mbox-list-extended-item *(SP mbox-list-extended-item) ")"
+                attributes.push([{ type: 'STRING', value: 'CHILDINFO' }, childInfo]);
+            }
+
+            connection.send(
+                {
+                    tag: '*',
+                    command: 'LIST',
+                    attributes
+                },
+                'LIST ITEM',
+                parsed,
+                data,
+                folder
+            );
+
+            request.returns.forEach((value, name) => {
+                const option = extensions.returnOptions[name];
+                if (option.onItem) {
+                    option.onItem(connection, folder, value, { matched: isMatch, exists: isExisting }, parsed, data);
+                }
+            });
+        });
+
+        connection.sendStatus(parsed, data, 'OK', 'Completed', false, 'LIST');
+        return callback();
+    });
+};

package/lib/plugins/list-status.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const { getListExtensions } = require('../list-extensions');
+const { parseStatusItems, sendStatus } = require('../commands/handlers/status');
+const listExtended = require('./list-extended');
+
+/**
+ * @help Adds LIST-STATUS [RFC5819] capability, the STATUS return option
+ * @help of LIST. Loads LIST-EXTENDED as well
+ */
+
+module.exports = function (server) {
+    // the STATUS return option needs the extended LIST syntax (RFC 5819 section 4)
+    listExtended(server);
+
+    server.registerCapability('LIST-STATUS');
+
+    // status-option = "STATUS" SP "(" status-att *(SP status-att) ")"
+    getListExtensions(server).returnOptions.STATUS = {
+        parse: (list, connection) => parseStatusItems(server, list, connection),
+
+        // RFC 5819 section 2: a STATUS response follows the LIST response of every selectable mailbox
+        // that matches the selection criteria. Mailboxes listed only for CHILDINFO or as \NonExistent
+        // get none. The selected mailbox is no exception (RFC 9051 section 6.3.11)
+        onItem: (connection, folder, items, info, parsed, data) => {
+            if (info.matched && info.exists) {
+                sendStatus(connection, folder.path, folder, items, parsed, data);
+            }
+        }
+    };
+};

package/lib/plugins/literalminus.js

@@ -0,0 +1,20 @@
+'use strict';
+
+/**
+ * @help Enables LITERAL- [RFC7888] capability
+ * @help Non-synchronizing literals up to 4096 octets, a larger
+ * @help one is dropped and answered with BAD [TOOBIG]
+ * @help Can not be loaded with LITERAL+
+ */
+
+module.exports = function (server) {
+    // RFC 7888 section 5: servers MUST NOT advertise both LITERAL+ and LITERAL-
+    if (server.capabilities['LITERAL+']) {
+        throw new Error('LITERAL- can not be enabled together with LITERAL+');
+    }
+    server.registerCapability('LITERAL-');
+    // loaded by name, LITERAL+ can not replace it any more (see IMAP4rev2)
+    server.impliedLiteralMinus = false;
+    server.literalPlus = true;
+    server.nonSyncLiteralLimit = 4096;
+};

package/lib/plugins/literalplus.js

@@ -0,0 +1,18 @@
+'use strict';
+
+/**
+ * @help Enables LITERAL+ [RFC7888] capability
+ * @help Can not be loaded with LITERAL-
+ */
+
+module.exports = function (server) {
+    // RFC 7888 section 5: servers MUST NOT advertise both LITERAL+ and LITERAL-. IMAP4rev2 adds LITERAL- only
+    // when LITERAL+ is not loaded, LITERAL+ replaces it then, as it allows more (RFC 9051 section 4.3)
+    if (server.capabilities['LITERAL-'] && !server.impliedLiteralMinus) {
+        throw new Error('LITERAL+ can not be enabled together with LITERAL-');
+    }
+    delete server.capabilities['LITERAL-'];
+    server.registerCapability('LITERAL+');
+    server.literalPlus = true;
+    server.nonSyncLiteralLimit = Infinity;
+};

package/lib/plugins/logindisabled.js

@@ -0,0 +1,50 @@
+'use strict';
+
+/**
+ * @help Disables LOGIN support for unencrypted connections
+ */
+
+module.exports = function (server) {
+    server.registerCapability('LOGINDISABLED', connection => {
+        return !connection.secureConnection && connection.state === 'Not Authenticated';
+    });
+
+    // Retrieve actual LOGIN handler
+    // Will be run if conditions are met
+    const oldHandler = server.getCommandHandler('LOGIN');
+
+    // Override LOGIN
+    server.setCommandHandler('LOGIN', (connection, parsed, data, callback) => {
+        // If the connection is unsecure, do not allow LOGIN
+        if (!connection.secureConnection) {
+            connection.send(
+                {
+                    tag: parsed.tag,
+                    command: 'NO',
+                    attributes: [
+                        {
+                            type: 'SECTION',
+                            section: [
+                                {
+                                    type: 'ATOM',
+                                    value: 'PRIVACYREQUIRED'
+                                }
+                            ]
+                        },
+                        {
+                            type: 'TEXT',
+                            value: 'Run STARTTLS first'
+                        }
+                    ]
+                },
+                'LOGIN FAILED',
+                parsed,
+                data
+            );
+            return callback();
+        }
+
+        // Reroute command to actual LOGIN handler
+        oldHandler(connection, parsed, data, callback);
+    });
+};

package/lib/plugins/messagelimit.js

@@ -0,0 +1,234 @@
+'use strict';
+
+const { badError } = require('../commands/handlers/search');
+const { parsePartialRange } = require('../esearch');
+const { MAX_NUMBER, isNzNumber } = require('../numbers');
+
+/**
+ * @help Adds MESSAGELIMIT [RFC9738] capability, advertised as MESSAGELIMIT=<n>
+ * @help Server option "messageLimit" sets n (default 1000). FETCH, STORE, SEARCH, MOVE, UID EXPUNGE
+ * @help and their UID variants only work on the n messages with the highest UIDs and add
+ * @help [MESSAGELIMIT n uid] to the tagged OK. COPY, APPEND (MULTIAPPEND), SORT and THREAD of
+ * @help more messages fail with NO [MESSAGELIMIT ...]. Adds the UIDAFTER and UIDBEFORE search keys.
+ * @help Can not be loaded with SAVELIMIT
+ *
+ * MESSAGELIMIT: https://www.rfc-editor.org/rfc/rfc9738
+ */
+
+// RFC 9738 section 3: the advertised limit SHOULD NOT be lower than 1000
+const DEFAULT_LIMIT = 1000;
+
+// RFC 9738 section 3.1: commands that operate on the messages with the highest UIDs and return the MESSAGELIMIT response code.
+// EXPUNGE, CLOSE and STATUS UNSEEN MUST NOT be limited
+const PARTIAL_COMMANDS = new Set(['FETCH', 'UID FETCH', 'STORE', 'UID STORE', 'MOVE', 'UID MOVE', 'UID EXPUNGE']);
+const SEARCH_COMMANDS = new Set(['SEARCH', 'UID SEARCH']);
+// RFC 9738 section 3.3: SORT and THREAD can not be run on more messages than the limit
+const SORT_COMMANDS = new Set(['SORT', 'UID SORT', 'THREAD', 'UID THREAD']);
+
+/**
+ * Reads the limit from the "messageLimit" server option
+ *
+ * @param {Object} server IMAPServer
+ * @param {String} name Capability name for the error message
+ * @return {Number} limit
+ */
+function getLimit(server, name) {
+    if (server.messageLimit) {
+        // RFC 9738 section 3: SAVELIMIT is advertised instead of MESSAGELIMIT, never both
+        throw new Error(name + ' can not be enabled together with ' + server.messageLimit.name);
+    }
+    const limit = 'messageLimit' in server.options ? server.options.messageLimit : DEFAULT_LIMIT;
+    // message-limit = nz-number
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_NUMBER) {
+        throw new TypeError('Invalid messageLimit option, expecting a positive integer');
+    }
+    server.messageLimit = { name, limit };
+    return limit;
+}
+
+/**
+ * Refuses COPY and APPEND of more messages than the limit, shared with the SAVELIMIT plugin. COPY and
+ * MULTIAPPEND APPEND are atomic, so nothing is copied or appended (RFC 9738 section 3.1)
+ *
+ * @param {Object} server IMAPServer
+ * @param {Number} limit Message limit
+ */
+function addSaveLimit(server, limit) {
+    server.appendChecks.push((connection, mailbox, messages, options) => {
+        if (messages.length <= limit) {
+            return false;
+        }
+        if (options.command) {
+            return { code: ['MESSAGELIMIT', limit], text: options.command + ' exceeds the limit of ' + limit + ' messages, nothing was appended' };
+        }
+        // MOVE is not atomic, it is cut to the limit before it gets here
+        if (!options.move) {
+            // the lowest UID the command would have processed, the messages are in UID order
+            const lastUid = messages[messages.length - limit].uid;
+            return { code: ['MESSAGELIMIT', limit, lastUid], text: 'Too many messages to copy, try a smaller subset' };
+        }
+        return false;
+    });
+}
+
+module.exports = function (server) {
+    const limit = getLimit(server, 'MESSAGELIMIT');
+    server.registerCapability('MESSAGELIMIT=' + limit);
+    addSaveLimit(server, limit);
+
+    const commandName = parsed => String(parsed.command || '').toUpperCase();
+
+    // FETCH, STORE, MOVE and UID EXPUNGE only operate on the messages with the highest UIDs, "the server is REQUIRED
+    // to process messages from highest to lowest UID". COPY is refused by addSaveLimit instead
+    server.rangeLimits.push((connection, parsed, range) => {
+        const command = commandName(parsed);
+        // a FETCH with the PARTIAL modifier was checked before it ran, its range is not cut
+        if (!PARTIAL_COMMANDS.has(command) || parsed.partialFetch) {
+            return false;
+        }
+        // UID EXPUNGE only operates on the \Deleted messages of the set
+        const operated = command === 'UID EXPUNGE' ? range.filter(entry => entry[1].flags.indexOf('\\Deleted') >= 0) : range;
+        if (operated.length <= limit) {
+            return false;
+        }
+        const dropped = new Set(operated.slice(0, -limit));
+        parsed.messageLimitUid = operated[operated.length - limit][1].uid;
+        // section 3.1: "when the MESSAGELIMIT response code is returned, the server is REQUIRED to process messages
+        // from highest to lowest UID", the FETCH, STORE, MOVE and UID EXPUNGE examples respond in that order
+        parsed.highestFirst = true;
+        return range.filter(entry => !dropped.has(entry)).reverse();
+    });
+
+    // RFC 9738 section 3.1: with the PARTIAL FETCH modifier (RFC 9394 section 3.3), the PARTIAL range is the message
+    // count, a larger range is refused without doing any work. The PARTIAL plugin answers an invalid modifier with BAD
+    server.commandChecks.push((connection, parsed) => {
+        const modifiers = server.capabilities.PARTIAL && parsed.attributes && parsed.attributes[2];
+        const command = commandName(parsed);
+        if (!Array.isArray(modifiers) || (command !== 'FETCH' && command !== 'UID FETCH')) {
+            return false;
+        }
+        const position = modifiers.findIndex((item, i) => !(i % 2) && item && item.type === 'ATOM' && String(item.value).toUpperCase() === 'PARTIAL');
+        let range;
+        try {
+            range = position >= 0 && parsePartialRange(modifiers[position + 1], true);
+        } catch {
+            return false;
+        }
+        if (range && range.to - range.from + 1 > limit) {
+            return { command: 'NO', code: ['MESSAGELIMIT', limit], text: command + ' exceeds the limit of ' + limit + ' messages' };
+        }
+        return false;
+    });
+
+    // RFC 9738 section 3.1: SEARCH counts the searched messages, not the matching ones. The messages a search
+    // looks at are the ones its top level sequence set, UID, UIDAFTER and UIDBEFORE keys allow
+    server.searchLimits.push((connection, messages, query) => {
+        // the running command, SEARCH and SORT do not pass it to the search
+        const parsed = connection._runningCommand && connection._runningCommand.parsed;
+        const command = parsed && commandName(parsed);
+        if (messages.length <= limit || (!SEARCH_COMMANDS.has(command) && !SORT_COMMANDS.has(command))) {
+            return false;
+        }
+        const candidates = messages.filter(message => isCandidate(query, message));
+        if (candidates.length <= limit) {
+            return false;
+        }
+        if (SORT_COMMANDS.has(command)) {
+            const err = new Error(command + ' exceeds the limit of ' + limit + ' messages, narrow it down with UIDAFTER or UIDBEFORE');
+            err.imapResponse = 'NO';
+            err.responseCode = ['MESSAGELIMIT', limit];
+            throw err;
+        }
+        // with SEARCHRES, only these results are saved in "$" (RFC 9738 section 3.4)
+        parsed.messageLimitUid = candidates[candidates.length - limit].uid;
+        return candidates.slice(-limit);
+    });
+
+    // RFC 9738 section 3.2: UIDAFTER <uid> is "UID <uid>+1:*", UIDBEFORE <uid> is "UID 1:<uid>-1"
+    const parseUniqueId = value => {
+        // uniqueid = nz-number
+        if (!isNzNumber(value)) {
+            throw badError('UIDAFTER and UIDBEFORE expect a UID');
+        }
+        return Number(value);
+    };
+    const uidAfter = (connection, message, index, uid) => message.uid > uid;
+    uidAfter.argumentTypes = () => [parseUniqueId];
+    const uidBefore = (connection, message, index, uid) => message.uid < uid;
+    uidBefore.argumentTypes = () => [parseUniqueId];
+    server.searchHandlers.UIDAFTER = uidAfter;
+    server.searchHandlers.UIDBEFORE = uidBefore;
+
+    const outputHandler = (connection, response, description, parsed, data) => {
+        // section 3.1 UID SEARCH example: the results go from the highest UID down, (MODSEQ n) of CONDSTORE stays last
+        if (parsed && parsed.messageLimitUid && response.tag === '*' && response.command === 'SEARCH' && Array.isArray(response.attributes)) {
+            const modseq = response.attributes.filter(Array.isArray);
+            response.attributes = response.attributes
+                .filter(attr => !Array.isArray(attr))
+                .reverse()
+                .concat(modseq);
+            return;
+        }
+        if (!parsed || !parsed.messageLimitUid || response.tag !== parsed.tag) {
+            return;
+        }
+        const lastUid = parsed.messageLimitUid;
+        parsed.messageLimitUid = false;
+        if (response.command !== 'OK') {
+            return;
+        }
+
+        // resp-text-code =/ "MESSAGELIMIT" SP message-limit [SP uniqueid]
+        const code = { type: 'SECTION', section: [{ type: 'ATOM', value: 'MESSAGELIMIT' }, limit, lastUid] };
+        const attributes = response.attributes || [];
+        if (attributes[0] && attributes[0].type === 'SECTION') {
+            // RFC 9738 section 3.1: when the tagged OK carries another response code (EXPUNGEISSUED there, and here
+            // also HIGHESTMODSEQ, MODIFIED), MESSAGELIMIT is sent in an untagged NO
+            connection.send(
+                {
+                    tag: '*',
+                    command: 'NO',
+                    attributes: [code, { type: 'TEXT', value: 'Only the last ' + limit + ' messages were processed' }]
+                },
+                'MESSAGELIMIT',
+                parsed,
+                data
+            );
+            return;
+        }
+        response.attributes = [code].concat(attributes);
+    };
+
+    // registered once every plugin is loaded, so that the response codes other plugins add to the tagged OK
+    // are already there
+    server.once('pluginsLoaded', () => server.outputHandlers.push(outputHandler));
+};
+
+/**
+ * Checks if a message passes the keys of a search query that every match must pass: sequence sets,
+ * UID, UIDAFTER and UIDBEFORE at the top level, or in parenthesized lists at the top level
+ *
+ * @param {Object} node AND node of the query tree, see commands/handlers/search.js
+ * @param {Object} message Message
+ * @return {Boolean} true if the message has to be searched
+ */
+function isCandidate(node, message) {
+    return node.args.every(arg => {
+        switch (arg.key) {
+            case 'AND':
+                return isCandidate(arg, message);
+            case '_SEQ':
+            case 'UID':
+                return arg.set.has(message);
+            case 'UIDAFTER':
+                return message.uid > arg.args[0];
+            case 'UIDBEFORE':
+                return message.uid < arg.args[0];
+            default:
+                return true;
+        }
+    });
+}
+
+module.exports.getLimit = getLimit;
+module.exports.addSaveLimit = addSaveLimit;

package/lib/plugins/metadata-server.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const { setup } = require('./metadata');
+
+/**
+ * @help Adds METADATA-SERVER [RFC5464] capability, like METADATA but
+ * @help only for server annotations (mailbox name ""). With METADATA
+ * @help also loaded, only METADATA is advertised
+ */
+
+module.exports = function (server) {
+    setup(server, false);
+};