imapkit 0.0.0-stage → 4.0.1

package/lib/plugins/sort.js

@@ -0,0 +1,132 @@
+'use strict';
+
+const { states } = require('../command-states');
+const { getMessageData } = require('../mimeparser');
+const { collationKey, baseSubject, arrivalTime, sentTime, addressMailbox, searchMessages } = require('../sorting');
+
+/**
+ * @help Adds SORT [RFC5256] capability
+ *
+ * SORT: https://tools.ietf.org/html/rfc5256
+ *
+ * Additional commands:
+ * - SORT
+ * - UID SORT
+ */
+module.exports = function (server) {
+    if (server.sortKeys) {
+        // already loaded, e.g. by the SORT=DISPLAY plugin
+        return;
+    }
+
+    server.registerCapability('SORT');
+
+    // RFC 5256 section 3: sort keys and the value of a message for each. A value is a number or the
+    // collation key of a string, see sorting.collationKey. SORT=DISPLAY adds its keys here
+    server.sortKeys = {
+        ARRIVAL: message => arrivalTime(message),
+        CC: message => collationKey(addressMailbox(message, 'cc')),
+        DATE: message => sentTime(message),
+        FROM: message => collationKey(addressMailbox(message, 'from')),
+        SIZE: message => getMessageData(message).raw.length,
+        SUBJECT: message => collationKey(baseSubject(getMessageData(message).tree.parsedHeader.subject).subject),
+        TO: message => collationKey(addressMailbox(message, 'to'))
+    };
+
+    const compareValues = (a, b) => (Buffer.isBuffer(a) ? Buffer.compare(a, b) : a - b);
+
+    /**
+     * Returns a comparator of messages for parsed sort criteria: ascending order, REVERSE turns one
+     * criterion around, and mailbox order (the sequence number) breaks ties (RFC 5256 section 3).
+     * Every value is computed once per message. Plugins (ESORT, CONTEXT=SORT) use it to sort again later
+     *
+     * @param {Array} criteria List of `{ key, reverse }`
+     * @return {Function} comparator for two messages of the same mailbox
+     */
+    server.sortComparator = criteria => {
+        const cache = new WeakMap();
+        const getValues = message => {
+            if (!cache.has(message)) {
+                cache.set(
+                    message,
+                    criteria.map(criterion => server.sortKeys[criterion.key](message))
+                );
+            }
+            return cache.get(message);
+        };
+        return (a, b) => {
+            const aValues = getValues(a);
+            const bValues = getValues(b);
+            for (let i = 0; i < criteria.length; i++) {
+                const diff = compareValues(aValues[i], bValues[i]);
+                if (diff) {
+                    return criteria[i].reverse ? -diff : diff;
+                }
+            }
+            // messages are kept in UID order, so this is the order of sequence numbers
+            return a.uid - b.uid;
+        };
+    };
+
+    const sortHandler = (isUid, connection, parsed, data, callback) => {
+        const command = isUid ? 'UID SORT' : 'SORT';
+        const attributes = parsed.attributes || [];
+
+        const fail = text => {
+            connection.sendStatus(parsed, data, 'BAD', text, false, command + ' FAILED');
+            return callback();
+        };
+
+        // RFC 5256 section 5: sort-criteria = "(" sort-criterion *(SP sort-criterion) ")",
+        // sort-criterion = ["REVERSE" SP] sort-key
+        if (!Array.isArray(attributes[0]) || !attributes[0].length) {
+            return fail(command + ' expects a list of sort criteria');
+        }
+        const criteria = [];
+        let reverse = false;
+        for (const item of attributes[0]) {
+            const key = item && item.type === 'ATOM' ? item.value.toUpperCase() : '';
+            if (key === 'REVERSE' && !reverse) {
+                reverse = true;
+                continue;
+            }
+            if (!Object.hasOwn(server.sortKeys, key)) {
+                return fail('Invalid sort criterion ' + (item && typeof item.value === 'string' ? item.value : ''));
+            }
+            criteria.push({ key, reverse });
+            reverse = false;
+        }
+        if (reverse) {
+            return fail('REVERSE must be followed by a sort key');
+        }
+
+        const result = searchMessages(connection, parsed, data, attributes.slice(1));
+        if (!result) {
+            return callback();
+        }
+
+        const compare = server.sortComparator(criteria);
+        const sorted = result.list.slice().sort(compare);
+
+        connection.send(
+            {
+                tag: '*',
+                command: 'SORT',
+                attributes: sorted.map(message => (isUid ? message.uid : result.numbers[message.uid]))
+            },
+            command,
+            parsed,
+            data,
+            // the search result, for CONDSTORE to append the highest mod-sequence (RFC 7162 section 3.1.9), with the
+            // sorted messages and the comparator for ESORT and CONTEXT=SORT
+            Object.assign(result, { sorted, compare })
+        );
+        connection.sendStatus(parsed, data, 'OK', command + ' completed', false, command);
+        return callback();
+    };
+
+    // RFC 5256 section 3: EXPUNGE responses are not permitted while responding to SORT, but are during UID SORT.
+    // The search criteria start after the sort criteria and the charset
+    server.setCommandHandler('SORT', sortHandler.bind(null, false), { states: states.SELECTED, searchCriteria: 2, noExpunge: true });
+    server.setCommandHandler('UID SORT', sortHandler.bind(null, true), { states: states.SELECTED, searchCriteria: 2 });
+};

package/lib/plugins/special-use.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const { getListExtensions } = require('../list-extensions');
+
+/**
+ * @help Enables SPECIAL-USE [RFC6154] capability
+ * @help Mailboxes need to have a "special-use"
+ * @help property (String or Array) that will be used
+ * @help as extra flag for LIST and LSUB responses.
+ * @help With LIST-EXTENDED the SPECIAL-USE selection and
+ * @help return options work with the other LIST options
+ */
+
+module.exports = function (server) {
+    // Register capability
+    server.registerCapability('SPECIAL-USE');
+
+    const getSpecialUse = folder => [].concat((folder && folder['special-use']) || []);
+
+    // RFC 6154 section 2: with LIST-EXTENDED, SPECIAL-USE is a list-select-independent-opt that
+    // implies the SPECIAL-USE return option. The LIST-EXTENDED plugin may be loaded before or after this one
+    const listExtensions = getListExtensions(server);
+    listExtensions.selectionOptions['SPECIAL-USE'] = {
+        type: 'independent',
+        returnOption: 'SPECIAL-USE',
+        match: folder => folder.flags.indexOf('\\Noselect') < 0 && getSpecialUse(folder).length > 0
+    };
+    // special-use attributes are always included, so the return option needs no extra handling
+    listExtensions.returnOptions['SPECIAL-USE'] = {};
+
+    const listHandler = server.getCommandHandler('LIST');
+
+    server.setCommandHandler('LIST', (connection, parsed, data, callback) => {
+        if (listExtensions.enabled) {
+            // LIST-EXTENDED handles the options
+            return listHandler(connection, parsed, data, callback);
+        }
+
+        // without LIST-EXTENDED only the SPECIAL-USE options are understood
+        let i;
+        if (parsed.attributes && Array.isArray(parsed.attributes[0])) {
+            for (i = parsed.attributes[0].length - 1; i >= 0; i--) {
+                if (parsed.attributes[0][i] && parsed.attributes[0][i].type === 'ATOM' && parsed.attributes[0][i].value.toUpperCase() === 'SPECIAL-USE') {
+                    parsed.attributes[0].splice(i, 1);
+                    parsed.listSpecialUseOnly = true;
+                }
+            }
+            // remove parameter if no other memebers were left
+            if (!parsed.attributes[0].length) {
+                parsed.attributes.splice(0, 1);
+            }
+        }
+
+        if (
+            parsed.attributes &&
+            parsed.attributes[2] &&
+            parsed.attributes[2].type === 'ATOM' &&
+            parsed.attributes[2].value.toUpperCase() === 'RETURN' &&
+            Array.isArray(parsed.attributes[3])
+        ) {
+            for (i = parsed.attributes[3].length - 1; i >= 0; i--) {
+                if (parsed.attributes[3][i] && parsed.attributes[3][i].type === 'ATOM' && parsed.attributes[3][i].value.toUpperCase() === 'SPECIAL-USE') {
+                    // special-use attributes are always included, so the return option needs no extra handling
+                    parsed.attributes[3].splice(i, 1);
+                }
+            }
+
+            // Remove RETURN (List) if no members were left
+            if (!parsed.attributes[3].length) {
+                parsed.attributes.splice(2, 2);
+            }
+        }
+
+        listHandler(connection, parsed, data, callback);
+    });
+
+    server.outputHandlers.push((connection, response, description, parsed, data, folder) => {
+        const specialUseList = getSpecialUse(folder).map(specialUse => {
+            return {
+                type: 'ATOM',
+                value: specialUse
+            };
+        });
+
+        if ((description === 'LIST ITEM' || description === 'LSUB ITEM') && folder && response.attributes && Array.isArray(response.attributes[0])) {
+            if (specialUseList.length) {
+                // special-use attributes are added to the other mailbox attributes, also with RETURN (SPECIAL-USE)
+                response.attributes[0] = response.attributes[0].concat(specialUseList);
+            } else if (parsed.listSpecialUseOnly) {
+                // Do not show this response
+                response.skipResponse = true;
+            }
+        }
+    });
+};

package/lib/plugins/starttls.js

@@ -0,0 +1,57 @@
+'use strict';
+
+/**
+ * @help Adds STARTTLS command
+ */
+
+module.exports = function (server) {
+    // Register capability, usable with unsecure connection
+    server.registerCapability('STARTTLS', connection => {
+        return !connection.secureConnection;
+    });
+
+    // Add STARTTLS command
+    server.setCommandHandler('STARTTLS', (connection, parsed, data, callback) => {
+        // only works in insecure setting
+        if (connection.secureConnection) {
+            return sendError('Connection is already secured', connection, parsed, data, callback);
+        }
+
+        connection.send(
+            {
+                tag: parsed.tag,
+                command: 'OK',
+                attributes: [
+                    {
+                        type: 'TEXT',
+                        value: 'Server ready to start TLS negotiation'
+                    }
+                ]
+            },
+            'STARTTLS INIT',
+            parsed,
+            data
+        );
+
+        connection.upgradeConnection(callback);
+    });
+};
+
+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/status-size.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const fetchHandlers = require('../commands/handlers/fetch');
+
+/**
+ * @help Adds STATUS=SIZE [RFC8438] capability. The SIZE status item
+ * @help is the sum of the RFC822.SIZE values of the messages, it can
+ * @help also be used with LIST-STATUS
+ */
+
+module.exports = function (server) {
+    server.registerCapability('STATUS=SIZE');
+
+    server.allowedStatus.push('SIZE');
+
+    // RFC 8438 section 3: at least the sum of the RFC822.SIZE values of all messages in the mailbox
+    server.statusHandlers.SIZE = (connection, mailbox) =>
+        mailbox.messages.reduce((size, message) => size + fetchHandlers['RFC822.SIZE'](connection, message), 0);
+};

package/lib/plugins/thread-orderedsubject.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { addThreadAlgorithm } = require('../threading');
+
+/**
+ * @help Adds THREAD=ORDEREDSUBJECT [RFC5256] capability
+ *
+ * THREAD: https://tools.ietf.org/html/rfc5256
+ *
+ * Additional commands:
+ * - THREAD ORDEREDSUBJECT
+ * - UID THREAD ORDEREDSUBJECT
+ */
+module.exports = function (server) {
+    addThreadAlgorithm(server, 'ORDEREDSUBJECT');
+};

package/lib/plugins/thread-references.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { addThreadAlgorithm } = require('../threading');
+
+/**
+ * @help Adds THREAD=REFERENCES [RFC5256] capability
+ *
+ * THREAD: https://tools.ietf.org/html/rfc5256
+ *
+ * Additional commands:
+ * - THREAD REFERENCES
+ * - UID THREAD REFERENCES
+ */
+module.exports = function (server) {
+    addThreadAlgorithm(server, 'REFERENCES');
+};

package/lib/plugins/uidonly.js

@@ -0,0 +1,135 @@
+'use strict';
+
+const { toVanished } = require('../vanished');
+const { isAtom } = require('../arguments');
+const { registerEnable, isEnabled } = require('./enable');
+
+/**
+ * @help Adds UIDONLY [RFC9586] capability, loads ENABLE as well
+ * @help After ENABLE UIDONLY: FETCH, STORE, SEARCH, COPY, MOVE, SORT, THREAD, REPLACE and
+ * @help message numbers in UID SEARCH (SORT, THREAD) criteria are refused with BAD [UIDREQUIRED],
+ * @help UIDFETCH responses replace FETCH responses and VANISHED replaces EXPUNGE.
+ * @help Load UIDPLUS for COPYUID and UID EXPUNGE
+ *
+ * UIDONLY: https://www.rfc-editor.org/rfc/rfc9586
+ */
+
+module.exports = function (server) {
+    server.registerCapability('UIDONLY');
+
+    registerEnable(server, 'UIDONLY');
+
+    // UNAUTHENTICATE clears the ENABLEd extensions (RFC 8437 section 4.1)
+    const isUidonly = connection => isEnabled(connection, 'UIDONLY');
+
+    const refuse = text => ({ command: 'BAD', code: 'UIDREQUIRED', text });
+
+    // RFC 9586 section 3: once UIDONLY is enabled, message numbers in any argument MUST be answered with a
+    // tagged BAD that has the UIDREQUIRED response code
+    const getRefusal = (connection, parsed) => {
+        const command = String(parsed.command || '').toUpperCase();
+        const options = server.getCommandOptions(command);
+        // the ESEARCH command of MULTISEARCH always returns UIDs (RFC 7377 section 2), like a UID command
+        const isUid = /^UID /.test(command) || command === 'ESEARCH';
+
+        // sections 3.2 and 3.8: FETCH, STORE, SEARCH, COPY, MOVE, SORT and THREAD are prohibited, also REPLACE
+        // (RFC 8508), its message argument is a sequence number. These have the sequenceSet or searchCriteria
+        // command option
+        if (!isUid && (options.sequenceSet !== false || options.searchCriteria !== false)) {
+            return refuse(command + ' is not allowed once UIDONLY is enabled, use UID ' + command);
+        }
+
+        // section 3.5: the <sequence set> search key is prohibited, also in UID SORT and UID THREAD
+        if (isUid && options.searchCriteria !== false && connection.usesSequenceNumbers(parsed)) {
+            return refuse('Message numbers are not allowed in the search criteria once UIDONLY is enabled, use UID <sequence set>');
+        }
+
+        // section 3.7: the fourth QRESYNC parameter (message sequence match data) MUST NOT be used
+        if ((command === 'SELECT' || command === 'EXAMINE') && Array.isArray(parsed.attributes && parsed.attributes[1])) {
+            const params = parsed.attributes[1];
+            const position = params.findIndex(param => isAtom(param, 'QRESYNC'));
+            const value = position >= 0 && params[position + 1];
+            if (Array.isArray(value) && value.slice(2).some(Array.isArray)) {
+                return refuse('QRESYNC message sequence match data is not allowed once UIDONLY is enabled');
+            }
+        }
+
+        return false;
+    };
+
+    server.commandChecks.push((connection, parsed) => isUidonly(connection) && getRefusal(connection, parsed));
+
+    // a prohibited command is refused before its literal is sent, before other checks that would answer NO
+    server.literalFilters.unshift((connection, command) => isUidonly(connection) && getRefusal(connection, { command }));
+
+    server.connectionHandlers.push(connection => {
+        // RFC 3501 section 5.5 is about commands with message numbers, these are all refused with
+        // BAD [UIDREQUIRED] once UIDONLY is enabled, as if they had waited
+        const isAmbiguous = connection.isAmbiguous;
+        connection.isAmbiguous = function (parsed) {
+            return !isUidonly(this) && isAmbiguous.call(this, parsed);
+        };
+
+        // RFC 9586 sections 3.4 and 3.6: expunges are announced with VANISHED instead of EXPUNGE, EXISTS and
+        // RECENT stay as they are
+        const prepareNotifications = connection.prepareNotifications;
+        connection.prepareNotifications = function (queue) {
+            queue = prepareNotifications.call(this, queue);
+            return isUidonly(this) ? toVanished(queue) : queue;
+        };
+    });
+
+    // RFC 9586 section 3: the server MUST NOT return message sequence numbers in any response
+    const outputHandler = (connection, response, description, parsed, data, extra) => {
+        if (!response || response.tag !== '*' || !Array.isArray(response.attributes) || !isUidonly(connection)) {
+            return;
+        }
+        const attributes = response.attributes;
+
+        // the UNSEEN response code of SELECT and EXAMINE is a message number (RFC 3501 section 7.1)
+        if (response.command === 'OK' && attributes[0] && attributes[0].type === 'SECTION' && isAtom(attributes[0].section[0], 'UNSEEN')) {
+            response.skipResponse = true;
+            return;
+        }
+
+        if (!isAtom(attributes[1], 'FETCH') || !Array.isArray(attributes[2])) {
+            return;
+        }
+
+        // section 3.3: uidfetch-resp = uniqueid SP "UIDFETCH" SP msg-att
+        // FETCH responses pass their message as `extra`, notifications like the MessageNew FETCH of NOTIFY carry it
+        const list = attributes[2];
+        const uidPos = list.findIndex((item, i) => !(i % 2) && isAtom(item, 'UID'));
+        const message = (extra && typeof extra.uid === 'number' && extra) || response.fetchedMessage;
+        const uid = message ? message.uid : uidPos >= 0 && list[uidPos + 1];
+        if (!uid) {
+            // never send a sequence number instead
+            response.skipResponse = true;
+            return;
+        }
+
+        // the UID data item is only included if the client asked for it, like in the examples of section 3.3
+        if (parsed && !('uidonlyKeepUid' in parsed)) {
+            parsed.uidonlyKeepUid = requestsUid(parsed);
+        }
+        let items = list;
+        if (uidPos >= 0 && list.length > 2 && !(parsed && parsed.uidonlyKeepUid)) {
+            items = list.slice(0, uidPos).concat(list.slice(uidPos + 2));
+        }
+        response.attributes = [uid, { type: 'ATOM', value: 'UIDFETCH' }, items];
+    };
+
+    // registered once every plugin is loaded, so that the other output handlers see the FETCH responses they
+    // know before these are turned into UIDFETCH responses
+    server.once('pluginsLoaded', () => server.outputHandlers.push(outputHandler));
+};
+
+// Checks if a UID FETCH command lists the UID data item
+function requestsUid(parsed) {
+    if (String(parsed.command || '').toUpperCase() !== 'UID FETCH' || !parsed.attributes) {
+        return false;
+    }
+    return [].concat(parsed.attributes[1] || []).some(item => isAtom(item, 'UID'));
+}
+
+module.exports.requires = ['ENABLE'];

package/lib/plugins/uidplus.js

@@ -0,0 +1,124 @@
+'use strict';
+
+const { toSequenceSet } = require('../esearch');
+
+/**
+ * @help Adds UIDPLUS [RFC4315] capability
+ *
+ * UIDPLUS: http://tools.ietf.org/html/rfc4315
+ *
+ * Additional commands:
+ * - UID EXPUNGE
+ *
+ * Additional response codes:
+ * - APPENDUID (with a UID set for MULTIAPPEND, and in an untagged OK for REPLACE)
+ * - COPYUID
+ * - Not implemented: UIDNOTSTICKY
+ */
+module.exports = function (server) {
+    server.registerCapability('UIDPLUS');
+
+    server.setCommandHandler('UID EXPUNGE', (connection, parsed, data, callback) => {
+        if (!parsed.attributes || parsed.attributes.length !== 1 || !parsed.attributes[0] || ['ATOM', 'SEQUENCE'].indexOf(parsed.attributes[0].type) < 0) {
+            connection.send(
+                {
+                    tag: parsed.tag,
+                    command: 'BAD',
+                    attributes: [
+                        {
+                            type: 'TEXT',
+                            value: 'UID EXPUNGE expects uid sequence set'
+                        }
+                    ]
+                },
+                'INVALID COMMAND',
+                parsed,
+                data
+            );
+            return callback();
+        }
+
+        if (connection.refuseReadOnly(parsed, data, 'UID EXPUNGE FAILED')) {
+            return callback();
+        }
+
+        const sequence = parsed.attributes[0].value;
+        const range = connection.limitRange(parsed, connection.getMessageRange(sequence, true));
+        // Only messages with the \Deleted flag are removed (RFC 4315 section 2.1)
+        const rangeMessages = range.map(x => x[1]).filter(message => message.flags.indexOf('\\Deleted') >= 0);
+
+        connection.expungeSpecificMessages(connection.selectedMailbox, rangeMessages, false, true, !!parsed.highestFirst);
+
+        connection.send(
+            {
+                tag: parsed.tag,
+                command: 'OK',
+                attributes: [
+                    {
+                        type: 'TEXT',
+                        value: 'UID EXPUNGE completed'
+                    }
+                ]
+            },
+            'UID EXPUNGE',
+            parsed,
+            data
+        );
+        callback();
+    });
+
+    server.outputHandlers.push((connection, response, description, parsed, data, extra) => {
+        if (description === 'APPEND' || description === 'REPLACE APPENDUID') {
+            // OK [APPENDUID <target-mailbox-uidvalidity> <uid>] APPEND Completed. With MULTIAPPEND the
+            // second value is a UID set, but never for a single message (RFC 4315 section 3)
+            const uids = extra.messages.map(message => message.uid);
+            response.attributes = [
+                {
+                    type: 'SECTION',
+                    section: [
+                        {
+                            type: 'ATOM',
+                            value: 'APPENDUID'
+                        },
+                        extra.mailbox.uidvalidity,
+                        uids.length > 1 ? { type: 'SEQUENCE', value: toSequenceSet(uids) } : uids[0]
+                    ]
+                }
+            ].concat(response.attributes);
+            // REPLACE sends APPENDUID in an untagged OK before the EXPUNGE (RFC 8508 section 4.3)
+            response.skipResponse = false;
+            return;
+        }
+
+        if (description === 'COPY' || description === 'UID COPY' || description === 'MOVE COPYUID' || description === 'UID MOVE COPYUID') {
+            // Nothing was copied, an empty COPYUID would break the response grammar
+            if (!extra || !extra.sourceUids || !extra.sourceUids.length) {
+                return;
+            }
+            response.attributes = [
+                {
+                    type: 'SECTION',
+                    section: [
+                        {
+                            type: 'ATOM',
+                            value: 'COPYUID'
+                        },
+                        extra.mailbox.uidvalidity,
+                        // The range was interpreted in ascending order so these
+                        // values are already in the right order.
+                        {
+                            type: 'SEQUENCE',
+                            value: extra.sourceUids.join(',')
+                        },
+                        {
+                            type: 'SEQUENCE',
+                            value: extra.targetUids.join(',')
+                        }
+                    ]
+                }
+            ].concat(response.attributes);
+            response.skipResponse = false;
+            return;
+        }
+    });
+};

package/lib/plugins/unauthenticate.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const { states } = require('../command-states');
+
+/**
+ * @help Adds UNAUTHENTICATE [RFC8437] capability
+ * @help Returns to the Not Authenticated state, everything
+ * @help but TLS is reset (selected mailbox, ENABLE, COMPRESS)
+ */
+
+module.exports = function (server) {
+    server.registerCapability('UNAUTHENTICATE');
+
+    server.setCommandHandler(
+        'UNAUTHENTICATE',
+        (connection, parsed, data, callback) => {
+            // RFC 8437 section 3: a NO response is not permitted, the reset can not fail here
+            connection.sendStatus(parsed, data, 'OK', 'Completed, now in not authenticated state');
+
+            // RFC 8437 sections 3 and 4.1: the mailbox is closed without EXPUNGE responses, ENABLEd
+            // extensions and CONDSTORE are turned off, and compression ends after the CRLF of the OK
+            connection.resetSession();
+
+            return callback();
+        },
+        { states: states.AUTHENTICATED, noArguments: true }
+    );
+};

package/lib/plugins/unselect.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const { states } = require('../command-states');
+
+/**
+ * @help Adds UNSELECT [RFC3691] capability
+ */
+
+module.exports = function (server) {
+    server.registerCapability('UNSELECT');
+
+    server.setCommandHandler(
+        'UNSELECT',
+        (connection, parsed, data, callback) => {
+            connection.send(
+                {
+                    tag: parsed.tag,
+                    command: 'OK',
+                    attributes: [
+                        {
+                            type: 'TEXT',
+                            value: 'Mailbox closed'
+                        }
+                    ]
+                },
+                'CLOSE',
+                parsed,
+                data
+            );
+
+            connection.closeMailbox();
+            return callback();
+        },
+        { states: states.SELECTED, noArguments: true }
+    );
+};