imapkit 4.0.3 → 4.1.1

package/dist/esm/commands/index.js

@@ -0,0 +1,55 @@
+// Built-in command handlers by command name
+import appendCommand from './append.js';
+import capabilityCommand from './capability.js';
+import checkCommand from './check.js';
+import closeCommand from './close.js';
+import copyCommand from './copy.js';
+import createCommand from './create.js';
+import deleteCommand from './delete.js';
+import examineCommand from './examine.js';
+import expungeCommand from './expunge.js';
+import fetchCommand from './fetch.js';
+import listCommand from './list.js';
+import loginCommand from './login.js';
+import logoutCommand from './logout.js';
+import lsubCommand from './lsub.js';
+import noopCommand from './noop.js';
+import renameCommand from './rename.js';
+import searchCommand from './search.js';
+import selectCommand from './select.js';
+import statusCommand from './status.js';
+import storeCommand from './store.js';
+import subscribeCommand from './subscribe.js';
+import uidCopyCommand from './uid-copy.js';
+import uidFetchCommand from './uid-fetch.js';
+import uidSearchCommand from './uid-search.js';
+import uidStoreCommand from './uid-store.js';
+import unsubscribeCommand from './unsubscribe.js';
+export const commands = {
+    APPEND: appendCommand,
+    CAPABILITY: capabilityCommand,
+    CHECK: checkCommand,
+    CLOSE: closeCommand,
+    COPY: copyCommand,
+    CREATE: createCommand,
+    DELETE: deleteCommand,
+    EXAMINE: examineCommand,
+    EXPUNGE: expungeCommand,
+    FETCH: fetchCommand,
+    LIST: listCommand,
+    LOGIN: loginCommand,
+    LOGOUT: logoutCommand,
+    LSUB: lsubCommand,
+    NOOP: noopCommand,
+    RENAME: renameCommand,
+    SEARCH: searchCommand,
+    SELECT: selectCommand,
+    STATUS: statusCommand,
+    STORE: storeCommand,
+    SUBSCRIBE: subscribeCommand,
+    'UID COPY': uidCopyCommand,
+    'UID FETCH': uidFetchCommand,
+    'UID SEARCH': uidSearchCommand,
+    'UID STORE': uidStoreCommand,
+    UNSUBSCRIBE: unsubscribeCommand
+};

package/dist/esm/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/esm/commands/list.js

@@ -0,0 +1,71 @@
+export default 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();
+}

package/dist/esm/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/{lib → dist/esm}/commands/login.js

@@ -1,67 +1,47 @@
-'use strict';
-
-module.exports = function (connection, parsed, data, callback) {
+export default function loginCommand(connection, parsed, data, callback) {
     // LOGIN expects 2 string params - username and password
-    if (
-        !parsed.attributes ||
+    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
-        );
+        ['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
-    );
-
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'User logged in'
+            }
+        ]
+    }, 'LOGIN SUCCESS', parsed, data);
     callback();
-};
+}

package/dist/esm/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/esm/commands/logout.js

@@ -0,0 +1,25 @@
+export default 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();
+}

package/dist/esm/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/esm/commands/lsub.js

@@ -0,0 +1,64 @@
+export default 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();
+}

package/dist/esm/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/esm/commands/noop.js

@@ -0,0 +1,13 @@
+export default function noopCommand(connection, parsed, data, callback) {
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'Completed'
+            }
+        ]
+    }, 'NOOP completed', parsed, data);
+    callback();
+}

package/dist/esm/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;

package/{lib → dist/esm}/commands/rename.js

@@ -1,58 +1,42 @@
-'use strict';
-
-module.exports = function (connection, parsed, data, callback) {
-    if (
-        !parsed.attributes ||
+export default function renameCommand(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: 'RENAME expects mailbox source and destination names'
-                    }
-                ]
-            },
-            'INVALID COMMAND',
-            parsed,
-            data
-        );
+        ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[1].type) < 0) {
+        connection.send({
+            tag: parsed.tag,
+            command: 'BAD',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'RENAME expects mailbox source and destination names'
+                }
+            ]
+        }, 'INVALID COMMAND', parsed, data);
         return callback();
     }
-
     const source = parsed.attributes[0].value;
     const destination = parsed.attributes[1].value;
-
     const server = connection.server;
     const mailbox = server.getMailbox(source);
     const target = server.getMailbox(destination);
-
     const sendError = (code, message) => {
         connection.sendStatus(parsed, data, 'NO', message, code, 'RENAME FAILED');
         return callback();
     };
-
     // check everything that can be checked up front, so that a failed RENAME never loses the source
     if (!mailbox || mailbox.flags.indexOf('\\Noselect') >= 0) {
         return sendError('NONEXISTENT', 'Mailbox does not exist');
     }
-
     if (target && target.flags.indexOf('\\Noselect') < 0) {
         return sendError('ALREADYEXISTS', 'Mailbox already exists');
     }
-
     const separator = server.getSeparator(mailbox);
     if (destination.substr(0, mailbox.path.length + separator.length) === mailbox.path + separator) {
         return sendError('CANNOT', 'Can not move a mailbox into itself');
     }
-
     const oldPath = mailbox.path;
     let newPath;
     try {
@@ -60,15 +44,17 @@ module.exports = function (connection, parsed, data, callback) {
             // Renaming INBOX moves its messages to the new mailbox and leaves INBOX empty (RFC 3501 section 6.3.5)
             const newMailbox = server.createMailbox(destination);
             newPath = newMailbox.path;
-            mailbox.messages.forEach(message => {
+            mailbox.messages.forEach((message) => {
                 server.copyMessage(newMailbox, message);
             });
             connection.expungeSpecificMessages(mailbox, () => true);
-        } else {
+        }
+        else {
             server.deleteMailbox(source, true);
             try {
                 server.createMailbox(destination, mailbox);
-            } catch (E) {
+            }
+            catch (E) {
                 // put the source mailbox back where it was
                 server.createMailbox(source, mailbox);
                 server.indexFolders();
@@ -77,26 +63,21 @@ module.exports = function (connection, parsed, data, callback) {
             server.indexFolders();
             newPath = mailbox.path;
         }
-    } catch (E) {
+    }
+    catch (err) {
+        const E = err;
         return sendError(E.code, E.message);
     }
     server.mailboxChanged('rename', newPath, { oldPath });
-
-    connection.send(
-        {
-            tag: parsed.tag,
-            command: 'OK',
-            attributes: [
-                {
-                    type: 'TEXT',
-                    value: 'RENAME completed'
-                }
-            ]
-        },
-        'RENAME',
-        parsed,
-        data,
-        mailbox
-    );
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'RENAME completed'
+            }
+        ]
+    }, 'RENAME', parsed, data, mailbox);
     return callback();
-};
+}

package/dist/esm/commands/search.d.ts

@@ -0,0 +1,10 @@
+import type { Callback, IMAPConnection, ParsedCommand } from '../types.js';
+/**
+ * Shared implementation of SEARCH and UID SEARCH
+ *
+ * @param {Boolean} isUid If true, the response lists UIDs instead of sequence numbers
+ */
+declare function processSearch(isUid: boolean, connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback): void;
+declare const searchCommand: (connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback) => void;
+export default searchCommand;
+export { processSearch };

package/dist/esm/commands/search.js

@@ -0,0 +1,54 @@
+import makeSearch from './handlers/search.js';
+import { criteriaValues, sendSearchError } from './handlers/search.js';
+/**
+ * Shared implementation of SEARCH and UID SEARCH
+ *
+ * @param {Boolean} isUid If true, the response lists UIDs instead of sequence numbers
+ */
+function processSearch(isUid, connection, parsed, data, callback) {
+    const command = isUid ? 'UID SEARCH' : 'SEARCH';
+    if (!parsed.attributes || !parsed.attributes.length) {
+        connection.send({
+            tag: parsed.tag,
+            command: 'BAD',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: command + ' expects search criteria, empty query given'
+                }
+            ]
+        }, command + ' FAILED', parsed, data);
+        return callback();
+    }
+    let searchResult;
+    try {
+        searchResult = makeSearch(connection, connection.getSessionMessages(), criteriaValues(parsed.attributes));
+    }
+    catch (E) {
+        sendSearchError(connection, parsed, data, E, command + ' FAILED');
+        return callback();
+    }
+    // RFC 3501 7.2.5: the SEARCH response is sent even when nothing matched. Plugins get the
+    // search result, so they can extend the response or replace it (e.g. ESEARCH)
+    connection.send({
+        tag: '*',
+        command: 'SEARCH',
+        attributes: searchResult.list.map(item => {
+            return isUid ? item.uid : searchResult.numbers[item.uid];
+        })
+    }, command, parsed, data, searchResult);
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: command + ' completed'
+            }
+        ]
+    }, command, parsed, data);
+    return callback();
+}
+const searchCommand = (connection, parsed, data, callback) => processSearch(false, connection, parsed, data, callback);
+export default searchCommand;
+export { processSearch };

package/dist/esm/commands/select.d.ts

@@ -0,0 +1,19 @@
+import type { Callback, IMAPConnection, ParsedCommand } from '../types.js';
+export default function selectCommand(connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback): void;
+/**
+ * Starts a SELECT or EXAMINE, also one that is going to fail: ENABLE is not allowed once a mailbox has been selected
+ * (RFC 5161 section 3.1), and the selected mailbox gets closed. CLOSED marks where the responses for the new mailbox
+ * start (RFC 7162 section 3.2.11, RFC 9051 sections 6.3.2 and 7.1)
+ *
+ * @param {Object} connection IMAP connection
+ * @param {Object} parsed Parsed command
+ * @param {String} data Raw command
+ */
+declare function beginSelect(connection: IMAPConnection, parsed: ParsedCommand, data: string): void;
+/**
+ * Shared implementation of SELECT and EXAMINE
+ *
+ * @param {Boolean} readOnly If true, the mailbox is opened read-only (EXAMINE)
+ */
+declare function selectMailbox(connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback, readOnly: boolean): void;
+export { selectMailbox, beginSelect };