gecko-web-runtime-client 1.4.2__tar.gz → 1.4.4__tar.gz

{gecko_web_runtime_client-1.4.2 → gecko_web_runtime_client-1.4.4}/PACKAGE_README.md

@@ -15,6 +15,47 @@ access to `childclm/gecko-web-runtime`. The Python client depends on
 `wpr-runtime-core` for Worker lifecycle and protocol compatibility. Historical
 HTTP imports are retained through `wpr-http`.
 
+## Optional HTTP WeChat integration
+
+The same distribution includes `gecko_web_runtime.integrations.wechat`.
+It uses `wpr-http` and a local Node.js environment, with no browser Page.
+Install version 1.4.4 or newer with its optional dependencies, then prepare Node.js
+20+ dependencies in the user's cache:
+
+```powershell
+pip install --upgrade "gecko-web-runtime-client[wechat]>=1.4.4"
+python -m gecko_web_runtime.integrations.wechat install-js
+```
+
+These commands require a client build containing this integration. An older
+published package does not acquire the integration by installing the extra.
+Local development: `pip install -e "./python[wechat]"`.
+
+```python
+from gecko_web_runtime.integrations.wechat import AsyncWechatClient
+
+async with AsyncWechatClient(proxy="") as client:
+    result = await client.get(article_url)
+    print(result.summary())
+    if result.ok:
+        article_html = result.html
+```
+
+Only Node dependencies are installed by `install-js`; a compatible Firefox
+network runtime is installed separately through `wpr-http`. Native graphics
+queries additionally require an installed Firefox ANGLE directory containing
+`libEGL.dll` and `libGLESv2.dll`, passed as `native_gl_dir` or `NATIVE_GL_DIR`.
+Direct article responses need neither Node nor native graphics.
+
+One client retains one HTTP session and serializes its article flows. Separate
+client instances have separate HTTP and JavaScript state. `total_timeout`
+bounds an active flow; cancellation terminates an active Node subprocess.
+The module uses Python logging and does not configure application handlers.
+Artifacts are off by default; `output_dir` opts into per-call directories that
+can contain session-sensitive diagnostic data. Keep those directories outside
+source control. Site rejection is returned as a structured failure, not a
+promise that any verification will succeed.
+
 ## Media capture
 
 For a browser-played Widevine page, use `AsyncMediaDownloader`. It starts the

{gecko_web_runtime_client-1.4.2 → gecko_web_runtime_client-1.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gecko-web-runtime-client
-Version: 1.4.2
+Version: 1.4.4
 Summary: Thin Python client for the Firefox-derived WPR Gecko Worker protocol
 Author: WPR project
 License: MPL-2.0-compatible client; see the runtime bundle notices
@@ -12,6 +12,12 @@ Requires-Dist: wpr-runtime-core<0.3,>=0.2.2
 Requires-Dist: wpr-http<0.3,>=0.2.0
 Provides-Extra: diagnostics
 Requires-Dist: loguru>=0.7.2; extra == "diagnostics"
+Provides-Extra: wechat
+Requires-Dist: wpr-http<0.3,>=0.2.1; extra == "wechat"
+Requires-Dist: wpr-runtime-core<0.3,>=0.2.3; extra == "wechat"
+Requires-Dist: Pillow<13,>=11; extra == "wechat"
+Requires-Dist: numpy<3,>=2; extra == "wechat"
+Requires-Dist: opencv-python-headless<6,>=4.10; extra == "wechat"
 
 # Gecko Web Runtime Client
 
@@ -30,6 +36,47 @@ access to `childclm/gecko-web-runtime`. The Python client depends on
 `wpr-runtime-core` for Worker lifecycle and protocol compatibility. Historical
 HTTP imports are retained through `wpr-http`.
 
+## Optional HTTP WeChat integration
+
+The same distribution includes `gecko_web_runtime.integrations.wechat`.
+It uses `wpr-http` and a local Node.js environment, with no browser Page.
+Install version 1.4.4 or newer with its optional dependencies, then prepare Node.js
+20+ dependencies in the user's cache:
+
+```powershell
+pip install --upgrade "gecko-web-runtime-client[wechat]>=1.4.4"
+python -m gecko_web_runtime.integrations.wechat install-js
+```
+
+These commands require a client build containing this integration. An older
+published package does not acquire the integration by installing the extra.
+Local development: `pip install -e "./python[wechat]"`.
+
+```python
+from gecko_web_runtime.integrations.wechat import AsyncWechatClient
+
+async with AsyncWechatClient(proxy="") as client:
+    result = await client.get(article_url)
+    print(result.summary())
+    if result.ok:
+        article_html = result.html
+```
+
+Only Node dependencies are installed by `install-js`; a compatible Firefox
+network runtime is installed separately through `wpr-http`. Native graphics
+queries additionally require an installed Firefox ANGLE directory containing
+`libEGL.dll` and `libGLESv2.dll`, passed as `native_gl_dir` or `NATIVE_GL_DIR`.
+Direct article responses need neither Node nor native graphics.
+
+One client retains one HTTP session and serializes its article flows. Separate
+client instances have separate HTTP and JavaScript state. `total_timeout`
+bounds an active flow; cancellation terminates an active Node subprocess.
+The module uses Python logging and does not configure application handlers.
+Artifacts are off by default; `output_dir` opts into per-call directories that
+can contain session-sensitive diagnostic data. Keep those directories outside
+source control. Site rejection is returned as a structured failure, not a
+promise that any verification will succeed.
+
 ## Media capture
 
 For a browser-played Widevine page, use `AsyncMediaDownloader`. It starts the

gecko_web_runtime_client-1.4.4/gecko_web_runtime/integrations/__init__.py

@@ -0,0 +1 @@
+"""Optional site integrations shipped with the browser client."""

gecko_web_runtime_client-1.4.4/gecko_web_runtime/integrations/wechat/__init__.py

@@ -0,0 +1,12 @@
+"""HTTP and local-JavaScript WeChat article client."""
+
+from .client import AsyncWechatClient
+from .exceptions import WechatDependencyError
+from .models import WechatArticle, WechatConfig
+
+__all__ = [
+    "AsyncWechatClient",
+    "WechatArticle",
+    "WechatConfig",
+    "WechatDependencyError",
+]

gecko_web_runtime_client-1.4.4/gecko_web_runtime/integrations/wechat/__main__.py

@@ -0,0 +1,23 @@
+"""Install optional Node dependencies into the user's WPR cache."""
+
+import argparse
+
+from .js_runtime.runtime import LocalJsRuntime
+from .models import WechatConfig
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("command", choices=["install-js"])
+    parser.add_argument("--cache-dir")
+    parser.add_argument("--node", default="node")
+    args = parser.parse_args()
+    runtime = LocalJsRuntime(
+        WechatConfig(js_cache_dir=args.cache_dir, node_executable=args.node)
+    )
+    print(runtime.install())
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

gecko_web_runtime_client-1.4.4/gecko_web_runtime/integrations/wechat/_article.py

@@ -0,0 +1,110 @@
+"""Article parsing without a Node dependency or a hard-coded article ID."""
+
+from html.parser import HTMLParser
+import hashlib
+import re
+from urllib.parse import parse_qs, urlsplit
+
+
+class ArticleParser(HTMLParser):
+    def __init__(self):
+        super().__init__(convert_charrefs=True)
+        self.stack = []
+        self.title = []
+        self.content = []
+        self.media = []
+        self.body_found = False
+
+    def handle_starttag(self, tag, attrs):
+        values = dict(attrs)
+        title = values.get("id") == "activity-name" or any(x[1] for x in self.stack)
+        body = values.get("id") == "js_content" or any(x[2] for x in self.stack)
+        self.body_found |= values.get("id") == "js_content"
+        skip = tag in {"script", "style"} or any(x[3] for x in self.stack)
+        if body and tag in {
+            "img",
+            "iframe",
+            "video",
+            "mp-video",
+            "mp-common-videosnap",
+        }:
+            self.media.append(
+                {
+                    "tag": tag,
+                    "src": values.get("data-src") or values.get("src", ""),
+                    "vid": values.get("vid") or values.get("data-vid", ""),
+                }
+            )
+        if body and tag in {"p", "section", "br", "h1", "h2"}:
+            self.content.append("\n")
+        if tag not in {
+            "area",
+            "base",
+            "br",
+            "col",
+            "embed",
+            "hr",
+            "img",
+            "input",
+            "link",
+            "meta",
+            "param",
+            "source",
+            "track",
+            "wbr",
+        }:
+            self.stack.append((tag, title, body, skip))
+
+    def handle_startendtag(self, tag, attrs):
+        self.handle_starttag(tag, attrs)
+        self.handle_endtag(tag)
+
+    def handle_endtag(self, tag):
+        for index in range(len(self.stack) - 1, -1, -1):
+            if self.stack[index][0] == tag:
+                if self.stack[index][2] and tag in {"p", "section", "h1", "h2"}:
+                    self.content.append("\n")
+                del self.stack[index:]
+                break
+
+    def handle_data(self, data):
+        if not self.stack or self.stack[-1][3]:
+            return
+        if self.stack[-1][1]:
+            self.title.append(data)
+        if self.stack[-1][2]:
+            self.content.append(data)
+
+
+def parse_article(html, url):
+    parser = ArticleParser()
+    parser.feed(html)
+    title = " ".join("".join(parser.title).split())
+    text = re.sub(
+        r"\n\s*\n+", "\n\n", re.sub(r"[ \t]+", " ", "".join(parser.content))
+    ).strip()
+    query = parse_qs(urlsplit(url).query)
+    identity = {
+        f"target_{key}_matches": query[key][0] in html if query.get(key) else None
+        for key in ("mid", "sn")
+    }
+    verified = (
+        bool(title)
+        and parser.body_found
+        and (len(text) > 100 or bool(parser.media))
+        and not re.search(r"register_code\s*:", html)
+        and all(value is not False for value in identity.values())
+    )
+    proof = {
+        "title": title,
+        "content_chars": len(text),
+        "media_count": len(parser.media),
+        "media": parser.media,
+        "html_bytes": len(html.encode("utf-8")),
+        "html_sha256": hashlib.sha256(html.encode("utf-8")).hexdigest(),
+        "article_verified": verified,
+        **identity,
+    }
+    if not verified:
+        raise ValueError("Article title/body/target identity verification failed")
+    return proof, text

gecko_web_runtime_client-1.4.4/gecko_web_runtime/integrations/wechat/_diagnostics.py

@@ -0,0 +1,207 @@
+"""Request-boundary observations; no proof generation or request mutation."""
+
+import asyncio
+import hashlib
+import hmac
+import ipaddress
+import json
+import re
+import secrets
+import time
+import traceback
+import os
+from pathlib import Path
+from datetime import datetime, timezone
+from urllib.parse import urlsplit
+
+_COOKIE_KEY = secrets.token_bytes(32)
+COOKIE_SCOPE = secrets.token_hex(6)
+EGRESS_URL = "https://myip.ipip.net"
+
+
+def observe_proxy_routes(
+    started_at, ended_at, *, process_names=("gecko-net-worker.exe",)
+):
+    """Read only target/echo routing records; never export subscriptions or auth."""
+    base = (
+        Path(os.environ.get("APPDATA", ""))
+        / "io.github.clash-verge-rev.clash-verge-rev"
+    )
+    hosts = {
+        "mp.weixin.qq.com",
+        "t.captcha.qq.com",
+        "captcha.gtimg.com",
+        "api.ipify.org",
+        "myip.ipip.net",
+    }
+    start = datetime.fromisoformat(started_at)
+    end = datetime.fromisoformat(ended_at)
+    rows = []
+    errors = []
+    for path in (base / "logs/service").glob("*.log"):
+        try:
+            for line in path.read_text(encoding="utf8", errors="replace").splitlines():
+                if not any(name in line for name in process_names) or not any(
+                    h in line for h in hosts
+                ):
+                    continue
+                stamp = re.search(r'time="([^\"]+)"', line)
+                route = re.search(
+                    r'--> ([^: ]+):(\d+) match (.*?) using (.*?)"?$', line
+                )
+                if not stamp or not route or route[1] not in hosts:
+                    continue
+                observed = datetime.fromisoformat(stamp[1])
+                if start <= observed <= end:
+                    rows.append(
+                        {
+                            "at": stamp[1],
+                            "host": route[1],
+                            "port": int(route[2]),
+                            "rule": route[3],
+                            "chain": route[4].rstrip('"'),
+                            "sourceLog": path.name,
+                        }
+                    )
+        except (OSError, ValueError) as error:
+            errors.append({"file": path.name, "type": type(error).__name__})
+    config = base / "clash-verge.yaml"
+    return {
+        "evidence": "read-only Mihomo connection logs; routing is not a server-side public-IP receipt",
+        "rows": sorted(rows, key=lambda row: row["at"]),
+        "errors": errors,
+        "configSha256": hashlib.sha256(config.read_bytes()).hexdigest()
+        if config.is_file()
+        else None,
+    }
+
+
+def utc_now():
+    return datetime.now(timezone.utc).isoformat(timespec="milliseconds")
+
+
+def safe_error_text(value):
+    text = str(value)
+    text = re.sub(
+        r'https?://[^\s\'"<>]+',
+        lambda m: (
+            urlsplit(m[0]).scheme
+            + "://"
+            + str(urlsplit(m[0]).hostname)
+            + urlsplit(m[0]).path
+        ),
+        text,
+    )
+    text = re.sub(
+        r"(?i)\b(cookie|authorization|ticket|randstr|sess|token|collect|eks)\s*[:=]\s*[^\s,;]+",
+        lambda m: m[1] + "=<redacted>",
+        text,
+    )
+    return re.sub(r"[A-Za-z0-9_+/=-]{48,}", "<opaque>", text)
+
+
+def exception_diagnostic(error, *, phase, round_number=None):
+    return {
+        "type": type(error).__name__,
+        "message": safe_error_text(error),
+        "phase": phase,
+        "round": round_number,
+        "atUtc": utc_now(),
+        "notes": [safe_error_text(x) for x in getattr(error, "__notes__", [])],
+        "frames": [
+            {
+                "file": frame.filename,
+                "line": frame.lineno,
+                "function": frame.name,
+                "source": safe_error_text(frame.line or ""),
+            }
+            for frame in traceback.extract_tb(error.__traceback__)
+        ],
+    }
+
+
+def native_gl_error_summary(entry):
+    keys = (
+        "query",
+        "stage",
+        "command",
+        "commandIndex",
+        "elapsedMs",
+        "executeMs",
+        "transportQueueMs",
+        "exitCode",
+        "exitCodeHex",
+        "processErrorCode",
+        "responseGenerated",
+        "backendPid",
+        "error",
+        "requestNumber",
+    )
+    return {
+        key: safe_error_text(entry[key]) if isinstance(entry[key], str) else entry[key]
+        for key in keys
+        if key in entry
+    }
+
+
+def cookie_observation(value=None):
+    """Tags are process-scoped; raw Cookie values are never written to disk."""
+
+    def tag(text):
+        return hmac.new(_COOKIE_KEY, text.encode("utf8"), hashlib.sha256).hexdigest()[
+            :24
+        ]
+
+    pairs = []
+    if value is not None:
+        for part in value.split(";"):
+            if "=" not in part:
+                continue
+            name, content = part.strip().split("=", 1)
+            pairs.append(
+                {
+                    "name": name,
+                    "valueBytes": len(content.encode("utf8")),
+                    "valueTag": tag(name + "\0" + content),
+                }
+            )
+    return {
+        "scope": COOKIE_SCOPE,
+        "headerSeen": value is not None,
+        "headerBytes": len(value.encode("utf8")) if value is not None else 0,
+        "headerTag": tag(value) if value is not None else None,
+        "pairs": pairs,
+    }
+
+
+async def observe_public_egress(client, endpoint=EGRESS_URL):
+    started = time.perf_counter()
+    result = {
+        "atUtc": utc_now(),
+        "endpoint": endpoint,
+        "evidence": "IP echo through this HTTP client; domain-based proxy routing may differ for target",
+        "targetEgressVerified": False,
+    }
+    try:
+        response = await asyncio.wait_for(
+            client.get(endpoint, header_policy="passthrough"), 6
+        )
+        raw = await asyncio.wait_for(response.read(), 6)
+        result["httpStatus"] = response.status_code
+        if response.status_code != 200:
+            raise RuntimeError("IP echo returned HTTP " + str(response.status_code))
+        text = raw.decode("utf8")
+        try:
+            address = ipaddress.ip_address(json.loads(text)["ip"])
+        except (ValueError, KeyError, TypeError):
+            found = re.search(r"\b(?:\d{1,3}\.){3}\d{1,3}\b", text)
+            if not found:
+                raise ValueError("IP echo did not contain an address")
+            address = ipaddress.ip_address(found[0])
+        if not address.is_global:
+            raise ValueError("IP echo returned a non-public address")
+        result["publicIp"] = str(address)
+    except Exception as error:
+        result["error"] = exception_diagnostic(error, phase="public_egress_echo")
+    result["elapsedMs"] = round((time.perf_counter() - started) * 1000, 2)
+    return result

gecko_web_runtime_client-1.4.4/gecko_web_runtime/integrations/wechat/_diagnostics_round.py

@@ -0,0 +1,177 @@
+"""Credential-free summaries of launcher lifecycle and parent/child inputs."""
+
+from collections import Counter
+from urllib.parse import urlsplit, parse_qsl
+import hashlib
+import hmac
+import re
+import secrets
+
+_BINDING_KEY = secrets.token_bytes(32)
+_BINDING_SCOPE = secrets.token_hex(6)
+
+
+def verification_response_summary(value):
+    """Keep diagnostic status text, never credentials or arbitrary response values."""
+
+    def safe_text(text):
+        text = re.sub(r"https?://\S+", "<url>", str(text))
+        text = re.sub(r"[A-Za-z0-9_+/=.-]{24,}", "<opaque>", text)
+        return " ".join(text.split())[:160]
+
+    result = {
+        "keys": sorted(str(k) for k in value),
+        "ticketPresent": bool(value.get("ticket")),
+        "randstrPresent": bool(value.get("randstr")),
+        "sessPresent": bool(value.get("sess")),
+    }
+    for key in [
+        "errorCode",
+        "errorMessage",
+        "errMessage",
+        "code",
+        "message",
+        "subcode",
+        "subCode",
+        "errorType",
+        "errcode",
+        "errmsg",
+        "msg",
+        "ret",
+        "err_msg",
+        "err_type",
+    ]:
+        if key in value and isinstance(value[key], (str, int, float, bool)):
+            result[key] = (
+                safe_text(value[key]) if isinstance(value[key], str) else value[key]
+            )
+    return result
+
+
+def binding_summary(
+    *,
+    source,
+    eks,
+    pre_sess,
+    submitted_sess,
+    pre_device,
+    submitted_device,
+    input_token,
+    output_token,
+):
+    def tag(kind, value):
+        if not value:
+            return None
+        return hmac.new(
+            _BINDING_KEY, (kind + "\0" + str(value)).encode("utf8"), hashlib.sha256
+        ).hexdigest()[:24]
+
+    candidates = [
+        match.group(2)
+        for match in re.finditer(
+            r"""window\.[A-Za-z_$][\w$]*\s*=\s*(['"])([A-Za-z0-9+/=]{100,})\1""", source
+        )
+    ]
+    return {
+        "scope": _BINDING_SCOPE,
+        "scopeMeaning": "process-local keyed equality tags; not authentication evidence",
+        "eksMatchesSourceLiteral": eks in candidates if candidates else None,
+        "sourceLiteralCandidates": len(candidates),
+        "sessPresent": bool(pre_sess),
+        "sessMatchesPrehandle": submitted_sess == pre_sess,
+        "deviceIdMatchesPrehandleQuery": submitted_device == pre_device,
+        "inputTokenPresent": bool(input_token),
+        "outputTokenPresent": bool(output_token),
+        "tokenRetained": bool(input_token) and input_token == output_token,
+        "preSessTag": tag("sess", pre_sess),
+        "submittedSessTag": tag("sess", submitted_sess),
+        "eksTag": tag("eks", eks),
+        "inputTokenTag": tag("token", input_token),
+        "outputTokenTag": tag("token", output_token),
+    }
+
+
+def request_boundary(name, method, url, headers, data=None):
+    parsed = urlsplit(url)
+    safe_headers = {}
+    for key, value in headers.items():
+        if key.lower() in {
+            "user-agent",
+            "accept",
+            "accept-language",
+            "accept-encoding",
+            "content-type",
+            "origin",
+            "sec-fetch-dest",
+            "sec-fetch-mode",
+            "sec-fetch-site",
+        }:
+            safe_headers[key.lower()] = str(value)
+        elif key.lower() == "referer":
+            ref = urlsplit(str(value))
+            safe_headers["referer"] = ref.scheme + "://" + ref.netloc + ref.path
+    shape = (
+        {str(key): len(str(value).encode("utf8")) for key, value in data.items()}
+        if isinstance(data, dict)
+        else None
+    )
+    return {
+        "name": name,
+        "method": str(method),
+        "endpoint": parsed.scheme + "://" + parsed.netloc + parsed.path,
+        "queryKeys": sorted({key for key, value in parse_qsl(parsed.query)}),
+        "preparedHeaders": safe_headers,
+        "bodyFieldBytes": shape,
+        "wireHeadersVerified": False,
+    }
+
+
+def resource_mismatch(stage, expected, actual):
+    return {
+        "stage": stage,
+        "expected": expected,
+        "actual": actual,
+        "matched": expected == actual,
+    }
+
+
+def summarize_round(generated, continuity, tdc_hash):
+    events = generated.get("events") or {}
+    handshake = generated.get("sdkHandshake") or {}
+    rows = (handshake.get("trackerData") or {}).get("slideValue") or []
+    messages = handshake.get("messages") or []
+    execution = generated.get("execution") or {}
+    return {
+        "tdcSha256": tdc_hash,
+        "lifecycle": generated.get("lifecycle") or [],
+        "phasesMs": execution.get("phases") or {},
+        "tokenContinuity": dict(continuity),
+        "parent": {
+            "rows": len(rows),
+            "eventTypes": dict(Counter(str(row[0]) for row in rows[1:] if row)),
+            "trustFlags": dict(
+                Counter(str(row[4]) for row in rows[1:] if len(row) > 4)
+            ),
+            "inputScope": events.get("parentInput"),
+            "completeParentSdk": handshake.get("completeParentSdk"),
+            "messages": [
+                {k: item.get(k) for k in ["phase", "from", "to", "type"]}
+                for item in messages
+            ],
+        },
+        "child": {
+            "eventTypes": events.get("types") or {},
+            "callbacks": events.get("callbacks"),
+            "trusted": events.get("trusted"),
+            "errorCount": len(events.get("errors") or []),
+        },
+        "motion": generated.get("dragMotion"),
+        "inputPlan": generated.get("dragInputPlan"),
+        "coordinates": generated.get("dragCoordinateAudit"),
+        "pageContext": generated.get("pageContext"),
+        **(
+            {"timeline": generated["hostTimeline"]}
+            if generated.get("hostTimeline")
+            else {}
+        ),
+    }