imapkit 4.0.3 → 4.1.1

package/dist/cjs/plugins/sort-display.d.ts

@@ -0,0 +1,11 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @help Adds SORT=DISPLAY [RFC5957] capability, also loads SORT
+ *
+ * SORT=DISPLAY: https://tools.ietf.org/html/rfc5957
+ *
+ * Additional sort keys for SORT and UID SORT:
+ * - DISPLAYFROM
+ * - DISPLAYTO
+ */
+export default function sortDisplayPlugin(server: IMAPServer): void;

package/dist/cjs/plugins/sort-display.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = sortDisplayPlugin;
+const sorting_js_1 = require("../sorting.js");
+const sort_js_1 = __importDefault(require("./sort.js"));
+/**
+ * @help Adds SORT=DISPLAY [RFC5957] capability, also loads SORT
+ *
+ * SORT=DISPLAY: https://tools.ietf.org/html/rfc5957
+ *
+ * Additional sort keys for SORT and UID SORT:
+ * - DISPLAYFROM
+ * - DISPLAYTO
+ */
+function sortDisplayPlugin(server) {
+    // RFC 5957 section 1: SORT=DISPLAY means the full SORT extension plus both sort keys
+    (0, sort_js_1.default)(server);
+    server.registerCapability('SORT=DISPLAY');
+    // RFC 5957 section 4: the DISPLAY sort value of the first address of env-from and env-to
+    server.sortKeys.DISPLAYFROM = (message) => (0, sorting_js_1.collationKey)((0, sorting_js_1.displayAddress)(message, 'from'));
+    server.sortKeys.DISPLAYTO = (message) => (0, sorting_js_1.collationKey)((0, sorting_js_1.displayAddress)(message, 'to'));
+}
+{
+    const defaultExport = exports.default;
+    if (defaultExport && (typeof defaultExport === 'function' || typeof defaultExport === 'object')) {
+        for (const key of Object.keys(exports)) {
+            if (key !== 'default' && !(key in defaultExport)) {
+                defaultExport[key] = exports[key];
+            }
+        }
+        Object.defineProperty(defaultExport, 'default', { value: defaultExport, enumerable: false, writable: true, configurable: true });
+        module.exports = defaultExport;
+    }
+}

package/dist/cjs/plugins/sort.d.ts

@@ -0,0 +1,11 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @help Adds SORT [RFC5256] capability
+ *
+ * SORT: https://tools.ietf.org/html/rfc5256
+ *
+ * Additional commands:
+ * - SORT
+ * - UID SORT
+ */
+export default function sortPlugin(server: IMAPServer): void;

package/dist/cjs/plugins/sort.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = sortPlugin;
+const command_states_js_1 = require("../command-states.js");
+const mimeparser_js_1 = require("../mimeparser.js");
+const sorting_js_1 = require("../sorting.js");
+/**
+ * @help Adds SORT [RFC5256] capability
+ *
+ * SORT: https://tools.ietf.org/html/rfc5256
+ *
+ * Additional commands:
+ * - SORT
+ * - UID SORT
+ */
+function sortPlugin(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) => (0, sorting_js_1.arrivalTime)(message),
+        CC: (message) => (0, sorting_js_1.collationKey)((0, sorting_js_1.addressMailbox)(message, 'cc')),
+        DATE: (message) => (0, sorting_js_1.sentTime)(message),
+        FROM: (message) => (0, sorting_js_1.collationKey)((0, sorting_js_1.addressMailbox)(message, 'from')),
+        SIZE: (message) => (0, mimeparser_js_1.getMessageData)(message).raw.length,
+        SUBJECT: (message) => (0, sorting_js_1.collationKey)((0, sorting_js_1.baseSubject)((0, mimeparser_js_1.getMessageData)(message).tree.parsedHeader.subject).subject),
+        TO: (message) => (0, sorting_js_1.collationKey)((0, sorting_js_1.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 = (0, sorting_js_1.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: command_states_js_1.states.SELECTED, searchCriteria: 2, noExpunge: true });
+    server.setCommandHandler('UID SORT', sortHandler.bind(null, true), { states: command_states_js_1.states.SELECTED, searchCriteria: 2 });
+}
+{
+    const defaultExport = exports.default;
+    if (defaultExport && (typeof defaultExport === 'function' || typeof defaultExport === 'object')) {
+        for (const key of Object.keys(exports)) {
+            if (key !== 'default' && !(key in defaultExport)) {
+                defaultExport[key] = exports[key];
+            }
+        }
+        Object.defineProperty(defaultExport, 'default', { value: defaultExport, enumerable: false, writable: true, configurable: true });
+        module.exports = defaultExport;
+    }
+}

package/dist/cjs/plugins/special-use.d.ts

@@ -0,0 +1,10 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @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
+ */
+export default function specialUsePlugin(server: IMAPServer): void;

package/dist/cjs/plugins/special-use.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = specialUsePlugin;
+const list_extensions_js_1 = require("../list-extensions.js");
+/**
+ * @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
+ */
+function specialUsePlugin(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 = (0, list_extensions_js_1.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;
+            }
+        }
+    });
+}
+{
+    const defaultExport = exports.default;
+    if (defaultExport && (typeof defaultExport === 'function' || typeof defaultExport === 'object')) {
+        for (const key of Object.keys(exports)) {
+            if (key !== 'default' && !(key in defaultExport)) {
+                defaultExport[key] = exports[key];
+            }
+        }
+        Object.defineProperty(defaultExport, 'default', { value: defaultExport, enumerable: false, writable: true, configurable: true });
+        module.exports = defaultExport;
+    }
+}

package/dist/cjs/plugins/starttls.d.ts

@@ -0,0 +1,5 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @help Adds STARTTLS command
+ */
+export default function starttlsPlugin(server: IMAPServer): void;

package/dist/cjs/plugins/starttls.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = starttlsPlugin;
+/**
+ * @help Adds STARTTLS command
+ */
+function starttlsPlugin(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();
+}
+{
+    const defaultExport = exports.default;
+    if (defaultExport && (typeof defaultExport === 'function' || typeof defaultExport === 'object')) {
+        for (const key of Object.keys(exports)) {
+            if (key !== 'default' && !(key in defaultExport)) {
+                defaultExport[key] = exports[key];
+            }
+        }
+        Object.defineProperty(defaultExport, 'default', { value: defaultExport, enumerable: false, writable: true, configurable: true });
+        module.exports = defaultExport;
+    }
+}

package/dist/cjs/plugins/status-size.d.ts

@@ -0,0 +1,7 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @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
+ */
+export default function statusSizePlugin(server: IMAPServer): void;

package/dist/cjs/plugins/status-size.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = statusSizePlugin;
+const fetch_js_1 = __importDefault(require("../commands/handlers/fetch.js"));
+/**
+ * @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
+ */
+function statusSizePlugin(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 + fetch_js_1.default['RFC822.SIZE'](connection, message), 0);
+}
+{
+    const defaultExport = exports.default;
+    if (defaultExport && (typeof defaultExport === 'function' || typeof defaultExport === 'object')) {
+        for (const key of Object.keys(exports)) {
+            if (key !== 'default' && !(key in defaultExport)) {
+                defaultExport[key] = exports[key];
+            }
+        }
+        Object.defineProperty(defaultExport, 'default', { value: defaultExport, enumerable: false, writable: true, configurable: true });
+        module.exports = defaultExport;
+    }
+}

package/dist/cjs/plugins/thread-orderedsubject.d.ts

@@ -0,0 +1,11 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @help Adds THREAD=ORDEREDSUBJECT [RFC5256] capability
+ *
+ * THREAD: https://tools.ietf.org/html/rfc5256
+ *
+ * Additional commands:
+ * - THREAD ORDEREDSUBJECT
+ * - UID THREAD ORDEREDSUBJECT
+ */
+export default function threadOrderedsubjectPlugin(server: IMAPServer): void;

package/dist/cjs/plugins/thread-orderedsubject.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = threadOrderedsubjectPlugin;
+const threading_js_1 = require("../threading.js");
+/**
+ * @help Adds THREAD=ORDEREDSUBJECT [RFC5256] capability
+ *
+ * THREAD: https://tools.ietf.org/html/rfc5256
+ *
+ * Additional commands:
+ * - THREAD ORDEREDSUBJECT
+ * - UID THREAD ORDEREDSUBJECT
+ */
+function threadOrderedsubjectPlugin(server) {
+    (0, threading_js_1.addThreadAlgorithm)(server, 'ORDEREDSUBJECT');
+}
+{
+    const defaultExport = exports.default;
+    if (defaultExport && (typeof defaultExport === 'function' || typeof defaultExport === 'object')) {
+        for (const key of Object.keys(exports)) {
+            if (key !== 'default' && !(key in defaultExport)) {
+                defaultExport[key] = exports[key];
+            }
+        }
+        Object.defineProperty(defaultExport, 'default', { value: defaultExport, enumerable: false, writable: true, configurable: true });
+        module.exports = defaultExport;
+    }
+}

package/dist/cjs/plugins/thread-references.d.ts

@@ -0,0 +1,11 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @help Adds THREAD=REFERENCES [RFC5256] capability
+ *
+ * THREAD: https://tools.ietf.org/html/rfc5256
+ *
+ * Additional commands:
+ * - THREAD REFERENCES
+ * - UID THREAD REFERENCES
+ */
+export default function threadReferencesPlugin(server: IMAPServer): void;

package/dist/cjs/plugins/thread-references.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = threadReferencesPlugin;
+const threading_js_1 = require("../threading.js");
+/**
+ * @help Adds THREAD=REFERENCES [RFC5256] capability
+ *
+ * THREAD: https://tools.ietf.org/html/rfc5256
+ *
+ * Additional commands:
+ * - THREAD REFERENCES
+ * - UID THREAD REFERENCES
+ */
+function threadReferencesPlugin(server) {
+    (0, threading_js_1.addThreadAlgorithm)(server, 'REFERENCES');
+}
+{
+    const defaultExport = exports.default;
+    if (defaultExport && (typeof defaultExport === 'function' || typeof defaultExport === 'object')) {
+        for (const key of Object.keys(exports)) {
+            if (key !== 'default' && !(key in defaultExport)) {
+                defaultExport[key] = exports[key];
+            }
+        }
+        Object.defineProperty(defaultExport, 'default', { value: defaultExport, enumerable: false, writable: true, configurable: true });
+        module.exports = defaultExport;
+    }
+}

package/dist/cjs/plugins/uidonly.d.ts

@@ -0,0 +1,15 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @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
+ */
+declare function uidonlyPlugin(server: IMAPServer): void;
+declare namespace uidonlyPlugin {
+    var requires: string[];
+}
+export default uidonlyPlugin;

package/dist/cjs/plugins/uidonly.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = uidonlyPlugin;
+const vanished_js_1 = require("../vanished.js");
+const arguments_js_1 = require("../arguments.js");
+const enable_js_1 = require("./enable.js");
+/**
+ * @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
+ */
+function uidonlyPlugin(server) {
+    server.registerCapability('UIDONLY');
+    (0, enable_js_1.registerEnable)(server, 'UIDONLY');
+    // UNAUTHENTICATE clears the ENABLEd extensions (RFC 8437 section 4.1)
+    const isUidonly = (connection) => (0, enable_js_1.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') && parsed.attributes && Array.isArray(parsed.attributes[1])) {
+            const params = parsed.attributes[1];
+            const position = params.findIndex((param) => (0, arguments_js_1.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) ? (0, vanished_js_1.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' && (0, arguments_js_1.isAtom)(attributes[0].section[0], 'UNSEEN')) {
+            response.skipResponse = true;
+            return;
+        }
+        if (!(0, arguments_js_1.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) && (0, arguments_js_1.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 => (0, arguments_js_1.isAtom)(item, 'UID'));
+}
+uidonlyPlugin.requires = ['ENABLE'];
+{
+    const defaultExport = exports.default;
+    if (defaultExport && (typeof defaultExport === 'function' || typeof defaultExport === 'object')) {
+        for (const key of Object.keys(exports)) {
+            if (key !== 'default' && !(key in defaultExport)) {
+                defaultExport[key] = exports[key];
+            }
+        }
+        Object.defineProperty(defaultExport, 'default', { value: defaultExport, enumerable: false, writable: true, configurable: true });
+        module.exports = defaultExport;
+    }
+}

package/dist/cjs/plugins/uidplus.d.ts

@@ -0,0 +1,15 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @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
+ */
+export default function uidplusPlugin(server: IMAPServer): void;