imapflow 1.6.2 → 1.6.3

package/.release-please-manifest.json

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

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # 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)
 
 

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)) {
@@ -485,10 +494,17 @@ module.exports = async (connection, reference, mailbox, options) => {
         // 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 || !entries.some(entry => entry.subscribed));
+        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 implement LSUB despite advertising
@@ -525,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.2",
+    "version": "1.6.3",
     "description": "IMAP Client for Node",
     "main": "lib/imap-flow.js",
     "types": "lib/imap-flow.d.ts",

package/test/commands-integration-test.js

@@ -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,
@@ -4333,8 +4437,9 @@ module.exports['Commands: list never falls back to LSUB on a rev2 session'] = as
 
     const result = await listCommand(connection, '', '*');
     test.equal(lsubCalled, false);
-    // No subscription source was available, so nothing claims the folder is subscribed
-    test.ok(!result.find(entry => entry.path === 'Folder1').subscribed);
+    // 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();
 };