dsh-baleen 0.1.0 → 0.2.0

package/index.js

@@ -1,9 +1,12 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { spawn } from 'node:child_process'
-import { openStore, migrate, counts, listItems, listSources, lastRun, getCursor, markFeedback, listFolders, createFolder, renameFolder, deleteFolder, setItemFolders, foldersOfItem, itemsWithFolders, candidates, latestDigests, exportItems, wipeLibrary } from './lib/store.js'
+import { openStore, migrate, counts, listItems, listSources, lastRun, getCursor, markFeedback, listFolders, createFolder, renameFolder, deleteFolder, setItemFolders, foldersOfItem, itemsWithFolders, candidates, latestDigests, exportItems, wipeLibrary, refreshItem, setMeta } from './lib/store.js'
 import { loadPreference, ensurePreferenceFile, bumpTuningFile, writePreference, readPreferenceRaw, clearTuningFile, validate } from './lib/preference.js'
 import { runOnce, syncSources } from './lib/runner.js'
+import { fetchFulltext } from './lib/fulltext.js'
+import { classifyError } from './lib/pool.js'
+import { stopXhsMcp, getXhsMcp } from './lib/mcp/xhs-client.js'
 import { createScheduler } from './lib/scheduler.js'
 import { makeLogger, redact } from './lib/diag.js'
 import { ensureHome } from './lib/paths.js'
@@ -24,7 +27,7 @@ const ALLOWED_ACTIONS = { dismiss: -0.1, save: 0.1 }
  * tuning 只走 /feedback 与 /tuning-reset，version 没有升级路径可写。
  * yt_dlp_path / network 这类进阶键留给手编文件，页签不碰。
  */
-const PREF_SECTIONS = new Set(['sources', 'follow', 'themes', 'redlines', 'schedule', 'limits', 'charter', 'require_theme_hit', 'inject_prompt'])
+const PREF_SECTIONS = new Set(['sources', 'follow', 'themes', 'redlines', 'schedule', 'limits', 'charter', 'require_theme_hit', 'inject_prompt', 'sidebar_takeover', 'sidebar_crop', 'fulltext'])
 
 /** 夹操作是白名单而不是 if 链：新加动作时漏了枚举就直接 400，不会悄悄走进某个分支 */
 const FOLDER_ACTIONS = new Set(['create', 'rename', 'delete'])
@@ -32,6 +35,32 @@ const FOLDER_ACTIONS = new Set(['create', 'rename', 'delete'])
 /** store 抛的是短码（name_taken / bad_name / …），这里只负责翻成 HTTP 语义 */
 const FOLDER_ERRORS = { name_taken: 409, name_too_long: 400, bad_name: 400, no_folder: 404, default_folder: 403 }
 
+/** 「浏览器打开」的 opener 解析链：① 注入（测试/明确指定）；② Electron 的
+ *  shell.openExternal（apply 若跑在宿主主进程里，createRequire('electron') 拿得到）；
+ *  ③ Windows 兜底 rundll32 走 ShellExecute → 默认浏览器（本机 2026-10-31 实证：
+ *  Start-Process 同一条 ShellExecute 路能拉起 Edge）。都拿不到返回 null——/open
+ *  路由据此如实回 500 open_unavailable，而不是静默 ok。
+ *  rundll32 的 exit code 不可靠，只当"发得出去"；真开不开由系统关联决定。 */
+async function resolveOpenExternal(log) {
+  try {
+    const { createRequire } = await import('node:module')
+    const electron = createRequire(import.meta.url)('electron')
+    if (electron && typeof electron.shell?.openExternal === 'function') {
+      return (url) => electron.shell.openExternal(url)
+    }
+  } catch (e) {
+    log?.({ level: 'info', event: 'open_external_opener', detail: `electron 不可用（${String(e?.code ?? e?.message ?? e).slice(0, 40)}），退回系统 rundll32` })
+  }
+  if (process.platform === 'win32') {
+    return (url) => new Promise((resolve, reject) => {
+      const child = spawn('rundll32', ['url.dll,FileProtocolHandler', url], { stdio: 'ignore' })
+      child.on('error', reject)
+      child.on('spawn', () => resolve())
+    })
+  }
+  return null
+}
+
 /**
  * /collect 自己的夹错误契约：no_folder 对齐 missing 扫描的 410（folder_gone 同源），
  * 不沿用 /folder 路由的 404。当前实际不可达——missing 扫描在前拦截，能把
@@ -280,8 +309,14 @@ export function apply(ctx, config = {}) {
   const boot = getPref()
   if (!boot.errors.length) syncSources(db, boot.pref)
   // 定时器可注入：测试里必须注入，否则一个 5 分钟的 interval 会把测试进程吊住不退出。
+  // runOnce 的正文补抓实现从这一层注入：调度器只会传 {db, pref, now, log, trigger, force}，
+  // 抓取用的 fetch 是宿主这边的事（config.fetchImpl 是既有的注入口，与工具面同一个）。
+  const runOnceWithFulltext = (opts = {}) => runOnce({
+    ...opts,
+    fetchFulltextImpl: (url, o = {}) => fetchFulltext(url, { ...o, fetchImpl: config.fetchImpl ?? globalThis.fetch })
+  })
   const scheduler = createScheduler({
-    db, getPref, runOnce, log,
+    db, getPref, runOnce: runOnceWithFulltext, log,
     now,
     tickMin: Number.isFinite(config.tickMin) ? config.tickMin : 5,
     setInterval: config.setInterval ?? setInterval,
@@ -292,6 +327,16 @@ export function apply(ctx, config = {}) {
   const credFile = path.join(dir, 'credentials', 'bili-cookie.txt')
   const probeYtDlp = makeYtDlpProbe({ spawnImpl: config.spawnImpl ?? spawn, getPref, now })
 
+  // 「浏览器打开」的出口（终审真修）：面板只报条目 id，这里查库取 URL 再交系统浏览器。
+  // opener 可注入；config 里显式给 null = 明确没有出口（测试里钉"缺席"行为用），
+  // 键缺席才走 Electron → rundll32 的解析链，解析一次并缓存。
+  let openerPromise = null
+  const getOpener = () => {
+    if (Object.hasOwn(config, 'openExternal')) return Promise.resolve(config.openExternal)
+    if (!openerPromise) openerPromise = resolveOpenExternal(log)
+    return openerPromise
+  }
+
   function state() {
     const { pref, errors } = getPref()
     const prev = lastRun(db)
@@ -405,6 +450,67 @@ export function apply(ctx, config = {}) {
           return json(res, code, { ok: false, error: code === 500 ? 'internal' : msg })
         }
       }
+      if (sub === '/open' && req.method === 'POST') {
+        // 外链出口（终审真修）：URL 只从库里来，不接受调用方传入——面板报 item_id，
+        // 宿主查库取 url。scheme 白名单 http/https 且拒带凭据的 URL（对齐宿主自己
+        // openExternal 的守卫）；opener 缺席（非 Electron 环境）如实 500 而非静默 ok。
+        let body
+        try { body = JSON.parse((await readBody(req)) || '{}') || {} } catch { return json(res, 400, { ok: false, error: 'bad_payload' }) }
+        if (!body || typeof body !== 'object' || Array.isArray(body) || !Number.isInteger(body.item_id)) {
+          return json(res, 400, { ok: false, error: 'bad_payload' })
+        }
+        const row = db.prepare('SELECT url FROM items WHERE id = ? LIMIT 1').get(body.item_id)
+        if (!row) return json(res, 404, { ok: false, error: 'no_item' })
+        let parsed = null
+        try { parsed = new URL(row.url) } catch { return json(res, 400, { ok: false, error: 'unsupported_scheme' }) }
+        if ((parsed.protocol !== 'http:' && parsed.protocol !== 'https:') || parsed.username || parsed.password) {
+          return json(res, 400, { ok: false, error: 'unsupported_scheme' })
+        }
+        const opener = await getOpener()
+        if (typeof opener !== 'function') {
+          log({ level: 'error', event: 'open_external_failed', detail: `item#${body.item_id}: opener 缺席` })
+          return json(res, 500, { ok: false, error: 'open_unavailable' })
+        }
+        try {
+          await opener(parsed.href)
+        } catch (e) {
+          log({ level: 'error', event: 'open_external_failed', detail: `item#${body.item_id}: ${String(e?.message ?? e).slice(0, 60)}` })
+          return json(res, 500, { ok: false, error: 'open_failed' })
+        }
+        log({ level: 'info', event: 'open_external', detail: `item#${body.item_id} → ${parsed.host}` })
+        return json(res, 200, { ok: true })
+      }
+      if (sub === '/xhs-status' && req.method === 'GET') {
+        // 小红书登录态探活（面板→宿主，非 agent 工具）。MCP 未配置/起不来都走 200 + 说明
+        // 文本——面板据此显示状态行，不该让一次探活把设置页打成红错。
+        const pref = getPref()
+        if (pref.errors.length || !pref.pref?.xhs?.mcp_path) {
+          return json(res, 200, { ok: true, configured: false, loggedIn: false, text: 'xhs.mcp_path 未配置（通道不启用）' })
+        }
+        try {
+          const client = await getXhsMcp(pref.pref, log)
+          const login = await client.checkLoginStatus()
+          return json(res, 200, { ok: true, configured: true, loggedIn: login.loggedIn, username: login.username, text: login.raw })
+        } catch (e) {
+          return json(res, 200, { ok: true, configured: true, loggedIn: false, text: String(e?.message ?? e).slice(0, 200) })
+        }
+      }
+      if (sub === '/xhs-login-qr' && req.method === 'GET') {
+        // 扫码登录（面板→宿主）：宿主侧调 MCP 的 get_login_qrcode，PNG 以 dataURL 回面板。
+        const pref = getPref()
+        if (pref.errors.length || !pref.pref?.xhs?.mcp_path) {
+          return json(res, 503, { ok: false, error: 'xhs.mcp_path 未配置（通道不启用）' })
+        }
+        try {
+          const client = await getXhsMcp(pref.pref, log)
+          const r = await client.callTool('get_login_qrcode')
+          const img = r.images[0]
+          if (!img?.data) return json(res, 503, { ok: false, error: (r.texts.join(' ') || '二维码为空').slice(0, 160) })
+          return json(res, 200, { ok: true, image: `data:${img.mimeType ?? 'image/png'};base64,${img.data}`, text: r.texts.join(' ').slice(0, 160) })
+        } catch (e) {
+          return json(res, 503, { ok: false, error: String(e?.message ?? e).slice(0, 200) })
+        }
+      }
       if (sub === '/folders' && req.method === 'GET') {
         return json(res, 200, { ok: true, folders: listFolders(db) })
       }
@@ -436,6 +542,46 @@ export function apply(ctx, config = {}) {
         const r = await scheduler.triggerNow()
         return json(res, 200, { ok: !r.skipped, ...r, state: state() })
       }
+      if (sub === '/fulltext' && req.method === 'POST') {
+        // 面板→宿主：按条目 id 现抓一次正文（不是 agent 工具，不进工具面）。
+        // 抓不到一律 502 + error：客户端靠"非 2xx"把按钮状态收回来（view-api.send），
+        // 回 200 配 ok:false 会让面板以为成功而白刷新一次。
+        let body
+        try { body = JSON.parse((await readBody(req)) || '{}') || {} } catch { return json(res, 400, { ok: false, error: 'bad_payload' }) }
+        if (!body || typeof body !== 'object' || Array.isArray(body) || !Number.isInteger(body.item_id)) {
+          return json(res, 400, { ok: false, error: 'bad_payload' })
+        }
+        const row = db.prepare('SELECT id, url, kind, body_state FROM items WHERE id = ? LIMIT 1').get(body.item_id)
+        if (!row) return json(res, 404, { ok: false, error: 'no_item' })
+        // 已经有正文（抓到的全文 / 视频字幕）就什么都不做：这条路由只负责补缺，
+        // 不是"再抓一次覆盖掉"——重复点击不该产生第二个网络请求。
+        if (row.body_state === 'full' || row.body_state === 'subtitle' || row.body_state === 'transcribed') {
+          return json(res, 200, { ok: true, body_state: row.body_state, already: true })
+        }
+        let parsed = null
+        try { parsed = new URL(row.url) } catch { return json(res, 400, { ok: false, error: 'unsupported_scheme' }) }
+        if ((parsed.protocol !== 'http:' && parsed.protocol !== 'https:') || parsed.username || parsed.password) {
+          return json(res, 400, { ok: false, error: 'unsupported_scheme' })
+        }
+        let got = null
+        try {
+          got = await fetchFulltext(parsed.href, { fetchImpl: config.fetchImpl ?? globalThis.fetch })
+        } catch (e) {
+          const cls = classifyError(e)
+          log({ level: 'warn', event: 'fulltext_failed', detail: `item#${row.id}: ${cls}` })
+          return json(res, 502, { ok: false, error: 'fetch_failed', error_class: cls })
+        }
+        if (!got || !got.text) {
+          log({ level: 'warn', event: 'fulltext_failed', detail: `item#${row.id}: empty` })
+          return json(res, 502, { ok: false, error: 'fetch_failed', error_class: 'empty' })
+        }
+        // 只改正文两列 + fetched_at：不动 status（面板刷新后它还是那条候选）。
+        refreshItem(db, row.id, { body_text: got.text, body_state: 'full', fetched_at: now() })
+        // 手动抓成功就把自动补抓的失败计数清零，让下一轮愿意再试
+        setMeta(db, `fulltext:fail:${row.id}`, 0)
+        log({ level: 'info', event: 'fulltext_ok', detail: `item#${row.id}: ${got.chars} 字` })
+        return json(res, 200, { ok: true, body_state: 'full', chars: got.chars })
+      }
       if (sub === '/feedback' && req.method === 'POST') {
         const body = JSON.parse((await readBody(req)) || '{}') || {}
         const actionDelta = ALLOWED_ACTIONS[body.action]
@@ -680,6 +826,10 @@ export function apply(ctx, config = {}) {
     return () => scheduler.stop(handle)
   }, 'dsh-baleen: scheduler')
 
+  // xhs 的 MCP 子进程（M6）：惰性拉起（配了 xhs 源且首次抓取才 spawn），禁用插件时
+  // 跟着停——没拉起过就是空操作。
+  ctx.effect(() => () => stopXhsMcp(), 'dsh-baleen: xhs-mcp')
+
   log({ level: 'info', event: 'plugin_loaded', detail: `M1 摄取侧就绪（只读路由 ${API_ROUTE}）` })
   return baleen
 }

package/lib/adapters/index.js

@@ -1,13 +1,14 @@
 import { rssAdapter } from './rss.js'
 import { biliAdapter } from './bili.js'
 import { ytAdapter } from './yt.js'
+import { xhsAdapter } from './xhs.js'
 
 /**
- * 适配器注册表。M1 只有 rss；bili（M4a）与 yt（M4b）已登记，xhs 由后续计划进，
- * runner 不需要认识任何具体平台——它只按 source.type 查这张表。
+ * 适配器注册表。M1 只有 rss；bili（M4a）与 yt（M4b）已登记；xhs（M6）经官方 MCP
+ * 接入——runner 不需要认识任何具体平台——它只按 source.type 查这张表。
  */
-export const ADAPTERS = { rss: rssAdapter, bili: biliAdapter, yt: ytAdapter }
-export { rssAdapter, biliAdapter, ytAdapter }
+export const ADAPTERS = { rss: rssAdapter, bili: biliAdapter, yt: ytAdapter, xhs: xhsAdapter }
+export { rssAdapter, biliAdapter, ytAdapter, xhsAdapter }
 
 export function adapterFor(type) {
   const key = String(type ?? '').toLowerCase()

package/lib/adapters/xhs.js

@@ -0,0 +1,173 @@
+import { getXhsMcp } from '../mcp/xhs-client.js'
+
+export const type = 'xhs'
+
+/**
+ * xhs 适配器 —— 小红书搜索关键词 → 笔记列表 → 逐条详情，经官方 MCP（HTTP，见
+ * lib/mcp/xhs-client.js）。选型与边界见 docs/v3-xhs-mcp-audit.md（V3）与 M6 计划：
+ *
+ * 边界（AGENTS.md 适配器红线，与 bili/yt 同款）：
+ *  - 只读：search_feeds / get_feed_detail / check_login_status 全是查询，写工具
+ *    在 client 白名单就被拒（红线之下的第二道闸）；
+ *  - 不判断、不写库：产出 RawItem，增量判定交给 putDraft 去重、backlog 交给 gate；
+ *  - 零重试：本层从不重试，失败上抛交 pool 分类（needs_login / mcp_missing /
+ *    xhs_risk 各自钉 error_class，游标不推进）。
+ */
+
+/** 每轮新条目上限：xhs 的详情是浏览器逐页滚动（比 B 站/yt 的 API 慢一个量级），
+ *  真机两轮实证 12 条装不进 90s/180s 预算——降到 6，余量按分批纪律留给下轮。 */
+const MAX_NEW_PER_RUN = 6
+/** 详情并发 2：小红书风控比 B 站敏感，礼貌优先；job 预算 90s 兜得住。 */
+const DETAIL_CONCURRENCY = 2
+
+function fail(message, props = {}) {
+  return Object.assign(new Error(message), props)
+}
+
+async function mapLimit(list, limit, fn) {
+  const results = new Array(list.length)
+  let next = 0
+  let broken = null
+  async function worker() {
+    while (broken === null) {
+      const i = next++
+      if (i >= list.length) return
+      try {
+        results[i] = await fn(list[i], i)
+      } catch (e) {
+        broken = e
+        throw e
+      }
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(limit, list.length) }, worker))
+  if (broken !== null) throw broken
+  return results
+}
+
+/** 互动数是小红书给的展示字符串（"26826"，偶尔带分隔），能解析就给数字，解析不了给 null 不编数。 */
+function parseCount(s) {
+  const n = Number(String(s ?? '').replace(/[,\s]/g, ''))
+  return Number.isFinite(n) && n >= 0 ? n : null
+}
+
+/** 笔记详情页地址。xsec_token 是详情接口的入场券（搜索结果自带），随 URL 保全。 */
+export function noteUrl(id, xsecToken) {
+  const q = new URLSearchParams({ xsec_token: String(xsecToken ?? ''), xsec_source: 'pc_search' })
+  return `https://www.xiaohongshu.com/explore/${encodeURIComponent(String(id))}?${q}`
+}
+
+/**
+ * fetchXhs(source, {…}) → RawItem[]
+ * 源主键是 source.query（搜索关键词）；needs_login 是一等公民错误类：登录态过期
+ * 本轮整源跳过，汇报里明写，不重试不静默。
+ */
+export async function fetchXhs(source, {
+  signal,
+  now = Date.now,
+  pref = null,
+  knownIds = null,
+  log = () => {},
+  mcp = null // 注入缝（测试/替身）；缺省走 getXhsMcp（惰性 spawn + 会话缓存）
+} = {}) {
+  // 关键词从 source.url 的 query 参数派生：sources 表只回传 url（与 bili 的 space URL
+  // 同构），preference 里的 query 字段进不了表。两种写法都收（query 优先）。
+  let keyword = String(source?.query ?? '').trim()
+  try {
+    const fromUrl = new URL(String(source?.url ?? '')).searchParams.get('query')
+    if (!keyword && fromUrl && fromUrl.trim()) keyword = fromUrl.trim()
+  } catch { /* url 不是合法 URL 时走 query 分支的报错 */ }
+  if (!keyword) {
+    throw fail('xhs 源解析不出搜索关键词——url 要形如 xiaohongshu.com/search?query=…', { error_class: 'bad_source' })
+  }
+  mcp = mcp ?? await getXhsMcp(pref, log)
+
+  const login = await mcp.checkLoginStatus()
+  if (!login.loggedIn) {
+    throw fail('小红书未登录——本轮跳过；到 设置 → 凭据与环境 重新扫码', { error_class: 'needs_login' })
+  }
+  if (login.username) log('xhs_login_as', `登录态有效（${login.username}）`)
+
+  const search = await mcp.searchFeeds(keyword)
+  const feeds = Array.isArray(search?.feeds) ? search.feeds : []
+  if (!feeds.length) {
+    throw fail(`xhs 搜索 "${keyword}" 没有返回任何笔记——关键词太冷门或风控拦了，先在浏览器里搜一次核对`, { empty: true })
+  }
+
+  // 已入库跳过（纯内存过滤，发生在任何 detail 请求之前）+ 每轮上限（预算分批）。
+  let fresh = feeds.filter((f) => f?.id)
+  if (knownIds?.size) {
+    const before = fresh.length
+    fresh = fresh.filter((f) => !knownIds.has(String(f.id)))
+    if (fresh.length < before) log('xhs_skipped_known', `${before - fresh.length} 条已入库，跳过详情`)
+  }
+  if (fresh.length > MAX_NEW_PER_RUN) {
+    const deferred = fresh.length - MAX_NEW_PER_RUN
+    fresh = fresh.slice(0, MAX_NEW_PER_RUN)
+    log('xhs_deferred', `本轮只处理 ${MAX_NEW_PER_RUN} 条新笔记，${deferred} 条留待下轮`)
+  }
+
+  // 详情受限并发 2；单条详情失败只跳过该条（一条风控不该掀翻整源），needs_login 级
+  // 的整源错误只可能发生在前面的探测与搜索阶段。
+  const mapped = await mapLimit(fresh, DETAIL_CONCURRENCY, async (f) => {
+    try {
+      const detail = await mcp.getFeedDetail(String(f.id), String(f.xsecToken ?? ''))
+      return toItem(detail, f, source, { now, signal })
+    } catch (e) {
+      log('xhs_item_skipped', `笔记 ${f.id} 详情失败被跳过：${String(e?.message ?? e).slice(0, 80)}`)
+      return null
+    }
+  })
+  return mapped.filter(Boolean)
+}
+
+/**
+ * 详情 → RawItem。详情 JSON 的字段名以实机返回为准做防御式读取；detail 不可用时
+ * 回落搜索卡片（列表里也有标题/作者/封面，只是没有正文——body_state 会如实降为 summary）。
+ */
+function toItem(detail, card, source, { now, signal }) {
+  // 工具的返回可能是 {note: …} / {currentNote: …} / 直接是笔记本体，逐层兜。
+  const note = detail?.note ?? detail?.currentNote ?? detail?.data?.note ?? (detail?.id ? detail : null)
+  const noteCard = card?.noteCard ?? {}
+  const interact = note?.interactInfo ?? noteCard.interactInfo ?? {}
+  const user = note?.user ?? noteCard.user ?? {}
+  const type = String(note?.type ?? noteCard.type ?? 'normal').toLowerCase()
+  const id = String(note?.id ?? card?.id ?? '')
+  if (!id) return null
+
+  const video = note?.video ?? noteCard.video ?? null
+  const durationSec = Number(video?.capa?.duration ?? video?.duration ?? NaN)
+  const images = Array.isArray(note?.imageList) ? note.imageList : []
+  const cover = noteCard.cover?.urlDefault || noteCard.cover?.url || images[0]?.urlDefault || images[0]?.url || null
+
+  const desc = typeof note?.desc === 'string' ? note.desc : ''
+  const title = String(note?.title ?? noteCard.displayTitle ?? '').trim()
+  const timeMs = Number(note?.time ?? NaN)
+
+  return {
+    source_id: source.id,
+    external_id: id,
+    title: title || '（无标题）',
+    url: noteUrl(id, note?.xsecToken ?? card?.xsecToken),
+    author: user.nickname ?? user.nickName ?? null,
+    author_id: user.userId ?? null,
+    // 小红书给不了可靠的发布时间就如实缺省（time_estimated 由 normalize 按缺省置 1）
+    published_at: Number.isFinite(timeMs) && timeMs > 0 ? timeMs : null,
+    fetched_at: now(),
+    thumb: cover,
+    // video 笔记 kind 归 video（有 duration 时 normalize 也认）；图文归 note——M1 预留的形态位
+    note_type: type === 'video' ? 'video' : 'image',
+    duration_sec: Number.isFinite(durationSec) && durationSec > 0 ? Math.round(durationSec) : null,
+    stats: {
+      likes: parseCount(interact.likedCount),
+      collects: parseCount(interact.collectedCount),
+      comments: parseCount(interact.commentCount)
+    },
+    // 正文：详情拿得到就是 full；detail 被跳过时 card 只有标题 → summary 由 normalize 判
+    body_html: desc ? `<p>${desc.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/\n/g, '</p><p>')}</p>` : '',
+    summary_html: desc ? `<p>${desc.slice(0, 200)}</p>` : (noteCard.displayTitle ? `<p>${noteCard.displayTitle}</p>` : ''),
+    tags: Array.isArray(note?.tagList) ? note.tagList.map((t) => t.name).filter(Boolean) : []
+  }
+}
+
+export const xhsAdapter = { type, fetch: fetchXhs }

package/lib/dedup.js

@@ -4,6 +4,12 @@ import { getItemByKey, findByUrl, findByTitleNorm, insertItem, refreshItem, setS
 const WINDOW = 14 * 86400000
 const MIN_TITLE_NORM = 8
 
+/**
+ * 「这条已经有可读正文了」的三态。full 是抓到的全文，subtitle/transcribed 是视频的字幕。
+ * summary_only / missing / burned_in 都不在此列——它们本来就该被更好的正文覆盖。
+ */
+const HAS_BODY = new Set(['full', 'subtitle', 'transcribed'])
+
 /**
  * 去掉空白与标点做比较键。"转载时改个问号/加个空格"是最常见的重复形态，
  * 但短到两三个字的标题（"教程"）不配参与查重，否则会把一片正常内容误吞掉。
@@ -49,7 +55,16 @@ export function putDraft(db, draft, now = Date.now) {
     if (key.status === 'archived' && !String(key.archived_reason ?? '').startsWith('duplicate')) {
       return { id: key.id, action: 'skip_seen', reason: `archived:${key.archived_reason}` }
     }
-    refreshItem(db, key.id, row, 'new')
+    // 已经抓到过正文的条目，不能被"这一轮又只给了摘要"覆盖回 summary_only：
+    // RSS 每轮都只搬 feed 的摘要，正文是我们另外去原文抓的（lib/fulltext.js）。
+    // 不挡这一下，补抓就变成每轮重抓一遍——既烧请求，也会让"已补全"这件事在库里
+    // 反复丢失。只剔 body 两列，其余（标题、分数、时间、thumb）照旧刷新。
+    const patch = { ...row }
+    if (HAS_BODY.has(key.body_state) && !HAS_BODY.has(row.body_state)) {
+      delete patch.body_text
+      delete patch.body_state
+    }
+    refreshItem(db, key.id, patch, 'new')
     return { id: key.id, action: 'update' }
   }
 

package/lib/fulltext.js

@@ -0,0 +1,222 @@
+/**
+ * fulltext.js —— 从原文页面抽正文，补「RSS 只给摘要」这个缺口。
+ *
+ * 为什么手写而不是引库：Readability 那一套是几万行加依赖，而这里只需要
+ * 「article/main/body 里挑一个容器、丢掉评论区与推荐区、收 p/h2/h3/li」。
+ * 判据是**宁可抽不到，也不要把评论区当正文**：抽出来太短就返回空串，
+ * 调用方据此保留原来的摘要——把评论与推荐当正文，比只读摘要更糟。
+ */
+
+import { stripTags } from './feed.js'
+
+export const FULLTEXT_MIN_CHARS = 400
+
+// 整块连内容一起丢：这些标签里要么是脚本样式，要么是页面框架，从来不是正文
+const DROP_TAGS = ['script', 'style', 'noscript', 'iframe', 'svg', 'form', 'header', 'footer', 'nav', 'aside']
+// 正文容器内按 class/id 判噪音（评论、分享、相关推荐、订阅、面包屑……）
+const NOISE_RE = /comment|share|related|recommend|sidebar|footer|nav|advert|promo|subscribe|newsletter|cookie|breadcrumb|social|toolbar/i
+// 只认这四类段落标签。div 里也常有正文，但 div 也常有导航和页脚——认它等于把噪音请回来
+const SEG_OPEN_RE = /<(p|h2|h3|li)\b[^>]*>/gi
+
+/**
+ * 找到 from 之后与 start 处同名开标签配对的闭合标签位置（同名嵌套按深度算）。
+ * 正则非贪婪在 `<div class="comments"><div class="comments">…</div></div>` 上会切在内层
+ * 闭合处，把外层剩下的正文一起吞掉，所以这里必须数深度。
+ */
+function closeIndex(text, from, tag) {
+  const openRe = new RegExp(`<${tag}(?:\\s[^>]*)?>`, 'gi')
+  const closeRe = new RegExp(`</${tag}\\s*>`, 'gi')
+  openRe.lastIndex = from
+  closeRe.lastIndex = from
+  let depth = 1
+  while (true) {
+    const c = closeRe.exec(text)
+    if (!c) return -1
+    const o = openRe.exec(text)
+    if (o && o.index < c.index) {
+      depth++
+      openRe.lastIndex = o.index + 1
+      closeRe.lastIndex = c.index + 1
+      continue
+    }
+    depth--
+    if (depth === 0) return c.index
+    closeRe.lastIndex = c.index + 1
+  }
+}
+
+/**
+ * 把某个标签的整块（含内容）剪掉。
+ * 没闭合时只剪开标签本身、内容留着——脚本样式整块丢是对的，
+ * 但一个坏页面不该因为少了一个 </header> 就把全文一起吞掉。
+ */
+function dropBlocks(text, tag) {
+  const openRe = new RegExp(`<${tag}(?:\\s[^>]*)?>`, 'gi')
+  let out = ''
+  let cursor = 0
+  let m
+  while ((m = openRe.exec(text))) {
+    const end = closeIndex(text, m.index + m[0].length, tag)
+    if (end < 0) continue
+    out += text.slice(cursor, m.index) + ' '
+    cursor = end + tag.length + 3
+    openRe.lastIndex = cursor
+  }
+  return out + text.slice(cursor)
+}
+
+/** 取 class 或 id 的原文（单双引号都认，无引号的值也收） */
+function attrOf(attrs, name) {
+  const m = new RegExp(`${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s>]+))`, 'i').exec(attrs)
+  return m ? (m[1] ?? m[2] ?? m[3] ?? '') : ''
+}
+
+/**
+ * 容器内按 class/id 丢噪音块：一次只剪一个命中，剪完从同一位置继续，
+ * 嵌套的随外层一起消失。先剪外层再扫内层，所以不会出现「父元素文字被连带丢掉」。
+ */
+function dropNoise(text) {
+  const re = /<([a-zA-Z][a-zA-Z0-9:-]*)((?:\s[^>]*)?)>/g
+  let out = ''
+  let cursor = 0
+  let m
+  while ((m = re.exec(text))) {
+    const attrs = m[2] ?? ''
+    if (!NOISE_RE.test(`${attrOf(attrs, 'class')} ${attrOf(attrs, 'id')}`)) continue
+    const end = closeIndex(text, m.index + m[0].length, m[1])
+    out += text.slice(cursor, m.index) + ' '
+    if (end < 0) {
+      // 自闭合或没闭合（img/br 一类）：只剪开标签，后面照常扫
+      cursor = m.index + m[0].length
+      re.lastIndex = cursor
+      continue
+    }
+    cursor = end + m[1].length + 3
+    re.lastIndex = cursor
+  }
+  return out + text.slice(cursor)
+}
+
+/** 正文容器：优先 article，其次 main，再次 body；都没闭合就退回全文 */
+function pickContainer(html) {
+  for (const tag of ['article', 'main', 'body']) {
+    const m = new RegExp(`<${tag}(?:\\s[^>]*)?>`, 'i').exec(html)
+    if (!m) continue
+    const end = closeIndex(html, m.index + m[0].length, tag)
+    if (end < 0) continue
+    return html.slice(m.index + m[0].length, end)
+  }
+  return html
+}
+
+/**
+ * 收段落文字。闭合的取配对区间；HTML 允许省略 </p>，没闭合的取到下一个段落开标签为止
+ * （真实博客里 `<p>甲<p>乙</p>` 这种写法比想象的常见，整段吞掉就等于白抓）。
+ */
+function collectSegments(text, segs) {
+  let m
+  SEG_OPEN_RE.lastIndex = 0
+  while ((m = SEG_OPEN_RE.exec(text))) {
+    const tag = m[1].toLowerCase()
+    const start = m.index + m[0].length
+    const end = closeIndex(text, start, tag)
+    if (end < 0) {
+      // 注意：exec 落空会把 lastIndex 归零，所以探路用另一枚正则
+      const ahead = new RegExp(SEG_OPEN_RE.source, 'gi')
+      ahead.lastIndex = start
+      const nxt = ahead.exec(text)
+      push(stripTags(text.slice(start, nxt ? nxt.index : text.length)), segs)
+      if (!nxt) break
+      SEG_OPEN_RE.lastIndex = nxt.index
+      continue
+    }
+    push(stripTags(text.slice(start, end)), segs)
+    SEG_OPEN_RE.lastIndex = end + tag.length + 3
+  }
+  return segs
+}
+
+/** 空段丢掉，相邻重复段只留一次（分享按钮里常把标题重复一遍） */
+function push(seg, segs) {
+  if (!seg) return
+  if (seg === segs[segs.length - 1]) return
+  segs.push(seg)
+}
+
+/**
+ * HTML → 纯文本（段落之间两个换行）。
+ * 抽出来比 FULLTEXT_MIN_CHARS 短就返回空串：'' 表示「没抽到比摘要更多的东西」，
+ * 调用方据此不覆盖已有内容——这是这个模块唯一对外承诺的语义。
+ */
+export function extractFulltext(html, url = '') {
+  let text = String(html ?? '').replace(/<!--[\s\S]*?-->/g, ' ')
+  for (const tag of DROP_TAGS) text = dropBlocks(text, tag)
+  text = dropNoise(pickContainer(text))
+  const segs = collectSegments(text, [])
+  const out = segs.join('\n\n')
+  return out.length >= FULLTEXT_MIN_CHARS ? out : ''
+}
+
+/**
+ * 抓 url 再抽正文。失败全部上抛，交给 pool 的 classifyError：
+ * HTTP 非 2xx → e.status；不是 HTML → e.parse；抽不到东西 → e.empty；
+ * 超时 → name='TimeoutError'。三种失败都只该让这条退回摘要，不该让一轮抓取停摆。
+ */
+export async function fetchFulltext(url, { signal, fetchImpl = globalThis.fetch, timeoutMs = 15000 } = {}) {
+  const controller = new AbortController()
+  const onAbort = () => controller.abort()
+  if (signal) {
+    if (signal.aborted) controller.abort()
+    else signal.addEventListener('abort', onAbort, { once: true })
+  }
+
+  let timer
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      controller.abort()
+      const e = new Error(`正文抓取超过 ${timeoutMs}ms 无响应`)
+      e.name = 'TimeoutError'
+      reject(e)
+    }, timeoutMs)
+  })
+
+  const work = (async () => {
+    const res = await fetchImpl(url, {
+      signal: controller.signal,
+      redirect: 'follow',
+      headers: {
+        'User-Agent': 'baleen/0.1.0 (+local; fulltext)',
+        Accept: 'text/html,application/xhtml+xml'
+      }
+    })
+    if (!res?.ok) {
+      const e = new Error(`HTTP ${res?.status ?? '?'}`)
+      e.status = res?.status ?? 0
+      throw e
+    }
+    const ctype = String(res.headers?.get?.('content-type') ?? '')
+    // xhtml 也是 HTML：Accept 里带了它，回过来就不该被当成"不是网页"
+    if (!/text\/html|application\/xhtml\+xml/i.test(ctype)) {
+      const e = new Error(`不是 HTML（content-type=${ctype || '缺失'}）`)
+      e.parse = true
+      throw e
+    }
+    const body = await res.text()
+    const text = extractFulltext(body, url)
+    if (!text) {
+      const e = new Error('页面里抽不出比摘要更多的正文')
+      e.empty = true
+      throw e
+    }
+    return { text, chars: text.length }
+  })()
+  // 超时先赢时 work 的迟到拒绝会变成 unhandledRejection，先挂个空 catch 兜住
+  work.catch(() => {})
+
+  try {
+    return await Promise.race([work, timeout])
+  } finally {
+    clearTimeout(timer)
+    if (signal) signal.removeEventListener('abort', onAbort)
+  }
+}