arn-browser 0.0.3 → 0.0.4

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

@@ -0,0 +1,123 @@
+// ============================================================================
+// PROXY CHAIN UTILITIES (UPDATED)
+// ============================================================================
+
+export interface ProxyConfig {
+	type: "http" | "https" | "socks5" | "socks" | "socks4";
+	host: string;
+	port: number | string;
+	user?: string;
+	pass?: string;
+}
+
+/**
+ * Geo-IP details fetched for a specific proxy connection.
+ */
+export interface GeoDetails {
+	/** The Public IP address */
+	ip: string;
+	/** Country name (e.g., "United States") */
+	country: string;
+	/** City name (e.g., "New York") */
+	city: string;
+	/** Timezone ID (e.g., "America/New_York"). Returns null if lookup failed. */
+	timezoneId: string | null;
+}
+
+/**
+ * Statistics for data transfer.
+ */
+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;
+}
+
+/**
+ * Configuration options for starting the Proxy Chain Server.
+ */
+export interface ProxyServerOptions {
+	/** Configuration for the default upstream proxy */
+	DEFAULT_DATA?: ProxyConfig;
+	/** Configuration for the first specific upstream proxy */
+	PROXY_1_DATA?: ProxyConfig;
+	/** Configuration for the second specific upstream proxy */
+	PROXY_2_DATA?: ProxyConfig;
+
+	/** Hostnames (wildcards supported) to route through PROXY_1 */
+	PROXY_1_HOSTS?: string[];
+	/** Hostnames (wildcards supported) to route through PROXY_2 */
+	PROXY_2_HOSTS?: string[];
+	/** Hostnames to bypass the proxy entirely (Direct connection) */
+	NO_PROXY_HOSTS?: string[];
+
+	/** * API Key for IP2Location.io.
+	 * - If provided: Uses IP2Location (HTTPS, highly accurate).
+	 * - If omitted: Falls back to Keyless IP2Location or ip-api.com.
+	 */
+	ip2LocationKey?: string;
+
+	/** Enable verbose logging (default: false) */
+	debug?: boolean;
+	/** Track proxy usage statistics (default: true) */
+	proxy_stats?: boolean;
+}
+
+/**
+ * The controller object returned by startProxyServer.
+ */
+export interface ProxyServerController {
+	/** The local port the proxy server is listening on */
+	port: number;
+	/** The full local proxy URL (e.g., http://127.0.0.1:50001) */
+	proxyUrl: string;
+
+	// --- Detailed Information ---
+
+	/** * Full Geo-IP details for configured channels.
+	 * Returns null if the channel was not configured or the connection failed.
+	 */
+	details: {
+		default: GeoDetails | null;
+		proxy1: GeoDetails | null;
+		proxy2: GeoDetails | null;
+	};
+
+	// --- Convenience Fields for Playwright ---
+
+	/** The detected Timezone ID for the Default Proxy (e.g., "Europe/Berlin") or null */
+	DEFAULT_PROXY_TIMEZONE: string | null;
+	/** The detected Timezone ID for Proxy 1 or null */
+	PROXY_1_TIMEZONE: string | null;
+	/** The detected Timezone ID for Proxy 2 or null */
+	PROXY_2_TIMEZONE: string | null;
+
+	/** The public IP of the default upstream proxy */
+	DEFAULT_PROXY_IP: string | null;
+	/** The public IP of Proxy 1 */
+	PROXY_1_IP: string | null;
+	/** The public IP of Proxy 2 */
+	PROXY_2_IP: string | null;
+
+	/** Gracefully closes the proxy server */
+	closeServer: () => Promise<void>;
+
+	/** Returns formatted statistics for all proxy channels */
+	getProxyStats: () => Record<string, TrafficStats>;
+}
+
+/**
+ * Starts a local proxy server that routes requests to different upstream proxies.
+ * Automatically fetches IP and Timezone details for configured proxies.
+ */
+export function startProxyServer(options: ProxyServerOptions): Promise<ProxyServerController | null>;
+
+/**
+ * Fetches the public IP address and Timezone ID via a specific proxy URL.
+ * * @param proxyUrl The proxy URL string (e.g., "http://user:pass@host:port"). Pass `null` to test the Local/Direct connection.
+ * @returns A promise resolving to GeoDetails (including timezoneId) or null if unreachable.
+ */
+export function fetchPublicIP(proxyUrl: string | null): Promise<GeoDetails | null>;

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

@@ -0,0 +1,337 @@
+import ProxyChain from "proxy-chain";
+import net from "net";
+import https from "https";
+import http from "http";
+import { HttpsProxyAgent } from "https-proxy-agent";
+import { SocksProxyAgent } from "socks-proxy-agent";
+
+// ==========================================
+// SECTION 1: NETWORK HELPERS
+// ==========================================
+
+function nativeGet(url, agent = null, timeout = 5000) {
+	return new Promise((resolve, reject) => {
+		const urlObj = new URL(url);
+		const requestModule = urlObj.protocol === "https:" ? https : http;
+
+		const options = {
+			agent: agent,
+			timeout: timeout,
+			headers: { "User-Agent": "Mozilla/5.0 (Node.js Proxy Checker)" },
+		};
+
+		const req = requestModule.get(url, options, (res) => {
+			if (res.statusCode < 200 || res.statusCode >= 300) {
+				res.resume();
+				return reject(new Error(`Status Code: ${res.statusCode}`));
+			}
+			let data = "";
+			res.setEncoding("utf8");
+			res.on("data", (chunk) => {
+				data += chunk;
+			});
+			res.on("end", () => resolve(data));
+		});
+
+		req.on("error", (err) => reject(err));
+		req.on("timeout", () => {
+			req.destroy();
+			reject(new Error("Request Timed Out"));
+		});
+	});
+}
+
+const isPortAvailable = (port) => {
+	return new Promise((resolve) => {
+		const server = net.createServer();
+		server.once("error", () => resolve(false));
+		server.once("listening", () => {
+			server.close();
+			resolve(true);
+		});
+		server.listen(port);
+	});
+};
+
+const findAvailablePort = async (startPort, endPort) => {
+	for (let port = startPort; port <= endPort; port++) {
+		if (await isPortAvailable(port)) return port;
+	}
+	return null;
+};
+
+// ==========================================
+// SECTION 2: HOST MATCHERS
+// ==========================================
+
+const createHostMatcher = (hostList) => {
+	const exactMatches = new Set();
+	const regexMatches = [];
+
+	hostList.forEach((host) => {
+		if (!host) return;
+		if (host.includes("%")) {
+			const cleanPattern = host.replace(/%/g, "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+			regexMatches.push(new RegExp(cleanPattern, "i"));
+		} else {
+			exactMatches.add(host.toLowerCase());
+		}
+	});
+
+	return (hostname) => {
+		if (!hostname) return false;
+		const lowerHost = hostname.toLowerCase();
+		if (exactMatches.has(lowerHost)) return true;
+		return regexMatches.some((rx) => rx.test(lowerHost));
+	};
+};
+
+// ==========================================
+// SECTION 3: SIMPLIFIED IP FETCHING
+// ==========================================
+
+export async function fetchPublicIP(proxyUrl) {
+	const details = await fetchProxyDetails(proxyUrl);
+	return details;
+}
+
+/**
+ * LOGIC:
+ * 1. If proxyUrl is provided -> Fetch Real Data (IP + Timezone).
+ * 2. If proxyUrl is NULL/Undefined -> Return "Local" Mock immediately.
+ */
+export async function fetchProxyDetails(proxyUrl, apiKey = null) {
+	// --- AUTOMATIC LOCAL FALLBACK ---
+	if (!proxyUrl) {
+		return {
+			ip: "127.0.0.1",
+			country: "Local",
+			city: "Local",
+			timezoneId: null, // Playwright will use system time
+		};
+	}
+
+	// --- EXTERNAL LOOKUP (Only if proxy exists) ---
+	const attempts = ["IP-API", "IP2Location"];
+
+	for (const provider of attempts) {
+		try {
+			const isSocks = proxyUrl.startsWith("socks");
+			const agent = isSocks ? new SocksProxyAgent(proxyUrl) : new HttpsProxyAgent(proxyUrl);
+
+			let apiUrl;
+
+			if (provider === "IP-API") {
+				apiUrl = "http://ip-api.com/json/?fields=status,message,country,city,timezone,query";
+			} else {
+				const baseUrl = "https://api.ip2location.io/";
+				const fields = "ip,country_name,city_name,time_zone,time_zone_olson";
+				apiUrl = apiKey
+					? `${baseUrl}?key=${apiKey}&format=json&fields=${fields}`
+					: `${baseUrl}?format=json&fields=${fields}`;
+			}
+
+			const jsonStr = await nativeGet(apiUrl, agent, 6000);
+			const data = JSON.parse(jsonStr);
+
+			if (provider === "IP-API") {
+				if (data.status === "success") {
+					return {
+						ip: data.query,
+						country: data.country,
+						city: data.city,
+						timezoneId: data.timezone || null,
+					};
+				}
+			} else if (provider === "IP2Location") {
+				if (data && data.ip) {
+					const tz = data.time_zone_olson || null;
+					const isValidId = tz && !tz.startsWith("+") && !tz.startsWith("-");
+					return {
+						ip: data.ip,
+						country: data.country_name,
+						city: data.city_name,
+						timezoneId: isValidId ? tz : null,
+					};
+				}
+			}
+		} catch (err) {
+			// Silently fail to next provider
+		}
+	}
+
+	// If proxy was provided but failed to connect:
+	return null;
+}
+
+// ==========================================
+// SECTION 4: MAIN PROXY SERVER
+// ==========================================
+
+export async function startProxyServer({
+	DEFAULT_DATA,
+	PROXY_1_DATA,
+	PROXY_2_DATA,
+	PROXY_1_HOSTS = [],
+	PROXY_2_HOSTS = [],
+	NO_PROXY_HOSTS = [],
+	ip2LocationKey = null,
+	debug = false,
+	proxy_stats = true,
+}) {
+	// 1. Matchers
+	const matchers = {
+		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"]),
+	};
+
+	// 2. Port
+	const selectedPort = await findAvailablePort(50001, 50010);
+	if (!selectedPort) {
+		console.error("❌ Critical Error: No available ports.");
+		return null;
+	}
+
+	// 3. Build URLs
+	const buildURL = (data) => {
+		if (!data) return null; // Returns null if no config
+		const { type = "http", host, port, user, pass } = data;
+		const protocol = type.toLowerCase().startsWith("socks") ? "socks" : "http";
+		const auth = user && pass ? `${user}:${pass}@` : "";
+		return `${protocol}://${auth}${host}:${port}`;
+	};
+
+	const upstreamProxies = {
+		default: buildURL(DEFAULT_DATA),
+		p1: buildURL(PROXY_1_DATA),
+		p2: buildURL(PROXY_2_DATA),
+	};
+
+	// 4. Fetch Details (Simplified Logic)
+	// We pass the URL (or null). The function handles the "Local" logic.
+	const [defaultDetails, p1Details, p2Details] = await Promise.all([
+		fetchProxyDetails(upstreamProxies.default, ip2LocationKey),
+		fetchProxyDetails(upstreamProxies.p1, ip2LocationKey),
+		fetchProxyDetails(upstreamProxies.p2, ip2LocationKey),
+	]);
+
+	// Warn only if proxy was configured (URL exists) but details came back null (Connection failed)
+	if (upstreamProxies.p1 && !p1Details) console.warn("⚠️ Warning: PROXY_1 configured but unreachable.");
+	if (upstreamProxies.p2 && !p2Details) console.warn("⚠️ Warning: PROXY_2 configured but unreachable.");
+
+	// 5. Stats
+	const stats = {
+		DEFAULT_PROXY: { request: 0, Tx: 0, Rx: 0 },
+		NO_PROXY: { request: 0, Tx: 0, Rx: 0 },
+		PROXY_1: { request: 0, Tx: 0, Rx: 0 },
+		PROXY_2: { request: 0, Tx: 0, Rx: 0 },
+	};
+	const connectionMap = {};
+
+	// 6. Server
+	const server = new ProxyChain.Server({
+		port: selectedPort,
+		host: "127.0.0.1",
+		verbose: debug,
+		prepareRequestFunction: ({ hostname, connectionId }) => {
+			// A. Direct (Force NO_PROXY)
+			if (matchers.noProxy(hostname)) {
+				connectionMap[connectionId] = { type: "NO_PROXY" };
+				return { upstreamProxyUrl: null, requestAuthentication: false };
+			}
+
+			// B. IP Check Interception (ip.bablosoft.com)
+			if (hostname === "ip.bablosoft.com") {
+				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",
+					}),
+				};
+			}
+
+			// C. Routing
+			if (matchers.proxy1(hostname) && upstreamProxies.p1) {
+				connectionMap[connectionId] = { type: "PROXY_1" };
+				return { upstreamProxyUrl: upstreamProxies.p1 };
+			}
+			if (matchers.proxy2(hostname) && upstreamProxies.p2) {
+				connectionMap[connectionId] = { type: "PROXY_2" };
+				return { upstreamProxyUrl: upstreamProxies.p2 };
+			}
+
+			// D. Default
+			connectionMap[connectionId] = { type: "DEFAULT_PROXY" };
+			return { upstreamProxyUrl: upstreamProxies.default };
+		},
+	});
+
+	server.on("connectionClosed", ({ connectionId, stats: connStats }) => {
+		const connectionInfo = connectionMap[connectionId];
+		if (connectionInfo && proxy_stats) {
+			const { type } = connectionInfo;
+			if (stats[type]) {
+				stats[type].request++;
+				stats[type].Tx += connStats.srcTxBytes;
+				stats[type].Rx += connStats.srcRxBytes;
+			}
+		}
+		delete connectionMap[connectionId];
+	});
+
+	try {
+		await server.listen();
+		console.log(`✅ Local Proxy Started: http://127.0.0.1:${selectedPort}`);
+	} catch (err) {
+		console.error("❌ Failed to start proxy server:", err);
+		return null;
+	}
+
+	const formatBytes = (bytes) => (bytes / 1024 / 1024).toFixed(2);
+
+	// 7. Return Controller
+	return {
+		port: selectedPort,
+		proxyUrl: `http://127.0.0.1:${selectedPort}`,
+
+		details: {
+			default: defaultDetails,
+			proxy1: p1Details,
+			proxy2: p2Details,
+		},
+
+		// If proxy is set -> returns timezone. If proxy is NOT set (null) -> returns null.
+		// Playwright handles null nicely (uses system time).
+		DEFAULT_PROXY_TIMEZONE: defaultDetails?.timezoneId || null,
+		PROXY_1_TIMEZONE: p1Details?.timezoneId || null,
+		PROXY_2_TIMEZONE: p2Details?.timezoneId || null,
+
+		DEFAULT_PROXY_IP: defaultDetails?.ip || null,
+		PROXY_1_IP: p1Details?.ip || null,
+		PROXY_2_IP: p2Details?.ip || null,
+
+		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",
+				};
+			}
+			return formatted;
+		},
+	};
+}

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

@@ -0,0 +1,91 @@
+/**
+ * Standard Proxy Object structure used across the application.
+ */
+export interface ProxyObject {
+	/** The protocol type (e.g., 'http', 'https', 'socks5'). */
+	type: string;
+	/** The IP address or hostname. */
+	host: string;
+	/** The port number. */
+	port: number;
+	/** Authentication username (if applicable). */
+	user?: string;
+	/** Authentication password (if applicable). */
+	pass?: string;
+}
+
+/**
+ * Options for configuring the Multilogin proxy request.
+ */
+export interface MultiloginProxyOptions {
+	/** ISO country code (e.g., "us", "gb", "any"). Default: "us" */
+	country?: string;
+	/** Session behavior: "sticky" or "rotating". Default: "sticky" */
+	sessionType?: string;
+	/** Connection protocol: "http", "https", "socks5". Default: "http" */
+	protocol?: string;
+	/** Specific region/state in snake_case (optional). */
+	region?: string;
+	/** Specific city in snake_case (optional). */
+	city?: string;
+	/** IP Time-To-Live in seconds for rotating sessions. Default: 1800 */
+	IPTTL?: number;
+	/** Enable strict mode for the Multilogin API. Default: false */
+	strictMode?: boolean;
+}
+
+/**
+ * Represents a row from the 'x_accounts_proxy' database table.
+ */
+export interface XProxyRow {
+	id: string | number;
+	provider?: string;
+	total_used: number;
+	last_used_time: string;
+	status: number;
+	[key: string]: any;
+}
+
+/**
+ * State object used to manage rotating AWS proxies.
+ */
+export interface ProxyState {
+	/** Flag to prevent concurrent fetches. */
+	isFetching: boolean;
+	/** The AWS instance name (ID) associated with this proxy state. */
+	proxyInstance: string;
+	/** The current active proxy object. */
+	proxy?: ProxyObject | { host: string; port: number } | null;
+	/** Counter for how many times the current proxy has been used. */
+	proxyUsed: number;
+	[key: string]: any;
+}
+
+/**
+ * Fetches and parses a Multilogin proxy.
+ * Always requests a single proxy count.
+ * @returns The proxy object or null on failure/timeout.
+ */
+export function get_multilogin_proxy(options?: MultiloginProxyOptions): Promise<ProxyObject | null>;
+
+/**
+ * Generates a PacketStream proxy object with a random session ID.
+ * Credentials are loaded dynamically from 'browser_automation_env.js'.
+ * @returns The proxy object.
+ */
+export function get_packetstream_proxy(): Promise<ProxyObject>;
+
+/**
+ * Fetches the least recently used proxy from the 'x_accounts_proxy' database table.
+ * Automatically increments usage stats.
+ * @param options Object containing optional provider filter.
+ * @returns The database row for the proxy or null if none found.
+ */
+export function get_x_proxy(options: { provider?: string }): Promise<XProxyRow | null>;
+
+/**
+ * Triggers a background fetch for a new AWS proxy IP to rotate the current session.
+ * Mutates the provided 'proxies' state object.
+ * @param proxies The state object containing current proxy details and flags.
+ */
+export function fetchNextProxy(proxies: ProxyState): void;