advanced-tls-client 3.0.1 → 3.0.3

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import { EventEmitter } from 'events';
 import { Readable, PassThrough } from 'stream';
 interface TLSFingerprint {
     cipherSuites: number[];
@@ -119,13 +120,36 @@ interface RequestOptions {
     content_type?: string;
     uri_modifier?: Function;
 }
+interface Response extends EventEmitter {
+    statusCode: number;
+    headers: Record<string, string | string[]>;
+    body: Buffer | Readable | any;
+    text?: string;
+    json?: any;
+    timing: {
+        socket: number;
+        lookup: number;
+        connect: number;
+        secureConnect: number;
+        response: number;
+        end: number;
+        total: number;
+    };
+    fingerprints: {
+        ja3: string;
+        ja3Hash: string;
+        akamai: string;
+    };
+    bytes?: number;
+    raw?: Buffer;
+    cookies?: Record<string, string>;
+    parser?: string;
+}
 declare class ProfileRegistry {
     private static getGrease;
     static chromeMobile143Android(): ChromeProfile;
     static chrome133PSK(): ChromeProfile;
     static chrome133(): ChromeProfile;
-    static firefox117(): ChromeProfile;
-    static safariIOS18(): ChromeProfile;
     static get(name: string): ChromeProfile;
     static get latest(): ChromeProfile;
     static get latestMobile(): ChromeProfile;
@@ -139,12 +163,12 @@ declare class AdvancedTLSClient {
     private cleanupInterval;
     private defaults;
     constructor(profileName?: string);
-    setup(uri: string, options: RequestOptions): any;
-    request(uri: string, data?: any, options?: RequestOptions, callback?: Function): Promise<FullResponse | PassThrough>;
+    private setup;
+    request(uri: string, data?: any, options?: RequestOptions, callback?: (err: any, res?: Response) => void): Promise<FullResponse | PassThrough>;
     private generateJA3;
     private buildMultipart;
     private generateMultipart;
     private flatten;
     destroy(): void;
 }
-export { AdvancedTLSClient, ProfileRegistry, FullResponse };
+export { AdvancedTLSClient, ProfileRegistry };

package/dist/index.js

@@ -46,9 +46,9 @@ const stream_1 = require("stream");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const url = __importStar(require("url"));
-const gunzip = (0, util_1.promisify)(zlib.gunzip);
-const brotliDecompress = (0, util_1.promisify)(zlib.brotliDecompress);
-const inflate = (0, util_1.promisify)(zlib.inflate);
+const brotliDecompressAsync = (0, util_1.promisify)(zlib.brotliDecompress);
+const gunzipAsync = (0, util_1.promisify)(zlib.gunzip);
+const inflateAsync = (0, util_1.promisify)(zlib.inflate);
 const GREASE_VALUES = [0x0a0a, 0x1a1a, 0x2a2a, 0x3a3a, 0x4a4a, 0x5a5a, 0x6a6a, 0x7a7a, 0x8a8a, 0x9a9a, 0xaaaa, 0xbaba, 0xcaca, 0xdada, 0xeaea, 0xfafa];
 class ProfileRegistry {
     static getGrease() {
@@ -414,202 +414,16 @@ class ProfileRegistry {
             secFetchDest: 'document'
         };
     }
-    static firefox117() {
-        return {
-            name: 'firefox_117',
-            version: '117.0',
-            tls: {
-                cipherSuites: [
-                    4865,
-                    4867,
-                    4866,
-                    49195,
-                    49199,
-                    52393,
-                    52392,
-                    49196,
-                    49200,
-                    159,
-                    158,
-                    49161,
-                    49162,
-                    156,
-                    157,
-                    47,
-                    53
-                ],
-                extensions: [0, 23, 65281, 10, 11, 35, 16, 5, 34, 51, 43, 13, 45, 28, 21],
-                supportedGroups: [
-                    29,
-                    23,
-                    24,
-                    25,
-                    256,
-                    257
-                ],
-                signatureAlgorithms: [
-                    1027,
-                    1283,
-                    1539,
-                    2052,
-                    2053,
-                    2054,
-                    1025,
-                    1281,
-                    1537,
-                    513,
-                    515
-                ],
-                supportedVersions: [
-                    772,
-                    771
-                ],
-                ecPointFormats: [0],
-                alpnProtocols: ['h2', 'http/1.1'],
-                pskKeyExchangeModes: [1],
-                compressionMethods: [0],
-                grease: false
-            },
-            http2: {
-                windowUpdate: 12517377,
-                headerTableSize: 65536,
-                enablePush: 0,
-                initialWindowSize: 131072,
-                maxFrameSize: 16384,
-                settingsOrder: [1, 4, 5],
-                connectionPreface: Buffer.from('PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n'),
-                priorityFrames: [
-                    { streamId: 3, weight: 200, dependency: 0, exclusive: false },
-                    { streamId: 5, weight: 100, dependency: 0, exclusive: false },
-                    { streamId: 7, weight: 0, dependency: 0, exclusive: false },
-                    { streamId: 9, weight: 0, dependency: 7, exclusive: false },
-                    { streamId: 11, weight: 0, dependency: 3, exclusive: false },
-                    { streamId: 13, weight: 240, dependency: 0, exclusive: false }
-                ],
-                pseudoHeaderOrder: [':method', ':path', ':authority', ':scheme'],
-                headerPriority: { streamDep: 13, exclusive: false, weight: 41 },
-                headerOrder: []
-            },
-            userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:117.0) Gecko/20100101 Firefox/117.0',
-            secChUa: '',
-            secChUaPlatform: '',
-            secChUaMobile: '',
-            secFetchSite: 'none',
-            secFetchMode: 'navigate',
-            secFetchDest: 'document'
-        };
-    }
-    static safariIOS18() {
-        const grease1 = this.getGrease();
-        const grease2 = this.getGrease();
-        return {
-            name: 'safari_ios_18_0',
-            version: '18.0',
-            tls: {
-                cipherSuites: [
-                    grease1,
-                    4865,
-                    4866,
-                    4867,
-                    49196,
-                    49195,
-                    52393,
-                    49200,
-                    49199,
-                    52392,
-                    159,
-                    158,
-                    49162,
-                    49161,
-                    157,
-                    156,
-                    53,
-                    47,
-                    49188,
-                    49187,
-                    60
-                ],
-                extensions: [
-                    grease2,
-                    0,
-                    23,
-                    65281,
-                    10,
-                    11,
-                    16,
-                    5,
-                    13,
-                    18,
-                    51,
-                    45,
-                    43,
-                    21
-                ],
-                supportedGroups: [
-                    29,
-                    23,
-                    24,
-                    25
-                ],
-                signatureAlgorithms: [
-                    1027,
-                    2052,
-                    1025,
-                    1283,
-                    513,
-                    2053,
-                    2053,
-                    1281,
-                    2054,
-                    1537,
-                    515
-                ],
-                supportedVersions: [
-                    772,
-                    771,
-                    770,
-                    769
-                ],
-                ecPointFormats: [0],
-                alpnProtocols: ['h2', 'http/1.1'],
-                pskKeyExchangeModes: [1],
-                compressionMethods: [0],
-                grease: true
-            },
-            http2: {
-                windowUpdate: 10420225,
-                headerTableSize: 4096,
-                enablePush: 0,
-                maxConcurrentStreams: 100,
-                initialWindowSize: 2097152,
-                maxFrameSize: 16384,
-                settingsOrder: [2, 3, 4, 8, 9],
-                connectionPreface: Buffer.from('PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n'),
-                priorityFrames: [],
-                pseudoHeaderOrder: [':method', ':scheme', ':authority', ':path'],
-                headerOrder: []
-            },
-            userAgent: 'Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Mobile/15E148 Safari/604.1',
-            secChUa: '',
-            secChUaPlatform: '',
-            secChUaMobile: '?1',
-            secFetchSite: 'none',
-            secFetchMode: 'navigate',
-            secFetchDest: 'document'
-        };
-    }
     static get(name) {
         switch (name.toLowerCase()) {
             case 'chrome_mobile_143_android': return this.chromeMobile143Android();
             case 'chrome_133_psk': return this.chrome133PSK();
             case 'chrome_133': return this.chrome133();
-            case 'firefox_117': return this.firefox117();
-            case 'safari_ios_18_0': return this.safariIOS18();
-            default: return this.chrome133();
+            default: return this.chromeMobile143Android();
         }
     }
     static get latest() {
-        return this.chrome133();
+        return this.chromeMobile143Android();
     }
     static get latestMobile() {
         return this.chromeMobile143Android();
@@ -675,16 +489,15 @@ class CookieJar {
         }
     }
 }
-var Protocol;
-(function (Protocol) {
-    Protocol["HTTP1"] = "http1";
-    Protocol["HTTP2"] = "http2";
-})(Protocol || (Protocol = {}));
+const Protocol = {
+    HTTP1: 'http1',
+    HTTP2: 'http2'
+};
 class UnifiedClientManager extends events_1.EventEmitter {
     constructor(tlsSocket, profile, hostname, cookieJar) {
         super();
         this.http2Client = null;
-        this.negotiatedProtocol = Protocol.HTTP1;
+        this.negotiatedProtocol = 'http1';
         this.tlsSocket = tlsSocket;
         this.profile = profile;
         this.hostname = hostname;
@@ -693,17 +506,17 @@ class UnifiedClientManager extends events_1.EventEmitter {
     async initialize() {
         const alpn = this.tlsSocket.alpnProtocol;
         if (alpn === 'h2') {
-            this.negotiatedProtocol = Protocol.HTTP2;
+            this.negotiatedProtocol = 'http2';
             await this.createHttp2Session();
         }
         else {
-            this.negotiatedProtocol = Protocol.HTTP1;
+            this.negotiatedProtocol = 'http1';
         }
     }
     async createHttp2Session() {
         return new Promise((resolve, reject) => {
             const settings = {};
-            this.profile.http2.settingsOrder.forEach(id => {
+            this.profile.http2.settingsOrder.forEach((id) => {
                 switch (id) {
                     case 1:
                         settings.headerTableSize = this.profile.http2.headerTableSize;
@@ -711,17 +524,9 @@ class UnifiedClientManager extends events_1.EventEmitter {
                     case 2:
                         settings.enablePush = this.profile.http2.enablePush === 1;
                         break;
-                    case 3:
-                        if (this.profile.http2.maxConcurrentStreams)
-                            settings.maxConcurrentStreams = this.profile.http2.maxConcurrentStreams;
-                        break;
                     case 4:
                         settings.initialWindowSize = this.profile.http2.initialWindowSize;
                         break;
-                    case 5:
-                        if (this.profile.http2.maxFrameSize)
-                            settings.maxFrameSize = this.profile.http2.maxFrameSize;
-                        break;
                     case 6:
                         if (this.profile.http2.maxHeaderListSize)
                             settings.maxHeaderListSize = this.profile.http2.maxHeaderListSize;
@@ -732,7 +537,7 @@ class UnifiedClientManager extends events_1.EventEmitter {
                 createConnection: () => this.tlsSocket,
                 settings
             });
-            this.http2Client.once('connect', () => resolve());
+            this.http2Client.once('connect', resolve);
             this.http2Client.once('error', reject);
             this.http2Client.once('timeout', () => reject(new Error('HTTP/2 session timeout')));
         });
@@ -749,7 +554,7 @@ class UnifiedClientManager extends events_1.EventEmitter {
         delete cleanHeaders['Upgrade'];
         delete cleanHeaders['transfer-encoding'];
         delete cleanHeaders['Transfer-Encoding'];
-        if (this.negotiatedProtocol === Protocol.HTTP2 && this.http2Client && !this.http2Client.destroyed) {
+        if (this.negotiatedProtocol === 'http2' && this.http2Client && !this.http2Client.destroyed) {
             await this.requestHttp2(path, options, timingStart, cleanHeaders, post_data, out, callback);
         }
         else {
@@ -757,13 +562,12 @@ class UnifiedClientManager extends events_1.EventEmitter {
         }
     }
     async requestHttp2(path, options, timingStart, headers, post_data, out, callback) {
-        if (!this.http2Client || this.http2Client.destroyed)
-            throw new Error('HTTP/2 session not available');
+        const normalizedPath = path.startsWith('/') ? path : `/${path}`;
         const reqHeaders = {
             ':method': options.method?.toUpperCase() || 'GET',
             ':authority': this.hostname,
             ':scheme': 'https',
-            ':path': path,
+            ':path': normalizedPath,
             ...headers
         };
         const stream = this.http2Client.request(reqHeaders);
@@ -774,84 +578,112 @@ class UnifiedClientManager extends events_1.EventEmitter {
             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`
         };
-        stream.once('response', (hdrs) => {
-            response.statusCode = hdrs[':status'];
-            response.headers = hdrs;
-            if (hdrs['set-cookie'])
-                this.cookieJar.parseSetCookie(this.hostname, hdrs['set-cookie']);
-            response.timing.response = Date.now() - timingStart;
-            out.emit('header', response.statusCode, hdrs);
-            out.emit('headers', hdrs);
-        });
         const chunks = [];
         const rawChunks = [];
-        stream.on('data', (chunk) => {
-            // Convert string to Buffer if needed
-            const bufferChunk = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-            rawChunks.push(bufferChunk);
-            chunks.push(bufferChunk);
-            out.write(bufferChunk);
-        });
-        stream.once('end', async () => {
+        let finished = false;
+        let hasHeaders = false;
+        const finish = async (error) => {
+            if (finished)
+                return;
+            finished = true;
+            stream.removeAllListeners();
+            if (error) {
+                out.emit('error', error);
+                if (callback)
+                    setImmediate(() => callback(error));
+                return;
+            }
             let body = Buffer.concat(chunks);
             response.bytes = body.length;
             response.raw = Buffer.concat(rawChunks);
             if (options.decompress !== false && response.headers) {
-                const encodingHeader = response.headers['content-encoding'];
-                const encoding = Array.isArray(encodingHeader) ? encodingHeader[0]?.toLowerCase() : typeof encodingHeader === 'string' ? encodingHeader.toLowerCase() : undefined;
+                const encoding = response.headers['content-encoding']?.toLowerCase();
                 if (encoding) {
                     try {
                         if (encoding.includes('gzip'))
-                            body = await gunzip(body);
+                            body = await gunzipAsync(body);
                         else if (encoding.includes('br'))
-                            body = await brotliDecompress(body);
+                            body = await brotliDecompressAsync(body);
                         else if (encoding.includes('deflate'))
-                            body = await inflate(body);
-                    }
-                    catch (e) {
-                        console.error('Decompression error:', e);
+                            body = await inflateAsync(body);
                     }
+                    catch { }
                 }
             }
             response.body = body;
             try {
                 response.text = body.toString('utf-8');
-                const contentTypeHeader = response.headers['content-type'];
-                const ct = Array.isArray(contentTypeHeader) ? contentTypeHeader[0] : typeof contentTypeHeader === 'string' ? contentTypeHeader : undefined;
-                if (ct && ct.includes('application/json')) {
+                if (response.headers['content-type']?.includes('application/json')) {
                     response.json = JSON.parse(response.text);
                 }
             }
             catch { }
             response.timing.end = Date.now() - timingStart;
             response.timing.total = response.timing.end;
-            out.end();
+            if (!out.writableEnded && !out.destroyed)
+                out.end();
+        };
+        stream.once('response', (hdrs) => {
+            hasHeaders = true;
+            response.statusCode = hdrs[':status'];
+            response.headers = hdrs;
+            if (hdrs['set-cookie'])
+                this.cookieJar.parseSetCookie(this.hostname, hdrs['set-cookie']);
+            response.timing.response = Date.now() - timingStart;
+            out.emit('header', response.statusCode, hdrs);
+            out.emit('headers', hdrs);
             if (callback)
-                callback(null, response, response.body);
+                setImmediate(() => callback(null, response));
         });
-        stream.once('error', (err) => {
-            out.emit('err', err);
-            if (callback)
-                callback(err);
+        stream.on('data', (chunk) => {
+            if (finished || out.destroyed || out.writableEnded)
+                return;
+            const bufferChunk = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            rawChunks.push(bufferChunk);
+            chunks.push(bufferChunk);
+            if (!out.write(bufferChunk))
+                stream.pause();
         });
+        out.on('drain', () => stream.resume());
+        stream.once('end', finish);
+        stream.once('error', finish);
         if (post_data) {
-            if (Buffer.isBuffer(post_data) || typeof post_data === 'string')
-                stream.end(post_data);
-            else if (post_data instanceof stream_1.Readable)
-                post_data.pipe(stream);
+            if (Buffer.isBuffer(post_data) || typeof post_data === 'string') {
+                if (!stream.closed && !stream.destroyed && stream.writable) {
+                    try {
+                        stream.write(post_data);
+                    }
+                    catch { }
+                }
+                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();
+                });
+            }
         }
         else {
-            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
-            },
+            headers: { host: this.hostname, ...headers },
             createConnection: () => this.tlsSocket
         };
         const req = https.request(reqOptions);
@@ -862,7 +694,55 @@ class UnifiedClientManager extends events_1.EventEmitter {
             ja3Hash: crypto.createHash('md5').update(this.generateJA3()).digest('hex'),
             akamai: ''
         };
+        const chunks = [];
+        const rawChunks = [];
+        let finished = false;
+        let hasHeaders = false;
+        const finish = async (error, res) => {
+            if (finished)
+                return;
+            finished = true;
+            req.removeAllListeners();
+            if (res)
+                res.removeAllListeners();
+            if (error) {
+                out.emit('error', error);
+                if (callback)
+                    setImmediate(() => callback(error));
+                return;
+            }
+            let body = Buffer.concat(chunks);
+            response.bytes = body.length;
+            response.raw = Buffer.concat(rawChunks);
+            if (options.decompress !== false && res?.headers) {
+                const encoding = (res.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 { }
+                }
+            }
+            response.body = body;
+            try {
+                response.text = body.toString('utf-8');
+                if (res.headers['content-type']?.includes('application/json')) {
+                    response.json = JSON.parse(response.text);
+                }
+            }
+            catch { }
+            response.timing.end = Date.now() - timingStart;
+            response.timing.total = response.timing.end;
+            if (!out.writableEnded && !out.destroyed)
+                out.end();
+        };
         req.once('response', (res) => {
+            hasHeaders = true;
             response.statusCode = res.statusCode;
             response.headers = res.headers;
             if (res.headers['set-cookie'])
@@ -870,68 +750,31 @@ class UnifiedClientManager extends events_1.EventEmitter {
             response.timing.response = Date.now() - timingStart;
             out.emit('header', response.statusCode, res.headers);
             out.emit('headers', res.headers);
-            const chunks = [];
-            const rawChunks = [];
+            if (callback)
+                setImmediate(() => callback(null, response));
             res.on('data', (chunk) => {
-                // Convert string to Buffer if needed
+                if (finished || out.destroyed || out.writableEnded)
+                    return;
                 const bufferChunk = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
                 rawChunks.push(bufferChunk);
                 chunks.push(bufferChunk);
                 out.write(bufferChunk);
             });
-            res.once('end', async () => {
-                let body = Buffer.concat(chunks);
-                response.bytes = body.length;
-                response.raw = Buffer.concat(rawChunks);
-                if (options.decompress !== false) {
-                    const encodingHeader = res.headers['content-encoding'];
-                    const encoding = Array.isArray(encodingHeader) ? encodingHeader[0]?.toLowerCase() : typeof encodingHeader === 'string' ? encodingHeader.toLowerCase() : undefined;
-                    if (encoding) {
-                        try {
-                            if (encoding.includes('gzip'))
-                                body = await gunzip(body);
-                            else if (encoding.includes('br'))
-                                body = await brotliDecompress(body);
-                            else if (encoding.includes('deflate'))
-                                body = await inflate(body);
-                        }
-                        catch (e) {
-                            console.error('Decompression error:', e);
-                        }
-                    }
-                }
-                response.body = body;
-                try {
-                    response.text = body.toString('utf-8');
-                    const contentTypeHeader = res.headers['content-type'];
-                    const ct = Array.isArray(contentTypeHeader) ? contentTypeHeader[0] : typeof contentTypeHeader === 'string' ? contentTypeHeader : undefined;
-                    if (ct && ct.includes('application/json')) {
-                        response.json = JSON.parse(response.text);
-                    }
-                }
-                catch { }
-                response.timing.end = Date.now() - timingStart;
-                response.timing.total = response.timing.end;
-                out.end();
-                if (callback)
-                    callback(null, response, response.body);
-            });
-            res.once('error', (err) => {
-                out.emit('err', err);
-                if (callback)
-                    callback(err);
-            });
-        });
-        req.once('error', (err) => {
-            out.emit('err', err);
-            if (callback)
-                callback(err);
+            res.once('end', () => finish(null, res));
+            res.once('error', finish);
         });
+        req.once('error', finish);
         if (post_data) {
-            if (Buffer.isBuffer(post_data) || typeof post_data === 'string')
-                req.end(post_data);
-            else if (post_data instanceof stream_1.Readable)
+            if (Buffer.isBuffer(post_data) || typeof post_data === 'string') {
+                req.write(post_data);
+                req.end();
+            }
+            else if (post_data instanceof stream_1.Readable) {
                 post_data.pipe(req);
+            }
+            else {
+                req.end();
+            }
         }
         else {
             req.end();
@@ -939,9 +782,9 @@ class UnifiedClientManager extends events_1.EventEmitter {
     }
     generateJA3() {
         const version = '771';
-        const ciphers = this.profile.tls.cipherSuites.filter(c => c < 0xff00).join('-');
-        const extensions = this.profile.tls.extensions.filter(e => typeof e === 'number' && e < 0xff00).join('-');
-        const curves = this.profile.tls.supportedGroups.filter(g => g < 0xff00).join('-');
+        const ciphers = this.profile.tls.cipherSuites.filter((c) => c < 0xff00).join('-');
+        const extensions = this.profile.tls.extensions.filter((e) => typeof e === 'number' && e < 0xff00).join('-');
+        const curves = this.profile.tls.supportedGroups.filter((g) => g < 0xff00).join('-');
         const ecPoints = this.profile.tls.ecPointFormats.join('-');
         return `${version},${ciphers},${extensions},${curves},${ecPoints}`;
     }
@@ -950,9 +793,6 @@ class UnifiedClientManager extends events_1.EventEmitter {
             this.http2Client.destroy();
         this.http2Client = null;
     }
-    getProtocol() {
-        return this.negotiatedProtocol;
-    }
 }
 class TLSSocketManager extends events_1.EventEmitter {
     constructor(profile, proxy) {
@@ -983,6 +823,7 @@ class TLSSocketManager extends events_1.EventEmitter {
             if (this.proxy) {
                 const proxyUrl = new url.URL(this.proxy);
                 this.socket = net.connect(+proxyUrl.port || 80, proxyUrl.hostname, () => {
+                    this.timing.connect = Date.now() - this.startTime;
                     let request = `CONNECT ${hostname}:${port} HTTP/1.1\r\nHost: ${hostname}:${port}\r\n`;
                     if (proxyUrl.username && proxyUrl.password) {
                         const auth = Buffer.from(`${decodeURIComponent(proxyUrl.username)}:${decodeURIComponent(proxyUrl.password)}`).toString('base64');
@@ -992,14 +833,19 @@ class TLSSocketManager extends events_1.EventEmitter {
                     this.socket.write(request);
                 });
                 let response = '';
-                this.socket.on('data', (chunk) => {
+                const onData = (chunk) => {
                     response += chunk.toString();
                     if (response.includes('\r\n\r\n')) {
-                        if (!response.startsWith('HTTP/1.1 200'))
+                        this.socket.removeListener('data', onData);
+                        if (!response.startsWith('HTTP/1.1 200')) {
+                            clearTimeout(timeout);
+                            this.destroy();
                             return reject(new Error('Proxy failed: ' + response.split('\r\n')[0]));
+                        }
                         this.proceedWithTLS(resolve, reject, timeout);
                     }
-                });
+                };
+                this.socket.on('data', onData);
             }
             else {
                 this.socket = new net.Socket();
@@ -1107,7 +953,7 @@ class AdvancedTLSClient {
             follow_if_same_location: false,
             use_proxy_from_env_var: true
         };
-        this.profile = ProfileRegistry.get(profileName || 'chrome_133');
+        this.profile = ProfileRegistry.get(profileName || 'chrome_mobile_143_android');
         this.cleanupInterval = setInterval(() => {
             const now = Date.now();
             for (const [key, session] of this.sessionCache) {
@@ -1121,7 +967,7 @@ class AdvancedTLSClient {
     }
     setup(uri, options) {
         const config = {
-            headers: { ...options.headers },
+            headers: {},
             proxy: options.proxy || this.defaults.proxy,
             decompress: options.decompress !== undefined ? options.decompress : true
         };
@@ -1139,6 +985,10 @@ class AdvancedTLSClient {
             config.headers['upgrade-insecure-requests'] = this.profile.upgradeInsecureRequests;
         if (this.profile.priority)
             config.headers['priority'] = this.profile.priority;
+        // Override with user headers
+        if (options.headers) {
+            Object.assign(config.headers, options.headers);
+        }
         return config;
     }
     async request(uri, data, options = {}, callback) {
@@ -1146,6 +996,9 @@ class AdvancedTLSClient {
             callback = options;
             options = {};
         }
+        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;
@@ -1171,12 +1024,15 @@ class AdvancedTLSClient {
         session.lastUsed = Date.now();
         const config = this.setup(uri, options);
         let post_data = null;
-        let json = options.json || (options.json !== false && config.headers['content-type']?.includes('application/json'));
+        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;
+                config.headers['content-type'] = `multipart/form-data; boundary=${boundary}`;
             }
             else if (data instanceof stream_1.Readable) {
                 post_data = data;
@@ -1202,78 +1058,62 @@ class AdvancedTLSClient {
         const cookies = this.cookieJar.getCookies(hostname, parsed.pathname, parsed.protocol === 'https:');
         if (cookies)
             config.headers['cookie'] = cookies;
-        // MODE LEGACY: Jika ada callback, kembalikan stream
+        if (options.stream === true) {
+            session.clientManager.request(path, options, startTime, config.headers, post_data, out);
+            return out;
+        }
         if (callback) {
-            await session.clientManager.request(path, options, startTime, config.headers, post_data, out, callback);
+            session.clientManager.request(path, options, startTime, config.headers, post_data, out, callback).catch(err => {
+                if (callback)
+                    callback(err);
+            });
             return out;
         }
-        // MODE BARU: Kembalikan object response lengkap
         return new Promise((resolve, reject) => {
             let statusCode = 0;
             let headers = {};
             const chunks = [];
-            out.on('header', (status, hdrs) => {
-                statusCode = status;
-                headers = hdrs;
-            });
-            out.on('headers', (hdrs) => {
-                headers = hdrs;
-            });
-            out.on('data', (chunk) => {
-                chunks.push(chunk);
-            });
-            out.once('end', async () => {
+            let done = false;
+            const complete = async (err) => {
+                if (done)
+                    return;
+                done = true;
+                if (err)
+                    return reject(err);
                 let body = Buffer.concat(chunks);
-                // Auto-decompress jika diminta
                 if (options.decompress !== false && headers) {
-                    const encodingHeader = headers['content-encoding'];
-                    const encoding = Array.isArray(encodingHeader)
-                        ? encodingHeader[0]?.toLowerCase()
-                        : typeof encodingHeader === 'string'
-                            ? encodingHeader.toLowerCase()
-                            : undefined;
+                    const encoding = headers['content-encoding']?.toLowerCase();
                     if (encoding) {
                         try {
                             if (encoding.includes('gzip'))
-                                body = await gunzip(body);
+                                body = await gunzipAsync(body);
                             else if (encoding.includes('br'))
-                                body = await brotliDecompress(body);
+                                body = await brotliDecompressAsync(body);
                             else if (encoding.includes('deflate'))
-                                body = await inflate(body);
-                        }
-                        catch (e) {
-                            console.error('Decompression failed:', e);
+                                body = await inflateAsync(body);
                         }
+                        catch { }
                     }
                 }
                 const text = body.toString('utf-8');
-                let parsedJson = undefined;
-                const contentType = headers['content-type'];
-                const ct = Array.isArray(contentType)
-                    ? contentType[0]
-                    : typeof contentType === 'string'
-                        ? contentType
-                        : undefined;
-                if (ct && ct.includes('application/json')) {
+                let parsedJson;
+                const ct = headers['content-type']?.toLowerCase();
+                if (ct?.includes('application/json')) {
                     try {
                         parsedJson = JSON.parse(text);
                     }
                     catch { }
                 }
-                // Generate fingerprints
-                const ja3 = this.generateJA3();
-                const ja3Hash = crypto.createHash('md5').update(ja3).digest('hex');
-                const 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 fullResponse = {
+                resolve({
                     statusCode,
                     headers,
                     body,
                     text,
                     json: parsedJson,
                     fingerprints: {
-                        ja3,
-                        ja3Hash,
-                        akamai
+                        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,
@@ -1284,19 +1124,26 @@ class AdvancedTLSClient {
                         end: Date.now() - startTime,
                         total: Date.now() - startTime
                     }
-                };
-                resolve(fullResponse);
+                });
+            };
+            out.on('header', (status, hdrs) => {
+                statusCode = status;
+                headers = hdrs;
             });
-            out.once('error', (err) => reject(err));
-            // Jalankan request
-            session.clientManager.request(path, options, startTime, config.headers, post_data, out).catch(reject);
+            out.on('data', (chunk) => {
+                if (!done)
+                    chunks.push(chunk);
+            });
+            out.once('end', () => complete());
+            out.once('error', complete);
+            session.clientManager.request(path, options, startTime, config.headers, post_data, out).catch(complete);
         });
     }
     generateJA3() {
         const version = '771';
-        const ciphers = this.profile.tls.cipherSuites.filter(c => c < 0xff00).join('-');
-        const extensions = this.profile.tls.extensions.filter(e => typeof e === 'number' && e < 0xff00).join('-');
-        const curves = this.profile.tls.supportedGroups.filter(g => g < 0xff00).join('-');
+        const ciphers = this.profile.tls.cipherSuites.filter((c) => c < 0xff00).join('-');
+        const extensions = this.profile.tls.extensions.filter((e) => typeof e === 'number' && e < 0xff00).join('-');
+        const curves = this.profile.tls.supportedGroups.filter((g) => g < 0xff00).join('-');
         const ecPoints = this.profile.tls.ecPointFormats.join('-');
         return `${version},${ciphers},${extensions},${curves},${ecPoints}`;
     }
@@ -1318,30 +1165,18 @@ class AdvancedTLSClient {
                     done();
                     continue;
                 }
-                if (Buffer.isBuffer(value)) {
-                    const part = { buffer: value, content_type: 'application/octet-stream' };
-                    this.generateMultipart(key, part, boundary).then(section => {
-                        body += section;
-                        done();
-                    });
-                }
-                else {
-                    const part = (value.buffer || value.file || value.content_type) ? value : { value: value };
-                    this.generateMultipart(key, part, boundary).then(section => {
-                        body += section;
-                        done();
-                    });
-                }
+                const part = Buffer.isBuffer(value) ? { buffer: value, content_type: 'application/octet-stream' } : (value.buffer || value.file || value.content_type) ? value : { value };
+                this.generateMultipart(key, part, boundary).then(section => { body += section; done(); });
             }
         });
     }
     async generateMultipart(name, part, boundary) {
-        let return_part = '--' + boundary + '\r\n';
-        return_part += 'Content-Disposition: form-data; name="' + name + '"';
+        let return_part = `--${boundary}\r\n`;
+        return_part += `Content-Disposition: form-data; name="${name}"`;
         const append = (data, filename) => {
             if (data) {
-                return_part += '; filename="' + encodeURIComponent(filename) + '"\r\n';
-                return_part += 'Content-Type: ' + (part.content_type || 'application/octet-stream') + '\r\n\r\n';
+                return_part += `; filename="${encodeURIComponent(filename)}"\r\n`;
+                return_part += `Content-Type: ${part.content_type || 'application/octet-stream'}\r\n\r\n`;
                 return_part += data.toString('binary');
             }
             return return_part + '\r\n';
@@ -1354,19 +1189,20 @@ class AdvancedTLSClient {
             return append(data, filename);
         }
         else {
-            return_part += '\r\n\r\n';
-            return_part += String(part.value || '');
-            return return_part + '\r\n';
+            return_part += '\r\n\r\n' + String(part.value || '') + '\r\n';
+            return return_part;
         }
     }
     flatten(object, into = {}, prefix) {
         for (const key in object) {
-            const prefix_key = prefix ? prefix + '[' + key + ']' : key;
+            const prefix_key = prefix ? `${prefix}[${key}]` : key;
             const prop = object[key];
-            if (prop && typeof prop === 'object' && !(prop.buffer || prop.file || prop.content_type))
+            if (prop && typeof prop === 'object' && !(prop.buffer || prop.file || prop.content_type)) {
                 this.flatten(prop, into, prefix_key);
-            else
+            }
+            else {
                 into[prefix_key] = prop;
+            }
         }
         return into;
     }

package/package.json

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