imapkit 4.0.3 → 4.1.1

package/{lib → dist/esm}/plugins/x-gm-ext-1.js

@@ -1,20 +1,13 @@
-'use strict';
-
-const search = require('../commands/handlers/search');
-const { MONTHS, isRealDate } = require('../dates');
-
-const { badError } = search;
-
+import search from '../commands/handlers/search.js';
+import { badError } from '../commands/handlers/search.js';
+import { MONTHS, isRealDate } from '../dates.js';
 // X-GM-MSGID is a 64 bit unsigned number, so it is tracked as a BigInt
-
 // Sample value from Gmail IMAP extensions API page
 // https://developers.google.com/workspace/gmail/imap/imap-extensions
 // Used as default, if server.options["HIGHESTX-GM-MSGID"]
 // is missing
 const SEED = '1278455344230334865';
-
 const MAX_UINT64 = 2n ** 64n - 1n;
-
 // X-GM-RAW mailbox shortcuts of in: and is: (Gmail search operators), as ImapKit criteria
 const RAW_SHORTCUTS = {
     'in:inbox': ['X-GM-LABELS', '\\Inbox'],
@@ -28,7 +21,6 @@ const RAW_SHORTCUTS = {
     'is:starred': ['FLAGGED'],
     'is:important': ['X-GM-LABELS', '\\Important']
 };
-
 // X-GM-RAW operators that take a value, as the search key the value is given to
 const RAW_OPERATORS = {
     from: 'FROM',
@@ -43,10 +35,8 @@ const RAW_OPERATORS = {
     before: 'BEFORE',
     rfc822msgid: 'HEADER'
 };
-
 // Gmail operators that ImapKit does not implement, answered with NO instead of a wrong result
 const RAW_UNSUPPORTED = ['is', 'has', 'list', 'filename', 'around', 'size', 'older', 'newer', 'older_than', 'newer_than', 'deliveredto', 'category'];
-
 /**
  * @help Adds Gmail specific X-GM-EXT-1 capability
  * @help (https://developers.google.com/workspace/gmail/imap/imap-extensions)
@@ -71,40 +61,35 @@ const RAW_UNSUPPORTED = ['is', 'has', 'list', 'filename', 'around', 'size', 'old
  * @help       (YYYY/MM/DD) and rfc822msgid:. Other Gmail operators are
  * @help       answered with NO
  */
-
-module.exports = function (server) {
+export default function xGmExt1Plugin(server) {
     server.registerCapability('X-GM-EXT-1');
-
     server['HIGHESTX-GM-MSGID'] = BigInt(server.options['HIGHESTX-GM-MSGID'] || SEED);
-
     // set X-GM-MSGID values when message is created / initialized
-    server.messageHandlers.push((connection, message, mailbox) => {
+    server.messageHandlers.push((server, message, mailbox) => {
         let labels;
-
         if (!message['X-GM-MSGID']) {
             server['HIGHESTX-GM-MSGID'] += 1n;
             message['X-GM-MSGID'] = server['HIGHESTX-GM-MSGID'].toString();
-        } else if (/^\d+$/.test(message['X-GM-MSGID']) && BigInt(message['X-GM-MSGID']) > server['HIGHESTX-GM-MSGID']) {
+        }
+        else if (/^\d+$/.test(message['X-GM-MSGID']) && BigInt(message['X-GM-MSGID']) > server['HIGHESTX-GM-MSGID']) {
             // Storage might be shared with another server instance, do not reuse existing values
             server['HIGHESTX-GM-MSGID'] = BigInt(message['X-GM-MSGID']);
         }
-
         // Ensure message has an array of labels
         message['X-GM-LABELS'] = [].concat(message['X-GM-LABELS'] || []);
-
         if (mailbox.path.toUpperCase() === 'INBOX') {
             labels = ['\\Inbox'];
-        } else if (mailbox['special-use'] && mailbox['special-use'].length) {
+        }
+        else if (mailbox['special-use'] && mailbox['special-use'].length) {
             labels = [].concat(mailbox['special-use']);
-        } else {
+        }
+        else {
             labels = [userLabel(mailbox.path)];
         }
-
         labels.forEach(label => {
             server.ensureFlag(message['X-GM-LABELS'], label);
         });
     });
-
     // A message starts its own thread unless storage puts it into one. With OBJECTID loaded, the messages of a THREADID
     // (RFC 8474 section 5.2) share an X-GM-THRID: the one of the first message of that thread, like Gmail uses the
     // X-GM-MSGID of the first message. This runs after every other message handler, so OBJECTID set the THREADID
@@ -121,7 +106,6 @@ module.exports = function (server) {
             }
         });
     });
-
     // Retrieve X-GM-MSGID values with FETCH
     server.fetchHandlers['X-GM-MSGID'] = function (connection, message) {
         return {
@@ -129,27 +113,23 @@ module.exports = function (server) {
             value: message['X-GM-MSGID']
         };
     };
-
     // Retrieve X-GM-LABELS values with FETCH
     server.fetchHandlers['X-GM-LABELS'] = function (connection, message) {
         return formatLabels(message);
     };
-
     // X-GM-MSGID and X-GM-THRID are 64 bit unsigned numbers
     const idArgument = () => [
-        value => {
+        (value) => {
             if (!/^\d{1,20}$/.test(value) || BigInt(value) > MAX_UINT64) {
                 throw badError('Expected a 64 bit unsigned number');
             }
             return BigInt(value).toString();
         }
     ];
-
     server.searchHandlers['X-GM-MSGID'] = function (connection, message, sequence, xGmMsgid) {
         return message['X-GM-MSGID'] === xGmMsgid;
     };
     server.searchHandlers['X-GM-MSGID'].argumentTypes = idArgument;
-
     // Retrieve X-GM-THRID values with FETCH
     server.fetchHandlers['X-GM-THRID'] = function (connection, message) {
         return {
@@ -157,15 +137,13 @@ module.exports = function (server) {
             value: message['X-GM-THRID']
         };
     };
-
     server.searchHandlers['X-GM-THRID'] = function (connection, message, sequence, xGmThrid) {
         return message['X-GM-THRID'] === xGmThrid;
     };
     server.searchHandlers['X-GM-THRID'].argumentTypes = idArgument;
-
     // SEARCH X-GM-LABELS label, the label is given in the form the session uses for mailbox names
     server.searchHandlers['X-GM-LABELS'] = function (connection, message, sequence, label) {
-        return message['X-GM-LABELS'].some(stored => {
+        return message['X-GM-LABELS'].some((stored) => {
             if (isSystemLabel(stored)) {
                 // system labels are matched without case, like flags
                 return stored.toLowerCase() === label.toLowerCase();
@@ -173,7 +151,6 @@ module.exports = function (server) {
             return connection.exportMailboxName(labelName(stored)) === label;
         });
     };
-
     // SEARCH X-GM-RAW query, a subset of the Gmail search syntax
     // the translated criteria are compiled once per SEARCH, they are the same array for every message
     const rawMatchers = new WeakMap();
@@ -186,43 +163,31 @@ module.exports = function (server) {
         return rawMatchers.get(criteria)(message, sequence);
     };
     server.searchHandlers['X-GM-RAW'].argumentTypes = () => [parseRawQuery];
-
     const setLabels = (message, labels) => {
         message['X-GM-LABELS'] = [];
         addLabels(message, labels);
     };
-
     const addLabels = (message, labels) => {
-        labels.forEach(label => server.ensureFlag(message['X-GM-LABELS'], label));
+        labels.forEach((label) => server.ensureFlag(message['X-GM-LABELS'], label));
     };
-
     const removeLabels = (message, labels) => {
-        labels.forEach(label => server.removeFlag(message['X-GM-LABELS'], label));
+        labels.forEach((label) => server.removeFlag(message['X-GM-LABELS'], label));
     };
-
     [
         ['X-GM-LABELS', setLabels],
         ['+X-GM-LABELS', addLabels],
         ['-X-GM-LABELS', removeLabels]
     ].forEach(([name, update]) => {
         // all labels are parsed before the message changes, an invalid one fails the STORE
-        const apply = (connection, message, flags) =>
-            update(
-                message,
-                flags.map(flag => parseLabel(connection, flag))
-            );
-
+        const apply = (connection, message, flags) => update(message, flags.map(flag => parseLabel(connection, flag)));
         server.storeHandlers[name] = function (connection, message, flags, index, parsed, data) {
             apply(connection, message, flags);
             sendLabelUpdate(connection, parsed, data, index, message);
         };
-
         server.storeHandlers[name + '.SILENT'] = apply;
-
         // labels are astrings (Gmail IMAP extensions): literals are accepted, NIL is a label name
         server.storeHandlers[name].astringValues = server.storeHandlers[name + '.SILENT'].astringValues = true;
     });
-
     // Gmail keeps the same X-GM-MSGID for a message in every mailbox, so copies get the value of the source message
     server.copyHandlers.push((server, source, copy) => {
         if (source['X-GM-MSGID']) {
@@ -230,17 +195,15 @@ module.exports = function (server) {
             copy['X-GM-THRID'] = source['X-GM-THRID'];
         }
     });
-};
-
+}
 /**
  * Labels are kept as strings in message["X-GM-LABELS"]. A system label like \Inbox starts with "\",
  * any other label is a mailbox name in storage form. A mailbox name that itself starts with "\" is
  * kept with one more "\" in front, so it can not be mistaken for a system label
  */
-const isSystemLabel = label => label.charAt(0) === '\\' && label.charAt(1) !== '\\';
-const userLabel = name => (name.charAt(0) === '\\' ? '\\' + name : name);
-const labelName = label => (label.charAt(0) === '\\' ? label.substr(1) : label);
-
+const isSystemLabel = (label) => label.charAt(0) === '\\' && label.charAt(1) !== '\\';
+const userLabel = (name) => (name.charAt(0) === '\\' ? '\\' + name : name);
+const labelName = (label) => (label.charAt(0) === '\\' ? label.substr(1) : label);
 /**
  * Converts a STORE X-GM-LABELS value to a stored label. An atom that starts with "\" is a system
  * label, anything else is a label name: an astring in the form the session uses for mailbox names
@@ -256,15 +219,13 @@ function parseLabel(connection, attr) {
     }
     return userLabel(connection.importMailboxName(value));
 }
-
 /**
  * Formats the labels of a message for a FETCH response. Label names are MAILBOX attributes, so the
  * session gets them in its own form and quoted when they are not atoms
  */
 function formatLabels(message) {
-    return message['X-GM-LABELS'].map(label => (isSystemLabel(label) ? { type: 'ATOM', value: label } : { type: 'MAILBOX', value: labelName(label) }));
+    return message['X-GM-LABELS'].map((label) => isSystemLabel(label) ? { type: 'ATOM', value: label } : { type: 'MAILBOX', value: labelName(label) });
 }
-
 /**
  * Translates an X-GM-RAW query (Gmail search syntax) to ImapKit search criteria. Terms are
  * ANDed, OR binds tighter than that ("a b OR c" is a AND (b OR c)), "-" negates a term, ( ) groups
@@ -284,23 +245,24 @@ function parseRawQuery(query) {
         end = re.lastIndex;
         if (match[1]) {
             tokens.push({ type: match[1] });
-        } else if (typeof match[2] === 'string') {
+        }
+        else if (typeof match[2] === 'string') {
             tokens.push({ type: 'word', value: match[2] });
-        } else if (match[3]) {
+        }
+        else if (match[3]) {
             tokens.push({ type: 'word', value: match[3] + match[4], operator: match[3].slice(0, -1), operand: match[4] });
-        } else {
+        }
+        else {
             tokens.push({ type: 'word', value: match[5] });
         }
     }
     if (query.slice(end).trim()) {
         throw badError('X-GM-RAW query has an unterminated quoted string');
     }
-
     let pos = 0;
     const peek = () => tokens[pos];
-
     // expression = 1*term, until the end or a closing bracket
-    const expression = end => {
+    const expression = (end) => {
         const terms = [];
         while (pos < tokens.length && (!peek() || peek().type !== end)) {
             terms.push(term());
@@ -316,7 +278,6 @@ function parseRawQuery(query) {
         }
         return terms.length === 1 ? terms[0] : terms;
     };
-
     // term = unary *("OR" unary)
     const term = () => {
         let result = unary();
@@ -326,7 +287,6 @@ function parseRawQuery(query) {
         }
         return result;
     };
-
     const unary = () => {
         const token = tokens[pos++];
         if (!token || token.type === ')' || token.type === '}') {
@@ -346,30 +306,31 @@ function parseRawQuery(query) {
             pos++;
             return options.reduce((any, option) => ['OR', any, option]);
         }
-        if (token.value === '-' && peek() && (peek().type === '(' || peek().type === '{')) {
+        // the brackets are handled above, a word always has a value
+        const value = token.value;
+        if (value === '-' && peek() && (peek().type === '(' || peek().type === '{')) {
             return ['NOT', unary()];
         }
-        if (token.value.charAt(0) === '-' && token.value.length > 1) {
-            return ['NOT', rawTerm(rawWord(token.value.substr(1)))];
+        if (value.charAt(0) === '-' && value.length > 1) {
+            return ['NOT', rawTerm(rawWord(value.substr(1)))];
         }
         return rawTerm(token);
     };
-
     return [expression()];
 }
-
 // splits "name:value" into an operator and an operand
 function rawWord(value) {
     const match = value.match(/^([a-z_0-9]+):(.+)$/i);
     return match ? { value, operator: match[1], operand: match[2] } : { value, operator: false, operand: false };
 }
-
 function rawTerm(token) {
-    const { operator, operand } = token.operator ? token : rawWord(token.value);
+    const word = token.operator ? token : rawWord(token.value);
+    const operator = word.operator;
     if (!operator) {
         return ['TEXT', token.value];
     }
-
+    // an operator always comes with its operand
+    const operand = word.operand;
     const name = operator.toLowerCase();
     // own keys only, names like "constructor:" are plain text
     const shortcutKey = name + ':' + operand.toLowerCase();
@@ -377,7 +338,6 @@ function rawTerm(token) {
     if (shortcut) {
         return shortcut;
     }
-
     const key = Object.hasOwn(RAW_OPERATORS, name) && RAW_OPERATORS[name];
     if (key) {
         switch (key) {
@@ -403,22 +363,18 @@ function rawTerm(token) {
                 return [key, operand];
         }
     }
-
     if (name === 'in') {
         // any other mailbox is a label
         return ['X-GM-LABELS', operand];
     }
-
     if (RAW_UNSUPPORTED.indexOf(name) >= 0) {
         const err = new Error('X-GM-RAW operator ' + name + ':' + operand + ' is not supported by imapkit');
         err.imapResponse = 'NO';
         throw err;
     }
-
     // not an operator, like "http://example.com"
     return ['TEXT', token.value];
 }
-
 function sendLabelUpdate(connection, parsed, data, index, message) {
     const resp = [
         {
@@ -427,7 +383,6 @@ function sendLabelUpdate(connection, parsed, data, index, message) {
         },
         formatLabels(message)
     ];
-
     if ((parsed.command || '').toUpperCase() === 'UID STORE') {
         resp.push({
             type: 'ATOM',
@@ -435,22 +390,15 @@ function sendLabelUpdate(connection, parsed, data, index, message) {
         });
         resp.push(message.uid);
     }
-
-    connection.send(
-        {
-            tag: '*',
-            attributes: [
-                index,
-                {
-                    type: 'ATOM',
-                    value: 'FETCH'
-                },
-                resp
-            ]
-        },
-        'FLAG UPDATE',
-        parsed,
-        data,
-        message
-    );
+    connection.send({
+        tag: '*',
+        attributes: [
+            index,
+            {
+                type: 'ATOM',
+                value: 'FETCH'
+            },
+            resp
+        ]
+    }, 'FLAG UPDATE', parsed, data, message);
 }

package/dist/esm/plugins/xoauth2.d.ts

@@ -0,0 +1,2 @@
+import type { IMAPServer } from '../types.js';
+export default function xoauth2Plugin(server: IMAPServer): void;

package/dist/esm/plugins/xoauth2.js

@@ -0,0 +1,140 @@
+// https://developers.google.com/gmail/xoauth2_protocol
+/**
+ * @help Enables XOAUTH2 capability
+ * @help Implementation difference - ImapKit requires
+ * @help SASL-IR enabled and used while Gmail does not
+ * @help Valid login info:
+ * @help   Username: testuser
+ * @help   Access Token: testtoken
+ */
+const utf8 = new TextDecoder('utf-8', { fatal: true });
+export default function xoauth2Plugin(server) {
+    // Register capability, usable for non authenticated users
+    server.registerCapability('AUTH=XOAUTH2', (connection) => {
+        return connection.state === 'Not Authenticated';
+    });
+    server.setCommandHandler('AUTHENTICATE XOAUTH2', (connection, parsed, data, callback) => {
+        if (!server.capabilities['SASL-IR'] || !server.capabilities['SASL-IR'](connection)) {
+            connection.send({
+                tag: parsed.tag,
+                command: 'BAD',
+                attributes: [
+                    {
+                        type: 'TEXT',
+                        value: 'SASL-IR must be enabled to support XOAUTH2'
+                    }
+                ]
+            }, 'AUTHENTICATE XOAUTH2 FAILED', parsed, data);
+            return callback();
+        }
+        if (!parsed.attributes || parsed.attributes.length !== 1 || !parsed.attributes[0] || ['STRING', 'ATOM'].indexOf(parsed.attributes[0].type) < 0) {
+            connection.send({
+                tag: parsed.tag,
+                command: 'NO',
+                attributes: [
+                    {
+                        type: 'TEXT',
+                        value: 'Invalid SASL argument'
+                    }
+                ]
+            }, 'AUTHENTICATE XOAUTH2 FAILED', parsed, data);
+            return callback();
+        }
+        const decoded = connection.decodeSaslResponse(parsed.attributes[0].value);
+        if (!decoded) {
+            connection.sendStatus(parsed, data, 'BAD', 'Invalid base64 in SASL response', false, 'AUTHENTICATE XOAUTH2 FAILED');
+            return callback();
+        }
+        let parts = [];
+        try {
+            // user names are unicode strings, like the keys of `users`
+            parts = utf8.decode(decoded).split('\x01');
+        }
+        catch {
+            // invalid UTF-8 is a malformed payload like any other
+        }
+        const user = (parts[0] || '').substr(5);
+        const accessToken = (parts[1] || '').substr(12);
+        if (parts.length !== 4 ||
+            !parts[0].match(/^user=/) ||
+            !parts[1].match(/^auth=Bearer /) ||
+            !user || // Must be present
+            !accessToken || // Must be present
+            parts[2] || // Must be empty
+            parts[3] // Must be empty
+        ) {
+            connection.send({
+                tag: parsed.tag,
+                command: 'NO',
+                attributes: [
+                    {
+                        type: 'TEXT',
+                        value: 'Invalid SASL argument.'
+                    }
+                ]
+            }, 'AUTHENTICATE XOAUTH2 FAILED', parsed, data);
+            return callback();
+        }
+        const userData = connection.server.getUser(user);
+        if (!userData) {
+            connection.send({
+                tag: parsed.tag,
+                command: 'NO',
+                attributes: [
+                    // RFC 5530 section 3: unknown user or bad token
+                    { type: 'SECTION', section: [{ type: 'ATOM', value: 'AUTHENTICATIONFAILED' }] },
+                    {
+                        type: 'TEXT',
+                        value: 'Invalid credentials'
+                    }
+                ]
+            }, 'AUTHENTICATE XOAUTH2 FAILED', parsed, data);
+            return callback();
+        }
+        if (!userData.xoauth2 || userData.xoauth2.accessToken !== accessToken) {
+            connection.send({
+                tag: '+',
+                attributes: [
+                    {
+                        type: 'ATOM',
+                        value: Buffer.from(JSON.stringify({
+                            status: '400',
+                            schemes: 'Bearer',
+                            scope: 'https://mail.google.com/'
+                        })).toString('base64')
+                    }
+                ]
+            }, 'AUTHENTICATE XOAUTH2 FAILED', parsed, data);
+            // wait for response
+            connection.inputHandler = function () {
+                connection.inputHandler = false;
+                connection.send({
+                    tag: parsed.tag,
+                    command: 'NO',
+                    attributes: [
+                        { type: 'SECTION', section: [{ type: 'ATOM', value: 'AUTHENTICATIONFAILED' }] },
+                        {
+                            type: 'TEXT',
+                            value: 'SASL authentication failed'
+                        }
+                    ]
+                }, 'AUTHENTICATE XOAUTH2 FAILED', parsed, data);
+            };
+        }
+        else {
+            connection.state = 'Authenticated';
+            connection.username = user;
+            connection.send({
+                tag: parsed.tag,
+                command: 'OK',
+                attributes: [
+                    {
+                        type: 'TEXT',
+                        value: 'User logged in'
+                    }
+                ]
+            }, 'AUTHENTICATE XOAUTH2 SUCCESS', parsed, data);
+        }
+        return callback();
+    });
+}

package/dist/esm/plugins/xtoybird.d.ts

@@ -0,0 +1,2 @@
+import type { IMAPServer } from '../types.js';
+export default function xtoybirdPlugin(server: IMAPServer): void;