advanced-tls-client 3.0.2 → 3.0.5

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,34 @@ 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;
@@ -140,7 +162,8 @@ declare class AdvancedTLSClient {
     private defaults;
     constructor(profileName?: string);
     private setup;
-    request(uri: string, data?: any, options?: RequestOptions, callback?: Function): Promise<FullResponse | PassThrough>;
+    private isRequestOptions;
+    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;
     private generateMultipart;

package/dist/index.js

@@ -177,438 +177,11 @@ class ProfileRegistry {
             priority: 'u=0, i'
         };
     }
-    static chrome133PSK() {
-        const grease1 = this.getGrease();
-        const grease2 = this.getGrease();
-        const grease3 = this.getGrease();
-        const grease4 = this.getGrease();
-        return {
-            name: 'chrome_133_psk',
-            version: '133.0.0.0',
-            tls: {
-                cipherSuites: [
-                    grease1,
-                    4865,
-                    4866,
-                    4867,
-                    49195,
-                    49199,
-                    49196,
-                    49200,
-                    52393,
-                    52392,
-                    49171,
-                    49172,
-                    156,
-                    157,
-                    47,
-                    53
-                ],
-                extensions: [
-                    grease2,
-                    0,
-                    23,
-                    65281,
-                    10,
-                    11,
-                    35,
-                    16,
-                    5,
-                    13,
-                    18,
-                    51,
-                    45,
-                    43,
-                    27,
-                    21,
-                    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],
-                compressionMethods: [0],
-                grease: true,
-                recordSizeLimit: 16385
-            },
-            http2: {
-                windowUpdate: 15663105,
-                headerTableSize: 65536,
-                enablePush: 0,
-                initialWindowSize: 6291456,
-                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: [
-                    {
-                        streamId: 0,
-                        weight: 256,
-                        dependency: 0,
-                        exclusive: true
-                    }
-                ],
-                pseudoHeaderOrder: [':method', ':authority', ':scheme', ':path'],
-                headerOrder: [
-                    'cache-control',
-                    '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-user',
-                    'sec-fetch-dest',
-                    'accept-encoding',
-                    'accept-language'
-                ]
-            },
-            userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
-            secChUa: '"Google Chrome";v="133", "Chromium";v="133", "Not_A Brand";v="24"',
-            secChUaPlatform: '"Windows"',
-            secChUaMobile: '?0',
-            secFetchSite: 'none',
-            secFetchMode: 'navigate',
-            secFetchDest: 'document'
-        };
-    }
-    static chrome133() {
-        const grease1 = this.getGrease();
-        const grease2 = this.getGrease();
-        const grease3 = this.getGrease();
-        const grease4 = this.getGrease();
-        return {
-            name: 'chrome_133',
-            version: '133.0.0.0',
-            tls: {
-                cipherSuites: [
-                    grease1,
-                    4865,
-                    4866,
-                    4867,
-                    49195,
-                    49199,
-                    49196,
-                    49200,
-                    52393,
-                    52392,
-                    49171,
-                    49172,
-                    156,
-                    157,
-                    47,
-                    53
-                ],
-                extensions: [
-                    grease2,
-                    0,
-                    23,
-                    65281,
-                    10,
-                    11,
-                    35,
-                    16,
-                    5,
-                    13,
-                    18,
-                    51,
-                    45,
-                    43,
-                    27,
-                    21,
-                    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],
-                compressionMethods: [0],
-                grease: true,
-                recordSizeLimit: 16385
-            },
-            http2: {
-                windowUpdate: 15663105,
-                headerTableSize: 65536,
-                enablePush: 0,
-                initialWindowSize: 6291456,
-                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: [
-                    {
-                        streamId: 0,
-                        weight: 256,
-                        dependency: 0,
-                        exclusive: true
-                    }
-                ],
-                pseudoHeaderOrder: [':method', ':authority', ':scheme', ':path'],
-                headerOrder: [
-                    'cache-control',
-                    '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-user',
-                    'sec-fetch-dest',
-                    'accept-encoding',
-                    'accept-language'
-                ]
-            },
-            userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
-            secChUa: '"Google Chrome";v="133", "Chromium";v="133", "Not_A Brand";v="24"',
-            secChUaPlatform: '"Windows"',
-            secChUaMobile: '?0',
-            secFetchSite: 'none',
-            secFetchMode: 'navigate',
-            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();
-        }
+        return this.chromeMobile143Android();
     }
     static get latest() {
-        return this.chrome133();
+        return this.chromeMobile143Android();
     }
     static get latestMobile() {
         return this.chromeMobile143Android();
@@ -747,13 +320,15 @@ 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': path,
+            ':path': normalizedPath,
             ...headers
         };
+        console.log('Sending HTTP/2 Request Headers:', reqHeaders);
         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 };
@@ -1133,7 +708,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) {
@@ -1147,7 +722,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
         };
@@ -1165,12 +740,46 @@ class AdvancedTLSClient {
             config.headers['upgrade-insecure-requests'] = this.profile.upgradeInsecureRequests;
         if (this.profile.priority)
             config.headers['priority'] = this.profile.priority;
+        if (options.headers) {
+            Object.assign(config.headers, options.headers);
+        }
         return config;
     }
-    async request(uri, data, options = {}, callback) {
-        if (typeof options === 'function') {
-            callback = options;
-            options = {};
+    isRequestOptions(obj) {
+        if (typeof obj !== 'object' || obj === null)
+            return false;
+        if (Buffer.isBuffer(obj) || obj instanceof stream_1.Readable)
+            return false;
+        const optionKeys = ['method', 'headers', 'proxy', 'decompress', 'stream', 'multipart', 'boundary', 'json', 'timeout'];
+        const keys = Object.keys(obj);
+        return keys.some(key => optionKeys.includes(key));
+    }
+    async request(uri, dataOrOptions, optionsOrCallback, callback) {
+        let data = null;
+        let options = {};
+        let cb = undefined;
+        if (typeof dataOrOptions === 'function') {
+            cb = dataOrOptions;
+        }
+        else if (dataOrOptions !== undefined && dataOrOptions !== null) {
+            if (this.isRequestOptions(dataOrOptions)) {
+                options = dataOrOptions;
+            }
+            else {
+                data = dataOrOptions;
+            }
+        }
+        if (typeof optionsOrCallback === 'function') {
+            cb = optionsOrCallback;
+        }
+        else if (optionsOrCallback !== undefined && optionsOrCallback !== null) {
+            options = optionsOrCallback;
+        }
+        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;
@@ -1197,7 +806,10 @@ 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;
@@ -1232,11 +844,10 @@ class AdvancedTLSClient {
             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);
+        if (cb) {
+            session.clientManager.request(path, options, startTime, config.headers, post_data, out, cb).catch(err => {
+                if (cb)
+                    cb(err);
             });
             return out;
         }

package/package.json

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