imapkit 4.0.3 → 4.1.1

package/dist/cjs/plugins/uidplus.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = uidplusPlugin;
+const esearch_js_1 = require("../esearch.js");
+/**
+ * @help Adds UIDPLUS [RFC4315] capability
+ *
+ * UIDPLUS: http://tools.ietf.org/html/rfc4315
+ *
+ * Additional commands:
+ * - UID EXPUNGE
+ *
+ * Additional response codes:
+ * - APPENDUID (with a UID set for MULTIAPPEND, and in an untagged OK for REPLACE)
+ * - COPYUID
+ * - Not implemented: UIDNOTSTICKY
+ */
+function uidplusPlugin(server) {
+    server.registerCapability('UIDPLUS');
+    server.setCommandHandler('UID EXPUNGE', (connection, parsed, data, callback) => {
+        if (!parsed.attributes || parsed.attributes.length !== 1 || !parsed.attributes[0] || ['ATOM', 'SEQUENCE'].indexOf(parsed.attributes[0].type) < 0) {
+            connection.send({
+                tag: parsed.tag,
+                command: 'BAD',
+                attributes: [
+                    {
+                        type: 'TEXT',
+                        value: 'UID EXPUNGE expects uid sequence set'
+                    }
+                ]
+            }, 'INVALID COMMAND', parsed, data);
+            return callback();
+        }
+        if (connection.refuseReadOnly(parsed, data, 'UID EXPUNGE FAILED')) {
+            return callback();
+        }
+        const sequence = parsed.attributes[0].value;
+        const range = connection.limitRange(parsed, connection.getMessageRange(sequence, true));
+        // Only messages with the \Deleted flag are removed (RFC 4315 section 2.1)
+        const rangeMessages = range.map(x => x[1]).filter((message) => message.flags.indexOf('\\Deleted') >= 0);
+        connection.expungeSpecificMessages(connection.selectedMailbox, rangeMessages, false, true, !!parsed.highestFirst);
+        connection.send({
+            tag: parsed.tag,
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'UID EXPUNGE completed'
+                }
+            ]
+        }, 'UID EXPUNGE', parsed, data);
+        callback();
+    });
+    server.outputHandlers.push((connection, response, description, parsed, data, extra) => {
+        if (description === 'APPEND' || description === 'REPLACE APPENDUID') {
+            // OK [APPENDUID <target-mailbox-uidvalidity> <uid>] APPEND Completed. With MULTIAPPEND the
+            // second value is a UID set, but never for a single message (RFC 4315 section 3)
+            const uids = extra.messages.map((message) => message.uid);
+            response.attributes = [
+                {
+                    type: 'SECTION',
+                    section: [
+                        {
+                            type: 'ATOM',
+                            value: 'APPENDUID'
+                        },
+                        extra.mailbox.uidvalidity,
+                        uids.length > 1 ? { type: 'SEQUENCE', value: (0, esearch_js_1.toSequenceSet)(uids) } : uids[0]
+                    ]
+                }
+            ].concat(response.attributes);
+            // REPLACE sends APPENDUID in an untagged OK before the EXPUNGE (RFC 8508 section 4.3)
+            response.skipResponse = false;
+            return;
+        }
+        if (description === 'COPY' || description === 'UID COPY' || description === 'MOVE COPYUID' || description === 'UID MOVE COPYUID') {
+            // Nothing was copied, an empty COPYUID would break the response grammar
+            if (!extra || !extra.sourceUids || !extra.sourceUids.length) {
+                return;
+            }
+            response.attributes = [
+                {
+                    type: 'SECTION',
+                    section: [
+                        {
+                            type: 'ATOM',
+                            value: 'COPYUID'
+                        },
+                        extra.mailbox.uidvalidity,
+                        // The range was interpreted in ascending order so these
+                        // values are already in the right order.
+                        {
+                            type: 'SEQUENCE',
+                            value: extra.sourceUids.join(',')
+                        },
+                        {
+                            type: 'SEQUENCE',
+                            value: extra.targetUids.join(',')
+                        }
+                    ]
+                }
+            ].concat(response.attributes);
+            response.skipResponse = false;
+            return;
+        }
+    });
+}
+{
+    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/unauthenticate.d.ts

@@ -0,0 +1,7 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @help Adds UNAUTHENTICATE [RFC8437] capability
+ * @help Returns to the Not Authenticated state, everything
+ * @help but TLS is reset (selected mailbox, ENABLE, COMPRESS)
+ */
+export default function unauthenticatePlugin(server: IMAPServer): void;

package/dist/cjs/plugins/unauthenticate.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = unauthenticatePlugin;
+const command_states_js_1 = require("../command-states.js");
+/**
+ * @help Adds UNAUTHENTICATE [RFC8437] capability
+ * @help Returns to the Not Authenticated state, everything
+ * @help but TLS is reset (selected mailbox, ENABLE, COMPRESS)
+ */
+function unauthenticatePlugin(server) {
+    server.registerCapability('UNAUTHENTICATE');
+    server.setCommandHandler('UNAUTHENTICATE', (connection, parsed, data, callback) => {
+        // RFC 8437 section 3: a NO response is not permitted, the reset can not fail here
+        connection.sendStatus(parsed, data, 'OK', 'Completed, now in not authenticated state');
+        // RFC 8437 sections 3 and 4.1: the mailbox is closed without EXPUNGE responses, ENABLEd
+        // extensions and CONDSTORE are turned off, and compression ends after the CRLF of the OK
+        connection.resetSession();
+        return callback();
+    }, { states: command_states_js_1.states.AUTHENTICATED, noArguments: true });
+}
+{
+    const defaultExport = exports.default;
+    if (defaultExport && (typeof defaultExport === 'function' || typeof defaultExport === 'object')) {
+        for (const key of Object.keys(exports)) {
+            if (key !== 'default' && !(key in defaultExport)) {
+                defaultExport[key] = exports[key];
+            }
+        }
+        Object.defineProperty(defaultExport, 'default', { value: defaultExport, enumerable: false, writable: true, configurable: true });
+        module.exports = defaultExport;
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @help Adds UNSELECT [RFC3691] capability
+ */
+export default function unselectPlugin(server: IMAPServer): void;

package/dist/cjs/plugins/unselect.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = unselectPlugin;
+const command_states_js_1 = require("../command-states.js");
+/**
+ * @help Adds UNSELECT [RFC3691] capability
+ */
+function unselectPlugin(server) {
+    server.registerCapability('UNSELECT');
+    server.setCommandHandler('UNSELECT', (connection, parsed, data, callback) => {
+        connection.send({
+            tag: parsed.tag,
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'Mailbox closed'
+                }
+            ]
+        }, 'CLOSE', parsed, data);
+        connection.closeMailbox();
+        return callback();
+    }, { states: command_states_js_1.states.SELECTED, noArguments: true });
+}
+{
+    const defaultExport = exports.default;
+    if (defaultExport && (typeof defaultExport === 'function' || typeof defaultExport === 'object')) {
+        for (const key of Object.keys(exports)) {
+            if (key !== 'default' && !(key in defaultExport)) {
+                defaultExport[key] = exports[key];
+            }
+        }
+        Object.defineProperty(defaultExport, 'default', { value: defaultExport, enumerable: false, writable: true, configurable: true });
+        module.exports = defaultExport;
+    }
+}

package/dist/cjs/plugins/utf8-accept.d.ts

@@ -0,0 +1,6 @@
+import type { IMAPServer } from '../types.js';
+declare function utf8AcceptPlugin(server: IMAPServer): void;
+declare namespace utf8AcceptPlugin {
+    var requires: string[];
+}
+export default utf8AcceptPlugin;

package/dist/cjs/plugins/utf8-accept.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = utf8AcceptPlugin;
+const utf8_session_js_1 = require("../utf8-session.js");
+const enable_js_1 = require("./enable.js");
+/**
+ * @help Adds UTF8=ACCEPT [RFC9755] capability, loads ENABLE as well
+ * @help After ENABLE UTF8=ACCEPT mailbox names are UTF-8 instead of
+ * @help modified UTF-7 and strings are sent quoted as UTF-8
+ */
+/**
+ * Checks if the header of a message holds 8-bit octets
+ *
+ * @param {String} raw Message source as a binary string
+ * @return {Boolean} true if the header has 8-bit octets
+ */
+function has8bitHeader(raw) {
+    const match = raw.match(/\r?\n\r?\n/);
+    return /[\x80-\xff]/.test(match ? raw.substr(0, match.index) : raw);
+}
+function utf8AcceptPlugin(server) {
+    // RFC 9755 section 3: the client turns UTF-8 support on with ENABLE
+    server.registerCapability('UTF8=ACCEPT');
+    (0, enable_js_1.registerEnable)(server, 'UTF8=ACCEPT');
+    // RFC 9755 section 3: a server that supports UTF8=ACCEPT accepts UTF-8 in quoted strings. Before
+    // ENABLE, mailbox names must still be modified UTF-7 and SEARCH needs CHARSET UTF-8 for 8-bit strings.
+    // See src/utf8-session.ts, the session state is shared with IMAP4rev2
+    server.utf8Accept = true;
+    server.connectionHandlers.push(utf8_session_js_1.updateSession);
+    // RFC 8437 section 3: UNAUTHENTICATE resets the ENABLEd extensions
+    server.resetHandlers.push(utf8_session_js_1.updateSession);
+    server.outputHandlers.push((connection, response, description, parsed, data, extra) => {
+        if (description === 'ENABLED' && Array.isArray(extra) && extra.indexOf('UTF8=ACCEPT') >= 0) {
+            // strings that are valid UTF-8 are sent quoted, mailbox names are UTF-8 in both directions
+            // ("&" is an ordinary character), SEARCH strings are UTF-8 and CHARSET is refused
+            (0, utf8_session_js_1.updateSession)(connection);
+        }
+    });
+    // RFC 9755 section 4: without ENABLE UTF8=ACCEPT, APPEND MUST be refused with NO
+    // if the message header has 8-bit characters
+    const appendHandler = server.getCommandHandler('APPEND');
+    server.setCommandHandler('APPEND', (connection, parsed, data, callback) => {
+        const args = parsed.attributes || [];
+        const raw = args[args.length - 1];
+        if (
+        // UTF-8 is on after ENABLE UTF8=ACCEPT, or IMAP4rev2, which permits 8-bit characters in the message
+        // (RFC 9051 section 6.3.12) and which RFC 9755 does not extend
+        !connection.utf8Enabled &&
+            args.length >= 2 &&
+            raw &&
+            ['LITERAL', 'LITERAL8'].indexOf(raw.type) >= 0 &&
+            has8bitHeader(raw.value || '')) {
+            connection.sendStatus(parsed, data, 'NO', 'Message header has 8-bit characters, ENABLE UTF8=ACCEPT first (RFC 9755 section 4)');
+            return callback();
+        }
+        return appendHandler(connection, parsed, data, callback);
+    });
+}
+// ENABLE UTF8=ACCEPT is the only way to use this extension
+utf8AcceptPlugin.requires = ['ENABLE'];
+{
+    const defaultExport = exports.default;
+    if (defaultExport && (typeof defaultExport === 'function' || typeof defaultExport === 'object')) {
+        for (const key of Object.keys(exports)) {
+            if (key !== 'default' && !(key in defaultExport)) {
+                defaultExport[key] = exports[key];
+            }
+        }
+        Object.defineProperty(defaultExport, 'default', { value: defaultExport, enumerable: false, writable: true, configurable: true });
+        module.exports = defaultExport;
+    }
+}

package/dist/cjs/plugins/x-gm-ext-1.d.ts

@@ -0,0 +1,26 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @help Adds Gmail specific X-GM-EXT-1 capability
+ * @help (https://developers.google.com/workspace/gmail/imap/imap-extensions)
+ * @help   X-GM-MSGID and X-GM-THRID: FETCH and SEARCH. X-GM-THRID is the
+ * @help       X-GM-MSGID of the message unless storage sets an X-GM-THRID
+ * @help       value, so every message is its own thread unless the
+ * @help       fixture groups messages. With OBJECTID, the messages of a
+ * @help       THREADID share the X-GM-THRID of its first message
+ * @help   X-GM-LABELS: FETCH, STORE (+/-, .SILENT) and SEARCH. System
+ * @help       labels are atoms that start with "\" (\Inbox for INBOX, the
+ * @help       special-use attribute for special-use mailboxes), other labels
+ * @help       are mailbox names, sent like mailbox names (modified UTF-7, or
+ * @help       UTF-8 after ENABLE UTF8=ACCEPT, quoted when not atoms). Labels
+ * @help       have no side effects: the message is not copied to or removed
+ * @help       from other mailboxes. In SEARCH a label that starts with "\"
+ * @help       is a system label
+ * @help   X-GM-RAW: a subset of the Gmail search syntax. Words and "quoted
+ * @help       phrases" (TEXT), -term, OR, (groups), {any of}, from: to: cc:
+ * @help       bcc: subject: label: in: (inbox sent drafts trash spam
+ * @help       anywhere, or a label) is: (read unread starred important)
+ * @help       larger: smaller: (k and m suffixes) after: before:
+ * @help       (YYYY/MM/DD) and rfc822msgid:. Other Gmail operators are
+ * @help       answered with NO
+ */
+export default function xGmExt1Plugin(server: IMAPServer): void;