@mercuryo-ai/captcha-solver 0.1.0

package/README.md

@@ -0,0 +1,38 @@
+# @mercuryo-ai/captcha-solver
+
+Standalone captcha-solving runtime primitives.
+
+This package owns the captcha-specific execution layer that should not live in
+`@mercuryo-ai/agentbrowse` and is not part of the long-term MagicPay payment SDK
+surface.
+
+It currently provides:
+
+- browser-connected captcha solving via `solveCaptchasByCdp(...)`
+- low-level solver client `CaptchaSolver`
+- detection and solving helpers for reCAPTCHA v2, hCaptcha, and Turnstile
+
+It does not provide:
+
+- browser session persistence
+- MagicPay CLI orchestration
+- payment/session/approval flow semantics
+
+## Install
+
+```bash
+npm i @mercuryo-ai/captcha-solver
+```
+
+## Example
+
+```ts
+import { solveCaptchasByCdp } from '@mercuryo-ai/captcha-solver';
+
+const result = await solveCaptchasByCdp('ws://127.0.0.1:9222/devtools/browser/test', 'ap_test', {
+  apiUrl: 'https://agents-api.mercuryo.io/functions/v1/api',
+  timeoutMs: 90_000,
+});
+
+console.log(result);
+```

package/dist/captcha-detector.d.ts

@@ -0,0 +1,23 @@
+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;
+    sharedTransport?: boolean;
+    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/captcha-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"captcha-detector.d.ts","sourceRoot":"","sources":["../src/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,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,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,CAwI3E;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,CAuHhC;AA2YD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,aAAa,GAAG,IAAI,CA4B3E"}

package/dist/captcha-detector.js

@@ -0,0 +1,638 @@
+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 seen = new Set();
+        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) {
+                const seenKey = ['recaptcha-v2', '', key, ''].join(':');
+                if (!seen.has(seenKey)) {
+                    seen.add(seenKey);
+                    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]) {
+                const seenKey = ['recaptcha-v2', '', match[1], ''].join(':');
+                if (!seen.has(seenKey)) {
+                    seen.add(seenKey);
+                    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) {
+                const seenKey = ['hcaptcha', '', key, ''].join(':');
+                if (!seen.has(seenKey)) {
+                    seen.add(seenKey);
+                    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) {
+                const seenKey = ['turnstile', '', key, ''].join(':');
+                if (!seen.has(seenKey)) {
+                    seen.add(seenKey);
+                    found.push({
+                        type: 'turnstile',
+                        siteKey: key,
+                        pageUrl: url,
+                    });
+                }
+            }
+        }
+        const challengeStore = window.__agentbrowseTurnstileChallenges;
+        if (Array.isArray(challengeStore)) {
+            for (const challenge of challengeStore) {
+                const callbackId = challenge.callbackId ?? '';
+                const siteKey = challenge.siteKey ?? '';
+                const seenKey = ['turnstile', 'cloudflare-challenge', siteKey, callbackId].join(':');
+                if (!seen.has(seenKey)) {
+                    seen.add(seenKey);
+                    found.push({
+                        type: 'turnstile',
+                        variant: 'cloudflare-challenge',
+                        siteKey,
+                        pageUrl: url,
+                        captureSource: challenge.captureSource ?? 'render-hook',
+                        challengeReady: Boolean(siteKey && challenge.cData && challenge.chlPageData),
+                        action: challenge.action ?? '',
+                        cData: challenge.cData ?? '',
+                        chlPageData: challenge.chlPageData ?? '',
+                        callbackId,
+                        userAgent: challenge.userAgent ?? '',
+                    });
+                }
+            }
+        }
+        if (found.length === 0) {
+            const hasChallengePlatformScript = document.querySelectorAll("script[src*='/cdn-cgi/challenge-platform/']").length > 0;
+            const hasChallengeField = Array.from(document.querySelectorAll("input[name='cf-turnstile-response'], textarea[name='cf-turnstile-response']")).some((node) => {
+                const id = node.getAttribute('id') ?? '';
+                return id.startsWith('cf-chl-widget');
+            });
+            const hasCfChlOpt = Boolean(window._cf_chl_opt &&
+                typeof window._cf_chl_opt === 'object');
+            if (hasChallengePlatformScript || hasChallengeField || hasCfChlOpt) {
+                const seenKey = ['turnstile', 'cloudflare-challenge', '', ''].join(':');
+                if (!seen.has(seenKey)) {
+                    seen.add(seenKey);
+                    found.push({
+                        type: 'turnstile',
+                        variant: 'cloudflare-challenge',
+                        siteKey: '',
+                        pageUrl: url,
+                        captureSource: 'dom-fallback',
+                        challengeReady: false,
+                    });
+                }
+            }
+        }
+        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;
+        }
+        if (captcha.variant === 'cloudflare-challenge' && captcha.challengeReady === false) {
+            const missingParamsOutcome = {
+                captcha,
+                injected: false,
+                clicked: false,
+                verified: false,
+                error: 'challenge-params-missing',
+            };
+            opts?.onProgress?.(`[captcha] detected ${captcha.type} on ${captcha.pageUrl}, but challenge params were not captured`);
+            outcomes.push(missingParamsOutcome);
+            opts?.onCaptchaResult?.(missingParamsOutcome);
+            continue;
+        }
+        if (captcha.variant === 'cloudflare-challenge' && opts?.sharedTransport !== true) {
+            const transportRequiredOutcome = {
+                captcha,
+                injected: false,
+                clicked: false,
+                verified: false,
+                error: 'challenge-shared-transport-required',
+            };
+            opts?.onProgress?.(`[captcha] detected ${captcha.type} on ${captcha.pageUrl}, but Cloudflare challenge pages need shared browser/solver transport and that orchestration path is still deferred`);
+            outcomes.push(transportRequiredOutcome);
+            opts?.onCaptchaResult?.(transportRequiredOutcome);
+            continue;
+        }
+        opts?.onProgress?.(`[captcha] detected ${captcha.type} on ${captcha.pageUrl}, sending to solver (timeout ${Math.ceil(timeoutMs / 1000)}s)`);
+        try {
+            const solveRequest = toSolverRequest(captcha);
+            const maybeToken = await Promise.race([
+                solveRequest
+                    ? solver.solve(captcha.type, captcha.siteKey, captcha.pageUrl, solveRequest)
+                    : 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 solution = maybeToken;
+            await applySolverUserAgent(page, solution.userAgent);
+            await injectCaptchaToken(page, captcha, solution.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 win = window;
+            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 }));
+                }
+            }
+            if (info.variant === 'cloudflare-challenge' && info.callbackId) {
+                const callback = win.__agentbrowseTurnstileCallbacks?.[info.callbackId];
+                if (typeof callback === 'function') {
+                    callback(info.token);
+                    win.__agentbrowseTurnstileSolved = {
+                        ...(win.__agentbrowseTurnstileSolved ?? {}),
+                        [info.callbackId]: info.token,
+                    };
+                }
+            }
+        }
+    }, {
+        type: captcha.type,
+        token,
+        variant: captcha.variant,
+        callbackId: captcha.callbackId,
+    });
+}
+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':
+            if (captcha.variant === 'cloudflare-challenge') {
+                return verifyCloudflareChallengeCleared(page);
+            }
+            return hasTokenInAnyFrame(page, [
+                "input[name='cf-turnstile-response']",
+                "textarea[name='cf-turnstile-response']",
+                "[id*='turnstile-response']",
+            ]);
+    }
+}
+async function verifyCloudflareChallengeCleared(page) {
+    const deadline = Date.now() + 10_000;
+    while (Date.now() < deadline) {
+        try {
+            const stillChallenge = await page.evaluate(() => {
+                const hasChallengePlatformScript = document.querySelectorAll("script[src*='/cdn-cgi/challenge-platform/']").length > 0;
+                const hasChallengeField = Array.from(document.querySelectorAll("input[name='cf-turnstile-response'], textarea[name='cf-turnstile-response']")).some((node) => {
+                    const id = node.getAttribute('id') ?? '';
+                    return id.startsWith('cf-chl-widget');
+                });
+                const hasCfChlOpt = Boolean(window._cf_chl_opt &&
+                    typeof window._cf_chl_opt === 'object');
+                const bodyText = document.body?.innerText ?? '';
+                return (hasChallengePlatformScript ||
+                    hasChallengeField ||
+                    hasCfChlOpt ||
+                    document.title === 'Just a moment...' ||
+                    bodyText.includes('Just a moment'));
+            });
+            if (!stillChallenge) {
+                return true;
+            }
+        }
+        catch {
+            // Page may be navigating between challenge and destination; retry briefly.
+        }
+        await sleep(500);
+    }
+    return false;
+}
+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);
+    }
+}
+function toSolverRequest(captcha) {
+    if (captcha.type !== 'turnstile' || captcha.variant !== 'cloudflare-challenge') {
+        return undefined;
+    }
+    return {
+        action: captcha.action,
+        data: captcha.cData,
+        pagedata: captcha.chlPageData,
+        userAgent: captcha.userAgent,
+    };
+}
+async function applySolverUserAgent(page, userAgent) {
+    if (!userAgent || !userAgent.trim())
+        return;
+    const client = await page.createCDPSession();
+    try {
+        await client.send('Network.setUserAgentOverride', {
+            userAgent,
+        });
+    }
+    finally {
+        await client.detach().catch(() => { });
+    }
+}

package/dist/captcha-runtime.d.ts

@@ -0,0 +1,21 @@
+import type { ProxyConfig } from './types.js';
+export type SolveCaptchasByCdpOptions = {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    solveTimeoutMs?: number;
+    connectTimeoutMs?: number;
+    apiUrl?: string;
+    proxy?: ProxyConfig;
+    sharedTransport?: boolean;
+    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/captcha-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"captcha-runtime.d.ts","sourceRoot":"","sources":["../src/captcha-runtime.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,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,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,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,CAgInC"}

package/dist/captcha-runtime.js

@@ -0,0 +1,166 @@
+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;
+    const sharedTransport = opts?.sharedTransport ?? Boolean(opts?.proxy);
+    onProgress?.('[captcha] connecting to browser...');
+    const browser = await withTimeout(puppeteer.connect({
+        ...buildConnectOptions(cdpUrl),
+        defaultViewport: null,
+    }), connectTimeoutMs, `Failed to connect to browser within ${Math.ceil(connectTimeoutMs / 1000)}s`);
+    try {
+        const solver = new CaptchaSolver({
+            apiKey,
+            apiUrl: opts?.apiUrl,
+            taskTimeoutMs: opts?.solveTimeoutMs,
+            proxy: opts?.proxy,
+        });
+        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,
+                    sharedTransport,
+                    skipCaptcha: (captcha) => solvedKeys.has(captchaKey(captcha)),
+                });
+                const hasMissingParamsChallenge = outcomes.some((outcome) => outcome.error === 'challenge-params-missing');
+                const hasSharedTransportRequiredChallenge = outcomes.some((outcome) => outcome.error === 'challenge-shared-transport-required');
+                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 (hasMissingParamsChallenge) {
+                    return finalizeResult(solved, detectedKeys, verifiedKeys, false, onProgress);
+                }
+                if (hasSharedTransportRequiredChallenge) {
+                    return finalizeResult(solved, detectedKeys, verifiedKeys, false, onProgress);
+                }
+                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/captcha-solver.d.ts

@@ -0,0 +1,37 @@
+import type { CaptchaType, ProxyConfig } from './types.js';
+export type CaptchaSolverConfig = {
+    apiKey: string;
+    apiUrl?: string;
+    requestTimeoutMs?: number;
+    taskPollIntervalMs?: number;
+    taskTimeoutMs?: number;
+    proxy?: ProxyConfig;
+};
+export type CaptchaSolveRequest = {
+    action?: string;
+    data?: string;
+    pagedata?: string;
+    userAgent?: string;
+    proxy?: ProxyConfig;
+};
+export type CaptchaSolveResult = {
+    token: string;
+    userAgent?: string;
+};
+/**
+ * Captcha gateway client used by higher-level orchestration layers.
+ */
+export declare class CaptchaSolver {
+    private readonly apiKey;
+    private readonly apiUrl;
+    private readonly requestTimeoutMs;
+    private readonly taskPollIntervalMs;
+    private readonly taskTimeoutMs;
+    private readonly proxy?;
+    constructor(config: CaptchaSolverConfig);
+    solve(type: CaptchaType, siteKey: string, pageUrl: string, request?: CaptchaSolveRequest): Promise<CaptchaSolveResult>;
+    private createTask;
+    private getTaskStatus;
+    private request;
+}
+//# sourceMappingURL=captcha-solver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"captcha-solver.d.ts","sourceRoot":"","sources":["../src/captcha-solver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE3D,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;IACvB,KAAK,CAAC,EAAE,WAAW,CAAC;CACrB,CAAC;AAiBF,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,WAAW,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAMF;;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;IACvC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAc;gBAEzB,MAAM,EAAE,mBAAmB;IAgBjC,KAAK,CACT,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,kBAAkB,CAAC;YAqBhB,UAAU;YAkBV,aAAa;YAOb,OAAO;CAuCtB"}

package/dist/captcha-solver.js

@@ -0,0 +1,99 @@
+const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+const DEFAULT_TASK_POLL_MS = 5_000;
+const DEFAULT_TASK_TIMEOUT_MS = 120_000;
+/**
+ * Captcha gateway client used by higher-level orchestration layers.
+ */
+export class CaptchaSolver {
+    apiKey;
+    apiUrl;
+    requestTimeoutMs;
+    taskPollIntervalMs;
+    taskTimeoutMs;
+    proxy;
+    constructor(config) {
+        this.apiKey = config.apiKey;
+        this.apiUrl = (config.apiUrl || '').replace(/\/$/, '');
+        this.requestTimeoutMs = config.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+        this.taskPollIntervalMs = config.taskPollIntervalMs ?? DEFAULT_TASK_POLL_MS;
+        this.taskTimeoutMs = config.taskTimeoutMs ?? DEFAULT_TASK_TIMEOUT_MS;
+        this.proxy = config.proxy;
+        if (!this.apiKey || this.apiKey.trim().length === 0) {
+            throw new Error('CaptchaSolver: apiKey is required');
+        }
+        if (!this.apiUrl || this.apiUrl.trim().length === 0) {
+            throw new Error('CaptchaSolver: apiUrl is required');
+        }
+    }
+    async solve(type, siteKey, pageUrl, request) {
+        const task = await this.createTask(type, siteKey, pageUrl, request);
+        const deadline = Date.now() + this.taskTimeoutMs;
+        while (Date.now() < deadline) {
+            await sleep(this.taskPollIntervalMs);
+            const status = await this.getTaskStatus(task.task_id);
+            if (status.status === 'ready' && status.token) {
+                return {
+                    token: status.token,
+                    userAgent: status.user_agent,
+                };
+            }
+            if (status.status === 'failed') {
+                throw new Error(`CAPTCHA solving failed: ${status.error || 'provider error'}`);
+            }
+        }
+        throw new Error(`CAPTCHA solving timed out after ${Math.ceil(this.taskTimeoutMs / 1000)}s`);
+    }
+    async createTask(type, siteKey, pageUrl, request) {
+        return this.request('POST', '/tools/captcha/tasks', {
+            type,
+            site_key: siteKey,
+            page_url: pageUrl,
+            action: request?.action,
+            data: request?.data,
+            pagedata: request?.pagedata,
+            user_agent: request?.userAgent,
+            proxy: request?.proxy ?? this.proxy,
+        });
+    }
+    async getTaskStatus(taskId) {
+        return this.request('GET', `/tools/captcha/tasks/${encodeURIComponent(taskId)}`);
+    }
+    async request(method, path, body) {
+        const url = `${this.apiUrl}${path}`;
+        const headers = {
+            Authorization: `Bearer ${this.apiKey}`,
+            Accept: 'application/json',
+        };
+        if (body !== undefined) {
+            headers['Content-Type'] = 'application/json';
+        }
+        let response;
+        try {
+            const requestInit = {
+                method,
+                headers,
+                body: body !== undefined ? JSON.stringify(body) : undefined,
+                signal: AbortSignal.timeout(this.requestTimeoutMs),
+            };
+            response = await fetch(url, requestInit);
+        }
+        catch (err) {
+            throw new Error(`CAPTCHA gateway network error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        let json;
+        try {
+            json = (await response.json());
+        }
+        catch {
+            throw new Error(`CAPTCHA gateway returned non-JSON response (${response.status})`);
+        }
+        if (!response.ok) {
+            const message = typeof json.error === 'string' ? json.error : `HTTP ${response.status}`;
+            throw new Error(`CAPTCHA gateway error (${response.status}): ${message}`);
+        }
+        return json;
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './captcha-solver.js';
+export * from './captcha-detector.js';
+export * from './captcha-runtime.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './captcha-solver.js';
+export * from './captcha-detector.js';
+export * from './captcha-runtime.js';

package/dist/types.d.ts

@@ -0,0 +1,22 @@
+export type ProxyConfig = {
+    server: string;
+    username?: string;
+    password?: string;
+};
+export type CaptchaType = 'recaptcha-v2' | 'hcaptcha' | 'turnstile';
+export type TurnstileVariant = 'standalone' | 'cloudflare-challenge';
+export type TurnstileCaptureSource = 'render-hook' | 'api-shim' | 'dom-fallback';
+export type DetectedCaptcha = {
+    type: CaptchaType;
+    siteKey: string;
+    pageUrl: string;
+    variant?: TurnstileVariant;
+    captureSource?: TurnstileCaptureSource;
+    challengeReady?: boolean;
+    action?: string;
+    cData?: string;
+    chlPageData?: string;
+    callbackId?: string;
+    userAgent?: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,cAAc,GAAG,UAAU,GAAG,WAAW,CAAC;AAEpE,MAAM,MAAM,gBAAgB,GAAG,YAAY,GAAG,sBAAsB,CAAC;AACrE,MAAM,MAAM,sBAAsB,GAAG,aAAa,GAAG,UAAU,GAAG,cAAc,CAAC;AAEjF,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,aAAa,CAAC,EAAE,sBAAsB,CAAC;IACvC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@mercuryo-ai/captcha-solver",
+  "version": "0.1.0",
+  "description": "Captcha-solving runtime primitives for MagicPay and agent workflows",
+  "type": "module",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nuanu-ai/mercuryo-agent-pay.git",
+    "directory": "packages/captcha-solver"
+  },
+  "bugs": {
+    "url": "https://github.com/nuanu-ai/mercuryo-agent-pay/issues"
+  },
+  "homepage": "https://github.com/nuanu-ai/mercuryo-agent-pay/tree/main/packages/captcha-solver",
+  "keywords": [
+    "captcha",
+    "solver",
+    "browser-automation",
+    "turnstile",
+    "hcaptcha",
+    "recaptcha"
+  ],
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "puppeteer": "^23.11.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "5.9.2",
+    "vitest": "^4.0.18"
+  },
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist',{ recursive: true, force: true })\" && tsc -p tsconfig.build.json",
+    "check-types": "tsc --noEmit",
+    "pack:verify": "node scripts/verify-pack-artifact.mjs",
+    "smoke:pack-install": "node scripts/verify-pack-install-smoke.mjs",
+    "test": "vitest run"
+  }
+}