arn-browser 0.1.22 → 0.1.23

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "arn-browser",
-	"version": "0.1.22",
+	"version": "0.1.23",
 	"description": "A lightweight, browser autmation helper.",
 	"main": "src/index.js",
 	"types": "src/index.d.ts",

package/src/utility/proxy-utility/proxy-chain.d.ts

@@ -30,10 +30,14 @@ export interface GeoDetails {
 export interface TrafficStats {
 	/** Number of requests handled */
 	req: number;
-	/** Data sent to client (Formatted MB string) */
-	Tx: string;
-	/** Data received from client (Formatted MB string) */
-	Rx: string;
+	/** Data sent to client (source Tx, formatted string) */
+	sTx: string;
+	/** Data received from client (source Rx, formatted string) */
+	sRx: string;
+	/** Data sent to upstream proxy (target Tx, formatted string). Only present when showTg is true. */
+	tTx?: string;
+	/** Data received from upstream proxy (target Rx, formatted string). Only present when showTg is true. */
+	tRx?: string;
 }
 
 /**
@@ -69,6 +73,8 @@ export interface ProxyServerOptions {
 	proxy_stats?: boolean;
 	/** Track hostname usage statistics (default: true) */
 	host_stats?: boolean;
+	/** Show target bytes (tTx/tRx) in stats output (default: false) */
+	tg_stats?: boolean;
 }
 
 /**

package/src/utility/proxy-utility/proxy-chain.js

@@ -10,8 +10,8 @@ import { SocksProxyAgent } from "socks-proxy-agent";
 // SECTION 1: NETWORK HELPERS
 // ==========================================
 
-function nativeGet(url, agent = null, timeout = 5000) {
-	return new Promise((resolve, reject) => {
+async function nativeGet(url, agent = null, timeout = 5000, retries = 5) {
+	const attempt = () => new Promise((resolve, reject) => {
 		const urlObj = new URL(url);
 		const requestModule = urlObj.protocol === "https:" ? https : http;
 
@@ -40,6 +40,15 @@ function nativeGet(url, agent = null, timeout = 5000) {
 			reject(new Error("Request Timed Out"));
 		});
 	});
+
+	for (let i = 1; i <= retries; i++) {
+		try {
+			return await attempt();
+		} catch (err) {
+			if (i === retries) throw err;
+			await sleep(1000);
+		}
+	}
 }
 
 const isPortAvailable = (port) => {
@@ -190,6 +199,7 @@ export async function startProxyServer({
 	debug = false,
 	proxy_stats = true,
 	host_stats = true,
+	tg_stats = false,
 }) {
 	// 1. Matchers
 	const matchers = {
@@ -360,16 +370,21 @@ export async function startProxyServer({
 		return (bytes / (1024 * 1024)).toFixed(3) + " MB";
 	};
 
+
+
 	const getProxyStatsFormatted = () => {
 		const formatted = {};
 		for (const [key, val] of Object.entries(stats)) {
-			formatted[key] = {
+			const entry = {
 				req: val.request,
 				sTx: formatBytes(val.srcTx),
 				sRx: formatBytes(val.srcRx),
-				tTx: formatBytes(val.trgTx),
-				tRx: formatBytes(val.trgRx),
 			};
+			if (tg_stats) {
+				entry.tTx = formatBytes(val.trgTx);
+				entry.tRx = formatBytes(val.trgRx);
+			}
+			formatted[key] = entry;
 		}
 		return formatted;
 	};
@@ -380,13 +395,16 @@ export async function startProxyServer({
 			const sortedHosts = Object.entries(hosts)
 				.sort((a, b) => b[1].req - a[1].req)
 				.reduce((acc, [host, hostData]) => {
-					acc[host] = {
+					const entry = {
 						req: hostData.req,
 						sTx: formatBytes(hostData.srcTx),
 						sRx: formatBytes(hostData.srcRx),
-						tTx: formatBytes(hostData.trgTx),
-						tRx: formatBytes(hostData.trgRx),
 					};
+					if (tg_stats) {
+						entry.tTx = formatBytes(hostData.trgTx);
+						entry.tRx = formatBytes(hostData.trgRx);
+					}
+					acc[host] = entry;
 					return acc;
 				}, {});
 
@@ -425,11 +443,11 @@ export async function startProxyServer({
 			await server.close(true);
 			serverRunning = false;
 
-			// Wait up to 2000ms (2 seconds) for all async 'connectionClosed' events to fire
+			// Wait up to 5000ms (5 seconds) for all async 'connectionClosed' events to fire
 			// When sockets are destroyed, their 'close' events happen asynchronously
-			let maxWait = 200; // 200 * 10ms = 2000ms
+			let maxWait = 250; // 250 * 20ms = 5000ms
 			while (Object.keys(connectionMap).length > 0 && maxWait > 0) {
-				await new Promise((resolve) => setTimeout(resolve, 10));
+				await new Promise((resolve) => setTimeout(resolve, 20));
 				maxWait--;
 			}