Upload 33 files

src/main.py

@@ -62,34 +62,42 @@ _IMAGE_TEXT_TYPES = [
 ]
 
 
-@asynccontextmanager
-async def lifespan(app: FastAPI) -> AsyncIterator[None]:
-    # ── startup ──
-    v3_solver = RecaptchaV3Solver(config)
-    await v3_solver.start()
-    for task_type in _RECAPTCHA_V3_TYPES:
-        task_manager.register_solver(task_type, v3_solver)
-    log.info("Registered reCAPTCHA v3 solver for types: %s", _RECAPTCHA_V3_TYPES)
-
-    v2_solver = RecaptchaV2Solver(config)
-    await v2_solver.start()
-    for task_type in _RECAPTCHA_V2_TYPES:
-        task_manager.register_solver(task_type, v2_solver)
-    log.info("Registered reCAPTCHA v2 solver for types: %s", _RECAPTCHA_V2_TYPES)
-
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncIterator[None]:
+    # ── startup ──
+    v3_solver = RecaptchaV3Solver(config)
+    for task_type in _RECAPTCHA_V3_TYPES:
+        task_manager.register_solver(task_type, v3_solver)
+    log.info(
+        "Registered reCAPTCHA v3 solver for types: %s (browser startup deferred)",
+        _RECAPTCHA_V3_TYPES,
+    )
+
+    v2_solver = RecaptchaV2Solver(config)
+    for task_type in _RECAPTCHA_V2_TYPES:
+        task_manager.register_solver(task_type, v2_solver)
+    log.info(
+        "Registered reCAPTCHA v2 solver for types: %s (browser startup deferred)",
+        _RECAPTCHA_V2_TYPES,
+    )
+
     classifier = ClassificationSolver(config)
 
     hcaptcha_solver = HCaptchaSolver(config, classifier=classifier)
-    await hcaptcha_solver.start()
     for task_type in _HCAPTCHA_TYPES:
         task_manager.register_solver(task_type, hcaptcha_solver)
-    log.info("Registered hCaptcha solver for types: %s", _HCAPTCHA_TYPES)
-
-    turnstile_solver = TurnstileSolver(config)
-    await turnstile_solver.start()
-    for task_type in _TURNSTILE_TYPES:
-        task_manager.register_solver(task_type, turnstile_solver)
-    log.info("Registered Turnstile solver for types: %s", _TURNSTILE_TYPES)
+    log.info(
+        "Registered hCaptcha solver for types: %s (browser startup deferred)",
+        _HCAPTCHA_TYPES,
+    )
+
+    turnstile_solver = TurnstileSolver(config)
+    for task_type in _TURNSTILE_TYPES:
+        task_manager.register_solver(task_type, turnstile_solver)
+    log.info(
+        "Registered Turnstile solver for types: %s (browser startup deferred)",
+        _TURNSTILE_TYPES,
+    )
 
     recognizer = CaptchaRecognizer(config)
     for task_type in _IMAGE_TEXT_TYPES:

src/services/hcaptcha.py

@@ -148,31 +148,46 @@ class HCaptchaSolver:
         self._browser: Browser | None = browser
         self._owns_browser = browser is None
         self._classifier = classifier
+        self._start_lock = asyncio.Lock()
 
     async def start(self) -> None:
         if self._browser is not None:
             return
-        self._playwright = await async_playwright().start()
-        self._browser = await self._playwright.chromium.launch(
-            headless=self._config.browser_headless,
-            args=[
-                "--disable-blink-features=AutomationControlled",
-                "--no-sandbox",
-                "--disable-dev-shm-usage",
-                "--disable-gpu",
-            ],
-        )
-        log.info("HCaptchaSolver browser started")
+
+        async with self._start_lock:
+            if self._browser is not None:
+                return
+            playwright = await async_playwright().start()
+            try:
+                browser = await playwright.chromium.launch(
+                    headless=self._config.browser_headless,
+                    args=[
+                        "--disable-blink-features=AutomationControlled",
+                        "--no-sandbox",
+                        "--disable-dev-shm-usage",
+                        "--disable-gpu",
+                    ],
+                )
+            except Exception:
+                await playwright.stop()
+                raise
+            self._playwright = playwright
+            self._browser = browser
+            log.info("HCaptchaSolver browser started lazily")
 
     async def stop(self) -> None:
-        if self._owns_browser:
-            if self._browser:
-                await self._browser.close()
-            if self._playwright:
-                await self._playwright.stop()
+        async with self._start_lock:
+            if self._owns_browser:
+                if self._browser:
+                    await self._browser.close()
+                    self._browser = None
+                if self._playwright:
+                    await self._playwright.stop()
+                    self._playwright = None
         log.info("HCaptchaSolver stopped")
 
     async def solve(self, params: dict[str, Any]) -> dict[str, Any]:
+        await self.start()
         website_url = params["websiteURL"]
         website_key = params["websiteKey"]
         enterprise_payload = params.get("enterprisePayload") or {}

src/services/recaptcha_v2.py

@@ -56,39 +56,54 @@ class RecaptchaV2Solver:
     challenge to the headless browser.
     """
 
-    def __init__(self, config: Config, browser: Browser | None = None) -> None:
-        self._config = config
-        self._playwright: Playwright | None = None
-        self._browser: Browser | None = browser
-        self._owns_browser = browser is None
-
-    async def start(self) -> None:
-        if self._browser is not None:
-            return
-        self._playwright = await async_playwright().start()
-        self._browser = await self._playwright.chromium.launch(
-            headless=self._config.browser_headless,
-            args=[
-                "--disable-blink-features=AutomationControlled",
-                "--no-sandbox",
-                "--disable-dev-shm-usage",
-                "--disable-gpu",
-            ],
-        )
-        log.info("RecaptchaV2Solver browser started")
-
-    async def stop(self) -> None:
-        if self._owns_browser:
-            if self._browser:
-                await self._browser.close()
-            if self._playwright:
-                await self._playwright.stop()
-        log.info("RecaptchaV2Solver stopped")
-
-    async def solve(self, params: dict[str, Any]) -> dict[str, Any]:
-        website_url = params["websiteURL"]
-        website_key = params["websiteKey"]
-        is_invisible = params.get("isInvisible", False)
+    def __init__(self, config: Config, browser: Browser | None = None) -> None:
+        self._config = config
+        self._playwright: Playwright | None = None
+        self._browser: Browser | None = browser
+        self._owns_browser = browser is None
+        self._start_lock = asyncio.Lock()
+
+    async def start(self) -> None:
+        if self._browser is not None:
+            return
+
+        async with self._start_lock:
+            if self._browser is not None:
+                return
+            playwright = await async_playwright().start()
+            try:
+                browser = await playwright.chromium.launch(
+                    headless=self._config.browser_headless,
+                    args=[
+                        "--disable-blink-features=AutomationControlled",
+                        "--no-sandbox",
+                        "--disable-dev-shm-usage",
+                        "--disable-gpu",
+                    ],
+                )
+            except Exception:
+                await playwright.stop()
+                raise
+            self._playwright = playwright
+            self._browser = browser
+            log.info("RecaptchaV2Solver browser started lazily")
+
+    async def stop(self) -> None:
+        async with self._start_lock:
+            if self._owns_browser:
+                if self._browser:
+                    await self._browser.close()
+                    self._browser = None
+                if self._playwright:
+                    await self._playwright.stop()
+                    self._playwright = None
+        log.info("RecaptchaV2Solver stopped")
+
+    async def solve(self, params: dict[str, Any]) -> dict[str, Any]:
+        await self.start()
+        website_url = params["websiteURL"]
+        website_key = params["websiteKey"]
+        is_invisible = params.get("isInvisible", False)
 
         last_error: Exception | None = None
         for attempt in range(self._config.captcha_retries):

src/services/recaptcha_v3.py

@@ -359,6 +359,7 @@ class RecaptchaV3Solver:
         self._config = config
         self._playwright: Playwright | None = None
         self._browser: Browser | None = None
+        self._start_lock = asyncio.Lock()
 
     @staticmethod
     def _build_proxy_settings(raw_proxy_url: str) -> dict[str, str]:
@@ -414,36 +415,54 @@ class RecaptchaV3Solver:
         }
 
     async def start(self) -> None:
-        self._playwright = await async_playwright().start()
-        launch_options: dict[str, Any] = {
-            "headless": self._config.browser_headless,
-            "args": [
-                "--disable-blink-features=AutomationControlled",
-                "--no-sandbox",
-                "--disable-dev-shm-usage",
-                "--disable-gpu",
-            ],
-        }
-        if self._config.browser_proxy_url:
-            launch_options["proxy"] = self._build_proxy_settings(
-                self._config.browser_proxy_url
-            )
+        if self._browser is not None:
+            return
 
-        self._browser = await self._playwright.chromium.launch(**launch_options)
-        log.info(
-            "Playwright browser started (headless=%s proxy=%s)",
-            self._config.browser_headless,
-            "configured" if self._config.browser_proxy_url else "none",
-        )
+        async with self._start_lock:
+            if self._browser is not None:
+                return
+
+            playwright = await async_playwright().start()
+            launch_options: dict[str, Any] = {
+                "headless": self._config.browser_headless,
+                "args": [
+                    "--disable-blink-features=AutomationControlled",
+                    "--no-sandbox",
+                    "--disable-dev-shm-usage",
+                    "--disable-gpu",
+                ],
+            }
+            if self._config.browser_proxy_url:
+                launch_options["proxy"] = self._build_proxy_settings(
+                    self._config.browser_proxy_url
+                )
+
+            try:
+                browser = await playwright.chromium.launch(**launch_options)
+            except Exception:
+                await playwright.stop()
+                raise
+
+            self._playwright = playwright
+            self._browser = browser
+            log.info(
+                "Playwright browser started lazily (headless=%s proxy=%s)",
+                self._config.browser_headless,
+                "configured" if self._config.browser_proxy_url else "none",
+            )
 
     async def stop(self) -> None:
-        if self._browser:
-            await self._browser.close()
-        if self._playwright:
-            await self._playwright.stop()
+        async with self._start_lock:
+            if self._browser:
+                await self._browser.close()
+                self._browser = None
+            if self._playwright:
+                await self._playwright.stop()
+                self._playwright = None
         log.info("Playwright browser stopped")
 
     async def solve(self, params: dict[str, Any]) -> dict[str, Any]:
+        await self.start()
         profile = self._build_task_profile(params)
         last_error: Exception | None = None
         for attempt in range(self._config.captcha_retries):

src/services/turnstile.py

@@ -44,38 +44,53 @@ _EXTRACT_TURNSTILE_TOKEN_JS = """
 class TurnstileSolver:
     """Solves Cloudflare Turnstile tasks via headless Chromium."""
 
-    def __init__(self, config: Config, browser: Browser | None = None) -> None:
-        self._config = config
-        self._playwright: Playwright | None = None
-        self._browser: Browser | None = browser
-        self._owns_browser = browser is None
-
-    async def start(self) -> None:
-        if self._browser is not None:
-            return
-        self._playwright = await async_playwright().start()
-        self._browser = await self._playwright.chromium.launch(
-            headless=self._config.browser_headless,
-            args=[
-                "--disable-blink-features=AutomationControlled",
-                "--no-sandbox",
-                "--disable-dev-shm-usage",
-                "--disable-gpu",
-            ],
-        )
-        log.info("TurnstileSolver browser started")
-
-    async def stop(self) -> None:
-        if self._owns_browser:
-            if self._browser:
-                await self._browser.close()
-            if self._playwright:
-                await self._playwright.stop()
-        log.info("TurnstileSolver stopped")
-
-    async def solve(self, params: dict[str, Any]) -> dict[str, Any]:
-        website_url = params["websiteURL"]
-        website_key = params["websiteKey"]
+    def __init__(self, config: Config, browser: Browser | None = None) -> None:
+        self._config = config
+        self._playwright: Playwright | None = None
+        self._browser: Browser | None = browser
+        self._owns_browser = browser is None
+        self._start_lock = asyncio.Lock()
+
+    async def start(self) -> None:
+        if self._browser is not None:
+            return
+
+        async with self._start_lock:
+            if self._browser is not None:
+                return
+            playwright = await async_playwright().start()
+            try:
+                browser = await playwright.chromium.launch(
+                    headless=self._config.browser_headless,
+                    args=[
+                        "--disable-blink-features=AutomationControlled",
+                        "--no-sandbox",
+                        "--disable-dev-shm-usage",
+                        "--disable-gpu",
+                    ],
+                )
+            except Exception:
+                await playwright.stop()
+                raise
+            self._playwright = playwright
+            self._browser = browser
+            log.info("TurnstileSolver browser started lazily")
+
+    async def stop(self) -> None:
+        async with self._start_lock:
+            if self._owns_browser:
+                if self._browser:
+                    await self._browser.close()
+                    self._browser = None
+                if self._playwright:
+                    await self._playwright.stop()
+                    self._playwright = None
+        log.info("TurnstileSolver stopped")
+
+    async def solve(self, params: dict[str, Any]) -> dict[str, Any]:
+        await self.start()
+        website_url = params["websiteURL"]
+        website_key = params["websiteKey"]
 
         last_error: Exception | None = None
         for attempt in range(self._config.captcha_retries):