arn-browser 0.0.3 → 0.0.5

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

@@ -0,0 +1,625 @@
+import {
+	EC2Client,
+	StopInstancesCommand,
+	StartInstancesCommand,
+	DescribeInstancesCommand,
+	ReleaseAddressCommand,
+	AllocateAddressCommand,
+	AssociateAddressCommand,
+	DescribeAddressesCommand,
+	DisassociateAddressCommand,
+	CreateTagsCommand,
+} from "@aws-sdk/client-ec2";
+import { SocksProxyAgent } from "socks-proxy-agent";
+import { setTimeout as sleep } from "timers/promises";
+import https from "https";
+import http from "http";
+import { arn, query } from "arn-knexjs";
+
+// ==========================================
+// SECTION 1: CONFIGURATION & UTILITIES
+// ==========================================
+
+/**
+ * Native Node.js implementation of an HTTP GET request to replace Superagent.
+ * Supports custom agents (SOCKS/HTTP).
+ *
+ * @param {string} url - The URL to fetch.
+ * @param {object} agent - The proxy agent (optional).
+ * @param {number} timeout - Request timeout in ms.
+ * @returns {Promise<string>} - The response body string.
+ */
+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(); // Consume response data to free up memory
+				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"));
+		});
+	});
+}
+
+// ==========================================
+// SECTION 2: AWS EC2 CLIENT HELPERS
+// ==========================================
+
+/**
+ * Fetches AWS credentials from the database and initializes the EC2 Client.
+ *
+ * @param {object} params - Object containing { instance_name }.
+ * @returns {Promise<object>} - Returns { ec2Client, instanceId, elasticIpName }.
+ */
+async function fetchAwsClientAndInstanceId({ instance_name }) {
+	const { data: [data] = [], error } = await arn.single(
+		query("api_aws_proxy_account").select("*").where({ instance_name }).limit(1)
+	);
+
+	if (error || !data) {
+		console.error("Error fetching AWS details:", error || "data not found");
+		throw new Error("Failed to fetch AWS details from Supabase.");
+	}
+
+	const ec2Client = new EC2Client({
+		region: data.region,
+		credentials: {
+			accessKeyId: data.access_key,
+			secretAccessKey: data.secret_access_key,
+		},
+	});
+
+	return {
+		ec2Client,
+		instanceId: data.instance_id,
+		elasticIpName: data.instance_name, // Using instance_name as the tag for Elastic IP
+	};
+}
+
+// ==========================================
+// SECTION 3: INSTANCE STATE MANAGEMENT
+// ==========================================
+
+/**
+ * Gets the current state name of the instance (e.g., 'running', 'stopped').
+ */
+export async function getInstanceStatus({ instance_name }) {
+	const { ec2Client, instanceId } = await fetchAwsClientAndInstanceId({ instance_name });
+
+	const params = { InstanceIds: [instanceId] };
+	const data = await ec2Client.send(new DescribeInstancesCommand(params));
+	return data.Reservations[0].Instances[0].State.Name;
+}
+
+/**
+ * Gets the Public IP address currently assigned to the instance.
+ */
+export async function getPublicIpAddress({ instance_name }) {
+	const { ec2Client, instanceId } = await fetchAwsClientAndInstanceId({ instance_name });
+
+	const params = { InstanceIds: [instanceId] };
+	const data = await ec2Client.send(new DescribeInstancesCommand(params));
+	return data.Reservations[0].Instances[0].PublicIpAddress;
+}
+
+const MAX_RETRIES = 30;
+
+/**
+ * Stops the EC2 instance.
+ * Waits for pending states to resolve before attempting to stop.
+ */
+export async function manageInstanceStop({ instance_name }) {
+	const { ec2Client, instanceId } = await fetchAwsClientAndInstanceId({ instance_name });
+	const params = { InstanceIds: [instanceId] };
+
+	// 1. Check current state and wait if in transition
+	let currentState = await getInstanceStatus({ instance_name });
+	let waitingRetries = 0;
+
+	while (currentState !== "running" && currentState !== "stopped" && waitingRetries < MAX_RETRIES) {
+		console.log("Waiting for instance to be either running or stopped...");
+		await sleep(10000);
+		currentState = await getInstanceStatus({ instance_name });
+		waitingRetries++;
+	}
+
+	if (waitingRetries === MAX_RETRIES) {
+		console.log("Maximum retries reached. Instance did not reach a valid state.");
+		return;
+	}
+
+	if (currentState === "stopped") {
+		console.log("Instance already stopped...");
+		return;
+	}
+
+	// 2. Send Stop Command
+	try {
+		const data = await ec2Client.send(new StopInstancesCommand(params));
+		console.log("Instance stopping...");
+
+		// 3. Wait for confirmation
+		let stoppingRetries = 0;
+		let newState = await getInstanceStatus({ instance_name });
+		while (newState !== "stopped" && stoppingRetries < MAX_RETRIES) {
+			await sleep(10000);
+			newState = await getInstanceStatus({ instance_name });
+			stoppingRetries++;
+		}
+
+		if (newState !== "stopped") {
+			console.log("Timeout reached. Instance might not have stopped.");
+			return;
+		}
+
+		console.log("Instance stopped.");
+		return data.StoppingInstances[0].InstanceId;
+	} catch (err) {
+		console.error("Error stopping instance", err);
+		throw err;
+	}
+}
+
+/**
+ * Starts the EC2 instance.
+ * Waits for pending states to resolve before attempting to start.
+ */
+export async function manageInstanceStart({ instance_name }) {
+	const { ec2Client, instanceId } = await fetchAwsClientAndInstanceId({ instance_name });
+	const params = { InstanceIds: [instanceId] };
+
+	// 1. Check current state and wait if in transition
+	let currentState = await getInstanceStatus({ instance_name });
+	let waitingRetries = 0;
+
+	while (currentState !== "running" && currentState !== "stopped" && waitingRetries < MAX_RETRIES) {
+		console.log("Waiting for instance to be either running or stopped...");
+		await sleep(10000);
+		currentState = await getInstanceStatus({ instance_name });
+		waitingRetries++;
+	}
+
+	if (waitingRetries === MAX_RETRIES) {
+		console.log("Maximum retries reached. Instance did not reach a valid state.");
+		return;
+	}
+
+	if (currentState === "running") {
+		console.log("Instance already running...");
+		return;
+	}
+
+	// 2. Send Start Command
+	try {
+		const data = await ec2Client.send(new StartInstancesCommand(params));
+		console.log("Instance starting...");
+
+		// 3. Wait for confirmation
+		let startingRetries = 0;
+		let newState = await getInstanceStatus({ instance_name });
+		while (newState !== "running" && startingRetries < MAX_RETRIES) {
+			await sleep(10000);
+			newState = await getInstanceStatus({ instance_name });
+			startingRetries++;
+		}
+
+		if (newState !== "running") {
+			console.log("Timeout reached. Instance might not have started.");
+			return;
+		}
+
+		console.log("Instance running.");
+		return data.StartingInstances[0].InstanceId;
+	} catch (err) {
+		console.error("Error starting instance", err);
+		throw err;
+	}
+}
+
+// ==========================================
+// SECTION 4: ELASTIC IP MANAGEMENT
+// ==========================================
+
+/**
+ * Associates an existing Elastic IP or allocates a new one if none exist.
+ */
+export async function AssociateAddress({ instance_name }) {
+	const { ec2Client, instanceId, elasticIpName } = await fetchAwsClientAndInstanceId({ instance_name });
+
+	try {
+		// Fetch Elastic IPs tagged with this instance name
+		const describeAddressesData = await ec2Client.send(
+			new DescribeAddressesCommand({ Filters: [{ Name: "tag:Name", Values: [elasticIpName] }] })
+		);
+
+		// Check if already associated correctly
+		for (const address of describeAddressesData.Addresses) {
+			if (address.InstanceId === instanceId) {
+				console.log(`Elastic IP ${elasticIpName} is already associated with this instance.`);
+				return true;
+			}
+		}
+
+		// Find an unassociated IP from the pool and associate it
+		for (const address of describeAddressesData.Addresses) {
+			if (!address.InstanceId) {
+				await ec2Client.send(
+					new AssociateAddressCommand({ InstanceId: instanceId, AllocationId: address.AllocationId })
+				);
+				console.log(`Elastic IP ${elasticIpName} associated successfully with instance.`);
+				return true;
+			}
+		}
+
+		// No free IP found: Allocate new, Tag it, Associate it
+		const allocateResponse = await ec2Client.send(new AllocateAddressCommand({ Domain: "vpc" }));
+
+		await ec2Client.send(
+			new CreateTagsCommand({
+				Resources: [allocateResponse.AllocationId],
+				Tags: [{ Key: "Name", Value: elasticIpName }],
+			})
+		);
+
+		await ec2Client.send(
+			new AssociateAddressCommand({ InstanceId: instanceId, AllocationId: allocateResponse.AllocationId })
+		);
+
+		console.log(`New Elastic IP allocated, tagged '${elasticIpName}', and associated.`);
+		return true;
+	} catch (error) {
+		console.error("Error during Elastic IP association:", error);
+		return false;
+	}
+}
+
+/**
+ * Disassociates the Elastic IP from the instance.
+ */
+export async function DisassociateAddress({ instance_name }) {
+	const { ec2Client, instanceId, elasticIpName } = await fetchAwsClientAndInstanceId({ instance_name });
+
+	try {
+		const describeAddressesData = await ec2Client.send(
+			new DescribeAddressesCommand({ Filters: [{ Name: "tag:Name", Values: [elasticIpName] }] })
+		);
+
+		if (describeAddressesData.Addresses.length > 0) {
+			const address = describeAddressesData.Addresses[0];
+			// Only disassociate if it is currently attached to our instance
+			if (address.InstanceId === instanceId) {
+				await ec2Client.send(new DisassociateAddressCommand({ AssociationId: address.AssociationId }));
+				console.log(`Elastic IP ${elasticIpName} disassociated successfully.`);
+				return true;
+			}
+		}
+		console.log(`No associated Elastic IP found with name ${elasticIpName} to disassociate.`);
+		return false;
+	} catch (error) {
+		console.error("Error during disassociation", error);
+		return false;
+	}
+}
+
+/**
+ * Deletes (Releases) any Elastic IPs that are not currently attached to an instance.
+ */
+export async function DeleteUnassociatedElasticIPs({ instance_name }) {
+	const { ec2Client, elasticIpName } = await fetchAwsClientAndInstanceId({ instance_name });
+
+	try {
+		const describeAddressesData = await ec2Client.send(
+			new DescribeAddressesCommand({ Filters: [{ Name: "tag:Name", Values: [elasticIpName] }] })
+		);
+		let foundUnassociated = false;
+
+		for (const address of describeAddressesData.Addresses) {
+			if (!address.AssociationId) {
+				await ec2Client.send(new ReleaseAddressCommand({ AllocationId: address.AllocationId }));
+				console.log(`Unassociated Elastic IP ${elasticIpName} deleted successfully.`);
+				foundUnassociated = true;
+			}
+		}
+
+		if (!foundUnassociated) {
+			console.log(`No unassociated Elastic IPs found with name ${elasticIpName} to delete.`);
+		}
+
+		return true;
+	} catch (error) {
+		console.error("Error during deletion of unassociated Elastic IPs", error);
+		return false;
+	}
+}
+
+// ==========================================
+// SECTION 5: DATABASE & LOGIC
+// ==========================================
+
+/**
+ * Resets servers that haven't been updated in 25+ minutes.
+ * Stops the instance and releases IPs.
+ */
+export async function resetServersAndIp() {
+	const thirtyMinutesAgo = new Date(new Date().getTime() - 25 * 60000).toISOString();
+
+	const { data, error } = await arn.single(
+		query("api_aws_proxy_account").select("*").where({ status: 1 }).andWhere("updated_at", "<=", thirtyMinutesAgo)
+	);
+
+	if (error) {
+		console.log(error);
+		return;
+	}
+
+	for (const server of data) {
+		await DisassociateAddress({ instance_name: server.instance_name });
+
+		if (await DeleteUnassociatedElasticIPs({ instance_name: server.instance_name })) {
+			console.log("DeleteUnassociatedElasticIPs Successful");
+		} else {
+			console.log("DeleteUnassociatedElasticIPs Failed");
+		}
+
+		await manageInstanceStop({ instance_name: server.instance_name });
+
+		// Update DB status to 2 (Available/Reset)
+		const { error: updateError } = await arn.single(
+			query("api_aws_proxy_account").update({ status: 2 }).where({ instance_name: server.instance_name })
+		);
+
+		if (updateError) {
+			console.log(`Error updating status for ${server.instance_name}:`, updateError);
+		} else {
+			console.log(`Status updated to 2 for ${server.instance_name}`);
+		}
+	}
+}
+
+/**
+ * Updates the database to indicate the server is currently being used (status: 1).
+ */
+async function keepServerAlivetoDB({ instance_name }) {
+	const { error: updateError } = await arn.single(
+		query("api_aws_proxy_account")
+			.update({
+				status: 1,
+				total_used: query.raw("total_used + 1"), // Increment total_used
+			})
+			.where({ instance_name: instance_name })
+	);
+
+	if (updateError) {
+		console.log(`Error updating status for ${instance_name}:`, updateError);
+	}
+}
+
+/**
+ * Tracks usage statistics for a specific IP address in the database.
+ */
+async function updateProxyToDB({ instance_name, ip_address }) {
+	// 1. Get Account ID
+	let { data: [accountData] = [], error: accountError } = await arn.single(
+		query("api_aws_proxy_account").select("id").where({ instance_name }).limit(1)
+	);
+
+	if (accountError || !accountData) {
+		console.error(`Error fetching account for ${instance_name}:`, accountError || "accountData not found");
+		return;
+	}
+
+	if (accountData) {
+		const accountId = accountData.id;
+
+		// 2. Check for existing usage record
+		let { data: [usageData] = [], error: usageError } = await arn.single(
+			query("api_aws_proxy_usage")
+				.select("id", "total_used")
+				.where({ account_id: accountId, ip_address: ip_address })
+				.limit(1)
+		);
+
+		if (usageError) {
+			console.error(`Error checking usage for account ID ${accountId}:`, usageError);
+			return;
+		}
+
+		// 3. Insert or Update
+		if (!usageData) {
+			// Insert new record
+			const { error: insertError } = await arn.single(
+				query("api_aws_proxy_usage").insert([{ account_id: accountId, ip_address: ip_address, total_used: 1 }])
+			);
+			if (insertError) console.error(`Error inserting usage:`, insertError);
+		} else {
+			// Update existing record
+			const { error: updateError } = await arn.single(
+				query("api_aws_proxy_usage")
+					.update({
+						total_used: usageData.total_used + 1,
+						last_used_time: new Date().toISOString(),
+					})
+					.where({ id: usageData.id })
+			);
+			if (updateError) console.error(`Error updating usage:`, updateError);
+		}
+	}
+}
+
+// ==========================================
+// SECTION 6: PROXY RETRIEVAL FLOWS
+// ==========================================
+
+/**
+ * FLOW 1: Standard Active Proxy.
+ * Starts instance, cycles IPs by associating/disassociating until a working one is found.
+ */
+export async function getActiveProxy({ instance_name }) {
+	await keepServerAlivetoDB({ instance_name });
+	await manageInstanceStart({ instance_name });
+
+	const MAX_IP_RETRIES = 3;
+	for (let i = 0; i < MAX_IP_RETRIES; i++) {
+		console.log("Unique IP Check Loop: ", i + 1);
+
+		try {
+			// Cycle the IP
+			await AssociateAddress({ instance_name });
+			await DisassociateAddress({ instance_name });
+			// Note: DeleteUnassociatedElasticIPs ensures we don't pay for unused IPs,
+			// but the original logic comments it out here. Uncomment if needed.
+		} catch (err) {
+			console.error("Error managing instance state:", err);
+			continue;
+		}
+
+		console.log("Please wait 1-2 Minutes");
+		await sleep(2000);
+
+		let publicIp;
+		try {
+			publicIp = await getPublicIpAddress({ instance_name });
+			console.log("Got New IP: ", publicIp);
+		} catch (err) {
+			console.error("Error getting public IP:", err);
+			continue;
+		}
+
+		await sleep(15000); // Wait for boot
+		const proxyAlive = await isProxyAlive(publicIp, 9002);
+		await sleep(5000);
+
+		if (!proxyAlive) {
+			console.log("No Unique IP Found or Proxy Dead");
+			continue;
+		} else {
+			await updateProxyToDB({ instance_name, ip_address: publicIp });
+			return publicIp;
+		}
+	}
+
+	return null;
+}
+
+/**
+ * FLOW 2: Hard Reset Proxy.
+ * Stops the instance completely, then starts it to get a new IP.
+ */
+export async function getActiveProxyWithStartStop({ instance_name }) {
+	await keepServerAlivetoDB({ instance_name });
+	const MAX_IP_RETRIES = 3;
+
+	for (let i = 0; i < MAX_IP_RETRIES; i++) {
+		await manageInstanceStop({ instance_name });
+		await manageInstanceStart({ instance_name });
+
+		let publicIp = await getPublicIpAddress({ instance_name });
+
+		await sleep(15000); // Wait for boot
+		const proxyAlive = await isProxyAlive(publicIp, 9002);
+
+		if (!proxyAlive) {
+			console.log("No Unique IP Found or Proxy Dead");
+			continue;
+		} else {
+			await updateProxyToDB({ instance_name, ip_address: publicIp });
+			return publicIp;
+		}
+	}
+
+	return null;
+}
+
+/**
+ * FLOW 3: Conditional Proxy.
+ * Checks if IP exists; if so, refreshes it. If not, allocates new.
+ */
+export async function getActiveProxyConditional({ instance_name }) {
+	await keepServerAlivetoDB({ instance_name });
+	await manageInstanceStart({ instance_name });
+
+	const { ec2Client, instanceId } = await fetchAwsClientAndInstanceId({ instance_name });
+	const describeAddressesData = await ec2Client.send(
+		new DescribeAddressesCommand({ Filters: [{ Name: "instance-id", Values: [instanceId] }] })
+	);
+
+	if (describeAddressesData.Addresses.length > 0) {
+		console.log("Elastic IP already associated. Disassociating and deleting unassociated IPs...");
+		await DisassociateAddress({ instance_name });
+		await DeleteUnassociatedElasticIPs({ instance_name });
+	} else {
+		console.log("No Elastic IP associated. Associating a new one...");
+		await AssociateAddress({ instance_name });
+		await DeleteUnassociatedElasticIPs({ instance_name });
+	}
+
+	console.log("Please wait 1-2 minutes for changes to take effect.");
+	await sleep(2000);
+
+	let publicIp = await getPublicIpAddress({ instance_name });
+	const proxyAlive = await isProxyAlive(publicIp, 9002);
+
+	if (!proxyAlive) {
+		console.log("Proxy is not alive or no unique IP found.");
+		return null;
+	} else {
+		await updateProxyToDB({ instance_name, ip_address: publicIp });
+		return publicIp;
+	}
+}
+
+// ==========================================
+// SECTION 7: PROXY VALIDATION
+// ==========================================
+
+/**
+ * Checks if the proxy is functioning by attempting to reach an external endpoint.
+ * Uses native Node.js HTTP/HTTPS modules via 'nativeGet'.
+ *
+ * @param {string} proxyHost - IP address of the proxy.
+ * @param {number} proxyPort - Port of the proxy (usually 9002).
+ */
+export async function isProxyAlive(proxyHost, proxyPort) {
+	const agent = new SocksProxyAgent(`socks5://${proxyHost}:${proxyPort}`);
+	const maxAttempts = 60;
+
+	for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+		try {
+			// Using nativeGet instead of superagent
+			await nativeGet("https://httpbin.org/ip", agent, 5000);
+
+			console.log(`Proxy ${proxyHost} is alive!`);
+			return proxyHost;
+		} catch (error) {
+			if (attempt < maxAttempts) {
+				console.log("Proxy live check loop...", attempt);
+				await sleep(500);
+			} else {
+				console.log("Proxy is dead or not responding.", error.message);
+				return null;
+			}
+		}
+	}
+
+	return null;
+}