✨ feat(manga,device): 漫画免签名兜底与 phone 注册身份选项

- /manga 设备池签名路线全部失败时自动降级 wkbrowser 免签名路线（materials/skeleton 三段策略收集原图直链，无需设备/签名/解密），响应附 source: wkbrowser
- 新增配置 fanqie.device_identity（默认 pad 保持现状；phone 对齐书源真机注册 payload：host_bit 64 + 补 hardware/device_device/fingerprint 字段）
- README 与 openapi.yaml 同步文档，新增 manga_fallback 解析测试

README.md

@@ -30,6 +30,12 @@ Go 语言实现的番茄小说非官方 API 服务，完整实现了签名算法
 - 分类首页数据
 - 分类详情页（支持筛选、排序、分页）
 
+### 榜单与个人数据
+
+- 🏆 榜单（推荐 / 完结 / 热搜 / 黑马 / 爆更）
+- 📚 我的书架（按分组浏览，需 sessionid）
+- 🕐 阅读历史（含阅读进度，需 sessionid）
+
 ### 技术特性
 
 - **签名算法** - Gorgon、8404、Argus、Ladon、Khronos
@@ -171,7 +177,23 @@ go run ./cmd/fanqie
 | 接口 | 方法 | 说明 | 参数 |
 | ------ | ------ | ------ | ------ |
 | `/category-front` | GET | 分类首页 | - |
-| `/category-landing` | GET | 分类详情 | `category_id`, `word_number`, `book_status`, `sort_by`, `offset` |
+| `/category-landing` | GET | 分类详情 | `category_id`, `word_number`, `book_status`, `sort_by`, `offset`, `selected_items`（新版分类标签自带筛选项，透传上游） |
+
+### 榜单与个人数据
+
+| 接口 | 方法 | 说明 | 参数 |
+| ------ | ------ | ------ | ------ |
+| `/rank` | GET | 榜单（免签名接口） | `side_type`（`10` 推荐 / `11` 完结 / `12` 热搜 / `13` 黑马 / `15` 爆更，默认推荐）, `page`（默认 1，每页 20 本） |
+| `/bookshelf` | GET | 我的书架（需登录） | `sessionid`（必填，见下方「获取 sessionid」）, `group`（可选，按分组过滤；响应含每本书的 `group_name`） |
+| `/read-history` | GET | 阅读历史（需登录） | `sessionid`（必填）, `offset`（默认 0，每页 20 条；响应每项的 `history` 字段保留上游原始记录，含阅读进度） |
+
+#### 获取 sessionid
+
+番茄网页版登录由字节风控（滑块验证）保护，无法通过 API 直接登录（书源实现同样依赖浏览器人工登录）。获取方式：
+
+1. 浏览器打开 [fanqienovel.com](https://fanqienovel.com/) 并登录（手机验证码或密码）
+2. F12 → Application → Cookies → 复制 `sessionid` 的值（有效期较长，可长期使用）
+3. 直接传入 `/bookshelf?sessionid=...` 或 `/read-history?sessionid=...` 使用（书架为空多半是 sessionid 无效或已过期）
 
 ### 媒体相关
 
@@ -256,6 +278,11 @@ fanqie:
   # - "sign4": X-Gorgon + X-Ladon + X-Argus + X-Khronos
   signature: "sign4"
 
+  # 注册设备身份:
+  # - "pad": 平板身份（默认，历史行为）
+  # - "phone": 手机身份（对齐书源真机注册 payload，可对照测试注册率/存活率）
+  device_identity: "pad"
+
   # 内容处理
   content:
     remove_images: false        # 移除图片
@@ -288,7 +315,7 @@ cache:
     password: ""           # 密码
     database: "fanqie"     # 数据库名
     sslmode: "disable"     # SSL 模式: disable | prefer | require
-  redis:                     # Redis 缓存（正文缓存与音频代理缓存，统计数据/设备池仍在 SQL 库）
+  redis:                     # Redis 热缓存层（启用后与 SQL 双写：Redis 短 TTL + SQL 持久层 30 天）
     enabled: false
     host: "127.0.0.1"      # 主机
     port: 6379             # 端口
@@ -337,6 +364,7 @@ cp .env.example .env
 | `server.protect_all` | 业务接口是否也要求访问密钥 | `false` |
 | `fanqie.algorithm` | 签名算法 `gorgon` / `8404` | `gorgon` |
 | `fanqie.signature` | 签名方法 `sign2` / `sign4` | `sign4` |
+| `fanqie.device_identity` | 注册设备身份 `phone` / `pad` | `pad` |
 | `fanqie.content.*` | 正文内容处理选项 | 见上文 |
 | `fanqie.manga.output_mode` | 漫画输出模式 | `proxy` |
 | `cache.enabled` | 是否启用正文内容缓存 | `true` |
@@ -388,15 +416,19 @@ cp .env.example .env
 
 ## 缓存机制
 
-- **接口缓存** - 命中直接返回，不打上游（Redis 启用时优先走 Redis）
+Redis 启用时为**双层架构**：Redis 热层（TTL=业务缓存时长）+ SQL 持久层（不可变内容固定保留 30 天）。
-- **自动清理** - 定期清理过期缓存（Redis 由 TTL 自动过期）
+
+- **读**：Redis → 未命中查 SQL（命中自动回填 Redis）→ 回源上游
+- **写**：Redis + SQL 双写；搜索/分类等动态短缓存只走 Redis 不落库
+- **防击穿**：singleflight 合并并发未命中请求，同一 key 只有一个请求打上游
+- **自动清理** - 定期按行内过期时间清理 SQL 过期缓存（Redis 由 TTL 自动过期）
 - **数据库压缩** - 支持 VACUUM 操作优化数据库
 
 | 接口 | 缓存时长 |
 | ------ | ------ |
-| `/content` | 24 小时 |
+| `/content`、`/multi-content` | 24 小时（SQL 层 30 天） |
-| `/detail`、`/info`、`/catalog`、`/multi-detail`、`/item-summary` | 24 小时 |
+| `/detail`、`/info`、`/catalog`、`/multi-detail`、`/item-summary` | 24 小时（SQL 层 30 天） |
-| `/search`、`/category-front`、`/category-landing` | 10 分钟 |
+| `/search`、`/category-front`、`/category-landing` | 10 分钟（仅 Redis） |
 | `/audio` 代理链接 | 2 小时（匹配 CDN 有效期） |
 
 失败响应不缓存；评论类接口为动态数据，不缓存。

cmd/fanqie/main.go

@@ -76,6 +76,7 @@ func main() {
 		logger.Error("设备密钥池初始化失败: " + err.Error())
 		os.Exit(1)
 	}
+	defer fqapi.FlushDevicePool() // 程序退出时落盘设备使用记录
 
 	// 设置路由
 	setupRoutes()
@@ -164,6 +165,9 @@ func setupRoutes() {
 	http.HandleFunc("/catalog", wrap(handlers.HandleCatalog))
 	http.HandleFunc("/directory/all_items", wrap(handlers.HandleCatalog))
 	http.HandleFunc("/multi-detail", wrap(handlers.HandleMultiDetail))
+	http.HandleFunc("/rank", wrap(handlers.HandleRank))
+	http.HandleFunc("/bookshelf", wrap(handlers.HandleBookshelf))
+	http.HandleFunc("/read-history", wrap(handlers.HandleReadHistory))
 	http.HandleFunc("/multi-content", wrap(handlers.HandleMultiContent))
 	http.HandleFunc("/content", wrap(handlers.HandleContent))
 	http.HandleFunc("/item-summary", wrap(handlers.HandleItemSummary))

deploy.sh

@@ -11,6 +11,7 @@
 #   ./deploy.sh v1.2.0 --no-restart   # 只部署，不重启服务
 #   ./deploy.sh --stop                # 停止服务
 #   ./deploy.sh --start               # 启动服务
+#   ./deploy.sh --clean               # 清除所有部署内容（服务/nginx/证书），重新 --init 前用
 #   ./deploy.sh --build-only          # 只编译，不部署
 #   ./deploy.sh --rollback            # 交互式回滚到指定版本
 #   ./deploy.sh --rollback v1.0.0     # 直接回滚到指定版本
@@ -73,6 +74,7 @@ AUTO_START="${AUTO_START:-true}"
 NO_RESTART=false
 STOP=false
 START=false
+CLEAN=false
 
 print_help() {
   cat <<EOF
@@ -85,6 +87,8 @@ print_help() {
   --no-restart          只部署不重启服务（自启设置仍会应用）
   --stop                停止服务后退出
   --start               启动服务后退出
+  --clean               清除本脚本部署的全部内容（服务/nginx/二进制/证书，含 certbot 残留；
+                        保留 SRC_DIR 下的 .env/配置/数据库），之后重新 --init 即可
   --build-only          只编译，不部署、不重启服务
   --force, -f           允许覆盖已存在的同名版本（默认报错退出）
   --rollback [版本]     回滚到指定版本（不带版本号则交互式选择）
@@ -114,6 +118,7 @@ while [ $i -lt ${#ARGS[@]} ]; do
     --no-restart)  NO_RESTART=true ;;
     --stop)        STOP=true ;;
     --start)       START=true ;;
+    --clean)       CLEAN=true ;;
     --build-only)  BUILD_ONLY=true ;;
     --rollback)
       ROLLBACK=true
@@ -189,6 +194,27 @@ cleanup_old_versions() {
   done
 }
 
+# 定位 acme.sh：PATH → 当前用户目录 → root 目录（sudo 后 HOME 可能被重置）
+find_acme_sh() {
+  local acme
+  acme="$(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" ] && [ -x "$c" ]; then acme="$c"; fi
+  done
+  echo "$acme"
+}
+
+# 删除已存在的路径并逐项记录（文件/目录/glob 展开结果均可，不存在则跳过）
+rm_logged() {
+  local p
+  for p in "$@"; do
+    if [ -e "$p" ] || [ -L "$p" ]; then
+      $SUDO rm -rf "$p"
+      log "  已删除: $p"
+    fi
+  done
+}
+
 # 应用开机自启设置（AUTO_START 由 --no-autostart / .deploy.env 决定）
 apply_autostart() {
   if [ "$AUTO_START" = true ]; then
@@ -222,11 +248,18 @@ restart_and_verify() {
     $SUDO systemctl reload nginx 2>/dev/null || $SUDO nginx -s reload 2>/dev/null || true
   fi
 
-  sleep 2
-
   # 健康自检：确认服务真正响应，而非仅进程存活
+  # 应用启动时初始化设备池（逐个注册设备）较慢，轮询等待就绪，最多 60s
   if command -v curl >/dev/null 2>&1; then
-    if curl -fsS --max-time 5 "http://127.0.0.1:${APP_PORT}/healthz" >/dev/null 2>&1; then
+    healthy=false
+    for _ in $(seq 1 30); do
+      if curl -fsS --max-time 2 "http://127.0.0.1:${APP_PORT}/healthz" >/dev/null 2>&1; then
+        healthy=true
+        break
+      fi
+      sleep 2
+    done
+    if [ "$healthy" = true ]; then
       log "健康检查通过: /healthz"
     else
       err "健康检查失败: http://127.0.0.1:${APP_PORT}/healthz"
@@ -330,6 +363,12 @@ server {
 ${root_location}
 }${ssl_block}
 NGINX_EOF
+
+  # 写入后立即校验并重载：ACME 验证必须打到最新配置，
+  # 否则签发时线上仍是内存里的旧配置（80→301→443→反代→404），验证必败
+  if $SUDO nginx -t 2>/dev/null; then
+    $SUDO systemctl reload nginx 2>/dev/null || $SUDO nginx -s reload 2>/dev/null || true
+  fi
 }
 
 # 更新已部署服务器的 nginx 配置：备份 → 重写 → 校验 → 失败回滚
@@ -390,6 +429,70 @@ if [ "$STOP" = true ] || [ "$START" = true ]; then
   exit 0
 fi
 
+# ==================== --clean ====================
+# 清除本脚本部署的全部内容，便于重新 --init 初次部署
+if [ "$CLEAN" = true ]; then
+  warn "将删除以下内容："
+  echo "  - systemd 服务: ${SERVICE_FILE}"
+  echo "  - nginx 配置:   ${NGINX_CONF}（含 --sync-nginx 的 .bak.* 备份）"
+  echo "  - 二进制目录:   ${BIN_DIR}"
+  echo "  - 证书:         ${CERT_DIR}/${DOMAIN}、acme.sh 中该域名的全部数据、certbot 残留"
+  echo "  （保留 ${SRC_DIR} 下的 .env / 配置 / 数据库；acme.sh 本体保留供重新部署使用）"
+  read -rp "确认清理？输入 yes 继续: " REPLY
+  [ "$REPLY" = "yes" ] || { info "已取消"; exit 0; }
+
+  echo ""
+  log "开始清理，实际删除项："
+
+  # 服务
+  if systemctl cat "${APP_NAME}" >/dev/null 2>&1; then
+    $SUDO systemctl disable --now "${APP_NAME}" || true
+    $SUDO rm -f "${SERVICE_FILE}"
+    $SUDO systemctl daemon-reload
+    log "  已删除: ${SERVICE_FILE}（服务已停止并取消自启）"
+  fi
+
+  # nginx 配置（含 --sync-nginx 产生的 .bak.* 备份）
+  if [ -f "${NGINX_CONF}" ] || ls "${NGINX_CONF}".bak.* >/dev/null 2>&1; then
+    rm_logged "${NGINX_CONF}" "${NGINX_CONF}".bak.*
+    if $SUDO nginx -t 2>/dev/null; then
+      $SUDO systemctl reload nginx 2>/dev/null || $SUDO nginx -s reload 2>/dev/null || true
+      log "  nginx 已重载"
+    fi
+  fi
+
+  # 二进制与版本目录
+  rm_logged "${BIN_DIR}"
+
+  # 证书：移除 acme.sh 管理（--remove 不吊销，LE 证书自然过期），删安装目录
+  # 及 acme.sh 域名数据（含验证失败残留的 domain key，否则重签会要求 --force）
+  ACME_SH="$(find_acme_sh)"
+  if [ -n "$ACME_SH" ]; then
+    $SUDO "$ACME_SH" --remove -d "${DOMAIN}" >/dev/null 2>&1 || true
+  fi
+  rm_logged "${CERT_DIR}/${DOMAIN}" \
+            "${HOME}/.acme.sh/${DOMAIN}_ecc" "${HOME}/.acme.sh/${DOMAIN}" \
+            "/root/.acme.sh/${DOMAIN}_ecc" "/root/.acme.sh/${DOMAIN}"
+
+  # certbot 残留（历史部署用 certbot 时遗留）
+  if command -v certbot &>/dev/null; then
+    if systemctl is-enabled certbot.timer >/dev/null 2>&1; then
+      $SUDO systemctl disable --now certbot.timer
+      log "  已停用: certbot.timer"
+    fi
+    if [ -d "/etc/letsencrypt/live/${DOMAIN}" ]; then
+      $SUDO certbot delete --cert-name "${DOMAIN}" --non-interactive >/dev/null 2>&1 || true
+    fi
+  fi
+  rm_logged "/etc/letsencrypt/live/${DOMAIN}" "/etc/letsencrypt/archive/${DOMAIN}" \
+            "/etc/letsencrypt/renewal/${DOMAIN}.conf" \
+            "/etc/letsencrypt/renewal-hooks/deploy/reload-nginx.sh"
+
+  echo ""
+  log "✅ 清理完成。重新部署: $0 --init"
+  exit 0
+fi
+
 # ==================== --rollback ====================
 if [ "$ROLLBACK" = true ]; then
   if [ ! -d "${BIN_DIR}" ]; then
@@ -511,18 +614,15 @@ EOF
   if [ -f "${CERT_DIR}/${DOMAIN}/fullchain.pem" ]; then
     log "证书已存在，跳过申请"
   else
-    # 定位 acme.sh：PATH → 当前用户目录 → root 目录（sudo 后 HOME 可能被重置）
+    ACME_SH="$(find_acme_sh)"
-    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}" \
+    # --force：上次验证失败会残留 domain key，重试时 acme.sh 拒绝覆盖要求 --force
+    if $SUDO "$ACME_SH" --issue -d "${DOMAIN}" -w /var/www/html --server letsencrypt --keylength ec-256 -m "${CERT_EMAIL}" --force \
        && $SUDO "$ACME_SH" --install-cert -d "${DOMAIN}" --ecc \
             --fullchain-file "${CERT_DIR}/${DOMAIN}/fullchain.pem" \
             --key-file "${CERT_DIR}/${DOMAIN}/privkey.pem" \

go.mod

@@ -10,6 +10,7 @@ require (
 	github.com/mattn/go-sqlite3 v1.14.18
 	github.com/redis/go-redis/v9 v9.22.0
 	github.com/spf13/viper v1.18.2
+	golang.org/x/sync v0.17.0
 	golang.org/x/time v0.5.0
 )
 
@@ -35,7 +36,6 @@ require (
 	go.uber.org/multierr v1.9.0 // indirect
 	golang.org/x/exp v0.0.0-20230905200255-921286631fa9 // indirect
 	golang.org/x/net v0.46.0 // indirect
-	golang.org/x/sync v0.17.0 // indirect
 	golang.org/x/sys v0.37.0 // indirect
 	golang.org/x/text v0.30.0 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect

internal/algos/signer.go

@@ -74,6 +74,7 @@ func Sign4(
 	// 添加 Ladon 和 Argus 签名
 	ladon := &Ladon{}
 	result["x-ladon"] = ladon.Encrypt(timestamp, licenseID, aid)
+	result["x-helios"] = result["x-ladon"] // X-Helios 与 X-Ladon 同值（对齐书源实现）
 
 	argus := &Argus{}
 	result["x-argus"] = argus.GetSign(

internal/config/config.go

@@ -39,6 +39,8 @@ type RequestLogConfig struct {
 type FanqieConfig struct {
 	Algorithm string        `mapstructure:"algorithm"`
 	Signature string        `mapstructure:"signature"` // 签名方法: sign2 / sign4
+	// 注册设备身份: pad（默认，历史行为）/ phone（对齐手机 App 书源注册 payload）
+	DeviceIdentity string   `mapstructure:"device_identity"`
 	Content   ContentConfig `mapstructure:"content"`
 	Manga     MangaConfig   `mapstructure:"manga"`
 	Video     VideoConfig   `mapstructure:"video"`
@@ -192,6 +194,7 @@ func setDefaults() {
 	// 番茄小说配置
 	viper.SetDefault("fanqie.algorithm", "gorgon")
 	viper.SetDefault("fanqie.signature", "sign2")
+	viper.SetDefault("fanqie.device_identity", "pad")
 	
 	// 内容处理配置
 	viper.SetDefault("fanqie.content.remove_images", false)

internal/fqapi/cache_manager.go

@@ -16,8 +16,31 @@ import (
 	_ "github.com/jackc/pgx/v5/stdlib"
 	_ "github.com/mattn/go-sqlite3"
 	"github.com/redis/go-redis/v9"
+	"golang.org/x/sync/singleflight"
 )
 
+const (
+	// sqlCacheTTLSeconds SQL 持久层保留时长：不可变内容（正文/详情/目录）与业务 TTL 解耦，
+	// Redis 过期或重启后由 SQL 回填，避免重新打上游
+	sqlCacheTTLSeconds = 30 * 86400
+)
+
+// volatileCachePrefixes 动态短缓存（值会变）只走 Redis/短 TTL，不进 SQL 长期层
+var volatileCachePrefixes = []string{"search_", "category_", "rank_"}
+
+// isVolatileCacheKey 判断是否为动态短缓存 key
+func isVolatileCacheKey(key string) bool {
+	for _, p := range volatileCachePrefixes {
+		if strings.HasPrefix(key, p) {
+			return true
+		}
+	}
+	return false
+}
+
+// cacheSF 合并并发 miss 的回源请求，防止缓存击穿
+var cacheSF singleflight.Group
+
 var (
 	cacheDB             *sql.DB
 	dbDriver            string // "sqlite3" | "pgx"
@@ -56,6 +79,11 @@ func InitRedis() error {
 		Addr:     fmt.Sprintf("%s:%d", cfg.Cache.Redis.Host, cfg.Cache.Redis.Port),
 		Password: cfg.Cache.Redis.Password,
 		DB:       cfg.Cache.Redis.DB,
+		// 缓存场景失败不重试：miss 直接降级 SQL，重试只会放大网络慢时的请求延迟
+		MaxRetries:      0,
+		ReadTimeout:     3 * time.Second,
+		WriteTimeout:    3 * time.Second,
+		MinRetryBackoff: 0,
 	})
 
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
@@ -149,12 +177,14 @@ func createTables() error {
 			`CREATE TABLE IF NOT EXISTS cache (
 			key TEXT PRIMARY KEY,
 			value TEXT,
+			expi INTEGER DEFAULT 0,
 			created_at INTEGER DEFAULT (strftime('%s', 'now')),
 			updated_at INTEGER DEFAULT (strftime('%s', 'now'))
 		)`,
 			`CREATE TABLE IF NOT EXISTS cache (
 			key TEXT PRIMARY KEY,
 			value TEXT,
+			expi BIGINT DEFAULT 0,
 			created_at BIGINT DEFAULT extract(epoch FROM now())::bigint,
 			updated_at BIGINT DEFAULT extract(epoch FROM now())::bigint
 		)`},
@@ -259,8 +289,10 @@ func createTables() error {
 	// 旧表补 created_at/updated_at 列（新表 DDL 自带，此处仅老库生效）
 	for _, m := range []struct{ table, col, ddl string }{
 		{"cache", "updated_at", "INTEGER DEFAULT 0"}, // SQLite ALTER 不允许非常量默认值，先补 0 再回填
+		{"cache", "expi", "INTEGER DEFAULT 0"},
 		{"statistics", "created_at", "INTEGER DEFAULT 0"},
 		{"device_pool", "updated_at", "INTEGER DEFAULT 0"},
+		{"device_pool", "key_ts", "INTEGER DEFAULT 0"},
 		{"audio_cache", "updated_at", "INTEGER DEFAULT 0"},
 	} {
 		if dbDriver == "pgx" {
@@ -278,6 +310,7 @@ func createTables() error {
 	// 旧行回填（幂等：仅 0 值行受影响）
 	for _, backfill := range []string{
 		`UPDATE cache SET updated_at = created_at WHERE updated_at = 0`,
+		`UPDATE cache SET expi = created_at + 86400 WHERE expi = 0`,
 		`UPDATE statistics SET created_at = updated_at WHERE created_at = 0`,
 		`UPDATE device_pool SET updated_at = last_used_at WHERE updated_at = 0`,
 		`UPDATE audio_cache SET updated_at = created_at WHERE updated_at = 0`,
@@ -299,7 +332,8 @@ func isCacheEnabled() bool {
 	return cfg.Cache.Enabled
 }
 
-// withCache 只读接口的缓存包装：命中直接返回，miss 回源后写入（仅缓存成功响应）
+// withCache 只读接口的缓存包装：命中直接返回，miss 回源后写入（仅缓存成功响应）。
+// singleflight 合并并发 miss，同一 key 只有一个请求打上游
 // ponytail: 空参等防御分支若漏到此处，其错误 JSON 也会被缓存到 TTL 到期——handler 层 validateParams 已拦截
 func withCache(key string, ttl int, fetch func() (string, error)) (string, error) {
 	if c := GetCache(key); c != "" {
@@ -307,21 +341,36 @@ func withCache(key string, ttl int, fetch func() (string, error)) (string, error
 		// （对新写入的已解包数据无影响）
 		return reencodeUnwrapped(c), nil
 	}
-	result, err := fetch()
+	v, err, _ := cacheSF.Do(key, func() (interface{}, error) {
-	if err == nil {
+		// 双重检查：等锁期间可能已被并发请求填充
-		UpdateCache(key, result, ttl)
+		if c := GetCache(key); c != "" {
+			return c, nil
+		}
+		result, err := fetch()
+		if err == nil {
+			UpdateCache(key, result, ttl)
+		}
+		return result, err
+	})
+	if err != nil {
+		return "", err
 	}
-	return result, err
+	return v.(string), nil
 }
 
-// GetCache 获取正文内容缓存
+// GetCache 获取缓存：Redis 热层 → SQL 持久层（命中回填 Redis）→ 未命中
 func GetCache(key string) string {
 	if !isCacheEnabled() {
 		return ""
 	}
 
 	if redisCache != nil {
-		return redisGetCache(key)
+		if v := redisGetCache(key); v != "" {
+			return v
+		}
+		if isVolatileCacheKey(key) {
+			return "" // 搜索/分类等动态数据不落库，Redis 未命中即回源
+		}
 	}
 
 	if cacheDB == nil {
@@ -329,7 +378,8 @@ func GetCache(key string) string {
 	}
 
 	var value string
-	err := cacheDB.QueryRow(q("SELECT value FROM cache WHERE key = ?"), key).Scan(&value)
+	var expi int64
+	err := cacheDB.QueryRow(q("SELECT value, expi FROM cache WHERE key = ?"), key).Scan(&value, &expi)
 	if err != nil {
 		if err != sql.ErrNoRows {
 			cacheLogger.Error("查询缓存失败: " + err.Error())
@@ -337,33 +387,46 @@ func GetCache(key string) string {
 		return ""
 	}
 
+	// 检查是否过期（expi 为 0 的旧行由启动回填兜底，此处防御）
+	if time.Now().Unix() >= expi {
+		cacheLogger.Debug("缓存已过期(SQL): " + key)
+		return ""
+	}
+
 	var cacheData CacheData
-	err = json.Unmarshal([]byte(value), &cacheData)
+	if err := json.Unmarshal([]byte(value), &cacheData); err != nil {
-	if err != nil {
 		cacheLogger.Error("解析缓存数据失败: " + err.Error())
 		return ""
 	}
 
-	cacheLogger.Debug("缓存命中: " + key)
+	cacheLogger.Debug("缓存命中(SQL): " + key)
 
-	// 检查是否过期
+	// SQL 命中而 Redis 未命中（过期/重启）：异步回填热层，剩余时长为 TTL，
-	if time.Now().Unix() < int64(cacheData.Expi) {
+	// 回填（尤其大 value）不阻塞本次请求
-		cacheLogger.Debug("缓存有效！")
+	if redisCache != nil {
-		return cacheData.Data
+		remain := int(expi - time.Now().Unix())
+		if remain < 60 {
+			remain = 60
+		}
+		go redisUpdateCache(key, cacheData.Data, remain)
 	}
-
+	return cacheData.Data
-	cacheLogger.Debug("缓存已过期！")
-	return ""
 }
 
-// UpdateCache 更新或插入正文内容缓存
+// UpdateCache 写入缓存：Redis 热层（TTL=业务过期时间）+ SQL 持久层双写。
+// 不可变内容在 SQL 固定保留 30 天，动态短缓存（search/category）只走 Redis。
+// Redis 写失败只降级不阻断：持久层照常落库，热层下次请求回填
 func UpdateCache(key string, value string, expi int) error {
 	if !isCacheEnabled() {
 		return nil
 	}
 
 	if redisCache != nil {
-		return redisUpdateCache(key, value, expi)
+		if err := redisUpdateCache(key, value, expi); err != nil {
+			cacheLogger.Warning(fmt.Sprintf("Redis 写入失败（降级为仅 SQL 落库）: %v", err))
+		} else if isVolatileCacheKey(key) {
+			return nil // 动态短缓存不落库（Redis 成功即止）
+		}
 	}
 
 	if cacheDB == nil {
@@ -380,10 +443,17 @@ func UpdateCache(key string, value string, expi int) error {
 		return err
 	}
 
+	// SQL 保留时长：不可变内容固定 30 天（Redis 未启用时沿用业务 TTL，保持纯 SQL 模式原行为）
+	sqlTTL := int64(sqlCacheTTLSeconds)
+	if redisCache == nil || isVolatileCacheKey(key) {
+		sqlTTL = int64(expi)
+	}
+
 	// UPSERT：ON CONFLICT 语法 SQLite 3.24+ 与 PostgreSQL 通用
-	_, err = cacheDB.Exec(q(`INSERT INTO cache (key, value, created_at, updated_at) VALUES (?, ?, ?, ?)
+	now := time.Now().Unix()
-		ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`),
+	_, err = cacheDB.Exec(q(`INSERT INTO cache (key, value, expi, created_at, updated_at) VALUES (?, ?, ?, ?, ?)
-		key, string(jsonData), time.Now().Unix(), time.Now().Unix())
+		ON CONFLICT(key) DO UPDATE SET value = excluded.value, expi = excluded.expi, updated_at = excluded.updated_at`),
+		key, string(jsonData), now+sqlTTL, now, now)
 	if err != nil {
 		cacheLogger.Error("更新缓存失败: " + err.Error())
 		return err
@@ -465,11 +535,8 @@ func CleanupExpiredCache() error {
 		return fmt.Errorf("数据库未初始化")
 	}
 
-	// 计算过期时间点（当前时间 - cleanup_seconds）
+	// 删除已过期的缓存（按行内过期时间 expi，而非创建时间）
-	expiredTime := time.Now().Unix() - int64(cfg.Cache.CleanupSeconds)
+	result, err := cacheDB.Exec(q("DELETE FROM cache WHERE expi < ?"), time.Now().Unix())
-
-	// 删除过期的缓存（created_at < expiredTime）
-	result, err := cacheDB.Exec(q("DELETE FROM cache WHERE created_at < ?"), expiredTime)
 	if err != nil {
 		cacheLogger.Error("清理过期缓存失败: " + err.Error())
 		return err
@@ -480,7 +547,7 @@ func CleanupExpiredCache() error {
 	if err != nil {
 		cacheLogger.Warning("获取删除行数失败: " + err.Error())
 	} else if rowsAffected > 0 {
-		cacheLogger.Info(fmt.Sprintf("已清理 %d 条过期缓存（创建时间早于 %d 秒前）", rowsAffected, cfg.Cache.CleanupSeconds))
+		cacheLogger.Info(fmt.Sprintf("已清理 %d 条过期缓存（SQL 持久层）", rowsAffected))
 	}
 
 	// 顺带清理磁盘视频缓存（7 天未访问的解密文件）

internal/fqapi/cache_manager_test.go

@@ -30,6 +30,7 @@ func TestConcurrentCacheAccess(t *testing.T) {
 	if _, err := db.Exec(`CREATE TABLE IF NOT EXISTS cache (
 		key TEXT PRIMARY KEY,
 		value TEXT,
+		expi INTEGER DEFAULT 0,
 		created_at INTEGER DEFAULT (strftime('%s', 'now')),
 		updated_at INTEGER DEFAULT (strftime('%s', 'now'))
 	)`); err != nil {
@@ -74,6 +75,7 @@ func TestWithCache(t *testing.T) {
 	}()
 	if _, err := db.Exec(`CREATE TABLE IF NOT EXISTS cache (
 		key TEXT PRIMARY KEY, value TEXT,
+		expi INTEGER DEFAULT 0,
 		created_at INTEGER DEFAULT (strftime('%s', 'now')),
 		updated_at INTEGER DEFAULT (strftime('%s', 'now'))
 	)`); err != nil {

internal/fqapi/category_front.go

@@ -17,10 +17,13 @@ func HandleCategoryFront(tab interface{}) (string, error) {
 func fetchCategoryFront(tab interface{}) (string, error) {
 	tabInt := ParseIntParam(tab, 0)
 
+	// 新版分类接口参数（category_new_page_715=1 + new_category_type，
+	// 旧参数 new_category_tab 已失效——对齐 2026-10 可用的书源实现）
 	reqURL := BuildURL(
 		"https://reading.snssdk.com/reading/bookapi/new_category/front/v/",
-		fmt.Sprintf("new_category_tab=%d", tabInt),
+		"category_new_page_715=1",
-		fmt.Sprintf("update_version_code=%s", "58932"),
+		fmt.Sprintf("new_category_type=%d", tabInt),
+		"update_version_code=" + ClientVersionCode,
 		"distinct_style=1",
 	)
 

internal/fqapi/category_landing.go

@@ -8,32 +8,54 @@ import (
 var categoryLandingLogger = common.NewLogger("category_landing", "INFO", "")
 
 // HandleCategoryLanding 处理获取分类详情,分类详情短缓存 10 分钟
-func HandleCategoryLanding(categoryID, offset, wordNumber, bookStatus, sortBy interface{}) (string, error) {
+// selectedItems：新版分类标签自带的筛选项（selected_items，透传上游）
-	return withCache(fmt.Sprintf("category_landing_%v_%v_%v_%v_%v", categoryID, offset, wordNumber, bookStatus, sortBy), 600, func() (string, error) {
+func HandleCategoryLanding(categoryID, offset, wordNumber, bookStatus, sortBy, selectedItems interface{}) (string, error) {
-		return fetchCategoryLanding(categoryID, offset, wordNumber, bookStatus, sortBy)
+	return withCache(fmt.Sprintf("category_landing_%v_%v_%v_%v_%v_%v", categoryID, offset, wordNumber, bookStatus, sortBy, selectedItems), 600, func() (string, error) {
+		return fetchCategoryLanding(categoryID, offset, wordNumber, bookStatus, sortBy, selectedItems)
 	})
 }
 
-func fetchCategoryLanding(categoryID, offset, wordNumber, bookStatus, sortBy interface{}) (string, error) {
+func fetchCategoryLanding(categoryID, offset, wordNumber, bookStatus, sortBy, selectedItems interface{}) (string, error) {
 	// 参数转换
 	categoryIDInt := ParseIntParam(categoryID, 0)
 	offsetInt := ParseIntParam(offset, 0)
 	wordNumberInt := ParseIntParam(wordNumber, 0)
 	bookStatusInt := ParseIntParam(bookStatus, 0)
 	sortByInt := ParseIntParam(sortBy, 0)
+	selectedItemsStr := ParseStringParam(selectedItems, "")
 
-	if categoryIDInt == 0 {
+	if categoryIDInt == 0 && selectedItemsStr == "" {
 		return BuildErrorResponseWithCode(100144, "参数错误"), nil
 	}
 
+	params := []string{
+		fmt.Sprintf("limit=%d", 20),
+		fmt.Sprintf("offset=%d", offsetInt),
+	}
+	if categoryIDInt != 0 {
+		params = append(params, fmt.Sprintf("category_id=%d", categoryIDInt))
+	}
+	if wordNumberInt != 0 {
+		params = append(params, fmt.Sprintf("word_number=%d", wordNumberInt))
+	}
+	if bookStatusInt != 0 {
+		params = append(params, fmt.Sprintf("book_status=%d", bookStatusInt))
+	}
+	if sortByInt != 0 {
+		params = append(params, fmt.Sprintf("sort_by=%d", sortByInt))
+	}
+	// 新版分类标签：selected_items 由 front 页标签自带，需与其 from_front_page 配对透传
+	if selectedItemsStr != "" {
+		params = append(params,
+			"selected_items="+selectedItemsStr,
+			"selected_item_from_front_page="+selectedItemsStr,
+			"source=front_category",
+		)
+	}
+
 	reqURL := BuildURL(
 		"https://reading.snssdk.com/reading/bookapi/new_category/landing/v/",
-		fmt.Sprintf("category_id=%d", categoryIDInt),
+		params...,
-		fmt.Sprintf("limit=%d", 20),
-		fmt.Sprintf("offset=%d", offsetInt),
-		fmt.Sprintf("word_number=%d", wordNumberInt),
-		fmt.Sprintf("book_status=%d", bookStatusInt),
-		fmt.Sprintf("sort_by=%d", sortByInt),
 	)
 
 	resp, err := GorgonRequest(reqURL, map[string]interface{}{

internal/fqapi/content.go

@@ -5,12 +5,14 @@ import (
 	"encoding/json"
 	"fanqie/internal/common"
 	"fmt"
-	"sort"
 	"strings"
+
+	"golang.org/x/sync/singleflight"
 )
 
 var (
 	contentLogger = common.NewLogger("content", "INFO", "")
+	contentSF     singleflight.Group // 合并同一章节的并发回源请求，防缓存击穿
 )
 
 // ContentFetcher 内容获取器
@@ -26,19 +28,27 @@ func HandleGetContent(itemID string, textMode, imageMode interface{}) (string, e
 	textModeBool := parseBoolParamDefault(textMode, getContentConfig().RemoveHTMLTags)
 	imageModeBool := parseBoolParamDefault(imageMode, !getContentConfig().RemoveImages)
 
-	// contentLogger.Info(fmt.Sprintf("获取内容 item_id=%s text_mode=%v image_mode=%v", itemID, textModeBool, imageModeBool))
-
-	// 检查缓存
 	cache := GetCache("content_" + itemID)
-	if cache != "" {
+	if cache == "" {
-		return processCachedContent(cache, textModeBool, imageModeBool)
+		// 同一章节并发请求只打一次上游，其余等待共享结果
+		v, err, _ := contentSF.Do("content_"+itemID, func() (interface{}, error) {
+			// 双重检查：等锁期间可能已被并发请求填充
+			if c := GetCache("content_" + itemID); c != "" {
+				return c, nil
+			}
+			return fetchContentFromAPI(itemID)
+		})
+		if err != nil {
+			return "", err
+		}
+		cache = v.(string)
 	}
 
-	// 缓存未命中，从API获取
+	// 出口按各自参数解析（缓存/回源共用同一路径）
-	return fetchContentFromAPI(itemID, textModeBool, imageModeBool)
+	return processCachedContent(cache, textModeBool, imageModeBool)
 }
 
-// processCachedContent 处理缓存内容
+// processCachedContent 处理缓存内容（content 为解密后的原始正文）
 func processCachedContent(cache string, textMode, imageMode bool) (string, error) {
 	var d map[string]interface{}
 	json.Unmarshal([]byte(cache), &d)
@@ -53,18 +63,18 @@ func processCachedContent(cache string, textMode, imageMode bool) (string, error
 	return buildJSONResponse(UnwrapJSONStrings(d)), nil
 }
 
-// fetchContentFromAPI 从API获取内容（带设备切换重试）
+// fetchContentFromAPI 从API获取内容（带设备切换重试），返回缓存格式 JSON
-func fetchContentFromAPI(itemID string, textMode, imageMode bool) (string, error) {
+func fetchContentFromAPI(itemID string) (string, error) {
-	return fetchContentWithRetry(itemID, textMode, imageMode, 0)
+	return fetchContentWithRetry(itemID, 0)
 }
 
 // fetchContentWithRetry 从API获取内容，支持设备切换重试
-func fetchContentWithRetry(itemID string, textMode, imageMode bool, retryCount int) (string, error) {
+func fetchContentWithRetry(itemID string, retryCount int) (string, error) {
 	// 防止无限递归
 	const maxRetries = 5
 	if retryCount >= maxRetries {
 		contentLogger.Warning(fmt.Sprintf("已重试 %d 次，尝试备用接口", maxRetries))
-		return tryBackupAPI(itemID, textMode, imageMode)
+		return tryBackupAPI(itemID)
 	}
 
 	// 从设备密钥池获取设备
@@ -79,6 +89,7 @@ func fetchContentWithRetry(itemID string, textMode, imageMode bool, retryCount i
 	currentKeyInfo := &KeyInfo{
 		Key: item.Key,
 		Ver: item.KeyVer,
+		Ts:  item.KeyTs,
 	}
 	contentLogger.Debug(fmt.Sprintf("使用池中设备 ID=%d (重试次数: %d)", item.ID, retryCount))
 
@@ -90,16 +101,13 @@ func fetchContentWithRetry(itemID string, textMode, imageMode bool, retryCount i
 		"app_name=novelapp",
 		"channel=0",
 		"device_platform=android",
-		"version_code=66.9",
+		"version_code=" + ClientVersionCode,
 		"item_id=" + itemID,
 		"os_version=0",
+		fmt.Sprintf("key_register_ts=%d", currentKeyInfo.Ts), // 降低上游密钥不匹配概率
 		headerWithoutVersion,
 	}
-
+	sortedParams := buildSortedQuery(params...)
-	allParams := strings.Join(params, "&")
-	paramList := strings.Split(allParams, "&")
-	sort.Strings(paramList)
-	sortedParams := strings.Join(paramList, "&")
 
 	url := "https://reading.snssdk.com/reading/reader/full/v/?" + sortedParams
 
@@ -114,7 +122,7 @@ func fetchContentWithRetry(itemID string, textMode, imageMode bool, retryCount i
 		contentLogger.Warning(fmt.Sprintf("主接口请求出错，标记设备无效并切换设备: %v", err))
 		pool.MarkInvalid(header)
 		pool.RemoveInvalid()
-		return fetchContentWithRetry(itemID, textMode, imageMode, retryCount+1)
+		return fetchContentWithRetry(itemID, retryCount+1)
 	}
 
 	var body map[string]interface{}
@@ -126,7 +134,7 @@ func fetchContentWithRetry(itemID string, textMode, imageMode bool, retryCount i
 			contentLogger.Warning("响应data字段无效，切换设备重试")
 			pool.MarkInvalid(header)
 			pool.RemoveInvalid()
-			return fetchContentWithRetry(itemID, textMode, imageMode, retryCount+1)
+			return fetchContentWithRetry(itemID, retryCount+1)
 		}
 
 		contentEncoded, ok := data["content"].(string)
@@ -135,76 +143,101 @@ func fetchContentWithRetry(itemID string, textMode, imageMode bool, retryCount i
 			contentLogger.Warning(fmt.Sprintf("内容返回 Invalid，标记设备无效并切换设备 (重试: %d)", retryCount))
 			pool.MarkInvalid(header)
 			pool.RemoveInvalid()
-			return fetchContentWithRetry(itemID, textMode, imageMode, retryCount+1)
+			return fetchContentWithRetry(itemID, retryCount+1)
 		}
 
 		// 检查密钥版本
 		keyVersion, _ := data["key_version"].(float64)
-		if currentKeyInfo != nil && int(keyVersion) != currentKeyInfo.Ver {
+		if int(keyVersion) != currentKeyInfo.Ver {
 			contentLogger.Warning("密钥版本不匹配，重新获取密钥")
 
 			// 更新池中的密钥
 			newKeyInfo, err := GetKey(header)
 			if err == nil {
-				UpdateKeyInPool(header, newKeyInfo.Key, newKeyInfo.Ver)
+				UpdateKeyInPool(header, newKeyInfo)
 				currentKeyInfo = newKeyInfo
 			} else {
 				// 获取密钥失败，切换设备
 				contentLogger.Warning("获取密钥失败，切换设备重试")
 				pool.MarkInvalid(header)
 				pool.RemoveInvalid()
-				return fetchContentWithRetry(itemID, textMode, imageMode, retryCount+1)
+				return fetchContentWithRetry(itemID, retryCount+1)
 			}
 		}
 
-		// 解密内容
+		contentStr, err := decodeContentBody(data, currentKeyInfo)
-		contentBytes, _ := base64.StdEncoding.DecodeString(contentEncoded)
-		if len(contentBytes) < 16 {
-			contentLogger.Warning("内容长度不足，切换设备重试")
-			pool.MarkInvalid(header)
-			pool.RemoveInvalid()
-			return fetchContentWithRetry(itemID, textMode, imageMode, retryCount+1)
-		}
-
-		iv := contentBytes[0:16]
-		encryptedData := contentBytes[16:]
-
-		keyBytes, _ := base64.StdEncoding.DecodeString(currentKeyInfo.Key)
-		decrypted, err := De(encryptedData, keyBytes, iv)
 		if err != nil {
 			contentLogger.Warning(fmt.Sprintf("解密失败，切换设备重试: %v", err))
 			pool.MarkInvalid(header)
 			pool.RemoveInvalid()
-			return fetchContentWithRetry(itemID, textMode, imageMode, retryCount+1)
+			return fetchContentWithRetry(itemID, retryCount+1)
 		}
 
-		// 处理内容
+		contentStr = strings.ReplaceAll(contentStr, `<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>`, "")
-		contentStr := string(decrypted)
-		contentStr = strings.Replace(contentStr, `<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>`, "", -1)
 		contentStr = strings.TrimSpace(contentStr)
 
 		data["content"] = contentStr
 
-		// 更新缓存
+		// 写缓存并返回缓存格式（按参数的解析统一放在出口 processCachedContent）
-		cacheData := buildCacheData(data)
+		cacheStr := marshalNoEscape(buildCacheData(UnwrapJSONStrings(data)))
-		saveCacheJSON("content_"+itemID, cacheData, 86400*2)
+		UpdateCache("content_"+itemID, cacheStr, 86400)
-
+		return cacheStr, nil
-		// 解析内容
-		parser := NewContentParser()
-		data["content"] = parser.Parse(contentStr, textMode, imageMode)
-
-		return buildJSONResponse(UnwrapJSONStrings(body)), nil
 	}
 
 	// 响应code不为0，切换设备重试
 	contentLogger.Warning(fmt.Sprintf("响应code异常: %.0f，切换设备重试", body["code"]))
 	pool.MarkInvalid(header)
 	pool.RemoveInvalid()
-	return fetchContentWithRetry(itemID, textMode, imageMode, retryCount+1)
+	return fetchContentWithRetry(itemID, retryCount+1)
 }
 
-// tryBackupAPI 尝试备用API（所有设备都失败后的最后手段）
+// decodeContentBody 按上游 crypt_status 解出正文：
-func tryBackupAPI(itemID string, textMode, imageMode bool) (string, error) {
+//   - 0：base64 密文，设备密钥 AES-CBC 解密（compress_status!=0 时解压）
+//   - 1：明文（可能压缩）
+//   - 2：密钥已失效，刷新密钥后由调用方重试
+func decodeContentBody(data map[string]interface{}, keyInfo *KeyInfo) (string, error) {
+	contentEncoded, _ := data["content"].(string)
+	cryptStatus, _ := data["crypt_status"].(float64)
+	compressStatus, _ := data["compress_status"].(float64)
+
+	switch int(cryptStatus) {
+	case 1:
+		if compressStatus != 0 {
+			return string(gunzipMaybe([]byte(contentEncoded))), nil
+		}
+		return contentEncoded, nil
+
+	case 2:
+		return "", fmt.Errorf("密钥已失效（crypt_status=2），需刷新密钥重试")
+
+	default:
+		// 500003 场景（设备无需解密）仍下发密文时按明文兜底
+		if keyInfo == nil || keyInfo.Key == "" {
+			return contentEncoded, nil
+		}
+
+		contentBytes, err := base64.StdEncoding.DecodeString(contentEncoded)
+		if err != nil || len(contentBytes) < 16 {
+			return "", fmt.Errorf("内容密文长度异常")
+		}
+
+		iv := contentBytes[0:16]
+		encryptedData := contentBytes[16:]
+
+		keyBytes, _ := base64.StdEncoding.DecodeString(keyInfo.Key)
+		decrypted, err := De(encryptedData, keyBytes, iv)
+		if err != nil {
+			return "", err
+		}
+		if compressStatus != 0 {
+			decrypted = gunzipMaybe(decrypted)
+		}
+		return string(decrypted), nil
+	}
+}
+
+// tryBackupAPI 尝试备用API（所有设备都失败后的最后手段），返回缓存格式 JSON
+func tryBackupAPI(itemID string) (string, error) {
 	contentLogger.Warning("尝试备用接口1（所有设备均失败）")
 
 	// 从设备池获取任意一个有效设备用于备用接口
@@ -217,8 +250,8 @@ func tryBackupAPI(itemID string, textMode, imageMode bool) (string, error) {
 	header := item.DeviceHeader
 
 	// 备用接口1：使用DH加密
-	backupAPI := fmt.Sprintf("https://novel.snssdk.com/api/novel/book/reader/content/v1?support_image=1&item_id=%s&aid=1319&app_name=novelapp&channel=0&device_platform=android&os_version=2&version_code=58932&%s",
+	backupAPI := fmt.Sprintf("https://novel.snssdk.com/api/novel/book/reader/content/v1?support_image=1&item_id=%s&aid=1319&app_name=novelapp&channel=0&device_platform=android&os_version=2&version_code=%s&%s",
-		itemID, header)
+		itemID, ClientVersionCode, header)
 
 	cm := NewCM()
 	resp, err := GorgonRequest(backupAPI, map[string]interface{}{
@@ -259,18 +292,14 @@ func tryBackupAPI(itemID string, textMode, imageMode bool) (string, error) {
 			contentLogger.Error("解密失败: " + err.Error())
 			return `{"code": -1, "msg": "解密失败"}`, err
 		}
+		decryptedContent = string(gunzipMaybe([]byte(decryptedContent)))
 
-		data["content"] = decryptedContent
+		data["content"] = strings.TrimSpace(decryptedContent)
 
-		// 更新缓存
+		// 写缓存并返回缓存格式
-		bodyJSONStr := buildJSONResponse(body)
+		cacheStr := marshalNoEscape(buildCacheData(UnwrapJSONStrings(data)))
-		UpdateCache("content_"+itemID, bodyJSONStr, 86400)
+		UpdateCache("content_"+itemID, cacheStr, 86400)
-
+		return cacheStr, nil
-		// 解析内容
-		parser := NewContentParser()
-		data["content"] = parser.Parse(decryptedContent, textMode, imageMode)
-
-		return buildJSONResponse(UnwrapJSONStrings(body)), nil
 	}
 
 	contentLogger.Warning("备用接口1获取正文出错！")

internal/fqapi/content_parser.go

@@ -9,6 +9,20 @@ import (
 	"github.com/PuerkitoBio/goquery"
 )
 
+// imgSrcRe 匹配 img 标签的 src 属性
+var imgSrcRe = regexp.MustCompile(`(?i)(<img[^>]*\ssrc=")([^"]*)(")`)
+
+// permanentizeImgSrc 将正文插图链接替换为永久 CDN 链接（原链接带临时参数会过期）
+func permanentizeImgSrc(html string) string {
+	return imgSrcRe.ReplaceAllStringFunc(html, func(m string) string {
+		parts := imgSrcRe.FindStringSubmatch(m)
+		if len(parts) < 3 || parts[2] == "" {
+			return m
+		}
+		return parts[1] + NormalizeNovelImageURL(parts[2]) + parts[3]
+	})
+}
+
 var (
 	parserLogger = common.NewLogger("content_parser", "INFO", "")
 )
@@ -118,6 +132,8 @@ func (p *ContentParser) extractText(content string) string {
 				divHTML = decodeHTMLEntities(divHTML)
 				// 标准化img属性
 				divHTML = normalizeImgAttributes(divHTML)
+				// 插图链接永久化
+				divHTML = permanentizeImgSrc(divHTML)
 				finalResult = append(finalResult, divHTML)
 			}
 			return
@@ -173,6 +189,9 @@ func (p *ContentParser) processHTMLMode(content string) string {
 	// 解码HTML实体
 	content = decodeHTMLEntities(content)
 
+	// 插图链接永久化（原链接带临时参数会过期）
+	content = permanentizeImgSrc(content)
+
 	// 根据配置决定是否移除空行
 	if p.cfg.RemoveBlankLines {
 		// 对HTML内容移除空的<p>标签

internal/fqapi/content_utils.go

@@ -2,12 +2,84 @@ package fqapi
 
 import (
 	"bytes"
+	"compress/gzip"
+	"compress/zlib"
 	"encoding/json"
 	"fanqie/internal/config"
-	"sort"
+	"io"
+	"net/url"
+	"regexp"
 	"strings"
 )
 
+// 客户端版本统一（与 2026-10 可用的书源实现一致；旧值 58932/5.8.9.32 混用易触发风控）
+const (
+	ClientVersionCode = "72732"
+	ClientVersionName = "7.2.7.32"
+)
+
+// PermanentNovelImgHost 番茄小说图片的永久 CDN 域名（原始链接带临时参数会过期失效）
+const PermanentNovelImgHost = "https://p6-novel.byteimg.com"
+
+// novelPicMd5Re 匹配图片路径中的 32 位十六进制资源 ID
+var novelPicMd5Re = regexp.MustCompile(`^/novel-pic/([a-f0-9]{32})`)
+
+// NormalizeNovelImageURL 将临时图片链接永久化：
+//   - /novel-pic/{md5} → p6-novel.byteimg.com/origin/novel-pic/{md5}（正文插图原图）
+//   - 含 ~tplv 的模板图（封面缩放）→ p6-novel.byteimg.com 保留原路径
+func NormalizeNovelImageURL(raw string) string {
+	u := strings.TrimSpace(strings.ReplaceAll(raw, "&", "&"))
+	if u == "" {
+		return ""
+	}
+	if strings.HasPrefix(u, "//") {
+		u = "https:" + u
+	}
+	idx := strings.Index(u, "/novel-pic/")
+	if idx < 0 {
+		return u
+	}
+	path := u[idx:]
+	if m := novelPicMd5Re.FindStringSubmatch(path); m != nil && !strings.Contains(path, "~tplv") {
+		return PermanentNovelImgHost + "/origin/novel-pic/" + m[1]
+	}
+	return PermanentNovelImgHost + path
+}
+
+// gunzipMaybe 自适应解压上游正文（gzip 与 zlib 帧都可能出现），非压缩数据原样返回
+func gunzipMaybe(data []byte) []byte {
+	if r, err := gzip.NewReader(bytes.NewReader(data)); err == nil {
+		if out, err2 := io.ReadAll(r); err2 == nil {
+			r.Close()
+			return out
+		}
+	}
+	if r, err := zlib.NewReader(bytes.NewReader(data)); err == nil {
+		if out, err2 := io.ReadAll(r); err2 == nil {
+			r.Close()
+			return out
+		}
+	}
+	return data
+}
+
+// buildSortedQuery 将若干 "k=v" 段合并为 form 编码的查询串（按键排序）。
+// 设备机型等值含空格时必须编码，否则实际请求的 URL 与签名输入不一致，
+// registerkey 等接口会注册失败（书源 2026-10-10 修复的同类问题）
+func buildSortedQuery(parts ...string) string {
+	vals := url.Values{}
+	for _, part := range parts {
+		for _, seg := range strings.Split(part, "&") {
+			if seg == "" {
+				continue
+			}
+			k, v, _ := strings.Cut(seg, "=")
+			vals.Add(k, v)
+		}
+	}
+	return vals.Encode()
+}
+
 // getContentConfig 获取内容配置（带默认值）
 func getContentConfig() config.ContentConfig {
 	if config.GetAppConfig() != nil {
@@ -188,7 +260,7 @@ func getDeviceHeader() string {
 
 // removeVersionFromHeader 移除header中的version_name参数
 func removeVersionFromHeader(header string) string {
-	return strings.Replace(header, "&version_name=5.8.9.32", "", -1)
+	return strings.Replace(header, "&version_name="+ClientVersionName, "", -1)
 }
 
 // ============ API参数构建工具 ============
@@ -203,7 +275,7 @@ func BuildURL(fullURL string, customParams ...string) string {
 		"channel=0",
 		"device_platform=android",
 		"os_version=0",
-		"version_code=58932",
+		"version_code=" + ClientVersionCode,
 	}
 
 	// 添加设备header
@@ -215,13 +287,8 @@ func BuildURL(fullURL string, customParams ...string) string {
 	// 添加自定义参数
 	allParams = append(allParams, customParams...)
 
-	// 合并、拆分、排序
+	// form 编码 + 排序（机型含空格等特殊字符时保证 URL 与签名一致）
-	joined := strings.Join(allParams, "&")
+	return fullURL + "?" + buildSortedQuery(allParams...)
-	paramList := strings.Split(joined, "&")
-	sort.Strings(paramList)
-	params := strings.Join(paramList, "&")
-
-	return fullURL + "?" + params
 }
 
 // ============ 缓存处理工具函数 ============

internal/fqapi/content_utils_test.go

@@ -0,0 +1,31 @@
+package fqapi
+
+import "testing"
+
+// TestBuildSortedQuery form 编码 + 排序（机型含空格时 URL 与签名一致的关键）
+func TestBuildSortedQuery(t *testing.T) {
+	got := buildSortedQuery("b=2", "a=1", "device_type=Pixel 6")
+	want := "a=1&b=2&device_type=Pixel+6"
+	if got != want {
+		t.Fatalf("buildSortedQuery = %q, want %q", got, want)
+	}
+}
+
+// TestNormalizeNovelImageURL 插图/封面/已永久化链接的归一化
+func TestNormalizeNovelImageURL(t *testing.T) {
+	cases := map[string]string{
+		// 正文插图（纯 md5）→ origin 原图
+		"//p9-novel.byteimg.com/img/novel-pic/0123456789abcdef0123456789abcdef": "https://p6-novel.byteimg.com/origin/novel-pic/0123456789abcdef0123456789abcdef",
+		// 已永久化的链接幂等
+		"https://p6-novel.byteimg.com/origin/novel-pic/0123456789abcdef0123456789abcdef": "https://p6-novel.byteimg.com/origin/novel-pic/0123456789abcdef0123456789abcdef",
+		// 封面模板图（~tplv 缩放）→ 保留原路径仅换域名
+		"https://p3-novel.byteimg.com/novel-pic/0123456789abcdef0123456789abcdef~tplv-novel-pic-large.webp": "https://p6-novel.byteimg.com/novel-pic/0123456789abcdef0123456789abcdef~tplv-novel-pic-large.webp",
+		// 非 novel-pic 链接原样返回
+		"https://example.com/other.jpg": "https://example.com/other.jpg",
+	}
+	for in, want := range cases {
+		if got := NormalizeNovelImageURL(in); got != want {
+			t.Errorf("NormalizeNovelImageURL(%q) = %q, want %q", in, got, want)
+		}
+	}
+}

internal/fqapi/detail.go

@@ -42,9 +42,13 @@ func fetchDetail(bookID string) (string, error) {
 	}
 
 	if code, ok := respJSON["code"].(float64); ok && code == 0 {
-		// 删除content字段
 		if data, ok := respJSON["data"].(map[string]interface{}); ok {
+			// 删除content字段
 			delete(data, "content")
+			// 封面链接永久化（原链接带临时参数会过期）
+			if thumb, ok := data["thumb_url"].(string); ok && thumb != "" {
+				data["thumb_url"] = NormalizeNovelImageURL(thumb)
+			}
 		}
 
 		// 重新序列化（解包 JSON 字符串字段）

internal/fqapi/device_key_pool.go

@@ -20,9 +20,14 @@ type DeviceKeyItem struct {
 	DeviceHeader string    `json:"device_header"`
 	Key          string    `json:"key"`
 	KeyVer       int       `json:"key_ver"`
+	KeyTs        int64     `json:"key_ts"` // 密钥注册时间戳（key_register_ts）
 	IsValid      bool      `json:"is_valid"`
 	CreatedAt    time.Time `json:"created_at"`
 	LastUsedAt   time.Time `json:"last_used_at"`
+
+	// 仅内存字段（不落库）
+	KeyFetchedAt time.Time `json:"-"` // 密钥获取时间，超 24h 异步刷新
+	KeyRefreshAt time.Time `json:"-"` // 上次刷新尝试时间，防刷新风暴
 }
 
 // DeviceKeyPool 设备密钥池
@@ -77,6 +82,10 @@ func (p *DeviceKeyPool) Initialize() error {
 	}
 
 	poolLogger.Info(fmt.Sprintf("设备密钥池初始化完成，当前有效设备数: %d", p.getValidCount()))
+
+	// last_used_at 批量落库（GetNext 不再同步写库）
+	p.StartDevicePoolFlusher()
+
 	return nil
 }
 
@@ -110,11 +119,22 @@ func (p *DeviceKeyPool) GetNext() (*DeviceKeyItem, error) {
 	item := validItems[p.currentIndex%len(validItems)]
 	p.currentIndex++
 
-	// 更新最后使用时间
+	// 只更新内存中的最后使用时间，由后台 flusher 定期批量落库
+	// （此前每次取设备同步 UPDATE，SQLite 单写锁下是吞吐瓶颈）
 	item.LastUsedAt = time.Now()
-	p.updateDeviceInDB(item)
 
-	// poolLogger.Debug(fmt.Sprintf("使用设备 ID=%d", item.ID))
+	// 密钥超 24h 未刷新：异步换新（本次请求仍用旧密钥，下次生效）
+	if time.Since(item.KeyFetchedAt) > 20*time.Hour && time.Since(item.KeyRefreshAt) > 10*time.Minute {
+		item.KeyRefreshAt = time.Now()
+		header := item.DeviceHeader
+		go func() {
+			if ki, err := GetKey(header); err == nil {
+				UpdateKeyInPool(header, ki)
+			} else {
+				poolLogger.Warning(fmt.Sprintf("刷新设备密钥失败: %v", err))
+			}
+		}()
+	}
 
 	// 异步检查是否需要补充
 	go p.checkAndRefill()
@@ -316,9 +336,11 @@ func (p *DeviceKeyPool) addNewDevice() error {
 		DeviceHeader: deviceHeader,
 		Key:          keyInfo.Key,
 		KeyVer:       keyInfo.Ver,
+		KeyTs:        keyInfo.Ts,
 		IsValid:      true,
 		CreatedAt:    time.Now(),
 		LastUsedAt:   time.Now(),
+		KeyFetchedAt: time.Now(),
 	}
 
 	// 保存到数据库
@@ -344,7 +366,7 @@ func (p *DeviceKeyPool) loadFromDB() error {
 	}
 
 	rows, err := cacheDB.Query(`
-		SELECT id, device_header, key, key_ver, is_valid, created_at, last_used_at 
+		SELECT id, device_header, key, key_ver, COALESCE(key_ts, 0), is_valid, created_at, last_used_at
 		FROM device_pool
 		ORDER BY id
 	`)
@@ -363,6 +385,7 @@ func (p *DeviceKeyPool) loadFromDB() error {
 			&item.DeviceHeader,
 			&item.Key,
 			&item.KeyVer,
+			&item.KeyTs,
 			&item.IsValid,
 			&createdAt,
 			&lastUsedAt,
@@ -374,6 +397,7 @@ func (p *DeviceKeyPool) loadFromDB() error {
 
 		item.CreatedAt = time.Unix(createdAt, 0)
 		item.LastUsedAt = time.Unix(lastUsedAt, 0)
+		item.KeyFetchedAt = time.Now() // 旧设备的密钥年龄未知，从加载起算
 		items = append(items, &item)
 	}
 
@@ -401,10 +425,10 @@ func (p *DeviceKeyPool) saveDeviceToDB(item *DeviceKeyItem) error {
 
 	// RETURNING id 同时兼容 SQLite(3.35+) 与 PostgreSQL，替代 LastInsertId()
 	err := cacheDB.QueryRow(q(`
-		INSERT INTO device_pool (device_header, key, key_ver, is_valid, created_at, last_used_at, updated_at)
+		INSERT INTO device_pool (device_header, key, key_ver, key_ts, is_valid, created_at, last_used_at, updated_at)
-		VALUES (?, ?, ?, ?, ?, ?, ?)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?)
 		RETURNING id
-	`), item.DeviceHeader, item.Key, item.KeyVer, boolToInt(item.IsValid),
+	`), item.DeviceHeader, item.Key, item.KeyVer, item.KeyTs, boolToInt(item.IsValid),
 		item.CreatedAt.Unix(), item.LastUsedAt.Unix(), item.CreatedAt.Unix()).Scan(&item.ID)
 
 	return err
@@ -418,14 +442,39 @@ func (p *DeviceKeyPool) updateDeviceInDB(item *DeviceKeyItem) error {
 
 	_, err := cacheDB.Exec(q(`
 		UPDATE device_pool
-		SET device_header = ?, key = ?, key_ver = ?, is_valid = ?, last_used_at = ?, updated_at = ?
+		SET device_header = ?, key = ?, key_ver = ?, key_ts = ?, is_valid = ?, last_used_at = ?, updated_at = ?
 		WHERE id = ?
-	`), item.DeviceHeader, item.Key, item.KeyVer, boolToInt(item.IsValid),
+	`), item.DeviceHeader, item.Key, item.KeyVer, item.KeyTs, boolToInt(item.IsValid),
 		item.LastUsedAt.Unix(), item.LastUsedAt.Unix(), item.ID)
 
 	return err
 }
 
+// StartDevicePoolFlusher 启动 last_used_at 批量落库任务（GetNext 已改为只写内存）
+func (p *DeviceKeyPool) StartDevicePoolFlusher() {
+	go func() {
+		for range time.Tick(time.Minute) {
+			FlushDevicePool()
+		}
+	}()
+	poolLogger.Info("设备池 last_used_at 批量落库已启动（每分钟）")
+}
+
+// FlushDevicePool 将内存中的设备使用时间批量刷入数据库
+// ponytail: 进程退出时最多丢 1 分钟使用记录（仅统计用途），无需精确停表
+func FlushDevicePool() {
+	p := GetDeviceKeyPool()
+	if !p.enabled || cacheDB == nil {
+		return
+	}
+	p.mu.RLock()
+	items := append([]*DeviceKeyItem(nil), p.items...)
+	p.mu.RUnlock()
+	for _, it := range items {
+		p.updateDeviceInDB(it)
+	}
+}
+
 // removeInvalidFromDB 从数据库移除无效设备
 func (p *DeviceKeyPool) removeInvalidFromDB() error {
 	if cacheDB == nil {
@@ -483,10 +532,10 @@ func GetKeyInfoFromPool(deviceHeader string) *KeyInfo {
 	return nil
 }
 
-// UpdateKeyInPool 更新池中设备的密钥
+// UpdateKeyInPool 更新池中设备的密钥（含注册时间戳）
-func UpdateKeyInPool(deviceHeader string, key string, ver int) error {
+func UpdateKeyInPool(deviceHeader string, ki *KeyInfo) error {
 	pool := GetDeviceKeyPool()
-	if !pool.IsEnabled() {
+	if !pool.IsEnabled() || ki == nil {
 		return nil
 	}
 
@@ -495,8 +544,10 @@ func UpdateKeyInPool(deviceHeader string, key string, ver int) error {
 
 	for _, item := range pool.items {
 		if item.DeviceHeader == deviceHeader {
-			item.Key = key
+			item.Key = ki.Key
-			item.KeyVer = ver
+			item.KeyVer = ki.Ver
+			item.KeyTs = ki.Ts
+			item.KeyFetchedAt = time.Now()
 			return pool.updateDeviceInDB(item)
 		}
 	}

internal/fqapi/device_register.go

@@ -5,6 +5,7 @@ import (
 	"encoding/hex"
 	"encoding/json"
 	"fanqie/internal/common"
+	"fanqie/internal/config"
 	"fmt"
 	"math/big"
 	"net"
@@ -186,6 +187,22 @@ func generateIPv6List() []map[string]string {
 	}
 }
 
+// deviceIdentity 注册设备身份：pad（默认，历史行为）/ phone（对齐手机 App 书源注册 payload）
+func deviceIdentity() string {
+	if cfg := config.GetConfig(); cfg != nil && cfg.Fanqie.DeviceIdentity == "phone" {
+		return "phone"
+	}
+	return "pad"
+}
+
+// deviceCustomFields 注册身份对应的 custom 字段
+func deviceCustomFields() map[string]interface{} {
+	if deviceIdentity() == "phone" {
+		return map[string]interface{}{"host_bit": 64, "dragon_device_type": "phone"}
+	}
+	return map[string]interface{}{"host_bit": 32, "dragon_device_type": "pad"}
+}
+
 // GenerateFullRequestBody 生成完整的请求体数据
 func GenerateFullRequestBody() map[string]interface{} {
 	rawData := map[string]interface{}{
@@ -214,7 +231,7 @@ func GenerateFullRequestBody() map[string]interface{} {
 			"sim_serial_number":     []interface{}{},
 			"oaid_may_support":      false,
 			"device_platform":       "android",
-			"custom":                map[string]interface{}{"host_bit": 32, "dragon_device_type": "pad"},
+			"custom":                deviceCustomFields(),
 			"pre_installed_channel": "",
 			"is_system_app":         0,
 			"sdk_flavor":            "china",
@@ -234,6 +251,16 @@ func GenerateFullRequestBody() map[string]interface{} {
 	}
 	header["ipv6_list"] = generateIPv6List()
 
+	// phone 身份补充真机指纹字段（对齐书源注册 payload，规避 pad 身份的差异化风控）
+	if deviceIdentity() == "phone" {
+		rom, _ := header["rom"].(string)
+		header["hardware"] = "qcom"
+		header["device_device"] = rom
+		header["fingerprint"] = fmt.Sprintf("%v/%v/%v:%v/%s/%s:user/release-keys",
+			header["device_brand"], header["device_model"], header["device_model"],
+			header["os_version"], rom, rom)
+	}
+
 	for k, v := range genTime {
 		rawData[k] = v
 	}
@@ -252,9 +279,9 @@ func tryActivatePremium(header string) {
 		"channel=0",
 		"device_platform=android",
 		"os_version=0",
-		"version_code=58932",
+		"version_code=" + ClientVersionCode,
-		"manifest_version_code=58932",
+		"manifest_version_code=" + ClientVersionCode,
-		"update_version_code=58932",
+		"update_version_code=" + ClientVersionCode,
 		header,
 	}
 
@@ -365,7 +392,7 @@ func Register() (string, error) {
 		}
 
 		deviceModel := data["header"].(map[string]interface{})["device_model"].(string)
-		header := fmt.Sprintf("device_id=%v&device_type=%s&iid=%v&version_name=5.8.9.32",
+		header := fmt.Sprintf("device_id=%v&device_type=%s&iid=%v&version_name="+ClientVersionName,
 			respData["device_id_str"],
 			deviceModel,
 			respData["install_id_str"])

internal/fqapi/gorgon_utils.go

@@ -14,6 +14,16 @@ func CreateMD5(s string) string {
 	return hex.EncodeToString(hasher.Sum(nil))
 }
 
+// setCommonHeaders 注入番茄客户端通用请求头（与签名头不冲突，对齐书源实现降低风控特征）
+func setCommonHeaders(headers map[string]string) {
+	if _, ok := headers["x-tt-store-region"]; ok {
+		return
+	}
+	headers["x-tt-store-region"] = "cn-zj"
+	headers["x-tt-store-region-src"] = "did"
+	headers["sdk-version"] = "2"
+}
+
 // GorgonRequest Gorgon请求（使用签名切换器）
 func GorgonRequest(urlStr string, options map[string]interface{}) (*common.ClientResponse, error) {
 	headers, ok := options["headers"].(map[string]string)
@@ -21,6 +31,7 @@ func GorgonRequest(urlStr string, options map[string]interface{}) (*common.Clien
 		headers = make(map[string]string)
 		options["headers"] = headers
 	}
+	setCommonHeaders(headers)
 
 	dataMD5 := ""
 	if body, ok := options["body"].(string); ok && body != "" {
@@ -53,6 +64,7 @@ func GorgonRequestSync(urlStr string, options map[string]interface{}) (*common.C
 		headers = make(map[string]string)
 		options["headers"] = headers
 	}
+	setCommonHeaders(headers)
 
 	dataMD5 := ""
 	if body, ok := options["body"].(string); ok && body != "" {
@@ -69,9 +81,7 @@ func GorgonRequestSync(urlStr string, options map[string]interface{}) (*common.C
 	signedHeaders := algos.GlobalSignatureSwitcher.Sign(urlStr, headers)
 
 	// 删除x-ss-stub（如果存在）
-	if _, exists := signedHeaders["x-ss-stub"]; exists {
+	delete(signedHeaders, "x-ss-stub")
-		delete(signedHeaders, "x-ss-stub")
-	}
 
 	// 更新headers
 	for k, v := range signedHeaders {
@@ -90,6 +100,7 @@ func ContentRequest(urlStr string, options map[string]interface{}) (*common.Clie
 		headers = make(map[string]string)
 		options["headers"] = headers
 	}
+	setCommonHeaders(headers)
 
 	dataMD5 := ""
 	if body, ok := options["body"].(string); ok && body != "" {

internal/fqapi/manga.go

@@ -58,9 +58,14 @@ type ImageResult struct {
 	Index  int    `json:"index"`
 }
 
-// HandleGetManga 处理漫画请求
+// HandleGetManga 处理漫画请求；设备池签名路线全部失败时降级 wkbrowser 免签名兜底
 func HandleGetManga(itemID string, showHTML bool, urlOutputMode string) (interface{}, error) {
-	return getMangaWithRetry(itemID, showHTML, urlOutputMode, 0)
+	res, err := getMangaWithRetry(itemID, showHTML, urlOutputMode, 0)
+	if err == nil {
+		return res, nil
+	}
+	mangaLogger.Warning(fmt.Sprintf("签名路线失败，尝试 wkbrowser 免签名兜底: %v", err))
+	return fetchMangaFallback(itemID, showHTML)
 }
 
 // getMangaWithRetry 获取漫画内容，支持设备切换重试
@@ -87,7 +92,7 @@ func getMangaWithRetry(itemID string, showHTML bool, urlOutputMode string, retry
 	mangaLogger.Debug(fmt.Sprintf("使用池中设备 ID=%d (重试次数: %d)", item.ID, retryCount))
 
 	// 2. 构建URL - 使用 BuildURL 添加设备参数
-	headerWithoutVersion := strings.Replace(header, "&version_name=5.8.9.32", "", -1)
+	headerWithoutVersion := removeVersionFromHeader(header)
 
 	url := BuildURL("https://reading.snssdk.com/reading/reader/full/v/",
 		"aid=1967",
@@ -146,7 +151,7 @@ func getMangaWithRetry(itemID string, showHTML bool, urlOutputMode string, retry
 			mangaLogger.Warning("密钥版本不匹配，重新获取密钥")
 			newKeyInfo, err := GetKey(header)
 			if err == nil {
-				UpdateKeyInPool(header, newKeyInfo.Key, newKeyInfo.Ver)
+				UpdateKeyInPool(header, newKeyInfo)
 				keyInfo = newKeyInfo
 			} else {
 				mangaLogger.Warning("获取密钥失败，切换设备重试")

internal/fqapi/manga_fallback.go

@@ -0,0 +1,212 @@
+package fqapi
+
+import (
+	"encoding/json"
+	"fmt"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+
+	"fanqie/internal/common"
+)
+
+// 漫画免签名兜底（对齐书源 20261012 的 wkbrowser 路线）：
+// 设备池签名路线全部失败时，直接从 m.wkbrowser.com 取章节图片，
+// 无需注册设备/签名/解密，返回原图直链。
+
+var (
+	mangaFallbackItemIDRe = regexp.MustCompile(`^\d+$`)
+	trailingNumberRe      = regexp.MustCompile(`(\d+)$`)
+)
+
+const mangaFallbackOrigin = "https://p6-novel.byteimg.com/origin/"
+
+// fetchMangaFallback 免签名获取漫画章节图片（wkbrowser 原图直链）
+func fetchMangaFallback(itemID string, showHTML bool) (interface{}, error) {
+	if !mangaFallbackItemIDRe.MatchString(itemID) {
+		return nil, fmt.Errorf("无效的 item_id: %s", itemID)
+	}
+
+	client := common.NewHTTPClient()
+	resp, err := client.Get("https://m.wkbrowser.com/i"+itemID+"/info/v2/", map[string]string{
+		"User-Agent": "Mozilla/5.0 (Linux; Android 14) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Mobile Safari/537.36",
+		"Accept":     "application/json, text/plain, */*",
+	})
+	if err != nil {
+		return nil, fmt.Errorf("wkbrowser 请求失败: %w", err)
+	}
+
+	var body map[string]interface{}
+	if err := json.Unmarshal(resp.Content, &body); err != nil {
+		return nil, fmt.Errorf("wkbrowser 响应解析失败: %w", err)
+	}
+	data, _ := body["data"].(map[string]interface{})
+	if data == nil {
+		return nil, fmt.Errorf("wkbrowser 响应缺少 data（code=%v）", body["code"])
+	}
+
+	// content 为 JSON 字符串或对象，内含 materials/skeleton 图片清单
+	payload := data["content"]
+	if s, ok := payload.(string); ok {
+		var p map[string]interface{}
+		if err := json.Unmarshal([]byte(s), &p); err != nil {
+			return nil, fmt.Errorf("wkbrowser 图片内容解析失败: %w", err)
+		}
+		payload = p
+	}
+
+	uris := collectMangaFallbackURIs(payload)
+	if len(uris) == 0 {
+		return nil, fmt.Errorf("wkbrowser 未找到图片")
+	}
+
+	images := make([]ImageResult, len(uris))
+	for i, u := range uris {
+		images[i] = ImageResult{Data: u, Format: "unknown", Index: i}
+	}
+
+	if showHTML {
+		var b strings.Builder
+		for _, img := range images {
+			fmt.Fprintf(&b, "<img src=\"%s\">\n", img.Data)
+		}
+		return map[string]interface{}{"content": b.String(), "source": "wkbrowser"}, nil
+	}
+	return map[string]interface{}{"images": images, "source": "wkbrowser"}, nil
+}
+
+// collectMangaFallbackURIs 按书源三段策略收集图片链接（保证页序）：
+// 1) skeleton.data 顺序引用 materials 的 key
+// 2) materials key 按末尾数字排序
+// 3) 递归遍历全树兜底（顺序不保证，仅防白屏）
+func collectMangaFallbackURIs(payload interface{}) []string {
+	p, _ := payload.(map[string]interface{})
+	if p == nil {
+		return nil
+	}
+
+	images := make([]string, 0, 32)
+	seen := map[string]bool{}
+	push := func(uri string) {
+		src := mangaFallbackImageURL(uri)
+		if src != "" && !seen[src] {
+			seen[src] = true
+			images = append(images, src)
+		}
+	}
+
+	materials, _ := p["materials"].(map[string]interface{})
+	skeletonWrapper, _ := p["skeleton"].(map[string]interface{})
+	skeleton, _ := skeletonWrapper["data"].([]interface{})
+
+	if materials != nil && skeleton != nil {
+		for _, s := range skeleton {
+			node, _ := s.(map[string]interface{})
+			if node == nil {
+				continue
+			}
+			key := ""
+			for _, k := range []string{"elementInfo", "key", "id"} {
+				if v, _ := node[k].(string); v != "" {
+					key = v
+					break
+				}
+			}
+			if m, ok := materials[key].(map[string]interface{}); ok {
+				if uri := mangaFallbackNodeURI(m); uri != "" {
+					push(uri)
+				}
+			}
+		}
+		if len(images) > 0 {
+			return images
+		}
+	}
+
+	if materials != nil {
+		keys := make([]string, 0, len(materials))
+		for k := range materials {
+			keys = append(keys, k)
+		}
+		sort.Slice(keys, func(i, j int) bool {
+			return trailingNumber(keys[i]) < trailingNumber(keys[j])
+		})
+		for _, k := range keys {
+			if m, ok := materials[k].(map[string]interface{}); ok {
+				if uri := mangaFallbackNodeURI(m); uri != "" {
+					push(uri)
+				}
+			}
+		}
+		if len(images) > 0 {
+			return images
+		}
+	}
+
+	var walk func(node interface{})
+	walk = func(node interface{}) {
+		switch t := node.(type) {
+		case []interface{}:
+			for _, item := range t {
+				walk(item)
+			}
+		case map[string]interface{}:
+			if uri := mangaFallbackNodeURI(t); uri != "" {
+				push(uri)
+				return
+			}
+			for _, v := range t {
+				switch v.(type) {
+				case map[string]interface{}, []interface{}:
+					walk(v)
+				}
+			}
+		}
+	}
+	walk(p)
+	return images
+}
+
+// mangaFallbackNodeURI 从 materials 节点取图片资源（web_uri 优先，其次 novel-pic/md5）
+func mangaFallbackNodeURI(node map[string]interface{}) string {
+	if d, ok := node["data"].(map[string]interface{}); ok {
+		if u, _ := d["web_uri"].(string); u != "" {
+			return u
+		}
+	}
+	if u, _ := node["web_uri"].(string); u != "" {
+		return u
+	}
+	if d, ok := node["data"].(map[string]interface{}); ok {
+		if md5, _ := d["md5"].(string); md5 != "" {
+			return "novel-pic/" + md5
+		}
+	}
+	return ""
+}
+
+// mangaFallbackImageURL web_uri 转可访问的原图直链
+func mangaFallbackImageURL(uri string) string {
+	u := strings.TrimPrefix(uri, "/")
+	if u == "" {
+		return ""
+	}
+	if strings.HasPrefix(u, "http://") {
+		return "https://" + strings.TrimPrefix(u, "http://")
+	}
+	if strings.HasPrefix(u, "https://") {
+		return u
+	}
+	return mangaFallbackOrigin + u
+}
+
+// trailingNumber 取字符串末尾数字（materials key 排序用），无数字排最后
+func trailingNumber(s string) int {
+	m := trailingNumberRe.FindStringSubmatch(s)
+	if m == nil {
+		return 1 << 30
+	}
+	n, _ := strconv.Atoi(m[1])
+	return n
+}

internal/fqapi/manga_fallback_test.go

@@ -0,0 +1,44 @@
+package fqapi
+
+import "testing"
+
+// TestCollectMangaFallbackURIs skeleton 顺序优先、web_uri/md5 取值与原图直链拼接
+func TestCollectMangaFallbackURIs(t *testing.T) {
+	payload := map[string]interface{}{
+		"materials": map[string]interface{}{
+			"img_1": map[string]interface{}{"data": map[string]interface{}{"web_uri": "novel-pic/aaa"}},
+			"img_2": map[string]interface{}{"data": map[string]interface{}{"web_uri": "/novel-pic/bbb"}},
+			"img_3": map[string]interface{}{"data": map[string]interface{}{"md5": "c0ffee"}},
+		},
+		"skeleton": map[string]interface{}{
+			"data": []interface{}{
+				map[string]interface{}{"elementInfo": "img_2"},
+				map[string]interface{}{"key": "img_1"},
+				map[string]interface{}{"id": "img_3"},
+			},
+		},
+	}
+
+	// 页序以 skeleton 引用顺序为准
+	want := []string{
+		"https://p6-novel.byteimg.com/origin/novel-pic/bbb",
+		"https://p6-novel.byteimg.com/origin/novel-pic/aaa",
+		"https://p6-novel.byteimg.com/origin/novel-pic/c0ffee",
+	}
+	got := collectMangaFallbackURIs(payload)
+	if len(got) != len(want) {
+		t.Fatalf("got %d 张 want %d 张: %v", len(got), len(want), got)
+	}
+	for i := range want {
+		if got[i] != want[i] {
+			t.Errorf("[%d] got %s want %s", i, got[i], want[i])
+		}
+	}
+
+	// 无 skeleton 时退化为 materials key 末尾数字排序
+	delete(payload, "skeleton")
+	got = collectMangaFallbackURIs(payload)
+	if got[0] != want[1] || got[1] != want[0] {
+		t.Errorf("key 排序错误: %v", got)
+	}
+}

internal/fqapi/multi_content.go

@@ -1,14 +1,9 @@
 package fqapi
 
 import (
-	"bytes"
-	"compress/zlib"
-	"encoding/base64"
 	"encoding/json"
 	"fanqie/internal/common"
 	"fmt"
-	"io"
-	"sort"
 	"strings"
 	"sync"
 )
@@ -17,57 +12,29 @@ var (
 	multiContentLogger = common.NewLogger("multi_content", "INFO", "")
 )
 
-// handleDecryptTask 处理解密任务
+// handleDecryptTask 处理解密任务（crypt_status 分支见 decodeContentBody）
 func handleDecryptTask(itemID string, itemData map[string]interface{}, keyInfo *KeyInfo, textMode, imageMode bool) (string, map[string]interface{}) {
 	if code, ok := itemData["code"].(float64); !ok || code != 0 {
 		return itemID, itemData
 	}
 
-	contentEncoded, ok := itemData["content"].(string)
+	if _, ok := itemData["content"].(string); !ok {
-	if !ok {
 		return itemID, itemData
 	}
 
-	// 解码content
+	// 解密（含压缩与明文分支）
-	contentBytes, err := base64.StdEncoding.DecodeString(contentEncoded)
+	contentStr, err := decodeContentBody(itemData, keyInfo)
-	if err != nil || len(contentBytes) < 16 {
+	if err != nil || contentStr == "" {
+		// 解密失败保留上游原样（ignore_failed 默认跳过失败章节）
 		return itemID, itemData
 	}
 
-	iv := contentBytes[0:16]
-	encryptedData := contentBytes[16:]
-
-	// 解密
-	if keyInfo == nil {
-		return itemID, itemData
-	}
-
-	keyBytes, _ := base64.StdEncoding.DecodeString(keyInfo.Key)
-	decrypted, err := De(encryptedData, keyBytes, iv)
-	if err != nil {
-		return itemID, itemData
-	}
-
-	// 检查是否需要解压
-	compressStatus, _ := itemData["compress_status"].(float64)
-	if compressStatus != 0 {
-		// zlib解压
-		reader, err := zlib.NewReader(bytes.NewReader(decrypted))
-		if err == nil {
-			decompressed, err := io.ReadAll(reader)
-			reader.Close()
-			if err == nil {
-				decrypted = decompressed
-			}
-		}
-	}
-
 	// 更新内容
 	bodyCopy := make(map[string]interface{})
 	for k, v := range itemData {
 		bodyCopy[k] = v
 	}
-	bodyCopy["content"] = string(decrypted)
+	bodyCopy["content"] = contentStr
 
 	// 缓存
 	cacheData := buildCacheData(bodyCopy)
@@ -75,7 +42,7 @@ func handleDecryptTask(itemID string, itemData map[string]interface{}, keyInfo *
 
 	// 解析内容
 	parser := NewContentParser()
-	bodyCopy["content"] = parser.Parse(string(decrypted), textMode, imageMode)
+	bodyCopy["content"] = parser.Parse(contentStr, textMode, imageMode)
 
 	return itemID, bodyCopy
 }
@@ -121,10 +88,11 @@ func MultiContent(itemIDs interface{}, bookID string, textMode, imageMode, ignor
 	currentKeyInfo := &KeyInfo{
 		Key: item.Key,
 		Ver: item.KeyVer,
+		Ts:  item.KeyTs,
 	}
 	multiContentLogger.Debug(fmt.Sprintf("使用池中设备 ID=%d (depth: %d)", item.ID, depth))
 
-	// 构建参数
+	// 构建参数（form 编码，见 buildSortedQuery 注释）
 	headerWithoutVersion := removeVersionFromHeader(header)
 
 	params := []string{
@@ -133,18 +101,15 @@ func MultiContent(itemIDs interface{}, bookID string, textMode, imageMode, ignor
 		"channel=0",
 		"device_platform=android",
 		"os_version=0",
-		"version_code=66.9",
+		"version_code=" + ClientVersionCode,
 		"book_id=" + bookID,
 		"item_ids=" + itemIDStr,
 		"novel_text_type=1",
 		"req_type=1",
+		fmt.Sprintf("key_register_ts=%d", currentKeyInfo.Ts),
 		headerWithoutVersion,
 	}
-
+	sortedParams := buildSortedQuery(params...)
-	allParams := strings.Join(params, "&")
-	paramList := strings.Split(allParams, "&")
-	sort.Strings(paramList)
-	sortedParams := strings.Join(paramList, "&")
 
 	url := "https://reading.snssdk.com/reading/reader/batch_full/v/?" + sortedParams
 
@@ -205,7 +170,7 @@ func MultiContent(itemIDs interface{}, bookID string, textMode, imageMode, ignor
 					multiContentLogger.Warning("密钥版本不匹配，重新获取密钥")
 					newKeyInfo, err := GetKey(header)
 					if err == nil {
-						UpdateKeyInPool(header, newKeyInfo.Key, newKeyInfo.Ver)
+						UpdateKeyInPool(header, newKeyInfo)
 					} else {
 						// 获取密钥失败，切换设备
 						multiContentLogger.Warning(fmt.Sprintf("获取密钥失败，切换设备重试 (depth: %d)", depth))

internal/fqapi/multi_detail.go

@@ -3,6 +3,7 @@ package fqapi
 import (
 	"fanqie/internal/common"
 	"fmt"
+	"sort"
 	"strings"
 	"sync"
 )
@@ -108,11 +109,41 @@ func chunkArray(arr []string, size int) [][]string {
 
 // HandleGetMultiDetail 处理批量获取书籍详情,详情数据基本不变,缓存 24 小时
 func HandleGetMultiDetail(bookID interface{}) (string, error) {
-	return withCache(fmt.Sprintf("multi_detail_%v", bookID), 86400, func() (string, error) {
+	// 缓存 key 归一化：ID 排序去重，相同集合不同顺序共享缓存
+	ids := normalizeIDList(bookID)
+	if ids == "" {
+		return fetchMultiDetail(bookID)
+	}
+	return withCache("multi_detail_"+ids, 86400, func() (string, error) {
 		return fetchMultiDetail(bookID)
 	})
 }
 
+// normalizeIDList 将 book_id 参数归一化为排序去重后的逗号串
+func normalizeIDList(bookID interface{}) string {
+	var list []string
+	switch v := bookID.(type) {
+	case string:
+		list = strings.Split(v, ",")
+	case []string:
+		list = v
+	default:
+		return ""
+	}
+	seen := make(map[string]bool, len(list))
+	out := make([]string, 0, len(list))
+	for _, id := range list {
+		id = strings.TrimSpace(id)
+		if id == "" || seen[id] {
+			continue
+		}
+		seen[id] = true
+		out = append(out, id)
+	}
+	sort.Strings(out)
+	return strings.Join(out, ",")
+}
+
 func fetchMultiDetail(bookID interface{}) (string, error) {
 	if bookID == nil {
 		return BuildErrorResponse("需要参数 book_id"), nil

internal/fqapi/rank.go

@@ -0,0 +1,77 @@
+package fqapi
+
+import (
+	"fanqie/internal/common"
+	"fmt"
+	"net/url"
+)
+
+var rankLogger = common.NewLogger("rank", "INFO", "")
+
+// rankSDKHosts 免签名榜单接口的可用域名（依次容错）
+var rankSDKHosts = []string{
+	"https://novel.snssdk.com",
+	"https://api.fanqiesdk.com",
+	"https://api-lf.fanqiesdk.com",
+}
+
+const rankSDKUA = "com.ss.android.article.news/7.0.3 (Linux; U; Android 12; zh_CN; Pixel 6)"
+
+// RankTypes 榜单类型
+var RankTypes = map[int]string{
+	10: "推荐榜",
+	11: "完结榜",
+	12: "热搜榜",
+	13: "黑马榜",
+	15: "爆更榜",
+}
+
+// HandleGetRank 处理获取榜单,榜单数据动态,短缓存 10 分钟
+// sideType 见 RankTypes（无效值回退推荐榜）；page 从 1 起，每页 20 本
+func HandleGetRank(sideType, page int) (string, error) {
+	if _, ok := RankTypes[sideType]; !ok {
+		sideType = 10
+	}
+	if page < 1 {
+		page = 1
+	}
+	return withCache(fmt.Sprintf("rank_%d_%d", sideType, page), 600, func() (string, error) {
+		return fetchRank(sideType, page)
+	})
+}
+
+// fetchRank 免签名 SDK 接口获取榜单（无设备/签名依赖，多域名容错）
+func fetchRank(sideType, page int) (string, error) {
+	vals := url.Values{
+		"aid":       {"13"},
+		"type":      {"1"},
+		"side_type": {fmt.Sprintf("%d", sideType)},
+		"offset":    {fmt.Sprintf("%d", page-1)},
+		"limit":     {"20"},
+	}
+	path := "/api/novel/channel/homepage/rank/rank_list/v2/?" + vals.Encode()
+
+	var lastErr error
+	client := common.NewHTTPClient()
+	for _, host := range rankSDKHosts {
+		resp, err := client.Get(host+path, map[string]string{
+			"User-Agent": rankSDKUA,
+			"Accept":     "application/json, text/plain, */*",
+		})
+		if err != nil {
+			lastErr = err
+			continue
+		}
+		respJSON, err := resp.JSON()
+		if err != nil {
+			lastErr = fmt.Errorf("响应解析失败: %w", err)
+			continue
+		}
+		if code, ok := respJSON["code"].(float64); ok && code == 0 {
+			return reencodeUnwrapped(resp.Text), nil
+		}
+		lastErr = fmt.Errorf("code=%.0f msg=%v", respJSON["code"], respJSON["message"])
+	}
+	rankLogger.Error(fmt.Sprintf("获取榜单失败: %v", lastErr))
+	return BuildErrorResponse("获取榜单失败"), lastErr
+}

internal/fqapi/register_key.go

@@ -12,15 +12,13 @@ import (
 	"fmt"
 	"math/rand"
 	"regexp"
-	"sort"
-	"strings"
-	"time"
 )
 
 // KeyInfo 密钥信息
 type KeyInfo struct {
 	Key string `json:"key"`
 	Ver int    `json:"ver"`
+	Ts  int64  `json:"ts"` // 密钥注册时间戳（key_register_ts），随正文请求上传可降低密钥不匹配重试
 }
 
 var (
@@ -154,25 +152,22 @@ func GetKey(header string) (*KeyInfo, error) {
 
 	keyLogger.Info("正在获取密钥...")
 
-	// 构建参数
+	// 构建参数（form 编码：机型含空格等字符时 URL 与签名一致才不会注册失败）
 	params := []string{
 		"aid=1967",
 		"app_name=novelapp",
 		"channel=0",
 		"device_platform=android",
 		"os_version=0",
-		"version_code=5.8.9.32",
+		"version_code=" + ClientVersionCode,
 		header,
 	}
-
+	sortedParams := buildSortedQuery(params...)
-	allParams := strings.Join(params, "&")
-	paramList := strings.Split(allParams, "&")
-	sort.Strings(paramList)
-	sortedParams := strings.Join(paramList, "&")
 
 	// 准备请求体
 	requestBody := map[string]string{
 		"content": content,
+		"keyver":  "1",
 	}
 
 	bodyJSON, _ := json.Marshal(requestBody)
@@ -203,6 +198,12 @@ func GetKey(header string) (*KeyInfo, error) {
 		var respData map[string]interface{}
 		json.Unmarshal(resp.Content, &respData)
 
+		// 上游判定该设备无需解密（正文明文下发），返回空密钥信息由调用方分支处理
+		if code, ok := respData["code"].(float64); ok && int(code) == 500003 {
+			keyLogger.Info("上游标记无需解密（code=500003）")
+			return &KeyInfo{}, nil
+		}
+
 		dataObj, ok := respData["data"].(map[string]interface{})
 		if !ok {
 			return nil, fmt.Errorf("响应格式错误")
@@ -231,12 +232,17 @@ func GetKey(header string) (*KeyInfo, error) {
 		finalKey := base64.StdEncoding.EncodeToString(decryptedKey)
 
 		keyVer, _ := dataObj["keyver"].(float64)
+		keyTs, _ := dataObj["key_register_ts"].(float64)
+		if keyTs == 0 {
+			keyTs, _ = dataObj["register_time"].(float64)
+		}
 		keyInfo = &KeyInfo{
 			Key: finalKey,
 			Ver: int(keyVer),
+			Ts:  int64(keyTs),
 		}
 
-		keyLogger.Info(fmt.Sprintf("密钥获取成功！"))
+		keyLogger.Info("密钥获取成功！")
 
 		return keyInfo, nil
 	}
@@ -248,7 +254,3 @@ func GetKey(header string) (*KeyInfo, error) {
 func GetKeyInfo() *KeyInfo {
 	return keyInfo
 }
-
-func init() {
-	rand.Seed(time.Now().UnixNano())
-}

internal/fqapi/request_log.go

@@ -16,7 +16,7 @@ type RequestLogEntry struct {
 	IP         string `json:"ip"`
 	Method     string `json:"method"`
 	Path       string `json:"path"`
-	Query      string `json:"query"`     // 解码后查询串（含 key，不脱敏）
+	Query      string `json:"query"`     // 解码后查询串（key 参数值已脱敏）
 	Status     int    `json:"status"`
 	DurationMs int64  `json:"duration_ms"`
 	ErrorMsg   string `json:"error_msg"`  // 仅 status>=400 时截断保留

internal/fqapi/search.go

@@ -6,12 +6,22 @@ import (
 	"fanqie/internal/common"
 	"fmt"
 	"net/url"
+	"regexp"
+	"strconv"
+	"time"
 )
 
 var searchLogger = common.NewLogger("search", "INFO", "")
 
-// GetDeviceHeader 获取设备header（需要从外部注入）
+// 搜索分页与上游续传参数（对齐书源 20261012：上游翻页依赖上一页返回的
-var GetDeviceHeader func() string
+// passback/search_id/next_offset/corrected_query 续传，仅传数字 offset 深翻页会拿到重复/错序结果）
+const (
+	searchPageSize     = 10 // 对外每页书数
+	searchMaxUpstreams = 24 // 单次搜索累计上游翻页上限（对齐书源）
+)
+
+// bookIDKeyRe 纯数字 15~20 位关键词按书 ID 直搜详情
+var bookIDKeyRe = regexp.MustCompile(`^\d{15,20}$`)
 
 // HandleBookSearch 处理书籍搜索,搜索结果短缓存 10 分钟,减轻上游压力
 func HandleBookSearch(key string, offset int, tabType int) (string, error) {
@@ -24,21 +34,111 @@ func fetchBookSearch(key string, offset int, tabType int) (string, error) {
 	if key == "" {
 		return BuildErrorResponseWithCode(1, "需要参数 key"), nil
 	}
-
 	if tabType == 0 {
 		tabType = 3
 	}
+	if offset < 0 {
+		offset = 0
+	}
 
-	// 编码查询关键字
+	// 书 ID 直搜：跳过搜索接口直接查详情，精确命中单本
-	encodedKey := url.QueryEscape(key)
+	if bookIDKeyRe.MatchString(key) {
+		return idSearchResult(key)
+	}
 
-	// 使用新的参数构建函数
+	// 累计翻页直到凑够本页书：上游单页 count=20，按 book_id 去重后切出 offset 起的 10 本
-	reqURL := BuildURL("https://reading.snssdk.com/reading/bookapi/search/tab/v/",
+	session := strconv.FormatInt(time.Now().UnixNano(), 10)
-		fmt.Sprintf("tab_type=%d", tabType),
+	var (
-		"update_version_code=58932",
+		rows      []interface{} // 上游搜索行（含 book_data 包装），原样透传
-		"query="+encodedKey,
+		seen      = map[string]bool{}
-		fmt.Sprintf("passback=%d", offset),
+		passback  = "0"
+		searchID  = ""
+		corrected = ""
+		nextOff   = 0
+		hasMore   = true
 	)
+	want := offset + searchPageSize
+
+	for i := 0; i < searchMaxUpstreams && hasMore && len(rows) < want; i++ {
+		params := []string{
+			fmt.Sprintf("tab_type=%d", tabType),
+			"update_version_code=" + ClientVersionCode,
+			"query=" + url.QueryEscape(key),
+			"passback=" + passback,
+			fmt.Sprintf("offset=%d", nextOff),
+			"count=20",
+			fmt.Sprintf("is_first_enter_search=%t", i == 0),
+			"normal_session_id=" + session,
+			"cold_start_session_id=" + session,
+		}
+		if searchID != "" {
+			params = append(params, "search_id="+searchID)
+		}
+		if corrected != "" {
+			params = append(params, "corrected_query="+corrected)
+		}
+
+		tab, err := fetchSearchTab(params, tabType)
+		if err != nil {
+			if i == 0 {
+				return BuildErrorResponseWithCode(1, "搜索请求失败"), err
+			}
+			break // 已有数据时后续页失败，降级返回现有结果
+		}
+		if tab == nil {
+			break
+		}
+
+		if data, ok := tab["data"].([]interface{}); ok {
+			for _, r := range data {
+				row, _ := r.(map[string]interface{})
+				if row == nil {
+					continue
+				}
+				// 行 ID 取 book_data[0].book_id；无包装的行按行本身的 book_id
+				bd, _ := row["book_data"].([]interface{})
+				if len(bd) > 0 {
+					if b, ok := bd[0].(map[string]interface{}); ok {
+						if id := searchRowID(b); id != "" && !seen[id] {
+							seen[id] = true
+							rows = append(rows, row)
+						}
+						continue
+					}
+				}
+				if id := searchRowID(row); id != "" && !seen[id] {
+					seen[id] = true
+					rows = append(rows, row)
+				}
+			}
+		}
+
+		hasMore = searchHasMore(tab["has_more"])
+		nextOff = searchInt(tab["next_offset"])
+		passback = searchStr(tab["passback"])
+		searchID = searchStr(tab["search_id"])
+		corrected = searchStr(tab["corrected_query"])
+	}
+
+	start, end := offset, offset+searchPageSize
+	if start > len(rows) {
+		start = len(rows)
+	}
+	if end > len(rows) {
+		end = len(rows)
+	}
+	return marshalNoEscape(UnwrapJSONStrings(map[string]interface{}{
+		"code":        0,
+		"message":     "SUCCESS",
+		"data":        rows[start:end],
+		"has_more":    hasMore || end < len(rows),
+		"next_offset": offset + searchPageSize,
+	})), nil
+}
+
+// fetchSearchTab 请求一页搜索并返回目标 tab_type 的 tab；nil 表示该页无匹配 tab
+func fetchSearchTab(params []string, tabType int) (map[string]interface{}, error) {
+	reqURL := BuildURL("https://reading.snssdk.com/reading/bookapi/search/tab/v/", params...)
 
 	resp, err := GorgonRequest(reqURL, map[string]interface{}{
 		"method": "GET",
@@ -46,35 +146,61 @@ func fetchBookSearch(key string, offset int, tabType int) (string, error) {
 			"User-Agent": "com.dragon.read",
 		},
 	})
-
 	if err != nil {
 		searchLogger.Error(fmt.Sprintf("搜索请求失败: %v", err))
-		return BuildErrorResponseWithCode(1, "搜索请求失败"), err
+		return nil, err
 	}
 
-	respJSON, err := resp.JSON()
+	// UseNumber 重新解析后按 tab_type 过滤:
-	if err != nil {
+	// 上游 search/tab/v/ 固定返回所有 tab 的 search_tabs;
+	// 大整数 ID 经 float64 重组会丢精度,必须 UseNumber
+	dec := json.NewDecoder(bytes.NewReader(resp.Content))
+	dec.UseNumber()
+	var pageJSON map[string]interface{}
+	if err := dec.Decode(&pageJSON); err != nil {
 		searchLogger.Error(fmt.Sprintf("解析响应失败: %v", err))
-		return BuildErrorResponseWithCode(1, "解析响应失败"), err
+		return nil, fmt.Errorf("解析失败")
+	}
+	if code, _ := pageJSON["code"].(float64); code != 0 {
+		return nil, fmt.Errorf("搜索失败 code=%v", pageJSON["code"])
 	}
 
-	if code, ok := respJSON["code"].(float64); ok && code == 0 {
+	filterSearchTabs(pageJSON, tabType)
-		// 用 UseNumber 重新解析后按 tab_type 过滤:
+	tabs, _ := pageJSON["search_tabs"].([]interface{})
-		// 上游 search/tab/v/ 固定返回所有 tab 的 search_tabs;
+	for _, t := range tabs {
-		// 大整数 ID 经 float64 重组会丢精度,必须 UseNumber
+		m, ok := t.(map[string]interface{})
-		dec := json.NewDecoder(bytes.NewReader(resp.Content))
+		if !ok {
-		dec.UseNumber()
+			continue
-		var numJSON map[string]interface{}
+		}
-		if err := dec.Decode(&numJSON); err != nil {
+		if tt, ok := m["tab_type"].(json.Number); ok {
-			return resp.Text, nil // 解析失败时退回原样转发
+			if v, err := tt.Int64(); err == nil && int(v) == tabType {
+				return m, nil
+			}
 		}
-		filterSearchTabs(numJSON, tabType)
-		unwrapSearchTab(numJSON)
-		UnwrapJSONStrings(numJSON)
-		return ToJSON(numJSON)
 	}
+	return nil, nil
+}
 
-	return BuildErrorResponseWithCode(1, "搜索失败"), nil
+// idSearchResult 书 ID 直搜：复用详情接口（24h 缓存），包成上游搜索行形状（book_data 包装）
+func idSearchResult(bookID string) (string, error) {
+	detailJSON, err := HandleGetDetail(bookID)
+	if err != nil {
+		return BuildErrorResponseWithCode(1, "ID 搜索失败"), err
+	}
+	var detail map[string]interface{}
+	if err := json.Unmarshal([]byte(detailJSON), &detail); err != nil {
+		return detailJSON, nil // 透传上游错误响应
+	}
+	if code, _ := detail["code"].(float64); code != 0 {
+		return detailJSON, nil
+	}
+	return marshalNoEscape(UnwrapJSONStrings(map[string]interface{}{
+		"code":        0,
+		"message":     "SUCCESS",
+		"data":        []interface{}{map[string]interface{}{"book_data": []interface{}{detail["data"]}}},
+		"has_more":    false,
+		"next_offset": 0,
+	})), nil
 }
 
 // filterSearchTabs 按 tab_type 只保留 search_tabs 中匹配的项;无匹配时保留原样
@@ -100,26 +226,44 @@ func filterSearchTabs(respJSON map[string]interface{}, tabType int) {
 	}
 }
 
-// unwrapSearchTab 将过滤后的唯一 tab 展平：去掉 search_tabs 包装，
+// searchRowID 取行的 book_id（UseNumber 下为 json.Number，也可能是字符串）
-// tab 的 data 直接作为顶层 data，并提升分页字段 has_more/next_offset
+func searchRowID(m map[string]interface{}) string {
-func unwrapSearchTab(respJSON map[string]interface{}) {
+	if m == nil {
-	tabs, ok := respJSON["search_tabs"].([]interface{})
+		return ""
-	if !ok || len(tabs) != 1 {
-		return
 	}
-	tab, ok := tabs[0].(map[string]interface{})
+	if s, _ := m["book_id"].(string); s != "" {
-	if !ok {
+		return s
-		return
 	}
-	delete(respJSON, "search_tabs")
+	if n, ok := m["book_id"].(json.Number); ok {
-	delete(respJSON, "selected_tab_idx") // tab 已展平，索引无意义
+		return n.String()
-	delete(respJSON, "server_ab_params") // 上游 AB 实验参数，透传无意义
-	if data, ok := tab["data"]; ok {
-		respJSON["data"] = data
-	}
-	for _, k := range []string{"has_more", "next_offset"} {
-		if v, ok := tab[k]; ok {
-			respJSON[k] = v
-		}
 	}
+	return ""
+}
+
+func searchStr(v interface{}) string {
+	s, _ := v.(string)
+	return s
+}
+
+func searchInt(v interface{}) int {
+	switch t := v.(type) {
+	case json.Number:
+		n, _ := t.Int64()
+		return int(n)
+	case string:
+		n, _ := strconv.Atoi(t)
+		return n
+	}
+	return 0
+}
+
+func searchHasMore(v interface{}) bool {
+	switch t := v.(type) {
+	case bool:
+		return t
+	case json.Number:
+		n, _ := t.Int64()
+		return n != 0
+	}
+	return false
 }

internal/fqapi/shelf.go

@@ -0,0 +1,194 @@
+package fqapi
+
+import (
+	"fanqie/internal/common"
+	"fmt"
+	"strings"
+)
+
+var shelfLogger = common.NewLogger("shelf", "INFO", "")
+
+// HandleBookshelf 获取登录用户书架。个人动态数据不缓存。
+// group 非空时只返回该分组的书；书架接口对无效/过期 sessionid 也返回空书架，无法区分——
+// 空结果时提示重新登录
+func HandleBookshelf(sessionID, group string) (string, error) {
+	if sessionID == "" {
+		return BuildErrorResponse("需要参数 sessionid（在 fanqienovel.com 登录后从浏览器 Cookie 中获取）"), nil
+	}
+
+	resp, err := signedBookAPIGet("/reading/bookapi/bookshelf/info/v/", nil, sessionID)
+	if err != nil {
+		shelfLogger.Error(fmt.Sprintf("获取书架失败: %v", err))
+		return BuildErrorResponse("获取书架失败"), err
+	}
+
+	items, err := bookAPIList(resp, "book_shelf_info")
+	if err != nil {
+		return BuildErrorResponse("获取书架失败: " + err.Error()), nil
+	}
+
+	// 过滤分组并收集 book_id
+	type shelfRow struct {
+		id        string
+		groupName string
+	}
+	rows := make([]shelfRow, 0, len(items))
+	for _, it := range items {
+		m, ok := it.(map[string]interface{})
+		if !ok {
+			continue
+		}
+		id := bookIDOf(m)
+		if id == "" {
+			continue
+		}
+		gn, _ := m["group_name"].(string)
+		if group != "" && gn != group {
+			continue
+		}
+		rows = append(rows, shelfRow{id: id, groupName: gn})
+	}
+
+	if len(rows) == 0 {
+		return BuildErrorResponse("书架为空：sessionid 可能无效或已过期，请重新获取"), nil
+	}
+
+	ids := make([]string, len(rows))
+	for i, row := range rows {
+		ids[i] = row.id
+	}
+	details := detailMapByIDs(ids)
+	result := make([]map[string]interface{}, 0, len(rows))
+	for _, row := range rows {
+		d := details[row.id]
+		if d == nil {
+			d = map[string]interface{}{"book_id": row.id}
+		}
+		d["group_name"] = row.groupName
+		result = append(result, d)
+	}
+
+	return marshalNoEscape(UnwrapJSONStrings(buildCacheData(result))), nil
+}
+
+// HandleReadHistory 获取登录用户阅读历史。个人动态数据不缓存。
+// offset 从 0 起，每页 20 条；每项合并书籍详情并保留原始记录（进度等）于 history 字段
+func HandleReadHistory(sessionID string, offset int) (string, error) {
+	if sessionID == "" {
+		return BuildErrorResponse("需要参数 sessionid（在 fanqienovel.com 登录后从浏览器 Cookie 中获取）"), nil
+	}
+	if offset < 0 {
+		offset = 0
+	}
+
+	resp, err := signedBookAPIGet("/reading/bookapi/read_history/list/v/",
+		[]string{fmt.Sprintf("offset=%d", offset), "book_type=0"}, sessionID)
+	if err != nil {
+		shelfLogger.Error(fmt.Sprintf("获取阅读历史失败: %v", err))
+		return BuildErrorResponse("获取阅读历史失败"), err
+	}
+
+	items, err := bookAPIList(resp, "data_list")
+	if err != nil {
+		return BuildErrorResponse("获取阅读历史失败: " + err.Error()), nil
+	}
+
+	type historyRow struct {
+		id  string
+		raw map[string]interface{}
+	}
+	rows := make([]historyRow, 0, len(items))
+	for _, it := range items {
+		m, ok := it.(map[string]interface{})
+		if !ok {
+			continue
+		}
+		id := bookIDOf(m)
+		if id == "" {
+			continue
+		}
+		rows = append(rows, historyRow{id: id, raw: m})
+	}
+
+	if len(rows) == 0 {
+		return marshalNoEscape(buildCacheData([]interface{}{})), nil
+	}
+
+	ids := make([]string, len(rows))
+	for i, row := range rows {
+		ids[i] = row.id
+	}
+	details := detailMapByIDs(ids)
+	result := make([]map[string]interface{}, 0, len(rows))
+	for _, row := range rows {
+		d := details[row.id]
+		if d == nil {
+			d = map[string]interface{}{"book_id": row.id}
+		}
+		// 原始记录（含阅读进度/时间）挂 history 字段保留
+		d["history"] = row.raw
+		result = append(result, d)
+	}
+
+	return marshalNoEscape(UnwrapJSONStrings(buildCacheData(result))), nil
+}
+
+// signedBookAPIGet 个人书架/历史接口：常规签名请求 + 登录态 Cookie
+func signedBookAPIGet(path string, extraParams []string, sessionID string) (*common.ClientResponse, error) {
+	reqURL := BuildURL("https://reading.snssdk.com"+path, extraParams...)
+	return GorgonRequest(reqURL, map[string]interface{}{
+		"method": "GET",
+		"headers": map[string]string{
+			"User-Agent": "com.dragon.read",
+			"Cookie":     "sessionid=" + sessionID,
+		},
+	})
+}
+
+// bookAPIList 校验上游响应并取出 data 下的指定列表字段
+func bookAPIList(resp *common.ClientResponse, field string) ([]interface{}, error) {
+	respJSON, err := resp.JSON()
+	if err != nil {
+		return nil, fmt.Errorf("响应解析失败: %w", err)
+	}
+	if code, ok := respJSON["code"].(float64); !ok || code != 0 {
+		msg, _ := respJSON["message"].(string)
+		return nil, fmt.Errorf("code=%.0f msg=%s", respJSON["code"], msg)
+	}
+	data, _ := respJSON["data"].(map[string]interface{})
+	items, _ := data[field].([]interface{})
+	return items, nil
+}
+
+// bookIDOf 兼容提取 book_id / book_id_str（数字或字符串）
+func bookIDOf(m map[string]interface{}) string {
+	for _, k := range []string{"book_id_str", "book_id", "bookId"} {
+		switch v := m[k].(type) {
+		case string:
+			if v != "" {
+				return v
+			}
+		case float64:
+			return fmt.Sprintf("%.0f", v)
+		}
+	}
+	return ""
+}
+
+// detailMapByIDs 按 book_id 建立详情映射（复用批量详情接口，分批请求）
+func detailMapByIDs(ids []string) map[string]map[string]interface{} {
+	m := make(map[string]map[string]interface{}, len(ids))
+	for _, chunk := range chunkArray(ids, 100) {
+		list, err := multiDetail(strings.Join(chunk, ","))
+		if err != nil {
+			shelfLogger.Warning(fmt.Sprintf("批量获取详情失败（该批保留 book_id）: %v", err))
+			continue
+		}
+		for _, d := range list {
+			if id, ok := d["book_id"].(string); ok {
+				m[id] = d
+			}
+		}
+	}
+	return m
+}

internal/handlers/book.go

@@ -103,3 +103,74 @@ func HandleMultiDetail(w http.ResponseWriter, r *http.Request) {
 
 	fmt.Fprint(w, result)
 }
+
+// HandleRank 榜单处理（推荐/完结/热搜/黑马/爆更榜，免签名接口）
+func HandleRank(w http.ResponseWriter, r *http.Request) {
+	incrementStat("total", "category")
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+
+	sideType, err := parseIntParam(r.URL.Query().Get("side_type"), "side_type")
+	if err != nil {
+		respondError(w, err.Error(), true)
+		return
+	}
+	page, err := parseIntParam(r.URL.Query().Get("page"), "page")
+	if err != nil {
+		respondError(w, err.Error(), true)
+		return
+	}
+
+	result, err := fqapi.HandleGetRank(sideType, page)
+	if err != nil {
+		respondError(w, "获取榜单失败: "+err.Error(), false)
+		return
+	}
+
+	fmt.Fprint(w, result)
+}
+
+// HandleBookshelf 书架处理（需登录 sessionid）
+func HandleBookshelf(w http.ResponseWriter, r *http.Request) {
+	incrementStat("total", "category")
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+
+	params, err := validateParams(r, "sessionid")
+	if err != nil {
+		respondError(w, err.Error(), true)
+		return
+	}
+
+	result, err := fqapi.HandleBookshelf(params["sessionid"], r.URL.Query().Get("group"))
+	if err != nil {
+		respondError(w, "获取书架失败: "+err.Error(), false)
+		return
+	}
+
+	fmt.Fprint(w, result)
+}
+
+// HandleReadHistory 阅读历史处理（需登录 sessionid）
+func HandleReadHistory(w http.ResponseWriter, r *http.Request) {
+	incrementStat("total", "category")
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+
+	params, err := validateParams(r, "sessionid")
+	if err != nil {
+		respondError(w, err.Error(), true)
+		return
+	}
+
+	offset, err := parseIntParam(r.URL.Query().Get("offset"), "offset")
+	if err != nil {
+		respondError(w, err.Error(), true)
+		return
+	}
+
+	result, err := fqapi.HandleReadHistory(params["sessionid"], offset)
+	if err != nil {
+		respondError(w, "获取阅读历史失败: "+err.Error(), false)
+		return
+	}
+
+	fmt.Fprint(w, result)
+}

internal/handlers/category.go

@@ -32,8 +32,10 @@ func HandleCategoryLanding(w http.ResponseWriter, r *http.Request) {
 	wordNumber := r.URL.Query().Get("word_number")
 	bookStatus := r.URL.Query().Get("book_status")
 	sortBy := r.URL.Query().Get("sort_by")
+	// 新版分类标签自带的筛选项（见 /category-front 返回的 category_landpage_url 参数）
+	selectedItems := r.URL.Query().Get("selected_items")
 
-	result, err := fqapi.HandleCategoryLanding(categoryID, offset, wordNumber, bookStatus, sortBy)
+	result, err := fqapi.HandleCategoryLanding(categoryID, offset, wordNumber, bookStatus, sortBy, selectedItems)
 	if err != nil {
 		respondError(w, "获取分类详情失败: "+err.Error(), false)
 		return

internal/handlers/common.go

@@ -270,7 +270,8 @@ func LogRequestMiddleware(handler http.HandlerFunc) http.HandlerFunc {
 	}
 }
 
-// decodedQuery 重组解码后的查询串（keyword=%E6%B5%8B → keyword=测），日志可读
+// decodedQuery 重组解码后的查询串（keyword=%E6%B5%8B → keyword=测），日志可读；
+// key 参数值脱敏（访问密钥不落日志）
 // ponytail: map 遍历乱序、%26 解码后与分隔符同名 —— 展示用途可接受
 func decodedQuery(r *http.Request) string {
 	vals := r.URL.Query() // 已解码
@@ -280,6 +281,9 @@ func decodedQuery(r *http.Request) string {
 	parts := make([]string, 0, len(vals))
 	for k, vs := range vals {
 		for _, v := range vs {
+			if strings.EqualFold(k, "key") && v != "" {
+				v = "***"
+			}
 			parts = append(parts, k+"="+v)
 		}
 	}

openapi.yaml

@@ -577,6 +577,7 @@ paths:
       summary: 获取漫画内容
       description: |
         返回漫画章节内容,图片经解密处理。
+        设备池签名路线全部失败时自动降级 wkbrowser 免签名兜底(直接返回原图直链,响应附 `source: wkbrowser`)。
         输出模式 `output` 优先于配置 `fanqie.manga.output_mode`:
         - `url`: 返回原始图片 URL 数组(不可用:链接 404 且内容加密,仅作上游原始信息展示)
         - `proxy`: 返回本地代理 URL(/manga/image/{item_id}/{index})——推荐,先调本接口再访问代理 URL(缓存 5 分钟)
@@ -710,6 +711,10 @@ paths:
           in: query
           description: 排序方式,透传上游(0=默认)
           schema: { type: integer, default: 0 }
+        - name: selected_items
+          in: query
+          description: 新版分类标签自带筛选项(从 /category-front 返回的 category_landpage_url 参数中获取),透传上游
+          schema: { type: string }
       responses:
         "200":
           description: 分类书籍列表(上游转发)
@@ -721,6 +726,85 @@ paths:
           $ref: "#/components/responses/BadRequest"
         "500":
           $ref: "#/components/responses/ServerError"
+  /rank:
+    get:
+      tags: [榜单与个人数据]
+      summary: 获取书籍榜单
+      description: 免签名接口,支持五种榜单,每页 20 本,短缓存 10 分钟。
+      operationId: getRank
+      parameters:
+        - name: side_type
+          in: query
+          description: 榜单类型
+          schema:
+            type: integer
+            default: 10
+            enum: [10, 11, 12, 13, 15]
+            x-enum-varnames: [推荐榜, 完结榜, 热搜榜, 黑马榜, 爆更榜]
+        - name: page
+          in: query
+          description: 页码,从 1 起
+          schema: { type: integer, default: 1, minimum: 1 }
+      responses:
+        "200":
+          description: 榜单书籍列表(上游转发,data.result 为书籍数组)
+          content:
+            application/json:
+              schema: { $ref: "#/components/schemas/UpstreamResponse" }
+        "500":
+          $ref: "#/components/responses/ServerError"
+  /bookshelf:
+    get:
+      tags: [榜单与个人数据]
+      summary: 获取我的书架
+      description: 需要番茄网页版登录态;每本书合并详情数据并附带 group_name。个人动态数据不缓存。
+      operationId: getBookshelf
+      parameters:
+        - name: sessionid
+          in: query
+          required: true
+          description: 番茄网页版(fanqienovel.com)登录后的 Cookie sessionid
+          schema: { type: string }
+        - name: group
+          in: query
+          description: 按分组过滤,为空返回全部
+          schema: { type: string }
+      responses:
+        "200":
+          description: 书架书籍列表(data 为数组,每项含书籍详情 + group_name)
+          content:
+            application/json:
+              schema: { $ref: "#/components/schemas/UpstreamResponse" }
+        "400":
+          $ref: "#/components/responses/BadRequest"
+        "500":
+          $ref: "#/components/responses/ServerError"
+  /read-history:
+    get:
+      tags: [榜单与个人数据]
+      summary: 获取阅读历史
+      description: 需要番茄网页版登录态;每页 20 条,每项合并书籍详情并保留原始记录(含阅读进度)于 history 字段。个人动态数据不缓存。
+      operationId: getReadHistory
+      parameters:
+        - name: sessionid
+          in: query
+          required: true
+          description: 番茄网页版(fanqienovel.com)登录后的 Cookie sessionid
+          schema: { type: string }
+        - name: offset
+          in: query
+          description: 偏移量,默认 0,每页 20 条
+          schema: { type: integer, default: 0, minimum: 0 }
+      responses:
+        "200":
+          description: 阅读历史列表(data 为数组)
+          content:
+            application/json:
+              schema: { $ref: "#/components/schemas/UpstreamResponse" }
+        "400":
+          $ref: "#/components/responses/BadRequest"
+        "500":
+          $ref: "#/components/responses/ServerError"
   /emoji/{file}:
     get:
       tags: [静态资源]

shareBookSource.json

@@ -1,68 +0,0 @@
-[
-  {
-    "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
-  }
-]