rezo 1.0.42 → 1.0.43

package/dist/adapters/entries/http2.d.ts

@@ -4355,6 +4355,71 @@ export declare class Rezo {
 	 * @see {@link cookieJar} - Access the underlying RezoCookieJar for more control
 	 */
 	clearCookies(): void;
+	/**
+	 * Convert a Rezo request configuration to a cURL command string.
+	 *
+	 * Generates a valid cURL command that can be executed in a terminal to
+	 * reproduce the same HTTP request. Useful for:
+	 * - Debugging and sharing requests
+	 * - Documentation and examples
+	 * - Testing requests outside of Node.js
+	 * - Exporting requests to other tools
+	 *
+	 * @param config - Request configuration object
+	 * @returns A cURL command string
+	 *
+	 * @example
+	 * ```typescript
+	 * const curl = Rezo.toCurl({
+	 *   url: 'https://api.example.com/users',
+	 *   method: 'POST',
+	 *   headers: { 'Content-Type': 'application/json' },
+	 *   body: { name: 'John', email: 'john@example.com' }
+	 * });
+	 * // Output: curl -X POST -H 'content-type: application/json' --data-raw '{"name":"John","email":"john@example.com"}' -L --compressed 'https://api.example.com/users'
+	 * ```
+	 */
+	static toCurl(config: RezoRequestConfig | RezoRequestOptions): string;
+	/**
+	 * Parse a cURL command string into a Rezo request configuration.
+	 *
+	 * Converts a cURL command into a configuration object that can be
+	 * passed directly to Rezo request methods. Useful for:
+	 * - Importing requests from browser DevTools
+	 * - Converting curl examples from API documentation
+	 * - Migrating scripts from curl to Rezo
+	 *
+	 * Supports common cURL options:
+	 * - `-X, --request` - HTTP method
+	 * - `-H, --header` - Request headers
+	 * - `-d, --data, --data-raw, --data-binary` - Request body
+	 * - `-u, --user` - Basic authentication
+	 * - `-x, --proxy` - Proxy configuration
+	 * - `--socks5, --socks4` - SOCKS proxy
+	 * - `-L, --location` - Follow redirects
+	 * - `--max-redirs` - Maximum redirects
+	 * - `--max-time` - Request timeout
+	 * - `-k, --insecure` - Skip TLS verification
+	 * - `-A, --user-agent` - User agent header
+	 *
+	 * @param curlCommand - A cURL command string
+	 * @returns A request configuration object
+	 *
+	 * @example
+	 * ```typescript
+	 * // From browser DevTools "Copy as cURL"
+	 * const config = Rezo.fromCurl(`
+	 *   curl 'https://api.example.com/data' \\
+	 *     -H 'Authorization: Bearer token123' \\
+	 *     -H 'Content-Type: application/json'
+	 * `);
+	 *
+	 * // Use with Rezo
+	 * const rezo = new Rezo();
+	 * const response = await rezo.request(config);
+	 * ```
+	 */
+	static fromCurl(curlCommand: string): RezoRequestOptions;
 }
 /**
  * Extended Rezo instance with Axios-compatible static helpers.

package/dist/adapters/entries/react-native.d.ts

@@ -4355,6 +4355,71 @@ export declare class Rezo {
 	 * @see {@link cookieJar} - Access the underlying RezoCookieJar for more control
 	 */
 	clearCookies(): void;
+	/**
+	 * Convert a Rezo request configuration to a cURL command string.
+	 *
+	 * Generates a valid cURL command that can be executed in a terminal to
+	 * reproduce the same HTTP request. Useful for:
+	 * - Debugging and sharing requests
+	 * - Documentation and examples
+	 * - Testing requests outside of Node.js
+	 * - Exporting requests to other tools
+	 *
+	 * @param config - Request configuration object
+	 * @returns A cURL command string
+	 *
+	 * @example
+	 * ```typescript
+	 * const curl = Rezo.toCurl({
+	 *   url: 'https://api.example.com/users',
+	 *   method: 'POST',
+	 *   headers: { 'Content-Type': 'application/json' },
+	 *   body: { name: 'John', email: 'john@example.com' }
+	 * });
+	 * // Output: curl -X POST -H 'content-type: application/json' --data-raw '{"name":"John","email":"john@example.com"}' -L --compressed 'https://api.example.com/users'
+	 * ```
+	 */
+	static toCurl(config: RezoRequestConfig | RezoRequestOptions): string;
+	/**
+	 * Parse a cURL command string into a Rezo request configuration.
+	 *
+	 * Converts a cURL command into a configuration object that can be
+	 * passed directly to Rezo request methods. Useful for:
+	 * - Importing requests from browser DevTools
+	 * - Converting curl examples from API documentation
+	 * - Migrating scripts from curl to Rezo
+	 *
+	 * Supports common cURL options:
+	 * - `-X, --request` - HTTP method
+	 * - `-H, --header` - Request headers
+	 * - `-d, --data, --data-raw, --data-binary` - Request body
+	 * - `-u, --user` - Basic authentication
+	 * - `-x, --proxy` - Proxy configuration
+	 * - `--socks5, --socks4` - SOCKS proxy
+	 * - `-L, --location` - Follow redirects
+	 * - `--max-redirs` - Maximum redirects
+	 * - `--max-time` - Request timeout
+	 * - `-k, --insecure` - Skip TLS verification
+	 * - `-A, --user-agent` - User agent header
+	 *
+	 * @param curlCommand - A cURL command string
+	 * @returns A request configuration object
+	 *
+	 * @example
+	 * ```typescript
+	 * // From browser DevTools "Copy as cURL"
+	 * const config = Rezo.fromCurl(`
+	 *   curl 'https://api.example.com/data' \\
+	 *     -H 'Authorization: Bearer token123' \\
+	 *     -H 'Content-Type: application/json'
+	 * `);
+	 *
+	 * // Use with Rezo
+	 * const rezo = new Rezo();
+	 * const response = await rezo.request(config);
+	 * ```
+	 */
+	static fromCurl(curlCommand: string): RezoRequestOptions;
 }
 /**
  * Extended Rezo instance with Axios-compatible static helpers.

package/dist/adapters/entries/xhr.d.ts

@@ -4355,6 +4355,71 @@ export declare class Rezo {
 	 * @see {@link cookieJar} - Access the underlying RezoCookieJar for more control
 	 */
 	clearCookies(): void;
+	/**
+	 * Convert a Rezo request configuration to a cURL command string.
+	 *
+	 * Generates a valid cURL command that can be executed in a terminal to
+	 * reproduce the same HTTP request. Useful for:
+	 * - Debugging and sharing requests
+	 * - Documentation and examples
+	 * - Testing requests outside of Node.js
+	 * - Exporting requests to other tools
+	 *
+	 * @param config - Request configuration object
+	 * @returns A cURL command string
+	 *
+	 * @example
+	 * ```typescript
+	 * const curl = Rezo.toCurl({
+	 *   url: 'https://api.example.com/users',
+	 *   method: 'POST',
+	 *   headers: { 'Content-Type': 'application/json' },
+	 *   body: { name: 'John', email: 'john@example.com' }
+	 * });
+	 * // Output: curl -X POST -H 'content-type: application/json' --data-raw '{"name":"John","email":"john@example.com"}' -L --compressed 'https://api.example.com/users'
+	 * ```
+	 */
+	static toCurl(config: RezoRequestConfig | RezoRequestOptions): string;
+	/**
+	 * Parse a cURL command string into a Rezo request configuration.
+	 *
+	 * Converts a cURL command into a configuration object that can be
+	 * passed directly to Rezo request methods. Useful for:
+	 * - Importing requests from browser DevTools
+	 * - Converting curl examples from API documentation
+	 * - Migrating scripts from curl to Rezo
+	 *
+	 * Supports common cURL options:
+	 * - `-X, --request` - HTTP method
+	 * - `-H, --header` - Request headers
+	 * - `-d, --data, --data-raw, --data-binary` - Request body
+	 * - `-u, --user` - Basic authentication
+	 * - `-x, --proxy` - Proxy configuration
+	 * - `--socks5, --socks4` - SOCKS proxy
+	 * - `-L, --location` - Follow redirects
+	 * - `--max-redirs` - Maximum redirects
+	 * - `--max-time` - Request timeout
+	 * - `-k, --insecure` - Skip TLS verification
+	 * - `-A, --user-agent` - User agent header
+	 *
+	 * @param curlCommand - A cURL command string
+	 * @returns A request configuration object
+	 *
+	 * @example
+	 * ```typescript
+	 * // From browser DevTools "Copy as cURL"
+	 * const config = Rezo.fromCurl(`
+	 *   curl 'https://api.example.com/data' \\
+	 *     -H 'Authorization: Bearer token123' \\
+	 *     -H 'Content-Type: application/json'
+	 * `);
+	 *
+	 * // Use with Rezo
+	 * const rezo = new Rezo();
+	 * const response = await rezo.request(config);
+	 * ```
+	 */
+	static fromCurl(curlCommand: string): RezoRequestOptions;
 }
 /**
  * Extended Rezo instance with Axios-compatible static helpers.

package/dist/adapters/http2.cjs

@@ -1,4 +1,5 @@
 const http2 = require("node:http2");
+const tls = require("node:tls");
 const zlib = require("node:zlib");
 const { URL } = require("node:url");
 const { Readable } = require("node:stream");
@@ -14,6 +15,8 @@ const { DownloadResponse } = require('../responses/download.cjs');
 const { UploadResponse } = require('../responses/upload.cjs');
 const { CompressionUtil } = require('../utils/compression.cjs');
 const { isSameDomain, RezoPerformance } = require('../utils/tools.cjs');
+const { SocksClient } = require('../internal/agents/socks-client.cjs');
+const net = require("node:net");
 const { ResponseCache } = require('../cache/response-cache.cjs');
 let zstdDecompressSync = null;
 let zstdChecked = false;
@@ -194,8 +197,9 @@ class Http2SessionPool {
       this.cleanupInterval.unref();
     }
   }
-  getSessionKey(url, options) {
-    return `${url.protocol}//${url.host}`;
+  getSessionKey(url, options, proxy) {
+    const proxyKey = proxy ? typeof proxy === "string" ? proxy : `${proxy.protocol}://${proxy.host}:${proxy.port}` : "";
+    return `${url.protocol}//${url.host}${proxyKey ? `@${proxyKey}` : ""}`;
   }
   isSessionHealthy(session, entry) {
     if (session.closed || session.destroyed)
@@ -207,8 +211,8 @@ class Http2SessionPool {
       return false;
     return true;
   }
-  async getSession(url, options, timeout, forceNew = false) {
-    const key = this.getSessionKey(url, options);
+  async getSession(url, options, timeout, forceNew = false, proxy) {
+    const key = this.getSessionKey(url, options, proxy);
     const existing = this.sessions.get(key);
     if (!forceNew && existing && this.isSessionHealthy(existing.session, existing)) {
       existing.lastUsed = Date.now();
@@ -221,12 +225,13 @@ class Http2SessionPool {
       } catch {}
       this.sessions.delete(key);
     }
-    const session = await this.createSession(url, options, timeout);
+    const session = await this.createSession(url, options, timeout, proxy);
     const entry = {
       session,
       lastUsed: Date.now(),
       refCount: 1,
-      goawayReceived: false
+      goawayReceived: false,
+      proxy
     };
     this.sessions.set(key, entry);
     session.on("close", () => {
@@ -240,15 +245,19 @@ class Http2SessionPool {
     });
     return session;
   }
-  createSession(url, options, timeout) {
+  async createSession(url, options, timeout, proxy) {
+    const authority = `${url.protocol}//${url.host}`;
+    const sessionOptions = {
+      ...options,
+      rejectUnauthorized: options?.rejectUnauthorized !== false,
+      ALPNProtocols: ["h2", "http/1.1"],
+      timeout
+    };
+    if (proxy) {
+      const tunnelSocket = await this.createProxyTunnel(url, proxy, timeout, options?.rejectUnauthorized);
+      sessionOptions.createConnection = () => tunnelSocket;
+    }
     return new Promise((resolve, reject) => {
-      const authority = `${url.protocol}//${url.host}`;
-      const sessionOptions = {
-        ...options,
-        rejectUnauthorized: options?.rejectUnauthorized !== false,
-        ALPNProtocols: ["h2", "http/1.1"],
-        timeout
-      };
       const session = http2.connect(authority, sessionOptions);
       let settled = false;
       const timeoutId = timeout ? setTimeout(() => {
@@ -279,8 +288,186 @@ class Http2SessionPool {
       });
     });
   }
-  releaseSession(url) {
-    const key = this.getSessionKey(url);
+  async createProxyTunnel(url, proxy, timeout, rejectUnauthorized) {
+    return new Promise((resolve, reject) => {
+      let proxyUrl;
+      let proxyAuth;
+      if (typeof proxy === "string") {
+        proxyUrl = new URL(proxy);
+        if (proxyUrl.username || proxyUrl.password) {
+          proxyAuth = Buffer.from(`${decodeURIComponent(proxyUrl.username)}:${decodeURIComponent(proxyUrl.password)}`).toString("base64");
+        }
+      } else {
+        const protocol = proxy.protocol || "http";
+        let proxyUrlStr = `${protocol}://${proxy.host}:${proxy.port}`;
+        if (proxy.auth) {
+          const encodedUser = encodeURIComponent(proxy.auth.username);
+          const encodedPass = encodeURIComponent(proxy.auth.password);
+          proxyUrlStr = `${protocol}://${encodedUser}:${encodedPass}@${proxy.host}:${proxy.port}`;
+          proxyAuth = Buffer.from(`${proxy.auth.username}:${proxy.auth.password}`).toString("base64");
+        }
+        proxyUrl = new URL(proxyUrlStr);
+      }
+      const targetHost = url.hostname;
+      const targetPort = url.port || (url.protocol === "https:" ? "443" : "80");
+      if (proxyUrl.protocol.startsWith("socks")) {
+        const socksType = proxyUrl.protocol === "socks5:" || proxyUrl.protocol === "socks5h:" ? 5 : 4;
+        const socksOpts = {
+          proxy: {
+            host: proxyUrl.hostname,
+            port: parseInt(proxyUrl.port || "1080", 10),
+            type: socksType,
+            userId: proxyUrl.username ? decodeURIComponent(proxyUrl.username) : undefined,
+            password: proxyUrl.password ? decodeURIComponent(proxyUrl.password) : undefined
+          },
+          destination: {
+            host: targetHost,
+            port: parseInt(targetPort, 10)
+          },
+          command: "connect",
+          timeout
+        };
+        SocksClient.createConnection(socksOpts).then(({ socket }) => {
+          if (url.protocol === "https:") {
+            const tlsSocket = tls.connect({
+              socket,
+              host: targetHost,
+              servername: targetHost,
+              rejectUnauthorized: rejectUnauthorized !== false,
+              ALPNProtocols: ["h2", "http/1.1"]
+            });
+            const tlsTimeoutId = timeout ? setTimeout(() => {
+              tlsSocket.destroy();
+              reject(new Error(`TLS handshake timeout after ${timeout}ms`));
+            }, timeout) : null;
+            tlsSocket.on("secureConnect", () => {
+              if (tlsTimeoutId)
+                clearTimeout(tlsTimeoutId);
+              const alpn = tlsSocket.alpnProtocol;
+              if (alpn && alpn !== "h2") {
+                tlsSocket.destroy();
+                reject(new Error(`Server does not support HTTP/2 (negotiated: ${alpn})`));
+                return;
+              }
+              resolve(tlsSocket);
+            });
+            tlsSocket.on("error", (err) => {
+              if (tlsTimeoutId)
+                clearTimeout(tlsTimeoutId);
+              reject(new Error(`TLS handshake failed: ${err.message}`));
+            });
+          } else {
+            resolve(socket);
+          }
+        }).catch((err) => {
+          reject(new Error(`SOCKS proxy connection failed: ${err.message}`));
+        });
+        return;
+      }
+      const proxyHost = proxyUrl.hostname;
+      const proxyPort = parseInt(proxyUrl.port || (proxyUrl.protocol === "https:" ? "443" : "80"), 10);
+      let proxySocket;
+      const connectToProxy = () => {
+        if (proxyUrl.protocol === "https:") {
+          proxySocket = tls.connect({
+            host: proxyHost,
+            port: proxyPort,
+            rejectUnauthorized: rejectUnauthorized !== false
+          });
+        } else {
+          proxySocket = net.connect({
+            host: proxyHost,
+            port: proxyPort
+          });
+        }
+        let settled = false;
+        const timeoutId = timeout ? setTimeout(() => {
+          if (!settled) {
+            settled = true;
+            proxySocket.destroy();
+            reject(new Error(`Proxy connection timeout after ${timeout}ms`));
+          }
+        }, timeout) : null;
+        proxySocket.on("error", (err) => {
+          if (!settled) {
+            settled = true;
+            if (timeoutId)
+              clearTimeout(timeoutId);
+            reject(new Error(`Proxy connection error: ${err.message}`));
+          }
+        });
+        proxySocket.on("connect", () => {
+          const connectRequest = [
+            `CONNECT ${targetHost}:${targetPort} HTTP/1.1`,
+            `Host: ${targetHost}:${targetPort}`,
+            proxyAuth ? `Proxy-Authorization: Basic ${proxyAuth}` : "",
+            "",
+            ""
+          ].filter(Boolean).join(`\r
+`);
+          proxySocket.write(connectRequest);
+        });
+        let responseBuffer = "";
+        proxySocket.on("data", function onData(data) {
+          if (settled)
+            return;
+          responseBuffer += data.toString();
+          const headerEnd = responseBuffer.indexOf(`\r
+\r
+`);
+          if (headerEnd !== -1) {
+            settled = true;
+            if (timeoutId)
+              clearTimeout(timeoutId);
+            proxySocket.removeListener("data", onData);
+            const statusLine = responseBuffer.split(`\r
+`)[0];
+            const statusMatch = statusLine.match(/HTTP\/\d\.\d (\d{3})/);
+            const statusCode = statusMatch ? parseInt(statusMatch[1], 10) : 0;
+            if (statusCode === 200) {
+              if (url.protocol === "https:") {
+                const tlsSocket = tls.connect({
+                  socket: proxySocket,
+                  host: targetHost,
+                  servername: targetHost,
+                  rejectUnauthorized: rejectUnauthorized !== false,
+                  ALPNProtocols: ["h2", "http/1.1"]
+                });
+                const tlsTimeoutId = timeout ? setTimeout(() => {
+                  tlsSocket.destroy();
+                  reject(new Error(`TLS handshake timeout after ${timeout}ms`));
+                }, timeout) : null;
+                tlsSocket.on("secureConnect", () => {
+                  if (tlsTimeoutId)
+                    clearTimeout(tlsTimeoutId);
+                  const alpn = tlsSocket.alpnProtocol;
+                  if (alpn && alpn !== "h2") {
+                    tlsSocket.destroy();
+                    reject(new Error(`Server does not support HTTP/2 (negotiated: ${alpn})`));
+                    return;
+                  }
+                  resolve(tlsSocket);
+                });
+                tlsSocket.on("error", (err) => {
+                  if (tlsTimeoutId)
+                    clearTimeout(tlsTimeoutId);
+                  reject(new Error(`TLS handshake failed: ${err.message}`));
+                });
+              } else {
+                resolve(proxySocket);
+              }
+            } else {
+              proxySocket.destroy();
+              reject(new Error(`Proxy CONNECT failed with status ${statusCode}: ${statusLine}`));
+            }
+          }
+        });
+      };
+      connectToProxy();
+    });
+  }
+  releaseSession(url, proxy) {
+    const key = this.getSessionKey(url, undefined, proxy);
     const entry = this.sessions.get(key);
     if (entry) {
       entry.refCount = Math.max(0, entry.refCount - 1);
@@ -293,8 +480,8 @@ class Http2SessionPool {
       }
     }
   }
-  closeSession(url) {
-    const key = this.getSessionKey(url);
+  closeSession(url, proxy) {
+    const key = this.getSessionKey(url, undefined, proxy);
     const entry = this.sessions.get(key);
     if (entry) {
       entry.session.close();
@@ -1008,10 +1195,10 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
       const forceNewSession = requestCount > 0;
       let session;
       if (config.debug) {
-        console.log(`[Rezo Debug] HTTP/2: Acquiring session for ${url.host}${forceNewSession ? " (forcing new for redirect)" : ""}...`);
+        console.log(`[Rezo Debug] HTTP/2: Acquiring session for ${url.host}${forceNewSession ? " (forcing new for redirect)" : ""}${fetchOptions.proxy ? " (via proxy)" : ""}...`);
       }
       try {
-        session = await (sessionPool || Http2SessionPool.getInstance()).getSession(url, sessionOptions, config.timeout !== null ? config.timeout : undefined, forceNewSession);
+        session = await (sessionPool || Http2SessionPool.getInstance()).getSession(url, sessionOptions, config.timeout !== null ? config.timeout : undefined, forceNewSession, fetchOptions.proxy);
         if (config.debug) {
           console.log(`[Rezo Debug] HTTP/2: Session acquired successfully`);
         }
@@ -1240,7 +1427,7 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
               config.transfer.requestSize = Buffer.byteLength(JSON.stringify(body), "utf8");
             }
           }
-          (sessionPool || Http2SessionPool.getInstance()).releaseSession(url);
+          (sessionPool || Http2SessionPool.getInstance()).releaseSession(url, fetchOptions.proxy);
           if (isRedirect) {
             _stats.statusOnNext = "redirect";
             const partialResponse = {
@@ -1417,7 +1604,7 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
           if (config.debug) {
             console.log(`[Rezo Debug] HTTP/2: Error in 'end' handler:`, endError.message);
           }
-          (sessionPool || Http2SessionPool.getInstance()).releaseSession(url);
+          (sessionPool || Http2SessionPool.getInstance()).releaseSession(url, fetchOptions.proxy);
           const error = buildSmartError(config, fetchOptions, endError);
           _stats.statusOnNext = "error";
           resolve(error);