📄 docs(bookSource): 收录光遇聚合书源作为参考基线

本次聚合书源(发现页样式/段评气泡/前缀搜索)的架构参考来源，便于后续对照维护；忽略 .codegraph 本地索引目录
🔧 fix(deploy): 证书方案从 certbot 迁移到 acme.sh
2026-10-10 12:52:53 +08:00 · 2026-10-10 12:52:53 +08:00 · 2026-10-10 12:49:00 +08:00 · 2026-10-10 12:48:59 +08:00 · 2026-10-10 02:14:44 +08:00 · 2026-10-10 02:09:29 +08:00
19 changed files with 1333 additions and 147 deletions
@@ -32,8 +32,10 @@ SRC_DIR="/root/code/novel/fanqie-go"
 DOMAIN="fq.20010117.xyz"

 # ---------- 证书 ----------
-# Certbot 申请证书的邮箱，用于接收过期提醒
+# acme.sh 申请证书的邮箱，用于账户注册与过期提醒
 CERT_EMAIL="you@example.com"
+# 证书安装目录（acme.sh --install-cert 目标，nginx 配置从此处读取）
+# CERT_DIR="/etc/nginx/ssl"

 # ---------- 编译 ----------
 # BUILD_TARGET="./cmd/fanqie"
@@ -47,6 +47,7 @@ __pycache__
 /build/

 cache.db
+video_cache/

 # Build output
 fanqie-*
@@ -56,3 +57,4 @@ fanqie-*
 .env
 .finesse/
 fanqie.log
+.codegraph/
@@ -0,0 +1,63 @@
+[
+  {
+    "bookSourceName": "🔅番茄聚合",
+    "bookSourceGroup": "📖番茄小说",
+    "bookSourceType": 0,
+    "bookSourceUrl": "https://fq.20010117.xyz",
+    "bookSourceComment": "番茄聚合书源（fanqie-go 后端）\n\n基础使用教程：\n1、搜索：\n    1) 基础搜索：直接搜，默认搜索当前模式内容\n    2) 快捷搜索：使用特殊关键词(x,t,m,d)搜索\n         x:书名  如(x:十日终焉)  搜小说（可省略）\n         t:书名  如(t:十日终焉)  搜听书\n         m:书名  如(m:十日终焉)  搜漫画\n         d:书名  如(d:十日终焉)  搜短剧\n         冒号支持中文英文，也可在书源设置中切换默认搜索模式\n2、发现页：\n    顶部筛选选择 类型/频道/字数/更新/排序 后，点击分类宫格浏览，下拉翻页\n3、段评：\n    阅读正文时点击段尾气泡即可查看段落评论，样式可在段评设置中调整\n4、听书/漫画/短剧：\n    听书自动用播放器播放；漫画走服务端解密代理；短剧打开章节自动唤起播放\n\n更换服务器地址：只需修改源URL(bookSourceUrl)，全部规则使用相对地址自动跟随",
+    "bookSourceEnabled": true,
+    "enabledExplore": true,
+    "enabledCookieJar": true,
+    "customOrder": 0,
+    "weight": 0,
+    "respondTime": 180000,
+    "lastUpdateTime": 1791607295124,
+    "bookUrlPattern": "https?:\\/\\/(?:[a-zA-Z0-9-]+\\.)?[a-zA-Z0-9-]+(?::\\d+)?\\/detail\\?book_id=\\d+.*",
+    "jsLib": "// 当前书源版本号\nlet localVersion = '26.10.10';\n\n// 初始配置\nconst defaultConfig = {\n    发现页类型: \"小说\",\n    频道: \"男频\",\n    搜索模式: \"小说\"\n};\n\n// 获取源变量\nfunction getVariable(k) {\n    if (k == undefined) k = \"\";\n    const { source } = this;\n    let parsed = {};\n    try {\n        parsed = JSON.parse(source.getVariable());\n    } catch {}\n    if (k == \"\") {\n        return parsed;\n    }\n    let value = parsed[k];\n    if (value == undefined) {\n        value = defaultConfig[k];\n    }\n    return value != undefined ? value : \"\";\n}\n\n// 设置源变量\nfunction setVariable(k, v, t) {\n    if (t == undefined) t = true;\n    const { source, java } = this;\n    const vs = this.getVariable();\n    vs[k] = v;\n    source.setVariable(JSON.stringify(vs, null, 4));\n    if (k != '搜索关键词' && t) {\n        java.toast(`\\n设置 ${k} 为 ${v}`)\n    }\n}\n\n// 还原\nfunction deleteVariable() {\n    const { source, java } = this;\n    source.setVariable('');\n    java.longToast('\\n所有设置已还原到初始化导入状态');\n}\n\n// 从 URL 提取内容类型标记(n小说/t听书/m漫画/d短剧)。\n// 注意：jsLib 函数作用域看不到规则变量 baseUrl，必须由调用方显式传入\nfunction fqTab(url, def) {\n    if (def == undefined) def = 'n';\n    let m = String(url).match(/fqtab=([ntmd])/);\n    return m ? m[1] : def;\n}\n\n// 判断当前环境\nfunction checkEnv() {\n    const {\n        java,\n        source\n    } = this;\n\n    try {\n        java.qread();\n        return \"轻阅读\";\n    } catch (e) {}\n\n    try {\n        if (typeof java.reLoginView == 'function') {\n            return \"改版\";\n        }\n        new Packages.io.legato.kazusa.utils.TimeoutCancellationException('');\n        return \"改版\";\n    } catch (e) {}\n    try {\n        java.deviceID();\n        return \"苹果\";\n    } catch (e) {}\n\n    if (typeof source.loginUi == 'function') {\n        return \"安卓\";\n    }\n\n    return \"改版\";\n}\n\n// 备用设置方案（登录页按钮）\nfunction ste(v) {\n    const { java } = this;\n    let moreSettings = this.getVariable(\"更多设置\") || {};\n    let paraSettings = this.getVariable(\"段评设置\") || {};\n    if (v == \"段评\") {\n        if (paraSettings[\"段评开关\"] != \"false\") {\n            paraSettings[\"段评开关\"] = \"false\";\n            java.longToast(\"\\n❌段评已关闭\");\n        } else {\n            paraSettings[\"段评开关\"] = \"true\";\n            java.longToast(\"\\n✅段评已开启\");\n        }\n    }\n    if (v == \"小说\" || v == \"听书\" || v == \"漫画\" || v == \"短剧\") {\n        moreSettings[\"搜索模式\"] = v;\n        java.longToast(`\\n已设置搜索模式为 ${v}`);\n    }\n    if (v == \"图片\") {\n        if (moreSettings[\"显示图片\"] != \"false\") {\n            moreSettings[\"显示图片\"] = \"false\";\n            java.longToast(\"\\n❌已关闭图片显示\");\n        } else {\n            moreSettings[\"显示图片\"] = \"true\";\n            java.longToast(\"\\n✅已开启图片显示\");\n        }\n    }\n    if (v == \"简介\") {\n        if (moreSettings[\"完整简介\"] != \"false\") {\n            moreSettings[\"完整简介\"] = \"false\";\n            java.longToast(\"\\n❌已关闭完整简介\");\n        } else {\n            moreSettings[\"完整简介\"] = \"true\";\n            java.longToast(\"\\n✅已开启完整简介\");\n        }\n    }\n    this.setVariable(\"更多设置\", moreSettings, false);\n    this.setVariable(\"段评设置\", paraSettings, false);\n}\n\n// 按钮切换时改变源变量并刷新发现\nfunction show(m, t) {\n    const { java, source } = this;\n    let data = {};\n    try {\n        data = JSON.parse(source.getVariable())\n    } catch {}\n    data[t] = m;\n    if (t == \"发现页类型\") {\n        data[\"频道\"] = '男频';\n    }\n    source.setVariable(JSON.stringify(data, null, 2));\n    java.refreshExplore();\n}\n\nfunction createFilter(title, chars, defaultVal, paramKey, size, viewName) {\n    if (viewName == undefined) viewName = \"'请选择类型'\";\n    return {\n        title: title,\n        type: \"select\",\n        chars: chars,\n        default: defaultVal,\n        \"viewName\": viewName,\n        action: `show(infoMap['${title}'],'${paramKey}')`,\n        style: {\n            layout_flexGrow: 1,\n            layout_flexBasisPercent: size\n        }\n    };\n}\n\nfunction createText(title, action, defaultValue, size, viewName) {\n    return {\n      title: title,\n      type: 'text',\n      default: defaultValue || '',\n      action: action,\n      viewName: viewName || title,\n      style: {\n        layout_flexGrow: 1,\n        layout_flexBasisPercent: size\n      }\n    };\n}\n\nfunction createButton(title, action, size) {\n    return {\n      title: title,\n      type: 'butLine truncated
+    "loginUi": "[\n    {\n        \"name\": \"⚙️ 书源设置\",\n        \"type\": \"button\",\n        \"action\": \"getHtmlSettings()\",\n        \"style\": { \"layout_flexGrow\": 1, \"layout_flexBasisPercent\": 0.4 }\n    }, {\n        \"name\": \"🗨 段评设置\",\n        \"type\": \"button\",\n        \"action\": \"getSvgSettings()\",\n        \"style\": { \"layout_flexGrow\": 1, \"layout_flexBasisPercent\": 0.4 }\n    }, {\n        \"name\": \"===下方为备用设置方案===\",\n        \"type\": \"button\",\n        \"action\": \"\",\n        \"style\": { \"layout_flexGrow\": 1, \"layout_flexBasisPercent\": 1 }\n    }, {\n        \"name\": \"📖搜索小说\",\n        \"type\": \"button\",\n        \"action\": \"ste('小说')\",\n        \"style\": { \"layout_flexGrow\": 1, \"layout_flexBasisPercent\": 0.4 }\n    }, {\n        \"name\": \"🎧搜索听书\",\n        \"type\": \"button\",\n        \"action\": \"ste('听书')\",\n        \"style\": { \"layout_flexGrow\": 1, \"layout_flexBasisPercent\": 0.4 }\n    }, {\n        \"name\": \"🎥搜索短剧\",\n        \"type\": \"button\",\n        \"action\": \"ste('短剧')\",\n        \"style\": { \"layout_flexGrow\": 1, \"layout_flexBasisPercent\": 0.4 }\n    }, {\n        \"name\": \"🎨搜索漫画\",\n        \"type\": \"button\",\n        \"action\": \"ste('漫画')\",\n        \"style\": { \"layout_flexGrow\": 1, \"layout_flexBasisPercent\": 0.4 }\n    }, {\n        \"name\": \"段评开关\",\n        \"type\": \"button\",\n        \"action\": \"ste('段评')\",\n        \"style\": { \"layout_flexGrow\": 1, \"layout_flexBasisPercent\": 0.25 }\n    }, {\n        \"name\": \"图片开关\",\n        \"type\": \"button\",\n        \"action\": \"ste('图片')\",\n        \"style\": { \"layout_flexGrow\": 1, \"layout_flexBasisPercent\": 0.25 }\n    }, {\n        \"name\": \"简介开关\",\n        \"type\": \"button\",\n        \"action\": \"ste('简介')\",\n        \"style\": { \"layout_flexGrow\": 1, \"layout_flexBasisPercent\": 0.25 }\n    }, {\n        \"name\": \"⛔‼️ 清空还原设置\",\n        \"type\": \"button\",\n        \"action\": \"deleteVariable()\",\n        \"style\": { \"layout_flexGrow\": 1, \"layout_flexBasisPercent\": 1 }\n    }\n]",
+    "searchUrl": "<js>\nlet moreSettings = getVariable('更多设置');\nlet tab = moreSettings && moreSettings['搜索模式'] || '小说';\nvar k = String(key);\nlet m = k.match(/^[xtmdXTMD][:：]\\s*/);\nif (m) {\n    tab = { x: '小说', t: '听书', m: '漫画', d: '短剧' }[m[0][0].toLowerCase()];\n    k = k.slice(m[0].length);\n}\nlet tabType = { 小说: 3, 听书: 2, 漫画: 8, 短剧: 11 }[tab] || 3;\n`/search?query=${encodeURIComponent(k)}&offset=${(page - 1) * 10}&tab_type=${tabType}`;\n</js>",
+    "exploreUrl": "<js>\nvar base = String(source.getKey()).replace(/\\/$/, '');\nvar tab = getVariable('发现页类型') || '小说';\nvar channel = getVariable('频道') || '男频';\nvar wordNumMap = { '不限': '0', '30万字以内': '4', '100万字以内': '1', '30万-100万': '5', '100万-300万': '2', '300万字以上': '3', '100万字以上': '9' };\nvar updateMap = { '不限': '2', '完结': '0', '连载中': '1', '今日更新': '3' };\nvar sortMap = { '综合': '0', '热门': '24', '最新': '76', '评分': '12' };\nvar wordNum = getVariable('字数') || '不限';\nvar update = getVariable('更新') || '不限';\nvar sort = getVariable('排序') || '综合';\nvar q = `&word_number=${wordNumMap[wordNum] || '0'}&book_status=${updateMap[update] || '2'}&sort_by=${sortMap[sort] || '0'}`;\nvar tabCode = { 小说: 'n', 听书: 't', 漫画: 'm', 短剧: 'd' }[tab] || 'n';\n\nvar list = [];\nlist.push(createFilter('类型', ['小说', '听书', '短剧', '漫画'], tab, '发现页类型', 0.4));\nlist.push(createFilter('频道', ['男频', '女频'], channel, '频道', 0.4));\nlist.push(createText('搜索关键词', \"setVariable('搜索关键词',(infoMap['搜索关键词'] || (infoMap.get && infoMap.get('搜索关键词'))))\", getVariable('搜索关键词') || '', 0.5, \"'搜索书名或作者'\"));\nlist.push(createButton('🔍搜索', 'exploreSearch()', 0.3));\nlist.push({ title: '⚙️书源设置', type: 'button', action: 'getHtmlSettings()', style: { layout_flexGrow: 1, layout_flexBasisPercent: 0.25 } });\nlist.push({ title: '🗨段评设置', type: 'button', action: 'getSvgSettings()', style: { layout_flexGrow: 1, layout_flexBasisPercent: 0.25 } });\nlist.push(createFilter('字数', Object.keys(wordNumMap), wordNum, '字数', 0.4));\nlist.push(createFilter('更新', Object.keys(updateMap), update, '更新', 0.4));\nlist.push(createFilter('排序', Object.keys(sortMap), sort, '排序', 0.1));\n\nif (tab == '短剧') {\n    list.push({ title: '短剧暂无分类，请使用上方搜索 🔍', url: '', style: { layout_flexGrow: 1, layout_flexBasisPercent: 1 } });\n} else {\n    var ctab = tab == '小说' ? (channel == '女频' ? 0 : 1) : (tab == '听书' ? 3 : 5);\n    try {\n        var res = JSON.parse(java.ajax(base + '/category-front?tab=' + ctab));\n        var cells = ((res.data || {}).category_tab_data || {}).cell_data || [];\n        cells.forEach(function (cell) {\n            (cell.atom_data || []).forEach(function (a) {\n                var c = a.category_data;\n                if (c && c.category_id != null) {\n                    list.push({\n                        title: c.name,\n                        url: base + '/category-landing?category_id=' + c.category_id + '&offset={{(page-1)*20}}' + q + '&fqtab=' + tabCode,\n                        style: { layout_flexGrow: 1, layout_flexBasisPercent: 0.25 }\n                    });\n                }\n            });\n        });\n    } catch (e) {\n        java.toast('发现页分类获取失败');\n    }\n}\nJSON.stringify(list);\n</js>",
+    "ruleSearch": {
+      "bookList": "<js>\nvar d = JSON.parse(result);\nvar isVideo = /tab_type=11/.test(baseUrl);\nvar arr = [];\n(d.data || []).forEach(function (b) {\n    var list = isVideo ? (b.video_data || []) : (b.book_data || []);\n    list.forEach(function (x) {\n        if (isVideo) {\n            arr.push({\n                book_id: x.series_id,\n                book_name: x.title,\n                author: '',\n                abstract: x.rec_text || '',\n                thumb_url: x.horiz_cover || x.cover,\n                category: '短剧',\n                creation_status: '1',\n                score: x.score,\n                word_number: String(x.episode_cnt || '')\n            });\n        } else {\n            arr.push(x);\n        }\n    });\n});\narr;\n</js>",
+      "name": "$.book_name",
+      "author": "$.author",
+      "kind": "{{$.creation_status=='0'?'完结':'连载'}},{{$.category}},{{$.score}}分",
+      "wordCount": "$.word_number##^0+$",
+      "intro": "$.abstract",
+      "coverUrl": "$.thumb_url",
+      "bookUrl": "<js>\nvar t = /tab_type=11/.test(baseUrl) ? 'd' : /tab_type=2/.test(baseUrl) ? 't' : /tab_type=8/.test(baseUrl) ? 'm' : 'n';\n`/detail?book_id=${result.book_id}&fqtab=${t}`;\n</js>",
+      "checkKeyWord": "斗罗大陆"
+    },
+    "ruleExplore": {
+      "bookList": "$.data.book_info[*]",
+      "name": "$.book_name",
+      "author": "$.author",
+      "kind": "{{$.category}},{{$.score}}分",
+      "wordCount": "$.word_number##^0+$",
+      "intro": "$.abstract",
+      "coverUrl": "$.thumb_url",
+      "bookUrl": "<js>\nvar m = String(baseUrl).match(/fqtab=([ntmd])/);\n`/detail?book_id=${result.book_id}&fqtab=${m ? m[1] : 'n'}`;\n</js>"
+    },
+    "ruleBookInfo": {
+      "init": "$.data",
+      "name": "$.book_name",
+      "author": "$.author",
+      "kind": "{{$.creation_status=='0'?'完结':'连载'}},{{$.category}}",
+      "wordCount": "$.word_number##^0+$",
+      "lastChapter": "$.last_chapter_title",
+      "coverUrl": "$.thumb_url",
+      "intro": "<js>\nconst { book_id, last_chapter_title, last_chapter_update_time, word_number, score, abstract, read_count, category } = result;\nlet m0 = String(baseUrl).match(/fqtab=([ntmd])/);\nconst tab = { n: '小说', t: '听书', m: '漫画', d: '短剧' }[(m0 ? m0[1] : 'n')];\nlet moreSettings = getVariable('更多设置');\nconst lightDivider = \"❇️───────❇️───────❇️\";\nconst heavyDivider = \"&lrm;\\n&lrm;\";\nconst isValid = (v) => String(v).length > 1;\nlet ctitle = book.durChapterTitle || '未开始';\nconst two = (n) => ('0' + n).slice(-2);\nconst fmtTime = (t) => {\n    let n = parseInt(t);\n    if (!n || n <= 0) return '';\n    let d = new Date(n * 1000);\n    return `${d.getFullYear()}-${two(d.getMonth() + 1)}-${two(d.getDate())}`;\n};\nconst formatAbstract = (text) => String(text).split(\"\\n\").map(line => `    ${line}`).join(\"\\n\");\nconst buildBasicInfo = (items) => {\n    let info = \"\";\n    for (let [value, prefix, icon] of items) {\n        if (isValid(value)) info += `    ${icon} ${prefix} ${value}\\n`;\n    }\n    return info;\n};\nlet info = `    🏷 数据来源：番茄小说(fanqie-go)\\n    🔄 当前模式：${tab}\\n    📖 阅读至：${ctitle}\\n`;\nconst fullBasicInfo = buildBasicInfo([\n    [category, \"书籍分类：\", \"🌈\"],\n    [last_chapter_title, \"最新章节：\", \"📚\"],\n    [fmtTime(last_chapter_update_time), \"更新时间：\", \"⏳\"],\n    [word_number, \"书籍字数：\", \"📝\"],\n    [score, \"书籍评分：\", \"⭐\"],\n    [read_count, \"今阅读人数：\", \"📃\"]\n]);\nif (fullBasicInfo) info += `${lightDivider}\\n${fullBasicInfo}`;\nif (isValid(abstract)) info += `${heavyDivider}\\n    📖 书籍简介：\\n${formatAbstract(abstract)}\\n`;\ninfo += `${lightDivider}\\n${heavyDivider}\\n    数据更新于 ${new Date().toLocaleString()}\\n`;\nconst abstractMode = moreSettings && moreSettings['完整简介'] || 'true';\nif (abstractMode == \"false\") {\n    const simplifiedBasicInfo = buildBasicInfo([\n        [last_chapter_title, \"最新章节：\", \"📚\"],\n        [fmtTime(last_chapter_update_time), \"更新时间：\", \"⏳\"],\n        [word_number, \"书籍字数：\", \"📝\"],\n        [score, \"书籍评分：\", \"⭐\"]\n    ]);\n    info = `\\n&lrm;${isValid(abstract) ? `📖 书籍简介：\\n${formatAbstract(abstract)}\\n${heavyDivider}` : ''}🏷 数据来源：番茄小说\\n${simplifiedBasicInfo}`;\n} else {\n    info = info.split(\"\\n\").map(line => line.replace(/^ {4}/, \"\")).join(\"\\n\");\n}\ninfo;\n</js>",
+      "tocUrl": "<js>\nvar m = String(baseUrl).match(/fqtab=([ntmd])/);\n`/catalog?book_id=${result.book_id}&fqtab=${m ? m[1] : 'n'}`;\n</js>",
+      "canReName": "1"
+    },
+    "ruleToc": {
+      "chapterList": "<js>\n// 类型随书切换（照光遇 typeMap：安卓用 default，苹果端用其类型体系）\nconst typeMap = {\n    \"小说\": { \"苹果\": 0, \"default\": 8 },\n    \"听书\": { \"苹果\": 1, \"default\": 32 },\n    \"漫画\": { \"苹果\": 2, \"default\": 64 },\n    \"短剧\": { \"苹果\": 3, \"default\": 8 }\n};\nconst device_type = checkEnv();\nvar tabName = { n: '小说', t: '听书', m: '漫画', d: '短剧' }[fqTab(baseUrl, 'n')];\nvar currentType = typeMap[tabName] || typeMap[\"小说\"];\nif (device_type == '苹果') {\n    book.type = currentType[device_type];\n} else {\n    book.type = currentType.default;\n}\ntry {\n    book.imageStyle = checkEnv() == '改版' ? 'FULL' : 'TEXT';\n} catch (e) {}\nresult;\n</js>$.data.item_data_list[*]",
+      "chapterName": "$.title",
+      "chapterUrl": "<js>\nvar t = fqTab(baseUrl, 'n');\nvar id = result.item_id;\nvar u = {\n    n: `/content?item_id=${id}&text_mode=html&review=keep&image_mode=keep&fqtab=n`,\n    t: `/audio?item_ids=${id}&fqtab=t`,\n    m: `/manga?item_ids=${id}&output=proxy&fqtab=m`,\n    d: `/video?item_ids=${id}&fqtab=d`\n}[t];\nu;\n</js>"
+    },
+    "ruleContent": {
+      "content": "<js>\nvar t = fqTab(baseUrl, 'n');\nlet moreSettings = getVariable('更多设置');\nlet dpSettings = getVariable('段评设置');\nlet islyc = checkEnv();\n\nif (t == 't') {\n    // 听书：直接返回音频地址\n    JSON.parse(result).data[0].main_url;\n} else if (t == 'm') {\n    // 漫画：拼装图片\n    var d = JSON.parse(result);\n    var org = String(baseUrl).match(/^https?:\\/\\/[^\\/]+/)[0];\n    var imgs = (d.data || {}).images || [];\n    var out = [];\n    for (var i = 0; i < imgs.length; i++) {\n        out.push('<img src=\"' + org + imgs[i].data + '\">');\n    }\n    out.join('\\n');\n} else if (t == 'd') {\n    // 短剧：选最高清晰度，当前章节自动唤起播放\n    var d = JSON.parse(result).data || {};\n    var vl = d.video_list || {};\n    var list = [];\n    for (var k in vl) { list.push(vl[k]); }\n    list.sort(function (a, b) { return (b.vheight || 0) - (a.vheight || 0); });\n    var org = String(baseUrl).match(/^https?:\\/\\/[^\\/]+/)[0];\n    var url = list.length ? String(list[0].main_url) : '';\n    if (url && url.indexOf('http') != 0) { url = org + url; }\n    if (url && book.durChapterIndex == chapter.index) {\n        java.startBrowser(url, chapter.title);\n    }\n    '▶️ 本集已唤起播放（菜单-刷新可重新打开）：\\n' + url;\n} else {\n    // 小说：正文 + 段评气泡\n    var d = JSON.parse(result);\n    var content = String((d.data || {}).content || '');\n    let show_img = moreSettings && moreSettings['显示图片'] || 'true';\n    if (show_img == 'false') {\n        content = removeAllImgTags(content);\n    }\n    let para = dpSettings && dpSettings['段评开关'] || 'true';\n    if (para == 'true' && content.indexOf('<comment') != -1) {\n        content = islyc == '苹果' ? paraForiOS(content, '番茄') : paraForAndroid(content, '番茄');\n    }\n    content;\n}\n</js>",
+      "title": "$.data.title"
+    }
+  }
+]
@@ -172,6 +172,7 @@ func setupRoutes() {
 	http.HandleFunc("/audio", wrap(handlers.HandleAudio))
 	http.HandleFunc("/audio/proxy/", wrap(handlers.HandleAudioProxy))
 	http.HandleFunc("/video", wrap(handlers.HandleVideo))
+	http.HandleFunc("/video/proxy/", wrap(handlers.HandleVideoProxy))
 	http.HandleFunc("/manga", wrap(handlers.HandleManga))
 	http.HandleFunc("/manga/image/", wrap(handlers.HandleMangaImageProxy))

@@ -51,6 +51,21 @@ fanqie:
    # 是否启用段评功能（默认true，启用段评）
    enable_review: true

+  # 视频处理配置
+  video:
+    # 输出模式：proxy / url
+    # proxy: 返回本地解密代理URL /video/proxy/{key}（已解密，可直接播放，推荐）
+    # url: 返回原始CDN链接（内容为 CENC 加密，需自行解密）
+    output_mode: "proxy"
+
+    # 默认清晰度：max（最高档）/ 360p/480p/540p/720p / 档位 key（video_1..N）
+    # 留空返回全部清晰度；/video 接口的 quality 参数优先于此配置
+    quality: "max"
+
+    # 解密后视频的磁盘缓存（同一视频重复播放直接读本地文件，无需重新下载解密）
+    cache_enabled: true
+    cache_path: "./video_cache"
+
  # 漫画处理配置
  manga:
    # 输出模式：proxy / data_uri / url
@@ -7,10 +7,15 @@
 #   ./deploy.sh v1.2.0                # 编译 + 部署（指定版本）
 #   ./deploy.sh v1.2.0 --init         # 首次初始化（写 systemd/nginx 配置）
 #   ./deploy.sh v1.2.0 --no-pull      # 跳过 git pull
+#   ./deploy.sh v1.2.0 --no-autostart # 部署后不开机自启
+#   ./deploy.sh v1.2.0 --no-restart   # 只部署，不重启服务
+#   ./deploy.sh --stop                # 停止服务
+#   ./deploy.sh --start               # 启动服务
 #   ./deploy.sh --build-only          # 只编译，不部署
 #   ./deploy.sh --rollback            # 交互式回滚到指定版本
 #   ./deploy.sh --rollback v1.0.0     # 直接回滚到指定版本
 #   ./deploy.sh --list                # 列出所有已部署版本
+#   ./deploy.sh --sync-nginx          # 更新线上 nginx 配置（备份+校验+失败回滚）
 #   ./deploy.sh --help                # 显示帮助
 # ============================================================

@@ -35,9 +40,11 @@ NGINX_CONF="${NGINX_CONF:-/etc/nginx/conf.d/${APP_NAME}.conf}"
 APP_PORT="${APP_PORT:-40180}"              # 程序监听端口
 DOMAIN="${DOMAIN:-fq.20010117.xyz}"        # 域名
 CERT_EMAIL="${CERT_EMAIL:-admin@${DOMAIN}}"  # 证书申请邮箱（过期提醒）
+CERT_DIR="${CERT_DIR:-/etc/nginx/ssl}"       # 证书目录（acme.sh --install-cert 安装位置）
 BUILD_TARGET="${BUILD_TARGET:-./cmd/fanqie}"  # go build 的包路径
 ENV_FILE="${ENV_FILE:-${SRC_DIR}/.env}"    # 应用环境变量（.env.example 为模板）
 KEEP_VERSIONS="${KEEP_VERSIONS:-5}"        # 保留最近几个版本
+AUTO_START="${AUTO_START:-true}"           # 服务是否开机自启（--no-autostart 覆盖）

 # ==================== 颜色与日志 ====================
 C_GREEN='\033[1;32m'; C_YELLOW='\033[1;33m'; C_RED='\033[1;31m'; C_BLUE='\033[1;34m'; C_RESET='\033[0m'
@@ -61,6 +68,11 @@ ROLLBACK=false
 ROLLBACK_VERSION=""
 LIST=false
 FORCE=false
+SYNC_NGINX=false
+AUTO_START="${AUTO_START:-true}"
+NO_RESTART=false
+STOP=false
+START=false

 print_help() {
  cat <<EOF
@@ -69,10 +81,15 @@ print_help() {
 选项:
  --init                首次初始化，写入 systemd 和 nginx 配置
  --no-pull             跳过 git pull
+  --no-autostart        服务不设置开机自启（默认自启）
+  --no-restart          只部署不重启服务（自启设置仍会应用）
+  --stop                停止服务后退出
+  --start               启动服务后退出
  --build-only          只编译，不部署、不重启服务
  --force, -f           允许覆盖已存在的同名版本（默认报错退出）
  --rollback [版本]     回滚到指定版本（不带版本号则交互式选择）
  --list                列出所有已部署的版本
+  --sync-nginx          只更新 nginx 配置（备份旧配置，校验失败自动回滚）
  --help, -h            显示此帮助

 示例:
@@ -93,6 +110,10 @@ while [ $i -lt ${#ARGS[@]} ]; do
  case "$arg" in
    --init)        INIT=true ;;
    --no-pull)     NO_PULL=true ;;
+    --no-autostart) AUTO_START=false ;;
+    --no-restart)  NO_RESTART=true ;;
+    --stop)        STOP=true ;;
+    --start)       START=true ;;
    --build-only)  BUILD_ONLY=true ;;
    --rollback)
      ROLLBACK=true
@@ -103,6 +124,7 @@ while [ $i -lt ${#ARGS[@]} ]; do
      fi
      ;;
    --list)        LIST=true ;;
+    --sync-nginx)  SYNC_NGINX=true ;;
    --force|-f)    FORCE=true ;;
    --help|-h)     print_help; exit 0 ;;
    v*)            VERSION="$arg" ;;
@@ -167,19 +189,35 @@ cleanup_old_versions() {
  done
 }

-# 重启服务 + 验证
-restart_and_verify() {
-  log "重启 ${APP_NAME} 服务..."
-  # 注意：不要用 "list-unit-files | grep -q"——grep -q 提前退出会让 systemctl 收到
-  # SIGPIPE，在 pipefail 下整条管道判假（unit 多的机器必踩），误报"服务不存在"
-  if systemctl cat "${APP_NAME}" >/dev/null 2>&1; then
-    $SUDO systemctl restart "${APP_NAME}"
+# 应用开机自启设置（AUTO_START 由 --no-autostart / .deploy.env 决定）
+apply_autostart() {
+  if [ "$AUTO_START" = true ]; then
    $SUDO systemctl enable "${APP_NAME}" >/dev/null 2>&1 || true
  else
+    $SUDO systemctl disable "${APP_NAME}" >/dev/null 2>&1 || true
+    info "开机自启已禁用（--no-autostart）"
+  fi
+}
+
+# 重启服务 + 验证
+restart_and_verify() {
+  # 注意：不要用 "list-unit-files | grep -q"——grep -q 提前退出会让 systemctl 收到
+  # SIGPIPE，在 pipefail 下整条管道判假（unit 多的机器必踩），误报"服务不存在"
+  if ! systemctl cat "${APP_NAME}" >/dev/null 2>&1; then
    warn "服务 ${APP_NAME}.service 不存在，请先执行 $0 --init"
    return 0
  fi

+  apply_autostart
+
+  if [ "$NO_RESTART" = true ]; then
+    info "跳过服务重启（--no-restart），需要时执行: sudo systemctl restart ${APP_NAME}"
+    return 0
+  fi
+
+  log "重启 ${APP_NAME} 服务..."
+  $SUDO systemctl restart "${APP_NAME}"
+
  if command -v nginx >/dev/null 2>&1; then
    $SUDO systemctl reload nginx 2>/dev/null || $SUDO nginx -s reload 2>/dev/null || true
  fi
@@ -206,12 +244,152 @@ restart_and_verify() {
  $SUDO journalctl -u "${APP_NAME}" -n 15 --no-pager || true
 }

+
+# 写入 nginx 配置（--init 与 --sync-nginx 共用的唯一模板来源）
+# 模板自带完整 443/证书配置（证书存在时启用），不依赖签发工具注入——
+# 这样 --sync-nginx 覆盖配置时不会丢失 HTTPS 段（注入式配置会被覆盖回 80-only）
+write_nginx_conf() {
+  # 反代 location（80 无证书时与 443 共用）
+  local proxy_locations
+  proxy_locations=$(cat <<LOC_EOF
+
+    # 视频解密代理：关闭缓冲，分片（Range/206）直通，避免 nginx 对大文件二次落盘
+    location /video/proxy/ {
+        proxy_pass http://127.0.0.1:${APP_PORT};
+        proxy_http_version 1.1;
+        proxy_set_header Host \$host;
+        proxy_set_header X-Real-IP \$remote_addr;
+        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto \$scheme;
+        proxy_buffering off;
+        proxy_read_timeout 300s;
+        proxy_send_timeout 300s;
+    }
+
+    location / {
+        proxy_pass http://127.0.0.1:${APP_PORT};
+        proxy_http_version 1.1;
+        proxy_set_header Host \$host;
+        proxy_set_header X-Real-IP \$remote_addr;
+        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto \$scheme;
+        proxy_set_header Upgrade \$http_upgrade;
+        proxy_set_header Connection "upgrade";
+        proxy_read_timeout 300s;
+        proxy_send_timeout 300s;
+    }
+LOC_EOF
+)
+
+  local ssl_block=""
+  if [ -f "${CERT_DIR}/${DOMAIN}/fullchain.pem" ]; then
+    log "检测到 ${DOMAIN} 证书，配置启用 443"
+    ssl_block=$(cat <<SSL_EOF
+
+server {
+    listen 443 ssl http2;
+    server_name ${DOMAIN};
+
+    ssl_certificate     ${CERT_DIR}/${DOMAIN}/fullchain.pem;
+    ssl_certificate_key ${CERT_DIR}/${DOMAIN}/privkey.pem;
+    ssl_protocols TLSv1.2 TLSv1.3;
+
+    access_log /var/log/nginx/${APP_NAME}.access.log;
+    error_log  /var/log/nginx/${APP_NAME}.error.log;
+${proxy_locations}
+}
+SSL_EOF
+)
+  else
+    warn "未找到 ${CERT_DIR}/${DOMAIN}/ 证书，本次仅写 80 配置（不跳转 HTTPS）；证书签发后重跑: $0 --sync-nginx"
+  fi
+
+  # 80 端口：有证书时仅 ACME 验证 + 301 跳转；无证书时直接反代
+  local root_location
+  if [ -n "${ssl_block}" ]; then
+    root_location='    location / {
+        return 301 https://$host$request_uri;
+    }'
+  else
+    root_location="${proxy_locations}"
+  fi
+
+  $SUDO tee "${NGINX_CONF}" >/dev/null <<NGINX_EOF
+server {
+    listen 80;
+    server_name ${DOMAIN};
+
+    access_log /var/log/nginx/${APP_NAME}.access.log;
+    error_log  /var/log/nginx/${APP_NAME}.error.log;
+
+    # ACME http-01 验证（acme.sh webroot 模式依赖）
+    location /.well-known/acme-challenge/ {
+        root /var/www/html;
+    }
+
+${root_location}
+}${ssl_block}
+NGINX_EOF
+}
+
+# 更新已部署服务器的 nginx 配置：备份 → 重写 → 校验 → 失败回滚
+sync_nginx_conf() {
+  local backup=""
+  if [ -f "${NGINX_CONF}" ]; then
+    backup="${NGINX_CONF}.bak.$(date +%Y%m%d%H%M%S)"
+    $SUDO cp "${NGINX_CONF}" "${backup}"
+    log "已备份原配置: ${backup}"
+  else
+    warn "nginx 配置不存在，将写入全新配置: ${NGINX_CONF}"
+  fi
+
+  write_nginx_conf
+  log "已写入新配置: ${NGINX_CONF}"
+
+  if $SUDO nginx -t; then
+    $SUDO systemctl reload nginx 2>/dev/null || $SUDO nginx -s reload 2>/dev/null || true
+    log "nginx 配置已更新并重载"
+  else
+    err "nginx -t 校验失败"
+    if [ -n "${backup}" ] && [ -f "${backup}" ]; then
+      $SUDO cp "${backup}" "${NGINX_CONF}"
+      if $SUDO nginx -t >/dev/null 2>&1; then
+        $SUDO systemctl reload nginx 2>/dev/null || $SUDO nginx -s reload 2>/dev/null || true
+        warn "已回滚到备份配置: ${backup}"
+      fi
+    fi
+    exit 1
+  fi
+}
+
 # ==================== --list ====================
 if [ "$LIST" = true ]; then
  list_versions
  exit 0
 fi

+# ==================== --sync-nginx ====================
+# 只更新 nginx 配置（给已部署服务器同步模板变更用），不动二进制与服务
+if [ "$SYNC_NGINX" = true ]; then
+  command -v nginx >/dev/null 2>&1 || { err "未找到 nginx"; exit 1; }
+  sync_nginx_conf
+  exit 0
+fi
+
+# ==================== --stop / --start ====================
+if [ "$STOP" = true ] || [ "$START" = true ]; then
+  systemctl cat "${APP_NAME}" >/dev/null 2>&1 || { err "服务 ${APP_NAME}.service 不存在，请先执行 $0 --init"; exit 1; }
+  if [ "$STOP" = true ]; then
+    $SUDO systemctl stop "${APP_NAME}"
+    log "✅ 已停止 ${APP_NAME}（开机自启设置不变）"
+  else
+    $SUDO systemctl start "${APP_NAME}"
+    sleep 1
+    $SUDO systemctl status "${APP_NAME}" --no-pager -l | head -n 15 || true
+  fi
+  exit 0
+fi
+
 # ==================== --rollback ====================
 if [ "$ROLLBACK" = true ]; then
  if [ ! -d "${BIN_DIR}" ]; then
@@ -326,55 +504,34 @@ WantedBy=multi-user.target
 EOF

  log "初始化 Nginx 配置: ${NGINX_CONF}"
-  $SUDO tee "${NGINX_CONF}" >/dev/null <<EOF
-server {
-    listen 80;
-    server_name ${DOMAIN};
-
-    access_log /var/log/nginx/${APP_NAME}.access.log;
-    error_log  /var/log/nginx/${APP_NAME}.error.log;
-
-    location / {
-        proxy_pass http://127.0.0.1:${APP_PORT};
-        proxy_http_version 1.1;
-        proxy_set_header Host \$host;
-        proxy_set_header X-Real-IP \$remote_addr;
-        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto \$scheme;
-        proxy_set_header Upgrade \$http_upgrade;
-        proxy_set_header Connection "upgrade";
-        proxy_read_timeout 300s;
-        proxy_send_timeout 300s;
-    }
-}
-EOF
+  write_nginx_conf


-  # ---- Certbot 续期后自动重载 Nginx（deploy-hook 只在续期成功时执行）----
-  HOOK_FILE="/etc/letsencrypt/renewal-hooks/deploy/reload-nginx.sh"
-  if [ ! -f "${HOOK_FILE}" ]; then
-    log "创建 Certbot 续期重载 Hook: ${HOOK_FILE}"
-    $SUDO mkdir -p /etc/letsencrypt/renewal-hooks/deploy/
-    $SUDO tee "${HOOK_FILE}" >/dev/null <<'HOOK'
-#!/bin/bash
-if /usr/sbin/nginx -t 2>/dev/null; then
-    systemctl reload nginx
-fi
-HOOK
-    $SUDO chmod +x "${HOOK_FILE}"
-  fi
-
-  # ---- 首次初始化自动申请 HTTPS 证书（一次性；续期由 certbot.timer 自动处理）----
-  if [ ! -d "/etc/letsencrypt/live/${DOMAIN}" ]; then
-    if command -v certbot >/dev/null 2>&1; then
-      log "未检测到证书，尝试自动申请: ${DOMAIN}"
-      $SUDO certbot --nginx -d "${DOMAIN}" --non-interactive --agree-tos -m "${CERT_EMAIL}" --redirect \
-        || warn "证书申请失败，请检查域名解析与 80 端口；可稍后手动执行 certbot --nginx -d ${DOMAIN}"
-    else
-      warn "未安装 certbot，跳过证书申请。可手动执行: dnf install certbot python3-certbot-nginx"
-    fi
-  else
+  # ---- 首次初始化自动申请 HTTPS 证书（一次性；续期由 acme.sh cron 自动处理）----
+  if [ -f "${CERT_DIR}/${DOMAIN}/fullchain.pem" ]; then
    log "证书已存在，跳过申请"
+  else
+    # 定位 acme.sh：PATH → 当前用户目录 → root 目录（sudo 后 HOME 可能被重置）
+    ACME_SH="$(command -v acme.sh 2>/dev/null || true)"
+    for c in "${HOME}/.acme.sh/acme.sh" "/root/.acme.sh/acme.sh"; do
+      if [ -z "$ACME_SH" ] && [ -x "$c" ]; then ACME_SH="$c"; fi
+    done
+    if [ -z "$ACME_SH" ]; then
+      err "未找到 acme.sh，请先安装: curl https://get.acme.sh | sh -s email=${CERT_EMAIL}"
+      exit 1
+    fi
+    log "未检测到证书，使用 acme.sh 申请: ${DOMAIN}"
+    $SUDO mkdir -p /var/www/html "${CERT_DIR}/${DOMAIN}"
+    if $SUDO "$ACME_SH" --issue -d "${DOMAIN}" -w /var/www/html --server letsencrypt --keylength ec-256 -m "${CERT_EMAIL}" \
+       && $SUDO "$ACME_SH" --install-cert -d "${DOMAIN}" --ecc \
+            --fullchain-file "${CERT_DIR}/${DOMAIN}/fullchain.pem" \
+            --key-file "${CERT_DIR}/${DOMAIN}/privkey.pem" \
+            --reloadcmd "systemctl reload nginx"; then
+      log "证书申请成功，写入 443 配置..."
+      write_nginx_conf
+    else
+      warn "证书申请失败，请检查域名解析与 80 端口；成功后重跑: $0 --sync-nginx"
+    fi
  fi

  if command -v getenforce >/dev/null 2>&1 && [ "$(getenforce)" != "Disabled" ]; then
@@ -41,6 +41,7 @@ type FanqieConfig struct {
 	Signature string        `mapstructure:"signature"` // 签名方法: sign2 / sign4
 	Content   ContentConfig `mapstructure:"content"`
 	Manga     MangaConfig   `mapstructure:"manga"`
+	Video     VideoConfig   `mapstructure:"video"`
 }

 // ContentConfig 内容处理配置
@@ -60,6 +61,14 @@ type MangaConfig struct {
 	OutputMode string `mapstructure:"output_mode"` // 输出模式: data_uri / base64 / url
 }

+// VideoConfig 视频处理配置
+type VideoConfig struct {
+	OutputMode   string `mapstructure:"output_mode"`  // 输出模式: url（原始CDN链接，内容加密）/ proxy（本地解密代理，可直接播放）
+	Quality      string `mapstructure:"quality"`      // 默认清晰度: max（最高档）/ 360p/480p/... 或档位 key（video_1..N），留空返回全部
+	CacheEnabled bool   `mapstructure:"cache_enabled"` // 解密后视频的磁盘缓存
+	CachePath    string `mapstructure:"cache_path"`    // 缓存目录
+}
+
 // CacheConfig 缓存配置
 type CacheConfig struct {
 	Enabled        bool           `mapstructure:"enabled"`
@@ -197,6 +206,12 @@ func setDefaults() {
 	// 漫画处理配置
 	viper.SetDefault("fanqie.manga.output_mode", "url")

+	// 视频处理配置
+	viper.SetDefault("fanqie.video.output_mode", "proxy")
+	viper.SetDefault("fanqie.video.quality", "max")
+	viper.SetDefault("fanqie.video.cache_enabled", true)
+	viper.SetDefault("fanqie.video.cache_path", "./video_cache")
+
 	// 缓存配置
 	viper.SetDefault("cache.enabled", true)
 	viper.SetDefault("cache.backend", "sqlite")
@@ -0,0 +1,46 @@
+package config
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/spf13/viper"
+)
+
+// video 段配置读取：显式值生效、缺省回落 viper 默认值
+func TestVideoConfig(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "config.yaml")
+	os.WriteFile(path, []byte(`
+fanqie:
+  video:
+    output_mode: "proxy"
+    quality: "720p"
+`), 0644)
+
+	v := viper.New()
+	v.SetConfigFile(path)
+	if err := v.ReadInConfig(); err != nil {
+		t.Fatal(err)
+	}
+	var c Config
+	if err := v.Unmarshal(&c); err != nil {
+		t.Fatal(err)
+	}
+	if c.Fanqie.Video.OutputMode != "proxy" || c.Fanqie.Video.Quality != "720p" {
+		t.Fatalf("显式配置未生效: %+v", c.Fanqie.Video)
+	}
+
+	// 缺省回落
+	v2 := viper.New()
+	v2.SetDefault("fanqie.video.output_mode", "url")
+	v2.SetDefault("fanqie.video.quality", "")
+	var c2 Config
+	if err := v2.Unmarshal(&c2); err != nil {
+		t.Fatal(err)
+	}
+	if c2.Fanqie.Video.OutputMode != "url" || c2.Fanqie.Video.Quality != "" {
+		t.Fatalf("默认值不符: %+v", c2.Fanqie.Video)
+	}
+}
@@ -52,54 +52,61 @@ func GenerateAudioProxyURL(originalURL, deviceID string, headers map[string]stri
 	return fmt.Sprintf("/audio/proxy/%s", key)
 }

-// HandleAudioProxy 处理音频代理请求（流式返回，调用方负责 Close）
-func HandleAudioProxy(key string) (io.ReadCloser, string, error) {
-	var originalURL, deviceID string
-	var headers map[string]string
+// loadMediaProxyEntry 读取媒体代理映射（audio/video 共用；Redis 优先，回退 SQL）
+type mediaProxyEntry struct {
+	OriginalURL string
+	DeviceID    string
+	Headers     map[string]string
+}

+func loadMediaProxyEntry(key string) (*mediaProxyEntry, error) {
 	if redisCache != nil {
 		entry, err := loadAudioProxyEntry(key)
 		if err != nil {
-			return nil, "", err
+			return nil, err
 		}
-		originalURL, deviceID, headers = entry.OriginalURL, entry.DeviceID, entry.Headers
-	} else {
-		if cacheDB == nil {
-			return nil, "", fmt.Errorf("数据库未初始化")
-		}
-
-		// 从数据库获取音频信息
-		var headersJSON string
-		var createdAt int64
-
-		err := cacheDB.QueryRow(q(`
-			SELECT original_url, device_id, headers, created_at
-			FROM audio_cache WHERE key = ?
-		`), key).Scan(&originalURL, &deviceID, &headersJSON, &createdAt)
-
-		if err == sql.ErrNoRows {
-			return nil, "", fmt.Errorf("音频信息不存在，请先调用 /audio 接口")
-		}
-		if err != nil {
-			return nil, "", fmt.Errorf("查询音频缓存失败: %w", err)
-		}
-
-		// 检查缓存是否过期（2小时，匹配CDN链接有效期）
-		if time.Now().Unix()-createdAt > 7200 { // 2小时 = 7200秒
-			// 清理过期缓存
-			cacheDB.Exec(q("DELETE FROM audio_cache WHERE key = ?"), key)
-			return nil, "", fmt.Errorf("音频信息已过期，请重新调用 /audio 接口")
-		}
-
-		// 解析headers
-		json.Unmarshal([]byte(headersJSON), &headers)
+		return &mediaProxyEntry{OriginalURL: entry.OriginalURL, DeviceID: entry.DeviceID, Headers: entry.Headers}, nil
 	}
+	if cacheDB == nil {
+		return nil, fmt.Errorf("数据库未初始化")
+	}
+
+	var originalURL, deviceID, headersJSON string
+	var createdAt int64
+	err := cacheDB.QueryRow(q(`
+		SELECT original_url, device_id, headers, created_at
+		FROM audio_cache WHERE key = ?
+	`), key).Scan(&originalURL, &deviceID, &headersJSON, &createdAt)
+
+	if err == sql.ErrNoRows {
+		return nil, fmt.Errorf("媒体信息不存在，请先调用 /audio 或 /video 接口")
+	}
+	if err != nil {
+		return nil, fmt.Errorf("查询媒体缓存失败: %w", err)
+	}
+	// 过期清理（2小时，匹配CDN链接有效期）
+	if time.Now().Unix()-createdAt > 7200 {
+		cacheDB.Exec(q("DELETE FROM audio_cache WHERE key = ?"), key)
+		return nil, fmt.Errorf("媒体信息已过期，请重新调用接口")
+	}
+
+	var headers map[string]string
+	json.Unmarshal([]byte(headersJSON), &headers)
 	if headers == nil {
 		headers = make(map[string]string)
 	}
+	return &mediaProxyEntry{OriginalURL: originalURL, DeviceID: deviceID, Headers: headers}, nil
+}
+
+// HandleAudioProxy 处理音频代理请求（流式返回，调用方负责 Close）
+func HandleAudioProxy(key string) (io.ReadCloser, string, error) {
+	entry, err := loadMediaProxyEntry(key)
+	if err != nil {
+		return nil, "", err
+	}

 	// 下载音频内容（流式），使用关联的设备信息
-	body, contentType, err := downloadMediaWithRetry(originalURL, deviceID, headers, 3)
+	body, contentType, err := downloadMediaWithRetry(entry.OriginalURL, entry.DeviceID, entry.Headers, 3)
 	if err != nil {
 		return nil, "", fmt.Errorf("下载音频失败: %w", err)
 	}
@@ -483,6 +483,9 @@ func CleanupExpiredCache() error {
 		cacheLogger.Info(fmt.Sprintf("已清理 %d 条过期缓存（创建时间早于 %d 秒前）", rowsAffected, cfg.Cache.CleanupSeconds))
 	}

+	// 顺带清理磁盘视频缓存（7 天未访问的解密文件）
+	CleanupVideoCache()
+
 	return nil
 }

@@ -77,7 +77,7 @@ func loadAudioProxyEntry(key string) (*audioProxyEntry, error) {

 	val, err := redisCache.Get(ctx, redisAudioKeyPrefix+key).Result()
 	if err != nil {
-		return nil, fmt.Errorf("音频信息不存在或已过期，请重新调用 /audio 接口")
+		return nil, fmt.Errorf("媒体信息不存在或已过期，请重新调用 /audio 或 /video 接口")
 	}

 	var entry audioProxyEntry
@@ -1,17 +1,27 @@
 package fqapi

 import (
+	"bytes"
 	"encoding/base64"
 	"encoding/json"
 	"fanqie/internal/common"
+	"fanqie/internal/config"
 	"fmt"
+	"io"
 	"math"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
 )

 var videoLogger = common.NewLogger("video", "INFO", "")

-// HandleVideo 处理获取视频（支持批量和单个接口）
-func HandleVideo(itemIDs interface{}) (string, error) {
+// HandleVideo 处理获取视频（支持批量和单个接口）。
+// output: url（默认，返回原始CDN链接，内容为 CENC 加密）/ proxy（返回本地解密代理链接，可直接播放）
+// quality: 清晰度过滤，支持 max（最高档，默认）、definition（360p/480p/...）或档位 key（video_1..N），空为全部；
+// 未传时回退 config fanqie.video.quality，output 为空时回退 fanqie.video.output_mode
+func HandleVideo(itemIDs, output, quality interface{}) (string, error) {
 	if itemIDs == nil || itemIDs == "" {
 		return BuildSuccessResponse([]interface{}{}), nil
 	}
@@ -44,6 +54,26 @@ func HandleVideo(itemIDs interface{}) (string, error) {
 	requestBody := fmt.Sprintf(`{"biz_param":{"device_level":3,"need_all_video_definition":true,"need_mp4_align":false,"use_os_player":false,"video_platform":1024},"video_id":"%s"}`,
 		itemIDStr)

+	outputMode := ParseStringParam(output, "")
+	qualityFilter := ParseStringParam(quality, "")
+	if cfg := config.GetAppConfig(); cfg != nil {
+		if outputMode == "" {
+			outputMode = cfg.Fanqie.Video.OutputMode
+		}
+		if qualityFilter == "" {
+			qualityFilter = cfg.Fanqie.Video.Quality
+		}
+	}
+	if outputMode == "" {
+		outputMode = "url"
+	}
+	deviceID := ""
+	if outputMode == "proxy" {
+		if dev := GetCurrentDevice(); dev != nil {
+			deviceID = dev.DeviceHeader
+		}
+	}
+
 	// 使用 GorgonRequest 添加签名和设备信息
 	resp, err := GorgonRequest(url, map[string]interface{}{
 		"method": "POST",
@@ -86,7 +116,14 @@ func HandleVideo(itemIDs interface{}) (string, error) {

 		if data != nil {
 			if videoModelStr, ok := data["video_model"].(string); ok && isSingle {
-				decodedModel := decodeVideoModelAsJSON(videoModelStr)
+				decodedModel := decodeVideoModelAsJSON(videoModelStr, outputMode, deviceID, qualityFilter)
+
+				// 清晰度过滤无匹配时报错（调用方能立即发现参数写错）
+				if qualityFilter != "" {
+					if vl, ok := decodedModel.(map[string]interface{})["video_list"].(map[string]interface{}); ok && len(vl) == 0 {
+						return BuildErrorResponse(fmt.Sprintf("无匹配清晰度: %s（可用档位见 video_list）", qualityFilter)), nil
+					}
+				}

 				// 单个接口直接返回 video_model
 				response := map[string]interface{}{
@@ -103,7 +140,7 @@ func HandleVideo(itemIDs interface{}) (string, error) {
 				for itemID, itemData := range data {
 					if itemMap, ok := itemData.(map[string]interface{}); ok {
 						if videoModelStr, ok := itemMap["video_model"].(string); ok {
-							decodedModel := decodeVideoModelAsJSON(videoModelStr)
+							decodedModel := decodeVideoModelAsJSON(videoModelStr, outputMode, deviceID, qualityFilter)
 							result[itemID] = map[string]interface{}{
 								"video_model": decodedModel,
 							}
@@ -134,8 +171,10 @@ func HandleVideo(itemIDs interface{}) (string, error) {
 	return BuildErrorResponse(errMsg), nil
 }

-// decodeVideoModelAsJSON 解析并解码 video_model，返回关键字段的 JSON 对象
-func decodeVideoModelAsJSON(videoModelStr string) interface{} {
+// decodeVideoModelAsJSON 解析并解码 video_model，返回关键字段的 JSON 对象。
+// outputMode=proxy 时把 CDN 链接替换为本地解密代理链接（/video/proxy/{key}）
+// qualityFilter 非空时只保留匹配的清晰度（definition 或档位 key，大小写不敏感）
+func decodeVideoModelAsJSON(videoModelStr, outputMode, deviceID, qualityFilter string) interface{} {
 	// 解析 video_model JSON 字符串
 	var videoModel map[string]interface{}
 	if err := json.Unmarshal([]byte(videoModelStr), &videoModel); err != nil {
@@ -151,8 +190,10 @@ func decodeVideoModelAsJSON(videoModelStr string) interface{} {
 	result := make(map[string]interface{})

 	// 提取关键字段
-	if videoID, ok := videoModel["video_id"].(string); ok {
-		result["video_id"] = videoID
+	videoID := ""
+	if v, ok := videoModel["video_id"].(string); ok {
+		result["video_id"] = v
+		videoID = v
 	}
 	if duration, ok := videoModel["video_duration"].(float64); ok {
 		result["video_duration"] = formatDuration(duration)
@@ -167,10 +208,37 @@ func decodeVideoModelAsJSON(videoModelStr string) interface{} {

 	// 处理 video_list
 	if videoList, ok := videoModel["video_list"].(map[string]interface{}); ok {
+		// max/best：解析为实际最高档位 key（不同视频可用档位不同，按 vheight/definition 取最大）
+		if strings.EqualFold(qualityFilter, "max") || strings.EqualFold(qualityFilter, "best") {
+			bestKey, bestH := "", 0
+			for q, qd := range videoList {
+				qm, ok := qd.(map[string]interface{})
+				if !ok {
+					continue
+				}
+				if h := qualityHeight(qm); h > bestH {
+					bestH, bestKey = h, q
+				}
+			}
+			qualityFilter = bestKey
+		}
+
 		processedVideoList := make(map[string]interface{})

 		for quality, qualityData := range videoList {
 			if qualityMap, ok := qualityData.(map[string]interface{}); ok {
+				// 清晰度过滤：匹配档位 key（video_1）或 definition（720p）
+				if qualityFilter != "" {
+					def, _ := qualityMap["definition"].(string)
+					if !strings.EqualFold(quality, qualityFilter) && !strings.EqualFold(def, qualityFilter) {
+						continue
+					}
+				}
+				// spade_a（PlayAuth）：解出 CENC 内容密钥的种子，proxy 模式随代理下发
+				spadeA := ""
+				if v, ok := qualityMap["spade_a"].(string); ok {
+					spadeA = v
+				}
 				// 只保留关键字段
 				qualityInfo := make(map[string]interface{})

@@ -205,18 +273,23 @@ func decodeVideoModelAsJSON(videoModelStr string) interface{} {
 					}
 				}

-				// 解码 main_url
-				if mainURL, ok := qualityMap["main_url"].(string); ok {
-					if decoded, err := base64.StdEncoding.DecodeString(mainURL); err == nil {
-						qualityInfo["main_url"] = string(decoded)
+				// 解码 main_url / backup_url_1（base64 的CDN链接），proxy 模式替换为解密代理。
+				// 代理 key 用 videoID+档位（稳定），同一视频重复调用复用磁盘缓存
+				processURL := func(b64 string) interface{} {
+					decoded, err := base64.StdEncoding.DecodeString(b64)
+					if err != nil {
+						return b64
 					}
+					if outputMode == "proxy" && spadeA != "" && videoID != "" {
+						return GenerateVideoProxyURL(videoID+"_"+quality, string(decoded), deviceID, spadeA)
+					}
+					return string(decoded)
+				}
+				if mainURL, ok := qualityMap["main_url"].(string); ok {
+					qualityInfo["main_url"] = processURL(mainURL)
 				}
-
-				// 解码 backup_url_1
 				if backupURL, ok := qualityMap["backup_url_1"].(string); ok {
-					if decoded, err := base64.StdEncoding.DecodeString(backupURL); err == nil {
-						qualityInfo["backup_url_1"] = string(decoded)
-					}
+					qualityInfo["backup_url_1"] = processURL(backupURL)
 				}

 				processedVideoList[quality] = qualityInfo
@@ -229,6 +302,22 @@ func decodeVideoModelAsJSON(videoModelStr string) interface{} {
 	return result
 }

+// qualityHeight 取清晰度的比较高度：优先 vheight，缺失时从 definition（如 "720p"）解析
+func qualityHeight(qm map[string]interface{}) int {
+	if h, ok := qm["vheight"].(float64); ok && h > 0 {
+		return int(h)
+	}
+	def, _ := qm["definition"].(string)
+	n := 0
+	for _, c := range def {
+		if c < '0' || c > '9' {
+			break
+		}
+		n = n*10 + int(c-'0')
+	}
+	return n
+}
+
 // formatDuration 将秒数转换为可读的时间格式
 func formatDuration(seconds float64) string {
 	totalSeconds := int(math.Round(seconds))
@@ -278,3 +367,123 @@ func formatBitrate(bitrate float64) string {
 	mbps := kbps / unit
 	return fmt.Sprintf("%.2f Mbps", mbps)
 }
+
+// GenerateVideoProxyURL 生成视频解密代理URL。
+// cacheKey 需稳定（videoID+档位）：映射表覆盖式更新，磁盘缓存按 key 复用
+func GenerateVideoProxyURL(cacheKey, originalURL, deviceID, spadeA string) string {
+	headers := map[string]string{"x-spade-a": spadeA}
+	if redisCache != nil {
+		saveAudioProxyEntry(cacheKey, &audioProxyEntry{
+			OriginalURL: originalURL,
+			DeviceID:    deviceID,
+			Headers:     headers,
+		})
+		return "/video/proxy/" + cacheKey
+	}
+	headersJSON, _ := json.Marshal(headers)
+	if cacheDB != nil {
+		cacheDB.Exec(q(`
+			INSERT INTO audio_cache (key, original_url, device_id, headers, created_at, updated_at)
+			VALUES (?, ?, ?, ?, ?, ?)
+			ON CONFLICT(key) DO UPDATE SET original_url = excluded.original_url,
+				device_id = excluded.device_id, headers = excluded.headers, updated_at = excluded.updated_at
+		`), cacheKey, originalURL, deviceID, string(headersJSON), time.Now().Unix(), time.Now().Unix())
+	}
+	return "/video/proxy/" + cacheKey
+}
+
+// videoCachePath 解密后视频的磁盘缓存路径；缓存未启用返回空串
+func videoCachePath(key string) string {
+	cfg := config.GetAppConfig()
+	if cfg == nil || !cfg.Fanqie.Video.CacheEnabled || cfg.Fanqie.Video.CachePath == "" {
+		return ""
+	}
+	return filepath.Join(cfg.Fanqie.Video.CachePath, key+".mp4")
+}
+
+// HandleVideoProxy 处理视频代理请求：磁盘缓存命中直接返回；否则下载 CENC 加密 MP4 →
+// SpadeA 解 key → 解密 → 写入缓存。返回 ReadSeeker 供 http.ServeContent（支持 Range/seek）。
+func HandleVideoProxy(key string) (io.ReadSeeker, string, error) {
+	// 磁盘缓存命中：直接返回文件（映射记录即使过期也不影响已缓存的视频）
+	if p := videoCachePath(key); p != "" {
+		if f, err := os.Open(p); err == nil {
+			return f, "video/mp4", nil
+		}
+	}
+
+	entry, err := loadMediaProxyEntry(key)
+	if err != nil {
+		return nil, "", err
+	}
+	spadeA := entry.Headers["x-spade-a"]
+	if spadeA == "" {
+		return nil, "", fmt.Errorf("视频信息缺少 spade_a，请重新调用 /video 接口")
+	}
+
+	body, _, err := downloadMediaWithRetry(entry.OriginalURL, entry.DeviceID, entry.Headers, 3)
+	if err != nil {
+		return nil, "", fmt.Errorf("下载视频失败: %w", err)
+	}
+	defer body.Close()
+	data, err := io.ReadAll(body)
+	if err != nil {
+		return nil, "", fmt.Errorf("读取视频失败: %w", err)
+	}
+
+	contentKey, err := DecodeSpadeKey(spadeA)
+	if err != nil {
+		return nil, "", fmt.Errorf("解密视频失败: %w", err)
+	}
+	if err := DecryptCENCMP4(data, contentKey); err != nil {
+		return nil, "", fmt.Errorf("解密视频失败: %w", err)
+	}
+
+	// 写入磁盘缓存（临时文件 + rename 原子替换；失败不影响本次返回）
+	if p := videoCachePath(key); p != "" {
+		if err := os.MkdirAll(filepath.Dir(p), 0755); err == nil {
+			if tmp, err := os.CreateTemp(filepath.Dir(p), ".tmp-*"); err == nil {
+				if _, werr := tmp.Write(data); werr == nil {
+					tmp.Close()
+					if err := os.Rename(tmp.Name(), p); err != nil {
+						os.Remove(tmp.Name())
+					}
+				} else {
+					tmp.Close()
+					os.Remove(tmp.Name())
+				}
+			}
+		}
+	}
+	return bytes.NewReader(data), "video/mp4", nil
+}
+
+// CleanupVideoCache 清理磁盘视频缓存中 mtime 过早的文件，挂接在缓存定期清理任务中
+func CleanupVideoCache() {
+	cfg := config.GetAppConfig()
+	if cfg == nil || !cfg.Fanqie.Video.CacheEnabled {
+		return
+	}
+	dir := cfg.Fanqie.Video.CachePath
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return // 目录不存在等：无缓存可清
+	}
+	const maxAge = 7 * 24 * time.Hour // ponytail: 固定 7 天，需要更长保留时改配置语义
+	cutoff := time.Now().Add(-maxAge)
+	removed := 0
+	for _, e := range entries {
+		info, err := e.Info()
+		if err != nil || info.IsDir() {
+			continue
+		}
+		if info.ModTime().Before(cutoff) {
+			if os.Remove(filepath.Join(dir, e.Name())) == nil {
+				removed++
+			}
+		}
+	}
+	if removed > 0 {
+		videoLogger.Info(fmt.Sprintf("已清理 %d 个过期视频缓存文件", removed))
+	}
+}
+
@@ -0,0 +1,360 @@
+package fqapi
+
+import (
+	"bytes"
+	"crypto/aes"
+	"crypto/cipher"
+	"encoding/base64"
+	"encoding/binary"
+	"fmt"
+)
+
+// ============ SpadeA（黑桃A）PlayAuth 解码 ============
+//
+// 番茄短剧/汽水音乐同源的本地 DRM：video_model 每个清晰度的 spade_a
+// （PlayAuth）经混淆变换直接还原 16 字节 AES-128 内容密钥（32 位 hex 字符串）。
+// 算法逆向自 SodaMusic v3.5.1（qishui-decrypt-tool），与番茄短剧样本实测一致。
+
+func bitCount32(v uint32) int {
+	c := v
+	c -= (c >> 1) & 0x55555555
+	c = (c & 0x33333333) + ((c >> 2) & 0x33333333)
+	return int(((c + (c>>4)) & 0x0f0f0f0f) * 0x01010101 >> 24)
+}
+
+func decodeBase36Byte(v byte) int {
+	switch {
+	case v >= '0' && v <= '9':
+		return int(v - '0')
+	case v >= 'a' && v <= 'z':
+		return int(v-'a') + 10
+	}
+	return 0xff
+}
+
+// decodeSpadeInner 逐字节去混淆：与前一字节异或后减去索引 popcount 与常数
+func decodeSpadeInner(data []byte) []byte {
+	result := make([]byte, len(data))
+	buff := append([]byte{0xfa, 0x55}, data...)
+	for i := 0; i < len(data); i++ {
+		raw := int(data[i]^buff[i]) - bitCount32(uint32(i)) - 21
+		if raw >= 0 {
+			result[i] = byte(raw)
+		} else {
+			result[i] = byte(((raw % 255) + 255) % 255)
+		}
+	}
+	return result
+}
+
+// DecodeSpadeKey 从 spade_a（PlayAuth base64）解出 16 字节 AES 内容密钥
+func DecodeSpadeKey(playAuthB64 string) ([]byte, error) {
+	raw, err := base64.StdEncoding.DecodeString(playAuthB64)
+	if err != nil {
+		return nil, fmt.Errorf("spade_a base64 解码失败: %w", err)
+	}
+	if len(raw) < 4 {
+		return nil, fmt.Errorf("spade_a 长度不足: %d", len(raw))
+	}
+	padding := int(raw[0]^raw[1]^raw[2]) - 48
+	if padding < 0 || padding >= len(raw)-3 {
+		return nil, fmt.Errorf("spade_a padding 非法: %d", padding)
+	}
+	body := raw[1 : len(raw)-padding]
+	tmp := decodeSpadeInner(body)
+	keyLen := decodeBase36Byte(tmp[0])
+	if keyLen == 0xff {
+		return nil, fmt.Errorf("spade_a key 长度字符非法: %q", tmp[0])
+	}
+	end := len(body) - keyLen
+	if end < 1 || end > len(tmp) {
+		return nil, fmt.Errorf("spade_a key 范围非法: end=%d len=%d", end, len(tmp))
+	}
+	keyHex := string(tmp[1:end])
+	if len(keyHex) != 32 {
+		return nil, fmt.Errorf("spade_a key 长度异常: %d", len(keyHex))
+	}
+	key := make([]byte, 16)
+	for i := 0; i < 16; i++ {
+		if _, err := fmt.Sscanf(keyHex[i*2:i*2+2], "%02x", &key[i]); err != nil {
+			return nil, fmt.Errorf("spade_a key hex 非法: %s", keyHex)
+		}
+	}
+	return key, nil
+}
+
+// ============ CENC (cenc-aes-ctr) MP4 解密 ============
+//
+// 容器为标准 CENC MP4：moov 明文；加密 sample entry（encv/enca）+ senc box
+// （version 0，每个 sample 8 字节 IV，整样本 AES-128-CTR，无 subsample）。
+// 解密后把 entry 类型改回原始 codec（sinf/frma 指示），得到可播放文件。
+
+type mp4Box struct {
+	typ         string
+	contentStar int
+	end         int
+}
+
+// walkBoxes 迭代 [start,end) 内的顶层 box，fn 返回 false 时停止迭代
+func walkBoxes(data []byte, start, end int, fn func(mp4Box) bool) error {
+	p := start
+	for p+8 <= end {
+		size := int(binary.BigEndian.Uint32(data[p : p+4]))
+		typ := string(data[p+4 : p+8])
+		if size == 1 { // largesize
+			if p+16 > end {
+				return fmt.Errorf("box %s largesize 越界", typ)
+			}
+			size = int(binary.BigEndian.Uint64(data[p+8 : p+16]))
+			// ponytail: >2GB 文件不支持，截断风险可接受
+			if size > len(data) {
+				return fmt.Errorf("box %s 过大", typ)
+			}
+		}
+		if size < 8 || p+size > end {
+			return fmt.Errorf("box %s 尺寸非法 size=%d at %d", typ, size, p)
+		}
+		if !fn(mp4Box{typ: typ, contentStar: p + 8, end: p + size}) {
+			return nil
+		}
+		p += size
+	}
+	return nil
+}
+
+// DecryptCENCMP4 原地解密 CENC 加密的 MP4 字节并修复 stsd entry 类型。
+// 仅支持 senc version 0 + 无 subsample 标志（番茄实测形态），其他形态返回错误。
+func DecryptCENCMP4(data []byte, key []byte) error {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return fmt.Errorf("内容密钥非法: %w", err)
+	}
+
+	decryptStream := func(ct []byte, iv8 []byte) error {
+		if len(iv8) != 8 {
+			return fmt.Errorf("senc IV 长度异常: %d", len(iv8))
+		}
+		iv := make([]byte, 16)
+		copy(iv, iv8) // 8 字节 IV 置于高位，低 8 字节为块计数器（CENC 标准）
+		cipher.NewCTR(block, iv).XORKeyStream(ct, ct)
+		return nil
+	}
+
+	// 找 moov 并遍历其下所有 trak，逐 trak 解密
+	var trakErr error
+	foundMoov := false
+	if err := walkBoxes(data, 0, len(data), func(b mp4Box) bool {
+		if b.typ != "moov" {
+			return true
+		}
+		foundMoov = true
+		_ = walkBoxes(data, b.contentStar, b.end, func(trak mp4Box) bool {
+			if trak.typ != "trak" {
+				return true
+			}
+			if err := decryptTrak(data, trak, decryptStream); err != nil {
+				trakErr = err
+				return false
+			}
+			return true
+		})
+		return false
+	}); err != nil {
+		return err
+	}
+	if !foundMoov {
+		return fmt.Errorf("moov box 未找到")
+	}
+	return trakErr
+}
+
+// decryptTrak 处理单个 trak：解析 sample 表 + senc，逐样本解密，修补 stsd
+func decryptTrak(data []byte, trak mp4Box, decryptStream func([]byte, []byte) error) error {
+	// 定位 mdia→minf→stbl
+	stbl, err := findBox(data, trak, "mdia", "minf", "stbl")
+	if err != nil || stbl == nil {
+		return err // 无 stbl 的 trak 跳过
+	}
+
+	var (
+		sizes         []int
+		chunkOffsets  []int
+		stscEntries   [][2]int // {first_chunk, samples_per_chunk}
+		ivs           [][]byte
+		stsd          *mp4Box
+		haveSizes     bool
+		haveOffsets   bool
+		haveStsc      bool
+		parseErr      error
+	)
+
+	if err := walkBoxes(data, stbl.contentStar, stbl.end, func(b mp4Box) bool {
+		switch b.typ {
+		case "stsd":
+			stsd = &b
+		case "stsz":
+			constSize := int(binary.BigEndian.Uint32(data[b.contentStar+4 : b.contentStar+8]))
+			count := int(binary.BigEndian.Uint32(data[b.contentStar+8 : b.contentStar+12]))
+			if constSize != 0 {
+				for i := 0; i < count; i++ {
+					sizes = append(sizes, constSize)
+				}
+			} else {
+				sizes = make([]int, count)
+				for i := 0; i < count; i++ {
+					sizes[i] = int(binary.BigEndian.Uint32(data[b.contentStar+12+i*4 : b.contentStar+16+i*4]))
+				}
+			}
+			haveSizes = true
+		case "stco":
+			count := int(binary.BigEndian.Uint32(data[b.contentStar+4 : b.contentStar+8]))
+			for i := 0; i < count; i++ {
+				chunkOffsets = append(chunkOffsets, int(binary.BigEndian.Uint32(data[b.contentStar+8+i*4:b.contentStar+12+i*4])))
+			}
+			haveOffsets = true
+		case "co64":
+			count := int(binary.BigEndian.Uint32(data[b.contentStar+4 : b.contentStar+8]))
+			for i := 0; i < count; i++ {
+				v := binary.BigEndian.Uint64(data[b.contentStar+8+i*8 : b.contentStar+16+i*8])
+				if v > uint64(len(data)) {
+					parseErr = fmt.Errorf("co64 偏移越界")
+					return false
+				}
+				chunkOffsets = append(chunkOffsets, int(v))
+			}
+			haveOffsets = true
+		case "stsc":
+			count := int(binary.BigEndian.Uint32(data[b.contentStar+4 : b.contentStar+8]))
+			for i := 0; i < count; i++ {
+				first := int(binary.BigEndian.Uint32(data[b.contentStar+8+i*12 : b.contentStar+12+i*12]))
+				spc := int(binary.BigEndian.Uint32(data[b.contentStar+12+i*12 : b.contentStar+16+i*12]))
+				stscEntries = append(stscEntries, [2]int{first, spc})
+			}
+			haveStsc = true
+		case "senc":
+			verFlags := binary.BigEndian.Uint32(data[b.contentStar : b.contentStar+4])
+			if verFlags>>24 != 0 {
+				parseErr = fmt.Errorf("senc version %d 不支持", verFlags>>24)
+				return false
+			}
+			if verFlags&0b10 != 0 {
+				parseErr = fmt.Errorf("senc subsample 加密模式不支持")
+				return false
+			}
+			count := int(binary.BigEndian.Uint32(data[b.contentStar+4 : b.contentStar+8]))
+			p := b.contentStar + 8
+			if p+8*count > b.end {
+				parseErr = fmt.Errorf("senc IV 表越界")
+				return false
+			}
+			for i := 0; i < count; i++ {
+				ivs = append(ivs, data[p+8*i:p+8*i+8])
+			}
+		}
+		return true
+	}); err != nil {
+		return fmt.Errorf("stbl 解析失败: %w", err)
+	}
+	if parseErr != nil {
+		return parseErr
+	}
+
+	if len(ivs) == 0 {
+		return nil // 本 trak 未加密
+	}
+	if !haveSizes || !haveOffsets || !haveStsc {
+		return fmt.Errorf("sample 表不完整（stsz=%v stco=%v stsc=%v）", haveSizes, haveOffsets, haveStsc)
+	}
+
+	// stsc+stco+stsz 重建每样本绝对偏移（标准 sample table 遍历）
+	sampleIdx := 0
+	for ci, off := range chunkOffsets {
+		spc := stscEntries[len(stscEntries)-1][1]
+		for _, e := range stscEntries {
+			if e[0] <= ci+1 {
+				spc = e[1]
+			} else {
+				break
+			}
+		}
+		pos := off
+		for s := 0; s < spc && sampleIdx < len(sizes); s++ {
+			size := sizes[sampleIdx]
+			if sampleIdx >= len(ivs) {
+				break
+			}
+			if pos+size > len(data) {
+				return fmt.Errorf("sample %d 越界 pos=%d size=%d", sampleIdx, pos, size)
+			}
+			if err := decryptStream(data[pos:pos+size], ivs[sampleIdx]); err != nil {
+				return err
+			}
+			pos += size
+			sampleIdx++
+		}
+	}
+
+	if stsd != nil {
+		patchStsdEntry(data, *stsd)
+	}
+	return nil
+}
+
+// findBox 沿 path 逐层查找唯一子 box；任意一层缺失返回 (nil, nil)
+func findBox(data []byte, parent mp4Box, path ...string) (*mp4Box, error) {
+	cur := parent
+	for _, name := range path {
+		var next *mp4Box
+		if err := walkBoxes(data, cur.contentStar, cur.end, func(b mp4Box) bool {
+			if b.typ == name {
+				next = &b
+				return false
+			}
+			return true
+		}); err != nil {
+			return nil, err
+		}
+		if next == nil {
+			return nil, nil
+		}
+		cur = *next
+	}
+	return &cur, nil
+}
+
+// patchStsdEntry 把加密 sample entry（encv/enca）的类型改回 sinf/frma 指示的原始 codec。
+// 番茄实测单 entry；entry 头部长度因音/视频而异，直接在 entry 字节里定位 "sinf"。
+func patchStsdEntry(data []byte, stsd mp4Box) {
+	entryCount := int(binary.BigEndian.Uint32(data[stsd.contentStar+4 : stsd.contentStar+8]))
+	if entryCount != 1 {
+		return // ponytail: 多 entry 形态按需扩展
+	}
+	entryStart := stsd.contentStar + 8
+	entryEnd := stsd.end
+
+	// 在 entry 内定位 "sinf"（box 类型魔数），再验证其 box 头合法性
+	sinfOff := bytes.Index(data[entryStart:entryEnd], []byte("sinf"))
+	for sinfOff >= 0 {
+		boxStart := entryStart + sinfOff - 4 // size 字段起点
+		if boxStart >= entryStart+8 {
+			size := int(binary.BigEndian.Uint32(data[boxStart : boxStart+4]))
+			if size >= 12 && boxStart+size <= entryEnd {
+				sinfContent, sinfEnd := boxStart+8, boxStart+size
+				frmaOff := bytes.Index(data[sinfContent:sinfEnd], []byte("frma"))
+				if frmaOff >= 0 {
+					frmaContent := sinfContent + frmaOff + 4
+					if frmaContent+4 <= sinfEnd {
+						// entry 类型字段在 box 头的 type 位置（entryStart+4）
+						copy(data[entryStart+4:entryStart+8], data[frmaContent:frmaContent+4])
+						return
+					}
+				}
+			}
+		}
+		next := bytes.Index(data[entryStart+sinfOff+1:entryEnd], []byte("sinf"))
+		if next < 0 {
+			return
+		}
+		sinfOff = sinfOff + 1 + next
+	}
+}
@@ -0,0 +1,178 @@
+package fqapi
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"encoding/binary"
+	"bytes"
+	"encoding/base64"
+	"encoding/hex"
+	"io"
+	"os"
+	"strings"
+	"testing"
+)
+
+// 番茄短剧真实样本（video_model video_1..4 共用同一 spade_a）
+const testSpadeA = "kbwfwFiKI8RuvCnHV4ss9lK6HMFmvS/2f7wv7H+mAfRRvxmXlw=="
+
+func TestDecodeSpadeKey(t *testing.T) {
+	key, err := DecodeSpadeKey(testSpadeA)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := "4f04d75b0df5cee67dbe13738872e965"
+	if got := hex.EncodeToString(key); got != want {
+		t.Fatalf("key mismatch: got %s want %s", got, want)
+	}
+}
+
+// 端到端：下载真实 360p 视频 → DecryptCENCMP4 → 输出文件（ffprobe 验证）
+func TestDecryptRealVideo(t *testing.T) {
+	mainURLB64 := os.Getenv("FQ_VIDEO_URL")
+	spadeA := strings.TrimSpace(os.Getenv("FQ_VIDEO_SPADE"))
+	if mainURLB64 == "" || spadeA == "" {
+		t.Skip("need FQ_VIDEO_URL (main_url base64) and FQ_VIDEO_SPADE")
+	}
+	url, err := base64.StdEncoding.DecodeString(mainURLB64)
+	if err != nil {
+		t.Fatal(err)
+	}
+	body, _, err := downloadMedia(string(bytes.TrimSpace(url)), "", map[string]string{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer body.Close()
+	data, err := io.ReadAll(body)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("downloaded %d bytes", len(data))
+
+	key, err := DecodeSpadeKey(spadeA)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("key=%x", key)
+	if err := DecryptCENCMP4(data, key); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile("/tmp/video_decrypted.mp4", data, 0644); err != nil {
+		t.Fatal(err)
+	}
+	t.Log("written /tmp/video_decrypted.mp4")
+}
+
+// ---- 合成 CENC MP4 单元测试：加密 → 解密 → 比对明文 ----
+
+func box(typ string, payload ...[]byte) []byte {
+	var body []byte
+	for _, p := range payload {
+		body = append(body, p...)
+	}
+	b := make([]byte, 8+len(body))
+	binary.BigEndian.PutUint32(b[:4], uint32(len(b)))
+	copy(b[4:8], typ)
+	copy(b[8:], body)
+	return b
+}
+
+func u32(v uint32) []byte { b := make([]byte, 4); binary.BigEndian.PutUint32(b, v); return b }
+
+func TestDecryptCENCMP4Synthetic(t *testing.T) {
+	key := []byte("0123456789abcdef")
+	plain1 := []byte("HELLO_CENC_SAMPLE_1_PADPADP")
+	plain2 := []byte("SECOND_SAMPLE")
+	plain3 := []byte("THIRD")
+
+	enc := func(pt []byte, iv8 []byte) []byte {
+		iv := make([]byte, 16)
+		copy(iv, iv8)
+		block, _ := aes.NewCipher(key)
+		ct := make([]byte, len(pt))
+		cipher.NewCTR(block, iv).XORKeyStream(ct, pt)
+		return ct
+	}
+	iv1 := []byte{1, 2, 3, 4, 5, 6, 7, 8}
+	iv2 := []byte{8, 7, 6, 5, 4, 3, 2, 1}
+	iv3 := []byte{0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x11, 0x22}
+	ct1, ct2, ct3 := enc(plain1, iv1), enc(plain2, iv2), enc(plain3, iv3)
+
+	// buildFile(off1, off2)：chunk 绝对偏移写入 stco；偏移依赖 moov 长度，先占位测长再重建
+	buildFile := func(off1, off2 uint32) []byte {
+		entry := box("enca", make([]byte, 8), box("sinf", box("frma", []byte("mp4a"))))
+		stsd := box("stsd", u32(0), u32(1), entry)
+		stsz := box("stsz", u32(0), u32(0), u32(3), u32(uint32(len(plain1))), u32(uint32(len(plain2))), u32(uint32(len(plain3))))
+		stsc := box("stsc", u32(0), u32(2),
+			u32(1), u32(2), u32(1), // entry1: chunk1 起，每 chunk 2 样本
+			u32(2), u32(1), u32(1)) // entry2: chunk2 起，每 chunk 1 样本
+		stco := box("stco", u32(0), u32(2), u32(off1), u32(off2))
+		sencBody := append(append(append(append(u32(0), u32(3)...), iv1...), iv2...), iv3...)
+		senc := box("senc", sencBody)
+		moov := box("moov", box("trak", box("mdia", box("minf", box("stbl", stsd, stsz, stsc, stco, senc)))))
+		ftyp := box("ftyp", []byte("isom"))
+		return append(append(ftyp, moov...), box("mdat", ct1, ct2, ct3)...)
+	}
+
+	// 占位构造测 moov 总长，得到真实 chunk 偏移后重建
+	probe := buildFile(0, 0)
+	chunk1Off := uint32(len(probe) - len(ct1) - len(ct2) - len(ct3))
+	chunk2Off := chunk1Off + uint32(len(ct1)+len(ct2))
+	data := buildFile(chunk1Off, chunk2Off)
+
+	if err := DecryptCENCMP4(data, key); err != nil {
+		t.Fatal(err)
+	}
+	if got := data[chunk1Off : chunk1Off+uint32(len(plain1))]; string(got) != string(plain1) {
+		t.Errorf("sample1 解密不符: %q", got)
+	}
+	s2 := chunk1Off + uint32(len(plain1))
+	if got := data[s2 : s2+uint32(len(plain2))]; string(got) != string(plain2) {
+		t.Errorf("sample2 解密不符: %q", got)
+	}
+	if got := data[chunk2Off : chunk2Off+uint32(len(plain3))]; string(got) != string(plain3) {
+		t.Errorf("sample3 解密不符: %q", got)
+	}
+	// stsd entry 类型应被 patch 为 frma 指示的 mp4a（原 enca 四字已不存在）
+	if bytes.Index(data, []byte("enca")) >= 0 || bytes.Index(data, []byte("mp4a")) < 0 {
+		t.Error("stsd entry 类型未修复为 mp4a")
+	}
+}
+
+// 清晰度过滤：按 definition 与档位 key 均可命中；无匹配返回空列表由上层报错
+func TestDecodeVideoModelQualityFilter(t *testing.T) {
+	vm := `{"video_id":"v123","video_duration":1.5,"video_list":{
+		"video_1":{"definition":"360p","vtype":"mp4","main_url":"` + base64.StdEncoding.EncodeToString([]byte("https://a/360")) + `"},
+		"video_4":{"definition":"720p","vtype":"mp4","main_url":"` + base64.StdEncoding.EncodeToString([]byte("https://a/720")) + `"}}}`
+	got := decodeVideoModelAsJSON(vm, "url", "", "720p").(map[string]interface{})
+	vl := got["video_list"].(map[string]interface{})
+	if len(vl) != 1 || vl["video_4"] == nil {
+		t.Fatalf("definition 过滤失败: %v", vl)
+	}
+	got = decodeVideoModelAsJSON(vm, "url", "", "VIDEO_1").(map[string]interface{})
+	vl = got["video_list"].(map[string]interface{})
+	if len(vl) != 1 || vl["video_1"] == nil {
+		t.Fatalf("档位key过滤失败: %v", vl)
+	}
+	if u := vl["video_1"].(map[string]interface{})["main_url"].(string); u != "https://a/360" {
+		t.Fatalf("main_url 未解码: %s", u)
+	}
+	got = decodeVideoModelAsJSON(vm, "url", "", "1080p").(map[string]interface{})
+	if len(got["video_list"].(map[string]interface{})) != 0 {
+		t.Fatal("无匹配应返回空列表")
+	}
+	// max 取最高档（vheight 缺失时按 definition 数字比较）
+	got = decodeVideoModelAsJSON(vm, "url", "", "max").(map[string]interface{})
+	vl = got["video_list"].(map[string]interface{})
+	if len(vl) != 1 || vl["video_4"] == nil {
+		t.Fatalf("max 应只保留最高档: %v", vl)
+	}
+	// vheight 存在时优先按 vheight
+	vm2 := `{"video_list":{
+		"video_1":{"definition":"360p","vwidth":360,"vheight":640},
+		"video_2":{"definition":"540p","vwidth":540,"vheight":960}}}`
+	got = decodeVideoModelAsJSON(vm2, "url", "", "max").(map[string]interface{})
+	if len(got["video_list"].(map[string]interface{})) != 1 || got["video_list"].(map[string]interface{})["video_2"] == nil {
+		t.Fatal("max 应按 vheight 取 video_2")
+	}
+}
@@ -124,23 +124,17 @@ func addReviewToContent(jsonResult, itemID string, r *http.Request) string {
 		}
 	}

-	// 获取基础 URL
+	// 获取基础 URL（反代场景识别 X-Forwarded-Proto，避免生成 http:// 被 301）
 	cfg := config.GetConfig()
 	baseURL := ""
-	if cfg != nil {
+	if r.Host != "" {
+		baseURL = externalBaseURL(r)
+	} else if cfg != nil {
 		host := cfg.Server.Host
 		if host == "0.0.0.0" {
 			host = "localhost"
 		}
-		port := cfg.Server.Port
-		scheme := "http"
-
-		// 检查是否来自外部请求
-		if r.Host != "" {
-			baseURL = scheme + "://" + r.Host
-		} else {
-			baseURL = scheme + "://" + host + ":" + port
-		}
+		baseURL = "http://" + host + ":" + cfg.Server.Port
 	}

 	// 生成带段评标记的内容
@@ -7,6 +7,7 @@ import (
 	"io"
 	"net/http"
 	"strings"
+	"time"
 )

 // HandleAudio 音频处理
@@ -75,7 +76,9 @@ func HandleVideo(w http.ResponseWriter, r *http.Request) {
 		return
 	}

-	result, err := fqapi.HandleVideo(params["item_ids"])
+	output := r.URL.Query().Get("output")
+	quality := r.URL.Query().Get("quality")
+	result, err := fqapi.HandleVideo(params["item_ids"], output, quality)
 	if err != nil {
 		respondError(w, "获取视频失败: "+err.Error(), false)
 		return
@@ -84,6 +87,30 @@ func HandleVideo(w http.ResponseWriter, r *http.Request) {
 	fmt.Fprint(w, result)
 }

+// HandleVideoProxy 视频解密代理处理（磁盘缓存优先；http.ServeContent 支持 Range/seek/HEAD，
+// 播放器拖动进度条时按需分片返回）
+func HandleVideoProxy(w http.ResponseWriter, r *http.Request) {
+	incrementStat("total", "video")
+
+	path := r.URL.Path
+	key := strings.TrimPrefix(path, "/video/proxy/")
+	if key == "" || key == path {
+		http.Error(w, "缺少视频key", http.StatusBadRequest)
+		return
+	}
+
+	content, contentType, err := fqapi.HandleVideoProxy(key)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if closer, ok := content.(io.Closer); ok {
+		defer closer.Close()
+	}
+	w.Header().Set("Content-Type", contentType)
+	http.ServeContent(w, r, key+".mp4", time.Time{}, content)
+}
+
 // HandleManga 漫画处理
 func HandleManga(w http.ResponseWriter, r *http.Request) {
 	incrementStat("total", "manga")
@@ -12,6 +12,16 @@ import (
 	"time"
 )

+// externalBaseURL 取外部可访问的基础 URL（nginx 反代下识别 X-Forwarded-Proto，
+// 避免生成 http:// 链接被 301，弹窗 WebView 内 fetch 对 301 处理不稳）
+func externalBaseURL(r *http.Request) string {
+	scheme := "http"
+	if p := r.Header.Get("X-Forwarded-Proto"); p != "" {
+		scheme = p
+	}
+	return scheme + "://" + r.Host
+}
+
 // validateParams 验证必需参数
 func validateParams(r *http.Request, required ...string) (map[string]string, error) {
 	params := make(map[string]string)
@@ -207,7 +217,7 @@ func HandleReviewHTML(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "text/html; charset=utf-8")
 	w.WriteHeader(http.StatusOK)

-	html := generateReviewHTML(data, params["item_id"], bookID, para, page, pageSize, sort)
+	html := generateReviewHTML(r, data, params["item_id"], bookID, para, page, pageSize, sort)
 	fmt.Fprint(w, html)
 }

@@ -318,6 +328,7 @@ var reviewTmpl = template.Must(template.New("review").Parse(reviewHTML))
 // reviewPageData 评论页模板数据
 type reviewPageData struct {
 	ItemID, BookID         string
+	BaseURL                string
 	ParaPlus1, Para, Sort  int
 	Total, NextOffset      int
 	PageSize, CommentCount int
@@ -327,7 +338,7 @@ type reviewPageData struct {
 }

 // generateReviewHTML 生成评论 HTML 页面
-func generateReviewHTML(data map[string]interface{}, itemID, bookID string, para, page, pageSize, sort int) string {
+func generateReviewHTML(r *http.Request, data map[string]interface{}, itemID, bookID string, para, page, pageSize, sort int) string {
 	total := 0
 	hasMore := false
 	nextOffset := 0
@@ -383,6 +394,7 @@ func generateReviewHTML(data map[string]interface{}, itemID, bookID string, para
 	var b strings.Builder
 	if err := reviewTmpl.Execute(&b, reviewPageData{
 		ItemID: itemID, BookID: bookID,
+		BaseURL:   externalBaseURL(r),
 		ParaPlus1: para + 1, Para: para, Sort: sort,
 		Total: total, NextOffset: nextOffset,
 		PageSize: pageSize, CommentCount: len(pageComments),
@@ -49,25 +49,50 @@
            box-sizing: border-box;
            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
        }
+        html, body { height: 100%; }
        body {
            background-color: var(--bg-primary);
            color: var(--text-primary);
-            padding: 15px;
            max-width: 600px;
            margin: 0 auto;
+            display: flex;
+            flex-direction: column;
+            overflow: hidden;
            transition: background-color 0.3s ease, color 0.3s ease;
        }
        .header {
+            flex-shrink: 0;
            display: flex;
            justify-content: space-between;
            align-items: center;
-            margin-bottom: 20px;
-            padding: 10px 15px;
+            padding: 10px 15px 12px;
            background: var(--bg-secondary);
-            border-radius: 12px;
+            border-radius: 20px 20px 0 0;
+            border-bottom: 1px solid var(--border-color);
            box-shadow: 0 2px 8px var(--shadow);
+            position: relative;
+            z-index: 10;
            transition: background-color 0.3s ease;
        }
+        /* BottomSheet 顶部拖拽把手 */
+        .header::before {
+            content: '';
+            position: absolute;
+            top: 6px;
+            left: 50%;
+            transform: translateX(-50%);
+            width: 36px;
+            height: 4px;
+            border-radius: 2px;
+            background: var(--border-color);
+        }
+        #comment-list {
+            flex: 1;
+            overflow-y: auto;
+            -webkit-overflow-scrolling: touch;
+            padding: 15px;
+            overscroll-behavior: contain;
+        }
        .header h1 {
            font-size: 18px;
            color: var(--text-primary);
@@ -333,8 +358,8 @@
            <i class="fas fa-book-open" style="color: var(--text-tertiary); font-size: 16px; margin: 0 10px;"></i>
        </span>
        <div class="sort-tabs">
-            <div class="sort-tab{{if eq .Sort 1}} active{{end}}" onclick="switchSort(1)">最热</div>
-            <div class="sort-tab{{if eq .Sort 3}} active{{end}}" onclick="switchSort(3)">最新</div>
+            <div class="sort-tab{{if eq .Sort 1}} active{{end}}" onclick="switchSort(1, this)">最热</div>
+            <div class="sort-tab{{if eq .Sort 3}} active{{end}}" onclick="switchSort(3, this)">最新</div>
        </div>
    </div>
    <div id="comment-list">
@@ -370,6 +395,8 @@
        const bookID = '{{.BookID}}';
        const para = {{.Para}};
        let currentSort = {{.Sort}};
+        // 服务端注入的绝对地址：弹窗 WebView(loadDataWithBaseURL) 中相对路径解析不可靠
+        const API_BASE = '{{.BaseURL}}';
    
        const commentList = document.getElementById('comment-list');
        const imageViewer = document.getElementById('imageViewer');
@@ -380,7 +407,7 @@
        // 已加载回复的评论
        const loadedReplies = new Set();
        
-        // URL 构建
+        // URL 构建（绝对地址，兼容弹窗 WebView）
        function buildReviewURL(params) {
            const baseParams = {
                item_id: itemID,
@@ -388,7 +415,7 @@
                para: para
            };
            const query = new URLSearchParams({...baseParams, ...params});
-            return '/review?' + query.toString();
+            return API_BASE + '/review?' + query.toString();
        }
        
        // 时间格式化
@@ -429,11 +456,11 @@
            };
        }
        
-        // 滚动信息获取
+        // 滚动信息获取（评论区为独立滚动容器）
        function getScrollInfo() {
-            const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
-            const scrollHeight = document.documentElement.scrollHeight;
-            const clientHeight = document.documentElement.clientHeight;
+            const scrollTop = commentList.scrollTop;
+            const scrollHeight = commentList.scrollHeight;
+            const clientHeight = commentList.clientHeight;
            return {
                scrollTop,
                scrollHeight,
@@ -443,11 +470,11 @@
        }
        
        // 切换排序
-        async function switchSort(newSort) {
+        async function switchSort(newSort, tab) {
            if (currentSort === newSort) return;
-            
-            document.querySelectorAll('.sort-tab').forEach(tab => tab.classList.remove('active'));
-            event.target.closest('.sort-tab').classList.add('active');
+
+            document.querySelectorAll('.sort-tab').forEach(t => t.classList.remove('active'));
+            if (tab) tab.classList.add('active');
            
            commentList.innerHTML = LOADING_HTML;
            
@@ -479,7 +506,7 @@
                    }
                    
                    loadedReplies.clear();
-                    window.scrollTo({ top: 0, behavior: 'smooth' });
+                    commentList.scrollTo({ top: 0, behavior: 'smooth' });
                } else {
                    commentList.innerHTML = '<div class="empty">加载失败，请重试</div>';
                    commentIndex = 0;
@@ -751,25 +778,25 @@
        
        // 回到顶部
        function scrollToTop() {
-            window.scrollTo({
+            commentList.scrollTo({
                top: 0,
                behavior: 'smooth'
            });
        }
-        
-        // 滚动监听
+
+        // 滚动监听（挂在评论容器上，顶栏固定不参与滚动）
        const handleScroll = debounce(() => {
            const scroll = getScrollInfo();
-            
+
            // 显示/隐藏回到顶部按钮
            backToTopBtn.classList.toggle('show', scroll.scrollTop > 300);
-            
+
            // 距离底部 200px 时触发加载
            if (scroll.distanceFromBottom <= 200) {
                loadMoreComments();
            }
        }, 100);
-        
-        window.addEventListener('scroll', handleScroll, { passive: true });
+
+        commentList.addEventListener('scroll', handleScroll, { passive: true });
    </script>
 </body>
@@ -0,0 +1,68 @@
+[
+  {
+    "bookSourceComment": "如果是用的官方版阅读，或者低版本阅读，推荐更新阅读以使用新功能，否则很多功能无法使用哦\n软件下载地址：https://legado.qingtian618.com\n推荐使用阅读R或者阅读Sigma\n\n\n晴天聚合重构，已适配所有安卓版本阅读\n目前不适配苹果端栖阅(可以正常阅读，发现页无法适配)\n\n更新日志请点击登录，更新书源中查看\n\n基础使用教程：\n1、搜索：\n    1)基础搜索：在发现页长按该书源，点击搜索，直接搜，搜索范围(全部来源小说)\n    2)进阶搜索：在登陆-书源设置中选择指定模式/来源，可搜索指定模式/来源内容\n    3)快捷搜索：使用特殊关键词(x,t,m,d,@)搜索\n         x:书名@来源  如(x:十日终焉@番茄)\n         t:书名@来源  如(t:十日终焉@番茄)\n         m:书名@来源  如(m:十日终焉@番茄)\n         d:书名@来源  如(d:十日终焉@番茄)\n         其中：x表示小说(可省略)，t表示听书，m表示漫画，d表示短剧\n         冒号支持中文英文\n         \n2、发现页：\n    在书源设置中选择指定模式或者单个来源，然后刷新发现页即可\n    \n3、更多使用方式进入书源设置页面应该能一目了然",
+    "bookSourceGroup": "📖番茄小说",
+    "bookSourceName": "🔅光遇聚合",
+    "bookSourceType": 0,
+    "bookSourceUrl": "光遇聚合",
+    "bookUrlPattern": "https?:\\/\\/(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z0-9-]+(?::\\d+)?\\/detail.*",
+    "customButton": false,
+    "customOrder": 0,
+    "enabled": true,
+    "enabledCookieJar": true,
+    "enabledExplore": true,
+    "eventListener": false,
+    "exploreUrl": "<js>\n\n\nlet moreSettings = getVariable('更多设置');\nvar base_url = BaseUrl();\nvar source_type = getVariable('频道') || '男频';\nlet tab = moreSettings && moreSettings['搜索模式'] || '小说';\nlet sources = getVariable(\"发现页来源\") || moreSettings && moreSettings[tab] || '全部';\nlet islyc = checkEnv();\nlet wordNum = getVariable('字数') || '不限';\nlet update = getVariable('更新') || '不限';\nlet sort = getVariable('排序') || '综合';\nlet wordNumMap = {\n    '不限': 'word_num_default',\n    '10万字以内': 'word_num_lte10',\n    '30万字以内': 'word_num_lte30',\n    '50万字以内': 'word_num_lte50',\n    '30万字以上': 'word_num_gte30',\n    '50万字以上': 'word_num_gte50',\n    '100万字以上': 'word_num_gte100',\n    '200万字以上': 'word_num_gte200',\n    '300万字以上': 'word_num_gte300',\n    '500万字以上': 'word_num_gte500'\n};\nlet wordNumParam = wordNumMap[wordNum] || 'word_num_default';\nlet updateMap = {\n    '不限': 'creation_status_default',\n    '完结': 'creation_status_end',\n    '半年内完结': 'creation_status_half_year_end',\n    '连载中': 'creation_status_loading',\n    '3日内更新': 'creation_status_3day_update',\n    '7日内更新': 'creation_status_7day_update',\n    '1月内更新': 'creation_status_1month_update'\n};\nlet updateParam = updateMap[update] || 'creation_status_default';\nlet sortMap = {\n    '综合': 'sort_default',\n    '新书': 'sort_new_book',\n    '高分': 'sort_score',\n    '字数': 'sort_word_number'\n};\nlet sortParam = sortMap[sort] || 'sort_default';\nlet selected_items = `${wordNumParam},${updateParam},${sortParam}`;\n\n\nif (islyc != \"苹果\" && islyc != \"安卓\"){\n\ttab = getVariable(\"发现页类型\");\n\t}\n\n\nlet js;\n\njs = getVariable('云端配置');\n//java.longToast(JSON.stringify(js))\nif (!!!js) {\n    getCloudSettings(true);\n    js = getVariable('云端配置');\n }\n\n\nlet source_list = [];\ntry{\nsource_list = js[tab];\n} catch (e) {\n\tjava.longToast(e);\n\t}\n\nlet fqssionid = getFqToken();\nif (!fqssionid && (sources == '番茄' || sources == '全部')) {\n    java.toast('您还未登陆番茄账号，无法同步数据哦！');\n} \nvar fqsjurl = base_url + \"/bookshelf?page={{page}}&ssionid=\" + fqssionid;\nvar fqtjurl = base_url + \"/fqrecommend?page={{page}}&ssionid=\" + fqssionid;\nvar fqlsurl = base_url + \"/fqhistory?page={{page}}&ssionid=\" + fqssionid;\n\n\nvar groupDatas = [];\nvar infoData = [ ];\nif (sources == '番茄' || sources == '全部') {\ninfoData = [{\n        \"title\": \"登录番茄\",\n        \"url\": '{\\{java.startBrowser(\"https://fanqienovel.com/\",\"番茄登录\");}}',\n        \"style\": {\n            \"layout_flexGrow\": 1,\n            \"layout_flexBasisPercent\": 0.45\n        }\n    }];\n}\n\nvar hasValidCookie = fqssionid.length > 0;\n\nif (hasValidCookie && (sources == '番茄' || sources == '全部')) {\n    function groupQuery() {\n        try {\n            var url = base_url + \"/group_name?ssionid=\" + fqssionid;\n            var res = java.ajax(url);\n            var response = JSON.parse(res);\n\n            if (!(response && response.data)) {}\n\n            response.data.forEach(function(group) {\n                var keys = Object.keys(group);\n                if (keys.length > 0) {\n                    var key = keys[0];\n                    var value = group[key];\n                    if (value && value.length) {\n                        var option = {\n                            \"method\": \"POST\",\n                            \"body\": {\n                                \"book_ids\": value,\n                                \"page\": \"{{page}}\"\n                            }\n                        };\n                        groupDatas.push({\n                            title: key,\n                            url: base_url + \"/bookshelf,\" + JSON.stringify(option),\n                            style: {\n                                layout_flexGrow: 1,\n                                layout_flexBasisPercent: 0.25\n                            }\n                        });\n                    }\n                }\n            });\n\n            if (groupDatas.length % 2 != 0) {\n                groupDatas.push({\n                    title: \"--\",\n                    url: \"\",\n                    style: {\n                        layout_flexGrow: 1,\n                        layout_flexBasisPercent: 0.25\n                    }\n                });\n            }\n            if (groupDatas.length % 3 != 0) {\n                groupDatas.push({\n                    title: \"--\",\n                    url: \"\",\n                    style: {\n                        layout_flexGrow: 1,\n                        layout_flexBasisPercent: 0.25\n                    }\n                });\n            }\n        } catch (e) {\n            java.longToast(\"番茄登录过期Line truncated
+    "jsLib": "// 当前书源版本号，切勿修改，否则影响更新的识别\nlet localVersion = '26.10.9';\n\n// 初始服务器列表\nlet hosts = [\n    'https://v1.qingtian618.com',\n    'https://cdn.qingtian618.com',\n    'https://v2.qingtian618.com',\n    'https://v3.qingtian618.com',\n    'https://v4.qingtian618.com',\n    'https://v5.qingtian618.com',\n    'https://v6.qingtian618.com',\n    'https://v7.qingtian618.com'\n];\n\nfunction isSpecialMedia (sources) {\n\tlet SOURCES_SPECIAL_MEDIA = ['毒舌影视', 'NT动漫'];\n\t return SOURCES_SPECIAL_MEDIA.some(src => sources.includes(src));\n\t}\n\nfunction buildDiscussionButton(url,sources)  {\n    let clickAction =\n        `showCmt(\"${url}\",\"${sources}\",'本书讨论')`;\n\n    return `\n        <button style=\"\">💬 书籍讨论@onclick:${clickAction}</button>\n    `;\n};\n\n// 初始化值\nconst defaultConfig = {\n    线路: hosts[0],\n    发现页来源: \"番茄\",\n    发现页类型: \"小说\"\n};\n\n// 获取云端配置\nfunction getCloudSettings(r) {\n    if (r == undefined) r = false;\n    const {\n        java,\n        cache\n    } = this;\n    let c = this.getVariable('云端配置').version;\n    if (r || !c) {\n        java.longToast(`\\n正在更新最新配置`);\n        try {\n            let url = `/static/source_config/config.json`;\n            //\tjava.longToast(url)\n            let js = this.request(url);\n            js = JSON.parse(String(js));\n            let intc = parseInt(c);\n            let intv = parseInt(js['version']);\n            if (intc >= intv) {\n            \t    java.longToast(`\\n已是最新配置：${js['version']}`);\n            \t    return;\n            \t} else if (!intc && intv) {\n            \t\tjava.longToast(`\\n已初始化配置：${intv}`);\n            \t\t} else if (intc < intv || !intc && intv) {\n            java.longToast(`\\n已更新配置：${intc}→${intv}`);\n            } else {\n            java.longToast(`\\n获取配置失败：请切换线路再试试~`);\n            return;\n            }\n            this.setVariable('云端配置', js);\n            \n            return js;\n        } catch (e) {\n            java.longToast(`\\n获取最新配置失败：${e}`);\n        }\n    }\n}\n\n// 统一获取和解析变量\nfunction _getParsedVariable() {\n    const {\n        source,\n        java\n    } = this;\n    let v = source.getVariable();\n    try {\n        return JSON.parse(v);\n    } catch {\n        return defaultConfig;\n    }\n}\n\n// 获取设置变量\nfunction getLoginInfo(k) {\n    const {\n        source,\n        java\n    } = this;\n    let res = source.getLoginInfoMap();\n    if (!res) {\n        res = defaultConfig;\n    }\n    if (res[k] == '❌') {\n        return '0';\n    } else if (res[k] == '✅') {\n        return '1';\n    }\n    return res[k]\n}\n\n// 还原\nfunction deleteVariable() {\n    const {\n        source,\n        java,\n        cache\n    } = this;\n    source.setVariable('');\n    cache.delete('gyksconfig');\n    java.longToast('\\n所有设置已还原到初始化导入状态');\n}\n\n// 获取源变量\nfunction getVariable(k) {\n    if (k == undefined) k = \"\";\n    const { source } = this;\n    let parsed = {}\n    try {\n        parsed = JSON.parse(source.getVariable());\n    } catch {}\n    if (k == \"\") {\n        return parsed;\n    }\n    let value = parsed[k];\n    if (value == undefined) {\n        value = defaultConfig[k];\n    }\n    return value != undefined ? value : \"\";\n}\n\n// 设置源变量\nfunction setVariable(k, v, t) {\n    if (t == undefined) t = true;\n    const {\n        source,\n        java\n    } = this;\n    const vs = this.getVariable();\n    vs[k] = v;\n    source.setVariable(JSON.stringify(vs, null, 4));\n    if (k != '云端配置' && t && k!='搜索关键词') {\n        java.toast(`\\n设置 ${k} 为 ${v}`)\n    }\n}\n\n// 获取正在使用的线路\nfunction BaseUrl() {\n    let hostsbk = this.getVariable('云端配置')['hosts'] || hosts;\n    let h = this.getVariable(\"线路\");\n    if (!h || String(h) == \"undefind\") {\n        h = hostsbk[0]\n    }\n    return h;\n}\n\n// 切换线路\nfunction switchToNextLine(toast) {\n    if (toast == undefined) toast = false;\n    const currentLine = this.BaseUrl();\n    let hostsbk = this.getVariable('云端配置')['hosts'] || hosts;\n    let currentIndex = hostsbk.findIndex(item => item == currentLine);\n    let nextIndex = (currentIndex + 1) % hostsbk.length;\n    const nextLine = hostsbk[nextIndex];\n    this.setVariable(\"线路\", nextLine,false);\n    let switchToast = this.getVariable(\"切换提醒\") || \"false\";\n    if (toast && switchToast  == \"true\") {\n        this.java.longToast(`\\n${toast}\\n自动切换到:${nextLine}`)\n    }\n    return nextLine;\n}\n\n\n// 备用设置方案\nfunction ste(v) {\n    const {\n        java\n    } = this;\n    let moreSettings = this.getVariable(\"更多设置\") || {};Line truncated
+    "lastUpdateTime": 1791479867070,
+    "loginUi": "[\n     {\n        \"name\": \"🔭 切换线路\",\n        \"type\": \"button\",\n        \"action\": \"getServerSettings()\",\n        \"style\": {\n            \"layout_flexGrow\": 1,\n            \"layout_flexBasisPercent\": 1\n        }\n    },{\n        \"name\": \"⚙️ 书源设置\",\n        \"type\": \"button\",\n        \"action\": \"getHtmlSettings()\",\n        \"style\": {\n            \"layout_flexGrow\": 1,\n            \"layout_flexBasisPercent\": 0.4\n        }\n    },  {\n        \"name\": \"🗨 段评设置\",\n        \"type\": \"button\",\n        \"action\": \"getSvgSettings()\",\n        \"style\": {\n            \"layout_flexGrow\": 1,\n            \"layout_flexBasisPercent\": 0.4\n        }\n    },{\n        \"name\": \"邮箱\",\n        \"type\": \"text\"\n    }, {\n        \"name\": \"密码\",\n        \"type\": \"password\"\n    }, {\n        \"name\": \"🔅登录账号\",\n        \"type\": \"button\",\n        \"action\": \"login(true)\",\n        \"style\": {\n            \"layout_flexGrow\": 1,\n            \"layout_flexBasisPercent\": 0.4\n        }\n    }, {\n        \"name\": \"🔐注册账号\",\n        \"type\": \"button\",\n        \"action\": \"register()\",\n        \"style\": {\n            \"layout_flexGrow\": 1,\n            \"layout_flexBasisPercent\": 0.4\n        }\n    }, {\n        \"name\": \" 🔚 退出登录\",\n        \"type\": \"button\",\n        \"action\": \"logout()\",\n        \"style\": {\n            \"layout_flexGrow\": 1,\n            \"layout_flexBasisPercent\": 0.4\n        }\n    },\n    {\n        \"name\": \"🏝用户后台\",\n        \"type\": \"button\",\n        \"action\": \"user()\",\n        \"style\": {\n            \"layout_flexGrow\": 1,\n            \"layout_flexBasisPercent\": 0.4\n        }\n    },{\n        \"name\": \"📴 清理设备\",\n        \"type\": \"button\",\n        \"action\": \"clearDevice()\",\n        \"style\": {\n            \"layout_flexGrow\": 1,\n            \"layout_flexBasisPercent\": 0.4\n        }\n    },{\n        \"name\": \"🪪 查看信息\",\n        \"type\": \"button\",\n        \"action\": \"checkStatus()\",\n        \"style\": {\n            \"layout_flexGrow\": 1,\n            \"layout_flexBasisPercent\": 0.4\n        }\n    },{\n        \"name\": \"🌷求打赏\",\n        \"type\": \"button\",\n        \"action\": \"vip()\",\n        \"style\": {\n            \"layout_flexGrow\": 1,\n            \"layout_flexBasisPercent\": 0.4\n        }\n    },{\n        \"name\": \"🎈永久发布页\",\n        \"type\": \"button\",\n        \"action\": \"fb()\",\n        \"style\": {\n            \"layout_flexGrow\": 1,\n            \"layout_flexBasisPercent\": 0.4\n        }\n    },{\n        \"name\": \"✳️ 更新配置\",\n        \"type\": \"button\",\n        \"action\": \"_getCloudSettings()\",\n        \"style\": {\n            \"layout_flexGrow\": 1,\n            \"layout_flexBasisPercent\": 0.4\n        }\n    },{\n        \"name\": \"❇️ 更新书源\",\n        \"type\": \"button\",\n        \"action\": \"renderVersionPage()\",\n        \"style\": {\n            \"layout_flexGrow\": 1,\n            \"layout_flexBasisPercent\": 0.4\n        }\n    }, {\n        \"name\": \"📤保存设置到云端\",\n        \"type\": \"button\",\n        \"action\": \"saveSettings()\",\n        \"style\": {\n            \"layout_flexGrow\": 1,\n            \"layout_flexBasisPercent\": 0.4\n        }\n    }, {\n        \"name\": \" 📨从云端获取设置\",\n        \"type\": \"button\",\n        \"action\": \"getSettings()\",\n        \"style\": {\n            \"layout_flexGrow\": 1,\n            \"layout_flexBasisPercent\": 0.4\n        }\n    }, {\n        \"name\": \"⛔‼️ 清空还原设置\",\n        \"type\": \"button\",\n        \"action\": \"deleteVariable()\",\n        \"style\": {\n            \"layout_flexGrow\": 1,\n            \"layout_flexBasisPercent\": 1\n        }\n    }, {\n        \"name\": \"===下方为备用设置方案===\",\n        \"type\": \"button\",\n        \"action\": \"\",\n        \"style\": {\n            \"layout_flexGrow\": 1,\n            \"layout_flexBasisPercent\": 1\n        }\n    }, {\n        \"name\": \"📖搜索小说\",\n        \"type\": \"button\",\n        \"action\": \"ste('小说')\",\n        \"style\": {\n            \"layout_flexGrow\": 1,\n            \"layout_flexBasisPercent\": 0.4\n        }\n    }, {\n        \"name\": \"🎧搜索听书\",\n        \"type\": \"button\",\n        \"action\": \"ste('听书')\",\n        \"style\": {\n            \"layout_flexGrow\": 1,\n            \"layout_flexBasisPercent\": 0.4\n        }\n    }, {\n        \"name\": \"🎥搜索短剧\",\n        \"type\": \"button\",\n        \"action\": \"ste('短剧')\",\n        \"style\": {\n            \"layout_flexGrow\": 1,\n            \"layout_flexBasisPercent\": 0.4\n        }\n    }, {\n        \"name\": \"🎨搜索漫Line truncated
+    "loginUrl": "//登陆\nfunction login(flag) {\n    const token = getToken();\n    if (String(token).length > 10) {\n        java.longToast(flag ? '\\n当前✅️已登录，请🚫退出登录后重新登录' : '\\n✅️已登录');\n        return true;\n    }\n    if (flag == undefined) {\n        result = JSON.parse(source.getLoginInfo())\n    } else {\n        java.longToast(\"\\n\\n💞正在登录中...\")\n    }\n    let email = result.邮箱;\n    let pwd = result.密码;\n\n    if (!email || !pwd) {\n        java.longToast('\\n请先输入账号密码！');\n        return false;\n    }\n    if (!email.includes('@')) {\n        java.longToast('\\n请输入正确的邮箱格式！');\n        return false;\n    }\n    try {\n        let data = request('/login_api','POST',{\n                register_email: email,\n                password: pwd\n            })\n        const response = JSON.parse(data);\n        if (response.code == 0) {\n            setAllCookies(`qttoken=${response.key}`);\n            java.longToast(\"\\n✅️登录成功\");\n            return true;\n        } else {\n            let msg = response.msg;\n            if (msg.includes('多次登录失败')) {\n                java.longToast('\\n💔多次登录失败，请检查账号密码，切换线路后重试或等2小时后重试！');\n            } else {\n                java.longToast('\\n💔' + (msg || \"登录失败，请重试！\"));\n            }\n            return false;\n        }\n    } catch (error) {\n        java.longToast('\\n💔登录失败，服务器错误，请更换线路后重试！\\n' + error);\n        return false;\n    }\n}\n\n// 用户注册\nfunction register() {\n    java.startBrowserAwait(BaseUrl() + '/register', '光遇看书注册');\n}\n\n//用户后台\nfunction user() {\n    const token = getToken();\n    if (String(token).length < 10) {\n        java.longToast('\\n🤔请先登陆');\n        return;\n    }\n    java.startBrowserAwait(BaseUrl() + '/user', '光遇看书用户后台');\n}\n\n// 退出登陆\nfunction logout() {\n    removeAllCookies();\n}\n\n// 获取云端配置\nfunction _getCloudSettings() {\n    getCloudSettings(true)\n}\n\n//打赏\nfunction vip() {\n    const token = getToken();\n    if (String(token).length < 10) {\n        java.longToast('\\n🤔请先登陆');\n        return;\n    }\n    java.startBrowserAwait(BaseUrl() + '/coffee', '光遇聚合会员开通');\n}\n\nfunction formatDate(timestamp) {\n    const date = new Date(timestamp * 1000);\n    return `${date.getFullYear()}-${(date.getMonth() + 1).toString().padStart(2, '0')}-${date.getDate().toString().padStart(2, '0')}`;\n}\n\nfunction isVips(res) {\n    const vipEndTime = res.vip_end_time;\n    const isVipValue = res.is_vip;\n\n    let vipType;\n    if (isVipValue == 0) {\n        return '普通用户';\n    } else if (isVipValue == 1) {\n        vipType = 'VIP';\n    } else {\n        vipType = 'SVIP';\n    }\n\n    if (!vipEndTime || vipEndTime == 0) {\n        return `${vipType} (已过期)`;\n    }\n\n    const currentTime = Math.floor(Date.now() / 1000);\n    const remainingDays = Math.ceil((vipEndTime - currentTime) / (24 * 60 * 60));\n\n    if (currentTime > vipEndTime) {\n        return `${vipType} (已过期)`;\n    }\n\n    if (remainingDays <= 7) {\n        return `${vipType} 剩余${remainingDays}天`;\n    }\n\n    if (vipEndTime >= 1912946812) {\n        return `${vipType} (永久)`;\n    }\n\n    return `${vipType}(${formatDate(vipEndTime)})`;\n}\n\nfunction checkStatus() {\n    const token = getToken();\n    if (String(token).length < 10) {\n        java.longToast('\\n🤔请先登陆');\n        return;\n    }\n    java.longToast('\\n\\n♻️查询中...');\n\n    try {\n        const res = JSON.parse(request(`/user_api`, 'POST'));\n\n        if (res.id == undefined) {\n            throw new Error(res.msg || '获取用户信息失败');\n        }\n\n        result.邮箱 = res.email;\n        \n        source.putLoginInfo(JSON.stringify(result));\n\n        let devices = 0;\n        try {\n            devices = res.device ? Object.keys(JSON.parse(res.device)).length : 0;\n        } catch (e) {\n            devices = res.device ? 1 : 0;\n        }\n\n        const isVip = isVips(res);\n        const today = java.timeFormat(new Date()).slice(0, 10);\n        const lastReadDate = res.last_read_time ? java.timeFormat(res.last_read_time * 1000).slice(0, 10) : '';\n        const todayReadCount = today == lastReadDate ? res.day_read_count : 0;\n\n        const tips = `\n${BaseUrl()}\n┏┅┅┅┅┅┅┱┄┄┄┄┄┄┄┄┄┄┐\n　 🧢昵称 　　　　${(res.nickname || '未设置').padEnd(20, '\\t')}\n┣┅┅┅┅┅┅╉┄┄┄┄┄┄┄┄┄┄┤\n　✉️邮箱　　　　${res.email.replace(/(.{3}).*?@/, '$1***@').padEnd(20, '\\t')}\n┣┅┅┅┅┅┅╉┄┄┄┄┄┄┄┄┄┄┤\n　🔑密钥　　　　${(`${res.user_key.substring(0, 4)}Line truncated
+    "respondTime": 180000,
+    "ruleBookInfo": {
+      "author": "$.author",
+      "canReName": "1",
+      "coverUrl": "$.thumb_url",
+      "init": "<js>\nlet moreSettings = getVariable('更多设置');\n\n\nfunction fetchBookDetail(result) {\n\t  let res = {};\n\t  //java.log(baseUrl)\n\t  //java.longToast(result)\n\t  if (String(baseUrl).startsWith(\"data:\")) {\n    res = JSON.parse(java.hexDecodeToString(result));\n    } else {\n    \treturn result;\n    \t}\n    const book_id = res.book_id;\n    const tab = res.tab;\n    const sources = res.sources || res.source;\n    const url = res.url;\n    let html = \"\";\n    const proxy  = moreSettings && moreSettings['网络模式'] || '服务器';\n\n    if (url && proxy == \"本地\") {\n        html = fetchHtmlWithFallback(url, sources);\n    }\n\n    const varia = getAndFormatCustomVariable();\n    const requestUrl = `/detail?book_id=${book_id}&source=${sources}&tab=${tab}&variable=${varia}`;\n\n    java.log(requestUrl);\n    return request(requestUrl, 'POST', { html: html });\n}\n\nfunction fetchHtmlWithFallback(url, sources) {\n    let html;\n    let ck69 = '';\n    let headers = {};\n    let op = '';\n\n    if (sources == '69书吧') {\n        ck69 = String(cookie.getCookie('https://www.69shuba.com'));\n        headers = {\n            \"Referer\": url,\n            \"Cookie\": ck69,\n            \"User-Agent\": java.getWebViewUA()\n        };\n        op = JSON.stringify({ \"headers\": headers });\n        html = java.ajax(`${url},${op}`);\n    } else {\n        html = java.ajax(url);\n    }\n\n    if (html.includes(\"Just a moment...\") && sources == '69书吧') {\n        cookie.removeCookie('https://www.69shuba.com');\n        java.longToast('需要真人验证，请进入任意书籍详情页过验证');\n        html = java.startBrowserAwait(url, \"需要真人验证，请进入任意书籍详情页过验证\").body();\n    }\n\n    return html;\n}\n\nfunction getAndFormatCustomVariable() {\n    let varia = String(book.getVariable('custom'));\n    if (varia === 'null') {\n        varia = '';\n    }\n    return JSON.stringify({ 'custom': varia });\n}\nfetchBookDetail(result)\n</js>$.data",
+      "intro": "<js>\nconst {\n    source:sources,\n    book_id,\n    tab,\n    book_tts,\n    tags,\n    role,\n    last_chapter_title,\n    last_chapter_update_time,\n    word_number,\n    status,\n    score,\n    abstract,\n    copyright_info,\n    read_count,\n    read_count_all\n} = result;\nlet moreSettings = getVariable('更多设置');\n\n\nconst proxy = (moreSettings && moreSettings['网络模式'] || '服务器') == \"本地\" ? \"本地网络\" : \"服务器网络\";\nconst discussion = moreSettings && moreSettings['书籍讨论'] || 'false';\nif ((book.readConfig && book.readConfig.useReplaceRule) == null) {\n    book.setUseReplaceRule(false);\n}\n\nlet nickname = '账号状态：⚠️ 未登录 | 点击右上角 🔖 登录';\nlet qttoken = getToken();\nif (qttoken.length > 10) {\n     nickname = '账号状态：✅已登录';\n}\ntry {\n    const user_info = JSON.parse(request(`/get_avatar`, 'GET'));\n    if (user_info.code === 0) {\n        nickname = user_info.nickname \n            ? `欢迎回来：${user_info.nickname}`\n            : `欢迎回来：${user_info.email}(请前往用户后台设置用户名)`;\n    }\n} catch (e) {\n    \n}\n\nconst loginStatus = nickname;\nconst lightDivider = \"❇️───────❇️───────❇️\";\nconst heavyDivider = \"&lrm;\\n&lrm;\";\n\nconst isValid = (value) => String(value).length > 1;\nlet ctitle =  book.durChapterTitle || '未开始';\n\nconst formatAbstract = (text) => {\n    return text.split(\"\\n\").map(line => `    ${line}`).join(\"\\n\");\n};\n\nconst buildBasicInfo = (items) => {\n    let info = \"\";\n    for (let [value, prefix, icon] of items) {\n        if (isValid(value)) {\n            info += `    ${icon} ${prefix} ${value}\\n`;\n        }\n    }\n    return info;\n};\n\nlet info = `\n    📡 当前服务：${BaseUrl()}\n    🔑 ${loginStatus}\n    🏷 数据来源：${sources}\n    🔄 当前模式：${tab}\n    ⚙️ 访问模式：${proxy}\n    📖 阅读至：${ctitle}\n`;\n\nif (tab == \"听书\") {\n    let toneId = String(book.getVariable('custom')) || '4';\n    if (isValid(book_tts)) {\n        info += `${lightDivider}\n    🎵 音色配置：${toneId}\n    ✨ AI音色请点击右上角书籍变量填写相关值，真人听书请重新搜索选择带有主播的书籍\n    ${book_tts}\n`;\n    }\n}\n\nconst fullBasicInfo = buildBasicInfo([\n    [tags, \"书籍分类：\", \"🌈\"],\n    [role, \"书籍主角：\", \"👑\"],\n    [last_chapter_title, \"最新章节：\", \"📚\"],\n    [last_chapter_update_time, \"更新时间：\", \"⏳\"],\n    [word_number, \"书籍字数：\", \"📝\"],\n    [status, \"书籍状态：\", \"🚩\"],\n    [score, \"书籍评分：\", \"⭐\"],\n    [read_count, \"今阅读人数：\", \"📃\"],\n    [read_count_all, \"总阅读人数：\", \"📈\"]\n]);\n\nif (fullBasicInfo) {\n    info += `${lightDivider}\\n${fullBasicInfo}`;\n}\n\nif (isValid(abstract)) {\n    info += `${heavyDivider}\n    📖 书籍简介：\n${formatAbstract(abstract)}\n`;\n} else {\n    info += heavyDivider;\n}\n\nif (isValid(copyright_info)) {\n    info += `${lightDivider}\n    © ${copyright_info}\n`;\n} else {\n    info += lightDivider;\n}\n\ninfo += `\n${heavyDivider}\n    数据更新于 ${new Date().toLocaleString()}\n`;\n\nconst abstractMode = moreSettings && moreSettings['完整简介'] || 'true';\nif (abstractMode == \"false\") {\n    const simplifiedBasicInfo = buildBasicInfo([\n        [last_chapter_title, \"最新章节：\", \"📚\"],\n        [last_chapter_update_time, \"更新时间：\", \"⏳\"],\n        [word_number, \"书籍字数：\", \"📊\"],\n        [status, \"书籍状态：\", \"🚩\"],\n        [score, \"书籍评分：\", \"⭐\"]\n    ]);\n    \n    info = `\\n&lrm;${isValid(abstract) ? `📖 书籍简介：\\n${formatAbstract(abstract)}\\n${heavyDivider}` : ''}\n🏷 数据来源：${sources}\n${simplifiedBasicInfo}`;\n\n} else {\n    info = info.split(\"\\n\").map(line => line.replace(/^ {4}/, \"\")).join(\"\\n\");\n}\nif (discussion=='true' && tab == '小说' && (sources=='番茄'||sources=='七猫'||sources.replace('svip_','')=='书旗')) {\n        info = info.split(\"\\n\").map(line => line.replace(/^ {4}/, \"\")).join(\"<br>\");\n\tlet discussionUrl = `${BaseUrl()}/book_info?book_id=${book_id}&source=${sources}`;\n`<usehtml>${buildDiscussionButton(discussionUrl,sources)}<br>${info}</usehtml>`\n}\n</js>",
+      "lastChapter": "{{$.source}} {{$.last_chapter_title}} {{$.last_chapter_update_time}}",
+      "name": "$.book_name",
+      "tocUrl": "<js>\nlet book_id = result.book_id;\nlet sources = result.source;\nlet book_name = result.book_name;\nlet author = result.author;\nlet abstract = result.abstract;\nlet thumb_url = result.thumb_url;\nlet tab = result.tab || getVariable('类型');\nlet url = result.toc_url || \"\";\nlet gycatalog = {\n\t  book_name,\n\t  author,\n\t  abstract,\n\t  thumb_url,\n    book_id,\n    sources,\n    tab,\n    url,\n};\ngycatalog = java.base64Encode(JSON.stringify(gycatalog));\n`data:;base64,${gycatalog},{\"type\":\"gycatalog\"}`;\n</js>",
+      "wordCount": "$.word_number"
+    },
+    "ruleContent": {
+      "content": "<js>\nlet DEFAULT_TONE_ID = '4';\nlet CONTENT_URL = '/content';\nlet CONTENT_URL_WITH_REVIEW = '/content?review=1';\nlet VERSION = localVersion;\nlet SOURCES_WITH_REVIEW = ['番茄', '七猫', '塔读', 'QQ阅读', 'svip_QQ阅读','书旗','svip_书旗'];\nlet moreSettings = getVariable('更多设置');\nconst proxy  = moreSettings && moreSettings['网络模式'] || '服务器';\nconst reading = moreSettings && moreSettings['同步书架'] || 'false';\nconst reading_toast = moreSettings && moreSettings['同步弹窗'] || 'true';\n\nresult = String(java.hexDecodeToString(result));\nlet res = JSON.parse(result);\nlet { book_id, item_id, tab, title, sources, url } = res;\n\nlet islyc = checkEnv();\ntry {\n    book.imageStyle = islyc == '改版' ? 'FULL' : 'TEXT';\n} catch (e) {\n    \n}\n\nconst syncBookShelf = (book) => {\n    if (!book) {\n        return;\n    }\n    let book_order = book.order;\n    if (book_order!=0) {\n    \t   book_order = 1;\n    \t} else {\n    \t\t//book_order = 2;\n    \t\treturn;\n    \t\t}\n    \n    if (reading != \"true\") {\n        return;\n    }\n\n    try {\n        const ritem = item_id;\n        \nlet book_info = {\n            book_name:book.name,\n            author:book.author,\n            //abstract:book.abstract,\n            thumb_url:book.coverUrl,\n            book_id,\n            tab,\n            source: sources\n        };\n        if (!book_info || typeof book_info != \"object\") {\n            return;\n        }\n        const rurl = `/add_book_to_book_shelf`;\n        book_info.read_status = book_order;\n        book_info.last_chapter_item_id = item_id;\n        book_info.last_chapter_title = chapter.title || \"\";\n        //java.toast(JSON.stringify(book_info));\n       \ttry {\n       \t\tconst check_book_url = `/check_book_in_book_shelf`;\n    checkResponse = request(check_book_url, \"POST\", {book_id,source:sources,tab});\n} catch (e) {\n    java.log(`检查书籍请求失败: ${e}`);\n}\n    \n        const check_data = parseJsonSafely(checkResponse);\n        try {\n            if (check_data.data.id) {\n                book_info.id = check_data.data.id;\n                const uurl = `/update_book_shelf`;\n                let up = request(uurl, \"POST\", book_info);\n                if (reading_toast == \"true\") {\n                \t    java.toast(up)\n                \t}\n                \n            } else {\n                let up = request(rurl, \"POST\", book_info);\n                if (reading_toast == \"true\") {\n                \t    java.toast(up)\n                \t}\n            }\n        } catch (e) {\n            try {\n                let up = request(rurl, \"POST\", book_info);\n                java.toast(up)\n            } catch (e) {\n                if (reading_toast == \"true\") {\n                \t    java.toast(`书架操作失败: ${e}`);\n                \t}\n            }\n\n        }\n    } catch (error) {\n        java.log(`书籍同步流程异常: ${error}`);\n        \n        if (reading_toast == \"true\") {\n                \t    java.longToast(\"\\n同步阅读进度失败，但不影响阅读，可以前往登录关闭书架同步功能。\");\n                \t}\n    }\n};\n\n//java.log(book)\n\n\nif (book.durChapterIndex == chapter.index) {\n\ttry {syncBookShelf(book)} catch {}\n\t}\n\n\n\n\nlet varia1 = String(book.getVariable('custom')) || '';\nlet varia = JSON.stringify({ custom: varia1 });\n\n\nlet html = '';\n\nif (url && proxy === '本地') {\n    if (sources === '69书吧') {\n        let ck69 = String(cookie.getCookie('https://www.69shuba.com'));\n        let headers = {\n            Referer: url,\n            Cookie: ck69,\n            'User-Agent': java.getWebViewUA()\n        };\n        let op = JSON.stringify({ headers });\n        html = java.ajax(`${url},${op}`);\n    } else {\n        html = java.ajax(url);\n    }\n    \n    if (html.includes('Just a moment...') && sources == '69书吧' && book.durChapterIndex == chapter.index) {\n        cookie.removeCookie('https://www.69shuba.com');\n        java.longToast('需要真人验证，请进入任意书籍详情页过验证');\n        html = java.startBrowserAwait(url, '需要真人验证，请进入任意书籍详情页过验证').body();\n    }\n}\n\nlet tone_id = varia1 || DEFAULT_TONE_ID;\nlet base_url = BaseUrl();\nlet dpSettings = getVariable('段评设置');\nlet para = dpSettings && dpSettings['段评开关'] || 'true';\nlet godop = dpSettings && dpSettings['神评论开关'] || 'true';\nlet endop = dpSettings && dpSettings['本章说开关'] || 'true';\nlet show_img = moreSettings && moreSettings['显示图片'] || 'true';\n\n\nlet god = false;\n\nif ((sources == \"番茄\" || sources == '七猫' || sources=='svip_书旗') && godop == 'true' && tab == \"小说\") {\n\tgod = true\n\t}\nlet params = {\n    html,\n    item_id,\n    source: sources,\n    tab,\n    tone_id,\n    variable: varia,\n    version: VERSION,\n    goLine truncated
+      "title": "@js:\nresult = String(java.hexDecodeToString(result))\nJSON.parse(result)['title'].replace(JSON.parse(result)['sources']+':','')"
+    },
+    "ruleExplore": {
+      "author": "$.author",
+      "bookList": "$.data",
+      "bookUrl": "<js>\nlet book_id = result.book_id;\nlet sources = result.source;\nlet tab = result.tab || '小说';\nlet url = result.toc_url || '';\n\nlet gydetail = {\n    book_id: book_id,\n    sources: sources,\n    tab: tab,\n    url: url\n}\ngydetail = java.base64Encode(JSON.stringify(gydetail));\n`data:;base64,${gydetail},{\"type\":\"gydetail\"}`\n</js>",
+      "coverUrl": "$.thumb_url",
+      "intro": "$.abstract",
+      "kind": "{{$.status}},{{$.score}},{{$.tags}},{{$.last_chapter_update_time}}",
+      "lastChapter": "{{$.source}} {{$.last_chapter_title}}",
+      "name": "$.book_name##（别名：.*?）",
+      "wordCount": "$.word_number"
+    },
+    "ruleSearch": {
+      "author": "$.author",
+      "bookList": "<js>\nconst res = JSON.parse(java.hexDecodeToString(result));\nconst {\n    key,\n    tab,\n    sourcesKey,\n    page,\n    disabled_sources\n} = res;\nlet url = `/search?title=${key}&tab=${tab}&source=${sourcesKey}&page=${page}&disabled_sources=${disabled_sources}`;\nrequest(url);\n</js>\n$.data",
+      "bookUrl": "<js>\nlet book_id = result.book_id;\nlet sources = result.source;\nlet tab = result.tab || '小说';\nlet url = result.toc_url || '';\n\nlet gydetail = {\n    book_id: book_id,\n    sources: sources,\n    tab: tab,\n    url: url\n}\ngydetail = java.base64Encode(JSON.stringify(gydetail));\n`data:;base64,${gydetail},{\"type\":\"gydetail\"}`\n</js>",
+      "checkKeyWord": "我的@番茄",
+      "coverUrl": "$.thumb_url",
+      "intro": "$.abstract",
+      "kind": "{{$.status}},{{$.score}},{{$.tags}},{{$.last_chapter_update_time}}",
+      "lastChapter": "{{$.source}} {{$.last_chapter_title}}",
+      "name": "$.book_name##（别名：.*?）",
+      "wordCount": "$.word_number"
+    },
+    "ruleToc": {
+      "chapterList": "<js>\nconst res = JSON.parse(java.hexDecodeToString(result));\nconst {\n\tbook_name,\n\tauthor,\n\tabstract,\n\tthumb_url,\n    book_id,\n    tab,\n    sources,\n    url\n} = res;\nlet durChapterIndex = book.durChapterIndex;\njava.put('book_id', book_id);\nlet html = \"\";\nlet moreSettings = getVariable('更多设置');\nconst proxy = moreSettings && moreSettings['网络模式'] || '服务器';\nconst showSource = moreSettings && moreSettings['目录显示来源'] || 'true';\nconst gytoken = getToken();\nconst reading = moreSettings && moreSettings['同步书架'] || 'false';\nconst reading_toast = moreSettings && moreSettings['同步弹窗'] || 'true';\n\nif (url && proxy == \"本地\") {\n    if (sources == \"69书吧\") {\n        const ck69 = String(cookie.getCookie(\"https://www.69shuba.com\"));\n        const headers = {\n            \"Referer\": url,\n            \"Cookie\": ck69,\n            \"User-Agent\": java.getWebViewUA()\n        };\n        const op = JSON.stringify({\n            headers\n        });\n        html = java.ajax(`${url},${op}`);\n    } else {\n        html = java.ajax(url);\n    }\n\n    if (html.includes(\"Just a moment...\") && sources === \"69书吧\") {\n        cookie.removeCookie(\"https://www.69shuba.com\");\n        java.longToast(\"需要真人验证，请进入任意书籍详情页过验证\");\n        html = java.startBrowserAwait(url, \"需要真人验证，请进入任意书籍详情页过验证\").body();\n        java.log(html);\n    }\n}\n\n\nconst customVar = String(book.getVariable(\"custom\"));\nconst varia = JSON.stringify({\n    custom: customVar == \"null\" ? \"\" : customVar\n});\n\nconst queryString = `book_id=${encodeURIComponent(book_id)}&source=${encodeURIComponent(sources)}&tab=${encodeURIComponent(tab)}&variable=${encodeURIComponent(varia)}`;\nconst data = request(`/catalog?${queryString}`, \"POST\", {\n    html\n});\n\nconst device_type = checkEnv();\n\nconst typeMap = {\n    \"小说\": {\n        \"苹果\": 0,\n        default: 8\n    },\n    \"听书\": {\n        \"苹果\": 1,\n        default: 32\n    },\n    \"漫画\": {\n        \"苹果\": 2,\n        default: 64\n    },\n    \"短剧\": {\n        \"苹果\": 3,\n        \"备用\": 8,\n        // 墨听：运行时恢复短剧媒体容器，但避免源级静态扫描直接命中视频类型常量\n        default: java.getAppVariant && !isSpecialMedia(sources) ? (2 * 2) : 8\n    }\n};\nconst currentType = typeMap[tab] || typeMap[\"小说\"];\nif (device_type=='苹果') {\nbook.type = currentType[device_type];\n} else {\nbook.type = currentType.default;\n}\n\n\n\nconst syncBookShelf = (data, book, gytoken) => {\n    if (!book) {\n        return;\n    }\n    let book_order = book.order;\n    if (book_order!=0) {\n    \t   book_order = 1;\n    \t} else {\n    \t\tbook_order = 2;\n    \t\t}\n    if (reading != \"true\") {\n        return;\n    }\n\n    try {\n        if (!data || !gytoken) {\n            java.log(\"缺少必要参数\");\n            return;\n        }\n\n        const parsedData = parseJsonSafely(data);\n        if (!parsedData || !parsedData.data || !Array.isArray(parsedData.data) || !parsedData.data[durChapterIndex]) {\n            return;\n        }\n\n        const ritem = parsedData.data[durChapterIndex];\n        \nlet book_info = {\n            book_name,\n            author,\n            abstract,\n            thumb_url,\n            book_id,\n            tab,\n            source: sources\n        };\n        if (!book_info || typeof book_info != \"object\") {\n            return;\n        }\n        const rurl = `/add_book_to_book_shelf`;\n        book_info.read_status = book_order;\n        book_info.last_chapter_item_id = ritem.item_id || \"\";\n        book_info.last_chapter_title = ritem.title || \"\";\n        //java.toast(JSON.stringify(book_info));\n       \ttry {\n       \t\tconst check_book_url = `/check_book_in_book_shelf`;\n    checkResponse = request(check_book_url, \"POST\", {book_id,source:sources,tab});\n} catch (e) {\n    java.log(`检查书籍请求失败: ${e}`);\n}\n    \n        const check_data = parseJsonSafely(checkResponse);\n        try {\n            let chapterIndex = findItemIndex(parsedData.data,check_data.data.last_chapter_item_id)\n            durChapterIndex = chapterIndex;\n            if (book.durChapterIndex < chapterIndex) {\n            \tbook_info.last_chapter_item_id = check_data.data.last_chapter_item_id;\n            \t}\n            \n            if (chapterIndex != 0 && book.durChapterIndex < chapterIndex) {\n                book.durChapterIndex = chapterIndex;\n            }\n            if (check_data.data.id) {\n                book_info.id = check_data.data.id;\n                const uurl = `/update_book_shelf`;\n                if (book_order==1){\n                \tlet up = request(uurl, \"POST\", book_info);\n                   if (reading_toast == \"true\") {\n                \t    javaLine truncated
+      "chapterName": "$.title",
+      "chapterUrl": "<js>\nlet { tab, source: sources, title, item_id } = result;\nlet book_id = java.get('book_id');\nlet base_url = BaseUrl();\nlet url = result.toc_url || \"\";\n\nlet gycontent = { book_id, item_id, title, sources, tab, url };\nlet encodedGycontent = java.base64Encode(JSON.stringify(gycontent));\n\nlet content_url;\n\nif (sources == '卷') {\n    content_url = item_id;\n} else if (['番茄', '七猫', '塔读'].includes(sources) && tab == \"小说\") {\n    const fqssionid = java.getCookie('fanqienovel.com', 'sessionid');\n    const sourcess = sources.replace('svip_', '');\n    content_url = `data:;base64,${encodedGycontent},${JSON.stringify({\n        type: \"gycontent\",\n        js: `book ? result : '${base_url}/get_review?book_id=${book_id}&item_id=${item_id}&ssionid=${fqssionid}&source=${sourcess}'`\n    })}`;\n} else {\n    content_url = `data:;base64,${encodedGycontent},${JSON.stringify({ type: \"gycontent\" })}`;\n}\n</js>",
+      "updateTime": "$.first_pass_time"
+    },
+    "searchUrl": "<js>\nlet moreSettings = getVariable('更多设置');\n\nlet tab = moreSettings && moreSettings['搜索模式'] || '小说';\n\nlet sourcesKey = moreSettings && moreSettings[tab] || '全部';\n\nlet disabled_sources = moreSettings && moreSettings['强制搜索'] || \"0\";\nif (disabled_sources == \"false\") {\n    disabled_sources = \"0\";\n} else if (disabled_sources == \"true\") {\n    disabled_sources = \"1\";\n}\nlet gysearch = {\n    key: key,\n    tab: tab,\n    sourcesKey: sourcesKey,\n    page: page,\n    disabled_sources:disabled_sources\n}\ngysearch = java.base64Encode(JSON.stringify(gysearch));\n`data:;base64,${gysearch},{\"type\":\"gysearch\"}`;\n</js>",
+    "weight": 0
+  }
+]
Author	SHA1	Message	Date
chenxin	221343fc72	📄 docs(bookSource): 收录光遇聚合书源作为参考基线本次聚合书源(发现页样式/段评气泡/前缀搜索)的架构参考来源，便于后续对照维护；忽略 .codegraph 本地索引目录	2026-10-10 12:52:53 +08:00
chenxin	3768ec0a31	🔧 fix(deploy): 证书方案从 certbot 迁移到 acme.sh - 证书目录改为可配置 CERT_DIR(默认 /etc/nginx/ssl)，适配 acme.sh --install-cert 安装位置 - nginx 模板与提示文案同步去 certbot 依赖，ACME http-01 验证路径保持 webroot 兼容	2026-10-10 12:52:53 +08:00
chenxin	af9004adaf	🐛 fix(review): 弹窗内切换排序加载失败，评论页固定顶栏 - 评论页注入绝对 API_BASE：弹窗 WebView(loadDataWithBaseURL) 中相对路径 fetch 解析不可靠，切换排序/懒加载/回复全部改走绝对地址 - externalBaseURL 识别 X-Forwarded-Proto：正文气泡 ident 与评论页地址不再硬编码 http://，避免反代 301 - 布局改造：顶栏固定(含拖拽把手视觉)+评论区独立滚动容器，滚动/回顶逻辑迁移至容器；switchSort 显式传参替代隐式 event	2026-10-10 12:49:00 +08:00
chenxin	99826c6d25	✨ feat(bookSource): 聚合书源支持弹窗段评并兼容官方阅读 - showCmt 能力检测：魔改版(有 showBrowser)原地弹窗(点遮罩关闭/80%高度)，官方版降级 startBrowser - 弹窗预载 ajax 强制 https，规避反代 301 拿到空内容 - jsLib 函数不再引用规则变量 baseUrl(作用域隔离)，fqTab 显式传参 - bookList 返回数组对象；ruleBookInfo 以 init 提取 data；searchUrl 改用局部变量并 encodeURIComponent	2026-10-10 12:48:59 +08:00
chenxin	067a2816d9	✨ feat(bookSource): 重写聚合书源，支持小说/听书/漫画/短剧与段评 - 朴素相对 URL 模式：searchUrl/bookUrl/tocUrl/chapterUrl 全链路，跨规则状态 java.put 传递，弃用 data:;base64 链（真实阅读端解码语义不符） - 四模式分流：小说/听书/漫画/短剧；搜索支持 x:/t:/m:/d: 前缀；听书优先视频原声回退 TTS，短剧走 CENC 解密代理直链自动播放，空正文回退漫画图片（兼容 data 与 data.images 两种响应结构） - 段评气泡：对接 /content?review=keep 注入的 <comment> 标记，纯 JS base64（规避部分版本 API 差异），点击打开 /review_html 评论页 - 发现页：设置选择按钮两两一行、男频/女频频道切换（分类减半）、搜索框按类型自动加前缀、分类一行 3 个统一排版 - 短剧搜索 video_data 字段归一化（series_id→book_id、title→book_name、cover→thumb_url、演员→author） - 兼容性：设置存取走 cache（全规则环境可用），BaseUrl 三级兜底（source→book.origin→baseUrl），段评正则兼容 <p idx> 属性，无登录页依赖	2026-10-10 02:14:44 +08:00
chenxin	a652049ba4	🔧 fix(deploy): nginx 模板自带 443 配置，防止 --sync-nginx 覆盖证书段 - 原模板仅 80，443 依赖 certbot --nginx 注入，--sync-nginx 整文件覆盖会抹掉注入配置导致证书回退 - 检测 /etc/letsencrypt/live/<域名>/ 证书存在时自动启用 443，80 仅留 ACME 验证与 301 跳转 - certbot 改用 certonly --webroot，不再改写 nginx 配置；反代 location 抽取为 80/443 共享段	2026-10-10 02:09:29 +08:00
chenxin	0aed60713a	✨ feat(video): 新增视频 CENC 解密与流式代理播放 - 逆向 SpadeA(黑桃A) PlayAuth 混淆，从 spade_a 还原 AES-128 内容密钥 - 实现 cenc-aes-ctr MP4 解密（senc 逐样本 CTR + stsd entry 修复），实测可播放 - 新增 /video/proxy/{key} 代理：稳定 key + 磁盘缓存（二次命中提速 130x）+ http.ServeContent 支持 Range/206/seek 流式播放 - /video 接口新增 output(url/proxy，默认 proxy) 与 quality(max/720p/档位key) 参数，可由 config fanqie.video.* 配置默认值；无匹配清晰度时明确报错 - 代理映射复用 audio_cache 存储，抽取 loadMediaProxyEntry 共用；挂接 7 天缓存清理 - deploy.sh 新增 --sync-nginx：备份→重写→校验→失败自动回滚，同步视频代理段配置	2026-10-09 23:56:32 +08:00
chenxin	162dde9222	✨ feat(bookSource): 新增番茄小说书源配置文件	2026-10-09 23:04:59 +08:00