agent-wire-cli 0.2.1__py3-none-any.whl

agent_wire/channels/tier2_pro/publishing.py

@@ -0,0 +1,84 @@
+"""Substack (posts API + comments) and Medium (reader with Wayback fallback on member-only stories)."""
+
+from urllib.parse import urlsplit
+
+from agent_wire.channels.base import Channel, WireUnsupported, html_to_markdown, ts
+from agent_wire.channels.tier1_global.web import extract_article
+from agent_wire.engine.waterfall import WireFetchError, wayback_snapshot
+from agent_wire.models import WireComment
+
+_PAYWALL = ("member-only story", "this post is for paid subscribers", "upgrade to paid")
+
+
+def parse_substack_comments(items: list[dict], depth: int = 0) -> list[WireComment]:
+    return [
+        WireComment(id=str(c.get("id")), body=c.get("body") or "", author_handle=c.get("name"),
+                    score=c.get("reaction_count") or sum((c.get("reactions") or {}).values()),
+                    timestamp=ts(c.get("date")), depth=depth,
+                    replies=parse_substack_comments(c.get("children") or [], depth + 1))
+        for c in items if c.get("body")
+    ]  # fmt: skip
+
+
+class PublishingChannel(Channel):
+    name = "publishing"
+
+    async def read(self, url, *, query=None, section=None, include_comments=True):
+        p = urlsplit(url)
+        host = p.hostname or ""
+        segs = [s for s in p.path.split("/") if s]
+        if segs[:1] == ["p"] and len(segs) > 1 and "medium.com" not in host:
+            return await self._substack(url, host, segs[1], include_comments)
+        return await self._medium(url, query, section)
+
+    async def _substack(self, url, host, slug, include_comments):
+        post, f = await self.fetch_json(f"https://{host}/api/v1/posts/{slug}")
+        body = html_to_markdown(post.get("body_html") or "")
+        if post.get("audience") == "only_paid" and len(body) < 2000:
+            body += "\n\n_Paid post: only the free preview is public._"
+        comments = []
+        if include_comments and post.get("id") and post.get("comment_count"):
+            try:
+                data, _ = await self.fetch_json(
+                    f"https://{host}/api/v1/post/{post['id']}/comments?all_comments=true&sort=best_first"
+                )
+                comments = parse_substack_comments(data.get("comments", []))
+            except (WireFetchError, ValueError):
+                comments = []
+        bylines = post.get("publishedBylines") or [{}]
+        return self.doc(
+            f, url, title=post.get("title"), author_handle=bylines[0].get("name"),
+            timestamp=ts(post.get("post_date")), body=f"{post.get('subtitle') or ''}\n\n{body}".strip(),
+            comments=comments, score=post.get("reaction_count"),
+            metadata={"comments": post.get("comment_count"), "audience": post.get("audience")},
+        )  # fmt: skip
+
+    async def _medium(self, url, query, section):
+        doc = await self.ctx.channel("web").read(url, query=query, section=section)
+        gated = any(m in doc.body.lower()[:4000] for m in _PAYWALL) or len(doc.body) < 1200
+        if gated and (snap := await wayback_snapshot(self.ctx.pool, url)):
+            f = await self.fetch(snap, archive=False, browser=False)
+            body, info = extract_article(f.text)
+            if len(body) > len(doc.body):
+                return self.doc(f, url, title=info["title"] or doc.title, author_handle=info["author"],
+                                body=body, metadata={"archived": snap})  # fmt: skip
+        return doc.model_copy(update={"channel": self.name})
+
+    async def feed(self, target, *, sort="hot", limit=10):
+        t = target.strip().rstrip("/")
+        if t.startswith("@") or "medium.com" in t:
+            handle = t.split("medium.com/")[-1]
+            return await self.ctx.channel("rss").feed(
+                f"https://medium.com/feed/{handle}", limit=limit
+            )
+        host = (
+            urlsplit(t).hostname if "//" in t else f"{t.removesuffix('.substack.com')}.substack.com"
+        )
+        if not host:
+            raise WireUnsupported(
+                "publishing feeds: '@medium_user', 'name' (Substack) or a newsletter URL"
+            )
+        return await self.ctx.channel("rss").feed(f"https://{host}/feed", limit=limit)
+
+
+CHANNEL = PublishingChannel

agent_wire/channels/tier2_pro/stocktwits.py

@@ -0,0 +1,79 @@
+"""StockTwits symbol streams (public API, no key): retail chatter and bull/bear sentiment."""
+
+import re
+from collections import Counter
+
+from agent_wire.channels.base import Channel, WireUnsupported, listing, ts
+from agent_wire.models import WireSearchHit
+
+API = "https://api.stocktwits.com/api/2"
+_SYMBOL = re.compile(r"^\$?([A-Za-z][A-Za-z0-9.\-]{0,11})$")
+
+
+def symbol_of(text: str) -> str:
+    m = _SYMBOL.match(text.strip().removeprefix("https://stocktwits.com/symbol/").strip("/"))
+    if not m:
+        raise WireUnsupported("stocktwits: give a ticker like $NVDA or BTC.X")
+    return m[1].upper()
+
+
+def _mood(msg: dict) -> str | None:
+    return ((msg.get("entities") or {}).get("sentiment") or {}).get("basic")
+
+
+def message_hits(data: dict) -> list[WireSearchHit]:
+    hits = []
+    for msg in data.get("messages") or []:
+        user = (msg.get("user") or {}).get("username")
+        mood, likes = _mood(msg), (msg.get("likes") or {}).get("total") or 0
+        hits.append(WireSearchHit(
+            url=f"https://stocktwits.com/{user}/message/{msg.get('id')}",
+            title=f"@{user}" + (f" · {mood}" if mood else ""), snippet=msg.get("body") or "",
+            source="stocktwits", rank_score=float(likes), timestamp=ts(msg.get("created_at")),
+            author=user, engagement={"likes": likes},
+        ))  # fmt: skip
+    return hits
+
+
+def sentiment(data: dict) -> str:
+    c = Counter(_mood(m) for m in data.get("messages") or [])
+    bull, bear = c.get("Bullish", 0), c.get("Bearish", 0)
+    return f"{bull} bullish / {bear} bearish" if bull + bear else "no tagged sentiment"
+
+
+class StockTwitsChannel(Channel):
+    name = "stocktwits"
+
+    async def _stream(self, symbol: str):
+        return await self.fetch_json(f"{API}/streams/symbol/{symbol}.json")
+
+    async def search(self, query, *, limit=5, sort="relevance", since=None):
+        data, _ = await self._stream(symbol_of(query))
+        hits = message_hits(data)
+        if since:
+            hits = [h for h in hits if h.timestamp is None or h.timestamp >= since]
+        return hits[:limit]
+
+    async def feed(self, target, *, sort="hot", limit=10):
+        if target.strip().lower() in ("trending", "hot"):
+            data, f = await self.fetch_json(f"{API}/trending/symbols.json")
+            items = [{"title": s.get("symbol"), "url": f"https://stocktwits.com/symbol/{s.get('symbol')}",
+                      "meta": [s.get("title"), f"{s.get('watchlist_count', 0):,} watchers"]}
+                     for s in (data.get("symbols") or [])[:limit]]  # fmt: skip
+            return self.doc(f, "https://stocktwits.com/sentiment", title="StockTwits · trending",
+                            body=listing(items))  # fmt: skip
+        sym = symbol_of(target)
+        data, f = await self._stream(sym)
+        info = data.get("symbol") or {}
+        items = [{"title": h.title, "url": h.url, "snippet": h.snippet,
+                  "meta": [h.timestamp.isoformat(timespec="minutes") if h.timestamp else None]}
+                 for h in message_hits(data)[:limit]]  # fmt: skip
+        head = f"{info.get('title') or sym} · {info.get('watchlist_count', 0):,} watchers · {sentiment(data)}"
+        return self.doc(f, f"https://stocktwits.com/symbol/{sym}", title=f"StockTwits · ${sym}",
+                        body=f"{head}\n\n{listing(items)}", metadata={"sentiment": sentiment(data)})  # fmt: skip
+
+    async def read(self, url, *, query=None, section=None, include_comments=True):
+        return await self.feed(url, limit=20)
+
+
+CHANNEL = StockTwitsChannel

agent_wire/channels/tier3_regional/bilibili.py

@@ -0,0 +1,171 @@
+"""Bilibili: video info, CC subtitles, hot comments, search, popular feed — in-process WBI signing."""
+
+import hashlib
+import re
+import time
+from urllib.parse import urlencode, urlsplit
+
+from agent_wire.channels.base import Channel, WireUnsupported, listing, ts
+from agent_wire.engine.http_pool import Fetched
+from agent_wire.engine.waterfall import WireFetchError
+from agent_wire.firewall.outbound_privacy import parse_json
+from agent_wire.media.subtitle_cleaner import to_paragraphs
+from agent_wire.models import WireComment, WireSearchHit
+
+API = "https://api.bilibili.com"
+HEADERS = {"Referer": "https://www.bilibili.com/", "Origin": "https://www.bilibili.com"}
+# Permutation table from Bilibili's web client for deriving the WBI mixin key.
+MIXIN = [46, 47, 18, 2, 53, 8, 23, 32, 15, 50, 10, 31, 58, 3, 45, 35, 27, 43, 5, 49, 33, 9, 42, 19,
+         29, 28, 14, 39, 12, 38, 41, 13, 37, 48, 7, 16, 24, 55, 40, 61, 26, 17, 0, 1, 60, 51, 30, 4,
+         22, 25, 54, 21, 56, 59, 6, 63, 57, 62, 11, 36, 20, 34, 44, 52]  # fmt: skip
+KEY_TTL_S = 6 * 3600
+_BVID = re.compile(r"(BV[0-9A-Za-z]{10})")
+_TAG = re.compile(r"<[^>]+>")
+
+
+def mixin_key(img_key: str, sub_key: str) -> str:
+    raw = img_key + sub_key
+    return "".join(raw[i] for i in MIXIN)[:32]
+
+
+def wbi_sign(params: dict, key: str, now: int | None = None) -> dict:
+    signed = {**params, "wts": now if now is not None else int(time.time())}
+    clean = {k: re.sub(r"[!'()*]", "", str(v)) for k, v in sorted(signed.items())}
+    query = urlencode(clean)
+    return {**clean, "w_rid": hashlib.md5((query + key).encode()).hexdigest()}
+
+
+def parse_replies(replies: list[dict], depth: int = 0) -> list[WireComment]:
+    return [
+        WireComment(id=str(r.get("rpid")), body=(r.get("content") or {}).get("message", ""),
+                    author_handle=(r.get("member") or {}).get("uname"), score=r.get("like") or 0,
+                    timestamp=ts(r.get("ctime")), depth=depth,
+                    replies=parse_replies(r.get("replies") or [], depth + 1))
+        for r in replies or []
+    ]  # fmt: skip
+
+
+class BilibiliChannel(Channel):
+    name = "bilibili"
+
+    def __init__(self, ctx):
+        super().__init__(ctx)
+        self._key: str | None = None
+        self._key_at = 0.0
+        self._primed = False
+
+    async def _get(self, url: str) -> Fetched:
+        # One shared anonymous chrome session; the API answers 412 until the homepage has set the
+        # buvid3/b_nut visitor cookies, so visit it once first.
+        if not self._primed:
+            await self.ctx.pool.get(
+                "https://www.bilibili.com/", impersonate="chrome", headers=HEADERS
+            )
+            self._primed = True
+        f = await self.ctx.pool.get(url, impersonate="chrome", headers=HEADERS)
+        if not f.ok:
+            raise WireFetchError(f"{url}: HTTP {f.status}")
+        return f
+
+    async def _api(self, path: str, params: dict, sign: bool = False) -> tuple[dict, Fetched]:
+        if sign:
+            params = wbi_sign(params, await self._wbi_key())
+        f = await self._get(f"{API}{path}?{urlencode(params)}")
+        data = parse_json(f.content)
+        if data.get("code") not in (0, None):
+            raise WireUnsupported(f"bilibili {path}: {data.get('message') or data.get('code')}")
+        return data.get("data") or {}, f
+
+    async def _wbi_key(self) -> str:
+        if not self._key or time.time() - self._key_at > KEY_TTL_S:
+            f = await self._get(f"{API}/x/web-interface/nav")
+            img = parse_json(f.content)["data"]["wbi_img"]  # present even when logged out
+            stem = lambda u: u.rsplit("/", 1)[-1].split(".")[0]
+            self._key, self._key_at = (
+                mixin_key(stem(img["img_url"]), stem(img["sub_url"])),
+                time.time(),
+            )
+        return self._key
+
+    async def read(self, url, *, query=None, section=None, include_comments=True):
+        if (urlsplit(url).hostname or "").endswith("b23.tv"):
+            url = (await self._get(url)).url  # short link -> video page
+        m = _BVID.search(url)
+        if not m:
+            raise WireUnsupported("bilibili: expected a /video/BV... URL")
+        view, f = await self._api("/x/web-interface/wbi/view", {"bvid": m[1]}, sign=True)
+        transcript = await self._subtitles(m[1], view.get("cid"))
+        comments = []
+        if include_comments and view.get("aid"):
+            try:
+                rep, _ = await self._api(
+                    "/x/v2/reply/wbi/main",
+                    {"oid": view["aid"], "type": 1, "mode": 3, "ps": 20},
+                    sign=True,
+                )
+                comments = parse_replies(rep.get("replies") or [])
+            except (WireFetchError, WireUnsupported, ValueError, KeyError):
+                comments = []
+        stat = view.get("stat", {})
+        parts = [
+            view.get("desc") or "",
+            f"## 字幕 Transcript\n{transcript}"
+            if transcript
+            else "_No CC subtitles (AI subtitles need a login)._",
+        ]
+        return self.doc(
+            f, f"https://www.bilibili.com/video/{m[1]}", title=view.get("title"),
+            author_handle=(view.get("owner") or {}).get("name"), timestamp=ts(view.get("pubdate")),
+            score=stat.get("like"), body="\n\n".join(p for p in parts if p), comments=comments,
+            metadata={"views": stat.get("view"), "likes": stat.get("like"), "coins": stat.get("coin"),
+                      "favorites": stat.get("favorite"), "danmaku": stat.get("danmaku"),
+                      "length": f"{(view.get('duration') or 0) // 60}m"},
+        )  # fmt: skip
+
+    async def _subtitles(self, bvid: str, cid) -> str:
+        if not cid:
+            return ""
+        try:
+            player, _ = await self._api("/x/player/wbi/v2", {"bvid": bvid, "cid": cid}, sign=True)
+            subs = (player.get("subtitle") or {}).get("subtitles") or []
+            if not subs:
+                return ""
+            sub = next((s for s in subs if s.get("lan", "").startswith("zh")), subs[0])
+            url = sub["subtitle_url"]
+            f = await self._get(url if url.startswith("http") else f"https:{url}")
+            lines = parse_json(f.content).get("body", [])
+            return to_paragraphs([(float(x.get("from", 0)), x.get("content", "")) for x in lines])
+        except (WireFetchError, WireUnsupported, ValueError, KeyError):
+            return ""
+
+    async def search(self, query, *, limit=5, sort="relevance"):
+        await self._get("https://www.bilibili.com/")  # sets buvid3, required by search
+        order = {"new": "pubdate", "top": "click"}.get(sort, "totalrank")
+        data, _ = await self._api("/x/web-interface/wbi/search/type",
+                                  {"search_type": "video", "keyword": query, "order": order}, sign=True)  # fmt: skip
+        return [WireSearchHit(url=f"https://www.bilibili.com/video/{v['bvid']}", title=_TAG.sub("", v.get("title", "")),
+                              snippet=f"{v.get('author')} · {v.get('play')} plays · {v.get('description', '')[:160]}",
+                              source="bilibili", rank_score=float(v.get("play") or 0))
+                for v in (data.get("result") or [])[:limit]]  # fmt: skip
+
+    async def feed(self, target, *, sort="hot", limit=10):
+        t = target.strip().lower()
+        if t in ("popular", "hot", "trending", ""):
+            data, f = await self._api("/x/web-interface/popular", {"ps": limit, "pn": 1})
+            videos = data.get("list", [])
+        elif t.isdigit():
+            data, f = await self._api(
+                "/x/space/wbi/arc/search", {"mid": t, "ps": limit, "pn": 1}, sign=True
+            )
+            videos = (data.get("list") or {}).get("vlist", [])
+        else:
+            raise WireUnsupported("bilibili feeds: 'popular' or an uploader's numeric mid")
+        items = [{"title": v.get("title"), "url": f"https://www.bilibili.com/video/{v.get('bvid')}",
+                  "meta": [(v.get("owner") or {}).get("name") or v.get("author"),
+                           f"{(v.get('stat') or {}).get('view', v.get('play'))} plays"],
+                  "snippet": v.get("desc") or v.get("description") or ""} for v in videos[:limit]]  # fmt: skip
+        return self.doc(f, "https://www.bilibili.com/v/popular/all", title=f"Bilibili · {t or 'popular'}",
+                        body=listing(items))  # fmt: skip
+
+
+CHANNEL = BilibiliChannel

agent_wire/channels/tier3_regional/boss_zhipin.py

@@ -0,0 +1,35 @@
+"""Boss Zhipin job descriptions (heavy anti-bot: local session or the stage-4 browser usually needed)."""
+
+from selectolax.lexbor import LexborHTMLParser
+
+from agent_wire.channels.base import Channel, WireUnsupported, html_to_markdown
+
+
+def parse_job(html: str) -> dict:
+    tree = LexborHTMLParser(html)
+    desc = tree.css_first(".job-sec-text, .job-detail-section .text")
+    if not desc:
+        raise WireUnsupported(
+            "zhipin served a verification page; run `wire auth login zhipin.com` or install the stealth extra"
+        )
+
+    def text(sel):
+        n = tree.css_first(sel)
+        return n.text(strip=True) if n else None
+
+    tags = [t.text(strip=True) for t in tree.css(".job-tags span, .job-keyword-list li")]
+    return {"title": text(".name h1, .job-name"), "author_handle": text(".company-info a[ka], .company-name"),
+            "body": html_to_markdown(desc.html),
+            "metadata": {"salary": text(".salary, .job-salary"), "city": text(".text-city, .job-area"),
+                         "tags": ", ".join(tags) or None}}  # fmt: skip
+
+
+class BossZhipinChannel(Channel):
+    name = "boss_zhipin"
+
+    async def read(self, url, *, query=None, section=None, include_comments=True):
+        f = await self.fetch(url, archive=False)
+        return self.doc(f, url, **parse_job(f.text))
+
+
+CHANNEL = BossZhipinChannel

agent_wire/channels/tier3_regional/douyin_tiktok.py

@@ -0,0 +1,85 @@
+"""TikTok (rehydration JSON + WebVTT captions, oEmbed fallback) and Douyin (iesdouyin share page)."""
+
+import re
+from urllib.parse import quote, urlsplit
+
+from agent_wire.channels.base import Channel, WireUnsupported, assigned_json, script_json, ts
+from agent_wire.engine.waterfall import WireFetchError
+from agent_wire.media.subtitle_cleaner import parse_captions, to_paragraphs
+
+MOBILE_UA = ("Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/605.1.15 "
+             "(KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1")  # fmt: skip
+
+
+def parse_tiktok(data: dict) -> dict:
+    scope = data.get("__DEFAULT_SCOPE__") or {}
+    item = ((scope.get("webapp.video-detail") or {}).get("itemInfo") or {}).get("itemStruct") or {}
+    if not item:
+        raise WireUnsupported("tiktok video data missing (removed, private or region-blocked)")
+    stats = item.get("stats") or {}
+    subs = (item.get("video") or {}).get("subtitleInfos") or []
+    return {"title": item.get("desc", "")[:80], "author_handle": (item.get("author") or {}).get("uniqueId"),
+            "timestamp": ts(item.get("createTime")), "score": stats.get("diggCount"), "body": item.get("desc", ""),
+            "metadata": {"plays": stats.get("playCount"), "likes": stats.get("diggCount"),
+                         "comments": stats.get("commentCount"), "shares": stats.get("shareCount")},
+            "_subs": subs}  # fmt: skip
+
+
+def parse_douyin(data: dict) -> dict:
+    loader = (data or {}).get("loaderData") or {}
+    page = next((v for k, v in loader.items() if "video" in k and isinstance(v, dict)), {})
+    items = ((page.get("videoInfoRes") or {}).get("item_list")) or []
+    if not items:
+        raise WireUnsupported("douyin video data missing from the share page")
+    it = items[0]
+    st = it.get("statistics") or {}
+    return {"title": it.get("desc", "")[:80], "author_handle": (it.get("author") or {}).get("nickname"),
+            "timestamp": ts(it.get("create_time")), "score": st.get("digg_count"), "body": it.get("desc", ""),
+            "metadata": {"likes": st.get("digg_count"), "comments": st.get("comment_count"),
+                         "shares": st.get("share_count"), "collects": st.get("collect_count")}}  # fmt: skip
+
+
+class DouyinTikTokChannel(Channel):
+    name = "douyin_tiktok"
+
+    async def read(self, url, *, query=None, section=None, include_comments=True):
+        host = urlsplit(url).hostname or ""
+        if "tiktok.com" in host:
+            return await self._tiktok(url)
+        if host.startswith("v.douyin.com"):
+            url = (await self.fetch(url, archive=False, browser=False)).url
+        m = re.search(r"/(?:video|note)/(\d+)", urlsplit(url).path)
+        if not m:
+            raise WireUnsupported("douyin: expected a /video/<id> URL")
+        f = await self.fetch(f"https://www.iesdouyin.com/share/video/{m[1]}/",
+                             headers={"User-Agent": MOBILE_UA}, archive=False)  # fmt: skip
+        data = assigned_json(f.text, "window._ROUTER_DATA", js_undefined=True)
+        return self.doc(f, url, **parse_douyin(data))
+
+    async def _tiktok(self, url):
+        try:
+            f = await self.fetch(url, archive=False)
+            info = parse_tiktok(
+                script_json(f.text, "script#__UNIVERSAL_DATA_FOR_REHYDRATION__") or {}
+            )
+        except (WireFetchError, WireUnsupported):
+            data, f = await self.fetch_json(
+                f"https://www.tiktok.com/oembed?url={quote(url, safe='')}"
+            )
+            return self.doc(f, url, title=data.get("title"), author_handle=data.get("author_unique_id"),
+                            body=data.get("title", ""), metadata={"via": "oembed"})  # fmt: skip
+        subs = info.pop("_subs")
+        sub = next(
+            (s for s in subs if str(s.get("LanguageCodeName", "")).startswith("en")),
+            subs[0] if subs else None,
+        )
+        if sub and sub.get("Url"):
+            try:
+                vtt = await self.fetch(sub["Url"], archive=False, browser=False)
+                info["body"] += "\n\n## Captions\n" + to_paragraphs(parse_captions(vtt.content))
+            except (WireFetchError, ValueError):
+                pass
+        return self.doc(f, url, **info)
+
+
+CHANNEL = DouyinTikTokChannel

agent_wire/channels/tier3_regional/v2ex.py

@@ -0,0 +1,70 @@
+"""V2EX: native public API for topics, replies and hot/latest/node feeds; SoV2EX for search."""
+
+import re
+from urllib.parse import quote, urlsplit
+
+from agent_wire.channels.base import Channel, WireUnsupported, listing, ts
+from agent_wire.models import WireComment, WireSearchHit
+
+API = "https://www.v2ex.com/api"
+
+
+def parse_replies(replies: list[dict], op: str | None) -> list[WireComment]:
+    return [WireComment(id=str(r.get("id")), body=r.get("content") or "",
+                        author_handle=(r.get("member") or {}).get("username"),
+                        timestamp=ts(r.get("created")), is_op=(r.get("member") or {}).get("username") == op)
+            for r in replies]  # fmt: skip
+
+
+def topic_items(topics: list[dict]) -> list[dict]:
+    return [{"title": t.get("title"), "url": t.get("url"),
+             "meta": [(t.get("node") or {}).get("title"), f"{t.get('replies', 0)} replies",
+                      (t.get("member") or {}).get("username")]} for t in topics]  # fmt: skip
+
+
+class V2exChannel(Channel):
+    name = "v2ex"
+
+    async def read(self, url, *, query=None, section=None, include_comments=True):
+        m = re.search(r"/t/(\d+)", urlsplit(url).path)
+        if not m:
+            node = re.search(r"/go/([\w-]+)", urlsplit(url).path)
+            if node:
+                return await self.feed(node[1])
+            raise WireUnsupported("v2ex: expected /t/<id> or /go/<node>")
+        topics, f = await self.fetch_json(f"{API}/topics/show.json?id={m[1]}")
+        if not topics:
+            raise WireUnsupported(f"v2ex topic {m[1]} not found")
+        t = topics[0]
+        op = (t.get("member") or {}).get("username")
+        comments = []
+        if include_comments and t.get("replies"):
+            replies, _ = await self.fetch_json(f"{API}/replies/show.json?topic_id={m[1]}")
+            comments = parse_replies(replies, op)
+        return self.doc(f, url, title=t.get("title"), author_handle=op, timestamp=ts(t.get("created")),
+                        body=t.get("content") or "", comments=comments,
+                        metadata={"node": (t.get("node") or {}).get("title"), "replies": t.get("replies")})  # fmt: skip
+
+    async def feed(self, target, *, sort="hot", limit=10):
+        t = target.strip().lower() or "hot"
+        path = {"hot": "topics/hot.json", "latest": "topics/latest.json"}.get(
+            t, f"topics/show.json?node_name={t}"
+        )
+        topics, f = await self.fetch_json(f"{API}/{path}")
+        return self.doc(
+            f,
+            f"https://www.v2ex.com/?tab={t}",
+            title=f"V2EX · {t}",
+            body=listing(topic_items(topics[:limit])),
+        )
+
+    async def search(self, query, *, limit=5, sort="relevance"):
+        data, _ = await self.fetch_json(
+            f"https://www.sov2ex.com/api/search?q={quote(query)}&size={limit}"
+        )
+        return [WireSearchHit(url=f"https://www.v2ex.com/t/{h['_source']['id']}", title=h["_source"].get("title", ""),
+                              snippet=(h["_source"].get("content") or "")[:200], source="v2ex")
+                for h in data.get("hits", [])]  # fmt: skip
+
+
+CHANNEL = V2exChannel

agent_wire/channels/tier3_regional/wechat.py

@@ -0,0 +1,67 @@
+"""WeChat official-account articles (mp.weixin.qq.com) and Sogou WeChat search."""
+
+import re
+from urllib.parse import quote
+
+from selectolax.lexbor import LexborHTMLParser
+
+from agent_wire.channels.base import Channel, WireUnsupported, html_to_markdown, ts
+from agent_wire.models import WireSearchHit
+
+WECHAT_UA = ("Mozilla/5.0 (Linux; Android 14; Pixel 8) AppleWebKit/537.36 (KHTML, like Gecko) "
+             "Chrome/124.0 Mobile Safari/537.36 MicroMessenger/8.0.49")  # fmt: skip
+
+
+def parse_article(html: str) -> dict:
+    tree = LexborHTMLParser(html)
+    content = tree.css_first("#js_content")
+    if not content:
+        raise WireUnsupported("wechat article body missing (deleted, or a verification page)")
+    # WeChat ships the body as visibility:hidden and reveals it with JS; the shield would drop it,
+    # so convert the children, not the hidden wrapper.
+    inner = "".join(child.html or "" for child in content.iter(include_text=True))
+    title = tree.css_first("#activity-name, h1.rich_media_title")
+    author = tree.css_first("#js_name")
+    ct = re.search(r'\bvar ct\s*=\s*"(\d+)"', html) or re.search(
+        r"create_time\s*[:=]\s*['\"]?(\d{9,})", html
+    )
+    return {"title": title.text(strip=True) if title else None,
+            "author_handle": author.text(strip=True) if author else None,
+            "timestamp": ts(ct[1]) if ct else None, "body": html_to_markdown(inner, links=False)}  # fmt: skip
+
+
+def parse_sogou(html: str) -> list[WireSearchHit]:
+    hits = []
+    for li in LexborHTMLParser(html).css("ul.news-list li"):
+        a = li.css_first("h3 a")
+        if not a:
+            continue
+        href = a.attributes.get("href") or ""
+        snippet = li.css_first("p.txt-info")
+        account = li.css_first(".s-p .all-time-y2, .s-p a.account")
+        hits.append(WireSearchHit(
+            url=href if href.startswith("http") else f"https://weixin.sogou.com{href}", title=a.text(strip=True),
+            snippet=" · ".join(x for x in (account.text(strip=True) if account else "",
+                                           snippet.text(strip=True) if snippet else "") if x),
+            source="wechat"))  # fmt: skip
+    return hits
+
+
+class WeChatChannel(Channel):
+    name = "wechat"
+
+    async def read(self, url, *, query=None, section=None, include_comments=True):
+        f = await self.fetch(url, headers={"User-Agent": WECHAT_UA}, archive=False)
+        return self.doc(f, url, **parse_article(f.text))
+
+    async def search(self, query, *, limit=5, sort="relevance"):
+        f = await self.fetch(
+            f"https://weixin.sogou.com/weixin?type=2&query={quote(query)}", archive=False
+        )
+        hits = parse_sogou(f.text)
+        if not hits and "antispider" in f.url:
+            raise WireUnsupported("Sogou WeChat search showed a CAPTCHA; try again later")
+        return hits[:limit]
+
+
+CHANNEL = WeChatChannel

agent_wire/channels/tier3_regional/xiaohongshu.py

@@ -0,0 +1,58 @@
+"""Xiaohongshu (RED): note body, stats, tags and any server-rendered comments from __INITIAL_STATE__."""
+
+import re
+from urllib.parse import urlsplit
+
+from agent_wire.channels.base import Channel, WireUnsupported, assigned_json, compact_count, ts
+from agent_wire.models import WireComment
+
+_NOTE = re.compile(r"/(?:explore|discovery/item|search_result)/([0-9a-f]{24})")
+
+
+def parse_note(state: dict, note_id: str) -> dict:
+    detail = ((state.get("note") or {}).get("noteDetailMap") or {}).get(note_id) or {}
+    note = detail.get("note") or {}
+    if not note:
+        raise WireUnsupported("xiaohongshu note not in page state (needs xsec_token or a login)")
+    inter = note.get("interactInfo") or {}
+    comments = [
+        WireComment(id=str(c.get("id")), body=c.get("content", ""),
+                    author_handle=(c.get("userInfo") or {}).get("nickname"),
+                    score=compact_count(c.get("likeCount")), timestamp=ts(c.get("createTime")))
+        for c in ((detail.get("comments") or {}).get("list") or [])
+    ]  # fmt: skip
+    tags = " ".join(f"#{t.get('name')}" for t in note.get("tagList") or [])
+    images = len(note.get("imageList") or [])
+    body = (note.get("desc") or "") + (f"\n\n{tags}" if tags else "")
+    return {
+        "title": note.get("title") or (note.get("desc") or "")[:40],
+        "author_handle": (note.get("user") or {}).get("nickname"),
+        "timestamp": ts(note.get("time")), "score": compact_count(inter.get("likedCount")),
+        "body": body, "comments": comments,
+        "metadata": {"likes": compact_count(inter.get("likedCount")),
+                     "collects": compact_count(inter.get("collectedCount")),
+                     "comments": compact_count(inter.get("commentCount")),
+                     "type": note.get("type"), "images": images or None},
+    }  # fmt: skip
+
+
+class XiaohongshuChannel(Channel):
+    name = "xiaohongshu"
+
+    async def read(self, url, *, query=None, section=None, include_comments=True):
+        f = await self.fetch(
+            url, archive=False
+        )  # login-only channel: local session attached if present
+        m = _NOTE.search(urlsplit(f.url).path) or _NOTE.search(urlsplit(url).path)
+        if not m:
+            raise WireUnsupported("xiaohongshu: expected an /explore/<note id> URL")
+        state = assigned_json(f.text, "window.__INITIAL_STATE__", js_undefined=True) or {}
+        return self.doc(f, url, **parse_note(state, m[1]))
+
+    async def search(self, query, *, limit=5, sort="relevance"):
+        raise WireUnsupported(
+            "xiaohongshu search needs its signed web API; share a note URL instead"
+        )
+
+
+CHANNEL = XiaohongshuChannel