feedscope 0.1.0__py3-none-any.whl

feedscope/subscriptions.py

@@ -0,0 +1,423 @@
+"""订阅管理业务：rss 的增删查 + OPML 进出，reddit 的 subreddit 与 telegram
+的频道增删查。
+
+只做管理编排：读改写 sources.toml（写路径统一走 config.update_feeds，
+enabled/hide 联动在那里）、rss add 拉一次 feed 取标题当默认显示名、
+reddit add 拉一次 r/{name}/ 页面校验存在性并取 subreddit 名、telegram
+add 拉一次 t.me/s 预览页校验可读并取频道名。TUI 订阅管理屏不直接调这里
+的函数，走 SubsStore 适配器（屏保持源无关）；CLI 的 rss 子命令直接调
+rss 函数。OPML 用 stdlib ElementTree 解析（嵌套目录拍平），导出手写
+模板——结构固定，不值得引库。
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Awaitable, Callable, Iterable
+from dataclasses import dataclass
+from pathlib import Path
+from urllib.parse import urlparse
+from xml.etree import ElementTree as ET
+from xml.sax.saxutils import escape
+
+from feedscope.core import config
+from feedscope.core.config import Subscription
+from feedscope.core.registry import get_class
+from feedscope.core.i18n import t
+from feedscope.core.source import SourceError
+
+
+def _reserved(source_id: str) -> tuple[str, ...]:
+    """订阅 key 的保留字（聚合流名 / 内置流名）：一律读源自己的声明
+    （Source.reserved_feed_keys，单一出处）——源新增内置流后保留字自动
+    跟上，不会再出现这里抄一份、那边忘了同步的窗口。"""
+    import feedscope.sources  # noqa: F401  import 即注册；只在这条保留字检查路径拉起源
+
+    cls = get_class(source_id)
+    return cls.reserved_feed_keys if cls is not None else ()
+
+
+class SubscriptionError(Exception):
+    """订阅操作的业务失败（重复 / key 冲突 / 文件读不了）：消息面向用户可直接打印。"""
+
+
+class BadSubscriptionFile(SubscriptionError):
+    """OPML 文件读不了 / 不是合法 OPML：用法级错误（CLI 退出码 2，与 argparse 约定一致）。"""
+
+
+def derive_key(url: str, existing: Iterable[str]) -> str:
+    """URL -> 订阅 key：域名清洗成 ASCII 段（www 剥掉、非法字符折叠成 -），
+    与 existing 撞名则加 -2、-3…；域名清洗后为空（如纯 IP 端口）回退 feed。
+
+    existing 是「要避开的 key 全集」——调用方把保留字（聚合流名等，见
+    _reserved）并进已有订阅一起传：派生出的 key 撞保留字会同样加后缀绕开，
+    显式 key 撞保留字的报错路径只在用户真的手输时才触发。"""
+    host = urlparse(url).netloc.lower().split("@")[-1].split(":")[0]
+    host = re.sub(r"^www\.", "", host)
+    base = re.sub(r"[^a-z0-9]+", "-", host).strip("-") or "feed"
+    keys = set(existing)
+    if base not in keys:
+        return base
+    n = 2
+    while f"{base}-{n}" in keys:
+        n += 1
+    return f"{base}-{n}"
+
+
+async def _fetch_body_or_none(url: str) -> bytes | None:
+    """拉一次地址；失败回 None——取名/自动发现是尽力而为，不挡加订阅。"""
+    from feedscope.core import http
+
+    try:
+        return (await http.get(url, source="RSS")).content
+    except Exception:
+        return None
+
+
+async def add_feed(url: str, *, key: str | None = None, label: str | None = None) -> Subscription:
+    """加一条订阅并落盘；显示名缺省拉一次 feed 标题，再缺省回 key。
+
+    地址不是 feed 而是站点首页时自动发现 feed 声明（<link rel="alternate">）
+    并改订发现的地址（key 沿用）；重复地址 / 显式 key 撞已有或保留字 all →
+    SubscriptionError（不动配置）。
+    """
+    # 源 parse 层按需导入：rss list / export 这类纯配置命令不必拉起全部源模块
+    from feedscope.sources.rss.parse import discover_feed_link, probe
+
+    feeds = config.rss_feeds()
+    if any(f.url == url for f in feeds):
+        dup = next(f.key for f in feeds if f.url == url)
+        raise SubscriptionError(t("subs.dup_url", key=dup))
+    if key is None:
+        # 保留字并进避让集：https://all.com/… 派生出的 key 是 all-2 而不是 all
+        #（撞上聚合流名的订阅会被读取侧静默跳过，加了等于没加）
+        key = derive_key(url, (*_reserved("rss"), *(f.key for f in feeds)))
+    elif key in _reserved("rss"):
+        raise SubscriptionError(t("subs.reserved_key", key=key))
+    elif key in {f.key for f in feeds}:
+        raise SubscriptionError(t("subs.key_taken", key=repr(key)))
+    if not label:
+        body = await _fetch_body_or_none(url)
+        if body is not None:
+            title, entries = probe(body)
+            if not title and not entries:
+                # 拉回来不像 feed：当首页试自动发现（粘博客首页也能订上）
+                alt = discover_feed_link(body.decode("utf-8", "ignore"), url)
+                if alt and alt != url:
+                    return await add_feed(alt, key=key)
+            label = title
+    feed = Subscription(key=key, label=label or key, url=url)
+    config.update_rss_feeds([*feeds, feed])
+    return feed
+
+
+def _rename(source_id: str, key: str, new_label: str) -> Subscription | None:
+    """改显示名（rss / reddit 共用）；名字清空 / key 不存在返回 None（不动配置）。"""
+    new_label = new_label.strip()
+    if not new_label:
+        return None
+    feeds = config.feeds_for(source_id)
+    if key not in {f.key for f in feeds}:
+        return None
+    renamed = Subscription(key=key, label=new_label, url=next(f.url for f in feeds if f.key == key))
+    config.update_feeds(source_id, [renamed if f.key == key else f for f in feeds])
+    return renamed
+
+
+def rename_feed(key: str, new_label: str) -> Subscription | None:
+    """改 rss 订阅的显示名。"""
+    return _rename("rss", key, new_label)
+
+
+async def add_from_input(text: str) -> tuple[list[Subscription], str]:
+    """添加入口的智能分流：http(s) 地址 → 单条添加；本地路径 → OPML 导入。
+
+    返回 (本次新增, 结果描述)；`~` 开头的路径自动展开。CLI 的 add 与 TUI
+    订阅管理屏的添加框共用这里，行为永远一致。
+    """
+    text = text.strip()
+    if not text:
+        raise SubscriptionError(t("subs.empty_input"))
+    if text.startswith(("http://", "https://")):
+        feed = await add_feed(text)
+        return [feed], t("subs.added_feed", key=feed.key, label=feed.label)
+    added, skipped = import_opml(read_opml_file(text))
+    detail = t("subs.imported_skip", n=len(skipped)) if skipped else ""
+    return added, t("subs.imported", n=len(added), detail=detail)
+
+
+def _remove(source_id: str, key: str, *, drop_when_empty: bool) -> Subscription | None:
+    """删一条订阅（各源共用），返回被删的；key 不存在返回 None（不动配置）。
+
+    drop_when_empty：删到空是否从 enabled 摘掉该源——rss/telegram 的 feeds
+    全来自订阅（删空 = 没有任何流）摘；reddit 有内置流不摘。
+    """
+    feeds = config.feeds_for(source_id)
+    kept = [f for f in feeds if f.key != key]
+    if len(kept) == len(feeds):
+        return None
+    config.update_feeds(source_id, kept, drop_enabled_when_empty=drop_when_empty)
+    return next(f for f in feeds if f.key == key)
+
+
+def remove_feed(key: str) -> Subscription | None:
+    """删一条 rss 订阅。"""
+    return _remove("rss", key, drop_when_empty=True)
+
+
+# ---- OPML 进出 ----
+
+
+def read_opml_file(path: str | Path) -> str:
+    """读 OPML 文件文本（`~` 展开）；读不了抛 BadSubscriptionFile（CLI/TUI 同一出口）。"""
+    try:
+        return Path(path).expanduser().read_text(encoding="utf-8")
+    except OSError as exc:
+        raise BadSubscriptionFile(t("subs.opml_unreadable", error=exc)) from None
+
+
+def parse_opml(text: str) -> list[tuple[str, str]]:
+    """OPML 文本 -> [(label, xmlUrl)]；嵌套目录拍平，无 xmlUrl 的节点只当容器。"""
+    try:
+        root = ET.fromstring(text)
+    except ET.ParseError as exc:
+        raise BadSubscriptionFile(t("subs.opml_invalid", error=exc)) from None
+    out: list[tuple[str, str]] = []
+    for outline in root.iter("outline"):
+        url = (outline.get("xmlUrl") or "").strip()
+        if not url:
+            continue
+        label = (outline.get("text") or outline.get("title") or "").strip()
+        out.append((label, url))
+    return out
+
+
+def import_opml(text: str) -> tuple[list[Subscription], list[str]]:
+    """OPML 批量导入（幂等合并）：返回 (新增订阅, 跳过原因列表)。
+
+    文件读不了 / 不是合法 OPML 抛 BadSubscriptionFile（用法级错误）。
+    已订阅的地址（含 OPML 内部重复）跳过；label 用 outline 的 text/title，
+    缺了回 key；一次落盘（中途失败不写半截配置）。
+    """
+    feeds = config.rss_feeds()
+    known_urls = {f.url for f in feeds}
+    # 保留字并进避让集（与 add_feed 的派生路径同一条规则）：OPML 里的
+    # all.com 订阅派生 all-2，不会产出被读取侧静默跳过的撞名 key
+    known_keys = {f.key for f in feeds} | set(_reserved("rss"))
+    added: list[Subscription] = []
+    skipped: list[str] = []
+    for label, url in parse_opml(text):
+        if url in known_urls:
+            skipped.append(t("subs.opml_dup", name=label or url))
+            continue
+        key = derive_key(url, known_keys)
+        known_urls.add(url)
+        known_keys.add(key)
+        added.append(Subscription(key=key, label=label or key, url=url))
+    if added:
+        config.update_rss_feeds([*feeds, *added])
+    return added, skipped
+
+
+_XML_QUOTE = '"'
+
+
+def _attr(value: str) -> str:
+    """字符串 -> XML 属性值：双引号包裹，& < > 与引号本体转义。"""
+    escaped = escape(value, {_XML_QUOTE: "&quot;"})
+    return f"{_XML_QUOTE}{escaped}{_XML_QUOTE}"
+
+
+def export_opml(feeds: list[Subscription]) -> str:
+    """订阅表 -> OPML 2.0 文本（标准阅读器都认，可再迁去别家）。"""
+    lines = [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<opml version="2.0">',
+        f"  <head><title>{t('subs.opml_title')}</title></head>",
+        "  <body>",
+    ]
+    lines += [
+        f'    <outline type="rss" text={_attr(f.label)} xmlUrl={_attr(f.url)} />' for f in feeds
+    ]
+    lines += ["  </body>", "</opml>", ""]
+    return "\n".join(lines)
+
+
+# ---- Reddit subreddit 订阅 ----
+# （订阅 key 的保留字＝内置流名 home/popular，读源声明：见 _reserved）
+
+
+# ---- Telegram 频道订阅 ----
+# （订阅 key 的保留字＝聚合流名 all，读源声明：见 _reserved）
+
+
+async def add_subreddit(text: str, *, label: str | None = None) -> Subscription:
+    """加一个 subreddit 订阅并落盘；显示名缺省取 r/{name}/ 页面里的 subreddit 名。
+
+    输入四形态归一（裸名 / r/name / /r/name/ / 站点地址，见 parse_subreddit_input）；
+    重复 / 撞内置流 / 页面拉不到（subreddit 不存在或未登录）→ SubscriptionError
+    （不动配置）。未登录时报错消息自带「需要登录」指引。
+    """
+    from feedscope.sources.reddit import require_login
+    from feedscope.sources.reddit.fetch import fetch_subreddit
+    from feedscope.sources.reddit.parse import parse_subreddit_input
+
+    name = parse_subreddit_input(text)
+    if not name:
+        raise SubscriptionError(t("subs.subreddit_unrecognized"))
+    if name in _reserved("reddit"):
+        raise SubscriptionError(t("subs.subreddit_reserved", name=name))
+    feeds = config.feeds_for("reddit")
+    if any(f.key == name for f in feeds):
+        raise SubscriptionError(t("subs.subreddit_dup", name=name))
+    try:
+        await require_login(f"r/{name}")
+        real = await fetch_subreddit(name)
+    except SourceError as exc:  # 含 LoginRequired：订阅管理屏没有账号动线，消息自带指引
+        raise SubscriptionError(t("subs.subreddit_failed", name=name, error=exc)) from None
+    display = real or name
+    feed = Subscription(key=name, label=label or display, url=f"https://www.reddit.com/r/{name}/")
+    config.update_feeds("reddit", [*feeds, feed])
+    return feed
+
+
+async def add_subreddit_from_input(text: str) -> tuple[list[Subscription], str]:
+    """订阅管理屏的 reddit 添加入口（与 rss 的 add_from_input 同形，store 注入用）。"""
+    feed = await add_subreddit(text)
+    return [feed], t("subs.added_subreddit", key=feed.key, label=feed.label)
+
+
+def remove_subreddit(key: str) -> Subscription | None:
+    """删一个 subreddit 订阅；key 不存在返回 None（不动配置）。"""
+    return _remove("reddit", key, drop_when_empty=False)
+
+
+def rename_subreddit(key: str, new_label: str) -> Subscription | None:
+    """改 subreddit 订阅的显示名；名字清空 / key 不存在返回 None（不动配置）。"""
+    return _rename("reddit", key, new_label)
+
+
+async def add_channel(text: str, *, label: str | None = None) -> Subscription:
+    """加一个 Telegram 频道订阅并落盘；显示名缺省拉一次预览页的频道名。
+
+    输入形态见 parse_telegram_input（durov / @durov / t.me/durov / 帖子直链）；
+    重复 / 撞保留字 all / 预览页拉不到任何消息（不存在、为空、站长关了 Web
+    预览）→ SubscriptionError（不动配置）。
+    """
+    from feedscope.sources.telegram.fetch import fetch_channel_html
+    from feedscope.sources.telegram.parse import (
+        channel_title,
+        parse_channel_html,
+        parse_telegram_input,
+    )
+
+    name = parse_telegram_input(text)
+    if not name:
+        raise SubscriptionError(t("subs.channel_unrecognized"))
+    if name in _reserved("telegram"):
+        # 防御分支：当前保留字 all 只有 3 字符，Telegram 用户名最短 5 字符，
+        # 实际到不了这里（先被输入归一拦下）——留给保留字集日后扩展长词
+        raise SubscriptionError(t("subs.channel_reserved", name=name))
+    feeds = config.feeds_for("telegram")
+    if any(f.key == name for f in feeds):
+        raise SubscriptionError(t("subs.channel_dup", name=name))
+    html = await fetch_channel_html(name)  # SourceError 顺势上抛（HTTP 层的中文消息够用）
+    items = parse_channel_html(html, channel=name, label=name)
+    if not items:
+        raise SubscriptionError(t("subs.channel_no_items", name=name))
+    display = channel_title(html) or name
+    feed = Subscription(key=name, label=label or display, url=f"https://t.me/{name}/")
+    config.update_feeds("telegram", [*feeds, feed])
+    return feed
+
+
+async def add_channel_from_input(text: str) -> tuple[list[Subscription], str]:
+    """订阅管理屏的 Telegram 添加入口（与 rss 的 add_from_input 同形，store 注入用）。"""
+    feed = await add_channel(text)
+    return [feed], t("subs.added_channel", key=feed.key, label=feed.label)
+
+
+def remove_channel(key: str) -> Subscription | None:
+    """删一个频道订阅；key 不存在返回 None（不动配置）。"""
+    return _remove("telegram", key, drop_when_empty=True)
+
+
+def rename_channel(key: str, new_label: str) -> Subscription | None:
+    """改频道订阅的显示名；名字清空 / key 不存在返回 None（不动配置）。"""
+    return _rename("telegram", key, new_label)
+
+
+# ---- 订阅管理屏的源适配器 ----
+
+
+@dataclass(frozen=True)
+class SubsStore:
+    """一个 subscribable 源的订阅管理适配器：四操作 + 文案，订阅管理屏只认它。
+
+    订阅概念不再只有 rss（reddit 的 subreddit、之后的 Telegram 频道共用
+    一屏）：源的差异收进这个对象，屏保持通用（列表 + 增删改名），业务
+    编排全部留在本模块。add 与 rss 的 add_from_input 同形——(新增, 概要)。
+    """
+
+    label: str  # 屏标题「{label} 订阅管理」
+    add_placeholder: str  # 添加输入框占位（各源可输入的形态不同）
+    hint: str  # 底部键位提示行
+    empty: str  # 零订阅占位文案
+    feeds: Callable[[], list[Subscription]]  # 当前订阅表（列表顺序 = 配置顺序）
+    add: Callable[[str], Awaitable[tuple[list[Subscription], str]]]
+    remove: Callable[[str], Subscription | None]
+    rename: Callable[[str, str], Subscription | None]
+
+
+def rss_store() -> SubsStore:
+    return SubsStore(
+        label="RSS",
+        add_placeholder=t("subs.rss_placeholder"),
+        hint=t("subs.rss_hint"),
+        empty=t("subs.rss_empty"),
+        feeds=config.rss_feeds,
+        add=add_from_input,
+        remove=remove_feed,
+        rename=rename_feed,
+    )
+
+
+def reddit_store() -> SubsStore:
+    return SubsStore(
+        label="Reddit",
+        add_placeholder=t("subs.reddit_placeholder"),
+        hint=t("subs.hint_basic"),
+        empty=t("subs.reddit_empty"),
+        feeds=lambda: config.feeds_for("reddit"),
+        add=add_subreddit_from_input,
+        remove=remove_subreddit,
+        rename=rename_subreddit,
+    )
+
+
+def telegram_store() -> SubsStore:
+    return SubsStore(
+        label="Telegram",
+        add_placeholder=t("subs.telegram_placeholder"),
+        hint=t("subs.hint_basic"),
+        empty=t("subs.telegram_empty"),
+        feeds=lambda: config.feeds_for("telegram"),
+        add=add_channel_from_input,
+        remove=remove_channel,
+        rename=rename_channel,
+    )
+
+
+# 源 id -> store 工厂：新增 subscribable 源在这里登记一个（订阅屏的入口分派）
+_STORES: dict[str, Callable[[], SubsStore]] = {
+    "rss": rss_store,
+    "reddit": reddit_store,
+    "telegram": telegram_store,
+}
+
+
+def store_for(source_id: str) -> SubsStore:
+    """订阅管理屏的入口工厂；未登记的 id = subscribable 声明与 store 不一致，尽早炸。"""
+    if build := _STORES.get(source_id):
+        return build()
+    raise ValueError(t("subs.no_store", source=source_id))

feedscope/ui/__init__.py

@@ -0,0 +1,10 @@
+"""TUI 层：Textual 应用与界面。"""
+
+from __future__ import annotations
+
+from textual.binding import Binding
+
+# 键位声明的类型别名：Textual 基类把 BINDINGS 声明为宽松的历史联合
+# （Binding | 两种元组形态），子类全用 Binding 对象声明时按它对齐，
+# mypy 的 list 不变检查才放行——别名在此一处，各屏不再各自与基类搏斗。
+Bindings = list[Binding | tuple[str, str] | tuple[str, str, str]]

feedscope/ui/account.py

@@ -0,0 +1,125 @@
+"""账号动线：撞墙自动询问与 Ctrl+U 手动登录/登出的编排（从 app.py 拆出）。
+
+MainScreen 只留 Ctrl+U 转发，状态与全过程在这里：
+- in_progress（有头登录进行中）：挡下刷新/切源，独占 profile 锁期间不碰浏览器
+- refused（本次运行内已拒绝询问的源）：撞墙不再自动弹框，只留常驻
+  「Ctrl+U 登录」提示；Ctrl+U 手动登录照常可用，登录成功/登出后清除，
+  后续撞墙（登录过期、换账号）恢复自动询问
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from feedscope import login
+from feedscope.core.source import Source
+from feedscope.core.i18n import t
+from feedscope.ui import feedback
+from feedscope.ui.dialogs import AccountScreen
+
+if TYPE_CHECKING:
+    from feedscope.ui.app import FeedScopeApp
+
+
+class AccountFlow:
+    """一个 App 一份账号动线（当前源语境由调用方给，不自己记选中位）。"""
+
+    def __init__(self, app: FeedScopeApp) -> None:
+        self.app = app
+        self.in_progress = False  # 有头登录进行中（挡刷新，见 action_refresh）
+        self.refused: set[str] = set()  # 已拒绝自动询问的源 id（本运行内有效）
+
+    async def on_login_wall(self, source: Source, hint: str) -> None:
+        """取数撞登录墙：弹登录框（等用户选「登录」才开浏览器，不擅自弹窗）。
+
+        每个源一次；取消即记住（本运行内不再自动问），切页/刷新不被反复
+        打断。调用方（_refresh）已在 worker 里，wait_for_dismiss 合法。
+        """
+        proceed = await self.app.push_screen(
+            AccountScreen(source.label_text, "dialogs.login"), wait_for_dismiss=True
+        )
+        if proceed:
+            self.app.run_worker(self.login(source), group="login", exclusive=True)
+        else:
+            self.refused.add(source.source_id)
+            if (main := self.app.main) is not None:
+                main.show_empty(hint)
+            feedback.info(self.app, t("account.login_refused"))
+
+    async def open(self, source: Source) -> None:
+        """Ctrl+U 的账号框：按当前源状态分派——匿名源提示、已登录弹登出、
+        未登录弹登录。
+
+        走 worker 因为 push_screen 的 wait_for_dismiss 只能在 worker 里用。
+        group 独立于列表加载的 default 组，Ctrl+U 不会打断在途的 _refresh。
+        """
+        if not source.login_url:
+            feedback.info(self.app, t("account.no_login_needed", label=source.label_text))
+            return
+        if self.in_progress:
+            feedback.info(self.app, t("account.login_in_progress"))
+            return
+        logged_in = await login.is_logged_in(source.source_id)
+        action_key = "dialogs.logout" if logged_in else "dialogs.login"
+        proceed = await self.app.push_screen(
+            AccountScreen(source.label_text, action_key), wait_for_dismiss=True
+        )
+        if not proceed:
+            if action_key == "dialogs.login":
+                # 手动框里取消同样算拒绝：之后撞墙不再自动弹（登出框取消无此语义）
+                self.refused.add(source.source_id)
+            return
+        # 后续动作放独立的 login 组：exclusive 会取消同组在途 worker，若与本
+        # worker（account 组）同组，等于把调用者自己也排进取消名单——现在能
+        # 活着只是因为派发后不再 await；分组错开即消除对这层时序的依赖。
+        if logged_in:
+            self.app.run_worker(self.logout(source), group="login", exclusive=True)
+        else:
+            self.app.run_worker(self.login(source), group="login", exclusive=True)
+
+    async def login(self, source: Source) -> None:
+        """关 headless session 让出 profile 锁 → 有头浏览器登录 → 刷新。
+
+        登录期间置 in_progress，挡下刷新误触发 profile 锁冲突；完成后
+        恢复并刷新（成功则列表出内容，失败/超时仍撞墙）。
+        """
+        self.in_progress = True
+        try:
+            if (main := self.app.main) is not None:
+                await main.release_feed_loader()  # 释放活页签，别跟有头登录抢 profile
+            await login.yield_profile()  # 关无头会话让出 profile 锁（语义在 login 侧）
+            try:
+                ok = await login.login(source.source_id, quiet=True)
+            except Exception:
+                ok = False
+            if ok:
+                self.refused.discard(source.source_id)  # 后续撞墙（过期）恢复自动询问
+                feedback.info(self.app, t("account.login_ok", label=source.label_text))
+            else:
+                # 未完成（超时/关窗放弃）：别再自动追问，重试入口在 toast 与常驻提示里
+                self.refused.add(source.source_id)
+                feedback.warn(
+                    self.app,
+                    t("account.login_incomplete", label=source.label_text),
+                    title=t("account.title_login"),
+                )
+        finally:
+            self.in_progress = False
+            if self.app.main is not None:
+                self.app.main.action_refresh()
+                # action_refresh 有 in_progress 挡门：复位必须在刷新之前（finally 保序）
+
+    async def logout(self, source: Source) -> None:
+        """清掉当前源登录 cookie → 刷新（撞墙弹登录框，即换账号动线）。"""
+        self.refused.discard(source.source_id)  # 主动登出 = 想换账号：撞墙要重新弹登录框
+        try:
+            had = await login.logout(source.source_id)
+        except Exception as exc:
+            feedback.fail(self.app, source, exc, action="feedback.action_logout_failed")
+            return
+        if had:
+            feedback.info(self.app, t("account.logged_out", label=source.label_text))
+        else:
+            feedback.info(self.app, t("account.not_logged_in", label=source.label_text))
+        if self.app.main is not None:
+            self.app.main.action_refresh()

feedscope/ui/app.py

@@ -0,0 +1,105 @@
+"""TUI 应用壳：主题/生命周期/全局键位与账号动线的宿主，主屏见 screens/main.py。
+
+App 只保留跨屏职责——主题注册、启动序列（注册表检查 + 浏览器预热）、
+退出清理（会话/连接池）、全局退出键；主屏（tab 条/边栏/列表/导航）整体
+住在 MainScreen（get_default_screen 返回，框架启动即挂为默认屏），经 app.main
+访问。这样键位归属与守卫自然对齐：主屏键只绑在主屏（弹层/详情在前台时
+不命中），全局键只剩 Ctrl+Q。
+"""
+
+from __future__ import annotations
+
+import os
+from typing import ClassVar
+
+from textual.app import App
+from textual.binding import Binding
+
+import feedscope.sources  # noqa: F401  import 即注册
+from feedscope.core import config, http
+from feedscope.core import i18n
+from feedscope.core.i18n import t
+from feedscope.core.browser import close_session, get_session
+from feedscope.core.registry import source_classes
+from feedscope.ui import Bindings
+from feedscope.ui.account import AccountFlow
+from feedscope.ui.labels import retranslate_bindings
+from feedscope.ui.screens.main import MainScreen
+from feedscope.ui.theme import FEEDSCOPE_THEME
+
+
+def _no_prewarm() -> bool:
+    """禁预热开关：FEEDSCOPE_NO_PREWARM=1 时启动不拉浏览器。
+
+    测试与截图脚本用（stub 源不需要真 Chrome，拉起来既慢又可能挂起）；
+    运行时读环境变量而非模块级开关，工具侧设 env 即生效、不用掰模块属性。
+    """
+    return os.environ.get("FEEDSCOPE_NO_PREWARM") == "1"
+
+
+class FeedScopeApp(App[None]):
+    # 标题随语言：TITLE 类属性在 import 期求值会冻住语言，on_mount 里按 t() 设
+
+    # 主屏即默认屏：框架启动时实例化（无需显式 push），详情/弹层盖在其上
+    def get_default_screen(self) -> MainScreen:
+        return MainScreen()
+
+    # 关闭 Textual 自带命令面板（页脚 palette 链接 + Ctrl+P）：里面只有框架默认的
+    # Theme/Quit/Keys/Screenshot 系统命令，对本应用全是冗余——主题定死编辑器风、
+    # 退出有 q，其余是调试入口，不该暴露给用户。
+    ENABLE_COMMAND_PALETTE = False
+
+    # 键位全部非打印键：字母/数字会被中文输入法拦进候选框，一个动作只留
+    # 一个键，不给字母留别名。全局只剩退出（Ctrl+C 连按退出是 Textual 自带
+    # 兜底，不占页脚）；主屏键（刷新/翻页/导航/F2/Ctrl+U）在 MainScreen——
+    # 屏级绑定只在该屏前台时命中，App 级动作不再需要「是否在主屏」守卫。
+    BINDINGS: ClassVar[Bindings] = [
+        Binding("ctrl+q", "quit", "bindings.quit", priority=True),
+    ]
+
+    def __init__(self) -> None:
+        super().__init__()
+        # 进程语言按配置设定（未设置 = 缺省英文，不是系统猜测——猜测只作
+        # 首启语言屏的预选高亮；这里保证直构 App 的路径（截图脚本 / 测试）
+        # 与 cli.main 组装的一致）。语言随进程固定：改语言走 Ctrl+L 落盘 + 重启
+        i18n.set_language(config.get_language() or i18n.DEFAULT_LANGUAGE)
+        # 克制的编辑器风配色（见 ui/theme.py），产品需求而非保守
+        self.register_theme(FEEDSCOPE_THEME)
+        self.theme = FEEDSCOPE_THEME.name
+        # 账号动线（撞墙自动询问 / Ctrl+U 登录登出）：状态与编排都在 ui/account.py
+        self.accounts = AccountFlow(self)
+
+    @property
+    def main(self) -> MainScreen | None:
+        """主屏实例（栈底，被弹层/详情覆盖时也在）；启动完成前可能为 None。"""
+        for screen in reversed(self.screen_stack):
+            if isinstance(screen, MainScreen):
+                return screen
+        return None
+
+    def on_mount(self) -> None:
+        self.title = t("app.title")
+        retranslate_bindings(self)  # App 级键位（ctrl+q）的键式文案解析，见 ui/labels.py
+        if not source_classes():
+            self.exit(message=t("app.exit_no_sources"))
+            return
+        if not _no_prewarm():
+            self.run_worker(self._prewarm(), group="prewarm")  # 后台预热，见 _prewarm
+
+    async def _prewarm(self) -> None:
+        """后台预热浏览器会话：首条列表不用再付冷启动（Chrome 拉起几秒；
+        UA 探针另有 7 天落盘缓存，多数启动只付 Chrome 拉起）。
+
+        知乎/Reddit（通道页签）与 X/Reddit（profile 读 cookie）都要浏览器，
+        预热几乎总用得上；失败静默——首次真正取数时自然再试并给正式报错。
+        """
+        try:
+            await get_session().start()
+        except Exception:
+            pass
+
+    # ---- 清理 ----
+
+    async def on_unmount(self) -> None:
+        await close_session()
+        await http.close()