@nuanu-ai/agentbrowse 0.1.0

package/dist/solver/captcha-detector.js

@@ -0,0 +1,463 @@
+const DEFAULT_SOLVE_TIMEOUT_MS = 90000;
+const SOLVE_TIMEOUT = Symbol('solve-timeout');
+export async function detectCaptchas(page) {
+    const pageUrl = page.url();
+    return page.evaluate((url) => {
+        const found = [];
+        const recaptchaEl = document.querySelector('.g-recaptcha[data-sitekey], div[data-sitekey]:not([data-hcaptcha-widget-id])');
+        if (recaptchaEl) {
+            const key = recaptchaEl.getAttribute('data-sitekey');
+            if (key)
+                found.push({ type: 'recaptcha-v2', siteKey: key, pageUrl: url });
+        }
+        const recaptchaIframe = document.querySelector('iframe[src*="recaptcha/api2"], iframe[src*="recaptcha/enterprise"]');
+        if (recaptchaIframe && found.length === 0) {
+            const match = recaptchaIframe.src.match(/[?&]k=([^&]+)/);
+            if (match?.[1])
+                found.push({ type: 'recaptcha-v2', siteKey: match[1], pageUrl: url });
+        }
+        const hcaptchaEl = document.querySelector('.h-captcha[data-sitekey], div[data-hcaptcha-widget-id][data-sitekey]');
+        if (hcaptchaEl) {
+            const key = hcaptchaEl.getAttribute('data-sitekey');
+            if (key)
+                found.push({ type: 'hcaptcha', siteKey: key, pageUrl: url });
+        }
+        const turnstileEl = document.querySelector('.cf-turnstile[data-sitekey]');
+        if (turnstileEl) {
+            const key = turnstileEl.getAttribute('data-sitekey');
+            if (key)
+                found.push({ type: 'turnstile', siteKey: key, pageUrl: url });
+        }
+        return found;
+    }, pageUrl);
+}
+export async function solveVisibleCaptchas(page, solver) {
+    const outcomes = await solveVisibleCaptchasWithOptions(page, solver, undefined);
+    return outcomes.filter((outcome) => outcome.injected).length;
+}
+export async function solveVisibleCaptchasWithOptions(page, solver, opts) {
+    const captchas = await detectCaptchas(page);
+    const outcomes = [];
+    const timeoutMs = opts?.solveTimeoutMs ?? DEFAULT_SOLVE_TIMEOUT_MS;
+    for (const captcha of captchas) {
+        if (opts?.skipCaptcha?.(captcha)) {
+            continue;
+        }
+        opts?.onProgress?.(`[captcha] detected ${captcha.type} on ${captcha.pageUrl}, sending to solver (timeout ${Math.ceil(timeoutMs / 1000)}s)`);
+        try {
+            const maybeToken = await Promise.race([
+                solver.solve(captcha.type, captcha.siteKey, captcha.pageUrl),
+                sleep(timeoutMs).then(() => SOLVE_TIMEOUT),
+            ]);
+            if (maybeToken === SOLVE_TIMEOUT) {
+                opts?.onProgress?.(`[captcha] solver timed out for ${captcha.type}`);
+                const timeoutOutcome = {
+                    captcha,
+                    injected: false,
+                    clicked: false,
+                    verified: false,
+                    error: 'solver-timeout',
+                };
+                outcomes.push(timeoutOutcome);
+                opts?.onCaptchaResult?.(timeoutOutcome);
+                continue;
+            }
+            const token = maybeToken;
+            await injectCaptchaToken(page, captcha, token);
+            let verified = await verifyCaptchaResolved(page, captcha);
+            let clicked = false;
+            // Click only as last resort — it triggers a new Google challenge flow,
+            // which ignores the injected token. Token + callback is the primary path.
+            if (!verified) {
+                clicked = await bestEffortClickCaptchaCheckbox(page, captcha, opts?.onProgress);
+                if (clicked) {
+                    verified = await verifyCaptchaResolved(page, captcha);
+                }
+            }
+            const outcome = {
+                captcha,
+                injected: true,
+                clicked,
+                verified,
+            };
+            outcomes.push(outcome);
+            opts?.onCaptchaResult?.(outcome);
+            if (verified) {
+                opts?.onSolvedCaptcha?.(captcha);
+                opts?.onProgress?.(`[captcha] solved ${captcha.type}, token injected${clicked ? ' + click' : ''}, verified`);
+            }
+            else {
+                opts?.onProgress?.(`[captcha] solved ${captcha.type}, token injected${clicked ? ' + click' : ''}, unresolved`);
+            }
+        }
+        catch (error) {
+            const reason = formatSolveError(error);
+            opts?.onProgress?.(`[captcha] solver failed for ${captcha.type}: ${reason}`);
+            const failOutcome = {
+                captcha,
+                injected: false,
+                clicked: false,
+                verified: false,
+                error: 'solver-failed',
+            };
+            outcomes.push(failOutcome);
+            opts?.onCaptchaResult?.(failOutcome);
+            // Continue with remaining captcha widgets.
+        }
+    }
+    return outcomes;
+}
+async function injectCaptchaToken(page, captcha, token) {
+    await page.evaluate((info) => {
+        if (info.type === 'recaptcha-v2') {
+            const selectors = [
+                '#g-recaptcha-response',
+                "textarea[name='g-recaptcha-response']",
+                "textarea[id*='g-recaptcha-response']",
+                "input[name='g-recaptcha-response']",
+            ];
+            for (const selector of selectors) {
+                const nodes = document.querySelectorAll(selector);
+                for (const node of Array.from(nodes)) {
+                    node.value = info.token;
+                    node.dispatchEvent(new Event('input', { bubbles: true }));
+                    node.dispatchEvent(new Event('change', { bubbles: true }));
+                }
+            }
+            // Invoke reCAPTCHA success callback
+            let callbackInvoked = false;
+            // Method 1: data-callback attribute (implicit rendering)
+            const el = document.querySelector('.g-recaptcha[data-callback], div[data-sitekey][data-callback]');
+            const callbackName = el?.getAttribute('data-callback');
+            if (callbackName) {
+                const cb = window[callbackName];
+                if (typeof cb === 'function') {
+                    cb(info.token);
+                    callbackInvoked = true;
+                }
+            }
+            // Method 2: ___grecaptcha_cfg.clients (explicit rendering / no data-callback)
+            if (!callbackInvoked) {
+                /* eslint-disable -- plain JS in browser evaluate context, no TS helpers available */
+                const win = window;
+                const cfg = win.___grecaptcha_cfg;
+                if (cfg && cfg.clients) {
+                    const queue = [];
+                    let found = null;
+                    for (const client of Object.values(cfg.clients)) {
+                        queue.push([client, 0]);
+                    }
+                    while (queue.length > 0 && !found) {
+                        const pair = queue.shift();
+                        const obj = pair[0];
+                        const depth = pair[1];
+                        if (depth > 5 || !obj || typeof obj !== 'object')
+                            continue;
+                        if (typeof obj.callback === 'function') {
+                            found = obj.callback;
+                            break;
+                        }
+                        for (const val of Object.values(obj)) {
+                            if (typeof val === 'object' && val !== null) {
+                                queue.push([val, depth + 1]);
+                            }
+                        }
+                    }
+                    if (found)
+                        found(info.token);
+                }
+                /* eslint-enable */
+            }
+            const submitBtn = document.querySelector("button[type='submit'], input[type='submit']");
+            if (submitBtn)
+                submitBtn.removeAttribute('disabled');
+        }
+        else if (info.type === 'hcaptcha') {
+            const selectors = [
+                "textarea[name='h-captcha-response']",
+                "textarea[id*='h-captcha-response']",
+                "textarea[name*='hcaptcha-response']",
+                "textarea[id*='hcaptcha-response']",
+                "input[name='h-captcha-response']",
+                "input[name*='hcaptcha-response']",
+            ];
+            for (const selector of selectors) {
+                const nodes = document.querySelectorAll(selector);
+                for (const node of Array.from(nodes)) {
+                    node.value = info.token;
+                    node.dispatchEvent(new Event('input', { bubbles: true }));
+                    node.dispatchEvent(new Event('change', { bubbles: true }));
+                }
+            }
+        }
+        else if (info.type === 'turnstile') {
+            const selectors = [
+                "input[name='cf-turnstile-response']",
+                "textarea[name='cf-turnstile-response']",
+                "[id*='turnstile-response']",
+            ];
+            for (const selector of selectors) {
+                const nodes = document.querySelectorAll(selector);
+                for (const node of Array.from(nodes)) {
+                    node.value = info.token;
+                    node.dispatchEvent(new Event('input', { bubbles: true }));
+                    node.dispatchEvent(new Event('change', { bubbles: true }));
+                }
+            }
+        }
+    }, { type: captcha.type, token });
+}
+function recaptchaAnchorFrames(page, siteKey) {
+    const all = page.frames().filter((frame) => frame.url().includes('/recaptcha/api2/anchor'));
+    const keyed = all.filter((frame) => {
+        try {
+            return new URL(frame.url()).searchParams.get('k') === siteKey;
+        }
+        catch {
+            return false;
+        }
+    });
+    return keyed.length > 0 ? keyed : all;
+}
+async function bestEffortClickCaptchaCheckbox(page, captcha, onProgress) {
+    if (captcha.type !== 'recaptcha-v2') {
+        return false;
+    }
+    const topology = await inspectRecaptchaTopology(page, captcha.siteKey);
+    if (topology.anchorCount === 0) {
+        onProgress?.('[captcha] best-effort click skipped: no anchor frames found');
+        return false;
+    }
+    if (topology.hasMultipleSiteKeys || topology.anchorCount > 1) {
+        onProgress?.(`[captcha] recaptcha topology: ${topology.anchorCount} anchor(s), ${topology.hasMultipleSiteKeys ? 'multiple' : 'single'} siteKey(s) — proceeding with targeted click`);
+    }
+    if (await isVisibleRecaptchaChallenge(page, captcha.siteKey)) {
+        onProgress?.('[captcha] best-effort click skipped: recaptcha image challenge already visible');
+        return false;
+    }
+    const frames = recaptchaAnchorFrames(page, captcha.siteKey);
+    for (const frame of frames) {
+        try {
+            const state = await frame.evaluate(() => {
+                const anchor = document.querySelector('#recaptcha-anchor');
+                if (!anchor) {
+                    return { present: false, checked: false };
+                }
+                return {
+                    present: true,
+                    checked: anchor.getAttribute('aria-checked') === 'true',
+                };
+            });
+            if (!state.present || state.checked) {
+                continue;
+            }
+            const anchor = await frame.$('#recaptcha-anchor');
+            if (!anchor) {
+                continue;
+            }
+            await anchor.click({ delay: 50 });
+            await anchor.dispose();
+            onProgress?.('[captcha] best-effort click: recaptcha checkbox');
+            await sleep(700);
+            return true;
+        }
+        catch {
+            // Continue with other matching frames.
+        }
+    }
+    return false;
+}
+async function inspectRecaptchaTopology(page, siteKey) {
+    try {
+        return await page.evaluate((key) => {
+            const anchors = Array.from(document.querySelectorAll('iframe[src*="recaptcha/api2/anchor"]'));
+            const siteKeys = new Set();
+            let anchorCount = 0;
+            for (const anchor of anchors) {
+                try {
+                    const k = new URL(anchor.src).searchParams.get('k');
+                    if (k)
+                        siteKeys.add(k);
+                    if (k === key)
+                        anchorCount += 1;
+                }
+                catch {
+                    // ignore malformed URL
+                }
+            }
+            return {
+                anchorCount,
+                hasMultipleSiteKeys: siteKeys.size > 1,
+            };
+        }, siteKey);
+    }
+    catch {
+        return { anchorCount: 0, hasMultipleSiteKeys: false };
+    }
+}
+async function isVisibleRecaptchaChallenge(page, siteKey) {
+    try {
+        return await page.evaluate((key) => {
+            const frames = Array.from(document.querySelectorAll('iframe[src*="recaptcha/api2/bframe"]'));
+            for (const frame of frames) {
+                try {
+                    const url = new URL(frame.src);
+                    const k = url.searchParams.get('k');
+                    if (k && k !== key)
+                        continue;
+                }
+                catch {
+                    // ignore malformed frame URL
+                }
+                const rect = frame.getBoundingClientRect();
+                if (rect.width <= 0 || rect.height <= 0) {
+                    continue;
+                }
+                if (rect.bottom < 0 || rect.top > window.innerHeight) {
+                    continue;
+                }
+                const style = window.getComputedStyle(frame);
+                if (style.visibility !== 'hidden' && style.display !== 'none' && style.opacity !== '0') {
+                    return true;
+                }
+            }
+            return false;
+        }, siteKey);
+    }
+    catch {
+        return false;
+    }
+}
+async function hasTokenInAnyFrame(page, selectors) {
+    for (const frame of page.frames()) {
+        try {
+            const hasToken = await frame.evaluate((selList) => {
+                for (const selector of selList) {
+                    const nodes = document.querySelectorAll(selector);
+                    for (const node of Array.from(nodes)) {
+                        const input = node;
+                        const direct = typeof input.value === 'string' ? input.value : '';
+                        const value = (direct || node.textContent || '').trim();
+                        if (value.length > 20) {
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            }, selectors);
+            if (hasToken)
+                return true;
+        }
+        catch {
+            // Some frames are inaccessible/transient; ignore.
+        }
+    }
+    return false;
+}
+async function verifyRecaptchaResolved(page, siteKey) {
+    const frames = recaptchaAnchorFrames(page, siteKey);
+    if (frames.length > 0) {
+        let sawAnchor = false;
+        for (const frame of frames) {
+            try {
+                const checked = await frame.evaluate(() => {
+                    const anchor = document.querySelector('#recaptcha-anchor');
+                    if (!anchor)
+                        return null;
+                    return anchor.getAttribute('aria-checked') === 'true';
+                });
+                if (checked === null)
+                    continue;
+                sawAnchor = true;
+                if (checked)
+                    return true;
+            }
+            catch {
+                // Ignore transient frame access errors.
+            }
+        }
+    }
+    // Token in response field is sufficient — injection + callback handles site-side verification;
+    // aria-checked is a visual indicator inside Google's iframe, not required for form submission.
+    return hasTokenInAnyFrame(page, [
+        '#g-recaptcha-response',
+        "textarea[name='g-recaptcha-response']",
+        "textarea[id*='g-recaptcha-response']",
+        "input[name='g-recaptcha-response']",
+    ]);
+}
+async function verifyCaptchaResolved(page, captcha) {
+    switch (captcha.type) {
+        case 'recaptcha-v2':
+            return verifyRecaptchaResolved(page, captcha.siteKey);
+        case 'hcaptcha':
+            return hasTokenInAnyFrame(page, [
+                "textarea[name='h-captcha-response']",
+                "textarea[id*='h-captcha-response']",
+                "textarea[name*='hcaptcha-response']",
+                "textarea[id*='hcaptcha-response']",
+                "input[name='h-captcha-response']",
+                "input[name*='hcaptcha-response']",
+            ]);
+        case 'turnstile':
+            return hasTokenInAnyFrame(page, [
+                "input[name='cf-turnstile-response']",
+                "textarea[name='cf-turnstile-response']",
+                "[id*='turnstile-response']",
+            ]);
+    }
+}
+export function setupCaptchaMonitor(page, solver) {
+    let solving = false;
+    const checkAndSolve = async () => {
+        if (solving)
+            return;
+        solving = true;
+        try {
+            await solveVisibleCaptchasWithOptions(page, solver);
+        }
+        catch {
+            // Page may navigate/close during scan.
+        }
+        finally {
+            solving = false;
+        }
+    };
+    page.on('domcontentloaded', () => {
+        void checkAndSolve();
+    });
+    const interval = setInterval(() => {
+        if (page.isClosed()) {
+            clearInterval(interval);
+            return;
+        }
+        void checkAndSolve();
+    }, 3000);
+    page.once('close', () => clearInterval(interval));
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function formatSolveError(error) {
+    if (error == null)
+        return 'unknown-error';
+    if (typeof error === 'string')
+        return error;
+    if (error instanceof Error) {
+        const withErr = error;
+        const details = [];
+        if (withErr.message)
+            details.push(withErr.message);
+        if (withErr.err)
+            details.push(String(withErr.err));
+        if (withErr.code != null)
+            details.push(`code=${String(withErr.code)}`);
+        return details.length > 0 ? details.join(' | ') : error.name;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}

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

@@ -0,0 +1,18 @@
+export type SolveCaptchasByCdpOptions = {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    solveTimeoutMs?: number;
+    connectTimeoutMs?: number;
+    apiUrl?: string;
+    onProgress?: (message: string) => void;
+};
+export type SolveCaptchasByCdpResult = {
+    solved: number;
+    verified: number;
+    unresolved: number;
+    unresolvedCaptchas: string[];
+    detected: number;
+    timedOut: boolean;
+};
+export declare function solveCaptchasByCdp(cdpUrl: string, apiKey: string, opts?: SolveCaptchasByCdpOptions): Promise<SolveCaptchasByCdpResult>;
+//# sourceMappingURL=captcha-runtime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"captcha-runtime.d.ts","sourceRoot":"","sources":["../../src/solver/captcha-runtime.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,yBAAyB,GAAG;IACtC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACxC,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAMF,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,yBAAyB,GAC/B,OAAO,CAAC,wBAAwB,CAAC,CA8GnC"}

package/dist/solver/captcha-runtime.js

@@ -0,0 +1,152 @@
+import puppeteer from 'puppeteer';
+import { CaptchaSolver } from './captcha-solver.js';
+import { detectCaptchas, solveVisibleCaptchasWithOptions } from './captcha-detector.js';
+const DEFAULT_TIMEOUT_MS = 90000;
+const DEFAULT_POLL_MS = 1500;
+const DEFAULT_CONNECT_TIMEOUT_MS = 15000;
+export async function solveCaptchasByCdp(cdpUrl, apiKey, opts) {
+    const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const pollIntervalMs = opts?.pollIntervalMs ?? DEFAULT_POLL_MS;
+    const connectTimeoutMs = opts?.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+    const deadline = Date.now() + timeoutMs;
+    const onProgress = opts?.onProgress;
+    onProgress?.('[captcha] connecting to browser...');
+    const browser = await withTimeout(puppeteer.connect(buildConnectOptions(cdpUrl)), connectTimeoutMs, `Failed to connect to browser within ${Math.ceil(connectTimeoutMs / 1000)}s`);
+    try {
+        const solver = new CaptchaSolver({
+            apiKey,
+            apiUrl: opts?.apiUrl,
+            taskTimeoutMs: opts?.solveTimeoutMs,
+        });
+        let solved = 0;
+        const detectedKeys = new Set();
+        const solvedKeys = new Set();
+        const verifiedKeys = new Set();
+        let sawCaptcha = false;
+        let lastWaitLogAt = 0;
+        onProgress?.(`[captcha] connected to browser, waiting for captcha up to ${Math.ceil(timeoutMs / 1000)}s`);
+        while (Date.now() < deadline) {
+            const pages = await getCandidatePages(browser);
+            if (pages.length === 0) {
+                if (Date.now() - lastWaitLogAt > 10000) {
+                    onProgress?.('[captcha] waiting for active page...');
+                    lastWaitLogAt = Date.now();
+                }
+                await sleep(pollIntervalMs);
+                continue;
+            }
+            let foundAnyCaptcha = false;
+            for (const page of pages) {
+                const captchas = await detectCaptchas(page);
+                if (captchas.length === 0)
+                    continue;
+                foundAnyCaptcha = true;
+                if (!sawCaptcha) {
+                    onProgress?.(`[captcha] captcha detected on ${stripQuery(page.url()) || 'current tab'} (${captchas.length})`);
+                }
+                for (const captcha of captchas) {
+                    const key = `${captcha.type}:${captcha.siteKey}:${captcha.pageUrl}`;
+                    detectedKeys.add(key);
+                }
+                sawCaptcha = true;
+                const unsolvedBefore = captchas.filter((captcha) => !solvedKeys.has(captchaKey(captcha)));
+                if (unsolvedBefore.length === 0) {
+                    return finalizeResult(solved, detectedKeys, verifiedKeys, false, onProgress);
+                }
+                const outcomes = await solveVisibleCaptchasWithOptions(page, solver, {
+                    solveTimeoutMs: opts?.solveTimeoutMs,
+                    onProgress,
+                    skipCaptcha: (captcha) => solvedKeys.has(captchaKey(captcha)),
+                });
+                for (const outcome of outcomes) {
+                    const key = captchaKey(outcome.captcha);
+                    if (outcome.injected || outcome.verified) {
+                        solved += 1;
+                        solvedKeys.add(key);
+                    }
+                    if (outcome.verified) {
+                        verifiedKeys.add(key);
+                    }
+                }
+                const unsolvedAfter = unsolvedBefore.filter((captcha) => !solvedKeys.has(captchaKey(captcha)));
+                if (unsolvedAfter.length === 0) {
+                    return finalizeResult(solved, detectedKeys, verifiedKeys, false, onProgress);
+                }
+            }
+            if (foundAnyCaptcha) {
+                await sleep(1000);
+                continue;
+            }
+            if (sawCaptcha) {
+                return finalizeResult(solved, detectedKeys, verifiedKeys, false, onProgress);
+            }
+            if (Date.now() - lastWaitLogAt > 10000) {
+                onProgress?.('[captcha] waiting for captcha...');
+                lastWaitLogAt = Date.now();
+            }
+            await sleep(pollIntervalMs);
+        }
+        onProgress?.('[captcha] timeout reached');
+        return finalizeResult(solved, detectedKeys, verifiedKeys, true, onProgress);
+    }
+    finally {
+        await browser.disconnect();
+    }
+}
+function finalizeResult(solved, detectedKeys, verifiedKeys, timedOut, onProgress) {
+    const detected = detectedKeys.size;
+    const unresolvedCaptchas = Array.from(detectedKeys).filter((key) => !verifiedKeys.has(key));
+    const verified = verifiedKeys.size;
+    const unresolved = unresolvedCaptchas.length;
+    onProgress?.(`[captcha] done: solved ${solved}, verified ${verified}, unresolved ${unresolved}, detected ${detected}`);
+    return {
+        solved,
+        verified,
+        unresolved,
+        unresolvedCaptchas,
+        detected,
+        timedOut,
+    };
+}
+function captchaKey(captcha) {
+    return `${captcha.type}:${captcha.siteKey}:${captcha.pageUrl}`;
+}
+async function getCandidatePages(browser) {
+    const pages = await browser.pages();
+    return pages.filter((page) => !page.url().startsWith('devtools://'));
+}
+function buildConnectOptions(cdpUrl) {
+    try {
+        const parsed = new URL(cdpUrl);
+        if (parsed.protocol === 'ws:' || parsed.protocol === 'wss:') {
+            return {
+                browserURL: `${parsed.protocol === 'wss:' ? 'https:' : 'http:'}//${parsed.host}`,
+            };
+        }
+        if (parsed.protocol === 'http:' || parsed.protocol === 'https:') {
+            return { browserURL: `${parsed.protocol}//${parsed.host}` };
+        }
+    }
+    catch {
+        // Fallback to raw WS endpoint below.
+    }
+    return { browserWSEndpoint: cdpUrl };
+}
+async function withTimeout(promise, timeoutMs, message) {
+    const timeoutPromise = sleep(timeoutMs).then(() => {
+        throw new Error(message);
+    });
+    return Promise.race([promise, timeoutPromise]);
+}
+function stripQuery(url) {
+    try {
+        const parsed = new URL(url);
+        return `${parsed.origin}${parsed.pathname}`;
+    }
+    catch {
+        return url;
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

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

@@ -0,0 +1,24 @@
+export type CaptchaType = 'recaptcha-v2' | 'hcaptcha' | 'turnstile';
+export type CaptchaSolverConfig = {
+    apiKey: string;
+    apiUrl?: string;
+    requestTimeoutMs?: number;
+    taskPollIntervalMs?: number;
+    taskTimeoutMs?: number;
+};
+/**
+ * Backend CAPTCHA gateway client. No direct provider keys are used in CLI.
+ */
+export declare class CaptchaSolver {
+    private readonly apiKey;
+    private readonly apiUrl;
+    private readonly requestTimeoutMs;
+    private readonly taskPollIntervalMs;
+    private readonly taskTimeoutMs;
+    constructor(config: CaptchaSolverConfig);
+    solve(type: CaptchaType, siteKey: string, pageUrl: string): Promise<string>;
+    private createTask;
+    private getTaskStatus;
+    private request;
+}
+//# sourceMappingURL=captcha-solver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"captcha-solver.d.ts","sourceRoot":"","sources":["../../src/solver/captcha-solver.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,cAAc,GAAG,UAAU,GAAG,WAAW,CAAC;AAEpE,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAoBF;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAC1C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAC5C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;gBAE3B,MAAM,EAAE,mBAAmB;IAejC,KAAK,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;YAkBnE,UAAU;YAYV,aAAa;YAOb,OAAO;CAsCtB"}