imapkit 4.0.2 → 4.1.0

package/dist/cjs/commands/handlers/status.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStatusItems = parseStatusItems;
+exports.sendStatus = sendStatus;
+exports.statusResponse = statusResponse;
+/**
+ * STATUS data items, shared by the STATUS command and the STATUS return option of LIST (LIST-STATUS,
+ * RFC 5819). A STATUS item can only be requested when it is listed in `server.allowedStatus`.
+ * Plugins add their items to `server.statusHandlers` (consulted before the built-in items) and to
+ * `server.allowedStatus`.
+ */
+const statusHandlers = {
+    MESSAGES: (connection, mailbox) => mailbox.messages.length,
+    RECENT: (connection, mailbox, status) => status.recent,
+    UIDNEXT: (connection, mailbox) => mailbox.uidnext,
+    UIDVALIDITY: (connection, mailbox) => mailbox.uidvalidity,
+    UNSEEN: (connection, mailbox, status) => status.unseen || 0,
+    // RFC 9051 section 6.3.11. Not in RFC 3501, QUOTA lists it in allowedStatus, IMAP4rev2 allows it per session
+    DELETED: (connection, mailbox, status) => status.flags['\\Deleted'] || 0
+};
+// RFC 3501 section 9 atom = 1*ATOM-CHAR
+/**
+ * Validates a list of STATUS data item names (RFC 3501 section 9, "(" status-att *(SP status-att) ")")
+ *
+ * @param {Object} server IMAPServer instance
+ * @param {Array} list Parsed list of status items
+ * @param {Object} [connection] IMAP connection, its `disabledStatusItems` set lists items the session can not use,
+ *   `addedStatusItems` the items only this session can use (DELETED after ENABLE IMAP4rev2)
+ * @return {Array} upper case item names
+ * @throws {Error} if the list is empty or has an invalid item, the message is for the BAD response
+ */
+function parseStatusItems(server, list, connection) {
+    if (!Array.isArray(list) || !list.length) {
+        throw new Error('Expecting a list of status items');
+    }
+    const disabled = connection && connection.disabledStatusItems;
+    const added = connection && connection.addedStatusItems;
+    return list.map((item, i) => {
+        const name = item && item.type === 'ATOM' && item.value.toUpperCase();
+        if (!name || (server.allowedStatus.indexOf(name) < 0 && !(added && added.has(name))) || (disabled && disabled.has(name))) {
+            throw new Error('Invalid status element (' + (i + 1) + ')');
+        }
+        return name;
+    });
+}
+/**
+ * Sends an untagged STATUS response
+ *
+ * @param {Object} connection IMAPConnection instance
+ * @param {String} path Storage name of the mailbox
+ * @param {Object} mailbox Mailbox object
+ * @param {Array} items Upper case item names from parseStatusItems
+ * @param {Object} parsed Parsed command
+ * @param {Object} data Command data
+ */
+function sendStatus(connection, path, mailbox, items, parsed, data) {
+    connection.send(statusResponse(connection, path, mailbox, items), 'STATUS', parsed, data);
+}
+/**
+ * Builds an untagged STATUS response
+ *
+ * @param {Object} connection IMAPConnection instance
+ * @param {String} path Storage name of the mailbox
+ * @param {Object} mailbox Mailbox object
+ * @param {Array} items Upper case item names
+ * @return {Object} STATUS response
+ */
+function statusResponse(connection, path, mailbox, items) {
+    const server = connection.server;
+    const status = server.getStatus(mailbox);
+    const list = [];
+    items.forEach(item => {
+        list.push({ type: 'ATOM', value: item }, (server.statusHandlers[item] || statusHandlers[item])(connection, mailbox, status));
+    });
+    return {
+        tag: '*',
+        command: 'STATUS',
+        // the mailbox name is converted for the session in IMAPConnection#send
+        attributes: [{ type: 'MAILBOX', value: path }, list]
+    };
+}

package/dist/cjs/commands/handlers/store.d.ts

@@ -0,0 +1,3 @@
+import type { StoreHandler } from '../../types.js';
+declare const storeHandlers: Record<string, StoreHandler>;
+export default storeHandlers;

package/dist/cjs/commands/handlers/store.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const flags_js_1 = require("./flags.js");
+const storeHandlers = {};
+exports.default = storeHandlers;
+function setFlags(connection, message, flags) {
+    // STORE runs in the Selected state
+    const mailbox = connection.selectedMailbox;
+    const messageFlags = [];
+    [].concat(flags).forEach(flag => {
+        flag = (0, flags_js_1.normalizeSystemFlag)(typeof flag === 'string' ? flag : String(flag.value || ''));
+        (0, flags_js_1.checkSystemFlags)(connection, flag);
+        // Ignore if it is not in allowed list and only permament flags are allowed to use
+        if (mailbox.permanentFlags.indexOf(flag) < 0 && !mailbox.allowPermanentFlags) {
+            return;
+        }
+        if (messageFlags.indexOf(flag) < 0) {
+            messageFlags.push(flag);
+        }
+    });
+    message.flags = messageFlags;
+    connection.server.rememberFlags(mailbox, messageFlags);
+}
+function addFlags(connection, message, flags) {
+    const mailbox = connection.selectedMailbox;
+    [].concat(flags).forEach(flag => {
+        flag = (0, flags_js_1.normalizeSystemFlag)(typeof flag === 'string' ? flag : String(flag.value || ''));
+        (0, flags_js_1.checkSystemFlags)(connection, flag);
+        // Ignore if it is not in allowed list and only permament flags are allowed to use
+        if (mailbox.permanentFlags.indexOf(flag) < 0 && !mailbox.allowPermanentFlags) {
+            return;
+        }
+        if (message.flags.indexOf(flag) < 0) {
+            message.flags.push(flag);
+        }
+    });
+    connection.server.rememberFlags(mailbox, message.flags);
+}
+function removeFlags(connection, message, flags) {
+    [].concat(flags).forEach(flag => {
+        flag = (0, flags_js_1.normalizeSystemFlag)(typeof flag === 'string' ? flag : String(flag.value || ''));
+        (0, flags_js_1.checkSystemFlags)(connection, flag);
+        if (message.flags.indexOf(flag) >= 0) {
+            for (let i = 0; i < message.flags.length; i++) {
+                if (message.flags[i] === flag) {
+                    message.flags.splice(i, 1);
+                    break;
+                }
+            }
+        }
+    });
+}
+function sendUpdate(connection, parsed, data, index, message) {
+    const resp = [
+        {
+            type: 'ATOM',
+            value: 'FLAGS'
+        },
+        connection.getFlags(message).map(flag => {
+            return {
+                type: 'ATOM',
+                value: flag
+            };
+        })
+    ];
+    if ((parsed.command || '').toUpperCase() === 'UID STORE') {
+        resp.push({
+            type: 'ATOM',
+            value: 'UID'
+        });
+        resp.push(message.uid);
+    }
+    connection.send({
+        tag: '*',
+        attributes: [
+            index,
+            {
+                type: 'ATOM',
+                value: 'FETCH'
+            },
+            resp
+        ]
+    }, 'FLAG UPDATE', parsed, data, message);
+}
+storeHandlers.FLAGS = function (connection, message, flags, index, parsed, data) {
+    setFlags(connection, message, flags);
+    sendUpdate(connection, parsed, data, index, message);
+};
+storeHandlers['+FLAGS'] = function (connection, message, flags, index, parsed, data) {
+    addFlags(connection, message, flags);
+    sendUpdate(connection, parsed, data, index, message);
+};
+storeHandlers['-FLAGS'] = function (connection, message, flags, index, parsed, data) {
+    removeFlags(connection, message, flags);
+    sendUpdate(connection, parsed, data, index, message);
+};
+storeHandlers['FLAGS.SILENT'] = function (connection, message, flags) {
+    setFlags(connection, message, flags);
+};
+storeHandlers['+FLAGS.SILENT'] = function (connection, message, flags) {
+    addFlags(connection, message, flags);
+};
+storeHandlers['-FLAGS.SILENT'] = function (connection, message, flags) {
+    removeFlags(connection, message, flags);
+};
+{
+    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/commands/index.d.ts

@@ -0,0 +1,2 @@
+import type { CommandHandler } from '../types.js';
+export declare const commands: Record<string, CommandHandler>;

package/dist/cjs/commands/index.js

@@ -0,0 +1,61 @@
+"use strict";
+// Built-in command handlers by command name
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commands = void 0;
+const append_js_1 = __importDefault(require("./append.js"));
+const capability_js_1 = __importDefault(require("./capability.js"));
+const check_js_1 = __importDefault(require("./check.js"));
+const close_js_1 = __importDefault(require("./close.js"));
+const copy_js_1 = __importDefault(require("./copy.js"));
+const create_js_1 = __importDefault(require("./create.js"));
+const delete_js_1 = __importDefault(require("./delete.js"));
+const examine_js_1 = __importDefault(require("./examine.js"));
+const expunge_js_1 = __importDefault(require("./expunge.js"));
+const fetch_js_1 = __importDefault(require("./fetch.js"));
+const list_js_1 = __importDefault(require("./list.js"));
+const login_js_1 = __importDefault(require("./login.js"));
+const logout_js_1 = __importDefault(require("./logout.js"));
+const lsub_js_1 = __importDefault(require("./lsub.js"));
+const noop_js_1 = __importDefault(require("./noop.js"));
+const rename_js_1 = __importDefault(require("./rename.js"));
+const search_js_1 = __importDefault(require("./search.js"));
+const select_js_1 = __importDefault(require("./select.js"));
+const status_js_1 = __importDefault(require("./status.js"));
+const store_js_1 = __importDefault(require("./store.js"));
+const subscribe_js_1 = __importDefault(require("./subscribe.js"));
+const uid_copy_js_1 = __importDefault(require("./uid-copy.js"));
+const uid_fetch_js_1 = __importDefault(require("./uid-fetch.js"));
+const uid_search_js_1 = __importDefault(require("./uid-search.js"));
+const uid_store_js_1 = __importDefault(require("./uid-store.js"));
+const unsubscribe_js_1 = __importDefault(require("./unsubscribe.js"));
+exports.commands = {
+    APPEND: append_js_1.default,
+    CAPABILITY: capability_js_1.default,
+    CHECK: check_js_1.default,
+    CLOSE: close_js_1.default,
+    COPY: copy_js_1.default,
+    CREATE: create_js_1.default,
+    DELETE: delete_js_1.default,
+    EXAMINE: examine_js_1.default,
+    EXPUNGE: expunge_js_1.default,
+    FETCH: fetch_js_1.default,
+    LIST: list_js_1.default,
+    LOGIN: login_js_1.default,
+    LOGOUT: logout_js_1.default,
+    LSUB: lsub_js_1.default,
+    NOOP: noop_js_1.default,
+    RENAME: rename_js_1.default,
+    SEARCH: search_js_1.default,
+    SELECT: select_js_1.default,
+    STATUS: status_js_1.default,
+    STORE: store_js_1.default,
+    SUBSCRIBE: subscribe_js_1.default,
+    'UID COPY': uid_copy_js_1.default,
+    'UID FETCH': uid_fetch_js_1.default,
+    'UID SEARCH': uid_search_js_1.default,
+    'UID STORE': uid_store_js_1.default,
+    UNSUBSCRIBE: unsubscribe_js_1.default
+};

package/dist/cjs/commands/list.d.ts

@@ -0,0 +1,2 @@
+import type { Callback, IMAPConnection, ParsedCommand } from '../types.js';
+export default function listCommand(connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback): void;

package/dist/cjs/commands/list.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = listCommand;
+function listCommand(connection, parsed, data, callback) {
+    let folders;
+    if (!parsed.attributes ||
+        parsed.attributes.length !== 2 ||
+        !parsed.attributes[0] ||
+        ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0 ||
+        !parsed.attributes[1] ||
+        ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[1].type) < 0) {
+        connection.send({
+            tag: parsed.tag,
+            command: 'BAD',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'LIST expects 2 string arguments'
+                }
+            ]
+        }, 'INVALID COMMAND', parsed, data);
+        return callback();
+    }
+    if (!parsed.attributes[1].value) {
+        // empty reference lists separator only
+        const namespace = connection.server.storage[parsed.attributes[1].value || connection.server.referenceNamespace];
+        if (namespace) {
+            connection.send({
+                tag: '*',
+                command: 'LIST',
+                attributes: [
+                    [
+                        {
+                            type: 'ATOM',
+                            value: '\\Noselect'
+                        }
+                    ],
+                    namespace.separator,
+                    ''
+                ]
+            }, 'LIST ITEM', parsed, data);
+        }
+    }
+    else {
+        folders = connection.server.matchFolders(parsed.attributes[0].value, parsed.attributes[1].value, (path) => connection.exportMailboxName(path));
+        folders.forEach((folder) => {
+            connection.send({
+                tag: '*',
+                command: 'LIST',
+                attributes: [
+                    folder.flags.map((flag) => {
+                        return {
+                            type: 'ATOM',
+                            value: flag
+                        };
+                    }),
+                    connection.server.getSeparator(folder),
+                    connection.exportMailboxName(folder.path)
+                ]
+            }, 'LIST ITEM', parsed, data, folder);
+        });
+    }
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'Completed'
+            }
+        ]
+    }, 'LIST', 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/commands/login.d.ts

@@ -0,0 +1,2 @@
+import type { Callback, IMAPConnection, ParsedCommand } from '../types.js';
+export default function loginCommand(connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback): void;

package/dist/cjs/commands/login.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = loginCommand;
+function loginCommand(connection, parsed, data, callback) {
+    // LOGIN expects 2 string params - username and password
+    if (!parsed.attributes ||
+        parsed.attributes.length !== 2 ||
+        !parsed.attributes[0] ||
+        !parsed.attributes[1] ||
+        ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0 ||
+        ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[1].type) < 0) {
+        connection.send({
+            tag: parsed.tag,
+            command: 'BAD',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'LOGIN takes 2 string arguments'
+                }
+            ]
+        }, 'INVALID COMMAND', parsed, data);
+        return callback();
+    }
+    // User names are unicode strings everywhere (LOGIN, SASL, ACL identifiers). LOGIN does not take UTF-8
+    // user names or passwords, a client MUST use AUTHENTICATE for these (RFC 6855 and RFC 9755 section 5)
+    if (parsed.attributes.some(attr => /[\x80-\xff]/.test(attr.value))) {
+        connection.sendStatus(parsed, data, 'BAD', 'LOGIN does not take UTF-8 user names or passwords, use AUTHENTICATE (RFC 9755 section 5)');
+        return callback();
+    }
+    const user = connection.server.getUser(parsed.attributes[0].value);
+    if (!user || user.password !== parsed.attributes[1].value) {
+        // RFC 5530 section 3: unknown user or bad password
+        connection.sendStatus(parsed, data, 'NO', 'Login failed: authentication failure', 'AUTHENTICATIONFAILED', 'LOGIN FAILED');
+        return callback();
+    }
+    connection.state = 'Authenticated';
+    // the authenticated user, for plugins that tell users apart (e.g. ACL)
+    connection.username = parsed.attributes[0].value;
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'User logged in'
+            }
+        ]
+    }, 'LOGIN SUCCESS', 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/commands/logout.d.ts

@@ -0,0 +1,2 @@
+import type { Callback, IMAPConnection, ParsedCommand } from '../types.js';
+export default function logoutCommand(connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback): void;

package/dist/cjs/commands/logout.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = logoutCommand;
+function logoutCommand(connection, parsed, data, callback) {
+    connection.state = 'Logout';
+    connection.send({
+        tag: '*',
+        command: 'BYE',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'LOGOUT received'
+            }
+        ]
+    }, 'LOGOUT UNTAGGED', parsed, data);
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'Completed'
+            }
+        ]
+    }, 'LOGOUT COMPLETED', parsed, data);
+    connection.end();
+    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/commands/lsub.d.ts

@@ -0,0 +1,2 @@
+import type { Callback, IMAPConnection, ParsedCommand } from '../types.js';
+export default function lsubCommand(connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback): void;

package/dist/cjs/commands/lsub.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = lsubCommand;
+function lsubCommand(connection, parsed, data, callback) {
+    if (!parsed.attributes ||
+        parsed.attributes.length !== 2 ||
+        !parsed.attributes[0] ||
+        ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0 ||
+        !parsed.attributes[1] ||
+        ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[1].type) < 0) {
+        connection.send({
+            tag: parsed.tag,
+            command: 'BAD',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'LSUB expects 2 string arguments'
+                }
+            ]
+        }, 'INVALID COMMAND', parsed, data);
+        return callback();
+    }
+    const server = connection.server;
+    const match = parsed.attributes[1].value;
+    const folders = server.matchFolders(parsed.attributes[0].value, match, (path) => connection.exportMailboxName(path), server.getSubscriptionTree());
+    folders.forEach((folder) => {
+        let flags;
+        if (folder.subscribed) {
+            // the subscription list holds names, a subscribed name is listed even if the mailbox does not exist.
+            // \Noselect has a special meaning in LSUB (RFC 5258 section 3.1), so it is not listed for these
+            flags = folder.flags.filter((flag) => flag !== '\\Noselect');
+        }
+        else if (match.substr(-1) === '%') {
+            // RFC 3501 section 6.3.9: with "%" a level that is not subscribed but has subscribed names
+            // below it is listed with \Noselect
+            flags = ['\\Noselect'];
+        }
+        else {
+            return;
+        }
+        connection.send({
+            tag: '*',
+            command: 'LSUB',
+            attributes: [
+                flags.map((flag) => {
+                    return {
+                        type: 'ATOM',
+                        value: flag
+                    };
+                }),
+                server.getSeparator(folder),
+                connection.exportMailboxName(folder.path)
+            ]
+        }, 'LSUB ITEM', parsed, data, folder);
+    });
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'Completed'
+            }
+        ]
+    }, 'LSUB', 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/commands/noop.d.ts

@@ -0,0 +1,2 @@
+import type { Callback, IMAPConnection, ParsedCommand } from '../types.js';
+export default function noopCommand(connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback): void;

package/dist/cjs/commands/noop.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = noopCommand;
+function noopCommand(connection, parsed, data, callback) {
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'Completed'
+            }
+        ]
+    }, 'NOOP completed', 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/commands/rename.d.ts

@@ -0,0 +1,2 @@
+import type { Callback, IMAPConnection, ParsedCommand } from '../types.js';
+export default function renameCommand(connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback): void;