chromix 152.0.7977.82__tar.gz

chromix-152.0.7977.82/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, xiaozhou26
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

chromix-152.0.7977.82/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: chromix
+Version: 152.0.7977.82
+Summary: Drive the Chromix stealth Chromium engine with a CloakBrowser-compatible API.
+Author: xiaozhou26
+License: BSD 3-Clause License
+        
+        Copyright (c) 2026, xiaozhou26
+        All rights reserved.
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        1. Redistributions of source code must retain the above copyright notice, this
+           list of conditions and the following disclaimer.
+        
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+        
+        3. Neither the name of the copyright holder nor the names of its
+           contributors may be used to endorse or promote products derived from
+           this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+Project-URL: Homepage, https://github.com/xiaozhou26/Chromix
+Project-URL: Source, https://github.com/xiaozhou26/Chromix
+Project-URL: Issues, https://github.com/xiaozhou26/Chromix/issues
+Keywords: chromium,stealth,browser,automation,anti-bot,cloakbrowser
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: playwright
+Requires-Dist: playwright; extra == "playwright"
+Dynamic: license-file
+
+# chromix (Python)
+
+Drive the Chromix stealth Chromium engine with a **CloakBrowser-compatible API** —
+function names, keyword arguments, return types (Playwright `Browser` / `BrowserContext`)
+and `CLOAKBROWSER_*` env-var names all match the [`cloakbrowser`](https://github.com/CloakHQ/CloakBrowser)
+wrapper, so existing CloakBrowser scripts run on Chromix by changing only the import:
+
+```diff
+- from cloakbrowser import launch
++ from chromix import launch
+```
+
+```python
+from chromix import launch
+
+browser = launch(proxy="http://user:pass@proxy:8080", geoip=True, humanize=True)
+page = browser.new_page()
+page.goto("https://example.com")
+browser.close()
+```
+
+## Install
+
+```bash
+pip install chromix playwright
+```
+
+The distribution and import package are both named `chromix`. To install the
+SDK directly from a repository checkout instead, run:
+
+```bash
+pip install ./sdk/python playwright
+```
+
+On first launch the stealth Chromium binary is downloaded from this repo's GitHub
+Release, SHA256-verified, and cached under `~/.cache/chromix`. Point
+`CLOAKBROWSER_BINARY_PATH` at a local build (e.g. your own `chrome.exe`) to skip
+the download.
+
+## API
+
+| Function | Description |
+|---|---|
+| `launch(**opts)` | Returns a Playwright `Browser` |
+| `launch_async(**opts)` | Async variant |
+| `launch_context(**opts)` | Returns a `BrowserContext` (viewport/locale/color_scheme pre-set) |
+| `launch_context_async(**opts)` | Async variant |
+| `launch_persistent_context(user_data_dir, **opts)` | Persistent profile |
+| `launch_persistent_context_async(user_data_dir, **opts)` | Async variant |
+| `build_args` / `get_default_stealth_args` | Arg assembly (32-bit random seed + platform claim) |
+| `maybe_resolve_geoip(geoip, proxy, tz, locale, args)` | Egress IP → (tz, locale, exit_ip) |
+| `ensure_binary` / `clear_cache` / `binary_info` / `check_for_update` | Binary management |
+| `HumanConfig` / `resolve_human_config` | Behavioral-layer config (`default` / `careful` presets) |
+| `ProxySettings` | Playwright-shaped proxy TypedDict |
+
+Options (`headless, proxy, args, stealth_args, timezone, locale, geoip, humanize,
+human_preset, human_config, extension_paths, license_key, browser_version,
+release_channel, user_agent, viewport, color_scheme`) match CloakBrowser
+name-for-name; `**kwargs` passes through to `playwright.chromium.launch()` /
+`browser.new_context()`.
+
+## Env vars
+
+- `CLOAKBROWSER_BINARY_PATH` — use a local chrome binary instead of downloading
+- `CLOAKBROWSER_VERSION` / `CLOAKBROWSER_RELEASE_CHANNEL` — pin a version/channel
+- `CLOAKBROWSER_GEOIP_TIMEOUT_SECONDS` — geoip lookup timeout
+- `CLOAKBROWSER_WIDEVINE_CDM` — explicit Widevine CDM dir (DRM); `CLOAKBROWSER_WIDEVINE=0` disables DRM
+- `CHROMIX_CACHE_DIR` / `CHROMIX_DOWNLOAD_HOST` — cache location / release host override
+
+High-risk engine ports are available only through explicit browser `args`:
+
+```python
+browser = launch(args=[
+    "--fingerprint-devtools-runtime-suppression",
+    "--fingerprint-canvas-bridge=127.0.0.1:9228",
+    "--fingerprint-canvas-bridge-unsafe",
+    "--fingerprint-webrtc-fake-srflx=203.0.113.20",
+    "--fingerprint-webrtc-fake-srflx-allow-udp",
+])
+```
+
+Runtime suppression can break console/binding-based automation. Canvas Bridge
+removes the sandbox from bridge renderer processes and forwards canvas/WebGL
+operations to the configured endpoint. Fake srflx does not enable non-proxied
+UDP unless the separate `allow-udp` flag is supplied.
+
+## CLI
+
+```bash
+python -m chromix install      # pre-download the binary
+python -m chromix info         # binary / cache info
+python -m chromix widevine     # fetch the Widevine CDM (Linux x64)
+python -m chromix clear-cache
+```
+
+## Intentional differences from CloakBrowser
+
+1. `license_key` is accepted and ignored (one open tier).
+2. `geoip` queries ip-api.com over HTTP instead of a local GeoLite2 database;
+   explicit `timezone=` / `locale=` always win.
+3. No `cloakbrowser/puppeteer` subpath — use the Playwright surface.
+4. Widevine is enabled automatically when a CDM is present (installed Chrome,
+   `CLOAKBROWSER_WIDEVINE_CDM`, or `python -m chromix widevine`).
+
+## License
+
+The Python SDK is available under the BSD 3-Clause License. See
+[`LICENSE`](LICENSE).

chromix-152.0.7977.82/README.md

@@ -0,0 +1,108 @@
+# chromix (Python)
+
+Drive the Chromix stealth Chromium engine with a **CloakBrowser-compatible API** —
+function names, keyword arguments, return types (Playwright `Browser` / `BrowserContext`)
+and `CLOAKBROWSER_*` env-var names all match the [`cloakbrowser`](https://github.com/CloakHQ/CloakBrowser)
+wrapper, so existing CloakBrowser scripts run on Chromix by changing only the import:
+
+```diff
+- from cloakbrowser import launch
++ from chromix import launch
+```
+
+```python
+from chromix import launch
+
+browser = launch(proxy="http://user:pass@proxy:8080", geoip=True, humanize=True)
+page = browser.new_page()
+page.goto("https://example.com")
+browser.close()
+```
+
+## Install
+
+```bash
+pip install chromix playwright
+```
+
+The distribution and import package are both named `chromix`. To install the
+SDK directly from a repository checkout instead, run:
+
+```bash
+pip install ./sdk/python playwright
+```
+
+On first launch the stealth Chromium binary is downloaded from this repo's GitHub
+Release, SHA256-verified, and cached under `~/.cache/chromix`. Point
+`CLOAKBROWSER_BINARY_PATH` at a local build (e.g. your own `chrome.exe`) to skip
+the download.
+
+## API
+
+| Function | Description |
+|---|---|
+| `launch(**opts)` | Returns a Playwright `Browser` |
+| `launch_async(**opts)` | Async variant |
+| `launch_context(**opts)` | Returns a `BrowserContext` (viewport/locale/color_scheme pre-set) |
+| `launch_context_async(**opts)` | Async variant |
+| `launch_persistent_context(user_data_dir, **opts)` | Persistent profile |
+| `launch_persistent_context_async(user_data_dir, **opts)` | Async variant |
+| `build_args` / `get_default_stealth_args` | Arg assembly (32-bit random seed + platform claim) |
+| `maybe_resolve_geoip(geoip, proxy, tz, locale, args)` | Egress IP → (tz, locale, exit_ip) |
+| `ensure_binary` / `clear_cache` / `binary_info` / `check_for_update` | Binary management |
+| `HumanConfig` / `resolve_human_config` | Behavioral-layer config (`default` / `careful` presets) |
+| `ProxySettings` | Playwright-shaped proxy TypedDict |
+
+Options (`headless, proxy, args, stealth_args, timezone, locale, geoip, humanize,
+human_preset, human_config, extension_paths, license_key, browser_version,
+release_channel, user_agent, viewport, color_scheme`) match CloakBrowser
+name-for-name; `**kwargs` passes through to `playwright.chromium.launch()` /
+`browser.new_context()`.
+
+## Env vars
+
+- `CLOAKBROWSER_BINARY_PATH` — use a local chrome binary instead of downloading
+- `CLOAKBROWSER_VERSION` / `CLOAKBROWSER_RELEASE_CHANNEL` — pin a version/channel
+- `CLOAKBROWSER_GEOIP_TIMEOUT_SECONDS` — geoip lookup timeout
+- `CLOAKBROWSER_WIDEVINE_CDM` — explicit Widevine CDM dir (DRM); `CLOAKBROWSER_WIDEVINE=0` disables DRM
+- `CHROMIX_CACHE_DIR` / `CHROMIX_DOWNLOAD_HOST` — cache location / release host override
+
+High-risk engine ports are available only through explicit browser `args`:
+
+```python
+browser = launch(args=[
+    "--fingerprint-devtools-runtime-suppression",
+    "--fingerprint-canvas-bridge=127.0.0.1:9228",
+    "--fingerprint-canvas-bridge-unsafe",
+    "--fingerprint-webrtc-fake-srflx=203.0.113.20",
+    "--fingerprint-webrtc-fake-srflx-allow-udp",
+])
+```
+
+Runtime suppression can break console/binding-based automation. Canvas Bridge
+removes the sandbox from bridge renderer processes and forwards canvas/WebGL
+operations to the configured endpoint. Fake srflx does not enable non-proxied
+UDP unless the separate `allow-udp` flag is supplied.
+
+## CLI
+
+```bash
+python -m chromix install      # pre-download the binary
+python -m chromix info         # binary / cache info
+python -m chromix widevine     # fetch the Widevine CDM (Linux x64)
+python -m chromix clear-cache
+```
+
+## Intentional differences from CloakBrowser
+
+1. `license_key` is accepted and ignored (one open tier).
+2. `geoip` queries ip-api.com over HTTP instead of a local GeoLite2 database;
+   explicit `timezone=` / `locale=` always win.
+3. No `cloakbrowser/puppeteer` subpath — use the Playwright surface.
+4. Widevine is enabled automatically when a CDM is present (installed Chrome,
+   `CLOAKBROWSER_WIDEVINE_CDM`, or `python -m chromix widevine`).
+
+## License
+
+The Python SDK is available under the BSD 3-Clause License. See
+[`LICENSE`](LICENSE).

chromix-152.0.7977.82/chromix/__init__.py

@@ -0,0 +1,46 @@
+"""chromix — drive the Chromix stealth Chromium engine with a CloakBrowser-compatible API.
+
+Function names, keyword arguments, return types (Playwright ``Browser`` /
+``BrowserContext``) and ``CLOAKBROWSER_*`` env-var names all match the
+``cloakbrowser`` wrapper (github.com/CloakHQ/CloakBrowser), so existing
+CloakBrowser scripts run on Chromix by changing only the import:
+
+    - from cloakbrowser import launch
+    + from chromix import launch
+
+    from chromix import launch
+
+    browser = launch(proxy="http://user:pass@proxy:8080", geoip=True, humanize=True)
+    page = browser.new_page()
+    page.goto("https://example.com")
+    browser.close()
+"""
+from .api import (
+    HumanConfig,
+    ProxySettings,
+    binary_info,
+    build_args,
+    check_for_update,
+    clear_cache,
+    ensure_binary,
+    get_default_stealth_args,
+    launch,
+    launch_async,
+    launch_context,
+    launch_context_async,
+    launch_persistent_context,
+    launch_persistent_context_async,
+    maybe_resolve_geoip,
+    resolve_human_config,
+)
+
+__version__ = "152.0.7977.82"
+
+__all__ = [
+    "launch", "launch_async", "launch_context", "launch_context_async",
+    "launch_persistent_context", "launch_persistent_context_async",
+    "ProxySettings", "build_args", "maybe_resolve_geoip",
+    "get_default_stealth_args", "ensure_binary", "clear_cache",
+    "binary_info", "check_for_update", "HumanConfig", "resolve_human_config",
+    "__version__",
+]

chromix-152.0.7977.82/chromix/__main__.py

@@ -0,0 +1,40 @@
+"""CLI: ``python -m chromix`` — pre-download / inspect / manage the binary."""
+import argparse
+import json
+import sys
+
+from . import __version__, binary_info, clear_cache, ensure_binary
+
+
+def main():
+    ap = argparse.ArgumentParser(
+        prog="chromix",
+        description="Manage the Chromix stealth Chromium binary.")
+    sub = ap.add_subparsers(dest="cmd")
+    sub.add_parser("install", help="download the stealth binary now")
+    sub.add_parser("info", help="show binary / cache info as JSON")
+    sub.add_parser("clear-cache", help="delete all cached binaries")
+    sub.add_parser("widevine", help="fetch the Widevine CDM (Linux x64) for DRM playback")
+    ap.add_argument("--version", action="version", version=f"chromix {__version__}")
+    args = ap.parse_args()
+
+    if args.cmd == "install":
+        print(ensure_binary())
+    elif args.cmd == "info":
+        print(json.dumps(binary_info(), indent=2))
+    elif args.cmd == "clear-cache":
+        clear_cache()
+        print("cache cleared")
+    elif args.cmd == "widevine":
+        from .widevine import ensure_widevine
+        cdm = ensure_widevine()
+        if cdm:
+            print(f"CDM ready: {cdm}")
+        else:
+            sys.exit("no Widevine CDM source available on this platform")
+    else:
+        ap.print_help()
+
+
+if __name__ == "__main__":
+    main()

chromix-152.0.7977.82/chromix/_binary.py

@@ -0,0 +1,107 @@
+"""Binary management for chromix: download, verify, cache the stealth Chromium bundle.
+
+Detects the platform, downloads the matching bundle from the GitHub Release,
+verifies it against SHA256SUMS, and caches it under ``~/.cache/chromix``.
+"""
+from __future__ import annotations
+import hashlib
+import os
+import platform
+import sys
+import tarfile
+import urllib.request
+import zipfile
+from pathlib import Path
+
+_REPO = "xiaozhou26/Chromix"
+# Release channels track the latest verified binary for each supported major.
+# Source/package versions may move ahead while the staged Chromium build runs.
+_CHANNELS = {
+    "stable": {"tag": "v151.0.7922.173"},
+    "latest": {"tag": "v152.0.7977.75"},
+}
+_CACHE = Path(os.environ.get("CHROMIX_CACHE_DIR",
+                             Path.home() / ".cache" / "chromix"))
+
+
+def _host(tag: str) -> str:
+    return os.environ.get("CHROMIX_DOWNLOAD_HOST",
+                          f"https://github.com/{_REPO}/releases/download/{tag}")
+
+
+# platform key -> (release asset, archive kind, launcher relative path)
+_ASSETS = {
+    "linux-x64":  ("chromix-linux-x64.tar.gz", "tar", "chromix/chromix"),
+    "win-x64":    ("chromix-win-x64.zip",      "zip", "chromix/chromix.cmd"),
+    "mac-arm64":  ("chromix-mac-arm64.tar.gz", "tar", "chromix/chromix"),
+    "mac-x64":    ("chromix-mac-x64.tar.gz",   "tar", "chromix/chromix"),
+}
+
+
+def resolve_platform() -> str | None:
+    sysname, mach = platform.system(), platform.machine().lower()
+    if sysname == "Linux" and mach in ("x86_64", "amd64"):
+        return "linux-x64"
+    if sysname == "Windows" and mach in ("amd64", "x86_64"):
+        return "win-x64"
+    if sysname == "Darwin":
+        return "mac-arm64" if mach in ("arm64", "aarch64") else "mac-x64"
+    return None
+
+
+def _sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as fh:
+        for chunk in iter(lambda: fh.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def _expected_sha(asset: str, host: str) -> str | None:
+    """Fetch SHA256SUMS from the release and return the hash for `asset`."""
+    try:
+        with urllib.request.urlopen(f"{host}/SHA256SUMS", timeout=30) as r:
+            for line in r.read().decode().splitlines():
+                parts = line.split()
+                if len(parts) == 2 and parts[1].lstrip("*") == asset:
+                    return parts[0].lower()
+    except Exception:
+        return None
+    return None
+
+
+def _download(plat: str, host: str, tag: str) -> Path:
+    """Ensure the bundle for `plat` is present + verified; return the launcher path."""
+    asset, kind, launcher_rel = _ASSETS[plat]
+    root = _CACHE / tag / plat   # cache per release tag so channels don't collide
+    launcher = root / launcher_rel
+    if launcher.exists():
+        return launcher
+    root.mkdir(parents=True, exist_ok=True)
+    archive = root / asset
+    url = f"{host}/{asset}"
+    sys.stderr.write(f"[chromix] downloading {url} ...\n")
+    urllib.request.urlretrieve(url, archive)
+
+    expected = _expected_sha(asset, host)
+    if expected:
+        actual = _sha256(archive)
+        if actual != expected:
+            archive.unlink(missing_ok=True)
+            raise RuntimeError(f"SHA256 mismatch for {asset}: expected {expected}, got {actual}")
+        sys.stderr.write("[chromix] SHA256 verified\n")
+    else:
+        sys.stderr.write("[chromix] WARNING: no SHA256SUMS published; skipping verification\n")
+
+    if kind == "tar":
+        with tarfile.open(archive) as t:
+            t.extractall(root)
+    else:
+        with zipfile.ZipFile(archive) as z:
+            z.extractall(root)
+    archive.unlink(missing_ok=True)
+    if launcher.exists() and not launcher.name.endswith(".cmd"):
+        launcher.chmod(0o755)
+    if not launcher.exists():
+        raise RuntimeError(f"bundle extracted but launcher missing: {launcher}")
+    return launcher

chromix-152.0.7977.82/chromix/_fonts.py

@@ -0,0 +1,46 @@
+"""Linux Fontconfig wiring for the bundled Windows font assets."""
+from __future__ import annotations
+
+import os
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any
+
+
+def linux_font_env(executable: str | os.PathLike) -> dict[str, str]:
+    """Return ``FONTCONFIG_FILE`` when a Linux bundle contains ``fonts/``."""
+    if sys.platform != "linux":
+        return {}
+
+    fonts_dir = Path(executable).resolve().parent / "fonts"
+    template = fonts_dir / "fonts.conf.template"
+    if not template.is_file():
+        return {}
+
+    try:
+        cache_dir = Path(os.environ.get("XDG_CACHE_HOME", Path.home() / ".cache")) \
+            / "chromix" / "fontconfig"
+        cache_dir.mkdir(parents=True, exist_ok=True)
+        config = template.read_text(encoding="utf-8")
+        config = config.replace("@FONTS_DIR@", str(fonts_dir))
+        config = config.replace("@CACHE_DIR@", str(cache_dir))
+        config_path = Path(tempfile.gettempdir()) / f"chromix-fontconfig-{os.getuid()}.conf"
+        config_path.write_text(config, encoding="utf-8")
+        return {"FONTCONFIG_FILE": str(config_path)}
+    except OSError:
+        return {}
+
+
+def apply_font_env(executable: str | os.PathLike,
+                   launch_kwargs: dict[str, Any]) -> None:
+    """Merge the bundled-font environment into Playwright launch options."""
+    font_env = linux_font_env(executable)
+    user_env = launch_kwargs.get("env")
+    if not font_env and user_env is None:
+        return
+    merged = dict(os.environ)
+    merged.update(font_env)
+    if user_env:
+        merged.update(user_env)
+    launch_kwargs["env"] = merged