arn-browser 0.0.3 → 0.0.5

package/src/human-cursor/index.d.ts

@@ -0,0 +1,154 @@
+/**
+ * TypeScript declarations for human-cursor-playwright
+ */
+
+import type { Page, Locator, Response, PageScreenshotOptions, WaitForURLOptions } from 'playwright';
+
+// ============= Tweening Functions =============
+
+export type EasingFunction = (n: number) => number;
+
+export function linear(n: number): number;
+export function easeOutQuad(n: number): number;
+export function easeInQuad(n: number): number;
+export function easeInOutQuad(n: number): number;
+export function easeOutCubic(n: number): number;
+export function easeInCubic(n: number): number;
+export function easeInOutCubic(n: number): number;
+export function easeOutQuart(n: number): number;
+export function easeInQuart(n: number): number;
+export function easeInOutQuart(n: number): number;
+export function easeOutQuint(n: number): number;
+export function easeInQuint(n: number): number;
+export function easeInOutQuint(n: number): number;
+export function easeOutSine(n: number): number;
+export function easeInSine(n: number): number;
+export function easeInOutSine(n: number): number;
+export function easeOutExpo(n: number): number;
+export function easeInExpo(n: number): number;
+export function easeInOutExpo(n: number): number;
+export function easeOutCirc(n: number): number;
+export function easeInCirc(n: number): number;
+export function easeInOutCirc(n: number): number;
+
+export const easingFunctions: Record<string, EasingFunction>;
+
+// ============= Bezier Curve =============
+
+export interface CurveOptions {
+    offsetBoundaryX?: number;
+    offsetBoundaryY?: number;
+    knotsCount?: number;
+    distortionMean?: number;
+    distortionStdDev?: number;
+    distortionFrequency?: number;
+    tweening?: EasingFunction;
+    targetPoints?: number;
+}
+
+export class HumanizeMouseTrajectory {
+    fromPoint: [number, number];
+    toPoint: [number, number];
+    points: Array<[number, number]>;
+
+    constructor(fromPoint: [number, number], toPoint: [number, number], options?: CurveOptions);
+}
+
+// ============= HumanLocator =============
+
+export interface HumanClickOptions {
+    clickCount?: number;
+    button?: 'left' | 'right' | 'middle';
+    delay?: number;
+    position?: { x: number; y: number };
+    steady?: boolean;
+    moveSpeed?: number;
+}
+
+export interface HumanFillOptions extends HumanClickOptions {
+    minDelay?: number;
+    maxDelay?: number;
+}
+
+/**
+ * Locator with human-like cursor movement
+ * All Playwright Locator methods work, with click/fill/type using human cursor
+ */
+export interface HumanLocator extends Locator {
+    click(options?: HumanClickOptions): Promise<void>;
+    dblclick(options?: HumanClickOptions): Promise<void>;
+    fill(value: string, options?: HumanFillOptions): Promise<void>;
+    type(text: string, options?: HumanFillOptions): Promise<void>;
+    hover(options?: HumanClickOptions): Promise<void>;
+    press(key: string, options?: HumanClickOptions): Promise<void>;
+
+    // Chainable methods return HumanLocator
+    filter(options: { has?: Locator; hasNot?: Locator; hasText?: string | RegExp }): HumanLocator;
+    first(): HumanLocator;
+    last(): HumanLocator;
+    nth(index: number): HumanLocator;
+    locator(selector: string): HumanLocator;
+    getByText(text: string | RegExp, options?: { exact?: boolean }): HumanLocator;
+    getByRole(role: string, options?: { name?: string | RegExp; exact?: boolean }): HumanLocator;
+    getByLabel(text: string | RegExp, options?: { exact?: boolean }): HumanLocator;
+    getByPlaceholder(text: string | RegExp, options?: { exact?: boolean }): HumanLocator;
+    getByTestId(testId: string | RegExp): HumanLocator;
+}
+
+// ============= HumanCursor Options =============
+
+export interface CreateCursorOptions {
+    /** Enable/disable human-like cursor movement (default: true) */
+    humanize?: boolean;
+    /** Maximum movement time in seconds (default: 1.5) */
+    maxTime?: number;
+    /** Minimum movement time in seconds (default: 0.5) */
+    minTime?: number;
+    /** Auto-show cursor indicator after goto (default: true) */
+    showCursor?: boolean;
+}
+
+// ============= HumanPage =============
+
+/**
+ * Page with human-like cursor movement
+ * All Playwright Page methods work, with locator methods returning HumanLocators
+ */
+export interface HumanPage extends Page {
+    // Override locator methods to return HumanLocator
+    locator(selector: string): HumanLocator;
+    getByText(text: string | RegExp, options?: { exact?: boolean }): HumanLocator;
+    getByRole(role: string, options?: { name?: string | RegExp; exact?: boolean }): HumanLocator;
+    getByLabel(text: string | RegExp, options?: { exact?: boolean }): HumanLocator;
+    getByPlaceholder(text: string | RegExp, options?: { exact?: boolean }): HumanLocator;
+    getByAltText(text: string | RegExp, options?: { exact?: boolean }): HumanLocator;
+    getByTitle(text: string | RegExp, options?: { exact?: boolean }): HumanLocator;
+    getByTestId(testId: string | RegExp): HumanLocator;
+
+    // Additional cursor utilities
+    showCursor(): Promise<void>;
+    originCoordinates: [number, number];
+    setPosition(x: number, y: number): void;
+}
+
+// ============= Main Export =============
+
+/**
+ * Create a cursor that acts as a drop-in replacement for Page
+ * All Page methods work, but locator actions (click, fill, type, hover) use human cursor
+ * 
+ * @example
+ * ```ts
+ * const cursor = createCursor(page, { showCursor: true });
+ * await cursor.goto('https://example.com');
+ * await cursor.locator('button').click(); // Uses human cursor!
+ * ```
+ */
+export function createCursor(page: Page, options?: CreateCursorOptions): HumanPage;
+
+/**
+ * @deprecated Use createCursor() instead
+ */
+export class HumanCursor {
+    constructor(page: Page, options?: CreateCursorOptions);
+}

package/src/human-cursor/index.js

@@ -0,0 +1,9 @@
+/**
+ * human-cursor-playwright
+ * Human-like cursor movements for Playwright
+ */
+
+export { HumanCursor, createCursor } from './HumanCursor.js';
+export { HumanizeMouseTrajectory, calculatePointsInCurve, bernsteinPolynomial } from './bezier.js';
+export * from './tweening.js';
+export { generateRandomCurveParameters, calculateAbsoluteOffset } from './randomizer.js';

package/src/human-cursor/randomizer.js

@@ -0,0 +1,149 @@
+/**
+ * Random curve parameter generation
+ * Ported from Python HumanCursor library
+ */
+
+import * as tweening from './tweening.js';
+
+/**
+ * Random integer between min and max (inclusive)
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
+ */
+function randInt(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+/**
+ * Randomly select from array
+ * @template T
+ * @param {T[]} arr
+ * @returns {T}
+ */
+function randomChoice(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
+}
+
+/**
+ * Weighted random selection
+ * @template T
+ * @param {T[]} choices
+ * @param {number[]} weights
+ * @returns {T}
+ */
+function weightedChoice(choices, weights) {
+    const totalWeight = weights.reduce((a, b) => a + b, 0);
+    let random = Math.random() * totalWeight;
+    for (let i = 0; i < choices.length; i++) {
+        random -= weights[i];
+        if (random <= 0) return choices[i];
+    }
+    return choices[choices.length - 1];
+}
+
+/**
+ * Calculate exact pixel offsets from relative position values
+ * @param {{ width: number, height: number }} size - Element dimensions
+ * @param {[number, number]} relativePosition - [x, y] percentages (0 to 1)
+ * @returns {[number, number]} Absolute pixel offsets
+ */
+export function calculateAbsoluteOffset(size, relativePosition) {
+    const xFinal = size.width * relativePosition[0];
+    const yFinal = size.height * relativePosition[1];
+    return [Math.floor(xFinal), Math.floor(yFinal)];
+}
+
+/**
+ * List of easing functions for random selection
+ */
+const tweenOptions = [
+    tweening.easeOutExpo,
+    tweening.easeInOutQuint,
+    tweening.easeInOutSine,
+    tweening.easeInOutQuart,
+    tweening.easeInOutExpo,
+    tweening.easeInOutCubic,
+    tweening.easeInOutCirc,
+    tweening.linear,
+    tweening.easeOutSine,
+    tweening.easeOutQuart,
+    tweening.easeOutQuint,
+    tweening.easeOutCubic,
+    tweening.easeOutCirc,
+];
+
+/**
+ * Generate random parameters for human-like curve
+ * @param {{ width: number, height: number }} viewportSize - Browser viewport size
+ * @param {[number, number]} preOrigin - Starting point
+ * @param {[number, number]} postDestination - Ending point
+ * @returns {Object} Curve parameters
+ */
+export function generateRandomCurveParameters(viewportSize, preOrigin, postDestination) {
+    const viewportWidth = viewportSize.width;
+    const viewportHeight = viewportSize.height;
+
+    const minWidth = viewportWidth * 0.15;
+    const maxWidth = viewportWidth * 0.85;
+    const minHeight = viewportHeight * 0.15;
+    const maxHeight = viewportHeight * 0.85;
+
+    const tween = randomChoice(tweenOptions);
+
+    let offsetBoundaryX = randomChoice(
+        weightedChoice(
+            [[20, 45], [45, 75], [75, 100]],
+            [0.2, 0.65, 0.15]
+        ).map(v => randInt(v, v))
+    ) || randInt(45, 75);
+
+    let offsetBoundaryY = randomChoice(
+        weightedChoice(
+            [[20, 45], [45, 75], [75, 100]],
+            [0.2, 0.65, 0.15]
+        ).map(v => randInt(v, v))
+    ) || randInt(45, 75);
+
+    let knotsCount = weightedChoice(
+        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+        [0.15, 0.36, 0.17, 0.12, 0.08, 0.04, 0.03, 0.02, 0.015, 0.005]
+    );
+
+    const distortionMean = randInt(80, 110) / 100;
+    const distortionStdDev = randInt(85, 110) / 100;
+    const distortionFrequency = randInt(25, 70) / 100;
+
+    const targetPoints = randomChoice(
+        weightedChoice(
+            [[35, 45], [45, 60], [60, 80]],
+            [0.53, 0.32, 0.15]
+        ).map(range => randInt(range[0], range[1]))
+    ) || randInt(45, 60);
+
+    // Reduce curve complexity if near viewport edges
+    const isOriginNearEdge =
+        preOrigin[0] < minWidth || preOrigin[0] > maxWidth ||
+        preOrigin[1] < minHeight || preOrigin[1] > maxHeight;
+
+    const isDestNearEdge =
+        postDestination[0] < minWidth || postDestination[0] > maxWidth ||
+        postDestination[1] < minHeight || postDestination[1] > maxHeight;
+
+    if (isOriginNearEdge || isDestNearEdge) {
+        offsetBoundaryX = 1;
+        offsetBoundaryY = 1;
+        knotsCount = 1;
+    }
+
+    return {
+        offsetBoundaryX,
+        offsetBoundaryY,
+        knotsCount,
+        distortionMean,
+        distortionStdDev,
+        distortionFrequency,
+        tween,
+        targetPoints
+    };
+}

package/src/human-cursor/tweening.js

@@ -0,0 +1,260 @@
+/**
+ * Pure JavaScript easing functions (no external dependencies)
+ * Ported from pytweening for human-like cursor movement
+ */
+
+/**
+ * Linear easing - constant speed
+ * @param {number} n - Progress (0 to 1)
+ * @returns {number}
+ */
+export function linear(n) {
+  return n;
+}
+
+/**
+ * Quadratic ease out - decelerating
+ * @param {number} n - Progress (0 to 1)
+ * @returns {number}
+ */
+export function easeOutQuad(n) {
+  return -n * (n - 2);
+}
+
+/**
+ * Quadratic ease in - accelerating
+ * @param {number} n - Progress (0 to 1)
+ * @returns {number}
+ */
+export function easeInQuad(n) {
+  return n * n;
+}
+
+/**
+ * Quadratic ease in-out
+ * @param {number} n - Progress (0 to 1)
+ * @returns {number}
+ */
+export function easeInOutQuad(n) {
+  if (n < 0.5) {
+    return 2 * n * n;
+  }
+  return -2 * n * n + 4 * n - 1;
+}
+
+/**
+ * Cubic ease out - decelerating
+ * @param {number} n - Progress (0 to 1)
+ * @returns {number}
+ */
+export function easeOutCubic(n) {
+  const n1 = n - 1;
+  return n1 * n1 * n1 + 1;
+}
+
+/**
+ * Cubic ease in - accelerating
+ * @param {number} n - Progress (0 to 1)
+ * @returns {number}
+ */
+export function easeInCubic(n) {
+  return n * n * n;
+}
+
+/**
+ * Cubic ease in-out
+ * @param {number} n - Progress (0 to 1)
+ * @returns {number}
+ */
+export function easeInOutCubic(n) {
+  if (n < 0.5) {
+    return 4 * n * n * n;
+  }
+  const p = 2 * n - 2;
+  return 0.5 * p * p * p + 1;
+}
+
+/**
+ * Quartic ease out - decelerating
+ * @param {number} n - Progress (0 to 1)
+ * @returns {number}
+ */
+export function easeOutQuart(n) {
+  const n1 = n - 1;
+  return -(n1 * n1 * n1 * n1 - 1);
+}
+
+/**
+ * Quartic ease in - accelerating
+ * @param {number} n - Progress (0 to 1)
+ * @returns {number}
+ */
+export function easeInQuart(n) {
+  return n * n * n * n;
+}
+
+/**
+ * Quartic ease in-out
+ * @param {number} n - Progress (0 to 1)
+ * @returns {number}
+ */
+export function easeInOutQuart(n) {
+  if (n < 0.5) {
+    return 8 * n * n * n * n;
+  }
+  const n1 = n - 1;
+  return -8 * n1 * n1 * n1 * n1 + 1;
+}
+
+/**
+ * Quintic ease out - decelerating
+ * @param {number} n - Progress (0 to 1)
+ * @returns {number}
+ */
+export function easeOutQuint(n) {
+  const n1 = n - 1;
+  return n1 * n1 * n1 * n1 * n1 + 1;
+}
+
+/**
+ * Quintic ease in - accelerating
+ * @param {number} n - Progress (0 to 1)
+ * @returns {number}
+ */
+export function easeInQuint(n) {
+  return n * n * n * n * n;
+}
+
+/**
+ * Quintic ease in-out
+ * @param {number} n - Progress (0 to 1)
+ * @returns {number}
+ */
+export function easeInOutQuint(n) {
+  if (n < 0.5) {
+    return 16 * n * n * n * n * n;
+  }
+  const p = 2 * n - 2;
+  return 0.5 * p * p * p * p * p + 1;
+}
+
+/**
+ * Sinusoidal ease out - decelerating
+ * @param {number} n - Progress (0 to 1)
+ * @returns {number}
+ */
+export function easeOutSine(n) {
+  return Math.sin(n * Math.PI / 2);
+}
+
+/**
+ * Sinusoidal ease in - accelerating
+ * @param {number} n - Progress (0 to 1)
+ * @returns {number}
+ */
+export function easeInSine(n) {
+  return -Math.cos(n * Math.PI / 2) + 1;
+}
+
+/**
+ * Sinusoidal ease in-out
+ * @param {number} n - Progress (0 to 1)
+ * @returns {number}
+ */
+export function easeInOutSine(n) {
+  return -0.5 * (Math.cos(Math.PI * n) - 1);
+}
+
+/**
+ * Exponential ease out - decelerating
+ * @param {number} n - Progress (0 to 1)
+ * @returns {number}
+ */
+export function easeOutExpo(n) {
+  if (n === 1) return 1;
+  return -(Math.pow(2, -10 * n)) + 1;
+}
+
+/**
+ * Exponential ease in - accelerating
+ * @param {number} n - Progress (0 to 1)
+ * @returns {number}
+ */
+export function easeInExpo(n) {
+  if (n === 0) return 0;
+  return Math.pow(2, 10 * (n - 1));
+}
+
+/**
+ * Exponential ease in-out
+ * @param {number} n - Progress (0 to 1)
+ * @returns {number}
+ */
+export function easeInOutExpo(n) {
+  if (n === 0) return 0;
+  if (n === 1) return 1;
+  if (n < 0.5) {
+    return 0.5 * Math.pow(2, 20 * n - 10);
+  }
+  return 1 - 0.5 * Math.pow(2, -20 * n + 10);
+}
+
+/**
+ * Circular ease out - decelerating
+ * @param {number} n - Progress (0 to 1)
+ * @returns {number}
+ */
+export function easeOutCirc(n) {
+  const n1 = n - 1;
+  return Math.sqrt(1 - n1 * n1);
+}
+
+/**
+ * Circular ease in - accelerating
+ * @param {number} n - Progress (0 to 1)
+ * @returns {number}
+ */
+export function easeInCirc(n) {
+  return -(Math.sqrt(1 - n * n) - 1);
+}
+
+/**
+ * Circular ease in-out
+ * @param {number} n - Progress (0 to 1)
+ * @returns {number}
+ */
+export function easeInOutCirc(n) {
+  if (n < 0.5) {
+    return -0.5 * (Math.sqrt(1 - 4 * n * n) - 1);
+  }
+  const n1 = 2 * n - 2;
+  return 0.5 * (Math.sqrt(1 - n1 * n1) + 1);
+}
+
+/**
+ * All available easing functions
+ */
+export const easingFunctions = {
+  linear,
+  easeOutQuad,
+  easeInQuad,
+  easeInOutQuad,
+  easeOutCubic,
+  easeInCubic,
+  easeInOutCubic,
+  easeOutQuart,
+  easeInQuart,
+  easeInOutQuart,
+  easeOutQuint,
+  easeInQuint,
+  easeInOutQuint,
+  easeOutSine,
+  easeInSine,
+  easeInOutSine,
+  easeOutExpo,
+  easeInExpo,
+  easeInOutExpo,
+  easeOutCirc,
+  easeInCirc,
+  easeInOutCirc
+};

package/src/index.d.ts

@@ -0,0 +1,19 @@
+// src/index.d.ts
+
+export * from "./utility/proxy-utility/custom-proxy";
+export * from "./utility/proxy-utility/proxy-chain";
+export * from "./all_routes/routeWithSuperagent";
+export {
+    type CamoufoxOptions,
+    type MultiloginOptions,
+    type LaunchOptions,
+    type BrowserController,
+    launchBrowser
+    // ProxyConfig is excluded - already exported from "./utility/proxy-utility/proxy-chain"
+} from "./utility/launchBrowser";
+export * from "./utility/proxy-utility/proxy-helper";
+
+export * from "./others/totp-generator";
+
+export * from "./utility/playwright-helper";
+//

package/src/index.js

@@ -0,0 +1,15 @@
+// Export the browser launcher (and any other exports from launchBrowser.js)
+export * from "./utility/launchBrowser.js";
+
+// Export the routing/request interception logic
+export * from "./all_routes/routeWithSuperagent.js";
+
+export * from "./utility/proxy-utility/proxy-chain.js";
+
+export * from "./utility/proxy-utility/custom-proxy.js";
+
+export * from "./utility/proxy-utility/proxy-helper.js";
+
+export * from "./others/totp-generator.js";
+
+export * from "./utility/playwright-helper.js";

package/src/others/totp-generator.d.ts

@@ -0,0 +1,15 @@
+export interface OTPResponse {
+	data: {
+		token: string;
+		time: string;
+		secondsRemaining: number;
+	} | null;
+	error: string | null;
+}
+
+export interface OTPOptions {
+	secret: string;
+	remainingSecond?: number;
+}
+
+export function generateOTP(options: OTPOptions): Promise<OTPResponse>;

package/src/others/totp-generator.js

@@ -0,0 +1,86 @@
+import speakeasy from "speakeasy";
+
+/**
+ * Helper to format a Date object as "YYYY-MM-DD HH:mm:ss" using local time.
+ * Replaces moment(unix).format("YYYY-MM-DD HH:mm:ss")
+ */
+function formatLocalTime(date) {
+	const pad = (num) => num.toString().padStart(2, "0");
+
+	const year = date.getFullYear();
+	const month = pad(date.getMonth() + 1); // Months are 0-indexed
+	const day = pad(date.getDate());
+	const hours = pad(date.getHours());
+	const minutes = pad(date.getMinutes());
+	const seconds = pad(date.getSeconds());
+
+	return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+}
+
+/**
+ * Generates a Time-based One-Time Password (TOTP) token.
+ *
+ * @param {Object} options - Configuration options.
+ * @param {string} options.secret - The secret key for generating the token.
+ * @param {number} [options.remainingSecond=10] - Minimum seconds remaining in the current window.
+ * @returns {Promise<{data: {token: string, time: string, secondsRemaining: number}|null, error: string|null}>}
+ */
+export const generateOTP = async ({ secret, remainingSecond = 10 }) => {
+	try {
+		if (!secret) {
+			throw new Error("Secret is required for OTP generation");
+		}
+
+		// Remove any spaces from the secret
+		const formattedSecret = secret.replace(/\s+/g, "");
+
+		// Get current time in seconds
+		const now = Math.floor(Date.now() / 1000);
+		const remaining = 30 - (now % 30);
+
+		if (remaining < remainingSecond) {
+			console.log(`Waiting for ${remaining} seconds to generate a new token...`);
+			// Adding 2 seconds buffer to ensure we are safely in the new window
+			await new Promise((resolve) => setTimeout(resolve, (remaining + 2) * 1000));
+		}
+
+		// Recalculate time after potentially waiting
+		const newNowSeconds = Math.floor(Date.now() / 1000);
+		const newDate = new Date(newNowSeconds * 1000);
+
+		// Generate the token
+		const token = speakeasy.totp({
+			secret: formattedSecret,
+			encoding: "base32",
+			step: 30,
+			window: 0,
+		});
+
+		const secondsRemaining = 30 - (newNowSeconds % 30);
+		const formattedTime = formatLocalTime(newDate);
+
+		// Log output
+		console.log("Current Time:", formattedTime);
+		console.log("Token:", token);
+		console.log("Seconds remaining:", secondsRemaining);
+
+		if (!token) {
+			throw new Error("Token generation returned null");
+		}
+
+		return {
+			data: {
+				token,
+				time: formattedTime,
+				secondsRemaining,
+			},
+			error: null,
+		};
+	} catch (error) {
+		console.error("Error generating token:", error.message);
+		return {
+			data: null,
+			error: error.message,
+		};
+	}
+};