feedscope 0.1.0__py3-none-any.whl

feedscope/sources/telegram/fetch.py

@@ -0,0 +1,79 @@
+"""取数层：t.me/s 频道预览页抓取 + 「全部」聚合流（共享编排）。
+
+- 单频道：GET https://t.me/s/<名>（可选 ?before=<最小id> 翻更旧一页，页内
+  ~20 条）；纯 HTML 无 JSON，免登录免 JS。预览页没有 ETag/Last-Modified
+  （不走 RSS 的条件请求），刷新就是整页重拉——一页 148KB 级，阅读节奏下无害
+- 聚合「全部」的编排（并发/失败隔离/倒序合并）见 core.source.merge_feeds；
+  Telegram 的差异是按发布时间（ISO 字符串）倒序、错误标签带 @
+"""
+
+from __future__ import annotations
+
+from feedscope.core import http
+from feedscope.core.config import Subscription
+from feedscope.core.models import FeedItem
+from feedscope.core.source import FeedLoader, dedup_append, merge_feeds
+from feedscope.sources.telegram.parse import parse_channel_html
+
+_SITE = "https://t.me/s"
+
+
+async def fetch_channel_html(name: str, before: int | None = None) -> str:
+    """一个频道的一页预览 HTML；before = 已见最小消息号（翻更旧一页）。"""
+    params = {"before": str(before)} if before else None
+    r = await http.get(f"{_SITE}/{name}", source=f"Telegram @{name}", params=params)
+    return r.text
+
+
+class TelegramFeedLoader(FeedLoader):
+    """单频道翻页：下一页游标 = 本页解析出的最小消息号；翻空即到头。
+
+    每页倒排追加（预览页是聊天式旧→新，阅读器时间线要新→旧）：翻页后
+    更旧的整页缀在更旧的位置上，全局严格最新在前——与「全部」聚合流
+    及所有源的时间线方向一致。
+    """
+
+    def __init__(self, channel: str, label: str) -> None:
+        self._channel = channel
+        self._label = label
+        self.items: list[FeedItem] = []
+        self._seen: set[str] = set()
+        self._before: int | None = None
+        self._done = False
+
+    @property
+    def done(self) -> bool:
+        return self._done
+
+    async def load_more(self) -> list[FeedItem]:
+        if self._done:
+            return []
+        html = await fetch_channel_html(self._channel, self._before)
+        items = parse_channel_html(html, channel=self._channel, label=self._label)
+        new = dedup_append(self.items, self._seen, items[::-1])
+        if not new:
+            self._done = True  # 翻到头（或该 before 段空页）：真到头不再打扰
+            return []
+        self._before = min(int(it.id.rsplit("/", 1)[-1]) for it in new)
+        return new
+
+
+async def _fetch_one(feed: Subscription) -> list[FeedItem]:
+    """拉一个频道的首页并解析；时间倒序（最新在前）。"""
+    html = await fetch_channel_html(feed.key)
+    items = parse_channel_html(html, channel=feed.key, label=feed.label, all_view=True)
+    return items[::-1]
+
+
+async def fetch_merged(feeds: list[Subscription]) -> tuple[list[FeedItem], list[str]]:
+    """并发拉全部频道 ->「全部」聚合：(条目, 失败原因列表)。
+
+    编排见 core.source.merge_feeds；Telegram 的差异：按发布时间（ISO 字符串）
+    倒序、错误标签带 @（时间缺失的条目垫底，罕见，预览页都有 datetime）。
+    """
+    return await merge_feeds(
+        feeds,
+        _fetch_one,
+        error_label=lambda f: f"@{f.key}",
+        sort_key=lambda it: str(it.extra.get("published") or ""),
+    )

feedscope/sources/telegram/parse.py

@@ -0,0 +1,182 @@
+"""解析层：t.me/s 频道预览 HTML -> FeedItem / 正文 markdown，纯函数不碰网络。
+
+Telegram 公开频道的 Web 预览页（t.me/s/<名>）是服务端渲染 HTML，免登录
+免 JS：一页约 20 条消息，更旧一页走 ?before=<最小id>。结构映射与 RSS 同形
+（纯订阅、无评论层、详情读列表自带正文零请求）：
+
+- 每条消息（data-post="频道/编号"）-> FeedItem：正文 HTML 走 html_to_md
+  共用管线（a/b/br 等行内标签全兼容），媒体（图/视频）换 [图片]/[视频] 记号
+- 标题取正文首行截断（频道帖没有标题，同 X 拿推文当标题的思路）；纯媒体帖
+  用记号本身当标题
+- 元信息列：观看数（预览页原生就是格式化文本，如 5.87M）+ 署名（频道
+  管理员签名）；「全部」聚合视图再前缀频道名
+
+实测锚点（2026-11 对 t.me/s/durov 抓样）：消息容器 `tgme_widget_message
+… js-widget_message` 带 data-post；正文 `message_text js-message_text`；
+观看 `message_views`；图片是 photo_wrap 锚点的 background-image（不是
+<img>，走属性提取）；视频播放器没有直链，记号指向帖子页。频道关闭 Web
+预览时页面没有任何消息节点——取数侧以「解析出 0 条」报错兜底。
+"""
+
+from __future__ import annotations
+
+import re
+
+from feedscope.core.media import html_to_md, mark
+from feedscope.core.i18n import t
+from feedscope.core.models import FeedItem
+from feedscope.core.text import truncate_display
+from feedscope.core.timefmt import fmt_iso
+
+SOURCE_ID = "telegram"
+
+_SITE = "https://t.me"
+
+# 标题截断的显示宽度：频道帖首行常常很长，列表要的是扫读不是阅读
+TITLE_WIDTH = 60
+
+# 频道名（username）域：字母开头、字母数字下划线；下限放宽到 4——校验
+# 过松的代价（拉一次预览 404/无消息）由添加时的实测校验兜住
+_NAME_RE = re.compile(r"^[A-Za-z][A-Za-z0-9_]{3,31}$")
+
+# 链接里的频道段：t.me/durov、t.me/s/durov、telegram.me/durov、帖子直链
+# t.me/durov/531 都归一到频道名（没链接上下文时整串当裸名走 _NAME_RE）
+_LINK_RE = re.compile(r"(?:t\.me|telegram\.me)/(?:s/)?([A-Za-z0-9_]+)")
+
+# 消息块切分：每个 tgme_widget_message 容器起一段（wrap 的闭合标签在下一
+# 个容器之前，块内即本条消息的全部元素）；data-post 缺失（服务消息）跳过
+_CHUNK_SPLIT = re.compile(r'(?=<div class="tgme_widget_message )')
+
+_POST_RE = re.compile(r'data-post="([^"]+)"')
+_TEXT_RE = re.compile(r'<div class="tgme_widget_message_text[^"]*"[^>]*>(.*?)</div>', re.DOTALL)
+_VIEWS_RE = re.compile(r'<span class="tgme_widget_message_views">\s*([^<]+?)\s*</span>')
+_AUTHOR_RE = re.compile(r'tgme_widget_message_from_author[^>]*>([^<]*)<')
+_TIME_RE = re.compile(r'<time datetime="([^"]+)"')
+_PHOTO_RE = re.compile(r'<a class="tgme_widget_message_photo_wrap[^>]*>')
+_BG_URL_RE = re.compile(r"background-image:url\('([^']+)'\)")
+_VIDEO_RE = re.compile(r"tgme_widget_message_video_player")
+_TITLE_RE = re.compile(r"<title>([^<]*)</title>")
+_OG_TITLE_RE = re.compile(r'og:title" content="([^"]*)"')
+
+# 预览页把 emoji 包成 <tg-emoji><i class="emoji" style="…"><b>🩵</b></i></tg-emoji>
+# （i/b 壳是旧客户端兜底）：整只塌缩成字符本身，否则 html2text 给每个表情
+# 套一层 **强调**，正文满屏星号
+_TG_EMOJI_RE = re.compile(
+    r'<tg-emoji[^>]*>(?:<i class="emoji"[^>]*>)?(?:<b>(.*?)</b>)?(?:</i>)?([^<]*)</tg-emoji>'
+)
+
+
+def channel_title(html: str) -> str:
+    """预览页的频道显示名（og:title 优先，缺了回 <title> 的尾巴）。"""
+    m = _OG_TITLE_RE.search(html) or _TITLE_RE.search(html)
+    if not m:
+        return ""
+    title = m.group(1).strip()
+    return re.sub(r"\s*\(via @[\w]+\)$", "", title)  # 部分频道尾巴带 "(via @x)"，去掉归 channel
+
+
+def _media_marks(chunk: str, post_url: str) -> list[str]:
+    """消息块里的媒体 -> 记号列表：图片取原图直链，视频没有直链指向帖子页。"""
+    marks: list[str] = []
+    if (m := _PHOTO_RE.search(chunk)) and (u := _BG_URL_RE.search(m.group(0))):
+        marks.append(mark(t("media.image"), u.group(1)))
+    if _VIDEO_RE.search(chunk):
+        marks.append(mark(t("media.video"), post_url))
+    return marks
+
+
+def _strip_emoji(text_html: str) -> str:
+    """tg-emoji 三层壳塌缩成字符本身（否则 html2text 给每个表情套 **强调**）。"""
+    return _TG_EMOJI_RE.sub(lambda m: m.group(1) or m.group(2) or "", text_html)
+
+
+def _plain_text(text_html: str) -> str:
+    """已剥 emoji 壳的正文 HTML -> 纯文本（标题用）：去标签 + 合并空白。"""
+    plain = re.sub(r"\s+", " ", re.sub(r"<[^>]+>", " ", text_html)).strip()
+    return re.sub(r"\s+([,.!?;:，。！？；：])", r"\1", plain)  # 标签位换成的空格别挤到标点前
+
+
+def _content_md(text_html: str, marks: list[str]) -> str:
+    """正文：已剥 emoji 壳的行内 HTML -> markdown + 媒体记号缀尾（与 X/RSS 同观感）。"""
+    blocks: list[str] = []
+    if md := html_to_md(text_html):
+        blocks.append(md)
+    blocks.extend(marks)
+    return "\n\n".join(blocks)
+
+
+def _title_of(text_html: str, marks: list[str]) -> str:
+    """标题 = 正文首行纯文本按显示宽度截断（标题列不要 markdown 记号）；
+    纯媒体帖用记号的标签文字（如「[图片]」），不带链接尾巴。"""
+    if text := _plain_text(text_html):
+        return truncate_display(text, TITLE_WIDTH)
+    labels = [
+        m[: m.index("]") + 1] if m.startswith("[") and "]" in m else m for m in marks
+    ]
+    return " ".join(labels) if labels else ""
+
+
+def parse_channel_html(
+    html: str, *, channel: str, label: str, all_view: bool = False
+) -> list[FeedItem]:
+    """一页预览 HTML -> FeedItem 列表（时间正序，调用方自行倒排/合并）。
+
+    all_view=True 是「全部」聚合视图：元信息列前缀频道名（单频道流里频道
+    名已在侧栏，不重复占位）。
+    """
+    items: list[FeedItem] = []
+    for chunk in _CHUNK_SPLIT.split(html):
+        post = _POST_RE.search(chunk)
+        if post is None:
+            continue  # 服务消息（无 data-post）：没有正文，跳条
+        post_id = post.group(1)
+        url = f"{_SITE}/{post_id}"
+        marks = _media_marks(chunk, url)
+        text_html = _strip_emoji(m.group(1)) if (m := _TEXT_RE.search(chunk)) else ""
+        md = _content_md(text_html, marks)
+        title = _title_of(text_html, marks)
+        if not title:
+            continue  # 既无正文也无媒体：不可展示，跳条不跳流
+        views = (m.group(1) if (m := _VIEWS_RE.search(chunk)) else "").strip()
+        author = (m.group(1) if (m := _AUTHOR_RE.search(chunk)) else "").strip()
+        parts = ([label] if all_view else []) + ([t("words.views", n=views)] if views else [])
+        # 聚合视图频道名已前缀：署名与频道同名时不再重复占位
+        if author and author != (label if all_view else ""):
+            parts.append(author)
+        items.append(
+            FeedItem(
+                source=SOURCE_ID,
+                id=post_id,
+                title=title,
+                url=url,
+                meta=" · ".join(parts),
+                extra={
+                    "content_md": md,
+                    "published": m.group(1) if (m := _TIME_RE.search(chunk)) else "",
+                    "author": author,
+                    "channel": label,
+                },
+            )
+        )
+    return items
+
+
+def parse_telegram_input(text: str) -> str:
+    """输入归一成裸频道名（小写）：durov / @durov / t.me/durov / 帖子直链都认。
+
+    认不出回空串（调用方给「没认出」反馈）。
+    """
+    s = (text or "").strip()
+    if not s:
+        return ""
+    s = s.removeprefix("@")
+    if m := _LINK_RE.search(s):
+        name = m.group(1)
+    else:
+        name = s.rstrip("/")  # 裸名形态：整个串（去尾斜杠）就是频道名
+    return name.lower() if _NAME_RE.match(name) else ""
+
+
+def display_time(published: str) -> str:
+    """extra 里存的 ISO 串 -> 展示文本（详情层时间行用）。"""
+    return fmt_iso(published or None)

feedscope/sources/v2ex/__init__.py

@@ -0,0 +1,64 @@
+"""V2EX 源（v2ex）：热门/最新两个信息流 + 主题详情（正文与回复楼层）。
+
+包内分层（全项目统一的源模板）：
+- fetch.py  取数层：官方 v1 公开 API（免 token 免登录、无登录态）
+- parse.py  解析层：v1 JSON -> FeedItem / 主题详情，纯函数可测
+- __init__.py 编排层：Source 能力声明与 open_* 分派（楼层翻页走 core 的
+  内存切片基类）
+
+结构映射是 X 式两层：topic 本体 -> 回复平铺当楼层（unit「回复」）；V2EX
+回复没有嵌套结构，无评论层（supports_comments=False，Enter 键位预告按此
+退场）。回复一次全量已在内存，楼层翻页是切片——详情打开后零额外请求；
+正文不走网络（列表透传，见 parse）。
+"""
+
+from __future__ import annotations
+
+from feedscope.core.models import FeedItem
+from feedscope.core.i18n import t
+from feedscope.core.registry import register
+from feedscope.core.source import (
+    SliceDetailLoader,
+    Source,
+    SourceError,
+    StaticFeedLoader,
+)
+from feedscope.sources.v2ex.fetch import fetch_replies, fetch_topics
+from feedscope.sources.v2ex.parse import SOURCE_ID, parse_detail, parse_topics
+
+
+class V2exDetailLoader(SliceDetailLoader):
+    """V2EX 详情加载器：回复已全在内存——楼层翻页是切片，零额外请求。
+
+    全部结构在 SliceDetailLoader.from_detail（裸 Answer 楼层、无评论树），
+    本类只声明报错文案里的源标签（楼层页宽用基类默认）。"""
+
+    source_label = "V2EX"
+
+
+@register
+class V2exSource(Source):
+    source_id = SOURCE_ID
+    label = "V2EX"
+    supports_detail = True
+    supports_comments = False  # 回复平铺无嵌套（楼中楼只是 @ 文字），详情到楼层为止
+    feeds: list[str] = ["hot", "new"]
+    feed_labels: dict[str, str] = {
+        "hot": "sources.v2ex.feeds.hot", "new": "sources.v2ex.feeds.new",
+    }
+    detail_kinds = frozenset({"topic"})  # 全部条目 Enter 都进终端详情
+    detail_unit_label = "units.reply"  # 楼层单位词：帖内回复（知乎「回答」、HN「评论」）
+
+    async def open_feed(self, name: str) -> StaticFeedLoader:
+        label = self.label_of(name)
+        # v1 一页全量（hot 10 / latest 40），无翻页：静态首屏出口收 0 条守卫
+        return self.static_feed(parse_topics(await fetch_topics(name, label)), label)
+
+    async def open_detail(self, item: FeedItem) -> SliceDetailLoader:
+        # 正文随列表透传（列表端点 content 即全量）；缺上下文的旧条目（如
+        # 跨进程恢复的列表）回列表重进即可，不值得为此多打一个端点
+        topic = item.extra.get("topic")
+        if not isinstance(topic, dict) or not topic:
+            raise SourceError(t("errors.v2ex_no_context"))
+        replies = await fetch_replies(item.id)
+        return V2exDetailLoader.from_detail(parse_detail(topic, replies), fallback_title=item.title)

feedscope/sources/v2ex/fetch.py

@@ -0,0 +1,46 @@
+"""取数层：V2EX 走官方 v1 公开 API（免 token 免登录）——列表 + 全量回复。
+
+端点都是单请求水合 JSON：hot 10 条 / latest 40 条一页全量（无分页参数，
+列表到头即止）；replies/show.json 实测忽略 page、一次返回全部回复——
+楼层翻页全在内存切片（见 __init__ 的内存 Loader），fetch 层只有两个
+无状态 GET。正文不走网络：列表端点的 content 就是全量（透传见 parse）。
+
+频率限制官方未明示（社区口径约 120 次/时/IP）：刷一次流 1 请求、开一篇
+详情 1 请求，正常阅读离上限很远。要按节点订阅时另有 v2 API（需 Personal
+Access Token）与 v1 的 node_name 查询，本层不做。
+"""
+
+from __future__ import annotations
+
+from feedscope.core import http
+from feedscope.core.i18n import t
+
+_API = "https://www.v2ex.com/api"
+
+# 各内置流的端点（feeds 词汇表与顺序见 __init__）
+FEEDS: dict[str, str] = {
+    "hot": f"{_API}/topics/hot.json",
+    "new": f"{_API}/topics/latest.json",
+}
+
+
+async def _get_list(url: str, source: str, params: dict[str, str] | None = None) -> list[dict]:
+    """GET 一个返回数组的端点 -> 原始 dict 列表（解析/校验见 http.get_json；非 dict 成员剔除）。"""
+    data = await http.get_json(url, source=source, params=params, expect=list)
+    return [d for d in data if isinstance(d, dict)]
+
+
+async def fetch_topics(name: str, label: str) -> list[dict]:
+    """一个信息流的全部主题（v1 一页全量，无翻页）。"""
+    try:
+        url = FEEDS[name]
+    except KeyError:
+        raise ValueError(t("errors.unknown_feed", name=name)) from None
+    return await _get_list(url, t("sources.v2ex.with_label", label=label))
+
+
+async def fetch_replies(topic_id: str) -> list[dict]:
+    """一条主题的全部回复（v1 端点一次给全量，page 参数形同虚设）。"""
+    return await _get_list(
+        f"{_API}/replies/show.json", t("sources.v2ex.replies"), params={"topic_id": topic_id}
+    )

feedscope/sources/v2ex/parse.py

@@ -0,0 +1,116 @@
+"""解析层：v1 JSON -> FeedItem / 主题详情，纯函数不碰网络。
+
+结构映射是 X 式两层（词汇重映射，UI 零特判）：topic 本体（正文 =
+content_rendered 转 markdown，自动内联图片换 [图片] 记号）-> 回复平铺
+当楼层（unit「回复」）。V2EX 回复没有嵌套字段——「楼中楼」只是正文里的
+@ 文字引用，还原不出树，故无评论层（supports_comments=False）。
+
+v1 列表端点的 content/content_rendered 是全量正文（实测无截断），列表
+条目把整个 topic dict 藏进 extra 透传给详情——打开详情只需再拉回复。
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+from feedscope.core.const import safe_int
+from feedscope.core.i18n import t
+from feedscope.core.media import html_to_md
+from feedscope.core.models import Answer, FeedItem
+from feedscope.core.timefmt import fmt_unix
+
+SOURCE_ID = "v2ex"
+
+_TOPIC_URL = "https://www.v2ex.com/t/"
+
+# 相对 href（@ 提及 /member/xxx、站内帖 /t/xxx）：TUI 点开要完整 URL，先绝对化；
+# // 开头的协议相对地址（CDN）不碰
+_REL_HREF = re.compile(r"""href=(["'])/((?!/)[^"']*)\1""")
+
+
+def _md(html: object) -> str:
+    """content_rendered HTML -> markdown：相对链接绝对化后走共用 img 记号管线。"""
+    if not isinstance(html, str) or not html:
+        return ""
+    return html_to_md(_REL_HREF.sub(r"href=\1https://www.v2ex.com/\2\1", html))
+
+
+def _username(member: object) -> str:
+    return str(member.get("username") or "") if isinstance(member, dict) else ""
+
+
+def _meta(topic: dict) -> str:
+    """一行元信息：节点 · 回复数 · 作者（节点即板块，放最前好扫读）。"""
+    parts: list[str] = []
+    node = topic.get("node")
+    if isinstance(node, dict) and (title := str(node.get("title") or "")):
+        parts.append(title)
+    if replies := safe_int(topic.get("replies")):
+        parts.append(t("display.replies_plain", n=replies))
+    if author := _username(topic.get("member")):
+        parts.append(author)
+    return " · ".join(parts)
+
+
+def parse_topics(topics: list[dict]) -> list[FeedItem]:
+    """列表端点 -> FeedItem 列表（保持返回序，野数据逐条防御）。
+
+    整个 topic dict 进 extra：列表正文就是全量，详情打开只再拉回复一个请求。
+    """
+    items: list[FeedItem] = []
+    for tp in topics:
+        tid = str(tp.get("id") or "")
+        if not tid.isdigit():
+            continue  # 无 id 无法寻址，跳条不跳流
+        items.append(
+            FeedItem(
+                source=SOURCE_ID,
+                id=tid,
+                title=str(tp.get("title") or "").strip() or t("words.no_title"),
+                url=f"{_TOPIC_URL}{tid}",
+                kind="topic",
+                meta=_meta(tp),
+                extra={"topic": tp},
+            )
+        )
+    return items
+
+
+@dataclass
+class TopicDetail:
+    """主题详情的解析结果：本体 + 全部回复楼层（平铺，无评论层）。"""
+
+    title: str
+    meta: str
+    time: str
+    description_md: str
+    replies: list[Answer] = field(default_factory=list)
+
+
+def parse_detail(topic: dict, replies: list[dict]) -> TopicDetail:
+    """topic（列表透传）+ 全量回复 -> TopicDetail（楼层 = 回复平铺直出）。"""
+    floors: list[Answer] = []
+    for r in replies:
+        content = _md(r.get("content_rendered"))
+        if not content:
+            continue  # 空壳回复（被移除/占位），跳条不跳流
+        rid = str(r.get("id") or "")
+        topic_id = str(r.get("topic_id") or "")
+        floors.append(
+            Answer(
+                author=_username(r.get("member")),
+                votes="",  # v1 回复不带赞数
+                content_md=content,
+                time=fmt_unix(r.get("created")),
+                # 楼层直达 = 原帖页的 reply 锚点（V2EX 的楼层 permalink 形态）
+                url=f"{_TOPIC_URL}{topic_id}#reply{rid}" if rid else "",
+            )
+        )
+    return TopicDetail(
+        title=str(topic.get("title") or "").strip(),
+        meta=_meta(topic),
+        time=fmt_unix(topic.get("created")),
+        description_md=_md(topic.get("content_rendered")),
+        replies=floors,
+    )

feedscope/sources/x/__init__.py

@@ -0,0 +1,68 @@
+"""X（Twitter）源（x）：推荐/正在关注时间线 + 推文详情（正文与回复）。
+
+包内分层（全项目统一的源模板）：
+- fetch.py  取数层：常驻 x.com 通道页签的页面 fetch 直调 GraphQL + 运行时
+  收割请求形状 + 游标翻页 Loader（搜索为何不做，见其模块头）
+- parse.py  解析层：URT JSON -> FeedItem / 详情，纯函数可测
+- __init__.py 编排层：Source 的能力声明（词汇表/登录）与 open_* 分派
+
+全部能力在登录墙后：`feedscope login x` 弹有头 Chrome 手动输账号密码（+2FA），
+轮询到 auth_token 即成功（login.py 源无关，零改动）。
+"""
+
+from __future__ import annotations
+
+from typing import ClassVar
+
+from feedscope.core.models import FeedItem
+from feedscope.core.i18n import t
+from feedscope.core.registry import register
+from feedscope.core.source import (
+    DetailLoader,
+    FeedLoader,
+    Source,
+    login_gate,
+)
+from feedscope.sources.x.fetch import (
+    XFeedLoader,
+    XTweetDetailLoader,
+    fetch_conversation,
+)
+
+
+async def require_login(what: str) -> None:
+    """判登门：auth_token/ct0 成对在 profile 里即已登录（通道页签的 cookie 由浏览器自带）。"""
+    await login_gate(
+        "https://x.com",
+        lambda c: bool(c.get("auth_token") and c.get("ct0")),
+        label="X",
+        what=what,
+    )
+
+
+@register
+class XSource(Source):
+    source_id = "x"
+    label = "X"
+    supports_detail = True
+    feeds: list[str] = ["foryou", "following"]  # 与 X 主页页签同序：默认进「推荐」
+    feed_labels: dict[str, str] = {
+        "foryou": "sources.x.feeds.foryou", "following": "sources.x.feeds.following",
+    }
+    detail_kinds = frozenset({"tweet"})  # Enter 进终端详情屏（正文 + 回复）
+    detail_unit_label = "units.reply"
+    login_url = "https://x.com/login"
+    login_cookie = "auth_token"  # feedscope login 轮询的判登 cookie（手动输密码后写入）
+    logout_cookies: ClassVar[list[str]] = ["auth_token", "ct0"]  # 登出清掉判登成对 cookie
+
+    async def open_feed(self, name: str) -> FeedLoader:
+        label = self.label_of(name)
+        await require_login(t("errors.what_timeline", label=label))
+        return await self.first_batch(XFeedLoader(name), label)
+
+    async def open_detail(self, item: FeedItem) -> DetailLoader:
+        await require_login(t("errors.what_tweet_detail"))
+        # 转发（RT）的会话在原推那里：列表已把原推 id 放进 extra（见 parse._tweet_from_result）
+        rest_id = str(item.extra.get("conversation_id") or item.id.rsplit("/", 1)[-1])
+        entries, cursor = await fetch_conversation(rest_id, None)
+        return XTweetDetailLoader(rest_id, entries, cursor)