imapflow 1.6.3 → 1.6.5

package/test/imap-flow-server-test.js

@@ -1310,3 +1310,165 @@ module.exports['Server: socket close triggers close handling'] = async test => {
     client.close();
     test.done();
 };
+
+module.exports['Server: an unparseable tagged completion fails the command instead of stalling'] = async test => {
+    // A tagged line the parser cannot make sense of used to be logged and dropped.
+    // currentRequest then stayed set forever, so trySend() stopped dispatching and
+    // every later command queued behind a promise that never settled.
+    let server = createServer({
+        handlers: {
+            SELECT(ctx) {
+                // A control character inside the response code is not parseable
+                ctx.write(`${ctx.tag} OK [\x01BAD-CODE] SELECT completed\r\n`);
+            }
+        }
+    });
+    let port = await listen(server);
+    let client = makeClient(port);
+    client.on('error', () => {});
+
+    await client.connect();
+
+    let selectErr = null;
+    try {
+        await client.mailboxOpen('INBOX');
+    } catch (err) {
+        selectErr = err;
+    }
+    test.ok(selectErr, 'the command whose completion could not be parsed must reject');
+
+    // The connection has to keep working: the next command still gets dispatched
+    let folders = await client.list();
+    test.ok(Array.isArray(folders) && folders.length, 'later commands still run');
+
+    await client.logout();
+    client.close();
+    server.close();
+    test.done();
+};
+
+module.exports['Server: a NUL-padded unparseable completion still fails the command'] = async test => {
+    // Buggy servers pad lines with leading NUL bytes; the parser strips them before
+    // reading the tag. The unparsed-completion recovery has to see the same tag the
+    // parser saw, or the command hangs for exactly the server class the NUL
+    // workaround exists for.
+    let server = createServer({
+        handlers: {
+            SELECT(ctx) {
+                ctx.write(`\x00\x00${ctx.tag} OK [\x01BAD-CODE] SELECT completed\r\n`);
+            }
+        }
+    });
+    let port = await listen(server);
+    let client = makeClient(port);
+    client.on('error', () => {});
+
+    await client.connect();
+
+    let selectErr = null;
+    try {
+        await client.mailboxOpen('INBOX');
+    } catch (err) {
+        selectErr = err;
+    }
+    test.ok(selectErr, 'the command whose completion could not be parsed must reject');
+
+    let folders = await client.list();
+    test.ok(Array.isArray(folders) && folders.length, 'later commands still run');
+
+    await client.logout();
+    client.close();
+    server.close();
+    test.done();
+};
+
+module.exports['Server: a sequence-shaped token in a server response does not fail the connection'] = async test => {
+    // The incoming token parser accepts sequence-shaped tokens the strict outgoing
+    // grammar rejects ("1:2:3"). Every parsed response is re-compiled for the log, so
+    // that pass must skip the validation - one quirky but parseable server line would
+    // otherwise tear down the whole connection.
+    let server = createServer({
+        handlers: {
+            NOOP(ctx) {
+                ctx.write(`${ctx.tag} OK [XDATA 1:2:3] NOOP completed\r\n`);
+            }
+        }
+    });
+    let port = await listen(server);
+    let client = makeClient(port);
+    client.on('error', () => {});
+
+    await client.connect();
+    await client.noop();
+    test.ok(client.usable, 'connection must stay usable');
+
+    let folders = await client.list();
+    test.ok(Array.isArray(folders) && folders.length, 'later commands still run');
+
+    await client.logout();
+    client.close();
+    server.close();
+    test.done();
+};
+
+module.exports['Server: an invalid range rejects the command without wedging the queue'] = async test => {
+    // The compiler refuses invalid sequence sets before anything reaches the wire.
+    // The dispatch layer has to treat that as the command's own failure: the request
+    // must reject (even when queued behind an in-flight command) and the queue must
+    // keep moving instead of waiting forever on a response that can never arrive.
+    let server = createServer();
+    let port = await listen(server);
+    let client = makeClient(port);
+    client.on('error', () => {});
+
+    await client.connect();
+    await client.mailboxOpen('INBOX');
+
+    let err = null;
+    try {
+        await client.fetchOne('1;2', { uid: true });
+    } catch (e) {
+        err = e;
+    }
+    test.ok(err, 'the invalid range must reject');
+    test.equal(err && err.code, 'InvalidSequenceSet');
+
+    // Queued variant: the invalid command sits behind an in-flight one; every promise
+    // must settle and the command behind the invalid one must still run
+    let results = await Promise.allSettled([client.noop(), client.fetchOne('3;4', { uid: true }), client.noop()]);
+    test.equal(results[0].status, 'fulfilled', 'command before the invalid one succeeds');
+    test.equal(results[1].status, 'rejected', 'queued invalid command must reject, not hang');
+    test.equal(results[2].status, 'fulfilled', 'command after the invalid one still runs');
+
+    await client.logout();
+    client.close();
+    server.close();
+    test.done();
+};
+
+module.exports['Server: a throwing response listener does not fail the command'] = async test => {
+    // 'response' is emitted after a tagged completion parses successfully. A listener
+    // throwing synchronously used to be caught by the parse-failure path, which
+    // rejected the in-flight command with a bogus ParserError even though the server
+    // had executed it.
+    let server = createServer();
+    let port = await listen(server);
+    let client = makeClient(port);
+    client.on('error', () => {});
+
+    await client.connect();
+    client.on('response', payload => {
+        if (payload.response === 'OK') {
+            throw new Error('listener bug');
+        }
+    });
+
+    await client.noop();
+    let mailbox = await client.mailboxOpen('INBOX');
+    test.ok(mailbox, 'commands succeed despite the throwing listener');
+
+    await client.logout();
+    client.close();
+    server.close();
+    test.done();
+};

package/test/imap-parser-test.js

@@ -1421,3 +1421,54 @@ module.exports['IMAP Parser, ATOM with <, [, ]'] = test =>
             ]
         });
     });
+
+module.exports['IMAP Parser: unbalanced bracket in a response code keeps the human-readable text'] = test =>
+    asyncWrapper(test, async test => {
+        // RFC 9051 lets a response code carry free text containing '[' but not ']'.
+        // Counting that '[' as a nested bracket loses the whole human-readable text,
+        // which is what NO/BAD error messages are built from.
+        const parsed = await parser('A1 NO [XFOO see bar[baz] mailbox is busy');
+        const text = (parsed.attributes || [])
+            .filter(entry => entry && entry.type === 'TEXT')
+            .map(entry => entry.value)
+            .join('');
+        test.equal(text, 'mailbox is busy');
+    });
+
+module.exports['IMAP Parser: balanced brackets inside a response code are still tolerated'] = test =>
+    asyncWrapper(test, async test => {
+        // Servers do put bracketed values inside a code, so a plain first-']' scan
+        // would cut the code in half
+        const parsed = await parser('* OK [PERMANENTFLAGS ([css3-page] \\*)] Flags permitted.');
+        const text = (parsed.attributes || [])
+            .filter(entry => entry && entry.type === 'TEXT')
+            .map(entry => entry.value)
+            .join('');
+        test.equal(text, 'Flags permitted.');
+        test.equal(parsed.attributes[0].section[0].value, 'PERMANENTFLAGS');
+    });
+
+module.exports['IMAP Parser: a parse failure after the tag exposes the parsed tag'] = test =>
+    asyncWrapper(test, async test => {
+        // The connection settles the in-flight command from an unparseable tagged
+        // completion using this tag - re-deriving it from the raw bytes instead would
+        // bypass the leading-NUL workaround and strand the command
+        let err = null;
+        try {
+            await parser(Buffer.from('A5 OK [\x01BAD-CODE] done', 'binary'));
+        } catch (e) {
+            err = e;
+        }
+        test.ok(err, 'the line must fail to parse');
+        test.equal(err && err.parsedTag, 'A5');
+
+        // The NUL-padding workaround is inherited: the exposed tag is the stripped one
+        err = null;
+        try {
+            await parser(Buffer.from('\x00\x00A6 OK [\x01BAD-CODE] done', 'binary'));
+        } catch (e) {
+            err = e;
+        }
+        test.ok(err, 'the padded line must fail to parse');
+        test.equal(err && err.parsedTag, 'A6');
+    });

package/test/imap-stream-edge-cases-test.js

@@ -456,3 +456,75 @@ module.exports['ImapStream: _destroy drains pending input queue callbacks'] = te
         test.done();
     });
 };
+
+module.exports['Literal marker scan stays linear on a long digit run'] = test => {
+    // A backwards scan that accumulated digits one at a time cost O(n^2), so a few
+    // hundred KB of digits blocked the event loop for seconds before the size was
+    // even known - all inside the default line-length budget
+    const stream = new ImapStream({ cid: 'test' });
+    stream.on('error', () => {});
+    stream.resume();
+
+    const line = Buffer.concat([Buffer.from('* OK {'), Buffer.from('9'.repeat(200000)), Buffer.from('}\r\n')]);
+
+    const started = process.hrtime.bigint();
+    stream.checkLiteralMarker(line);
+    const elapsedMs = Number(process.hrtime.bigint() - started) / 1e6;
+
+    test.ok(elapsedMs < 250, `scan should stay cheap, took ${elapsedMs.toFixed(1)}ms`);
+    test.done();
+};
+
+module.exports['Literal marker fails the stream on an oversized digit run'] = test => {
+    // An impossible size is still a syntactically valid marker. Treating it as an
+    // ordinary line instead would feed the announced literal body to the line parser
+    // and desynchronize the session, so the stream must end with LiteralTooLarge.
+    const stream = new ImapStream({ cid: 'test' });
+    let streamErr = null;
+    stream.on('error', err => {
+        streamErr = err;
+    });
+    stream.resume();
+
+    const line = Buffer.concat([Buffer.from('* OK {'), Buffer.from('1'.repeat(40)), Buffer.from('}\r\n')]);
+
+    test.equal(stream.checkLiteralMarker(line), false, 'an impossible size must not start literal mode');
+    test.ok(stream.destroyed, 'the stream must fail closed instead of continuing as if the marker were text');
+    setImmediate(() => {
+        test.ok(streamErr && streamErr.code === 'LiteralTooLarge', 'must fail with LiteralTooLarge');
+        test.done();
+    });
+};
+
+module.exports['Literal marker accepts a zero-padded size'] = test => {
+    // The RFC "number" production is 1*DIGIT, so leading zeros are legal - a long
+    // digit run can still denote a small size and must be consumed as a literal
+    const stream = new ImapStream({ cid: 'test' });
+    stream.on('error', () => {});
+    stream.resume();
+
+    const line = Buffer.from(`* 1 FETCH (BODY[] {${'0'.repeat(21)}123}\r\n`);
+
+    test.equal(stream.checkLiteralMarker(line), true, 'a zero-padded marker is a valid literal marker');
+    test.equal(stream.literalWaiting, 123, 'the padded size must parse to its numeric value');
+    stream.destroy();
+    test.done();
+};
+
+module.exports['Literal marker still accepts sizes at the digit-length bound'] = test => {
+    const stream = new ImapStream({ cid: 'test', maxLiteralSize: Number.MAX_SAFE_INTEGER });
+    stream.on('error', () => {});
+    stream.resume();
+
+    // 19 digits is the widest a number64 gets, so it must still be recognized
+    const line = Buffer.from(`* OK {${'9'.repeat(19)}}\r\n`);
+
+    test.equal(stream.checkLiteralMarker(line), false, 'a size beyond the configured maximum fails the stream rather than parsing');
+
+    const ok = new ImapStream({ cid: 'test' });
+    ok.on('error', () => {});
+    ok.resume();
+    test.equal(ok.checkLiteralMarker(Buffer.from('* OK {1024}\r\n')), true);
+    test.equal(ok.literalWaiting, 1024);
+    test.done();
+};

package/test/integration/rev2-live-test.js

@@ -150,7 +150,12 @@ module.exports['Live rev2: statusQuery is answered inline via LIST-STATUS'] = as
 
         const folders = await client.list({ statusQuery: { messages: true, unseen: true } });
 
-        test.ok(clientSent(logs, 'STATUS'), 'LIST should carry RETURN (STATUS ...)');
+        // Pin the inline LIST-STATUS behavior: the STATUS request must ride on the
+        // LIST command itself, and no standalone STATUS command may be issued -
+        // a plain substring check would also pass on the fallback path
+        const listLine = wireLines(logs).find(entry => entry.src === 'c' && /^\S+ LIST /.test(entry.msg));
+        test.ok(listLine && listLine.msg.includes('RETURN') && listLine.msg.includes('STATUS'), 'LIST should carry RETURN (STATUS ...)');
+        test.ok(!wireLines(logs).some(entry => entry.src === 'c' && /^\S+ STATUS /.test(entry.msg)), 'no standalone STATUS command should be needed');
         const inbox = folders.find(folder => folder.path === 'INBOX');
         test.equal(inbox.status.messages, 1, 'inline STATUS should report the appended message');
     } finally {
@@ -207,6 +212,56 @@ module.exports['Live rev2: returnOptions search is answered via a real ESEARCH r
     test.done();
 };
 
+module.exports['Live rev2: SEARCHRES saved result is usable as a sequence set'] = async test => {
+    // SEARCH RETURN (SAVE) stores the result server-side (RFC 5182) and '$'
+    // references it in later commands. '$' has to make it through the outgoing
+    // sequence-set validation for that to work at all.
+    const client = await connectClient();
+    try {
+        test.ok(client.capabilities.has('SEARCHRES'), 'Dovecot should advertise SEARCHRES');
+
+        await client.append('INBOX', Buffer.from('Subject: first\r\n\r\nfirst\r\n'));
+        await client.append('INBOX', Buffer.from('Subject: second\r\n\r\nsecond\r\n'));
+
+        await client.mailboxOpen('INBOX');
+        await client.search({ subject: 'second' }, { uid: true, returnOptions: ['SAVE'] });
+
+        let flagResult = await client.messageFlagsAdd('$', ['\\Flagged'], { uid: true });
+        test.ok(flagResult, 'STORE against the saved result must succeed');
+
+        let messages = [];
+        for await (let msg of client.fetch('$', { flags: true, envelope: true }, { uid: true })) {
+            messages.push(msg);
+        }
+        test.equal(messages.length, 1, 'the saved result references exactly the matched message');
+        test.equal(messages[0].envelope.subject, 'second');
+        test.ok(messages[0].flags.has('\\Flagged'), 'the flag change applied to the saved result');
+    } finally {
+        await client.logout();
+    }
+    test.done();
+};
+
+module.exports['Live rev2: MODSEQ search criterion surfaces modseq from the ESEARCH response'] = async test => {
+    const client = await connectClient();
+    try {
+        await client.append('INBOX', Buffer.from('Subject: first\r\n\r\nfirst\r\n'));
+        await client.append('INBOX', Buffer.from('Subject: second\r\n\r\nsecond\r\n'));
+
+        await client.mailboxOpen('INBOX');
+        // RFC 7162: a MODSEQ criterion on a CONDSTORE session makes the server
+        // append MODSEQ to the ESEARCH response
+        const result = await client.search({ modseq: 1 }, { returnOptions: ['ALL', 'COUNT'] });
+
+        test.equal(result.count, 2);
+        test.equal(result.all, '1:2');
+        test.ok(typeof result.modseq === 'bigint' && result.modseq > 0n, 'modseq should surface as a positive BigInt');
+    } finally {
+        await client.logout();
+    }
+    test.done();
+};
+
 module.exports['Live rev2: STATUS reports SIZE and DELETED'] = async test => {
     const logs = [];
     const client = await connectClient(null, logs);
@@ -253,8 +308,17 @@ module.exports['Live rev2: SELECT response carries an untagged LIST and re-selec
         test.equal(mailbox.path, 'INBOX');
 
         // RFC 9051 6.3.1: the SELECT response includes an untagged LIST for the
-        // selected mailbox - the client must consume it without issue
-        test.ok(serverSentUntagged(logs, 'LIST'), 'rev2 SELECT should include an untagged LIST response');
+        // selected mailbox - the client must consume it without issue. Scoped to
+        // the SELECT exchange itself: mailboxOpen() also issues its own LIST
+        // command first, whose untagged replies would satisfy a global check
+        // even if the SELECT response omitted the LIST
+        const lines = wireLines(logs);
+        const selectIdx = lines.findIndex(entry => entry.src === 'c' && /^\S+ SELECT /.test(entry.msg));
+        test.ok(selectIdx >= 0, 'SELECT command should be on the wire');
+        const selectTag = lines[selectIdx].msg.split(' ')[0];
+        const doneIdx = lines.findIndex((entry, i) => i > selectIdx && entry.src === 's' && entry.msg.startsWith(`${selectTag} `));
+        const listInSelect = lines.some((entry, i) => i > selectIdx && i < doneIdx && entry.src === 's' && /^\* LIST( |$)/.test(entry.msg));
+        test.ok(listInSelect, 'rev2 SELECT response should include an untagged LIST response');
 
         // switching mailboxes must produce a CLOSED response code for the old one
         await client.mailboxOpen('Closer');

package/test/search-compiler-test.js

@@ -87,13 +87,49 @@ module.exports['Search Compiler: SEQ with number'] = test => {
     test.done();
 };
 
-module.exports['Search Compiler: SEQ ignores invalid values'] = test => {
+module.exports['Search Compiler: SEQ passes invalid values through to the compiler guard'] = test => {
     let connection = createMockConnection();
 
-    // Whitespace in sequence is invalid
+    // An invalid sequence string used to be dropped silently here, which turned the
+    // filter into an unrestricted search matching every message. It is now emitted as
+    // a SEQUENCE token so the IMAP compiler rejects it with a coded error instead.
     let compiled = searchCompiler(connection, { seq: '1 2 3' });
-    test.equal(compiled.length, 0);
+    let seqAttr = compiled.find(a => a.type === 'SEQUENCE');
+    test.ok(seqAttr, 'the sequence value must not be dropped');
+    test.equal(seqAttr.value, '1 2 3');
+
+    // Junk values pass through too, so they fail loudly at the compiler instead of
+    // silently widening the search
+    let junk = searchCompiler(connection, { seq: {} });
+    test.ok(
+        junk.find(a => a.type === 'SEQUENCE'),
+        'a junk value must not be dropped'
+    );
+
+    // Zero is not a valid IMAP sequence number but it is a valid filter value,
+    // so it must reach the compiler guard rather than be dropped as falsy
+    let zero = searchCompiler(connection, { seq: 0 });
+    test.equal(zero.find(a => a.type === 'SEQUENCE').value, '0', 'zero must not be dropped');
+
+    test.done();
+};
+
+module.exports['Search Compiler: SEQ array compiles to a single comma-joined set'] = test => {
+    let connection = createMockConnection();
+    let compiled = searchCompiler(connection, { seq: [1, 3] });
+
+    let seqAttr = compiled.find(a => a.type === 'SEQUENCE');
+    test.ok(seqAttr, 'array must produce a sequence set');
+    test.equal(seqAttr.value, '1,3');
+    test.done();
+};
 
+module.exports['Search Compiler: SEQ empty string compiles to nothing'] = test => {
+    let connection = createMockConnection();
+    let compiled = searchCompiler(connection, { seq: '' });
+
+    test.ok(!compiled.find(a => a.type === 'SEQUENCE'), 'an empty set adds no SEQUENCE attribute');
+    test.equal(compiled.length, 0);
     test.done();
 };
 
@@ -366,6 +402,30 @@ module.exports['Search Compiler: UID with number'] = test => {
     test.done();
 };
 
+module.exports['Search Compiler: UID array compiles to a single comma-joined set'] = test => {
+    let connection = createMockConnection();
+    let compiled = searchCompiler(connection, { uid: [5, 7, 9] });
+
+    // Separate tokens ("UID 5 7 9") would be parsed by the server as extra
+    // sequence-number search keys ANDed to the query - the array means the set {5,7,9}
+    test.ok(hasAttr(compiled, 'UID'));
+    let uidValueAttr = compiled.find(a => a.value === '5,7,9');
+    test.ok(uidValueAttr, 'array must be joined into one sequence set');
+    test.equal(uidValueAttr.type, 'SEQUENCE');
+    test.done();
+};
+
+module.exports['Search Compiler: UID accepts the SEARCHRES $ marker'] = test => {
+    let connection = createMockConnection();
+    let compiled = searchCompiler(connection, { uid: '$' });
+
+    test.ok(hasAttr(compiled, 'UID'));
+    let uidValueAttr = compiled.find(a => a.value === '$');
+    test.ok(uidValueAttr, 'the saved-result marker must pass through');
+    test.equal(uidValueAttr.type, 'SEQUENCE');
+    test.done();
+};
+
 // ============================================
 // EMAILID / THREADID tests
 // ============================================
@@ -488,6 +548,19 @@ module.exports['Search Compiler: LABELS not compiles to -label: via X-GM-RAW'] =
     test.done();
 };
 
+module.exports['Search Compiler: LABELS with a non-object value is ignored'] = test => {
+    let connection = createMockConnection();
+
+    // Neither a falsy value nor a plain string is a { has, not } filter - both
+    // must compile to nothing even without the Gmail extension
+    let compiledNull = searchCompiler(connection, { labels: null });
+    test.equal(compiledNull.length, 0);
+
+    let compiledString = searchCompiler(connection, { labels: 'Horizon' });
+    test.equal(compiledString.length, 0);
+    test.done();
+};
+
 module.exports['Search Compiler: LABELS has and not combined'] = test => {
     let connection = createMockConnection({
         capabilities: [['X-GM-EXT-1', true]]
@@ -991,6 +1064,20 @@ module.exports['Search Compiler: non-ASCII GMRAW adds CHARSET UTF-8'] = test =>
     test.done();
 };
 
+module.exports['Search Compiler: non-ASCII LABELS adds CHARSET UTF-8'] = test => {
+    let connection = createMockConnection({
+        capabilities: [['X-GM-EXT-1', true]],
+        enabled: new Set()
+    });
+    // The label filter compiles into an X-GM-RAW query, and a non-ASCII label name
+    // must mark the compiled query as Unicode the same way a direct gmraw value does
+    let compiled = searchCompiler(connection, { labels: { has: ['Tähtis'] } });
+    test.ok(hasAttr(compiled, 'CHARSET'));
+    test.ok(hasAttr(compiled, 'X-GM-RAW'));
+    test.ok(hasAttr(compiled, 'label:Tähtis'));
+    test.done();
+};
+
 // ============================================
 // Complex query tests
 // ============================================

package/test/search-test.js

@@ -212,16 +212,45 @@ module.exports['ESEARCH: command path returns false on exec error'] = test => {
 };
 
 module.exports['ESEARCH: parseEsearchResponse ignores unknown keywords'] = test => {
-    // Dovecot with CONDSTORE may append MODSEQ to ESEARCH responses
+    // Unknown result keywords must be skipped with their value so the
+    // key/value stream stays aligned for the entries that follow
+    const attrs = [
+        { type: 'ATOM', value: 'RELEVANCY' },
+        { type: 'ATOM', value: '87' },
+        { type: 'ATOM', value: 'COUNT' },
+        { type: 'ATOM', value: '5' }
+    ];
+    const result = parseEsearchResponse(attrs);
+    test.equal(result.count, 5);
+    test.equal(result.relevancy, undefined, 'unknown keys should not appear in result');
+    test.done();
+};
+
+module.exports['ESEARCH: parseEsearchResponse parses MODSEQ as BigInt'] = test => {
+    // RFC 7162: CONDSTORE sessions append MODSEQ to ESEARCH responses when the
+    // search used a MODSEQ criterion
     const attrs = [
         { type: 'ATOM', value: 'COUNT' },
         { type: 'ATOM', value: '5' },
         { type: 'ATOM', value: 'MODSEQ' },
-        { type: 'ATOM', value: '12345' }
+        { type: 'ATOM', value: '9007199254740993' }
     ];
     const result = parseEsearchResponse(attrs);
     test.equal(result.count, 5);
-    test.equal(result.modseq, undefined, 'unknown keys should not appear in result');
+    test.strictEqual(result.modseq, 9007199254740993n, 'modseq should be an exact BigInt');
+    test.done();
+};
+
+module.exports['ESEARCH: parseEsearchResponse drops non-numeric MODSEQ'] = test => {
+    const attrs = [
+        { type: 'ATOM', value: 'MODSEQ' },
+        { type: 'ATOM', value: 'bogus' },
+        { type: 'ATOM', value: 'COUNT' },
+        { type: 'ATOM', value: '3' }
+    ];
+    const result = parseEsearchResponse(attrs);
+    test.equal(result.modseq, undefined, 'invalid modseq must be dropped');
+    test.equal(result.count, 3, 'stream must stay aligned after a dropped value');
     test.done();
 };
 

package/test/tools-test.js

@@ -234,8 +234,23 @@ module.exports['Tools: hasCapability with advertised token'] = test => {
 
 module.exports['Tools: hasCapability folds extensions into active rev2'] = test => {
     let connection = createMockConnection({ capabilities: [['IMAP4rev2', true]] });
-    // RFC 9051 Appendix E folds these into base IMAP4rev2
-    for (let capability of ['UIDPLUS', 'MOVE', 'NAMESPACE', 'ESEARCH', 'LITERAL-', 'LIST-EXTENDED', 'LIST-STATUS', 'SPECIAL-USE', 'ENABLE']) {
+    // RFC 9051 Appendix E folds these into base IMAP4rev2 - the complete set
+    for (let capability of [
+        'ENABLE',
+        'ESEARCH',
+        'IDLE',
+        'LIST-EXTENDED',
+        'LIST-STATUS',
+        'LITERAL-',
+        'MOVE',
+        'NAMESPACE',
+        'SASL-IR',
+        'SEARCHRES',
+        'SPECIAL-USE',
+        'STATUS=SIZE',
+        'UIDPLUS',
+        'UNSELECT'
+    ]) {
         test.equal(tools.hasCapability(connection, capability), true, `${capability} should be folded into rev2`);
     }
     // BINARY is intentionally not folded
@@ -336,6 +351,17 @@ module.exports['Tools: getErrorText with valid response'] = async test => {
     test.done();
 };
 
+module.exports['Tools: getErrorText survives a response that cannot be re-encoded'] = async test => {
+    // The parser tolerates stray bytes inside an OK/NO/BAD atom, and those have no
+    // valid IMAP string encoding. The error text is diagnostic, so it must still be
+    // produced rather than replacing the server's error with an encoding failure.
+    let response = await parser(Buffer.from('A1 NO [SERVERBUG\x00X] it failed', 'binary'));
+    let result = await tools.getErrorText(response);
+    test.ok(typeof result === 'string', 'error text should still be produced');
+    test.ok(result.includes('it failed'), 'the human-readable part must survive');
+    test.done();
+};
+
 // ============================================
 // getFlagColor tests
 // ============================================