imapkit 4.3.1 → 5.0.1

package/bin/imapkit.js

@@ -21,25 +21,39 @@ const { values: argv } = parseArgs({
         storage: { type: 'string' },
         script: { type: 'string' },
         plugin: { type: 'string', multiple: true },
-        smtpPort: { type: 'string' }
+        smtpPort: { type: 'string' },
+        'smtp-port': { type: 'string' },
+        'rest-port': { type: 'string' },
+        'rest-host': { type: 'string' },
+        'rest-token': { type: 'string' },
+        quirk: { type: 'string', multiple: true },
+        'script-seed': { type: 'string' }
     }
 });
 
 const isTrue = value => (value || '').toString().trim().toLowerCase() === 'true';
 
+// a repeated option or a comma separated list, e.g. --plugin=IDLE,MOVE --plugin=ID
+const listOption = value =>
+    []
+        .concat(value || [])
+        .flatMap(item =>
+            String(item)
+                .trim()
+                .split(/\s*,\s*/)
+        )
+        .filter(Boolean);
+
 const configLocation = argv.config || process.env.IMAPKIT_CONFIG;
 const storageLocation = argv.storage || process.env.IMAPKIT_STORAGE;
 const scriptLocation = argv.script || process.env.IMAPKIT_SCRIPT;
-const smtpPort = argv.smtpPort || process.env.IMAPKIT_SMTPPORT;
-const pluginsList = []
-    .concat(argv.plugin || process.env.IMAPKIT_PLUGINS || [])
-    .flatMap(plugin =>
-        String(plugin)
-            .toUpperCase()
-            .trim()
-            .split(/\s*,\s*/)
-    )
-    .filter(Boolean);
+const smtpPort = argv.smtpPort || argv['smtp-port'] || process.env.IMAPKIT_SMTPPORT;
+const restPort = argv['rest-port'] || process.env.IMAPKIT_REST_PORT;
+const restHost = argv['rest-host'] || process.env.IMAPKIT_REST_HOST;
+const restToken = argv['rest-token'] || process.env.IMAPKIT_REST_TOKEN;
+const quirksList = listOption(argv.quirk || process.env.IMAPKIT_QUIRKS);
+const scriptSeed = argv['script-seed'] || process.env.IMAPKIT_SCRIPT_SEED;
+const pluginsList = listOption(argv.plugin || process.env.IMAPKIT_PLUGINS).map(plugin => plugin.toUpperCase());
 const secure = isTrue(argv.secure || process.env.IMAPKIT_SECURE);
 const debug = isTrue(argv.debug || process.env.IMAPKIT_DEBUG);
 
@@ -69,7 +83,9 @@ if (debug) {
     config.debug = true;
 }
 
-const port = argv.port || process.env.IMAPKIT_PORT || config.port || (secure ? 993 : 143);
+// secureConnection can also come from the --config file
+const isSecure = secure || config.secureConnection === true;
+const port = argv.port || process.env.IMAPKIT_PORT || config.port || (isSecure ? 993 : 143);
 
 if (argv.help) {
     const help = fs.readFileSync(path.join(__dirname, 'help.txt'), 'utf-8');
@@ -93,18 +109,42 @@ if (argv.help) {
             .trim()
     );
 } else {
-    const server = imapkit(config);
-    console.log('Starting ImapKit ...');
-    server.server.on('error', err => {
-        console.error('Failed to start ImapKit on port %s: %s', port, err.message);
-        process.exit(1);
-    });
-    server.listen(port, () => {
-        console.log('ImapKit successfully%s listening on port %s', secure ? ' and securely' : '', port);
-    });
-
+    if (quirksList.length) {
+        config.quirks = quirksList;
+    }
+    if (scriptSeed !== undefined) {
+        config.scriptSeed = Number(scriptSeed);
+    }
+    if (restPort) {
+        config.rest = { port: Number(restPort), host: restHost, token: restToken };
+    }
     if (smtpPort) {
-        // loaded on demand, smtp-server is only needed when SMTP is enabled
-        import('../dist/esm/smtp-listener.js').then(({ startSMTPServer }) => startSMTPServer(smtpPort, server));
+        // smtp-server is an optional dependency, start() loads it only when SMTP is enabled
+        config.smtp = { port: Number(smtpPort) };
+    }
+    let server;
+    try {
+        server = imapkit(config);
+    } catch (err) {
+        // an unknown plugin or quirk name, invalid storage ...
+        console.error('Failed to start ImapKit: %s', err.message);
+        process.exit(1);
     }
+    console.log('Starting ImapKit ...');
+    server.start(Number(port)).then(
+        listening => {
+            // the actual port, also for -p 0
+            console.log('ImapKit successfully%s listening on port %s', isSecure ? ' and securely' : '', listening);
+            if (server.restServer) {
+                console.log('REST API listening on %s:%s', (config.rest && config.rest.host) || '127.0.0.1', server.restServer.address().port);
+            }
+            if (server.smtpServer) {
+                console.log('Incoming SMTP server up and running on port %s', server.smtpServer.server.address().port);
+            }
+        },
+        err => {
+            console.error('Failed to start ImapKit: %s', err.message);
+            process.exit(1);
+        }
+    );
 }

package/dist/cjs/commands/append.js

@@ -45,7 +45,7 @@ function parseFlags(connection, list) {
                 throw new Error('Invalid flags argument');
             }
             const value = (0, flags_js_1.normalizeSystemFlag)(flag.value);
-            (0, flags_js_1.checkSystemFlags)(connection, value);
+            (0, flags_js_1.checkSystemFlags)(connection.server, value);
             return value;
         });
     }

package/dist/cjs/commands/create.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = createCommand;
+const store_operations_js_1 = require("../store-operations.js");
 function createCommand(connection, parsed, data, callback) {
     if (!parsed.attributes || parsed.attributes.length !== 1 || !parsed.attributes[0] || ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0) {
         connection.send({
@@ -18,7 +19,7 @@ function createCommand(connection, parsed, data, callback) {
     const path = parsed.attributes[0].value;
     let mailbox;
     try {
-        mailbox = connection.server.createMailbox(path);
+        mailbox = (0, store_operations_js_1.createMailbox)(connection.server, path);
     }
     catch (err) {
         const E = err;
@@ -26,7 +27,6 @@ function createCommand(connection, parsed, data, callback) {
         connection.sendStatus(parsed, data, 'NO', E.message, E.code, 'CREATE FAILED');
         return callback();
     }
-    connection.server.mailboxChanged('create', mailbox.path);
     connection.send({
         tag: parsed.tag,
         command: 'OK',

package/dist/cjs/commands/delete.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = deleteCommand;
+const store_operations_js_1 = require("../store-operations.js");
 function deleteCommand(connection, parsed, data, callback) {
     if (!parsed.attributes || parsed.attributes.length !== 1 || !parsed.attributes[0] || ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0) {
         connection.send({
@@ -16,27 +17,14 @@ function deleteCommand(connection, parsed, data, callback) {
         return callback();
     }
     const path = parsed.attributes[0].value;
-    const mailbox = connection.server.getMailbox(path);
-    if (!mailbox) {
-        connection.sendStatus(parsed, data, 'NO', 'Mailbox does not exist', 'NONEXISTENT', 'DELETE FAILED');
-        return callback();
-    }
     try {
-        connection.server.deleteMailbox(path);
+        (0, store_operations_js_1.deleteMailbox)(connection.server, path);
     }
     catch (err) {
         const E = err;
         connection.sendStatus(parsed, data, 'NO', E.message, E.code, 'DELETE FAILED');
         return callback();
     }
-    connection.server.mailboxChanged('delete', mailbox.path, { mailbox });
-    // RFC 2180 section 3.3: the other sessions that have the mailbox selected are disconnected with an untagged
-    // BYE (RFC 2683 section 3.1.2), as they can not be told about the deletion in any other way
-    connection.server.connections.forEach(other => {
-        if (other !== connection && other.selectedMailbox === mailbox) {
-            other.bye('Selected mailbox was deleted', 'MAILBOX DELETED');
-        }
-    });
     connection.send({
         tag: parsed.tag,
         command: 'OK',

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

@@ -85,7 +85,8 @@ function getSection(data, query, global) {
     else if (query.section.length > 1) {
         throw new Error((key || 'Part number') + ' does not take any arguments');
     }
-    // RFC 3501 6.4.5: a part that does not exist is returned as an empty string
+    // a part that does not exist is returned as an empty string, like Dovecot does: RFC 3501 and RFC 9051 section
+    // 6.4.5 define no error for it, only an empty string for a partial range that starts beyond the end of the text
     const node = path ? (0, mimeparser_js_1.resolveNode)(data.tree, path, global) : data.tree;
     if (!node) {
         return '';

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

@@ -1,4 +1,4 @@
-import type { IMAPConnection } from '../../types.js';
+import type { IMAPServer } from '../../types.js';
 declare const INVALID_KEYWORD_CHAR: RegExp;
 /**
  * System flags are case-insensitive, so "\seen" becomes "\Seen"
@@ -10,8 +10,8 @@ declare function normalizeSystemFlag(flag: string): string;
 /**
  * Throws if a flag can not be stored: an unknown system flag (including \Recent) or an invalid keyword
  *
- * @param {Object} connection IMAP connection
+ * @param {Object} server IMAP server, its systemFlags are the system flags that can be stored
  * @param {String} flag Normalized flag value
  */
-declare function checkSystemFlags(connection: IMAPConnection, flag: string): void;
+declare function checkSystemFlags(server: IMAPServer, flag: string): void;
 export { INVALID_KEYWORD_CHAR, normalizeSystemFlag, checkSystemFlags };

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

@@ -24,12 +24,12 @@ function normalizeSystemFlag(flag) {
 /**
  * Throws if a flag can not be stored: an unknown system flag (including \Recent) or an invalid keyword
  *
- * @param {Object} connection IMAP connection
+ * @param {Object} server IMAP server, its systemFlags are the system flags that can be stored
  * @param {String} flag Normalized flag value
  */
-function checkSystemFlags(connection, flag) {
+function checkSystemFlags(server, flag) {
     if (flag.charAt(0) === '\\') {
-        if (connection.server.systemFlags.indexOf(flag) < 0) {
+        if (server.systemFlags.indexOf(flag) < 0) {
             throw new Error('Invalid system flag ' + flag);
         }
     }

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

@@ -9,9 +9,9 @@ function setFlags(connection, message, flags) {
     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) {
+        (0, flags_js_1.checkSystemFlags)(connection.server, flag);
+        // a flag that is not in PERMANENTFLAGS is ignored (RFC 3501 section 7.1, RFC 9051 section 7.1)
+        if (!connection.server.isPermanentFlag(mailbox, flag)) {
             return;
         }
         if (messageFlags.indexOf(flag) < 0) {
@@ -25,9 +25,9 @@ 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) {
+        (0, flags_js_1.checkSystemFlags)(connection.server, flag);
+        // a flag that is not in PERMANENTFLAGS is ignored (RFC 3501 section 7.1, RFC 9051 section 7.1)
+        if (!connection.server.isPermanentFlag(mailbox, flag)) {
             return;
         }
         if (message.flags.indexOf(flag) < 0) {
@@ -39,7 +39,7 @@ function addFlags(connection, 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);
+        (0, flags_js_1.checkSystemFlags)(connection.server, flag);
         if (message.flags.indexOf(flag) >= 0) {
             for (let i = 0; i < message.flags.length; i++) {
                 if (message.flags[i] === flag) {

package/dist/cjs/commands/list.js

@@ -22,8 +22,22 @@ function listCommand(connection, parsed, data, callback) {
         return callback();
     }
     if (!parsed.attributes[1].value) {
-        // empty reference lists separator only
-        const namespace = connection.server.storage[parsed.attributes[1].value || connection.server.referenceNamespace];
+        // RFC 3501 section 6.3.8: "An empty ("" string) mailbox name argument is a special request to return the
+        // hierarchy delimiter and the root name of the name given in the reference. The value returned as the root
+        // MAY be the empty string if the reference is non-rooted or is an empty string."
+        const server = connection.server;
+        const reference = parsed.attributes[0].value || '';
+        // the namespace of the reference, the personal one for a reference that is not a valid name
+        let key = server.referenceNamespace;
+        try {
+            key = server.getNamespace(connection.importMailboxName(reference)) || key;
+        }
+        catch {
+            // not a mailbox name, so not in another namespace
+        }
+        const namespace = key !== false ? server.storage[key] : undefined;
+        // the root of a name in another namespace is the prefix of that namespace, like "#news." in the RFC example
+        const root = key !== false && key !== server.referenceNamespace ? connection.exportMailboxName(key) : '';
         if (namespace) {
             connection.send({
                 tag: '*',
@@ -36,7 +50,7 @@ function listCommand(connection, parsed, data, callback) {
                         }
                     ],
                     namespace.separator,
-                    ''
+                    root
                 ]
             }, 'LIST ITEM', parsed, data);
         }

package/dist/cjs/commands/rename.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = renameCommand;
+const store_operations_js_1 = require("../store-operations.js");
 function renameCommand(connection, parsed, data, callback) {
     if (!parsed.attributes ||
         parsed.attributes.length !== 2 ||
@@ -22,56 +23,15 @@ function renameCommand(connection, parsed, data, 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;
+    let renamed;
     try {
-        if (source.toUpperCase() === 'INBOX') {
-            // 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) => {
-                server.copyMessage(newMailbox, message);
-            });
-            connection.expungeSpecificMessages(mailbox, () => true);
-        }
-        else {
-            server.deleteMailbox(source, true);
-            try {
-                server.createMailbox(destination, mailbox);
-            }
-            catch (E) {
-                // put the source mailbox back where it was
-                server.createMailbox(source, mailbox);
-                server.indexFolders();
-                throw E;
-            }
-            server.indexFolders();
-            newPath = mailbox.path;
-        }
+        renamed = (0, store_operations_js_1.renameMailbox)(connection.server, source, destination);
     }
     catch (err) {
         const E = err;
-        return sendError(E.code, E.message);
+        connection.sendStatus(parsed, data, 'NO', E.message, E.code, 'RENAME FAILED');
+        return callback();
     }
-    server.mailboxChanged('rename', newPath, { oldPath });
     connection.send({
         tag: parsed.tag,
         command: 'OK',
@@ -81,7 +41,7 @@ function renameCommand(connection, parsed, data, callback) {
                 value: 'RENAME completed'
             }
         ]
-    }, 'RENAME', parsed, data, mailbox);
+    }, 'RENAME', parsed, data, renamed.mailbox);
     return callback();
 }
 {

package/dist/cjs/commands/select.js

@@ -60,6 +60,7 @@ function selectMailbox(connection, parsed, data, callback, readOnly) {
     connection.state = 'Selected';
     connection.selectedMailbox = mailbox;
     connection.readOnly = readOnly;
+    connection.emitSession('select');
     connection.notificationQueue = [];
     // \Recent is a session flag: a read-write session takes over the messages
     // that no other session has seen yet (RFC 3501 section 2.3.2)

package/dist/cjs/commands/subscribe.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = subscribeCommand;
+const store_operations_js_1 = require("../store-operations.js");
 function subscribeCommand(connection, parsed, data, callback) {
     if (!parsed.attributes || parsed.attributes.length !== 1 || !parsed.attributes[0] || ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0) {
         connection.send({
@@ -15,15 +16,13 @@ function subscribeCommand(connection, parsed, data, callback) {
         }, 'INVALID COMMAND', parsed, data);
         return callback();
     }
-    const path = parsed.attributes[0].value;
-    const mailbox = connection.server.getMailbox(path);
-    if (!mailbox || mailbox.flags.indexOf('\\Noselect') >= 0) {
-        connection.sendStatus(parsed, data, 'NO', 'Mailbox does not exist', 'NONEXISTENT', 'SUBSCRIBE FAILED');
-        return callback();
+    try {
+        (0, store_operations_js_1.subscribeMailbox)(connection.server, parsed.attributes[0].value);
     }
-    if (!mailbox.subscribed) {
-        mailbox.subscribed = true;
-        connection.server.mailboxChanged('subscribe', mailbox.path);
+    catch (err) {
+        const E = err;
+        connection.sendStatus(parsed, data, 'NO', E.message, E.code, 'SUBSCRIBE FAILED');
+        return callback();
     }
     connection.send({
         tag: parsed.tag,

package/dist/cjs/commands/unsubscribe.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = unsubscribeCommand;
+const store_operations_js_1 = require("../store-operations.js");
 function unsubscribeCommand(connection, parsed, data, callback) {
     if (!parsed.attributes || parsed.attributes.length !== 1 || !parsed.attributes[0] || ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0) {
         connection.send({
@@ -15,15 +16,8 @@ function unsubscribeCommand(connection, parsed, data, callback) {
         }, 'INVALID COMMAND', parsed, data);
         return callback();
     }
-    let path = parsed.attributes[0].value;
-    if (path.toUpperCase() === 'INBOX') {
-        path = 'INBOX';
-    }
-    // The subscription list holds names, so a name stays removable after its mailbox is deleted
-    // (RFC 3501 section 6.3.6). Removing a name that is not subscribed is not an error (RFC 9051 section 6.3.8)
-    if (connection.server.subscriptions.delete(path)) {
-        connection.server.mailboxChanged('unsubscribe', path);
-    }
+    // removing a name that is not subscribed is not an error (RFC 9051 section 6.3.8)
+    (0, store_operations_js_1.unsubscribeMailbox)(connection.server, parsed.attributes[0].value);
     connection.send({
         tag: parsed.tag,
         command: 'OK',