imapkit 4.0.3 → 4.1.0

package/dist/cjs/plugins/index.js

@@ -0,0 +1,119 @@
+"use strict";
+// Built-in plugins by name (the file name without extension), see load-plugins.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugins = void 0;
+const acl_js_1 = __importDefault(require("./acl.js"));
+const appendlimit_js_1 = __importDefault(require("./appendlimit.js"));
+const auth_plain_js_1 = __importDefault(require("./auth-plain.js"));
+const binary_js_1 = __importDefault(require("./binary.js"));
+const catenate_js_1 = __importDefault(require("./catenate.js"));
+const compress_js_1 = __importDefault(require("./compress.js"));
+const condstore_js_1 = __importDefault(require("./condstore.js"));
+const context_search_js_1 = __importDefault(require("./context-search.js"));
+const context_sort_js_1 = __importDefault(require("./context-sort.js"));
+const create_special_use_js_1 = __importDefault(require("./create-special-use.js"));
+const enable_js_1 = __importDefault(require("./enable.js"));
+const esearch_js_1 = __importDefault(require("./esearch.js"));
+const esort_js_1 = __importDefault(require("./esort.js"));
+const id_js_1 = __importDefault(require("./id.js"));
+const idle_js_1 = __importDefault(require("./idle.js"));
+const imap4rev2_js_1 = __importDefault(require("./imap4rev2.js"));
+const list_extended_js_1 = __importDefault(require("./list-extended.js"));
+const list_status_js_1 = __importDefault(require("./list-status.js"));
+const literalminus_js_1 = __importDefault(require("./literalminus.js"));
+const literalplus_js_1 = __importDefault(require("./literalplus.js"));
+const logindisabled_js_1 = __importDefault(require("./logindisabled.js"));
+const messagelimit_js_1 = __importDefault(require("./messagelimit.js"));
+const metadata_js_1 = __importDefault(require("./metadata.js"));
+const metadata_server_js_1 = __importDefault(require("./metadata-server.js"));
+const move_js_1 = __importDefault(require("./move.js"));
+const multiappend_js_1 = __importDefault(require("./multiappend.js"));
+const multisearch_js_1 = __importDefault(require("./multisearch.js"));
+const namespace_js_1 = __importDefault(require("./namespace.js"));
+const notify_js_1 = __importDefault(require("./notify.js"));
+const oauthbearer_js_1 = __importDefault(require("./oauthbearer.js"));
+const objectid_js_1 = __importDefault(require("./objectid.js"));
+const partial_js_1 = __importDefault(require("./partial.js"));
+const preview_js_1 = __importDefault(require("./preview.js"));
+const qresync_js_1 = __importDefault(require("./qresync.js"));
+const quota_js_1 = __importDefault(require("./quota.js"));
+const replace_js_1 = __importDefault(require("./replace.js"));
+const sasl_ir_js_1 = __importDefault(require("./sasl-ir.js"));
+const savedate_js_1 = __importDefault(require("./savedate.js"));
+const savelimit_js_1 = __importDefault(require("./savelimit.js"));
+const searchres_js_1 = __importDefault(require("./searchres.js"));
+const sort_js_1 = __importDefault(require("./sort.js"));
+const sort_display_js_1 = __importDefault(require("./sort-display.js"));
+const special_use_js_1 = __importDefault(require("./special-use.js"));
+const starttls_js_1 = __importDefault(require("./starttls.js"));
+const status_size_js_1 = __importDefault(require("./status-size.js"));
+const thread_orderedsubject_js_1 = __importDefault(require("./thread-orderedsubject.js"));
+const thread_references_js_1 = __importDefault(require("./thread-references.js"));
+const uidonly_js_1 = __importDefault(require("./uidonly.js"));
+const uidplus_js_1 = __importDefault(require("./uidplus.js"));
+const unauthenticate_js_1 = __importDefault(require("./unauthenticate.js"));
+const unselect_js_1 = __importDefault(require("./unselect.js"));
+const utf8_accept_js_1 = __importDefault(require("./utf8-accept.js"));
+const x_gm_ext_1_js_1 = __importDefault(require("./x-gm-ext-1.js"));
+const xoauth2_js_1 = __importDefault(require("./xoauth2.js"));
+const xtoybird_js_1 = __importDefault(require("./xtoybird.js"));
+exports.plugins = {
+    acl: acl_js_1.default,
+    appendlimit: appendlimit_js_1.default,
+    'auth-plain': auth_plain_js_1.default,
+    binary: binary_js_1.default,
+    catenate: catenate_js_1.default,
+    compress: compress_js_1.default,
+    condstore: condstore_js_1.default,
+    'context-search': context_search_js_1.default,
+    'context-sort': context_sort_js_1.default,
+    'create-special-use': create_special_use_js_1.default,
+    enable: enable_js_1.default,
+    esearch: esearch_js_1.default,
+    esort: esort_js_1.default,
+    id: id_js_1.default,
+    idle: idle_js_1.default,
+    imap4rev2: imap4rev2_js_1.default,
+    'list-extended': list_extended_js_1.default,
+    'list-status': list_status_js_1.default,
+    literalminus: literalminus_js_1.default,
+    literalplus: literalplus_js_1.default,
+    logindisabled: logindisabled_js_1.default,
+    messagelimit: messagelimit_js_1.default,
+    metadata: metadata_js_1.default,
+    'metadata-server': metadata_server_js_1.default,
+    move: move_js_1.default,
+    multiappend: multiappend_js_1.default,
+    multisearch: multisearch_js_1.default,
+    namespace: namespace_js_1.default,
+    notify: notify_js_1.default,
+    oauthbearer: oauthbearer_js_1.default,
+    objectid: objectid_js_1.default,
+    partial: partial_js_1.default,
+    preview: preview_js_1.default,
+    qresync: qresync_js_1.default,
+    quota: quota_js_1.default,
+    replace: replace_js_1.default,
+    'sasl-ir': sasl_ir_js_1.default,
+    savedate: savedate_js_1.default,
+    savelimit: savelimit_js_1.default,
+    searchres: searchres_js_1.default,
+    sort: sort_js_1.default,
+    'sort-display': sort_display_js_1.default,
+    'special-use': special_use_js_1.default,
+    starttls: starttls_js_1.default,
+    'status-size': status_size_js_1.default,
+    'thread-orderedsubject': thread_orderedsubject_js_1.default,
+    'thread-references': thread_references_js_1.default,
+    uidonly: uidonly_js_1.default,
+    uidplus: uidplus_js_1.default,
+    unauthenticate: unauthenticate_js_1.default,
+    unselect: unselect_js_1.default,
+    'utf8-accept': utf8_accept_js_1.default,
+    'x-gm-ext-1': x_gm_ext_1_js_1.default,
+    xoauth2: xoauth2_js_1.default,
+    xtoybird: xtoybird_js_1.default
+};

package/dist/cjs/plugins/list-extended.d.ts

@@ -0,0 +1,2 @@
+import type { IMAPServer } from '../types.js';
+export default function listExtendedPlugin(server: IMAPServer): void;

package/dist/cjs/plugins/list-extended.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = listExtendedPlugin;
+const node_util_1 = require("node:util");
+const list_extensions_js_1 = require("../list-extensions.js");
+/**
+ * @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 arguments_js_1 = require("../arguments.js");
+/**
+ * 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;
+function listExtendedPlugin(server) {
+    const extensions = (0, list_extensions_js_1.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();
+            // only return options take a value (parse)
+            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) && !(0, node_util_1.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 (!(0, arguments_js_1.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(arguments_js_1.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
+        // the match functions also get the subscribed names that are not mailboxes
+        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();
+    });
+}
+{
+    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/list-status.d.ts

@@ -0,0 +1,6 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @help Adds LIST-STATUS [RFC5819] capability, the STATUS return option
+ * @help of LIST. Loads LIST-EXTENDED as well
+ */
+export default function listStatusPlugin(server: IMAPServer): void;

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

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = listStatusPlugin;
+const list_extensions_js_1 = require("../list-extensions.js");
+const status_js_1 = require("../commands/handlers/status.js");
+const list_extended_js_1 = __importDefault(require("./list-extended.js"));
+/**
+ * @help Adds LIST-STATUS [RFC5819] capability, the STATUS return option
+ * @help of LIST. Loads LIST-EXTENDED as well
+ */
+function listStatusPlugin(server) {
+    // the STATUS return option needs the extended LIST syntax (RFC 5819 section 4)
+    (0, list_extended_js_1.default)(server);
+    server.registerCapability('LIST-STATUS');
+    // status-option = "STATUS" SP "(" status-att *(SP status-att) ")"
+    (0, list_extensions_js_1.getListExtensions)(server).returnOptions.STATUS = {
+        parse: (list, connection) => (0, status_js_1.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) {
+                (0, status_js_1.sendStatus)(connection, folder.path, folder, items, parsed, data);
+            }
+        }
+    };
+}
+{
+    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/literalminus.d.ts

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

package/dist/cjs/plugins/literalminus.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = literalminusPlugin;
+/**
+ * @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+
+ */
+function literalminusPlugin(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;
+}
+{
+    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/literalplus.d.ts

@@ -0,0 +1,6 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @help Enables LITERAL+ [RFC7888] capability
+ * @help Can not be loaded with LITERAL-
+ */
+export default function literalplusPlugin(server: IMAPServer): void;

package/dist/cjs/plugins/literalplus.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = literalplusPlugin;
+/**
+ * @help Enables LITERAL+ [RFC7888] capability
+ * @help Can not be loaded with LITERAL-
+ */
+function literalplusPlugin(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;
+}
+{
+    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/logindisabled.d.ts

@@ -0,0 +1,5 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @help Disables LOGIN support for unencrypted connections
+ */
+export default function logindisabledPlugin(server: IMAPServer): void;

package/dist/cjs/plugins/logindisabled.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = logindisabledPlugin;
+/**
+ * @help Disables LOGIN support for unencrypted connections
+ */
+function logindisabledPlugin(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);
+    });
+}
+{
+    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/messagelimit.d.ts

@@ -0,0 +1,19 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * Reads the limit from the "messageLimit" server option
+ *
+ * @param {Object} server IMAPServer
+ * @param {String} name Capability name for the error message
+ * @return {Number} limit
+ */
+declare function getLimit(server: IMAPServer, name: string): any;
+/**
+ * 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
+ */
+declare function addSaveLimit(server: IMAPServer, limit: number): void;
+export default function messagelimitPlugin(server: IMAPServer): void;
+export { getLimit, addSaveLimit };