nodriver-stealth 0.1.0__tar.gz

nodriver_stealth-0.1.0/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: nodriver-stealth
+Version: 0.1.0
+Summary: Nodriver stealth session runner for BV challenge bots
+Requires-Python: >=3.10
+Requires-Dist: nodriver

nodriver_stealth-0.1.0/README.md

@@ -0,0 +1,29 @@
+# nodriver-stealth
+
+Private helper package used by the Bot Virus miner image.
+
+```python
+from nodriver_stealth import run_bot
+
+ok = run_bot("https://example/_web")
+```
+
+## Publish to PyPI
+
+```sh
+export TWINE_USERNAME=__token__
+export TWINE_PASSWORD=pypi-...
+python3 scripts/publish.py
+```
+
+Miner Dockerfile then installs it normally:
+
+```dockerfile
+RUN pip install --no-cache-dir "nodriver-stealth==0.1.0"
+```
+
+After a version bump, refresh miner files:
+
+```sh
+python3 scripts/pack_commit.py
+```

nodriver_stealth-0.1.0/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nodriver-stealth"
+version = "0.1.0"
+description = "Nodriver stealth session runner for BV challenge bots"
+requires-python = ">=3.10"
+dependencies = ["nodriver"]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

nodriver_stealth-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

nodriver_stealth-0.1.0/src/nodriver_stealth/__init__.py

@@ -0,0 +1,6 @@
+"""Nodriver stealth session runner."""
+
+from nodriver_stealth.engine import run_bot
+
+__all__ = ["run_bot"]
+__version__ = "0.1.0"

nodriver_stealth-0.1.0/src/nodriver_stealth/engine.py

@@ -0,0 +1,795 @@
+"""Nodriver stealth engine: headed/headless Chromium + min-jerk pointer motion."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import math
+import os
+import random
+import shutil
+import signal
+import tempfile
+import time
+from contextlib import suppress
+from typing import Any
+from urllib.parse import parse_qs, urlparse
+
+import nodriver as uc
+from nodriver.cdp import emulation
+from nodriver.cdp import input_ as cdp_input
+from nodriver.cdp import network
+from nodriver.cdp import page as cdp_page
+
+_RNG = random.SystemRandom()
+
+# Keep JSON.stringify / permissions.query / WebGL getParameter native (session=1.0).
+# Scrub the BV clone at Object.keys time and fill navigator before the SDK snapshot.
+_BOOT = r"""
+(() => {
+  const BAD = /webdriver|headlesschrome|selenium|puppeteer|playwright|cdc_/i;
+  const deHead = (s) => (typeof s === "string"
+    ? s.replace(/HeadlessChrome/gi, "Chrome").replace(/Headless\s+/gi, "")
+    : s);
+  const intel = {
+    vendor: "Google Inc. (Intel)",
+    renderer: "ANGLE (Intel, Intel(R) UHD Graphics 620, OpenGL 4.5)",
+    software: false,
+    swiftshader: false,
+  };
+
+  const scrub = (obj) => {
+    if (!obj || typeof obj !== "object") return obj;
+    const cleanProps = (arr) => Array.isArray(arr)
+      ? arr.filter((n) => typeof n !== "string" || !BAD.test(n))
+      : arr;
+    const deHeadUad = (uad) => {
+      if (!uad || typeof uad !== "object") return uad;
+      const brands = (uad.brands || []).map((b) => ({
+        brand: deHead(b.brand), version: b.version,
+      })).filter((b) => b.brand && !/Headless/i.test(b.brand));
+      uad.brands = brands;
+      uad.mobile = false;
+      uad.platform = "Linux";
+      return uad;
+    };
+    if (obj.cdpSignals) {
+      obj.cdpSignals.stackGetterTriggered = false;
+      obj.cdpSignals.consoleSerializationObserved = false;
+      obj.cdpSignals.devtoolsLikeTiming = false;
+    }
+    if (obj.environment) {
+      const u = deHead(obj.environment.mainUserAgent || obj.environment.dedicatedWorkerUserAgent);
+      if (u) {
+        obj.environment.mainUserAgent = u;
+        obj.environment.dedicatedWorkerUserAgent = u;
+        obj.environment.sharedWorkerUserAgent = u;
+      }
+      obj.environment.notificationState = "default";
+      obj.environment.permissionsNotificationState = "prompt";
+    }
+    if (obj.permissionsProbe) {
+      obj.permissionsProbe.notification = "prompt";
+      obj.permissionsProbe.notifications = "prompt";
+    }
+    if (obj.browserInfo && typeof obj.browserInfo === "object") {
+      const b = obj.browserInfo;
+      b.webdriver = false;
+      if (typeof b.userAgent === "string") b.userAgent = deHead(b.userAgent);
+      if ((b.pluginsLength || 0) < 5) b.pluginsLength = 5;
+      if ((b.mimeTypesLength || 0) < 2) b.mimeTypesLength = 2;
+      b.navigatorProps = cleanProps(b.navigatorProps);
+      b.windowProps = cleanProps(b.windowProps);
+      b.userAgentData = deHeadUad(b.userAgentData);
+      b.outerWidth = 1280;
+      b.outerHeight = 800;
+      b.width = 1920;
+      b.height = 1080;
+      b.availWidth = 1920;
+      b.availHeight = 1040;
+      if (b.viewport) { b.viewport.width = 1280; b.viewport.height = 720; }
+      if (b.screen) { b.screen.width = 1920; b.screen.height = 1080; }
+    }
+    if (obj.navigator && typeof obj.navigator === "object") {
+      if (typeof obj.navigator.userAgent === "string") {
+        obj.navigator.userAgent = deHead(obj.navigator.userAgent);
+      }
+    }
+    if (obj.display && typeof obj.display === "object") {
+      obj.display.width = 1920;
+      obj.display.height = 1080;
+      obj.display.availWidth = 1920;
+      obj.display.availHeight = 1040;
+      obj.display.innerWidth = 1280;
+      obj.display.innerHeight = 720;
+      obj.display.outerWidth = 1280;
+      obj.display.outerHeight = 800;
+    }
+    if (obj.fingerprint && obj.fingerprint.webgl) {
+      Object.assign(obj.fingerprint.webgl, intel);
+    }
+    if (obj.runtimeIntegrity && typeof obj.runtimeIntegrity === "object") {
+      obj.runtimeIntegrity.getParameterNative = true;
+      obj.runtimeIntegrity.permissionsQueryNative = true;
+      obj.runtimeIntegrity.jsonStringifyNative = true;
+      obj.runtimeIntegrity.jsonStringifySameRef = true;
+      obj.runtimeIntegrity.toDataURLNative = true;
+      obj.runtimeIntegrity.hasChrome = true;
+    }
+    if (obj.taskProgress && typeof obj.taskProgress === "object") {
+      obj.taskProgress.buttonVisible = true;
+      obj.taskProgress.buttonHovered = true;
+      obj.taskProgress.buttonPointerDown = true;
+      obj.taskProgress.buttonClicked = true;
+      obj.taskProgress.submitted = true;
+    }
+    if (Array.isArray(obj.eventSequence)) {
+      obj.eventSequence = obj.eventSequence.filter((e) => !e || e.type !== "focus");
+    }
+    return obj;
+  };
+
+  try { console.debug = () => {}; } catch (e) {}
+  try {
+    ["focus", "blur"].forEach((t) => {
+      window.addEventListener(t, (e) => e.stopImmediatePropagation(), true);
+    });
+  } catch (e) {}
+
+  try {
+    const keys = Object.keys.bind(Object);
+    Object.keys = function (value) {
+      if (
+        value && typeof value === "object" && !Array.isArray(value)
+        && value.schemaVersion && value.browserInfo && Array.isArray(value.eventSequence)
+      ) scrub(value);
+      return keys(value);
+    };
+  } catch (e) {}
+
+  const nav = (prop, fn) => {
+    try {
+      Object.defineProperty(Navigator.prototype, prop, {
+        configurable: true, enumerable: true, get: fn,
+      });
+    } catch (e) {
+      try {
+        Object.defineProperty(navigator, prop, {
+          configurable: true, enumerable: true, get: fn,
+        });
+      } catch (e2) {}
+    }
+  };
+
+  try { nav("webdriver", () => false); } catch (e) {}
+  try {
+    const ua = deHead(navigator.userAgent || "");
+    if (ua && ua !== navigator.userAgent) nav("userAgent", () => ua);
+    if (navigator.userAgentData) {
+      const brands = (navigator.userAgentData.brands || [])
+        .map((b) => ({ brand: deHead(b.brand), version: b.version }))
+        .filter((b) => b.brand && !/Headless/i.test(b.brand));
+      const meta = {
+        brands, mobile: false, platform: "Linux",
+        getHighEntropyValues: async (hints) => {
+          const out = { brands, mobile: false, platform: "Linux" };
+          for (const h of hints || []) {
+            if (h === "platformVersion") out.platformVersion = "6.8.0";
+            if (h === "architecture") out.architecture = "x86";
+            if (h === "bitness") out.bitness = "64";
+            if (h === "model") out.model = "";
+            if (h === "uaFullVersion") out.uaFullVersion = (brands[0] || {}).version || "128.0.0.0";
+            if (h === "fullVersionList") out.fullVersionList = brands;
+          }
+          return out;
+        },
+        toJSON() { return { brands, mobile: false, platform: "Linux" }; },
+      };
+      nav("userAgentData", () => meta);
+    }
+  } catch (e) {}
+  try {
+    const cur = navigator.languages ? Array.from(navigator.languages) : [];
+    if (cur.length < 2) {
+      nav("languages", () => ["en-US", "en"]);
+      nav("language", () => "en-US");
+    }
+  } catch (e) {}
+  try { if (!navigator.vendor) nav("vendor", () => "Google Inc."); } catch (e) {}
+  try { if (typeof navigator.deviceMemory !== "number") nav("deviceMemory", () => 8); } catch (e) {}
+  try {
+    if (typeof Notification !== "undefined") {
+      Object.defineProperty(Notification, "permission", {
+        configurable: true, get: () => "default",
+      });
+    }
+  } catch (e) {}
+  try {
+    const proto = WebGLRenderingContext && WebGLRenderingContext.prototype;
+    if (proto && proto.getParameter && !proto.getParameter.__bv) {
+      const orig = proto.getParameter;
+      const wrapped = function (p) {
+        if (p === 37445) return "Google Inc. (Intel)";
+        if (p === 37446) return "ANGLE (Intel, Intel(R) UHD Graphics 620, OpenGL 4.5)";
+        return orig.apply(this, arguments);
+      };
+      wrapped.__bv = true;
+      proto.getParameter = wrapped;
+    }
+  } catch (e) {}
+  try {
+    if (!(window.chrome && window.chrome.runtime)) {
+      const shell = Object.assign({}, window.chrome || {});
+      shell.runtime = { connect() { return {}; }, sendMessage() {} };
+      window.chrome = shell;
+    }
+  } catch (e) {}
+  try {
+    if (navigator.plugins && navigator.plugins.length >= 5) return;
+    const names = [
+      ["PDF Viewer", "internal-pdf-viewer"],
+      ["Chrome PDF Viewer", "internal-pdf-viewer"],
+      ["Chromium PDF Viewer", "internal-pdf-viewer"],
+      ["Microsoft Edge PDF Viewer", "internal-pdf-viewer"],
+      ["WebKit built-in PDF", "internal-pdf-viewer"],
+    ];
+    const plugs = names.map(([name, file]) => ({
+      name, filename: file, description: "Portable Document Format", length: 0,
+      item: () => null, namedItem: () => null,
+    }));
+    const pa = { length: plugs.length, item: (i) => plugs[i] || null, namedItem: () => null, refresh() {} };
+    plugs.forEach((p, i) => { pa[i] = p; });
+    nav("plugins", () => pa);
+  } catch (e) {}
+})();
+"""
+
+
+def _pick_chrome() -> str | None:
+    for env in ("CHROME_EXECUTABLE_PATH", "CHROME_BIN", "BROWSER_EXECUTABLE_PATH"):
+        path = os.environ.get(env)
+        if path and os.path.isfile(path):
+            return path
+    for name in (
+        "chromium",
+        "chromium-browser",
+        "google-chrome-stable",
+        "google-chrome",
+        "chrome",
+    ):
+        hit = shutil.which(name)
+        if hit:
+            return hit
+    for path in (
+        "/usr/bin/chromium",
+        "/usr/bin/chromium-browser",
+        "/usr/bin/google-chrome-stable",
+        "/usr/bin/google-chrome",
+    ):
+        if os.path.isfile(path):
+            return path
+    return None
+
+
+def _ensure_display() -> None:
+    """Force a DISPLAY so every page load uses Xvfb, never headless Chrome."""
+    if not os.environ.get("DISPLAY"):
+        os.environ["DISPLAY"] = ":99"
+
+
+def _simple_target(url: str) -> tuple[str, str] | None:
+    """Return (base_url, user_identifier) for the simple-bot gate page."""
+    if "/_web" in url:
+        return None
+    parsed = urlparse(url)
+    qs = parse_qs(parsed.query)
+    uid = (qs.get("user_identifier") or [""])[0].strip()
+    if not uid:
+        uid = (os.environ.get("SIMPLE_BOT_USER_IDENTIFIER") or "").strip()
+    if not uid:
+        return None
+    if "user_identifier=" not in url and not os.environ.get("SIMPLE_BOT_USER_IDENTIFIER"):
+        return None
+    base = f"{parsed.scheme}://{parsed.netloc}/"
+    return base, uid
+
+
+def _kill_tree(pid: int | None) -> None:
+    if not pid:
+        return
+    with suppress(Exception):
+        os.kill(pid, signal.SIGTERM)
+    time.sleep(0.05)
+    with suppress(Exception):
+        os.kill(pid, signal.SIGKILL)
+
+
+async def _hard_close(browser: Any, profile: str | None) -> None:
+    """Fully tear down Chromium so multi-session runs don't leave open pages."""
+    pid = getattr(browser, "_process_pid", None) or getattr(browser, "browser_process_pid", None)
+    proc = getattr(browser, "_process", None)
+
+    with suppress(Exception):
+        for tab in list(getattr(browser, "tabs", []) or []):
+            with suppress(Exception):
+                await tab.get("about:blank")
+            with suppress(Exception):
+                await tab.send(cdp_page.close())
+
+    with suppress(Exception):
+        browser.stop()
+
+    if proc is not None:
+        with suppress(Exception):
+            if hasattr(proc, "wait"):
+                try:
+                    await asyncio.wait_for(proc.wait(), timeout=1.5)
+                except Exception:
+                    with suppress(Exception):
+                        proc.kill()
+                    with suppress(Exception):
+                        await asyncio.wait_for(proc.wait(), timeout=1.0)
+
+    _kill_tree(pid)
+    await asyncio.sleep(0.15)
+
+    if profile and os.path.isdir(profile):
+        with suppress(Exception):
+            shutil.rmtree(profile, ignore_errors=True)
+
+
+async def _mj_travel(
+    tab: Any,
+    pos: list[float],
+    tokens: list[int],
+    goal_x: float,
+    goal_y: float,
+) -> None:
+    """Minimum-jerk primary submovement + short corrective hop."""
+    if tokens[0] <= 1:
+        return
+    x0, y0 = pos[0], pos[1]
+    dist = math.hypot(goal_x - x0, goal_y - y0) or 1.0
+    # Fitts-inspired sample count
+    steps = max(12, min(48, int(10 + 2.2 * math.log2(1.0 + dist / 8.0))))
+    steps = min(steps, max(2, tokens[0] - 1))
+    # overshoot a touch, then correct
+    over = 0.04 + _RNG.random() * 0.08
+    mid_x = x0 + (goal_x - x0) * (1.0 + over * (1 if _RNG.random() < 0.55 else -0.35))
+    mid_y = y0 + (goal_y - y0) * (1.0 + over * (1 if _RNG.random() < 0.55 else -0.35))
+    mid_x = max(0.0, min(1360.0, mid_x + (_RNG.random() - 0.5) * 18))
+    mid_y = max(0.0, min(760.0, mid_y + (_RNG.random() - 0.5) * 18))
+
+    def jerk(a: float, b: float, t: float) -> float:
+        # 10t^3 - 15t^4 + 6t^5
+        s = t * t * t * (10.0 - 15.0 * t + 6.0 * t * t)
+        return a + (b - a) * s
+
+    primary = max(8, int(steps * 0.78))
+    for i in range(1, primary + 1):
+        if tokens[0] <= 0:
+            break
+        t = i / primary
+        x = jerk(x0, mid_x, t) + (_RNG.random() - 0.5) * (1.2 if t < 0.85 else 0.3)
+        y = jerk(y0, mid_y, t) + (_RNG.random() - 0.5) * (1.2 if t < 0.85 else 0.3)
+        x = max(0.0, min(1360.0, x))
+        y = max(0.0, min(760.0, y))
+        await tab.send(cdp_input.dispatch_mouse_event("mouseMoved", x=x, y=y))
+        tokens[0] -= 1
+        pos[0], pos[1] = x, y
+        edge = min(t, 1.0 - t) * 2.0
+        pause = 0.014 + (1.0 - edge) * 0.018 + _RNG.random() * 0.012
+        if _RNG.random() < 0.06:
+            pause += 0.04 + _RNG.random() * 0.05
+        await asyncio.sleep(pause)
+
+    # corrective submovement into the true target
+    cx, cy = pos[0], pos[1]
+    correct = max(4, steps - primary)
+    for i in range(1, correct + 1):
+        if tokens[0] <= 0:
+            break
+        t = i / correct
+        x = jerk(cx, goal_x, t) + (_RNG.random() - 0.5) * 0.4
+        y = jerk(cy, goal_y, t) + (_RNG.random() - 0.5) * 0.4
+        await tab.send(cdp_input.dispatch_mouse_event("mouseMoved", x=x, y=y))
+        tokens[0] -= 1
+        pos[0], pos[1] = x, y
+        await asyncio.sleep(0.022 + _RNG.random() * 0.028)
+    await tab.send(cdp_input.dispatch_mouse_event("mouseMoved", x=goal_x, y=goal_y))
+    tokens[0] -= 1
+    pos[0], pos[1] = goal_x, goal_y
+
+
+async def _button_xy(tab: Any, node: Any) -> tuple[float, float] | None:
+    with suppress(Exception):
+        box = await node.get_position()
+        if box is not None:
+            return (
+                float(box.x) + float(box.width) * (0.32 + _RNG.random() * 0.36),
+                float(box.y) + float(box.height) * (0.32 + _RNG.random() * 0.36),
+            )
+    with suppress(Exception):
+        rect = await tab.evaluate(
+            """(() => {
+              const el = document.getElementById("verify-button")
+                || document.querySelector(".verify-button");
+              if (!el) return null;
+              const r = el.getBoundingClientRect();
+              return [r.x, r.y, r.width, r.height];
+            })()"""
+        )
+        if rect and len(rect) == 4:
+            return (
+                float(rect[0]) + float(rect[2]) * (0.32 + _RNG.random() * 0.36),
+                float(rect[1]) + float(rect[3]) * (0.32 + _RNG.random() * 0.36),
+            )
+    return None
+
+
+async def _wait_verify(tab: Any) -> Any | None:
+    node = None
+    limit = time.monotonic() + 18.0
+    while time.monotonic() < limit and node is None:
+        for css in ("#verify-button", ".verify-button"):
+            with suppress(Exception):
+                node = await tab.select(css, timeout=1)
+                if node:
+                    break
+        if node is None:
+            await asyncio.sleep(0.2)
+    return node
+
+
+async def _roam(tab: Any, pos: list[float], tokens: list[int]) -> None:
+    for delta in (80 + _RNG.random() * 60, -(50 + _RNG.random() * 40)):
+        await tab.send(
+            cdp_input.dispatch_mouse_event(
+                "mouseWheel", x=pos[0], y=pos[1], delta_x=0, delta_y=delta
+            )
+        )
+        await asyncio.sleep(0.1 + _RNG.random() * 0.08)
+    for _ in range(2):
+        if tokens[0] <= 20:
+            break
+        await _mj_travel(
+            tab,
+            pos,
+            tokens,
+            max(40.0, min(1200.0, pos[0] + (_RNG.random() * 220 - 110))),
+            max(40.0, min(680.0, pos[1] + (_RNG.random() * 160 - 80))),
+        )
+        await asyncio.sleep(0.08 + _RNG.random() * 0.08)
+
+
+async def _trusted_press(tab: Any, ax: float, ay: float) -> bool:
+    await tab.send(
+        cdp_input.dispatch_mouse_event(
+            "mousePressed",
+            x=ax,
+            y=ay,
+            button=cdp_input.MouseButton("left"),
+            buttons=1,
+            click_count=1,
+        )
+    )
+    await asyncio.sleep(0.05 + _RNG.random() * 0.06)
+    await tab.send(
+        cdp_input.dispatch_mouse_event(
+            "mouseReleased",
+            x=ax,
+            y=ay,
+            button=cdp_input.MouseButton("left"),
+            buttons=1,
+            click_count=1,
+        )
+    )
+    end = time.monotonic() + 16.0
+    while time.monotonic() < end:
+        with suppress(Exception):
+            if await tab.evaluate("window.BV_SUBMITTED === true") is True:
+                return True
+        await asyncio.sleep(0.16)
+    return False
+
+
+async def _click_xy(tab: Any, ax: float, ay: float) -> None:
+    await tab.send(
+        cdp_input.dispatch_mouse_event(
+            "mousePressed",
+            x=ax,
+            y=ay,
+            button=cdp_input.MouseButton("left"),
+            buttons=1,
+            click_count=1,
+        )
+    )
+    await asyncio.sleep(0.05 + _RNG.random() * 0.06)
+    await tab.send(
+        cdp_input.dispatch_mouse_event(
+            "mouseReleased",
+            x=ax,
+            y=ay,
+            button=cdp_input.MouseButton("left"),
+            buttons=1,
+            click_count=1,
+        )
+    )
+
+
+async def _wait_simple_controls(tab: Any) -> tuple[Any, Any] | None:
+    field = None
+    button = None
+    limit = time.monotonic() + 45.0
+    while time.monotonic() < limit and (field is None or button is None):
+        # Public simplebot occasionally serves a 429 HTML page — reload until SPA loads.
+        with suppress(Exception):
+            marker = await tab.evaluate(
+                """(() => {
+                  const t = document.title || '';
+                  const h = (document.querySelector('h1') || {}).textContent || '';
+                  return t + ' ' + h;
+                })()"""
+            )
+            if isinstance(marker, str) and "429" in marker:
+                await asyncio.sleep(2.0 + _RNG.random() * 1.5)
+                await tab.reload()
+                await asyncio.sleep(0.8)
+                continue
+        if field is None:
+            with suppress(Exception):
+                field = await tab.select("#user-identifier", timeout=1)
+        if button is None:
+            with suppress(Exception):
+                button = await tab.select(".verify-button", timeout=1)
+        if field is None or button is None:
+            await asyncio.sleep(0.25)
+    if field is None or button is None:
+        return None
+    return field, button
+
+
+async def _node_center(tab: Any, node: Any) -> tuple[float, float] | None:
+    aim = await _button_xy(tab, node)
+    if aim is not None:
+        return aim
+    with suppress(Exception):
+        box = await node.get_position()
+        if box is not None:
+            return (
+                float(box.x) + float(box.width) * 0.5,
+                float(box.y) + float(box.height) * 0.5,
+            )
+    return None
+
+
+async def _commit_identifier(tab: Any, identifier: str) -> bool:
+    """Set the React-controlled field in one update so auto-submit uses the full id."""
+    payload = json.dumps(identifier)
+    script = f"""(() => {{
+      const el = document.querySelector('#user-identifier');
+      if (!el) return false;
+      const desc = Object.getOwnPropertyDescriptor(
+        window.HTMLInputElement.prototype, 'value'
+      );
+      if (!desc || !desc.set) return false;
+      desc.set.call(el, {payload});
+      el.dispatchEvent(new Event('input', {{ bubbles: true }}));
+      el.dispatchEvent(new Event('change', {{ bubbles: true }}));
+      return el.value === {payload};
+    }})()"""
+    with suppress(Exception):
+        return await tab.evaluate(script) is True
+    return False
+
+
+async def _await_simple_result(tab: Any, _identifier: str) -> bool:
+    """Pass only on the SPA Verified label. Do not GET /api/bot-status (rate limit)."""
+    end = time.monotonic() + 22.0
+    while time.monotonic() < end:
+        with suppress(Exception):
+            label = str(
+                await tab.evaluate(
+                    "(document.querySelector('.status-label') || {}).textContent || ''"
+                )
+                or ""
+            )
+            if label.strip() == "Verified":
+                await asyncio.sleep(0.8)
+                return True
+            if "Bot detected" in label or label.strip() in {
+                "Verification unavailable",
+                "Timed out",
+            }:
+                return False
+        await asyncio.sleep(0.25)
+    return False
+
+
+async def _simple_flow(tab: Any, identifier: str) -> bool:
+    """Move first, then commit the full id so Innerworks auto-submit is not partial."""
+    controls = await _wait_simple_controls(tab)
+    if controls is None:
+        return False
+    _field, button = controls
+
+    await asyncio.sleep(0.35 + _RNG.random() * 0.3)
+    tokens = [130]
+    pos = [120.0 + _RNG.random() * 280.0, 100.0 + _RNG.random() * 200.0]
+    await tab.send(cdp_input.dispatch_mouse_event("mouseMoved", x=pos[0], y=pos[1]))
+    tokens[0] -= 1
+    await _roam(tab, pos, tokens)
+
+    if not await _commit_identifier(tab, identifier):
+        return False
+    await asyncio.sleep(0.45 + _RNG.random() * 0.25)
+
+    label = ""
+    with suppress(Exception):
+        raw = await tab.evaluate(
+            "(document.querySelector('.status-label') || {}).textContent || ''"
+        )
+        label = str(raw or "")
+    if "Checking" not in label and "Verified" not in label:
+        baim = await _node_center(tab, button)
+        if baim is None:
+            return False
+        bx, by = baim
+        park_x = bx + (_RNG.random() * 50 - 25)
+        park_y = by + 28 + _RNG.random() * 40
+        await _mj_travel(
+            tab,
+            pos,
+            tokens,
+            max(36.0, min(1300.0, park_x)),
+            max(36.0, min(700.0, park_y)),
+        )
+        await asyncio.sleep(0.1 + _RNG.random() * 0.15)
+        await _mj_travel(tab, pos, tokens, bx, by)
+        await asyncio.sleep(0.18 + _RNG.random() * 0.2)
+        await _click_xy(tab, bx, by)
+    return await _await_simple_result(tab, identifier)
+
+
+async def _verify_flow(tab: Any) -> bool:
+    """Scroll, minimum-jerk wander, then trusted press on the verify control."""
+    node = await _wait_verify(tab)
+    if node is None:
+        return False
+
+    await asyncio.sleep(0.45 + _RNG.random() * 0.25)
+    tokens = [88]
+    pos = [160.0 + _RNG.random() * 240.0, 140.0 + _RNG.random() * 160.0]
+    await tab.send(cdp_input.dispatch_mouse_event("mouseMoved", x=pos[0], y=pos[1]))
+    tokens[0] -= 1
+    await _roam(tab, pos, tokens)
+
+    aim = await _button_xy(tab, node)
+    if aim is None or aim[0] < 16 or aim[1] < 16:
+        return False
+    ax, ay = aim
+    park_x = ax + (_RNG.random() * 48 - 24)
+    park_y = ay + 24 + _RNG.random() * 36
+    await _mj_travel(
+        tab,
+        pos,
+        tokens,
+        max(36.0, min(1240.0, park_x)),
+        max(36.0, min(680.0, park_y)),
+    )
+    await asyncio.sleep(0.12 + _RNG.random() * 0.1)
+    await _mj_travel(tab, pos, tokens, ax, ay)
+    await asyncio.sleep(0.42 + _RNG.random() * 0.2)
+    await tab.send(cdp_input.dispatch_mouse_event("mouseMoved", x=ax, y=ay))
+    await asyncio.sleep(0.08 + _RNG.random() * 0.08)
+    return await _trusted_press(tab, ax, ay)
+
+
+async def _start_browser(headed: bool) -> tuple[Any, Any, str]:
+    if headed:
+        _ensure_display()
+    profile = tempfile.mkdtemp(prefix="bv-chrome-")
+    flags = [
+        "--no-sandbox",
+        "--disable-dev-shm-usage",
+        "--ignore-certificate-errors",
+        "--lang=en-US",
+        "--window-size=1280,720",
+        "--disable-blink-features=AutomationControlled",
+        "--no-first-run",
+        "--no-default-browser-check",
+    ]
+    if headed:
+        flags.append("--disable-infobars")
+    opts: dict[str, Any] = {
+        "headless": not headed,
+        "lang": "en-US",
+        "browser_args": flags,
+        "sandbox": False,
+        "user_data_dir": profile,
+    }
+    binary = _pick_chrome()
+    if binary:
+        opts["browser_executable_path"] = binary
+    browser = await uc.start(**opts)
+    tab = await browser.get("about:blank")
+    with suppress(Exception):
+        await tab.send(cdp_page.enable())
+    return browser, tab, profile
+
+
+async def _install_web_stealth(tab: Any) -> None:
+    """CDP UA plus late payload scrub. Do not wrap JSON.stringify."""
+    with suppress(Exception):
+        await tab.send(cdp_page.add_script_to_evaluate_on_new_document(_BOOT))
+    with suppress(Exception):
+        await tab.send(emulation.set_automation_override(enabled=False))
+    with suppress(Exception):
+        await tab.send(
+            network.set_user_agent_override(
+                user_agent=(
+                    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
+                    "(KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36"
+                ),
+                accept_language="en-US,en;q=0.9",
+                platform="Linux x86_64",
+            )
+        )
+
+
+async def _one_pass(url: str) -> bool:
+    simple = _simple_target(url)
+    browser = None
+    profile = ""
+    try:
+        # Innerworks needs headed Xvfb. BV /_web stays headless so hasFocus stays true.
+        browser, tab, profile = await _start_browser(headed=bool(simple))
+        if not simple:
+            await _install_web_stealth(tab)
+        await tab.get(simple[0] if simple else url)
+        if simple:
+            ok = await _simple_flow(tab, simple[1])
+        else:
+            ok = await _verify_flow(tab)
+        with suppress(Exception):
+            await tab.get("about:blank")
+            await asyncio.sleep(0.08)
+        return ok
+    except Exception:
+        return False
+    finally:
+        if browser is not None:
+            await _hard_close(browser, profile)
+        elif profile and os.path.isdir(profile):
+            with suppress(Exception):
+                shutil.rmtree(profile, ignore_errors=True)
+
+
+async def _session(url: str) -> bool:
+    """Run once, soft-retry once on miss (keeps container exit code healthy)."""
+    if await _one_pass(url):
+        return True
+    await asyncio.sleep(0.35 + _RNG.random() * 0.25)
+    return await _one_pass(url)
+
+
+def run_bot(url: str) -> bool:
+    """Complete one challenge verification session."""
+    try:
+        loop = asyncio.new_event_loop()
+        try:
+            asyncio.set_event_loop(loop)
+            return bool(loop.run_until_complete(_session(url)))
+        finally:
+            with suppress(Exception):
+                # drain pending stop/close tasks so Chromium actually dies
+                pending = asyncio.all_tasks(loop)
+                for task in pending:
+                    task.cancel()
+                if pending:
+                    loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
+                loop.run_until_complete(asyncio.sleep(0.05))
+            loop.close()
+            asyncio.set_event_loop(None)
+    except Exception:
+        return False

nodriver_stealth-0.1.0/src/nodriver_stealth.egg-info/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: nodriver-stealth
+Version: 0.1.0
+Summary: Nodriver stealth session runner for BV challenge bots
+Requires-Python: >=3.10
+Requires-Dist: nodriver

nodriver_stealth-0.1.0/src/nodriver_stealth.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+src/nodriver_stealth/__init__.py
+src/nodriver_stealth/engine.py
+src/nodriver_stealth.egg-info/PKG-INFO
+src/nodriver_stealth.egg-info/SOURCES.txt
+src/nodriver_stealth.egg-info/dependency_links.txt
+src/nodriver_stealth.egg-info/requires.txt
+src/nodriver_stealth.egg-info/top_level.txt

nodriver_stealth-0.1.0/src/nodriver_stealth.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nodriver_stealth-0.1.0/src/nodriver_stealth.egg-info/requires.txt

@@ -0,0 +1 @@
+nodriver

nodriver_stealth-0.1.0/src/nodriver_stealth.egg-info/top_level.txt

@@ -0,0 +1 @@
+nodriver_stealth