Delete scripts

scripts/check_model_catalog_sync.py

@@ -1,108 +0,0 @@
-#!/usr/bin/env python3
-"""
-Lightweight guard for model catalog consistency across runtimes.
-
-Checks:
-1) app/services/grok/model.py and src/grok/models.ts expose the exact same model ids.
-2) src/**/*.ts must not contain removed legacy model identifiers.
-"""
-
-from __future__ import annotations
-
-import re
-import sys
-from pathlib import Path
-
-
-ROOT = Path(__file__).resolve().parents[1]
-PY_MODEL_FILE = ROOT / "app" / "services" / "grok" / "model.py"
-TS_MODEL_FILE = ROOT / "src" / "grok" / "models.ts"
-TS_SRC_DIR = ROOT / "src"
-
-PY_MODEL_ID_RE = re.compile(r'model_id\s*=\s*"([^"]+)"')
-TS_MODEL_ID_RE = re.compile(r'^\s*"(?P<id>grok-[^"]+)"\s*:\s*{', re.MULTILINE)
-
-REMOVED_IDENTIFIERS = (
-    "grok-3-fast",
-    "grok-4-fast",
-    "grok-4-mini-thinking-tahoe",
-    "grok-4.1",
-)
-
-
-def _read_text(path: Path) -> str:
-    return path.read_text(encoding="utf-8")
-
-
-def _collect_python_model_ids(text: str) -> set[str]:
-    return {v for v in PY_MODEL_ID_RE.findall(text) if v.startswith("grok-")}
-
-
-def _collect_workers_model_ids(text: str) -> set[str]:
-    return {m.group("id") for m in TS_MODEL_ID_RE.finditer(text)}
-
-
-def _build_token_pattern(token: str) -> re.Pattern[str]:
-    # Exact token match (avoid matching prefixes like `grok-4.1-mini` for `grok-4.1`).
-    escaped = re.escape(token)
-    return re.compile(rf"(?<![A-Za-z0-9_.-]){escaped}(?![A-Za-z0-9_.-])")
-
-
-def _scan_removed_identifiers() -> list[tuple[str, int, str, str]]:
-    patterns = [(token, _build_token_pattern(token)) for token in REMOVED_IDENTIFIERS]
-    findings: list[tuple[str, int, str, str]] = []
-
-    for ts_file in sorted(TS_SRC_DIR.rglob("*.ts")):
-        text = _read_text(ts_file)
-        for line_no, line in enumerate(text.splitlines(), start=1):
-            for token, pat in patterns:
-                if pat.search(line):
-                    findings.append(
-                        (
-                            ts_file.relative_to(ROOT).as_posix(),
-                            line_no,
-                            token,
-                            line.strip(),
-                        ),
-                    )
-    return findings
-
-
-def main() -> int:
-    errors: list[str] = []
-
-    py_ids = _collect_python_model_ids(_read_text(PY_MODEL_FILE))
-    ts_ids = _collect_workers_model_ids(_read_text(TS_MODEL_FILE))
-
-    if py_ids != ts_ids:
-        only_python = sorted(py_ids - ts_ids)
-        only_workers = sorted(ts_ids - py_ids)
-        lines = ["Model catalog mismatch between python and workers."]
-        if only_python:
-            lines.append("Only in app/services/grok/model.py:")
-            lines.extend(f"  - {mid}" for mid in only_python)
-        if only_workers:
-            lines.append("Only in src/grok/models.ts:")
-            lines.extend(f"  - {mid}" for mid in only_workers)
-        errors.append("\n".join(lines))
-
-    removed_hits = _scan_removed_identifiers()
-    if removed_hits:
-        lines = ["Removed model identifiers found under src/**/*.ts:"]
-        for rel_path, line_no, token, snippet in removed_hits:
-            lines.append(f"  - {rel_path}:{line_no} -> {token}")
-            lines.append(f"    {snippet}")
-        errors.append("\n".join(lines))
-
-    if errors:
-        print("[check_model_catalog_sync] FAILED", file=sys.stderr)
-        for idx, msg in enumerate(errors, start=1):
-            print(f"\n[{idx}] {msg}", file=sys.stderr)
-        return 1
-
-    print("[check_model_catalog_sync] OK: model catalogs are synchronized and legacy identifiers are absent.")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

scripts/entrypoint.sh

@@ -1,7 +0,0 @@
-#!/usr/bin/env sh
-set -eu
-
-/app/scripts/init_storage.sh
-python /app/scripts/wait_for_storage.py
-
-exec "$@"

scripts/init_storage.sh

@@ -1,20 +0,0 @@
-#!/usr/bin/env sh
-set -eu
-
-ROOT_DIR="$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)"
-DATA_DIR="$ROOT_DIR/data"
-LOG_DIR="$ROOT_DIR/logs"
-TMP_DIR="$DATA_DIR/tmp"
-DEFAULT_CONFIG="$ROOT_DIR/config.defaults.toml"
-
-mkdir -p "$DATA_DIR" "$LOG_DIR" "$TMP_DIR"
-
-if [ ! -f "$DATA_DIR/config.toml" ]; then
-  cp "$DEFAULT_CONFIG" "$DATA_DIR/config.toml"
-fi
-
-if [ ! -f "$DATA_DIR/token.json" ]; then
-  echo "{}" > "$DATA_DIR/token.json"
-fi
-
-chmod 600 "$DATA_DIR/config.toml" "$DATA_DIR/token.json" || true

scripts/smoke_test.py

@@ -1,165 +0,0 @@
-import argparse
-import json
-import os
-import sys
-from typing import Any
-from urllib.error import HTTPError, URLError
-from urllib.request import Request, urlopen
-
-
-def http_get(url: str, *, headers: dict[str, str] | None = None, timeout: float = 5.0) -> tuple[int, bytes]:
-    req = Request(url, headers=headers or {}, method="GET")
-    try:
-        with urlopen(req, timeout=timeout) as resp:
-            return int(getattr(resp, "status", 200)), resp.read()
-    except HTTPError as e:
-        body = b""
-        try:
-            body = e.read()
-        except Exception:
-            pass
-        return int(getattr(e, "code", 0) or 0), body
-
-
-def http_post(
-    url: str,
-    *,
-    body: bytes,
-    headers: dict[str, str] | None = None,
-    timeout: float = 5.0,
-) -> tuple[int, dict[str, str], bytes]:
-    req = Request(url, data=body, headers=headers or {}, method="POST")
-    try:
-        with urlopen(req, timeout=timeout) as resp:
-            return (
-                int(getattr(resp, "status", 200)),
-                {k.lower(): v for k, v in dict(resp.headers).items()},
-                resp.read(),
-            )
-    except HTTPError as e:
-        body_bytes = b""
-        try:
-            body_bytes = e.read()
-        except Exception:
-            pass
-        return (
-            int(getattr(e, "code", 0) or 0),
-            {k.lower(): v for k, v in dict(e.headers).items()} if e.headers else {},
-            body_bytes,
-        )
-
-
-def require_ok(name: str, status: int, body: bytes, *, allow: set[int] | None = None) -> None:
-    allow = allow or {200}
-    if status in allow:
-        return
-    text = body.decode("utf-8", errors="replace")
-    raise SystemExit(f"[smoke] {name} failed: status={status}, body={text[:500]}")
-
-
-def try_parse_json(body: bytes) -> Any:
-    try:
-        return json.loads(body.decode("utf-8"))
-    except Exception:
-        return None
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description="Grok2API smoke test (local/docker/cloudflare).")
-    parser.add_argument(
-        "--base-url",
-        default=os.getenv("GROK2API_BASE_URL", "http://127.0.0.1:8000"),
-        help="Base URL, e.g. http://127.0.0.1:8000",
-    )
-    parser.add_argument(
-        "--api-key",
-        default=os.getenv("GROK2API_API_KEY", ""),
-        help="Optional API key (Bearer). Enables /v1/models check.",
-    )
-    parser.add_argument(
-        "--timeout",
-        type=float,
-        default=float(os.getenv("GROK2API_SMOKE_TIMEOUT", "5")),
-        help="HTTP timeout seconds.",
-    )
-    parser.add_argument(
-        "--check-image-stream",
-        action="store_true",
-        help="Also validate /v1/images/generations stream response Content-Type.",
-    )
-    args = parser.parse_args()
-
-    base_url = (args.base_url or "").strip().rstrip("/")
-    if not base_url:
-        print("[smoke] missing --base-url", file=sys.stderr)
-        return 2
-
-    timeout = max(0.5, float(args.timeout))
-
-    # 1) /health
-    health_url = f"{base_url}/health"
-    try:
-        status, body = http_get(health_url, timeout=timeout)
-    except URLError as e:
-        raise SystemExit(f"[smoke] /health network error: {e}") from e
-    require_ok("/health", status, body)
-    parsed = try_parse_json(body) or {}
-    runtime = (parsed.get("runtime") if isinstance(parsed, dict) else None) or "unknown"
-    print(f"[smoke] /health OK (runtime={runtime})")
-
-    # 2) /login (admin UI entry)
-    login_url = f"{base_url}/login"
-    status, body = http_get(login_url, timeout=timeout)
-    require_ok("/login", status, body, allow={200, 302, 307, 308})
-    print("[smoke] /login OK")
-
-    # 3) /v1/models (requires API key)
-    api_key = (args.api_key or "").strip()
-    if api_key:
-        models_url = f"{base_url}/v1/models"
-        status, body = http_get(models_url, headers={"Authorization": f"Bearer {api_key}"}, timeout=timeout)
-        require_ok("/v1/models", status, body)
-        print("[smoke] /v1/models OK")
-
-        method_url = f"{base_url}/v1/images/method"
-        status, body = http_get(method_url, headers={"Authorization": f"Bearer {api_key}"}, timeout=timeout)
-        require_ok("/v1/images/method", status, body)
-        parsed_method = try_parse_json(body) or {}
-        method = str((parsed_method.get("image_generation_method") if isinstance(parsed_method, dict) else "") or "")
-        if method not in {"legacy", "imagine_ws_experimental"}:
-            raise SystemExit(f"[smoke] /v1/images/method unexpected value: {method!r}")
-        print(f"[smoke] /v1/images/method OK (method={method})")
-
-        if args.check_image_stream:
-            stream_url = f"{base_url}/v1/images/generations"
-            payload = {
-                "prompt": "smoke test image",
-                "model": "grok-imagine-1.0",
-                "n": 1,
-                "stream": True,
-                "response_format": "b64_json",
-            }
-            status, resp_headers, body = http_post(
-                stream_url,
-                body=json.dumps(payload).encode("utf-8"),
-                headers={
-                    "Authorization": f"Bearer {api_key}",
-                    "Content-Type": "application/json",
-                },
-                timeout=timeout,
-            )
-            require_ok("/v1/images/generations(stream)", status, body)
-            ctype = str(resp_headers.get("content-type", "")).lower()
-            if "text/event-stream" not in ctype:
-                raise SystemExit(
-                    f"[smoke] /v1/images/generations(stream) invalid content-type: {ctype!r}"
-                )
-            print("[smoke] /v1/images/generations(stream) Content-Type OK")
-    else:
-        print("[smoke] /v1/models and /v1/images/method skipped (no --api-key)")
-
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

scripts/start.sh

@@ -1,11 +0,0 @@
-#!/usr/bin/env sh
-set -eu
-
-HOST="${SERVER_HOST:-0.0.0.0}"
-PORT="${SERVER_PORT:-8000}"
-WORKERS="${SERVER_WORKERS:-1}"
-
-LOG_LEVEL_LOWER="$(printf "%s" "${LOG_LEVEL:-INFO}" | tr '[:upper:]' '[:lower:]')"
-
-exec uvicorn main:app --host "$HOST" --port "$PORT" --workers "$WORKERS" --log-level "$LOG_LEVEL_LOWER"
-

scripts/turnstile_solver/api_solver.py

@@ -1,1047 +0,0 @@
-import os
-import sys
-import time
-import uuid
-import random
-import logging
-import asyncio
-from typing import Optional, Union
-import argparse
-from quart import Quart, request, jsonify
-try:
-    from camoufox.async_api import AsyncCamoufox
-except Exception:  # pragma: no cover
-    AsyncCamoufox = None  # type: ignore
-
-try:
-    from patchright.async_api import async_playwright
-except Exception:  # pragma: no cover
-    from playwright.async_api import async_playwright
-from db_results import init_db, save_result, load_result, cleanup_old_results
-from browser_configs import browser_config
-from rich.console import Console
-from rich.panel import Panel
-from rich.text import Text
-from rich.align import Align
-from rich import box
-
-
-
-COLORS = {
-    'MAGENTA': '\033[35m',
-    'BLUE': '\033[34m',
-    'GREEN': '\033[32m',
-    'YELLOW': '\033[33m',
-    'RED': '\033[31m',
-    'RESET': '\033[0m',
-}
-
-
-class CustomLogger(logging.Logger):
-    @staticmethod
-    def format_message(level, color, message):
-        timestamp = time.strftime('%H:%M:%S')
-        return f"[{timestamp}] [{COLORS.get(color)}{level}{COLORS.get('RESET')}] -> {message}"
-
-    def debug(self, message, *args, **kwargs):
-        super().debug(self.format_message('DEBUG', 'MAGENTA', message), *args, **kwargs)
-
-    def info(self, message, *args, **kwargs):
-        super().info(self.format_message('INFO', 'BLUE', message), *args, **kwargs)
-
-    def success(self, message, *args, **kwargs):
-        super().info(self.format_message('SUCCESS', 'GREEN', message), *args, **kwargs)
-
-    def warning(self, message, *args, **kwargs):
-        super().warning(self.format_message('WARNING', 'YELLOW', message), *args, **kwargs)
-
-    def error(self, message, *args, **kwargs):
-        super().error(self.format_message('ERROR', 'RED', message), *args, **kwargs)
-
-
-logging.setLoggerClass(CustomLogger)
-logger: CustomLogger = logging.getLogger("TurnstileAPIServer")  # type: ignore
-logger.setLevel(logging.DEBUG)
-handler = logging.StreamHandler(sys.stdout)
-logger.addHandler(handler)
-
-
-class TurnstileAPIServer:
-
-    def __init__(self, headless: bool, useragent: Optional[str], debug: bool, browser_type: str, thread: int, proxy_support: bool, use_random_config: bool = False, browser_name: Optional[str] = None, browser_version: Optional[str] = None):
-        self.app = Quart(__name__)
-        self.debug = debug
-        self.browser_type = browser_type
-        self.headless = headless
-        self.thread_count = thread
-        self.proxy_support = proxy_support
-        self.browser_pool = asyncio.Queue()
-        self.use_random_config = use_random_config
-        self.browser_name = browser_name
-        self.browser_version = browser_version
-        self.console = Console()
-        
-        # Initialize useragent and sec_ch_ua attributes
-        self.useragent = useragent
-        self.sec_ch_ua = None
-        
-        
-        if self.browser_type in ['chromium', 'chrome', 'msedge']:
-            if browser_name and browser_version:
-                config = browser_config.get_browser_config(browser_name, browser_version)
-                if config:
-                    useragent, sec_ch_ua = config
-                    self.useragent = useragent
-                    self.sec_ch_ua = sec_ch_ua
-            elif useragent:
-                self.useragent = useragent
-            else:
-                browser, version, useragent, sec_ch_ua = browser_config.get_random_browser_config(self.browser_type)
-                self.browser_name = browser
-                self.browser_version = version
-                self.useragent = useragent
-                self.sec_ch_ua = sec_ch_ua
-        
-        self.browser_args = []
-        if self.useragent:
-            self.browser_args.append(f"--user-agent={self.useragent}")
-
-        self._setup_routes()
-
-    def display_welcome(self):
-        """Displays welcome screen with logo."""
-        self.console.clear()
-        
-        combined_text = Text()
-        combined_text.append("\nChannel: ", style="bold white")
-        combined_text.append("https://t.me/D3_vin", style="cyan")
-        combined_text.append("\nChat: ", style="bold white")
-        combined_text.append("https://t.me/D3vin_chat", style="cyan")
-        combined_text.append("\nGitHub: ", style="bold white")
-        combined_text.append("https://github.com/D3-vin", style="cyan")
-        combined_text.append("\nVersion: ", style="bold white")
-        combined_text.append("1.2a", style="green")
-        combined_text.append("\n")
-
-        info_panel = Panel(
-            Align.left(combined_text),
-            title="[bold blue]Turnstile Solver[/bold blue]",
-            subtitle="[bold magenta]Dev by D3vin[/bold magenta]",
-            box=box.ROUNDED,
-            border_style="bright_blue",
-            padding=(0, 1),
-            width=50
-        )
-
-        try:
-            self.console.print(info_panel)
-            self.console.print()
-        except UnicodeEncodeError:
-            # Fallback for Windows consoles with non-UTF8 encoding
-            print("Turnstile Solver")
-            print("Channel: https://t.me/D3_vin")
-            print("Chat: https://t.me/D3vin_chat")
-            print("GitHub: https://github.com/D3-vin")
-            print("Version: 1.2a")
-
-
-
-
-    def _setup_routes(self) -> None:
-        """Set up the application routes."""
-        self.app.before_serving(self._startup)
-        self.app.route('/turnstile', methods=['GET'])(self.process_turnstile)
-        self.app.route('/result', methods=['GET'])(self.get_result)
-        self.app.route('/')(self.index)
-        
-
-    async def _startup(self) -> None:
-        """Initialize the browser and page pool on startup."""
-        self.display_welcome()
-        logger.info("Starting browser initialization")
-        try:
-            await init_db()
-            await self._initialize_browser()
-            
-            # Запускаем периодическую очистку старых результатов
-            asyncio.create_task(self._periodic_cleanup())
-            
-        except Exception as e:
-            logger.error(f"Failed to initialize browser: {str(e)}")
-            raise
-
-    async def _initialize_browser(self) -> None:
-        """Initialize the browser and create the page pool."""
-        playwright = None
-        camoufox = None
-
-        if self.browser_type in ['chromium', 'chrome', 'msedge']:
-            playwright = await async_playwright().start()
-        elif self.browser_type == "camoufox":
-            if AsyncCamoufox is None:
-                raise RuntimeError("camoufox is not installed. Please install camoufox or use --browser_type chromium.")
-            camoufox = AsyncCamoufox(headless=self.headless)
-
-        browser_configs = []
-        for _ in range(self.thread_count):
-            if self.browser_type in ['chromium', 'chrome', 'msedge']:
-                if self.use_random_config:
-                    browser, version, useragent, sec_ch_ua = browser_config.get_random_browser_config(self.browser_type)
-                elif self.browser_name and self.browser_version:
-                    config = browser_config.get_browser_config(self.browser_name, self.browser_version)
-                    if config:
-                        useragent, sec_ch_ua = config
-                        browser = self.browser_name
-                        version = self.browser_version
-                    else:
-                        browser, version, useragent, sec_ch_ua = browser_config.get_random_browser_config(self.browser_type)
-                else:
-                    browser = getattr(self, 'browser_name', 'custom')
-                    version = getattr(self, 'browser_version', 'custom')
-                    useragent = self.useragent
-                    sec_ch_ua = getattr(self, 'sec_ch_ua', '')
-            else:
-                # Для camoufox и других браузеров используем значения по умолчанию
-                browser = self.browser_type
-                version = 'custom'
-                useragent = self.useragent
-                sec_ch_ua = getattr(self, 'sec_ch_ua', '')
-
-            
-            browser_configs.append({
-                'browser_name': browser,
-                'browser_version': version,
-                'useragent': useragent,
-                'sec_ch_ua': sec_ch_ua
-            })
-
-        for i in range(self.thread_count):
-            config = browser_configs[i]
-            
-            browser_args = [
-                "--window-position=0,0",
-                "--force-device-scale-factor=1"
-            ]
-            if config['useragent']:
-                browser_args.append(f"--user-agent={config['useragent']}")
-            
-            browser = None
-            if self.browser_type in ['chromium', 'chrome', 'msedge'] and playwright:
-                launch_kwargs = {
-                    "headless": self.headless,
-                    "args": browser_args,
-                }
-                # Only pass `channel` for branded browsers. Playwright's bundled Chromium does not use channel.
-                if self.browser_type in ["chrome", "msedge"]:
-                    launch_kwargs["channel"] = self.browser_type
-                browser = await playwright.chromium.launch(**launch_kwargs)
-            elif self.browser_type == "camoufox" and camoufox:
-                browser = await camoufox.start()
-
-            if browser:
-                await self.browser_pool.put((i+1, browser, config))
-
-            if self.debug:
-                logger.info(f"Browser {i + 1} initialized successfully with {config['browser_name']} {config['browser_version']}")
-
-        logger.info(f"Browser pool initialized with {self.browser_pool.qsize()} browsers")
-        
-        if self.use_random_config:
-            logger.info(f"Each browser in pool received random configuration")
-        elif self.browser_name and self.browser_version:
-            logger.info(f"All browsers using configuration: {self.browser_name} {self.browser_version}")
-        else:
-            logger.info("Using custom configuration")
-            
-        if self.debug:
-            for i, config in enumerate(browser_configs):
-                logger.debug(f"Browser {i+1} config: {config['browser_name']} {config['browser_version']}")
-                logger.debug(f"Browser {i+1} User-Agent: {config['useragent']}")
-                logger.debug(f"Browser {i+1} Sec-CH-UA: {config['sec_ch_ua']}")
-
-    async def _periodic_cleanup(self):
-        """Periodic cleanup of old results every hour"""
-        while True:
-            try:
-                await asyncio.sleep(3600)
-                deleted_count = await cleanup_old_results(days_old=7)
-                if deleted_count > 0:
-                    logger.info(f"Cleaned up {deleted_count} old results")
-            except Exception as e:
-                logger.error(f"Error during periodic cleanup: {e}")
-
-    async def _antishadow_inject(self, page):
-        await page.add_init_script("""
-          (function() {
-            const originalAttachShadow = Element.prototype.attachShadow;
-            Element.prototype.attachShadow = function(init) {
-              const shadow = originalAttachShadow.call(this, init);
-              if (init.mode === 'closed') {
-                window.__lastClosedShadowRoot = shadow;
-              }
-              return shadow;
-            };
-          })();
-        """)
-
-
-
-    async def _optimized_route_handler(self, route):
-        """Оптимизированный обработчик маршрутов для экономии ресурсов."""
-        url = route.request.url
-        resource_type = route.request.resource_type
-
-        allowed_types = {'document', 'script', 'xhr', 'fetch'}
-
-        allowed_domains = [
-            'challenges.cloudflare.com',
-            'static.cloudflareinsights.com',
-            'cloudflare.com'
-        ]
-        
-        if resource_type in allowed_types:
-            await route.continue_()
-        elif any(domain in url for domain in allowed_domains):
-            await route.continue_() 
-        else:
-            await route.abort()
-
-    async def _block_rendering(self, page):
-        """Блокировка рендеринга для экономии ресурсов"""
-        await page.route("**/*", self._optimized_route_handler)
-
-    async def _unblock_rendering(self, page):
-        """Разблокировка рендеринга"""
-        await page.unroute("**/*", self._optimized_route_handler)
-
-    async def _find_turnstile_elements(self, page, index: int):
-        """Умная проверка всех возможных Turnstile элементов"""
-        selectors = [
-            '.cf-turnstile',
-            '[data-sitekey]',
-            'iframe[src*="turnstile"]',
-            'iframe[title*="widget"]',
-            'div[id*="turnstile"]',
-            'div[class*="turnstile"]'
-        ]
-        
-        elements = []
-        for selector in selectors:
-            try:
-                # Безопасная проверка count()
-                try:
-                    count = await page.locator(selector).count()
-                except Exception:
-                    # Если count() дает ошибку, пропускаем этот селектор
-                    continue
-                    
-                if count > 0:
-                    elements.append((selector, count))
-                    if self.debug:
-                        logger.debug(f"Browser {index}: Found {count} elements with selector '{selector}'")
-            except Exception as e:
-                if self.debug:
-                    logger.debug(f"Browser {index}: Selector '{selector}' failed: {str(e)}")
-                continue
-        
-        return elements
-
-    async def _find_and_click_checkbox(self, page, index: int):
-        """Найти и кликнуть по чекбоксу Turnstile CAPTCHA внутри iframe"""
-        try:
-            # Пробуем разные селекторы iframe с защитой от ошибок
-            iframe_selectors = [
-                'iframe[src*="challenges.cloudflare.com"]',
-                'iframe[src*="turnstile"]',
-                'iframe[title*="widget"]'
-            ]
-            
-            iframe_locator = None
-            for selector in iframe_selectors:
-                try:
-                    test_locator = page.locator(selector).first
-                    # Безопасная проверка count для iframe
-                    try:
-                        iframe_count = await test_locator.count()
-                    except Exception:
-                        iframe_count = 0
-                        
-                    if iframe_count > 0:
-                        iframe_locator = test_locator
-                        if self.debug:
-                            logger.debug(f"Browser {index}: Found Turnstile iframe with selector: {selector}")
-                        break
-                except Exception as e:
-                    if self.debug:
-                        logger.debug(f"Browser {index}: Iframe selector '{selector}' failed: {str(e)}")
-                    continue
-            
-            if iframe_locator:
-                try:
-                    # Получаем frame из iframe
-                    iframe_element = await iframe_locator.element_handle()
-                    frame = await iframe_element.content_frame()
-                    
-                    if frame:
-                        # Ищем чекбокс внутри iframe
-                        checkbox_selectors = [
-                            'input[type="checkbox"]',
-                            '.cb-lb input[type="checkbox"]',
-                            'label input[type="checkbox"]'
-                        ]
-                        
-                        for selector in checkbox_selectors:
-                            try:
-                                # Полностью избегаем locator.count() в iframe - используем альтернативный подход
-                                try:
-                                    # Пробуем кликнуть напрямую без count проверки
-                                    checkbox = frame.locator(selector).first
-                                    await checkbox.click(timeout=2000)
-                                    if self.debug:
-                                        logger.debug(f"Browser {index}: Successfully clicked checkbox in iframe with selector '{selector}'")
-                                    return True
-                                except Exception as click_e:
-                                    # Если прямой клик не сработал, записываем в debug но не падаем
-                                    if self.debug:
-                                        logger.debug(f"Browser {index}: Direct checkbox click failed for '{selector}': {str(click_e)}")
-                                    continue
-                            except Exception as e:
-                                if self.debug:
-                                    logger.debug(f"Browser {index}: Iframe checkbox selector '{selector}' failed: {str(e)}")
-                                continue
-                    
-                        # Если нашли iframe, но не смогли кликнуть чекбокс, пробуем клик по iframe
-                        try:
-                            if self.debug:
-                                logger.debug(f"Browser {index}: Trying to click iframe directly as fallback")
-                            await iframe_locator.click(timeout=1000)
-                            return True
-                        except Exception as e:
-                            if self.debug:
-                                logger.debug(f"Browser {index}: Iframe direct click failed: {str(e)}")
-                
-                except Exception as e:
-                    if self.debug:
-                        logger.debug(f"Browser {index}: Failed to access iframe content: {str(e)}")
-            
-        except Exception as e:
-            if self.debug:
-                logger.debug(f"Browser {index}: General iframe search failed: {str(e)}")
-        
-        return False
-
-    async def _try_click_strategies(self, page, index: int):
-        strategies = [
-            ('checkbox_click', lambda: self._find_and_click_checkbox(page, index)),
-            ('direct_widget', lambda: self._safe_click(page, '.cf-turnstile', index)),
-            ('iframe_click', lambda: self._safe_click(page, 'iframe[src*="turnstile"]', index)),
-            ('js_click', lambda: page.evaluate("document.querySelector('.cf-turnstile')?.click()")),
-            ('sitekey_attr', lambda: self._safe_click(page, '[data-sitekey]', index)),
-            ('any_turnstile', lambda: self._safe_click(page, '*[class*="turnstile"]', index)),
-            ('xpath_click', lambda: self._safe_click(page, "//div[@class='cf-turnstile']", index))
-        ]
-        
-        for strategy_name, strategy_func in strategies:
-            try:
-                result = await strategy_func()
-                if result is True or result is None:  # None означает успех для большинства стратегий
-                    if self.debug:
-                        logger.debug(f"Browser {index}: Click strategy '{strategy_name}' succeeded")
-                    return True
-            except Exception as e:
-                if self.debug:
-                    logger.debug(f"Browser {index}: Click strategy '{strategy_name}' failed: {str(e)}")
-                continue
-        
-        return False
-
-    async def _safe_click(self, page, selector: str, index: int):
-        """Полностью безопасный клик с максимальной защитой от ошибо��"""
-        try:
-            # Пробуем кликнуть напрямую без count() проверки
-            locator = page.locator(selector).first
-            await locator.click(timeout=1000)
-            return True
-        except Exception as e:
-            # Логируем ошибку только в debug режиме
-            if self.debug and "Can't query n-th element" not in str(e):
-                logger.debug(f"Browser {index}: Safe click failed for '{selector}': {str(e)}")
-            return False
-
-    async def _inject_captcha_directly(self, page, websiteKey: str, action: str = '', cdata: str = '', index: int = 0):
-        """Inject CAPTCHA directly into the target website"""
-        script = f"""
-        // Remove any existing turnstile widgets first
-        document.querySelectorAll('.cf-turnstile').forEach(el => el.remove());
-        document.querySelectorAll('[data-sitekey]').forEach(el => el.remove());
-        
-        // Create turnstile widget directly on the page
-        const captchaDiv = document.createElement('div');
-        captchaDiv.className = 'cf-turnstile';
-        captchaDiv.setAttribute('data-sitekey', '{websiteKey}');
-        captchaDiv.setAttribute('data-callback', 'onTurnstileCallback');
-        {f'captchaDiv.setAttribute("data-action", "{action}");' if action else ''}
-        {f'captchaDiv.setAttribute("data-cdata", "{cdata}");' if cdata else ''}
-        captchaDiv.style.position = 'fixed';
-        captchaDiv.style.top = '20px';
-        captchaDiv.style.left = '20px';
-        captchaDiv.style.zIndex = '9999';
-        captchaDiv.style.backgroundColor = 'white';
-        captchaDiv.style.padding = '15px';
-        captchaDiv.style.border = '2px solid #0f79af';
-        captchaDiv.style.borderRadius = '8px';
-        captchaDiv.style.boxShadow = '0 4px 12px rgba(0, 0, 0, 0.3)';
-        
-        // Add to body immediately
-        document.body.appendChild(captchaDiv);
-        
-        // Load Turnstile script and render widget
-        const loadTurnstile = () => {{
-            const script = document.createElement('script');
-            script.src = 'https://challenges.cloudflare.com/turnstile/v0/api.js';
-            script.async = true;
-            script.defer = true;
-            script.onload = function() {{
-                console.log('Turnstile script loaded');
-                // Wait a bit for script to initialize
-                setTimeout(() => {{
-                    if (window.turnstile && window.turnstile.render) {{
-                        try {{
-                            window.turnstile.render(captchaDiv, {{
-                                sitekey: '{websiteKey}',
-                                {f'action: "{action}",' if action else ''}
-                                {f'cdata: "{cdata}",' if cdata else ''}
-                                callback: function(token) {{
-                                    console.log('Turnstile solved with token:', token);
-                                    // Create hidden input for token
-                                    let tokenInput = document.querySelector('input[name="cf-turnstile-response"]');
-                                    if (!tokenInput) {{
-                                        tokenInput = document.createElement('input');
-                                        tokenInput.type = 'hidden';
-                                        tokenInput.name = 'cf-turnstile-response';
-                                        document.body.appendChild(tokenInput);
-                                    }}
-                                    tokenInput.value = token;
-                                }},
-                                'error-callback': function(error) {{
-                                    console.log('Turnstile error:', error);
-                                }}
-                            }});
-                        }} catch (e) {{
-                            console.log('Turnstile render error:', e);
-                        }}
-                    }} else {{
-                        console.log('Turnstile API not available');
-                    }}
-                }}, 1000);
-            }};
-            script.onerror = function() {{
-                console.log('Failed to load Turnstile script');
-            }};
-            document.head.appendChild(script);
-        }};
-        
-        // Check if Turnstile is already loaded
-        if (window.turnstile) {{
-            console.log('Turnstile already loaded, rendering immediately');
-            try {{
-                window.turnstile.render(captchaDiv, {{
-                    sitekey: '{websiteKey}',
-                    {f'action: "{action}",' if action else ''}
-                    {f'cdata: "{cdata}",' if cdata else ''}
-                    callback: function(token) {{
-                        console.log('Turnstile solved with token:', token);
-                        let tokenInput = document.querySelector('input[name="cf-turnstile-response"]');
-                        if (!tokenInput) {{
-                            tokenInput = document.createElement('input');
-                            tokenInput.type = 'hidden';
-                            tokenInput.name = 'cf-turnstile-response';
-                            document.body.appendChild(tokenInput);
-                        }}
-                        tokenInput.value = token;
-                    }},
-                    'error-callback': function(error) {{
-                        console.log('Turnstile error:', error);
-                    }}
-                }});
-            }} catch (e) {{
-                console.log('Immediate render error:', e);
-                loadTurnstile();
-            }}
-        }} else {{
-            loadTurnstile();
-        }}
-        
-        // Setup global callback
-        window.onTurnstileCallback = function(token) {{
-            console.log('Global turnstile callback executed:', token);
-        }};
-        """
-
-        await page.evaluate(script)
-        if self.debug:
-            logger.debug(f"Browser {index}: Injected CAPTCHA directly into website with sitekey: {websiteKey}")
-
-    async def _solve_turnstile(self, task_id: str, url: str, sitekey: str, action: Optional[str] = None, cdata: Optional[str] = None):
-        """Solve the Turnstile challenge."""
-        proxy = None
-
-        index, browser, browser_config = await self.browser_pool.get()
-        
-        try:
-            if hasattr(browser, 'is_connected') and not browser.is_connected():
-                if self.debug:
-                    logger.warning(f"Browser {index}: Browser disconnected, skipping")
-                await self.browser_pool.put((index, browser, browser_config))
-                await save_result(task_id, "turnstile", {"value": "CAPTCHA_FAIL", "elapsed_time": 0})
-                return
-        except Exception as e:
-            if self.debug:
-                logger.warning(f"Browser {index}: Cannot check browser state: {str(e)}")
-
-        if self.proxy_support:
-            proxy_file_path = os.path.join(os.getcwd(), "proxies.txt")
-
-            try:
-                with open(proxy_file_path) as proxy_file:
-                    proxies = [line.strip() for line in proxy_file if line.strip()]
-
-                proxy = random.choice(proxies) if proxies else None
-                
-                if self.debug and proxy:
-                    logger.debug(f"Browser {index}: Selected proxy: {proxy}")
-                elif self.debug and not proxy:
-                    logger.debug(f"Browser {index}: No proxies available")
-                    
-            except FileNotFoundError:
-                logger.warning(f"Proxy file not found: {proxy_file_path}")
-                proxy = None
-            except Exception as e:
-                logger.error(f"Error reading proxy file: {str(e)}")
-                proxy = None
-
-            if proxy:
-                if '@' in proxy:
-                    try:
-                        scheme_part, auth_part = proxy.split('://')
-                        auth, address = auth_part.split('@')
-                        username, password = auth.split(':')
-                        ip, port = address.split(':')
-                        if self.debug:
-                            logger.debug(f"Browser {index}: Creating context with proxy {scheme_part}://{ip}:{port} (auth: {username}:***)")
-                        context_options = {
-                            "proxy": {
-                                "server": f"{scheme_part}://{ip}:{port}",
-                                "username": username,
-                                "password": password
-                            },
-                            "user_agent": browser_config['useragent']
-                        }
-                        
-                        if browser_config['sec_ch_ua'] and browser_config['sec_ch_ua'].strip():
-                            context_options['extra_http_headers'] = {
-                                'sec-ch-ua': browser_config['sec_ch_ua']
-                            }
-                        
-                        context = await browser.new_context(**context_options)
-                    except ValueError:
-                        raise ValueError(f"Invalid proxy format: {proxy}")
-                else:
-                    parts = proxy.split(':')
-                    if len(parts) == 5:
-                        proxy_scheme, proxy_ip, proxy_port, proxy_user, proxy_pass = parts
-                        if self.debug:
-                            logger.debug(f"Browser {index}: Creating context with proxy {proxy_scheme}://{proxy_ip}:{proxy_port} (auth: {proxy_user}:***)")
-                        context_options = {
-                            "proxy": {
-                                "server": f"{proxy_scheme}://{proxy_ip}:{proxy_port}",
-                                "username": proxy_user,
-                                "password": proxy_pass
-                            },
-                            "user_agent": browser_config['useragent']
-                        }
-                        
-                        if browser_config['sec_ch_ua'] and browser_config['sec_ch_ua'].strip():
-                            context_options['extra_http_headers'] = {
-                                'sec-ch-ua': browser_config['sec_ch_ua']
-                            }
-                        
-                        context = await browser.new_context(**context_options)
-                    elif len(parts) == 3:
-                        if self.debug:
-                            logger.debug(f"Browser {index}: Creating context with proxy {proxy}")
-                        context_options = {
-                            "proxy": {"server": f"{proxy}"},
-                            "user_agent": browser_config['useragent']
-                        }
-                        
-                        if browser_config['sec_ch_ua'] and browser_config['sec_ch_ua'].strip():
-                            context_options['extra_http_headers'] = {
-                                'sec-ch-ua': browser_config['sec_ch_ua']
-                            }
-                        
-                        context = await browser.new_context(**context_options)
-                    else:
-                        raise ValueError(f"Invalid proxy format: {proxy}")
-            else:
-                if self.debug:
-                    logger.debug(f"Browser {index}: Creating context without proxy")
-                context_options = {"user_agent": browser_config['useragent']}
-                
-                if browser_config['sec_ch_ua'] and browser_config['sec_ch_ua'].strip():
-                    context_options['extra_http_headers'] = {
-                        'sec-ch-ua': browser_config['sec_ch_ua']
-                    }
-                
-                context = await browser.new_context(**context_options)
-        else:
-            context_options = {"user_agent": browser_config['useragent']}
-            
-            if browser_config['sec_ch_ua'] and browser_config['sec_ch_ua'].strip():
-                context_options['extra_http_headers'] = {
-                    'sec-ch-ua': browser_config['sec_ch_ua']
-                }
-            
-            context = await browser.new_context(**context_options)
-
-        page = await context.new_page()
-        
-        await self._antishadow_inject(page)
-        
-        await self._block_rendering(page)
-        
-        await page.add_init_script("""
-        Object.defineProperty(navigator, 'webdriver', {
-            get: () => undefined,
-        });
-        
-        window.chrome = {
-            runtime: {},
-            loadTimes: function() {},
-            csi: function() {},
-        };
-        """)
-        
-        if self.browser_type in ['chromium', 'chrome', 'msedge']:
-            await page.set_viewport_size({"width": 500, "height": 100})
-            if self.debug:
-                logger.debug(f"Browser {index}: Set viewport size to 500x240")
-
-        start_time = time.time()
-
-        try:
-            if self.debug:
-                logger.debug(f"Browser {index}: Starting Turnstile solve for URL: {url} with Sitekey: {sitekey} | Action: {action} | Cdata: {cdata} | Proxy: {proxy}")
-                logger.debug(f"Browser {index}: Setting up optimized page loading with resource blocking")
-
-            if self.debug:
-                logger.debug(f"Browser {index}: Loading real website directly: {url}")
-
-            await page.goto(url, wait_until='domcontentloaded', timeout=30000)
-
-            await self._unblock_rendering(page)
-
-            # Сразу инъектируем виджет Turnstile на целевой сайт
-            if self.debug:
-                logger.debug(f"Browser {index}: Injecting Turnstile widget directly into target site")
-            
-            await self._inject_captcha_directly(page, sitekey, action or '', cdata or '', index)
-            
-            # Ждем время для загрузки и рендеринга виджета
-            await asyncio.sleep(3)
-
-            locator = page.locator('input[name="cf-turnstile-response"]')
-            max_attempts = 30
-            click_count = 0
-            max_clicks = 10
-
-            for attempt in range(max_attempts):
-                try:
-                    # Безопасная проверка количества элементов с токеном
-                    try:
-                        count = await locator.count()
-                    except Exception as e:
-                        if self.debug:
-                            logger.debug(f"Browser {index}: Locator count failed on attempt {attempt + 1}: {str(e)}")
-                        count = 0
-
-                    if count == 0:
-                        if self.debug and attempt % 5 == 0:
-                            logger.debug(f"Browser {index}: No token elements found on attempt {attempt + 1}")
-                    elif count == 1:
-                        # Если только од��н элемент, проверяем его токен
-                        try:
-                            token = await locator.input_value(timeout=500)
-                            if token:
-                                elapsed_time = round(time.time() - start_time, 3)
-                                logger.success(f"Browser {index}: Successfully solved captcha - {COLORS.get('MAGENTA')}{token[:10]}{COLORS.get('RESET')} in {COLORS.get('GREEN')}{elapsed_time}{COLORS.get('RESET')} Seconds")
-                                await save_result(task_id, "turnstile", {"value": token, "elapsed_time": elapsed_time})
-                                return
-                        except Exception as e:
-                            if self.debug:
-                                logger.debug(f"Browser {index}: Single token element check failed: {str(e)}")
-                    else:
-                        # Если несколько элементов, проверяем все по очереди
-                        if self.debug:
-                            logger.debug(f"Browser {index}: Found {count} token elements, checking all")
-
-                        for i in range(count):
-                            try:
-                                element_token = await locator.nth(i).input_value(timeout=500)
-                                if element_token:
-                                    elapsed_time = round(time.time() - start_time, 3)
-                                    logger.success(f"Browser {index}: Successfully solved captcha - {COLORS.get('MAGENTA')}{element_token[:10]}{COLORS.get('RESET')} in {COLORS.get('GREEN')}{elapsed_time}{COLORS.get('RESET')} Seconds")
-                                    await save_result(task_id, "turnstile", {"value": element_token, "elapsed_time": elapsed_time})
-                                    return
-                            except Exception as e:
-                                if self.debug:
-                                    logger.debug(f"Browser {index}: Token element {i} check failed: {str(e)}")
-                                continue
-
-                    if attempt > 2 and attempt % 3 == 0 and click_count < max_clicks:
-                        click_success = await self._try_click_strategies(page, index)
-                        click_count += 1
-                        if click_success and self.debug:
-                            logger.debug(f"Browser {index}: Click successful (click #{click_count}/{max_clicks})")
-                        elif not click_success and self.debug:
-                            logger.debug(f"Browser {index}: All click strategies failed on attempt {attempt + 1} (click #{click_count}/{max_clicks})")
-
-                    # Адаптивное ожидание
-                    wait_time = min(0.5 + (attempt * 0.05), 2.0)
-                    await asyncio.sleep(wait_time)
-
-                    if self.debug and attempt % 5 == 0:
-                        logger.debug(f"Browser {index}: Attempt {attempt + 1}/{max_attempts} - Waiting for token (clicks: {click_count}/{max_clicks})")
-
-                except Exception as e:
-                    if self.debug:
-                        logger.debug(f"Browser {index}: Attempt {attempt + 1} error: {str(e)}")
-                    continue
-            
-            elapsed_time = round(time.time() - start_time, 3)
-            await save_result(task_id, "turnstile", {"value": "CAPTCHA_FAIL", "elapsed_time": elapsed_time})
-            if self.debug:
-                logger.error(f"Browser {index}: Error solving Turnstile in {COLORS.get('RED')}{elapsed_time}{COLORS.get('RESET')} Seconds")
-        except Exception as e:
-            elapsed_time = round(time.time() - start_time, 3)
-            await save_result(task_id, "turnstile", {"value": "CAPTCHA_FAIL", "elapsed_time": elapsed_time})
-            if self.debug:
-                logger.error(f"Browser {index}: Error solving Turnstile: {str(e)}")
-        finally:
-            if self.debug:
-                logger.debug(f"Browser {index}: Closing browser context and cleaning up")
-            
-            try:
-                await context.close()
-                if self.debug:
-                    logger.debug(f"Browser {index}: Context closed successfully")
-            except Exception as e:
-                if self.debug:
-                    logger.warning(f"Browser {index}: Error closing context: {str(e)}")
-            
-            try:
-                if hasattr(browser, 'is_connected') and browser.is_connected():
-                    await self.browser_pool.put((index, browser, browser_config))
-                    if self.debug:
-                        logger.debug(f"Browser {index}: Browser returned to pool")
-                else:
-                    if self.debug:
-                        logger.warning(f"Browser {index}: Browser disconnected, not returning to pool")
-            except Exception as e:
-                if self.debug:
-                    logger.warning(f"Browser {index}: Error returning browser to pool: {str(e)}")
-
-
-
-
-
-
-    async def process_turnstile(self):
-        """Handle the /turnstile endpoint requests."""
-        url = request.args.get('url')
-        sitekey = request.args.get('sitekey')
-        action = request.args.get('action')
-        cdata = request.args.get('cdata')
-
-        if not url or not sitekey:
-            return jsonify({
-                "errorId": 1,
-                "errorCode": "ERROR_WRONG_PAGEURL",
-                "errorDescription": "Both 'url' and 'sitekey' are required"
-            }), 200
-
-        task_id = str(uuid.uuid4())
-        await save_result(task_id, "turnstile", {
-            "status": "CAPTCHA_NOT_READY",
-            "createTime": int(time.time()),
-            "url": url,
-            "sitekey": sitekey,
-            "action": action,
-            "cdata": cdata
-        })
-
-        try:
-            asyncio.create_task(self._solve_turnstile(task_id=task_id, url=url, sitekey=sitekey, action=action, cdata=cdata))
-
-            if self.debug:
-                logger.debug(f"Request completed with taskid {task_id}.")
-            return jsonify({
-                "errorId": 0,
-                "taskId": task_id
-            }), 200
-        except Exception as e:
-            logger.error(f"Unexpected error processing request: {str(e)}")
-            return jsonify({
-                "errorId": 1,
-                "errorCode": "ERROR_UNKNOWN",
-                "errorDescription": str(e)
-            }), 200
-
-    async def get_result(self):
-        """Return solved data"""
-        task_id = request.args.get('id')
-
-        if not task_id:
-            return jsonify({
-                "errorId": 1,
-                "errorCode": "ERROR_WRONG_CAPTCHA_ID",
-                "errorDescription": "Invalid task ID/Request parameter"
-            }), 200
-
-        result = await load_result(task_id)
-        if not result:
-            return jsonify({
-                "errorId": 1,
-                "errorCode": "ERROR_CAPTCHA_UNSOLVABLE",
-                "errorDescription": "Task not found"
-            }), 200
-
-        if result == "CAPTCHA_NOT_READY" or (isinstance(result, dict) and result.get("status") == "CAPTCHA_NOT_READY"):
-            return jsonify({"status": "processing"}), 200
-
-        if isinstance(result, dict) and result.get("value") == "CAPTCHA_FAIL":
-            return jsonify({
-                "errorId": 1,
-                "errorCode": "ERROR_CAPTCHA_UNSOLVABLE",
-                "errorDescription": "Workers could not solve the Captcha"
-            }), 200
-
-        if isinstance(result, dict) and result.get("value") and result.get("value") != "CAPTCHA_FAIL":
-            return jsonify({
-                "errorId": 0,
-                "status": "ready",
-                "solution": {
-                    "token": result["value"]
-                }
-            }), 200
-        else:
-            return jsonify({
-                "errorId": 1,
-                "errorCode": "ERROR_CAPTCHA_UNSOLVABLE",
-                "errorDescription": "Workers could not solve the Captcha"
-            }), 200
-
-    
-
-    @staticmethod
-    async def index():
-        """Serve the API documentation page."""
-        return """
-            <!DOCTYPE html>
-            <html lang="en">
-            <head>
-                <meta charset="UTF-8">
-                <meta name="viewport" content="width=device-width, initial-scale=1.0">
-                <title>Turnstile Solver API</title>
-                <script src="https://cdn.tailwindcss.com"></script>
-            </head>
-            <body class="bg-gray-900 text-gray-200 min-h-screen flex items-center justify-center">
-                <div class="bg-gray-800 p-8 rounded-lg shadow-md max-w-2xl w-full border border-red-500">
-                    <h1 class="text-3xl font-bold mb-6 text-center text-red-500">Welcome to Turnstile Solver API</h1>
-
-                    <p class="mb-4 text-gray-300">To use the turnstile service, send a GET request to 
-                       <code class="bg-red-700 text-white px-2 py-1 rounded">/turnstile</code> with the following query parameters:</p>
-
-                    <ul class="list-disc pl-6 mb-6 text-gray-300">
-                        <li><strong>url</strong>: The URL where Turnstile is to be validated</li>
-                        <li><strong>sitekey</strong>: The site key for Turnstile</li>
-                    </ul>
-
-                    <div class="bg-gray-700 p-4 rounded-lg mb-6 border border-red-500">
-                        <p class="font-semibold mb-2 text-red-400">Example usage:</p>
-                        <code class="text-sm break-all text-red-300">/turnstile?url=https://example.com&sitekey=sitekey</code>
-                    </div>
-
-
-                    <div class="bg-gray-700 p-4 rounded-lg mb-6">
-                        <p class="text-gray-200 font-semibold mb-3">📢 Connect with Us</p>
-                        <div class="space-y-2 text-sm">
-                            <p class="text-gray-300">
-                                📢 <strong>Channel:</strong> 
-                                <a href="https://t.me/D3_vin" class="text-red-300 hover:underline">https://t.me/D3_vin</a> 
-                                - Latest updates and releases
-                            </p>
-                            <p class="text-gray-300">
-                                💬 <strong>Chat:</strong> 
-                                <a href="https://t.me/D3vin_chat" class="text-red-300 hover:underline">https://t.me/D3vin_chat</a> 
-                                - Community support and discussions
-                            </p>
-                            <p class="text-gray-300">
-                                📁 <strong>GitHub:</strong> 
-                                <a href="https://github.com/D3-vin" class="text-red-300 hover:underline">https://github.com/D3-vin</a> 
-                                - Source code and development
-                            </p>
-                        </div>
-                    </div>
-                </div>
-            </body>
-            </html>
-        """
-
-
-def parse_args():
-    """Parse command-line arguments."""
-    parser = argparse.ArgumentParser(description="Turnstile API Server")
-
-    parser.add_argument('--no-headless', action='store_true', help='Run the browser with GUI (disable headless mode). By default, headless mode is enabled.')
-    parser.add_argument('--useragent', type=str, help='User-Agent string (if not specified, random configuration is used)')
-    parser.add_argument('--debug', action='store_true', help='Enable or disable debug mode for additional logging and troubleshooting information (default: False)')
-    parser.add_argument('--browser_type', type=str, default='chromium', help='Specify the browser type for the solver. Supported options: chromium, chrome, msedge, camoufox (default: chromium)')
-    parser.add_argument('--thread', type=int, default=4, help='Set the number of browser threads to use for multi-threaded mode. Increasing this will speed up execution but requires more resources (default: 1)')
-    parser.add_argument('--proxy', action='store_true', help='Enable proxy support for the solver (Default: False)')
-    parser.add_argument('--random', action='store_true', help='Use random User-Agent and Sec-CH-UA configuration from pool')
-    parser.add_argument('--browser', type=str, help='Specify browser name to use (e.g., chrome, firefox)')
-    parser.add_argument('--version', type=str, help='Specify browser version to use (e.g., 139, 141)')
-    parser.add_argument('--host', type=str, default='0.0.0.0', help='Specify the IP address where the API solver runs. (Default: 127.0.0.1)')
-    parser.add_argument('--port', type=str, default='5072', help='Set the port for the API solver to listen on. (Default: 5072)')
-    return parser.parse_args()
-
-
-def create_app(headless: bool, useragent: str, debug: bool, browser_type: str, thread: int, proxy_support: bool, use_random_config: bool, browser_name: str, browser_version: str) -> Quart:
-    server = TurnstileAPIServer(headless=headless, useragent=useragent, debug=debug, browser_type=browser_type, thread=thread, proxy_support=proxy_support, use_random_config=use_random_config, browser_name=browser_name, browser_version=browser_version)
-    return server.app
-
-
-if __name__ == '__main__':
-    args = parse_args()
-    browser_types = [
-        'chromium',
-        'chrome',
-        'msedge',
-        'camoufox',
-    ]
-    if args.browser_type not in browser_types:
-        logger.error(f"Unknown browser type: {COLORS.get('RED')}{args.browser_type}{COLORS.get('RESET')} Available browser types: {browser_types}")
-    else:
-        app = create_app(
-            headless=not args.no_headless, 
-            debug=args.debug, 
-            useragent=args.useragent, 
-            browser_type=args.browser_type, 
-            thread=args.thread, 
-            proxy_support=args.proxy,
-            use_random_config=args.random,
-            browser_name=args.browser,
-            browser_version=args.version
-        )
-        app.run(host=args.host, port=int(args.port))

scripts/turnstile_solver/browser_configs.py

@@ -1,17 +0,0 @@
-import random
-
-class browser_config:
-    @staticmethod
-    def get_random_browser_config(browser_type):
-        # 返回: 浏览器名, 版本, User-Agent, Sec-CH-UA
-        versions = ["120.0.0.0", "121.0.0.0", "122.0.0.0", "124.0.0.0"]
-        ver = random.choice(versions)
-        ua = f"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{ver} Safari/537.36"
-        sec_ch_ua = f'"Not(A:Brand";v="99", "Google Chrome";v="{ver.split(".")[0]}", "Chromium";v="{ver.split(".")[0]}"'
-        return "chrome", ver, ua, sec_ch_ua
-
-    @staticmethod
-    def get_browser_config(name, version):
-        ua = f"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{version} Safari/537.36"
-        sec_ch_ua = f'"Google Chrome";v="{version}", "Chromium";v="{version}"'
-        return ua, sec_ch_ua

scripts/turnstile_solver/db_results.py

@@ -1,27 +0,0 @@
-import time
-import asyncio
-
-# 内存数据库，用于临时存储验证码结果
-results_db = {}
-
-async def init_db():
-    print("[系统] 结果数据库初始化成功 (内存模式)")
-
-async def save_result(task_id, task_type, data):
-    # 存储结果，如果 data 是字典则存入，否则构造字典
-    results_db[task_id] = data
-    print(f"[系统] 任务 {task_id} 状态更新: {data.get('value', '正在处理')}")
-
-async def load_result(task_id):
-    return results_db.get(task_id)
-
-async def cleanup_old_results(days_old=7):
-    # 简单的清理逻辑
-    now = time.time()
-    to_delete = []
-    for tid, res in results_db.items():
-        if isinstance(res, dict) and now - res.get('createTime', now) > days_old * 86400:
-            to_delete.append(tid)
-    for tid in to_delete:
-        del results_db[tid]
-    return len(to_delete)

scripts/wait_for_storage.py

@@ -1,85 +0,0 @@
-import os
-import socket
-import sys
-import time
-from urllib.parse import urlparse
-
-
-DEFAULT_PORTS: dict[str, int] = {
-    "redis": 6379,
-    "mysql": 3306,
-    "pgsql": 5432,
-}
-
-
-def _log(msg: str) -> None:
-    print(f"[wait_for_storage] {msg}", flush=True)
-
-
-def _as_int(value: str | None, default: int) -> int:
-    try:
-        return int(value) if value is not None else default
-    except Exception:
-        return default
-
-
-def _get_target(storage_type: str, storage_url: str) -> tuple[str, int] | None:
-    if not storage_url:
-        return None
-
-    parsed = urlparse(storage_url)
-    host = parsed.hostname
-    if not host:
-        return None
-
-    port = parsed.port
-    if port is None:
-        port = DEFAULT_PORTS.get(storage_type)
-
-    if port is None:
-        return None
-
-    return host, int(port)
-
-
-def main() -> int:
-    storage_type = (os.getenv("SERVER_STORAGE_TYPE", "local") or "local").lower().strip()
-    if storage_type in {"", "local"}:
-        return 0
-
-    storage_url = (os.getenv("SERVER_STORAGE_URL", "") or "").strip()
-    target = _get_target(storage_type, storage_url)
-    if target is None:
-        _log(
-            f"skip: unable to parse host/port for SERVER_STORAGE_TYPE={storage_type!r} from SERVER_STORAGE_URL",
-        )
-        return 1
-
-    host, port = target
-    timeout_s = _as_int(os.getenv("STORAGE_WAIT_TIMEOUT"), 60)
-    interval_s = max(0.1, float(os.getenv("STORAGE_WAIT_INTERVAL", "0.5") or "0.5"))
-
-    _log(f"waiting for {storage_type} at {host}:{port} (timeout={timeout_s}s)")
-
-    deadline = time.monotonic() + max(1, timeout_s)
-    last_log_at = 0.0
-
-    while time.monotonic() < deadline:
-        try:
-            with socket.create_connection((host, port), timeout=2):
-                _log("ready")
-                return 0
-        except OSError as e:
-            now = time.monotonic()
-            if now - last_log_at >= 3:
-                _log(f"not ready yet: {e.__class__.__name__}: {e}")
-                last_log_at = now
-            time.sleep(interval_s)
-
-    _log("timeout: storage is still not reachable")
-    return 1
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
-