imapflow 1.6.4 → 1.6.6

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

@@ -212,6 +212,36 @@ 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 {

package/test/jp-decoder-test.js

@@ -245,3 +245,60 @@ module.exports['JPDecoder: handles EUC-JP charset'] = async test => {
     test.ok(result.length > 0);
     test.done();
 };
+
+// ============================================
+// maxBytes buffering bound
+// ============================================
+
+module.exports['JPDecoder: buffers at most maxBytes'] = test => {
+    // The whole-input buffering must honor the caller's download limit: without the
+    // bound a server could defeat maxBytes just by labelling a part with a Japanese
+    // charset, since nothing is emitted (and limited) until _flush
+    let decoder = new JPDecoder('iso-2022-jp', 8);
+    decoder.resume();
+
+    decoder.write(Buffer.from('hello '));
+    decoder.write(Buffer.from('world'));
+
+    test.equal(decoder.chunklen, 8);
+    test.equal(Buffer.concat(decoder.chunks).toString(), 'hello wo');
+    decoder.end();
+    test.done();
+};
+
+module.exports['JPDecoder: a fractional maxBytes still bounds the decoder'] = test => {
+    // A computed limit (a percentage of a budget, say) is not an integer, and silently turning
+    // that into "no limit at all" is exactly the exposure the bound exists to close
+    const decoder = new JPDecoder('sjis', 512.5);
+    test.equal(decoder.maxBytes, 512, 'a fractional bound is floored to a whole byte count');
+    decoder.resume();
+    decoder.write(Buffer.alloc(1024, 0x61));
+    test.equal(decoder.chunklen, 512, 'nothing beyond the bound is buffered');
+    test.equal(decoder.limited, true, 'the decoder reports that it is full');
+    decoder.end();
+    test.done();
+};
+
+module.exports['JPDecoder: a non-numeric maxBytes leaves the decoder unbounded'] = test => {
+    test.equal(new JPDecoder('sjis').maxBytes, Infinity);
+    test.equal(new JPDecoder('sjis', Infinity).maxBytes, Infinity);
+    test.equal(new JPDecoder('sjis', 'lots').maxBytes, Infinity);
+    test.equal(new JPDecoder('sjis', -1).maxBytes, Infinity);
+    test.equal(new JPDecoder('sjis').limited, false);
+    test.done();
+};
+
+module.exports['JPDecoder: reports limited once the bound is reached'] = test => {
+    // The decoder emits nothing until _flush, so a limiter downstream cannot tell that it is
+    // full - the download loop reads this flag instead to stop pulling from the server
+    const decoder = new JPDecoder('sjis', 10);
+    decoder.resume();
+    test.equal(decoder.limited, false);
+    decoder.write(Buffer.alloc(4, 0x61));
+    test.equal(decoder.limited, false, 'not full yet');
+    decoder.write(Buffer.alloc(6, 0x61));
+    test.equal(decoder.limited, true);
+    test.equal(decoder.chunklen, 10);
+    decoder.end();
+    test.done();
+};

package/test/limited-passthrough-test.js

@@ -273,3 +273,27 @@ module.exports['LimitedPassthrough: single byte writes'] = async test => {
     test.equal(result.toString(), 'abc');
     test.done();
 };
+
+module.exports['LimitedPassthrough: a fractional maxBytes is floored so limited is reachable'] = async test => {
+    // With a fractional bound `processed` can only ever reach its floor, so `limited` would
+    // never flip - and the download loop polls exactly that flag to stop pulling
+    let stream = new LimitedPassthrough({ maxBytes: 512.5 });
+    test.equal(stream.maxBytes, 512);
+
+    let chunks = [];
+    stream.on('data', chunk => chunks.push(chunk));
+    stream.write(Buffer.alloc(1024, 0x61));
+    stream.end();
+    await new Promise(resolve => stream.on('end', resolve));
+
+    test.equal(Buffer.concat(chunks).length, 512);
+    test.equal(stream.limited, true, 'the limiter must report that it is full');
+    test.done();
+};
+
+module.exports['LimitedPassthrough: a numeric-string maxBytes is honored'] = test => {
+    test.equal(new LimitedPassthrough({ maxBytes: '100' }).maxBytes, 100);
+    test.equal(new LimitedPassthrough({ maxBytes: 'lots' }).maxBytes, Infinity);
+    test.equal(new LimitedPassthrough({ maxBytes: -5 }).maxBytes, Infinity);
+    test.done();
+};

package/test/parser-limits-test.js

@@ -9,6 +9,7 @@
 
 const { ImapStream } = require('../lib/handler/imap-stream');
 const { parser } = require('../lib/handler/imap-handler');
+const { MAX_LINE_SIZE, MAX_LITERAL_SIZE, MAX_RESPONSE_SIZE } = require('../lib/handler/limits');
 
 // Collects every emitted command payload and the first stream error. `error` resolves once the
 // stream fails; `settled` resolves once processing has quiesced (error or writable end).
@@ -272,3 +273,20 @@ module.exports['Parser limits: maxLiteralSize 0 rejects any non-empty inline lit
     test.equal(err.maxSize, 0);
     test.done();
 };
+
+module.exports['Parser limits: a junk limit falls back to the default'] = test => {
+    // Without validation an unusable value is honored as-is, and every comparison against it is
+    // false - so a caller who mistypes a limit silently gets no bound at all, or (for a negative
+    // value) a bound that rejects everything
+    for (let junk of ['4096', 'abc', 1.5, -1, -Infinity, null, {}, [], NaN, true]) {
+        const stream = new ImapStream({ cid: 'test', maxLineLength: junk, maxLiteralSize: junk, maxResponseSize: junk });
+        test.equal(stream.maxLineLength, MAX_LINE_SIZE, `maxLineLength ${JSON.stringify(junk)} must fall back`);
+        test.equal(stream.maxLiteralSize, MAX_LITERAL_SIZE, `maxLiteralSize ${JSON.stringify(junk)} must fall back`);
+        test.equal(stream.maxResponseSize, MAX_RESPONSE_SIZE, `maxResponseSize ${JSON.stringify(junk)} must fall back`);
+    }
+
+    // an explicit 0 is a real limit, not a missing one, and must not be swallowed
+    const zero = new ImapStream({ cid: 'test', maxLiteralSize: 0 });
+    test.equal(zero.maxLiteralSize, 0);
+    test.done();
+};

package/test/reliability-improvements-test.js

@@ -422,14 +422,14 @@ module.exports['Reliability: throttle back-off aborts promptly on close()'] = as
 
     // Let reader() reach the (tracked) back-off wait.
     await new Promise(r => setTimeout(r, 50));
-    test.ok(client._throttleTimer, 'back-off timer is tracked while waiting');
+    test.equal(client._throttleWaits.size, 1, 'back-off wait is tracked while waiting');
 
     client.close();
     await new Promise(r => setImmediate(r));
 
     test.ok(rejected, 'request rejected promptly after close()');
     test.equal(rejected.code, 'NoConnection', 'rejected with connection error, not ETHROTTLE');
-    test.equal(client._throttleTimer, null, 'throttle timer cleared on close()');
+    test.equal(client._throttleWaits.size, 0, 'throttle wait cleared on close()');
     test.ok(Date.now() - start < 5000, 'settled well under the 5-minute cap');
 
     await readerDone;
@@ -457,7 +457,7 @@ module.exports['Reliability: throttle back-off still rejects ETHROTTLE on normal
     test.ok(rejected, 'request rejected after the back-off elapses');
     test.equal(rejected.code, 'ETHROTTLE', 'normal expiry still rejects ETHROTTLE');
     test.equal(rejected.throttleReset, 50, 'throttleReset preserved');
-    test.equal(client._throttleTimer, null, 'throttle timer cleared after normal expiry');
+    test.equal(client._throttleWaits.size, 0, 'throttle wait cleared after normal expiry');
 
     await readerDone;
     client.close();

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/timer-policy-test.js

@@ -208,7 +208,33 @@ module.exports['Timers: the throttle back-off timer is unrefd and cleared'] = as
 
         // history() returns snapshots, so re-read it after close()
         test.ok(timers.history().find(timer => timer.id === backoff.id).cleared, 'close() clears the back-off timer');
-        test.equal(client._throttleTimer, null);
+        test.equal(client._throttleWaits.size, 0);
+        test.done();
+    });
+};
+
+module.exports['Timers: throttleWait caps a server-suggested back-off'] = async test => {
+    // The delay comes straight from a server hint (a Microsoft 365 "Suggested Backoff Time"),
+    // which is unbounded. Asserted on the armed timer rather than by waiting it out.
+    await withFakeTimers(async timers => {
+        let client = makeClient({ port: 1 });
+
+        let pending = client.throttleWait(7 * 24 * 3600 * 1000); // a week
+        let armed = timers.history()[timers.history().length - 1];
+        test.equal(armed.delay, 5 * 60 * 1000, 'the back-off is capped at five minutes');
+        test.ok(armed.unrefd, 'the back-off timer must not keep the process alive');
+
+        client.close();
+        test.equal(await pending, true, 'close() aborts the wait');
+        test.ok(timers.history().find(timer => timer.id === armed.id).cleared, 'close() clears the timer');
+
+        // a delay under the cap is honored as given, and junk becomes an immediate wait
+        let client2 = makeClient({ port: 1 });
+        client2.throttleWait(1500);
+        test.equal(timers.history()[timers.history().length - 1].delay, 1500);
+        client2.throttleWait('nonsense');
+        test.equal(timers.history()[timers.history().length - 1].delay, 0);
+        client2.close();
         test.done();
     });
 };

package/test/tools-test.js

@@ -1503,8 +1503,9 @@ module.exports['Tools: formatMessageResponse handles NIL, Buffer and unknown key
         literals: [Buffer.from('999')]
     });
     let r = await tools.formatMessageResponse(untagged, { path: 'INBOX' });
-    test.equal(r.uid, 0); // NIL value -> getString returns false -> Number(false) = 0
-    test.equal(r.size, 0);
+    test.equal(r.uid, undefined); // a NIL UID is left unset rather than reported as UID 0
+    test.equal(r.size, 0); // size keeps its 0 default
+
     test.equal(r.emailId, '999'); // Buffer literal value -> getString stringifies it
     test.equal(r.source, false); // BODY[] NIL -> getBuffer returns false
     test.done();
@@ -1749,3 +1750,151 @@ module.exports['Tools: packMessageRange dedupes duplicate values'] = test => {
     test.equal(tools.packMessageRange([5, 5, 5]), '5');
     test.done();
 };
+
+// ============================================
+// Security regression tests: hostile server input
+// ============================================
+
+module.exports['Tools: getStructuredParams drops __proto__ continuation parameters'] = test => {
+    // A parameter named "__proto__*0*" groups under "__proto__": without a guard the
+    // grouping wrote attacker-controlled values onto Object.prototype (and then threw)
+    let result = tools.getStructuredParams([{ value: '__proto__*0*' }, { value: "utf-8''polluted" }]);
+    test.deepEqual(result, {});
+    test.equal({}.charset, undefined, 'Object.prototype must stay clean');
+    test.done();
+};
+
+module.exports['Tools: getStructuredParams drops a plain __proto__ parameter'] = test => {
+    // A plain "__proto__" parameter never reaches the output and never touches the prototype.
+    // The string value alone cannot pollute (the __proto__ setter ignores primitives) - the
+    // object-valued continuation form above is the case the live guard covers - so this
+    // pins the output contract: the parameter is dropped, the rest of the list survives.
+    let result = tools.getStructuredParams([{ value: '__proto__' }, { value: 'polluted' }, { value: 'a' }, { value: 'b' }]);
+    test.deepEqual(result, { a: 'b' });
+    test.ok(!Object.prototype.hasOwnProperty.call(result, '__proto__'), 'no own __proto__ property is created');
+    test.equal(Object.getPrototypeOf(result), Object.prototype, 'the prototype must stay untouched');
+    test.done();
+};
+
+module.exports['Tools: formatMessageResponse ignores a non-numeric MODSEQ'] = async test => {
+    // BigInt() throws on garbage, and the throw used to drop the whole message
+    // from the result set - a malformed MODSEQ must be skipped instead
+    let untagged = await parser('* 1 FETCH (UID 1 MODSEQ (abc) FLAGS (\\Seen))');
+    let result = await tools.formatMessageResponse(untagged, {});
+    test.equal(result.uid, 1);
+    test.equal(result.modseq, undefined);
+    test.ok(result.flags.has('\\Seen'));
+
+    // an unparenthesized MODSEQ yields no usable value either
+    let untagged2 = await parser('* 1 FETCH (UID 1 MODSEQ 123)');
+    let result2 = await tools.formatMessageResponse(untagged2, {});
+    test.equal(result2.uid, 1);
+    test.equal(result2.modseq, undefined);
+    test.done();
+};
+
+module.exports['Tools: parseEnvelope skips NIL address entries'] = test => {
+    // A NIL inside an address list used to throw on the dereference, dropping the message
+    let entry = [
+        null, // date
+        null, // subject
+        [null, [{ value: 'Name' }, null, { value: 'user' }, { value: 'example.com' }]], // from: NIL entry + valid entry
+        [], // sender
+        [], // reply-to
+        [], // to
+        [], // cc
+        [], // bcc
+        null, // in-reply-to
+        null // message-id
+    ];
+
+    let result = tools.parseEnvelope(entry);
+    test.equal(result.from.length, 1);
+    test.equal(result.from[0].address, 'user@example.com');
+    test.done();
+};
+
+// ============================================
+// Bounded parsing of untrusted numeric values
+// ============================================
+
+module.exports['Tools: expandRange returns nothing for a non-string range'] = test => {
+    // untaggedVanished() leaves the sequence set as `false` when the response carries only the
+    // (EARLIER) tag, and throwing here would abort the handler for the rest of the response
+    test.deepEqual(tools.expandRange(false), []);
+    test.deepEqual(tools.expandRange(undefined), []);
+    test.deepEqual(tools.expandRange(null), []);
+    test.deepEqual(tools.expandRange(123), []);
+    test.deepEqual(tools.expandRange(['1:3']), []);
+    test.deepEqual(tools.expandRange('1:3'), [1, 2, 3], 'a real range still expands');
+    test.done();
+};
+
+module.exports['Tools: isDecimalString accepts only bounded digit runs'] = test => {
+    test.equal(tools.isDecimalString('12', 10), true);
+    test.equal(tools.isDecimalString('1234567890', 10), true);
+    test.equal(tools.isDecimalString('12345678901', 10), false, 'one digit past the bound is rejected');
+    test.equal(tools.isDecimalString('', 10), false);
+    test.equal(tools.isDecimalString('1e5', 10), false);
+    test.equal(tools.isDecimalString(' 12 ', 10), false);
+    test.equal(tools.isDecimalString('0x10', 10), false);
+    test.equal(tools.isDecimalString('-1', 10), false);
+    test.equal(tools.isDecimalString('1.5', 10), false);
+    test.equal(tools.isDecimalString(12, 10), false, 'only strings are accepted');
+    test.equal(tools.isDecimalString(null, 10), false);
+    test.done();
+};
+
+module.exports['Tools: parseBigIntValue rejects everything BigInt would throw on'] = test => {
+    // isNaN() passes '1e5', ' 12 ' and 'Infinity'; BigInt() throws on all three, and the throw
+    // propagates out of a response handler that was only trying to read one field
+    test.equal(tools.parseBigIntValue('9122'), 9122n);
+    for (let bad of ['1e5', ' 12 ', 'Infinity', 'none', '', '-1', '1.5', null, undefined, 12, ['1']]) {
+        test.equal(tools.parseBigIntValue(bad), false, `${JSON.stringify(bad)} must be rejected`);
+    }
+    test.done();
+};
+
+module.exports['Tools: parseBigIntValue bounds the digit count before converting'] = test => {
+    // BigInt() on a multi-megabyte digit run costs hundreds of milliseconds of non-yielding
+    // CPU, and a response line may carry up to maxLineLength digits
+    test.equal(tools.parseBigIntValue('9'.repeat(19)), BigInt('9'.repeat(19)), '63-bit values still fit the default bound');
+    test.equal(tools.parseBigIntValue('9'.repeat(20)), false);
+    test.equal(tools.parseBigIntValue('9'.repeat(400000)), false);
+    test.equal(tools.parseBigIntValue('12345678901', tools.MAX_UINT32_DIGITS), false, 'a tighter bound can be requested');
+    test.done();
+};
+
+module.exports['Tools: parseUintValue rejects values outside the safe integer range'] = test => {
+    test.equal(tools.parseUintValue('1000'), 1000);
+    test.equal(tools.parseUintValue('0'), 0);
+    test.equal(tools.parseUintValue('9'.repeat(19)), false, 'a value past 2^53-1 is refused, not rounded');
+    test.equal(tools.parseUintValue('9'.repeat(400)), false, 'a digit run that would coerce to Infinity is refused');
+    for (let bad of ['1e3', '0x10', ' 12 ', '-5', '1.5', '']) {
+        test.equal(tools.parseUintValue(bad), false, `${JSON.stringify(bad)} must be rejected`);
+    }
+    test.done();
+};
+
+module.exports['Tools: expandRange caps the total expansion, not just each range'] = test => {
+    // A per-range bound alone is multiplied by an unbounded number of ranges. With the budget
+    // already spent inside the second range, the two after it must be abandoned rather than
+    // expanded on top of it.
+    let result = tools.expandRange('1:16777215,16777215:16777220,1:5,7');
+    test.equal(result.length, tools.EXPANDED_RANGE_LIMIT);
+    test.equal(result[0], 1);
+    // the second range gets the single remaining entry, and the two after it never start
+    test.equal(result[result.length - 1], 16777215);
+    test.done();
+};
+
+module.exports['Tools: formatMessageResponse drops an unusable sequence number'] = async test => {
+    // Number('9'.repeat(400)) is Infinity, and a seq of Infinity indexes into nothing
+    let untagged = await parser('* 1 FETCH (UID 5)');
+    let ok = await tools.formatMessageResponse(untagged, { path: 'INBOX' });
+    test.equal(ok.seq, 1);
+
+    let overflowing = await tools.formatMessageResponse({ command: '9'.repeat(400), attributes: [] }, { path: 'INBOX' });
+    test.equal(overflowing.seq, undefined);
+    test.done();
+};