koishi-plugin-kkk 1.0.0

package/src/karin/platform/douyin/push.ts

@@ -0,0 +1,1241 @@
+import fs from 'node:fs'
+
+import type { DouyinSearchResponse } from '@ikenxuan/amagi'
+import type { DouyinUserListData } from '@template/template/douyin/userlist/components/types'
+import { format } from 'date-fns'
+import type { AdapterType, Elements, ImageElement, Message } from 'node-karin'
+import karin, { common, logger, segment } from 'node-karin'
+
+import {
+  Base,
+  baseHeaders,
+  buildGoogleMotionPhoto,
+  cleanOldDynamicCache,
+  Common,
+  douyinDB,
+  downloadFile,
+  downLoadFileOptions,
+  downloadVideo,
+  fileInfo,
+  type LiveImageMergeOptions,
+  loopVideoWithTransition,
+  Networks,
+  processLocalImageFile,
+  processImageUrl,
+  Render
+} from '@/module'
+import { Config } from '@/module/utils/Config'
+import { DouyinIdData, buildDouyinPlayUrl, douyinProcessVideos, type dyVideo, getDouyinID } from '@/platform/douyin'
+import type { DouyinListItem } from '@/platform/douyin/types'
+import { getDouyinLiveImageSendPolicy, getWorkTypeDisplayName, getWorkTypeInfo } from '@/platform/douyin/workType'
+import type { douyinPushItem } from '@/types/config/pushlist'
+
+import { processFavoriteList } from './push/favorite'
+import { processLiveStream } from './push/live'
+import { processPostList } from './push/post'
+import { processRecommendList } from './push/recommend'
+import { renderFavoriteImage, renderLiveImage, renderRecommendImage, renderWorkImage } from './push/render'
+import { type DouyinPushItem, type DouyinWorkPushItem, type WillBePushList } from './push/types'
+
+// Re-export types for backward compatibility
+export type { DouyinPushItem, DouyinWorkPushItem }
+
+const douyinBaseHeaders: downLoadFileOptions['headers'] = {
+  ...baseHeaders,
+  Referer: 'https://www.douyin.com',
+  Cookie: Config.amagi.cookies.douyin
+}
+
+export class DouYinpush extends Base {
+  private force = false
+  /**
+   *
+   * @param e  事件Message
+   * @param force 是否强制推送
+   * @default false
+   * @returns
+   */
+  constructor(e = {} as Message, force: boolean = false) {
+    super(e)
+    this.headers!.Referer = 'https://www.douyin.com'
+    this.headers!.Cookie = Config.amagi.cookies.douyin
+    this.force = force
+  }
+
+  private injectBotToEventForRender(targets: Array<{ groupId: string; botId: string }>): void {
+    const targetBotId = targets.find((item) => item.botId)?.botId
+    if (!targetBotId) return
+
+    const bot = karin.getBot(targetBotId) as AdapterType | undefined
+    if (!bot) return
+
+    const eventWithBot = this.e as Message & { bot?: AdapterType; selfId?: string }
+    eventWithBot.bot = bot
+    eventWithBot.selfId = eventWithBot.selfId ?? targetBotId
+  }
+
+  /**
+   * 执行主要的操作流程
+   */
+  async action() {
+    await this.syncConfigToDatabase()
+
+    // 清理旧的作品缓存记录
+    const deletedCount = await cleanOldDynamicCache('douyin')
+    if (deletedCount > 0) {
+      logger.info(`已清理 ${deletedCount} 条过期的抖音作品缓存记录`)
+    }
+
+    // 检查备注信息
+    if (await this.checkremark()) return true
+
+    // 检查并补全配置文件中缺失的字段
+    await this.ensureConfigFields(Config.pushlist.douyin)
+
+    // 获取已注册的 bot 列表，过滤未注册的 bot
+    const registeredBotIds = karin.getAllBotID()
+    const filteredPushList = this.filterPushListByRegisteredBots(Config.pushlist.douyin, registeredBotIds)
+
+    if (filteredPushList.length === 0) {
+      // 推送列表本来就是空的属正常情况，别刷 warn（用户反馈日志一直被它刷屏）
+      if ((Config.pushlist as any).douyin?.length) {
+        logger.warn('推送列表里的机器人都不在线，本次跳过抖音推送')
+      } else {
+        logger.debug('抖音推送列表为空，跳过')
+      }
+      return true
+    }
+
+    const data = await this.getDynamicList(filteredPushList)
+
+    if (Object.keys(data).length === 0) return true
+
+    if (this.force) return await this.forcepush(data)
+    else return await this.getdata(data)
+  }
+
+  /**
+   * 检查并补全配置文件中缺失的字段
+   * @param pushList 推送配置列表
+   */
+  private async ensureConfigFields(pushList: douyinPushItem[]): Promise<void> {
+    if (!pushList || pushList.length === 0) return
+
+    let hasChanges = false
+
+    for (const item of pushList) {
+      // 检查并补全 sec_uid 字段
+      if (!item.sec_uid && item.short_id) {
+        try {
+          logger.info(`自动获取用户 ${item.remark || item.short_id} 的 sec_uid`)
+          const searchResult = await this.amagi.douyin.fetcher.searchContent({
+            query: item.short_id,
+            type: 'user'
+          })
+
+          // 在搜索结果中查找匹配的用户
+          let matchedUser = null
+          for (const userItem of searchResult.data.user_list) {
+            const currentDouyinId = userItem.user_info.unique_id || userItem.user_info.short_id
+            if (currentDouyinId === item.short_id) {
+              matchedUser = userItem.user_info
+              break
+            }
+          }
+
+          if (matchedUser?.sec_uid) {
+            item.sec_uid = matchedUser.sec_uid
+            hasChanges = true
+            logger.info(`已为 ${item.remark || item.short_id} 补全 sec_uid: ${item.sec_uid}`)
+          } else {
+            logger.warn(`无法获取用户 ${item.short_id} 的 sec_uid`)
+          }
+        } catch (error) {
+          logger.error(`获取 ${item.short_id} 的 sec_uid 失败: ${error}`)
+        }
+      }
+
+      // 检查并补全 pushTypes 字段
+      if (!item.pushTypes || item.pushTypes.length === 0) {
+        item.pushTypes = ['post', 'live', 'favorite', 'recommend']
+        hasChanges = true
+        logger.info(`为用户 ${item.remark ?? item.sec_uid} 自动补全推送类型：作品列表、直播、收藏、推荐`)
+      }
+
+      // 检查并补全 switch 字段
+      if (item.switch === undefined) {
+        item.switch = true
+        hasChanges = true
+      }
+    }
+
+    // 如果有修改，保存到配置文件
+    if (hasChanges) {
+      Config.Modify('pushlist', 'douyin', pushList)
+      logger.info('已自动补全配置文件中缺失的字段并保存')
+    }
+  }
+
+  /**
+   * 根据已注册的 bot 列表过滤推送配置
+   * @param pushList 原始推送配置列表
+   * @param registeredBotIds 已注册的 bot ID 列表
+   * @returns 过滤后的推送配置列表
+   */
+  private filterPushListByRegisteredBots(pushList: douyinPushItem[], registeredBotIds: string[]): douyinPushItem[] {
+    if (!pushList || pushList.length === 0) return []
+
+    const registeredSet = new Set(registeredBotIds)
+    const filteredList: douyinPushItem[] = []
+
+    for (const item of pushList) {
+      // 过滤 group_id 中未注册的 bot
+      const filteredGroupIds = item.group_id.filter((groupWithBot) => {
+        const botId = groupWithBot.split(':')[1]
+        const isRegistered = registeredSet.has(botId)
+        if (!isRegistered) {
+          logger.debug(`Bot ${botId} 未注册，跳过群组 ${groupWithBot.split(':')[0]} 的推送`)
+        }
+        return isRegistered
+      })
+
+      // 如果过滤后还有有效的群组，则保留该订阅项
+      if (filteredGroupIds.length > 0) {
+        filteredList.push({
+          ...item,
+          group_id: filteredGroupIds
+        })
+      } else {
+        logger.debug(`用户 ${item.remark ?? item.sec_uid} 的所有推送目标 bot 均未注册，跳过`)
+      }
+    }
+
+    return filteredList
+  }
+
+  /**
+   * 同步配置文件中的订阅信息到数据库
+   */
+  async syncConfigToDatabase() {
+    // 如果配置文件中没有抖音推送列表，直接返回
+    if (!Config.pushlist.douyin || Config.pushlist.douyin.length === 0) {
+      return
+    }
+
+    await douyinDB.syncConfigSubscriptions(Config.pushlist.douyin)
+  }
+
+  async getdata(data: WillBePushList) {
+    if (Object.keys(data).length === 0) return true
+
+    for (const awemeId in data) {
+      const pushItem = data[awemeId]
+      const actualAwemeId = awemeId.replace(/^(post|favorite|recommend|live)_/, '') // 移除推送类型前缀
+      const shareUrl =
+        pushItem.pushType === 'live'
+          ? `https://live.douyin.com/${pushItem.Detail_Data.room_data?.owner.web_rid}`
+          : (pushItem.Detail_Data.share_url ?? `https://www.douyin.com/video/${actualAwemeId}`)
+      let pushTypeLabel: string
+      switch (pushItem.pushType) {
+        case 'post':
+          pushTypeLabel = '作品列表'
+          break
+        case 'favorite':
+          pushTypeLabel = '喜欢列表'
+          break
+        case 'recommend':
+          pushTypeLabel = '推荐列表'
+          break
+        default:
+          pushTypeLabel = '直播'
+          break
+      }
+
+      logger.mark(`
+        ${logger.blue('开始处理并渲染抖音动态图片')}
+        ${logger.blue('博主')}: ${logger.green(pushItem.remark)} 
+        ${logger.blue('推送类型')}: ${logger.magenta(pushTypeLabel)}
+        ${logger.cyan('作品id')}：${logger.yellow(actualAwemeId)}
+        ${logger.cyan('访问地址')}：${logger.green('https://www.douyin.com/video/' + actualAwemeId)}
+        ${logger.cyan('分享链接')}: ${logger.green(shareUrl)}
+        `)
+
+      const Detail_Data = pushItem.Detail_Data
+      const workTypeInfo = getWorkTypeInfo(Detail_Data)
+      const skip = await skipDynamic(pushItem)
+      if (skip) {
+        logger.warn(`作品 https://www.douyin.com/video/${actualAwemeId} 已被处理，跳过`)
+      }
+      let img: ImageElement[] = []
+      let iddata: DouyinIdData = { type: 'one_work' }
+      /** 按画质配置选中、即将下载发送的那一路视频源 */
+      let selectedVideo: dyVideo | null = null
+      this.injectBotToEventForRender(pushItem.targets)
+
+      if (!skip) {
+        iddata = await getDouyinID(this.e, shareUrl, false)
+      }
+
+      if (!skip) {
+        // 画质选档必须早于渲染和分享链接拼接：卡片上展示的清晰度要和后面实际下载的那一路视频源完全一致，
+        // 否则会出现「卡片写 4K、实际下载 720p」的错位。
+        if (pushItem.pushType !== 'live' && workTypeInfo.isVideo && pushItem.Detail_Data.video?.bit_rate?.length) {
+          selectedVideo = douyinProcessVideos(pushItem.Detail_Data.video.bit_rate, Config.douyin.videoQuality)[0]
+        }
+
+        let workShareLink: string | undefined
+        if (pushItem.pushType !== 'live') {
+          if (workTypeInfo.isArticle) {
+            workShareLink = `https://www.douyin.com/article/${actualAwemeId}`
+          } else if (workTypeInfo.isImage) {
+            // 图文和合辑使用无追踪参数的短链接，降低二维码密度并提高扫描识别率。
+            workShareLink = `https://www.douyin.com/note/${actualAwemeId}`
+          } else if (Config.douyin.push.shareType === 'web') {
+            // 视频同样用无追踪参数的规范链接：share_url 302 之后只是多出一串追踪参数，白搭一次网络请求还会拉高二维码密度
+            workShareLink = `https://www.douyin.com/video/${actualAwemeId}`
+          } else {
+            // 直链模式：优先用选档后的视频源拼播放地址，二维码内容与卡片展示的清晰度一致
+            const playAddr = selectedVideo?.play_addr ?? pushItem.Detail_Data.video?.play_addr
+            workShareLink = playAddr ? buildDouyinPlayUrl(playAddr) : `https://www.douyin.com/video/${actualAwemeId}`
+          }
+        }
+
+        switch (pushItem.pushType) {
+          case 'live': {
+            if (!pushItem.Detail_Data.room_data || !pushItem.Detail_Data.live_data) break
+            img = await renderLiveImage({
+              e: this.e,
+              Detail_Data: pushItem.Detail_Data,
+              dynamicTypeLabel: '直播动态推送'
+            })
+            break
+          }
+
+          case 'favorite': {
+            img = await renderFavoriteImage({
+              e: this.e,
+              Detail_Data: pushItem.Detail_Data,
+              create_time: pushItem.create_time,
+              shareLink: workShareLink!,
+              remark: pushItem.remark
+            })
+            break
+          }
+
+          case 'recommend': {
+            img = await renderRecommendImage({
+              e: this.e,
+              Detail_Data: pushItem.Detail_Data,
+              create_time: pushItem.create_time,
+              shareLink: workShareLink!,
+              remark: pushItem.remark
+            })
+            break
+          }
+
+          case 'post':
+          default: {
+            img = await renderWorkImage({
+              e: this.e,
+              Detail_Data: pushItem.Detail_Data,
+              create_time: pushItem.create_time,
+              shareLink: workShareLink!,
+              videoSource: selectedVideo
+            })
+            break
+          }
+        }
+      }
+
+      // 遍历目标群组，并发送消息
+      for (const target of pushItem.targets) {
+        let status = { message_id: '' }
+        const { groupId, botId } = target
+
+        if (!skip) {
+          const Contact = karin.contactGroup(groupId)
+
+          // 为当前目标注入 bot，后续解析下载沿用该 bot 身份
+          const bot = karin.getBot(botId) as AdapterType
+          const eventWithBot = this.e as Message & { bot?: AdapterType; selfId?: string }
+          eventWithBot.bot = bot
+          eventWithBot.selfId = botId
+          const pushImg = img ?? []
+
+          // 仅 QQ 官方机器人支持按钮：非直播作品在卡片末尾追加「解析」回调按钮，点击后下发 #解析 + 分享链接
+          const parseButton =
+            bot?.adapter?.name === 'QQ Official Bot' && pushItem.pushType !== 'live' && pushItem.Detail_Data.share_url
+              ? [
+                  segment.button([
+                    { text: '解析', callback: true, data: `#解析${pushItem.Detail_Data.share_url}` },
+                    { text: '帮助', callback: true, data: `#kkk帮助` }
+                  ])
+                ]
+              : []
+
+          // 发送消息
+          status = await karin.sendMsg(botId, Contact, [...pushImg, ...parseButton])
+
+          // 如果是直播推送，更新直播状态
+          if (pushItem.pushType === 'live' && 'room_data' in pushItem.Detail_Data && status.message_id) {
+            await douyinDB.updateLiveStatus(pushItem.sec_uid, true)
+          }
+
+          // 是否一同解析该新作品？（直播推送没有可解析的作品内容）
+          if (pushItem.pushType !== 'live' && Config.douyin.push.parsedynamic && status.message_id) {
+            // 收窄为作品类推送的作品详情
+            const Detail_Data = pushItem.Detail_Data
+            logger.debug(`开始解析作品，类型为：${getWorkTypeDisplayName(workTypeInfo)}`)
+            // 如果新作品是视频
+            if (workTypeInfo.isVideo && Detail_Data.video) {
+              /** 默认视频下载地址 */
+              let downloadUrl = buildDouyinPlayUrl(Detail_Data.video.play_addr)
+              // 根据配置文件自动选择分辨率
+              logger.debug(`开始排除不符合条件的视频分辨率；\n
+                    共拥有${logger.yellow(Detail_Data.video.bit_rate.length)}个视频源\n
+                    视频ID：${logger.green(Detail_Data.aweme_id)}\n
+                    分享链接：${logger.green(Detail_Data.share_url)}
+                    `)
+              // 复用渲染前已选好的视频源，卡片展示的清晰度与实际下载的必然一致
+              const videoObj = selectedVideo ?? douyinProcessVideos(Detail_Data.video.bit_rate, Config.douyin.videoQuality)[0]
+              logger.debug('获取精确下载地址')
+              downloadUrl = await new Networks({
+                url: videoObj.play_addr.url_list[0],
+                headers: douyinBaseHeaders
+              }).getLongLink()
+              // 下载视频
+              await downloadVideo(
+                this.e,
+                {
+                  video_url: downloadUrl,
+                  title: { timestampTitle: `tmp_${Date.now()}.mp4`, originTitle: `${Detail_Data.desc}.mp4` }
+                },
+                { active: true, activeOption: { uin: botId, group_id: groupId } }
+              )
+            } else if (workTypeInfo.isImage && iddata.type === 'one_work') {
+              // 如果新作品是图集或合辑
+              // 判断是否为合辑（is_slides）
+              const isSlides = Detail_Data.is_slides === true
+
+              if (isSlides && Detail_Data.images) {
+                // 合辑处理逻辑
+                const images: Elements[] = []
+                const temp: fileInfo[] = []
+                let hasGeneratedLivePhoto = false // 标记是否生成了实况图
+
+                /** 下载 BGM（如果存在） */
+                let liveimgbgm: fileInfo | null = null
+                let bgmContext: LiveImageMergeOptions['context'] | null = null
+                const mergeMode = Config.douyin.liveImageMergeMode ?? 'independent'
+
+                if (Detail_Data.music) {
+                  let mp3Path = ''
+                  // 该声音由于版权原因在当前地区不可用
+                  if (Detail_Data.music.play_url.uri === '') {
+                    const extraData = JSON.parse(Detail_Data.music.extra)
+                    mp3Path = extraData.original_song_url
+                  } else {
+                    mp3Path = Detail_Data.music.play_url.uri
+                  }
+
+                  liveimgbgm = await downloadFile(mp3Path, {
+                    title: `Douyin_tmp_A_${Date.now()}.mp3`,
+                    headers: douyinBaseHeaders
+                  })
+                  temp.push(liveimgbgm)
+                }
+
+                const images1 = Detail_Data.images ?? []
+                if (!images1.length) {
+                  logger.debug('未获取到合辑的图片数据')
+                }
+
+                for (const [index, item] of images1.entries()) {
+                  // 静态图片，clip_type为2或undefined
+                  if (item.clip_type === 2 || item.clip_type === undefined) {
+                    const imageUrl = await processImageUrl(item.url_list[0], Detail_Data.desc, index)
+                    images.push(segment.image(imageUrl))
+                    continue
+                  }
+
+                  /** 动图/短片 */
+                  const livePlayAddr = item.video?.play_addr_h264
+                  if (!livePlayAddr?.uri) {
+                    logger.warn(`合辑第 ${index + 1} 个动态媒体缺少视频源，跳过`)
+                    continue
+                  }
+                  const liveimg = await downloadFile(buildDouyinPlayUrl(livePlayAddr), {
+                    title: `Douyin_tmp_V_${Date.now()}.mp4`,
+                    headers: douyinBaseHeaders
+                  })
+
+                  if (liveimg.filepath) {
+                    const outputPath = Common.tempDri.video + `Douyin_Result_${Date.now()}.mp4`
+                    const loopCount = item.clip_type === 4 ? 1 : 3
+                    let staticImgPath = ''
+                    if (item.url_list?.[0]) {
+                      const staticImg = await downloadFile(item.url_list[0], {
+                        title: `Douyin_static_${Date.now()}_${index}.jpg`,
+                        headers: douyinBaseHeaders,
+                        filepath: Common.tempDri.images + `Douyin_static_${Date.now()}_${index}.jpg`
+                      })
+                      if (staticImg.filepath) {
+                        temp.push({ filepath: staticImg.filepath, totalBytes: 0 })
+                      }
+                      staticImgPath = staticImg.filepath ?? ''
+                    }
+
+                    const { shouldGenerateVideo, shouldGenerateLivePhoto } = getDouyinLiveImageSendPolicy(
+                      item.clip_type,
+                      Config.app.livePhotoMode ?? 'video_and_livephoto'
+                    )
+
+                    // 生成视频
+                    if (shouldGenerateVideo) {
+                      const transitionEnabled = loopCount > 1 && Boolean(staticImgPath)
+                      const safeStaticPath = staticImgPath || liveimg.filepath
+                      const result = await loopVideoWithTransition({
+                        inputPath: liveimg.filepath,
+                        outputPath,
+                        loopCount,
+                        staticImagePath: safeStaticPath,
+                        transitionEnabled,
+                        bgmPath: liveimgbgm?.filepath,
+                        mergeMode,
+                        context: bgmContext ?? undefined
+                      })
+                      const success = result.success
+                      if (mergeMode === 'continuous' && result.context) {
+                        bgmContext = result.context
+                      }
+
+                      if (success) {
+                        const filePath = Common.tempDri.video + `tmp_${Date.now()}.mp4`
+                        fs.renameSync(outputPath, filePath)
+                        logger.mark(`视频文件重命名完成: ${outputPath.split('/').pop()} -> ${filePath.split('/').pop()}`)
+                        temp.push({ filepath: filePath, totalBytes: 0 })
+                        const videoPath =
+                          Config.app.videoSendMode === 'base64'
+                            ? `base64://${fs.readFileSync(filePath).toString('base64')}`
+                            : `file://${filePath}`
+                        images.push(segment.video(videoPath))
+                      }
+                    }
+
+                    // 生成实况图（clip_type === 5 是 livePhoto）
+                    if (shouldGenerateLivePhoto && item.clip_type === 5 && item.url_list?.[0]) {
+                      let hasPushedMotionPhotoCover = false
+                      if (staticImgPath) {
+                        const motionPhotoCoverPath =
+                          Common.tempDri.images + `MVIMG_${format(new Date(), 'yyyyMMdd_HHmmss_SSS')}_${index}.jpg`
+                        const motionPhotoCreated = await buildGoogleMotionPhoto({
+                          imagePath: staticImgPath,
+                          videoPath: liveimg.filepath,
+                          outputPath: motionPhotoCoverPath
+                        })
+                        if (motionPhotoCreated) {
+                          temp.push({ filepath: motionPhotoCoverPath, totalBytes: 0 })
+                          const motionPhotoCover = processLocalImageFile(motionPhotoCoverPath)
+                          images.push(segment.image(motionPhotoCover))
+                          hasPushedMotionPhotoCover = true
+                        }
+                      }
+                      if (!hasPushedMotionPhotoCover) {
+                        const imageUrl = await processImageUrl(item.url_list[0], Detail_Data.desc, index)
+                        images.push(segment.image(imageUrl))
+                      } else {
+                        hasGeneratedLivePhoto = true // 标记已生成实况图
+                      }
+                    }
+
+                    logger.mark('正在尝试删除缓存文件')
+                    await Common.removeFile(liveimg.filepath, true)
+                  }
+                }
+
+                // 如果生成了实况图，添加提示文字
+                if (hasGeneratedLivePhoto) {
+                  const tipImg = await Render(this.e, 'other/live-photo-tip', {
+                    title: '实况照片已生成',
+                    description: '保存原图到相册即可识别为实况图'
+                  })
+                  images.push(...tipImg)
+                }
+
+                const bot = karin.getBot(botId) as AdapterType
+                try {
+                  if (images.length === 0) {
+                    logger.warn(`抖音合辑推送解析未生成可发送内容，aweme_id=${Detail_Data.aweme_id}`)
+                  } else {
+                    const Element = common.makeForward(images, botId, bot.account.name)
+                    await bot.sendForwardMsg(Contact, Element, {
+                      source: '合辑内容',
+                      summary: `查看${Element.length}张图片/视频消息`,
+                      prompt: '抖音合辑解析结果',
+                      news: [{ text: '点击查看解析结果' }]
+                    })
+                  }
+                } catch (error) {
+                  logger.error(`发送合辑失败: ${error}`)
+                } finally {
+                  for (const item of temp) {
+                    await Common.removeFile(item.filepath, true)
+                  }
+                }
+              } else if (Detail_Data.images) {
+                // 普通图集处理逻辑
+                // 检查是否包含 live 图（clip_type !== 2 且 clip_type !== undefined）
+                const hasLiveImage = Detail_Data.images.some((item) => item.clip_type !== 2 && item.clip_type !== undefined)
+
+                if (hasLiveImage) {
+                  // 包含 live 图，需要特殊处理
+                  const processedImages: Elements[] = []
+                  const temp: fileInfo[] = []
+                  let hasGeneratedLivePhoto = false // 标记是否生成了实况图
+
+                  /** 下载 BGM（如果存在） */
+                  let liveimgbgm: fileInfo | null = null
+                  let bgmContext: LiveImageMergeOptions['context'] | null = null
+                  const mergeMode = Config.douyin.liveImageMergeMode ?? 'independent'
+
+                  if (Detail_Data.music) {
+                    let mp3Path = ''
+                    if (Detail_Data.music.play_url.uri === '') {
+                      const extraData = JSON.parse(Detail_Data.music.extra)
+                      mp3Path = extraData.original_song_url
+                    } else {
+                      mp3Path = Detail_Data.music.play_url.uri
+                    }
+
+                    liveimgbgm = await downloadFile(mp3Path, {
+                      title: `Douyin_tmp_A_${Date.now()}.mp3`,
+                      headers: douyinBaseHeaders
+                    })
+                    temp.push(liveimgbgm)
+                  }
+
+                  for (const [index, item] of Detail_Data.images.entries()) {
+                    // 静态图片，clip_type为2或undefined
+                    if (item.clip_type === 2 || item.clip_type === undefined) {
+                      const image_url = item.url_list[2] ?? item.url_list[1]
+                      if (!image_url) continue
+                      const imageUrl = await processImageUrl(image_url, Detail_Data.desc, index)
+                      processedImages.push(segment.image(imageUrl))
+                      continue
+                    }
+
+                    /** live 图 */
+                    const livePlayAddr = item.video?.play_addr_h264
+                    if (!livePlayAddr?.uri) {
+                      logger.warn(`图集第 ${index + 1} 个动态媒体缺少视频源，跳过`)
+                      continue
+                    }
+                    const liveimg = await downloadFile(buildDouyinPlayUrl(livePlayAddr), {
+                      title: `Douyin_tmp_V_${Date.now()}.mp4`,
+                      headers: douyinBaseHeaders
+                    })
+
+                    if (liveimg.filepath) {
+                      const outputPath = Common.tempDri.video + `Douyin_Result_${Date.now()}.mp4`
+                      const loopCount = item.clip_type === 4 ? 1 : 3
+                      let staticImgPath = ''
+                      if (item.url_list?.[0]) {
+                        const staticImg = await downloadFile(item.url_list[0], {
+                          title: `Douyin_static_${Date.now()}_${index}.jpg`,
+                          headers: douyinBaseHeaders,
+                          filepath: Common.tempDri.images + `Douyin_static_${Date.now()}_${index}.jpg`
+                        })
+                        if (staticImg.filepath) {
+                          temp.push({ filepath: staticImg.filepath, totalBytes: 0 })
+                        }
+                        staticImgPath = staticImg.filepath ?? ''
+                      }
+
+                      const { shouldGenerateVideo, shouldGenerateLivePhoto } = getDouyinLiveImageSendPolicy(
+                        item.clip_type,
+                        Config.app.livePhotoMode ?? 'video_and_livephoto'
+                      )
+
+                      // 生成视频
+                      if (shouldGenerateVideo) {
+                        const transitionEnabled = loopCount > 1 && Boolean(staticImgPath)
+                        const safeStaticPath = staticImgPath || liveimg.filepath
+                        const result = await loopVideoWithTransition({
+                          inputPath: liveimg.filepath,
+                          outputPath,
+                          loopCount,
+                          staticImagePath: safeStaticPath,
+                          transitionEnabled,
+                          bgmPath: liveimgbgm?.filepath,
+                          mergeMode,
+                          context: bgmContext ?? undefined
+                        })
+                        const success = result.success
+                        if (mergeMode === 'continuous' && result.context) {
+                          bgmContext = result.context
+                        }
+
+                        if (success) {
+                          const filePath = Common.tempDri.video + `tmp_${Date.now()}.mp4`
+                          fs.renameSync(outputPath, filePath)
+                          logger.mark(`视频文件重命名完成: ${outputPath.split('/').pop()} -> ${filePath.split('/').pop()}`)
+                          temp.push({ filepath: filePath, totalBytes: 0 })
+                          const videoPath =
+                            Config.app.videoSendMode === 'base64'
+                              ? `base64://${fs.readFileSync(filePath).toString('base64')}`
+                              : `file://${filePath}`
+                          processedImages.push(segment.video(videoPath))
+                        }
+                      }
+
+                      // 生成实况图（clip_type === 5 是 livePhoto）
+                      if (shouldGenerateLivePhoto && item.clip_type === 5 && item.url_list?.[0]) {
+                        let hasPushedMotionPhotoCover = false
+                        if (staticImgPath) {
+                          const motionPhotoCoverPath =
+                            Common.tempDri.images + `MVIMG_${format(new Date(), 'yyyyMMdd_HHmmss_SSS')}_${index}.jpg`
+                          const motionPhotoCreated = await buildGoogleMotionPhoto({
+                            imagePath: staticImgPath,
+                            videoPath: liveimg.filepath,
+                            outputPath: motionPhotoCoverPath
+                          })
+                          if (motionPhotoCreated) {
+                            temp.push({ filepath: motionPhotoCoverPath, totalBytes: 0 })
+                            const motionPhotoCover = processLocalImageFile(motionPhotoCoverPath)
+                            processedImages.push(segment.image(motionPhotoCover))
+                            hasPushedMotionPhotoCover = true
+                          }
+                        }
+                        if (!hasPushedMotionPhotoCover) {
+                          const imageUrl = await processImageUrl(item.url_list[0], Detail_Data.desc, index)
+                          processedImages.push(segment.image(imageUrl))
+                        } else {
+                          hasGeneratedLivePhoto = true // 标记已生成实况图
+                        }
+                      }
+
+                      logger.mark('正在尝试删除缓存文件')
+                      await Common.removeFile(liveimg.filepath, true)
+                    }
+                  }
+
+                  // 如果生成了实况图，添加提示文字
+                  if (hasGeneratedLivePhoto) {
+                    const tipImg = await Render(this.e, 'other/live-photo-tip', {
+                      title: '实况照片已生成',
+                      description: '保存原图到相册即可识别为实况图'
+                    })
+                    processedImages.push(...tipImg)
+                  }
+
+                  const bot = karin.getBot(botId) as AdapterType
+                  try {
+                    if (processedImages.length === 0) {
+                      logger.warn(`抖音图集推送解析未生成可发送内容，aweme_id=${Detail_Data.aweme_id}`)
+                    } else {
+                      const Element = common.makeForward(processedImages, botId, bot.account.name)
+                      await bot.sendForwardMsg(Contact, Element, {
+                        source: '图集内容',
+                        summary: `查看${Element.length}张图片/视频消息`,
+                        prompt: '抖音图集解析结果',
+                        news: [{ text: '点击查看解析结果' }]
+                      })
+                    }
+                  } catch (error) {
+                    logger.error(`发送图集失败: ${error}`)
+                  } finally {
+                    for (const item of temp) {
+                      await Common.removeFile(item.filepath, true)
+                    }
+                  }
+                } else {
+                  // 纯静态图集
+                  const imageres: ImageElement[] = []
+                  let image_url
+                  for (const [index, item] of Detail_Data.images.entries()) {
+                    image_url = item.url_list[2] ?? item.url_list[1] // 图片地址
+                    if (!image_url) continue
+                    const imageUrl = await processImageUrl(image_url, Detail_Data.desc, index)
+                    imageres.push(segment.image(imageUrl))
+                  }
+                  const bot = karin.getBot(botId) as AdapterType
+
+                  if (imageres.length === 1 && image_url) {
+                    // 单张图片直接发送
+                    const imageUrl = await processImageUrl(image_url, Detail_Data.desc)
+                    await bot.sendMsg(Contact, [segment.image(imageUrl)])
+                  } else {
+                    // 多张图片使用合并转发
+                    const forwardMsg = common.makeForward(imageres, botId, bot.account.name)
+                    await bot.sendForwardMsg(Contact, forwardMsg, {
+                      source: '图片合集',
+                      summary: `查看${forwardMsg.length}张图片消息`,
+                      prompt: '抖音图集解析结果',
+                      news: [{ text: '点击查看解析结果' }]
+                    })
+                  }
+                }
+              }
+            }
+          }
+        }
+
+        // 添加作品缓存（直播不需要缓存aweme_id）
+        if (skip || (pushItem.pushType !== 'live' && status.message_id)) {
+          await douyinDB.addAwemeCache(actualAwemeId, pushItem.sec_uid, groupId, pushItem.pushType)
+        }
+      }
+    }
+
+    return true
+  }
+
+  /**
+   * 根据配置文件获取用户当天的作品列表。
+   * @returns 将要推送的列表
+   */
+  async getDynamicList(userList: douyinPushItem[]): Promise<WillBePushList> {
+    const willbepushlist: WillBePushList = {}
+
+    try {
+      /** 过滤掉不启用的订阅项 */
+      const filteredUserList = userList.filter((item) => item.switch !== false)
+      for (const item of filteredUserList) {
+        await common.sleep(2000)
+
+        if (!item.sec_uid) {
+          logger.warn(`用户 ${item.remark || item.short_id} 缺少 sec_uid，跳过`)
+          continue
+        }
+
+        const sec_uid = item.sec_uid
+        const pushTypes = item.pushTypes || ['post'] // 默认推送作品列表
+
+        logger.debug(`开始获取用户：${item.remark}（${sec_uid}）的内容，推送类型：${pushTypes.join(', ')}`)
+
+        const userinfo = await this.amagi.douyin.fetcher.fetchUserProfile({ sec_uid })
+
+        const targets = item.group_id.map((groupWithBot) => {
+          const [groupId, botId] = groupWithBot.split(':')
+          return { groupId, botId }
+        })
+
+        // 如果没有订阅群组，跳过该用户
+        if (targets.length === 0) continue
+
+        // special_state 特殊状态，用户已注销
+        if (userinfo.data.user?.special_state_info?.special_state === 1 && userinfo.data.user?.user_deleted === true) {
+          logger.warn(`${item.remark}（${sec_uid}）${userinfo.data.user.special_state_info.title}`)
+          continue
+        }
+
+        // 遍历每种推送类型
+        for (const pushType of pushTypes) {
+          await common.sleep(1000)
+
+          // 处理直播推送
+          if (pushType === 'live') {
+            const liveItem = await processLiveStream(sec_uid, userinfo.data, item, targets, this.amagi)
+            if (liveItem) {
+              willbepushlist[`live_${sec_uid}`] = liveItem
+            }
+            continue
+          }
+
+          let contentList: DouyinListItem[] = []
+          let listName = ''
+
+          // 根据推送类型获取不同的列表
+          switch (pushType) {
+            case 'post':
+              listName = '作品列表'
+              const videolist = await this.amagi.douyin.fetcher.fetchUserVideoList({
+                sec_uid,
+                number: 15
+              })
+              contentList = videolist.data.aweme_list || []
+              break
+            case 'favorite':
+              listName = '喜欢列表'
+              const favoritelist = await this.amagi.douyin.fetcher.fetchUserFavoriteList({
+                sec_uid,
+                number: 15
+              })
+              if (favoritelist.data.aweme_list.length === 0)
+                logger.warn(`${item.remark}(${item.short_id}) 获取到的喜欢列表数量为零！此博主可能未公开他/她的喜欢列表`)
+              contentList = favoritelist.data.aweme_list || []
+              break
+            case 'recommend':
+              listName = '推荐列表'
+              const recommendlist = await this.amagi.douyin.fetcher.fetchUserRecommendList({
+                sec_uid,
+                number: 15
+              })
+              if (recommendlist.data.aweme_list.length === 0)
+                logger.warn(`${item.remark}(${item.short_id}) 获取到的推荐列表数量为零！此博主可能未公开他/她的推荐列表`)
+              contentList = recommendlist.data.aweme_list || []
+              break
+          }
+
+          logger.debug(`获取到 ${item.remark} 的${listName}，共 ${contentList.length} 条`)
+
+          // 根据推送类型调用不同的处理函数
+          if (contentList.length > 0) {
+            let pushItems: DouyinWorkPushItem[] = []
+            switch (pushType) {
+              case 'post':
+                pushItems = await processPostList(contentList, sec_uid, userinfo.data, item, targets)
+                break
+              case 'favorite':
+                pushItems = await processFavoriteList(contentList, sec_uid, userinfo.data, item, targets, this.force)
+                break
+              case 'recommend':
+                pushItems = await processRecommendList(contentList, sec_uid, userinfo.data, item, targets, this.force)
+                break
+            }
+
+            // 将返回的推送项添加到willbepushlist中
+            for (const pushItem of pushItems) {
+              const key = `${pushType}_${pushItem.Detail_Data.aweme_id}`
+              willbepushlist[key] = pushItem
+            }
+          }
+        }
+      }
+    } catch (error) {
+      throw new Error(`获取抖音用户内容列表失败: ${error}`)
+    }
+
+    return willbepushlist
+  }
+
+  /**
+   * 检查作品是否已经推送过
+   * @param aweme_id 作品ID
+   * @param sec_uid 用户sec_uid
+   * @param groupIds 群组ID列表
+   * @param pushType 推送类型
+   * @returns 是否已经推送过
+   */
+  async checkIfAlreadyPushed(aweme_id: string, sec_uid: string, groupIds: string[], pushType: string = 'post'): Promise<boolean> {
+    for (const groupId of groupIds) {
+      const isPushed = await douyinDB.isAwemePushed(aweme_id, sec_uid, groupId, pushType)
+      if (!isPushed) {
+        return false
+      }
+    }
+    return true
+  }
+
+  /**
+   * 设置或更新特定 sec_uid 的群组信息。
+   * @param data 抖音的搜索结果数据。需要接口返回的原始数据
+   * @returns 操作成功或失败的消息字符串。
+   */
+  async setting(data: DouyinSearchResponse): Promise<void> {
+    const groupInfo = await this.e.bot.getGroupInfo('groupId' in this.e && this.e.groupId ? this.e.groupId : '')
+    const config = Config.pushlist // 读取配置文件
+    const groupId = 'groupId' in this.e && this.e.groupId ? this.e.groupId : ''
+    const botId = this.e.selfId
+
+    try {
+      // 获取用户输入的抖音号
+      const inputDouyinId = this.e.msg.replace(/^#设置抖音推送/, '').trim()
+
+      /**
+       * 搜索结果按响应形态自述（判别式 `__search_type`，由 amagi 的 normalize 按响应结构 +
+       * 请求类型写入）。订阅只认「用户搜索」那一支：抖音把 user 请求回成别的形态时在这里说清楚，
+       * 而不是拿一个 undefined 去遍历。
+       */
+      if (data.__search_type !== 'user') {
+        throw new Error(`抖音没有返回用户搜索结果（返回形态：${data.__search_type ?? '未知'}）`)
+      }
+
+      // 在用户列表中查找匹配的用户
+      let matchedUser = null
+      for (const userItem of data.user_list) {
+        const currentDouyinId = userItem.user_info.unique_id === '' ? userItem.user_info.short_id : userItem.user_info.unique_id
+        if (currentDouyinId === inputDouyinId) {
+          matchedUser = userItem.user_info
+          break
+        }
+      }
+
+      // 如果没找到匹配的用户，抛出错误
+      if (!matchedUser) {
+        throw new Error(`未找到抖音号为 ${inputDouyinId} 的用户`)
+      }
+
+      // 使用匹配到的用户的 sec_uid 进行下一步请求
+      const sec_uid = matchedUser.sec_uid
+      const UserInfoData = await this.amagi.douyin.fetcher.fetchUserProfile({ sec_uid })
+
+      /** 处理抖音号 */
+      let user_shortid
+      user_shortid = UserInfoData.data.user.unique_id === '' ? UserInfoData.data.user.short_id : UserInfoData.data.user.unique_id
+
+      // 初始化 douyin 数组
+      config.douyin ??= []
+
+      // 查找是否存在相同的 sec_uid
+      const existingItem = config.douyin.find((item: { sec_uid: string }) => item.sec_uid === sec_uid)
+
+      // 检查数据库中是否已订阅
+      const isSubscribed = await douyinDB.isSubscribed(sec_uid, groupId)
+
+      if (existingItem) {
+        // 如果已经存在相同的 sec_uid，则检查是否存在相同的 group_id
+        let has = false
+        let groupIndexToRemove = -1 // 用于记录要删除的 group_id 对象的索引
+        for (let index = 0; index < existingItem.group_id.length; index++) {
+          // 分割每个对象的 id 属性，并获取第一部分
+          const item = existingItem.group_id[index]
+          const existingGroupId = item.split(':')[0]
+
+          // 检查分割后的第一部分是否与提供的 group_id 相同
+          if (existingGroupId === String(groupId)) {
+            has = true
+            groupIndexToRemove = index
+            break // 找到匹配项后退出循环
+          }
+        }
+
+        if (has) {
+          // 如果存在相同的 group_id，则删除它
+          existingItem.group_id.splice(groupIndexToRemove, 1)
+
+          // 同时从数据库中取消订阅
+          if (isSubscribed) {
+            await douyinDB.unsubscribeDouyinUser(groupId, sec_uid)
+          }
+
+          // 如果删除后 group_id 数组为空，则删除整个属性
+          if (existingItem.group_id.length === 0) {
+            const index = config.douyin.indexOf(existingItem)
+            config.douyin.splice(index, 1)
+          }
+
+          // 保存配置到文件
+          Config.Modify('pushlist', 'douyin', config.douyin)
+          await this.e.reply(
+            `群：${groupInfo.groupName}(${groupId})\n删除成功！${UserInfoData.data.user.nickname}\n抖音号：${user_shortid}`
+          )
+          logger.info(`\n删除成功！${UserInfoData.data.user.nickname}\n抖音号：${user_shortid}\nsec_uid${UserInfoData.data.user.sec_uid}`)
+        } else {
+          // 否则，将新的 group_id 添加到该 sec_uid 对应的数组中
+          existingItem.group_id.push(`${groupId}:${botId}`)
+
+          // 确保 pushTypes 字段存在，如果不存在则添加默认值
+          if (!existingItem.pushTypes || existingItem.pushTypes.length === 0) {
+            existingItem.pushTypes = ['post', 'live']
+          }
+
+          // 同时在数据库中添加订阅
+          if (!isSubscribed) {
+            await douyinDB.subscribeDouyinUser(groupId, botId, sec_uid, user_shortid, UserInfoData.data.user.nickname)
+          }
+
+          // 保存配置到文件
+          Config.Modify('pushlist', 'douyin', config.douyin)
+          await this.e.reply(
+            `群：${groupInfo.groupName}(${groupId})\n添加成功！${UserInfoData.data.user.nickname}\n抖音号：${user_shortid}`
+          )
+          if (Config.douyin.push.switch === false) await this.e.reply('请发送「#设置抖音推送开启」以进行推送')
+          logger.info(`\n设置成功！${UserInfoData.data.user.nickname}\n抖音号：${user_shortid}\nsec_uid${UserInfoData.data.user.sec_uid}`)
+        }
+      } else {
+        // 如果不存在相同的 sec_uid，则新增一个属性
+        config.douyin.push({
+          switch: true,
+          sec_uid,
+          group_id: [`${groupId}:${botId}`],
+          remark: UserInfoData.data.user.nickname,
+          short_id: user_shortid,
+          pushTypes: ['post', 'live']
+        })
+
+        // 同时在数据库中添加订阅
+        if (!isSubscribed) {
+          await douyinDB.subscribeDouyinUser(groupId, botId, sec_uid, user_shortid, UserInfoData.data.user.nickname)
+        }
+
+        // 保存配置到文件
+        Config.Modify('pushlist', 'douyin', config.douyin)
+        await this.e.reply(`群：${groupInfo.groupName}(${groupId})\n添加成功！${UserInfoData.data.user.nickname}\n抖音号：${user_shortid}`)
+        if (Config.douyin.push.switch === false) await this.e.reply('请发送「#设置抖音推送开启」以进行推送')
+        logger.info(`\n设置成功！${UserInfoData.data.user.nickname}\n抖音号：${user_shortid}\nsec_uid${UserInfoData.data.user.sec_uid}`)
+      }
+
+      await this.renderPushList()
+    } catch (error) {
+      throw new Error(`设置失败，请查看日志: ${error}`)
+    }
+  }
+
+  /** 渲染推送列表图片 */
+  async renderPushList(): Promise<void> {
+    await this.syncConfigToDatabase()
+    const groupInfo = await this.e.bot.getGroupInfo('groupId' in this.e && this.e.groupId ? this.e.groupId : '')
+
+    // 获取当前群组的所有订阅
+    const subscriptions = await douyinDB.getGroupSubscriptions(groupInfo.groupId)
+
+    if (subscriptions.length === 0) {
+      await this.e.reply(
+        `当前群：${groupInfo.groupName}(${groupInfo.groupId})\n没有设置任何抖音博主推送！\n可使用「#设置抖音推送 + 抖音号」进行设置`
+      )
+      return
+    }
+
+    const renderOpt: DouyinUserListData['renderOpt'] = []
+
+    for (const subscription of subscriptions) {
+      const sec_uid = subscription.sec_uid
+      const userInfo = await this.amagi.douyin.fetcher.fetchUserProfile({ sec_uid })
+
+      // 查找配置文件中对应的全局开关状态
+      const configItem = Config.pushlist.douyin?.find((item: douyinPushItem) => item.sec_uid === sec_uid)
+      const switchStatus = configItem?.switch !== false // 默认为 true
+      const pushTypes = configItem?.pushTypes || ['post']
+
+      renderOpt.push({
+        avatar_img: userInfo.data.user.avatar_larger.url_list[0],
+        username: userInfo.data.user.nickname,
+        short_id: userInfo.data.user.unique_id === '' ? userInfo.data.user.short_id : userInfo.data.user.unique_id,
+        fans: this.count(userInfo.data.user.follower_count),
+        total_favorited: this.count(userInfo.data.user.total_favorited),
+        following_count: this.count(userInfo.data.user.following_count),
+        switch: switchStatus,
+        pushTypes
+      })
+    }
+    const img = await Render(this.e, 'douyin/userlist', {
+      renderOpt,
+      groupInfo: {
+        groupId: groupInfo.groupId || '',
+        groupName: groupInfo.groupName || '',
+        groupAvatar: groupInfo.avatar || ''
+      }
+    })
+    await this.e.reply(img)
+  }
+
+  /**
+   * 强制推送
+   * @param data 处理完成的推送列表
+   */
+  async forcepush(data: WillBePushList) {
+    const currentGroupId = 'groupId' in this.e && this.e.groupId ? this.e.groupId : ''
+    const currentBotId = this.e.selfId
+
+    // 如果不是全部强制推送，需要过滤数据
+    if (!this.e.msg.includes('全部')) {
+      // 获取当前群组订阅的所有抖音用户
+      const subscriptions = await douyinDB.getGroupSubscriptions(currentGroupId)
+      const subscribedUids = subscriptions.map((sub) => sub.sec_uid)
+
+      // 创建一个新的推送列表，只包含当前群组订阅的用户的作品
+      const filteredData: WillBePushList = {}
+
+      for (const awemeId in data) {
+        // 检查该作品的用户是否被当前群组订阅
+        if (subscribedUids.includes(data[awemeId].sec_uid)) {
+          // 复制该作品到过滤后的列表，并将目标设置为当前群组
+          filteredData[awemeId] = {
+            ...data[awemeId],
+            targets: [
+              {
+                groupId: currentGroupId,
+                botId: currentBotId
+              }
+            ]
+          }
+        }
+      }
+
+      // 使用过滤后的数据进行推送
+      await this.getdata(filteredData)
+    } else {
+      // 全部强制推送，保持原有逻辑
+      await this.getdata(data)
+    }
+  }
+
+  /**
+   * 检查并更新备注信息
+   */
+  async checkremark() {
+    // 读取配置文件内容
+    const config = Config.pushlist
+    const updateList: { sec_uid: string }[] = []
+
+    if (Config.pushlist.douyin === null || Config.pushlist.douyin.length === 0) return true
+
+    // 遍历配置文件中的用户列表，收集需要更新备注信息的用户
+    for (const i of Config.pushlist.douyin) {
+      const remark = i.remark
+      const sec_uid = i.sec_uid
+
+      if (remark === undefined || remark === '') {
+        updateList.push({ sec_uid })
+      }
+    }
+
+    // 如果有需要更新备注的用户，则逐个获取备注信息并更新到配置文件中
+    if (updateList.length > 0) {
+      for (const i of updateList) {
+        // 从外部数据源获取用户备注信息
+        const userinfo = await this.amagi.douyin.fetcher.fetchUserProfile({ sec_uid: i.sec_uid })
+        const remark = userinfo.data.user.nickname
+
+        // 在配置文件中找到对应的用户，并更新其备注信息
+        const matchingItemIndex = config.douyin.findIndex((item: { sec_uid: string }) => item.sec_uid === i.sec_uid)
+        if (matchingItemIndex !== -1) {
+          config.douyin[matchingItemIndex].remark = remark
+        }
+      }
+
+      // 将更新后的配置文件内容写回文件
+      Config.Modify('pushlist', 'douyin', config.douyin)
+    }
+
+    return false
+  }
+
+  /**
+   * 格式化数字
+   */
+  count(num: number) {
+    if (num > 10000) {
+      return (num / 10000).toFixed(1) + '万'
+    }
+    return num.toString()
+  }
+}
+
+/**
+ * 判断标题是否有屏蔽词或屏蔽标签
+ * @param PushItem 推送项
+ * @returns 是否应该跳过推送
+ */
+const skipDynamic = async (PushItem: DouyinPushItem): Promise<boolean> => {
+  // 直播动态不做内容过滤
+  if (PushItem.pushType === 'live' || 'liveStatus' in PushItem.Detail_Data) {
+    return false
+  }
+
+  const tags: string[] = []
+
+  // 提取标签
+  if (PushItem.Detail_Data.text_extra) {
+    for (const item of PushItem.Detail_Data.text_extra) {
+      if (item.hashtag_name) {
+        tags.push(item.hashtag_name)
+      }
+    }
+  }
+
+  logger.debug(`检查作品是否需要过滤：${PushItem.Detail_Data.share_url}`)
+  const shouldFilter = await douyinDB.shouldFilter(PushItem, tags)
+  return shouldFilter
+}