arn-browser 0.0.4 → 0.0.6

package/package.json

@@ -1,16 +1,21 @@
 {
 	"name": "arn-browser",
-	"version": "0.0.4",
+	"version": "0.0.6",
 	"description": "A lightweight, browser autmation helper.",
 	"main": "src/index.js",
 	"types": "src/index.d.ts",
+	"files": [
+		"src"
+	],
 	"directories": {
 		"test": "test"
 	},
 	"dependencies": {
 		"@aws-sdk/client-ec2": "^3.946.0",
 		"@ghostery/adblocker": "^2.13.0",
+		"arn-knexjs": "^0.0.1",
 		"camoufox-js": "^0.8.4",
+		"dotenv": "^17.2.3",
 		"fingerprint-injector": "^2.1.78",
 		"https-proxy-agent": "^7.0.6",
 		"node-cache": "^5.1.2",

package/src/human-cursor/HumanCursor.js

@@ -0,0 +1,516 @@
+/**
+ * HumanCursor - Human-like cursor movements for Playwright
+ * Drop-in replacement for Page with human cursor for click/fill/type/hover
+ */
+
+import { HumanizeMouseTrajectory } from './bezier.js';
+import { generateRandomCurveParameters, calculateAbsoluteOffset } from './randomizer.js';
+
+/**
+ * Random integer between min and max (inclusive)
+ */
+function randInt(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+/**
+ * Sleep for specified milliseconds
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Creates a HumanLocator that wraps a Playwright Locator
+ * with human-like cursor movement for actions
+ */
+function createHumanLocator(cursor, locator) {
+    // Methods that need human cursor movement
+    const humanMethods = {
+        async click(options = {}) {
+            // If humanize is disabled, use native Playwright click
+            if (!cursor.config.humanize) {
+                return await locator.click(options);
+            }
+
+            await cursor._moveToLocator(locator, options);
+            const clicks = options.clickCount || 1;
+            const button = options.button || 'left';
+
+            for (let i = 0; i < clicks; i++) {
+                if (options.delay) {
+                    await cursor._page.mouse.down({ button });
+                    await sleep(options.delay);
+                    await cursor._page.mouse.up({ button });
+                } else {
+                    await cursor._page.mouse.click(
+                        cursor.originCoordinates[0],
+                        cursor.originCoordinates[1],
+                        { button }
+                    );
+                }
+                if (i < clicks - 1) {
+                    await sleep(randInt(170, 280));
+                }
+            }
+        },
+
+        async dblclick(options = {}) {
+            if (!cursor.config.humanize) {
+                return await locator.dblclick(options);
+            }
+            await cursor._moveToLocator(locator, options);
+            await cursor._page.mouse.dblclick(
+                cursor.originCoordinates[0],
+                cursor.originCoordinates[1]
+            );
+        },
+
+        async fill(value, options = {}) {
+            if (!cursor.config.humanize) {
+                return await locator.fill(value, options);
+            }
+            // Humanize: Move to element, click, then fill instantly
+            await this.click(options);
+            return await locator.fill(value, options);
+        },
+
+        async fillSequentially(value, options = {}) {
+            if (!cursor.config.humanize) {
+                return await locator.fill(value, options);
+            }
+            await this.click(options);
+            await cursor._page.keyboard.press('Control+A');
+            await sleep(randInt(50, 100));
+            // Human type with delays
+            await cursor._type(value, options);
+        },
+
+        async type(text, options = {}) {
+            if (!cursor.config.humanize) {
+                return await locator.type(text, options);
+            }
+            await this.click(options);
+            await cursor._type(text, options);
+        },
+
+        async hover(options = {}) {
+            if (!cursor.config.humanize) {
+                return await locator.hover(options);
+            }
+            await cursor._moveToLocator(locator, options);
+        },
+
+        async press(key, options = {}) {
+            if (!cursor.config.humanize) {
+                return await locator.press(key, options);
+            }
+            await this.click(options);
+            await cursor._page.keyboard.press(key);
+        },
+
+        async check(options = {}) {
+            if (!cursor.config.humanize) {
+                return await locator.check(options);
+            }
+            if (!(await locator.isChecked())) {
+                await this.click(options);
+            }
+        },
+
+        async uncheck(options = {}) {
+            if (!cursor.config.humanize) {
+                return await locator.uncheck(options);
+            }
+            if (await locator.isChecked()) {
+                await this.click(options);
+            }
+        },
+
+        async setChecked(checked, options = {}) {
+            if (!cursor.config.humanize) {
+                return await locator.setChecked(checked, options);
+            }
+            if (checked) {
+                await this.check(options);
+            } else {
+                await this.uncheck(options);
+            }
+        },
+
+        async pressSequentially(text, options = {}) {
+            if (!cursor.config.humanize) {
+                return await locator.pressSequentially(text, options);
+            }
+            await this.click(options);
+            await cursor._type(text, options);
+        },
+
+        // Chainable methods that return new HumanLocators
+        filter(options) {
+            return createHumanLocator(cursor, locator.filter(options));
+        },
+        first() {
+            return createHumanLocator(cursor, locator.first());
+        },
+        last() {
+            return createHumanLocator(cursor, locator.last());
+        },
+        nth(index) {
+            return createHumanLocator(cursor, locator.nth(index));
+        },
+        locator(selector) {
+            return createHumanLocator(cursor, locator.locator(selector));
+        },
+        getByText(text, options) {
+            return createHumanLocator(cursor, locator.getByText(text, options));
+        },
+        getByRole(role, options) {
+            return createHumanLocator(cursor, locator.getByRole(role, options));
+        },
+        getByLabel(text, options) {
+            return createHumanLocator(cursor, locator.getByLabel(text, options));
+        },
+        getByPlaceholder(text, options) {
+            return createHumanLocator(cursor, locator.getByPlaceholder(text, options));
+        },
+        getByTestId(testId) {
+            return createHumanLocator(cursor, locator.getByTestId(testId));
+        }
+    };
+
+    // Use Proxy to pass through all other methods to original locator
+    return new Proxy(locator, {
+        get(target, prop) {
+            // Human methods override
+            if (prop in humanMethods) {
+                return humanMethods[prop];
+            }
+            // Pass through to original locator
+            const value = target[prop];
+            if (typeof value === 'function') {
+                return value.bind(target);
+            }
+            return value;
+        }
+    });
+}
+
+/**
+ * Create a HumanCursor that acts as a drop-in replacement for Page
+ * All page methods work, but click/fill/type/check/hover use human cursor
+ * 
+ * @param {import('playwright').Page} page - Playwright Page object
+ * @param {Object} options - Configuration options
+ * @returns {import('playwright').Page & HumanCursorMethods}
+ */
+export function createCursor(page, options = {}) {
+    const config = {
+        humanize: options.humanize ?? true,  // Enable human cursor by default
+        maxTime: options.maxTime ?? 1.5,
+        minTime: options.minTime ?? 0.5,
+        showCursor: options.showCursor ?? true  // Show cursor by default
+    };
+
+    // Internal state
+    const cursor = {
+        _page: page,
+        originCoordinates: [0, 0],
+        config,
+
+        async _moveToLocator(locator, options = {}) {
+            await locator.scrollIntoViewIfNeeded();
+            const bounds = await locator.boundingBox();
+
+            if (!bounds) {
+                throw new Error('Element not found or not visible');
+            }
+
+            let xOffset, yOffset;
+            if (options.position) {
+                xOffset = options.position.x;
+                yOffset = options.position.y;
+            } else {
+                xOffset = bounds.width * (randInt(25, 75) / 100);
+                yOffset = bounds.height * (randInt(25, 75) / 100);
+            }
+
+            const destination = [bounds.x + xOffset, bounds.y + yOffset];
+            return await this._moveToPoint(destination, options);
+        },
+
+        async _moveToPoint(destination, options = {}) {
+            const viewport = page.viewportSize() || { width: 1280, height: 720 };
+
+            const params = generateRandomCurveParameters(
+                viewport,
+                this.originCoordinates,
+                destination
+            );
+
+            if (options.steady) {
+                params.offsetBoundaryX = 10;
+                params.offsetBoundaryY = 10;
+                params.distortionMean = 1.2;
+                params.distortionStdDev = 1.2;
+                params.distortionFrequency = 1;
+            }
+
+            const curve = new HumanizeMouseTrajectory(
+                this.originCoordinates,
+                destination,
+                {
+                    offsetBoundaryX: params.offsetBoundaryX,
+                    offsetBoundaryY: params.offsetBoundaryY,
+                    knotsCount: params.knotsCount,
+                    distortionMean: params.distortionMean,
+                    distortionStdDev: params.distortionStdDev,
+                    distortionFrequency: params.distortionFrequency,
+                    tweening: params.tween,
+                    targetPoints: params.targetPoints
+                }
+            );
+
+            const distance = Math.sqrt(
+                Math.pow(destination[0] - this.originCoordinates[0], 2) +
+                Math.pow(destination[1] - this.originCoordinates[1], 2)
+            );
+            const totalTime = Math.min(
+                config.maxTime,
+                Math.max(config.minTime, distance / 1000)
+            ) * 1000;
+            const baseDelay = totalTime / curve.points.length;
+            const speedMultiplier = options.moveSpeed || 1.0;
+
+            for (const point of curve.points) {
+                await page.mouse.move(point[0], point[1]);
+                if (baseDelay > 0) {
+                    await sleep((baseDelay / speedMultiplier) + Math.random() * 2);
+                }
+            }
+
+            this.originCoordinates = destination;
+            return destination;
+        },
+
+        async _type(text, options = {}) {
+            const minDelay = options.minDelay ?? 50;
+            const maxDelay = options.maxDelay ?? 150;
+
+            for (const char of text) {
+                await page.keyboard.type(char);
+                await sleep(randInt(minDelay, maxDelay));
+            }
+        },
+
+        async showCursor() {
+            await page.evaluate(() => {
+                if (window.__humanCursorDot) return;
+
+                let cursor;
+                function updateCursor(event) {
+                    const x = event.clientX;
+                    const y = event.clientY;
+
+                    if (!cursor) {
+                        // Create cursor container
+                        cursor = document.createElement('div');
+                        cursor.id = '__human_cursor';
+                        cursor.style.cssText = `
+                            position: fixed;
+                            pointer-events: none;
+                            z-index: 2147483647;
+                            transition: left 0.05s ease-out, top 0.05s ease-out;
+                        `;
+
+                        // Outer ring (animated)
+                        const ring = document.createElement('div');
+                        ring.style.cssText = `
+                            width: 28px;
+                            height: 28px;
+                            border: 2px solid rgba(59, 130, 246, 0.6);
+                            border-radius: 50%;
+                            box-sizing: border-box;
+                            position: absolute;
+                            top: -14px;
+                            left: -14px;
+                            animation: pulse 1.5s ease-in-out infinite;
+                        `;
+
+                        // Inner dot
+                        const dot = document.createElement('div');
+                        dot.style.cssText = `
+                            width: 10px;
+                            height: 10px;
+                            background: linear-gradient(135deg, #3b82f6, #8b5cf6);
+                            border-radius: 50%;
+                            position: absolute;
+                            top: -5px;
+                            left: -5px;
+                            box-shadow: 0 0 12px rgba(59, 130, 246, 0.8), 0 0 4px rgba(255, 255, 255, 0.9);
+                        `;
+
+                        // Click indicator
+                        const clickRing = document.createElement('div');
+                        clickRing.id = '__human_cursor_click';
+                        clickRing.style.cssText = `
+                            width: 36px;
+                            height: 36px;
+                            border: 2px solid rgba(239, 68, 68, 0.8);
+                            border-radius: 50%;
+                            box-sizing: border-box;
+                            position: absolute;
+                            top: -18px;
+                            left: -18px;
+                            opacity: 0;
+                            transform: scale(0.5);
+                            transition: opacity 0.15s, transform 0.15s;
+                        `;
+
+                        // Add pulse animation
+                        const style = document.createElement('style');
+                        style.textContent = `
+                            @keyframes pulse {
+                                0%, 100% { transform: scale(1); opacity: 0.6; }
+                                50% { transform: scale(1.2); opacity: 0.3; }
+                            }
+                        `;
+                        document.head.appendChild(style);
+
+                        cursor.appendChild(ring);
+                        cursor.appendChild(dot);
+                        cursor.appendChild(clickRing);
+                        document.body.appendChild(cursor);
+
+                        // Click effect
+                        document.addEventListener('mousedown', () => {
+                            const click = document.getElementById('__human_cursor_click');
+                            if (click) {
+                                click.style.opacity = '1';
+                                click.style.transform = 'scale(1)';
+                            }
+                        });
+                        document.addEventListener('mouseup', () => {
+                            const click = document.getElementById('__human_cursor_click');
+                            if (click) {
+                                click.style.opacity = '0';
+                                click.style.transform = 'scale(0.5)';
+                            }
+                        });
+                    }
+
+                    cursor.style.left = x + 'px';
+                    cursor.style.top = y + 'px';
+                }
+
+                document.addEventListener('mousemove', updateCursor);
+                window.__humanCursorDot = true;
+            });
+        }
+    };
+
+    // Methods that return HumanLocators
+    const locatorMethods = {
+        locator(selector) {
+            return createHumanLocator(cursor, page.locator(selector));
+        },
+        getByText(text, opts) {
+            return createHumanLocator(cursor, page.getByText(text, opts));
+        },
+        getByRole(role, opts) {
+            return createHumanLocator(cursor, page.getByRole(role, opts));
+        },
+        getByLabel(text, opts) {
+            return createHumanLocator(cursor, page.getByLabel(text, opts));
+        },
+        getByPlaceholder(text, opts) {
+            return createHumanLocator(cursor, page.getByPlaceholder(text, opts));
+        },
+        getByAltText(text, opts) {
+            return createHumanLocator(cursor, page.getByAltText(text, opts));
+        },
+        getByTitle(text, opts) {
+            return createHumanLocator(cursor, page.getByTitle(text, opts));
+        },
+        getByTestId(testId) {
+            return createHumanLocator(cursor, page.getByTestId(testId));
+        }
+    };
+
+    // Wrap goto to auto-show cursor after navigation
+    const originalGoto = page.goto.bind(page);
+    const wrappedGoto = async (...args) => {
+        const result = await originalGoto(...args);
+        if (config.showCursor) {
+            await cursor.showCursor();
+        }
+        return result;
+    };
+
+    // Use Proxy to create drop-in page replacement
+    return new Proxy(page, {
+        get(target, prop) {
+            // Override goto to auto-show cursor
+            if (prop === 'goto') {
+                return wrappedGoto;
+            }
+            // Locator methods return HumanLocators
+            if (prop in locatorMethods) {
+                return locatorMethods[prop];
+            }
+
+            // Override Page methods to use HumanLocator
+            if (['click', 'dblclick', 'fill', 'hover', 'type', 'press', 'check', 'uncheck'].includes(prop)) {
+                return async (selector, ...args) => {
+                    const humanLocator = createHumanLocator(cursor, page.locator(selector));
+                    return await humanLocator[prop](...args);
+                };
+            }
+            if (prop === 'fillSequentially') {
+                return async (selector, ...args) => {
+                    const humanLocator = createHumanLocator(cursor, page.locator(selector));
+                    return await humanLocator.fillSequentially(...args);
+                };
+            }
+            if (prop === 'pressSequentially') {
+                return async (selector, ...args) => {
+                    const humanLocator = createHumanLocator(cursor, page.locator(selector));
+                    return await humanLocator.pressSequentially(...args);
+                };
+            }
+
+            // Expose cursor utilities
+            if (prop === 'showCursor') {
+                return cursor.showCursor.bind(cursor);
+            }
+            if (prop === 'originCoordinates') {
+                return cursor.originCoordinates;
+            }
+            if (prop === 'setPosition') {
+                return (x, y) => { cursor.originCoordinates = [x, y]; };
+            }
+            // Pass through everything else to original page
+            const value = target[prop];
+            if (typeof value === 'function') {
+                return value.bind(target);
+            }
+            return value;
+        }
+    });
+}
+
+// Legacy class export for backwards compatibility
+export class HumanCursor {
+    constructor(page, options = {}) {
+        this.page = page;
+        this.originCoordinates = [0, 0];
+        this.options = {
+            maxTime: options.maxTime ?? 1.5,
+            minTime: options.minTime ?? 0.5,
+            showCursor: options.showCursor ?? true  // Show cursor by default
+        };
+
+        // Return proxy instead of class instance
+        return createCursor(page, options);
+    }
+}