imapflow 1.3.4 → 1.3.6

package/test/connection-edge-cases-test.js

@@ -2,6 +2,7 @@
 
 const { ImapFlow } = require('../lib/imap-flow');
 const { EventEmitter } = require('events');
+const net = require('net');
 
 // Edge Cases Tests
 
@@ -1067,6 +1068,8 @@ module.exports['Connection Edge: unbind removes socket listeners and returns soc
     test.ok(result.writeSocket, 'Should return writeSocket');
     test.equal(result.readSocket, client.socket);
     test.equal(result.writeSocket, client.socket);
+    // Non-compression path: the raw socket is the same object as read/write.
+    test.equal(result.socket, client.socket);
 
     test.done();
 };
@@ -1103,6 +1106,72 @@ module.exports['Connection Edge: unbind with inflate stream'] = test => {
     test.done();
 };
 
+module.exports['Connection Edge: unbind survives post-handoff socket error (compression)'] = test => {
+    let client = new ImapFlow({
+        host: 'imap.example.com',
+        port: 993,
+        auth: { user: 'test', pass: 'test' }
+    });
+
+    // Mock the compression topology: raw socket plus a separate PassThrough-like
+    // writeSocket, an inflate read stream and a deflate stream. The writeSocket
+    // and deflate error forwarders re-emit onto the raw socket, exactly like compress().
+    client.socket = new EventEmitter();
+    client.socket.unpipe = () => {};
+
+    client.writeSocket = new EventEmitter();
+    client.writeSocket.on('error', err => {
+        if (client.socket) {
+            client.socket.emit('error', err);
+        }
+    });
+
+    client._inflate = new EventEmitter();
+    client._inflate.unpipe = () => {};
+
+    client._deflate = new EventEmitter();
+    client._deflate.on('error', err => {
+        if (client.socket) {
+            client.socket.emit('error', err);
+        }
+    });
+
+    client.setSocketHandlers();
+
+    let result = client.unbind();
+
+    // Explicit contract: raw socket is now exposed alongside read/write sockets.
+    test.equal(result.socket, client.socket, 'Should expose the raw socket');
+    test.equal(result.readSocket, client._inflate);
+    test.equal(result.writeSocket, client.writeSocket);
+
+    // ImapFlow's own _socketError must be detached from writeSocket; only the
+    // forwarder closure remains.
+    test.equal(client.writeSocket.listenerCount('error'), 1);
+
+    // Emitting 'error' on a listener-less EventEmitter throws synchronously, so
+    // each of these would crash the host before the fix. After unbind() the
+    // benign listener on the orphaned raw socket must swallow them all.
+    test.doesNotThrow(() => {
+        client.socket.emit('error', Object.assign(new Error('upstream reset'), { code: 'ECONNRESET' }));
+    }, 'Direct socket error after unbind must not throw');
+
+    test.doesNotThrow(() => {
+        client.writeSocket.emit('error', new Error('write failure'));
+    }, 'writeSocket error forwarded to the raw socket must not throw');
+
+    test.doesNotThrow(() => {
+        client._deflate.emit('error', new Error('deflate failure'));
+    }, 'deflate error forwarded to the raw socket must not throw');
+
+    // close() must remain safe to call after unbind().
+    test.doesNotThrow(() => {
+        client.close();
+    }, 'close() after unbind must not throw');
+
+    test.done();
+};
+
 module.exports['Connection Edge: resolveRange with number input'] = async test => {
     let client = new ImapFlow({
         host: 'imap.example.com',
@@ -1471,7 +1540,14 @@ async function setupCompressedClient() {
     mockSocket.destroy = () => {};
     mockSocket.destroyed = false;
     client.socket = mockSocket;
-    client.streamer = new EventEmitter();
+    // Mock streamer that tracks destruction like a real stream, so close() drives it into
+    // the destroyed state the post-close guards actually check.
+    client.streamer = Object.assign(new EventEmitter(), {
+        destroyed: false,
+        destroy() {
+            this.destroyed = true;
+        }
+    });
 
     client.run = async command => {
         if (command === 'COMPRESS') {
@@ -1562,6 +1638,33 @@ module.exports['Connection Edge: compress _deflate error after close does not cr
     test.done();
 };
 
+module.exports['Connection Edge: compress _inflate error after close does not crash'] = async test => {
+    let { client } = await setupCompressedClient();
+
+    let inflate = client._inflate;
+
+    // close() removes the streamer 'error' listener and destroys the streamer.
+    // A late inflate error must not be forwarded into the destroyed streamer
+    // (which would throw an unhandled 'error' and crash the process).
+    client.close();
+
+    // Confirm we actually reached the post-close state the guard targets.
+    test.ok(client.streamer.destroyed, 'streamer is destroyed after close()');
+
+    // Re-attach an 'error' listener so listenerCount('error') > 0: this isolates the
+    // `!streamer.destroyed` term of the guard. If forwarding still happened, this listener
+    // would throw and escape doesNotThrow — proving the destroyed-check is what suppresses it.
+    client.streamer.on('error', () => {
+        throw new Error('inflate error must not be forwarded into a destroyed streamer');
+    });
+
+    test.doesNotThrow(() => {
+        inflate.emit('error', new Error('late inflate error'));
+    });
+
+    test.done();
+};
+
 // ============================================
 // Mailbox Lock Tests
 // ============================================
@@ -1655,3 +1758,105 @@ module.exports['Connection Edge: multiple locks rejected when no connection'] =
     }
     test.done();
 };
+
+// ============================================
+// reader() survives a write() throw without stalling the stream
+// ============================================
+
+module.exports['Connection Edge: reader survives write throw on + continuation'] = async test => {
+    let client = new ImapFlow({
+        host: 'imap.example.com',
+        port: 993,
+        auth: { user: 'test', pass: 'test' },
+        logger: false
+    });
+
+    client.currentRequest = false;
+    client.commandParts = [Buffer.from('literal-bytes')];
+
+    let writeAttempted = false;
+    client.write = () => {
+        writeAttempted = true;
+        throw new Error('write boom');
+    };
+
+    let nextCalled = false;
+    let done = false;
+    client.streamer.read = () => {
+        if (done) {
+            return null;
+        }
+        done = true;
+        return {
+            payload: Buffer.from('+ Ready'),
+            literals: [],
+            next: () => {
+                nextCalled = true;
+            }
+        };
+    };
+
+    let rejected = false;
+    await client.reader().catch(() => {
+        rejected = true;
+    });
+
+    test.ok(writeAttempted, 'the literal-continuation write path was exercised');
+    test.equal(rejected, false, 'reader did not reject on write throw');
+    test.ok(nextCalled, 'data.next() was still called so the stream is not stalled');
+    test.done();
+};
+
+// ============================================
+// BYE greeting surfaces its reason on the connect rejection
+// ============================================
+
+module.exports['Connection Edge: BYE greeting surfaces reason on connect rejection'] = async test => {
+    // Deterministic ordering: the server ends the socket only AFTER the client has parsed the
+    // BYE and set byeReason, instead of racing a fixed 50ms timer that could flake on slow CI.
+    let signalByeParsed;
+    let byeParsed = new Promise(resolve => {
+        signalByeParsed = resolve;
+    });
+
+    let server = net.createServer(socket => {
+        socket.on('error', () => {});
+        socket.write('* BYE Server too busy\r\n');
+        byeParsed.then(() => socket.end());
+    });
+
+    await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+    let port = server.address().port;
+
+    let client = new ImapFlow({
+        host: '127.0.0.1',
+        port,
+        secure: false,
+        disableAutoIdle: true,
+        logger: false,
+        auth: { user: 'test', pass: 'test' }
+    });
+    client.on('error', () => {});
+
+    // Signal once the client's BYE handler has run, so byeReason is guaranteed set before close().
+    let origServerBye = client.serverBye.bind(client);
+    client.serverBye = async parsed => {
+        await origServerBye(parsed);
+        signalByeParsed();
+    };
+
+    let connectErr = null;
+    try {
+        await client.connect();
+        test.ok(false, 'connect() should reject after a BYE greeting');
+    } catch (err) {
+        connectErr = err;
+    }
+
+    test.ok(connectErr, 'connect() rejected');
+    test.equal(connectErr.reason, 'Server too busy', 'BYE reason surfaced on the rejection');
+
+    client.close();
+    server.close();
+    test.done();
+};

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

@@ -131,6 +131,64 @@ module.exports['LiteralTooLarge error'] = test => {
     stream.write(Buffer.from('A APPEND {1073741825}\r\n'));
 };
 
+module.exports['LiteralTooLarge error honors configured maxLiteralSize'] = test => {
+    const cap = 1024; // 1KB cap
+    const stream = new ImapStream({ cid: 'test', maxLiteralSize: cap });
+
+    stream.on('error', err => {
+        test.equal(err.code, 'LiteralTooLarge', 'error code should be LiteralTooLarge');
+        test.equal(err.maxSize, cap, 'maxSize should reflect the configured cap');
+        test.equal(err.literalSize, 2048, 'literalSize should be the offending value');
+        stream.destroy();
+        test.done();
+    });
+
+    stream.write(Buffer.from('A APPEND {2048}\r\n'));
+};
+
+module.exports['maxLiteralSize: 0 is honored (not swallowed into the default)'] = test => {
+    // Regression: `this.options.maxLiteralSize || MAX_LITERAL_SIZE` turned an explicit 0 into
+    // the 1GB default. An explicit 0 must mean "reject any non-empty literal".
+    test.expect(2);
+
+    const stream = new ImapStream({ cid: 'test', maxLiteralSize: 0 });
+    test.equal(stream.maxLiteralSize, 0, 'an explicit 0 cap is preserved, not replaced by the default');
+
+    stream.on('error', err => {
+        test.equal(err.code, 'LiteralTooLarge', 'a 1-byte literal exceeds the 0 cap');
+        stream.destroy();
+        test.done();
+    });
+
+    stream.write(Buffer.from('A APPEND {1}\r\n'));
+};
+
+module.exports['Literal within configured maxLiteralSize parses cleanly'] = test => {
+    // Require both literal assertions to actually run: 'end' fires even if the parser never
+    // emits the command, so without expect() a dropped-literal regression would pass green.
+    test.expect(2);
+
+    const stream = new ImapStream({ cid: 'test', maxLiteralSize: 1024 });
+    const literal = Buffer.alloc(512, 0x61); // 512 * 'a'
+
+    stream.on('readable', () => {
+        let cmd;
+        while ((cmd = stream.read()) !== null) {
+            test.equal(cmd.literals.length, 1, 'should have one literal');
+            test.equal(cmd.literals[0].length, 512, 'literal length should be 512');
+            cmd.next();
+        }
+    });
+
+    stream.on('error', err => test.ifError(err));
+
+    stream.on('end', () => test.done());
+
+    stream.write(Buffer.from('A APPEND {512}\r\n'));
+    stream.write(literal);
+    stream.end(Buffer.from('\r\n'));
+};
+
 module.exports['Incomplete line continued in next chunk'] = test => {
     runStreamTest(
         test,
@@ -266,3 +324,71 @@ module.exports['logRaw option triggers trace logging'] = test => {
 
     stream.end(Buffer.from('A CMD\r\n'));
 };
+
+module.exports['Adjacent literals with marker at line start'] = test => {
+    // After the first literal's data (12345) is consumed, parsing resumes at the very start of
+    // a line that is itself a literal marker ({3}). The marker begins at byte 0 of the resumed
+    // line, which the backward scan must still recognize. Previously the loop bound skipped
+    // index 0, so the second literal was silently dropped.
+    runStreamTest(
+        test,
+        cmd => {
+            test.equal(cmd.literals.length, 2, 'both adjacent literals must be extracted');
+            test.equal(cmd.literals[0].toString(), '12345', 'first literal content');
+            test.equal(cmd.literals[1].toString(), 'ABC', 'second literal content');
+        },
+        async stream => {
+            stream.end(Buffer.from('A LOGIN {5}\r\n12345{3}\r\nABC\r\n'));
+        },
+        1
+    );
+};
+
+module.exports['Line length cap rejects oversized line'] = test => {
+    // A server that never sends a line terminator must not grow the line buffer without bound.
+    const stream = new ImapStream({ cid: 'test', maxLineLength: 16 });
+    let errored = false;
+
+    stream.on('error', err => {
+        errored = true;
+        test.equal(err.code, 'LineTooLarge', 'error code should be LineTooLarge');
+        test.equal(err.maxSize, 16, 'error should report the configured cap');
+        stream.destroy();
+        test.done();
+    });
+
+    stream.on('end', () => {
+        if (!errored) {
+            test.ok(false, 'expected a LineTooLarge error');
+            test.done();
+        }
+    });
+
+    // 24 bytes, no LF, written across chunks -> exceeds the 16 byte cap.
+    stream.write(Buffer.from('AAAAAAAA'));
+    stream.write(Buffer.from('BBBBBBBB'));
+    stream.write(Buffer.from('CCCCCCCC'));
+};
+
+module.exports['Line length cap allows line within limit'] = test => {
+    // A normal line under the configured cap must still parse cleanly.
+    const stream = new ImapStream({ cid: 'test', maxLineLength: 32 });
+    let payloads = [];
+
+    stream.on('readable', () => {
+        let cmd;
+        while ((cmd = stream.read()) !== null) {
+            payloads.push(cmd.payload.toString());
+            cmd.next();
+        }
+    });
+
+    stream.on('error', err => test.ifError(err));
+
+    stream.on('end', () => {
+        test.deepEqual(payloads, ['A NOOP'], 'line under the cap should parse');
+        test.done();
+    });
+
+    stream.end(Buffer.from('A NOOP\r\n'));
+};

package/test/proxy-connection-test.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const proxyquire = require('proxyquire').noCallThru();
+const { EventEmitter } = require('events');
 
 // Mock socket object
 const createMockSocket = () => ({
@@ -10,6 +11,16 @@ const createMockSocket = () => ({
     destroy: () => {}
 });
 
+// Real EventEmitter-backed mock socket, for tests that need listener tracking / emit.
+const createMockEmitterSocket = () => Object.assign(new EventEmitter(), { write() {}, end() {}, destroy() {} });
+
+// Asserts proxyConnection returned the socket and guarded it with an error listener.
+const assertEarlyErrorHandler = (test, socket, mockSocket) => {
+    test.equal(socket, mockSocket);
+    test.ok(socket.listenerCount('error') >= 1, 'proxy socket carries an error listener before being returned');
+    test.doesNotThrow(() => socket.emit('error', new Error('early proxy error')), 'an early proxy socket error does not throw');
+};
+
 // Mock logger
 const createMockLogger = () => {
     const logs = { info: [], error: [] };
@@ -539,3 +550,78 @@ module.exports['Proxy Connection: SOCKS with username only'] = async test => {
     await proxyConnection(logger, 'socks5://testuser@proxy.example.com:1080', '192.168.1.1', 993);
     test.done();
 };
+
+// ============================================
+// Early error handler (no unhandled 'error' before ImapFlow takes over)
+// ============================================
+
+module.exports['Proxy Connection: HTTP socket has early error handler before return'] = async test => {
+    const mockSocket = createMockEmitterSocket();
+    const logger = createMockLogger();
+
+    const { proxyConnection } = proxyquire('../lib/proxy-connection', {
+        'nodemailer/lib/smtp-connection/http-proxy-client': (url, port, host, cb) => {
+            cb(null, mockSocket);
+        },
+        socks: { SocksClient: {} },
+        dns: { promises: { resolve: async () => ['127.0.0.1'] } },
+        net: { isIP: () => true }
+    });
+
+    const socket = await proxyConnection(logger, 'http://proxy.example.com:8080', '192.168.1.1', 993);
+
+    assertEarlyErrorHandler(test, socket, mockSocket);
+    test.done();
+};
+
+module.exports['Proxy Connection: SOCKS socket has early error handler before return'] = async test => {
+    const mockSocket = createMockEmitterSocket();
+    const logger = createMockLogger();
+
+    const { proxyConnection } = proxyquire('../lib/proxy-connection', {
+        'nodemailer/lib/smtp-connection/http-proxy-client': () => {},
+        socks: {
+            SocksClient: {
+                createConnection: async () => ({ socket: mockSocket })
+            }
+        },
+        dns: { promises: { resolve: async () => ['127.0.0.1'] } },
+        net: { isIP: () => true }
+    });
+
+    const socket = await proxyConnection(logger, 'socks5://proxy.example.com:1080', '192.168.1.1', 993);
+
+    assertEarlyErrorHandler(test, socket, mockSocket);
+    test.done();
+};
+
+// detachEarlyErrorHandler must remove the guard once the caller takes ownership of the socket,
+// so it no longer swallows/logs errors meant for the new owner's handlers.
+module.exports['Proxy Connection: detachEarlyErrorHandler removes the early guard'] = async test => {
+    const mockSocket = createMockEmitterSocket();
+    const logger = createMockLogger();
+
+    const { proxyConnection, detachEarlyErrorHandler } = proxyquire('../lib/proxy-connection', {
+        'nodemailer/lib/smtp-connection/http-proxy-client': (url, port, host, cb) => {
+            cb(null, mockSocket);
+        },
+        socks: { SocksClient: {} },
+        dns: { promises: { resolve: async () => ['127.0.0.1'] } },
+        net: { isIP: () => true }
+    });
+
+    const socket = await proxyConnection(logger, 'http://proxy.example.com:8080', '192.168.1.1', 993);
+    test.ok(socket.listenerCount('error') >= 1, 'early error handler attached on return');
+    test.ok(typeof socket._earlyErrorHandler === 'function', 'handler reference stored on the socket');
+
+    detachEarlyErrorHandler(socket);
+
+    test.equal(socket.listenerCount('error'), 0, 'early error handler removed after detach');
+    test.equal(socket._earlyErrorHandler, null, 'stored handler reference cleared');
+
+    // Detaching again (or on a bare socket) must be a safe no-op.
+    test.doesNotThrow(() => detachEarlyErrorHandler(socket));
+    test.doesNotThrow(() => detachEarlyErrorHandler(createMockEmitterSocket()));
+
+    test.done();
+};

package/test/reliability-improvements-test.js

@@ -368,3 +368,91 @@ module.exports['Reliability: decoder emit(error) does not crash when user has no
 
     test.done();
 };
+
+// ============================================================================
+// Throttle back-off timer is tracked and abortable on close()
+// ============================================================================
+
+// Feed a single throttling BAD response into reader() once, then null.
+const stubThrottleResponse = (client, backoffMs) => {
+    let request = { tag: 'A001', command: 'FETCH', resolve: () => {}, reject: () => {} };
+    client.requestTagMap = new Map([['A001', request]]);
+
+    let done = false;
+    client.streamer.read = () => {
+        if (done) {
+            return null;
+        }
+        done = true;
+        return {
+            payload: Buffer.from(`A001 BAD Request is throttled. Suggested Backoff Time: ${backoffMs} milliseconds`),
+            literals: [],
+            next: () => {}
+        };
+    };
+
+    return request;
+};
+
+module.exports['Reliability: throttle back-off aborts promptly on close()'] = async test => {
+    let client = new ImapFlow({
+        host: 'imap.example.com',
+        port: 993,
+        auth: { user: 'test', pass: 'test' },
+        logger: false
+    });
+    client.socket = { destroyed: false, destroy: () => {} };
+    client.writeSocket = client.socket;
+
+    let rejected = null;
+    let request = stubThrottleResponse(client, 300000); // 5 min back-off
+    request.reject = err => {
+        rejected = err;
+    };
+
+    let start = Date.now();
+    let readerDone = client.reader().catch(() => {});
+
+    // 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');
+
+    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.ok(Date.now() - start < 5000, 'settled well under the 5-minute cap');
+
+    await readerDone;
+    test.done();
+};
+
+module.exports['Reliability: throttle back-off still rejects ETHROTTLE on normal expiry'] = async test => {
+    let client = new ImapFlow({
+        host: 'imap.example.com',
+        port: 993,
+        auth: { user: 'test', pass: 'test' },
+        logger: false
+    });
+
+    let rejected = null;
+    let request = stubThrottleResponse(client, 50); // 50ms back-off
+    request.reject = err => {
+        rejected = err;
+    };
+
+    let readerDone = client.reader().catch(() => {});
+
+    await new Promise(r => setTimeout(r, 250));
+
+    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');
+
+    await readerDone;
+    client.close();
+    test.done();
+};