TwilightRain Hexo https://twilightrain.com/ All rights reserved 2026, TwilightRain TwilightRain 的个人博客，记录技术探索与日常思考 TwilightRain 2026-08-26T05:06:32.651Z TwilightRain

2020 年 12 月 31 日，Adobe 官方停止支持 Flash。中国大陆除外，因为”代理”还在用 flash.cn 续命，给你弹广告、弹”版本过旧”、弹闪退。

最近玩 Flash 小游戏，Flash 酱一反常态地暴躁。游戏加载到一半，弹窗”您的 Flash 版本过旧，请升级”，点掉之后直接闪退。而且这待遇是中国 IP 限定的，症状集中指向 flash.cn 特供版。

一、实锤，本机装的是 flash.cn 特供版 34.0.0.282

查安装日志 C:\Windows\SysWOW64\Macromed\Flash\FlashInstall32.log，

1
=M/M/34.0.0.282 2023-05-20+09-46-41.993=

34.0.0.282？Adobe 官方最后一版是 32.0.0.465（2020 年 12 月）。
这个34.x是谁编出来的？flash.cn代理商在官方停更后继续”维护”的版本号比官方还高两代，里面塞了自己的更新检查逻辑，连上自家服务器（flash.cn 域名），就通知你”版本过旧”，顺手弹广告。什么叫做最新版版本过旧？！！！！！！（官方正版受害者233）

你走吧，太老了。（Flash酱的不屑）

本机 hosts 里原本已有 Adobe 官方域名的屏蔽（geo2.adobe.com、fpdownload.macromedia.com），但漏了 flash.cn 自家的域名。

二、Resources 里的纪念版方案

贴吧链接tieba.baidu.com
教程灵感来源
贴吧对应的网盘wwa.lanzoub.com
网盘包来源

A:\work_zone\Resources 下有两个包，

  1. Flash_Player_v32.0.0.465 三件套，官方最终版（ActiveX / NPAPI / PPAPI），README 说”最好全装”
  2. 文件夹内文件拖入C盘覆盖，一个 0 字节的 settings.sol + 一份 hosts 模板

原理很直白，flash.cn 版的行为状态被写进 Flash 的全局设置（settings.sol），同时它连自家服务器判断要不要弹窗。把 settings.sol 清空 + hosts 屏蔽域名，双管齐下。

三、动手，备份、清空、补屏蔽

备份放到 A:\work_zone\Temp\FlashFix_backup_20260826（原 hosts + 整个 Flash Player 设置目录）。

settings.sol 清空

两个位置，

  • %APPDATA%\Macromedia\Flash Player\macromedia.com\support\flashplayer\sys\settings.sol
  • 同目录下 #local\settings.sol

用包里的 0 字节文件覆盖。注意同级的 #SharedObjects 目录是游戏存档（相当于 localStorage），不能动，README 那句”用 Everything 删掉所有 settings.sol”是有坑的，照做会连游戏进度一起清掉。

hosts 只补一行

包里的 hosts 是纯净模板，但本机 hosts 有 Pixiv、Docker、Steam 的条目（才不告诉你我劫持这些主机用来干什么呢！），不能整包覆盖。只追加，127.0.0.1 flash.cn

结果当场翻车，原文件末尾没有换行符，Add-Content 追加把内容拼进了上一行，变成 # Adobe End127.0.0.1 flash.cn，整行是注释，屏蔽无效。用正则把行拆开才修好。

教训

改 hosts 先看文件末尾有没有换行符。追加内容被拼进注释行就是静默失效，比没改还隐蔽。

四、三件套安装，两个顺利，一个装了个寂寞

  • ActiveX，SFX 后台运行，自己提权装好了（Flash.ocx 32/64 位 + 注册表 32.0.0.465）
  • PPAPI，提权脚本一次成功（pepflashplayer.dll 32/64 + manifest.json）
  • NPAPI，两次”运行完成”，什么都没装

NPAPI 那个安装器跑了 45 秒显示完成，但 NPSWF.dll 没落地、注册表没有 FlashPlayerPlugin 键。勾起了我的好奇。

五、解包取证，批处理第一行就是答案

安装器是 7-Zip 自解压包（SFX），里面藏着安装批处理。解包过程，

  1. Python 的 py7zr 能读到档案列表，但里面的 DLL 用了 BCJ2 过滤器，解不出来
  2. 本机有 msys2，pacman -S p7zip 一条命令装好
  3. 7z x 直接解带 PE 头的 exe，7z 会自动跳过 stub

看到批处理第一行，一切豁然开朗，

1
2
@ECHO OFF&(PUSHD "%~DP0")&(REG QUERY "HKU\S-1-5-19">NUL 2>&1)||(
powershell -Command "Start-Process '%~sdpnx0' -Verb RunAs"&&EXIT)

它检测自己是否跑在管理员上下文（HKU\S-1-5-19 是系统账户的注册表 hive），不是就 Start-Process -Verb RunAs 提权重启自己。UAC 弹窗没人点 → 静默 EXIT。之前两次失败都卡在这一环，安装器自己提权重启，UAC 没被确认，安装流程就悄悄结束了。

真相

“安装器运行了但什么都没装”，大概率是安装器内部有提权重启逻辑，UAC 被忽略就静默退出。看文件、看注册表，别信安装器自己报的”完成”。

六、手动安装 NPAPI

包已经解开，直接手动装，

  • x64files\NPSWF.dll → System32\Macromed\Flash\
  • x32files\NPSWF.dll + FlashPlayerPlugin.exe + flashplayer.xpt → SysWOW64\Macromed\Flash\
  • 注册表，Macromedia\FlashPlayerPlugin 和 MozillaPlugins\@adobe.com/FlashPlayer（含 Wow6432Node 32 位视图），Version = 32.0.0.465、PlayerPath、XPTPath

提权跑一遍脚本，验证通过。

七、最终状态

项目状态
ActiveXFlash.ocx 32/64 + 注册表 32.0.0.465
NPAPINPSWF.dll 32/64 + FlashPlayerPlugin 注册表
PPAPIpepflashplayer.dll 32/64 + 注册表 32.0.0.465
hostsflash.cn 已屏蔽，原有条目全部保留
settings.sol0 字节（sys\ 与 #local\）
mms.cfgAutoUpdateDisable=1、DisableAnalytics=1
备份A:\work_zone\Temp\FlashFix_backup_20260826

经验

  • 中国特供版续命软件的原罪，版本号比官方高、弹窗、更新检查全都自己说了算。能用官方版就不用代理版。（代理商全家活暗暗了）
  • 安装器”完成”不等于装上。文件落没落地、注册表有没有键，才是真相。
  • SFX 自解压包可以解包看源码。7z 直接解 exe。py7zr 遇到 BCJ2 就换 p7zip（msys2 一个 pacman 搞定）。
  • 改 hosts 只补不盖。先备份，注意末尾换行。
  • settings.sol 清空是合法的，但同目录的 #SharedObjects 是游戏存档，删了就是进度清零。

尾声

Flash 酱安静下来了。版本 32.0.0.465，官方最终版，不再有”版本过旧”的问候，也不再有闪退的告别。

玩你的臭游戏去吧。（什么狗公主，粉红兔子，羔羊，lostlife，才没有听说过呢，笑）

]]> https://twilightrain.com/2026/08/26/flash-cn-special-edition-fix/ 2026-08-26T04:30:00.000Z flash.cn 最新特供版的版本过旧弹窗和闪退，UAC静默之谜。 Flash的中国？！特供！？版。 2026-08-26T05:06:32.651Z TwilightRain

你所生活的世界，不过是cmd.exe的一场梦。
—— 某位戴着红领巾的Lain（不是）

那一天，人类终于回想起了，被C:\Windows\system32支配的恐惧。

说人话，最近 Windows Terminal 酱抽风了。无论从开始菜单、资源管理器地址栏敲 wt，还是在终端里敲 wt，新窗口一律落在 C:\Windows\system32。这一定，是世界的意志吧！（并不是）
让Claude帮忙排查，过程比想象中曲折，中间还翻了一次车，差点被它写的脚本卡到干不了活，气晕233。

一，偽物是 settings.json 里的 %CD%

第一嫌疑就潜伏在settings.json的深处。

1
"defaults": { "startingDirectory": "%__CD__%" }

文件修改时间是当天 22:05，和「终端开始暴走」对得上。

%__CD__% 是 cmd.exe 的动态伪变量，展开结果是”当前目录加反斜杠”。
这类伪变量只活在 cmd 自己的展开逻辑里，不是真实环境变量。
Windows Terminal酱试图从自己的进程环境块（Process Environment Block）中读取这个变量，理所当然地，就会有。

失败

NUL！！！

解析失败就回退，回退目标的先知之地是 C:\Windows\System32，所以无论从哪个入口打开，都落在 system32，wt酱的蜜汁宽容呢（笑）。

最迷惑人的一步出现在验证环节。

我在PowerShell里执行 echo $env:__CD__，居然能打出当前目录，看起来这变量是真的。
「什么嘛，这不是有吗——！」
我兴奋地把cmd、bash、python、甚至node.js都拉出来测了一圈。
注册表HKCU、HKLM，两个根键翻了个底朝天。
全部！！！查询失败。

真相只有一个

$env:__CD__ 属于 PowerShell 自己提供的伪动态值，环境块里根本没有这条。
网上流传的「用 %__CD__% 让WT跟随当前目录」的说法，八成是哪个萌新在PowerShell里试了一下，「哦！！！！有值！」然后就发帖了www。
信了你就输了。

删掉这行之后，落点变成 C:\Users\hxdn，不再回退 system32。system32的噩梦，第一阶段，解除了哟。

二，WT 1.24 根本不继承调用方目录

WT 1.24の掟～ 受け継がれぬディレクトリ

Claude说，「地址栏敲wt什么的，应该会继承当前目录吧？」

测了。错的。 （Claude酱尼在干神魔鸭！！！）

Windows Terminal 1.24.11911.0 的行为是。

  • 不设 startingDirectory 时，一律落在 %USERPROFILE%，从终端敲 wt 也一样，不会继承调用方的当前目录。
  • 地址栏也没救。wt.exe 是应用执行别名（App Execution Alias），从资源管理器启动时，当前目录在别名转发那一步就丢了。

Windows Terminal酱根本不知道你在哪个文件夹。
她只是一如既往地，回到初始の地。想就地打开，只能显式传目录：wt -d .。

就像你不能指望绫波丽对你笑一样。那是设定（什么？！）。

三，顺手修了 Win+X 的空”起始位置”

Win+X 菜单里 01 - Command Prompt.lnk 和 01a - Windows PowerShell.lnk 的”起始位置”，空っぽ（笑）。
从那里打开cmd或PowerShell会像被世界遗忘的孩子，孤独地落在system32。
我流着泪，把它们改成了 %HOMEDRIVE%%HOMEPATH%，和另外两个（02 和 02a）保持一致。

四，右键菜单查漏了注册表视图，白装了一个重复项

为了让资源管理器里「就地打开」可靠，先检查了右键菜单是否已装。
Claude检查时只看了 Directory\shell 这类 shell 动词。

  • 没有查 shellex\MenuHandler。
  • 没有查 ContextMenuHandlers
  • 没有查 WOW6432Node 32 位视图
  • 没有查 AppX 包清单

得出”未安装”的结论。（Claude酱尼又在干神魔鸭！！！）

「没装呢。」Claude酱微笑着装了自己的「Open in Windows Terminal here」。（你为什么要笑啊！！！）

结果右键菜单里出现了两个终端条目。Windows 10 22H2系统内置的「在终端中打开（T）」一直都在。
温柔地，安静地被Claude漏看了。（悲）最后我把加的三个注册表键全部删掉，保留系统项。

教训：查注册表菜单，要从动词、扩展处理器、32位视图到包清单全部过一遍。
漏一个，就是命运的岔路。（别TM中二了好吗！！）

五，双击 .cmd 的坑：脚本把窗口藏起来了

修双击 .cmd 文件的问题时，我写了VBS辅助脚本，sh.Run cmdline, 0, False
0这个数字，带着圣洁的「安静启动」光环，在我脑海中浮现。（我想掐死半个小时前的自己）
那是**？！SW_HIDE！？**。
0号窗口样式居然是完全隐藏启动进程的主窗口，我的大脑仿佛是离开了地面的猩猩。（离开了Claude酱的人类已经无法生活自理，确信）

双击 test.cmd。无反应。
任务管理器里，「Windows Terminal」进程却在后台，安静地小脑宕机。
屏幕空空如也。我当时急得像碇真嗣看到使徒从海面升起。（什么狗屁比喻233……）

查文档得到WScript.Shell.Run 第二个参数，0到11，每个数字都有明确含义。
0是隐藏，1是显示。改成 1。 窗口出现了。 落地位置正确。 世界恢复色彩。

VBS是老了。（确信）

六，最终状态和经验

项目状态
双击 .cmd / .bat在文件所在目录打开，窗口保持
右键菜单只剩系统内置”在终端中打开（T）”
settings.json无 startingDirectory（%__CD__% 已删）
Win+X 01 / 01a起始位置 = %HOMEDRIVE%%HOMEPATH%

几条经验。

  • 伪变量不是环境变量。某个 shell 里”看起来有值”（$env:__CD__ 会骗人），不等于进程环境里有。
  • Windows 的当前目录继承有三道坑。应用执行别名丢目录、UAC 提权重置目录、Explorer 家族启动回退 %USERPROFILE%。
  • 排查时留意文件修改时间，settings.json 的 22:05 直接指向”最近改动”。
  • 一次改一处，备份先行，改错了立刻还原。
  • 人卡住的时候，先给一条立刻能用的命令，再慢慢修。
]]> https://twilightrain.com/2026/08/25/wt-startdir-debug/ 2026-08-25T14:45:00.000Z %CD%这个伪神欺骗了所有人，我查遍注册表视图，然后用VBS脚本把窗口送进了虚数之海。 Windows Terminal酱的暴走！打开目录的连环物语。 2026-08-26T05:06:32.651Z TwilightRain 本文是 ink 写作能力的验收样文，并附带模板层能力（分享、相关文章、双链等）。

文内双链示例：[[关于我]]。

提示块（admonitions）

用 :::admon[类型] 包裹内容即可生成彩色提示块，类型有五种，各自有独立的颜色与图标：

Note

高亮读者需要留意的信息，即使只是扫读也该看到。

Tip

可选信息，帮助读者更顺利地使用。

Important

读者成功所需的关键信息。

Warning

需要立即注意的潜在风险内容。

Caution

某个操作可能带来的负面后果。

标题可以自定义：

提示块的标题可以自定义

默认标题显示类型名（Note / Tip 等），用 :::admon[类型 标题] 可以覆盖。块内支持完整的 Markdown：加粗、行内代码、列表与代码块。

Mermaid 图表

graph TD    A[写文章] --> B{用了新语法?}    B -->|是| C[渲染为图表]    B -->|否| D[普通代码块高亮]    C --> E[发布到 main 分支]    D --> E
sequenceDiagram    participant 作者    participant 博客    作者->>博客: 提交 Markdown    博客->>博客: 构建与发布    博客-->>读者: 渲染 HTML

阅读时间、公式与目录

文章页显示「约 N 字 · 阅读约 M 分钟」（构建期计算）。行内公式 $E=mc^2$，块级公式：

$$\int_0^1 x^2 , dx = \frac{1}{3}$$

长文自动生成目录卡（与头图并排）；标题 hover 显示 # 锚点。

通用链接卡片

关于本站twilightrain.com
个人介绍与站点说明

GitHub 仓库卡片

TwilightRainDev/TwilightRain
本博客源码仓库
hexojs/hexo
Hexo 博客框架

标签页 tabs

在 Markdown 里用 :::tabs 与 --- 标题 分隔子页。

点击按钮切换面板，默认激活第一个。

文内照片墙

图一图二图三

隐藏与折叠（推荐 :::fold）

悬停或点击查看剧透

这是 :::fold[text] 行内揭示块，适合短剧透或答案。

展开详细说明

:::fold[details] 是统一的块级折叠容器，支持 Markdown 与列表。

文内时间线（Butterfly 批一）

写作特性演进
Reimu 批一

段落锚点、懒加载、代码折叠、文章时效

Butterfly 批一

timeline / btn·label

Butterfly 批二

B 站嵌入

Butterfly 批三

站点卡、系列文

B 站懒嵌入（Butterfly 批二）

系列文目录

本篇 front matter 含 series: 写作特性验收，文内 ::series 会输出系列目录（当前仅一篇，作展示）。

代码块复制与超长折叠

下方为 45 行占位代码，应出现「展开全部」按钮且预览区可见正文开头（非空列对行号）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
// fold-demo line 01
// fold-demo line 02
// fold-demo line 03
// fold-demo line 04
// fold-demo line 05
// fold-demo line 06
// fold-demo line 07
// fold-demo line 08
// fold-demo line 09
// fold-demo line 10
// fold-demo line 11
// fold-demo line 12
// fold-demo line 13
// fold-demo line 14
// fold-demo line 15
// fold-demo line 16
// fold-demo line 17
// fold-demo line 18
// fold-demo line 19
// fold-demo line 20
// fold-demo line 21
// fold-demo line 22
// fold-demo line 23
// fold-demo line 24
// fold-demo line 25
// fold-demo line 26
// fold-demo line 27
// fold-demo line 28
// fold-demo line 29
// fold-demo line 30
// fold-demo line 31
// fold-demo line 32
// fold-demo line 33
// fold-demo line 34
// fold-demo line 35
// fold-demo line 36
// fold-demo line 37
// fold-demo line 38
// fold-demo line 39
// fold-demo line 40
// fold-demo line 41
// fold-demo line 42
// fold-demo line 43
// fold-demo line 44
// fold-demo line 45

模板层能力（无需正文语法）

  • 分享：版权声明下方微博 / QQ / X 链接（post.ejs）
  • 相关文章：文末按标签交集推荐（本篇标签「博客」「写作」）
  • 双链：文首与文末「链接到 / 反向链接」区块
Important

验收通过标准：上述块级语法均渲染为对应 DOM 类名；交互类（hide、tabs、代码折叠、B 站占位）可无控制台错误地响应点击/滚动。

]]> https://twilightrain.com/2026/08/17/blog-writing-features/ 2026-08-17T02:00:00.000Z 本验收文含提示块、Mermaid、链接卡片及大量语法模板功能。 博客写作全部特性验收 2026-08-26T05:06:32.651Z TwilightRain 我把《提问的智慧》改成了 2026 年的样子。

千禧年那会儿，Eric S. Raymond和Rick Moen这俩老哥写了篇东西，叫提问的智慧，最后一次动笔是2014年，那阵子大伙还在IRC里“/me 拍了拍你”，能让人爽一整天。中文圈靠D.H.Grand几位老翻译抬了一手，ryanhanwu那个仓库的版本流传最广，跟祖传秘方似的。
但它的时代背景停在”Google 是你的朋友”。2026年的提问现场是 Discord，GitHub Discussions，还有一道当年不存在的前置关卡，AI。
道理到今天依然管用。你问得多蠢，决定你被喷得多惨。社区不歧视无知，只过滤不带脑子来的。
我把它改写了一版，基于那些早期译本续命 2026年。

TwilightRainDev/HowToAskQue
仓库叫HowToAskQue

改写原则是，骨架不动，血肉换新。

最大的改动，AI 成了第一道关

原版的提问前置流程是，搜索，搜论坛，读手册，读 FAQ，做实验，问朋友，读源码。新版在这曹植七步诗之前加了一步，先把问题完整扔给 AI。

DeepSeek，ChatGPT，Claude这三尊大佛，秒级识别低级问题跟喝汤一样。拼写错误啊，环境变量没配啊，版本不兼容啊，缩进比狗啃的还难看啊，AI都秒了，你就不用去社区社死。

Important

千万别找豆包！经典梗图：医生，你的诊断结果怎么跟豆包说的不一样啊？

如果 AI 给的答案没用，就把它给过的回复附在你的提问里。这等于向人类回答者交投名状，不是像个哈巴狗空手来要。

删掉了能气死人的话

原版里有一段搁现在看，血压直接拉满。有人问”我的 Windows 电脑有问题怎么办”，答案是”扔掉微软的垃圾”。

这话在现在属于嘉豪

嘉豪：一种标新立异以取得关注的人。

新版把它改掉了。2026 年的开发者用 Windows加WSL2再正常不过，赛博缝合怪都缝出艺术感了。
问题要分两类。

  • WSL2 内核，Docker 挂载卷这类开源工具链的问题，带日志去社区。
  • 公司 AD 域控，组策略，VPN 的问题，找自己公司的 IT。
    社区没权限也没义务帮你绕过企业安全策略，别把开源社区当你们公司的外包运维。

新形态的旧问题

原版警告过的”我的程序没用了怎么办”这种小脑缺失的信息残缺式提问逐渐销声匿迹，然而有了新形态，跟隔壁宝可梦差不多，居然还进化了（开智了？并没有）。
有人甩一个几百 MB 的 zip 说”帮我看看”。新版明确写了，代码片段加Dockerfile的组合远比压缩包受欢迎，你甩个压缩包，谁闲得慌帮你解压？
剪裁最小复现用例用 git bisect，别手工逐行注释。手工注释到凌晨，眼睛比熊猫还黑，结果发现是空格问题，这种蠢事咱都干过，别干了。

XY 问题值得单独拎出来吊着打。它是技术社区最常见也最隐蔽的陷阱。
这就好比你肚子饿（X），你自己脑补“我得把冰箱拆了才能拿到吃的”（Y），然后问“冰箱门螺丝拧不动怎么办”（Y）。回答者教你拧螺丝拧到天荒地老（Y），最后你说“其实我就想拿个馒头”（X），对面直接脑溢血。
规避方法只有一句话，先说最终目标，再说你打算怎么做，卡在哪，把路径选择权交给社区。

骨架和嘴臭都没动

核心速查表，描述问题的六个要点，RTFM 和 STFW 的解读，低声下气和傲慢都不能代替功课，解决后补收尾说明。这些 2001 年就成立的东西，2026 年一字不用改。语气也留了。原版最值钱的是它的直率，新版没有把它软化成亲，这边建议您友好提问哦或者你们太过分了，他们还只是个孩子。

RTFM 和 STFW 分别是什么？
  • RTFM：你的问题在手册/文档里有答案，先去看。
  • STFW：你的问题在网上随便一搜就有答案，先去搜。

新版还保留了”如何更好地回答问题”一节。提问指南的另一半其实是写给回答者的.

  • 态度和善一点，你不欠对方，但也没必要往死里踩。
  • 对初犯者私下提醒，公开处刑是最后手段。
  • 不确定就说“据我推测”，别装大尾巴狼。

社区的知识质量靠所有参与者共同维护，批评一个提问者的时候，你也在维护这个社区。

引用前先读免责声明

如果你维护的开源项目想引用这份指南，欢迎，但请按 README 的要求注明，本指南不提供该项目的实际技术支持。

这条免责声明不是矫情。过往经验表明，真的会有人以为你发布了指南，就等于承诺解答所有问题。

到那时候，回一句找搜索引擎去，别在这找事，那个人反手把你挂小红书。冤不冤？冤。但咱先把免责声明糊脸上，总比事后扯皮强。

呐，改完了。 要我说，你拿出去发，保证有人回你一句“www笑死”，然后默默收藏。

]]> https://twilightrain.com/2026/08/13/how-to-ask-questions/ 2026-08-13T08:00:00.000Z AI 成了提问前置的第一道关卡，回答前先证明你做过预筛选。 我把《提问的智慧》改成了 2026 年的人话 2026-08-26T05:06:32.651Z TwilightRain 把踩过的坑编译成技能

我在 Windows 上用 Claude Code 干活，环境有点特殊，H 盘是 exFAT，路径里有中文，终端默认 GBK，脚本用 PowerShell 写，核心逻辑扔给 Python 跑。这四个条件凑齐，乱码就是日常，不是事故。

最早几次我还认真排查，编码声明写没写？管道是不是在作怪？后来学乖了，每踩一个坑就把结论写成一条规则，攒多了变成一个技能（skill），让 Claude Code 在需要的时候自己读。

TwilightRainDev/claude-skills
这个仓库就是攒下来的东西

EncodingGuide，一条铁律，七个陷阱

EncodingGuide 全名”Windows PowerShell 中文编码安全基线”，内容是纯实战。它只有一条铁律。

绝对不要把含中文的内容通过管道传给 python -c，也不要用 heredoc 传。

PowerShell 的管道会自己解析 Unicode 和转义符，中文变 ??、脚本崩溃、JSON 乱码，根源都在这一条。技能围绕它列了七个致命陷阱，挑几个说说。

Out-File -Encoding UTF8 会往文件头写 BOM（EF BB BF）。TOML 解析器不认这个，直接报 Invalid statement (at line 1, column 1)。所以写 pyproject.toml 得用 [System.IO.File]::WriteAllText 配 UTF8Encoding($false) 写出无 BOM 文件。

json.dump 忘写 ensure_ascii=False，整个文件变成 \uXXXX 地狱。indent=2 和末尾换行也别省，git diff 会感谢你。

-Path 会做通配符展开，文件名里的 [1] 会被吃掉。要用 -LiteralPath。

这些规则单独看都不高深，值钱的是它们被写成清单，AI 写脚本时逐条对照，而不是临场发挥。

技能最后一节我尤其喜欢，叫”检查文件内容与元数据时的误判陷阱”。它来自一次真实误判，我用 head -6 SKILL.md | grep description 检查技能描述字段，输出看起来是空的，差点判定文件损坏。其实 YAML 的 | 是多行块标量指示符，正文在后面的缩进行里，head 把它截掉了。这个教训和技能主题同构，在 Windows 环境里，直觉方法的输出不可轻信，下结论前先怀疑读取方法本身。说”文件坏了”之前，至少用两种独立方式交叉验证。

CreatePrompts，先问清楚，再原样转录

CreatePrompts 是另一个画风。它不是排坑清单，是流程设计，两阶段，刨根问底，然后生成。

阶段一，苏格拉底式澄清。AI 扮演需求架构师，只提问，不给答案，不评价。六个维度，核心目标、受众、场景、流程、约束、成功标准。规则很硬，每轮一个问题，不超过三十个字。只问开放式问题。不猜测。用户说”没想过”就标记 [未指定]，绝不用自己的知识补空白。

阶段二，刚性转录。角色整个翻过来，AI 变成编译器，把确认过的需求快照机械翻译成提示词模板。缺失字段必须写 [未指定]。不许出现”建议””可以”这类词。不修饰用户的措辞。输出每句话都要能追溯到快照。

为什么把角色切得这么死？因为我发现同一个模型，澄清阶段共情越到位，生成阶段就越喜欢顺手把没说清的地方补上，补的往往是它自己的猜测而不是你的需求。两阶段的意义就是，先问清楚，再原样转录，中间不让模型发挥。

技能和笔记的区别

这两个技能都不大。但技能和笔记的区别在于，笔记要自己翻，技能在合适的时机自己跳出来。踩坑攒成技能，下次 AI 动手之前先被提醒，比事后再查文档省事得多。

仓库是MIT 许可，目录拷进 ~/.claude/skills/ 就能用。后续踩到新坑会继续往里加。

]]> https://twilightrain.com/2026/08/13/claude-skills/ 2026-08-13T07:00:00.000Z 在特殊环境下，踩坑总结规则，建成技能仓库。 把踩过的坑编译成技能 2026-08-26T05:06:32.651Z TwilightRain 如果我想成为时间管理大师

$$ \tau = \int_{t_1}^{t_2} \sqrt{1 - \frac{v(t)^2}{c^2}} , dt $$

我想成为Timegame高手，把一天过出两倍效果，但说实话，咱连自己每天在手机上耗了多少时间都说不清楚。于是咱决定给自己写个应用，让它替咱盯着。反正自己写的东西，总比那些“屏幕使用时间”里的黑盒数据可信吧？说干就干。没想到，两天后它居然真能跑了。应用本身挺糙的，没啥可炫耀的。但就做它的这两天，咱的收获比这几年翻过的所有鸡汤叠起来都大。

先交代动机，其实很简单。咱总觉得最近好像刷手机有点多，但有点多是几小时？三小时？五小时？咱没概念。没概念就没法管。咱写了 TimeTrack，每15分钟采样一次系统事件流，算亮屏时长，算每个应用占多少，画成 GitHub 提交记录那种绿格子热力图，一年365天铺开。

两天，22 个任务，92 个单测全绿，装到我的 iQOO 上实测。Token 成本折下来大概 23 块人民币，比买高效能人士的七个习惯还便宜二分之一。这波血赚。

TwilightRainDev/TwilightRainTimeTrack
咱的计数器

数据给咱的第一记耳光

应用跑起来后的第一批数字就教育了我。昨天我手机亮了 10.7 个小时。近七天咱在小说应用上花了 881 分钟，排第一。我以为自己是偶尔看看，数据说，不是，你是天天看。

更离谱的是7月30号那天的格子显示我亮屏54小时。一天只有24小时，咱难道掌握了时间折叠技术？

我居然这么？！强强！？

查了半天的结论是，vivo 系统自己的日聚合把时长算了两遍，我的应用忠实复制了系统数据，于是连错误一起复制了过来。修法倒简单，超过 24 小时的天直接标”无效”，画成蓝灰格子白叉，不进统计。

手机系统自己算自己都能算岔，人脑那点我感觉这周没怎么玩，可信度能高到哪去？咱感觉这周没怎么玩手机这句话，可信度跟 54 小时差不多。时间管理的第一步，压根不是什么番茄钟，而是先让数字和你的感觉当面对质。番茄钟是第二步的事。

记录可以不完美，但不能不知道哪里不完美

后台服务毕竟不是神。有时候它被系统杀掉，有时候它自己睡着了。咱不可能每15分钟都手动记一笔。我的做法是给每个格子标近似，当天第一条样本晚于 00:05，或者最后一条早于 23:55，或者中间断过 45 分钟以上，这个格子的数字就带个小角标，告诉你，这块是估的。

然后拿系统自带的屏幕使用时间当基准做验收。回填出来的历史日，偏差 1.8%，很满意。有缺口的当天偏差 23%，看着吓人，但缺口补上之后偏差立刻降到2.3%，不错。

关键是，我心里清楚哪儿不准。全是精确数的假账，还不如一本明明白白写着大概二字的真账呢。

计划和环境是两回事

咱的应用碰到了一个硬茬，OriginOS。国产ROM杀后台那是刻进基因里的本能，咱用尽了手段，前台服务常驻，每15分钟采样，Shizuku提权，把白名单灌满，JobScheduler定时兜底。能上的全上了。

结果深夜它还是输了。进程没被杀，但被系统冻住了17.4个小时。整个应用活着，但跟死了没区别，连系统调度器都不给它醒来的机会。没想到，解冻的时机竟是咱第二天碰了手机。

唯一的安慰是数据一条没丢。系统的事件流一直在记，打开应用的瞬间能全部补回来，跟系统口径的偏差仅有0.6%。

打断肯定会来，日程肯定会被打乱。与其琢磨怎么防着不被干扰，不如想想断了之后怎么续上。我的办法就是留底。把做到哪儿了，什么状态都随手记下来，能几乎零成本地捡起来接着干。

知道什么时候停

TimeTrack 的停止记录是真停。取消后台任务，撤掉白名单，杀进程，保证它不会半夜自己复活。README 里写明白，你不想记了，它就是停的。

一个记录时间的应用，把停做成硬功能，听着矛盾，其实是一回事。不然，用户会觉得它是流氓软件，咱也一样。881 分钟看小说那一周，咱没什么负罪感，数据只是告诉我，你在干什么。真要说问题，是那两天开发期间，咱手机上使用时长排第一的应用叫 TimeTrack 自己。用刷手机的方式戒刷手机，属实是行为艺术。咱也没办法啊。

咱还做了个噪音过滤，切到前台 5 秒以内又退出的，算误触，不计入，阈值能在设置里拉滑条调。较真到把误触都算进去，是另一种时间浪费。

两天 22 个任务，靠的不是自律

计划的文档写了上千行。每个任务写清楚要建哪些文件，接口长什么样，单测断言什么，真机验收怎么验。做完一个提交一次，然后一个评审代理专门挑错，通不过就返工。中间翻过两次车，编辑器重启杀掉了一个正在干活的代理，靠台账恢复。另一个代理把后面三个任务的活提前干了，编译炸了。靠 git 还原，再逐任务收口，救回来了。每次翻车都有记录可查，所以每次都不致命。

纯逻辑的部分全部测试先行。先挖一个注定失败的坑，再写填坑让它通过的代码。跨午夜的会话怎么按天拆分，锁屏期间算不算亮屏，这类边界全是用例钉死的。

咱自律水平真的一般。两天能做完，靠的是流程拯救了意志力，每个环节都有验收标准，做完没做完不以感觉为准，以绿不绿为准。

这笔账算下来也值。整个项目实际消耗约 4 亿 token，折人民币 23 块。两天加 23 块，换一个数据不出手机的时间记录工具，恐怕某些会员上百的软件已经急哭了。做一件小事的成本已经低到这种程度。哼，剩下的借口才不是因为不想做呢。

如果现在有人问咱怎么成为时间管理大师，咱的建议是先装个计数器。剩下的都是工程问题。咱的计数器数据全在本地，连联网权限都没申请。

]]> https://twilightrain.com/2026/08/13/time-management-master/ 2026-08-13T03:40:00.000Z 为了搞清每天到底刷多少时间手机，两天写出 TimeTrack。 如果我想成为时间管理大师 2026-08-26T05:06:32.651Z TwilightRain 带上她的眼睛

咳咳，众所粥知。刘慈欣这个老不死的电工（手动狗头），写了个短篇，叫带上她的眼睛。里面那妹子飞船怼进地心，黑得伸手不见五指，得靠别人戴传感眼镜替她看草原。

咱寻思，咱养在本地这台破电脑里的Claude Code，不也一个德性？

她没沉在地心，就住在咱C盘角落里瑟瑟发抖，底层套的是DeepSeek。咱给她换了中转，原因很朴素，国内直连Anthropic卡成PPT，还天天封号，谁能遭得住呐。DeepSeek便宜，文本能力没什么好抱怨的，一百万上下文，写代码查资料，稳如老狗。但她看不见，就一睁眼瞎。我甩截图，设计稿，报错弹窗，她只会乖乖回一句：“图我没收到。”（脑补无口萝莉脸好趴）

所以遇到要看图的时候，咱就得充当她的眼睛，截图转文字，一句一句描述喂给她。一次两次还挺浪漫，多了就觉得咱像给盲人指路的傻叉（狗头）。她明明就在这台电脑里，凭什么看一张本地的 jpg 还要咱人肉中转？咱受不了了，给她装了github的me9rez/llm-vision-mcp。自己动手，丰衣足食。

me9rez/llm-vision-mcp
Github链接
Important

得装node依赖！有依赖洁癖的尽快邪灵退散，否则我一个一个退治了！（红白认真脸）

七种姿势

这玩意是一个 MCP 服务器，背后起node进程，得把node的依赖加上才成。它的本职是把图片转成文字描述，默认走阿里后端 ModelScope 的 Qwen-VL，免费额度每天 2000 次，对咱这种懒狗来说量大管饱。

它一口气挂了七个龙珠出来，

  • analyze_image，通用看图说话，啥都能唠
  • analyze_chart，专治各种折线柱状饼图，金融狗狂喜
  • extract_text，OCR，抠字眼比律师还准
  • code_from_screenshot，截图直接变前端代码，这个咱直接社保
  • describe_ui，描述界面长什么样，UI仔末日
  • diagnose_error，从报错截图里找线索，debug不用瞪眼
  • understand_diagram，理解流程图之类，脑内渲染终结者

听着挺唬人，其实没有魔法。Qwen-VL看图产的是文字，真正理解这些文字的，还是DeepSeek的傻白甜文本模型。视觉信号并没有直接灌进她的大脑，只是变成了文字，让她读得懂。就像给盲人姑娘摸盲文，只不过这次是AI念给AI听。

装上，第一张图就跪了

安装一行命令，

1
npm install -g @me9rez/llm-vision-mcp

然后往 ~/.claude.json 的 mcpServers 里加蜜汁酱料，最终形态是这样的，

1
2
3
4
5
6
"llm-vision-mcp": {
  "type": "stdio",
  "command": "cmd",
  "args": ["/c", "D:/nodejs/node.exe", "C:/Users/hxdn/AppData/Roaming/npm/node_modules/@me9rez/llm-vision-mcp/index.js", "mcp"],
  "env": { "API_KEY": "ms-xxxx" }
}

这里面两个坑，Win老狗都懂。一是 cmd /c 套 node.exe 绝对路径，绕开 npx 那破.cmd垫片。另一个是 npm exec 本地 bin 优先解析的玄学。折腾得我差点砸键盘，最后试出这个写法，我直接对着屏幕比了个中指（并没有）。

改完配置重启会话，MCP server启动时加载。咱敲了句 claude mcp list，看一眼，看到Connected那一刻，仿佛听见她说了句，欢迎回家，主人。

呐，咱自觉枪毙去了。（元首：七万个嫂夫人挨个Biu！）

然后第一张图就失败了。直接给咱返回 403 。

查了半天，原因荒唐得让咱想笑，ModelScope 要求关联的阿里云账号完成实名认证。没过实名，连免费接口都不给用。咱万万没想到，给 AI 配一双眼睛，还得先向阿里云证明“咱是个人，不是狗”。虽然我确实是条单身狗。
认证完再试，终于通了。拿系统自带的壁纸C:\Windows\Web\Wallpaper\Windows\img0.jpg 丢给 analyze_image，中文描述正常返回。那一刻，我差点泪目，蛇了。

还有个不算坑的小事，1×1的纯色小图，模型啥也没认出来，返回空内容。想了想也算合理，你给朋友看个像素点，朋友回你个白眼，不把你打一顿，说“我涩图呢？”都算好的了。嘛，礼尚往来。

现在她能看见咱发过去的东西了。报错截图，设计稿，别人转来的图表，咱直接扔过去，她就能说出个子丑寅卯，不用咱再对着屏幕口述半天。剩下的事情反而简单。哪天 DeepSeek 自己长出视觉模型，这双借来的眼睛就该退休了。在那之前，先戴着吧。

exFAT 的小插曲

装第三方东西之前，咱习惯把源码拉下来扫一眼，确认没藏奇奇怪怪的挖矿脚本。克隆到 H 盘，npm ci 一跑就死，25 分钟，最后报 ENOTEMPTY。咱愣了半天才反应过来 H 盘是 exFAT 格式，根本撑不起 node_modules 这种碎文件森林，跟往豆腐渣里插牙签似的。只好把依赖挪到 C 盘的 NTFS 上装，上游测试 70/70 全过，才敢正式接上。审计副本留在咱电脑里，咱想看随时能看，毕竟防人之心不可无。

]]> https://twilightrain.com/2026/08/13/with-her-eyes/ 2026-08-13T03:10:00.000Z Claude Code 底层套着 DeepSeek，看得见代码却看不见图。8 月 7 号给她装上 llm-vision-mcp，让她有了眼睛。 带上她的眼睛。 2026-08-26T05:06:32.651Z TwilightRain 有天突发奇想，能不能让AI直接给我写一首MIDI曲子？这个念头本身平平无奇，真正魔幻的是接下来一整个下午的连环事件。装技能，写歌，发现bug，给开源项目发issue，从网上下了一个老掉牙的MIDI文件，然后被那份陈年数据坑到怀疑人生。最后居然全都解决了，忍不住写下来纪念一下。

一，装技能，16次安装量的小众神作

需求很直接，AI帮我生成MIDI歌曲文件。我本地装了27个技能，没一个干这活的，于是去技能商店搜“midi”。

搜索结果挺热闹，但点开一看，全是挂羊头卖狗肉的。

  • midi-synth？那是把已有MIDI渲染成音频的，不是生成。
  • voice-note-to-midi？人声转MIDI，方向反了。
  • ElevenLabs，Suno？那些是API生成音频文件，跟MIDI不搭边。

真正对口的只有一个，tubone24/midi-agent-skill@midi-generation。安装量16，冷门中的冷门，但描述写的就是“用GM乐器和乐理生成MIDI文件”。工作方式是本地Python脚本加midiutil库生成.mid文件，免费，不用API。

按惯例先过一遍安全审查，SKILL.md内容干净，四个脚本通读一遍没啥恶意，requirements.txt里只有midiutil。装！

冒烟测试一次过，三轨多乐器的小样，228字节，跑起来了。

二，写ZUN歌，1分20秒

我G:\Downloads里躺着一份主旋律.txt，内容写的是「ZUN节」，车万里那段经典旋律。简谱长这样，-6 2 3 5 3 2循环三遍，再加个-7 1 -7 -5的尾巴。

第一版用的C大调，120BPM，大钢琴两轨（右手旋律，左手分解和弦），引子加主题四遍加尾声，总共40小节，正好80秒。拿mido库验证时长，80.0秒，完美。

然后我开始迭代，翻倍速度到240BPM，40秒播完，再把最后10秒剪到中间当bridge。就是从这一步开始，事情不对劲了。

三，踩坑，休止符被吞，旋律凭空短了10秒

变速重排之后验证音轨，发现旋律轨30秒就播完了，伴奏轨却还在响。最后10秒只有伴奏孤零零地撑着场面。

排查下来，是技能的一个隐蔽bug，它的Note对象只有pitch和duration两个字段，生成脚本里音符时间是靠time += duration累加出来的，它根本没有表达休止符的能力。AI作曲的时候跳过休止拍，所有音符就全往前挪了，休止拍被吞掉，旋律整体前移。

第一版其实就有这毛病，但那会儿我只验证了总时长，没细听。80秒的文件，旋律早就结束了，我只听了开头觉得还不错，愣是没发现，直到重排结构时才暴露出来。

解决办法很简单，给技能打了个本地补丁，Note增加一个可选字段time，用来指定绝对拍位置，向后兼容。修完重新生成，各轨终于对位了。

四，迭代，从两轨钢琴到六轨小乐队

第一版只是开始。接下来我折腾了好几轮，

变速加bridge重排。 想听快点，BPM 直接翻倍到 240，让80秒缩到40秒，又嫌结构平淡，再把最后10秒剪到中间当bridge，前20秒铺垫，中间10秒对比段，后面10秒接回主题，三段式结构有了，不过，也顺便埋了上一节那个大坑。

补终止。 剪完发现结尾停在D4上，悬在半空不落地。补了个G-C终止，G和弦分解上行，C琶音上滚，C5长音收尾，四秒搞定。

加音色。 纯钢琴太素了。我加了弦乐群铺和声长音，跟和弦走根音和五音，不抢旋律频段。又加了钢片琴在高八度点缀，只在bridge和终止段出现，带点空灵的味道。四轨了。

换军鼓，加bass。 钢片琴点缀完，总觉得还缺节奏层。换成军鼓，结果发现技能根本没有打击乐通道的概念，它的脚本会特意跳过GM标准的9号通道（打击乐专用）。于是第二次给技能打补丁，Note增加可选channel字段，指定通道就覆盖自动分配。顺手捡了个便宜，军鼓的MIDI音号是38，正好等于音名D2，填"D2"就行，不用改解析器。bass也补上了，根音跟和弦走，低音区撑住。

小号回归。 30秒处小号进，主旋律整体高八度再吹一遍，明亮的音色接回主题，跟钢片琴在终止段撞出一个八度齐奏的亮丽结尾。bass再往后压到20秒才进，让每个声部错峰登场。

最终定格在六轨，大钢琴旋律，大钢琴分解，弦乐pad，军鼓，bass，小号，44秒，240BPM。每一版我都用mido实测验证，时长，音符数，音轨位置全对得上才收工。诺，这里。

ZUN_Festival_Ensemble_Full.mid

五，发issue，冷门项目也有被认真对待的一天

修完顺手想，这个bug对原项目也是有用的，写个issue报上去吧。

按《提问的智慧》那套流程来，先查仓库有没有现成issue，其实没有，25颗星的小仓库很安静。然后套六要点模板，目标，环境，报错，已做功课，复现步骤，实际与预期。核心事实全是实测数据，160拍的曲子，旋律轨55.5秒结束，伴奏轨79.5秒。附上修复diff，标注了“未验证，可开PR”。

英文项目就写英文。发完。

六，老MIDI的复仇，2秒起，噪音炸了

issue发完，我转头想继续玩MIDI，从网上下了一份众神眷恋的幻想乡。202秒，3个音轨，931加882个音符。看文件头，GBK中文曲名，乐器名写着“Microsoft GS波表软件合成器”，千禧年代初的。给老资历跪了。

用mido一读，？！直接崩溃！？，data byte must be in range 0..127。

这可不是小问题。MIDI文件里出现了规范外的字节，严格解析器直接拒收。我用耳朵加PotPlayer试听，那噪音楼上张阿姨都听得见。

于是开始跟这份老文件斗智斗勇。先怀疑文件损坏，逐字节检查chunk边界，结构完好，三个音轨的长度字段和文件大小精确吻合。再怀疑音符数据损坏，我手动写了个容错解析器，音符流全干净。那到底在哪崩溃的？

答案藏在两个地方，

第一，track0有16个CC7音量消息，值全是0xFF（255）。 MIDI规范里CC值只允许0-127，255是非法的，严格解析器当场暴毙。微软波表播放器大概见多识广，默默钳位成127继续播。

第二，也是最精彩的，track2有19个CC64延音踏板消息，从1.74秒开始，值从85，86，87……一路递增到104，然后就没然后了，从头到尾没有释放。

延音踏板是开关量，半踏板最多也是固定值。85→104，每秒两三个地递增，这不是踏板，这是别的数据被错标成了踏板，大概率是音量或表情的渐变，被某个老工具映射到了CC64。

而我听到的“从2-3秒开始的大噪音”，正是从1.74秒踏板踩下开始的。track2的每一个音符都被无限延音，持续叠加，两秒之后就混成了一片，越积越浑浊。时间线严丝合缝。

修复倒简单，删掉那19个CC64，把CC7改成127，保存。严格模式读取通过，音符一个不少，时长一分不差。试播，Windows自带播放器，PotPlayer，全都正常了。

七，事后

一整天下来，其实只干了一件小事，让AI写了一首MIDI。但沿途捡到了这些，

  • 一个安装量16的冷门技能（实测能用）
  • 一个技能自身的静默bug（已修复，已发issue）
  • 一份2000年代老东西的病历（CC64数据污染加非法CC7）
  • 一个深刻教训，MIDI文件里最可怕的是控制器数据错。音符错了你听得出来，CC错了它会悄悄毁掉整首歌，还让严格解析器当场去世。

哦对，还有一版修复好的众神眷恋的幻想乡 touhou_fixed.mid 躺在下载目录里。有缘人拿去吧，老曲子的修复版，免费。

]]> https://twilightrain.com/2026/08/08/ai-midi-adventure/ 2026-08-08T14:00:00.000Z 途中被各种MIDI错误坑到怀疑人生，最后居然全解决了。 AI写歌，怒怼老资历MIDI 2026-08-26T05:06:32.650Z TwilightRain

三个智能体，各司其职，之间不允许对话，听起来像职场宫斗，但这确实是我最近在用的代码审查工作流。

如果你也经历过这种场景，让同一个 AI 既当找 bug 的、又当修 bug 的、还当审核的，最后它自己推翻自己，在同一个对话里反复横跳，那这篇文章可能对你有用。

背景：我为什么受不了了

有段时间我一直在和 AI 对话写代码，就是那种「我出想法、AI 写实现」的 Vibe Coding 模式。听起来挺高效的对吧？

但实际操作起来有个很烦的问题：

同一个 AI 对话窗口里，我说「帮我看一下这段代码有什么 bug」。它列了五条。然后我说「那你改一下吧」。它改了，但改完之后自己又把其中两条「我刚刚说的其实也没那么严重」给推翻了。我再追问一句，它又开始往回找补，最后整个对话变成了一场 AI 和自己的辩论赛。

左脑搏击右脑，毫无生产力。

这个问题不是偶然的。LLM 的本质是对话模型，它的回答天然倾向于调和矛盾、保持一致性、尽量不得罪用户。你让它检查 bug，它查了。你让它反过来质疑自己查到的 bug，它大概率会说「你说得对，这里可能确实没那么严重」。

这不是 AI 笨，这是它的天性，它被训练成以对话者为中心。

那怎么办？我的答案是：不给它对话的机会。

设计思路：流水线化与角色固化

我参考了制造业质量管理里的一个经典概念，质量门禁（Quality Gate）。在生产线上的每个关键节点设一道门，原材料进、成品出，中间单向流动，不允许逆流。

那么对于 AI 代码审查，我也设了三道门。三扇门后面站着三个 AI，每个有且只有一个角色，角色之间不对话、不辩论。

flowchart TD    A[原始代码] --> B[AI-1 档案员<br/>Archivist]    B --> C[事实锚点<br/>project_context.txt]    C --> D[AI-2 啄木鸟<br/>Woodpecker]    D --> E[审查报告<br/>audit_report_v1.md]    E --> F[AI-3 铁匠<br/>Blacksmith]    F --> G[最终方案<br/>final_action_plan.md]

每个角色只做一件事，做完就输出一份确定的文档，然后切断对话，把这份文档原封不动地喂给下一个角色。

我把这个方法叫做 三子智能体单向质量门禁法（Triple-AI One-Way Quality Gate）。

下面展开说这三个角色的分工。

第一阶段：AI-1 档案员

角色名字叫 Archivist，档案员。它的工作异常简单，什么也不分析，只收集事实。

输入是一堆源代码。

输出是一份叫 project_context.txt 的结构化文档，内容包括：目录树、项目元信息、配置文件全文、入口文件全文、核心源文件清单，以及一个上下文完整性声明。

它不做什么

  • 不评价代码质量
  • 不分析架构
  • 不提出任何建议
  • 不使用任何推测性词汇（「看起来」「似乎」「可能」「或许」「感觉」，全部禁止）

它做什么

全量扫描目录树，然后自动发现并读取以下几类文件：

  • 配置文件：package.json、tsconfig.json、Dockerfile、.env.example 等
  • 入口文件：从 package.json 的 main/bin/exports 字段定位，找不到就按惯例搜
  • 核心源文件：沿 import 链读取直接依赖的核心模块（不超过 3 层、10 个文件）

如果文件不存在，如实写「该文件不存在」。不解释原因，不脑补内容。

输出文档的最后一节是一张完整性声明表，坦承这个文件覆盖了项目多大比例、哪些类别的文件被收录、有没有已知的遗漏。遗漏处留空，由人工判断是否需要补充。

为什么要有这道工序

因为 AI 的「分析」经常建立在错误的事实基础上。它可能猜错了你的目录结构、记混了你的配置文件、或者编造了一个不存在的依赖。先让一个角色纯粹地确认事实，后续的分析才不会在沙上建塔。

输出之后，窗口 A 关闭。

第二阶段：AI-2 啄木鸟

角色叫 Woodpecker，啄木鸟。它是极端悲观主义者，只做减法，只找错。

输入是 project_context.txt + 核心代码片段。它不看原始项目目录，它只认档案员给的事实锚点。

审查维度

审查分为四个级别：

级别含义示例
Error未捕获异常、安全漏洞、版本不兼容src/api.ts L45 — 未对用户输入 name 做转义，直接拼入 SQL
Risk内存泄漏、硬编码密钥、圈复杂度 >10 的函数utils/handler.ts L120 — setInterval 未存储返回值，页面卸载时未清除
Redundancy未使用的依赖/变量、重复度超过3次的代码块、过时的 Polyfillpackage.json — lodash 仅使用了 _.get 方法，可改用可选链
上下文缺口AI-1 遗漏的关键文件（兜底补偿）src/middleware/auth.ts — 文件存在于目录树但未被 AI-1 收录，其 verifyToken 被多处路由引用

输出格式是一张严格的结构化表格，有级别、文件路径、行号、现象描述、建议修正动作。依然是无开场白、无废话、无模糊评价。

值得一提的是「上下文缺口」这个维度，啄木鸟在审查开始前，会基于目录树检查有没有「存在但未被收录」的关键文件。发现缺口不会阻塞审查，而是如实列出，由人工决定是否补喂。这是一个人机协作的兜底机制。

输出之后，窗口 B 关闭。

第三阶段：AI-3 铁匠

角色叫 Blacksmith，铁匠。它是极端实用主义者，不评价啄木鸟的智商，只拿着一份报告去对照真实代码，能做就做，做不了就改。

输入是 project_context.txt + audit_report_v1.md。

三条验证准则

准则含义处理方式
妥适性建议删除的代码是否真的未被别处引用？若被引用，直接删除该条目，不废话
准确性建议的行号是否精确？不精确则直接修正
可落地性建议是否受限于框架版本？重写该条目的修正动作，使其兼容当前环境

输出是 final_action_plan.md，格式和啄木鸟的报告完全一样。

语气约束（强制注入）

我给铁匠设了一段不可绕过的 System Prompt，重点只有一句话：

禁止展示思考过程、对比过程或发现错误的过程。只输出最终的修正结果。

这意味着铁匠看到「AI-2 说这里要删某行」，对照代码发现那行另有引用，它不会说「等等，这里不对，AI-2 你搞错了」，它只是静默地把那条条目从表格里删掉，直接输出修正后的表格。

矛盾处理遵循最小改动原则：如果两条建议冲突（比如一个建议删文件、另一个建议改该文件），保留改动最小的那条，删除改动大的那条。

完整工作流示意图

flowchart TD    A[原始项目代码] -->|AI-1 一次性探测扫描| B[AI-1 档案员<br/>Archivist<br/>只收集事实，不分析不判断]    B -->|只输出结构化事实陈述| C[project_context.txt<br/>事实锚点文件 含完整性声明]    C -->|操作者快速浏览| D{完整性声明确认}    D -->|发现遗漏| E[手动补充至文件]    E --> C    D -->|确认无误<br/>投喂 context + 核心代码片段| F[AI-2 啄木鸟<br/>Woodpecker<br/>只做减法：找错、删减、警告]    F -->|只输出结构化表格 含上下文缺口| G[audit_report_v1.md<br/>初版审查报告]    G -->|投喂 context + audit_report_v1.md| H[AI-3 铁匠<br/>Blacksmith<br/>验证、修正、落地]    H -->|只输出修正后表格| I[final_action_plan.md<br/>铁板钉钉的施工图纸]    I --> J[最终执行<br/>三方再无交流]

实际操作：如何避免左脑搏击右脑

一开始我用的是三个连续 Prompt 的写法，同一个对话窗口里依次让 AI 扮演档案员、啄木鸟、铁匠。效果有，但不够干净。

因为 AI 记得它上一轮扮演过档案员、写过哪些文件、发现了什么问题。到铁匠那一步，它天然地放水，「这条是我自己（作为啄木鸟时）写的，应该没问题吧」。

第一次迭代是：开三个独立的对话窗口。

窗口角色操作
窗口 A档案员执行完毕 → 提取 project_context.txt → 关闭窗口 A
窗口 B啄木鸟粘贴 project_context.txt 作为输入 → 输出报告 → 关闭窗口 B
窗口 C铁匠粘贴 project_context.txt + audit_report_v1.md 作为输入

关掉窗口意味着物理上切断记忆。新的窗口没有之前的上下文，AI 不知道啄木鸟是谁、档案员是谁、它自己上一轮说过什么。它只能对着当前的事实锚点和报告条目逐一验证。

这听起来有点笨拙，但实际用下来效果确实好。上下文隔离是阻止 AI 自我推翻最有效的手段，没有之一。

第二次迭代：在子智能体协作模式下，上下文隔离是内置设计，无需人工干预。三个智能体各自运行于独立的、无状态的会话中，彼此不共享任何历史记忆，每一次调用都如同首次见面。数据流由编排层自动驱动，每个智能体完成自己的输出后，其会话即被销毁，下一个智能体只能看到上游产出的文档，而无法感知之前的对话过程。

智能体角色操作
智能体 A档案员执行完毕，生成 project_context.txt，自动触发智能体 B
智能体 B啄木鸟读取 project_context.txt 作为输入，输出 audit_report_v1.md，自动触发智能体 C
智能体 C铁匠读取 project_context.txt + audit_report_v1.md 作为输入，输出最终方案

这套流程不再需要人工开三个窗口、手动关闭。智能体之间的衔接由流水线调度器完成，每个智能体以无状态函数的方式被调用，上下文天然隔离。而在子智能体协作模式里，它不再是笨拙的权宜之计，而是架构层面的原生特性。

用了几次之后的感受

目前这个工作流我主要用在项目代码审查和大型重构的预检阶段。说几个实际体感：

档案员是最容易被低估的角色。 很多人觉得「扫描目录+读文件」没什么技术含量，直接让 AI 一步到位审查不就行了。但事实是，缺少这一步，啄木鸟的分析经常建立在对代码结构一知半解的基础上。有了事实锚点，后面两阶段的产出质量明显更稳定。

上下文缺口这个兜底机制有用。 档案员扫描目录时，可能因为文件过多或者规则限制，漏掉了某些关键文件。啄木鸟从目录树里发现这些缺口并列出，至少让人知道自己「不知道什么」，这比盲审要好得多。

铁匠的角色定位是关键创新。 大多数代码审查工具只做「检查→报告」两步。加入一个「验证→修正」的第三阶段，并且强制这个阶段不输出解释、只输出结果，有效地过滤掉了 AI 自己的错觉和过度报告。

总结

三子智能体单向质量门禁法的核心就三点：

  1. 角色固化，每个 AI 只做一件事，不跨界
  2. 单向数据流，上游输出就是下游输入，没有反馈回路，禁止对话
  3. 上下文隔离，物理上切断记忆窗口，让 AI 无法自我推翻

如果你也在用 AI 做代码审查，不妨试试这个模式。不一定需要三个角色完全照搬，但「把它拆成独立步骤，每一步只做一件事，切掉对话回路」这个思路，应该是通用的。

方法总比解法多。尤其是在和 AI 协作这件事上，我觉得与其抱怨 AI 不靠谱，不如想想怎么设计流程，让它不靠谱的部分够不到终点线。

]]> https://twilightrain.com/2026/07/30/triple-ai-quality-gate/ 2026-07-30T06:00:00.000Z Vibe Coding 质量由找，审核与修 bug的 AI 各司其职保证。 三AI单向门禁的流水线 2026-08-26T05:06:32.651Z TwilightRain

集行合并，文件拼接，中文截断修复，标点替换于一体

写代码的人大概都经历过这样的时刻：手头有一批文本文件需要处理，合并短行，拼接文件，修复莫名其妙被截断的中文，批量替换标点符号。需求本身不复杂，但每次都要翻出零散的批处理脚本，PowerShell 命令，或者临时写一段 C# 控制台程序，用完就扔，下次再从头来过。

这些碎片化的处理方式困扰了我很久。于是我把它们攒到了一起，做成了一个 Windows 桌面工具，TwilightRainTextTool。

TwilightRainDev/TwilightRainTextTool
项目地址

为什么会有这个工具

最开始，我维护着四五个功能重叠的批处理/PowerShell 脚本，散落在不同项目的角落里。每次要用的时候，得先回忆”那个处理中文截断的脚本放在哪个文件夹了”，再手动改参数，拖文件，等执行。更麻烦的是，这些脚本的输入输出格式还不统一，有的原地修改，有的生成新文件，有的需要手动指定编码。

需求是固定的，但每次处理的成本却是重复的。与其每次都写一次胶水代码，不如做一个统一的 GUI 工具，把常用的文本处理能力集成进去，点点鼠标就能完成。

它能做什么

工具目前提供了四个核心功能，分别对应四个标签页。

1. 行合并

这是最常用的功能。把一堆短行按阈值合并成有意义的段落，比如把被意外拆散的文本重新拼接起来。支持按字节数或字符数两种模式合并，阈值范围 1 到 1000，可以灵活调整。

合并之后还有三道后处理工序：

  • 修复中文截断：如果当前行以中文字符结尾，自动合并下一行（Hello\nWorld → HelloWorld）
  • 修复标点截断：如果当前行以自定义标点结尾，自动合并下一行（回家吧，\n孩子 → 回家吧，孩子）
  • 行尾不合并：如果当前行以特定标点（如句号，感叹号，章节标题标记）结尾，则阻止合并，保持独立

整个处理是单次文件写入的流水线：读文件 → 阈值合并 → 中文修复 → 标点截断修复 → 标点替换 → 写输出。

2. 文件拼接

把一个目录下匹配通配符模式的所有文件按名称排序后合并成一个文件。每个文件会单独检测编码，统一以 UTF-8 with BOM 格式输出。

3. 标点替换

自由配置查找-替换规则（比如把连续的句号 。。 替换成单个 。），支持规则的增删改和排序。规则以 JSON 格式持久化到 replace_rules.json，重启程序后自动加载。

4. 关于页面

显示版本，作者信息和 GitHub 链接，并提供了语言切换功能，简体中文，繁體中文，English 三语实时切换，偏好自动保存。

一些设计上的考量

在开发这个工具时，我给自己定了几条原则：

安全第一。所有处理结果都保存为 *_Processed.* 格式的新文件，绝不覆盖原始文件。误操作了？原始文件还在，随时可以重来。

编码自动检测。文本处理最头疼的问题就是编码。工具会优先检测 BOM，其次尝试 UTF-8 验证，最后 fallback 到 GBK。大多数常见的中文文本文件都能自动识别，不需要用户手动选择编码。

批量处理。支持一次拖拽多个文件，全部处理完毕。不用一个一个等。

拖拽即用。直接把 .txt 文件拖到窗口上就能开始处理。操作路径尽可能短。

国际化。内置了三种语言，并根据系统 UI 语言自动匹配。虽然是个小工具，但多语言支持从第一天就做了。

技术实现

工具基于 .NET 7 WinForms 开发。架构上做了比较清晰的分层：

  • Controls/：四个标签页的 UI 控件，从主窗体独立出来，保持 MainForm 只有约 165 行
  • Services/：核心业务逻辑，编码检测，行合并算法，文件拼接，标点替换，处理流水线编排
  • Localization/：三语 JSON 资源文件 + 运行时切换逻辑
  • TextTool.Tests/：63 个单元测试，覆盖各个服务类

整个项目遵循了比较规整的项目结构，也写了架构文档（ARCHITECTURE.md）和架构决策记录（adr/），方便后续维护和他人理解。

写在最后

TwilightRainTextTool 不是一个宏大的项目，它解决的是我日常工作中真实遇到的小问题。但正是这些小工具，积少成多，最终能节省下可观的时间。

如果你也有类似的文本处理需求，欢迎下载试用。项目开源在 GitHub 上，Issue 和 PR 都随时欢迎。

]]> https://twilightrain.com/2026/07/25/windows-text-tool-intro/ 2026-07-25T05:00:00.000Z 把散落四处的文本处理脚本，统一成图形化工具箱。 用Win文本工具箱告别散装脚本 2026-08-26T05:06:32.651Z TwilightRain 从发现仿冒到逆向取证，再到提交网警报案，这是我完整的维权实录。

前几天，我在搜索”蓝河工具箱”的时候，发现了一个仿冒网站。

www.lanhegongjuxiang.com

名字起得挺像那么回事，”蓝河工具箱官网”。页面风格也刻意模仿正规工具类软件的调性，口号是什么”免费手机系统优化”、”全局插帧直驱供”……

要不是我一直在用正版App，差点就信了。

下载下来的东西，不对劲

我在这个网站下载了一个APK，文件名是 lhgjx.apk。

一对比就发现问题了，正版”蓝河工具箱 6.11.apk”只有 4.7 MB，而仿冒版有 35 MB。

35 MB 的工具箱？这得塞了多少东西进去？

直觉告诉我，这事没那么简单。

解包对比：一个工具箱，一个漫画阅读器

我虽然不是开发者，但平时也懂一点反编译工具，把两个APK都拆开看了看，结果一目了然。

对比项正版仿冒版
包名com.bluestudiocjd.appcom.bly.dkplat
技术栈原生 Android (Kotlin)Flutter
应用类型手机工具箱漫画阅读器
大小4.7 MB35 MB
原生库libadb.so、libintegrity.solibflutter.so、多个广告SDK

说白了，这个仿冒版和”工具箱”半毛钱关系都没有。它就是一个披着”蓝河工具箱”名字的 Flutter 漫画 App。

里面的 list.json 暴露了一切：

  • 精选：《这个神兽有点萌之通天嗜宠》
  • 更新：《展示魅力时刻》
  • 新作：《我的同学》
  • 人气：《恶魔在哪里》
  • 恋爱：《苏三起界》
  • 热血：《妖娆妻》

这是工具箱？这分明是漫画阅读器。

关键问题：它抄了正版代码吗？

我沿着证据往下查，搜索了仿冒版全部 3 个 DEX 文件（共约 16 MB 代码）：

  • 搜索 bluestudiocjd（正版开发者标识）：正版命中 100+ 处，仿冒版 0 处
  • 搜索”蓝河”/lanhe：正版有引用，仿冒版 0 处
  • 搜索 ADB、无线调试等功能关键词：正版有，仿冒版 0 处

结论很明确：这个仿冒 App 没有使用任何正版源代码。它只是盗用了”蓝河工具箱”的品牌名称和视觉标识。

这不是开源协议违规，因为根本没有”衍生”，它完全是另一个东西。

这是商标侵权加不正当竞争。

真正可怕的事情，在后面

既然代码上没有抄袭，那这个 35 MB 的”漫画阅读器”里，到底装了什么？

我继续深挖，结果让人头皮发麻。

一、它要了 28 个敏感权限

一个漫画阅读器，要这些权限干什么？

权限级别具体权限
恶意级INSTALL_PACKAGES（静默安装）、REQUEST_INSTALL_PACKAGES（绕过商店安装）、MANAGE_EXTERNAL_STORAGE（全盘读写）、SYSTEM_ALERT_WINDOW（悬浮窗）
追踪级ACCESS_FINE_LOCATION（精确定位）、CAMERA（摄像头）、RECORD_AUDIO（录音）、READ_PHONE_STATE（IMEI）、GET_ACCOUNTS（账户信息）
高风险READ_CONTACTS、READ_CALL_LOG、WRITE_CALL_LOG、READ_SMS……

二、疑似 Joker 家族恶意软件

Joker 是臭名昭著的 Android 木马家族，专门干这种事：

  • 自动订阅扣费：拦截短信验证码，后台订阅付费服务，从话费扣款
  • 动态加载恶意代码：使用 DexClassLoader 运行时加载恶意 payload，逃避静态检测
  • 隐藏图标：FLAG_HINT_HIDE_ICON、setHintHideIcon 相关代码
  • 拦截或转发短信：SMS 拦截相关代码

我在代码里找到了这些特征的实锤：

恶意行为证据数量
订阅扣费5 处
隐藏图标3 处
自动安装2 处
读取验证码1 处
动态加载 DEX5 处

三、极端隐私窃取

代码中引用的数据采集点数量（反编译统计）：

数据类型引用次数
IMEI 获取36 处
MAC 地址249 处
位置 / GPS392 处
OAID / 广告 ID100 处
设备指纹199 处
已安装 App 列表22 处
账户信息7 处
联系人 / 通话记录5 处

这些数据一旦外传，可以精确识别每一个用户，你是谁、在哪、用什么手机、装了什么软件、通讯录里都有谁。

四、堆了 4 家广告 SDK

  • 穿山甲（Pangle）
  • 友盟（Umeng）
  • Sigmob
  • 广点通（GDT）

一个漫画 App 塞 4 家广告 SDK，目的只有一个：广告欺诈，伪造设备指纹、刷广告点击、骗广告主预算。

我给它的定性

这不是开源协议问题，也不是简单的商标侵权。

这是一款披着”工具箱”外衣的 Joker 家族恶意软件，通过仿冒网站公开传播：

  1. 盗用品牌名称和视觉标识，诱导用户下载
  2. 索要远超正常需求的 28 项敏感权限
  3. 具备静默安装、动态加载、短信拦截等恶意能力
  4. 采集 IMEI、位置、联系人、通话记录等隐私数据
  5. 堆叠 4 家广告 SDK，疑似广告欺诈
  6. 符合 Joker 自动订阅木马的行为特征

这已经触犯 《刑法》第 285 条和第 286 条，提供专门用于侵入、非法控制计算机信息系统的程序、工具罪。

我已经提交网报警报了

项目内容
举报编号J2026072510234300239
举报类型计算机破坏 / 传播病毒
违法网站https://www.lanhegongjuxiang.com
仿冒 APK 哈希22b22eba760c3232c97e77009726501d0c7092370e1b06b2aaa867aa1a07df7d
状态待人工核查

举报描述中，我把品牌混淆到用户误信下载，再到逆向分析取证，最后到恶意代码定性的完整证据链都提交了。

给你的提醒

如果你也在用”蓝河工具箱”或者类似的工具类软件，请注意：

  1. 认准官方渠道：不要从搜索引擎随便点开一个”官网”就下载
  2. 安装时仔细看权限：一个工具箱要你的通讯录、短信、通话记录？直接拒绝
  3. 对比 APK 大小：4.7 MB 变成 35 MB，一定有鬼
  4. 这个仿冒网站的”工具箱”实际上是一个漫画阅读器加木马

我已经走了报案流程。如果你也下载过这个 APK，建议：

  • 立即卸载 lhgjx.apk 及任何来自 lanhegongjuxiang.com 的软件
  • 修改重要账号密码，尤其是短信验证码可能已被拦截的情况下
  • 向同一平台举报，增加这个仿冒网站的下架压力

最后

我本来只是想查一下这个仿冒网站到底怎么回事，结果挖出了这么个东西。

从”有人盗用正版名字”到”有人在分发病毒”，这个跨度，我自己都没预料到。

网络安全无小事。如果你身边有朋友在用”蓝河工具箱”，把这篇转给他看看。别让恶意软件披着正经工具的外衣，躺进他的手机。

后续进展我会持续跟进。有新的消息再跟大家同步。

]]> https://twilightrain.com/2026/07/25/fake-toolbox-malware-investigation/ 2026-07-25T03:00:00.000Z 这是从发现仿冒站，确认Joker病毒到报案的全过程维权实录。 举报仿冒网站，实为病毒 2026-08-26T05:06:32.651Z TwilightRain

以下为 BiliCompact 用户脚本 v2.6.0 的完整源码，MIT 协议，可自由使用、修改、分发。
安装方法：复制到 Tampermonkey / Violentmonkey 新建脚本中保存即可。
从动机、设计、技术三个维度完整回顾这个非侵入式的 B 站首页精简用户脚本项目。

TwilightRainDev/TwilightRainBiliCompact
BiliCompact 官方仓库：完整源码、版本发布与 issue 追踪

项目地址：GreasyFork - BiliCompact

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
// ==UserScript==
// @name         网页端B站主页精简~ BiliCompact
// @namespace    http://tampermonkey.net/
// @version      2.6.0
// @license MIT
// @description  你是否厌倦了B站网页端极多视频？想要更简要的界面？这个插件将帮助你只显示指定数量的视频，支持多种页面、黑/白名单、配置持久化。非侵入式设计，不在B站页面注入任何UI元素。支持简中，繁中，英语。
// @author       TwilightRain
// @match        https://www.bilibili.com/
// @match        https://www.bilibili.com/?*
// @match        https://www.bilibili.com/index/*
// @match        https://www.bilibili.com/v/popular/*
// @match        https://www.bilibili.com/v/*/*
// @match        https://www.bilibili.com/video/*
// @match        https://www.bilibili.com/dynamic*
// @match        https://www.bilibili.com/search*
// @match        https://www.bilibili.com/anime/*
// @match        https://www.bilibili.com/guochuang/*
// @match        https://www.bilibili.com/music/*
// @match        https://www.bilibili.com/dance/*
// @match        https://www.bilibili.com/game/*
// @match        https://www.bilibili.com/technology/*
// @match        https://www.bilibili.com/life/*
// @match        https://www.bilibili.com/food/*
// @match        https://www.bilibili.com/car/*
// @match        https://www.bilibili.com/animal/*
// @match        https://www.bilibili.com/kichiku/*
// @match        https://www.bilibili.com/fashion/*
// @match        https://www.bilibili.com/ent/*
// @match        https://www.bilibili.com/cinephile/*
// @match        https://www.bilibili.com/popular/*
// @run-at       document-end
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_registerMenuCommand
// @grant        GM_addStyle
// @grant        GM_log
// @icon         https://www.bilibili.com/favicon.ico
// @downloadURL https://update.greasyfork.org/scripts/585777/%E7%BD%91%E9%A1%B5%E7%AB%AFB%E7%AB%99%E4%B8%BB%E9%A1%B5%E7%B2%BE%E7%AE%80~%20BiliCompact.user.js
// @updateURL https://update.greasyfork.org/scripts/585777/%E7%BD%91%E9%A1%B5%E7%AB%AFB%E7%AB%99%E4%B8%BB%E9%A1%B5%E7%B2%BE%E7%AE%80~%20BiliCompact.meta.js
// ==/UserScript==

(function() {
    'use strict';

    // ======================== 国际化 (i18n) ========================
    const I18N = {
        zh_CN: {
            // Log
            LogPrefix: '[B站精简]',
            LogSelectorData: '通过data属性探测到选择器:',
            LogSelectorFound: '探测到选择器:',
            LogSelectorFallback: '通过链接回退探测到选择器:',
            LogNoCards: '未找到视频卡片，跳过',
            LogStillNoCards: '仍未找到视频卡片',
            LogProcessed: '已处理: 总视频 {0}, 显示 {1}, 隐藏 {2}',
            LogErrorLimit: 'limitVideos 出错:',
            LogContainerFound: '探测到容器:',
            LogConfigLoaded: '配置加载完成:',
            LogStatus: '精简状态: {0}',
            LogStatusOn: '已开启',
            LogStatusOff: '已关闭',
            LogQuickSet: '已设置最大数量:',
            LogTimerRetry: '定时器检测到可见视频过多，重新执行限制',
            LogInitDone: '脚本初始化完成，当前配置:',
            LogInitError: '初始化失败:',
            LogObserverStarted: 'MutationObserver 已启动，监听容器:',
            LogUrlChanged: 'URL变化:',

            // Menu
            MenuSettings: 'B站精简设置',
            MenuRefresh: '手动刷新精简',
            MenuToggle: '切换精简状态',
            MenuQuickSet: '快速设数量',
            MenuCommentPurifier: '切换评论净化',

            // Panel
            PanelTitle: 'B站精简设置',
            PanelStatusLabel: '当前状态',
            PanelStatusActive: '精简中',
            PanelStatusPaused: '已暂停',
            PanelMaxVideos: '最大显示数量',
            PanelExcludeLive: '排除直播',
            PanelExcludeAd: '排除广告',
            PanelExcludeBangumi: '排除番剧',
            PanelExcludePaid: '排除付费课程',
            PanelKeepPromoted: '保留推广位',
            PanelKeepUpids: '保留UP主ID（逗号分隔）',
            PanelDebug: '调试模式',
            PanelEnableCommentPurifier: '启用评论净化（删除@提及，隐藏短评论）',
            PanelLanguage: '界面语言 / Language',
            PanelLanguageAuto: '自动 (Auto)',
            PanelBtnPause: '暂停精简',
            PanelBtnResume: '启用精简',
            PanelBtnReset: '恢复默认',
            PanelBtnSave: '保存并应用',
            PanelBtnClose: '关闭',
            PanelColorMode: '颜色模式',
            PanelColorAuto: '跟随系统',
            PanelColorDark: '深色',
            PanelColorLight: '浅色',

            // Prompt
            PromptQuickSet: '输入最大显示视频数量（1-100）：',
        },
        zh_TW: {
            // Log
            LogPrefix: '[B站精簡]',
            LogSelectorData: '透過data屬性探測到選擇器:',
            LogSelectorFound: '探測到選擇器:',
            LogSelectorFallback: '透過連結回退探測到選擇器:',
            LogNoCards: '未找到影片卡片，跳過',
            LogStillNoCards: '仍未找到影片卡片',
            LogProcessed: '已處理: 總影片 {0}, 顯示 {1}, 隱藏 {2}',
            LogErrorLimit: 'limitVideos 出錯:',
            LogContainerFound: '探測到容器:',
            LogConfigLoaded: '設定載入完成:',
            LogStatus: '精簡狀態: {0}',
            LogStatusOn: '已開啟',
            LogStatusOff: '已關閉',
            LogQuickSet: '已設定最大數量:',
            LogTimerRetry: '定時器偵測到可見影片過多，重新執行限制',
            LogInitDone: '指令碼初始化完成（非侵入式），目前設定:',
            LogInitError: '初始化失敗:',
            LogObserverStarted: 'MutationObserver 已啟動，監聽容器:',
            LogUrlChanged: 'URL變化:',

            // Menu
            MenuSettings: 'B站精簡設定',
            MenuRefresh: '手動重新整理精簡',
            MenuToggle: '切換精簡狀態',
            MenuQuickSet: '快速設數量',
            MenuCommentPurifier: '切換評論淨化',

            // Panel
            PanelTitle: 'B站精簡設定',
            PanelStatusLabel: '目前狀態',
            PanelStatusActive: '精簡中',
            PanelStatusPaused: '已暫停',
            PanelMaxVideos: '最大顯示數量',
            PanelExcludeLive: '排除直播',
            PanelExcludeAd: '排除廣告',
            PanelExcludeBangumi: '排除番劇',
            PanelExcludePaid: '排除付費課程',
            PanelKeepPromoted: '保留推廣位',
            PanelKeepUpids: '保留UP主ID（逗號分隔）',
            PanelDebug: '除錯模式',
            PanelEnableCommentPurifier: '啟用評論淨化（刪除@提及，隱藏短評論）',
            PanelLanguage: '介面語言 / Language',
            PanelLanguageAuto: '自動 (Auto)',
            PanelBtnPause: '暫停精簡',
            PanelBtnResume: '啟用精簡',
            PanelBtnReset: '回復預設',
            PanelBtnSave: '儲存並套用',
            PanelBtnClose: '關閉',
            PanelColorMode: '顏色模式',
            PanelColorAuto: '跟隨系統',
            PanelColorDark: '深色',
            PanelColorLight: '淺色',

            // Prompt
            PromptQuickSet: '輸入最大顯示影片數量（1-100）：',
        },
        en_US: {
            // Log
            LogPrefix: '[BiliCompact]',
            LogSelectorData: 'Selector detected via data attribute:',
            LogSelectorFound: 'Selector detected:',
            LogSelectorFallback: 'Selector detected via link fallback:',
            LogNoCards: 'No video cards found, skipping',
            LogStillNoCards: 'Still no video cards found',
            LogProcessed: 'Processed: total {0}, shown {1}, hidden {2}',
            LogErrorLimit: 'limitVideos error:',
            LogContainerFound: 'Container detected:',
            LogConfigLoaded: 'Config loaded:',
            LogStatus: 'Compact status: {0}',
            LogStatusOn: 'Enabled',
            LogStatusOff: 'Disabled',
            LogQuickSet: 'Max videos set to:',
            LogTimerRetry: 'Timer detected too many visible videos, re-running limit',
            LogInitDone: 'BiliCompact initialized (non-invasive), config:',
            LogInitError: 'Initialization failed:',
            LogObserverStarted: 'MutationObserver started, watching container:',
            LogUrlChanged: 'URL changed:',

            // Menu
            MenuSettings: 'BiliCompact Settings',
            MenuRefresh: 'Refresh Compact',
            MenuToggle: 'Toggle Compact',
            MenuQuickSet: 'Quick Set Count',
            MenuCommentPurifier: 'Toggle Comment Purifier',

            // Panel
            PanelTitle: 'BiliCompact Settings',
            PanelStatusLabel: 'Status',
            PanelStatusActive: 'Active',
            PanelStatusPaused: 'Paused',
            PanelMaxVideos: 'Max videos',
            PanelExcludeLive: 'Exclude live streams',
            PanelExcludeAd: 'Exclude ads',
            PanelExcludeBangumi: 'Exclude bangumi',
            PanelExcludePaid: 'Exclude paid courses',
            PanelKeepPromoted: 'Keep promoted items',
            PanelKeepUpids: 'Whitelist UP IDs (comma-separated)',
            PanelDebug: 'Debug mode',
            PanelEnableCommentPurifier: 'Enable comment purifier (remove @mentions, hide short comments)',
            PanelLanguage: 'Language / 語言',
            PanelLanguageAuto: 'Auto',
            PanelBtnPause: 'Pause',
            PanelBtnResume: 'Resume',
            PanelBtnReset: 'Reset Defaults',
            PanelBtnSave: 'Save &amp; Apply',
            PanelBtnClose: 'Close',
            PanelColorMode: 'Color Mode',
            PanelColorAuto: 'Auto (System)',
            PanelColorDark: 'Dark',
            PanelColorLight: 'Light',

            // Prompt
            PromptQuickSet: 'Enter max videos to show (1-100):',
        }
    };

    // 当前生效的语言
    let CurrentLang = 'zh_CN';

    function ResolveLanguage() {
        if (Config.Language &amp;&amp; Config.Language !== 'auto') {
            return Config.Language;
        }
        const Nav = (navigator.language || '').toLowerCase();
        if (/^zh-(tw|hk|mo)$/i.test(Nav) || /^zh-(hant)$/i.test(Nav)) return 'zh_TW';
        if (/^zh/i.test(Nav)) return 'zh_CN';
        if (/^en/i.test(Nav)) return 'en_US';
        return 'zh_CN'; // fallback
    }

    function T(Key, ...Args) {
        const Map = I18N[CurrentLang] || I18N['zh_CN'];
        let Str = Map[Key];
        if (Str === undefined) {
            // Fallback to zh_CN if key missing in current locale
            Str = I18N['zh_CN'][Key];
        }
        if (Str === undefined) return Key; // ultimate fallback: show the key itself
        // Replace placeholders {0}, {1}, {2}...
        for (let I = 0; I &lt; Args.length; I++) {
            Str = Str.replace('{' + I + '}', Args[I]);
        }
        return Str;
    }

    // ======================== 配置（默认值，会从GM存储读取） ========================
    const DEFAULTS = {
        MaxVideos: 10,                 // 最大显示数量
        ExcludeLive: true,             // 排除直播
        ExcludeAd: true,              // 排除广告
        ExcludeBangumi: true,         // 排除番剧
        ExcludePaid: true,            // 排除付费课程
        KeepSpecialUPIDs: [],         // 保留的UP主ID列表（数字）
        KeepPromoted: false,          // 保留推广位（不计入数量）
        Language: 'auto',             // 界面语言: auto | zh_CN | zh_TW | en_US
        Debug: false,                 // 调试模式
        EnableCommentPurifier: false, // 评论净化器 (删除@提及，隐藏短评论)
        RemovedElements: {},          // 元素去除: { presetId: true/false }
        ColorMode: 'auto',            // 颜色模式: auto | dark | light
    };

    // ======================== 状态 ========================
    let Config = {};
    let IsActive = true;               // 是否启用精简（切换开关）
    let EffectiveSelector = null;      // 缓存的有效选择器
    let VideoListContainer = null;     // 缓存的列表容器
    let Observer = null;
    let DebounceTimer = null;
    let PurifierStarted = false;         // 评论净化器是否已启动
    let PurifierObservers = [];          // 评论净化器的 MutationObserver 列表
    let LastRun = 0;
    const THROTTLE_INTERVAL = 200;     // 节流间隔（ms）

    // ======================== 工具函数 ========================
    function Log(...Args) {
        if (Config.Debug) console.log(T('LogPrefix'), ...Args);
    }

    function ErrorLog(...Args) {
        console.error(T('LogPrefix'), ...Args);
    }

    // 安全获取存储
    function GetConfig() {
        const Cfg = {};
        for (const [Key, Def] of Object.entries(DEFAULTS)) {
            try {
                const Val = GM_getValue(Key, Def);
                Cfg[Key] = Val;
            } catch (E) {
                Cfg[Key] = Def;
            }
        }
        return Cfg;
    }

    function SaveConfig(Cfg) {
        for (const [Key, Val] of Object.entries(Cfg)) {
            try {
                GM_setValue(Key, Val);
            } catch (E) {}
        }
    }

    // ======================== 评论净化器 (Comment Purifier) ========================

    /**
     * 检查页面中是否存在 BilibiliBlocker 的标记
     * Blocker 会在 bili-comment-user-info 的 shadowRoot 中插入 button[gz_type]
     * 一次同步检测，不做任何等待；没装就是没装，直接跳过协调。
     */
    function purifierHasBlockerInstalled() {
        try {
            const comments = document.querySelector('bili-comments');
            if (!comments?.shadowRoot) return false;
            const threads = comments.shadowRoot.querySelectorAll('bili-comment-thread-renderer');
            if (threads.length === 0) return false;
            return Array.from(threads).some(thread =&gt; {
                const comment = thread.shadowRoot?.getElementById('comment');
                if (!comment?.shadowRoot) return false;
                const userInfo = comment.shadowRoot.querySelector('bili-comment-user-info');
                if (!userInfo?.shadowRoot) return false;
                const info = userInfo.shadowRoot.getElementById('info');
                return !!info?.querySelector('button[gz_type]');
            });
        } catch { return false; }
    }

    /**
     * 从 bili-comment-renderer 内部获取 #contents 容器
     * 穿透 2 层 Shadow DOM: bili-comment-renderer -&gt; bili-rich-text
     */
    function purifierGetContentsEl(renderer) {
        try {
            const richText = renderer.shadowRoot.querySelector('bili-rich-text');
            if (richText &amp;&amp; richText.shadowRoot) {
                return richText.shadowRoot.getElementById('contents');
            }
        } catch (_) {}
        return null;
    }

    /**
     * 查找页面上所有 &lt;bili-comment-renderer&gt;
     * 从 &lt;bili-comments&gt; 开始穿透 Shadow DOM
     */
    function purifierFindRenderers() {
        const list = [];
        try {
            const comments = document.querySelector('bili-comments');
            if (comments &amp;&amp; comments.shadowRoot) {
                const threads = comments.shadowRoot.querySelectorAll('bili-comment-thread-renderer');
                for (const thread of threads) {
                    if (thread.shadowRoot) {
                        thread.shadowRoot.querySelectorAll('bili-comment-renderer').forEach(r =&gt; list.push(r));
                    }
                }
            }
        } catch (_) {}
        return list;
    }

    /**
     * 处理单条评论：
     *   a. 删除所有 @提及 &lt;a data-type="mention"&gt;
     *   b. 清理后有效字符 &lt; 5 -&gt; 隐藏整条评论
     */
    function purifierProcessRenderer(renderer) {
        const doneKey = 'bcPurified';
        if (renderer.dataset[doneKey]) return;
        renderer.dataset[doneKey] = '1';

        const contents = purifierGetContentsEl(renderer);
        if (!contents) return;

        // 删除所有 @提及标签
        const mentions = contents.querySelectorAll('a[data-type="mention"]');
        for (const m of mentions) {
            m.remove();
        }

        // 计算剩余有效字符
        const remaining = contents.textContent.replace(/\s+/g, '').trim();

        // 不足5字 -&gt; 隐藏整条评论
        if (remaining.length &lt; 5) {
            renderer.style.display = 'none';
            try {
                const threadRenderer = renderer.getRootNode().host;
                if (threadRenderer) threadRenderer.style.display = 'none';
            } catch (_) {}
        }
    }

    /**
     * 启动评论净化器
     * - 监听评论区动态加载，自动处理新增评论
     * - 首次扫描零延迟；检测到 Blocker 只在日志中标记，不影响流程
     */
    function startCommentPurifier() {
        if (!Config.EnableCommentPurifier) return;
        if (PurifierStarted) return;
        PurifierStarted = true;

        let scanTimer = null;

        function scheduleScan() {
            if (scanTimer) clearTimeout(scanTimer);
            scanTimer = setTimeout(() =&gt; {
                purifierFindRenderers().forEach(purifierProcessRenderer);
                scanTimer = null;
            }, 800);
        }

        // MutationObserver 监听 bili-comments 的 shadowRoot
        try {
            const comments = document.querySelector('bili-comments');
            if (comments?.shadowRoot) {
                const obs = new MutationObserver(() =&gt; scheduleScan());
                obs.observe(comments.shadowRoot, { childList: true, subtree: true });
                PurifierObservers.push(obs);
            }
        } catch (_) {}

        // MutationObserver 监听 document.body（兜底）
        const obsBody = new MutationObserver(() =&gt; scheduleScan());
        obsBody.observe(document.body, { childList: true, subtree: true });
        PurifierObservers.push(obsBody);

        // 首次扫描——不等待、不轮询，直接执行
        purifierFindRenderers().forEach(purifierProcessRenderer);

        const hasBlocker = purifierHasBlockerInstalled();
        Log('评论净化器已启动' + (hasBlocker ? '（检测到 BilibiliBlocker，兼容模式）' : ''));
    }

    /**
     * 停止评论净化器
     * - 断开所有 MutationObserver
     * - 已处理的评论保持状态不变
     */
    function stopCommentPurifier() {
        PurifierStarted = false;
        for (const obs of PurifierObservers) {
            try { obs.disconnect(); } catch (_) {}
        }
        PurifierObservers = [];
        Log('评论净化器已停止');
    }

    /**
     * 切换评论净化器（供 TM 菜单命令调用）
     * 同时保存配置变更
     */
    function toggleCommentPurifier() {
        Config.EnableCommentPurifier = !Config.EnableCommentPurifier;
        SaveConfig({ EnableCommentPurifier: Config.EnableCommentPurifier });
        if (Config.EnableCommentPurifier) {
            startCommentPurifier();
        } else {
            stopCommentPurifier();
        }
    }

    // ======================== 元素去除 (Element Removal) ========================

    /**
     * 可去除的元素预设列表
     * 每条包含：唯一 id、适用域名 host、显示名称 name、CSS选择器列表 selectors（多版本兼容）
     */
    const ELEMENT_REMOVAL_PRESETS = [
        {
            id: 'carousel',
            host: 'www.bilibili.com',
            name: '首页轮播图',
            selectors: [
                '#i_cecream &gt; div.bili-feed4:last-child &gt; main.bili-feed4-layout:nth-child(3) &gt; div.feed2:last-child &gt; div.recommended-container_floor-aside &gt; div.container.is-version8:first-child &gt; div.recommended-swipe.grid-anchor:first-child &gt; div.recommended-swipe-core &gt; div.recommended-swipe-body:last-child &gt; div.carousel-area &gt; div.carousel',
                '#app &gt; div.bili-feed4:last-child &gt; main.bili-feed4-layout:nth-child(2) &gt; div.feed2:last-child &gt; div.recommended-container_floor-aside &gt; div.container.is-version8:first-child &gt; div.recommended-swipe:first-child',
                '#app &gt; div.bili-feed4:last-child &gt; main.bili-feed4-layout:nth-child(3) &gt; div.feed2:last-child &gt; div.recommended-container_floor-aside &gt; div.container.is-version8:first-child &gt; div.recommended-swipe:first-child'
            ]
        },
        {
            id: 'right-channel',
            host: 'www.bilibili.com',
            name: '右侧频道导航',
            selectors: [
                '#i_cecream &gt; div.bili-feed4:last-child &gt; div.bili-header.large-header:first-child &gt; div.bili-header__channel:nth-child(3) &gt; div.right-channel-container:last-child',
                '#app &gt; div.bili-feed4:last-child &gt; div.bili-header.large-header:first-child &gt; div.bili-header__channel:last-child &gt; div.right-channel-container:last-child'
            ]
        },
        {
            id: 'channel-icons',
            host: 'www.bilibili.com',
            name: '频道图标行',
            selectors: [
                '#i_cecream &gt; div.bili-feed4:last-child &gt; div.bili-header.large-header:first-child &gt; div.bili-header__channel:nth-child(3) &gt; div.channel-icons:first-child',
                '#app &gt; div.bili-feed4:last-child &gt; div.bili-header.large-header:first-child &gt; div.bili-header__channel:last-child &gt; div.channel-icons:first-child'
            ]
        },
        {
            id: 'channel-bar',
            host: 'www.bilibili.com',
            name: '频道栏（整体）',
            selectors: [
                '#app &gt; div.bili-feed4:last-child &gt; div.bili-header.large-header:first-child &gt; div.bili-header__channel:last-child'
            ]
        },
        {
            id: 'creation-entry',
            host: 'www.bilibili.com',
            name: '创作中心入口',
            selectors: [
                '#i_cecream &gt; div.bili-feed4:last-child &gt; div.bili-header.large-header:first-child &gt; div.bili-header__bar:first-child &gt; ul.left-entry:first-child &gt; li.v-popover-wrap.left-loc-entry:nth-child(8) &gt; div'
            ]
        },
        {
            id: 'upload-entry',
            host: 'www.bilibili.com',
            name: '投稿入口',
            selectors: [
                '#i_cecream &gt; div.bili-feed4:last-child &gt; div.bili-header.large-header:first-child &gt; div.bili-header__bar:first-child &gt; ul.left-entry:first-child &gt; li.v-popover-wrap.left-loc-entry:nth-child(9) &gt; div &gt; a.loc-entry.loc-moveclip'
            ]
        },
        {
            id: 'live-entry',
            host: 'www.bilibili.com',
            name: '直播入口',
            selectors: [
                '#i_cecream &gt; div.bili-feed4:last-child &gt; div.bili-header.large-header:first-child &gt; div.bili-header__bar:first-child &gt; ul.left-entry:first-child &gt; li.v-popover-wrap:last-child'
            ]
        },
        {
            id: 'dynamic-entry',
            host: 'www.bilibili.com',
            name: '动态入口',
            selectors: [
                '#i_cecream &gt; div.bili-feed4:last-child &gt; div.bili-header.large-header:first-child &gt; div.bili-header__bar:first-child &gt; ul.left-entry:first-child &gt; li.v-popover-wrap:nth-child(5)'
            ]
        },
        {
            id: 'vip-entry',
            host: 'www.bilibili.com',
            name: '大会员VIP',
            selectors: [
                '#i_cecream &gt; div.bili-feed4:last-child &gt; div.bili-header.large-header:first-child &gt; div.bili-header__bar:first-child &gt; ul.right-entry:last-child &gt; div.vip-wrap:nth-child(2)'
            ]
        },
        {
            id: 'adblock-tips',
            host: 'www.bilibili.com',
            name: '广告提示条',
            selectors: [
                '#i_cecream &gt; div.adblock-tips:nth-child(2)'
            ]
        },
        {
            id: 'left-entries',
            host: 'www.bilibili.com',
            name: '左侧全部入口',
            selectors: [
                '#app &gt; div.bili-feed4:last-child &gt; div.bili-header.large-header:first-child &gt; div.bili-header__bar:first-child &gt; ul.left-entry:first-child'
            ]
        },
        {
            id: 'palette-btn',
            host: 'www.bilibili.com',
            name: '调色板浮窗',
            selectors: [
                '#app &gt; div.bili-feed4:last-child &gt; div.palette-button-outer.palette-feed4:nth-child(4)'
            ]
        },
        {
            id: 'space-notif',
            host: 'space.bilibili.com',
            name: '空间-消息通知',
            selectors: [
                '#biliMainHeader &gt; div.bili-header &gt; div.bili-header__bar.mini-header:first-child &gt; ul.left-entry:first-child &gt; li.v-popover-wrap:last-child'
            ]
        }
    ];

    let ElementRemovalStates = {};  // { presetId: { element, originalDisplay } }

    /**
     * 应用/恢复元素去除
     * 按配置隐藏勾选的元素，恢复取消勾选的元素
     */
    function applyElementRemoval() {
        const enabled = Config.RemovedElements || {};
        const host = location.hostname;

        // 先恢复已取消勾选的元素
        for (const id of Object.keys(ElementRemovalStates)) {
            if (!enabled[id]) {
                ElementRemovalStates[id].element.style.display = ElementRemovalStates[id].originalDisplay;
                delete ElementRemovalStates[id];
            }
        }

        // 再应用新勾选的元素
        for (const preset of ELEMENT_REMOVAL_PRESETS) {
            if (preset.host !== host) continue;
            if (!enabled[preset.id]) continue;
            if (ElementRemovalStates[preset.id]) continue; // 已隐藏

            for (const sel of preset.selectors) {
                try {
                    const el = document.querySelector(sel);
                    if (el) {
                        ElementRemovalStates[preset.id] = {
                            element: el,
                            originalDisplay: el.style.display || ''
                        };
                        el.style.display = 'none';
                        break; // 找到一个版本即隐藏，不再试其他
                    }
                } catch (_) {}
            }
        }
    }

    // ======================== 选择器探测与缓存 ========================
    function DetectSelector() {
        if (EffectiveSelector) return EffectiveSelector;

        // 第一梯队：具体选择器（优先使用，构建联合选择器）
        const SpecificCandidates = [
            '.bili-video-card',
            '.feed-card',
            '.bili-feed-card',
            '.floor-single-card',
            '.floor-card',
            '.video-item',
            '.feed-item'
        ];

        // 第二梯队：宽泛选择器（仅在具体选择器全部失败时使用）
        const BroadCandidates = [
            '[class*="video-card"]',
            '[class*="bili-video"]',
            '[class*="feed-card"]',
            '[class*="feed-item"]',
            '[class*="floor-card"]'
        ];

        // 收集所有能匹配到元素的具体选择器，构建联合选择器
        const MatchedSelectors = [];

        // 首先尝试通过 data 属性查找
        const DataCandidates = [
            '[data-video-id]',
            '[data-aid]'
        ];
        for (const Sel of DataCandidates) {
            const Els = document.querySelectorAll(Sel);
            if (Els.length &gt; 0) {
                for (const El of Els) {
                    const Card = El.closest('.bili-video-card, .feed-card, .bili-feed-card, .video-item, .feed-item, .floor-single-card, .floor-card, [class*="video-card"], [class*="feed-card"], [class*="feed-item"], [class*="floor-card"]');
                    if (Card) {
                        const CardSel = (Card.tagName === El.tagName) ? Sel :
                            Array.from(Card.classList).map(C =&gt; '.' + C).join('');
                        if (!MatchedSelectors.includes(CardSel)) {
                            MatchedSelectors.push(CardSel);
                        }
                    }
                }
            }
        }

        // 遍历具体候选选择器，收集所有匹配到的
        for (const Sel of SpecificCandidates) {
            try {
                const Els = document.querySelectorAll(Sel);
                if (Els.length &gt; 0) {
                    if (!MatchedSelectors.includes(Sel)) {
                        MatchedSelectors.push(Sel);
                    }
                }
            } catch (E) {
                // 跳过无效选择器
            }
        }

        if (MatchedSelectors.length &gt; 0) {
            EffectiveSelector = MatchedSelectors.join(', ');
            Log(T('LogSelectorFound'), EffectiveSelector);
            return EffectiveSelector;
        }

        // 具体选择器全部失败时，尝试宽泛选择器（仅取第一个匹配的）
        for (const Sel of BroadCandidates) {
            try {
                const Els = document.querySelectorAll(Sel);
                if (Els.length &gt; 0) {
                    EffectiveSelector = Sel;
                    Log(T('LogSelectorFound'), EffectiveSelector);
                    return EffectiveSelector;
                }
            } catch (E) {
                // 跳过无效选择器
            }
        }

        // 最后回退：查找包含 /video/, /bangumi/ 或 live.bilibili.com 链接的父级卡片
        const LinkSelectors = [
            'a[href*="/video/"]',
            'a[href*="/bangumi/"]',
            'a[href*="live.bilibili.com"]'
        ];
        for (const LinkSel of LinkSelectors) {
            const Links = document.querySelectorAll(LinkSel);
            for (const Link of Links) {
                let Parent = Link.parentElement;
                let Depth = 0;
                while (Parent &amp;&amp; Depth &lt; 5) {
                    const Cls = Parent.className || '';
                    if (Cls.includes('card') || Cls.includes('item') || Cls.includes('feed') || Cls.includes('video') || Cls.includes('floor')) {
                        EffectiveSelector = '.' + Cls.split(' ').join('.');
                        Log(T('LogSelectorFallback'), EffectiveSelector);
                        return EffectiveSelector;
                    }
                    Parent = Parent.parentElement;
                    Depth++;
                }
            }
        }

        return null;
    }

    // 获取视频列表容器（缩小观察范围）
    function DetectContainer() {
        if (VideoListContainer) return VideoListContainer;
        const Containers = [
            '.bili-feed4',
            '.bili-feed',
            '.feed2',
            '.feed-list',
            '.video-list',
            '.bili-video-list',
            '.recommend-container',
            '.recommended-container_floor-aside'
        ];
        for (const Sel of Containers) {
            const El = document.querySelector(Sel);
            if (El) {
                VideoListContainer = El;
                Log(T('LogContainerFound'), Sel);
                return El;
            }
        }
        VideoListContainer = document.body;
        return VideoListContainer;
    }

    // ======================== 卡片显示/隐藏辅助函数 ========================
    // 需要同时隐藏的祖先包装器类名（解决 B站 CSS Grid 单元格不塌陷问题）
    const WRAPPER_CLASSES = ['bili-feed-card', 'feed-card'];

    function ApplyHideStyles(El) {
        El.classList.add('BiliLimitedHide');
        El.style.display = 'none';
        El.style.visibility = 'hidden';
        El.style.opacity = '0';
        El.style.height = '0';
        El.style.margin = '0';
        El.style.padding = '0';
        El.style.overflow = 'hidden';
        El.style.flex = '0 0 0';
        El.style.position = 'absolute';
    }

    function ClearHideStyles(El) {
        El.classList.remove('BiliLimitedHide');
        El.style.display = '';
        El.style.visibility = '';
        El.style.opacity = '';
        El.style.height = '';
        El.style.margin = '';
        El.style.padding = '';
        El.style.overflow = '';
        El.style.position = '';
        El.style.flex = '';
    }

    // 隐藏卡片及其祖先包装器（.bili-feed-card, .feed-card）
    function HideCardTree(Card) {
        ApplyHideStyles(Card);
        let Ancestor = Card.parentElement;
        while (Ancestor &amp;&amp; Ancestor !== document.body) {
            const Cls = (Ancestor.className || '').toLowerCase();
            let IsWrapper = false;
            for (let W = 0; W &lt; WRAPPER_CLASSES.length; W++) {
                if (Cls.indexOf(WRAPPER_CLASSES[W]) !== -1) {
                    IsWrapper = true;
                    break;
                }
            }
            if (IsWrapper) {
                ApplyHideStyles(Ancestor);
            }
            Ancestor = Ancestor.parentElement;
        }
    }

    // 显示卡片及其祖先包装器
    function ShowCardTree(Card) {
        ClearHideStyles(Card);
        let Ancestor = Card.parentElement;
        while (Ancestor &amp;&amp; Ancestor !== document.body) {
            const Cls = (Ancestor.className || '').toLowerCase();
            let IsWrapper = false;
            for (let W = 0; W &lt; WRAPPER_CLASSES.length; W++) {
                if (Cls.indexOf(WRAPPER_CLASSES[W]) !== -1) {
                    IsWrapper = true;
                    break;
                }
            }
            if (IsWrapper) {
                ClearHideStyles(Ancestor);
            }
            Ancestor = Ancestor.parentElement;
        }
    }

    // ======================== 核心过滤逻辑 ========================
    function LimitVideos() {
        if (!IsActive) {
            RestoreAllVideos();
            return;
        }

        try {
            const Selector = DetectSelector();
            if (!Selector) {
                Log(T('LogNoCards'));
                return;
            }

            // 获取所有卡片
            let Cards = document.querySelectorAll(Selector);
            if (Cards.length === 0) {
                // 扩展回退：同时查找 /video/, /bangumi/ 和 live.bilibili.com 链接
                const LinkSelectors = [
                    'a[href*="/video/"]',
                    'a[href*="/bangumi/"]',
                    'a[href*="live.bilibili.com"]'
                ];
                const ParentCards = new Set();
                for (const LinkSel of LinkSelectors) {
                    const Links = document.querySelectorAll(LinkSel);
                    for (const Link of Links) {
                        let Parent = Link.parentElement;
                        let Depth = 0;
                        while (Parent &amp;&amp; Depth &lt; 5) {
                            if (Parent.className &amp;&amp; (Parent.className.includes('card') || Parent.className.includes('item') || Parent.className.includes('feed') || Parent.className.includes('floor'))) {
                                ParentCards.add(Parent);
                                break;
                            }
                            Parent = Parent.parentElement;
                            Depth++;
                        }
                    }
                }
                Cards = Array.from(ParentCards);
                if (Cards.length === 0) {
                    Log(T('LogStillNoCards'));
                    return;
                }
            }

            let VideoCards = Array.from(Cards);

            // 去重：移除嵌套包装器，只保留最内层卡片（bili-video-card &gt; 其他包装器）
            // 避免同一个卡片被多次计数
            const NestedRemoval = new Set();
            for (let I = 0; I &lt; VideoCards.length; I++) {
                for (let J = 0; J &lt; VideoCards.length; J++) {
                    if (I !== J &amp;&amp; VideoCards[I].contains(VideoCards[J])) {
                        // VideoCards[I] 是 VideoCards[J] 的祖先 → 移除祖先
                        NestedRemoval.add(I);
                        break;
                    }
                }
            }
            if (NestedRemoval.size &gt; 0) {
                VideoCards = VideoCards.filter((_, Idx) =&gt; !NestedRemoval.has(Idx));
            }

            // 辅助函数：检查卡片链接是否指向特定域名/路径
            function CardLinksTo(Card, Pattern) {
                const Links = Card.querySelectorAll('a[href]');
                for (const Link of Links) {
                    if (Link.href.indexOf(Pattern) !== -1) return true;
                }
                return false;
            }

            // 过滤非视频内容 —— 收集被排除的卡片，稍后统一隐藏
            const ExcludedCards = [];
            VideoCards = VideoCards.filter(Card =&gt; {
                const Text = (Card.textContent || '').toLowerCase();
                const Cls = (Card.className || '').toLowerCase();
                // 检查 floor-title 标签（B站新版卡片分类标签）
                const FloorTitle = Card.querySelector('.floor-title');
                const FloorTitleText = FloorTitle ? (FloorTitle.textContent || '').toLowerCase() : '';

                let ShouldExclude = false;

                if (Config.ExcludeLive &amp;&amp; (
                    Cls.includes('live') ||
                    Text.includes('直播') || Text.includes('正在直播') || Text.includes('直播中') ||
                    FloorTitleText.includes('直播') || FloorTitleText.includes('赛事') ||
                    CardLinksTo(Card, 'live.bilibili.com')
                )) {
                    ShouldExclude = true;
                }
                if (!ShouldExclude &amp;&amp; Config.ExcludeAd &amp;&amp; (Cls.includes('ad') || Cls.includes('advert') || Text.includes('广告') || Text.includes('sponsor'))) {
                    ShouldExclude = true;
                }
                if (!ShouldExclude &amp;&amp; Config.ExcludeBangumi &amp;&amp; (
                    Cls.includes('bangumi') ||
                    Text.includes('番剧') || Text.includes('追番') ||
                    Text.includes('国创') ||
                    FloorTitleText.includes('番剧') || FloorTitleText.includes('国创') ||
                    CardLinksTo(Card, '/bangumi/')
                )) {
                    ShouldExclude = true;
                }
                if (!ShouldExclude &amp;&amp; Config.ExcludePaid &amp;&amp; (Text.includes('付费') || Text.includes('课程') || Text.includes('￥') || Text.includes('¥'))) {
                    ShouldExclude = true;
                }

                if (ShouldExclude) {
                    ExcludedCards.push(Card);
                    return false;
                }
                return true;
            });

            // 处理特殊保留（UP主ID）
            if (Config.KeepSpecialUPIDs &amp;&amp; Config.KeepSpecialUPIDs.length &gt; 0) {
                const KeepSet = new Set(Config.KeepSpecialUPIDs.map(Id =&gt; String(Id)));
                const Kept = [];
                const Rest = [];
                for (const Card of VideoCards) {
                    const UpLink = Card.querySelector('a[href*="/space/"]');
                    let Upid = null;
                    if (UpLink) {
                        const Match = UpLink.href.match(/\/space\/(\d+)/);
                        if (Match) Upid = Match[1];
                    }
                    if (Upid &amp;&amp; KeepSet.has(Upid)) {
                        Kept.push(Card);
                    } else {
                        Rest.push(Card);
                    }
                }
                VideoCards = Kept.concat(Rest);
            }

            // 保留推广位
            let PromotedCards = [];
            if (Config.KeepPromoted) {
                PromotedCards = VideoCards.filter(Card =&gt; {
                    const Text = (Card.textContent || '').toLowerCase();
                    return Text.includes('推广') || Text.includes('广告') || Text.includes('sponsor');
                });
                VideoCards = VideoCards.filter(Card =&gt; !PromotedCards.includes(Card));
            }

            // 处理置顶/推荐卡片
            const TopSelectors = ['.bili-feed__banner', '.bili-feed__top', '.top-banner', '.recommend-banner'];
            let TopCards = [];
            for (const Sel of TopSelectors) {
                const Tops = document.querySelectorAll(Sel);
                for (const Top of Tops) {
                    const InnerCards = Top.querySelectorAll(Selector);
                    for (const Card of InnerCards) {
                        if (VideoCards.includes(Card)) {
                            TopCards.push(Card);
                            const Idx = VideoCards.indexOf(Card);
                            if (Idx !== -1) VideoCards.splice(Idx, 1);
                        }
                    }
                }
            }

            // 限制数量
            const Max = Math.max(1, Number(Config.MaxVideos) || 10);
            const ToShow = VideoCards.slice(0, Max);
            const ToHide = VideoCards.slice(Max);

            // 显示前max个
            ToShow.forEach(Card =&gt; { ShowCardTree(Card); });

            // 隐藏超出限制的卡片 以及 被过滤规则排除的卡片
            const AllToHide = ToHide.concat(ExcludedCards);
            AllToHide.forEach(Card =&gt; { HideCardTree(Card); });

            // 确保推广位和置顶卡片可见
            [...PromotedCards, ...TopCards].forEach(Card =&gt; { ShowCardTree(Card); });

            const Total = VideoCards.length + ExcludedCards.length + PromotedCards.length + TopCards.length;
            const Shown = ToShow.length + PromotedCards.length + TopCards.length;
            Log(T('LogProcessed', Total, Shown, ToHide.length + ExcludedCards.length));

        } catch (E) {
            ErrorLog(T('LogErrorLimit'), E);
        }
    }

    function RestoreAllVideos() {
        const Selector = DetectSelector();
        if (!Selector) return;
        const Cards = document.querySelectorAll(Selector);
        for (const Card of Cards) {
            ShowCardTree(Card);
        }
    }

    // ======================== CSS 样式（仅过滤类和动态配置面板） ========================
    function InjectStyles() {
        GM_addStyle(`
            .BiliLimitedHide {
                display: none !important;
                visibility: hidden !important;
                opacity: 0 !important;
                height: 0 !important;
                margin: 0 !important;
                padding: 0 !important;
                overflow: hidden !important;
                flex: 0 0 0 !important;
                position: absolute !important;
                pointer-events: none !important;
            }
        `);
    }

    // ======================== 配置面板（非侵入式：按需创建/销毁） ========================
    function InjectPanelStyles() {
        if (document.getElementById('BiliCompactPanelStyles')) return;
        const StyleEl = document.createElement('style');
        StyleEl.id = 'BiliCompactPanelStyles';
        StyleEl.textContent = `
            .BiliCompactOverlay {
                position: fixed;
                top: 0;
                left: 0;
                width: 100%;
                height: 100%;
                background: rgba(0,0,0,0.4);
                z-index: 2147483646;
                display: flex;
                align-items: center;
                justify-content: center;
                font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
                font-size: 14px;
            }
            .BiliCompactPanel {
                /* Dark theme (default) variables */
                --bg: #1e1e1e;
                --text: #eee;
                --text-secondary: #ccc;
                --text-heading: #fff;
                --input-bg: #2a2a2a;
                --border: #333;
                --border-light: #444;
                --hr: #333;
                --accent: #fb7299;
                --accent-hover: #ff85a8;
                --badge-off: #666;
                --btn-secondary-bg: #444;
                --btn-secondary-hover: #555;
                --btn-secondary-text: #fff;
                --collapse-hover: #333;

                background: var(--bg);
                color: var(--text);
                padding: 24px 30px;
                border-radius: 16px;
                box-shadow: 0 8px 40px rgba(0,0,0,0.6);
                min-width: 340px;
                max-width: 420px;
                border: 1px solid var(--border);
                display: flex;
                flex-direction: column;
                gap: 12px;
                position: relative;
                max-height: 85vh;
                overflow-y: auto;
            }
            .BiliCompactPanel.light-mode {
                --bg: #ffffff;
                --text: #333;
                --text-secondary: #555;
                --text-heading: #111;
                --input-bg: #f5f5f5;
                --border: #ddd;
                --border-light: #e0e0e0;
                --hr: #eee;
                --accent: #00AEEC;
                --accent-hover: #33c0f0;
                --badge-off: #bbb;
                --btn-secondary-bg: #eee;
                --btn-secondary-hover: #ddd;
                --btn-secondary-text: #333;
                --collapse-hover: #eee;
                box-shadow: 0 4px 24px rgba(0,0,0,0.12);
            }
            .BiliCompactPanel h3 {
                margin: 0 0 4px 0;
                font-weight: 500;
                color: var(--text-heading);
                font-size: 16px;
            }
            .BiliCompactPanel label {
                display: flex;
                justify-content: space-between;
                align-items: center;
                font-size: 14px;
                color: var(--text-secondary);
                gap: 8px;
            }
            .BiliCompactPanel input[type="number"],
            .BiliCompactPanel input[type="text"] {
                background: var(--input-bg);
                border: 1px solid var(--border-light);
                color: var(--text);
                padding: 4px 10px;
                border-radius: 6px;
                width: 80px;
                font-size: 14px;
                font-family: inherit;
            }
            .BiliCompactPanel input[type="text"] {
                width: 140px;
            }
            .BiliCompactPanel select {
                background: var(--input-bg);
                border: 1px solid var(--border-light);
                color: var(--text);
                padding: 4px 8px;
                border-radius: 6px;
                font-size: 14px;
                font-family: inherit;
                cursor: pointer;
            }
            .BiliCompactPanel input[type="checkbox"] {
                accent-color: var(--accent);
                width: 18px;
                height: 18px;
                cursor: pointer;
            }
            .BiliCompactPanel .BtnRow {
                display: flex;
                gap: 10px;
                justify-content: flex-end;
                margin-top: 6px;
                flex-wrap: wrap;
            }
            .BiliCompactPanel button {
                background: var(--accent);
                border: none;
                color: #fff;
                padding: 6px 18px;
                border-radius: 20px;
                cursor: pointer;
                font-size: 14px;
                font-family: inherit;
                transition: background 0.2s;
            }
            .BiliCompactPanel button.Secondary {
                background: var(--btn-secondary-bg);
                color: var(--btn-secondary-text);
            }
            .BiliCompactPanel button:hover {
                background: var(--accent-hover);
            }
            .BiliCompactPanel button.Secondary:hover {
                background: var(--btn-secondary-hover);
            }
            .BiliCompactPanel .Hint {
                font-size: 12px;
                color: #888;
                margin-top: -4px;
                line-height: 1.4;
            }
            .BiliCompactPanel .StatusRow {
                display: flex;
                align-items: center;
                justify-content: space-between;
                font-size: 14px;
                color: var(--text-secondary);
            }
            .BiliCompactPanel .StatusBadge {
                background: var(--accent);
                color: #fff;
                border-radius: 12px;
                padding: 2px 12px;
                font-size: 12px;
                font-weight: bold;
            }
            .BiliCompactPanel .StatusBadge.Off {
                background: var(--badge-off);
            }
            /* Collapsible section */
            .BiliCompactPanel .CollapseHeader {
                display: flex;
                align-items: center;
                gap: 6px;
                cursor: pointer;
                padding: 6px 8px;
                border-radius: 6px;
                user-select: none;
                font-size: 13px;
                color: var(--accent);
                font-weight: 500;
                transition: background 0.15s;
            }
            .BiliCompactPanel .CollapseHeader:hover {
                background: var(--collapse-hover);
            }
            .BiliCompactPanel .CollapseArrow {
                transition: transform 0.2s;
                font-size: 12px;
                line-height: 1;
            }
            .BiliCompactPanel .CollapseArrow.open {
                transform: rotate(90deg);
            }
            .BiliCompactPanel .CollapseContent {
                display: flex;
                flex-direction: column;
                gap: 8px;
            }
            .BiliCompactPanel .CollapseContent.collapsed {
                display: none;
            }
        `;
        document.head.appendChild(StyleEl);
    }

    let PanelDestroyFn = null;

    function OpenConfigPanel() {
        if (PanelDestroyFn) {
            PanelDestroyFn();
            PanelDestroyFn = null;
        }

        InjectPanelStyles();

        const Overlay = document.createElement('div');
        Overlay.className = 'BiliCompactOverlay';

        const Panel = document.createElement('div');
        Panel.className = 'BiliCompactPanel';

        // 应用颜色模式
        const effectiveColorMode = (Config.ColorMode || 'auto') === 'auto'
            ? (window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light')
            : Config.ColorMode;
        if (effectiveColorMode === 'light') {
            Panel.classList.add('light-mode');
        }

        // 语言选项
        const LangOptions = [
            { Value: 'auto',  Label: T('PanelLanguageAuto') },
            { Value: 'zh_CN', Label: '简体中文' },
            { Value: 'zh_TW', Label: '繁體中文' },
            { Value: 'en_US', Label: 'English' },
        ];
        const LangSelectHTML = LangOptions.map(Opt =&gt;
            `&lt;option value="${Opt.Value}" ${Config.Language === Opt.Value ? 'selected' : ''}&gt;${Opt.Label}&lt;/option&gt;`
        ).join('');

        Panel.innerHTML = `
            &lt;h3&gt;${T('PanelTitle')}&lt;/h3&gt;
            &lt;div class="StatusRow"&gt;
                &lt;span&gt;${T('PanelStatusLabel')}&lt;/span&gt;
                &lt;span class="StatusBadge ${IsActive ? '' : 'Off'}" id="CfgStatusBadge"&gt;${IsActive ? T('PanelStatusActive') : T('PanelStatusPaused')}&lt;/span&gt;
            &lt;/div&gt;
            &lt;label&gt;${T('PanelMaxVideos')} &lt;input type="number" id="CfgMax" value="${Config.MaxVideos}" min="1" max="100"&gt;&lt;/label&gt;
            &lt;label&gt;${T('PanelExcludeLive')} &lt;input type="checkbox" id="CfgExcludeLive" ${Config.ExcludeLive ? 'checked' : ''}&gt;&lt;/label&gt;
            &lt;label&gt;${T('PanelExcludeAd')} &lt;input type="checkbox" id="CfgExcludeAd" ${Config.ExcludeAd ? 'checked' : ''}&gt;&lt;/label&gt;
            &lt;label&gt;${T('PanelExcludeBangumi')} &lt;input type="checkbox" id="CfgExcludeBangumi" ${Config.ExcludeBangumi ? 'checked' : ''}&gt;&lt;/label&gt;
            &lt;label&gt;${T('PanelExcludePaid')} &lt;input type="checkbox" id="CfgExcludePaid" ${Config.ExcludePaid ? 'checked' : ''}&gt;&lt;/label&gt;
            &lt;label&gt;${T('PanelKeepPromoted')} &lt;input type="checkbox" id="CfgKeepPromoted" ${Config.KeepPromoted ? 'checked' : ''}&gt;&lt;/label&gt;
            &lt;label&gt;${T('PanelDebug')} &lt;input type="checkbox" id="CfgDebug" ${Config.Debug ? 'checked' : ''}&gt;&lt;/label&gt;
            &lt;label&gt;${T('PanelEnableCommentPurifier')} &lt;input type="checkbox" id="CfgEnablePurifier" ${Config.EnableCommentPurifier ? 'checked' : ''}&gt;&lt;/label&gt;
            &lt;label&gt;${T('PanelLanguage')} &lt;select id="CfgLanguage"&gt;${LangSelectHTML}&lt;/select&gt;&lt;/label&gt;
            &lt;label&gt;${T('PanelColorMode')} &lt;select id="CfgColorMode"&gt;
                &lt;option value="auto" ${(Config.ColorMode || 'auto') === 'auto' ? 'selected' : ''}&gt;${T('PanelColorAuto')}&lt;/option&gt;
                &lt;option value="dark" ${Config.ColorMode === 'dark' ? 'selected' : ''}&gt;${T('PanelColorDark')}&lt;/option&gt;
                &lt;option value="light" ${Config.ColorMode === 'light' ? 'selected' : ''}&gt;${T('PanelColorLight')}&lt;/option&gt;
            &lt;/select&gt;&lt;/label&gt;
            &lt;label&gt;${T('PanelKeepUpids')} &lt;input type="text" id="CfgKeepUids" value="${(Config.KeepSpecialUPIDs || []).join(',')}"&gt;&lt;/label&gt;
            &lt;hr style="margin:8px 0;border:none;border-top:1px solid var(--hr, #333)"&gt;
            &lt;div class="CollapseHeader" id="CfgCollapseRm"&gt;
                &lt;span class="CollapseArrow" id="CfgCollapseRmArrow"&gt;▸&lt;/span&gt;
                &lt;span&gt;${'去除元素'}&lt;/span&gt;
            &lt;/div&gt;
            &lt;div class="CollapseContent collapsed" id="CfgCollapseRmContent"&gt;
            ${ELEMENT_REMOVAL_PRESETS.map(function(P) {
                return '&lt;label&gt;&lt;span style="flex:1"&gt;' + P.name + '&lt;/span&gt; &lt;input type="checkbox" id="CfgRm_' + P.id + '" ' + ((Config.RemovedElements || {})[P.id] ? 'checked' : '') + '&gt;&lt;/label&gt;';
            }).join('')}
            &lt;/div&gt;
            &lt;div class="BtnRow"&gt;
                &lt;button class="Secondary" id="CfgToggle"&gt;${IsActive ? T('PanelBtnPause') : T('PanelBtnResume')}&lt;/button&gt;
                &lt;button class="Secondary" id="CfgReset"&gt;${T('PanelBtnReset')}&lt;/button&gt;
                &lt;button id="CfgSave"&gt;${T('PanelBtnSave')}&lt;/button&gt;
            &lt;/div&gt;
        `;

        Overlay.appendChild(Panel);
        document.body.appendChild(Overlay);

        // —— 事件绑定 ——

        document.getElementById('CfgSave').addEventListener('click', function() {
            const Max = parseInt(document.getElementById('CfgMax').value) || 10;
            const NewLang = document.getElementById('CfgLanguage').value;
            const LangChanged = NewLang !== Config.Language;

            const NewConfig = {
                MaxVideos: Max,
                ExcludeLive: document.getElementById('CfgExcludeLive').checked,
                ExcludeAd: document.getElementById('CfgExcludeAd').checked,
                ExcludeBangumi: document.getElementById('CfgExcludeBangumi').checked,
                ExcludePaid: document.getElementById('CfgExcludePaid').checked,
                KeepPromoted: document.getElementById('CfgKeepPromoted').checked,
                Language: NewLang,
                ColorMode: document.getElementById('CfgColorMode').value,
                KeepSpecialUPIDs: document.getElementById('CfgKeepUids').value.split(',').map(S =&gt; S.trim()).filter(Boolean).map(Number),
                Debug: document.getElementById('CfgDebug').checked,
                EnableCommentPurifier: document.getElementById('CfgEnablePurifier').checked,
                RemovedElements: (function() {
                    var obj = {};
                    for (var I = 0; I &lt; ELEMENT_REMOVAL_PRESETS.length; I++) {
                        var cb = document.getElementById('CfgRm_' + ELEMENT_REMOVAL_PRESETS[I].id);
                        if (cb) obj[ELEMENT_REMOVAL_PRESETS[I].id] = cb.checked;
                    }
                    return obj;
                })()
            };
            Object.assign(Config, NewConfig);
            SaveConfig(Config);

            // 语言变更时立即生效
            if (LangChanged) {
                CurrentLang = ResolveLanguage();
            }

            DestroyPanel();
            LimitVideos();
            applyElementRemoval();

            // 评论净化器开关变更后立即启停
            if (NewConfig.EnableCommentPurifier) {
                startCommentPurifier();
            } else {
                stopCommentPurifier();
            }

            // 语言变更后重新打开面板（让用户看到新语言）
            if (LangChanged) {
                setTimeout(() =&gt; OpenConfigPanel(), 100);
            }
        });

        document.getElementById('CfgReset').addEventListener('click', function() {
            Object.assign(Config, DEFAULTS);
            SaveConfig(Config);
            CurrentLang = ResolveLanguage();
            // 刷新面板输入
            document.getElementById('CfgMax').value = Config.MaxVideos;
            document.getElementById('CfgExcludeLive').checked = Config.ExcludeLive;
            document.getElementById('CfgExcludeAd').checked = Config.ExcludeAd;
            document.getElementById('CfgExcludeBangumi').checked = Config.ExcludeBangumi;
            document.getElementById('CfgExcludePaid').checked = Config.ExcludePaid;
            document.getElementById('CfgKeepPromoted').checked = Config.KeepPromoted;
            document.getElementById('CfgDebug').checked = Config.Debug;
            document.getElementById("CfgEnablePurifier").checked = false;
            document.getElementById('CfgColorMode').value = Config.ColorMode || 'auto';
            document.getElementById('CfgKeepUids').value = '';
            for (var I = 0; I &lt; ELEMENT_REMOVAL_PRESETS.length; I++) {
                var cb = document.getElementById('CfgRm_' + ELEMENT_REMOVAL_PRESETS[I].id);
                if (cb) cb.checked = false;
            }
            stopCommentPurifier();
            // 重置后重新应用颜色模式主题
            const resetPanel = document.querySelector('.BiliCompactPanel');
            if (resetPanel) {
                const resetMode = (Config.ColorMode || 'auto') === 'auto'
                    ? (window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light')
                    : Config.ColorMode;
                resetPanel.classList.toggle('light-mode', resetMode === 'light');
            }
            LimitVideos();
            applyElementRemoval();
        });

        document.getElementById('CfgToggle').addEventListener('click', function() {
            IsActive = !IsActive;
            if (IsActive) {
                LimitVideos();
            } else {
                RestoreAllVideos();
            }
            const Badge = document.getElementById('CfgStatusBadge');
            if (Badge) {
                Badge.textContent = IsActive ? T('PanelStatusActive') : T('PanelStatusPaused');
                Badge.className = 'StatusBadge' + (IsActive ? '' : ' Off');
            }
            this.textContent = IsActive ? T('PanelBtnPause') : T('PanelBtnResume');
        });

        // 去除元素折叠切换
        document.getElementById('CfgCollapseRm').addEventListener('click', function() {
            const content = document.getElementById('CfgCollapseRmContent');
            const arrow = document.getElementById('CfgCollapseRmArrow');
            const isCollapsed = content.classList.contains('collapsed');
            if (isCollapsed) {
                content.classList.remove('collapsed');
                arrow.classList.add('open');
            } else {
                content.classList.add('collapsed');
                arrow.classList.remove('open');
            }
        });

        Overlay.addEventListener('click', function(E) {
            if (E.target === Overlay) {
                DestroyPanel();
            }
        });

        function OnKeyDown(E) {
            if (E.key === 'Escape') {
                DestroyPanel();
            }
        }
        document.addEventListener('keydown', OnKeyDown);

        function DestroyPanel() {
            document.removeEventListener('keydown', OnKeyDown);
            if (Overlay.parentNode) {
                Overlay.parentNode.removeChild(Overlay);
            }
            PanelDestroyFn = null;
        }

        PanelDestroyFn = DestroyPanel;
    }

    function CloseConfigPanel() {
        if (PanelDestroyFn) {
            PanelDestroyFn();
            PanelDestroyFn = null;
        }
    }


    // ======================== 观察者 ========================
    function InitObserver() {
        if (Observer) {
            Observer.disconnect();
            Observer = null;
        }

        const Container = DetectContainer();
        if (!Container) return;

        Observer = new MutationObserver(function(Mutations) {
            let ShouldProcess = false;
            for (const Mutation of Mutations) {
                if (Mutation.type === 'childList' &amp;&amp; (Mutation.addedNodes.length &gt; 0 || Mutation.removedNodes.length &gt; 0)) {
                    for (const Node of Mutation.addedNodes) {
                        if (Node.nodeType === 1) {
                            const Sel = DetectSelector();
                            if (Sel &amp;&amp; (Node.matches(Sel) || Node.querySelector(Sel))) {
                                ShouldProcess = true;
                                break;
                            }
                        }
                    }
                    if (!ShouldProcess) {
                        for (const Node of Mutation.removedNodes) {
                            if (Node.nodeType === 1) {
                                const Sel = DetectSelector();
                                if (Sel &amp;&amp; (Node.matches(Sel) || Node.querySelector(Sel))) {
                                    ShouldProcess = true;
                                    break;
                                }
                            }
                        }
                    }
                }
                if (ShouldProcess) break;
            }

            if (ShouldProcess) {
                const Now = Date.now();
                if (Now - LastRun &lt; THROTTLE_INTERVAL) {
                    clearTimeout(DebounceTimer);
                    DebounceTimer = setTimeout(() =&gt; {
                        LastRun = Date.now();
                        LimitVideos();
                    }, 300);
                } else {
                    LastRun = Now;
                    LimitVideos();
                }
            }
        });

        Observer.observe(Container, {
            childList: true,
            subtree: true,
            attributes: false
        });

        Log(T('LogObserverStarted'), Container);
    }

    // ======================== 路由变化监听 ========================
    function WatchUrlChange() {
        let LastUrl = location.href;
        setInterval(() =&gt; {
            if (location.href !== LastUrl) {
                LastUrl = location.href;
                Log(T('LogUrlChanged'), LastUrl);
                EffectiveSelector = null;
                VideoListContainer = null;
                setTimeout(() =&gt; {
                    DetectSelector();
                    DetectContainer();
                    LimitVideos();
                    applyElementRemoval();
                }, 500);
            }
        }, 1000);
    }

    // ======================== 菜单命令（唯一入口，在语言解析后注册） ========================
    function RegisterMenu() {
        GM_registerMenuCommand(T('MenuSettings'), function() {
            OpenConfigPanel();
        });
        GM_registerMenuCommand(T('MenuRefresh'), function() {
            EffectiveSelector = null;
            VideoListContainer = null;
            LimitVideos();
        });
        GM_registerMenuCommand(T('MenuToggle'), function() {
            IsActive = !IsActive;
            if (IsActive) {
                LimitVideos();
            } else {
                RestoreAllVideos();
            }
            Log(T('LogStatus'), IsActive ? T('LogStatusOn') : T('LogStatusOff'));
        });
        GM_registerMenuCommand(T('MenuCommentPurifier'), function() {
            toggleCommentPurifier();
        });
        GM_registerMenuCommand(T('MenuQuickSet'), function() {
            const Num = prompt(T('PromptQuickSet'), Config.MaxVideos);
            if (Num !== null) {
                const N = parseInt(Num);
                if (N &gt;= 1 &amp;&amp; N &lt;= 100) {
                    Config.MaxVideos = N;
                    SaveConfig({ MaxVideos: N });
                    if (!IsActive) {
                        IsActive = true;
                    }
                    LimitVideos();
                    Log(T('LogQuickSet'), N);
                }
            }
        });
    }

    // ======================== 初始化 ========================
    function Init() {
        try {
            // 加载配置
            Config = GetConfig();

            // 解析语言（必须在任何 T() 调用之前）
            CurrentLang = ResolveLanguage();

            Log(T('LogConfigLoaded'), Config);

            // 注入样式（仅过滤类，不注入任何UI节点）
            InjectStyles();

            // 注册菜单（TM菜单是唯一入口，不在页面注入UI）
            RegisterMenu();

            // 启动评论净化器（如果启用）
            startCommentPurifier();

            // 启动观察
            InitObserver();

            // 路由监听
            WatchUrlChange();

            // 初次执行
            setTimeout(() =&gt; {
                DetectSelector();
                DetectContainer();
                LimitVideos();
                applyElementRemoval();
            }, 500);

            // 定时后备检查
            setInterval(() =&gt; {
                if (IsActive) {
                    const Selector = DetectSelector();
                    if (Selector) {
                        const Cards = document.querySelectorAll(Selector);
                        let VisibleCount = 0;
                        for (const Card of Cards) {
                            if (!(Card.style.display === 'none' || Card.classList.contains('BiliLimitedHide'))) {
                                VisibleCount++;
                            }
                        }
                        if (VisibleCount &gt; Config.MaxVideos) {
                            Log(T('LogTimerRetry'));
                            LimitVideos();
                        }
                    }
                }
                // 定时重试元素去除（B站SPA可能动态替换DOM）
                applyElementRemoval();
            }, 5000);

            Log(T('LogInitDone'), Config);

        } catch (E) {
            ErrorLog(T('LogInitError'), E);
        }
    }

    // 页面加载完成
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', Init);
    } else {
        Init();
    }

})();

一键安装

推荐

方式一：Greasyfork 直接安装（推荐）

点击下方按钮，一键安装到 Tampermonkey / Violentmonkey：

从 Greasyfork 安装

已上架 Greasyfork，自动更新，省心省力。

方式二：复制源码，手动创建

如果你想审查每一行代码再安装，也可以复制上面的源码，在 Tampermonkey 中新建脚本，粘贴保存即可。

1
2
3
4
1. 打开浏览器的 Tampermonkey / Violentmonkey 扩展
2. 点击「新建脚本」
3. 删除默认内容，粘贴上方源码
4. Ctrl+S 保存

两种方式效果完全一致，推荐方式一，后续新版本会自动推送更新。

为什么要写这个脚本

写了一天代码，晚上瘫在椅子上，打开 B 站想刷两个视频放松一下。

结果首页一刷新，直播，番剧，推广，付费课程铺了一整屏。我就想看两三个视频，信息量却先灌一脸，反而更累了。

这种憋屈感持续了挺久。不是说直播没人爱看，番剧没人追，但 B 站不管你想看什么，一股脑全塞给你。

我忍过，也试过假装看不见。但每次打开首页都像被按着头喂饭。后来觉得与其每次都烦，不如自己动手。

于是有了 BiliCompact。

要求很简单，首页想显示几个视频就显示几个。十个太多？五个。五个还多？三个也行。直播，广告，番剧推广，不想看就别出现。评论区满屏的 @某某某 刷屏，能自动清掉最好。

然后就动手了。

B 站首页的信息过载

打开 B 站首页，扑面而来的是：

  • 直播流，大量正在直播的推荐
  • 番剧推荐，你不一定感兴趣
  • 广告与推广，商业内容
  • 付费课程，推销入口

真正想看的视频，被淹没在其中。

1
2
3
4
5
直播 ████████████████████████████████████ 100%
番剧 ██████████████████████████████ 80%
广告 ████████████████████ 50%
付费 ██████████ 20%
想看 ██████ 12%

非侵入式的设计哲学：

很多同类脚本会在页面注入 UI 元素，按钮、浮窗、侧边栏。好处是交互直观，坏处是耦合太深。B 站的前端频繁改版，每次 DOM 结构调整，注入的 UI 就可能错位、失效，甚至阻塞页面渲染。

BiliCompact 的做法相反：

  • 不在 B 站页面注入任何 UI 元素
  • 配置面板通过 Tampermonkey 的 GM_registerMenuCommand 唤起，以浮层形式展示
  • 所有过滤逻辑在后台执行，页面外观无变化
1
2
3
GM_registerMenuCommand(T('MenuSettings'), () => OpenConfigPanel());
GM_registerMenuCommand(T('MenuRefresh'), () => LimitVideos());
GM_registerMenuCommand(T('MenuToggle'), () => { IsActive = !IsActive; });

这样做的代价是交互入口不那么直观，藏在扩展菜单里，但换来的是高稳定性，B 站改版几次了，脚本还能正常工作。

功能速览

功能说明
数量限制设置每页最大显示视频数量，不同页面可独立设置
智能过滤排除直播 / 广告 / 番剧 / 付费课程
UP 主白名单保留指定 UP 主的内容
一键切换快捷开关，随时恢复原始首页
评论净化删除 @ 提及，隐藏短评论
配置持久化跨页面保存所有设置

配置面板

通过 Tampermonkey 菜单打开：

设置项说明默认
最大显示数量每页最多显示的视频数10
排除直播隐藏直播推荐[Checked]
排除广告隐藏推广内容[Checked]
排除番剧隐藏番剧推荐[Checked]
排除付费课程隐藏付费内容[Checked]
保留推广位推广内容不计入数量[Unchecked]
调试模式输出日志到控制台[Unchecked]
评论净化自动删除 @ 提及[Unchecked]

每种页面可以独立配置数量：首页 10、热门 8、分区 10、动态 6、搜索 10。

技术架构

选择器探测机制

B 站首页的 DOM 结构经常变化，直接写死 CSS 选择器是行不通的。脚本实现了一套多层级降级探测策略：

1
2
3
4
5
6
第一层  id / class 精准选择器              覆盖 2%
第二层  data-* 属性探测 (data-video-id)     +3%
第三层  宽泛属性选择器 [class*="video"]      +5%
第四层  链接文本回退 (<a href="/video/">)    +80%
────────────────────────────────────────
最终覆盖率                                  99%+

具体实现上，每层依次尝试：

  1. 精确类名（.bili-video-card, .feed-card 等）
  2. 通配类名（[class*="video-card"] 等）
  3. 通过链接回退（查找包含 /video/ 链接的父级卡片）

选择器被缓存，在 URL 变化时自动失效重新探测，适应 SPA 路由切换。

过滤引擎

过滤逻辑分为几个阶段，顺序执行：

  1. 去重：消除嵌套卡片，避免同一个视频被重复计数
  2. 规则过滤：按配置排除直播、广告、番剧、付费内容
  3. UP 主白名单：指定 ID 的 UP 主视频始终保留
  4. 数量截断：超出限制的视频隐藏
  5. 推广位保护：配置为保留推广位时，不计入数量限制

Grid 塌陷处理

B 站使用 CSS Grid 布局，简单地 display: none 卡片元素不会让网格塌陷，会留下空白。

BiliCompact 的处理方式是同时设置多个样式：

1
2
3
4
5
6
7
8
9
El.style.display = 'none';
El.style.visibility = 'hidden';
El.style.opacity = '0';
El.style.height = '0';
El.style.margin = '0';
El.style.padding = '0';
El.style.overflow = 'hidden';
El.style.flex = '0 0 0';
El.style.position = 'absolute';

通过 height: 0 + padding: 0 + position: absolute + overflow: hidden 的组合，确保网格完全塌陷，不留视觉空白。

MutationObserver + 节流

为了应对 B 站 SPA 动态加载内容，BiliCompact 使用 MutationObserver 监听 DOM 变化：

1
2
3
DOM 变化 → MutationObserver 触发 → 防抖/节流(200ms) → 执行精简
                                                              ↕
                                                      定时回查(5s)
  • 200ms 节流：防止高频触发
  • 300ms 防抖：等待 DOM 稳定后再执行
  • 5s 定时回查：兜底处理动态加载的内容

Shadow DOM 穿透

B 站新版评论区使用 Web Components 技术，评论内容在多层 Shadow DOM 内部：

1
2
3
4
5
6
7
8
<bili-comments>
  └─ shadowRoot →
    <bili-comment-thread-renderer>
      └─ shadowRoot →
        <bili-comment-renderer>
          └─ shadowRoot →
            <bili-rich-text>
              └─ shadowRoot → #contents

净化器递归访问 element.shadowRoot 属性，穿透所有 Shadow DOM 边界，找到评论内容容器：

1
2
3
4
5
6
7
function purifierGetContentsEl(renderer) {
    const richText = renderer.shadowRoot.querySelector('bili-rich-text');
    if (richText && richText.shadowRoot) {
        return richText.shadowRoot.getElementById('contents');
    }
    return null;
}

删除所有 a[data-type="mention"]（@ 提及标签），然后检查剩余文字长度，不足 5 字的评论整体隐藏。通过 MutationObserver 监听评论区动态加载，新评论出现时自动处理。同时兼容同页面其他脚本，检测到共存时仅做日志标记，不冲突。

元素去除系统

除了核心的视频数量限制，脚本还提供了一组可选的 UI 元素去除预设，涵盖首页轮播图、频道导航、创作中心入口、直播入口等 13 个可去除元素。每个预设包含多版本选择器，适配 B 站不同的 DOM 版本。

多语言支持

内置完整的 i18n 系统，支持简体中文、繁体中文、英文，自动根据浏览器语言切换：

1
2
3
4
5
6
7
8
9
10
function ResolveLanguage() {
    if (Config.Language && Config.Language !== 'auto') {
        return Config.Language;
    }
    const Nav = (navigator.language || '').toLowerCase();
    if (/^zh-(tw|hk|mo)$/i.test(Nav) || /^zh-(hant)$/i.test(Nav)) return 'zh_TW';
    if (/^zh/i.test(Nav)) return 'zh_CN';
    if (/^en/i.test(Nav)) return 'en_US';
    return 'zh_CN';
}

所有用户可见文本通过 T(key, ...args) 函数统一翻译，键缺失时自动回退到中文，不会出现英文报错。语言可在配置面板中手动切换，切换后立即生效。

持久化与实时生效

所有配置通过 GM_setValue / GM_getValue 持久化，刷新页面不丢失。配置变更后立即生效，无需手动刷新。同时包含定时后备检查（每 5 秒），防止 B 站 SPA 的动态加载导致视频数量超出限制，这是一种防御性编程，确保极端情况下也能正常工作。

用户反馈

没想到会有人愿意用这东西。

一开始只是自己用，顺手传到了 GreasyFork，想着万一有人需要呢。后来真有人说不用被首页轰炸了，还有人问能不能加某某功能。

看到这些还挺高兴的。

现在的互联网产品越做越重，功能越堆越多。但用户想要的，有时候就是清静一点。在产品和用户之间，BiliCompact 尝试稍微往用户这边拉一拉。

如果你也装了它，觉得有用，那我很高兴。觉得哪里不好用，也欢迎提。

代码完全开源，MIT 协议，想改就改，想删就删，没什么藏着掖着的。

总结

BiliCompact 在功能上并不复杂，它的设计重心在稳定性和非侵入性上。一些值得借鉴的点：

  1. 选择器多梯队探测，应对频繁的前端改版
  2. 非侵入式 UI，不污染页面 DOM，降低耦合
  3. Shadow DOM 穿透，处理现代前端框架的封装
  4. 防御性定时检查，SPA 动态加载的兜底策略
]]> https://twilightrain.com/2026/07/22/bilicompact-source/ 2026-07-22T04:00:00.000Z BiliCompact 用户脚本 v2.6.0 源码与回顾。 BiliCompact 完整源码与解析 2026-08-26T05:06:32.651Z TwilightRain 缘起

事情是这样的。

我的 Hexo 博客之前一直部署在 GitHub Pages 上，但我发现它在国内的访问体验很不稳定，时而能打开，时而转圈圈，时而直接超时。这是因为 github.io 域名在国内的 CDN 节点访问不畅，加上可能存在的 DNS 污染，导致博客对国内读者不太友好。

于是我开始寻找解决方案。最直接的办法是使用 Cloudflare Pages 来托管博客，利用它的全球 CDN 加速，让国内访问更稳定。

第一步：在 Cloudflare Pages 创建项目

操作本身不复杂：

  1. 登录 Cloudflare Dashboard → Workers & Pages
  2. 点击 Create application → 选择 Pages 选项卡
  3. 点击 Connect to Git，授权 Cloudflare 访问你的 GitHub
  4. 选择你的博客仓库，填入构建设置：
配置项填写值
Production branchmain
Framework presetNone（列表中没有 Hexo）
Build commandnpm run build
Build directorypublic
  1. 点击 Save and Deploy

一切都看起来很简单……直到我看到了红色的报错。

第二步：踩坑，package.json 找不到了？

Cloudflare Pages 的构建日志赫然写着：

1
2
3
npm error code ENOENT
npm error path /opt/buildhome/repo/package.json
npm error enoent Could not read package.json

嗯？我的仓库里明明有 package.json 啊。

回头一看 GitHub 仓库，我明白了，

根因：推送错了内容

我的 GitHub 仓库里只有这些文件：

1
2
3
4
5
6
index.html
2026/07/13/hello-world/
archives/
css/
fancybox/
js/

全是 hexo generate 生成的静态文件，没有 package.json，没有 _config.yml，没有 source/ 文件夹。

换句话说，我之前一直用 hexo deploy 把编译后的 public/ 目录推到了仓库里。这在 GitHub Pages 的流程下是正常的，它只需要静态文件。但 Cloudflare Pages 需要的是源代码，因为它要在服务端执行 npm install 和 npm run build。

修复：推送正确的源代码

解决方案很简单：把 Hexo 的源代码推上去。

1
2
3
4
5
6
# 在博客根目录执行
git init
git add .
git commit -m "推送 Hexo 源码到 Cloudflare Pages"
git remote add origin https://github.com/你的用户名/你的仓库名.git
git push -u origin main --force

注意 .gitignore 要确保忽略了 node_modules/ 和 public/：

1
2
3
4
node_modules/
public/
db.json
.deploy*/

这样推送上去的就是干净的源代码，Cloudflare 拉取后会自动安装依赖并构建。

第三步：又踩一坑，分支名称

推送成功后，我兴冲冲地点了 Retry deployment，结果……还是同样的错误。

再次查看构建日志，发现 Cloudflare 拉取的依然是旧 commit：

1
2
 * branch 8eb197c... -> FETCH_HEAD
HEAD is now at 8eb197c Site updated: 2026-07-13 18:25:29

奇怪，明明推送成功了，为什么还拉取旧代码？

原因在于 Cloudflare Pages 配置的 Production branch 还是 master，而我的仓库默认分支已经改成了 main（且 master 已经不存在了）。Cloudflare 找不到 master 分支，就用了一个缓存中的旧提交。

解决方案：在 Cloudflare Pages 项目设置中，把 Production branch 从 master 改为 main，然后再次重试部署。

这次终于成功了！

最终效果

博客成功部署到了 twilightrain.pages.dev，构建和部署都自动完成。以后更新博客只需要：

1
2
3
4
5
hexo new post "我的新文章"
# 写文章...
git add .
git commit -m "新文章"
git push

Cloudflare Pages 会自动检测到 push 事件，拉取代码、安装依赖、构建、部署，整个流程全自动。

总结几个要点

  1. GitHub Pages 推静态文件，Cloudflare Pages 推源代码，这两种部署方式对仓库内容的要求完全不同，搞清楚区别才能避免踩坑。
  2. Production branch 要匹配，Cloudflare Pages 配置的部署分支必须和 GitHub 仓库的默认分支一致。
  3. Cloudflare Pages 的构建命令记得用 npm run build，而不是 hexo generate。确保 package.json 的 scripts 中有 "build": "hexo generate"。

希望这篇文章能帮到同样想迁移到 Cloudflare Pages 的朋友。如果你也遇到了类似的报错，对照上面的步骤检查一下，大概率能解决问题。

]]> https://twilightrain.com/2026/07/21/hexo-to-cloudflare-pages/ 2026-07-21T06:45:00.000Z 动机与建项目，以及两次部署踩坑。 Hexo博客从GHP到CFP迁移记录 2026-08-26T05:06:32.651Z