@withbuddi/buddi 0.1.0-pre.21 → 0.1.0-pre.23

package/node_modules/imapflow/dist/cjs/search-compiler.js

@@ -91,6 +91,17 @@ let processDateField = (attributes, term, value) => {
 };
 // Pre-compiled regex for better performance
 const UNICODE_PATTERN = /[^\x00-\x7F]/;
+/**
+ * Throws a coded search compilation error.
+ *
+ * @param code - Error code, one of the ImapFlowErrorCode values
+ * @param message - Error message
+ */
+let fail = (code, message) => {
+    let error = new Error(message);
+    error.code = code;
+    throw error;
+};
 /**
  * Checks if a string contains Unicode characters.
  * Used to determine if CHARSET UTF-8 needs to be specified.
@@ -110,7 +121,7 @@ let isUnicodeString = (str) => {
  * Compiles a JavaScript object query into IMAP search command attributes.
  * Supports standard IMAP search criteria and extensions like OBJECTID and Gmail extensions.
  *
- * @param connection - IMAP connection object (capabilities, enabled extensions and the current mailbox are read)
+ * @param connection - IMAP connection object (capabilities and enabled extensions are read)
  * @param query - Search query object
  * @returns Array of IMAP search attributes
  * @throws {Error} When required server extensions are not available
@@ -136,21 +147,29 @@ const searchCompiler = (connection, query) => {
     const attributes = [];
     // Track if we need to specify UTF-8 charset
     let hasUnicode = false;
-    const mailbox = connection.mailbox;
     /**
      * Recursively walks through the query object and builds IMAP attributes.
      * @param params - Query parameters to process
      */
     const walk = (params) => {
-        // Walks a query object and wraps the resulting attributes in a
-        // sub-array so the IMAP compiler emits parentheses around them.
-        // Used when a single search-key is required (NOT, OR operands)
-        // but the condition has multiple keys (RFC 3501 Section 6.4.4).
-        let walkGrouped = (obj) => {
+        // Compiles one NOT or OR operand, which the caller has already put its operator in
+        // front of. An operand with several keys is wrapped in a sub-array so the IMAP compiler
+        // emits parentheses around it, as the operator takes a single search-key
+        // (RFC 3501 Section 6.4.4). An operand that compiles to nothing (an invalid date, an
+        // empty object, ...) is refused: the operator would otherwise bind to whatever
+        // criterion follows it and invert or widen the search.
+        let walkOperand = (operator, obj) => {
             let startIdx = attributes.length;
-            walk(obj);
-            let subAttrs = attributes.splice(startIdx);
-            attributes.push(subAttrs);
+            if (obj && typeof obj === 'object') {
+                walk(obj);
+            }
+            if (attributes.length === startIdx) {
+                fail('InvalidSearchQuery', `Search operand for ${operator} does not include any usable search criteria`);
+            }
+            if (Object.keys(obj).length > 1) {
+                let subAttrs = attributes.splice(startIdx);
+                attributes.push(subAttrs);
+            }
         };
         Object.keys(params || {}).forEach(term => {
             switch (term.toUpperCase()) {
@@ -196,9 +215,7 @@ const searchCompiler = (connection, query) => {
                         // reject the whole search with a tagged BAD, so fail with a
                         // descriptive error instead
                         if ((0, tools_js_1.isRev2Active)(connection)) {
-                            let error = new Error(`The "${term.toLowerCase()}" search key does not exist in IMAP4rev2`);
-                            error.code = 'MissingServerExtension';
-                            throw error;
+                            fail('MissingServerExtension', `The "${term.toLowerCase()}" search key does not exist in IMAP4rev2`);
                         }
                         setBoolOpt(attributes, term, true);
                     }
@@ -244,6 +261,11 @@ const searchCompiler = (connection, query) => {
                         // Fallback to Gmail message ID
                         setOpt(attributes, 'X-GM-MSGID', params[term]);
                     }
+                    else if (params[term]) {
+                        // Dropping the criterion would widen the search to every message
+                        // matching the rest of the query, which a delete or move acts on
+                        fail('MissingServerExtension', 'Server does not support OBJECTID or X-GM-EXT-1 extension required for EMAILID');
+                    }
                     break;
                 // Thread ID support (OBJECTID or Gmail extension)
                 case 'THREADID':
@@ -254,6 +276,11 @@ const searchCompiler = (connection, query) => {
                         // Fallback to Gmail thread ID
                         setOpt(attributes, 'X-GM-THRID', params[term]);
                     }
+                    else if (params[term]) {
+                        // Dropping the criterion would widen the search to every message
+                        // matching the rest of the query, which a delete or move acts on
+                        fail('MissingServerExtension', 'Server does not support OBJECTID or X-GM-EXT-1 extension required for THREADID');
+                    }
                     break;
                 // Gmail raw search
                 case 'GMRAW':
@@ -265,9 +292,7 @@ const searchCompiler = (connection, query) => {
                         setOpt(attributes, 'X-GM-RAW', params[term]);
                     }
                     else {
-                        let error = new Error('Server does not support X-GM-EXT-1 extension required for X-GM-RAW');
-                        error.code = 'MissingServerExtension';
-                        throw error;
+                        fail('MissingServerExtension', 'Server does not support X-GM-EXT-1 extension required for X-GM-RAW');
                     }
                     break;
                 // Gmail label search. Compiles { has, not } into an X-GM-RAW "label:"/"-label:" query
@@ -301,9 +326,7 @@ const searchCompiler = (connection, query) => {
                         break;
                     }
                     if (!connection.capabilities.has('X-GM-EXT-1')) {
-                        let error = new Error('Server does not support X-GM-EXT-1 extension required for label search');
-                        error.code = 'MissingServerExtension';
-                        throw error;
+                        fail('MissingServerExtension', 'Server does not support X-GM-EXT-1 extension required for label search');
                     }
                     let rawQuery = rawParts.join(' ');
                     if (isUnicodeString(rawQuery)) {
@@ -347,8 +370,10 @@ const searchCompiler = (connection, query) => {
                 case 'UNKEYWORD':
                     {
                         let flag = (0, tools_js_1.formatFlag)(params[term]);
-                        // Only add if flag is supported or already exists in mailbox
-                        if ((0, tools_js_1.canUseFlag)(mailbox, flag) || mailbox.flags.has(flag)) {
+                        // Compiled even when the mailbox does not allow the keyword: the
+                        // correct answer is then the empty set, which dropping the
+                        // criterion would turn into every message matching the rest
+                        if (flag) {
                             setOpt(attributes, term, flag);
                         }
                     }
@@ -377,12 +402,7 @@ const searchCompiler = (connection, query) => {
                 case 'NOT':
                     if (params[term] && typeof params[term] === 'object') {
                         attributes.push({ type: 'ATOM', value: 'NOT' });
-                        if (Object.keys(params[term]).length > 1) {
-                            walkGrouped(params[term]);
-                        }
-                        else {
-                            walk(params[term]);
-                        }
+                        walkOperand('NOT', params[term]);
                     }
                     break;
                 // OR operator - complex logic for building OR trees
@@ -441,14 +461,7 @@ const searchCompiler = (connection, query) => {
                                 entry.forEach(walkOrTree);
                                 return;
                             }
-                            if (entry && typeof entry === 'object') {
-                                if (Object.keys(entry).length > 1) {
-                                    walkGrouped(entry);
-                                }
-                                else {
-                                    walk(entry);
-                                }
-                            }
+                            walkOperand('OR', entry);
                         };
                         walkOrTree(genOrTree(params[term]));
                     }

package/node_modules/imapflow/dist/cjs/tools.js

@@ -816,11 +816,18 @@ async function formatMessageResponse(untagged, mailbox) {
             case 'flags':
                 map.flags = new Set(getArray(attribute));
                 break;
+            // A server with nothing to report can answer ENVELOPE NIL or BODYSTRUCTURE NIL.
+            // The field is left unset then: parsing NIL threw, and the whole message
+            // disappeared from the FETCH result.
             case 'envelope':
-                map.envelope = parseEnvelope(attribute);
+                if (Array.isArray(attribute)) {
+                    map.envelope = parseEnvelope(attribute);
+                }
                 break;
             case 'bodystructure':
-                map.bodyStructure = parseBodystructure(attribute);
+                if (Array.isArray(attribute)) {
+                    map.bodyStructure = parseBodystructure(attribute);
+                }
                 break;
             case 'internaldate': {
                 let value = getString(attribute);

package/node_modules/imapflow/dist/esm/commands/list.js

@@ -148,10 +148,12 @@ export default async function list(connection, reference, mailbox, options) {
                         if (!untagged.attributes || !untagged.attributes.length) {
                             return;
                         }
+                        // A name sent as a literal arrives as a Buffer, so convert it once for both fields
+                        let rawPath = ((untagged.attributes[2] && untagged.attributes[2].value) || '').toString();
                         let entry = {
                             // Decode from modified UTF-7 wire format and normalize the path
-                            path: normalizePath(connection, decodePath(connection, ((untagged.attributes[2] && untagged.attributes[2].value) || ''))),
-                            pathAsListed: ((untagged.attributes[2] && untagged.attributes[2].value) || ''),
+                            path: normalizePath(connection, decodePath(connection, rawPath)),
+                            pathAsListed: rawPath,
                             flags: new Set(getStringList(untagged.attributes[0])),
                             delimiter: (untagged.attributes[1] && untagged.attributes[1].value),
                             listed: true
@@ -379,9 +381,11 @@ export default async function list(connection, reference, mailbox, options) {
                         if (!untagged.attributes || !untagged.attributes.length) {
                             return;
                         }
+                        // A name sent as a literal arrives as a Buffer, so convert it once for both fields
+                        let rawPath = ((untagged.attributes[2] && untagged.attributes[2].value) || '').toString();
                         let entry = {
-                            path: normalizePath(connection, decodePath(connection, ((untagged.attributes[2] && untagged.attributes[2].value) || ''))),
-                            pathAsListed: ((untagged.attributes[2] && untagged.attributes[2].value) || ''),
+                            path: normalizePath(connection, decodePath(connection, rawPath)),
+                            pathAsListed: rawPath,
                             flags: new Set(getStringList(untagged.attributes[0])),
                             delimiter: (untagged.attributes[1] && untagged.attributes[1].value),
                             subscribed: true
@@ -447,15 +451,23 @@ export default async function list(connection, reference, mailbox, options) {
         // Resolve special-use conflicts. Each type goes to one mailbox and each mailbox gets
         // at most one type. Candidates are taken in priority order across all types (user >
         // extension > name, then alphabetically), so a mailbox claimed by a stronger match
-        // leaves its other type to that type's next candidate instead of to nobody.
+        // leaves its other type to that type's next candidate instead of to nobody. Within a
+        // source a shallower mailbox wins before the alphabetical order is consulted, so that
+        // INBOX.Sent is preferred over INBOX.Archive.Sent.
         let candidates = Object.entries(specialUseMatches).flatMap(([type, matches]) => matches.map(match => ({ type, ...match })));
         candidates.sort((a, b) => {
             let aSource = SOURCE_SORT_ORDER.indexOf(a.source);
             let bSource = SOURCE_SORT_ORDER.indexOf(b.source);
-            if (aSource === bSource) {
-                return a.entry.path.localeCompare(b.entry.path);
+            if (aSource !== bSource) {
+                return aSource - bSource;
             }
-            return aSource - bSource;
+            // parent is set on every listed entry before the candidates are ranked
+            let aDepth = a.entry.parent.length;
+            let bDepth = b.entry.parent.length;
+            if (aDepth !== bDepth) {
+                return aDepth - bDepth;
+            }
+            return a.entry.path.localeCompare(b.entry.path);
         });
         let assignedTypes = new Set();
         for (let { type, entry, source } of candidates) {

package/node_modules/imapflow/dist/esm/errors.d.ts

@@ -37,12 +37,14 @@ export declare const ImapFlowErrorCode: {
     readonly InvalidTokenValue: "InvalidTokenValue";
     readonly InvalidTextValue: "InvalidTextValue";
     readonly InvalidSequenceSet: "InvalidSequenceSet";
+    readonly InvalidSearchQuery: "InvalidSearchQuery";
     readonly DownloadOverflow: "DownloadOverflow";
     readonly DownloadIncomplete: "DownloadIncomplete";
     readonly ProxyError: "ProxyError";
     readonly EPROXY: "EPROXY";
     readonly UnsupportedProxyAddress: "UnsupportedProxyAddress";
     readonly ERR_INVALID_URL: "ERR_INVALID_URL";
+    readonly InstanceReused: "InstanceReused";
 };
 /** One of the {@link ImapFlowErrorCode} values */
 export type ImapFlowErrorCode = (typeof ImapFlowErrorCode)[keyof typeof ImapFlowErrorCode];

package/node_modules/imapflow/dist/esm/errors.js

@@ -41,6 +41,7 @@ export const ImapFlowErrorCode = {
     InvalidTokenValue: 'InvalidTokenValue',
     InvalidTextValue: 'InvalidTextValue',
     InvalidSequenceSet: 'InvalidSequenceSet',
+    InvalidSearchQuery: 'InvalidSearchQuery',
     // download()
     DownloadOverflow: 'DownloadOverflow',
     DownloadIncomplete: 'DownloadIncomplete',
@@ -48,7 +49,9 @@ export const ImapFlowErrorCode = {
     ProxyError: 'ProxyError',
     EPROXY: 'EPROXY',
     UnsupportedProxyAddress: 'UnsupportedProxyAddress',
-    ERR_INVALID_URL: 'ERR_INVALID_URL'
+    ERR_INVALID_URL: 'ERR_INVALID_URL',
+    // API misuse
+    InstanceReused: 'InstanceReused'
 };
 /**
  * Error subclass thrown when IMAP authentication fails.

package/node_modules/imapflow/dist/esm/handler/imap-stream.js

@@ -1,5 +1,5 @@
 import { Transform } from 'node:stream';
-import logger from '../logger.js';
+import { createConnectionLogger } from '../logger.js';
 import { MAX_LITERAL_SIZE, MAX_LINE_SIZE, MAX_RESPONSE_SIZE, normalizeLimit, createLiteralTooLargeError } from './limits.js';
 const LINE = 0x01;
 const LITERAL = 0x02;
@@ -30,13 +30,12 @@ export class ImapStream extends Transform {
         });
         this.options = options || {};
         this.cid = this.options.cid;
-        this.log =
-            this.options.logger && typeof this.options.logger === 'object'
-                ? this.options.logger
-                : logger.child({
-                    component: 'imap-connection',
-                    cid: this.cid
-                });
+        if (this.options.logger && typeof this.options.logger === 'object') {
+            this.log = this.options.logger;
+        }
+        else {
+            this.log = createConnectionLogger({ cid: this.cid, logRaw: this.options.logRaw });
+        }
         this.readBytesCounter = 0;
         // Maximum length of a single line (response without a literal). Bounds the line buffer
         // so a server that never sends a line terminator cannot exhaust memory.

package/node_modules/imapflow/dist/esm/imap-flow.js

@@ -7,7 +7,7 @@ import crypto from 'node:crypto';
 import zlib from 'node:zlib';
 import { EventEmitter } from 'node:events';
 import { PassThrough } from 'node:stream';
-import logger from './logger.js';
+import { createConnectionLogger } from './logger.js';
 import * as packageInfo from './package-info.js';
 import { ImapStream } from './handler/imap-stream.js';
 import { parser, compiler } from './handler/imap-handler.js';
@@ -1890,9 +1890,17 @@ export class ImapFlow extends EventEmitter {
     async connect() {
         if (this._connectCalled) {
             // Prevent re-using ImapFlow instances by allowing to call connect just once.
-            throw new Error('Can not re-use ImapFlow instance');
+            let err = new Error('Can not re-use ImapFlow instance');
+            err.code = 'InstanceReused';
+            throw err;
         }
         this._connectCalled = true;
+        let closedError = () => this.createNoConnectionError(this.byeReason, { rejectedFrom: 'connect' });
+        // close() already ran, so there is no connection to set up and nothing would ever
+        // settle a connect attempt started now.
+        if (this.isClosed) {
+            throw closedError();
+        }
         // One deadline for the whole attempt, started before anything is resolved or negotiated.
         // Proxy DNS and proxy negotiation used to run entirely outside the timer, so a stalled
         // proxy could hang far beyond the documented connectionTimeout.
@@ -1938,9 +1946,20 @@ export class ImapFlow extends EventEmitter {
                 error._err = err;
                 throw error;
             }
+            // close() during proxy setup found no socket to destroy and no connect to reject,
+            // so the tunnel that just opened is dropped here instead of being handed to a
+            // closed client.
+            if (this.isClosed) {
+                socket.destroy();
+                throw closedError();
+            }
         }
         // Guarded: close() rejects a pending connect() synchronously. See guardedPromise().
         let connectPromise = guardedPromise((resolve, reject) => {
+            // Stored before the transport is up, so a close() that lands before onConnect
+            // still rejects this attempt through closeConnectSteps().
+            this.initialResolve = resolve;
+            this.initialReject = reject;
             // Whatever the proxy phase already used is gone from the budget
             this.connectTimeout = setTimeout(() => {
                 let err = deadline.error();
@@ -1992,9 +2011,6 @@ export class ImapFlow extends EventEmitter {
                     this.setSocketHandlers();
                     this.setEventHandlers();
                     connected.pipe(this.streamer);
-                    // executed by initial "* OK"
-                    this.initialResolve = resolve;
-                    this.initialReject = reject;
                     /* c8 ignore next 4 */ // defensive: the onConnect setup body does not throw under normal operation
                 }
                 catch (ex) {
@@ -2178,7 +2194,10 @@ export class ImapFlow extends EventEmitter {
             this._upgradeReject = null;
             reject(this.createNoConnectionError(false, { rejectedFrom: 'upgrade' }));
         }
-        if (typeof this.initialReject === 'function' && !this.options.verifyOnly) {
+        // A verifyOnly session closes itself with LOGOUT and startSession() settles connect()
+        // with the outcome, so the close is not a failure there. Before the greeting nothing
+        // else can settle it (BYE greeting, FIN, close() while the transport is still coming up).
+        if (typeof this.initialReject === 'function' && (!this.options.verifyOnly || !this.greetingReceived)) {
             clearTimer(this.greetingTimeout);
             let reject = this.initialReject;
             this.initialResolve = false;
@@ -2489,7 +2508,26 @@ export class ImapFlow extends EventEmitter {
      * // 125
      */
     async mailboxOpen(path, options) {
-        return await this.run('SELECT', path, options);
+        try {
+            return await this.run('SELECT', path, options);
+        }
+        catch (err) {
+            if (err.responseStatus === 'NO') {
+                // SELECT failed with NO: verify whether the mailbox exists at all by running
+                // LIST. This sets mailboxMissing on the error so the caller can distinguish
+                // "doesn't exist" from other failures, for getMailboxLock() callers as well.
+                try {
+                    let folders = await this.run('LIST', '', normalizePath(this, path), { listOnly: true });
+                    if (!folders || !folders.length) {
+                        err.mailboxMissing = true;
+                    }
+                }
+                catch (E) {
+                    this.log.trace({ msg: 'Failed to verify failed mailbox', path, err: E });
+                }
+            }
+            throw err;
+        }
     }
     /**
      * Closes a previously opened mailbox
@@ -3191,20 +3229,7 @@ export class ImapFlow extends EventEmitter {
                     break; // Wait for this lock to be released
                 }
                 catch (err) {
-                    if (err.responseStatus === 'NO') {
-                        // SELECT failed with NO: verify whether the mailbox exists
-                        // at all by running LIST. This sets mailboxMissing on the error
-                        // so the caller can distinguish "doesn't exist" from other failures.
-                        try {
-                            let folders = await this.run('LIST', '', path, { listOnly: true });
-                            if (!folders || !folders.length) {
-                                err.mailboxMissing = true;
-                            }
-                        }
-                        catch (E) {
-                            this.log.trace({ msg: 'Failed to verify failed mailbox', path, err: E });
-                        }
-                    }
+                    // mailboxOpen() has already marked a missing mailbox (mailboxMissing)
                     this.log.trace({
                         msg: 'Failed to acquire mailbox lock',
                         path,
@@ -3295,12 +3320,14 @@ export class ImapFlow extends EventEmitter {
     }
     /** @internal */
     getLogger() {
-        let mainLogger = this.options.logger && typeof this.options.logger === 'object'
-            ? this.options.logger
-            : logger.child({
-                component: 'imap-connection',
-                cid: this.id
-            });
+        let mainLogger = {};
+        if (this.options.logger && typeof this.options.logger === 'object') {
+            mainLogger = this.options.logger;
+        }
+        else if (this.options.logger !== false) {
+            // {logger:false} never consults mainLogger, so it does not create the default logger
+            mainLogger = createConnectionLogger({ cid: this.id, logRaw: this.options.logRaw });
+        }
         let synteticLogger = {};
         let levels = ['trace', 'debug', 'info', 'warn', 'error', 'fatal'];
         for (let level of levels) {

package/node_modules/imapflow/dist/esm/logger.d.ts

@@ -1,3 +1,21 @@
-import pino from 'pino';
-declare const logger: pino.Logger<never, boolean>;
-export default logger;
+import { type Logger as PinoLogger } from 'pino';
+/**
+ * Returns the shared default logger, used when a connection is given no logger of its own.
+ * Created on first use, so importing the library does not set up a stdout logger nobody asked
+ * for. Level info: a caller that asks for raw socket data (logRaw) lowers its own child logger
+ * to trace.
+ *
+ * @returns The default pino logger
+ */
+export declare function getDefaultLogger(): PinoLogger;
+/**
+ * Returns the child of the default logger a connection logs through when it was given no
+ * logger of its own.
+ *
+ * @param options - cid is the connection id to stamp on entries, logRaw asks for raw socket data
+ * @returns A child logger of the default logger
+ */
+export declare function createConnectionLogger(options: {
+    cid?: string | undefined;
+    logRaw?: boolean | undefined;
+}): PinoLogger;

package/node_modules/imapflow/dist/esm/logger.js

@@ -1,4 +1,34 @@
 import pino from 'pino';
-const logger = pino();
-logger.level = 'trace';
-export default logger;
+let logger = null;
+/**
+ * Returns the shared default logger, used when a connection is given no logger of its own.
+ * Created on first use, so importing the library does not set up a stdout logger nobody asked
+ * for. Level info: a caller that asks for raw socket data (logRaw) lowers its own child logger
+ * to trace.
+ *
+ * @returns The default pino logger
+ */
+export function getDefaultLogger() {
+    if (!logger) {
+        logger = pino({ level: 'info' });
+    }
+    return logger;
+}
+/**
+ * Returns the child of the default logger a connection logs through when it was given no
+ * logger of its own.
+ *
+ * @param options - cid is the connection id to stamp on entries, logRaw asks for raw socket data
+ * @returns A child logger of the default logger
+ */
+export function createConnectionLogger(options) {
+    let child = getDefaultLogger().child({
+        component: 'imap-connection',
+        cid: options.cid
+    });
+    // Raw socket data is logged at trace level, so asking for it lowers the threshold
+    if (options.logRaw) {
+        child.level = 'trace';
+    }
+    return child;
+}

package/node_modules/imapflow/dist/esm/package-info.d.ts

@@ -1,3 +1,3 @@
 export declare const name = "imapflow";
-export declare const version = "2.1.0";
+export declare const version = "2.1.2";
 export declare const homepage = "https://imapflow.com/";

package/node_modules/imapflow/dist/esm/package-info.js

@@ -1,4 +1,4 @@
 // Generated by scripts/build.js from package.json. Do not edit by hand.
 export const name = "imapflow";
-export const version = "2.1.0";
+export const version = "2.1.2";
 export const homepage = "https://imapflow.com/";

package/node_modules/imapflow/dist/esm/search-compiler.d.ts

@@ -9,7 +9,7 @@ export type SearchAttribute = ImapAttributeNode | SearchAttribute[];
  * Compiles a JavaScript object query into IMAP search command attributes.
  * Supports standard IMAP search criteria and extensions like OBJECTID and Gmail extensions.
  *
- * @param connection - IMAP connection object (capabilities, enabled extensions and the current mailbox are read)
+ * @param connection - IMAP connection object (capabilities and enabled extensions are read)
  * @param query - Search query object
  * @returns Array of IMAP search attributes
  * @throws {Error} When required server extensions are not available