imapkit 0.0.0-stage → 4.0.1

package/lib/bodystructure.js

@@ -0,0 +1,149 @@
+'use strict';
+
+// Converts a parsed MIME tree into BODY and BODYSTRUCTURE data. Ported from WildDuck
+// (imap-core/lib/indexer/body-structure.js)
+
+const envelope = require('./envelope');
+const { partsOf, embeddedMessage } = require('./mimeparser');
+
+// Expose to the world
+module.exports = createBodystructure;
+
+/**
+ * Generates an object out of parsed mime tree, that can be
+ * serialized into a BODYSTRUCTURE string
+ *
+ * @param {Object} tree Parsed mime tree (see mimeparser.js for input)
+ * @param {Object} [options] Optional options object
+ * @param {Boolean} [options.upperCaseKeys] If true, use only upper case key names
+ * @param {Boolean} [options.skipContentLocation] If true, do not include Content-Location in the output
+ * @param {Boolean} [options.body] If true, skip extension fields (needed for BODY)
+ * @param {Boolean} [options.messageGlobal] If true, describe message/global like message/rfc822 (IMAP4rev2, RFC 9051 section 7.5.2)
+ * @return {Array} Object structure in the form of BODYSTRUCTURE
+ */
+function createBodystructure(tree, options) {
+    options = options || {};
+
+    const key = name => (options.upperCaseKeys && typeof name === 'string' ? name.toUpperCase() : name);
+
+    // Parameter list of a parsed structured header value, as the flat `(key value key value)` list
+    const paramList = parsed => {
+        if (!parsed || !parsed.hasParams) {
+            return null;
+        }
+        const list = [];
+        Object.keys(parsed.params).forEach(name => {
+            list.push(key(name), parsed.params[name]);
+        });
+        return list.length ? list : null;
+    };
+
+    const getBasicFields = node => {
+        const contentType = node.parsedHeader['content-type'] || {};
+        let bodyType = contentType.type || null;
+        let bodySubtype = contentType.subtype || null;
+
+        if (!bodyType || !bodySubtype) {
+            // prevent strange content types like (NIL "/ms-word") that may break some clients
+            if (bodyType === 'text' || bodySubtype === 'plain') {
+                bodyType = 'text';
+                bodySubtype = 'plain';
+            } else {
+                bodyType = 'application';
+                bodySubtype = 'octet-stream';
+            }
+        }
+
+        return [
+            key(bodyType),
+            key(bodySubtype),
+            // body parameter parenthesized list
+            paramList(contentType),
+            // body id
+            node.parsedHeader['content-id'] || null,
+            // body description
+            node.parsedHeader['content-description'] || null,
+            // body encoding
+            key(node.parsedHeader['content-transfer-encoding'] || '7bit'),
+            // body size
+            node.size
+        ];
+    };
+
+    // The extension fields every part has (a non-multipart part also has an MD5 before them)
+    const getExtensionFields = node => {
+        const languageString = node.parsedHeader['content-language'] && node.parsedHeader['content-language'].replace(/[ ,]+/g, ',').replace(/^,+|,+$/g, '');
+        const language = (languageString && languageString.split(',')) || null;
+        const disposition = node.parsedHeader['content-disposition'];
+
+        const data = [
+            // body disposition
+            (disposition && [key(disposition.value), paramList(disposition)]) || null,
+            // body language
+            language
+        ];
+
+        // NB! RFC3501 has an errata with content-location type, it is described as
+        // "A string list" (eg. an array) in RFC but the errata page states
+        // that it is a string (http://www.rfc-editor.org/errata_search.php?rfc=3501)
+        // see note for "Section 7.4.2, page 75"
+        if (!options.skipContentLocation) {
+            data.push(node.parsedHeader['content-location'] || null);
+        }
+
+        return data;
+    };
+
+    // A non-multipart node: the basic fields, the fields of its type (line count for text, envelope and
+    // structure for message/rfc822), and the extension fields unless BODY was asked for
+    const processLeaf = (node, extra) => {
+        let data = getBasicFields(node).concat(extra);
+        if (!options.body) {
+            data = data.concat([node.parsedHeader['content-md5'] || null], getExtensionFields(node));
+        }
+        return data;
+    };
+
+    const processMultipartNode = node => {
+        let data = partsOf(node)
+            .map(walker)
+            .concat([key(node.multipart)]);
+
+        if (!options.body) {
+            // RFC 3501 7.4.2: BODY is BODYSTRUCTURE without extension data, and for a multipart the
+            // parameter list is the first extension field (body-ext-mpart)
+            data = data.concat([paramList(node.parsedHeader['content-type'])], getExtensionFields(node));
+        }
+
+        // body-type-mpart = 1*body SP media-subtype, there is no SP between the bodies (RFC 3501 section 9)
+        Object.defineProperty(data, 'adjacentLists', { value: true });
+        return data;
+    };
+
+    const walker = node => {
+        const contentType = node.parsedHeader['content-type'] || {};
+        switch (contentType.type) {
+            case 'multipart':
+                // a multipart without a boundary parameter has no parts and is described with the
+                // basic fields (RFC 3501 body-type-mpart needs at least one body)
+                return partsOf(node) ? processMultipartNode(node) : processLeaf(node, []);
+            case 'text':
+                return processLeaf(node, [node.lineCount]);
+            case 'message': {
+                // RFC 2045 5.1: the subtype is not case sensitive. Other message subtypes, such as
+                // message/delivery-status, are described as basic parts. RFC 9051 section 9 media-message
+                // adds message/global, RFC 3501 body-type-basic describes it as a basic part
+                // (embeddedMessage() only returns the message of these types)
+                const embedded = embeddedMessage(node, options.messageGlobal);
+                if (embedded) {
+                    return processLeaf(node, [envelope(embedded.parsedHeader), walker(embedded), node.lineCount]);
+                }
+                return processLeaf(node, []);
+            }
+            default:
+                return processLeaf(node, []);
+        }
+    };
+
+    return walker(tree);
+}

package/lib/command-states.js

@@ -0,0 +1,109 @@
+'use strict';
+
+// Connection states in which each command is valid (RFC 3501 sections 3 and 6). Commands valid
+// in the authenticated state are also valid in the selected state.
+const ANY = ['Not Authenticated', 'Authenticated', 'Selected'];
+const NOT_AUTHENTICATED = ['Not Authenticated'];
+const AUTHENTICATED = ['Authenticated', 'Selected'];
+const SELECTED = ['Selected'];
+
+/**
+ * Normalizes command options
+ *
+ * @param {Object|Array} options `{ states, noArguments, mailboxArguments, astringArguments, searchCriteria, sequenceSet, noExpunge,
+ *   literal8, noPipelining }`, or just the list of states
+ * @return {Object} options with all keys set
+ */
+function commandOptions(options) {
+    if (Array.isArray(options)) {
+        options = { states: options };
+    }
+    options = options || {};
+    return {
+        // false means any state
+        states: options.states ? [].concat(options.states) : false,
+        // "Arguments: none" in the command description
+        noArguments: !!options.noArguments,
+        // positions of the arguments that are mailbox names, checked against RFC 3501 section 5.1.3
+        mailboxArguments: [].concat(options.mailboxArguments || []),
+        // positions of other arguments that are astrings (RFC 3501 section 9), like user names. In these, in the mailbox
+        // name arguments and in search criteria a NIL atom is a string, not the nil of an nstring
+        astringArguments: [].concat(options.astringArguments || []),
+        // position of the first search key argument, for commands that take search criteria (RFC 3501 section 6.4.4)
+        searchCriteria: typeof options.searchCriteria === 'number' ? options.searchCriteria : false,
+        // position of the argument that holds message sequence numbers (a sequence set or a seq-number, not UIDs), for
+        // the RFC 3501 section 5.5 ambiguity check and for UIDONLY (RFC 9586 section 3)
+        sequenceSet: typeof options.sequenceSet === 'number' ? options.sequenceSet : false,
+        // EXPUNGE responses must not be sent while the command runs, so a client does not have to wait for its
+        // completion before sending a command with sequence numbers (RFC 3501 sections 5.5 and 7.4.1)
+        noExpunge: !!options.noExpunge,
+        // if the command accepts literal8 arguments `~{n}`: true, or the capability that allows them, like
+        // "BINARY" for the APPEND message (RFC 3516 section 4.4)
+        literal8: options.literal8 === true || typeof options.literal8 === 'string' ? options.literal8 : false,
+        // the client must not send anything after the command before it has seen the result, because the command changes
+        // the layers below the protocol (STARTTLS, RFC 9051 section 6.2.1, COMPRESS, RFC 4978 section 3). The command is
+        // refused with BAD if more input is waiting
+        noPipelining: !!options.noPipelining,
+        // the command takes a message after its mailbox argument like APPEND does (REPLACE, RFC 8508 section 3.4), so a
+        // message literal to a missing mailbox is refused before it is sent
+        appendMessage: !!options.appendMessage
+    };
+}
+
+// RFC 3501 core commands. Plugins pass the options of their commands to setCommandHandler
+const CORE_COMMANDS = {
+    CAPABILITY: commandOptions({ states: ANY, noArguments: true }),
+    NOOP: commandOptions({ states: ANY, noArguments: true }),
+    LOGOUT: commandOptions({ states: ANY, noArguments: true }),
+
+    STARTTLS: commandOptions({ states: NOT_AUTHENTICATED, noArguments: true, noPipelining: true }),
+    // login = "LOGIN" SP userid SP password, both astrings
+    LOGIN: commandOptions({ states: NOT_AUTHENTICATED, astringArguments: [0, 1] }),
+
+    SELECT: commandOptions({ states: AUTHENTICATED, mailboxArguments: [0] }),
+    EXAMINE: commandOptions({ states: AUTHENTICATED, mailboxArguments: [0] }),
+    CREATE: commandOptions({ states: AUTHENTICATED, mailboxArguments: [0] }),
+    DELETE: commandOptions({ states: AUTHENTICATED, mailboxArguments: [0] }),
+    RENAME: commandOptions({ states: AUTHENTICATED, mailboxArguments: [0, 1] }),
+    SUBSCRIBE: commandOptions({ states: AUTHENTICATED, mailboxArguments: [0] }),
+    UNSUBSCRIBE: commandOptions({ states: AUTHENTICATED, mailboxArguments: [0] }),
+    // the reference is a mailbox name, the pattern a list-mailbox, an atom NIL is a valid name for both
+    LIST: commandOptions({ states: AUTHENTICATED, astringArguments: [0, 1] }),
+    LSUB: commandOptions({ states: AUTHENTICATED, astringArguments: [0, 1] }),
+    STATUS: commandOptions({ states: AUTHENTICATED, mailboxArguments: [0] }),
+    APPEND: commandOptions({ states: AUTHENTICATED, mailboxArguments: [0], literal8: 'BINARY', appendMessage: true }),
+
+    CHECK: commandOptions({ states: SELECTED, noArguments: true }),
+    CLOSE: commandOptions({ states: SELECTED, noArguments: true }),
+    EXPUNGE: commandOptions({ states: SELECTED, noArguments: true }),
+    SEARCH: commandOptions({ states: SELECTED, searchCriteria: 0, noExpunge: true }),
+    FETCH: commandOptions({ states: SELECTED, sequenceSet: 0, noExpunge: true }),
+    STORE: commandOptions({ states: SELECTED, sequenceSet: 0, noExpunge: true }),
+    COPY: commandOptions({ states: SELECTED, sequenceSet: 0, mailboxArguments: [1] }),
+    'UID COPY': commandOptions({ states: SELECTED, mailboxArguments: [1] }),
+    'UID SEARCH': commandOptions({ states: SELECTED, searchCriteria: 0 })
+};
+
+const UID_COMMAND = commandOptions({ states: SELECTED });
+const AUTHENTICATE_COMMAND = commandOptions({ states: NOT_AUTHENTICATED });
+
+/**
+ * Returns the options of a core command
+ *
+ * @param {String} command Upper case command name, e.g. "UID FETCH"
+ * @return {Object|Boolean} command options (see commandOptions) or false if the command is not a core command
+ */
+function getCommandOptions(command) {
+    if (Object.hasOwn(CORE_COMMANDS, command)) {
+        return CORE_COMMANDS[command];
+    }
+    if (/^UID /.test(command)) {
+        return UID_COMMAND;
+    }
+    if (/^AUTHENTICATE /.test(command)) {
+        return AUTHENTICATE_COMMAND;
+    }
+    return false;
+}
+
+module.exports = { getCommandOptions, commandOptions, states: { ANY, NOT_AUTHENTICATED, AUTHENTICATED, SELECTED } };

package/lib/commands/append.js

@@ -0,0 +1,313 @@
+'use strict';
+
+const imapHandler = require('imap-handler');
+const { normalizeSystemFlag, checkSystemFlags } = require('./handlers/flags');
+const { restoreNilAtoms, isAstring } = require('../arguments');
+
+/**
+ * Creates an error that refuses an APPEND like command
+ *
+ * @param {String} text Human readable text
+ * @param {String} [code] Response code, e.g. "TOOBIG"
+ * @param {Array} [codeArgs] Arguments of the response code, as response attributes
+ * @param {String} [response] "NO" (default) or "BAD"
+ * @return {Error} Error object
+ */
+function appendError(text, code, codeArgs, response) {
+    const err = new Error(text);
+    err.imapResponse = response || 'NO';
+    err.responseCode = code || false;
+    err.responseCodeArgs = codeArgs || [];
+    return err;
+}
+
+const badArgument = text => appendError(text, false, false, 'BAD');
+
+/**
+ * Parses a flag list, flags are atoms, and \Recent or unknown system flags can not be set (RFC 3501 section 9)
+ *
+ * @param {Object} connection IMAPConnection
+ * @param {Array} list Parsed flag list
+ * @return {Array} Flags
+ */
+function parseFlags(connection, list) {
+    try {
+        return list.map(flag => {
+            if (!flag || flag.type !== 'ATOM') {
+                throw new Error('Invalid flags argument');
+            }
+            const value = normalizeSystemFlag(flag.value);
+            checkSystemFlags(connection, value);
+            return value;
+        });
+    } catch {
+        throw badArgument('Invalid flags argument');
+    }
+}
+
+/**
+ * Parses the messages of an APPEND like command. RFC 3502 and RFC 4466 section 3:
+ * append-message = [SP flag-list] [SP date-time] SP append-data, where append-data is a literal
+ * or an extension (label SP value) from `server.appendDataHandlers`, e.g. CATENATE (RFC 4469)
+ *
+ * @param {Object} connection IMAPConnection
+ * @param {Array} args Parsed arguments after the mailbox name
+ * @param {Number} maxMessages Largest number of messages allowed
+ * @return {Array} Messages `{ flags, internaldate, raw, resolve, literal8 }`, resolve builds the message source
+ *   of an append-data extension. Throws a BAD error if the arguments break the grammar
+ */
+function parseMessages(connection, args, maxMessages) {
+    const server = connection.server;
+    const messages = [];
+
+    for (let i = 0; i < args.length;) {
+        const message = { flags: [], internaldate: false, raw: false };
+
+        if (Array.isArray(args[i])) {
+            message.flags = parseFlags(connection, args[i++]);
+        }
+
+        // date-time is always a quoted string, a literal here is the message
+        if (args[i] && args[i].type === 'STRING') {
+            if (!server.validateInternalDate(args[i].value)) {
+                throw badArgument('Invalid internaldate argument');
+            }
+            message.internaldate = args[i++].value;
+        }
+
+        const appendData = args[i++];
+        const label = appendData && appendData.type === 'ATOM' ? String(appendData.value).toUpperCase() : '';
+        if (appendData && appendData.type === 'LITERAL') {
+            message.raw = appendData.value;
+        } else if (appendData && appendData.type === 'LITERAL8' && server.appendLiteral8) {
+            // RFC 3516 section 4.4: the message as a literal8, server.appendLiteral8 (BINARY) stores it
+            message.raw = appendData.value;
+            message.literal8 = true;
+        } else if (label && Object.hasOwn(server.appendDataHandlers, label) && i < args.length) {
+            message.resolve = server.appendDataHandlers[label](connection, args[i++]);
+        } else {
+            throw badArgument('Invalid message source argument');
+        }
+
+        messages.push(message);
+    }
+
+    if (!messages.length) {
+        throw badArgument('Missing message argument');
+    }
+
+    if (messages.length > maxMessages) {
+        // only a single message unless MULTIAPPEND is supported (RFC 4466 section 3)
+        throw badArgument('Only a single message can be appended');
+    }
+
+    return messages;
+}
+
+/**
+ * Sends the response for an error from appendError()
+ *
+ * @param {Object} connection IMAPConnection
+ * @param {Object} parsed Parsed command
+ * @param {String} data Raw command
+ * @param {Error} err Error object
+ * @param {String} description Description of a NO response
+ */
+function sendAppendError(connection, parsed, data, err, description) {
+    const attributes = [];
+    if (err.responseCode) {
+        attributes.push({
+            type: 'SECTION',
+            section: [{ type: 'ATOM', value: err.responseCode }].concat(err.responseCodeArgs)
+        });
+    }
+    attributes.push({ type: 'TEXT', value: err.message });
+
+    connection.send(
+        {
+            tag: parsed.tag,
+            command: err.imapResponse,
+            attributes
+        },
+        err.imapResponse === 'BAD' ? 'INVALID COMMAND' : description,
+        parsed,
+        data
+    );
+}
+
+/**
+ * Finds the target mailbox name of an APPEND or REPLACE command when a literal of a message (or of a CATENATE TEXT
+ * part) is announced. Only the start of the command up to the mailbox argument is parsed, so the data of earlier
+ * literals is not parsed again for every message of a MULTIAPPEND
+ *
+ * @param {Object} connection IMAPConnection
+ * @param {String} command Upper case command name
+ * @param {String} line Command received so far, up to the literal size marker
+ * @return {String|Boolean} storage name of the mailbox, or false if the literal is not a message or the name is not
+ *   known yet or not valid
+ */
+function getPendingTarget(connection, command, line) {
+    const options = connection.server.getCommandOptions(command);
+    if (!options.appendMessage) {
+        return false;
+    }
+    const mailboxPosition = options.mailboxArguments[0];
+
+    // the literal of a CATENATE URL is not a message part
+    if (/[ (]URL $/i.test(line.slice(-5))) {
+        return false;
+    }
+
+    // an open CATENATE list is closed for parsing
+    const parse = text => {
+        text = text.replace(/ $/, '');
+        for (const suffix of ['', ')']) {
+            try {
+                const parsed = imapHandler.parser(text + suffix);
+                restoreNilAtoms(parsed, text, path => path.length === 1 && path[0] === mailboxPosition);
+                return parsed.attributes || [];
+            } catch {
+                // try the next suffix
+            }
+        }
+        return [];
+    };
+
+    // the command up to the first literal, or up to the end of it when that literal is the mailbox name
+    const literal = line.match(/(~?)\{(\d+)\+?\}\r\n/);
+    let attributes = parse(literal ? line.substr(0, literal.index) : line);
+    if (attributes.length <= mailboxPosition && literal && !literal[1]) {
+        attributes = parse(line.substr(0, literal.index + literal[0].length + Number(literal[2])));
+    }
+    // a literal8 can not be a mailbox name, the command handler refuses it
+    const pathArg = attributes[mailboxPosition];
+    if (!isAstring(pathArg)) {
+        return false;
+    }
+    try {
+        return connection.importMailboxName(pathArg.value);
+    } catch {
+        // the command handler refuses the name
+        return false;
+    }
+}
+
+/**
+ * A literal filter (`server.literalFilters`) that refuses the message of an APPEND or REPLACE to a mailbox that does
+ * not exist before the client sends it, by not sending a continuation request (RFC 3502 section 6.3.11 example A004,
+ * RFC 3501 section 6.3.11: TRYCREATE). Not while earlier commands are still waiting, these could create the mailbox
+ *
+ * @param {Object} connection IMAPConnection
+ * @param {String} command Upper case command name
+ * @param {String} line Command received so far, up to the literal size marker
+ * @return {Object|Boolean} `{ command, code, text }` to refuse the literal, or false
+ */
+function refuseMissingTarget(connection, command, line) {
+    const path = !connection.isBusy() && getPendingTarget(connection, command, line);
+    return path !== false && connection.server.targetRefusal(path);
+}
+
+/**
+ * Prepares the messages of an APPEND like command (APPEND, REPLACE): parses the arguments, checks
+ * the target mailbox, builds the message sources and runs `server.appendChecks` through
+ * IMAPConnection#checkAppend. Nothing is stored yet, so a failure leaves every mailbox as it was
+ * (RFC 3502 section 6.3.11). The error response is sent here.
+ *
+ * The checks get the built messages (with `raw`) of the whole command and the options as
+ * `{ command, replaced }`, `replaced` is the message that REPLACE removes.
+ *
+ * @param {Object} connection IMAPConnection
+ * @param {Object} parsed Parsed command
+ * @param {String} data Raw command
+ * @param {Object} pathArg Parsed mailbox name argument
+ * @param {Array} args Parsed arguments after the mailbox name
+ * @param {Object} options `{ command, maxMessages, replaced }`
+ * @return {Object|Boolean} `{ mailbox, messages }` or false if an error response was sent
+ */
+function prepareAppend(connection, parsed, data, pathArg, args, options) {
+    const description = options.command + ' FAILED';
+    const maxMessages = options.maxMessages || (connection.server.multiAppend ? Infinity : 1);
+    try {
+        if (!pathArg || ['STRING', 'ATOM', 'LITERAL'].indexOf(pathArg.type) < 0) {
+            throw badArgument('Invalid mailbox argument');
+        }
+        const messages = parseMessages(connection, args, maxMessages);
+
+        // getTargetMailbox sends the NO response itself
+        const mailbox = connection.getTargetMailbox(pathArg.value, parsed, data, description);
+        if (!mailbox) {
+            return false;
+        }
+
+        messages.forEach(message => {
+            if (message.resolve) {
+                message.raw = message.resolve();
+            } else if (message.literal8) {
+                message.raw = connection.server.appendLiteral8(message.raw);
+            }
+        });
+
+        // checkAppend sends the NO response itself
+        if (!connection.checkAppend(mailbox, messages, parsed, data, description, { command: options.command, replaced: options.replaced })) {
+            return false;
+        }
+
+        return { mailbox, messages };
+    } catch (err) {
+        if (!err.imapResponse) {
+            throw err;
+        }
+        sendAppendError(connection, parsed, data, err, description);
+        return false;
+    }
+}
+
+/**
+ * Stores prepared messages. The sessions that have the target mailbox selected get EXISTS updates
+ *
+ * @param {Object} connection IMAPConnection
+ * @param {Object} prepared Result of prepareAppend()
+ * @return {Object} `{ mailbox, message, messages }`, message is the last stored message
+ */
+function storeMessages(connection, prepared) {
+    const messages = prepared.messages.map(
+        message => connection.server.appendMessage(prepared.mailbox, message.flags, message.internaldate, message.raw).message
+    );
+    return { mailbox: prepared.mailbox, message: messages[messages.length - 1], messages };
+}
+
+module.exports = function (connection, parsed, data, callback) {
+    const args = [].concat(parsed.attributes || []);
+
+    const prepared = prepareAppend(connection, parsed, data, args.shift(), args, { command: 'APPEND' });
+    if (!prepared) {
+        return callback();
+    }
+
+    const appendResult = storeMessages(connection, prepared);
+
+    connection.send(
+        {
+            tag: parsed.tag,
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'APPEND Completed'
+                }
+            ]
+        },
+        'APPEND',
+        parsed,
+        data,
+        appendResult
+    );
+    callback();
+};
+
+module.exports.appendError = appendError;
+module.exports.badArgument = badArgument;
+module.exports.prepareAppend = prepareAppend;
+module.exports.storeMessages = storeMessages;
+module.exports.getPendingTarget = getPendingTarget;
+module.exports.refuseMissingTarget = refuseMissingTarget;

package/lib/commands/capability.js

@@ -0,0 +1,47 @@
+'use strict';
+
+module.exports = function (connection, parsed, data, callback) {
+    const capabilities = ['IMAP4rev1'];
+
+    Object.keys(connection.server.capabilities).forEach(key => {
+        if (connection.server.capabilities[key](connection)) {
+            capabilities.push(key);
+        }
+    });
+
+    connection.send(
+        {
+            tag: '*',
+            command: 'CAPABILITY',
+            attributes: capabilities.map(capability => {
+                return {
+                    type: 'TEXT',
+                    value: capability
+                };
+            })
+        },
+        'CAPABILITY LIST',
+        parsed,
+        data,
+        capabilities
+    );
+
+    connection.send(
+        {
+            tag: parsed.tag,
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'Completed'
+                }
+            ]
+        },
+        'CAPABILITY COMPLETED',
+        parsed,
+        data,
+        capabilities
+    );
+
+    callback();
+};

package/lib/commands/check.js

@@ -0,0 +1,21 @@
+'use strict';
+
+module.exports = function (connection, parsed, data, callback) {
+    connection.send(
+        {
+            tag: parsed.tag,
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'Completed'
+                }
+            ]
+        },
+        'CHECK',
+        parsed,
+        data
+    );
+
+    callback();
+};

package/lib/commands/close.js

@@ -0,0 +1,30 @@
+'use strict';
+
+module.exports = function (connection, parsed, data, callback) {
+    // a read-only mailbox is closed without removing anything
+    if (connection.canExpunge()) {
+        connection.expungeDeleted(connection.selectedMailbox, true);
+    }
+
+    // CLOSE does not send pending EXPUNGE or EXISTS responses (RFC 3501 section 6.4.2)
+    connection.notificationQueue = [];
+
+    connection.send(
+        {
+            tag: parsed.tag,
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'Mailbox closed'
+                }
+            ]
+        },
+        'CLOSE',
+        parsed,
+        data
+    );
+
+    connection.closeMailbox();
+    return callback();
+};