imapkit 4.0.3 → 4.1.0

package/dist/cjs/smtp-listener.d.ts

@@ -0,0 +1,13 @@
+import { SMTPServer } from 'smtp-server';
+import type { IMAPServer } from './types.js';
+/**
+ * Starts an SMTP server that appends every received message to the INBOX
+ * of the given ImapKit IMAP server. Any sender, recipient and credentials
+ * are accepted.
+ *
+ * @param {Number} smtpPort - port to listen on for SMTP commands
+ * @param {Object} imapServer - the ImapKit IMAP server
+ * @param {Function} [callback] - function executed when SMTP server is listening
+ * @return {SMTPServer} the SMTP server instance, use `close()` to stop it
+ */
+export declare function startSMTPServer(smtpPort: number, imapServer: IMAPServer, callback?: (() => void) | null): SMTPServer;

package/dist/cjs/smtp-listener.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startSMTPServer = startSMTPServer;
+const smtp_server_1 = require("smtp-server");
+/**
+ * Starts an SMTP server that appends every received message to the INBOX
+ * of the given ImapKit IMAP server. Any sender, recipient and credentials
+ * are accepted.
+ *
+ * @param {Number} smtpPort - port to listen on for SMTP commands
+ * @param {Object} imapServer - the ImapKit IMAP server
+ * @param {Function} [callback] - function executed when SMTP server is listening
+ * @return {SMTPServer} the SMTP server instance, use `close()` to stop it
+ */
+function startSMTPServer(smtpPort, imapServer, callback) {
+    const credentials = imapServer.getCredentials();
+    const server = new smtp_server_1.SMTPServer({
+        banner: 'ImapKit',
+        key: credentials.key,
+        cert: credentials.cert,
+        authOptional: true,
+        logger: false,
+        onAuth(auth, session, done) {
+            done(null, { user: auth.username });
+        },
+        onData(stream, session, done) {
+            const chunks = [];
+            stream.on('data', (chunk) => chunks.push(chunk));
+            stream.on('error', done);
+            stream.on('end', () => {
+                // smtp-server has already removed the dot-stuffing (RFC 5321 section 4.5.2)
+                imapServer.appendMessage('INBOX', [], false, Buffer.concat(chunks).toString('binary'));
+                done();
+            });
+        }
+    });
+    server.on('error', (err) => {
+        if (imapServer.options.debug) {
+            console.error('SMTP server error: %s', err.message);
+        }
+    });
+    server.listen(smtpPort, () => {
+        console.log('Incoming SMTP server up and running on port %s', server.server.address().port);
+        callback?.();
+    });
+    return server;
+}

package/dist/cjs/sorting.d.ts

@@ -0,0 +1,77 @@
+import makeSearch from './commands/handlers/search.js';
+import type { Attribute, IMAPConnection, Message, ParsedCommand } from './types.js';
+/**
+ * Returns the i;unicode-casemap form of a string (RFC 5051 section 2): every character is titlecased
+ * and then decomposed (NFKD). Comparing the UTF-8 octets of the results is the collation that
+ * RFC 5256 section 7 requires for SORT and THREAD (I18NLEVEL=1, RFC 5255 section 4.5)
+ *
+ * @param {String} str Unicode string
+ * @return {Buffer} UTF-8 octets to compare with Buffer.compare
+ */
+declare function collationKey(str: string): Buffer;
+/**
+ * Extracts the base subject (RFC 5256 section 2.1) and tells if the subject marks a reply or a
+ * forward (RFC 5256 section 3, REFERENCES): the extraction removed a subj-refwd, a "(fwd)" trailer
+ * or a subj-fwd-hdr and subj-fwd-trl pair.
+ *
+ * @param {String} subject Subject header value as a binary string
+ * @return {Object} `{ subject, isReply }`, subject is the base subject as a Unicode string
+ */
+declare function baseSubject(subject: string | undefined): {
+    subject: string;
+    isReply: boolean;
+};
+/**
+ * Internal date and time of a message in milliseconds (RFC 5256 ARRIVAL)
+ *
+ * @param {Object} message Message object
+ * @return {Number} timestamp, 0 if the internal date can not be parsed
+ */
+declare function arrivalTime(message: Message): number;
+/**
+ * Sent date of a message in milliseconds (RFC 5256 section 2.2): the Date header normalized to UTC.
+ * An invalid zone is read as UTC and an invalid time as 00:00:00, and if the header is missing or
+ * has no valid date, the internal date is used instead.
+ *
+ * @param {Object} message Message object
+ * @return {Number} timestamp
+ */
+declare function sentTime(message: Message): number;
+/**
+ * addr-mailbox of the first address in a header (RFC 5256 CC, FROM and TO), empty if there is none
+ *
+ * @param {Object} message Message object
+ * @param {String} header "from", "to" or "cc"
+ * @return {String} Unicode string
+ */
+declare function addressMailbox(message: Message, header: string): string;
+/**
+ * DISPLAY sort value of the first address in a header (RFC 5957 sections 3 and 4): the decoded
+ * addr-name, or addr-mailbox@addr-host, or addr-mailbox, or the empty string
+ *
+ * @param {Object} message Message object
+ * @param {String} header "from" or "to"
+ * @return {String} Unicode string
+ */
+declare function displayAddress(message: Message, header: string): string;
+/**
+ * Lists the Message IDs in a header value, normalized so that quoting does not matter (RFC 5256
+ * section 3, REFERENCES): comments and white space are dropped and a quoted id-left is unquoted.
+ * Only ids of the form "<" id-left "@" id-right ">" (RFC 5322 section 3.6.4) are valid.
+ *
+ * @param {String|Array} value Header value
+ * @return {Array} Message IDs
+ */
+declare function parseMessageIds(value: string | string[] | undefined): string[];
+/**
+ * Runs the search part of SORT and THREAD (RFC 5256 section 3): the charset is mandatory and the
+ * criteria follow it, both as in SEARCH. Sends a tagged BAD or NO response if the search fails.
+ *
+ * @param {Object} connection IMAP connection
+ * @param {Object} parsed Parsed command
+ * @param {String} data Raw command
+ * @param {Array} attributes Command arguments starting with the charset
+ * @return {Object|Boolean} `{ list, numbers }` like the SEARCH handler returns, or false after an error
+ */
+declare function searchMessages(connection: IMAPConnection, parsed: ParsedCommand, data: string, attributes: Attribute[]): ReturnType<typeof makeSearch> | false;
+export { collationKey, baseSubject, arrivalTime, sentTime, addressMailbox, displayAddress, parseMessageIds, searchMessages };

package/dist/cjs/sorting.js

@@ -0,0 +1,290 @@
+"use strict";
+// Message values for SORT and THREAD (RFC 5256): string collation, base subject, sent date,
+// addresses and Message IDs, and the search step that both commands start with
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collationKey = collationKey;
+exports.baseSubject = baseSubject;
+exports.arrivalTime = arrivalTime;
+exports.sentTime = sentTime;
+exports.addressMailbox = addressMailbox;
+exports.displayAddress = displayAddress;
+exports.parseMessageIds = parseMessageIds;
+exports.searchMessages = searchMessages;
+const mimeparser_js_1 = require("./mimeparser.js");
+const envelope_js_1 = require("./envelope.js");
+const dates_js_1 = require("./dates.js");
+const search_js_1 = __importDefault(require("./commands/handlers/search.js"));
+const search_js_2 = require("./commands/handlers/search.js");
+const encoded_words_js_1 = require("./encoded-words.js");
+// UnicodeData.txt titlecase mappings that differ from the single code point uppercase mapping
+// that String#toUpperCase gives: the Latin digraphs and the Greek letters with ypogegrammeni
+const TITLECASE = new Map([
+    [0x01c4, 0x01c5],
+    [0x01c6, 0x01c5],
+    [0x01c7, 0x01c8],
+    [0x01c9, 0x01c8],
+    [0x01ca, 0x01cb],
+    [0x01cc, 0x01cb],
+    [0x01f1, 0x01f2],
+    [0x01f3, 0x01f2],
+    [0x1fb3, 0x1fbc],
+    [0x1fc3, 0x1fcc],
+    [0x1ff3, 0x1ffc]
+]);
+for (const start of [0x1f80, 0x1f90, 0x1fa0]) {
+    for (let i = 0; i < 8; i++) {
+        TITLECASE.set(start + i, start + i + 8);
+    }
+}
+/**
+ * Returns the i;unicode-casemap form of a string (RFC 5051 section 2): every character is titlecased
+ * and then decomposed (NFKD). Comparing the UTF-8 octets of the results is the collation that
+ * RFC 5256 section 7 requires for SORT and THREAD (I18NLEVEL=1, RFC 5255 section 4.5)
+ *
+ * @param {String} str Unicode string
+ * @return {Buffer} UTF-8 octets to compare with Buffer.compare
+ */
+function collationKey(str) {
+    let result = '';
+    for (const char of str) {
+        const code = char.codePointAt(0);
+        if (TITLECASE.has(code)) {
+            result += String.fromCodePoint(TITLECASE.get(code));
+            continue;
+        }
+        // full case mappings (e.g. "ß" to "SS") are not the simple mapping of UnicodeData.txt
+        const upper = char.toUpperCase();
+        result += [...upper].length === 1 ? upper : char;
+    }
+    return Buffer.from(result.normalize('NFKD'), 'utf-8');
+}
+// RFC 5256 section 5: subj-refwd = ("re" / ("fw" ["d"])) *WSP [subj-blob] ":", subj-blob = "[" *BLOBCHAR "]" *WSP
+const SUBJ_BLOB = '\\[[^[\\]]*\\] *';
+const SUBJ_LEADER = new RegExp('^(?:' + SUBJ_BLOB + ')*(?:re|fwd?) *(?:' + SUBJ_BLOB + ')?:', 'i');
+const SUBJ_BLOB_PREFIX = new RegExp('^' + SUBJ_BLOB);
+/**
+ * Extracts the base subject (RFC 5256 section 2.1) and tells if the subject marks a reply or a
+ * forward (RFC 5256 section 3, REFERENCES): the extraction removed a subj-refwd, a "(fwd)" trailer
+ * or a subj-fwd-hdr and subj-fwd-trl pair.
+ *
+ * @param {String} subject Subject header value as a binary string
+ * @return {Object} `{ subject, isReply }`, subject is the base subject as a Unicode string
+ */
+function baseSubject(subject) {
+    let isReply = false;
+    // (1) decode encoded words, tabs and continuations become a space, runs of spaces one space
+    let text = (0, encoded_words_js_1.decodeHeader)(subject)
+        .replace(/\r?\n(?=[ \t])/g, '')
+        .replace(/[\t\r\n]/g, ' ')
+        .replace(/ {2,}/g, ' ');
+    for (;;) {
+        // (2) remove subj-trailer text until there is none
+        let end = text.length;
+        for (;;) {
+            if (text.charAt(end - 1) === ' ') {
+                end--;
+            }
+            else if (end >= 5 && text.substring(end - 5, end).toLowerCase() === '(fwd)') {
+                isReply = true;
+                end -= 5;
+            }
+            else {
+                break;
+            }
+        }
+        text = text.substring(0, end);
+        // (3) remove subj-leader text, (4) remove a subj-blob prefix if a subj-base remains, (5) repeat
+        for (;;) {
+            let match;
+            if (text.charAt(0) === ' ') {
+                text = text.substr(1);
+            }
+            else if ((match = text.match(SUBJ_LEADER))) {
+                isReply = true;
+                text = text.substr(match[0].length);
+            }
+            else if ((match = text.match(SUBJ_BLOB_PREFIX)) && match[0].length < text.length) {
+                text = text.substr(match[0].length);
+            }
+            else {
+                break;
+            }
+        }
+        // (6) unwrap "[fwd: ... ]" and start over from step (2)
+        if (/^\[fwd:/i.test(text) && /\]$/.test(text)) {
+            isReply = true;
+            text = text.slice(5, -1);
+            continue;
+        }
+        // (7) the remaining text is the base subject
+        return { subject: text, isReply };
+    }
+}
+/**
+ * Internal date and time of a message in milliseconds (RFC 5256 ARRIVAL)
+ *
+ * @param {Object} message Message object
+ * @return {Number} timestamp, 0 if the internal date can not be parsed
+ */
+function arrivalTime(message) {
+    const date = (0, dates_js_1.parseDateTime)(message.internaldate);
+    return date ? (0, dates_js_1.toTimestamp)(date) : 0;
+}
+/**
+ * Sent date of a message in milliseconds (RFC 5256 section 2.2): the Date header normalized to UTC.
+ * An invalid zone is read as UTC and an invalid time as 00:00:00, and if the header is missing or
+ * has no valid date, the internal date is used instead.
+ *
+ * @param {Object} message Message object
+ * @return {Number} timestamp
+ */
+function sentTime(message) {
+    const date = (0, dates_js_1.parseHeaderDate)((0, mimeparser_js_1.getMessageData)(message).tree.parsedHeader.date);
+    if (!date) {
+        return arrivalTime(message);
+    }
+    // the parsers set minutes and seconds together with hours
+    if (date.hours === undefined || date.hours > 23 || date.minutes > 59 || date.seconds > 60) {
+        Object.assign(date, { hours: 0, minutes: 0, seconds: 0 });
+    }
+    return (0, dates_js_1.toTimestamp)(date);
+}
+/**
+ * Returns the first address of an envelope address list, as [name, adl, mailbox, host]
+ */
+function firstAddress(message, header) {
+    const list = (0, envelope_js_1.processAddress)((0, mimeparser_js_1.getMessageData)(message).tree.parsedHeader[header]);
+    return (list && list[0]) || null;
+}
+/**
+ * addr-mailbox of the first address in a header (RFC 5256 CC, FROM and TO), empty if there is none
+ *
+ * @param {Object} message Message object
+ * @param {String} header "from", "to" or "cc"
+ * @return {String} Unicode string
+ */
+function addressMailbox(message, header) {
+    const address = firstAddress(message, header);
+    return address && address[2] ? (0, encoded_words_js_1.decodeHeader)(address[2]) : '';
+}
+/**
+ * DISPLAY sort value of the first address in a header (RFC 5957 sections 3 and 4): the decoded
+ * addr-name, or addr-mailbox@addr-host, or addr-mailbox, or the empty string
+ *
+ * @param {Object} message Message object
+ * @param {String} header "from" or "to"
+ * @return {String} Unicode string
+ */
+function displayAddress(message, header) {
+    const address = firstAddress(message, header);
+    const name = address && address[0] ? (0, encoded_words_js_1.decodeHeader)(address[0]) : '';
+    if (name || !address || !address[2]) {
+        return name;
+    }
+    return (0, encoded_words_js_1.decodeHeader)(address[3] ? address[2] + '@' + address[3] : address[2]);
+}
+/**
+ * Lists the Message IDs in a header value, normalized so that quoting does not matter (RFC 5256
+ * section 3, REFERENCES): comments and white space are dropped and a quoted id-left is unquoted.
+ * Only ids of the form "<" id-left "@" id-right ">" (RFC 5322 section 3.6.4) are valid.
+ *
+ * @param {String|Array} value Header value
+ * @return {Array} Message IDs
+ */
+function parseMessageIds(value) {
+    const str = [].concat(value || []).join(' ');
+    const ids = [];
+    let depth = 0;
+    let quoted = false;
+    let current = null;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charAt(i);
+        if (quoted) {
+            if (char === '\\') {
+                if (current !== null) {
+                    current += str.charAt(i + 1);
+                }
+                i++;
+            }
+            else if (char === '"') {
+                quoted = false;
+            }
+            else if (current !== null) {
+                current += char;
+            }
+        }
+        else if (depth) {
+            if (char === '\\') {
+                i++;
+            }
+            else if (char === '(') {
+                depth++;
+            }
+            else if (char === ')') {
+                depth--;
+            }
+        }
+        else if (char === '"') {
+            quoted = true;
+        }
+        else if (char === '(') {
+            depth++;
+        }
+        else if (char === '<') {
+            current = '';
+        }
+        else if (char === '>') {
+            if (current !== null) {
+                const at = current.lastIndexOf('@');
+                if (at > 0 && at < current.length - 1) {
+                    ids.push(current);
+                }
+            }
+            current = null;
+        }
+        else if (current !== null && !/\s/.test(char)) {
+            current += char;
+        }
+    }
+    return ids;
+}
+/**
+ * Runs the search part of SORT and THREAD (RFC 5256 section 3): the charset is mandatory and the
+ * criteria follow it, both as in SEARCH. Sends a tagged BAD or NO response if the search fails.
+ *
+ * @param {Object} connection IMAP connection
+ * @param {Object} parsed Parsed command
+ * @param {String} data Raw command
+ * @param {Array} attributes Command arguments starting with the charset
+ * @return {Object|Boolean} `{ list, numbers }` like the SEARCH handler returns, or false after an error
+ */
+function searchMessages(connection, parsed, data, attributes) {
+    const command = parsed.command.toUpperCase();
+    const charset = attributes[0];
+    try {
+        // RFC 5256 section 5: charset = atom / quoted
+        if (attributes.length < 2) {
+            throw (0, search_js_2.badError)(command + ' expects a charset and search criteria');
+        }
+        if (!charset || ['ATOM', 'STRING'].indexOf(charset.type) < 0) {
+            throw (0, search_js_2.badError)('Charset must be an atom or a quoted string');
+        }
+        const criteria = (0, search_js_2.criteriaValues)(attributes.slice(1));
+        if (connection.searchCharset) {
+            // RFC 9755 section 3: with a fixed session charset (UTF8=ACCEPT) other charsets are BAD
+            if (charset.value.toUpperCase() !== connection.searchCharset) {
+                throw (0, search_js_2.badError)('Charset must be ' + connection.searchCharset + ' in this session');
+            }
+            return (0, search_js_1.default)(connection, connection.getSessionMessages(), criteria);
+        }
+        const params = ['CHARSET', charset.value].concat(criteria);
+        return (0, search_js_1.default)(connection, connection.getSessionMessages(), params);
+    }
+    catch (E) {
+        (0, search_js_2.sendSearchError)(connection, parsed, data, E, command + ' FAILED');
+        return false;
+    }
+}

package/dist/cjs/threading.d.ts

@@ -0,0 +1,30 @@
+import type { IMAPServer, Message } from './types.js';
+/** A searched message with the values that threading looks at */
+export interface ThreadEntry {
+    message: Message;
+    seq: number;
+    /** sent date, see sentTime() */
+    date: number;
+    /** the base subject as a binary string of its collation key, and if the subject marks a reply or forward */
+    subject: {
+        id: string;
+        isReply: boolean;
+    };
+}
+/** A node of a thread tree, a node without an entry is a dummy */
+export interface ThreadNode {
+    entry: ThreadEntry | null;
+    parent: ThreadNode | null;
+    children: ThreadNode[];
+}
+/** A threading algorithm, returns the top level nodes */
+export type ThreadAlgorithm = (entries: ThreadEntry[]) => ThreadNode[];
+/**
+ * Adds the THREAD and UID THREAD commands, unless another algorithm plugin did already, and the
+ * THREAD=<algorithm> capability
+ *
+ * @param {Object} server IMAP server
+ * @param {String} algorithm "ORDEREDSUBJECT" or "REFERENCES"
+ */
+declare function addThreadAlgorithm(server: IMAPServer, algorithm: string): void;
+export { addThreadAlgorithm };