@mercuryo-ai/agentbrowse 0.2.50

package/dist/solver/browser-launcher.js

@@ -0,0 +1,799 @@
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { connect as connectPuppeteer } from 'puppeteer';
+import puppeteerExtra from 'puppeteer-extra';
+import StealthPlugin from 'puppeteer-extra-plugin-stealth';
+import { buildTurnstileApiShimSource, isTurnstileApiRequest } from './turnstile-challenge.js';
+const enhancedPuppeteer = puppeteerExtra;
+const solverStealthPlugin = StealthPlugin();
+// Some iframe-backed checkout flows break when this evasion runs on a connected real Chrome.
+solverStealthPlugin.enabledEvasions.delete('iframe.contentWindow');
+// We already pin the browser UA at launch time; this evasion races popup teardown on CI.
+solverStealthPlugin.enabledEvasions.delete('user-agent-override');
+enhancedPuppeteer.use(solverStealthPlugin);
+const AUTO_CDP_PORT = 0;
+const CDP_DISCOVERY_TIMEOUT_MS = 30_000;
+const CDP_DISCOVERY_INTERVAL_MS = 500;
+const BROWSER_CLOSE_TIMEOUT_MS = 1_000;
+const EXTRA_PAGE_CLOSE_TIMEOUT_MS = 250;
+const INTERCEPTED_PAGES = new WeakSet();
+const LINUX_CI_CHROME_ARGS = [
+    '--no-sandbox',
+    '--disable-setuid-sandbox',
+    '--disable-dev-shm-usage',
+];
+const MAC_CHROME_ARGS = ['--use-mock-keychain'];
+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 ?? AUTO_CDP_PORT;
+    const executablePath = resolveChromeExecutable(opts?.executablePath);
+    const chromeProcess = spawnChromeProcess(executablePath, profile, fp, cdpPort, opts?.windowSize, opts?.headless, undefined);
+    try {
+        const cdpUrl = await discoverCdpUrl({
+            requestedPort: opts?.cdpPort,
+            userDataDir: profile.userDataDir,
+            chromeProcess,
+        });
+        if (!cdpUrl) {
+            throw buildCdpDiscoveryError(chromeProcess, opts?.cdpPort, profile.userDataDir);
+        }
+        const browser = await connectToBrowser(cdpUrl, opts?.stealth);
+        let page;
+        if (opts?.url) {
+            page = await createConfiguredPage(browser, fp);
+            page = await navigateConfiguredPage(browser, page, fp, opts.url);
+        }
+        else {
+            page = await createConfiguredPage(browser, fp);
+        }
+        await closeLaunchLeftoverPages(browser, page);
+        return {
+            browser,
+            page,
+            cdpUrl,
+            pid: chromeProcess.pid,
+            profile,
+            close: async () => {
+                try {
+                    await closeBrowserWithinTimeout(browser, BROWSER_CLOSE_TIMEOUT_MS);
+                }
+                finally {
+                    terminateProcessGroup(chromeProcess.pid);
+                }
+            },
+            disconnect: async () => {
+                await browser.disconnect();
+            },
+        };
+    }
+    catch (error) {
+        terminateProcessGroup(chromeProcess.pid);
+        throw error;
+    }
+}
+async function connectToBrowser(browserWSEndpoint, stealth) {
+    if (stealth === false) {
+        return connectPuppeteer({ browserWSEndpoint });
+    }
+    return enhancedPuppeteer.connect({ browserWSEndpoint });
+}
+async function discoverCdpUrl(options) {
+    const deadline = Date.now() + CDP_DISCOVERY_TIMEOUT_MS;
+    const activePortPath = path.join(options.userDataDir, 'DevToolsActivePort');
+    while (Date.now() < deadline) {
+        if (typeof options.requestedPort === 'number') {
+            const cdpUrl = await discoverCdpUrlOnPort(options.requestedPort);
+            if (cdpUrl) {
+                return cdpUrl;
+            }
+        }
+        else {
+            const activePort = readDevToolsActivePort(activePortPath);
+            const discoveredViaActivePort = await discoverCdpUrlFromActivePort(activePort);
+            if (discoveredViaActivePort) {
+                return discoveredViaActivePort;
+            }
+        }
+        if (typeof options.chromeProcess?.exitCode === 'number' || options.chromeProcess?.signalCode) {
+            break;
+        }
+        await sleep(CDP_DISCOVERY_INTERVAL_MS);
+    }
+    return null;
+}
+async function closeBrowserWithinTimeout(browser, timeoutMs) {
+    let timeoutId;
+    await Promise.race([
+        // Prefer Browser.close so puppeteer-extra can finish target shutdown hooks
+        // before we force-kill the owned Chrome process on slow CI runners.
+        browser
+            .close()
+            .catch(() => { }),
+        new Promise((resolve) => {
+            timeoutId = setTimeout(resolve, timeoutMs);
+        }),
+    ]);
+    if (timeoutId) {
+        clearTimeout(timeoutId);
+    }
+}
+async function closeLaunchLeftoverPages(browser, activePage) {
+    const allPages = await browser.pages();
+    for (const candidate of allPages) {
+        if (candidate === activePage || !isCloseableLaunchLeftover(candidate.url())) {
+            continue;
+        }
+        await closePageWithinTimeout(candidate, EXTRA_PAGE_CLOSE_TIMEOUT_MS);
+    }
+}
+function isCloseableLaunchLeftover(url) {
+    const normalized = url.trim().toLowerCase();
+    return (normalized.length === 0 ||
+        normalized === 'about:blank' ||
+        normalized === 'chrome://newtab/' ||
+        normalized === 'chrome://new-tab-page/' ||
+        normalized === 'chrome://newtab');
+}
+async function closePageWithinTimeout(page, timeoutMs) {
+    let timeoutId;
+    await Promise.race([
+        page.close().catch(() => undefined),
+        new Promise((resolve) => {
+            timeoutId = setTimeout(resolve, timeoutMs);
+        }),
+    ]);
+    if (timeoutId) {
+        clearTimeout(timeoutId);
+    }
+}
+async function discoverCdpUrlOnPort(port) {
+    try {
+        const res = await fetch(`http://127.0.0.1:${port}/json/version`);
+        if (!res.ok) {
+            return null;
+        }
+        const json = (await res.json());
+        return json.webSocketDebuggerUrl ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+async function discoverCdpUrlFromActivePort(activePort) {
+    if (!activePort) {
+        return null;
+    }
+    const candidatePorts = new Set();
+    if (activePort.browserWSEndpoint) {
+        const wsPort = portFromBrowserWSEndpoint(activePort.browserWSEndpoint);
+        if (wsPort) {
+            candidatePorts.add(wsPort);
+        }
+    }
+    if (activePort.port > 0) {
+        candidatePorts.add(activePort.port);
+    }
+    for (const port of candidatePorts) {
+        const cdpUrl = await discoverCdpUrlOnPort(port);
+        if (cdpUrl) {
+            return cdpUrl;
+        }
+    }
+    return null;
+}
+function portFromBrowserWSEndpoint(browserWSEndpoint) {
+    try {
+        const url = new URL(browserWSEndpoint);
+        const port = Number(url.port);
+        return Number.isFinite(port) && port > 0 ? port : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readDevToolsActivePort(activePortPath) {
+    if (!existsSync(activePortPath)) {
+        return null;
+    }
+    try {
+        const raw = readFileSync(activePortPath, 'utf-8').trim();
+        if (!raw) {
+            return null;
+        }
+        const [portLine = '', wsPathLine = ''] = raw.split(/\r?\n/, 2);
+        const port = Number(portLine.trim());
+        if (!Number.isFinite(port) || port <= 0) {
+            return null;
+        }
+        const wsPath = wsPathLine.trim();
+        return {
+            port,
+            browserWSEndpoint: wsPath
+                ? wsPath.startsWith('ws://')
+                    ? wsPath
+                    : `ws://127.0.0.1:${port}${wsPath.startsWith('/') ? wsPath : `/${wsPath}`}`
+                : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function buildCdpDiscoveryError(chromeProcess, requestedPort, userDataDir) {
+    const details = [`pid ${chromeProcess.pid ?? 'unknown'}`];
+    if (typeof chromeProcess.exitCode === 'number') {
+        details.push(`exitCode ${chromeProcess.exitCode}`);
+    }
+    if (chromeProcess.signalCode) {
+        details.push(`signal ${chromeProcess.signalCode}`);
+    }
+    if (typeof requestedPort === 'number') {
+        return new Error(`Chrome launched but CDP not reachable on port ${requestedPort} within ${CDP_DISCOVERY_TIMEOUT_MS}ms (${details.join(', ')}).`);
+    }
+    return new Error(`Chrome launched but CDP not reachable via auto discovery within ${CDP_DISCOVERY_TIMEOUT_MS}ms (${details.join(', ')}). Checked ${path.join(userDataDir, 'DevToolsActivePort')}.`);
+}
+async function createConfiguredPage(browser, fp) {
+    const page = await browser.newPage();
+    await installTurnstileApiInterception(page);
+    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 installTurnstileApiInterception(page) {
+    if (INTERCEPTED_PAGES.has(page)) {
+        return;
+    }
+    await page.setRequestInterception(true);
+    page.on('request', (request) => {
+        void (async () => {
+            try {
+                if (isTurnstileApiRequest(request.url())) {
+                    await request.respond({
+                        status: 200,
+                        contentType: 'application/javascript',
+                        headers: {
+                            'access-control-allow-origin': '*',
+                            'cross-origin-resource-policy': 'cross-origin',
+                            'cache-control': 'no-store',
+                        },
+                        body: buildTurnstileApiShimSource(request.url()),
+                    });
+                    return;
+                }
+                await request.continue();
+            }
+            catch {
+                try {
+                    await request.continue();
+                }
+                catch {
+                    // Ignore navigations or already-handled requests.
+                }
+            }
+        })();
+    });
+    INTERCEPTED_PAGES.add(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}`,
+        '--remote-debugging-address=127.0.0.1',
+        `--user-data-dir=${profile.userDataDir}`,
+        `--window-size=${width},${height}`,
+        `--user-agent=${fp.userAgent}`,
+        '--disable-blink-features=AutomationControlled',
+        '--no-first-run',
+        '--no-default-browser-check',
+    ];
+    args.push(...chromeArgsForEnvironment());
+    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;
+}
+export function chromeArgsForEnvironment(platform = process.platform, env = process.env) {
+    const isLinuxCi = platform === 'linux' && (env.CI === 'true' || env.GITHUB_ACTIONS === 'true');
+    if (platform === 'darwin') {
+        return [...MAC_CHROME_ARGS];
+    }
+    return isLinuxCi ? [...LINUX_CI_CHROME_ARGS] : [];
+}
+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 sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+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 win = window;
+        const callbacksKey = '__agentbrowseTurnstileCallbacks';
+        const challengesKey = '__agentbrowseTurnstileChallenges';
+        const stateKey = '__agentbrowseTurnstileState';
+        if (!Array.isArray(win[challengesKey])) {
+            win[challengesKey] = [];
+        }
+        if (!win[callbacksKey] || typeof win[callbacksKey] !== 'object') {
+            win[callbacksKey] = {};
+        }
+        if (!win[stateKey] || typeof win[stateKey] !== 'object') {
+            win[stateKey] = { nextCallbackId: 1 };
+        }
+        let turnstileValue = win.turnstile;
+        if (turnstileValue && typeof turnstileValue === 'object') {
+            const turnstile = turnstileValue;
+            if (typeof turnstile.render === 'function' && !turnstile.__agentbrowseWrapped) {
+                const originalRender = turnstile.render.bind(turnstile);
+                turnstile.render = (container, options) => {
+                    const state = win[stateKey];
+                    const callbacks = win[callbacksKey];
+                    const challenges = win[challengesKey];
+                    const callbackId = typeof options?.callback === 'function'
+                        ? `cf-turnstile-callback-${state.nextCallbackId ?? 1}`
+                        : '';
+                    if (callbackId) {
+                        callbacks[callbackId] = options.callback;
+                        state.nextCallbackId = (state.nextCallbackId ?? 1) + 1;
+                    }
+                    const siteKey = typeof options?.sitekey === 'string'
+                        ? options.sitekey
+                        : typeof options?.siteKey === 'string'
+                            ? options.siteKey
+                            : '';
+                    if (siteKey) {
+                        challenges.push({
+                            siteKey,
+                            action: typeof options?.action === 'string' ? options.action : '',
+                            cData: typeof options?.cData === 'string' ? options.cData : '',
+                            chlPageData: typeof options?.chlPageData === 'string' ? options.chlPageData : '',
+                            callbackId,
+                            userAgent: navigator.userAgent,
+                        });
+                    }
+                    return originalRender(container, options);
+                };
+                turnstile.__agentbrowseWrapped = true;
+            }
+            else {
+                let renderValue = turnstile.render;
+                try {
+                    Object.defineProperty(turnstile, 'render', {
+                        configurable: true,
+                        enumerable: true,
+                        get: () => renderValue,
+                        set: (value) => {
+                            if (typeof value !== 'function') {
+                                renderValue = value;
+                                return;
+                            }
+                            const originalRender = value.bind(turnstile);
+                            renderValue = (container, options) => {
+                                const state = win[stateKey];
+                                const callbacks = win[callbacksKey];
+                                const challenges = win[challengesKey];
+                                const callbackId = typeof options?.callback === 'function'
+                                    ? `cf-turnstile-callback-${state.nextCallbackId ?? 1}`
+                                    : '';
+                                if (callbackId) {
+                                    callbacks[callbackId] = options.callback;
+                                    state.nextCallbackId = (state.nextCallbackId ?? 1) + 1;
+                                }
+                                const siteKey = typeof options?.sitekey === 'string'
+                                    ? options.sitekey
+                                    : typeof options?.siteKey === 'string'
+                                        ? options.siteKey
+                                        : '';
+                                if (siteKey) {
+                                    challenges.push({
+                                        siteKey,
+                                        action: typeof options?.action === 'string' ? options.action : '',
+                                        cData: typeof options?.cData === 'string' ? options.cData : '',
+                                        chlPageData: typeof options?.chlPageData === 'string' ? options.chlPageData : '',
+                                        callbackId,
+                                        userAgent: navigator.userAgent,
+                                    });
+                                }
+                                return originalRender(container, options);
+                            };
+                            turnstile.__agentbrowseWrapped = true;
+                        },
+                    });
+                }
+                catch {
+                    // Ignore non-configurable render properties.
+                }
+            }
+        }
+        try {
+            Object.defineProperty(win, 'turnstile', {
+                configurable: true,
+                enumerable: true,
+                get: () => turnstileValue,
+                set: (value) => {
+                    turnstileValue = value;
+                    if (!value || typeof value !== 'object')
+                        return;
+                    const turnstile = value;
+                    if (typeof turnstile.render !== 'function' || turnstile.__agentbrowseWrapped) {
+                        let renderValue = turnstile.render;
+                        try {
+                            Object.defineProperty(turnstile, 'render', {
+                                configurable: true,
+                                enumerable: true,
+                                get: () => renderValue,
+                                set: (nextValue) => {
+                                    if (typeof nextValue !== 'function') {
+                                        renderValue = nextValue;
+                                        return;
+                                    }
+                                    const originalRender = nextValue.bind(turnstile);
+                                    renderValue = (container, options) => {
+                                        const state = win[stateKey];
+                                        const callbacks = win[callbacksKey];
+                                        const challenges = win[challengesKey];
+                                        const callbackId = typeof options?.callback === 'function'
+                                            ? `cf-turnstile-callback-${state.nextCallbackId ?? 1}`
+                                            : '';
+                                        if (callbackId) {
+                                            callbacks[callbackId] = options.callback;
+                                            state.nextCallbackId = (state.nextCallbackId ?? 1) + 1;
+                                        }
+                                        const siteKey = typeof options?.sitekey === 'string'
+                                            ? options.sitekey
+                                            : typeof options?.siteKey === 'string'
+                                                ? options.siteKey
+                                                : '';
+                                        if (siteKey) {
+                                            challenges.push({
+                                                siteKey,
+                                                action: typeof options?.action === 'string' ? options.action : '',
+                                                cData: typeof options?.cData === 'string' ? options.cData : '',
+                                                chlPageData: typeof options?.chlPageData === 'string' ? options.chlPageData : '',
+                                                callbackId,
+                                                userAgent: navigator.userAgent,
+                                            });
+                                        }
+                                        return originalRender(container, options);
+                                    };
+                                    turnstile.__agentbrowseWrapped = true;
+                                },
+                            });
+                        }
+                        catch {
+                            // Ignore non-configurable render properties.
+                        }
+                        return;
+                    }
+                    const originalRender = turnstile.render.bind(turnstile);
+                    turnstile.render = (container, options) => {
+                        const state = win[stateKey];
+                        const callbacks = win[callbacksKey];
+                        const challenges = win[challengesKey];
+                        const callbackId = typeof options?.callback === 'function'
+                            ? `cf-turnstile-callback-${state.nextCallbackId ?? 1}`
+                            : '';
+                        if (callbackId) {
+                            callbacks[callbackId] = options.callback;
+                            state.nextCallbackId = (state.nextCallbackId ?? 1) + 1;
+                        }
+                        const siteKey = typeof options?.sitekey === 'string'
+                            ? options.sitekey
+                            : typeof options?.siteKey === 'string'
+                                ? options.siteKey
+                                : '';
+                        if (siteKey) {
+                            challenges.push({
+                                siteKey,
+                                action: typeof options?.action === 'string' ? options.action : '',
+                                cData: typeof options?.cData === 'string' ? options.cData : '',
+                                chlPageData: typeof options?.chlPageData === 'string' ? options.chlPageData : '',
+                                callbackId,
+                                userAgent: navigator.userAgent,
+                            });
+                        }
+                        return originalRender(container, options);
+                    };
+                    turnstile.__agentbrowseWrapped = true;
+                },
+            });
+        }
+        catch {
+            const fallbackTurnstile = win.turnstile;
+            if (fallbackTurnstile && typeof fallbackTurnstile === 'object') {
+                const turnstile = fallbackTurnstile;
+                if (typeof turnstile.render === 'function' && !turnstile.__agentbrowseWrapped) {
+                    const originalRender = turnstile.render.bind(turnstile);
+                    turnstile.render = (container, options) => {
+                        const state = win[stateKey];
+                        const callbacks = win[callbacksKey];
+                        const challenges = win[challengesKey];
+                        const callbackId = typeof options?.callback === 'function'
+                            ? `cf-turnstile-callback-${state.nextCallbackId ?? 1}`
+                            : '';
+                        if (callbackId) {
+                            callbacks[callbackId] = options.callback;
+                            state.nextCallbackId = (state.nextCallbackId ?? 1) + 1;
+                        }
+                        const siteKey = typeof options?.sitekey === 'string'
+                            ? options.sitekey
+                            : typeof options?.siteKey === 'string'
+                                ? options.siteKey
+                                : '';
+                        if (siteKey) {
+                            challenges.push({
+                                siteKey,
+                                action: typeof options?.action === 'string' ? options.action : '',
+                                cData: typeof options?.cData === 'string' ? options.cData : '',
+                                chlPageData: typeof options?.chlPageData === 'string' ? options.chlPageData : '',
+                                callbackId,
+                                userAgent: navigator.userAgent,
+                            });
+                        }
+                        return originalRender(container, options);
+                    };
+                    turnstile.__agentbrowseWrapped = true;
+                }
+                else if (!turnstile.__agentbrowseWrapped) {
+                    let renderValue = turnstile.render;
+                    try {
+                        Object.defineProperty(turnstile, 'render', {
+                            configurable: true,
+                            enumerable: true,
+                            get: () => renderValue,
+                            set: (value) => {
+                                if (typeof value !== 'function') {
+                                    renderValue = value;
+                                    return;
+                                }
+                                const originalRender = value.bind(turnstile);
+                                renderValue = (container, options) => {
+                                    const state = win[stateKey];
+                                    const callbacks = win[callbacksKey];
+                                    const challenges = win[challengesKey];
+                                    const callbackId = typeof options?.callback === 'function'
+                                        ? `cf-turnstile-callback-${state.nextCallbackId ?? 1}`
+                                        : '';
+                                    if (callbackId) {
+                                        callbacks[callbackId] = options.callback;
+                                        state.nextCallbackId = (state.nextCallbackId ?? 1) + 1;
+                                    }
+                                    const siteKey = typeof options?.sitekey === 'string'
+                                        ? options.sitekey
+                                        : typeof options?.siteKey === 'string'
+                                            ? options.siteKey
+                                            : '';
+                                    if (siteKey) {
+                                        challenges.push({
+                                            siteKey,
+                                            action: typeof options?.action === 'string' ? options.action : '',
+                                            cData: typeof options?.cData === 'string' ? options.cData : '',
+                                            chlPageData: typeof options?.chlPageData === 'string' ? options.chlPageData : '',
+                                            callbackId,
+                                            userAgent: navigator.userAgent,
+                                        });
+                                    }
+                                    return originalRender(container, options);
+                                };
+                                turnstile.__agentbrowseWrapped = true;
+                            },
+                        });
+                    }
+                    catch {
+                        // Ignore non-configurable render properties.
+                    }
+                }
+            }
+        }
+        const pollId = window.setInterval(() => {
+            const candidate = window.turnstile;
+            if (!candidate || typeof candidate !== 'object')
+                return;
+            const turnstile = candidate;
+            if (typeof turnstile.render !== 'function' || turnstile.__agentbrowseWrapped) {
+                return;
+            }
+            const originalRender = turnstile.render.bind(turnstile);
+            turnstile.render = (container, options) => {
+                const state = win[stateKey];
+                const callbacks = win[callbacksKey];
+                const challenges = win[challengesKey];
+                const callbackId = typeof options?.callback === 'function'
+                    ? `cf-turnstile-callback-${state.nextCallbackId ?? 1}`
+                    : '';
+                if (callbackId) {
+                    callbacks[callbackId] = options.callback;
+                    state.nextCallbackId = (state.nextCallbackId ?? 1) + 1;
+                }
+                const siteKey = typeof options?.sitekey === 'string'
+                    ? options.sitekey
+                    : typeof options?.siteKey === 'string'
+                        ? options.siteKey
+                        : '';
+                if (siteKey) {
+                    challenges.push({
+                        siteKey,
+                        action: typeof options?.action === 'string' ? options.action : '',
+                        cData: typeof options?.cData === 'string' ? options.cData : '',
+                        chlPageData: typeof options?.chlPageData === 'string' ? options.chlPageData : '',
+                        callbackId,
+                        userAgent: navigator.userAgent,
+                    });
+                }
+                return originalRender(container, options);
+            };
+            turnstile.__agentbrowseWrapped = true;
+        }, 50);
+        window.setTimeout(() => {
+            window.clearInterval(pollId);
+        }, 30_000);
+        try {
+            if (typeof WebGLRenderingContext !== 'undefined') {
+                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);
+                };
+            }
+        }
+        catch {
+            // Some environments block prototype patching; keep the turnstile hook alive.
+        }
+        try {
+            Object.defineProperty(navigator, 'hardwareConcurrency', {
+                get: () => fingerprint.hardwareConcurrency,
+            });
+        }
+        catch {
+            // Ignore non-configurable navigator fields.
+        }
+        try {
+            Object.defineProperty(navigator, 'deviceMemory', {
+                get: () => fingerprint.deviceMemory,
+            });
+        }
+        catch {
+            // Ignore non-configurable navigator fields.
+        }
+        try {
+            Object.defineProperty(screen, 'width', { get: () => fingerprint.screen.width });
+            Object.defineProperty(screen, 'height', { get: () => fingerprint.screen.height });
+            Object.defineProperty(screen, 'colorDepth', { get: () => fingerprint.screen.colorDepth });
+        }
+        catch {
+            // Ignore non-configurable screen fields.
+        }
+    }, {
+        webglVendor: fp.webglVendor,
+        webglRenderer: fp.webglRenderer,
+        hardwareConcurrency: fp.hardwareConcurrency,
+        deviceMemory: fp.deviceMemory,
+        screen: fp.screen,
+    });
+    await client.detach();
+}