koishi-plugin-bilibili-notify 2.0.0-alpha.0 → 2.0.0-alpha.10

package/lib/comRegister.js

@@ -10,15 +10,16 @@ const jsx_runtime_1 = require("@satorijs/element/jsx-runtime");
 const koishi_1 = require("koishi");
 // 导入qrcode
 const qrcode_1 = __importDefault(require("qrcode"));
-const jimp_1 = require("jimp");
 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 = {}));
 class ComRegister {
     static inject = ['ba', 'gi', 'database', 'sm'];
+    qqRelatedBotList = ['qq', 'onebot', 'red', 'satori', 'chronocat'];
     logger;
     config;
     loginTimer;
@@ -26,8 +27,10 @@ class ComRegister {
     rebootCount = 0;
     subNotifier;
     subManager = [];
+    // 检查登录数据库是否有数据
+    loginDBData;
     // 机器人实例
-    bot;
+    privateBot;
     // 动态销毁函数
     dynamicDispose;
     // 发送消息方式
@@ -36,26 +39,27 @@ class ComRegister {
     constructor(ctx, config) {
         this.logger = ctx.logger('cr');
         this.config = config;
-        // 拿到机器人实例
-        this.bot = ctx.bots.find(bot => bot.platform === config.platform);
-        if (!this.bot) {
+        // 拿到私人机器人实例
+        this.privateBot = ctx.bots.find(bot => bot.platform === config.master.platform);
+        if (!this.privateBot) {
             ctx.notifier.create({
-                type: 'danger',
-                content: '未找到对应机器人实例，请检查配置是否正确或重新配置适配器！'
+                content: '您未配置私人机器人，将无法向您推送机器人状态！'
             });
-            this.logger.error('未找到对应机器人实例，请检查配置是否正确或重新配置适配器！');
+            this.logger.error('您未配置私人机器人，将无法向您推送机器人状态！');
         }
+        // 检查登录数据库是否有数据
+        ctx.database.get('loginBili', 1, ['dynamic_group_id']).then(data => this.loginDBData = data[0]);
         // 从数据库获取订阅
         this.getSubFromDatabase(ctx);
         // 判断消息发送方式
         if (config.automaticResend) {
-            this.sendMsgFunc = async (guild, content) => {
+            this.sendMsgFunc = async (bot, channelId, content) => {
                 // 多次尝试发送消息
                 const attempts = 3;
                 for (let i = 0; i < attempts; i++) {
                     try {
                         // 发送消息
-                        await this.bot.sendMessage(guild, content);
+                        await bot.sendMessage(channelId, content);
                         // 防止消息发送速度过快被忽略
                         await ctx.sleep(500);
                         // 成功发送消息，跳出循环
@@ -63,19 +67,19 @@ class ComRegister {
                     }
                     catch (e) {
                         if (i === attempts - 1) { // 已尝试三次
-                            this.logger.error(`发送群组ID:${guild}消息失败！原因: ` + e.message);
+                            this.logger.error(`发送群组ID:${channelId}消息失败！原因: ` + e.message);
                             console.log(e);
-                            this.sendPrivateMsg(`发送群组ID:${guild}消息失败，请查看日志`);
+                            this.sendPrivateMsg(`发送群组ID:${channelId}消息失败，请查看日志`);
                         }
                     }
                 }
             };
         }
         else {
-            this.sendMsgFunc = async (guild, content) => {
+            this.sendMsgFunc = async (bot, guild, content) => {
                 try {
                     // 发送消息
-                    await this.bot.sendMessage(guild, content);
+                    await bot.sendMessage(guild, content);
                 }
                 catch (e) {
                     this.logger.error(`发送群组ID:${guild}消息失败！原因: ` + e.message);
@@ -99,9 +103,30 @@ class ComRegister {
             .usage('查看订阅管理对象')
             .example('status sm')
             .action(async () => {
-            console.log(this.subManager);
+            this.logger.info(this.subManager);
             return '查看控制台';
         });
+        statusCom
+            .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('--------------------------------');
+            });
+        });
+        statusCom
+            .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站之后才可以进行之后的操作')
@@ -216,6 +241,7 @@ class ComRegister {
                             await session.send(this.unsubSingle(ctx, sub.uid, 1)); /* 1为取消订阅Dynamic */
                         // 将存在flag设置为true
                         exist = true;
+                        // 结束循环
                         return;
                     }
                     // 取消全部订阅 执行dispose方法，销毁定时器
@@ -227,10 +253,13 @@ class ComRegister {
                     this.subManager.splice(i, 1);
                     // 将订阅对象移出订阅关注组
                     const removeUserFromGroupData = await ctx.ba.removeUserFromGroup(sub.uid);
-                    // 判断是否移出成功
-                    if (removeUserFromGroupData.code !== 0) {
+                    // 判断是否移出成功 22105关注对象为自己
+                    if (removeUserFromGroupData.code !== 0 && removeUserFromGroupData.code !== 22105) {
                         // 移出失败
-                        session.send('取消订阅对象失败，请稍后重试');
+                        await session.send('取消订阅对象失败，请稍后重试');
+                        // 将存在flag设置为true
+                        exist = true;
+                        // 结束循环
                         return;
                     }
                     // id--
@@ -243,7 +272,7 @@ class ComRegister {
                         this.dynamicDispose = null;
                     }
                     // 发送成功通知
-                    session.send('已取消订阅该用户');
+                    await session.send('已取消订阅该用户');
                     // 更新控制台提示
                     this.updateSubNotifier(ctx);
                     // 将存在flag设置为true
@@ -252,7 +281,7 @@ class ComRegister {
             }));
             // 未订阅该用户，无需取消订阅
             if (!exist)
-                session.send('未订阅该用户，无需取消订阅');
+                await session.send('未订阅该用户，无需取消订阅');
         });
         biliCom
             .subcommand('.show', '展示订阅对象')
@@ -263,24 +292,18 @@ class ComRegister {
             return subTable;
         });
         biliCom
-            .subcommand('.sub <mid:string> [...guildId:string]', '订阅用户动态和直播通知')
+            .subcommand('.sub <mid: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')
-            .usage('订阅用户动态和直播通知，若需要订阅直播请加上-l，需要订阅动态则加上-d。若没有加任何参数，之后会向你单独询问，尖括号中为必选参数，中括号为可选参数，目标群号若不填，则默认为当前群聊')
-            .example('bili sub 1194210119 目标QQ群号(实验性) -l -d 订阅UID为1194210119的UP主的动态和直播')
-            .action(async ({ session, options }, mid, ...guildId) => {
+            .option('atAll', '-a')
+            .usage('订阅用户动态和直播通知，若需要订阅直播请加上-l，需要订阅动态则加上-d')
+            .example('bili sub 1194210119 目标群号或频道号 -l -d 订阅UID为1194210119的UP主的动态和直播')
+            .action(async ({ session, options }, mid) => {
             this.logger.info('调用bili.sub指令');
-            // 检查是否是不支持的平台
-            switch (session.event.platform) {
-                case 'lark':
-                case 'red':
-                case 'onebot':
-                case 'telegram':
-                case 'satori':
-                case 'chronocat':
-                case 'qq':
-                case 'qqguild': break;
-                default: return '暂不支持该平台';
+            // 先判断是否订阅直播，再判断是否解锁订阅限制，最后判断直播订阅是否已超三个
+            if (options.live && !this.config.unlockSubLimits && (this.subManager.reduce((acc, cur) => acc + (cur.live ? 1 : 0), 0) >= 3)) {
+                return '直播订阅已达上限，请取消部分直播订阅后再进行订阅';
             }
             // 检查是否登录
             if (!(await this.checkIfIsLogin(ctx))) {
@@ -290,54 +313,80 @@ class ComRegister {
             // 检查必选参数是否已填
             if (!mid)
                 return '请输入用户uid';
-            // 检查数据库是否有数据
-            const loginDBData = (await ctx.database.get('loginBili', 1, ['dynamic_group_id']))[0];
-            // 判断是否有数据
-            if (loginDBData.dynamic_group_id === '' || loginDBData.dynamic_group_id === null) {
-                // 没有数据，没有创建分组，尝试创建分组
-                const createGroupData = await ctx.ba.createGroup("订阅");
-                // 如果分组已创建，则获取分组id
-                if (createGroupData.code === 22106) {
-                    // 分组已存在，拿到之前的分组id
-                    const allGroupData = await ctx.ba.getAllGroup();
-                    // 遍历所有分组
-                    for (const group of allGroupData.data) {
-                        // 找到订阅分组
-                        if (group.name === '订阅') {
-                            // 拿到分组id
-                            loginDBData.dynamic_group_id = group.tagid;
-                            break;
+            // 订阅对象
+            const subUserData = await this.subUserInBili(ctx, mid);
+            // 判断是否订阅对象存在
+            if (!subUserData.flag)
+                return '订阅对象失败，请稍后重试！';
+            // 定义目标变量
+            let target = [];
+            // 判断是否使用多平台功能
+            if (options.multiplatform) {
+                // 分割字符串，赋值给target
+                target = this.splitMultiPlatformStr(options.multiplatform);
+            }
+            // 判断是否使用了多平台
+            if (target) {
+                target.forEach(async ({ channelIdArr, platform }, index) => {
+                    if (channelIdArr.length > 0) { // 输入了推送群号或频道号
+                        // 拿到对应的bot
+                        const bot = this.getBot(ctx, platform);
+                        // 判断是否配置了对应平台的机器人
+                        if (!ctx.bots.some(bot => bot.platform === platform)) {
+                            await session.send('您未配置对应平台的机器人，不能在该平台进行订阅操作');
                         }
+                        // 判断是否需要加入的群全部推送
+                        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, atAll: options.atAll }], platform: session.event.platform }];
+                                // 没有满足条件的群组或频道
+                                await session.send('没有满足条件的群组或频道，默认订阅到当前聊天环境');
+                            }
+                            // 将符合条件的群组添加到target中
+                            target[index].channelIdArr = targetArr;
+                        }
+                        // 如果为all则全部推送，不需要进行处理
                     }
-                }
-                else if (createGroupData.code !== 0) {
-                    // 创建分组失败
-                    return '创建关注分组出错';
-                }
-                // 创建成功，保存到数据库
-                ctx.database.set('loginBili', 1, { dynamic_group_id: loginDBData.dynamic_group_id });
-            }
-            // 订阅对象
-            const subUserData = await ctx.ba.follow(mid);
-            // 判断是否订阅成功
-            switch (subUserData.code) {
-                case -101: return '账号未登录，请使用指令bili login登录后再进行订阅操作';
-                case -102: return '账号被封停，无法进行订阅操作';
-                case 22002: return '因对方隐私设置，无法进行订阅操作';
-                case 22003: return '你已将对方拉黑，无法进行订阅操作';
-                case 22013: return '账号已注销，无法进行订阅操作';
-                case 40061: return '账号不存在，请检查uid输入是否正确或用户是否存在';
-                case 22001: break; // 订阅对象为自己 无需添加到分组
-                case 22014: // 已关注订阅对象 无需再次关注
-                case 0: { // 执行订阅成功
-                    // 把订阅对象添加到分组中
-                    const copyUserToGroupData = await ctx.ba.copyUserToGroup(mid, loginDBData.dynamic_group_id);
-                    // 判断是否添加成功
-                    if (copyUserToGroupData.code !== 0) {
-                        // 添加失败
-                        return '添加订阅对象到分组失败，请稍后重试';
+                    else {
+                        // 未填写群号或频道号，默认为当前环境
+                        target = [{ channelIdArr: [{ channelId: session.event.channel.id, atAll: options.atAll }], platform: session.event.platform }];
+                        // 发送提示消息
+                        await session.send('没有填写群号或频道号，默认订阅到当前聊天环境');
                     }
-                }
+                });
+            }
+            else {
+                // 用户直接订阅，将当前环境赋值给target
+                target = [{ channelIdArr: [{ channelId: session.event.channel.id, atAll: options.atAll }], platform: session.event.platform }];
             }
             // 定义外围变量                
             let content;
@@ -374,90 +423,14 @@ class ComRegister {
                 // 返回错误信息
                 return msg;
             }
-            // 定义目标群组id
-            let targetId;
-            // 定义目标群组id数组
-            let targetIdArr;
-            // 判断是否输入了QQ群号
-            if (guildId.length > 0) { // 输入了QQ群号
-                // 定义方法
-                const checkIfGuildHasJoined = async (bot) => {
-                    // 获取机器人加入的群组
-                    const guildList = await bot.getGuildList();
-                    // 定义满足条件的群组数组
-                    const targetArr = [];
-                    // 判断群号是否符合条件
-                    for (const guild of guildId) {
-                        // 判断是否机器人加入了该群
-                        if (guildList.data.some(cv => cv.id === guild)) { // 机器人加入了该群
-                            // 保存到数组
-                            targetArr.push(guild);
-                            // 继续下一个循环
-                            continue;
-                        }
-                        // 不满足条件发送错误提示
-                        session.send(`您的机器未加入${guild}，无法对该群进行推送`);
-                    }
-                    // 返回数组
-                    return targetArr;
-                };
-                // 定义可用的群组数组
-                let okGuild = [];
-                // 判断是否需要加入的群全部推送
-                if (guildId[0] === 'all') {
-                    // 判断是否有群机器人相关Bot
-                    if (['qq', 'onebot', 'red', 'satori', 'chronocat'].includes(session.event.platform)) {
-                        // 推送所有群组
-                        okGuild.push('all');
-                    }
-                    else {
-                        // 发送错误提示并返回
-                        session.send('您尚未配置任何QQ群相关机器人，不能对QQ群进行操作');
-                        // 直接返回
-                        return;
-                    }
-                }
-                else {
-                    // 判断是否有群机器人相关Bot
-                    switch (session.event.platform) {
-                        case 'qq':
-                        case 'onebot':
-                        case 'red':
-                        case 'satori':
-                        case 'chronocat': {
-                            // 检查机器人是否加入该群
-                            okGuild = await checkIfGuildHasJoined(this.bot);
-                            break;
-                        }
-                        default: {
-                            // 发送错误提示并返回
-                            session.send('您尚未配置任何QQ群相关机器人，不能对QQ群进行操作');
-                            // 直接返回
-                            return;
-                        }
-                    }
-                }
-                // 将可用的目标赋值给数组
-                targetIdArr = okGuild;
-                // 将群号用空格进行分割
-                targetId = okGuild.join(' ');
-            }
-            else { // 没有输入QQ群号
-                // 为当前群聊环境进行推送
-                targetId = session.event.channel.id;
-                // 将目标id转换为数组进行赋值
-                targetIdArr = [session.event.channel.id];
-            }
             // 获取data
             const { data } = content;
             // 判断是否需要订阅直播和动态
-            const [liveMsg, dynamicMsg] = await this.checkIfNeedSub(options.live, options.dynamic, session, data);
-            console.log('Live MSG:', liveMsg);
-            console.log('Dynamic MSG:', dynamicMsg);
+            const [liveMsg, dynamicMsg] = await this.checkIfNeedSub(options.live, options.dynamic, session, data.live_room);
             // 判断是否未订阅任何消息
-            if (!liveMsg && !dynamicMsg) {
+            if (!liveMsg && !dynamicMsg)
                 return '您未订阅该UP的任何消息';
-            }
+            // 获取到对应的订阅对象
             const subUser = this.subManager.find(sub => sub.uid === mid);
             // 判断要订阅的用户是否已经存在于订阅管理对象中
             if (subUser) {
@@ -472,43 +445,22 @@ class ComRegister {
             }
             // 获取直播房间号
             const roomId = data.live_room?.roomid.toString();
-            // 保存到数据库中
-            const sub = await ctx.database.create('bilibili', {
-                uid: mid,
-                room_id: roomId,
-                dynamic: dynamicMsg ? 1 : 0,
-                video: 1,
-                live: liveMsg ? 1 : 0,
-                targetId,
-                platform: session.event.platform,
-                time: new Date()
-            });
-            // 订阅数+1
-            this.num++;
-            // 保存新订阅对象
-            this.subManager.push({
-                id: sub.id,
-                uid: mid,
-                targetIdArr,
-                roomId,
-                platform: session.event.platform,
-                live: liveMsg,
-                dynamic: dynamicMsg,
-                liveDispose: null
-            });
             // 获取用户信息
             let userData;
             try {
-                const { data } = await ctx.ba.getMasterInfo(sub.uid);
+                const { data } = await ctx.ba.getMasterInfo(mid);
                 userData = data;
             }
             catch (e) {
                 this.logger.error('bili sub指令 getMasterInfo() 发生了错误，错误为：' + e.message);
                 return '订阅出错啦，请重试';
             }
+            // 定义live销毁函数
+            let liveDispose;
             // 订阅直播
             if (liveMsg) {
-                await session.execute(`bili live ${roomId} ${targetId.split(',').join(' ')}`);
+                // 开始循环检测
+                liveDispose = ctx.setInterval(this.liveDetect(ctx, roomId, target), config.liveLoopTime * 1000);
                 // 发送订阅消息通知
                 await session.send(`订阅${userData.info.uname}直播通知`);
             }
@@ -517,44 +469,42 @@ class ComRegister {
                 // 判断是否开启动态监测
                 if (!this.dynamicDispose) {
                     // 开启动态监测
-                    this.dynamicDispose = ctx.setInterval(this.dynamicDetect(ctx), config.dynamicLoopTime * 1000);
+                    if (this.config.dynamicDebugMode) {
+                        this.dynamicDispose = ctx.setInterval(this.debug_dynamicDetect(ctx), config.dynamicLoopTime * 1000);
+                    }
+                    else {
+                        this.dynamicDispose = ctx.setInterval(this.dynamicDetect(ctx), config.dynamicLoopTime * 1000);
+                    }
                 }
                 // 发送订阅消息通知
                 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,
+                liveDispose
+            });
             // 新增订阅展示到控制台
             this.updateSubNotifier(ctx);
         });
-        /* biliCom
-            .subcommand('.dynamic <uid:string> <...guildId:string>', '订阅用户动态推送', { hidden: true })
-            .usage('订阅用户动态推送')
-            .example('bili dynamic 1194210119 订阅UID为1194210119的动态')
-            .action(async () => {
-                // Log
-                this.logger.info('调用bili.dynamic指令')
-                // 开始循环检测
-                this.dynamicDispose = ctx.setInterval(this.dynamicDetect(ctx), config.dynamicLoopTime * 1000)
-            }) */
-        biliCom
-            .subcommand('.live <roomId:string> <...guildId:string>', '订阅主播开播通知', { hidden: true })
-            .usage('订阅主播开播通知')
-            .example('bili live 26316137 订阅房间号为26316137的直播间')
-            .action(async (_, roomId, ...guildId) => {
-            this.logger.info('调用bili.live指令');
-            // 如果room_id为空则返回
-            if (!roomId)
-                return `${roomId}非法调用 dynamic 指令`; // 订阅主播房间号不能为空
-            if (!guildId)
-                return `${roomId}非法调用 dynamic 指令`; // 目标群组或频道不能为空
-            // 要订阅的对象不在订阅管理对象中，直接返回
-            const index = this.subManager.findIndex(sub => sub.roomId === roomId);
-            if (index === -1)
-                return '请勿直接调用该指令';
-            // 开始循环检测
-            const dispose = ctx.setInterval(this.liveDetect(ctx, roomId, guildId), config.liveLoopTime * 1000);
-            // 保存销毁函数
-            this.subManager[index].liveDispose = dispose;
-        });
         biliCom
             .subcommand('.status <roomId:string>', '查询主播当前直播状态', { hidden: true })
             .usage('查询主播当前直播状态')
@@ -598,19 +548,6 @@ class ComRegister {
             // pic不存在，说明使用的是page模式
             await session.send(koishi_1.h.image(buffer, 'image/png'));
         });
-        biliCom
-            .subcommand('.bot', '查询当前拥有的机器人信息', { hidden: true })
-            .usage('查询当前拥有的机器人信息')
-            .example('bili 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('--------------------------------');
-            });
-        });
         biliCom
             .subcommand('.private', '向主人账号发送一条测试消息', { hidden: true })
             .usage('向主人账号发送一条测试消息')
@@ -622,15 +559,28 @@ class ComRegister {
             await session.send('已发送消息，如未收到则说明您的机器人不支持发送私聊消息或您的信息填写有误');
         });
     }
+    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, atAll };
+            });
+            return { channelIdArr, platform };
+        });
+    }
+    getBot(ctx, pf) {
+        return ctx.bots.find(bot => bot.platform === pf);
+    }
     async sendPrivateMsg(content) {
         if (this.config.master.enable) {
             if (this.config.master.masterAccountGuildId) {
                 // 向机器人主人发送消息
-                await this.bot.sendPrivateMessage(this.config.master.masterAccount, content, this.config.master.masterAccountGuildId);
+                await this.privateBot.sendPrivateMessage(this.config.master.masterAccount, content, this.config.master.masterAccountGuildId);
             }
             else {
                 // 向机器人主人发送消息
-                await this.bot.sendPrivateMessage(this.config.master.masterAccount, content);
+                await this.privateBot.sendPrivateMessage(this.config.master.masterAccount, content);
             }
         }
     }
@@ -675,25 +625,207 @@ class ComRegister {
         // 结束
         return;
     }
-    async sendMsg(targets, content) {
-        // 定义需要发送的数组
-        let sendArr = [];
-        // 判断是否需要推送所有机器人加入的群
-        if (targets[0] === 'all') {
-            // 获取所有guild
-            for (const guild of (await this.bot.getGuildList()).data) {
-                sendArr.push(guild.id);
+    async sendMsg(ctx, targets, content, live) {
+        for (const target of targets) {
+            // 获取机器人实例
+            const bot = this.getBot(ctx, target.platform);
+            // 定义需要发送的数组
+            let sendArr = [];
+            // 判断是否需要推送所有机器人加入的群
+            if (target.channelIdArr[0].channelId === 'all') {
+                // 获取所有guild
+                for (const guild of (await bot.getGuildList()).data) {
+                    sendArr.push({ channelId: guild.id, atAll: target.channelIdArr[0].atAll });
+                }
+            }
+            else {
+                sendArr = target.channelIdArr;
+            }
+            // 循环给每个群组发送
+            if (live) {
+                // 直播推送，需要判断是否为
+                for (const channel of sendArr) {
+                    await this.sendMsgFunc(bot, channel.channelId, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [channel.atAll && (0, jsx_runtime_1.jsx)("at", { type: "all" }), content] }));
+                }
+            }
+            else {
+                for (const channel of sendArr) {
+                    await this.sendMsgFunc(bot, channel.channelId, content);
+                }
             }
-        }
-        else {
-            sendArr = targets;
-        }
-        // 循环给每个群组发送
-        for (const guild of sendArr) {
-            await this.sendMsgFunc(guild, content);
         }
     }
     dynamicDetect(ctx) {
+        let detectSetup = true;
+        let updateBaseline;
+        // 相当于锁的作用，防止上一个循环没处理完
+        let flag = true;
+        // 返回一个闭包函数
+        return async () => {
+            // 判断上一个循环是否完成
+            if (!flag)
+                return;
+            flag = false;
+            // 无论是否执行成功都要释放锁
+            try {
+                // 检测启动初始化
+                if (detectSetup) {
+                    // 获取动态信息
+                    const data = await ctx.ba.getAllDynamic();
+                    // 判断获取动态信息是否成功
+                    if (data.code !== 0)
+                        return;
+                    // 设置更新基线
+                    updateBaseline = data.data.update_baseline;
+                    // 设置初始化为false
+                    detectSetup = false;
+                    // 初始化完成
+                    return;
+                }
+                // 获取用户所有动态数据
+                let updateNum;
+                let content;
+                try {
+                    // 查询是否有新动态
+                    const data = await ctx.ba.hasNewDynamic(updateBaseline);
+                    updateNum = data.data.update_num;
+                    // 没有新动态或获取动态信息失败直接返回
+                    if (updateNum <= 0 || data.code !== 0)
+                        return;
+                    // 获取动态内容
+                    content = await ctx.ba.getAllDynamic(updateBaseline);
+                }
+                catch (e) {
+                    return this.logger.error('dynamicDetect getUserSpaceDynamic() 发生了错误，错误为：' + e.message);
+                }
+                // 判断获取动态内容是否成功
+                if (content.code !== 0) {
+                    switch (content.code) {
+                        case -101: { // 账号未登录
+                            // 输出日志
+                            this.logger.error('账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件');
+                            // 发送私聊消息
+                            await this.sendPrivateMsg('账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件');
+                            // 停止服务
+                            await ctx.sm.disposePlugin();
+                            // 结束循环
+                            break;
+                        }
+                        case -352: { // 风控
+                            // 输出日志
+                            this.logger.error('账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件');
+                            // 发送私聊消息
+                            await this.sendPrivateMsg('账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件');
+                            // 停止服务
+                            await ctx.sm.disposePlugin();
+                            // 结束循环
+                            break;
+                        }
+                        case 4101128:
+                        case 4101129: { // 获取动态信息错误
+                            // 输出日志
+                            this.logger.error('获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message);
+                            // 发送私聊消息
+                            await this.sendPrivateMsg('获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
+                            // 结束循环
+                            break;
+                        }
+                        default: { // 未知错误
+                            // 发送私聊消息
+                            await this.sendPrivateMsg('获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
+                            // 结束循环
+                            break;
+                        }
+                    }
+                }
+                // 获取数据内容
+                const data = content.data;
+                // 更新基线
+                updateBaseline = data.update_baseline;
+                // 有新动态内容
+                const items = data.items;
+                // 检查更新的动态
+                for (let num = updateNum - 1; num >= 0; num--) {
+                    // 没有动态内容则直接跳过
+                    if (!items[num])
+                        continue;
+                    // 从动态数据中取出UP主名称、UID和动态ID
+                    const upUID = items[num].modules.module_author.mid;
+                    // 寻找关注的UP主的动态
+                    this.subManager.forEach(async (sub) => {
+                        // 判断是否是订阅的UP主
+                        if (sub.uid == upUID) {
+                            // 订阅该UP主，推送该动态
+                            // 定义变量
+                            let pic;
+                            let buffer;
+                            // 从动态数据中取出UP主名称和动态ID
+                            const upName = content.data.items[num].modules.module_author.name;
+                            const dynamicId = content.data.items[num].id_str;
+                            // 推送该条动态
+                            const attempts = 3;
+                            for (let i = 0; i < attempts; i++) {
+                                // 获取动态推送图片
+                                try {
+                                    // 渲染图片
+                                    const { pic: gimgPic, buffer: gimgBuffer } = await ctx.gi.generateDynamicImg(items[num]);
+                                    // 赋值
+                                    pic = gimgPic;
+                                    buffer = gimgBuffer;
+                                    // 成功则跳出循环
+                                    break;
+                                }
+                                catch (e) {
+                                    // 直播开播动态，不做处理
+                                    if (e.message === '直播开播动态，不做处理')
+                                        return;
+                                    if (e.message === '出现关键词，屏蔽该动态') {
+                                        // 如果需要发送才发送
+                                        if (this.config.filter.notify) {
+                                            await this.sendMsg(ctx, sub.target, `${upName}发布了一条含有屏蔽关键字的动态`);
+                                        }
+                                        return;
+                                    }
+                                    if (e.message === '已屏蔽转发动态') {
+                                        if (this.config.filter.notify) {
+                                            await this.sendMsg(ctx, sub.target, `${upName}发布了一条转发动态，已屏蔽`);
+                                        }
+                                        return;
+                                    }
+                                    // 未知错误
+                                    if (i === attempts - 1) {
+                                        this.logger.error('dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：' + e.message);
+                                        // 发送私聊消息并重启服务
+                                        return await this.sendPrivateMsgAndStopService(ctx);
+                                    }
+                                }
+                            }
+                            // 判断是否需要发送URL
+                            const dUrl = this.config.dynamicUrl ? `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}` : '';
+                            // 如果pic存在，则直接返回pic
+                            if (pic) {
+                                this.logger.info('推送动态中，使用render模式');
+                                // pic存在，使用的是render模式
+                                await this.sendMsg(ctx, sub.target, pic + (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: dUrl }));
+                            }
+                            else if (buffer) {
+                                this.logger.info('推送动态中，使用page模式');
+                                // pic不存在，说明使用的是page模式
+                                await this.sendMsg(ctx, 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 + '发布了一条动态，但是推送失败');
+                            }
+                        }
+                    });
+                }
+            }
+            finally {
+                flag = true;
+            }
+        };
+    }
+    debug_dynamicDetect(ctx) {
         let detectSetup = true;
         let updateBaseline;
         // 相当于锁的作用，防止上一个循环没处理完
@@ -834,13 +966,13 @@ class ComRegister {
                                     if (e.message === '出现关键词，屏蔽该动态') {
                                         // 如果需要发送才发送
                                         if (this.config.filter.notify) {
-                                            await this.sendMsg(sub.targetIdArr, `${upName}发布了一条含有屏蔽关键字的动态`);
+                                            await this.sendMsg(ctx, sub.target, `${upName}发布了一条含有屏蔽关键字的动态`);
                                         }
                                         return;
                                     }
                                     if (e.message === '已屏蔽转发动态') {
                                         if (this.config.filter.notify) {
-                                            await this.sendMsg(sub.targetIdArr, `${upName}发布了一条转发动态，已屏蔽`);
+                                            await this.sendMsg(ctx, sub.target, `${upName}发布了一条转发动态，已屏蔽`);
                                         }
                                         return;
                                     }
@@ -858,12 +990,12 @@ class ComRegister {
                             if (pic) {
                                 this.logger.info('推送动态中，使用render模式');
                                 // pic存在，使用的是render模式
-                                await this.sendMsg(sub.targetIdArr, pic + (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: dUrl }));
+                                await this.sendMsg(ctx, sub.target, pic + (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: dUrl }));
                             }
                             else if (buffer) {
                                 this.logger.info('推送动态中，使用page模式');
                                 // pic不存在，说明使用的是page模式
-                                await this.sendMsg(sub.targetIdArr, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, 'image/png'), dUrl] }));
+                                await this.sendMsg(ctx, 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 + '发布了一条动态，但是推送失败');
@@ -877,7 +1009,7 @@ class ComRegister {
             }
         };
     }
-    liveDetect(ctx, roomId, guildId) {
+    liveDetect(ctx, roomId, target) {
         let firstSubscription = true;
         let timer = 0;
         let open = false;
@@ -887,80 +1019,40 @@ class ComRegister {
         // 相当于锁的作用，防止上一个循环没处理完
         let flag = true;
         // 定义发送直播通知卡片方法
-        let sendLiveNotifyCard;
-        // 判断直播是否需要@全体成员
-        if (this.config.pushUrl) {
-            sendLiveNotifyCard = async (data, liveType, liveStartMsg, atAll) => {
-                // 定义变量
-                let pic;
-                let buffer;
-                // 多次尝试生成图片
-                const attempts = 3;
-                for (let i = 0; i < attempts; i++) {
-                    try {
-                        // 获取直播通知卡片
-                        const { pic: picv, buffer: bufferv } = await ctx.gi.generateLiveImg(data, username, userface, liveType);
-                        // 赋值
-                        pic = picv;
-                        buffer = bufferv;
-                        // 成功则跳出循环
-                        break;
-                    }
-                    catch (e) {
-                        if (i === attempts - 1) { // 已尝试三次
-                            this.logger.error('liveDetect generateLiveImg() 推送卡片生成失败，原因：' + e.message);
-                            // 发送私聊消息并重启服务
-                            return await this.sendPrivateMsgAndStopService(ctx);
-                        }
-                    }
-                }
-                // 推送直播信息
-                // pic 存在，使用的是render模式
-                if (pic) {
-                    const msg = (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [atAll && (0, jsx_runtime_1.jsx)("at", { type: "all" }), liveStartMsg && liveStartMsg, liveType !== LiveType.StartBroadcasting ? `https://live.bilibili.com/${roomId}` : ''] });
-                    return await this.sendMsg(guildId, pic + msg);
+        const sendLiveNotifyCard = async (data, liveType, liveNotifyMsg) => {
+            // 定义变量
+            let pic;
+            let buffer;
+            // 多次尝试生成图片
+            const attempts = 3;
+            for (let i = 0; i < attempts; i++) {
+                try {
+                    // 获取直播通知卡片
+                    const { pic: picv, buffer: bufferv } = await ctx.gi.generateLiveImg(data, username, userface, liveType);
+                    // 赋值
+                    pic = picv;
+                    buffer = bufferv;
+                    // 成功则跳出循环
+                    break;
                 }
-                // pic不存在，说明使用的是page模式
-                const msg = (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, 'image/png'), atAll && (0, jsx_runtime_1.jsx)("at", { type: "all" }), liveStartMsg && liveStartMsg, liveType !== LiveType.StartBroadcasting ? `https://live.bilibili.com/${roomId}` : ''] });
-                await this.sendMsg(guildId, msg);
-            };
-        }
-        else {
-            sendLiveNotifyCard = async (data, liveType, liveStartMsg, atAll) => {
-                // 定义变量
-                let pic;
-                let buffer;
-                // 多次尝试生成图片
-                const attempts = 3;
-                for (let i = 0; i < attempts; i++) {
-                    try {
-                        // 获取直播通知卡片
-                        const { pic: picv, buffer: bufferv } = await ctx.gi.generateLiveImg(data, username, userface, liveType);
-                        // 赋值
-                        pic = picv;
-                        buffer = bufferv;
-                        // 成功则跳出循环
-                        break;
-                    }
-                    catch (e) {
-                        if (i === attempts - 1) { // 已尝试三次
-                            this.logger.error('liveDetect generateLiveImg() 推送卡片生成失败，原因：' + e.message);
-                            // 发送私聊消息并重启服务
-                            return await this.sendPrivateMsgAndStopService(ctx);
-                        }
+                catch (e) {
+                    if (i === attempts - 1) { // 已尝试三次
+                        this.logger.error('liveDetect generateLiveImg() 推送卡片生成失败，原因：' + e.message);
+                        // 发送私聊消息并重启服务
+                        return await this.sendPrivateMsgAndStopService(ctx);
                     }
                 }
-                // 推送直播信息
-                // pic 存在，使用的是render模式
-                if (pic) {
-                    const msg = (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [atAll && (0, jsx_runtime_1.jsx)("at", { type: "all" }), liveStartMsg && liveStartMsg] });
-                    return await this.sendMsg(guildId, pic + msg);
-                }
-                // pic不存在，说明使用的是page模式
-                const msg = (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, 'image/png'), atAll && (0, jsx_runtime_1.jsx)("at", { type: "all" }), liveStartMsg && liveStartMsg] });
-                await this.sendMsg(guildId, msg);
-            };
-        }
+            }
+            // 推送直播信息
+            // pic 存在，使用的是render模式
+            if (pic) {
+                const msg = (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: liveNotifyMsg && liveNotifyMsg });
+                return await this.sendMsg(ctx, target, pic + msg, true);
+            }
+            // pic不存在，说明使用的是page模式
+            const msg = (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, 'image/png'), liveNotifyMsg && liveNotifyMsg] });
+            await this.sendMsg(ctx, target, msg, true);
+        };
         // 定义获取主播信息方法
         let useMasterInfo;
         if (this.config.changeMasterInfoApi) {
@@ -1048,22 +1140,10 @@ class ComRegister {
                             const liveEndMsg = this.config.customLiveEnd
                                 .replace('-name', username)
                                 .replace('-time', await ctx.gi.getTimeDifference(liveTime));
-                            // 获取头像并缩放
-                            let resizedImage;
-                            // Jimp无法处理Webp格式，直接跳过
-                            try {
-                                resizedImage = await jimp_1.Jimp.read(userface).then(async (image) => {
-                                    return await image.resize({ w: 100, h: 100 }).getBuffer(jimp_1.JimpMime.png);
-                                });
-                            }
-                            catch (e) {
-                                if (e.message === 'Unsupported MIME type: image/webp')
-                                    console.log('主播使用的是webp格式头像，无法进行渲染');
-                                else
-                                    console.log(e);
-                            }
-                            // 发送下播通知
-                            await this.sendMsg(guildId, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [resizedImage && koishi_1.h.image(resizedImage, 'image/png'), " ", liveEndMsg] }));
+                            // 更改直播时长
+                            data.live_time = liveTime;
+                            // 发送@全体成员通知
+                            await sendLiveNotifyCard(data, LiveType.StopBroadcast, liveEndMsg);
                         }
                         // 未进循环，还未开播，继续循环
                         break;
@@ -1097,15 +1177,8 @@ class ComRegister {
                                 .replace('-name', username)
                                 .replace('-time', await ctx.gi.getTimeDifference(liveTime))
                                 .replace('-link', `https://live.bilibili.com/${data.short_id === 0 ? data.room_id : data.short_id}`);
-                            // 判断是否需要@全体成员
-                            if (this.config.liveStartAtAll) {
-                                // 发送@全体成员通知
-                                await sendLiveNotifyCard(data, LiveType.StartBroadcasting, liveStartMsg, true);
-                            }
-                            else {
-                                // 发送直播通知卡片
-                                await sendLiveNotifyCard(data, LiveType.StartBroadcasting, liveStartMsg);
-                            }
+                            // 发送消息
+                            await sendLiveNotifyCard(data, LiveType.StartBroadcasting, liveStartMsg);
                         }
                         else { // 还在直播
                             if (this.config.pushTime > 0) {
@@ -1114,8 +1187,13 @@ class ComRegister {
                                 if (timer >= (6 * 60 * this.config.pushTime)) { // 到时间推送直播消息
                                     // 到时间重新计时
                                     timer = 0;
+                                    // 定义直播中通知消息
+                                    const liveMsg = this.config.customLive ? this.config.customLive
+                                        .replace('-name', username)
+                                        .replace('-time', await ctx.gi.getTimeDifference(liveTime))
+                                        .replace('-link', `https://live.bilibili.com/${data.short_id === 0 ? data.room_id : data.short_id}`) : '';
                                     // 发送直播通知卡片
-                                    sendLiveNotifyCard(data, LiveType.LiveBroadcast);
+                                    sendLiveNotifyCard(data, LiveType.LiveBroadcast, liveMsg);
                                 }
                             }
                             // 否则继续循环
@@ -1137,19 +1215,25 @@ class ComRegister {
         });
         return table ? table : '没有订阅任何UP';
     }
-    async checkIfNeedSub(liveSub, dynamicSub, session, data) {
+    async checkIfNeedSub(liveSub, dynamicSub, session, liveRoomData) {
         // 定义方法：用户直播间是否存在
         const liveRoom = async () => {
-            if (!data.live_room) {
+            if (!liveRoomData) {
                 // 未开通直播间
                 await session.send('该用户未开通直播间，无法订阅直播');
                 // 返回false
-                return false;
+                return true;
             }
+            return false;
         };
         // 如果两者都为true或者都为false则直接返回
-        if ((liveSub && dynamicSub) || (!liveSub && !dynamicSub))
+        if ((liveSub && dynamicSub) || (!liveSub && !dynamicSub)) {
+            // 判断是否存在直播间
+            if (await liveRoom())
+                return [false, true];
+            // 返回
             return [true, true];
+        }
         // 如果只订阅直播
         if (liveSub) {
             // 判断是否存在直播间
@@ -1195,6 +1279,97 @@ class ComRegister {
             check();
         });
     }
+    async subUserInBili(ctx, mid) {
+        // 获取关注分组信息
+        const checkGroupIsReady = async () => {
+            // 判断是否有数据
+            if (this.loginDBData.dynamic_group_id === '' || this.loginDBData.dynamic_group_id === null) {
+                // 没有数据，没有创建分组，尝试创建分组
+                const createGroupData = await ctx.ba.createGroup("订阅");
+                // 如果分组已创建，则获取分组id
+                if (createGroupData.code === 22106) {
+                    // 分组已存在，拿到之前的分组id
+                    const allGroupData = await ctx.ba.getAllGroup();
+                    // 遍历所有分组
+                    for (const group of allGroupData.data) {
+                        // 找到订阅分组
+                        if (group.name === '订阅') {
+                            // 拿到分组id
+                            this.loginDBData.dynamic_group_id = group.tagid;
+                            // 结束循环
+                            break;
+                        }
+                    }
+                }
+                else if (createGroupData.code !== 0) {
+                    console.log(createGroupData);
+                    // 创建分组失败
+                    return false;
+                }
+                // 创建成功，保存到数据库
+                ctx.database.set('loginBili', 1, { dynamic_group_id: this.loginDBData.dynamic_group_id });
+                // 创建成功
+                return true;
+            }
+            return true;
+        };
+        // 判断分组是否准备好
+        const flag = await checkGroupIsReady();
+        // 判断是否创建成功
+        if (!flag) {
+            // 创建分组失败
+            return { flag: false, msg: '创建分组失败，请尝试重启插件' };
+        }
+        // 获取分组明细
+        const relationGroupDetailData = await ctx.ba.getRelationGroupDetail(this.loginDBData.dynamic_group_id);
+        // 判断分组信息是否获取成功
+        if (relationGroupDetailData.code !== 0) {
+            if (relationGroupDetailData.code === 22104) {
+                // 将原先的分组id置空
+                this.loginDBData.dynamic_group_id = null;
+                // 分组不存在
+                const flag = await checkGroupIsReady();
+                // 判断是否创建成功
+                if (!flag) {
+                    // 创建分组失败
+                    return { flag: false, msg: '创建分组失败，请尝试重启插件' };
+                }
+                return { flag: true, msg: '分组不存在，已重新创建分组' };
+            }
+            // 获取分组明细失败
+            return { flag: false, msg: '获取分组明细失败' };
+        }
+        relationGroupDetailData.data.forEach(user => {
+            if (user.mid === mid) {
+                // 已关注订阅对象
+                return { flag: true, msg: '订阅对象已存在于分组中' };
+            }
+        });
+        // 订阅对象
+        const subUserData = await 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 22014: // 已关注订阅对象 无需再次关注
+            case 0: { // 执行订阅成功
+                // 把订阅对象添加到分组中
+                const copyUserToGroupData = await ctx.ba.copyUserToGroup(mid, this.loginDBData.dynamic_group_id);
+                // 判断是否添加成功
+                if (copyUserToGroupData.code !== 0) {
+                    // 添加失败
+                    return { flag: false, msg: '添加订阅对象到分组失败，请稍后重试' };
+                }
+            }
+        }
+        // 订阅成功
+        return { flag: true, msg: '用户订阅成功' };
+    }
     async getSubFromDatabase(ctx) {
         // 判断登录信息是否已加载完毕
         await this.checkIfLoginInfoIsLoaded(ctx);
@@ -1209,6 +1384,8 @@ class ComRegister {
             return;
         // 从数据库中获取数据
         const subData = await ctx.database.get('bilibili', { id: { $gt: 0 } });
+        // 定义变量：订阅直播数
+        let liveSubNum = 0;
         // 循环遍历
         for (const sub of subData) {
             // 判断是否存在没有任何订阅的数据
@@ -1220,8 +1397,21 @@ class ComRegister {
                 // 跳过下面的步骤
                 continue;
             }
+            // 判断用户是否在B站中订阅了
+            const subUserData = await this.subUserInBili(ctx, sub.uid);
+            // 判断是否订阅
+            if (!subUserData.flag) {
+                // log
+                this.logger.warn(`UID:${sub.uid} ${subUserData.msg}，自动取消订阅`);
+                // 发送私聊消息
+                await this.sendPrivateMsg(`UID:${sub.uid} ${subUserData.msg}，自动取消订阅`);
+                // 删除该条数据
+                await ctx.database.remove('bilibili', { id: sub.id });
+                // 跳过下面的步骤
+                continue;
+            }
             // 获取推送目标数组
-            const targetIdArr = sub.targetId.split(' ');
+            const target = JSON.parse(sub.target);
             /* 判断数据库是否被篡改 */
             // 获取用户信息
             let content;
@@ -1271,7 +1461,7 @@ class ComRegister {
                 }
             }
             // 检测房间号是否被篡改
-            if (sub.live && (!data.live_room || data.live_room.roomid.toString() !== sub.room_id)) {
+            if (sub.live && (!data.live_room || data.live_room.roomid != sub.room_id)) {
                 // 房间号被篡改，删除该订阅
                 await deleteSub();
                 // log
@@ -1285,17 +1475,30 @@ class ComRegister {
                 id: sub.id,
                 uid: sub.uid,
                 roomId: sub.room_id,
-                targetIdArr,
+                target,
                 platform: sub.platform,
-                live: +sub.live === 1 ? true : false,
-                dynamic: +sub.dynamic === 1 ? true : false,
+                live: sub.live === 1 ? true : false,
+                dynamic: sub.dynamic === 1 ? true : false,
                 liveDispose: null
             };
-            if (sub.live) { // 需要订阅直播
-                // 开始循环检测
-                const dispose = ctx.setInterval(this.liveDetect(ctx, sub.room_id, targetIdArr), this.config.liveLoopTime * 1000);
-                // 保存销毁函数
-                subManagerItem.liveDispose = dispose;
+            // 判断是否订阅直播
+            if (sub.live) {
+                // 判断订阅直播数是否超过限制
+                if (!this.config.unlockSubLimits && liveSubNum >= 3) {
+                    subManagerItem.live = false;
+                    // log
+                    this.logger.warn(`UID:${sub.uid} 订阅直播数超过限制，自动取消订阅`);
+                    // 发送错误消息
+                    this.sendPrivateMsg(`UID:${sub.uid} 订阅直播数超过限制，自动取消订阅`);
+                }
+                else {
+                    // 直播订阅数+1
+                    liveSubNum++;
+                    // 订阅直播，开始循环检测
+                    const dispose = ctx.setInterval(this.liveDetect(ctx, sub.room_id, target), this.config.liveLoopTime * 1000);
+                    // 保存销毁函数
+                    subManagerItem.liveDispose = dispose;
+                }
             }
             // 保存新订阅对象
             this.subManager.push(subManagerItem);
@@ -1303,7 +1506,12 @@ class ComRegister {
         // 检查是否有订阅对象需要动态监测
         if (this.subManager.some(sub => sub.dynamic)) {
             // 开始动态监测
-            this.dynamicDispose = ctx.setInterval(this.dynamicDetect(ctx), 10000 /* this.config.dynamicLoopTime * 1000 */);
+            if (this.config.dynamicDebugMode) {
+                this.dynamicDispose = ctx.setInterval(this.debug_dynamicDetect(ctx), 10000);
+            }
+            else {
+                this.dynamicDispose = ctx.setInterval(this.dynamicDetect(ctx), 10000 /* this.config.dynamicLoopTime * 1000 */);
+            }
         }
         // 在控制台中显示订阅对象
         this.updateSubNotifier(ctx);
@@ -1322,7 +1530,7 @@ class ComRegister {
             // num--
             this.num--;
             // 判断是否还存在订阅了动态的对象，不存在则停止动态监测
-            this.checkIfUserThatIsSubDynAndUnsub();
+            this.checkIfUserIsTheLastOneWhoSubDyn();
         };
         try {
             switch (type) {
@@ -1367,7 +1575,7 @@ class ComRegister {
                     // 取消订阅
                     this.subManager[index].dynamic = false;
                     // 判断是否还存在订阅了动态的对象，不存在则停止动态监测
-                    this.checkIfUserThatIsSubDynAndUnsub();
+                    this.checkIfUserIsTheLastOneWhoSubDyn();
                     // 如果没有对这个UP的任何订阅，则移除
                     if (checkIfNoSubExist(sub)) {
                         // 从管理对象中移除
@@ -1388,7 +1596,7 @@ class ComRegister {
             this.updateSubNotifier(ctx);
         }
     }
-    checkIfUserThatIsSubDynAndUnsub() {
+    checkIfUserIsTheLastOneWhoSubDyn() {
         if (this.subManager.some(sub => sub.dynamic)) {
             // 停止动态监测
             this.dynamicDispose();
@@ -1401,7 +1609,7 @@ class ComRegister {
             if (sub.live)
                 await this.subManager[i].liveDispose();
             // 判断是否还存在订阅了动态的对象，不存在则停止动态监测
-            this.checkIfUserThatIsSubDynAndUnsub();
+            this.checkIfUserIsTheLastOneWhoSubDyn();
             // 从数据库中删除订阅
             await ctx.database.remove('bilibili', { uid: this.subManager[i].uid });
             // 将该订阅对象从订阅管理对象中移除
@@ -1426,21 +1634,20 @@ class ComRegister {
 }
 (function (ComRegister) {
     ComRegister.Config = koishi_1.Schema.object({
-        platform: koishi_1.Schema.string(),
         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()
         }),
         unlockSubLimits: koishi_1.Schema.boolean().required(),
         automaticResend: koishi_1.Schema.boolean().required(),
         changeMasterInfoApi: koishi_1.Schema.boolean().required(),
-        liveStartAtAll: koishi_1.Schema.boolean().required(),
         restartPush: koishi_1.Schema.boolean().required(),
-        pushUrl: koishi_1.Schema.boolean().required(),
         pushTime: koishi_1.Schema.number().required(),
         liveLoopTime: koishi_1.Schema.number().default(10),
         customLiveStart: koishi_1.Schema.string().required(),
+        customLive: koishi_1.Schema.string(),
         customLiveEnd: koishi_1.Schema.string().required(),
         dynamicUrl: koishi_1.Schema.boolean().required(),
         dynamicLoopTime: koishi_1.Schema.number().default(60),