@nuanu-ai/agentbrowse 0.1.0

package/dist/solver/browser-launcher.js

@@ -0,0 +1,265 @@
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import puppeteerExtra from 'puppeteer-extra';
+import StealthPlugin from 'puppeteer-extra-plugin-stealth';
+const enhancedPuppeteer = puppeteerExtra;
+enhancedPuppeteer.use(StealthPlugin());
+const DEFAULT_CDP_PORT = 9222;
+const CHROME_PATHS = [
+    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+    '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary',
+    '/Applications/Chromium.app/Contents/MacOS/Chromium',
+    '/usr/bin/google-chrome',
+    '/usr/bin/google-chrome-stable',
+    '/usr/bin/chromium-browser',
+    '/usr/bin/chromium',
+    '/snap/bin/chromium',
+];
+export async function launchSolver(profile, opts) {
+    const fp = withWindowSize(profile.fingerprint, opts?.windowSize);
+    const cdpPort = opts?.cdpPort ?? DEFAULT_CDP_PORT;
+    const executablePath = resolveChromeExecutable(opts?.executablePath);
+    const chromePid = spawnChromeProcess(executablePath, profile, fp, cdpPort, opts?.windowSize, opts?.headless, opts?.url);
+    try {
+        const cdpUrl = await discoverCdpUrl(cdpPort);
+        if (!cdpUrl) {
+            throw new Error(`Chrome launched but CDP not reachable on port ${cdpPort}`);
+        }
+        const browser = await enhancedPuppeteer.connect({ browserWSEndpoint: cdpUrl });
+        let page;
+        if (opts?.url) {
+            // Chrome was launched with the URL — reuse the existing tab.
+            const existingPages = await browser.pages();
+            page = existingPages[0] ?? (await browser.newPage());
+            await applyFingerprint(page, fp);
+            if (fp.proxy?.username && fp.proxy.password) {
+                await page.authenticate({ username: fp.proxy.username, password: fp.proxy.password });
+            }
+            // If Chrome hasn't finished loading yet, wait for it.
+            const currentUrl = page.url();
+            if (!currentUrl || currentUrl === 'about:blank' || currentUrl === 'chrome://newtab/') {
+                await page
+                    .waitForNavigation({ waitUntil: 'domcontentloaded', timeout: 15_000 })
+                    .catch(() => { });
+            }
+        }
+        else {
+            page = await createConfiguredPage(browser, fp);
+        }
+        // Close leftover blank tabs (if any).
+        const allPages = await browser.pages();
+        for (const p of allPages) {
+            if (p !== page) {
+                try {
+                    await p.close();
+                }
+                catch {
+                    /* already closed */
+                }
+            }
+        }
+        return {
+            browser,
+            page,
+            cdpUrl,
+            profile,
+            close: async () => {
+                try {
+                    await browser.disconnect();
+                }
+                finally {
+                    terminateProcessGroup(chromePid);
+                }
+            },
+            disconnect: async () => {
+                await browser.disconnect();
+            },
+        };
+    }
+    catch (error) {
+        terminateProcessGroup(chromePid);
+        throw error;
+    }
+}
+async function discoverCdpUrl(port) {
+    for (let i = 0; i < 10; i++) {
+        try {
+            const res = await fetch(`http://localhost:${port}/json/version`);
+            if (!res.ok)
+                throw new Error(`CDP endpoint returned ${res.status}`);
+            const json = (await res.json());
+            if (json.webSocketDebuggerUrl) {
+                return json.webSocketDebuggerUrl;
+            }
+        }
+        catch {
+            // Retry while Chrome is initializing.
+        }
+        await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    return null;
+}
+async function createConfiguredPage(browser, fp) {
+    const page = await browser.newPage();
+    await applyFingerprint(page, fp);
+    if (fp.proxy?.username && fp.proxy.password) {
+        await page.authenticate({
+            username: fp.proxy.username,
+            password: fp.proxy.password,
+        });
+    }
+    return page;
+}
+async function navigateConfiguredPage(browser, page, fp, url) {
+    try {
+        await page.goto(url, { waitUntil: 'domcontentloaded' });
+        return page;
+    }
+    catch (err) {
+        if (!isDetachedFrameError(err)) {
+            throw err;
+        }
+    }
+    // Chrome may recycle the initial page during startup; retry on a fresh page once.
+    try {
+        if (!page.isClosed()) {
+            await page.close({ runBeforeUnload: false });
+        }
+    }
+    catch {
+        // Ignore close failures for detached/closed pages.
+    }
+    const retryPage = await createConfiguredPage(browser, fp);
+    await retryPage.goto(url, { waitUntil: 'domcontentloaded' });
+    return retryPage;
+}
+function isDetachedFrameError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return message.toLowerCase().includes('detached frame');
+}
+function resolveChromeExecutable(explicitPath) {
+    if (explicitPath) {
+        if (!existsSync(explicitPath)) {
+            throw new Error(`Chrome executable does not exist: ${explicitPath}`);
+        }
+        return explicitPath;
+    }
+    if (process.env.CHROME_PATH && existsSync(process.env.CHROME_PATH)) {
+        return process.env.CHROME_PATH;
+    }
+    for (const chromePath of CHROME_PATHS) {
+        if (existsSync(chromePath))
+            return chromePath;
+    }
+    throw new Error(`Chrome executable not found. Set CHROME_PATH or pass executablePath explicitly. Checked: ${CHROME_PATHS.join(', ')}`);
+}
+function spawnChromeProcess(executablePath, profile, fp, cdpPort, windowSize, headless, url) {
+    mkdirSync(profile.userDataDir, { recursive: true });
+    const width = windowSize?.width ?? fp.viewport.width;
+    const height = windowSize?.height ?? fp.viewport.height;
+    const args = [
+        `--remote-debugging-port=${cdpPort}`,
+        `--user-data-dir=${profile.userDataDir}`,
+        `--window-size=${width},${height}`,
+        '--disable-blink-features=AutomationControlled',
+        '--no-first-run',
+        '--no-default-browser-check',
+    ];
+    if (headless) {
+        args.push('--headless=new');
+    }
+    if (fp.proxy?.server) {
+        args.push(`--proxy-server=${fp.proxy.server}`);
+    }
+    if (url) {
+        args.push(url);
+    }
+    const proc = spawn(executablePath, args, {
+        stdio: 'ignore',
+        detached: true,
+        env: process.env,
+        cwd: path.join(os.homedir()),
+    });
+    proc.unref();
+    if (!proc.pid) {
+        throw new Error('Failed to launch Chrome process');
+    }
+    return proc.pid;
+}
+function terminateProcessGroup(pid) {
+    try {
+        process.kill(-pid, 'SIGTERM');
+        return;
+    }
+    catch {
+        // Fall back to killing a single process.
+    }
+    try {
+        process.kill(pid, 'SIGTERM');
+    }
+    catch {
+        // Ignore already terminated process.
+    }
+}
+function withWindowSize(fingerprint, windowSize) {
+    if (!windowSize)
+        return fingerprint;
+    const width = Math.max(800, Math.floor(windowSize.width));
+    const height = Math.max(600, Math.floor(windowSize.height));
+    const viewportHeight = Math.max(500, Math.min(height - 80, height));
+    return {
+        ...fingerprint,
+        viewport: {
+            width,
+            height: viewportHeight,
+        },
+        screen: {
+            ...fingerprint.screen,
+            width,
+            height,
+        },
+    };
+}
+async function applyFingerprint(page, fp) {
+    const client = await page.createCDPSession();
+    await client.send('Network.setUserAgentOverride', {
+        userAgent: fp.userAgent,
+        platform: fp.platform,
+        acceptLanguage: fp.locale,
+    });
+    await page.setViewport({
+        width: fp.viewport.width,
+        height: fp.viewport.height,
+    });
+    await page.emulateTimezone(fp.timezone);
+    await page.evaluateOnNewDocument((fingerprint) => {
+        const getParameter = WebGLRenderingContext.prototype.getParameter;
+        WebGLRenderingContext.prototype.getParameter = function (parameter) {
+            const UNMASKED_VENDOR = 0x9245;
+            const UNMASKED_RENDERER = 0x9246;
+            if (parameter === UNMASKED_VENDOR)
+                return fingerprint.webglVendor;
+            if (parameter === UNMASKED_RENDERER)
+                return fingerprint.webglRenderer;
+            return getParameter.call(this, parameter);
+        };
+        Object.defineProperty(navigator, 'hardwareConcurrency', {
+            get: () => fingerprint.hardwareConcurrency,
+        });
+        Object.defineProperty(navigator, 'deviceMemory', {
+            get: () => fingerprint.deviceMemory,
+        });
+        Object.defineProperty(screen, 'width', { get: () => fingerprint.screen.width });
+        Object.defineProperty(screen, 'height', { get: () => fingerprint.screen.height });
+        Object.defineProperty(screen, 'colorDepth', { get: () => fingerprint.screen.colorDepth });
+    }, {
+        webglVendor: fp.webglVendor,
+        webglRenderer: fp.webglRenderer,
+        hardwareConcurrency: fp.hardwareConcurrency,
+        deviceMemory: fp.deviceMemory,
+        screen: fp.screen,
+    });
+    await client.detach();
+}

package/dist/solver/captcha-detector.d.ts

@@ -0,0 +1,22 @@
+import type { Page } from 'puppeteer';
+import type { CaptchaSolver } from './captcha-solver.js';
+import type { DetectedCaptcha } from './types.js';
+export type SolveVisibleCaptchasOptions = {
+    solveTimeoutMs?: number;
+    onProgress?: (message: string) => void;
+    skipCaptcha?: (captcha: DetectedCaptcha) => boolean;
+    onSolvedCaptcha?: (captcha: DetectedCaptcha) => void;
+    onCaptchaResult?: (result: CaptchaSolveOutcome) => void;
+};
+export type CaptchaSolveOutcome = {
+    captcha: DetectedCaptcha;
+    injected: boolean;
+    clicked: boolean;
+    verified: boolean;
+    error?: string;
+};
+export declare function detectCaptchas(page: Page): Promise<DetectedCaptcha[]>;
+export declare function solveVisibleCaptchas(page: Page, solver: CaptchaSolver): Promise<number>;
+export declare function solveVisibleCaptchasWithOptions(page: Page, solver: CaptchaSolver, opts?: SolveVisibleCaptchasOptions): Promise<CaptchaSolveOutcome[]>;
+export declare function setupCaptchaMonitor(page: Page, solver: CaptchaSolver): void;
+//# sourceMappingURL=captcha-detector.d.ts.map

package/dist/solver/captcha-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"captcha-detector.d.ts","sourceRoot":"","sources":["../../src/solver/captcha-detector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,MAAM,MAAM,2BAA2B,GAAG;IACxC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,OAAO,CAAC;IACpD,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,CAAC;IACrD,eAAe,CAAC,EAAE,CAAC,MAAM,EAAE,mBAAmB,KAAK,IAAI,CAAC;CACzD,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,eAAe,CAAC;IACzB,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAKF,wBAAsB,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAqC3E;AAED,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAG7F;AAED,wBAAsB,+BAA+B,CACnD,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,aAAa,EACrB,IAAI,CAAC,EAAE,2BAA2B,GACjC,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAmFhC;AAyUD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,aAAa,GAAG,IAAI,CA4B3E"}