dsh-daily-brief 2.0.3 → 2.1.0

package/README.md

@@ -27,9 +27,10 @@
 ## 环境要求
 
 - Windows 10/11（弹窗与计划任务依赖 Windows；其他平台只能生成 HTML）。
+- DeepSeek Harness 核心 **≥ 0.2.1-rc.3**（已声明 `engines.dsh`，在 0.2.2-rc.1 上验证）。
 - 已安装 DeepSeek Harness，并能用 `plugin_manager` 安装本地插件目录。
 - 本机有 Microsoft Edge 或 Google Chrome（用于独立窗口）。
-- Node.js 随 DSH 提供；若要跑测试，需要 Node 18+。
+- Node.js 20+（随 DSH 提供；跑测试也用它）。
 
 ## 安装
 
@@ -83,8 +84,8 @@
 | --- | --- |
 | `you@gmail.com`、`me@school.edu` | 邮箱（IMAP）。Gmail 用应用专用密码；学校邮箱识别不出服务器时会多出一个 IMAP 服务器输入框 |
 | `me@outlook.com`、`me@hotmail.com`、`me@live.com` | 不再要求 Azure：给出一张「转发到 Gmail / QQ」的三步指南；按指南把 Outlook 邮件转发过去，再添加接收邮箱即可。Outlook 日历则直接粘贴发布的 ICS 链接 |
-| `https://youtube.com/@频道`、`https://youtu.be/视频ID`、播放列表 | YouTube 更新（频道 RSS / 视频页），不需要登录 |
-| `https://space.bilibili.com/UP主ID`、`https://bilibili.com/video/BV…`、排行榜 | 哔哩哔哩更新（UP 主投稿 / 单个视频 / 排行榜），公开接口，无需登录 |
+| `https://youtube.com/@频道`、`https://youtu.be/视频ID`、播放列表 | YouTube 更新（频道 RSS / 视频页），不需要登录；同时读取每个视频的评论数，评论最多的那条会单独生成「今日热议」卡 |
+| `https://space.bilibili.com/UP主ID`、`https://bilibili.com/video/BV…`、排行榜 | 哔哩哔哩更新（UP 主投稿 / 单个视频 / 排行榜），公开接口，无需登录；同样读每条视频的评论数，评论最多的那条生成「今日热议」卡 |
 | `https://…/feed.xml`、`.ics`、任意网页 | 订阅源 / 日历 / 网页。普通网页会自动判断是「单篇文章」还是「列表页」：文章提取标题、正文摘要与发布时间；列表页提取最近条目，抓不到时提示设置 CSS 选择器 |
 | `https://www.managebac.com/...`、`https://…managebac.cn/...` | ManageBac 通知（.com / .cn 及学校子域；需要登录 Cookie，或日历订阅链接） |
 | `https://…feishu.cn/docx|wiki|calendar/...` | 飞书文档 / 知识库 / 日历；前端渲染抓不到时建议用 ICS 订阅 |
@@ -158,6 +159,12 @@ Outlook 日历 →「设置 → 共享日历 → 发布日历」→ 复制 ICS
 
 - 默认「自动」：仅当本机 DSH 有可用登录时，用 headless 方式让模型写标题、一句引言和两段要点；失败自动回退本地文案。
 - 只改文案，不改抓取结果、不增删条目；提示词里明确禁止编造与出现网址。
+- 提示词里会带上视频的评论数与「今日热议」的三条热评，因此要点能写出「46 条评论都在吐槽片头」这类内容；评论数只由接口给出，模型不得自行推测。
+- 以下任一条件不满足就会跳过，并在简报顶部写明原因（`logs\runner.log` 里是同一句）：
+  1. `%(LOCALAPPDATA)%\Programs\DSH NEXT\DSH NEXT.exe` 存在，且 `resources\app.asar` 或解包后的 `resources\app` 里有 `lib\desktop-cli.js`；
+  2. headless profile 已登录（`…\daily-brief\headless-auth.yml`，跟随你桌面端当前账号）；
+  3. 模型在 `ai.timeoutSec`（默认 120 秒）内返回可解析的 JSON。
+- 关掉：`ai.polish` 设为 `off`，或面板里选择「不润色」。
 
 ## 数据与隐私
 
@@ -171,15 +178,21 @@ Outlook 日历 →「设置 → 共享日历 → 发布日历」→ 复制 ICS
 | --- | --- |
 | 面板提示「重启一次 DSH」 | 插件主进程仍是旧代码：完全退出并重开 DSH，面板会恢复可编辑 |
 | X 新闻经常很少 | syndication 对同一出口 IP 限流很紧（约每 15 分钟 1 次），插件会自动用官方博客补位；可减少账号数量，或改用 RSS 订阅 |
+| 简报有条目，但没有标题和要点 | AI 润色被跳过，简报顶部会写「AI 润色未生效：原因」。常见原因：headless 未登录、DSH 升级后目录结构变化（v2.1 起 `app.asar` 与解包后的 `app\` 都认）、模型超过 `ai.timeoutSec`、或 `ai.polish` 被设成 `off` |
+| 某个来源长期「获取超时（35 秒）」 | 慢来源（X / YouTube / B 站 / Steam / 浏览器 / IMAP / Graph）每个 35 秒、普通来源 22 秒，超时即记 error 且当天 0 条。X 最容易吃满：syndication 限流按出口 IP 共享，账号多了第一轮就耗尽，之后还要等官方博客兜底 |
+| B 站报 -352 / -412 | UP 主空间接口对冷请求很敏感。现在会自动改走「动态」接口（另一套风控，通常还能读到投稿）；两条都被挡住时说明本机 IP 被临时限制，等 5–30 分钟再试，或改用单条视频 / 排行榜（这两个接口更宽松）。整轮里命中 -412 后评论数请求会直接短路，避免把封禁时间越拖越长 |
 | Steam 显示「暂时连不上」 | 官方新闻接口偶发超时，会自动显示上次结果；稍后重跑即可 |
 | 服务器一直离线 | 确认地址与端口、服务器是否开机；内网地址需允许私有网络（已默认允许） |
 | 桌面窗口没出现 | 检查是否安装 Edge/Chrome；查看 `logs\runner.log` 的投递记录 |
 | 飞书/ManageBac 抓不到条目 | 多为前端渲染或需要登录：改用日历 ICS 订阅，或在「添加来源」里填入 Cookie |
 | Outlook 邮箱填密码后报错 / 连不上 | Microsoft 已停用 IMAP 密码登录，但不再需要 Azure：按上面「Outlook 怎么办」把邮件转发到 Gmail / QQ，再添加接收邮箱；或直接用 Outlook 日历的 ICS 链接 |
+| 插件市场里安装失败，任务日志是 `pnpm` 且提到 `@napi-rs/canvas-*` / `@img/sharp-*` 或 `EPERM`/`EBUSY` | 失败发生在市场对整个 DSH profile 做 pnpm 重解析时（删宿主自带的原生可选包，被运行中的 DSH 占用），与插件包无关。完全退出 DSH（含托盘）后重装；仍失败就在终端执行 `dsh plugin add dsh-daily-brief` 取真正的错误行 |
 
 ## 配置参考（`config.json`）
 
 - `sources[]`：`type`（x/steam/minecraft/http/rss/atom/json/ics/page/youtube/bilibili/imap/graph/browser/managebac）、`section`、`label`、`enabled`、`options`。
+- YouTube 的 `options`：`limit`、`sinceHours`、`commentScan`（默认 6，最多 10，看前几条视频的评论数；`comments:false` 可整体关掉评论读取）、`commentsPerVideo`（默认 4，热议卡里带几条热评）。
+- Bilibili 的 `options`：`limit`、`sinceHours`、`mid` / `bvid`（覆盖链接里的 ID）、`commentScan`、`commentsPerVideo`、`comments:false`，含义同上。
 - `graph.clientId`：仅 To Do 等高级 Microsoft Graph 来源需要的 Azure 应用（客户端）ID；普通 Outlook 邮件/日历不用填。
 - `persona`：`preset`（whale/assistant/butler/officer/custom 或自建卡片的 id）、`customName`、`customTagline`、`customAccent`、`customPrompt`，以及 `cards[]`（每张 `{ id, name, tagline, accent, prompt }`，最多 12 张）。
 - `schedule`：`time`（HH:MM）、`enabled`、`wakeToRun`、`prepareLeadMin`（提前准备分钟数，默认 10）。

package/lib/engine/ai.js

@@ -32,10 +32,18 @@ export function resolveDesktopRuntime(env = process.env) {
   const resources = process.versions.electron && process.resourcesPath
     ? process.resourcesPath
     : path.join(path.dirname(exe), 'resources');
-  const asar = path.join(resources, 'app.asar');
-  const cli = path.join(asar, 'lib', 'desktop-cli.js');
-  // 在普通 Node 下 fs 不识别 asar 内部路径，但 Electron 能读取；两种入口都算可用。
-  return { exe, cli, resources, asar, available: fs.existsSync(exe) && (fs.existsSync(cli) || fs.existsSync(asar)) };
+  // Packaged builds ship app.asar; a patched/unpacked install keeps a plain
+  // `app` folder instead. The CLI lives at the same relative path in both.
+  const roots = [path.join(resources, 'app.asar'), path.join(resources, 'app')];
+  const root = roots.find((candidate) => fs.existsSync(path.join(candidate, 'lib', 'desktop-cli.js'))) || roots[0];
+  const cli = path.join(root, 'lib', 'desktop-cli.js');
+  return {
+    exe,
+    cli,
+    resources,
+    asar: path.join(resources, 'app.asar'),
+    available: fs.existsSync(exe) && fs.existsSync(cli),
+  };
 }
 
 function buildPrompt(briefing, config) {
@@ -57,9 +65,20 @@ function buildPrompt(briefing, config) {
     lines.push(`\n【${section.zh}】共 ${section.items.length} 条`);
     for (const item of section.items) {
       const detail = String(item.detail || '').replace(/\s+/g, ' ').trim().slice(0, 110);
-      lines.push(`- ${item.title}${item.meta ? `（${item.meta}）` : ''}${detail ? `：${detail}` : ''}`);
+      const hits = Number(item.commentCount) > 0 ? `（${item.commentCount} 条评论）` : '';
+      lines.push(`- ${item.title}${item.meta ? `（${item.meta}）` : ''}${hits}${detail ? `：${detail}` : ''}`);
     }
   }
+  const featured = briefing.featured;
+  if (featured && featured.title) {
+    lines.push(`\n【今日热议】${featured.title}（${Number(featured.commentCount) || 0} 条评论）`);
+    for (const comment of (Array.isArray(featured.comments) ? featured.comments : []).slice(0, 3)) {
+      if (!comment?.text) continue;
+      const likes = Number(comment.likes) > 0 ? `，${comment.likes} 赞` : '';
+      lines.push(`- 热评${comment.author ? ` @${comment.author}` : ''}${likes}：${String(comment.text).replace(/\s+/g, ' ').slice(0, 90)}`);
+    }
+    lines.push('这条热议内容必须出现在对应板块（通常是游戏）的一条要点里：点出视频讲了什么、评论区在讨论什么，可以引用一句热评的意思，但不要照抄原句，也不要编造评论数以外的事实。');
+  }
   lines.push('', 'points 只写 aiNews 与 gameNews 两个键，值是字符串数组；没有内容的板块给空数组。');
   return lines.join('\n').slice(0, 12000);
 }

package/lib/engine/collect/bilibili-comments.js

@@ -0,0 +1,229 @@
+/**
+ * Bilibili comments — two public reply endpoints, no login required.
+ *
+ *   /x/v2/reply/count?type=1&oid=<aid>              → { count }
+ *   /x/v2/reply/main?type=1&oid=<aid>&mode=3&next=0 → { top_replies, replies, cursor }
+ *
+ * Counts are exact for every video. A logged-out client is only shown three
+ * replies per call (the web player behaves the same way), so the card shows at
+ * most a handful of hot comments; adding a Cookie to the source raises the cap.
+ * Replies come back already ordered by relevance, but we sort by likes anyway
+ * so the card is stable between runs.
+ *
+ * The module takes a `getJson(url, referer)` callback instead of fetching on its
+ * own: bilibili.js already owns the buvid cookie, the 400 ms gap and the saved
+ * per-source Cookie header, and both callers must share them.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { plainCommentText as stripEmotes, stripHtml, truncate } from '../text.js';
+import { mapLimit } from './youtube-comments.js';
+
+export { plainCommentText } from '../text.js';
+
+export const COMMENT_CACHE_MS = 6 * 3600 * 1000;
+export const COMMENT_SCAN_DEFAULT = 6;
+export const COMMENT_SCAN_MAX = 10;
+export const COMMENT_CONCURRENCY = 2;
+
+function cachePath(storeDir, aid) {
+  if (!storeDir) return '';
+  return path.join(storeDir, '.cache', `bilibili-comments-${aid}.json`);
+}
+
+function readCache(file) {
+  if (!file) return null;
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(file, value) {
+  if (!file) return;
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(value));
+  } catch {
+    /* cache is best-effort */
+  }
+}
+
+/** Reply count already carried by a list payload (space/ranking/view). */
+export function commentCountFromVideo(video) {
+  const candidates = [video?.stat?.reply, video?.comment, video?.reply_count, video?.rcount];
+  for (const raw of candidates) {
+    const value = Number(raw);
+    if (Number.isFinite(value) && value > 0) return Math.round(value);
+  }
+  return 0;
+}
+
+/** One API reply → the flat shape the briefing card renders. */
+export function normalizeReply(reply) {
+  const ctime = Number(reply?.ctime);
+  return {
+    id: String(reply?.rpid_str || reply?.rpid || ''),
+    author: truncate(String(reply?.member?.uname || reply?.member?.name || '').trim(), 48),
+    text: truncate(stripEmotes(reply?.content?.message), 220),
+    likes: Math.max(0, Math.round(Number(reply?.like) || 0)),
+    replies: Math.max(0, Math.round(Number(reply?.rcount) || 0)),
+    published: Number.isFinite(ctime) && ctime > 0 ? new Date(ctime * 1000).toISOString() : '',
+  };
+}
+
+/** Merge pinned + hot replies, drop duplicates/empties, best-liked first. */
+export function readReplyPage(data) {
+  const raw = [];
+  for (const bucket of [data?.top_replies, data?.top, data?.replies]) {
+    if (Array.isArray(bucket)) raw.push(...bucket);
+  }
+  const seen = new Set();
+  const out = [];
+  for (const reply of raw) {
+    const item = normalizeReply(reply);
+    if (item.text === '') continue;
+    const key = item.id || `${item.author}\u0000${item.text}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(item);
+  }
+  return out.sort((a, b) => b.likes - a.likes);
+}
+
+export function parseReplyCount(data) {
+  const value = Number(data?.count);
+  return Number.isFinite(value) && value >= 0 ? Math.round(value) : null;
+}
+
+/**
+ * Comment count (and optionally hot comments) for one video.
+ * Never throws: a block (-352/-412), a deleted video or a network error comes
+ * back as `{ error }` and the caller keeps the title it already had.
+ */
+export async function fetchVideoComments(
+  aid,
+  { getJson, storeDir, withComments = true, maxComments = 4, cacheMs = COMMENT_CACHE_MS, force = false } = {},
+) {
+  const id = Number(aid);
+  if (!Number.isFinite(id) || id <= 0) return { aid, commentCount: null, comments: [], bytes: 0, elapsedMs: 0 };
+  const file = cachePath(storeDir, id);
+  const cached = force ? null : readCache(file);
+  const fresh = cached && Date.now() - Number(cached.at || 0) < cacheMs;
+  // A count-only lookup must not satisfy a later "give me the replies" call.
+  const hasComments = cached && (cached.full === true || (Array.isArray(cached.comments) && cached.comments.length > 0));
+  if (fresh && Number.isFinite(Number(cached.commentCount)) && (!withComments || hasComments)) {
+    const comments = withComments ? (cached.comments || []).slice(0, maxComments) : [];
+    return { aid: id, commentCount: Number(cached.commentCount), comments, bytes: 0, elapsedMs: 0, cached: true };
+  }
+
+  const referer = `https://www.bilibili.com/video/av${id}`;
+  let bytes = 0;
+  let elapsedMs = 0;
+  // A fresh cache still holding the count saves the count request when only the
+  // replies are missing.
+  let commentCount = fresh && Number.isFinite(Number(cached.commentCount)) ? Number(cached.commentCount) : null;
+  let comments = [];
+
+  if (commentCount === null) {
+    try {
+      const counted = await getJson(`https://api.bilibili.com/x/v2/reply/count?type=1&oid=${id}`, referer);
+      bytes += counted.bytes || 0;
+      elapsedMs += counted.elapsedMs || 0;
+      commentCount = parseReplyCount(counted.data);
+    } catch (error) {
+      return {
+        aid: id,
+        commentCount: cached ? Number(cached.commentCount) : null,
+        comments: cached?.comments || [],
+        bytes,
+        elapsedMs,
+        error: error?.message || '评论数读取失败',
+      };
+    }
+  }
+
+  if (withComments && commentCount > 0) {
+    try {
+      const page = await getJson(
+        `https://api.bilibili.com/x/v2/reply/main?type=1&oid=${id}&mode=3&next=0&ps=20`,
+        referer,
+      );
+      bytes += page.bytes || 0;
+      elapsedMs += page.elapsedMs || 0;
+      comments = readReplyPage(page.data).slice(0, Math.max(1, Math.min(6, maxComments)));
+    } catch {
+      /* count is what ranks the video; comments are decoration */
+    }
+  }
+
+  writeCache(file, { at: Date.now(), commentCount, comments, full: withComments && commentCount > 0 });
+  return { aid: id, commentCount, comments, bytes, elapsedMs };
+}
+
+/**
+ * Give a list of videos their comment counts and pick the most-discussed one.
+ * Counts that the list payload already carries (space/ranking/view) cost no
+ * request, so a ranking board usually needs exactly one extra call.
+ */
+export async function enrichBilibiliComments(list, options, context, getJson) {
+  const items = Array.isArray(list) ? list : [];
+  const requested = Number(options?.commentScan ?? COMMENT_SCAN_DEFAULT);
+  const scanLimit =
+    options?.comments === false
+      ? 0
+      : Math.max(
+          0,
+          Math.min(items.length, Number.isFinite(requested) ? requested : COMMENT_SCAN_DEFAULT, COMMENT_SCAN_MAX),
+        );
+  if (scanLimit === 0) return { items, featured: null, bytes: 0, note: '' };
+
+  let bytes = 0;
+  let failures = 0;
+  const scanned = await mapLimit(items.slice(0, scanLimit), COMMENT_CONCURRENCY, async (item) => {
+    if (Number(item.commentCount) > 0) return item;
+    const aid = Number(item.aid);
+    if (!Number.isFinite(aid) || aid <= 0) return item;
+    const stats = await fetchVideoComments(aid, { getJson, storeDir: context.storeDir, withComments: false });
+    bytes += stats.bytes || 0;
+    if (stats.error) failures += 1;
+    if (Number.isFinite(stats.commentCount) && stats.commentCount > 0) {
+      item.commentCount = Math.round(stats.commentCount);
+    }
+    return item;
+  });
+
+  const ranked = scanned.filter((item) => Number(item.commentCount) > 0).sort((a, b) => b.commentCount - a.commentCount);
+  if (ranked.length === 0) {
+    return { items, featured: null, bytes, note: failures > 0 ? '评论数暂时读不到' : '' };
+  }
+
+  const best = ranked[0];
+  const requestedComments = Number(options?.commentsPerVideo ?? 4);
+  const perVideo = Math.max(1, Math.min(6, Number.isFinite(requestedComments) ? requestedComments : 4));
+  const full = await fetchVideoComments(Number(best.aid), {
+    getJson,
+    storeDir: context.storeDir,
+    withComments: true,
+    maxComments: perVideo,
+  });
+  bytes += full.bytes || 0;
+  const comments = (full.comments ?? []).slice(0, perVideo);
+  best.comments = comments;
+
+  return {
+    items,
+    featured: {
+      id: best.id,
+      title: best.title,
+      url: best.url,
+      date: best.date ?? '',
+      meta: best.meta ?? 'B 站',
+      commentCount: best.commentCount,
+      comments,
+    },
+    bytes,
+    note: `评论最多：${truncate(best.title, 60)}（${best.commentCount} 条）`,
+  };
+}

package/lib/engine/collect/bilibili.js

@@ -13,6 +13,7 @@ import path from 'node:path';
 import { safeFetch } from '../fetch.js';
 import { readSourceHeaders } from '../secrets.js';
 import { truncate, stripHtml } from '../text.js';
+import { commentCountFromVideo, enrichBilibiliComments } from './bilibili-comments.js';
 
 const NAV_CACHE_MS = 6 * 3600 * 1000;
 const ITEMS_CACHE_MS = 8 * 60 * 1000;
@@ -82,7 +83,19 @@ function biliError(data) {
   return `B 站接口返回 ${Number.isFinite(code) ? code : '未知'}：${data?.message || '未知错误'}`;
 }
 
-async function biliJson(url, storeDir, referer, source) {
+// B 站风控按 IP 计费：一旦答 -412，同一轮里再敲十几次只会把封禁时间拖长。
+// 命中后进入冷却，后续请求直接短路；列表类请求可用 bypassRiskCooldown 再试一次。
+let riskUntil = 0;
+const RISK_COOLDOWN_MS = 10 * 60 * 1000;
+
+function isRiskError(error) {
+  return /-(352|412|799)|风控|限流|冷却/.test(String(error?.message || ''));
+}
+
+async function biliJson(url, storeDir, referer, source, options = {}) {
+  if (options.bypassRiskCooldown !== true && Date.now() < riskUntil) {
+    throw new Error('B 站接口仍在风控冷却中，本次跳过');
+  }
   await gap();
   const cookie = await buvidCookie(storeDir);
   // A saved Cookie request header lets users read spaces that would otherwise
@@ -100,6 +113,7 @@ async function biliJson(url, storeDir, referer, source) {
     },
   });
   const data = parseJson(response.text);
+  if (Number(data?.code) === -412) riskUntil = Date.now() + RISK_COOLDOWN_MS;
   if (Number(data?.code) !== 0) throw new Error(biliError(data));
   return { data: data.data, bytes: response.bytes, elapsedMs: response.elapsedMs };
 }
@@ -197,6 +211,8 @@ function itemFromVideo(video, authorFallback = '') {
   const date = created > 0 ? new Date(created * 1000).toISOString() : '';
   const author = String(video?.owner?.name || video?.author || authorFallback || '').trim();
   const description = String(video?.desc || video?.description || '').trim();
+  const aid = Number(video?.aid || 0);
+  const commentCount = commentCountFromVideo(video);
   return {
     id: (`bilibili-${bvid || video?.aid || video?.title || ''}`).slice(0, 300),
     title: truncate(stripHtml(video?.title || ''), 180),
@@ -206,10 +222,35 @@ function itemFromVideo(video, authorFallback = '') {
     meta: author || 'B 站',
     badge: 'B站',
     tone: '',
+    // aid stays on the item so the comment pass can ask about exactly the
+    // videos it shows; normalizeItem() drops it again before rendering.
+    ...(Number.isFinite(aid) && aid > 0 ? { aid } : {}),
+    ...(commentCount > 0 ? { commentCount } : {}),
   };
 }
 
 async function collectSpace(mid, source, context) {
+  try {
+    return await collectSpaceArchive(mid, source, context);
+  } catch (error) {
+    // 空间接口在限流时也会用「空列表」冒充成功，所以「没有公开视频」也要再试一次。
+    if (!isUnavailable(error)) throw error;
+    try {
+      return await collectSpaceDynamic(mid, source, context);
+    } catch (fallback) {
+      if (!isUnavailable(fallback)) throw fallback;
+      throw new Error('B 站空间暂时读不到（本机 IP 被限流 -412，或该 UP 没有公开投稿）：限流通常 5–30 分钟恢复；也可以先改用单条视频链接，或给该来源补填浏览器 Cookie。');
+    }
+  }
+}
+
+/** 限流与「读不到」都值得换条路再试；真正的配置错误不该被吞掉。 */
+function isUnavailable(error) {
+  const message = String(error?.message || '');
+  return isRiskError(error) || /没有公开视频|读不到/.test(message);
+}
+
+async function collectSpaceArchive(mid, source, context) {
   const limit = source.options.limit ?? 8;
   const keys = await wbiKeys(context.storeDir);
   const query = signQuery(
@@ -221,6 +262,7 @@ async function collectSpace(mid, source, context) {
     context.storeDir,
     `https://space.bilibili.com/${mid}`,
     source,
+    { bypassRiskCooldown: true },
   );
   const list = data?.list?.vlist || [];
   if (list.length === 0) throw new Error('这个 B 站空间暂时没有公开视频');
@@ -233,6 +275,59 @@ async function collectSpace(mid, source, context) {
   };
 }
 
+/** 动态接口里的投稿（DYNAMIC_TYPE_AV）摊平成视频对象。 */
+function dynamicVideos(data) {
+  const entries = Array.isArray(data?.items) ? data.items : [];
+  const videos = [];
+  for (const entry of entries) {
+    if (String(entry?.type || '') !== 'DYNAMIC_TYPE_AV') continue;
+    const archive = entry?.modules?.module_dynamic?.major?.archive;
+    if (!archive?.bvid) continue;
+    const published = Number(archive.pubdate || entry?.modules?.module_author?.pub_ts || 0);
+    videos.push({
+      ...archive,
+      created: published,
+      owner: { name: String(entry?.modules?.module_author?.name || '') },
+    });
+  }
+  return videos;
+}
+
+async function collectSpaceDynamic(mid, source, context) {
+  const limit = Math.min(source.options.limit ?? 8, 12);
+  const cutoff = Date.now() - (source.options.sinceHours ?? 24) * 3600000;
+  let offset = '';
+  let bytes = 0;
+  let elapsedMs = 0;
+  const videos = [];
+  for (let page = 0; page < 3; page += 1) {
+    const suffix = offset === '' ? '' : `&offset=${encodeURIComponent(offset)}`;
+    const { data, bytes: size, elapsedMs: spent } = await biliJson(
+      `https://api.bilibili.com/x/polymer/web-dynamic/v1/feed/space?host_mid=${encodeURIComponent(mid)}&timezone_offset=-480&features=itemOpusStyle${suffix}`,
+      context.storeDir,
+      `https://space.bilibili.com/${mid}/dynamic`,
+      source,
+      { bypassRiskCooldown: true },
+    );
+    bytes += size;
+    elapsedMs += spent;
+    videos.push(...dynamicVideos(data));
+    const next = data?.offset;
+    if (data?.has_more !== true || !next || String(next) === offset) break;
+    offset = String(next);
+    const oldest = videos.reduce((min, video) => Math.min(min, Number(video.created) * 1000 || Number.MAX_SAFE_INTEGER), Number.MAX_SAFE_INTEGER);
+    if (videos.length >= limit * 2 || oldest < cutoff) break;
+  }
+  if (videos.length === 0) throw new Error('这个 B 站空间暂时没有公开视频');
+  const name = String(videos[0]?.owner?.name || '').trim();
+  return {
+    items: videos.map((video) => itemFromVideo(video, name)).filter((item) => item.title !== ''),
+    note: name ? `来自 ${name} 的 B 站投稿` : 'B 站 UP 主更新',
+    bytes,
+    elapsedMs,
+  };
+}
+
 async function collectVideo(source, parsed, context) {
   let bvid = String(source.options.bvid || parsed.bvid || '').trim();
   let aid = String(parsed.aid || '').trim();
@@ -307,7 +402,20 @@ export async function collectBilibili(source, context = {}) {
 
   let result;
   if (mode === 'space') {
-    result = await collectSpace(String(options.mid || parsed.mid), source, context);
+    try {
+      result = await collectSpace(String(options.mid || parsed.mid), source, context);
+    } catch (error) {
+      // 空间接口限流时，宁可端出上次读到的投稿，也不要让整个来源当天消失。
+      const stale = readCache(file);
+      const items = stale?.value?.items || [];
+      if (isUnavailable(error) && items.length > 0) {
+        return {
+          ...stale.value,
+          note: [stale.value.note, '接口限流，沿用上次缓存'].filter(Boolean).join(' · '),
+        };
+      }
+      throw error;
+    }
   } else if (mode === 'ranking') {
     result = await collectRanking(source, context);
   } else {
@@ -319,6 +427,22 @@ export async function collectBilibili(source, context = {}) {
     return new Date(item.date).getTime() >= cutoff;
   });
   if (fresh.length > 0 && mode === 'space') result = { ...result, items: fresh.slice(0, options.limit ?? 8) };
+
+  // Same treatment as YouTube: count every video on the card, then keep the
+  // most-discussed one as the day's featured card with its hottest replies.
+  const enriched = await enrichBilibiliComments(result.items, options, context, (url, referer) =>
+    biliJson(url, context.storeDir, referer, source),
+  );
+  if (enriched.featured || enriched.note) {
+    result = {
+      ...result,
+      items: enriched.items,
+      bytes: (result.bytes || 0) + (enriched.bytes || 0),
+      ...(enriched.featured ? { featured: enriched.featured } : {}),
+      ...(enriched.note ? { note: [result.note, enriched.note].filter(Boolean).join(' · ') } : {}),
+    };
+  }
+
   writeCache(file, { value: result, at: Date.now() });
   return result;
 }

package/lib/engine/collect/index.js

@@ -17,7 +17,7 @@ import { collectBilibili } from './bilibili.js';
 import { collectX } from './x.js';
 import { collectSteam } from './steam.js';
 import { collectMinecraft } from './minecraft.js';
-import { truncate } from '../text.js';
+import { plainCommentText, truncate } from '../text.js';
 
 export const COLLECTORS = {
   x: collectX,
@@ -41,8 +41,38 @@ export const COLLECTORS = {
 // API hops (channel id, feed, WBI signature), so these need more headroom.
 const SLOW_TYPES = new Set(['imap', 'graph', 'browser', 'x', 'steam', 'youtube', 'bilibili']);
 
-function normalizeItem(item, source) {
+function normalizeComments(value) {
+  if (!Array.isArray(value)) return [];
+  return value
+    .slice(0, 4)
+    .map((comment) => ({
+      author: truncate(String(comment?.author ?? '').replace(/\s+/g, ' ').trim(), 48),
+      text: truncate(plainCommentText(comment?.text), 220),
+      likes: Number(comment?.likes) > 0 ? Math.round(Number(comment.likes)) : 0,
+      replies: Number(comment?.replies) > 0 ? Math.round(Number(comment.replies)) : 0,
+    }))
+    .filter((comment) => comment.text !== '');
+}
+
+function normalizeFeatured(featured, source) {
+  if (!featured || typeof featured !== 'object') return null;
+  const commentCount = Number(featured.commentCount);
   return {
+    id: truncate(String(featured.id ?? featured.url ?? ''), 300),
+    title: truncate(String(featured.title ?? ''), 200),
+    url: typeof featured.url === 'string' ? featured.url : '',
+    date: typeof featured.date === 'string' ? featured.date : '',
+    meta: truncate(String(featured.meta ?? ''), 80),
+    commentCount: Number.isFinite(commentCount) && commentCount > 0 ? Math.round(commentCount) : 0,
+    comments: normalizeComments(featured.comments),
+    sourceId: source.id,
+    sourceLabel: source.label,
+    section: source.section,
+  };
+}
+
+function normalizeItem(item, source) {
+  const out = {
     id: truncate(String(item.id ?? item.url ?? item.title ?? `${Math.random()}`), 300),
     title: truncate(String(item.title ?? ''), 200),
     url: typeof item.url === 'string' ? item.url : '',
@@ -54,6 +84,11 @@ function normalizeItem(item, source) {
     sourceId: source.id,
     sourceLabel: source.label,
   };
+  const commentCount = Number(item.commentCount);
+  if (Number.isFinite(commentCount) && commentCount > 0) out.commentCount = Math.round(commentCount);
+  const comments = normalizeComments(item.comments);
+  if (comments.length > 0) out.comments = comments;
+  return out;
 }
 
 export async function collectSource(source, context = {}) {
@@ -75,6 +110,7 @@ export async function collectSource(source, context = {}) {
       }),
     ]);
     const items = (result?.items ?? []).map((item) => normalizeItem(item, source)).filter((item) => item.title !== '');
+    const featured = normalizeFeatured(result?.featured, source);
     return {
       sourceId: source.id,
       status: result?.status ?? (items.length > 0 ? 'ok' : 'skipped'),
@@ -82,6 +118,7 @@ export async function collectSource(source, context = {}) {
       note: result?.note ?? '',
       bytes: result?.bytes,
       server: result?.server,
+      ...(featured ? { featured } : {}),
       elapsedMs: result?.elapsedMs ?? Date.now() - started,
     };
   } catch (error) {