advanced-tls-client 5.0.0 → 5.0.1

package/dist/index.d.ts

@@ -61,6 +61,7 @@ interface FullResponse {
         end: number;
         total: number;
     };
+    redirectCount?: number;
 }
 interface ChromeProfile {
     name: string;
@@ -144,6 +145,7 @@ interface Response extends EventEmitter {
     raw?: Buffer;
     cookies?: Record<string, string>;
     parser?: string;
+    redirectCount?: number;
 }
 declare class ProfileRegistry {
     private static getGrease;
@@ -163,6 +165,9 @@ declare class AdvancedTLSClient {
     constructor(profileName?: string);
     private setup;
     private isRequestOptions;
+    private shouldFollowRedirect;
+    private getRedirectLocation;
+    private adjustHeadersForRedirect;
     request(uri: string, dataOrOptions?: any, optionsOrCallback?: RequestOptions | ((err: any, res?: Response) => void), callback?: (err: any, res?: Response) => void): Promise<FullResponse | PassThrough>;
     private generateJA3;
     private buildMultipart;

package/dist/index.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProfileRegistry = exports.AdvancedTLSClient = void 0;
 const tls = __importStar(require("tls"));
 const net = __importStar(require("net"));
+const https = __importStar(require("https"));
 const http2 = __importStar(require("http2"));
 const crypto = __importStar(require("crypto"));
 const events_1 = require("events");
@@ -62,66 +63,11 @@ class ProfileRegistry {
             name: 'chrome_mobile_143_android',
             version: '143.0.0.0',
             tls: {
-                cipherSuites: [
-                    grease1,
-                    4865,
-                    4866,
-                    4867,
-                    49195,
-                    49199,
-                    49196,
-                    49200,
-                    52393,
-                    52392,
-                    49171,
-                    49172,
-                    156,
-                    157,
-                    47,
-                    53
-                ],
-                extensions: [
-                    grease2,
-                    65037,
-                    27,
-                    43,
-                    16,
-                    35,
-                    45,
-                    11,
-                    65281,
-                    5,
-                    10,
-                    23,
-                    0,
-                    17513,
-                    51,
-                    18,
-                    13,
-                    grease3
-                ],
-                supportedGroups: [
-                    grease4,
-                    25497,
-                    29,
-                    23,
-                    24
-                ],
-                signatureAlgorithms: [
-                    1027,
-                    2052,
-                    1025,
-                    1283,
-                    2053,
-                    1281,
-                    2054,
-                    1537
-                ],
-                supportedVersions: [
-                    grease2,
-                    772,
-                    771
-                ],
+                cipherSuites: [grease1, 4865, 4866, 4867, 49195, 49199, 49196, 49200, 52393, 52392, 49171, 49172, 156, 157, 47, 53],
+                extensions: [grease2, 65037, 27, 43, 16, 35, 45, 11, 65281, 5, 10, 23, 0, 17513, 51, 18, 13, grease3],
+                supportedGroups: [grease4, 25497, 29, 23, 24],
+                signatureAlgorithms: [1027, 2052, 1025, 1283, 2053, 1281, 2054, 1537],
+                supportedVersions: [grease2, 772, 771],
                 ecPointFormats: [0],
                 alpnProtocols: ['h2', 'http/1.1'],
                 pskKeyExchangeModes: [1],
@@ -141,29 +87,9 @@ class ProfileRegistry {
                 maxHeaderListSize: 262144,
                 settingsOrder: [1, 2, 4, 6],
                 connectionPreface: Buffer.from('PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n'),
-                priorityFrames: [
-                    {
-                        streamId: 0,
-                        weight: 256,
-                        dependency: 0,
-                        exclusive: true
-                    }
-                ],
+                priorityFrames: [{ streamId: 0, weight: 256, dependency: 0, exclusive: true }],
                 pseudoHeaderOrder: [':method', ':authority', ':scheme', ':path'],
-                headerOrder: [
-                    'sec-ch-ua',
-                    'sec-ch-ua-mobile',
-                    'sec-ch-ua-platform',
-                    'upgrade-insecure-requests',
-                    'user-agent',
-                    'accept',
-                    'sec-fetch-site',
-                    'sec-fetch-mode',
-                    'sec-fetch-dest',
-                    'accept-encoding',
-                    'accept-language',
-                    'priority'
-                ]
+                headerOrder: ['sec-ch-ua', 'sec-ch-ua-mobile', 'sec-ch-ua-platform', 'upgrade-insecure-requests', 'user-agent', 'accept', 'sec-fetch-site', 'sec-fetch-mode', 'sec-fetch-dest', 'accept-encoding', 'accept-language', 'priority']
             },
             userAgent: 'Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36',
             secChUa: '"Google Chrome";v="143", "Chromium";v="143", "Not A(Brand";v="24"',
@@ -177,15 +103,9 @@ class ProfileRegistry {
             priority: 'u=0, i'
         };
     }
-    static get(name) {
-        return this.chromeMobile143Android();
-    }
-    static get latest() {
-        return this.chromeMobile143Android();
-    }
-    static get latestMobile() {
-        return this.chromeMobile143Android();
-    }
+    static get(name) { return this.chromeMobile143Android(); }
+    static get latest() { return this.chromeMobile143Android(); }
+    static get latestMobile() { return this.chromeMobile143Android(); }
 }
 exports.ProfileRegistry = ProfileRegistry;
 class CookieJar {
@@ -247,10 +167,6 @@ class CookieJar {
         }
     }
 }
-const Protocol = {
-    HTTP1: 'http1',
-    HTTP2: 'http2'
-};
 class UnifiedClientManager extends events_1.EventEmitter {
     constructor(tlsSocket, profile, hostname, cookieJar) {
         super();
@@ -291,10 +207,7 @@ class UnifiedClientManager extends events_1.EventEmitter {
                         break;
                 }
             });
-            this.http2Client = http2.connect(`https://${this.hostname}`, {
-                createConnection: () => this.tlsSocket,
-                settings
-            });
+            this.http2Client = http2.connect(`https://${this.hostname}`, { createConnection: () => this.tlsSocket, settings });
             this.http2Client.once('connect', resolve);
             this.http2Client.once('error', reject);
             this.http2Client.once('timeout', () => reject(new Error('HTTP/2 session timeout')));
@@ -321,21 +234,11 @@ class UnifiedClientManager extends events_1.EventEmitter {
     }
     async requestHttp2(path, options, timingStart, headers, post_data, out, callback) {
         const normalizedPath = path.startsWith('/') ? path : `/${path}`;
-        const reqHeaders = {
-            ':method': options.method?.toUpperCase() || 'GET',
-            ':authority': this.hostname,
-            ':scheme': 'https',
-            ':path': normalizedPath,
-            ...headers
-        };
+        const reqHeaders = { ':method': options.method?.toUpperCase() || 'GET', ':authority': this.hostname, ':scheme': 'https', ':path': normalizedPath, ...headers };
         const stream = this.http2Client.request(reqHeaders);
         const response = new events_1.EventEmitter();
         response.timing = { socket: timingStart, lookup: 0, connect: 0, secureConnect: 0, response: 0, end: 0, total: 0 };
-        response.fingerprints = {
-            ja3: this.generateJA3(),
-            ja3Hash: crypto.createHash('md5').update(this.generateJA3()).digest('hex'),
-            akamai: `1:${this.profile.http2.headerTableSize};2:${this.profile.http2.enablePush};4:${this.profile.http2.initialWindowSize};6:${this.profile.http2.maxHeaderListSize ?? ''}|00|0|m,a,s,p`
-        };
+        response.fingerprints = { ja3: this.generateJA3(), ja3Hash: crypto.createHash('md5').update(this.generateJA3()).digest('hex'), akamai: `1:${this.profile.http2.headerTableSize};2:${this.profile.http2.enablePush};4:${this.profile.http2.initialWindowSize};6:${this.profile.http2.maxHeaderListSize ?? ''}|00|0|m,a,s,p` };
         const chunks = [];
         const rawChunks = [];
         let finished = false;
@@ -370,9 +273,8 @@ class UnifiedClientManager extends events_1.EventEmitter {
             response.body = body;
             try {
                 response.text = body.toString('utf-8');
-                if (response.headers['content-type']?.includes('application/json')) {
+                if (response.headers['content-type']?.includes('application/json'))
                     response.json = JSON.parse(response.text);
-                }
             }
             catch { }
             response.timing.end = Date.now() - timingStart;
@@ -411,45 +313,29 @@ class UnifiedClientManager extends events_1.EventEmitter {
                     }
                     catch { }
                 }
-                setImmediate(() => {
-                    if (!stream.closed && !stream.destroyed && stream.writable) {
-                        stream.end();
-                    }
-                });
+                setImmediate(() => { if (!stream.closed && !stream.destroyed && stream.writable)
+                    stream.end(); });
             }
             else if (post_data instanceof stream_1.Readable) {
                 post_data.pipe(stream, { end: true });
                 post_data.on('error', err => stream.destroy(err));
             }
             else {
-                setImmediate(() => {
-                    if (stream.writable)
-                        stream.end();
-                });
+                setImmediate(() => { if (stream.writable)
+                    stream.end(); });
             }
         }
         else {
-            setImmediate(() => {
-                if (stream.writable)
-                    stream.end();
-            });
+            setImmediate(() => { if (stream.writable)
+                stream.end(); });
         }
     }
     async requestHttp1(path, options, timingStart, headers, post_data, out, callback) {
-        const reqOptions = {
-            method: options.method?.toUpperCase() || 'GET',
-            path,
-            headers: { host: this.hostname, ...headers },
-            createConnection: () => this.tlsSocket
-        };
-        const req = require('https').request(reqOptions);
+        const reqOptions = { method: options.method?.toUpperCase() || 'GET', path, headers: { host: this.hostname, ...headers }, createConnection: () => this.tlsSocket };
+        const req = https.request(reqOptions);
         const response = new events_1.EventEmitter();
         response.timing = { socket: timingStart, lookup: 0, connect: 0, secureConnect: 0, response: 0, end: 0, total: 0 };
-        response.fingerprints = {
-            ja3: this.generateJA3(),
-            ja3Hash: crypto.createHash('md5').update(this.generateJA3()).digest('hex'),
-            akamai: ''
-        };
+        response.fingerprints = { ja3: this.generateJA3(), ja3Hash: crypto.createHash('md5').update(this.generateJA3()).digest('hex'), akamai: '' };
         const chunks = [];
         const rawChunks = [];
         let finished = false;
@@ -486,9 +372,8 @@ class UnifiedClientManager extends events_1.EventEmitter {
             response.body = body;
             try {
                 response.text = body.toString('utf-8');
-                if (res.headers['content-type']?.includes('application/json')) {
+                if (res.headers['content-type']?.includes('application/json'))
                     response.json = JSON.parse(response.text);
-                }
             }
             catch { }
             response.timing.end = Date.now() - timingStart;
@@ -565,15 +450,8 @@ class TLSSocketManager extends events_1.EventEmitter {
         this.port = port;
         this.startTime = Date.now();
         return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                this.destroy();
-                reject(new Error('Connection timeout'));
-            }, 30000);
-            const handleError = (err) => {
-                clearTimeout(timeout);
-                this.destroy();
-                reject(err);
-            };
+            const timeout = setTimeout(() => { this.destroy(); reject(new Error('Connection timeout')); }, 30000);
+            const handleError = (err) => { clearTimeout(timeout); this.destroy(); reject(err); };
             if (this.proxy) {
                 const proxyUrl = new url.URL(this.proxy);
                 this.socket = net.connect(+proxyUrl.port || 80, proxyUrl.hostname, () => {
@@ -605,9 +483,7 @@ class TLSSocketManager extends events_1.EventEmitter {
                 this.socket = new net.Socket();
                 this.socket.setNoDelay(true);
                 this.socket.setKeepAlive(true, 60000);
-                this.socket.once('lookup', () => {
-                    this.timing.lookup = Date.now() - this.startTime;
-                });
+                this.socket.once('lookup', () => { this.timing.lookup = Date.now() - this.startTime; });
                 this.socket.connect(port, hostname, () => {
                     this.timing.connect = Date.now() - this.startTime;
                     this.proceedWithTLS(resolve, reject, timeout);
@@ -618,37 +494,8 @@ class TLSSocketManager extends events_1.EventEmitter {
         });
     }
     proceedWithTLS(resolve, reject, timeout) {
-        const validCiphers = [
-            'TLS_AES_256_GCM_SHA384',
-            'TLS_CHACHA20_POLY1305_SHA256',
-            'TLS_AES_128_GCM_SHA256',
-            'ECDHE-ECDSA-AES256-GCM-SHA384',
-            'ECDHE-RSA-AES256-GCM-SHA384',
-            'ECDHE-ECDSA-CHACHA20-POLY1305',
-            'ECDHE-RSA-CHACHA20-POLY1305',
-            'ECDHE-ECDSA-AES128-GCM-SHA256',
-            'ECDHE-RSA-AES128-GCM-SHA256',
-            'ECDHE-ECDSA-AES256-SHA',
-            'ECDHE-RSA-AES256-SHA',
-            'ECDHE-ECDSA-AES128-SHA',
-            'ECDHE-RSA-AES128-SHA',
-            'AES256-GCM-SHA384',
-            'AES128-GCM-SHA256',
-            'AES256-SHA',
-            'AES128-SHA'
-        ].join(':');
-        const tlsOptions = {
-            socket: this.socket,
-            servername: this.hostname,
-            ALPNProtocols: this.profile.tls.alpnProtocols,
-            ciphers: validCiphers,
-            minVersion: 'TLSv1.2',
-            maxVersion: 'TLSv1.3',
-            rejectUnauthorized: false,
-            requestCert: false,
-            honorCipherOrder: true,
-            sessionTimeout: 300
-        };
+        const validCiphers = ['TLS_AES_256_GCM_SHA384', 'TLS_CHACHA20_POLY1305_SHA256', 'TLS_AES_128_GCM_SHA256', 'ECDHE-ECDSA-AES256-GCM-SHA384', 'ECDHE-RSA-AES256-GCM-SHA384', 'ECDHE-ECDSA-CHACHA20-POLY1305', 'ECDHE-RSA-CHACHA20-POLY1305', 'ECDHE-ECDSA-AES128-GCM-SHA256', 'ECDHE-RSA-AES128-GCM-SHA256', 'ECDHE-ECDSA-AES256-SHA', 'ECDHE-RSA-AES256-SHA', 'ECDHE-ECDSA-AES128-SHA', 'ECDHE-RSA-AES128-SHA', 'AES256-GCM-SHA384', 'AES128-GCM-SHA256', 'AES256-SHA', 'AES128-SHA'].join(':');
+        const tlsOptions = { socket: this.socket, servername: this.hostname, ALPNProtocols: this.profile.tls.alpnProtocols, ciphers: validCiphers, minVersion: 'TLSv1.2', maxVersion: 'TLSv1.3', rejectUnauthorized: false, requestCert: false, honorCipherOrder: true, sessionTimeout: 300 };
         this.tlsSocket = tls.connect(tlsOptions);
         this.tlsSocket.once('secureConnect', () => {
             clearTimeout(timeout);
@@ -656,24 +503,11 @@ class TLSSocketManager extends events_1.EventEmitter {
             this.timing.socket = this.startTime;
             resolve(this.tlsSocket);
         });
-        this.tlsSocket.on('error', (err) => {
-            clearTimeout(timeout);
-            this.destroy();
-            reject(err);
-        });
-    }
-    getTiming() {
-        return { ...this.timing, total: Date.now() - this.startTime };
-    }
-    destroy() {
-        this.tlsSocket?.destroy();
-        this.socket?.destroy();
-        this.tlsSocket = null;
-        this.socket = null;
-    }
-    getSocket() {
-        return this.tlsSocket;
+        this.tlsSocket.on('error', (err) => { clearTimeout(timeout); this.destroy(); reject(err); });
     }
+    getTiming() { return { ...this.timing, total: Date.now() - this.startTime }; }
+    destroy() { this.tlsSocket?.destroy(); this.socket?.destroy(); this.tlsSocket = null; this.socket = null; }
+    getSocket() { return this.tlsSocket; }
 }
 class AdvancedTLSClient {
     constructor(profileName) {
@@ -720,11 +554,7 @@ class AdvancedTLSClient {
         }, 60000);
     }
     setup(uri, options) {
-        const config = {
-            headers: {},
-            proxy: options.proxy || this.defaults.proxy,
-            decompress: options.decompress !== undefined ? options.decompress : true
-        };
+        const config = { headers: {}, proxy: options.proxy || this.defaults.proxy, decompress: options.decompress !== undefined ? options.decompress : true };
         config.headers['user-agent'] = this.profile.userAgent;
         config.headers['accept-language'] = this.profile.acceptLanguage || 'en-US,en;q=0.9';
         config.headers['accept-encoding'] = 'gzip, deflate, br';
@@ -739,9 +569,8 @@ class AdvancedTLSClient {
             config.headers['upgrade-insecure-requests'] = this.profile.upgradeInsecureRequests;
         if (this.profile.priority)
             config.headers['priority'] = this.profile.priority;
-        if (options.headers) {
+        if (options.headers)
             Object.assign(config.headers, options.headers);
-        }
         return config;
     }
     isRequestOptions(obj) {
@@ -753,174 +582,238 @@ class AdvancedTLSClient {
         const keys = Object.keys(obj);
         return keys.some(key => optionKeys.includes(key));
     }
+    shouldFollowRedirect(status, options) {
+        if (options.followRedirects === false)
+            return false;
+        return [301, 302, 303, 307, 308].includes(status);
+    }
+    getRedirectLocation(headers, baseUrl) {
+        const location = headers['location'];
+        if (!location)
+            return null;
+        const loc = Array.isArray(location) ? location[0] : location;
+        if (!loc)
+            return null;
+        try {
+            return new url.URL(loc, baseUrl).href;
+        }
+        catch {
+            return null;
+        }
+    }
+    adjustHeadersForRedirect(headers, status) {
+        const newHeaders = { ...headers };
+        if (status === 303 || status === 301 || status === 302) {
+            delete newHeaders['content-length'];
+            delete newHeaders['Content-Length'];
+        }
+        if (status === 303) {
+            delete newHeaders['content-type'];
+            delete newHeaders['Content-Type'];
+        }
+        return newHeaders;
+    }
     async request(uri, dataOrOptions, optionsOrCallback, callback) {
         let data = null;
         let options = {};
         let cb = undefined;
-        if (typeof dataOrOptions === 'function') {
+        if (typeof dataOrOptions === 'function')
             cb = dataOrOptions;
-        }
         else if (dataOrOptions !== undefined && dataOrOptions !== null) {
-            if (this.isRequestOptions(dataOrOptions)) {
+            if (this.isRequestOptions(dataOrOptions))
                 options = dataOrOptions;
-            }
-            else {
+            else
                 data = dataOrOptions;
-            }
         }
-        if (typeof optionsOrCallback === 'function') {
+        if (typeof optionsOrCallback === 'function')
             cb = optionsOrCallback;
-        }
-        else if (optionsOrCallback !== undefined && optionsOrCallback !== null) {
+        else if (optionsOrCallback !== undefined && optionsOrCallback !== null)
             options = optionsOrCallback;
-        }
-        if (callback !== undefined) {
+        if (callback !== undefined)
             cb = callback;
-        }
-        if (data && typeof data !== 'object' && !Buffer.isBuffer(data) && !(data instanceof stream_1.Readable)) {
-            throw new Error('Invalid data type');
-        }
-        const parsed = new url.URL(uri);
-        const hostname = parsed.hostname;
-        const port = parsed.port ? +parsed.port : 443;
-        const path = parsed.pathname + parsed.search;
-        const cacheKey = `${hostname}:${port}`;
-        const startTime = Date.now();
-        const out = new stream_1.PassThrough();
-        let session = this.sessionCache.get(cacheKey);
-        if (!session || session.tlsManager.getSocket()?.destroyed) {
-            const tlsManager = new TLSSocketManager(this.profile, options.proxy);
-            const tlsSocket = await tlsManager.connect(hostname, port);
-            const clientManager = new UnifiedClientManager(tlsSocket, this.profile, hostname, this.cookieJar);
-            await clientManager.initialize();
-            session = { tlsManager, clientManager, lastUsed: Date.now() };
-            this.sessionCache.set(cacheKey, session);
-            if (this.sessionCache.size > this.maxCachedSessions) {
-                const oldest = [...this.sessionCache.entries()].sort((a, b) => a[1].lastUsed - b[1].lastUsed)[0];
-                oldest[1].clientManager.destroy();
-                oldest[1].tlsManager.destroy();
-                this.sessionCache.delete(oldest[0]);
-            }
-        }
-        session.lastUsed = Date.now();
-        const config = this.setup(uri, options);
-        let post_data = null;
-        let json = options.json !== undefined ? options.json : false;
-        if (json === undefined && config.headers['content-type']?.includes('application/json')) {
-            json = true;
-        }
-        if (data) {
-            if (options.multipart) {
-                const boundary = options.boundary || this.defaults.boundary;
-                post_data = await this.buildMultipart(data, boundary);
-                config.headers['content-type'] = `multipart/form-data; boundary=${boundary}`;
-            }
-            else if (data instanceof stream_1.Readable) {
-                post_data = data;
-            }
-            else if (Buffer.isBuffer(data)) {
-                post_data = data;
-            }
-            else if (typeof data === 'string') {
-                post_data = data;
+        const maxRedirects = options.maxRedirects ?? options.follow_max ?? 20;
+        let redirectCount = 0;
+        let currentUri = uri;
+        let currentMethod = options.method?.toUpperCase() || 'GET';
+        let currentBody = data;
+        let currentHeaders = options.headers || {};
+        const execute = async (targetUri) => {
+            const parsed = new url.URL(targetUri);
+            const hostname = parsed.hostname;
+            const port = parsed.port ? +parsed.port : 443;
+            const path = parsed.pathname + parsed.search;
+            const cacheKey = `${hostname}:${port}`;
+            const startTime = Date.now();
+            const out = new stream_1.PassThrough();
+            let session = this.sessionCache.get(cacheKey);
+            if (!session || session.tlsManager.getSocket()?.destroyed) {
+                const tlsManager = new TLSSocketManager(this.profile, options.proxy);
+                const tlsSocket = await tlsManager.connect(hostname, port);
+                const clientManager = new UnifiedClientManager(tlsSocket, this.profile, hostname, this.cookieJar);
+                await clientManager.initialize();
+                session = { tlsManager, clientManager, lastUsed: Date.now() };
+                this.sessionCache.set(cacheKey, session);
+                if (this.sessionCache.size > this.maxCachedSessions) {
+                    const oldest = [...this.sessionCache.entries()].sort((a, b) => a[1].lastUsed - b[1].lastUsed)[0];
+                    oldest[1].clientManager.destroy();
+                    oldest[1].tlsManager.destroy();
+                    this.sessionCache.delete(oldest[0]);
+                }
             }
-            else if (json) {
-                post_data = JSON.stringify(data);
-                config.headers['content-type'] = 'application/json; charset=utf-8';
+            session.lastUsed = Date.now();
+            const config = this.setup(targetUri, options);
+            config.headers = { ...config.headers, ...currentHeaders };
+            let post_data = null;
+            let json = options.json !== undefined ? options.json : false;
+            if (currentBody) {
+                if (options.multipart) {
+                    const boundary = options.boundary || this.defaults.boundary;
+                    post_data = await this.buildMultipart(currentBody, boundary);
+                    config.headers['content-type'] = `multipart/form-data; boundary=${boundary}`;
+                }
+                else if (currentBody instanceof stream_1.Readable) {
+                    post_data = currentBody;
+                }
+                else if (Buffer.isBuffer(currentBody)) {
+                    post_data = currentBody;
+                }
+                else if (typeof currentBody === 'string') {
+                    post_data = currentBody;
+                }
+                else if (json) {
+                    post_data = JSON.stringify(currentBody);
+                    config.headers['content-type'] = 'application/json; charset=utf-8';
+                }
+                else {
+                    post_data = new URLSearchParams(currentBody).toString();
+                    config.headers['content-type'] = 'application/x-www-form-urlencoded';
+                }
+                if (post_data && (typeof post_data === 'string' || Buffer.isBuffer(post_data))) {
+                    config.headers['content-length'] = Buffer.byteLength(post_data).toString();
+                }
             }
-            else {
-                post_data = new URLSearchParams(data).toString();
-                config.headers['content-type'] = 'application/x-www-form-urlencoded';
+            const cookies = this.cookieJar.getCookies(hostname, parsed.pathname, parsed.protocol === 'https:');
+            if (cookies)
+                config.headers['cookie'] = cookies;
+            if (options.stream === true) {
+                session.clientManager.request(path, options, startTime, config.headers, post_data, out);
+                return out;
             }
-            if (post_data && (typeof post_data === 'string' || Buffer.isBuffer(post_data))) {
-                config.headers['content-length'] = Buffer.byteLength(post_data).toString();
+            if (cb) {
+                session.clientManager.request(path, options, startTime, config.headers, post_data, out, cb);
+                return out;
             }
-        }
-        const cookies = this.cookieJar.getCookies(hostname, parsed.pathname, parsed.protocol === 'https:');
-        if (cookies)
-            config.headers['cookie'] = cookies;
-        if (options.stream === true) {
-            session.clientManager.request(path, options, startTime, config.headers, post_data, out);
-            return out;
-        }
-        if (cb) {
-            session.clientManager.request(path, options, startTime, config.headers, post_data, out, cb).catch(err => {
-                if (cb)
-                    cb(err);
-            });
-            return out;
-        }
-        return new Promise((resolve, reject) => {
-            let statusCode = 0;
-            let headers = {};
-            const chunks = [];
-            let done = false;
-            const complete = async (err) => {
-                if (done)
-                    return;
-                done = true;
-                if (err)
-                    return reject(err);
-                let body = Buffer.concat(chunks);
-                if (options.decompress !== false && headers) {
-                    const encoding = headers['content-encoding']?.toLowerCase();
-                    if (encoding) {
+            return new Promise((resolve, reject) => {
+                let statusCode = 0;
+                let headers = {};
+                const chunks = [];
+                let done = false;
+                const complete = async (err) => {
+                    if (done)
+                        return;
+                    done = true;
+                    if (err)
+                        return reject(err);
+                    let body = Buffer.concat(chunks);
+                    if (options.decompress !== false && headers) {
+                        const encoding = headers['content-encoding']?.toLowerCase();
+                        if (encoding) {
+                            try {
+                                if (encoding.includes('gzip'))
+                                    body = await gunzipAsync(body);
+                                else if (encoding.includes('br'))
+                                    body = await brotliDecompressAsync(body);
+                                else if (encoding.includes('deflate'))
+                                    body = await inflateAsync(body);
+                            }
+                            catch { }
+                        }
+                    }
+                    const text = body.toString('utf-8');
+                    let parsedJson = undefined;
+                    const ct = headers['content-type']?.toLowerCase();
+                    if (ct?.includes('application/json')) {
                         try {
-                            if (encoding.includes('gzip'))
-                                body = await gunzipAsync(body);
-                            else if (encoding.includes('br'))
-                                body = await brotliDecompressAsync(body);
-                            else if (encoding.includes('deflate'))
-                                body = await inflateAsync(body);
+                            parsedJson = JSON.parse(text);
                         }
                         catch { }
                     }
-                }
-                const text = body.toString('utf-8');
-                let parsedJson = undefined;
-                const ct = headers['content-type']?.toLowerCase();
-                if (ct?.includes('application/json')) {
-                    try {
-                        parsedJson = JSON.parse(text);
-                    }
-                    catch (e) {
-                        parsedJson = undefined;
-                    }
-                }
-                resolve({
-                    statusCode,
-                    headers,
-                    body,
-                    text,
-                    json: parsedJson,
-                    fingerprints: {
-                        ja3: this.generateJA3(),
-                        ja3Hash: crypto.createHash('md5').update(this.generateJA3()).digest('hex'),
-                        akamai: `1:${this.profile.http2.headerTableSize};2:${this.profile.http2.enablePush};4:${this.profile.http2.initialWindowSize};6:${this.profile.http2.maxHeaderListSize ?? ''}|00|0|m,a,s,p`
-                    },
-                    timing: {
-                        socket: startTime,
-                        lookup: 0,
-                        connect: 0,
-                        secureConnect: 0,
-                        response: Date.now() - startTime,
-                        end: Date.now() - startTime,
-                        total: Date.now() - startTime
+                    const responseObj = {
+                        statusCode,
+                        headers,
+                        body,
+                        text,
+                        json: parsedJson,
+                        fingerprints: {
+                            ja3: this.generateJA3(),
+                            ja3Hash: crypto.createHash('md5').update(this.generateJA3()).digest('hex'),
+                            akamai: `1:${this.profile.http2.headerTableSize};2:${this.profile.http2.enablePush};4:${this.profile.http2.initialWindowSize};6:${this.profile.http2.maxHeaderListSize ?? ''}|00|0|m,a,s,p`
+                        },
+                        timing: {
+                            socket: startTime,
+                            lookup: 0,
+                            connect: 0,
+                            secureConnect: 0,
+                            response: Date.now() - startTime,
+                            end: Date.now() - startTime,
+                            total: Date.now() - startTime
+                        },
+                        redirectCount
+                    };
+                    resolve(responseObj);
+                };
+                out.on('header', (status, hdrs) => {
+                    statusCode = status;
+                    headers = hdrs;
+                    if (this.shouldFollowRedirect(status, options)) {
+                        const newLocation = this.getRedirectLocation(hdrs, targetUri);
+                        if (newLocation) {
+                            redirectCount++;
+                            if (redirectCount > maxRedirects)
+                                return complete(new Error(`Too many redirects (${maxRedirects} max)`));
+                            currentUri = newLocation;
+                            currentHeaders = this.adjustHeadersForRedirect(config.headers, status);
+                            if (status === 303) {
+                                currentMethod = 'GET';
+                                currentBody = null;
+                            }
+                            else if (status === 301 || status === 302) {
+                                if (currentMethod === 'POST') {
+                                    currentMethod = 'GET';
+                                    currentBody = null;
+                                }
+                            }
+                            out.removeAllListeners();
+                            execute(currentUri).then(resolve).catch(reject);
+                            return;
+                        }
                     }
+                    out.on('data', (chunk) => { if (!done)
+                        chunks.push(chunk); });
+                    out.once('end', () => complete());
+                    out.once('error', complete);
                 });
-            };
-            out.on('header', (status, hdrs) => {
-                statusCode = status;
-                headers = hdrs;
-            });
-            out.on('data', (chunk) => {
-                if (!done)
-                    chunks.push(chunk);
+                session.clientManager.request(path, options, startTime, config.headers, post_data, out).catch(complete);
             });
-            out.once('end', () => complete());
-            out.once('error', complete);
-            session.clientManager.request(path, options, startTime, config.headers, post_data, out).catch(complete);
-        });
+        };
+        try {
+            const result = await execute(currentUri);
+            if (cb) {
+                if (result instanceof stream_1.PassThrough) {
+                    result.on('error', err => cb(err));
+                    result.on('end', () => cb(null, result));
+                }
+                else {
+                    cb(null, result);
+                }
+            }
+            return result;
+        }
+        catch (err) {
+            if (cb)
+                cb(err);
+            throw err;
+        }
     }
     generateJA3() {
         const version = '771';
@@ -938,10 +831,8 @@ class AdvancedTLSClient {
             if (count === 0)
                 return reject(new Error('Empty multipart body'));
             let doneCount = count;
-            const done = () => {
-                if (--doneCount === 0)
-                    resolve(Buffer.from(body + '--' + boundary + '--\r\n'));
-            };
+            const done = () => { if (--doneCount === 0)
+                resolve(Buffer.from(body + '--' + boundary + '--\r\n')); };
             for (const key in object) {
                 const value = object[key];
                 if (value === null || typeof value === 'undefined') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "advanced-tls-client",
-  "version": "5.0.0",
+  "version": "5.0.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {