arn-browser 0.0.3 → 0.0.4

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

@@ -0,0 +1,245 @@
+import { setTimeout as sleep } from "timers/promises";
+import randomstring from "randomstring";
+import fs from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+import { getMultiloginToken } from "../multilogin_token_manager.js";
+// Assuming fetchAwsProxy is in the same directory or adjust path accordingly
+import { getActiveProxyWithStartStop as fetchAwsProxy } from "./custom-proxy.js";
+
+// Global configuration cache
+let config = null;
+
+// ==========================================
+// SECTION 1: CONFIGURATION & UTILITIES
+// ==========================================
+
+/**
+ * Dynamically loads 'browser_automation_env.js' from the user's project root.
+ */
+async function loadUserConfig() {
+	if (config) return config;
+
+	try {
+		const projectRoot = process.cwd();
+		const envPath = path.join(projectRoot, "utility", "browser_automation_env.js");
+
+		if (!fs.existsSync(envPath)) {
+			throw new Error(`Could not find configuration file at: ${envPath}`);
+		}
+
+		const envUrl = pathToFileURL(envPath).href;
+		const userEnv = await import(envUrl);
+
+		// Validate required exports
+		const requiredKeys = [
+			"arn",
+			"query",
+			"PACKETSTREAM_USER",
+			"PACKETSTREAM_PASS_KEY",
+			"PACKETSTREAM_HOST",
+			"PACKETSTREAM_PORT",
+		];
+
+		const missing = requiredKeys.filter((key) => !userEnv[key]);
+
+		if (missing.length > 0) {
+			throw new Error(`[Proxy Manager] 'browser_automation_env.js' is missing exports: ${missing.join(", ")}`);
+		}
+
+		config = userEnv;
+		return config;
+	} catch (error) {
+		console.error("❌ Config Error:", error.message);
+		throw error;
+	}
+}
+
+// ==========================================
+// SECTION 2: MULTILOGIN PROXY
+// ==========================================
+
+/**
+ * Fetches and parses a Multilogin proxy using Native Fetch.
+ */
+export async function get_multilogin_proxy({
+	country = "us",
+	sessionType = "sticky",
+	protocol = "http",
+	region = "",
+	city = "",
+	IPTTL = 1800,
+	strictMode = false,
+} = {}) {
+	try {
+		// 1. Get Token
+		const token = await getMultiloginToken();
+
+		// 2. Prepare Data
+		const data = { country, sessionType, protocol, region, city, IPTTL, count: 1 };
+		Object.keys(data).forEach((k) => (data[k] === "" || data[k] === 0 || data[k] == null) && delete data[k]);
+
+		// 3. Setup Timeout
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), 20000);
+
+		try {
+			const response = await fetch("https://profile-proxy.multilogin.com/v1/proxy/connection_url", {
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${token}`,
+					"X-Strict-Mode": strictMode ? "true" : "false",
+					"Content-Type": "application/json",
+				},
+				body: JSON.stringify(data),
+				signal: controller.signal,
+			});
+
+			if (!response.ok) {
+				const errText = await response.text();
+				throw new Error(`HTTP ${response.status}: ${errText}`);
+			}
+
+			const json = await response.json();
+
+			let proxyStr = json?.data;
+			if (Array.isArray(proxyStr)) proxyStr = proxyStr[0];
+
+			if (!proxyStr || typeof proxyStr !== "string") {
+				console.error("Multilogin proxy API: Unexpected format", json);
+				return null;
+			}
+
+			// Format: host:port:user:pass
+			const parts = proxyStr.split(":");
+			if (parts.length < 4) {
+				console.error("Unexpected Multilogin proxy string:", proxyStr);
+				return null;
+			}
+
+			const [host, port, user, ...passParts] = parts;
+			const pass = passParts.join(":");
+
+			const temp_proxy = {
+				type: protocol,
+				host,
+				port: parseInt(port, 10),
+				user,
+				pass,
+			};
+
+			console.log("Multilogin Proxy:", temp_proxy);
+			return temp_proxy;
+		} finally {
+			clearTimeout(timeoutId);
+		}
+	} catch (error) {
+		console.error("Failed to get Multilogin proxy:", error.message);
+		return null;
+	}
+}
+
+// ==========================================
+// SECTION 3: PACKETSTREAM PROXY
+// ==========================================
+
+/**
+ * Generates a PacketStream proxy object with a random session ID using credentials from config.
+ */
+export async function get_packetstream_proxy() {
+	// 1. Load config dynamically
+	const { PACKETSTREAM_USER, PACKETSTREAM_PASS_KEY, PACKETSTREAM_HOST, PACKETSTREAM_PORT } = await loadUserConfig();
+
+	// 2. Generate Random Session ID
+	const proxy_session_id = randomstring.generate({
+		length: 8,
+		charset: "alphanumeric",
+		capitalization: "both",
+		readable: false,
+	});
+
+	// 3. Construct the proxy object
+	const temp_proxy = {
+		type: "http",
+		host: PACKETSTREAM_HOST,
+		port: Number(PACKETSTREAM_PORT),
+		user: PACKETSTREAM_USER,
+		pass: `${PACKETSTREAM_PASS_KEY}-${proxy_session_id}`,
+	};
+
+	console.log("PacketStream Proxy:", temp_proxy);
+	return temp_proxy;
+}
+
+// ==========================================
+// SECTION 4: DATABASE PROXY (X_ACCOUNTS)
+// ==========================================
+
+export async function get_x_proxy({ provider }) {
+	const { arn, query } = await loadUserConfig();
+
+	const { data: [proxyInstance] = [], error: getProxy_error } = await arn.single(
+		query("x_accounts_proxy")
+			.update({
+				total_used: query.raw("total_used + 1"),
+				last_used_time: new Date().toISOString(),
+			})
+			.where("id", function () {
+				let subquery = this.select("id").from("x_accounts_proxy").where("status", 1);
+
+				if (provider) {
+					subquery = subquery.where("provider", provider);
+				}
+
+				subquery = subquery
+					.andWhere(
+						query.raw("COALESCE(last_used_time, '1970-01-01T00:00:00.000Z') < ?", [
+							new Date(Date.now() - 60 * 60 * 1000).toISOString(),
+						])
+					)
+					.orderBy("total_used", "asc")
+					.limit(1);
+				return subquery;
+			})
+			.returning("*")
+	);
+
+	if (getProxy_error || !proxyInstance) {
+		console.error(getProxy_error || "No proxy instances found");
+		await sleep(30000);
+		return null;
+	}
+
+	return proxyInstance;
+}
+
+// ==========================================
+// SECTION 5: AWS PROXY ROTATION
+// ==========================================
+
+export function fetchNextProxy(proxies) {
+	if (proxies.isFetching) return;
+
+	proxies.isFetching = true;
+
+	fetchAwsProxy({
+		instance_name: proxies.proxyInstance,
+	})
+		.then((newProxyIp) => {
+			if (newProxyIp) {
+				proxies.proxy = {
+					host: newProxyIp,
+					port: 9002,
+				};
+				proxies.proxyUsed = 0;
+				console.log(`Successfully prepared next proxy: ${newProxyIp}`);
+			} else {
+				console.log("Next proxy fetch returned null");
+			}
+			proxies.isFetching = false;
+		})
+		.catch((error) => {
+			console.error(`Error fetching next proxy ${proxies.proxyInstance}:`, error.message);
+			proxies.isFetching = false;
+		});
+}

package/dist/__main__.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/__main__.js

@@ -1,127 +0,0 @@
-#!/usr/bin/env node
-import { existsSync, rmSync } from "node:fs";
-import { Command } from "commander";
-import { DefaultAddons, maybeDownloadAddons } from "./addons.js";
-import { ALLOW_GEOIP, downloadMMDB, removeMMDB } from "./locale.js";
-import { CamoufoxFetcher, INSTALL_DIR, installedVerStr } from "./pkgman.js";
-import { launchServer } from "./server.js";
-import { Camoufox } from "./sync_api.js";
-import { getAsBooleanFromENV } from "./utils.js";
-class CamoufoxUpdate extends CamoufoxFetcher {
-    currentVerStr;
-    constructor() {
-        super();
-        this.currentVerStr = null;
-        try {
-            this.currentVerStr = installedVerStr();
-        }
-        catch (error) {
-            if (error instanceof Error && error.name === "FileNotFoundError") {
-                this.currentVerStr = null;
-            }
-            else {
-                throw error;
-            }
-        }
-    }
-    static async create() {
-        const updater = new CamoufoxUpdate();
-        await updater.init();
-        return updater;
-    }
-    isUpdateNeeded() {
-        if (getAsBooleanFromENV("PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD", false)) {
-            console.log("Skipping browser download / update check due to PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD set!");
-            return false;
-        }
-        return this.currentVerStr === null || this.currentVerStr !== this.verstr;
-    }
-    async update() {
-        if (!this.isUpdateNeeded()) {
-            console.log("Camoufox binaries up to date!");
-            console.log(`Current version: v${this.currentVerStr}`);
-            return;
-        }
-        if (this.currentVerStr !== null) {
-            console.log(`Updating Camoufox binaries from v${this.currentVerStr} => v${this.verstr}`, "yellow");
-        }
-        else {
-            console.log(`Fetching Camoufox binaries...`);
-        }
-        await this.install();
-    }
-    async cleanup() {
-        if (!existsSync(INSTALL_DIR)) {
-            return false;
-        }
-        await rmSync(INSTALL_DIR, { recursive: true, force: true });
-        console.log("Camoufox binaries removed!");
-        return true;
-    }
-}
-const program = new Command();
-program.command("fetch").action(async () => {
-    const updater = await CamoufoxUpdate.create();
-    await updater.update();
-    if (ALLOW_GEOIP) {
-        downloadMMDB();
-    }
-    maybeDownloadAddons(DefaultAddons);
-});
-program.command("remove").action(async () => {
-    const updater = await CamoufoxUpdate.create();
-    if (!(await updater.cleanup())) {
-        console.log("Camoufox binaries not found!", "red");
-    }
-    removeMMDB();
-});
-program
-    .command("test")
-    .argument("[url]", "URL to open", null)
-    .action(async (url) => {
-    const browser = await Camoufox({
-        headless: false,
-        env: process.env,
-        config: { showcursor: true },
-        humanize: 0.5,
-        geoip: true,
-    });
-    const page = await browser.newPage();
-    if (url) {
-        await page.goto(url);
-    }
-    await page.pause();
-});
-program.command("server").action(async () => {
-    const server = await launchServer({});
-    console.log(`Camoufox server started at ${server.wsEndpoint()}`);
-    console.log();
-    console.log(`You can connect to it using Playwright's BrowserType.connect() method.`);
-    console.log(`To stop the server, press Ctrl+C or close this terminal.`);
-});
-program.command("path").action(() => {
-    console.log(INSTALL_DIR);
-});
-program.command("version").action(async () => {
-    try {
-        const pkgVersion = require("pkg-version");
-        console.log(`Pip package:\tv${pkgVersion("camoufox")}`);
-    }
-    catch (_error) {
-        console.log("Pip package:\tNot installed!", "red");
-    }
-    const updater = await CamoufoxUpdate.create();
-    const binVer = updater.currentVerStr;
-    if (!binVer) {
-        console.log("Camoufox:\tNot downloaded!", "red");
-        return;
-    }
-    console.log(`Camoufox:\tv${binVer} `, "green", false);
-    if (updater.isUpdateNeeded()) {
-        console.log(`(Latest supported: v${updater.verstr})`, "red");
-    }
-    else {
-        console.log("(Up to date!)", "yellow");
-    }
-});
-program.parse(process.argv);

package/dist/__version__.d.ts

@@ -1,11 +0,0 @@
-/**
- * Camoufox version constants.
- */
-export declare class CONSTRAINTS {
-    /**
-     * The minimum and maximum supported versions of the Camoufox browser.
-     */
-    static readonly MIN_VERSION: string;
-    static readonly MAX_VERSION: string;
-    static asRange(): string;
-}

package/dist/__version__.js

@@ -1,16 +0,0 @@
-/**
- * Camoufox version constants.
- */
-export class CONSTRAINTS {
-    /**
-     * The minimum and maximum supported versions of the Camoufox browser.
-     */
-    static MIN_VERSION = "beta.19";
-    static MAX_VERSION = "1";
-    static asRange() {
-        /**
-         * Returns the version range as a string.
-         */
-        return `>=${CONSTRAINTS.MIN_VERSION}, <${CONSTRAINTS.MAX_VERSION}`;
-    }
-}

package/dist/addons.d.ts

@@ -1,17 +0,0 @@
-export declare const DefaultAddons: {
-    /**
-     * Default addons to be downloaded
-     */
-    UBO: string;
-};
-export declare function confirmPaths(paths: string[]): void;
-export declare function addDefaultAddons(_addonsList: string[], _excludeList?: (keyof typeof DefaultAddons)[]): void;
-/**
- * Downloads and extracts an addon from a given URL to a specified path
- */
-export declare function downloadAndExtract(url: string, extractPath: string, name: string): Promise<void>;
-/**
- * Downloads and extracts addons from a given dictionary to a specified list
- * Skips downloading if the addon is already downloaded
- */
-export declare function maybeDownloadAddons(addons: Record<string, string>, addonsList?: string[]): void;

package/dist/addons.js

@@ -1,70 +0,0 @@
-import fs from "node:fs";
-import { join } from "node:path";
-import { InvalidAddonPath } from "./exceptions.js";
-import { getPath, unzip, webdl } from "./pkgman.js";
-import { getAsBooleanFromENV } from "./utils.js";
-export const DefaultAddons = {
-    /**
-     * Default addons to be downloaded
-     */
-    UBO: "https://addons.mozilla.org/firefox/downloads/latest/ublock-origin/latest.xpi",
-};
-export function confirmPaths(paths) {
-    /**
-     * Confirms that the addon paths are valid
-     */
-    for (const path of paths) {
-        if (!fs.existsSync(path) || !fs.lstatSync(path).isDirectory()) {
-            throw new InvalidAddonPath(path);
-        }
-        if (!fs.existsSync(join(path, "manifest.json"))) {
-            throw new InvalidAddonPath("manifest.json is missing. Addon path must be a path to an extracted addon.");
-        }
-    }
-}
-export function addDefaultAddons(_addonsList, _excludeList = []) {
-    // TODO - enable addons
-    /**
-     * Adds default addons, minus any specified in excludeList, to addonsList
-     */
-    // const addons = Object.values(DefaultAddons).filter(addon => !excludeList.includes(addon as keyof typeof DefaultAddons));
-    // maybeDownloadAddons(addons, addonsList);
-}
-/**
- * Downloads and extracts an addon from a given URL to a specified path
- */
-export async function downloadAndExtract(url, extractPath, name) {
-    const buffer = await webdl(url, `Downloading addon (${name})`, false);
-    unzip(buffer, extractPath, `Extracting addon (${name})`, false);
-}
-/**
- * Returns a path to the addon
- */
-function getAddonPath(addonName) {
-    return getPath(join("addons", addonName));
-}
-/**
- * Downloads and extracts addons from a given dictionary to a specified list
- * Skips downloading if the addon is already downloaded
- */
-export function maybeDownloadAddons(addons, addonsList = []) {
-    if (getAsBooleanFromENV("PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD", false)) {
-        console.log("Skipping addon download due to PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD set!");
-        return;
-    }
-    for (const addonName in addons) {
-        const addonPath = getAddonPath(addonName);
-        if (fs.existsSync(addonPath)) {
-            addonsList.push(addonPath);
-            continue;
-        }
-        try {
-            fs.mkdirSync(addonPath, { recursive: true });
-            downloadAndExtract(addons[addonName], addonPath, addonName);
-            addonsList.push(addonPath);
-        }
-        catch (e) {
-            console.error(`Failed to download and extract ${addonName}: ${e}`);
-        }
-    }
-}