imapflow 1.6.1 → 1.6.3

package/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-    ".": "1.6.1"
+    ".": "1.6.3"
 }

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [1.6.3](https://github.com/postalsys/imapflow/compare/v1.6.2...v1.6.3) (2026-07-28)
+
+
+### Bug Fixes
+
+* assume folders are subscribed when the server reports no subscription state ([f576e3b](https://github.com/postalsys/imapflow/commit/f576e3b0eb34ee1340b34f66e389b8c29408d80a))
+
+## [1.6.2](https://github.com/postalsys/imapflow/compare/v1.6.1...v1.6.2) (2026-07-28)
+
+
+### Bug Fixes
+
+* never fall back to LSUB on an IMAP4rev2 session ([329f588](https://github.com/postalsys/imapflow/commit/329f58829592a3c9a9f69fa74387596a3e55eac3))
+
 ## [1.6.1](https://github.com/postalsys/imapflow/compare/v1.6.0...v1.6.1) (2026-07-27)
 
 

package/lib/commands/list.js

@@ -311,6 +311,14 @@ module.exports = async (connection, reference, mailbox, options) => {
         // decision below
         let successStage = null;
 
+        // Whether any source actually reported subscription state. RETURN (SUBSCRIBED)
+        // and LSUB are the only two, and a server can refuse both
+        let subscriptionStateKnown = false;
+
+        // A server may also volunteer \Subscribed on a plain LIST, which normalizeFlags
+        // folds into the entry - that counts as the state having been reported
+        let anyEntrySubscribed = () => entries.some(entry => entry.subscribed);
+
         let lastRejectedStage = null;
         let auxRetryInserted = false;
         for (let i = 0; i < stages.length; i++) {
@@ -346,6 +354,7 @@ module.exports = async (connection, reference, mailbox, options) => {
                     }
                 }
                 successStage = stage;
+                subscriptionStateKnown = !!stage.subscribed;
                 break;
             } catch (err) {
                 if (i === stages.length - 1 || !isRejectedCommand(err)) {
@@ -478,20 +487,28 @@ module.exports = async (connection, reference, mailbox, options) => {
             response.next();
         };
 
-        // Skipped when RETURN (SUBSCRIBED) already provided subscription state or when
-        // this connection's server already rejected LSUB once. Safety net: if the
-        // extended LIST was accepted but not a single mailbox came back subscribed on a
-        // non-rev2 session, assume the server silently ignored RETURN (SUBSCRIBED) and
-        // fall back to LSUB anyway (a rev2 session has no LSUB to fall back to, and an
-        // account without any subscriptions legitimately looks the same).
-        let needsLsub = !successStage.subscribed || (!isRev2Active(connection) && !entries.some(entry => entry.subscribed));
+        // Never sent on a rev2 session - LSUB is not part of that protocol version, and
+        // some servers break the rest of the session over the rejection, so this is
+        // decided up front rather than left to the skipLsub latch below. On rev1 it is
+        // skipped when RETURN (SUBSCRIBED) already answered. Safety net: if the extended
+        // LIST was accepted but not a single mailbox came back subscribed, assume the
+        // server silently ignored the option and fall back to LSUB anyway (an account
+        // with no subscriptions legitimately looks the same).
+        let needsLsub = !isRev2Active(connection) && (!successStage.subscribed || !anyEntrySubscribed());
+        if (needsLsub) {
+            // Reaching here means the listing did not settle the question after all -
+            // either no RETURN (SUBSCRIBED) was granted, or one was and the server
+            // ignored it. Only LSUB can answer now
+            subscriptionStateKnown = false;
+        }
         if (needsLsub && !connection.skipLsub) {
             try {
                 await runLsub();
+                subscriptionStateKnown = true;
             } catch (err) {
                 if (isRejectedCommand(err)) {
-                    // Tagged BAD: the server does not recognize the command (IMAP4rev2
-                    // removed LSUB) - skip LSUB for the rest of this connection
+                    // Tagged BAD: the server does not implement LSUB despite advertising
+                    // rev1 - skip it for the rest of this connection
                     connection.skipLsub = true;
                 } else if (err.responseStatus !== 'NO' || err.code === 'ETHROTTLE') {
                     // Transport failures and throttling: rethrow, every follow-up
@@ -524,6 +541,21 @@ module.exports = async (connection, reference, mailbox, options) => {
             }
         }
 
+        // No source answered, so "not subscribed" was never actually reported for any of
+        // these folders - the state is unknown, not false. Reporting the whole listing as
+        // unsubscribed would hide every folder from a client that filters on subscription
+        // state, so assume subscribed instead. Phantom entries are excluded, the same way
+        // the rest of this file declines to trust them. NB! a transient LSUB NO lands here
+        // too, so the assumption can hold for one listing and be replaced by real state on
+        // the next
+        if (!subscriptionStateKnown && !anyEntrySubscribed()) {
+            for (let entry of entries) {
+                if (!entry.flags.has('\\NonExistent')) {
+                    entry.subscribed = true;
+                }
+            }
+        }
+
         // INBOX should always appear as subscribed regardless of LSUB results
         let inboxEntry = entries.find(entry => entry.specialUse === '\\Inbox');
         if (inboxEntry && !inboxEntry.subscribed) {

package/lib/imap-flow.d.ts

@@ -129,7 +129,7 @@ export interface MailboxObject {
     specialUse?: string;
     /** True if mailbox was found from the output of LIST command */
     listed?: boolean;
-    /** True if the mailbox is subscribed - reported by LSUB or by LIST RETURN (SUBSCRIBED) on LIST-EXTENDED/IMAP4rev2 servers */
+    /** True if the mailbox is subscribed - reported by LSUB or by LIST RETURN (SUBSCRIBED) on LIST-EXTENDED/IMAP4rev2 servers. Servers that answer neither report no subscription state at all, and every mailbox is then assumed to be subscribed */
     subscribed?: boolean;
     /** A Set of flags available to use in this mailbox. If it is not set or includes special flag "\*" then any flag can be used */
     permanentFlags?: Set<string>;
@@ -212,7 +212,7 @@ export interface ListResponse {
     specialUseSource?: 'user' | 'extension' | 'name';
     /** True if mailbox was found from the output of LIST command */
     listed: boolean;
-    /** True if the mailbox is subscribed - reported by LSUB or by LIST RETURN (SUBSCRIBED) on LIST-EXTENDED/IMAP4rev2 servers */
+    /** True if the mailbox is subscribed - reported by LSUB or by LIST RETURN (SUBSCRIBED) on LIST-EXTENDED/IMAP4rev2 servers. Servers that answer neither report no subscription state at all, and every mailbox is then assumed to be subscribed */
     subscribed: boolean;
     /** If statusQuery was used, then this value includes the status response */
     status?: StatusObject;
@@ -268,7 +268,7 @@ export interface ListTreeResponse {
     specialUse?: string;
     /** True if mailbox was found from the output of LIST command */
     listed?: boolean;
-    /** True if the mailbox is subscribed - reported by LSUB or by LIST RETURN (SUBSCRIBED) on LIST-EXTENDED/IMAP4rev2 servers */
+    /** True if the mailbox is subscribed - reported by LSUB or by LIST RETURN (SUBSCRIBED) on LIST-EXTENDED/IMAP4rev2 servers. Servers that answer neither report no subscription state at all, and every mailbox is then assumed to be subscribed */
     subscribed?: boolean;
     /** If true then this mailbox can not be selected in the UI */
     disabled?: boolean;

package/lib/imap-flow.js

@@ -71,7 +71,7 @@ const states = {
  * @property {Set<string>} flags list of flags for this mailbox
  * @property {String} [specialUse] one of special-use flags (if applicable): "\All", "\Archive", "\Drafts", "\Flagged", "\Junk", "\Sent", "\Trash". Additionally INBOX has non-standard "\Inbox" flag set
  * @property {Boolean} listed `true` if mailbox was found from the output of LIST command
- * @property {Boolean} subscribed `true` if the mailbox is subscribed - reported by LSUB or by LIST RETURN (SUBSCRIBED) on LIST-EXTENDED/IMAP4rev2 servers
+ * @property {Boolean} subscribed `true` if the mailbox is subscribed - reported by LSUB or by LIST RETURN (SUBSCRIBED) on LIST-EXTENDED/IMAP4rev2 servers. Servers that answer neither report no subscription state at all, and every mailbox is then assumed to be subscribed
  * @property {Set<string>} permanentFlags A Set of flags available to use in this mailbox. If it is not set or includes special flag "\\\*" then any flag can be used.
  * @property {String} [mailboxId] unique mailbox ID if server has `OBJECTID` extension enabled
  * @property {BigInt} [highestModseq] latest known modseq value if server has CONDSTORE or XYMHIGHESTMODSEQ enabled
@@ -2518,7 +2518,7 @@ class ImapFlow extends EventEmitter {
      * @property {String} specialUse one of special-use flags (if applicable): "\All", "\Archive", "\Drafts", "\Flagged", "\Junk", "\Sent", "\Trash". Additionally INBOX has non-standard "\Inbox" flag set
      * @property {String} [specialUseSource] how `specialUse` was determined: `"user"` (from `specialUseHints`), `"extension"` (SPECIAL-USE or XLIST flag reported by the server) or `"name"` (matched against known localized folder names)
      * @property {Boolean} listed `true` if mailbox was found from the output of LIST command
-     * @property {Boolean} subscribed `true` if the mailbox is subscribed - reported by LSUB or by LIST RETURN (SUBSCRIBED) on LIST-EXTENDED/IMAP4rev2 servers
+     * @property {Boolean} subscribed `true` if the mailbox is subscribed - reported by LSUB or by LIST RETURN (SUBSCRIBED) on LIST-EXTENDED/IMAP4rev2 servers. Servers that answer neither report no subscription state at all, and every mailbox is then assumed to be subscribed
      * @property {StatusObject} [status] If `statusQuery` was used, then this value includes the status response
      */
 
@@ -2569,7 +2569,7 @@ class ImapFlow extends EventEmitter {
      * @property {Set<string>} flags list of flags for this mailbox
      * @property {String} specialUse one of special-use flags (if applicable): "\All", "\Archive", "\Drafts", "\Flagged", "\Junk", "\Sent", "\Trash". Additionally INBOX has non-standard "\Inbox" flag set
      * @property {Boolean} listed `true` if mailbox was found from the output of LIST command
-     * @property {Boolean} subscribed `true` if the mailbox is subscribed - reported by LSUB or by LIST RETURN (SUBSCRIBED) on LIST-EXTENDED/IMAP4rev2 servers
+     * @property {Boolean} subscribed `true` if the mailbox is subscribed - reported by LSUB or by LIST RETURN (SUBSCRIBED) on LIST-EXTENDED/IMAP4rev2 servers. Servers that answer neither report no subscription state at all, and every mailbox is then assumed to be subscribed
      * @property {Boolean} disabled If `true` then this mailbox can not be selected in the UI
      * @property {ListTreeResponse[]} folders An array of subfolders
      * @property {StatusObject} [status] If `statusQuery` was used, then this value includes the status response

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "imapflow",
-    "version": "1.6.1",
+    "version": "1.6.3",
     "description": "IMAP Client for Node",
     "main": "lib/imap-flow.js",
     "types": "lib/imap-flow.d.ts",
@@ -30,9 +30,9 @@
     "homepage": "https://imapflow.com/",
     "devDependencies": {
         "@eslint/js": "10.0.1",
-        "@types/node": "26.1.1",
+        "@types/node": "26.1.2",
         "c8": "12.0.0",
-        "eslint": "10.7.0",
+        "eslint": "10.8.0",
         "eslint-config-nodemailer": "1.2.0",
         "eslint-config-prettier": "10.1.8",
         "grunt": "1.6.2",

package/test/commands-integration-test.js

@@ -4168,7 +4168,7 @@ module.exports['Commands: list survives LSUB rejection'] = async test => {
         exec: async (cmd, attrs, opts) => {
             if (cmd === 'LSUB') {
                 lsubCalls++;
-                // e.g. Exchange in IMAP4rev2 mode responds "BAD Command Argument Error"
+                // e.g. Exchange responds "BAD Command Argument Error"
                 throw commandError('Command failed', 'BAD');
             }
             if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
@@ -4189,6 +4189,9 @@ module.exports['Commands: list survives LSUB rejection'] = async test => {
     test.ok(inbox);
     // INBOX is always reported as subscribed even without LSUB data
     test.equal(inbox.subscribed, true);
+    // Nothing reported subscription state, so it is unknown rather than false - every
+    // folder is reported as subscribed instead of none of them
+    test.equal(result.find(e => e.path === 'Folder1').subscribed, true);
 
     // The rejection is remembered - a follow-up listing skips LSUB entirely
     test.equal(connection.skipLsub, true);
@@ -4197,6 +4200,107 @@ module.exports['Commands: list survives LSUB rejection'] = async test => {
     test.done();
 };
 
+module.exports['Commands: list keeps a genuinely empty subscription set'] = async test => {
+    // LSUB answers, it just has nothing to report. That is a real "nothing is
+    // subscribed", not the unknown state, so it must not be overwritten
+    const connection = createMockConnection({
+        state: 3,
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+                await opts.untagged.LIST({
+                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'Folder1' }]
+                });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await listCommand(connection, '', '*');
+    test.ok(!result.find(entry => entry.path === 'Folder1').subscribed);
+    test.done();
+};
+
+module.exports['Commands: list treats an ignored RETURN (SUBSCRIBED) plus a rejected LSUB as unknown'] = async test => {
+    // The server accepts the RETURN option but reports no \Subscribed at all, which is
+    // why the listing falls back to LSUB - and that is rejected too. Accepting the
+    // command is not the same as answering it, so this is the unknown state
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([
+            ['IMAP4rev1', true],
+            ['LIST-EXTENDED', true]
+        ]),
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LSUB') {
+                throw commandError('Command failed', 'BAD');
+            }
+            if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+                await opts.untagged.LIST({
+                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'Folder1' }]
+                });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await listCommand(connection, '', '*');
+    test.equal(result.find(entry => entry.path === 'Folder1').subscribed, true);
+    test.done();
+};
+
+module.exports['Commands: list leaves phantom folders out of the assumed subscription'] = async test => {
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([['IMAP4rev2', true]]),
+        enabled: new Set(['IMAP4REV2']),
+        skipListSubscribedArg: true,
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+                await opts.untagged.LIST({
+                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'Folder1' }]
+                });
+                await opts.untagged.LIST({
+                    attributes: [[{ value: '\\NonExistent' }], { value: '/' }, { value: 'Ghost' }]
+                });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await listCommand(connection, '', '*');
+    test.equal(result.find(entry => entry.path === 'Folder1').subscribed, true);
+    // A folder the server says does not exist is not claimed to be subscribed
+    test.ok(!result.find(entry => entry.path === 'Ghost').subscribed);
+    test.done();
+};
+
+module.exports['Commands: list keeps subscription flags volunteered by a plain LIST'] = async test => {
+    // No RETURN option was granted and LSUB is not available on rev2, but the server
+    // reported \Subscribed on its own - that is real state and must not be widened
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([['IMAP4rev2', true]]),
+        enabled: new Set(['IMAP4REV2']),
+        skipListSubscribedArg: true,
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+                await opts.untagged.LIST({
+                    attributes: [[{ value: '\\Subscribed' }, { value: '\\HasNoChildren' }], { value: '/' }, { value: 'Folder1' }]
+                });
+                await opts.untagged.LIST({
+                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'Folder2' }]
+                });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await listCommand(connection, '', '*');
+    test.equal(result.find(entry => entry.path === 'Folder1').subscribed, true);
+    test.ok(!result.find(entry => entry.path === 'Folder2').subscribed);
+    test.done();
+};
+
 module.exports['Commands: list fails when LSUB dies without a server rejection'] = async test => {
     const connection = createMockConnection({
         state: 3,
@@ -4304,6 +4408,41 @@ module.exports['Commands: list retries with plain LIST when RETURN is rejected']
     test.done();
 };
 
+module.exports['Commands: list never falls back to LSUB on a rev2 session'] = async test => {
+    let lsubCalled = false;
+    // An Exchange-alike that advertises both revisions and negotiates rev2 via ENABLE,
+    // having already proved it rejects RETURN (SUBSCRIBED). The listing therefore
+    // carries no subscription state - and the LSUB that rev1 would fall back to is not
+    // part of rev2, so asking anyway only risks upsetting the session.
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([
+            ['IMAP4rev2', true],
+            ['IMAP4rev1', true]
+        ]),
+        enabled: new Set(['IMAP4REV2']),
+        skipListSubscribedArg: true,
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LSUB') {
+                lsubCalled = true;
+            }
+            if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+                await opts.untagged.LIST({
+                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'Folder1' }]
+                });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await listCommand(connection, '', '*');
+    test.equal(lsubCalled, false);
+    // Neither source could answer, so the folder is reported as subscribed rather than
+    // claiming the server said it is not
+    test.equal(result.find(entry => entry.path === 'Folder1').subscribed, true);
+    test.done();
+};
+
 module.exports['Commands: list does not retry extended LIST on transport errors'] = async test => {
     let listCalls = 0;
     const connection = createMockConnection({