arn-browser 0.1.1 → 0.1.3

package/package.json

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

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

@@ -91,3 +91,38 @@ export function isProxyAlive(proxyHost: string, proxyPort: number): Promise<stri
  * @param timeout - Request timeout in ms.
  */
 export function nativeGet(url: string, agent?: any, timeout?: number): Promise<string>;
+
+/**
+ * Proxy configuration object returned by fetchAwsProxy.
+ */
+export interface ProxyConfig {
+	type: "socks5" | "http";
+	host: string;
+	port: number;
+	user: string | null;
+	pass: string | null;
+}
+
+/**
+ * Parameters for fetchAwsProxy function.
+ */
+export interface FetchAwsProxyParams {
+	instance_name: string;
+	/**
+	 * If true, uses getActiveProxyWithStartStop (hard reset).
+	 * If false, uses getActiveProxy (IP cycling).
+	 * @default true
+	 */
+	useStartStop?: boolean;
+	/**
+	 * The proxy type. Determines the port (socks5: 10001, http: 9001).
+	 * @default 'socks5'
+	 */
+	proxy_type?: "socks5" | "http";
+}
+
+/**
+ * Fetches an active AWS proxy and returns it in a standardized format.
+ * @returns The proxy configuration object or null if not found.
+ */
+export function fetchAwsProxy(params: FetchAwsProxyParams): Promise<ProxyConfig | null>;

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

@@ -623,3 +623,43 @@ export async function isProxyAlive(proxyHost, proxyPort) {
 
 	return null;
 }
+
+// ==========================================
+// SECTION 8: HIGH-LEVEL PROXY FETCH
+// ==========================================
+
+/**
+ * @typedef {Object} ProxyConfig
+ * @property {'socks5'|'http'} type - The proxy type.
+ * @property {string} host - The proxy host IP address.
+ * @property {number} port - The proxy port.
+ * @property {string|null} user - The proxy username (null if not required).
+ * @property {string|null} pass - The proxy password (null if not required).
+ */
+
+/**
+ * Fetches an active AWS proxy and returns it in a standardized format.
+ *
+ * @param {Object} params - The parameters object.
+ * @param {string} params.instance_name - The name of the EC2 instance.
+ * @param {boolean} [params.useStartStop=true] - If true, uses getActiveProxyWithStartStop (hard reset).
+ *                                               If false, uses getActiveProxy (IP cycling).
+ * @param {'socks5'|'http'} [params.proxy_type='socks5'] - The proxy type (socks5: port 10001, http: port 9001).
+ * @returns {Promise<ProxyConfig|null>} - The proxy configuration object or null if not found.
+ */
+export const fetchAwsProxy = async ({ instance_name, useStartStop = true, proxy_type = "socks5" }) => {
+	let getawsproxy;
+	if (useStartStop) {
+		getawsproxy = await getActiveProxyWithStartStop({ instance_name: instance_name });
+	} else {
+		getawsproxy = await getActiveProxy({ instance_name: instance_name });
+	}
+	if (!getawsproxy) {
+		console.log("Aws proxy not found");
+		return null;
+	}
+	/** @type {ProxyConfig} */
+	const port = proxy_type === "socks5" ? 10001 : 9001;
+	let temp_proxy = { type: proxy_type, host: getawsproxy, port: port, user: null, pass: null };
+	return temp_proxy;
+};

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, number>>;
 }
 
 /**

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

@@ -178,6 +178,7 @@ export async function startProxyServer({
 	ip2LocationKey = null,
 	debug = false,
 	proxy_stats = true,
+	host_stats = true,
 }) {
 	// 1. Matchers
 	const matchers = {
@@ -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,42 +245,61 @@ 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 };
+			if (host_stats && hostname) {
+				// Ensure the type exists in map (it should, but safety first)
+				if (!hostStatsMap[proxyType]) hostStatsMap[proxyType] = {};
+				hostStatsMap[proxyType][hostname] = (hostStatsMap[proxyType][hostname] || 0) + 1;
 			}
-			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
+			};
 		},
 	});
 
@@ -289,6 +318,7 @@ export async function startProxyServer({
 
 	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 +327,37 @@ 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] - a[1]) // Sort by count descending
+				.reduce((acc, [host, count]) => {
+					acc[host] = count;
+					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 +379,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,
 	};
 }