advanced-tls-client 1.0.2 → 3.0.2

package/dist/index.js

@@ -42,9 +42,12 @@ const events_1 = require("events");
 const zlib = __importStar(require("zlib"));
 const util_1 = require("util");
 const stream_1 = require("stream");
-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 fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const url = __importStar(require("url"));
+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() {
@@ -134,8 +137,8 @@ class ProfileRegistry {
                 headerTableSize: 65536,
                 enablePush: 0,
                 initialWindowSize: 6291456,
-                maxHeaderListSize: 262144,
                 maxFrameSize: 16384,
+                maxHeaderListSize: 262144,
                 settingsOrder: [1, 2, 4, 6],
                 connectionPreface: Buffer.from('PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n'),
                 priorityFrames: [
@@ -640,147 +643,65 @@ class CookieJar {
         return validCookies.join('; ');
     }
     parseSetCookie(domain, setCookieHeaders) {
-        for (const header of setCookieHeaders) {
+        if (!setCookieHeaders)
+            return;
+        const headers = Array.isArray(setCookieHeaders) ? setCookieHeaders : typeof setCookieHeaders === 'string' ? [setCookieHeaders] : [];
+        for (const header of headers) {
             const parts = header.split(';').map(p => p.trim());
             const [nameValue] = parts;
-            const [name, value] = nameValue.split('=');
+            if (!nameValue)
+                continue;
+            const [name, value = ''] = nameValue.split('=');
             const options = { path: '/' };
             for (let i = 1; i < parts.length; i++) {
-                const [key, val] = parts[i].split('=');
+                const part = parts[i];
+                if (!part)
+                    continue;
+                const [key, val] = part.split('=');
                 const lowerKey = key.toLowerCase();
-                if (lowerKey === 'expires')
+                if (lowerKey === 'expires' && val)
                     options.expires = new Date(val);
-                else if (lowerKey === 'path')
+                else if (lowerKey === 'path' && val)
                     options.path = val;
                 else if (lowerKey === 'secure')
                     options.secure = true;
                 else if (lowerKey === 'httponly')
                     options.httpOnly = true;
-                else if (lowerKey === 'samesite')
+                else if (lowerKey === 'samesite' && val)
                     options.sameSite = val;
             }
             this.setCookie(domain, name, value, options);
         }
     }
 }
-class TLSSocketManager extends events_1.EventEmitter {
-    constructor(profile) {
-        super();
-        this.socket = null;
-        this.tlsSocket = null;
-        this.startTime = 0;
-        this.hostname = '';
-        this.port = 443;
-        this.profile = profile;
-        this.timing = { socket: 0, lookup: 0, connect: 0, secureConnect: 0, response: 0, end: 0, total: 0 };
-    }
-    async connect(hostname, port = 443) {
-        this.hostname = hostname;
-        this.port = port;
-        this.startTime = Date.now();
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                this.destroy();
-                reject(new Error('Connection timeout'));
-            }, 30000);
-            this.socket = new net.Socket();
-            this.socket.setNoDelay(true);
-            this.socket.setKeepAlive(true, 60000);
-            this.socket.on('lookup', () => {
-                this.timing.lookup = Date.now() - this.startTime;
-            });
-            this.socket.connect(port, hostname, () => {
-                this.timing.connect = Date.now() - this.startTime;
-                const validCiphers = this.profile.tls.cipherSuites
-                    .filter(c => c < 0xff00)
-                    .map(c => {
-                    const hex = c.toString(16).toUpperCase();
-                    return hex.length === 3 ? `0${hex}` : hex;
-                });
-                const cipherList = [
-                    'TLS_AES_128_GCM_SHA256',
-                    'TLS_AES_256_GCM_SHA384',
-                    'TLS_CHACHA20_POLY1305_SHA256',
-                    'ECDHE-ECDSA-AES128-GCM-SHA256',
-                    'ECDHE-RSA-AES128-GCM-SHA256',
-                    'ECDHE-ECDSA-AES256-GCM-SHA384',
-                    'ECDHE-RSA-AES256-GCM-SHA384',
-                    'ECDHE-ECDSA-CHACHA20-POLY1305',
-                    'ECDHE-RSA-CHACHA20-POLY1305',
-                    'ECDHE-RSA-AES128-SHA',
-                    'ECDHE-RSA-AES256-SHA',
-                    'AES128-GCM-SHA256',
-                    'AES256-GCM-SHA384',
-                    'AES128-SHA',
-                    'AES256-SHA'
-                ].join(':');
-                const tlsOptions = {
-                    socket: this.socket,
-                    servername: hostname,
-                    ALPNProtocols: this.profile.tls.alpnProtocols,
-                    ciphers: cipherList,
-                    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);
-                    this.timing.secureConnect = Date.now() - this.startTime;
-                    this.timing.socket = this.startTime;
-                    resolve(this.tlsSocket);
-                });
-                this.tlsSocket.on('error', (err) => {
-                    clearTimeout(timeout);
-                    this.destroy();
-                    reject(err);
-                });
-            });
-            this.socket.on('error', (err) => {
-                clearTimeout(timeout);
-                this.destroy();
-                reject(err);
-            });
-            this.socket.on('timeout', () => {
-                clearTimeout(timeout);
-                this.destroy();
-                reject(new Error('Socket timeout'));
-            });
-        });
-    }
-    getTiming() {
-        return { ...this.timing, total: Date.now() - this.startTime };
-    }
-    destroy() {
-        if (this.tlsSocket && !this.tlsSocket.destroyed) {
-            this.tlsSocket.destroy();
-        }
-        if (this.socket && !this.socket.destroyed) {
-            this.socket.destroy();
-        }
-        this.tlsSocket = null;
-        this.socket = null;
-    }
-    getSocket() {
-        return this.tlsSocket;
-    }
-}
-class HTTP2ClientManager extends events_1.EventEmitter {
+const Protocol = {
+    HTTP1: 'http1',
+    HTTP2: 'http2'
+};
+class UnifiedClientManager extends events_1.EventEmitter {
     constructor(tlsSocket, profile, hostname, cookieJar) {
         super();
-        this.client = null;
+        this.http2Client = null;
+        this.negotiatedProtocol = 'http1';
         this.tlsSocket = tlsSocket;
         this.profile = profile;
         this.hostname = hostname;
         this.cookieJar = cookieJar;
     }
-    async createSession() {
+    async initialize() {
+        const alpn = this.tlsSocket.alpnProtocol;
+        if (alpn === 'h2') {
+            this.negotiatedProtocol = 'http2';
+            await this.createHttp2Session();
+        }
+        else {
+            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;
@@ -788,171 +709,396 @@ class HTTP2ClientManager 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;
                         break;
                 }
             });
-            this.client = http2.connect(`https://${this.hostname}`, {
+            this.http2Client = http2.connect(`https://${this.hostname}`, {
                 createConnection: () => this.tlsSocket,
                 settings
             });
-            this.client.once('connect', () => resolve(this.client));
-            this.client.once('error', reject);
-            this.client.once('timeout', () => reject(new Error('HTTP/2 session timeout')));
+            this.http2Client.once('connect', resolve);
+            this.http2Client.once('error', reject);
+            this.http2Client.once('timeout', () => reject(new Error('HTTP/2 session timeout')));
         });
     }
-    async request(path, options = {}, timingStart) {
-        if (!this.client || this.client.destroyed) {
-            throw new Error('HTTP/2 session not established or destroyed');
+    async request(path, options, timingStart, headers, post_data, out, callback) {
+        const cleanHeaders = { ...headers };
+        delete cleanHeaders['connection'];
+        delete cleanHeaders['Connection'];
+        delete cleanHeaders['keep-alive'];
+        delete cleanHeaders['Keep-Alive'];
+        delete cleanHeaders['proxy-connection'];
+        delete cleanHeaders['Proxy-Connection'];
+        delete cleanHeaders['upgrade'];
+        delete cleanHeaders['Upgrade'];
+        delete cleanHeaders['transfer-encoding'];
+        delete cleanHeaders['Transfer-Encoding'];
+        if (this.negotiatedProtocol === 'http2' && this.http2Client && !this.http2Client.destroyed) {
+            await this.requestHttp2(path, options, timingStart, cleanHeaders, post_data, out, callback);
         }
-        const headers = {
+        else {
+            await this.requestHttp1(path, options, timingStart, cleanHeaders, post_data, out, callback);
+        }
+    }
+    async requestHttp2(path, options, timingStart, headers, post_data, out, callback) {
+        const reqHeaders = {
             ':method': options.method?.toUpperCase() || 'GET',
             ':authority': this.hostname,
             ':scheme': 'https',
-            ':path': path
+            ':path': path,
+            ...headers
         };
-        const defaultHeaders = {
-            'user-agent': this.profile.userAgent,
-            'sec-ch-ua': this.profile.secChUa,
-            'sec-ch-ua-mobile': this.profile.secChUaMobile,
-            'sec-ch-ua-platform': this.profile.secChUaPlatform,
-            'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8',
-            'accept-language': this.profile.acceptLanguage || 'en-US,en;q=0.9',
-            'accept-encoding': 'gzip, deflate, br, zstd',
-            'sec-fetch-site': this.profile.secFetchSite,
-            'sec-fetch-mode': this.profile.secFetchMode,
-            'sec-fetch-dest': this.profile.secFetchDest,
+        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`
         };
-        if (this.profile.upgradeInsecureRequests)
-            defaultHeaders['upgrade-insecure-requests'] = '1';
-        if (this.profile.priority)
-            defaultHeaders['priority'] = this.profile.priority;
-        if (this.profile.http2.headerOrder.length > 0) {
-            this.profile.http2.headerOrder.forEach(name => {
-                if (defaultHeaders[name])
-                    headers[name] = defaultHeaders[name];
-            });
-        }
-        Object.assign(headers, defaultHeaders);
-        const cookies = this.cookieJar.getCookies(this.hostname, path);
-        if (cookies)
-            headers['cookie'] = cookies;
-        if (options.headers)
-            Object.assign(headers, options.headers);
-        if (options.body && (options.method || 'GET').toUpperCase() !== 'GET') {
-            if (!headers['content-type'])
-                headers['content-type'] = 'application/x-www-form-urlencoded';
-            if (typeof options.body === 'string') {
-                headers['content-length'] = Buffer.byteLength(options.body).toString();
+        const chunks = [];
+        const rawChunks = [];
+        let finished = 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 encoding = response.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 (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;
+            if (!out.writableEnded && !out.destroyed)
+                out.end();
+            if (callback)
+                setImmediate(() => callback(null, response, response.body));
+        };
+        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);
+        });
+        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') {
+                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 if (Buffer.isBuffer(options.body)) {
-                headers['content-length'] = options.body.length.toString();
+            else {
+                setImmediate(() => {
+                    if (stream.writable)
+                        stream.end();
+                });
             }
         }
-        const stream = this.client.request(headers);
-        const response = new events_1.EventEmitter();
-        response.timing = {
-            socket: timingStart,
-            lookup: 0,
-            connect: 0,
-            secureConnect: 0,
-            response: 0,
-            end: 0,
-            total: 0
+        else {
+            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 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`
+            akamai: ''
         };
         const chunks = [];
-        stream.once('response', (headers, flags) => {
-            response.statusCode = headers[':status'];
-            response.headers = headers;
-            const setCookies = headers['set-cookie'];
-            if (setCookies) {
-                const cookies = Array.isArray(setCookies) ? setCookies : [setCookies];
-                this.cookieJar.parseSetCookie(this.hostname, cookies);
+        const rawChunks = [];
+        let finished = 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;
             }
-            response.timing.response = Date.now() - timingStart;
-        });
-        stream.on('data', (chunk) => chunks.push(chunk));
-        stream.once('end', async () => {
             let body = Buffer.concat(chunks);
-            if (options.decompress !== false) {
-                const encoding = response.headers['content-encoding']?.toLowerCase();
-                try {
-                    if (encoding === 'gzip')
-                        body = await gunzip(body);
-                    else if (encoding === 'br')
-                        body = await brotliDecompress(body);
-                    else if (encoding === 'deflate')
-                        body = await inflate(body);
+            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 { }
                 }
-                catch (e) { }
             }
             response.body = body;
             try {
                 response.text = body.toString('utf-8');
-                if ((response.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;
             response.timing.total = response.timing.end;
-            response.emit('complete', response);
+            if (!out.writableEnded && !out.destroyed)
+                out.end();
+            if (callback)
+                setImmediate(() => callback(null, response, response.body));
+        };
+        req.once('response', (res) => {
+            response.statusCode = res.statusCode;
+            response.headers = res.headers;
+            if (res.headers['set-cookie'])
+                this.cookieJar.parseSetCookie(this.hostname, res.headers['set-cookie']);
+            response.timing.response = Date.now() - timingStart;
+            out.emit('header', response.statusCode, res.headers);
+            out.emit('headers', res.headers);
+            res.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);
+                out.write(bufferChunk);
+            });
+            res.once('end', () => finish(null, res));
+            res.once('error', finish);
         });
-        stream.once('error', (err) => response.emit('error', err));
-        stream.once('close', () => response.emit('close'));
-        if (options.body) {
-            if (Buffer.isBuffer(options.body) || typeof options.body === 'string') {
-                stream.end(options.body);
+        req.once('error', finish);
+        if (post_data) {
+            if (Buffer.isBuffer(post_data) || typeof post_data === 'string') {
+                req.write(post_data);
+                req.end();
             }
-            else if (options.body instanceof stream_1.Readable) {
-                options.body.pipe(stream);
+            else if (post_data instanceof stream_1.Readable) {
+                post_data.pipe(req);
+            }
+            else {
+                req.end();
             }
         }
         else {
-            stream.end();
+            req.end();
         }
-        return new Promise((resolve, reject) => {
-            response.once('complete', () => resolve(response));
-            response.once('error', reject);
-        });
     }
     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}`;
     }
     destroy() {
-        if (this.client && !this.client.destroyed) {
-            this.client.destroy();
-        }
-        this.client = null;
+        if (this.http2Client && !this.http2Client.destroyed)
+            this.http2Client.destroy();
+        this.http2Client = null;
+    }
+}
+class TLSSocketManager extends events_1.EventEmitter {
+    constructor(profile, proxy) {
+        super();
+        this.socket = null;
+        this.tlsSocket = null;
+        this.startTime = 0;
+        this.hostname = '';
+        this.port = 443;
+        this.profile = profile;
+        this.proxy = proxy;
+        this.timing = { socket: 0, lookup: 0, connect: 0, secureConnect: 0, response: 0, end: 0, total: 0 };
+    }
+    async connect(hostname, port = 443) {
+        this.hostname = hostname;
+        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);
+            };
+            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');
+                        request += `Proxy-Authorization: Basic ${auth}\r\n`;
+                    }
+                    request += '\r\n';
+                    this.socket.write(request);
+                });
+                let response = '';
+                const onData = (chunk) => {
+                    response += chunk.toString();
+                    if (response.includes('\r\n\r\n')) {
+                        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();
+                this.socket.setNoDelay(true);
+                this.socket.setKeepAlive(true, 60000);
+                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);
+                });
+            }
+            this.socket.on('error', handleError);
+            this.socket.on('timeout', () => handleError(new Error('Socket timeout')));
+        });
+    }
+    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
+        };
+        this.tlsSocket = tls.connect(tlsOptions);
+        this.tlsSocket.once('secureConnect', () => {
+            clearTimeout(timeout);
+            this.timing.secureConnect = Date.now() - this.startTime;
+            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;
     }
 }
 class AdvancedTLSClient {
@@ -961,74 +1107,280 @@ class AdvancedTLSClient {
         this.cookieJar = new CookieJar();
         this.maxCachedSessions = 10;
         this.sessionTimeout = 300000;
+        this.defaults = {
+            boundary: '--------------------SIPUTZXCOMPANY',
+            encoding: 'utf8',
+            parse_response: 'all',
+            proxy: null,
+            agent: null,
+            headers: {},
+            accept: '*/*',
+            user_agent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
+            open_timeout: 10000,
+            response_timeout: 0,
+            read_timeout: 0,
+            follow_max: 0,
+            stream_length: -1,
+            signal: null,
+            compressed: false,
+            decode_response: true,
+            parse_cookies: true,
+            follow_set_cookies: false,
+            follow_set_referer: false,
+            follow_keep_method: false,
+            follow_if_same_host: false,
+            follow_if_same_protocol: false,
+            follow_if_same_location: false,
+            use_proxy_from_env_var: true
+        };
         this.profile = ProfileRegistry.get(profileName || 'chrome_133');
         this.cleanupInterval = setInterval(() => {
             const now = Date.now();
             for (const [key, session] of this.sessionCache) {
                 if (now - session.lastUsed > this.sessionTimeout) {
-                    session.http2Manager.destroy();
+                    session.clientManager.destroy();
                     session.tlsManager.destroy();
                     this.sessionCache.delete(key);
                 }
             }
         }, 60000);
     }
-    async request(url, options = {}) {
-        const parsed = new URL(url);
+    setup(uri, options) {
+        const config = {
+            headers: { ...options.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';
+        config.headers['accept'] = 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8';
+        config.headers['sec-ch-ua'] = this.profile.secChUa;
+        config.headers['sec-ch-ua-mobile'] = this.profile.secChUaMobile;
+        config.headers['sec-ch-ua-platform'] = this.profile.secChUaPlatform;
+        config.headers['sec-fetch-site'] = this.profile.secFetchSite;
+        config.headers['sec-fetch-mode'] = this.profile.secFetchMode;
+        config.headers['sec-fetch-dest'] = this.profile.secFetchDest;
+        if (this.profile.upgradeInsecureRequests)
+            config.headers['upgrade-insecure-requests'] = this.profile.upgradeInsecureRequests;
+        if (this.profile.priority)
+            config.headers['priority'] = this.profile.priority;
+        return config;
+    }
+    async request(uri, data, options = {}, callback) {
+        if (typeof options === 'function') {
+            callback = options;
+            options = {};
+        }
+        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}`;
-        let session = this.sessionCache.get(cacheKey);
         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);
+            const tlsManager = new TLSSocketManager(this.profile, options.proxy);
             const tlsSocket = await tlsManager.connect(hostname, port);
-            const http2Manager = new HTTP2ClientManager(tlsSocket, this.profile, hostname, this.cookieJar);
-            await http2Manager.createSession();
-            session = { tlsManager, http2Manager, lastUsed: Date.now() };
+            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].http2Manager.destroy();
+                oldest[1].clientManager.destroy();
                 oldest[1].tlsManager.destroy();
                 this.sessionCache.delete(oldest[0]);
             }
         }
         session.lastUsed = Date.now();
-        options.headers = options.headers || {};
-        options.headers['user-agent'] = this.profile.userAgent;
-        options.headers['accept-language'] = this.profile.acceptLanguage || 'en-US,en;q=0.9';
-        options.headers['accept-encoding'] = 'gzip, deflate, br';
-        options.headers['accept'] = 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8';
-        options.headers['sec-ch-ua'] = this.profile.secChUa;
-        options.headers['sec-ch-ua-mobile'] = this.profile.secChUaMobile;
-        options.headers['sec-ch-ua-platform'] = this.profile.secChUaPlatform;
-        options.headers['sec-fetch-site'] = this.profile.secFetchSite;
-        options.headers['sec-fetch-mode'] = this.profile.secFetchMode;
-        options.headers['sec-fetch-dest'] = this.profile.secFetchDest;
-        if (this.profile.upgradeInsecureRequests)
-            options.headers['upgrade-insecure-requests'] = this.profile.upgradeInsecureRequests;
-        if (this.profile.priority)
-            options.headers['priority'] = this.profile.priority;
+        const config = this.setup(uri, options);
+        let post_data = null;
+        let json = options.json || (options.json !== false && config.headers['content-type']?.includes('application/json'));
+        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;
+            }
+            else if (json) {
+                post_data = JSON.stringify(data);
+                config.headers['content-type'] = 'application/json; charset=utf-8';
+            }
+            else {
+                post_data = new URLSearchParams(data).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();
+            }
+        }
         const cookies = this.cookieJar.getCookies(hostname, parsed.pathname, parsed.protocol === 'https:');
         if (cookies)
-            options.headers['cookie'] = cookies;
-        let response = await session.http2Manager.request(path, options, startTime);
-        if (options.followRedirects !== false && [301, 302, 303, 307, 308].includes(response.statusCode) && (options.maxRedirects ?? 5) > 0) {
-            options.maxRedirects = (options.maxRedirects ?? 5) - 1;
-            const location = response.headers['location'];
-            if (location) {
-                const redirectUrl = new URL(location, url).toString();
-                return this.request(redirectUrl, options);
+            config.headers['cookie'] = cookies;
+        if (options.stream === true) {
+            session.clientManager.request(path, options, startTime, config.headers, post_data, out);
+            return out;
+        }
+        if (callback) {
+            const typedCallback = callback;
+            session.clientManager.request(path, options, startTime, config.headers, post_data, out, typedCallback).catch(err => {
+                if (typedCallback)
+                    typedCallback(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) {
+                        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;
+                const ct = headers['content-type']?.toLowerCase();
+                if (ct?.includes('application/json')) {
+                    try {
+                        parsedJson = JSON.parse(text);
+                    }
+                    catch { }
+                }
+                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
+                    }
+                });
+            };
+            out.on('header', (status, hdrs) => {
+                statusCode = status;
+                headers = hdrs;
+            });
+            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 ecPoints = this.profile.tls.ecPointFormats.join('-');
+        return `${version},${ciphers},${extensions},${curves},${ecPoints}`;
+    }
+    async buildMultipart(data, boundary) {
+        return new Promise((resolve, reject) => {
+            let body = '';
+            const object = this.flatten(data);
+            const count = Object.keys(object).length;
+            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'));
+            };
+            for (const key in object) {
+                const value = object[key];
+                if (value === null || typeof value === 'undefined') {
+                    done();
+                    continue;
+                }
+                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}"`;
+        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 += data.toString('binary');
+            }
+            return return_part + '\r\n';
+        };
+        if ((part.file || part.buffer) && part.content_type) {
+            const filename = part.filename || (part.file ? path.basename(part.file) : name);
+            if (part.buffer)
+                return append(part.buffer, filename);
+            const data = await fs.promises.readFile(part.file);
+            return append(data, filename);
+        }
+        else {
+            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 prop = object[key];
+            if (prop && typeof prop === 'object' && !(prop.buffer || prop.file || prop.content_type)) {
+                this.flatten(prop, into, prefix_key);
+            }
+            else {
+                into[prefix_key] = prop;
             }
         }
-        return response;
+        return into;
     }
     destroy() {
         clearInterval(this.cleanupInterval);
         this.sessionCache.forEach(s => {
-            s.http2Manager.destroy();
+            s.clientManager.destroy();
             s.tlsManager.destroy();
         });
         this.sessionCache.clear();