arn-browser 0.1.2 → 0.1.4

package/package.json

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

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

@@ -64,6 +64,8 @@ export interface ProxyServerOptions {
 	debug?: boolean;
 	/** Track proxy usage statistics (default: true) */
 	proxy_stats?: boolean;
+	/** Track hostname usage statistics (default: true) */
+	host_stats?: boolean;
 }
 
 /**
@@ -102,11 +104,17 @@ export interface ProxyServerController {
 	/** The public IP of Proxy 2 */
 	PROXY_2_IP: string | null;
 
+	/** Check if the proxy server is currently running */
+	isServerRunning: () => boolean;
+
 	/** Gracefully closes the proxy server */
 	closeServer: () => Promise<void>;
 
 	/** Returns formatted statistics for all proxy channels */
 	getProxyStats: () => Record<string, TrafficStats>;
+
+	/** Returns formatted statistics for hostnames per proxy channel */
+	getHostStats: () => Record<string, Record<string, TrafficStats>>;
 }
 
 /**

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

@@ -178,10 +178,11 @@ export async function startProxyServer({
 	ip2LocationKey = null,
 	debug = false,
 	proxy_stats = true,
+	host_stats = true,
 }) {
 	// 1. Matchers
 	const matchers = {
-		noProxy: createHostMatcher([...NO_PROXY_HOSTS, "brave.com", "gvt1.com"]),
+		noProxy: createHostMatcher([...NO_PROXY_HOSTS, "%brave.com%", "%gvt1.com%"]),
 		proxy1: createHostMatcher([...PROXY_1_HOSTS, "proxy.multilogin.com", "multilogin.com"]),
 		proxy2: createHostMatcher([...PROXY_2_HOSTS, "proxy.multilogin.com", "multilogin.com"]),
 	};
@@ -227,7 +228,16 @@ export async function startProxyServer({
 		PROXY_1: { request: 0, Tx: 0, Rx: 0 },
 		PROXY_2: { request: 0, Tx: 0, Rx: 0 },
 	};
-	const connectionMap = {};
+	// hostStatsMap is now categorized by proxy type
+	const hostStatsMap = {
+		DEFAULT_PROXY: {},
+		NO_PROXY: {},
+		PROXY_1: {},
+		PROXY_2: {},
+	};
+
+	const connectionMap = {}; // Maps connectionId -> { type: "..." }
+	let serverRunning = false;
 
 	// 6. Server
 	const server = new ProxyChain.Server({
@@ -235,60 +245,88 @@ export async function startProxyServer({
 		host: "127.0.0.1",
 		verbose: debug,
 		prepareRequestFunction: ({ hostname, connectionId }) => {
-			// A. Direct (Force NO_PROXY)
+			let proxyType = "DEFAULT_PROXY";
+			let upstreamUrl = upstreamProxies.default;
+			let isCustomResponse = false;
+			let customResponseData = null;
+
+			// Logic to determine Proxy Type
 			if (matchers.noProxy(hostname)) {
-				connectionMap[connectionId] = { type: "NO_PROXY" };
-				return { upstreamProxyUrl: null, requestAuthentication: false };
+				// A. Direct
+				proxyType = "NO_PROXY";
+				upstreamUrl = null;
+			} else if (matchers.proxy1(hostname) && upstreamProxies.p1) {
+				// C1. Proxy 1
+				proxyType = "PROXY_1";
+				upstreamUrl = upstreamProxies.p1;
+			} else if (matchers.proxy2(hostname) && upstreamProxies.p2) {
+				// C2. Proxy 2
+				proxyType = "PROXY_2";
+				upstreamUrl = upstreamProxies.p2;
 			}
 
-			// B. IP Check Interception (ip.bablosoft.com)
+			// B. IP Check Interception (Overrules standard routing for specific domain)
 			if (hostname === "ip.bablosoft.com") {
+				isCustomResponse = true;
+				// Inherit the proxyType determined above to fetch the correct IP details
+				// (e.g. if it matched PROXY_1 matchers, we show PROXY_1 IP)
 				let displayedIP;
-
-				if (matchers.proxy1(hostname)) displayedIP = p1Details?.ip;
-				else if (matchers.proxy2(hostname)) displayedIP = p2Details?.ip;
-				else displayedIP = defaultDetails?.ip; // Uses Default (or Local fallback)
-
-				return {
-					customResponseFunction: () => ({
-						statusCode: 200,
-						headers: { "Content-Type": "text/plain", Connection: "close" },
-						body: displayedIP || "Unknown IP",
-					}),
+				if (proxyType === "PROXY_1") displayedIP = p1Details?.ip;
+				else if (proxyType === "PROXY_2") displayedIP = p2Details?.ip;
+				else if (proxyType === "NO_PROXY") displayedIP = "127.0.0.1";
+				else displayedIP = defaultDetails?.ip;
+
+				customResponseData = {
+					statusCode: 200,
+					headers: { "Content-Type": "text/plain", Connection: "close" },
+					body: displayedIP || "Unknown IP",
 				};
 			}
 
-			// C. Routing
-			if (matchers.proxy1(hostname) && upstreamProxies.p1) {
-				connectionMap[connectionId] = { type: "PROXY_1" };
-				return { upstreamProxyUrl: upstreamProxies.p1 };
+			// Record Stats
+			connectionMap[connectionId] = { type: proxyType, hostname: hostname };
+			if (host_stats && hostname) {
+				// Ensure the type exists in map (it should, but safety first)
+				if (!hostStatsMap[proxyType]) hostStatsMap[proxyType] = {};
+				if (!hostStatsMap[proxyType][hostname]) {
+					hostStatsMap[proxyType][hostname] = { req: 0, Tx: 0, Rx: 0 };
+				}
+				hostStatsMap[proxyType][hostname].req++;
 			}
-			if (matchers.proxy2(hostname) && upstreamProxies.p2) {
-				connectionMap[connectionId] = { type: "PROXY_2" };
-				return { upstreamProxyUrl: upstreamProxies.p2 };
+
+			// Return Decision
+			if (isCustomResponse) {
+				return { customResponseFunction: () => customResponseData };
 			}
 
-			// D. Default
-			connectionMap[connectionId] = { type: "DEFAULT_PROXY" };
-			return { upstreamProxyUrl: upstreamProxies.default };
+			return {
+				upstreamProxyUrl: upstreamUrl,
+				requestAuthentication: false, // Auto-handle upstream auth via URL
+			};
 		},
 	});
 
 	server.on("connectionClosed", ({ connectionId, stats: connStats }) => {
 		const connectionInfo = connectionMap[connectionId];
-		if (connectionInfo && proxy_stats) {
-			const { type } = connectionInfo;
-			if (stats[type]) {
+		if (connectionInfo) {
+			const { type, hostname } = connectionInfo;
+			if (proxy_stats && stats[type]) {
 				stats[type].request++;
 				stats[type].Tx += connStats.srcTxBytes;
 				stats[type].Rx += connStats.srcRxBytes;
 			}
+			// Update host stats with Tx/Rx on connection close
+			if (host_stats && hostname && hostStatsMap[type] && hostStatsMap[type][hostname]) {
+				hostStatsMap[type][hostname].Tx += connStats.srcTxBytes;
+				hostStatsMap[type][hostname].Rx += connStats.srcRxBytes;
+			}
 		}
 		delete connectionMap[connectionId];
 	});
 
 	try {
 		await server.listen();
+		serverRunning = true;
 		console.log(`✅ Local Proxy Started: http://127.0.0.1:${selectedPort}`);
 	} catch (err) {
 		console.error("❌ Failed to start proxy server:", err);
@@ -297,6 +335,41 @@ export async function startProxyServer({
 
 	const formatBytes = (bytes) => (bytes / 1024 / 1024).toFixed(2);
 
+	const getProxyStatsFormatted = () => {
+		const formatted = {};
+		for (const [key, val] of Object.entries(stats)) {
+			formatted[key] = {
+				req: val.request,
+				Tx: formatBytes(val.Tx) + " MB",
+				Rx: formatBytes(val.Rx) + " MB",
+			};
+		}
+		return formatted;
+	};
+
+	const getHostStatsFormatted = () => {
+		const result = {};
+		// Iterate over each proxy category
+		for (const [type, hosts] of Object.entries(hostStatsMap)) {
+			const sortedHosts = Object.entries(hosts)
+				.sort((a, b) => b[1].req - a[1].req) // Sort by request count descending
+				.reduce((acc, [host, hostData]) => {
+					acc[host] = {
+						req: hostData.req,
+						Tx: formatBytes(hostData.Tx) + " MB",
+						Rx: formatBytes(hostData.Rx) + " MB",
+					};
+					return acc;
+				}, {});
+
+			// Only include categories that have traffic
+			if (Object.keys(sortedHosts).length > 0) {
+				result[type] = sortedHosts;
+			}
+		}
+		return result;
+	};
+
 	// 7. Return Controller
 	return {
 		port: selectedPort,
@@ -318,20 +391,24 @@ export async function startProxyServer({
 		PROXY_1_IP: p1Details?.ip || null,
 		PROXY_2_IP: p2Details?.ip || null,
 
+		isServerRunning: () => serverRunning,
+
 		closeServer: async () => {
 			await server.close(true);
-			console.log("🔒 Proxy server closed.");
-		},
-		getProxyStats: () => {
-			const formatted = {};
-			for (const [key, val] of Object.entries(stats)) {
-				formatted[key] = {
-					req: val.request,
-					Tx: formatBytes(val.Tx) + " MB",
-					Rx: formatBytes(val.Rx) + " MB",
-				};
+			serverRunning = false;
+
+			// Auto console.log stats on close
+			if (proxy_stats) {
+				console.log("📊 Proxy Stats:", getProxyStatsFormatted());
+			}
+			if (host_stats) {
+				console.log("🌐 Host Stats:", getHostStatsFormatted());
 			}
-			return formatted;
+
+			console.log("🔒 Proxy server closed.");
 		},
+
+		getProxyStats: getProxyStatsFormatted,
+		getHostStats: getHostStatsFormatted,
 	};
 }