koishi-plugin-bilibili-notify 3.0.0-alpha.2 → 3.0.0-alpha.21

package/lib/comRegister.js

@@ -4,24 +4,27 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const jsx_runtime_1 = require("@satorijs/element/jsx-runtime");
-/* eslint-disable @typescript-eslint/ban-types */
-/* eslint-disable @typescript-eslint/no-namespace */
-/* eslint-disable @typescript-eslint/no-explicit-any */
+// Koishi核心依赖
 const koishi_1 = require("koishi");
-// 导入qrcode
+// 外部依赖：qrcode
 const qrcode_1 = __importDefault(require("qrcode"));
-var LiveType;
-(function (LiveType) {
-    LiveType[LiveType["NotLiveBroadcast"] = 0] = "NotLiveBroadcast";
-    LiveType[LiveType["StartBroadcasting"] = 1] = "StartBroadcasting";
-    LiveType[LiveType["LiveBroadcast"] = 2] = "LiveBroadcast";
-    LiveType[LiveType["StopBroadcast"] = 3] = "StopBroadcast";
-})(LiveType || (LiveType = {}));
+// Utils
+const utils_1 = require("./utils");
+// Types
+const type_1 = require("./type");
+// TODO:WorlCloud
+// import { Segment, useDefault } from "segmentit";
 class ComRegister {
     // 必须服务
-    static inject = ['ba', 'gi', 'database', 'bl', 'sm'];
+    static inject = ["ba", "gi", "database", "bl", "sm"];
     // 定义数组：QQ相关bot
-    qqRelatedBotList = ['qq', 'onebot', 'red', 'satori', 'chronocat'];
+    qqRelatedBotList = [
+        "qq",
+        "onebot",
+        "red",
+        "satori",
+        "chronocat",
+    ];
     // logger
     logger;
     // config
@@ -42,8 +45,10 @@ class ComRegister {
     loginDBData;
     // 机器人实例
     privateBot;
-    // 动态销毁函数
+    // 动态检测销毁函数
     dynamicDispose;
+    // 直播检测销毁函数
+    liveDispose;
     // 发送消息方式
     sendMsgFunc;
     // 构造函数
@@ -53,76 +58,82 @@ class ComRegister {
         // 初始化
         this.init(config);
         // 注册指令
-        const statusCom = ctx.command('status', '插件状态相关指令', { permissions: ['authority:5'] });
-        statusCom.subcommand('.dyn', '查看动态监测运行状态')
-            .usage('查看动态监测运行状态')
-            .example('status dyn')
+        const statusCom = ctx.command("status", "插件状态相关指令", {
+            permissions: ["authority:5"],
+        });
+        statusCom
+            .subcommand(".dyn", "查看动态监测运行状态")
+            .usage("查看动态监测运行状态")
+            .example("status dyn")
             .action(() => {
             if (this.dynamicDispose) {
-                return '动态监测正在运行';
-            }
-            else {
-                return '动态监测未运行';
+                return "动态监测正在运行";
             }
+            return "动态监测未运行";
         });
-        statusCom.subcommand('.sm', '查看订阅管理对象')
-            .usage('查看订阅管理对象')
-            .example('status sm')
+        statusCom
+            .subcommand(".sm", "查看订阅管理对象")
+            .usage("查看订阅管理对象")
+            .example("status sm")
             .action(async () => {
             this.logger.info(this.subManager);
-            return '查看控制台';
+            return "查看控制台";
         });
         statusCom
-            .subcommand('.bot', '查询当前拥有的机器人信息', { hidden: true })
-            .usage('查询当前拥有的机器人信息')
-            .example('status bot 查询当前拥有的机器人信息')
+            .subcommand(".bot", "查询当前拥有的机器人信息", { hidden: true })
+            .usage("查询当前拥有的机器人信息")
+            .example("status bot 查询当前拥有的机器人信息")
             .action(() => {
-            this.logger.info('开始输出BOT信息');
-            ctx.bots.forEach(bot => {
-                this.logger.info('--------------------------------');
-                this.logger.info('平台：' + bot.platform);
-                this.logger.info('名称：' + bot.user.name);
-                this.logger.info('--------------------------------');
-            });
+            this.logger.info("开始输出BOT信息");
+            for (const bot of ctx.bots) {
+                this.logger.info("--------------------------------");
+                this.logger.info(`平台：${bot.platform}`);
+                this.logger.info(`名称：${bot.user.name}`);
+                this.logger.info("--------------------------------");
+            }
         });
         statusCom
-            .subcommand('.env', '查询当前环境的信息', { hidden: true })
-            .usage('查询当前环境的信息')
-            .example('status env 查询当前环境的信息')
+            .subcommand(".env", "查询当前环境的信息", { hidden: true })
+            .usage("查询当前环境的信息")
+            .example("status env 查询当前环境的信息")
             .action(async ({ session }) => {
             await session.send(`Guild ID:${session.event.guild.id}`);
             await session.send(`Channel ID: ${session.event.channel.id}`);
         });
-        const biliCom = ctx.command('bili', 'bili-notify插件相关指令', { permissions: ['authority:3'] });
-        biliCom.subcommand('.login', '登录B站之后才可以进行之后的操作')
-            .usage('使用二维码登录，登录B站之后才可以进行之后的操作')
-            .example('bili login')
+        const biliCom = ctx.command("bili", "bili-notify插件相关指令", {
+            permissions: ["authority:3"],
+        });
+        biliCom
+            .subcommand(".login", "登录B站之后才可以进行之后的操作")
+            .usage("使用二维码登录，登录B站之后才可以进行之后的操作")
+            .example("bili login")
             .action(async ({ session }) => {
-            this.logger.info('调用bili login指令');
+            this.logger.info("调用bili login指令");
             // 获取二维码
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
             let content;
             try {
                 content = await ctx.ba.getLoginQRCode();
             }
             catch (e) {
-                return 'bili login getLoginQRCode() 本次网络请求失败';
+                return "bili login getLoginQRCode() 本次网络请求失败";
             }
             // 判断是否出问题
             if (content.code !== 0)
-                return await session.send('出问题咯，请联系管理员解决');
+                return await session.send("出问题咯，请联系管理员解决");
             // 生成二维码
             qrcode_1.default.toBuffer(content.data.url, {
-                errorCorrectionLevel: 'H', // 错误更正水平
-                type: 'png', // 输出类型
+                errorCorrectionLevel: "H", // 错误更正水平
+                type: "png", // 输出类型
                 margin: 1, // 边距大小
                 color: {
-                    dark: '#000000', // 二维码颜色
-                    light: '#FFFFFF' // 背景颜色
-                }
+                    dark: "#000000", // 二维码颜色
+                    light: "#FFFFFF", // 背景颜色
+                },
             }, async (err, buffer) => {
                 if (err)
-                    return await session.send('二维码生成出错，请重新尝试');
-                await session.send(koishi_1.h.image(buffer, 'image/png'));
+                    return await session.send("二维码生成出错，请重新尝试");
+                await session.send(koishi_1.h.image(buffer, "image/png"));
             });
             // 检查之前是否存在登录定时器
             if (this.loginTimer)
@@ -137,6 +148,7 @@ class ComRegister {
                         return;
                     flag = false;
                     // 获取登录信息
+                    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
                     let loginContent;
                     try {
                         loginContent = await ctx.ba.getLoginStatus(content.data.qrcode_key);
@@ -147,33 +159,35 @@ class ComRegister {
                     }
                     if (loginContent.code !== 0) {
                         this.loginTimer();
-                        return await session.send('登录失败请重试');
+                        return await session.send("登录失败请重试");
                     }
                     if (loginContent.data.code === 86038) {
                         this.loginTimer();
-                        return await session.send('二维码已失效，请重新登录');
+                        return await session.send("二维码已失效，请重新登录");
                     }
-                    if (loginContent.data.code === 0) { // 登录成功
+                    if (loginContent.data.code === 0) {
+                        // 登录成功
                         const encryptedCookies = ctx.ba.encrypt(ctx.ba.getCookies());
                         const encryptedRefreshToken = ctx.ba.encrypt(loginContent.data.refresh_token);
-                        await ctx.database.upsert('loginBili', [{
+                        await ctx.database.upsert("loginBili", [
+                            {
                                 id: 1,
                                 bili_cookies: encryptedCookies,
-                                bili_refresh_token: encryptedRefreshToken
-                            }]);
+                                bili_refresh_token: encryptedRefreshToken,
+                            },
+                        ]);
                         // 销毁定时器
                         this.loginTimer();
-                        // 订阅之前的订阅
-                        await this.loadSubFromDatabase();
+                        // 订阅手动订阅中的订阅
+                        await this.loadSubFromConfig(config.sub);
                         // 清除控制台通知
                         ctx.ba.disposeNotifier();
                         // 发送成功登录推送
-                        await session.send('登录成功');
+                        await session.send("登录成功");
                         // bili show
-                        await session.execute('bili show');
+                        await session.execute("bili show");
                         // 开启cookies刷新检测
                         ctx.ba.enableRefreshCookiesDetect();
-                        return;
                     }
                 }
                 finally {
@@ -182,428 +196,143 @@ class ComRegister {
             }, 1000);
         });
         biliCom
-            .subcommand('.unsub <uid:string>', '取消订阅UP主动态、直播或全部')
-            .usage('取消订阅，加-l为取消直播订阅，加-d为取消动态订阅，什么都不加则为全部取消')
-            .option('live', '-l')
-            .option('dynamic', '-d')
-            .example('bili unsub 用户UID -ld')
-            .action(async ({ session, options }, uid) => {
-            this.logger.info('调用bili.unsub指令');
-            // 若用户UID为空则直接返回
-            if (!uid)
-                return '用户UID不能为空';
-            // -d -l两个选项不能同时存在
-            if (options.dynamic && options.live)
-                return '需要取消订阅该UP主请直接使用指令bili unsub 用户UID';
-            // 定义是否存在
-            let exist;
-            await Promise.all(this.subManager.map(async (sub, i) => {
-                if (sub.uid === uid) {
-                    // 取消单个订阅
-                    if (options.live || options.dynamic) {
-                        if (options.live)
-                            await session.send(this.unsubSingle(sub.roomId, 0)); /* 0为取消订阅Live */
-                        if (options.dynamic)
-                            await session.send(this.unsubSingle(sub.uid, 1)); /* 1为取消订阅Dynamic */
-                        // 将存在flag设置为true
-                        exist = true;
-                        // 结束循环
-                        return;
-                    }
-                    // 从数据库中删除订阅
-                    await ctx.database.remove('bilibili', { uid: this.subManager[i].uid });
-                    // 将该订阅对象从订阅管理对象中移除
-                    this.subManager.splice(i, 1);
-                    // 将订阅对象移出订阅关注组
-                    const removeUserFromGroupData = await ctx.ba.removeUserFromGroup(sub.uid);
-                    // 判断是否移出成功 22105关注对象为自己
-                    if (removeUserFromGroupData.code !== 0 && removeUserFromGroupData.code !== 22105) {
-                        // 移出失败
-                        await session.send('取消订阅对象失败，请稍后重试');
-                        // 将存在flag设置为true
-                        exist = true;
-                        // 结束循环
-                        return;
-                    }
-                    // id--
-                    this.num--;
-                    // 判断是否还有动态订阅
-                    this.checkIfUserIsTheLastOneWhoSubDyn();
-                    // 发送成功通知
-                    await session.send('已取消订阅该用户');
-                    // 更新控制台提示
-                    this.updateSubNotifier();
-                    // 将存在flag设置为true
-                    exist = true;
-                }
-            }));
-            // 未订阅该用户，无需取消订阅
-            if (!exist)
-                await session.send('未订阅该用户，无需取消订阅');
-        });
-        biliCom
-            .subcommand('.show', '展示订阅对象')
-            .usage('展示订阅对象')
-            .example('bili show')
+            .subcommand(".list", "展示订阅对象")
+            .usage("展示订阅对象")
+            .example("bili list")
             .action(() => {
             const subTable = this.subShow();
             return subTable;
         });
         biliCom
-            .subcommand('.sub <mid:string> [...groupId:string]', '订阅用户动态和直播通知')
-            .option('multiplatform', '-m <value:string>', { type: /^(?:-?[A-Za-z0-9]+@?(?:,-?[A-Za-z0-9]+@?)*\.[A-Za-z0-9]+)(?:;(?:-?[A-Za-z0-9]+@?(?:,-?[A-Za-z0-9]+@?)*\.[A-Za-z0-9]+))*$/ })
-            .option('live', '-l')
-            .option('dynamic', '-d')
-            .option('atAll', '-a')
-            .usage('订阅用户动态和直播通知，若需要订阅直播请加上-l，需要订阅动态则加上-d')
-            .example('bili sub 1194210119 目标群号或频道号 -l -d 订阅UID为1194210119的UP主的动态和直播')
-            .action(async ({ session, options }, mid, ...groupId) => {
-            this.logger.info('调用bili.sub指令');
-            // 先判断是否订阅直播，再判断是否解锁订阅限制，最后判断直播订阅是否已超三个
-            if (options.live && !this.config.unlockSubLimits && (this.subManager.reduce((acc, cur) => acc + (cur.live ? 1 : 0), 0) >= 3)) {
-                return '直播订阅已达上限，请取消部分直播订阅后再进行订阅';
-            }
-            // 检查是否登录
-            if (!(await this.checkIfIsLogin())) {
-                // 未登录直接返回
-                return '请使用指令bili login登录后再进行订阅操作';
-            }
-            // 检查必选参数是否已填
-            if (!mid)
-                return '请输入用户uid';
-            // 订阅对象
-            const subUserData = await this.subUserInBili(mid);
-            // 判断是否订阅对象存在
-            if (!subUserData.flag)
-                return '订阅对象失败，请稍后重试！';
-            // 定义目标变量
-            let target = [];
-            // 判断是否使用了多群组推送
-            if (groupId.length > 0) {
-                // 定义channelIdArr
-                const channelIdArr = [];
-                // 遍历输入的群组
-                groupId.forEach(group => {
-                    channelIdArr.push({
-                        channelId: group,
-                        dynamic: true,
-                        live: true,
-                        liveDanmaku: false,
-                        atAll: options.atAll
-                    });
-                });
-                target.push({
-                    channelIdArr,
-                    platform: session.event.platform
-                });
-            }
-            else {
-                // 判断是否使用多平台功能
-                if (options.multiplatform) {
-                    // 分割字符串，赋值给target
-                    target = this.splitMultiPlatformStr(options.multiplatform);
-                }
-                // 判断是否使用了多平台
-                if (target.length > 0) {
-                    for (const [index, { channelIdArr, platform }] of target.entries()) {
-                        if (channelIdArr.length > 0) { // 输入了推送群号或频道号
-                            // 拿到对应的bot
-                            const bot = this.getBot(platform);
-                            // 判断是否配置了对应平台的机器人
-                            if (!ctx.bots.some(bot => bot.platform === platform)) {
-                                // 发送提示消息
-                                await session.send('您未配置对应平台的机器人，不能在该平台进行订阅操作');
-                                // 直接返回
-                                return;
-                            }
-                            // 判断是否需要加入的群全部推送
-                            if (channelIdArr[0].channelId !== 'all') {
-                                // 定义满足条件的群组数组
-                                const targetArr = [];
-                                // 获取机器人加入的群组
-                                const guildList = await bot.getGuildList();
-                                // 遍历target数组
-                                for (const channelId of channelIdArr) {
-                                    // 定义是否加入群组标志
-                                    let flag = false;
-                                    // 遍历群组
-                                    for (const guild of guildList.data) {
-                                        // 获取频道列表
-                                        const channelList = await bot.getChannelList(guild.id);
-                                        // 判断机器人是否加入群聊或频道
-                                        if (channelList.data.some(channel => channel.id === channelId.channelId)) {
-                                            // 加入群聊或频道
-                                            targetArr.push(channelId);
-                                            // 设置标志位为true
-                                            flag = true;
-                                            // 结束循环
-                                            break;
-                                        }
-                                    }
-                                    if (!flag) {
-                                        // 不满足条件发送错误提示
-                                        await session.send(`您的机器未加入${channelId.channelId}，无法对该群或频道进行推送`);
-                                    }
-                                }
-                                // 判断targetArr是否为空
-                                if (target.length === 0) {
-                                    // 为空则默认为当前环境
-                                    target = [{ channelIdArr: [{ channelId: session.event.channel.id, dynamic: true, live: true, liveDanmaku: false, atAll: options.atAll ? options.atAll : false }], platform: session.event.platform }];
-                                    // 没有满足条件的群组或频道
-                                    await session.send('没有满足条件的群组或频道，默认订阅到当前聊天环境');
-                                }
-                                // 将符合条件的群组添加到target中
-                                target[index].channelIdArr = targetArr;
-                            }
-                            // 如果为all则全部推送，不需要进行处理
-                        }
-                        else {
-                            // 未填写群号或频道号，默认为当前环境
-                            target = [{ channelIdArr: [{ channelId: session.event.channel.id, dynamic: true, live: true, liveDanmaku: false, atAll: options.atAll ? options.atAll : false }], platform: session.event.platform }];
-                            // 发送提示消息
-                            await session.send('没有填写群号或频道号，默认订阅到当前聊天环境');
-                        }
-                    }
-                }
-                else {
-                    // 用户直接订阅，将当前环境赋值给target
-                    target = [{ channelIdArr: [{ channelId: session.event.channel.id, dynamic: true, live: true, liveDanmaku: false, atAll: options.atAll ? options.atAll : false }], platform: session.event.platform }];
-                }
-            }
-            // 定义外围变量                
-            let content;
-            try {
-                // 获取用户信息
-                content = await ctx.ba.getUserInfo(mid);
-            }
-            catch (e) {
-                // 返回错误信息
-                return 'bili sub getUserInfo() 发生了错误，错误为：' + e.message;
-            }
-            // 判断是否成功获取用户信息
-            if (content.code !== 0) {
-                // 定义错误消息
-                let msg;
-                // 判断错误代码
-                switch (content.code) {
-                    case -400:
-                        msg = '请求错误';
-                        break;
-                    case -403:
-                        msg = '访问权限不足，请尝试重新登录';
-                        break;
-                    case -404:
-                        msg = '用户不存在';
-                        break;
-                    case -352:
-                        msg = '风控校验失败，请尝试更换UA';
-                        break;
-                    default:
-                        msg = '未知错误，错误信息：' + content.message;
-                        break;
-                }
-                // 返回错误信息
-                return msg;
-            }
-            // 获取data
-            const { data } = content;
-            // 判断是否需要订阅直播和动态
-            const [liveMsg, dynamicMsg] = await this.checkIfNeedSub(options.live, options.dynamic, session, data.live_room);
-            // 判断是否未订阅任何消息
-            if (!liveMsg && !dynamicMsg)
-                return '您未订阅该UP的任何消息';
-            // 获取到对应的订阅对象
-            const subUser = this.subManager.find(sub => sub.uid === mid);
-            // 判断要订阅的用户是否已经存在于订阅管理对象中
-            if (subUser) {
-                // 已存在，判断是否重复订阅直播通知
-                if (liveMsg && subUser.live) {
-                    return '已订阅该用户直播通知，请勿重复订阅';
-                }
-                // 已存在，判断是否重复订阅动态通知
-                if (dynamicMsg && subUser.dynamic) {
-                    return '已订阅该用户动态通知，请勿重复订阅';
-                }
-            }
-            // 获取直播房间号
-            const roomId = data.live_room?.roomid.toString();
-            // 获取用户信息
-            let userData;
-            try {
-                const { data } = await ctx.ba.getMasterInfo(mid);
-                userData = data;
-            }
-            catch (e) {
-                this.logger.error('bili sub指令 getMasterInfo() 发生了错误，错误为：' + e.message);
-                return '订阅出错啦，请重试';
-            }
-            // 订阅直播
-            if (liveMsg) {
-                // 连接到服务器
-                this.liveDetectWithListener(roomId, target);
-                // 发送订阅消息通知
-                await session.send(`订阅${userData.info.uname}直播通知`);
-            }
-            // 订阅动态
-            if (dynamicMsg) {
-                // 判断是否开启动态监测
-                if (!this.dynamicDispose) {
-                    this.enableDynamicDetect();
-                }
-                // 发送订阅消息通知
-                await session.send(`订阅${userData.info.uname}动态通知`);
-            }
-            // 保存到数据库中
-            const sub = await ctx.database.create('bilibili', {
-                uid: mid,
-                room_id: roomId,
-                dynamic: dynamicMsg ? 1 : 0,
-                live: liveMsg ? 1 : 0,
-                target: JSON.stringify(target),
-                platform: session.event.platform,
-                time: new Date()
-            });
-            // 订阅数+1
-            this.num++;
-            // 保存新订阅对象
-            this.subManager.push({
-                id: sub.id,
-                uid: mid,
-                roomId,
-                target,
-                platform: session.event.platform,
-                live: liveMsg,
-                dynamic: dynamicMsg,
-            });
-            // 新增订阅展示到控制台
-            this.updateSubNotifier();
-        });
-        biliCom
-            .subcommand('.status <roomId:string>', '查询主播当前直播状态', { hidden: true })
-            .usage('查询主播当前直播状态')
-            .example('bili status 732')
-            .action(async ({ session }, roomId) => {
-            this.logger.info('调用bili.status指令');
-            if (!roomId)
-                return session.send('请输入房间号!');
-            let content;
-            try {
-                content = await ctx.ba.getLiveRoomInfo(roomId);
-            }
-            catch (e) {
-                return 'bili status指令 getLiveRoomInfo() 发生了错误，错误为：' + e.message;
-            }
-            const { data } = content;
-            let userData;
-            try {
-                const { data: userInfo } = await ctx.ba.getMasterInfo(data.uid);
-                userData = userInfo;
-            }
-            catch (e) {
-                return 'bili status指令 getMasterInfo() 发生了错误，错误为：' + e.message;
-            }
-            // B站出问题了
-            if (content.code !== 0) {
-                if (content.msg === '未找到该房间') {
-                    session.send('未找到该房间');
-                }
-                else {
-                    session.send('未知错误，错误信息为：' + content.message);
-                }
-                return;
-            }
-            const { pic, buffer } = await ctx.gi.generateLiveImg(data, userData.info.uname, userData.info.face, data.live_status !== 1 ?
-                LiveType.NotLiveBroadcast :
-                LiveType.LiveBroadcast);
-            // pic 存在，使用的是render模式
-            if (pic)
-                return pic;
-            // pic不存在，说明使用的是page模式
-            await session.send(koishi_1.h.image(buffer, 'image/png'));
-        });
-        biliCom
-            .subcommand('.private', '向主人账号发送一条测试消息', { hidden: true })
-            .usage('向主人账号发送一条测试消息')
-            .example('bili private 向主人账号发送一条测试消息')
+            .subcommand(".private", "向主人账号发送一条测试消息", { hidden: true })
+            .usage("向主人账号发送一条测试消息")
+            .example("bili private 向主人账号发送一条测试消息")
             .action(async ({ session }) => {
             // 发送消息
-            await this.sendPrivateMsg('Hello World');
+            await this.sendPrivateMsg("Hello World");
             // 发送提示
-            await session.send('已发送消息，如未收到则说明您的机器人不支持发送私聊消息或您的信息填写有误');
+            await session.send("已发送消息，如未收到则说明您的机器人不支持发送私聊消息或您的信息填写有误");
         });
     }
     async init(config) {
         // 设置logger
-        this.logger = this.ctx.logger('cr');
+        this.logger = this.ctx.logger("cr");
+        // logger
+        this.logger.info("加载订阅中...");
         // 将config设置给类属性
         this.config = config;
         // 拿到私人机器人实例
-        this.privateBot = this.ctx.bots.find(bot => bot.platform === config.master.platform);
+        this.privateBot = this.ctx.bots.find((bot) => bot.platform === config.master.platform);
         if (!this.privateBot) {
             this.ctx.notifier.create({
-                content: '您未配置私人机器人，将无法向您推送机器人状态！'
+                content: "您未配置私人机器人，将无法向您推送机器人状态！",
             });
-            this.logger.error('您未配置私人机器人，将无法向您推送机器人状态！');
         }
         // 判断消息发送方式
         if (config.automaticResend) {
-            this.sendMsgFunc = async (bot, channelId, content) => {
-                // 多次尝试发送消息
-                const attempts = 3;
-                for (let i = 0; i < attempts; i++) {
-                    try {
-                        // 发送消息
-                        await bot.sendMessage(channelId, content);
-                        // 防止消息发送速度过快被忽略
-                        await this.ctx.sleep(500);
-                        // 成功发送消息，跳出循环
-                        break;
-                    }
-                    catch (e) {
-                        if (i === attempts - 1) { // 已尝试三次
-                            this.logger.error(`发送群组ID:${channelId}消息失败！原因: ` + e.message);
-                            console.log(e);
-                            this.sendPrivateMsg(`发送群组ID:${channelId}消息失败，请查看日志`);
-                        }
+            this.sendMsgFunc = async (
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+            bot, channelId, 
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+            content) => {
+                (0, utils_1.withRetry)(async () => await bot.sendMessage(channelId, content)).catch(async (e) => {
+                    if (e.message === "this._request is not a function") {
+                        // 2S之后重新发送消息
+                        this.ctx.setTimeout(async () => {
+                            await this.sendMsgFunc(bot, channelId, content);
+                        }, 2000);
+                        // 返回
+                        return;
                     }
-                }
+                    // 打印错误信息
+                    this.logger.error(`发送群组ID:${channelId}消息失败！原因: ${e.message}`);
+                    await this.sendPrivateMsg(`发送群组ID:${channelId}消息失败，请查看日志`);
+                });
             };
         }
         else {
-            this.sendMsgFunc = async (bot, guild, content) => {
+            this.sendMsgFunc = async (
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+            bot, channelId, 
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+            content) => {
                 try {
                     // 发送消息
-                    await bot.sendMessage(guild, content);
+                    await bot.sendMessage(channelId, content);
                 }
                 catch (e) {
-                    this.logger.error(`发送群组ID:${guild}消息失败！原因: ` + e.message);
-                    await this.sendPrivateMsg(`发送群组ID:${guild}消息失败，请查看日志`);
+                    if (e.message === "this._request is not a function") {
+                        // 2S之后重新发送消息
+                        this.ctx.setTimeout(async () => {
+                            await this.sendMsgFunc(bot, channelId, content);
+                        }, 2000);
+                        // 返回
+                        return;
+                    }
+                    // 打印错误信息
+                    this.logger.error(`发送群组ID:${channelId}消息失败！原因: ${e.message}`);
+                    await this.sendPrivateMsg(`发送群组ID:${channelId}消息失败，请查看日志`);
                 }
             };
         }
         // 检查登录数据库是否有数据
-        this.loginDBData = (await this.ctx.database.get('loginBili', 1, ['dynamic_group_id']))[0];
+        this.loginDBData = (await this.ctx.database.get("loginBili", 1, ["dynamic_group_id"]))[0];
+        // 判断登录信息是否已加载完毕
+        await this.checkIfLoginInfoIsLoaded();
+        // 如果未登录，则直接返回
+        if (!(await this.checkIfIsLogin())) {
+            // log
+            this.logger.info("账号未登录，请登录");
+            return;
+        }
         // 从配置获取订阅
-        config.sub && await this.loadSubFromConfig(config.sub);
-        // 从数据库获取订阅
-        await this.loadSubFromDatabase();
+        config.sub && (await this.loadSubFromConfig(config.sub));
         // 检查是否需要动态监测
         this.checkIfDynamicDetectIsNeeded();
         // 在控制台中显示订阅对象
         this.updateSubNotifier();
+        // logger
+        this.logger.info("订阅加载完毕！");
     }
-    splitMultiPlatformStr(str) {
-        return str.split(';').map(cv => cv.split('.')).map(([idStr, platform]) => {
-            const channelIdArr = idStr.split(',').map(id => {
-                const atAll = /@$/.test(id); // 使用正则表达式检查 id 是否以 @ 结尾
-                const channelId = atAll ? id.slice(0, -1) : id; // 去除末尾的 @
-                return { channelId, dynamic: true, live: true, liveDanmaku: false, atAll };
-            });
-            return { channelIdArr, platform };
-        });
-    }
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
     getBot(pf) {
-        return this.ctx.bots.find(bot => bot.platform === pf);
+        return this.ctx.bots.find((bot) => bot.platform === pf);
+    }
+    // TODO:WordCloud
+    async test_wordCloud() {
+        /* const currentLiveDanmakuArr = []
+        // 定义获取弹幕权重Record函数
+        const getDanmakuWeightRecord = (): Record<string, number> => {
+            // 创建segmentit
+            const segmentit = useDefault(new Segment());
+            // 创建Record
+            const danmakuWeightRecord: Record<string, number> = {};
+            // 循环遍历currentLiveDanmakuArr
+            for (const danmaku of currentLiveDanmakuArr) {
+                // 遍历结果
+                segmentit.doSegment(danmaku).map((word: { w: string; p: number }) => {
+                    // 定义权重
+                    danmakuWeightRecord[word.w] = (danmakuWeightRecord[word.w] || 0) + 1;
+                });
+            }
+            // 返回Record
+            return danmakuWeightRecord;
+        }; */
+        // Test
+        const testTarget = [
+            {
+                channelIdArr: [
+                    {
+                        channelId: "635762054",
+                        dynamic: true,
+                        live: false,
+                        liveGuardBuy: false,
+                        atAll: false,
+                    },
+                ],
+                platform: "qqguild",
+            },
+        ];
     }
     async sendPrivateMsg(content) {
         if (this.config.master.enable) {
@@ -621,9 +350,9 @@ class ComRegister {
         // 判断重启次数是否超过三次
         if (this.rebootCount >= 3) {
             // logger
-            this.logger.error('已重启插件三次，请检查机器人状态后使用指令 sys start 启动插件');
+            this.logger.error("已重启插件三次，请检查机器人状态后使用指令 sys start 启动插件");
             // 重启失败，发送消息
-            await this.sendPrivateMsg('已重启插件三次，请检查机器人状态后使用指令 sys start 启动插件');
+            await this.sendPrivateMsg("已重启插件三次，请检查机器人状态后使用指令 sys start 启动插件");
             // 关闭插件
             await this.ctx.sm.disposePlugin();
             // 结束
@@ -632,32 +361,33 @@ class ComRegister {
         // 重启次数+1
         this.rebootCount++;
         // logger
-        this.logger.info('插件出现未知错误，正在重启插件');
+        this.logger.info("插件出现未知错误，正在重启插件");
         // 重启插件
         const flag = await this.ctx.sm.restartPlugin();
         // 判断是否重启成功
         if (flag) {
-            this.logger.info('重启插件成功');
+            this.logger.info("重启插件成功");
         }
         else {
             // logger
-            this.logger.error('重启插件失败，请检查机器人状态后使用指令 sys start 启动插件');
+            this.logger.error("重启插件失败，请检查机器人状态后使用指令 sys start 启动插件");
             // 重启失败，发送消息
-            await this.sendPrivateMsg('重启插件失败，请检查机器人状态后使用指令 sys start 启动插件');
+            await this.sendPrivateMsg("重启插件失败，请检查机器人状态后使用指令 sys start 启动插件");
             // 关闭插件
             await this.ctx.sm.disposePlugin();
         }
     }
     async sendPrivateMsgAndStopService() {
         // 发送消息
-        await this.sendPrivateMsg('插件发生未知错误，请检查机器人状态后使用指令 sys start 启动插件');
+        await this.sendPrivateMsg("插件发生未知错误，请检查机器人状态后使用指令 sys start 启动插件");
         // logger
-        this.logger.error('插件发生未知错误，请检查机器人状态后使用指令 sys start 启动插件');
+        this.logger.error("插件发生未知错误，请检查机器人状态后使用指令 sys start 启动插件");
         // 关闭插件
         await this.ctx.sm.disposePlugin();
         // 结束
         return;
     }
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
     async sendMsg(targets, content, live) {
         for (const target of targets) {
             // 获取机器人实例
@@ -665,15 +395,15 @@ class ComRegister {
             // 定义需要发送的数组
             let sendArr = [];
             // 判断是否需要推送所有机器人加入的群
-            if (target.channelIdArr[0].channelId === 'all') {
+            if (target.channelIdArr[0].channelId === "all") {
                 // 获取所有guild
                 for (const guild of (await bot.getGuildList()).data) {
                     sendArr.push({
                         channelId: guild.id,
                         dynamic: target.channelIdArr[0].dynamic,
                         live: target.channelIdArr[0].live,
-                        liveDanmaku: target.channelIdArr[0].liveDanmaku,
-                        atAll: target.channelIdArr[0].atAll
+                        liveGuardBuy: target.channelIdArr[0].liveGuardBuy,
+                        atAll: target.channelIdArr[0].atAll,
                     });
                 }
             }
@@ -696,7 +426,7 @@ class ComRegister {
             }
             else {
                 for (const channel of sendArr) {
-                    // 判断是否需要推送动态消息和直播消息
+                    // 判断是否需要推送动态消息
                     if (channel.dynamic || channel.live) {
                         await this.sendMsgFunc(bot, channel.channelId, content);
                     }
@@ -724,7 +454,7 @@ class ComRegister {
                 // 检测启动初始化
                 if (detectSetup) {
                     // 获取动态信息
-                    const data = await this.ctx.ba.getAllDynamic();
+                    const data = (await this.ctx.ba.getAllDynamic());
                     // 判断获取动态信息是否成功
                     if (data.code !== 0)
                         return;
@@ -737,6 +467,7 @@ class ComRegister {
                 }
                 // 获取用户所有动态数据
                 let updateNum;
+                // biome-ignore lint/suspicious/noExplicitAny: <explanation>
                 let content;
                 try {
                     // 查询是否有新动态
@@ -746,46 +477,50 @@ class ComRegister {
                     if (updateNum <= 0 || data.code !== 0)
                         return;
                     // 获取动态内容
-                    content = await this.ctx.ba.getAllDynamic(updateBaseline);
+                    content = (await this.ctx.ba.getAllDynamic(updateBaseline));
                 }
                 catch (e) {
-                    return this.logger.error('dynamicDetect getUserSpaceDynamic() 发生了错误，错误为：' + e.message);
+                    return this.logger.error(`dynamicDetect getUserSpaceDynamic() 发生了错误，错误为：${e.message}`);
                 }
                 // 判断获取动态内容是否成功
                 if (content.code !== 0) {
                     switch (content.code) {
-                        case -101: { // 账号未登录
+                        case -101: {
+                            // 账号未登录
                             // 输出日志
-                            this.logger.error('账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件');
+                            this.logger.error("账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件");
                             // 发送私聊消息
-                            await this.sendPrivateMsg('账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件');
+                            await this.sendPrivateMsg("账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件");
                             // 停止服务
                             await this.ctx.sm.disposePlugin();
                             // 结束循环
                             break;
                         }
-                        case -352: { // 风控
+                        case -352: {
+                            // 风控
                             // 输出日志
-                            this.logger.error('账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件');
+                            this.logger.error("账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件");
                             // 发送私聊消息
-                            await this.sendPrivateMsg('账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件');
+                            await this.sendPrivateMsg("账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件");
                             // 停止服务
                             await this.ctx.sm.disposePlugin();
                             // 结束循环
                             break;
                         }
                         case 4101128:
-                        case 4101129: { // 获取动态信息错误
+                        case 4101129: {
+                            // 获取动态信息错误
                             // 输出日志
-                            this.logger.error('获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message);
+                            this.logger.error(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`);
                             // 发送私聊消息
-                            await this.sendPrivateMsg('获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
+                            await this.sendPrivateMsg(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`); // 未知错误
                             // 结束循环
                             break;
                         }
-                        default: { // 未知错误
+                        default: {
+                            // 未知错误
                             // 发送私聊消息
-                            await this.sendPrivateMsg('获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
+                            await this.sendPrivateMsg(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`); // 未知错误
                             // 结束循环
                             break;
                         }
@@ -805,9 +540,11 @@ class ComRegister {
                     // 从动态数据中取出UP主名称、UID和动态ID
                     const upUID = items[num].modules.module_author.mid;
                     // 寻找关注的UP主的动态
-                    this.subManager.forEach(async (sub) => {
+                    for (const sub of this.subManager) {
                         // 判断是否是订阅的UP主
-                        if (sub.dynamic && sub.uid == upUID) { // 订阅该UP主，推送该动态
+                        // biome-ignore lint/suspicious/noDoubleEquals: <explanation>
+                        if (sub.dynamic && sub.uid == upUID) {
+                            // 订阅该UP主，推送该动态
                             // 判断更新动态是否为1条
                             if (updateNum === 1) {
                                 // 判断dynamicIdStr是否有值，是否与当前动态ID一致
@@ -839,16 +576,16 @@ class ComRegister {
                                 }
                                 catch (e) {
                                     // 直播开播动态，不做处理
-                                    if (e.message === '直播开播动态，不做处理')
+                                    if (e.message === "直播开播动态，不做处理")
                                         return;
-                                    if (e.message === '出现关键词，屏蔽该动态') {
+                                    if (e.message === "出现关键词，屏蔽该动态") {
                                         // 如果需要发送才发送
                                         if (this.config.filter.notify) {
                                             await this.sendMsg(sub.target, `${upName}发布了一条含有屏蔽关键字的动态`);
                                         }
                                         return;
                                     }
-                                    if (e.message === '已屏蔽转发动态') {
+                                    if (e.message === "已屏蔽转发动态") {
                                         if (this.config.filter.notify) {
                                             await this.sendMsg(sub.target, `${upName}发布了一条转发动态，已屏蔽`);
                                         }
@@ -856,30 +593,32 @@ class ComRegister {
                                     }
                                     // 未知错误
                                     if (i === attempts - 1) {
-                                        this.logger.error('dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：' + e.message);
+                                        this.logger.error(`dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：${e.message}`);
                                         // 发送私聊消息并重启服务
                                         return await this.sendPrivateMsgAndStopService();
                                     }
                                 }
                             }
                             // 判断是否需要发送URL
-                            const dUrl = this.config.dynamicUrl ? `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}` : '';
+                            const dUrl = this.config.dynamicUrl
+                                ? `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}`
+                                : "";
                             // 如果pic存在，则直接返回pic
                             if (pic) {
-                                this.logger.info('推送动态中，使用render模式');
+                                this.logger.info("推送动态中，使用render模式");
                                 // pic存在，使用的是render模式
-                                await this.sendMsg(sub.target, pic + (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: dUrl }));
+                                await this.sendMsg(sub.target, pic + dUrl);
                             }
                             else if (buffer) {
-                                this.logger.info('推送动态中，使用page模式');
+                                this.logger.info("推送动态中，使用page模式");
                                 // pic不存在，说明使用的是page模式
-                                await this.sendMsg(sub.target, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, 'image/png'), dUrl] }));
+                                await this.sendMsg(sub.target, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, "image/png"), dUrl] }));
                             }
                             else {
-                                this.logger.info(items[num].modules.module_author.name + '发布了一条动态，但是推送失败');
+                                this.logger.info(`${items[num].modules.module_author.name}发布了一条动态，但是推送失败`);
                             }
                         }
-                    });
+                    }
                 }
             }
             finally {
@@ -908,7 +647,7 @@ class ComRegister {
                 // 检测启动初始化
                 if (detectSetup) {
                     // 获取动态信息
-                    const data = await this.ctx.ba.getAllDynamic();
+                    const data = (await this.ctx.ba.getAllDynamic());
                     // 判断获取动态信息是否成功
                     if (data.code !== 0)
                         return;
@@ -922,59 +661,65 @@ class ComRegister {
                 }
                 // 获取用户所有动态数据
                 let updateNum;
+                // biome-ignore lint/suspicious/noExplicitAny: <explanation>
                 let content;
                 try {
                     // 查询是否有新动态
                     const data = await this.ctx.ba.hasNewDynamic(updateBaseline);
                     updateNum = data.data.update_num;
+                    // biome-ignore lint/style/noUnusedTemplateLiteral: <explanation>
                     console.log(`获取是否有新动态：`);
                     console.log(data);
                     // 没有新动态或获取动态信息失败直接返回
                     if (updateNum <= 0 || data.code !== 0)
                         return;
                     // 获取动态内容
-                    content = await this.ctx.ba.getAllDynamic(updateBaseline);
-                    console.log('获取动态内容：');
+                    content = (await this.ctx.ba.getAllDynamic(updateBaseline));
+                    console.log("获取动态内容：");
                     console.log(content.data.items[0]);
                 }
                 catch (e) {
-                    return this.logger.error('dynamicDetect getUserSpaceDynamic() 发生了错误，错误为：' + e.message);
+                    return this.logger.error(`dynamicDetect getUserSpaceDynamic() 发生了错误，错误为：${e.message}`);
                 }
                 // 判断获取动态内容是否成功
                 if (content.code !== 0) {
                     switch (content.code) {
-                        case -101: { // 账号未登录
+                        case -101: {
+                            // 账号未登录
                             // 输出日志
-                            this.logger.error('账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件');
+                            this.logger.error("账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件");
                             // 发送私聊消息
-                            await this.sendPrivateMsg('账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件');
+                            await this.sendPrivateMsg("账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件");
                             // 停止服务
                             await this.ctx.sm.disposePlugin();
                             // 结束循环
                             break;
                         }
-                        case -352: { // 风控
+                        case -352: {
+                            // 风控
                             // 输出日志
-                            this.logger.error('账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件');
+                            this.logger.error("账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件");
                             // 发送私聊消息
-                            await this.sendPrivateMsg('账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件');
+                            await this.sendPrivateMsg("账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件");
                             // 停止服务
                             await this.ctx.sm.disposePlugin();
                             // 结束循环
                             break;
                         }
                         case 4101128:
-                        case 4101129: { // 获取动态信息错误
+                        case 4101129: {
+                            // 获取动态信息错误
                             // 输出日志
-                            this.logger.error('获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message);
+                            this.logger.error(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`);
                             // 发送私聊消息
-                            await this.sendPrivateMsg('获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
+                            await this.sendPrivateMsg(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`); // 未知错误
                             // 结束循环
                             break;
                         }
-                        default: { // 未知错误
+                        default: {
+                            // 未知错误
                             // 发送私聊消息
-                            await this.sendPrivateMsg('获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
+                            await this.sendPrivateMsg(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`); // 未知错误
                             // 结束循环
                             break;
                         }
@@ -990,7 +735,7 @@ class ComRegister {
                 // 检查更新的动态
                 for (let num = updateNum - 1; num >= 0; num--) {
                     // 有更新动态
-                    console.log('有更新动态');
+                    console.log("有更新动态");
                     // 没有动态内容则直接跳过
                     if (!items[num])
                         continue;
@@ -1000,10 +745,12 @@ class ComRegister {
                     const dynamicId = content.data.items[num].id_str;
                     console.log(`寻找关注的UP主，当前动态UP主：${upName}，UID：${upUID}，动态ID：${dynamicId}`);
                     // 寻找关注的UP主的动态
-                    this.subManager.forEach(async (sub) => {
+                    for (const sub of this.subManager) {
                         console.log(`当前订阅UP主：${sub.uid}`);
                         // 判断是否是订阅的UP主
-                        if (sub.dynamic && sub.uid == upUID) { // 订阅该UP主，推送该动态
+                        // biome-ignore lint/suspicious/noDoubleEquals: <explanation>
+                        if (sub.dynamic && sub.uid == upUID) {
+                            // 订阅该UP主，推送该动态
                             // 判断更新动态是否为1条
                             if (updateNum === 1) {
                                 // 判断dynamicIdStr是否有值，是否与当前动态ID一致
@@ -1036,16 +783,16 @@ class ComRegister {
                                 }
                                 catch (e) {
                                     // 直播开播动态，不做处理
-                                    if (e.message === '直播开播动态，不做处理')
+                                    if (e.message === "直播开播动态，不做处理")
                                         return;
-                                    if (e.message === '出现关键词，屏蔽该动态') {
+                                    if (e.message === "出现关键词，屏蔽该动态") {
                                         // 如果需要发送才发送
                                         if (this.config.filter.notify) {
                                             await this.sendMsg(sub.target, `${upName}发布了一条含有屏蔽关键字的动态`);
                                         }
                                         return;
                                     }
-                                    if (e.message === '已屏蔽转发动态') {
+                                    if (e.message === "已屏蔽转发动态") {
                                         if (this.config.filter.notify) {
                                             await this.sendMsg(sub.target, `${upName}发布了一条转发动态，已屏蔽`);
                                         }
@@ -1053,30 +800,32 @@ class ComRegister {
                                     }
                                     // 未知错误
                                     if (i === attempts - 1) {
-                                        this.logger.error('dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：' + e.message);
+                                        this.logger.error(`dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：${e.message}`);
                                         // 发送私聊消息并重启服务
                                         return await this.sendPrivateMsgAndStopService();
                                     }
                                 }
                             }
                             // 判断是否需要发送URL
-                            const dUrl = this.config.dynamicUrl ? `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}` : '';
+                            const dUrl = this.config.dynamicUrl
+                                ? `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}`
+                                : "";
                             // 如果pic存在，则直接返回pic
                             if (pic) {
-                                this.logger.info('推送动态中，使用render模式');
+                                this.logger.info("推送动态中，使用render模式");
                                 // pic存在，使用的是render模式
-                                await this.sendMsg(sub.target, pic + (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: dUrl }));
+                                await this.sendMsg(sub.target, pic + dUrl);
                             }
                             else if (buffer) {
-                                this.logger.info('推送动态中，使用page模式');
+                                this.logger.info("推送动态中，使用page模式");
                                 // pic不存在，说明使用的是page模式
-                                await this.sendMsg(sub.target, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, 'image/png'), dUrl] }));
+                                await this.sendMsg(sub.target, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, "image/png"), dUrl] }));
                             }
                             else {
-                                this.logger.info(items[num].modules.module_author.name + '发布了一条动态，但是推送失败');
+                                this.logger.info(`${items[num].modules.module_author.name}发布了一条动态，但是推送失败`);
                             }
                         }
-                    });
+                    }
                 }
             }
             finally {
@@ -1085,7 +834,7 @@ class ComRegister {
         };
     }
     // 定义发送直播通知卡片方法
-    async sendLiveNotifyCard(info, liveType, liveNotifyMsg) {
+    async sendLiveNotifyCard(info, liveType, followerDisplay, liveNotifyMsg) {
         // 定义变量
         let pic;
         let buffer;
@@ -1094,7 +843,7 @@ class ComRegister {
         for (let i = 0; i < attempts; i++) {
             try {
                 // 获取直播通知卡片
-                const { pic: picv, buffer: bufferv } = await this.ctx.gi.generateLiveImg(info.data, info.username, info.userface, liveType);
+                const { pic: picv, buffer: bufferv } = await this.ctx.gi.generateLiveImg(info.data, info.username, info.userface, followerDisplay, liveType);
                 // 赋值
                 pic = picv;
                 buffer = bufferv;
@@ -1102,8 +851,9 @@ class ComRegister {
                 break;
             }
             catch (e) {
-                if (i === attempts - 1) { // 已尝试三次
-                    this.logger.error('liveDetect generateLiveImg() 推送卡片生成失败，原因：' + e.message);
+                if (i === attempts - 1) {
+                    // 已尝试三次
+                    this.logger.error(`liveDetect generateLiveImg() 推送卡片生成失败，原因：${e.message}`);
                     // 发送私聊消息并重启服务
                     return await this.sendPrivateMsgAndStopService();
                 }
@@ -1113,28 +863,61 @@ class ComRegister {
         // pic 存在，使用的是render模式
         if (pic) {
             // 只有在开播时才艾特全体成员
-            if (liveType === LiveType.StartBroadcasting) {
-                return await this.sendMsg(info.target, pic + (liveNotifyMsg ?? ''), true);
+            if (liveType === type_1.LiveType.StartBroadcasting) {
+                return await this.sendMsg(info.target, pic + (liveNotifyMsg ?? ""), true);
             }
             // 正常不需要艾特全体成员
-            return await this.sendMsg(info.target, pic + (liveNotifyMsg ?? ''));
+            return await this.sendMsg(info.target, pic + (liveNotifyMsg ?? ""));
         }
         // pic不存在，说明使用的是page模式
-        const msg = (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, 'image/png'), liveNotifyMsg || ''] });
+        const msg = ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, "image/png"), liveNotifyMsg || ""] }));
         // 只有在开播时才艾特全体成员
-        if (liveType === LiveType.StartBroadcasting) {
+        if (liveType === type_1.LiveType.StartBroadcasting) {
             return await this.sendMsg(info.target, msg, true);
         }
         // 正常不需要艾特全体成员
         return await this.sendMsg(info.target, msg);
     }
     // 定义获取主播信息方法
-    async useMasterInfo(uid) {
+    async useMasterInfo(uid, masterInfo, liveType) {
+        // 获取主播信息
         const { data } = await this.ctx.ba.getMasterInfo(uid);
-        return { username: data.info.uname, userface: data.info.face, roomId: data.room_id };
+        // 定义粉丝数变量
+        let liveOpenFollowerNum;
+        let liveEndFollowerNum;
+        let liveFollowerChange;
+        // 判断直播状态
+        if (liveType === type_1.LiveType.StartBroadcasting ||
+            liveType === type_1.LiveType.FirstLiveBroadcast) {
+            // 第一次启动或刚开播
+            // 将当前粉丝数赋值给liveOpenFollowerNum、liveEndFollowerNum
+            liveOpenFollowerNum = data.follower_num;
+            liveEndFollowerNum = data.follower_num;
+            // 将粉丝数变化赋值为0
+            liveFollowerChange = 0;
+        }
+        if (liveType === type_1.LiveType.StopBroadcast ||
+            liveType === type_1.LiveType.LiveBroadcast) {
+            // 将上一次的liveOpenFollowerNum赋值给本次的liveOpenFollowerNum
+            liveOpenFollowerNum = masterInfo.liveOpenFollowerNum;
+            // 将当前粉丝数赋值给liveEndFollowerNum
+            liveEndFollowerNum = data.follower_num;
+            // 计算粉丝数变化量
+            liveFollowerChange = liveEndFollowerNum - masterInfo.liveOpenFollowerNum;
+        }
+        // 返回值
+        return {
+            username: data.info.uname,
+            userface: data.info.face,
+            roomId: data.room_id,
+            liveOpenFollowerNum,
+            liveEndFollowerNum,
+            liveFollowerChange,
+        };
     }
     async useLiveRoomInfo(roomId) {
         // 发送请求获取直播间信息
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
         let content;
         const attempts = 3;
         for (let i = 0; i < attempts; i++) {
@@ -1145,8 +928,9 @@ class ComRegister {
                 break;
             }
             catch (e) {
-                this.logger.error('liveDetect getLiveRoomInfo 发生了错误，错误为：' + e.message);
-                if (i === attempts - 1) { // 已尝试三次
+                this.logger.error(`liveDetect getLiveRoomInfo 发生了错误，错误为：${e.message}`);
+                if (i === attempts - 1) {
+                    // 已尝试三次
                     // 发送私聊消息并重启服务
                     return await this.sendPrivateMsgAndStopService();
                 }
@@ -1154,210 +938,6 @@ class ComRegister {
         }
         return content.data;
     }
-    async liveDetectWithAPI() {
-        // 定义变量：第一次订阅
-        let firstSubscription = true;
-        // 定义变量：timer计时器
-        let timer = 0;
-        // 相当于锁的作用，防止上一个循环没处理完
-        let flag = true;
-        // 定义订阅对象Record 0未开播 1正在直播 2轮播中
-        const liveRecord = {};
-        // 初始化subRecord
-        this.subManager.forEach(sub => {
-            // 判断是否订阅直播
-            if (sub.live) {
-                // 将该订阅添加到subRecord中
-                liveRecord[sub.uid] = { liveStatus: 0, liveTime: '', target: sub.target };
-            }
-        });
-        // 定义函数: 发送请求获取直播状态
-        const useLiveStatus = async (roomId) => {
-            let content;
-            const attempts = 3;
-            for (let i = 0; i < attempts; i++) {
-                try {
-                    // 发送请求获取room信息
-                    content = await this.ctx.ba.getLiveRoomInfo(roomId);
-                    // 成功则跳出循环
-                    break;
-                }
-                catch (e) {
-                    this.logger.error('liveDetect getLiveRoomInfo 发生了错误，错误为：' + e.message);
-                    if (i === attempts - 1) { // 已尝试三次
-                        // 发送私聊消息并重启服务
-                        return await this.sendPrivateMsgAndStopService();
-                    }
-                }
-            }
-            // 返回data
-            return content.data;
-        };
-        return async () => {
-            // 如果flag为false则说明前面的代码还未执行完，则直接返回
-            if (!flag)
-                return;
-            // 将标志位置为false
-            flag = false;
-            try {
-                // 获取正在直播对象
-                const liveUsers = await this.ctx.ba.getTheUserWhoIsLiveStreaming();
-                // 判断是否是第一次订阅
-                if (firstSubscription) {
-                    // 将第一次订阅置为false
-                    firstSubscription = false;
-                    // 先判断是否有UP主正在直播
-                    if (liveUsers.count > 0) {
-                        // 遍历liveUsers
-                        liveUsers.items.forEach(async (item) => {
-                            // 判断是否有订阅对象正在直播
-                            if (liveRecord[item.mid]) {
-                                // 获取当前用户直播间信息
-                                const data = await useLiveStatus(item.room_id.toString());
-                                // 设置开播时间
-                                liveRecord[item.mid].liveTime = data.live_time;
-                                // 设置直播中消息
-                                const liveMsg = this.config.customLive ? this.config.customLive
-                                    .replace('-name', item.uname)
-                                    .replace('-time', await this.ctx.gi.getTimeDifference(liveRecord[item.mid].liveTime))
-                                    .replace('-link', `https://live.bilibili.com/${data.short_id === 0 ? data.room_id : data.short_id}`) : null;
-                                // 发送直播通知卡片
-                                if (this.config.restartPush)
-                                    this.sendLiveNotifyCard({
-                                        username: item.uname,
-                                        userface: item.face,
-                                        target: liveRecord[item.mid].target,
-                                        data
-                                    }, LiveType.LiveBroadcast, liveMsg);
-                                // 改变开播状态
-                                liveRecord[item.mid].liveStatus = 1;
-                            }
-                        });
-                    }
-                    // 没有正在直播的订阅对象，直接返回
-                    return;
-                }
-                // 获取当前订阅直播的数量
-                const currentLiveSubs = this.subManager.filter(sub => sub.live);
-                // 获取当前liveRecord里的订阅数量
-                const currentLiveRecordKeys = Object.keys(liveRecord);
-                // 判断是否能匹配双方数量
-                if (currentLiveRecordKeys.length < currentLiveSubs.length) {
-                    // 遍历currentLiveSubs
-                    for (const sub of currentLiveSubs) {
-                        // 判断liveRecord中缺少了哪些订阅
-                        if (!liveRecord[sub.uid]) {
-                            // 获取当前用户直播间信息
-                            const data = await useLiveStatus(sub.roomId.toString());
-                            switch (data.live_status) {
-                                case 0:
-                                case 2: { // 未开播
-                                    // 添加到liveRecord中
-                                    liveRecord[sub.uid] = { liveStatus: 0, liveTime: '', target: sub.target };
-                                    // break
-                                    break;
-                                }
-                                case 1: { //正在直播
-                                    // 添加到liveRecord中
-                                    liveRecord[sub.uid] = { liveStatus: 1, liveTime: data.live_time, target: sub.target };
-                                }
-                            }
-                        }
-                    }
-                }
-                if (currentLiveRecordKeys.length > currentLiveSubs.length) {
-                    // 创建Set
-                    const setCurrentLiveSubs = new Set(currentLiveSubs.map(sub => sub.uid));
-                    // 找出 currentLiveRecordKeys中比currentLiveSubs 多的元素
-                    const extraInCurrentLiveSubs = currentLiveRecordKeys.filter(key => !setCurrentLiveSubs.has(key));
-                    // 遍历 extraInCurrentLiveSubs 
-                    for (const subUID of extraInCurrentLiveSubs) {
-                        // 删除记录
-                        delete liveRecord[subUID];
-                    }
-                }
-                // 数量没有差异，则不进行其他操作
-                // 遍历liveUsers
-                liveUsers.items.forEach(async (item) => {
-                    // 判断是否有正在直播的订阅对象
-                    if (liveRecord[item.mid]) { // 有正在直播的订阅对象
-                        // 获取当前用户直播间信息
-                        const data = await useLiveStatus(item.room_id.toString());
-                        // 判断开播状态
-                        switch (liveRecord[item.mid].liveStatus) {
-                            case 0: { // 之前未开播，现在开播了
-                                // 设置开播时间
-                                liveRecord[item.mid].liveTime = data.live_time;
-                                // 定义开播通知语                            
-                                const liveStartMsg = this.config.customLiveStart ? this.config.customLiveStart
-                                    .replace('-name', item.uname)
-                                    .replace('-time', await this.ctx.gi.getTimeDifference(liveRecord[item.mid].liveTime))
-                                    .replace('-link', `https://live.bilibili.com/${data.short_id === 0 ? data.room_id : data.short_id}`) : null;
-                                // 发送直播通知卡片
-                                await this.sendLiveNotifyCard({
-                                    username: item.uname,
-                                    userface: item.face,
-                                    target: liveRecord[item.mid].target,
-                                    data
-                                }, LiveType.LiveBroadcast, liveStartMsg);
-                                // 改变开播状态
-                                liveRecord[item.mid].liveStatus = 1;
-                                // 结束
-                                break;
-                            }
-                            case 1: { // 仍在直播
-                                if (this.config.pushTime > 0) {
-                                    timer++;
-                                    // 开始记录时间
-                                    if (timer >= (6 * 60 * this.config.pushTime)) { // 到时间推送直播消息
-                                        // 到时间重新计时
-                                        timer = 0;
-                                        // 定义直播中通知消息
-                                        const liveMsg = this.config.customLive ? this.config.customLive
-                                            .replace('-name', item.uname)
-                                            .replace('-time', await this.ctx.gi.getTimeDifference(liveRecord[item.mid].liveTime))
-                                            .replace('-link', `https://live.bilibili.com/${data.short_id === 0 ? data.room_id : data.short_id}`) : null;
-                                        // 发送直播通知卡片
-                                        this.sendLiveNotifyCard({
-                                            username: item.uname,
-                                            userface: item.face,
-                                            target: liveRecord[item.mid].target,
-                                            data
-                                        }, LiveType.LiveBroadcast, liveMsg);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                });
-                // 找出liveRecord中liveStatus为1但liveUsers中没有的元素
-                const extraInLiveRecord = currentLiveRecordKeys.filter(key => !liveUsers.items.some(item => item.mid === Number(key)));
-                // 遍历 extraInLiveRecord
-                for (const subUID of extraInLiveRecord) { // 下播的主播
-                    // 获取主播信息
-                    const masterInfo = await this.useMasterInfo(subUID);
-                    // 获取直播间消息
-                    const liveRoomInfo = await this.useLiveRoomInfo(masterInfo.roomId.toString());
-                    // 定义下播播通知语                            
-                    const liveEndMsg = this.config.customLiveEnd ? this.config.customLiveEnd
-                        .replace('-name', masterInfo.username)
-                        .replace('-time', await this.ctx.gi.getTimeDifference(liveRecord[subUID].liveTime))
-                        .replace('-link', `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`) : null;
-                    // 发送下播通知
-                    this.sendLiveNotifyCard({
-                        username: masterInfo.username,
-                        userface: masterInfo.userface,
-                        target: liveRecord[subUID].target,
-                        data: liveRoomInfo
-                    }, LiveType.StopBroadcast, liveEndMsg);
-                }
-            }
-            finally {
-                // 执行完方法体不论如何都把flag设置为true
-                flag = true;
-            }
-        };
-    }
     async liveDetectWithListener(roomId, target) {
         // 定义开播时间
         let liveTime;
@@ -1365,180 +945,236 @@ class ComRegister {
         let pushAtTimeTimer;
         // 定义弹幕存放数组
         const currentLiveDanmakuArr = [];
-        const temporaryLiveDanmakuArr = [];
+        // 定义开播状态
+        let liveStatus = false;
         // 处理target
+        // 定义channelIdArr总长度
+        let channelIdArrLen = 0;
+        // 定义数据
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        let liveRoomInfo;
+        let masterInfo;
+        let watchedNum;
         // 找到频道/群组对应的
-        const newTarget = target.map(channel => {
-            const liveDanmakuArr = channel.channelIdArr.filter(channelId => channelId.liveDanmaku);
+        const liveGuardBuyPushTargetArr = target.map((channel) => {
+            // 获取符合条件的target
+            const liveGuardBuyArr = channel.channelIdArr.filter((channelId) => channelId.liveGuardBuy);
+            // 将当前liveDanmakuArr的长度+到channelIdArrLen中
+            channelIdArrLen += liveGuardBuyArr.length;
+            // 返回符合的target
             return {
-                channelIdArr: liveDanmakuArr,
-                platform: channel.platform
+                channelIdArr: liveGuardBuyArr,
+                platform: channel.platform,
             };
         });
         // 定义定时推送函数
         const pushAtTimeFunc = async () => {
-            // 获取直播间信息
-            const liveRoomInfo = await this.useLiveRoomInfo(roomId);
-            // 获取主播信息
-            const masterInfo = await this.useMasterInfo(liveRoomInfo.uid);
-            // 定义直播中通知消息
-            const liveMsg = this.config.customLive ? this.config.customLive
-                .replace('-name', masterInfo.username)
-                .replace('-time', await this.ctx.gi.getTimeDifference(liveTime))
-                .replace('-link', `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`) : null;
+            // 判断是否信息是否获取成功
+            if (!(await useMasterAndLiveRoomInfo(type_1.LiveType.LiveBroadcast))) {
+                // 未获取成功，直接返回
+                return this.sendPrivateMsg("获取直播间信息失败，推送直播卡片失败！");
+            }
+            // 设置开播时间
+            liveTime = liveRoomInfo.live_time;
+            // 获取watched
+            const watched = watchedNum || "暂未获取到";
+            // 设置直播中消息
+            const liveMsg = this.config.customLive
+                ? this.config.customLive
+                    .replace("-name", masterInfo.username)
+                    .replace("-time", await this.ctx.gi.getTimeDifference(liveTime))
+                    .replace("-watched", watched)
+                    .replace("-link", `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`)
+                : null;
             // 发送直播通知卡片
             await this.sendLiveNotifyCard({
                 username: masterInfo.username,
                 userface: masterInfo.userface,
-                target: newTarget,
-                data: liveRoomInfo
-            }, LiveType.LiveBroadcast, liveMsg);
+                target,
+                data: liveRoomInfo,
+            }, type_1.LiveType.LiveBroadcast, watched, liveMsg);
         };
-        // 定义弹幕推送函数
-        const danmakuPushFunc = () => {
-            // 判断数组是否有内容
-            if (temporaryLiveDanmakuArr.length > 0) {
-                // 发送消息
-                this.sendMsg(newTarget, temporaryLiveDanmakuArr.join('\n'));
-                // 将临时消息数组清空
-                temporaryLiveDanmakuArr.length = 0;
+        // 定义直播间信息获取函数
+        const useMasterAndLiveRoomInfo = async (liveType) => {
+            // 定义函数是否执行成功flag
+            let flag = true;
+            // 获取直播间信息
+            liveRoomInfo = await this.useLiveRoomInfo(roomId).catch(() => {
+                // 设置flag为false
+                flag = false;
+                // 返回空
+                return null;
+            });
+            // 判断是否成功获取信息
+            if (!flag || !liveRoomInfo || !liveRoomInfo.uid) {
+                // 上一步未成功
+                flag = false;
+                // 返回flag
+                return flag;
             }
+            // 获取主播信息(需要满足flag为true，liveRoomInfo.uid有值)
+            masterInfo = await this.useMasterInfo(liveRoomInfo.uid, masterInfo, liveType).catch(() => {
+                // 设置flag为false
+                flag = false;
+                // 返回空
+                return null;
+            });
+            // 返回信息
+            return flag;
         };
-        // 获取直播间信息
-        const liveRoomInfo = await this.useLiveRoomInfo(roomId);
-        // 获取主播信息
-        const masterInfo = await this.useMasterInfo(liveRoomInfo.uid);
         // 构建消息处理函数
         const handler = {
-            onOpen: () => {
-                this.logger.info('直播间连接成功');
-            },
-            onClose: () => {
-                this.logger.info('直播间连接已断开');
-            },
             onIncomeDanmu: ({ body }) => {
-                // 处理消息，只需要UP主名字和消息内容
-                const content = `【${masterInfo.username}的直播间】${body.user.uname}：${body.content}`;
                 // 保存消息到数组
                 currentLiveDanmakuArr.push(body.content);
-                temporaryLiveDanmakuArr.push(content);
             },
             onIncomeSuperChat: ({ body }) => {
-                // 处理SC消息
-                const content = `【${masterInfo.username}的直播间】${body.user.uname}发送了一条SC：${body.content}`;
                 // 保存消息到数组
                 currentLiveDanmakuArr.push(body.content);
-                temporaryLiveDanmakuArr.push(content);
+            },
+            onWatchedChange: ({ body }) => {
+                // 保存观看人数到变量
+                watchedNum = body.text_small;
             },
             onGuardBuy: ({ body }) => {
-                const content = `【${masterInfo.username}的直播间】${body.user.uname}加入了大航海（${body.gift_name}）`;
-                // 保存消息到数组
-                currentLiveDanmakuArr.push(content);
-                temporaryLiveDanmakuArr.push(content);
+                // 定义消息
+                const content = `${body.user.uname}加入了大航海（${body.gift_name}）`;
+                // 直接发送消息
+                channelIdArrLen > 0 && this.sendMsg(liveGuardBuyPushTargetArr, content);
             },
             onLiveStart: async () => {
-                // 获取直播间信息
-                const liveRoomInfo = await this.useLiveRoomInfo(roomId);
-                // 获取主播信息
-                const masterInfo = await this.useMasterInfo(liveRoomInfo.uid);
-                // 定义下播通知消息
-                const liveEndMsg = this.config.customLiveEnd ? this.config.customLiveEnd
-                    .replace('-name', masterInfo.username)
-                    .replace('-time', await this.ctx.gi.getTimeDifference(liveTime)) : null;
-                // 更改直播时长
-                liveRoomInfo.live_time = liveTime;
-                // 推送下播通知
+                // 判断是否已经开播
+                if (liveStatus)
+                    return;
+                // 设置开播状态为true
+                liveStatus = true;
+                // 判断是否信息是否获取成功
+                if (!(await useMasterAndLiveRoomInfo(type_1.LiveType.StartBroadcasting))) {
+                    // 设置开播状态为false
+                    liveStatus = false;
+                    // 未获取成功，直接返回
+                    return await this.sendPrivateMsg("获取直播间信息失败，推送直播开播卡片失败！");
+                }
+                // 设置开播时间
+                liveTime = liveRoomInfo.live_time;
+                // 获取当前粉丝数
+                const follower = masterInfo.liveOpenFollowerNum >= 10_000
+                    ? `${(masterInfo.liveOpenFollowerNum / 10000).toFixed(1)}万`
+                    : masterInfo.liveOpenFollowerNum.toString();
+                // 定义开播通知语
+                const liveStartMsg = this.config.customLiveStart
+                    ? this.config.customLiveStart
+                        .replace("-name", masterInfo.username)
+                        .replace("-time", await this.ctx.gi.getTimeDifference(liveTime))
+                        .replace("-follower", follower)
+                        .replace("-link", `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`)
+                    : null;
+                // 推送开播通知
                 await this.sendLiveNotifyCard({
                     username: masterInfo.username,
                     userface: masterInfo.userface,
-                    target: newTarget,
-                    data: liveRoomInfo
-                }, LiveType.StopBroadcast, liveEndMsg);
+                    target,
+                    data: liveRoomInfo,
+                }, type_1.LiveType.StartBroadcasting, follower, liveStartMsg);
+                // 判断定时器是否已开启
+                if (!pushAtTimeTimer) {
+                    // 开始直播，开启定时器
+                    pushAtTimeTimer = this.ctx.setInterval(pushAtTimeFunc, this.config.pushTime * 1000 * 60 * 60);
+                }
             },
             onLiveEnd: async () => {
-                // 获取直播间消息
-                const liveRoomInfo = await this.useLiveRoomInfo(roomId);
-                // 获取主播信息
-                const masterInfo = await this.useMasterInfo(liveRoomInfo.uid);
-                // 关闭定时推送定时器
-                pushAtTimeTimer();
-                // 将推送定时器变量置空
-                pushAtTimeTimer = null;
-                // 定义下播播通知语                            
-                const liveEndMsg = this.config.customLiveEnd ? this.config.customLiveEnd
-                    .replace('-name', masterInfo.username)
-                    .replace('-time', await this.ctx.gi.getTimeDifference(liveTime))
-                    .replace('-link', `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`) : null;
+                // 将直播状态设置为false
+                liveStatus = false;
+                // 判断是否信息是否获取成功
+                if (!(await useMasterAndLiveRoomInfo(type_1.LiveType.StopBroadcast))) {
+                    // 未获取成功，直接返回
+                    return this.sendPrivateMsg("获取直播间信息失败，推送直播下播卡片失败！");
+                }
+                // 更改直播时长
+                liveRoomInfo.live_time = liveTime;
+                // 获取粉丝数变化
+                const followerChange = (() => {
+                    // 获取直播关注变化值
+                    const liveFollowerChangeNum = masterInfo.liveFollowerChange;
+                    // 判断是否大于0
+                    if (liveFollowerChangeNum > 0) {
+                        // 大于0则加+
+                        return liveFollowerChangeNum >= 10_000
+                            ? `+${liveFollowerChangeNum.toFixed(1)}万`
+                            : `+${liveFollowerChangeNum}`;
+                    }
+                    // 小于0
+                    return liveFollowerChangeNum <= -10_000
+                        ? `${liveFollowerChangeNum.toFixed(1)}万`
+                        : liveFollowerChangeNum.toString();
+                })();
+                // 定义下播播通知语
+                const liveEndMsg = this.config.customLiveEnd
+                    ? this.config.customLiveEnd
+                        .replace("-name", masterInfo.username)
+                        .replace("-time", await this.ctx.gi.getTimeDifference(liveTime))
+                        .replace("-follower_change", followerChange)
+                    : null;
                 // 推送通知卡片
                 await this.sendLiveNotifyCard({
                     username: masterInfo.username,
                     userface: masterInfo.userface,
-                    target: newTarget,
-                    data: liveRoomInfo
-                }, LiveType.StartBroadcasting, liveEndMsg);
-            }
+                    target,
+                    data: liveRoomInfo,
+                }, type_1.LiveType.StopBroadcast, followerChange, liveEndMsg);
+                // 关闭定时推送定时器
+                pushAtTimeTimer();
+                // 将推送定时器变量置空
+                pushAtTimeTimer = null;
+            },
         };
         // 启动直播间弹幕监测
-        this.ctx.bl.startLiveRoomListener(roomId, handler, danmakuPushFunc);
+        await this.ctx.bl.startLiveRoomListener(roomId, handler);
+        // 第一次启动获取信息并判信息是否获取成功
+        if (!(await useMasterAndLiveRoomInfo(type_1.LiveType.FirstLiveBroadcast))) {
+            // 未获取成功，直接返回
+            return this.sendPrivateMsg("获取直播间信息失败，启动直播间弹幕检测失败！");
+        }
         // 判断直播状态
         if (liveRoomInfo.live_status === 1) {
             // 设置开播时间
             liveTime = liveRoomInfo.live_time;
+            // 获取当前累计观看人数
+            const watched = watchedNum || "暂未获取到";
             // 定义直播中通知消息
-            const liveMsg = this.config.customLive ? this.config.customLive
-                .replace('-name', masterInfo.username)
-                .replace('-time', await this.ctx.gi.getTimeDifference(liveTime))
-                .replace('-link', `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`) : null;
+            const liveMsg = this.config.customLive
+                ? this.config.customLive
+                    .replace("-name", masterInfo.username)
+                    .replace("-time", await this.ctx.gi.getTimeDifference(liveTime))
+                    .replace("-watched", watched)
+                    .replace("-link", `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`)
+                : null;
             // 发送直播通知卡片
             if (this.config.restartPush) {
                 await this.sendLiveNotifyCard({
                     username: masterInfo.username,
                     userface: masterInfo.userface,
-                    target: newTarget,
-                    data: liveRoomInfo
-                }, LiveType.LiveBroadcast, liveMsg);
+                    target,
+                    data: liveRoomInfo,
+                }, type_1.LiveType.LiveBroadcast, watched, liveMsg);
             }
             // 正在直播，开启定时器
-            pushAtTimeTimer = this.ctx.setInterval(pushAtTimeFunc, this.config.pushTime * 1000 * 60 * 60);
+            // 判断定时器是否已开启
+            if (!pushAtTimeTimer) {
+                // 开始直播，开启定时器
+                pushAtTimeTimer = this.ctx.setInterval(pushAtTimeFunc, this.config.pushTime * 1000 * 60 * 60);
+            }
+            // 设置直播状态为true
+            liveStatus = true;
         }
     }
     subShow() {
         // 在控制台中显示订阅对象
-        let table = ``;
-        this.subManager.forEach(sub => {
-            table += `UID:${sub.uid}  ${sub.dynamic ? '已订阅动态' : ''}  ${sub.live ? '已订阅直播' : ''}` + '\n';
-        });
-        return table ? table : '没有订阅任何UP';
-    }
-    async checkIfNeedSub(liveSub, dynamicSub, session, liveRoomData) {
-        // 定义方法：用户直播间是否存在
-        const liveRoom = async () => {
-            if (!liveRoomData) {
-                // 未开通直播间
-                await session.send('该用户未开通直播间，无法订阅直播');
-                // 返回false
-                return true;
-            }
-            return false;
-        };
-        // 如果两者都为true或者都为false则直接返回
-        if ((liveSub && dynamicSub) || (!liveSub && !dynamicSub)) {
-            // 判断是否存在直播间
-            if (await liveRoom())
-                return [false, true];
-            // 返回
-            return [true, true];
-        }
-        // 如果只订阅直播
-        if (liveSub) {
-            // 判断是否存在直播间
-            if (await liveRoom())
-                return [false, false];
-            // 返回
-            return [true, false];
+        let table = "";
+        for (const sub of this.subManager) {
+            table += `UID:${sub.uid}  ${sub.dynamic ? "已订阅动态" : ""}  ${sub.live ? "已订阅直播" : ""}\n`;
         }
-        // 只订阅动态
-        return [false, true];
+        return table ? table : "没有订阅任何UP";
     }
     updateSubNotifier() {
         // 更新控制台提示
@@ -1547,28 +1183,30 @@ class ComRegister {
         // 获取订阅信息
         const subInfo = this.subShow();
         // 定义table
-        let table = '';
-        if (subInfo === '没有订阅任何UP') {
+        let table = "";
+        if (subInfo === "没有订阅任何UP") {
             table = subInfo;
         }
         else {
             // 获取subTable
-            const subTableArray = subInfo.split('\n');
+            const subTableArray = subInfo.split("\n");
             subTableArray.splice(subTableArray.length - 1, 1);
             // 定义Table
-            table = (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [(0, jsx_runtime_1.jsx)("p", { children: "\u5F53\u524D\u8BA2\u9605\u5BF9\u8C61\uFF1A" }), (0, jsx_runtime_1.jsx)("ul", { children: subTableArray.map(str => ((0, jsx_runtime_1.jsx)("li", { children: str }))) })] });
+            table = ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [(0, jsx_runtime_1.jsx)("p", { children: "\u5F53\u524D\u8BA2\u9605\u5BF9\u8C61\uFF1A" }), (0, jsx_runtime_1.jsx)("ul", { children: subTableArray.map((str) => (
+                        // biome-ignore lint/correctness/useJsxKeyInIterable: <explanation>
+                        (0, jsx_runtime_1.jsx)("li", { children: str }))) })] }));
         }
         // 设置更新后的提示
         this.subNotifier = this.ctx.notifier.create(table);
     }
     async checkIfLoginInfoIsLoaded() {
-        return new Promise(resolve => {
+        return new Promise((resolve) => {
             const check = () => {
                 if (!this.ctx.ba.getLoginInfoIsLoaded()) {
                     this.ctx.setTimeout(check, 500);
                 }
                 else {
-                    resolve('success');
+                    resolve("success");
                 }
             };
             check();
@@ -1578,7 +1216,8 @@ class ComRegister {
         // 获取关注分组信息
         const checkGroupIsReady = async () => {
             // 判断是否有数据
-            if (this.loginDBData.dynamic_group_id === '' || this.loginDBData.dynamic_group_id === null) {
+            if (this.loginDBData.dynamic_group_id === "" ||
+                this.loginDBData.dynamic_group_id === null) {
                 // 没有数据，没有创建分组，尝试创建分组
                 const createGroupData = await this.ctx.ba.createGroup("订阅");
                 // 如果分组已创建，则获取分组id
@@ -1588,7 +1227,7 @@ class ComRegister {
                     // 遍历所有分组
                     for (const group of allGroupData.data) {
                         // 找到订阅分组
-                        if (group.name === '订阅') {
+                        if (group.name === "订阅") {
                             // 拿到分组id
                             this.loginDBData.dynamic_group_id = group.tagid;
                             // 结束循环
@@ -1602,7 +1241,9 @@ class ComRegister {
                     return false;
                 }
                 // 创建成功，保存到数据库
-                this.ctx.database.set('loginBili', 1, { dynamic_group_id: this.loginDBData.dynamic_group_id });
+                this.ctx.database.set("loginBili", 1, {
+                    dynamic_group_id: this.loginDBData.dynamic_group_id,
+                });
                 // 创建成功
                 return true;
             }
@@ -1613,7 +1254,7 @@ class ComRegister {
         // 判断是否创建成功
         if (!flag) {
             // 创建分组失败
-            return { flag: false, msg: '创建分组失败，请尝试重启插件' };
+            return { flag: false, msg: "创建分组失败，请尝试重启插件" };
         }
         // 获取分组明细
         const relationGroupDetailData = await this.ctx.ba.getRelationGroupDetail(this.loginDBData.dynamic_group_id);
@@ -1627,51 +1268,67 @@ class ComRegister {
                 // 判断是否创建成功
                 if (!flag) {
                     // 创建分组失败
-                    return { flag: false, msg: '创建分组失败，请尝试重启插件' };
+                    return { flag: false, msg: "创建分组失败，请尝试重启插件" };
                 }
-                return { flag: true, msg: '分组不存在，已重新创建分组' };
+                return { flag: true, msg: "分组不存在，已重新创建分组" };
             }
             // 获取分组明细失败
-            return { flag: false, msg: '获取分组明细失败' };
+            return { flag: false, msg: "获取分组明细失败" };
         }
-        relationGroupDetailData.data.forEach(user => {
+        for (const user of relationGroupDetailData.data) {
             if (user.mid === mid) {
                 // 已关注订阅对象
-                return { flag: true, msg: '订阅对象已存在于分组中' };
+                return { flag: true, msg: "订阅对象已存在于分组中" };
             }
-        });
+        }
         // 订阅对象
         const subUserData = await this.ctx.ba.follow(mid);
         // 判断是否订阅成功
         switch (subUserData.code) {
-            case -101: return { flag: false, msg: '账号未登录，请使用指令bili login登录后再进行订阅操作' };
-            case -102: return { flag: false, msg: '账号被封停，无法进行订阅操作' };
-            case 22002: return { flag: false, msg: '因对方隐私设置，无法进行订阅操作' };
-            case 22003: return { flag: false, msg: '你已将对方拉黑，无法进行订阅操作' };
-            case 22013: return { flag: false, msg: '账号已注销，无法进行订阅操作' };
-            case 40061: return { flag: false, msg: '账号不存在，请检查uid输入是否正确或用户是否存在' };
-            case 22001: break; // 订阅对象为自己 无需添加到分组
+            case -101:
+                return {
+                    flag: false,
+                    msg: "账号未登录，请使用指令bili login登录后再进行订阅操作",
+                };
+            case -102:
+                return { flag: false, msg: "账号被封停，无法进行订阅操作" };
+            case 22002:
+                return { flag: false, msg: "因对方隐私设置，无法进行订阅操作" };
+            case 22003:
+                return { flag: false, msg: "你已将对方拉黑，无法进行订阅操作" };
+            case 22013:
+                return { flag: false, msg: "账号已注销，无法进行订阅操作" };
+            case 40061:
+                return {
+                    flag: false,
+                    msg: "账号不存在，请检查uid输入是否正确或用户是否存在",
+                };
+            case 22001:
+                break; // 订阅对象为自己 无需添加到分组
             case 22014: // 已关注订阅对象 无需再次关注
-            case 0: { // 执行订阅成功
+            case 0: {
+                // 执行订阅成功
                 // 把订阅对象添加到分组中
                 const copyUserToGroupData = await this.ctx.ba.copyUserToGroup(mid, this.loginDBData.dynamic_group_id);
                 // 判断是否添加成功
                 if (copyUserToGroupData.code !== 0) {
                     // 添加失败
-                    return { flag: false, msg: '添加订阅对象到分组失败，请稍后重试' };
+                    return { flag: false, msg: "添加订阅对象到分组失败，请稍后重试" };
                 }
             }
         }
         // 订阅成功
-        return { flag: true, msg: '用户订阅成功' };
+        return { flag: true, msg: "用户订阅成功" };
     }
     async loadSubFromConfig(subs) {
         for (const sub of subs) {
             // 定义Data
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
             let data;
             // 判断是否需要订阅直播
             if (sub.live) {
                 // 获取用户信息
+                // biome-ignore lint/suspicious/noExplicitAny: <explanation>
                 let content;
                 // 设置重试次数
                 const attempts = 3;
@@ -1683,8 +1340,9 @@ class ComRegister {
                         break;
                     }
                     catch (e) {
-                        this.logger.error('getSubFromDatabase() getUserInfo() 发生了错误，错误为：' + e.message);
-                        if (i === attempts - 1) { // 已尝试三次
+                        this.logger.error(`loadSubFromConfig() getUserInfo() 发生了错误，错误为：${e.message}`);
+                        if (i === attempts - 1) {
+                            // 已尝试三次
                             // 发送私聊消息并重启服务
                             return await this.sendPrivateMsgAndStopService();
                         }
@@ -1701,8 +1359,8 @@ class ComRegister {
                 }
                 // 判断是否订阅直播
                 if (sub.live) {
-                    // 订阅直播
-                    this.liveDetectWithListener(data.live_room.roomid, sub.target);
+                    // 启动直播监测
+                    await this.liveDetectWithListener(data.live_room.roomid, sub.target);
                 }
             }
             // 在B站中订阅该对象
@@ -1714,151 +1372,17 @@ class ComRegister {
             this.subManager.push({
                 id: +sub.uid,
                 uid: sub.uid,
-                roomId: sub.live ? data.live_room.roomid : '',
+                roomId: sub.live ? data.live_room.roomid : "",
                 target: sub.target,
-                platform: '',
+                platform: "",
                 live: sub.live,
-                dynamic: sub.dynamic
+                dynamic: sub.dynamic,
             });
         }
     }
-    async loadSubFromDatabase() {
-        // 判断登录信息是否已加载完毕
-        await this.checkIfLoginInfoIsLoaded();
-        // 如果未登录，则直接返回
-        if (!(await this.checkIfIsLogin())) {
-            // log
-            this.logger.info(`账号未登录，请登录`);
-            return;
-        }
-        // 已存在订阅管理对象，不再进行订阅操作
-        if (this.subManager.length !== 0)
-            return;
-        // 从数据库中获取数据
-        const subData = await this.ctx.database.get('bilibili', { id: { $gt: 0 } });
-        // 定义变量：订阅直播数
-        let liveSubNum = 0;
-        // 循环遍历
-        for (const sub of subData) {
-            // 判断是否存在没有任何订阅的数据
-            if (!sub.dynamic && !sub.live) { // 存在未订阅任何项目的数据
-                // 删除该条数据
-                this.ctx.database.remove('bilibili', { id: sub.id });
-                // log
-                this.logger.warn(`UID:${sub.uid} 该条数据没有任何订阅数据，自动取消订阅`);
-                // 跳过下面的步骤
-                continue;
-            }
-            // 判断用户是否在B站中订阅了
-            const subUserData = await this.subUserInBili(sub.uid);
-            // 判断是否订阅
-            if (!subUserData.flag) {
-                // log
-                this.logger.warn(`UID:${sub.uid} ${subUserData.msg}，自动取消订阅`);
-                // 发送私聊消息
-                await this.sendPrivateMsg(`UID:${sub.uid} ${subUserData.msg}，自动取消订阅`);
-                // 删除该条数据
-                await this.ctx.database.remove('bilibili', { id: sub.id });
-                // 跳过下面的步骤
-                continue;
-            }
-            // 获取推送目标数组
-            const target = JSON.parse(sub.target);
-            /* 判断数据库是否被篡改 */
-            // 获取用户信息
-            let content;
-            const attempts = 3;
-            for (let i = 0; i < attempts; i++) {
-                try {
-                    // 获取用户信息
-                    content = await this.ctx.ba.getUserInfo(sub.uid);
-                    // 成功则跳出循环
-                    break;
-                }
-                catch (e) {
-                    this.logger.error('getSubFromDatabase() getUserInfo() 发生了错误，错误为：' + e.message);
-                    if (i === attempts - 1) { // 已尝试三次
-                        // 发送私聊消息并重启服务
-                        return await this.sendPrivateMsgAndStopService();
-                    }
-                }
-            }
-            // 获取data
-            const { data } = content;
-            // 定义函数删除数据和发送提示
-            const deleteSub = async () => {
-                // 从数据库删除该条数据
-                await this.ctx.database.remove('bilibili', { id: sub.id });
-                // 给用户发送提示
-                await this.sendPrivateMsg(`UID:${sub.uid} 数据库内容被篡改，已取消对该UP主的订阅`);
-            };
-            // 判断是否有其他问题
-            if (content.code !== 0) {
-                switch (content.code) {
-                    case -352:
-                    case -403: {
-                        await this.sendPrivateMsg('你的登录信息已过期，请重新登录Bilibili');
-                        return;
-                    }
-                    case -400:
-                    case -404:
-                    default: {
-                        await deleteSub();
-                        // PrivateMsg
-                        await this.sendPrivateMsg(`UID:${sub.uid} 数据出现问题，自动取消订阅`);
-                        // log
-                        this.logger.info(`UID:${sub.uid} 数据出现问题，自动取消订阅`);
-                        return;
-                    }
-                }
-            }
-            // 检测房间号是否被篡改
-            if (sub.live && (!data.live_room || data.live_room.roomid != sub.room_id)) {
-                // 房间号被篡改，删除该订阅
-                await deleteSub();
-                // log
-                this.logger.info(`UID:${sub.uid} 房间号被篡改，自动取消订阅`);
-                // Send msg
-                await this.sendPrivateMsg(`UID:${sub.uid} 房间号被篡改，自动取消订阅`);
-                // 直接返回
-                return;
-            }
-            // 构建订阅对象
-            const subManagerItem = {
-                id: sub.id,
-                uid: sub.uid,
-                roomId: sub.room_id,
-                target,
-                platform: sub.platform,
-                live: sub.live === 1 ? true : false,
-                dynamic: sub.dynamic === 1 ? true : false,
-                liveDispose: null
-            };
-            // 判断是否订阅直播
-            if (sub.live) {
-                // 判断订阅直播数是否超过限制
-                if (!this.config.unlockSubLimits && liveSubNum >= 3) {
-                    // 将live改为false
-                    subManagerItem.live = false;
-                    // log
-                    this.logger.warn(`UID:${sub.uid} 订阅直播数超过限制，自动取消订阅`);
-                    // 发送错误消息
-                    await this.sendPrivateMsg(`UID:${sub.uid} 订阅直播数超过限制，自动取消订阅`);
-                }
-                else {
-                    // 直播订阅数+1
-                    liveSubNum++;
-                    // 订阅直播，开始循环检测
-                    this.liveDetectWithListener(sub.room_id, target);
-                }
-            }
-            // 保存新订阅对象
-            this.subManager.push(subManagerItem);
-        }
-    }
     checkIfDynamicDetectIsNeeded() {
         // 检查是否有订阅对象需要动态监测
-        if (this.subManager.some(sub => sub.dynamic))
+        if (this.subManager.some((sub) => sub.dynamic))
             this.enableDynamicDetect();
     }
     enableDynamicDetect() {
@@ -1870,110 +1394,12 @@ class ComRegister {
             this.dynamicDispose = this.ctx.setInterval(this.dynamicDetect(), this.config.dynamicLoopTime * 1000);
         }
     }
-    unsubSingle(id /* UID或RoomId */, type /* 0取消Live订阅，1取消Dynamic订阅 */) {
-        // 定义返回消息
-        let msg;
-        // 定义方法：检查是否没有任何订阅
-        const checkIfNoSubExist = (sub) => !sub.dynamic && !sub.live;
-        // 定义方法：将订阅对象从订阅管理对象中移除
-        const removeSub = (index) => {
-            // 从管理对象中移除
-            this.subManager.splice(index, 1);
-            // 从数据库中删除
-            this.ctx.database.remove('bilibili', [this.subManager[index].id]);
-            // num--
-            this.num--;
-            // 判断是否还存在订阅了动态的对象，不存在则停止动态监测
-            this.checkIfUserIsTheLastOneWhoSubDyn();
-        };
-        try {
-            switch (type) {
-                case 0: { // 取消Live订阅
-                    // 获取订阅对象所在的索引
-                    const index = this.subManager.findIndex(sub => sub.roomId === id);
-                    // 获取订阅对象
-                    const sub = this.subManager.find(sub => sub.roomId === id);
-                    // 判断是否存在订阅对象
-                    if (!sub) {
-                        msg = '未订阅该用户，无需取消订阅';
-                        return msg;
-                    }
-                    // 取消订阅
-                    sub.live = false;
-                    // 如果没有对这个UP的任何订阅，则移除
-                    if (checkIfNoSubExist(sub)) {
-                        // 从管理对象中移除
-                        removeSub(index);
-                        return '已取消订阅该用户';
-                    }
-                    // 更新数据库
-                    this.ctx.database.upsert('bilibili', [{
-                            id: +`${sub.id}`,
-                            live: 0
-                        }]);
-                    return '已取消订阅Live';
-                }
-                case 1: { // 取消Dynamic订阅
-                    // 获取订阅对象所在的索引
-                    const index = this.subManager.findIndex(sub => sub.uid === id);
-                    // 获取订阅对象
-                    const sub = this.subManager.find(sub => sub.uid === id);
-                    // 判断是否存在订阅对象
-                    if (!sub) {
-                        msg = '未订阅该用户，无需取消订阅';
-                        return msg;
-                    }
-                    // 取消订阅
-                    this.subManager[index].dynamic = false;
-                    // 判断是否还存在订阅了动态的对象，不存在则停止动态监测
-                    this.checkIfUserIsTheLastOneWhoSubDyn();
-                    // 如果没有对这个UP的任何订阅，则移除
-                    if (checkIfNoSubExist(sub)) {
-                        // 从管理对象中移除
-                        removeSub(index);
-                        return '已取消订阅该用户';
-                    }
-                    // 更新数据库
-                    this.ctx.database.upsert('bilibili', [{
-                            id: sub.id,
-                            dynamic: 0
-                        }]);
-                    return '已取消订阅Dynamic';
-                }
-            }
-        }
-        finally {
-            // 执行完该方法后，保证执行一次updateSubNotifier()
-            this.updateSubNotifier();
-        }
-    }
-    checkIfUserIsTheLastOneWhoSubDyn() {
-        if (this.dynamicDispose && !this.subManager.some(sub => sub.dynamic)) {
-            // 停止动态监测
-            this.dynamicDispose();
-            this.dynamicDispose = null;
-        }
-    }
-    unsubAll(uid) {
-        this.subManager.filter(sub => sub.uid === uid).map(async (sub, i) => {
-            // 判断是否还存在订阅了动态的对象，不存在则停止动态监测
-            this.checkIfUserIsTheLastOneWhoSubDyn();
-            // 从数据库中删除订阅
-            await this.ctx.database.remove('bilibili', { uid: this.subManager[i].uid });
-            // 将该订阅对象从订阅管理对象中移除
-            this.subManager.splice(i, 1);
-            // id--
-            this.num--;
-            // 发送成功通知
-            this.sendPrivateMsg(`UID:${uid}，已取消订阅该用户`);
-            // 更新控制台提示
-            this.updateSubNotifier();
-        });
-    }
     async checkIfIsLogin() {
-        if ((await this.ctx.database.get('loginBili', 1)).length !== 0) { // 数据库中有数据
+        if ((await this.ctx.database.get("loginBili", 1)).length !== 0) {
+            // 数据库中有数据
             // 检查cookie中是否有值
-            if (this.ctx.ba.getCookies() !== '[]') { // 有值说明已登录
+            if (this.ctx.ba.getCookies() !== "[]") {
+                // 有值说明已登录
                 return true;
             }
         }
@@ -1983,28 +1409,33 @@ class ComRegister {
 (function (ComRegister) {
     ComRegister.Config = koishi_1.Schema.object({
         sub: koishi_1.Schema.array(koishi_1.Schema.object({
-            uid: koishi_1.Schema.string().description('订阅用户UID'),
-            dynamic: koishi_1.Schema.boolean().description('是否订阅用户动态'),
-            live: koishi_1.Schema.boolean().description('是否订阅用户直播'),
+            uid: koishi_1.Schema.string().description("订阅用户UID"),
+            dynamic: koishi_1.Schema.boolean().description("是否订阅用户动态"),
+            live: koishi_1.Schema.boolean().description("是否订阅用户直播"),
             target: koishi_1.Schema.array(koishi_1.Schema.object({
                 channelIdArr: koishi_1.Schema.array(koishi_1.Schema.object({
-                    channelId: koishi_1.Schema.string().description('频道/群组号'),
-                    dynamic: koishi_1.Schema.boolean().description('该频道/群组是否推送动态信息'),
-                    live: koishi_1.Schema.boolean().description('该频道/群组是否推送直播通知'),
-                    liveDanmaku: koishi_1.Schema.boolean().description('该频道/群组是否推送弹幕消息'),
-                    atAll: koishi_1.Schema.boolean().description('推送开播通知时是否艾特全体成员')
-                })).description('频道/群组信息'),
-                platform: koishi_1.Schema.string().description('推送平台')
-            })).description('订阅用户需要发送的频道/群组信息')
-        })).role('table').description('手动输入订阅信息，方便自定义订阅内容，这里的订阅内容不会存入数据库。uid: 订阅用户UID，dynamic: 是否需要订阅动态，live: 是否需要订阅直播'),
+                    channelId: koishi_1.Schema.string().description("频道/群组号"),
+                    dynamic: koishi_1.Schema.boolean().description("该频道/群组是否推送动态信息"),
+                    live: koishi_1.Schema.boolean().description("该频道/群组是否推送直播通知"),
+                    liveGuardBuy: koishi_1.Schema.boolean().description("该频道/群组是否推送弹幕消息"),
+                    atAll: koishi_1.Schema.boolean().description("推送开播通知时是否艾特全体成员"),
+                })).description("频道/群组信息"),
+                platform: koishi_1.Schema.string().description("推送平台"),
+            })).description("订阅用户需要发送的频道/群组信息"),
+        }))
+            .role("table")
+            .description("手动输入订阅信息，方便自定义订阅内容，这里的订阅内容不会存入数据库。uid: 订阅用户UID，dynamic: 是否需要订阅动态，live: 是否需要订阅直播"),
         master: koishi_1.Schema.object({
             enable: koishi_1.Schema.boolean(),
             platform: koishi_1.Schema.string(),
             masterAccount: koishi_1.Schema.string(),
-            masterAccountGuildId: koishi_1.Schema.string()
+            masterAccountGuildId: koishi_1.Schema.string(),
         }),
-        unlockSubLimits: koishi_1.Schema.boolean().required(),
         automaticResend: koishi_1.Schema.boolean().required(),
+        liveDetectMode: koishi_1.Schema.union([
+            koishi_1.Schema.const("API"),
+            koishi_1.Schema.const("WS"),
+        ]).required(),
         restartPush: koishi_1.Schema.boolean().required(),
         pushTime: koishi_1.Schema.number().required(),
         liveLoopTime: koishi_1.Schema.number().default(10),
@@ -2013,14 +1444,13 @@ class ComRegister {
         customLiveEnd: koishi_1.Schema.string().required(),
         dynamicUrl: koishi_1.Schema.boolean().required(),
         dynamicLoopTime: koishi_1.Schema.number().default(60),
-        dynamicCheckNumber: koishi_1.Schema.number().required(),
         filter: koishi_1.Schema.object({
             enable: koishi_1.Schema.boolean(),
             notify: koishi_1.Schema.boolean(),
             regex: koishi_1.Schema.string(),
             keywords: koishi_1.Schema.array(String),
         }),
-        dynamicDebugMode: koishi_1.Schema.boolean().required()
+        dynamicDebugMode: koishi_1.Schema.boolean().required(),
     });
 })(ComRegister || (ComRegister = {}));
 exports.default = ComRegister;