koishi-plugin-kkk 1.0.0

package/src/karin/module/utils/Config.ts

@@ -0,0 +1,443 @@
+import fs from 'node:fs'
+
+import { logger, watch } from 'node-karin'
+import { karinPathBase } from 'node-karin/root'
+import YAML from 'node-karin/yaml'
+
+import type { ConfigType } from '@/types'
+import type { bilibiliPushItem, douyinPushItem } from '@/types/config/pushlist'
+
+import { Root } from '../../root'
+import { getParseOverride } from './ParseOverride'
+
+type ConfigDirType = 'config' | 'default_config'
+
+/**
+ * 把「本次消息的解析参数」叠加到平台配置上。
+ *
+ * 只在解析链路里（{@link getParseOverride} 有值时）生效：定时推送、其它会话读到的仍是配置项本身。
+ * 返回浅拷贝而不是原地改 —— 配置对象来自每次读盘，但覆盖值必须只影响这一次调用。
+ * @param section 配置段名
+ * @param value 配置段
+ */
+const applyOverride = (section: string, value: any): any => {
+  const override = getParseOverride()
+  if (!override || !value || typeof value !== 'object') return value
+  if (section === 'bilibili' && override.bilibiliQuality !== undefined) {
+    return { ...value, videoQuality: override.bilibiliQuality }
+  }
+  if (section === 'douyin' && override.douyinQuality !== undefined) {
+    return { ...value, videoQuality: override.douyinQuality }
+  }
+  if (section === 'xiaohongshu' && override.xiaohongshuQuality !== undefined) {
+    return { ...value, videoQuality: override.xiaohongshuQuality }
+  }
+  return value
+}
+
+class Cfg {
+  /** 用户配置文件路径 */
+  private dirCfgPath: string
+  /** 默认配置文件路径 */
+  private defCfgPath: string
+  /** JSON 配置文件路径 */
+  private get jsonConfigPath() {
+    return `${this.dirCfgPath}/config.json`
+  }
+  private get defJsonConfigPath() {
+    return `${this.defCfgPath}/config.json`
+  }
+
+  constructor() {
+    this.dirCfgPath = `${karinPathBase}/${Root.pluginName}/config`
+    this.defCfgPath = `${Root.pluginPath}/config/default_config/`
+  }
+
+  /** 初始化配置 */
+  initCfg() {
+    // 1. 确保用户配置目录存在
+    if (!fs.existsSync(this.dirCfgPath)) {
+      fs.mkdirSync(this.dirCfgPath, { recursive: true })
+    }
+
+    // 2. 如果用户没有 config.json 且没有 YAML 文件，复制默认配置（全新安装）
+    const hasJson = fs.existsSync(this.jsonConfigPath)
+    const hasYaml = ['app', 'bilibili', 'cookies', 'douyin', 'kuaishou', 'pushlist', 'request', 'upload', 'xiaohongshu'].some((name) =>
+      fs.existsSync(`${this.dirCfgPath}/${name}.yaml`)
+    )
+
+    if (!hasJson && !hasYaml && fs.existsSync(this.defJsonConfigPath)) {
+      fs.copyFileSync(this.defJsonConfigPath, this.jsonConfigPath)
+    }
+
+    // 3. 合并默认配置（处理新增字段）
+    if (fs.existsSync(this.jsonConfigPath) && fs.existsSync(this.defJsonConfigPath)) {
+      const userConfig = this.getJson()
+      const defConfig = JSON.parse(fs.readFileSync(this.defJsonConfigPath, 'utf8'))
+      const merged = this.mergeJsonConfigs(defConfig, userConfig)
+      if (JSON.stringify(merged) !== JSON.stringify(userConfig)) {
+        this.setJson(merged)
+      }
+    }
+
+    // 4. 监听 config.json 变化
+    setTimeout(() => {
+      if (fs.existsSync(this.jsonConfigPath)) {
+        watch(this.jsonConfigPath, (old, now) => {
+          // @ts-ignore
+          if (old?.amagi !== now?.amagi) {
+            logger.debug('[koishi-plugin-kkk][Config] 检测到 amagi 配置变化，正在重载 Amagi Client...')
+            import('./amagiClient')
+              .then(({ reloadAmagiConfig }) => reloadAmagiConfig())
+              .catch((error) => logger.error(`[koishi-plugin-kkk][Config] 重载 Amagi Client 失败: ${error}`))
+          }
+        })
+      }
+    }, 2000)
+
+    return this
+  }
+
+  /** 读取 JSON 配置 */
+  private getJson(): any {
+    return JSON.parse(fs.readFileSync(this.jsonConfigPath, 'utf8'))
+  }
+
+  /** 写入 JSON 配置 */
+  private setJson(config: any) {
+    fs.writeFileSync(this.jsonConfigPath, JSON.stringify(config, null, 2), 'utf8')
+  }
+
+  /** 深度合并 JSON 配置（保留用户值，补充默认值） */
+  private mergeJsonConfigs(def: any, user: any): any {
+    if (!def || typeof def !== 'object' || Array.isArray(def)) return user ?? def
+    if (!user || typeof user !== 'object' || Array.isArray(user)) return user ?? def
+
+    const result: any = { ...def }
+    for (const key in user) {
+      if (typeof user[key] === 'object' && !Array.isArray(user[key]) && user[key] !== null) {
+        result[key] = this.mergeJsonConfigs(def[key], user[key])
+      } else {
+        result[key] = user[key]
+      }
+    }
+    return result
+  }
+
+  /**
+   * 获取配置
+   * @param name 配置键名
+   */
+  getDefOrConfig(name: keyof ConfigType) {
+    const config = this.getJson()
+    return config[name] || {}
+  }
+
+  /** 获取所有配置文件 */
+  async All(): Promise<ConfigType> {
+    const { getDouyinDB, getBilibiliDB } = await import('../db')
+    const douyinDB = await getDouyinDB()
+    const bilibiliDB = await getBilibiliDB()
+
+    const allConfig: any = this.getJson()
+
+    // 从数据库获取过滤配置并合并到推送列表中
+    if (allConfig.pushlist) {
+      try {
+        if (allConfig.pushlist.douyin) {
+          for (const item of allConfig.pushlist.douyin) {
+            const filterWords = await douyinDB.getFilterWords(item.sec_uid)
+            const filterTags = await douyinDB.getFilterTags(item.sec_uid)
+            const userInfo = await douyinDB.getDouyinUser(item.sec_uid)
+            if (userInfo) {
+              item.filterMode = (userInfo.filterMode as 'blacklist' | 'whitelist') || 'blacklist'
+            }
+            item.Keywords = filterWords
+            item.Tags = filterTags
+          }
+        }
+        if (allConfig.pushlist.bilibili) {
+          for (const item of allConfig.pushlist.bilibili) {
+            const filterWords = await bilibiliDB.getFilterWords(item.host_mid)
+            const filterTags = await bilibiliDB.getFilterTags(item.host_mid)
+            const userInfo = await bilibiliDB.getOrCreateBilibiliUser(item.host_mid)
+            if (userInfo) {
+              item.filterMode = (userInfo.filterMode as 'blacklist' | 'whitelist') || 'blacklist'
+            }
+            item.Keywords = filterWords
+            item.Tags = filterTags
+          }
+        }
+      } catch (error) {
+        logger.error(`从数据库获取过滤配置时出错: ${error}`)
+      }
+    }
+
+    return allConfig as ConfigType
+  }
+
+  /**
+   * 修改整个配置文件
+   * @param name 文件名
+   * @param config 完整的配置对象
+   */
+  async ModifyPro<T extends keyof ConfigType>(name: T, config: ConfigType[T], type: ConfigDirType = 'config') {
+    if (type !== 'config') return false
+
+    const { getDouyinDB, getBilibiliDB } = await import('../db')
+    const douyinDB = await getDouyinDB()
+    const bilibiliDB = await getBilibiliDB()
+
+    const jsonConfig = this.getJson()
+    jsonConfig[name] = config
+    this.setJson(jsonConfig)
+
+    // 同步到数据库
+    if ('douyin' in config) {
+      await this.syncFilterConfigToDb(config.douyin as douyinPushItem[], douyinDB, 'sec_uid')
+      logger.debug('[koishi-plugin-kkk][Config] 已同步抖音过滤配置到数据库')
+    }
+    if ('bilibili' in config) {
+      await this.syncFilterConfigToDb(config.bilibili as bilibiliPushItem[], bilibiliDB, 'host_mid')
+      logger.debug('[koishi-plugin-kkk][Config] 已同步B站过滤配置到数据库')
+    }
+    return true
+  }
+
+  /**
+   * 修改配置字段（支持深层嵌套路径，包括数组索引）
+   * @param moduleName 模块名
+   * @param path 字段路径，如 'push.switch' 或 'cookies.douyin' 或 'list[0].name'
+   * @param value 新值
+   */
+  async Modify<T extends keyof ConfigType>(moduleName: T, path: string, value: any) {
+    const jsonConfig = this.getJson()
+    const pathKeys = this.parsePath(path)
+
+    // 导航到目标对象
+    let target: any = jsonConfig[moduleName]
+    for (let i = 0; i < pathKeys.length - 1; i++) {
+      const key = pathKeys[i]
+      if (!(key in target)) {
+        target[key] = {}
+      }
+      target = target[key]
+    }
+
+    // 设置值
+    const lastKey = pathKeys[pathKeys.length - 1]
+    target[lastKey] = value
+
+    // 保存
+    this.setJson(jsonConfig)
+
+    // 同步数据库
+    if (moduleName === 'pushlist') {
+      const { getDouyinDB, getBilibiliDB } = await import('../db')
+      const douyinDB = await getDouyinDB()
+      const bilibiliDB = await getBilibiliDB()
+
+      if ('douyin' in jsonConfig[moduleName]) {
+        await this.syncFilterConfigToDb(jsonConfig[moduleName].douyin, douyinDB, 'sec_uid')
+      }
+      if ('bilibili' in jsonConfig[moduleName]) {
+        await this.syncFilterConfigToDb(jsonConfig[moduleName].bilibili, bilibiliDB, 'host_mid')
+      }
+    }
+
+    return true
+  }
+
+  /**
+   * 解析路径字符串，支持点号和数组索引
+   * 'a.b.c' => ['a', 'b', 'c']
+   * 'a[0].b' => ['a', '0', 'b']
+   */
+  private parsePath(path: string): string[] {
+    return path.replace(/\[(\d+)\]/g, '.$1').split('.')
+  }
+
+  /**
+   * 同步过滤配置到数据库
+   * @param items 推送项列表
+   * @param db 数据库实例
+   * @param idField ID字段名称
+   */
+  private async syncFilterConfigToDb(items: any[], db: any, idField: string) {
+    for (const item of items) {
+      const id = item[idField]
+      if (!id) continue
+
+      if (item.filterMode) {
+        await db.updateFilterMode(id, item.filterMode)
+      }
+
+      if (item.Keywords && Array.isArray(item.Keywords)) {
+        const existingWords = await db.getFilterWords(id)
+        for (const word of existingWords) {
+          if (!item.Keywords.includes(word)) {
+            await db.removeFilterWord(id, word)
+          }
+        }
+        for (const word of item.Keywords) {
+          if (!existingWords.includes(word)) {
+            await db.addFilterWord(id, word)
+          }
+        }
+      }
+
+      if (item.Tags && Array.isArray(item.Tags)) {
+        const existingTags = await db.getFilterTags(id)
+        for (const tag of existingTags) {
+          if (!item.Tags.includes(tag)) {
+            await db.removeFilterTag(id, tag)
+          }
+        }
+        for (const tag of item.Tags) {
+          if (!existingTags.includes(tag)) {
+            await db.addFilterTag(id, tag)
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * 同步配置到数据库
+   */
+  async syncConfigToDatabase() {
+    try {
+      const { getDouyinDB, getBilibiliDB } = await import('../db')
+      const douyinDB = await getDouyinDB()
+      const bilibiliDB = await getBilibiliDB()
+
+      const config = this.getJson()
+      const pushCfg = config.pushlist
+
+      if (pushCfg?.bilibili) await bilibiliDB.syncConfigSubscriptions(pushCfg.bilibili)
+      if (pushCfg?.douyin) await douyinDB.syncConfigSubscriptions(pushCfg.douyin)
+      logger.debug('[koishi-plugin-kkk][BilibiliDB] + [DouyinDB] 配置已同步到数据库')
+    } catch (error) {
+      logger.error('[koishi-plugin-kkk]同步配置到数据库失败:', error)
+    }
+  }
+}
+
+type Config$ = ConfigType & Pick<Cfg, 'All' | 'Modify' | 'ModifyPro' | 'syncConfigToDatabase'>
+
+let configInstance: Config$ | null = null
+let migrationExecuted = false
+
+const getConfigInstance = (): Config$ => {
+  if (!configInstance) {
+    // 首次初始化时执行迁移
+    if (!migrationExecuted) {
+      migrateConfigFromYaml()
+      migrationExecuted = true
+    }
+
+    configInstance = new Proxy(new Cfg().initCfg(), {
+      get(target, prop: string) {
+        if (prop in target) return target[prop as keyof Cfg]
+        return target.getDefOrConfig(prop as keyof ConfigType)
+      }
+    }) as unknown as Config$
+  }
+  return configInstance
+}
+
+export const Config: Config$ = new Proxy({} as Config$, {
+  get(target, prop: string) {
+    return applyOverride(prop, getConfigInstance()[prop as keyof Config$])
+  }
+})
+
+/**
+ * 从 YAML 迁移到 JSON
+ */
+const migrateConfigFromYaml = () => {
+  const dirCfgPath = `${karinPathBase}/${Root.pluginName}/config`
+  const defCfgPath = `${Root.pluginPath}/config/default_config/`
+  const jsonConfigPath = `${dirCfgPath}/config.json`
+
+  if (fs.existsSync(jsonConfigPath)) return
+
+  const yamlFiles = ['app', 'bilibili', 'cookies', 'douyin', 'kuaishou', 'pushlist', 'request', 'upload', 'xiaohongshu']
+  const hasYaml = yamlFiles.some((name) => fs.existsSync(`${dirCfgPath}/${name}.yaml`))
+  if (!hasYaml) return
+
+  try {
+    // 读取默认配置作为模板
+    const defYaml: any = {}
+    for (const name of yamlFiles) {
+      const file = `${defCfgPath}/${name}.yaml`
+      if (fs.existsSync(file)) {
+        defYaml[name] = YAML.parse(fs.readFileSync(file, 'utf8'))
+      }
+    }
+
+    // 读取用户配置，只保留默认配置中存在的字段
+    const userYaml: any = {}
+    for (const name of yamlFiles) {
+      const file = `${dirCfgPath}/${name}.yaml`
+      if (fs.existsSync(file)) {
+        const data = YAML.parse(fs.readFileSync(file, 'utf8'))
+        userYaml[name] = filterKeys(data, defYaml[name])
+      }
+    }
+
+    // 转换结构
+    const jsonConfig = {
+      amagi: {
+        timeout: userYaml.request?.timeout ?? defYaml.request?.timeout,
+        'User-Agent': userYaml.request?.['User-Agent'] ?? defYaml.request?.['User-Agent'],
+        proxy: userYaml.request?.proxy ?? defYaml.request?.proxy,
+        cookies: userYaml.cookies || defYaml.cookies || {},
+        APIServer: userYaml.app?.APIServer ?? defYaml.app?.APIServer,
+        APIServerMount: userYaml.app?.APIServerMount ?? defYaml.app?.APIServerMount,
+        APIServerPort: userYaml.app?.APIServerPort ?? defYaml.app?.APIServerPort
+      },
+      app: {
+        ...defYaml.app,
+        ...defYaml.upload,
+        ...userYaml.app,
+        ...userYaml.upload
+      },
+      douyin: userYaml.douyin || defYaml.douyin,
+      bilibili: userYaml.bilibili || defYaml.bilibili,
+      kuaishou: userYaml.kuaishou || defYaml.kuaishou,
+      xiaohongshu: userYaml.xiaohongshu || defYaml.xiaohongshu,
+      pushlist: userYaml.pushlist || defYaml.pushlist
+    }
+
+    fs.writeFileSync(jsonConfigPath, JSON.stringify(jsonConfig, null, 2), 'utf8')
+
+    // 备份 YAML
+    const backupDir = `${dirCfgPath}/yaml_backup_${Date.now()}`
+    fs.mkdirSync(backupDir, { recursive: true })
+    for (const name of yamlFiles) {
+      const file = `${dirCfgPath}/${name}.yaml`
+      if (fs.existsSync(file)) {
+        fs.copyFileSync(file, `${backupDir}/${name}.yaml`)
+        fs.unlinkSync(file)
+      }
+    }
+
+    logger.info(`[koishi-plugin-kkk][Config] YAML 配置已迁移到 config.json，备份保存在 ${backupDir}`)
+  } catch (error) {
+    logger.error(`[koishi-plugin-kkk][Config] YAML 迁移失败: ${error}`)
+  }
+}
+
+const filterKeys = (user: any, template: any): any => {
+  if (!template || typeof template !== 'object') return user
+  if (Array.isArray(template)) return user
+
+  const result: any = {}
+  for (const key in template) {
+    if (key in user) {
+      result[key] = typeof template[key] === 'object' && !Array.isArray(template[key]) ? filterKeys(user[key], template[key]) : user[key]
+    }
+  }
+  return result
+}

package/src/karin/module/utils/EmojiReaction.ts

@@ -0,0 +1,268 @@
+/**
+ * Emoji 表情回复工具模块
+ */
+import type { Message } from 'node-karin'
+import { logger } from 'node-karin'
+
+import { Config } from './Config'
+
+/**
+ * 各平台表情 ID 配置
+ */
+const PLATFORM_EMOJI_IDS = {
+  qq: {
+    /** 已读/注意：https://koishi.js.org/QFace/#/qqnt/%F0%9F%91%80 */
+    EYES: 128064,
+    /** 处理中：https://koishi.js.org/QFace/#/qqnt/366 */
+    PROCESSING: 366,
+    /** 成功完成：https://koishi.js.org/QFace/#/qqnt/389 */
+    SUCCESS: 389,
+    /** 失败：https://koishi.js.org/QFace/#/qqnt/379 */
+    ERROR: 379
+  },
+  wechat: {
+    /** 已读/注意 - 占位符 */
+    EYES: 'WECHAT_EYES_PLACEHOLDER',
+    /** 处理中 - 占位符 */
+    PROCESSING: 'WECHAT_PROCESSING_PLACEHOLDER',
+    /** 成功完成 - 占位符 */
+    SUCCESS: 'WECHAT_SUCCESS_PLACEHOLDER',
+    /** 失败 - 占位符 */
+    ERROR: 'WECHAT_ERROR_PLACEHOLDER'
+  },
+  telegram: {
+    /** 已读/注意 - 占位符 */
+    EYES: 'TELEGRAM_EYES_PLACEHOLDER',
+    /** 处理中 - 占位符 */
+    PROCESSING: 'TELEGRAM_PROCESSING_PLACEHOLDER',
+    /** 成功完成 - 占位符 */
+    SUCCESS: 'TELEGRAM_SUCCESS_PLACEHOLDER',
+    /** 失败 - 占位符 */
+    ERROR: 'TELEGRAM_ERROR_PLACEHOLDER'
+  },
+  discord: {
+    /** 已读/注意 */
+    EYES: '👀',
+    /** 处理中 */
+    PROCESSING: '⏳',
+    /** 成功完成 */
+    SUCCESS: '✅',
+    /** 失败 */
+    ERROR: '❌'
+  },
+  koko: {
+    /** 已读/注意 - 占位符 */
+    EYES: 'KOKO_EYES_PLACEHOLDER',
+    /** 处理中 - 占位符 */
+    PROCESSING: 'KOKO_PROCESSING_PLACEHOLDER',
+    /** 成功完成 - 占位符 */
+    SUCCESS: 'KOKO_SUCCESS_PLACEHOLDER',
+    /** 失败 - 占位符 */
+    ERROR: 'KOKO_ERROR_PLACEHOLDER'
+  },
+  other: {
+    /** 已读/注意 - 占位符 */
+    EYES: 'OTHER_EYES_PLACEHOLDER',
+    /** 处理中 - 占位符 */
+    PROCESSING: 'OTHER_PROCESSING_PLACEHOLDER',
+    /** 成功完成 - 占位符 */
+    SUCCESS: 'OTHER_SUCCESS_PLACEHOLDER',
+    /** 失败 - 占位符 */
+    ERROR: 'OTHER_ERROR_PLACEHOLDER'
+  }
+} as const
+
+/**
+ * 表情类型
+ */
+export type EmojiType = 'EYES' | 'PROCESSING' | 'SUCCESS' | 'ERROR'
+
+/**
+ * 根据平台和表情类型获取表情 ID
+ * @param e 消息事件对象
+ * @param type 表情类型
+ * @returns 表情 ID
+ */
+export function getEmojiId(e: Message, type: EmojiType): string | number {
+  const platform = e.bot?.adapter?.platform || 'other'
+  // node-karin 的 AdapterPlatform 联合里有本表未覆盖的取值（如 dingtalk），
+  // 索引前先按「表里有没有这个键」收窄，缺的一律落到 other
+  const platformEmojis = platform in PLATFORM_EMOJI_IDS ? PLATFORM_EMOJI_IDS[platform as keyof typeof PLATFORM_EMOJI_IDS] : PLATFORM_EMOJI_IDS.other
+  return platformEmojis[type]
+}
+
+/**
+ * 表情 ID 常量（向后兼容，使用 QQ 平台的 ID）
+ * @deprecated 建议使用 getEmojiId 函数获取平台特定的表情 ID
+ */
+export const EMOJI_IDS = PLATFORM_EMOJI_IDS.qq
+
+/**
+ * 设置消息表情回复
+ * @param e 消息事件对象
+ * @param emojiId 表情ID
+ * @param isSet 是否设置表情（true=设置，false=取消），默认为 true
+ * @returns 是否成功设置表情
+ */
+export async function setEmojiReaction(e: Message, emojiId: string | number, isSet: boolean = true): Promise<boolean> {
+  // 如果未启用表情回复功能，直接返回
+  if (!Config.app.EmojiReply) {
+    return false
+  }
+
+  // 私聊不发送表情回复
+  if (e.isPrivate) {
+    return false
+  }
+
+  try {
+    await e.bot.setMsgReaction(e.contact, e.messageId, emojiId, isSet)
+    return true
+  } catch (err) {
+    // 始终忽略错误，不影响主流程
+    logger.debug('[EmojiReaction] 设置表情回复失败（已忽略）:', err)
+    return false
+  }
+}
+
+/**
+ * 表情回复管理器
+ */
+export class EmojiReactionManager {
+  private e: Message
+  private emojiIds: Set<string | number> = new Set()
+
+  constructor(e: Message) {
+    this.e = e
+  }
+
+  /**
+   * 根据表情类型获取平台特定的表情 ID
+   * @param type 表情类型
+   * @returns 表情 ID
+   */
+  private getPlatformEmojiId(type: EmojiType): string | number {
+    return getEmojiId(this.e, type)
+  }
+
+  /**
+   * 规范化表情 ID（如果是表情类型字符串，则转换为平台特定的 ID）
+   * @param emojiId 表情ID 或表情类型
+   * @returns 实际的表情 ID
+   */
+  private normalizeEmojiId(emojiId: string | number | EmojiType): string | number {
+    return typeof emojiId === 'string' && ['EYES', 'PROCESSING', 'SUCCESS', 'ERROR'].includes(emojiId)
+      ? this.getPlatformEmojiId(emojiId as EmojiType)
+      : emojiId
+  }
+
+  /**
+   * 添加表情
+   * @param emojiId 表情ID 或表情类型
+   * @returns 是否成功
+   */
+  async add(emojiId: string | number | EmojiType): Promise<boolean> {
+    const actualEmojiId = this.normalizeEmojiId(emojiId)
+    const success = await setEmojiReaction(this.e, actualEmojiId, true)
+    if (success) {
+      this.emojiIds.add(actualEmojiId)
+    }
+    return success
+  }
+
+  /**
+   * 移除表情
+   * @param emojiId 表情ID 或表情类型
+   * @returns 是否成功
+   */
+  async remove(emojiId: string | number | EmojiType): Promise<boolean> {
+    const actualEmojiId = this.normalizeEmojiId(emojiId)
+    const success = await setEmojiReaction(this.e, actualEmojiId, false)
+    if (success) {
+      this.emojiIds.delete(actualEmojiId)
+    }
+    return success
+  }
+
+  /**
+   * 替换表情（先添加新的，等待指定时间后移除旧的）
+   * @param oldEmojiId 旧表情ID 或表情类型
+   * @param newEmojiId 新表情ID 或表情类型
+   * @param delayMs 添加新表情后等待多少毫秒再移除旧表情，默认 2000ms
+   * @returns 是否成功
+   */
+  async replace(
+    oldEmojiId: string | number | EmojiType,
+    newEmojiId: string | number | EmojiType,
+    delayMs: number = 2000
+  ): Promise<boolean> {
+    // 先添加新表情
+    const addSuccess = await this.add(newEmojiId)
+    // 等待指定时间
+    await new Promise((resolve) => setTimeout(resolve, delayMs))
+    // 再移除旧表情
+    await this.remove(oldEmojiId)
+    return addSuccess
+  }
+
+  /**
+   * 清除所有表情
+   * @returns 成功清除的数量
+   */
+  async clearAll(): Promise<number> {
+    let count = 0
+    for (const emojiId of this.emojiIds) {
+      const success = await setEmojiReaction(this.e, emojiId, false)
+      if (success) count++
+    }
+    this.emojiIds.clear()
+    return count
+  }
+
+  /**
+   * 只保留指定的表情，移除其他所有表情
+   * @param keepEmojiIds 要保留的表情ID列表
+   * @returns 移除的表情数量
+   */
+  async keepOnly(keepEmojiIds: (string | number)[]): Promise<number> {
+    const keepSet = new Set(keepEmojiIds)
+    let removedCount = 0
+
+    for (const emojiId of this.emojiIds) {
+      if (!keepSet.has(emojiId)) {
+        const success = await this.remove(emojiId)
+        if (success) removedCount++
+      }
+    }
+
+    // 添加需要保留但当前不存在的表情
+    for (const emojiId of keepEmojiIds) {
+      if (!this.emojiIds.has(emojiId)) {
+        await this.add(emojiId)
+      }
+    }
+
+    return removedCount
+  }
+
+  /**
+   * 获取当前所有表情ID
+   */
+  getCurrentEmojiIds(): (string | number)[] {
+    return Array.from(this.emojiIds)
+  }
+
+  /**
+   * 检查是否有指定的表情
+   */
+  has(emojiId: string | number): boolean {
+    return this.emojiIds.has(emojiId)
+  }
+
+  /**
+   * 获取当前表情数量
+   */
+  count(): number {
+    return this.emojiIds.size
+  }
+}