@acedatacloud/skills 2026.713.6 → 2026.714.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acedatacloud/skills",
-  "version": "2026.713.6",
+  "version": "2026.714.1",
   "description": "Agent Skills for AceDataCloud AI services — music, image, video generation, LLM chat, web search. Compatible with Claude Code, GitHub Copilot, Gemini CLI, OpenAI Codex, and 30+ AI coding agents.",
   "keywords": [
     "agent-skills",

package/skills/tgstat/SKILL.md

@@ -12,14 +12,16 @@ allowed_tools: [Bash, web_search, web_fetch]
 license: Apache-2.0
 metadata:
   author: acedatacloud
-  version: "2.1"
+  version: "2.2"
 ---
 
 # TGStat Research
 
 Use [scripts/tgstat.py](./scripts/tgstat.py) for public TGStat research. It uses
-only the Python standard library. Resolve the script at the start of every Bash
-call because each call runs in a fresh shell:
+only the Python standard library. Under the hood it fetches TGStat pages through
+the platform render service (headless Chromium), which bypasses the public
+site's bot protection, so each lookup can take several seconds. Resolve the
+script at the start of every Bash call because each call runs in a fresh shell:
 
 ```bash
 TGSTAT="$SKILL_DIR/scripts/tgstat.py"; [ -f "$TGSTAT" ] || TGSTAT=$(find /tmp -maxdepth 8 -path '*/skills/*/scripts/tgstat.py' 2>/dev/null | head -1)
@@ -93,10 +95,15 @@ python3 "$TGSTAT" info @durov
 python3 "$TGSTAT" stat https://t.me/example_public_chat
 ```
 
-In public mode, `info`/`stat` resolves whether the target is a channel or chat,
-returns public metadata, and enriches it with ranking metrics when the entity
-appears in the current public ranking. Empty metrics mean TGStat did not expose
-them publicly; do not call that full statistics.
+In public mode, `info`/`stat` resolves whether the target is a channel or chat
+and returns its public identity (title, description) plus the visible
+subscriber / participant count. Deeper engagement metrics (average post reach,
+citation index, ER) are charted client-side on TGStat, so they are only
+available for entities that appear in the public top ratings — for those the
+command enriches the result from the ranking snapshot. Empty or missing metrics
+mean TGStat did not expose them on the public page; do not call that full
+statistics. Use `rankings` when you need reach / citation index for large
+public sources.
 
 For ad selection, rank by relevant reach/activity rather than subscriber count
 alone. High subscribers with weak reach or chat MAU can indicate an inactive or

package/skills/tgstat/scripts/tgstat.py

@@ -8,6 +8,7 @@ import json
 import os
 import re
 import sys
+import time
 import urllib.error
 import urllib.parse
 import urllib.request
@@ -15,14 +16,17 @@ from html.parser import HTMLParser
 from typing import Dict, List, Optional, Tuple, Union
 
 DEFAULT_PUBLIC_BASE = "https://tgstat.com"
-USER_AGENT = (
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
-    "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126 Safari/537.36"
-)
+# Public tgstat.com sits behind Cloudflare, so pages are fetched through the
+# platform WebExtrator render service (headless Chromium) instead of directly.
+RENDER_ENDPOINT = os.environ.get("TGSTAT_RENDER_ENDPOINT", "https://api.acedata.cloud/webextrator/render")
+RENDER_TOKEN_ENV = "TGSTAT_RENDER_TOKEN"
+RENDER_DELAY_SECONDS = 2
+RENDER_BLOCK_RESOURCES = ["image", "font", "media", "stylesheet"]
 PUBLIC_USERNAME_RE = re.compile(r"[A-Za-z0-9_]{3,}")
 TGSTAT_HOST_RE = re.compile(r"^(?:[a-z]{2,3}\.)?tgstat\.com$", re.IGNORECASE)
 TGSTAT_INPUT_HOST_RE = re.compile(r"^(?:(?:[a-z]{2,3}\.)?tgstat\.com|tgstat\.ru)$", re.IGNORECASE)
-ENTITY_PATH_RE = re.compile(r"/(channel|chat)/(@[A-Za-z0-9_]{3,}|id\d+)/stat/?", re.IGNORECASE)
+# The /stat suffix is optional: the summary metrics live on the main entity page.
+ENTITY_PATH_RE = re.compile(r"/(channel|chat)/(@[A-Za-z0-9_]{3,}|id\d+)(?:/stat)?/?", re.IGNORECASE)
 
 
 class TGStatError(RuntimeError):
@@ -81,24 +85,6 @@ def _validate_request_url(url: str, initial_host: Optional[str] = None) -> None:
         raise TGStatError(f"unsupported TGStat request host: {allowed_from}")
 
 
-class SafeRedirectHandler(urllib.request.HTTPRedirectHandler):
-    def __init__(self, initial_host: str) -> None:
-        super().__init__()
-        self.initial_host = initial_host
-
-    def redirect_request(self, req, fp, code, msg, headers, newurl):
-        _validate_request_url(newurl, self.initial_host)
-        return super().redirect_request(req, fp, code, msg, headers, newurl)
-
-
-def _open_url(request: urllib.request.Request, timeout: int):
-    initial_url = request.full_url
-    _validate_request_url(initial_url)
-    initial_host = urllib.parse.urlsplit(initial_url).hostname or ""
-    opener = urllib.request.build_opener(SafeRedirectHandler(initial_host))
-    return opener.open(request, timeout=timeout)
-
-
 class RankingParser(HTMLParser):
     def __init__(self) -> None:
         super().__init__(convert_charrefs=True)
@@ -215,9 +201,12 @@ class DetailParser(HTMLParser):
         self.metrics: Dict[str, Union[int, float, str]] = {}
         self.metrics_display: Dict[str, str] = {}
         self.text_parts: List[str] = []
+        self._tag_index = 0
+        self._pending_at = -100
 
     def handle_starttag(self, tag: str, attrs: List[Tuple[str, Optional[str]]]) -> None:
         attr = {key.lower(): value or "" for key, value in attrs}
+        self._tag_index += 1
         if tag == "meta":
             key = (attr.get("property") or attr.get("name") or "").lower()
             if key in {"og:title", "og:description", "description"} and attr.get("content"):
@@ -229,10 +218,12 @@ class DetailParser(HTMLParser):
         kind = ""
         if tag == "title":
             kind = "title"
-        elif tag == "h4":
+        elif tag in {"h2", "h3", "h4"} and "text-dark" in classes:
             kind = "metric_value"
-        elif tag == "div" and {"text-muted", "text-truncate"}.issubset(classes):
-            if self.pending_metric is not None:
+        elif tag == "div" and {"text-uppercase", "font-12"}.issubset(classes):
+            # Only pair a label that sits right after its value inside the same
+            # stat card, so a stray numeric heading can't grab a distant label.
+            if self.pending_metric is not None and self._tag_index - self._pending_at <= 6:
                 kind = "metric_label"
         if kind:
             self.capture = {"kind": kind, "depth": 1, "parts": []}
@@ -248,13 +239,15 @@ class DetailParser(HTMLParser):
         self.capture = None
         if kind == "title" and value:
             self.meta.setdefault("title", value)
-        elif kind == "metric_value" and value:
+        elif kind == "metric_value" and _metric_number(value) is not None:
             self.pending_metric = value
+            self._pending_at = self._tag_index
         elif kind == "metric_label" and value and self.pending_metric is not None:
-            key = _metric_key(value)
-            self.metrics_display[key] = self.pending_metric
             number = _metric_number(self.pending_metric)
-            self.metrics[key] = number if number is not None else self.pending_metric
+            if number is not None:
+                key = _metric_key(value)
+                self.metrics_display[key] = self.pending_metric
+                self.metrics[key] = number
             self.pending_metric = None
 
     def handle_data(self, data: str) -> None:
@@ -277,13 +270,24 @@ def parse_detail_html(html: str, url: str) -> dict:
     text = " ".join(parser.text_parts)
     entity = _entity_from_url(url)
     title = parser.meta.get("og:title") or parser.meta.get("title")
-    recognized = bool(entity and parser.meta.get("og:title") and title and "tgstat" in title.casefold())
+    # A real entity page echoes the requested @username / id in its title or
+    # emits an og:title; tgstat error / search / interstitial pages do neither
+    # (the bare "TGStat" brand in <title> is not proof the entity exists).
+    identifier_token = str(entity[1]).casefold() if entity else ""
+    recognized = bool(
+        entity and title and (identifier_token in title.casefold() or bool(parser.meta.get("og:title")))
+    )
+    lowered_title = (title or "").casefold()
+    if "not found" in lowered_title or "404" in lowered_title:
+        status = "not_found"
+    elif "authentication required" in text.lower():
+        status = "restricted"
+    elif recognized:
+        status = "ok"
+    else:
+        status = "unrecognized"
     result = {
-        "status": (
-            "restricted"
-            if "authentication required" in text.lower()
-            else "ok" if recognized else "unrecognized"
-        ),
+        "status": status,
         "type": entity[0] if entity else None,
         "identifier": entity[1] if entity else None,
         "title": title,
@@ -301,28 +305,88 @@ def _json_out(payload: object) -> None:
     print(json.dumps(payload, ensure_ascii=False, indent=2))
 
 
-def _request_with_url(
-    url: str, timeout: int, data: Optional[bytes] = None, headers: Optional[dict] = None
-) -> Tuple[str, str]:
-    request_headers = {
-        "User-Agent": USER_AGENT,
-        "Accept": "application/json, text/html;q=0.9, */*;q=0.8",
-        "Accept-Language": "en-US,en;q=0.9",
-        **(headers or {}),
-    }
-    request = urllib.request.Request(url, data=data, headers=request_headers)
-    try:
-        with _open_url(request, timeout) as response:
-            return response.read().decode("utf-8", "replace"), response.geturl()
-    except urllib.error.HTTPError as exc:
-        body = exc.read().decode("utf-8", "replace")
-        raise TGStatError(f"HTTP {exc.code} from {_safe_url(url)}: {_safe_error_body(body)}") from exc
-    except urllib.error.URLError as exc:
-        raise TGStatError(f"network error for {_safe_url(url)}: {_safe_error_body(str(exc.reason))}") from exc
+def _render_token() -> str:
+    token = os.environ.get(RENDER_TOKEN_ENV, "").strip()
+    if not token:
+        raise TGStatError("TGStat rendering is not configured: the platform render token is missing")
+    return token
+
+
+# Render statuses worth retrying: Cloudflare/anti-bot interstitials surface as
+# 422 antibot_blocked, and the render service can transiently 429/5xx.
+_RETRYABLE_RENDER_STATUS = frozenset({422, 425, 429, 500, 502, 503, 504})
+_RENDER_ATTEMPTS = 3
+
+
+def _request_with_url(url: str, timeout: int) -> Tuple[str, str]:
+    # Public tgstat.com is behind Cloudflare; render it through the platform
+    # WebExtrator service (headless Chromium) rather than fetching directly.
+    # Anti-bot blocks are intermittent, so retry with a longer settle and a
+    # cache bypass before giving up.
+    _validate_request_url(url)
+    render_timeout = max(20, min(timeout, 45))
+    token = _render_token()
+    last_reason = ""
+    for attempt in range(_RENDER_ATTEMPTS):
+        payload = json.dumps(
+            {
+                "url": url,
+                "wait_until": "domcontentloaded",
+                "delay": RENDER_DELAY_SECONDS + 2 * attempt,
+                "timeout": render_timeout,
+                "block_resources": RENDER_BLOCK_RESOURCES,
+                "bypass_cache": attempt > 0,
+            }
+        ).encode()
+        request = urllib.request.Request(
+            RENDER_ENDPOINT,
+            data=payload,
+            headers={
+                "Authorization": f"Bearer {token}",
+                "Content-Type": "application/json",
+                "Accept": "application/json",
+            },
+        )
+        try:
+            with urllib.request.urlopen(request, timeout=render_timeout + 75) as response:
+                envelope = json.loads(response.read().decode("utf-8", "replace"))
+        except urllib.error.HTTPError as exc:
+            body = exc.read().decode("utf-8", "replace")
+            if exc.code in _RETRYABLE_RENDER_STATUS or "antibot" in body.lower():
+                last_reason = f"render blocked (HTTP {exc.code}): {_safe_error_body(body)}"
+                _render_backoff(attempt)
+                continue
+            raise TGStatError(f"render service HTTP {exc.code}: {_safe_error_body(body)}") from exc
+        except urllib.error.URLError as exc:
+            last_reason = f"render service unreachable: {_safe_error_body(str(exc.reason))}"
+            _render_backoff(attempt)
+            continue
+        except json.JSONDecodeError as exc:
+            raise TGStatError(f"render service returned invalid JSON: {_safe_error_body(str(exc))}") from exc
+        render = envelope.get("data") if isinstance(envelope, dict) else None
+        if isinstance(render, dict):
+            html = render.get("html") or ""
+            final_url = render.get("finalUrl") or render.get("url") or url
+            if html.strip() and "challenge-platform" not in html and "Just a moment" not in html:
+                final_host = urllib.parse.urlparse(final_url).hostname or ""
+                if not (TGSTAT_HOST_RE.fullmatch(final_host) or TGSTAT_INPUT_HOST_RE.fullmatch(final_host)):
+                    raise TGStatError(f"render redirected to an unexpected host: {final_host}")
+                return html, final_url
+            last_reason = f"empty or interstitial render (upstream status {render.get('status')})"
+        else:
+            last_reason = "render service returned no page data"
+        _render_backoff(attempt)
+    raise TGStatError(f"could not render {_safe_url(url)}: {last_reason}")
+
 
+def _render_backoff(attempt: int) -> None:
+    # Skip the wait after the final attempt; give Cloudflare a moment otherwise.
+    if attempt < _RENDER_ATTEMPTS - 1:
+        time.sleep(min(2 + 2 * attempt, 6))
 
-def _request(url: str, timeout: int, data: Optional[bytes] = None, headers: Optional[dict] = None) -> str:
-    return _request_with_url(url, timeout, data, headers)[0]
+
+def _request(url: str, timeout: int) -> str:
+    return _request_with_url(url, timeout)[0]
 
 
 def _public_base(value: str) -> str:
@@ -468,7 +532,10 @@ def command_rankings(args: argparse.Namespace) -> None:
 def _public_info(args: argparse.Namespace, target: str, peer_type: str) -> dict:
     identifier, inferred_type, exact_url = _normalize_target(target)
     types = [inferred_type] if inferred_type else ([peer_type] if peer_type != "auto" else ["channel", "chat"])
-    urls = [exact_url] if exact_url else [f"{_public_base(args.host)}/{kind}/{identifier}/stat" for kind in types]
+    if exact_url:
+        urls = [re.sub(r"/stat/?$", "", exact_url)]
+    else:
+        urls = [f"{_public_base(args.host)}/{kind}/{identifier}" for kind in types]
     errors: List[str] = []
     for url in urls:
         if not url:
@@ -476,7 +543,7 @@ def _public_info(args: argparse.Namespace, target: str, peer_type: str) -> dict:
         try:
             html, final_url = _request_with_url(url, args.timeout)
             final_host = urllib.parse.urlparse(final_url).hostname or ""
-            if not TGSTAT_HOST_RE.fullmatch(final_host):
+            if not (TGSTAT_HOST_RE.fullmatch(final_host) or TGSTAT_INPUT_HOST_RE.fullmatch(final_host)):
                 raise TGStatError(f"TGStat redirected to an unexpected host: {final_host}")
             result = parse_detail_html(html, final_url)
         except TGStatError as exc:
@@ -504,7 +571,7 @@ def _public_info(args: argparse.Namespace, target: str, peer_type: str) -> dict:
                         "source": ranking_url,
                     }
             return result
-        errors.append(f"restricted or empty public page: {url}")
+        errors.append(f"{result['status']} public page: {url}")
     raise TGStatError("; ".join(errors) or "could not resolve target on public TGStat pages")
 
 
@@ -521,7 +588,7 @@ def command_stat(args: argparse.Namespace) -> None:
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--host", default=os.environ.get("TGSTAT_PUBLIC_HOST", DEFAULT_PUBLIC_BASE))
-    parser.add_argument("--timeout", type=int, default=30)
+    parser.add_argument("--timeout", type=int, default=45)
     sub = parser.add_subparsers(dest="command", required=True)
 
     sub.add_parser("profile").set_defaults(func=command_profile)

package/skills/xiaohongshu/scripts/vendor/xhs/cdp.py

@@ -11,6 +11,7 @@ import os
 import random
 import select
 import time
+from collections import deque
 from typing import Any
 
 from .errors import CDPError, ElementNotFoundError
@@ -105,6 +106,7 @@ class Page:
         self.session_id = session_id
         self._transport = cdp._transport
         self._id_counter = 1000
+        self._events: deque[dict[str, Any]] = deque(maxlen=256)
 
     def _send_session(self, method: str, params: dict | None = None) -> dict:
         """向 session 发送命令。"""
@@ -132,8 +134,25 @@ class Page:
                 if "error" in data:
                     raise CDPError(f"CDP 错误: {data['error']}")
                 return data.get("result", {})
+            if "method" in data and data.get("sessionId") == self.session_id:
+                self._events.append(data)
         raise CDPError(f"等待 session 响应超时 (id={msg_id})")
 
+    def clear_events(self) -> None:
+        self._events.clear()
+
+    def wait_for_event(self, timeout: float) -> dict[str, Any] | None:
+        if self._events:
+            return self._events.popleft()
+        try:
+            raw = self._transport.recv(timeout)
+        except TimeoutError:
+            return None
+        data = json.loads(raw)
+        if "method" in data and data.get("sessionId") == self.session_id:
+            return data
+        return None
+
     def navigate(self, url: str) -> None:
         """导航到指定 URL。"""
         logger.info("导航到: %s", url)
@@ -335,6 +354,97 @@ class Page:
         self.mouse_click(x, y)
         return True
 
+    def click_pierced_button(self, host_name: str, button_text: str) -> bool:
+        document = self._send_session("DOM.getDocument", {"depth": -1, "pierce": True})
+        targets: list[dict[str, Any]] = []
+
+        def attrs(node: dict[str, Any]) -> dict[str, str]:
+            values = node.get("attributes") or []
+            return dict(zip(values[0::2], values[1::2]))
+
+        def content(node: dict[str, Any]) -> str:
+            chunks = [node.get("nodeValue") or ""]
+            for child in node.get("children") or []:
+                chunks.append(content(child))
+            for shadow_root in node.get("shadowRoots") or []:
+                chunks.append(content(shadow_root))
+            return "".join(chunks).strip()
+
+        def find_button(node: dict[str, Any]) -> None:
+            properties = attrs(node)
+            if (
+                node.get("nodeName") == "BUTTON"
+                and content(node) == button_text
+                and "disabled" not in properties
+                and properties.get("aria-disabled") != "true"
+            ):
+                targets.append(node)
+                return
+            for child in node.get("children") or []:
+                find_button(child)
+            for shadow_root in node.get("shadowRoots") or []:
+                find_button(shadow_root)
+
+        def find_host(node: dict[str, Any]) -> None:
+            properties = attrs(node)
+            if node.get("nodeName") == host_name.upper() and properties.get("is-publish") == "true":
+                for shadow_root in node.get("shadowRoots") or []:
+                    find_button(shadow_root)
+                return
+            for child in node.get("children") or []:
+                find_host(child)
+
+        find_host(document["root"])
+        for target in targets:
+            node_ref = {"backendNodeId": target["backendNodeId"]}
+            try:
+                self._send_session("DOM.scrollIntoViewIfNeeded", node_ref)
+                model = self._send_session("DOM.getBoxModel", node_ref).get("model")
+            except CDPError:
+                continue
+            if not model or not model.get("width") or not model.get("height"):
+                continue
+            quad = model.get("border") or model.get("content")
+            if not quad or len(quad) < 8:
+                continue
+            x = sum(quad[0::2]) / 4
+            y = sum(quad[1::2]) / 4
+            hit = self._send_session(
+                "DOM.getNodeForLocation",
+                {"x": int(x), "y": int(y), "includeUserAgentShadowDOM": True},
+            )
+            hit_id = hit.get("backendNodeId")
+            if hit_id != target.get("backendNodeId"):
+                if not hit_id:
+                    continue
+                try:
+                    hit_object_id = self._send_session(
+                        "DOM.resolveNode", {"backendNodeId": hit_id}
+                    ).get("object", {}).get("objectId")
+                    button_object_id = self._send_session(
+                        "DOM.resolveNode", node_ref
+                    ).get("object", {}).get("objectId")
+                    if not hit_object_id or not button_object_id:
+                        continue
+                    contains = self._send_session(
+                        "Runtime.callFunctionOn",
+                        {
+                            "objectId": hit_object_id,
+                            "functionDeclaration": "function(button) { return button.contains(this); }",
+                            "arguments": [{"objectId": button_object_id}],
+                            "returnByValue": True,
+                        },
+                    ).get("result", {}).get("value")
+                except CDPError:
+                    contains = False
+                if contains is not True:
+                    continue
+            self.mouse_move(x, y)
+            time.sleep(random.uniform(0.03, 0.08))
+            self.mouse_click(x, y)
+            return True
+        return False
+
     def input_text(self, selector: str, text: str) -> None:
         """向指定选择器的元素输入文本。"""
         self.evaluate(

package/skills/xiaohongshu/scripts/vendor/xhs/publish.py

@@ -7,6 +7,8 @@ import logging
 import random
 import re
 import time
+import base64
+from urllib.parse import urlsplit
 
 from .cdp import Page
 from .errors import (
@@ -255,46 +257,161 @@ def click_publish_button(page: Page) -> None:
         """
     )
 
-    # 2) dispatchEvent 触发发布
-    fire_result = page.evaluate(
+    # 2) 点击 closed shadow DOM 内的真实按钮（CDP Input，isTrusted=true）
+    host_state = page.evaluate(
         """
         (() => {
             const host = document.querySelector('xhs-publish-btn[is-publish="true"]');
             if (!host) return 'not_found';
             if (host.getAttribute('submit-disabled') === 'true') return 'disabled';
             window.__xhsPublishStartedAt = Date.now();
-            if (typeof host._onPublish === 'function') host._onPublish();
-            else host.dispatchEvent(new CustomEvent('publish', {
-                bubbles: true, composed: true, cancelable: true
-            }));
-            return 'fired';
+            return 'ready';
         })()
         """
     )
-    if fire_result == "not_found":
+    if host_state == "not_found":
         raise PublishError("未找到 <xhs-publish-btn> 发布按钮容器")
-    if fire_result == "disabled":
+    if host_state == "disabled":
         raise PublishError("发布按钮 submit-disabled=true，不可发布")
+    page._send_session("Network.enable")
+    page.clear_events()
+    if not page.click_pierced_button("xhs-publish-btn", "发布"):
+        raise PublishError("未找到可安全点击的原生发布按钮")
 
-    # 3) 轮询等待 publish API 响应（15s 超时）
+    # 3) 优先从 CDP Network 事件读取响应，页面 hook 仅作兼容兜底
     deadline = time.monotonic() + 15
     result = None
+    requests: dict[str, bool] = {}
+
+    def publish_path_kind(url: str) -> str:
+        segments = {part for part in urlsplit(url).path.lower().split("/") if part}
+        note_segments = {"note", "notes", "publish_note", "create_note"}
+        if not segments & note_segments:
+            return ""
+        if segments & {"publish", "publish_note"}:
+            return "publish"
+        if segments & {"create", "create_note"}:
+            return "create"
+        return ""
+
+    def publish_result(body: str) -> dict[str, Any] | None:
+        try:
+            parsed = json.loads(body)
+        except (json.JSONDecodeError, TypeError):
+            return None
+        if not isinstance(parsed, dict):
+            return None
+        serialized = json.dumps(parsed, ensure_ascii=False)
+        has_publish_evidence = bool(
+            re.search(r'"note_id"\s*:\s*"[^"\s]+"', serialized)
+            or re.search(r'"code"\s*:\s*-913\d', serialized)
+            or "禁止发笔记" in serialized
+            or "HTTPBizError" in serialized
+        )
+        return parsed if has_publish_evidence else None
+
+    def find_field(value: Any, name: str) -> Any:
+        if isinstance(value, dict):
+            if name in value:
+                return value[name]
+            for item in value.values():
+                found = find_field(item, name)
+                if found is not None:
+                    return found
+        elif isinstance(value, list):
+            for item in value:
+                found = find_field(item, name)
+                if found is not None:
+                    return found
+        return None
+
+    def find_risk(value: Any) -> tuple[int, str] | None:
+        if isinstance(value, dict):
+            code_value = value.get("code")
+            if isinstance(code_value, int) and -9140 <= code_value <= -9130:
+                return code_value, str(value.get("msg") or "账号被风控")
+            for item in value.values():
+                found = find_risk(item)
+                if found:
+                    return found
+        elif isinstance(value, list):
+            for item in value:
+                found = find_risk(item)
+                if found:
+                    return found
+        return None
+
     while time.monotonic() < deadline:
-        result = page.evaluate("window.__xhsPublishResult")
+        event = page.wait_for_event(min(0.3, max(0.01, deadline - time.monotonic())))
+        if event and event.get("method") == "Network.requestWillBeSent":
+            params = event.get("params") or {}
+            request = params.get("request") or {}
+            method = str(request.get("method") or "")
+            url = str(request.get("url") or "")
+            path_kind = publish_path_kind(url)
+            if method in {"POST", "PUT", "PATCH"} and path_kind:
+                requests[str(params.get("requestId") or "")] = path_kind == "publish"
+        elif event and event.get("method") == "Network.loadingFinished":
+            params = event.get("params") or {}
+            request_id = str(params.get("requestId") or "")
+            if request_id in requests:
+                authoritative_success = requests[request_id]
+                try:
+                    response_body = page._send_session(
+                        "Network.getResponseBody", {"requestId": request_id}
+                    )
+                    body = response_body.get("body", "")
+                    if response_body.get("base64Encoded") is True:
+                        body = base64.b64decode(body, validate=True).decode("utf-8")
+                    parsed = publish_result(body)
+                    if parsed:
+                        risk = find_risk(parsed)
+                        note_id = find_field(parsed, "note_id")
+                        if risk or authoritative_success or not note_id:
+                            result = {"source": "cdp", **parsed}
+                except (CDPError, ValueError, UnicodeDecodeError):
+                    result = None
+                finally:
+                    requests.pop(request_id, None)
+        elif event and event.get("method") == "Network.loadingFailed":
+            request_id = str((event.get("params") or {}).get("requestId") or "")
+            requests.pop(request_id, None)
+        if not result:
+            fallback = page.evaluate("window.__xhsPublishResult")
+            if isinstance(fallback, dict):
+                fallback_code = fallback.get("code")
+                fallback_msg = str(fallback.get("msg") or "")
+                if (
+                    isinstance(fallback_code, int)
+                    and fallback_code != 0
+                    or "HTTPBizError" in fallback_msg
+                    or "禁止发笔记" in fallback_msg
+                ):
+                    result = fallback
         if result:
             break
-        time.sleep(0.3)
 
     if not result:
         raise PublishError("15s 内未捕获到发布成功反馈")
 
     # 4) 解析业务码
     source = result.get("source", "unknown")
-    code = result.get("code")
-    msg = result.get("msg", "")
+    nested_risk = find_risk(result)
+    if nested_risk:
+        raise AccountRiskControlError(*nested_risk)
+    code = find_field(result, "code")
+    msg = find_field(result, "msg") or ""
     success = result.get("success")
+    note_id = find_field(result, "note_id")
+    if not isinstance(note_id, str):
+        note_id = ""
     logger.info("捕获发布响应（来源=%s code=%s msg=%r）", source, code, msg)
 
+    if note_id:
+        logger.info("发布成功（CDP 已返回 note_id）")
+        time.sleep(2)
+        return
+
     if code == 0 or success is True:
         confirmed = page.evaluate(
             """
@@ -972,13 +1089,16 @@ def _set_visibility(page: Page, visibility: str) -> None:
 
     selected = page.evaluate(
         f"""
-        (() => [...document.querySelectorAll({json.dumps(VISIBILITY_OPTIONS)})]
-            .some(opt => opt.textContent.includes({json.dumps(visibility)}) && (
+        (() => {{
+            const legacySelected = [...document.querySelectorAll({json.dumps(VISIBILITY_OPTIONS)})]
+                .some(opt => opt.textContent.includes({json.dumps(visibility)}) && (
                 opt.classList.contains('active')
                 || opt.classList.contains('selected')
                 || opt.getAttribute('aria-selected') === 'true'
                 || opt.querySelector('input:checked')
-            )))()
+            ));
+            return legacySelected;
+        }})()
         """
     )
     if not selected:

package/skills/xiaohongshu/tests/test_xiaohongshu.py

@@ -538,14 +538,367 @@ class CommandSafetyTests(unittest.TestCase):
         import xhs.publish as publish
 
         page = MagicMock()
-        page.evaluate.side_effect = [None, "fired", *([None] * 60)]
+        page.evaluate.side_effect = [None, "ready", *([None] * 60)]
+        page.wait_for_event.return_value = None
+        page.click_pierced_button.return_value = True
         with (
             patch.object(publish.time, "monotonic", side_effect=[0, 0, *range(1, 17)]),
-            patch.object(publish.time, "sleep"),
             self.assertRaisesRegex(publish.PublishError, "未捕获到发布成功反馈"),
         ):
             publish.click_publish_button(page)
 
+    def test_publish_ignores_creator_telemetry_and_waits_for_finished_body(self) -> None:
+        if str(MODULE.VENDOR_DIR) not in sys.path:
+            sys.path.insert(0, str(MODULE.VENDOR_DIR))
+        import xhs.publish as publish
+
+        page = MagicMock()
+        page.evaluate.side_effect = [None, "ready", None, None, None, None, True]
+        page.click_pierced_button.return_value = True
+        page.wait_for_event.side_effect = [
+            {
+                "method": "Network.requestWillBeSent",
+                "params": {
+                    "requestId": "telemetry",
+                    "request": {
+                        "method": "POST",
+                        "url": "https://creator.xiaohongshu.com/api/telemetry",
+                    },
+                },
+            },
+            {"method": "Network.loadingFinished", "params": {"requestId": "telemetry"}},
+            {
+                "method": "Network.requestWillBeSent",
+                "params": {
+                    "requestId": "publish",
+                    "request": {
+                        "method": "POST",
+                        "url": "https://edith.xiaohongshu.com/api/sns/web/v1/note/publish",
+                    },
+                },
+            },
+            {
+                "method": "Network.responseReceived",
+                "params": {"requestId": "publish"},
+            },
+            {"method": "Network.loadingFinished", "params": {"requestId": "publish"}},
+        ]
+
+        def send(method: str, _params: dict | None = None) -> dict:
+            if method == "Network.getResponseBody":
+                return {"body": '{"code":0,"data":{"note_id":"note"}}'}
+            return {}
+
+        page._send_session.side_effect = send
+        with (
+            patch.object(publish.time, "monotonic", return_value=0),
+            patch.object(publish.time, "sleep"),
+        ):
+            publish.click_publish_button(page)
+
+        body_calls = [
+            call
+            for call in page._send_session.call_args_list
+            if call.args and call.args[0] == "Network.getResponseBody"
+        ]
+        self.assertEqual(len(body_calls), 1)
+        self.assertEqual(body_calls[0].args[1], {"requestId": "publish"})
+
+    def test_publish_decodes_base64_body_and_ignores_success_fallback(self) -> None:
+        if str(MODULE.VENDOR_DIR) not in sys.path:
+            sys.path.insert(0, str(MODULE.VENDOR_DIR))
+        import base64
+        import xhs.publish as publish
+
+        page = MagicMock()
+        page.evaluate.side_effect = [
+            None,
+            "ready",
+            {"code": 0, "success": True, "note_id": "autosave"},
+            {"code": 0, "success": True, "note_id": "autosave"},
+            True,
+        ]
+        page.click_pierced_button.return_value = True
+        page.wait_for_event.side_effect = [
+            {
+                "method": "Network.requestWillBeSent",
+                "params": {
+                    "requestId": "publish",
+                    "request": {
+                        "method": "POST",
+                        "url": "https://edith.xiaohongshu.com/api/note/publish",
+                    },
+                },
+            },
+            {"method": "Network.responseReceived", "params": {"requestId": "publish"}},
+            {"method": "Network.loadingFinished", "params": {"requestId": "publish"}},
+        ]
+        encoded = base64.b64encode(b'{"data":{"note_id":"published"}}').decode()
+
+        def send(method: str, _params: dict | None = None) -> dict:
+            if method == "Network.getResponseBody":
+                return {"body": encoded, "base64Encoded": True}
+            return {}
+
+        page._send_session.side_effect = send
+        with (
+            patch.object(publish.time, "monotonic", return_value=0),
+            patch.object(publish.time, "sleep"),
+        ):
+            publish.click_publish_button(page)
+
+        self.assertEqual(
+            [call.args[0] for call in page._send_session.call_args_list].count(
+                "Network.getResponseBody"
+            ),
+            1,
+        )
+
+    def test_publish_classifies_nested_risk_control_response(self) -> None:
+        if str(MODULE.VENDOR_DIR) not in sys.path:
+            sys.path.insert(0, str(MODULE.VENDOR_DIR))
+        import xhs.publish as publish
+
+        page = MagicMock()
+        page.evaluate.side_effect = [None, "ready", None]
+        page.click_pierced_button.return_value = True
+        page.wait_for_event.side_effect = [
+            {
+                "method": "Network.requestWillBeSent",
+                "params": {
+                    "requestId": "publish",
+                    "request": {
+                        "method": "POST",
+                        "url": "https://edith.xiaohongshu.com/api/note/publish",
+                    },
+                },
+            },
+            {"method": "Network.loadingFinished", "params": {"requestId": "publish"}},
+        ]
+        page._send_session.side_effect = lambda method, _params=None: (
+            {"body": '{"code":0,"data":{"code":-9136,"msg":"禁止发笔记"}}'}
+            if method == "Network.getResponseBody"
+            else {}
+        )
+        with (
+            patch.object(publish.time, "monotonic", return_value=0),
+            self.assertRaises(publish.AccountRiskControlError),
+        ):
+            publish.click_publish_button(page)
+
+    def test_create_note_id_cannot_outrun_publish_response(self) -> None:
+        if str(MODULE.VENDOR_DIR) not in sys.path:
+            sys.path.insert(0, str(MODULE.VENDOR_DIR))
+        import xhs.publish as publish
+
+        page = MagicMock()
+        page.evaluate.side_effect = [None, "ready", None, None, None, True]
+        page.click_pierced_button.return_value = True
+        page.wait_for_event.side_effect = [
+            {
+                "method": "Network.requestWillBeSent",
+                "params": {
+                    "requestId": "create",
+                    "request": {
+                        "method": "POST",
+                        "url": "https://edith.xiaohongshu.com/api/note/create",
+                    },
+                },
+            },
+            {"method": "Network.loadingFinished", "params": {"requestId": "create"}},
+            {
+                "method": "Network.requestWillBeSent",
+                "params": {
+                    "requestId": "publish",
+                    "request": {
+                        "method": "POST",
+                        "url": "https://edith.xiaohongshu.com/api/note/publish",
+                    },
+                },
+            },
+            {"method": "Network.loadingFinished", "params": {"requestId": "publish"}},
+        ]
+
+        def send(method: str, params: dict | None = None) -> dict:
+            if method != "Network.getResponseBody":
+                return {}
+            note_id = "draft" if params == {"requestId": "create"} else "published"
+            return {"body": json.dumps({"data": {"note_id": note_id}})}
+
+        page._send_session.side_effect = send
+        with (
+            patch.object(publish.time, "monotonic", return_value=0),
+            patch.object(publish.time, "sleep"),
+        ):
+            publish.click_publish_button(page)
+
+        body_ids = [
+            call.args[1]["requestId"]
+            for call in page._send_session.call_args_list
+            if call.args and call.args[0] == "Network.getResponseBody"
+        ]
+        self.assertEqual(body_ids, ["create", "publish"])
+
+    def test_page_retains_unsolicited_events_while_waiting_for_response(self) -> None:
+        if str(MODULE.VENDOR_DIR) not in sys.path:
+            sys.path.insert(0, str(MODULE.VENDOR_DIR))
+        from xhs.cdp import Page
+
+        transport = MagicMock()
+        expected_event = {
+            "method": "Network.responseReceived",
+            "sessionId": "session",
+            "params": {"requestId": "request"},
+        }
+        transport.recv.side_effect = [
+            json.dumps(expected_event),
+            json.dumps({"id": 1001, "result": {"ok": True}}),
+        ]
+        page = Page(MagicMock(_transport=transport), "target", "session")
+
+        self.assertEqual(page._wait_session(1001), {"ok": True})
+        self.assertEqual(page.wait_for_event(0), expected_event)
+
+    def test_page_event_queue_is_bounded(self) -> None:
+        if str(MODULE.VENDOR_DIR) not in sys.path:
+            sys.path.insert(0, str(MODULE.VENDOR_DIR))
+        from xhs.cdp import Page
+
+        page = Page(MagicMock(_transport=MagicMock()), "target", "session")
+        for index in range(300):
+            page._events.append({"method": "Network.event", "index": index})
+        self.assertEqual(len(page._events), 256)
+        self.assertEqual(page._events[0]["index"], 44)
+
+    def test_pierced_publish_button_requires_coordinate_hit(self) -> None:
+        if str(MODULE.VENDOR_DIR) not in sys.path:
+            sys.path.insert(0, str(MODULE.VENDOR_DIR))
+        from xhs.cdp import Page
+
+        page = Page(MagicMock(_transport=MagicMock()), "target", "session")
+        page._send_session = MagicMock(
+            side_effect=[
+                {
+                    "root": {
+                        "nodeName": "#document",
+                        "children": [
+                            {
+                                "nodeName": "XHS-PUBLISH-BTN",
+                                "attributes": ["is-publish", "true"],
+                                "shadowRoots": [
+                                    {
+                                        "nodeName": "#document-fragment",
+                                        "children": [
+                                            {
+                                                "nodeName": "BUTTON",
+                                                "backendNodeId": 42,
+                                                "children": [
+                                                    {"nodeName": "#text", "nodeValue": "发布"}
+                                                ],
+                                            }
+                                        ],
+                                    }
+                                ],
+                            }
+                        ],
+                    }
+                },
+                {},
+                {
+                    "model": {
+                        "width": 10,
+                        "height": 10,
+                        "border": [0, 0, 10, 0, 10, 10, 0, 10],
+                    }
+                },
+                {"backendNodeId": 43},
+                {"object": {"objectId": "hit"}},
+                {"object": {"objectId": "button"}},
+                {"result": {"value": False}},
+            ]
+        )
+        page.mouse_click = MagicMock()
+
+        self.assertFalse(page.click_pierced_button("xhs-publish-btn", "发布"))
+        page.mouse_click.assert_not_called()
+
+    def test_pierced_publish_button_skips_hidden_first_candidate(self) -> None:
+        if str(MODULE.VENDOR_DIR) not in sys.path:
+            sys.path.insert(0, str(MODULE.VENDOR_DIR))
+        from xhs.cdp import Page
+
+        def button(backend_node_id: int) -> dict:
+            return {
+                "nodeName": "BUTTON",
+                "backendNodeId": backend_node_id,
+                "children": [{"nodeName": "#text", "nodeValue": "发布"}],
+            }
+
+        page = Page(MagicMock(_transport=MagicMock()), "target", "session")
+        page._send_session = MagicMock(
+            side_effect=[
+                {
+                    "root": {
+                        "nodeName": "#document",
+                        "children": [
+                            {
+                                "nodeName": "XHS-PUBLISH-BTN",
+                                "attributes": ["is-publish", "true"],
+                                "shadowRoots": [
+                                    {
+                                        "nodeName": "#document-fragment",
+                                        "children": [button(41), button(42)],
+                                    }
+                                ],
+                            }
+                        ],
+                    }
+                },
+                {},
+                {"model": {"width": 0, "height": 0, "border": [0] * 8}},
+                {},
+                {
+                    "model": {
+                        "width": 10,
+                        "height": 10,
+                        "border": [0, 0, 10, 0, 10, 10, 0, 10],
+                    }
+                },
+                {"backendNodeId": 42},
+            ]
+        )
+        page.mouse_move = MagicMock()
+        page.mouse_click = MagicMock()
+
+        with patch("xhs.cdp.time.sleep"):
+            self.assertTrue(page.click_pierced_button("xhs-publish-btn", "发布"))
+        page.mouse_click.assert_called_once()
+
+    def test_visibility_requires_explicit_selected_marker(self) -> None:
+        if str(MODULE.VENDOR_DIR) not in sys.path:
+            sys.path.insert(0, str(MODULE.VENDOR_DIR))
+        import xhs.publish as publish
+
+        page = MagicMock()
+        page.evaluate.side_effect = [True, False]
+        with (
+            patch.object(publish.time, "sleep"),
+            self.assertRaisesRegex(publish.PublishError, "可见范围未确认生效"),
+        ):
+            publish._set_visibility(page, "仅自己可见")
+        script = page.evaluate.call_args_list[1].args[0]
+        self.assertNotIn("dropdown?.textContent", script)
+
+    def test_visibility_accepts_explicit_selected_marker(self) -> None:
+        if str(MODULE.VENDOR_DIR) not in sys.path:
+            sys.path.insert(0, str(MODULE.VENDOR_DIR))
+        import xhs.publish as publish
+
+        page = MagicMock()
+        page.evaluate.side_effect = [True, True]
+        with patch.object(publish.time, "sleep"):
+            publish._set_visibility(page, "仅自己可见")
+
     def test_verification_challenge_stops_without_navigation_retry(self) -> None:
         if str(MODULE.VENDOR_DIR) not in sys.path:
             sys.path.insert(0, str(MODULE.VENDOR_DIR))