human-input-kit 0.2.1__py3-none-any.whl

human_input_kit/idle.py

@@ -0,0 +1,41 @@
+"""Idle micro-movements."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING
+
+from human_input_kit.bezier import bezier_mouse_path, move_mouse_along
+from human_input_kit.rng import get_rng
+
+if TYPE_CHECKING:
+    from playwright.async_api import Page
+
+
+async def idle_jitter(
+    page: Page,
+    *,
+    origin: tuple[float, float] | None = None,
+    moves: int = 4,
+    radius: float = 18.0,
+) -> None:
+    """Small bezier moves around a point to mimic idle hand movement."""
+    rng = get_rng()
+    viewport = page.viewport_size
+    if origin is None:
+        width = viewport["width"] if viewport else 1280
+        height = viewport["height"] if viewport else 720
+        current = (width / 2, height / 2)
+    else:
+        current = origin
+
+    await page.mouse.move(current[0], current[1])
+    for _ in range(moves):
+        target = (
+            current[0] + rng.uniform(-radius, radius),
+            current[1] + rng.uniform(-radius, radius),
+        )
+        path = bezier_mouse_path(current, target, steps=8, spread=0.2)
+        await move_mouse_along(page, path, delay_ms=rng.uniform(6, 14))
+        current = target
+        await asyncio.sleep(rng.uniform(0.1, 0.35))

human_input_kit/keyboard.py

@@ -0,0 +1,31 @@
+"""Human-like typing."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING
+
+from human_input_kit.rng import get_rng
+
+if TYPE_CHECKING:
+    from playwright.async_api import Page
+
+
+async def human_type(
+    page: Page,
+    selector: str,
+    text: str,
+    *,
+    min_delay_ms: int = 45,
+    max_delay_ms: int = 180,
+    pause_chance: float = 0.08,
+) -> None:
+    """Type text with variable per-character delays and occasional pauses."""
+    rng = get_rng()
+    await page.click(selector)
+    for char in text:
+        await page.keyboard.type(char, delay=0)
+        delay = rng.randint(min_delay_ms, max_delay_ms) / 1000.0
+        await asyncio.sleep(delay)
+        if rng.random() < pause_chance:
+            await asyncio.sleep(rng.uniform(0.15, 0.45))

human_input_kit/record.py

@@ -0,0 +1,90 @@
+"""Record gestures from a Playwright page."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import TYPE_CHECKING
+
+from human_input_kit.gestures import GestureEvent, GestureRecording
+from human_input_kit.idle import idle_jitter
+from human_input_kit.rng import get_rng
+from human_input_kit.scroll import random_scroll
+
+if TYPE_CHECKING:
+    from playwright.async_api import Page
+
+RECORD_INIT_SCRIPT = """
+() => {
+  window.__humanInputEvents = [];
+  const push = (event) => window.__humanInputEvents.push(event);
+  const t0 = performance.now();
+  const now = () => (performance.now() - t0) / 1000;
+  window.addEventListener("mousemove", (e) => {
+    push({ type: "move", t: now(), x: e.clientX, y: e.clientY });
+  }, { passive: true });
+  window.addEventListener("wheel", (e) => {
+    push({ type: "scroll", t: now(), dx: e.deltaX, dy: e.deltaY });
+  }, { passive: true });
+  window.addEventListener("keydown", (e) => {
+    if (e.key.length === 1) {
+      push({ type: "type", t: now(), text: e.key });
+    }
+  }, { passive: true });
+}
+"""
+
+
+async def record_gestures(
+    page: Page,
+    *,
+    duration: float = 30.0,
+    warmup_actions: bool = True,
+) -> GestureRecording:
+    """Record browser input events for a duration (seconds)."""
+    await page.evaluate(RECORD_INIT_SCRIPT)
+    start = time.monotonic()
+
+    if warmup_actions:
+        rng = get_rng()
+        await random_scroll(page, bursts=rng.randint(2, 4))
+        await idle_jitter(page, moves=rng.randint(2, 4))
+
+    while time.monotonic() - start < duration:
+        await asyncio.sleep(0.1)
+
+    raw = await page.evaluate("() => window.__humanInputEvents || []")
+    events: list[GestureEvent] = []
+    if isinstance(raw, list):
+        for item in raw:
+            if not isinstance(item, dict) or "type" not in item:
+                continue
+            event_type = item["type"]
+            if event_type not in {"move", "scroll", "type"}:
+                continue
+            events.append(
+                GestureEvent(
+                    type=event_type,
+                    t=float(item.get("t", 0)),
+                    x=item.get("x"),
+                    y=item.get("y"),
+                    dx=item.get("dx"),
+                    dy=item.get("dy"),
+                    text=item.get("text"),
+                )
+            )
+
+    return GestureRecording(url=page.url, events=_thin_moves(events))
+
+
+def _thin_moves(events: list[GestureEvent], *, min_gap_s: float = 0.05) -> list[GestureEvent]:
+    """Reduce noisy mousemove streams for compact replay files."""
+    thinned: list[GestureEvent] = []
+    last_move_t = -1.0
+    for event in events:
+        if event.type == "move":
+            if event.t - last_move_t < min_gap_s:
+                continue
+            last_move_t = event.t
+        thinned.append(event)
+    return thinned

human_input_kit/replay.py

@@ -0,0 +1,57 @@
+"""Replay recorded gestures on a Playwright page."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from human_input_kit.bezier import bezier_mouse_path, move_mouse_along
+from human_input_kit.gestures import GestureRecording, load_recording
+
+if TYPE_CHECKING:
+    from playwright.async_api import Page
+
+
+async def replay_gestures(
+    page: Page,
+    recording: GestureRecording,
+    *,
+    speed: float = 1.0,
+) -> None:
+    """Replay a gesture recording with original timing."""
+    if recording.url and recording.url != "about:blank":
+        await page.goto(recording.url, wait_until="domcontentloaded")
+
+    last_t = 0.0
+    last_pos: tuple[float, float] | None = None
+    typed_buffer = ""
+
+    for event in recording.events:
+        wait_s = max(0.0, (event.t - last_t) / speed)
+        if wait_s:
+            await asyncio.sleep(wait_s)
+        last_t = event.t
+
+        if event.type == "move" and event.x is not None and event.y is not None:
+            target = (event.x, event.y)
+            if last_pos is None:
+                await page.mouse.move(target[0], target[1])
+            else:
+                path = bezier_mouse_path(last_pos, target, steps=12)
+                await move_mouse_along(page, path, delay_ms=6)
+            last_pos = target
+        elif event.type == "scroll":
+            await page.mouse.wheel(event.dx or 0, event.dy or 0)
+        elif event.type == "type" and event.text:
+            typed_buffer += event.text
+        elif event.type == "wait" and event.duration_ms:
+            await asyncio.sleep(event.duration_ms / 1000.0 / speed)
+
+    if typed_buffer:
+        await page.keyboard.type(typed_buffer, delay=35)
+
+
+async def replay_file(page: Page, path: Path | str, *, speed: float = 1.0) -> None:
+    """Load and replay a validated gestures JSON file."""
+    await replay_gestures(page, load_recording(path, validate=True), speed=speed)

human_input_kit/rng.py

@@ -0,0 +1,16 @@
+"""Seeded random number generator for reproducible human-like variance."""
+
+from __future__ import annotations
+
+import random
+
+_rng = random.Random(42)
+
+
+def seed_rng(seed: int) -> None:
+    """Set the global RNG seed for deterministic behavior in tests."""
+    _rng.seed(seed)
+
+
+def get_rng() -> random.Random:
+    return _rng

human_input_kit/scroll.py

@@ -0,0 +1,28 @@
+"""Human-like scrolling."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING
+
+from human_input_kit.rng import get_rng
+
+if TYPE_CHECKING:
+    from playwright.async_api import Page
+
+
+async def random_scroll(
+    page: Page,
+    *,
+    bursts: int = 3,
+    min_delta: int = 120,
+    max_delta: int = 520,
+) -> None:
+    """Perform several scroll wheel bursts with random deltas and pauses."""
+    rng = get_rng()
+    for _ in range(bursts):
+        delta_y = rng.randint(min_delta, max_delta)
+        if rng.random() < 0.2:
+            delta_y *= -1
+        await page.mouse.wheel(0, delta_y)
+        await asyncio.sleep(rng.uniform(0.25, 0.9))

human_input_kit/sync_.py

@@ -0,0 +1,143 @@
+"""Playwright sync API — human-like input helpers."""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Sequence
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from human_input_kit.bezier import Point, bezier_mouse_path
+from human_input_kit.gestures import GestureRecording, load_recording
+from human_input_kit.rng import get_rng
+
+if TYPE_CHECKING:
+    from playwright.sync_api import Page
+
+__all__ = [
+    "bezier_mouse_path",
+    "human_type",
+    "idle_jitter",
+    "move_mouse_along",
+    "random_scroll",
+    "replay_file",
+    "replay_gestures",
+]
+
+
+def move_mouse_along(page: Page, path: Sequence[Point], *, delay_ms: float = 8.0) -> None:
+    """Move Playwright sync mouse along a bezier path."""
+    for x, y in path:
+        page.mouse.move(x, y)
+        if delay_ms > 0:
+            time.sleep(delay_ms / 1000.0)
+
+
+def human_type(
+    page: Page,
+    selector: str,
+    text: str,
+    *,
+    min_delay_ms: int = 45,
+    max_delay_ms: int = 180,
+    pause_chance: float = 0.08,
+) -> None:
+    """Type text with variable per-character delays and occasional pauses."""
+    rng = get_rng()
+    page.click(selector)
+    for char in text:
+        page.keyboard.type(char, delay=0)
+        delay = rng.randint(min_delay_ms, max_delay_ms) / 1000.0
+        time.sleep(delay)
+        if rng.random() < pause_chance:
+            time.sleep(rng.uniform(0.15, 0.45))
+
+
+def random_scroll(
+    page: Page,
+    *,
+    bursts: int = 3,
+    min_delta: int = 120,
+    max_delta: int = 520,
+) -> None:
+    """Perform several scroll wheel bursts with random deltas and pauses."""
+    rng = get_rng()
+    for _ in range(bursts):
+        delta_y = rng.randint(min_delta, max_delta)
+        if rng.random() < 0.2:
+            delta_y *= -1
+        page.mouse.wheel(0, delta_y)
+        time.sleep(rng.uniform(0.25, 0.9))
+
+
+def idle_jitter(
+    page: Page,
+    *,
+    origin: tuple[float, float] | None = None,
+    moves: int = 4,
+    radius: float = 18.0,
+) -> None:
+    """Small bezier moves around a point to mimic idle hand movement."""
+    rng = get_rng()
+    viewport = page.viewport_size
+    if origin is None:
+        width = viewport["width"] if viewport else 1280
+        height = viewport["height"] if viewport else 720
+        current = (width / 2, height / 2)
+    else:
+        current = origin
+
+    page.mouse.move(current[0], current[1])
+    for _ in range(moves):
+        target = (
+            current[0] + rng.uniform(-radius, radius),
+            current[1] + rng.uniform(-radius, radius),
+        )
+        path = bezier_mouse_path(current, target, steps=8, spread=0.2)
+        move_mouse_along(page, path, delay_ms=rng.uniform(6, 14))
+        current = target
+        time.sleep(rng.uniform(0.1, 0.35))
+
+
+def replay_gestures(
+    page: Page,
+    recording: GestureRecording,
+    *,
+    speed: float = 1.0,
+) -> None:
+    """Replay a gesture recording with original timing."""
+    if recording.url and recording.url != "about:blank":
+        page.goto(recording.url, wait_until="domcontentloaded")
+
+    last_t = 0.0
+    last_pos: tuple[float, float] | None = None
+    typed_buffer = ""
+
+    for event in recording.events:
+        wait_s = max(0.0, (event.t - last_t) / speed)
+        if wait_s:
+            time.sleep(wait_s)
+        last_t = event.t
+
+        if event.type == "move" and event.x is not None and event.y is not None:
+            target = (event.x, event.y)
+            if last_pos is None:
+                page.mouse.move(target[0], target[1])
+            else:
+                path = bezier_mouse_path(last_pos, target, steps=12)
+                move_mouse_along(page, path, delay_ms=6)
+            last_pos = target
+        elif event.type == "scroll":
+            page.mouse.wheel(event.dx or 0, event.dy or 0)
+        elif event.type == "type" and event.text:
+            typed_buffer += event.text
+        elif event.type == "wait" and event.duration_ms:
+            time.sleep(event.duration_ms / 1000.0 / speed)
+
+    if typed_buffer:
+        page.keyboard.type(typed_buffer, delay=35)
+
+
+def replay_file(page: Page, path: Path | str, *, speed: float = 1.0) -> None:
+    """Load and replay a validated gestures JSON file."""
+    replay_gestures(page, load_recording(path, validate=True), speed=speed)

human_input_kit-0.2.1.dist-info/METADATA

@@ -0,0 +1,272 @@
+Metadata-Version: 2.4
+Name: human-input-kit
+Version: 0.2.1
+Summary: Human-like Playwright mouse, scroll, and typing — Bezier warmup with deterministic seeds. CLI: human-input.
+Project-URL: Homepage, https://github.com/human-input-kit/human-input-kit
+Project-URL: Documentation, https://github.com/human-input-kit/human-input-kit#readme
+Project-URL: Repository, https://github.com/human-input-kit/human-input-kit
+Project-URL: Issues, https://github.com/human-input-kit/human-input-kit/issues
+Author: human-input-kit contributors
+License-Expression: MIT
+License-File: LICENSE
+Keywords: behavior-replay,bezier-curve,bot-cadence,bot-detection,gesture-recording,human-behavior,human-like-mouse,idle-jitter,interaction-polish,mouse-movement,multilogin-warmup,playwright-input,playwright-scroll,playwright-warmup,scroll-simulation,typing-simulation,warmup-script
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP :: Browsers
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: click>=8.1
+Requires-Dist: playwright>=1.40
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'
+Provides-Extra: mlx
+Description-Content-Type: text/markdown
+
+# human-input-kit
+
+**Human-like Playwright mouse & scroll** — Bezier paths, typing delays, and warmup recipes with deterministic seeds.
+
+[![PyPI version](https://img.shields.io/pypi/v/human-input-kit.svg)](https://pypi.org/project/human-input-kit/)
+[![Python versions](https://img.shields.io/pypi/pyversions/human-input-kit.svg)](https://pypi.org/project/human-input-kit/)
+[![License: MIT](https://img.shields.io/pypi/l/human-input-kit.svg)](https://pypi.org/project/human-input-kit/)
+
+```bash
+pip install human-input-kit
+human-input --help
+```
+
+CLI: **`human-input`** · Python **3.10+** · optional **`[mlx]`** for Launcher helpers
+
+Human-like **mouse**, **scroll**, and **typing** helpers for Playwright — Bezier paths, variable delays, idle jitter, and gesture record/replay.
+
+## Problem
+
+Raw `page.click()` and `page.keyboard.type()` bursts look mechanical. Warmup workflows need curved mouse paths, uneven scroll cadence, and typing pauses. Teams reinvent these snippets in every scraper.
+
+`human-input-kit` packages the primitives and a small CLI for demo, record, and replay flows.
+
+## Install
+
+```bash
+pip install human-input-kit
+playwright install chromium
+```
+
+Development:
+
+```bash
+pip install human-input-kit[dev]
+```
+
+![Warmup demo](docs/assets/demo.gif)
+
+> Placeholder: add a screen recording at `docs/assets/demo.gif` (not shipped in the wheel).
+
+## Quick start
+
+```bash
+# Reproducible motion (default seed 42)
+human-input --seed 42 demo-scroll --url https://news.ycombinator.com
+human-input record --duration 30 -o gestures.json
+human-input replay gestures.json   # validates gesture JSON schema first
+
+# Runnable warmup example
+python examples/demo_warmup.py --seed 42
+
+# Documented recipes (deterministic with --seed)
+python recipes/scroll_news.py --seed 42
+python recipes/youtube_idle.py --seed 42 --seconds 30 --headed
+```
+
+**Sync Playwright API** (default package exports):
+
+```python
+from human_input_kit import (
+    bezier_mouse_path,
+    human_type,
+    idle_jitter,
+    move_mouse_along,
+    random_scroll,
+    seed_rng,
+)
+
+seed_rng(42)
+path = bezier_mouse_path((100, 100), (500, 300))
+move_mouse_along(page, path)          # sync Page
+random_scroll(page, bursts=4)
+idle_jitter(page)
+human_type(page, "input[name='q']", "playwright warmup")
+```
+
+**Async Playwright API** (`human_input_kit.async_`):
+
+```python
+from human_input_kit import seed_rng
+from human_input_kit import async_ as human_async
+
+seed_rng(42)
+path = human_async.bezier_mouse_path((100, 100), (500, 300))
+await human_async.move_mouse_along(page, path)
+await human_async.random_scroll(page, bursts=4)
+```
+
+See `examples/demo_warmup.py` for a full async script.
+
+### Recipes
+
+Copy-paste scripts in [`recipes/`](recipes/) for common warmup patterns. Each accepts `--seed` so demo motion is reproducible in CI and screen recordings.
+
+| Recipe | Command | Behavior |
+|--------|---------|----------|
+| News scroll | `python recipes/scroll_news.py --seed 42` | Bezier drift → scroll bursts → idle jitter on a news feed |
+| YouTube idle | `python recipes/youtube_idle.py --seed 42 --headed` | Idle micro-moves + rare scroll on `youtube.com` |
+
+Options: `--url`, `--headed` (both); `--bursts` (scroll_news); `--seconds` (youtube_idle).
+
+## MLX warmup (single profile)
+
+`human-input-kit` does **not** bundle MLX or Launcher clients. For one-off MLX profile warmup, follow the **cdp-connect-kit** peer pattern:
+
+```bash
+pip install human-input-kit
+pip install cdp-connect-kit[mlx]   # peer dependency — not required by human-input-kit
+playwright install chromium
+
+export MLX_TOKEN=your_bearer_token
+export MLX_FOLDER_ID=your-folder-uuid
+
+# Pseudocode demo with TODO markers for Launcher start/stop:
+python examples/mlx_warmup_demo.py --profile-id PROFILE_UUID
+
+# Or warmup an already-started profile (CDP_URL from Launcher):
+CDP_URL=http://127.0.0.1:55513 python examples/mlx_warmup_demo.py --profile-id PROFILE_UUID
+```
+
+`examples/mlx_warmup_demo.py` documents: Launcher start → `connect_over_cdp` → Bezier scroll/jitter warmup → Launcher stop. Set `HUMAN_INPUT_KIT_MLX_DEMO=1` after installing `cdp-connect-kit[mlx]` to enable the live Launcher calls.
+
+Optional marker extra (installs nothing): `pip install human-input-kit[mlx]`
+
+## CLI
+
+| Command | Description |
+|---------|-------------|
+| `human-input demo-scroll --url URL` | Scroll + idle jitter demo |
+| `human-input record --duration SEC -o FILE` | Record gestures JSON |
+| `human-input replay FILE` | Replay saved gestures (schema-validated) |
+| `human-input --seed N` | Global RNG seed on all subcommands (default `42`) |
+
+## API
+
+| Module | Use with |
+|--------|----------|
+| `human_input_kit` | Playwright **sync** `Page` |
+| `human_input_kit.async_` | Playwright **async** `Page` |
+| `human_input_kit.bezier` | Path math only (`bezier_mouse_path`) |
+
+| Function | Description |
+|----------|-------------|
+| `bezier_mouse_path(start, end, steps=25)` | Cubic Bezier point list (sync, fast) |
+| `move_mouse_along(page, path)` | Animate mouse along path |
+| `human_type(page, selector, text)` | Variable per-char typing delays |
+| `random_scroll(page, bursts=3)` | Random wheel bursts with pauses |
+| `idle_jitter(page, moves=4)` | Small idle hand movements |
+| `seed_rng(n)` | Deterministic variance for tests/demos |
+| `load_recording(path, validate=True)` | Load gestures JSON with schema check |
+
+### Gesture format
+
+```json
+{
+  "version": 1,
+  "url": "https://news.ycombinator.com",
+  "events": [
+    {"type": "move", "t": 0.0, "x": 120, "y": 80},
+    {"type": "scroll", "t": 1.2, "dy": 320}
+  ]
+}
+```
+
+## Behavioral mimicry vs profile isolation
+
+Human-like mouse paths and scroll timing can reduce **obvious automation cadence**, but behavioral mimicry alone is **necessary and insufficient** for production multi-account workflows.
+
+Detection stacks also correlate:
+
+- Browser fingerprint consistency (UA, WebGL, Client Hints)
+- IP / proxy reputation
+- Cookie and storage isolation
+- TLS and network signals
+
+Use `human-input-kit` for **warmup and interaction polish** inside an already-isolated profile (dedicated browser profile, proxy, and storage boundary). Pair with [fingerprint-coherence](https://pypi.org/project/fingerprint-coherence/) and [playwright-cdp-probe](https://pypi.org/project/playwright-cdp-probe/) for profile-level QA.
+
+## When mechanical clicks still get flagged (playbook)
+
+Behavior polish helps **cadence** — not fingerprint or IP. Typical order of operations:
+
+| Signal still failing | Tool | Action |
+|----------------------|------|--------|
+| Teleport mouse / constant intervals | `human-input-kit` | Bezier paths, `--seed` for reproducible demos |
+| UA / screen / timezone mismatch | [fingerprint-coherence](https://pypi.org/project/fingerprint-coherence/) | Audit profile before warmup |
+| `navigator.webdriver` / headless leaks | [playwright-cdp-probe](https://pypi.org/project/playwright-cdp-probe/) | Compare vanilla vs Launcher CDP |
+| One profile ok, N profiles not | `automation-farm-runner` | `farm-runner mlx-pool` + warmup script reading `CDP_URL` |
+
+**Warmup pipeline (single profile):**
+
+```bash
+export MLX_TOKEN=... MLX_FOLDER_ID=...
+# cdp-connect-kit starts profile → CDP_URL
+CDP_URL=http://127.0.0.1:PORT python examples/mlx_warmup_demo.py --profile-id UUID
+human-input --seed 42 demo-scroll --url https://news.ycombinator.com
+cdp-probe mlx --profile-id UUID --url https://example.com
+```
+
+**Warmup at scale:** farm job imports `human_input_kit`, reads `CDP_URL` / `PROFILE_ID` from env — gestures stay in this package; queueing stays in `farm-runner`.
+
+## Limitations
+
+- **Playwright only** — APIs expect a Playwright `Page`.
+- **Record mode** captures DOM events + scripted warmup; not a full OS-level input recorder.
+- **Not undetectable** — reduces mechanical patterns; does not spoof fingerprints or network identity.
+- **Headless motion** — some sites behave differently in headless Chromium.
+
+## Production
+
+For **many profiles** (folder pool, cron, concurrency), use **`farm-runner`** (`automation-farm-runner`) with a warmup script that imports `human_input_kit` and reads `CDP_URL` / `PROFILE_ID`. This package is the gesture library; the farm runner owns MLX pool lifecycle.
+
+**Partner note (affiliate):** Human-like input pays off **inside** isolated Multilogin X profiles (proxy + fingerprint already matched) — not on leaky vanilla Chromium. If folder-scale warmup is your bottleneck, eligible new browser purchases may accept code **`SAAS50`** at [multilogin.com](https://multilogin.com/?ref=SAAS50) — verify terms before checkout. Demos and recipes work without MLX. Full disclosure: [docs/AFFILIATE.md](docs/AFFILIATE.md). Coupon details only via `human-input --show-deal` (never printed by default).
+
+**FAQ:** [docs/FAQ.md](docs/FAQ.md) — human-like mouse movement, Playwright scroll warmup, bot detection cadence.
+
+
+
+
+
+## Related tools (on PyPI)
+
+| Package | CLI | Role |
+|---------|-----|------|
+| [playwright-cdp-probe](https://pypi.org/project/playwright-cdp-probe/) | `cdp-probe` | CDP / WebDriver exposure score |
+| [cookie-jar-bridge](https://pypi.org/project/cookie-jar-bridge/) | `cookie-bridge` | Netscape ↔ Playwright cookies |
+| [proxy-lane-checker](https://pypi.org/project/proxy-lane-checker/) | `proxy-lane` | Proxy TCP / HTTP / geo / DNSBL |
+| [fingerprint-coherence](https://pypi.org/project/fingerprint-coherence/) | `fp-coherence` | UA / screen / timezone lint |
+
+**Toolkit pipeline:** `proxy-lane check` → `fp-coherence audit` → automate → `cdp-probe run` → `cookie-bridge validate`
+
+## License
+
+MIT
+
+---
+
+**Production antidetect:** [Multilogin X](https://multilogin.com/?ref=SAAS50) · Code `SAAS50` (-50% browser) · `MIN50` (-50% cloud phone)  
+More scripts: [@Multilogin_Scripts_Bot](https://t.me/Multilogin_Scripts_Bot) · [Coupons](https://anti-detect.github.io/)