@biggora/claude-plugins 1.1.1 → 1.2.2

package/src/skills/captcha/scripts/solve_captcha.py

@@ -0,0 +1,323 @@
+#!/usr/bin/env python3
+"""
+CAPTCHA solver — submits to 2captcha, CapMonster, or Anti-Captcha and returns a token.
+
+No external dependencies required (uses Python stdlib only).
+
+Usage:
+    python solve_captcha.py --type recaptcha-v2 --sitekey KEY --pageurl URL
+    python solve_captcha.py --type recaptcha-v3 --sitekey KEY --pageurl URL --action verify
+    python solve_captcha.py --type hcaptcha    --sitekey KEY --pageurl URL
+    python solve_captcha.py --type turnstile   --sitekey KEY --pageurl URL
+    python solve_captcha.py --type image       --image path/to/captcha.png
+
+Environment variables:
+    CAPTCHA_API_KEY   — API key for the solving service
+    CAPTCHA_SERVICE   — "2captcha" (default) | "capmonster" | "anticaptcha"
+
+Output (JSON to stdout):
+    {"success": true,  "token": "03AGdBq25...", "type": "recaptcha-v2"}
+    {"success": false, "error": "ERROR_ZERO_BALANCE"}
+"""
+
+import argparse
+import base64
+import json
+import os
+import sys
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+
+
+# Base URLs for each service — all support the same 2captcha-compatible API
+SERVICE_URLS = {
+    "2captcha":    "https://2captcha.com",
+    "capmonster":  "https://api.capmonster.cloud",
+    "anticaptcha": "https://api.anti-captcha.com",
+}
+
+# How long to wait before first poll (solvers need processing time)
+INITIAL_WAIT = 15  # seconds
+
+# Interval between poll attempts
+POLL_INTERVAL = 5  # seconds
+
+
+# ---------------------------------------------------------------------------
+# HTTP helpers (stdlib only)
+# ---------------------------------------------------------------------------
+
+def _post(url, data):
+    """HTTP POST with form-encoded body. Returns response text."""
+    payload = urllib.parse.urlencode(data).encode()
+    req = urllib.request.Request(url, data=payload, method="POST")
+    req.add_header("Content-Type", "application/x-www-form-urlencoded")
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            return resp.read().decode()
+    except urllib.error.HTTPError as e:
+        raise RuntimeError(f"HTTP {e.code}: {e.read().decode()}")
+
+
+def _get(url):
+    """HTTP GET. Returns response text."""
+    try:
+        with urllib.request.urlopen(url, timeout=30) as resp:
+            return resp.read().decode()
+    except urllib.error.HTTPError as e:
+        raise RuntimeError(f"HTTP {e.code}: {e.read().decode()}")
+
+
+# ---------------------------------------------------------------------------
+# Task submission
+# ---------------------------------------------------------------------------
+
+def _submit(api_key, service, data):
+    """Submit a task. Returns the task ID string."""
+    base = SERVICE_URLS.get(service, SERVICE_URLS["2captcha"])
+    data = {**data, "key": api_key, "json": "1"}
+    resp = _post(f"{base}/in.php", data)
+    result = json.loads(resp)
+    if result.get("status") != 1:
+        raise RuntimeError(result.get("request", str(result)))
+    return str(result["request"])
+
+
+def submit_recaptcha_v2(api_key, sitekey, pageurl, service="2captcha", invisible=False):
+    data = {
+        "method":    "userrecaptcha",
+        "googlekey": sitekey,
+        "pageurl":   pageurl,
+    }
+    if invisible:
+        data["invisible"] = "1"
+    return _submit(api_key, service, data)
+
+
+def submit_recaptcha_v3(api_key, sitekey, pageurl, action="verify",
+                        min_score=0.5, service="2captcha"):
+    return _submit(api_key, service, {
+        "method":    "userrecaptcha",
+        "version":   "v3",
+        "googlekey": sitekey,
+        "pageurl":   pageurl,
+        "action":    action,
+        "min_score": str(min_score),
+    })
+
+
+def submit_hcaptcha(api_key, sitekey, pageurl, service="2captcha"):
+    return _submit(api_key, service, {
+        "method":  "hcaptcha",
+        "sitekey": sitekey,
+        "pageurl": pageurl,
+    })
+
+
+def submit_turnstile(api_key, sitekey, pageurl, service="2captcha"):
+    return _submit(api_key, service, {
+        "method":  "turnstile",
+        "sitekey": sitekey,
+        "pageurl": pageurl,
+    })
+
+
+def submit_image(api_key, image_source, service="2captcha"):
+    """image_source: file path or raw base64 string."""
+    if os.path.isfile(image_source):
+        with open(image_source, "rb") as f:
+            img_b64 = base64.b64encode(f.read()).decode()
+    else:
+        img_b64 = image_source  # assume already base64
+    return _submit(api_key, service, {
+        "method": "base64",
+        "body":   img_b64,
+    })
+
+
+# ---------------------------------------------------------------------------
+# Polling
+# ---------------------------------------------------------------------------
+
+def poll(api_key, task_id, service="2captcha", timeout=120):
+    """Poll until solved. Returns the token string."""
+    base = SERVICE_URLS.get(service, SERVICE_URLS["2captcha"])
+    url = (
+        f"{base}/res.php"
+        f"?key={urllib.parse.quote(api_key)}"
+        f"&action=get"
+        f"&id={urllib.parse.quote(task_id)}"
+        f"&json=1"
+    )
+
+    print(f"[captcha] Waiting {INITIAL_WAIT}s for solver...", file=sys.stderr)
+    time.sleep(INITIAL_WAIT)
+
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        resp = _get(url)
+        result = json.loads(resp)
+
+        if result.get("status") == 1:
+            return result["request"]
+
+        if result.get("request") == "CAPCHA_NOT_READY":
+            remaining = int(deadline - time.time())
+            print(f"[captcha] Not ready yet, polling again in {POLL_INTERVAL}s "
+                  f"({remaining}s remaining)...", file=sys.stderr)
+            time.sleep(POLL_INTERVAL)
+            continue
+
+        # Any other response is an error
+        raise RuntimeError(result.get("request", str(result)))
+
+    raise TimeoutError(f"CAPTCHA not solved within {timeout}s. "
+                       "Try increasing --timeout or check service status.")
+
+
+# ---------------------------------------------------------------------------
+# High-level solve()
+# ---------------------------------------------------------------------------
+
+def solve(captcha_type, api_key, service="2captcha", **kwargs):
+    """
+    Solve a CAPTCHA and return the token string.
+
+    captcha_type: recaptcha-v2 | recaptcha-v3 | hcaptcha | turnstile | image
+    Required kwargs by type:
+      recaptcha-v2/v3, hcaptcha, turnstile: sitekey, pageurl
+      image: image (file path or base64)
+    Optional:
+      invisible (bool)  — for recaptcha-v2
+      action (str)      — for recaptcha-v3, default "verify"
+      min_score (float) — for recaptcha-v3, default 0.5
+      timeout (int)     — max seconds to wait, default 120
+    """
+    dispatch = {
+        "recaptcha-v2": lambda: submit_recaptcha_v2(
+            api_key, kwargs["sitekey"], kwargs["pageurl"],
+            service=service, invisible=kwargs.get("invisible", False)
+        ),
+        "recaptcha2": lambda: submit_recaptcha_v2(
+            api_key, kwargs["sitekey"], kwargs["pageurl"],
+            service=service, invisible=kwargs.get("invisible", False)
+        ),
+        "recaptcha-v3": lambda: submit_recaptcha_v3(
+            api_key, kwargs["sitekey"], kwargs["pageurl"],
+            action=kwargs.get("action", "verify"),
+            min_score=kwargs.get("min_score", 0.5),
+            service=service
+        ),
+        "recaptcha3": lambda: submit_recaptcha_v3(
+            api_key, kwargs["sitekey"], kwargs["pageurl"],
+            action=kwargs.get("action", "verify"),
+            min_score=kwargs.get("min_score", 0.5),
+            service=service
+        ),
+        "hcaptcha": lambda: submit_hcaptcha(
+            api_key, kwargs["sitekey"], kwargs["pageurl"], service=service
+        ),
+        "turnstile": lambda: submit_turnstile(
+            api_key, kwargs["sitekey"], kwargs["pageurl"], service=service
+        ),
+        "image": lambda: submit_image(api_key, kwargs["image"], service=service),
+    }
+
+    submit_fn = dispatch.get(captcha_type)
+    if submit_fn is None:
+        raise ValueError(
+            f"Unknown CAPTCHA type: {captcha_type!r}. "
+            f"Choose from: {', '.join(sorted(set(dispatch.keys())))}"
+        )
+
+    task_id = submit_fn()
+    print(f"[captcha] Task submitted (id={task_id})", file=sys.stderr)
+    return poll(api_key, task_id, service=service, timeout=kwargs.get("timeout", 120))
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Solve a CAPTCHA via a third-party service and print the token as JSON.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+    parser.add_argument(
+        "--type", required=True,
+        choices=["recaptcha-v2", "recaptcha-v3", "hcaptcha", "turnstile", "image"],
+        help="CAPTCHA type",
+    )
+    parser.add_argument("--sitekey", help="CAPTCHA sitekey (recaptcha/hcaptcha/turnstile)")
+    parser.add_argument("--pageurl", help="Full URL of the page with the CAPTCHA")
+    parser.add_argument("--image", help="Image file path or base64 string (for --type image)")
+    parser.add_argument(
+        "--api-key",
+        default=os.environ.get("CAPTCHA_API_KEY"),
+        help="Solving service API key (default: $CAPTCHA_API_KEY)",
+    )
+    parser.add_argument(
+        "--service",
+        default=os.environ.get("CAPTCHA_SERVICE", "2captcha"),
+        choices=list(SERVICE_URLS.keys()),
+        help="Solving service to use (default: 2captcha)",
+    )
+    parser.add_argument("--action", default="verify", help="reCAPTCHA v3 action name")
+    parser.add_argument("--min-score", type=float, default=0.5,
+                        help="reCAPTCHA v3 minimum acceptable score (0.1–0.9)")
+    parser.add_argument("--invisible", action="store_true",
+                        help="Use invisible reCAPTCHA v2 mode")
+    parser.add_argument("--timeout", type=int, default=120,
+                        help="Max seconds to wait for a solution (default: 120)")
+
+    args = parser.parse_args()
+
+    if not args.api_key:
+        out = {"success": False, "error":
+               "No API key provided. Use --api-key or set CAPTCHA_API_KEY env var."}
+        print(json.dumps(out))
+        sys.exit(1)
+
+    # Validate required args per type
+    needs_sitekey = args.type in ("recaptcha-v2", "recaptcha-v3", "hcaptcha", "turnstile")
+    if needs_sitekey and not args.sitekey:
+        print(json.dumps({"success": False,
+                          "error": f"--sitekey is required for --type {args.type}"}))
+        sys.exit(1)
+    if needs_sitekey and not args.pageurl:
+        print(json.dumps({"success": False,
+                          "error": f"--pageurl is required for --type {args.type}"}))
+        sys.exit(1)
+    if args.type == "image" and not args.image:
+        print(json.dumps({"success": False,
+                          "error": "--image is required for --type image"}))
+        sys.exit(1)
+
+    try:
+        token = solve(
+            args.type,
+            args.api_key,
+            service=args.service,
+            sitekey=args.sitekey,
+            pageurl=args.pageurl,
+            image=args.image,
+            action=args.action,
+            min_score=args.min_score,
+            invisible=args.invisible,
+            timeout=args.timeout,
+        )
+        print(json.dumps({"success": True, "token": token, "type": args.type}))
+    except TimeoutError as e:
+        print(json.dumps({"success": False, "error": str(e)}))
+        sys.exit(1)
+    except Exception as e:
+        print(json.dumps({"success": False, "error": str(e)}))
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/src/skills/captcha/scripts/solve_image_grid.py

@@ -0,0 +1,350 @@
+#!/usr/bin/env python3
+"""
+Solve reCAPTCHA v2 image grid challenges using vision AI.
+
+After clicking the checkbox, if an image grid appears ("select all traffic
+lights"), this script screenshots the grid, sends it to Claude or GPT-4V,
+gets back which cells to click, and handles multiple rounds automatically.
+
+Usage in your Playwright script:
+    from solve_image_grid import solve_image_grid
+
+    # Click the checkbox first
+    page.frame_locator('iframe[title="reCAPTCHA"]') \\
+        .locator('.recaptcha-checkbox-border').click()
+
+    # Solve the grid (if it appears)
+    solved = solve_image_grid(page)
+
+Standalone test (opens the Google demo):
+    python solve_image_grid.py
+
+Requirements:
+    pip install playwright anthropic    # Claude (recommended)
+    # or: pip install playwright openai # GPT-4V fallback
+
+Environment:
+    ANTHROPIC_API_KEY  — Claude API key (preferred, better spatial reasoning)
+    OPENAI_API_KEY     — OpenAI API key (fallback)
+"""
+
+import base64
+import json
+import os
+import re
+import sys
+import time
+import random
+
+# ---------------------------------------------------------------------------
+# Timing constants
+# ---------------------------------------------------------------------------
+
+CELL_CLICK_DELAY  = (0.25, 0.65)   # random pause between cell clicks (seconds)
+VERIFY_WAIT_SEC   = 2.5            # pause after clicking Verify before checking result
+ROUND_DELAY       = (1.5, 3.0)     # pause between rounds
+
+# ---------------------------------------------------------------------------
+# Selectors
+# ---------------------------------------------------------------------------
+
+CHECKBOX_IFRAME     = 'iframe[title="reCAPTCHA"]'
+
+# The challenge iframe may have slightly different titles across reCAPTCHA versions
+CHALLENGE_IFRAME_SELECTORS = [
+    'iframe[title*="recaptcha challenge"]',
+    'iframe[src*="recaptcha/api2/bframe"]',
+    'iframe[src*="recaptcha/enterprise/bframe"]',
+]
+
+# Selectors *inside* the challenge iframe
+TASK_TEXT_SEL = '.rc-imageselect-desc-no-canonical, .rc-imageselect-desc'
+GRID_SEL      = '.rc-imageselect-table-33, .rc-imageselect-table-44, table.rc-imageselect-table'
+CELL_SEL      = 'td.rc-imageselect-tile, .rc-imageselect-tile'
+VERIFY_BTN    = '#recaptcha-verify-button'
+
+
+# ---------------------------------------------------------------------------
+# Vision AI: ask which cells match the task
+# ---------------------------------------------------------------------------
+
+def _prompt(task_text: str, grid_size: int) -> str:
+    n = grid_size * grid_size
+    return (
+        f'This is a reCAPTCHA image grid ({grid_size}×{grid_size}, {n} cells total).\n'
+        f'Task: "{task_text}"\n\n'
+        f'Number the cells 1–{n} left-to-right, top-to-bottom (row 1 first).\n'
+        f'Return ONLY a JSON array of the cell numbers that match the task.\n'
+        f'Examples: [2,5,8]  or  []  (empty if none match)\n'
+        f'No explanation — just the array.'
+    )
+
+
+def _call_claude(image_b64: str, task_text: str, grid_size: int) -> list:
+    import anthropic
+    client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
+    msg = client.messages.create(
+        model="claude-opus-4-6",
+        max_tokens=64,
+        messages=[{
+            "role": "user",
+            "content": [
+                {
+                    "type": "image",
+                    "source": {
+                        "type": "base64",
+                        "media_type": "image/png",
+                        "data": image_b64,
+                    },
+                },
+                {"type": "text", "text": _prompt(task_text, grid_size)},
+            ],
+        }],
+    )
+    return _parse_response(msg.content[0].text, grid_size)
+
+
+def _call_openai(image_b64: str, task_text: str, grid_size: int) -> list:
+    from openai import OpenAI
+    client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
+    resp = client.chat.completions.create(
+        model="gpt-4o",
+        max_tokens=64,
+        messages=[{
+            "role": "user",
+            "content": [
+                {
+                    "type": "image_url",
+                    "image_url": {"url": f"data:image/png;base64,{image_b64}"},
+                },
+                {"type": "text", "text": _prompt(task_text, grid_size)},
+            ],
+        }],
+    )
+    return _parse_response(resp.choices[0].message.content, grid_size)
+
+
+def _parse_response(raw: str, grid_size: int) -> list:
+    """Extract a valid list of cell ints from the AI's raw response."""
+    match = re.search(r'\[.*?\]', raw.strip(), re.DOTALL)
+    if not match:
+        return []
+    try:
+        cells = json.loads(match.group())
+        n = grid_size * grid_size
+        return [c for c in cells if isinstance(c, int) and 1 <= c <= n]
+    except (json.JSONDecodeError, TypeError):
+        return []
+
+
+def ask_vision_ai(image_b64: str, task_text: str, grid_size: int) -> list:
+    """
+    Ask the available vision AI which cells match the task.
+    Tries Claude first, falls back to GPT-4V.
+    Returns a list of 1-indexed cell numbers.
+    """
+    if os.environ.get("ANTHROPIC_API_KEY"):
+        try:
+            cells = _call_claude(image_b64, task_text, grid_size)
+            print(f"[grid] Claude selected: {cells}", file=sys.stderr)
+            return cells
+        except Exception as e:
+            print(f"[grid] Claude error: {e} — trying OpenAI...", file=sys.stderr)
+
+    if os.environ.get("OPENAI_API_KEY"):
+        cells = _call_openai(image_b64, task_text, grid_size)
+        print(f"[grid] GPT-4V selected: {cells}", file=sys.stderr)
+        return cells
+
+    raise RuntimeError(
+        "No vision AI key found. Set ANTHROPIC_API_KEY or OPENAI_API_KEY."
+    )
+
+
+# ---------------------------------------------------------------------------
+# Playwright helpers
+# ---------------------------------------------------------------------------
+
+def _find_challenge_frame(page):
+    """Return the challenge FrameLocator if visible, else None."""
+    for sel in CHALLENGE_IFRAME_SELECTORS:
+        try:
+            frame = page.frame_locator(sel)
+            if frame.locator(TASK_TEXT_SEL).is_visible(timeout=1500):
+                return frame
+        except Exception:
+            continue
+    return None
+
+
+def _challenge_visible(page) -> bool:
+    for sel in CHALLENGE_IFRAME_SELECTORS:
+        try:
+            if page.locator(sel).is_visible(timeout=400):
+                return True
+        except Exception:
+            pass
+    return False
+
+
+def _get_task(frame) -> str:
+    try:
+        return frame.locator(TASK_TEXT_SEL).first.inner_text(timeout=3000).strip()
+    except Exception:
+        return ""
+
+
+def _get_grid_size(frame) -> int:
+    try:
+        if frame.locator('.rc-imageselect-table-44').count() > 0:
+            return 4
+    except Exception:
+        pass
+    return 3
+
+
+def _screenshot_grid(frame) -> str:
+    """Screenshot just the image grid and return as base64 PNG."""
+    try:
+        png = frame.locator(GRID_SEL).first.screenshot()
+    except Exception:
+        png = frame.locator("body").screenshot()
+    return base64.b64encode(png).decode()
+
+
+def _click_cells(frame, cell_numbers: list, grid_size: int) -> None:
+    """
+    Click the specified cells (1-indexed, left-to-right top-to-bottom).
+
+    Uses element-based clicking via frame_locator rather than raw pixel
+    coordinates — more reliable across different viewport sizes and DPIs.
+    """
+    if not cell_numbers:
+        return
+    cells = frame.locator(CELL_SEL).all()
+    for num in cell_numbers:
+        idx = num - 1
+        if idx < len(cells):
+            try:
+                cells[idx].click()
+                time.sleep(random.uniform(*CELL_CLICK_DELAY))
+            except Exception as e:
+                print(f"[grid] Cell {num} click failed: {e}", file=sys.stderr)
+
+
+# ---------------------------------------------------------------------------
+# Main public function
+# ---------------------------------------------------------------------------
+
+def solve_image_grid(page, max_rounds: int = 6) -> bool:
+    """
+    Solve a reCAPTCHA v2 image grid challenge on the given Playwright page.
+
+    Call this after clicking the reCAPTCHA checkbox. If a grid challenge
+    appears, the function loops through rounds (new grids keep appearing
+    until Google is satisfied) and clicks the correct cells each time.
+
+    If the checkbox passed without triggering a grid (common on trusted IPs
+    and during testing), the function returns True immediately.
+
+    Args:
+        page:       Playwright Page object
+        max_rounds: Give up after this many rounds (default: 6)
+
+    Returns:
+        True  — challenge closed (solved or no challenge appeared)
+        False — failed to solve within max_rounds or API error
+    """
+    # Wait briefly for the challenge to appear
+    print("[grid] Checking for image challenge...", file=sys.stderr)
+    for _ in range(8):
+        if _find_challenge_frame(page):
+            break
+        time.sleep(0.7)
+    else:
+        print("[grid] No grid challenge — checkbox solved directly.", file=sys.stderr)
+        return True
+
+    for round_num in range(1, max_rounds + 1):
+        frame = _find_challenge_frame(page)
+        if not frame:
+            print("[grid] Challenge closed — done.", file=sys.stderr)
+            return True
+
+        task_text = _get_task(frame)
+        grid_size = _get_grid_size(frame)
+        print(f"[grid] Round {round_num}: '{task_text}' ({grid_size}×{grid_size})",
+              file=sys.stderr)
+
+        image_b64 = _screenshot_grid(frame)
+
+        try:
+            cells = ask_vision_ai(image_b64, task_text, grid_size)
+        except Exception as e:
+            print(f"[grid] Vision AI failed: {e}", file=sys.stderr)
+            return False
+
+        _click_cells(frame, cells, grid_size)
+
+        # Small pause before clicking Verify (mimics human review time)
+        time.sleep(random.uniform(0.6, 1.4))
+
+        try:
+            frame.locator(VERIFY_BTN).click()
+        except Exception as e:
+            print(f"[grid] Verify click failed: {e}", file=sys.stderr)
+            return False
+
+        time.sleep(VERIFY_WAIT_SEC + random.uniform(0, 1))
+
+        if not _challenge_visible(page):
+            print("[grid] Challenge dismissed — solved.", file=sys.stderr)
+            return True
+
+        print("[grid] New round appeared.", file=sys.stderr)
+
+    print(f"[grid] Gave up after {max_rounds} rounds.", file=sys.stderr)
+    return False
+
+
+# ---------------------------------------------------------------------------
+# Standalone test
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    from playwright.sync_api import sync_playwright
+
+    if not (os.environ.get("ANTHROPIC_API_KEY") or os.environ.get("OPENAI_API_KEY")):
+        print("ERROR: set ANTHROPIC_API_KEY or OPENAI_API_KEY", file=sys.stderr)
+        sys.exit(1)
+
+    with sync_playwright() as p:
+        browser = p.chromium.launch(headless=False)
+        context = browser.new_context(
+            viewport={"width": 1280, "height": 800},
+            user_agent=(
+                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                "AppleWebKit/537.36 (KHTML, like Gecko) "
+                "Chrome/124.0.0.0 Safari/537.36"
+            ),
+        )
+        context.add_init_script(
+            "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
+        )
+        page = context.new_page()
+        page.goto("https://www.google.com/recaptcha/api2/demo", wait_until="networkidle")
+
+        print("[main] Clicking checkbox...")
+        page.frame_locator(CHECKBOX_IFRAME) \
+            .locator(".recaptcha-checkbox-border").click()
+
+        ok = solve_image_grid(page)
+        print(f"[main] Grid result: {'SOLVED' if ok else 'FAILED'}")
+
+        if ok:
+            page.click("#recaptcha-demo-submit")
+            page.wait_for_timeout(3000)
+
+        page.screenshot(path="grid_result.png")
+        print("[main] Screenshot saved to grid_result.png")
+        browser.close()