koishi-plugin-bilibili-notify 3.0.0-alpha.15 → 3.0.0-alpha.17

package/lib/comRegister.js

@@ -7,16 +7,10 @@ const jsx_runtime_1 = require("@satorijs/element/jsx-runtime");
 const koishi_1 = require("koishi");
 // 导入qrcode
 const qrcode_1 = __importDefault(require("qrcode"));
+const type_1 = require("./type");
 // 弹幕词云
 // TODO:WorlCloud
 // import { Segment } from "segmentit";
-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", "bl", "sm"];
@@ -183,8 +177,6 @@ class ComRegister {
                         this.loginTimer();
                         // 订阅手动订阅中的订阅
                         await this.loadSubFromConfig(config.sub);
-                        // 订阅之前的订阅
-                        await this.loadSubFromDatabase();
                         // 清除控制台通知
                         ctx.ba.disposeNotifier();
                         // 发送成功登录推送
@@ -201,413 +193,13 @@ 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", "展示订阅对象")
+            .subcommand(".list", "展示订阅对象")
             .usage("展示订阅对象")
-            .example("bili show")
+            .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 = [];
-                // 遍历输入的群组
-                for (const group of groupId) {
-                    channelIdArr.push({
-                        channelId: group,
-                        dynamic: true,
-                        live: true,
-                        liveGuardBuy: 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,
-                                                    liveGuardBuy: 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,
-                                            liveGuardBuy: 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,
-                                    liveGuardBuy: false,
-                                    atAll: options.atAll ? options.atAll : false,
-                                },
-                            ],
-                            platform: session.event.platform,
-                        },
-                    ];
-                }
-            }
-            // 定义外围变量
-            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-            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();
-            // 获取用户信息
-            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-            let userData;
-            try {
-                const { data } = await ctx.ba.getMasterInfo(mid);
-                userData = data;
-            }
-            catch (e) {
-                this.logger.error(`bili sub指令 getMasterInfo() 发生了错误，错误为：${e.message}`);
-                return "订阅出错啦，请重试";
-            }
-            const liveDetectModeSelector = {
-                API: async () => {
-                    // 判断是否已开启直播检测
-                    if (!this.liveDispose) {
-                        // 未开启直播检测
-                        // 开启直播检测并保存销毁函数
-                        this.liveDispose = await this.liveDetectWithAPI();
-                    }
-                },
-                WS: async () => {
-                    // 连接到服务器
-                    await this.liveDetectWithListener(roomId, target);
-                },
-            };
-            // 订阅直播
-            if (liveMsg) {
-                // 判断直播订阅方式
-                await liveDetectModeSelector[this.config.liveDetectMode]();
-                // 发送订阅消息通知
-                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("请输入房间号!");
-            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-            let content;
-            try {
-                content = await ctx.ba.getLiveRoomInfo(roomId);
-            }
-            catch (e) {
-                return `bili status指令 getLiveRoomInfo() 发生了错误，错误为：${e.message}`;
-            }
-            const { data } = content;
-            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-            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("向主人账号发送一条测试消息")
@@ -630,7 +222,6 @@ class ComRegister {
             this.ctx.notifier.create({
                 content: "您未配置私人机器人，将无法向您推送机器人状态！",
             });
-            this.logger.error("您未配置私人机器人，将无法向您推送机器人状态！");
         }
         // 判断消息发送方式
         if (config.automaticResend) {
@@ -689,8 +280,6 @@ class ComRegister {
         }
         // 从配置获取订阅
         config.sub && (await this.loadSubFromConfig(config.sub));
-        // 从数据库获取订阅
-        await this.loadSubFromDatabase();
         // 检查是否需要动态监测
         this.checkIfDynamicDetectIsNeeded();
         // 在控制台中显示订阅对象
@@ -714,25 +303,6 @@ class ComRegister {
         const buffer = await this.ctx.gi.generateWordCloudImg();
         this.sendMsg(testTarget, h.image(buffer, "image/png")); */
     }
-    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,
-                    liveGuardBuy: false,
-                    atAll,
-                };
-            });
-            return { channelIdArr, platform };
-        });
-    }
     // biome-ignore lint/suspicious/noExplicitAny: <explanation>
     getBot(pf) {
         return this.ctx.bots.find((bot) => bot.platform === pf);
@@ -1237,7 +807,7 @@ class ComRegister {
         };
     }
     // 定义发送直播通知卡片方法
-    async sendLiveNotifyCard(info, liveType, liveNotifyMsg) {
+    async sendLiveNotifyCard(info, liveType, followerDisplay, liveNotifyMsg) {
         // 定义变量
         let pic;
         let buffer;
@@ -1246,7 +816,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;
@@ -1266,7 +836,7 @@ class ComRegister {
         // pic 存在，使用的是render模式
         if (pic) {
             // 只有在开播时才艾特全体成员
-            if (liveType === LiveType.StartBroadcasting) {
+            if (liveType === type_1.LiveType.StartBroadcasting) {
                 return await this.sendMsg(info.target, pic + (liveNotifyMsg ?? ""), true);
             }
             // 正常不需要艾特全体成员
@@ -1275,19 +845,47 @@ class ComRegister {
         // pic不存在，说明使用的是page模式
         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);
+        // 定义粉丝数变量
+        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) {
@@ -1313,7 +911,7 @@ class ComRegister {
         }
         return content.data;
     }
-    async liveDetectWithAPI() {
+    /* async liveDetectWithAPI() {
         // 定义变量：第一次订阅
         let liveDetectSetup = true;
         // 定义变量：timer计时器
@@ -1321,11 +919,19 @@ class ComRegister {
         // 相当于锁的作用，防止上一个循环没处理完
         let flag = true;
         // 定义订阅对象Record 0未开播 1正在直播 2轮播中
-        const liveRecord = {};
+        const liveRecord: Record<
+            number,
+            {
+                liveStatus: number;
+                liveTime: string;
+                target: Target;
+            }
+        > = {};
+
         // 定义函数: 发送请求获取直播状态
-        const useLiveStatus = async (roomId) => {
+        const useLiveStatus = async (roomId: string) => {
             // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-            let content;
+            let content: any;
             const attempts = 3;
             for (let i = 0; i < attempts; i++) {
                 try {
@@ -1333,9 +939,10 @@ class ComRegister {
                     content = await this.ctx.ba.getLiveRoomInfo(roomId);
                     // 成功则跳出循环
                     break;
-                }
-                catch (e) {
-                    this.logger.error(`liveDetect getLiveRoomInfo 发生了错误，错误为：${e.message}`);
+                } catch (e) {
+                    this.logger.error(
+                        `liveDetect getLiveRoomInfo 发生了错误，错误为：${e.message}`,
+                    );
                     if (i === attempts - 1) {
                         // 已尝试三次
                         // 发送私聊消息并重启服务
@@ -1346,10 +953,10 @@ class ComRegister {
             // 返回data
             return content.data;
         };
+
         return async () => {
             // 如果flag为false则说明前面的代码还未执行完，则直接返回
-            if (!flag)
-                return;
+            if (!flag) return;
             // 将标志位置为false
             flag = false;
             try {
@@ -1386,18 +993,30 @@ class ComRegister {
                                 // 设置直播中消息
                                 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}`)
+                                            .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);
+                                    this.sendLiveNotifyCard(
+                                        {
+                                            username: item.uname,
+                                            userface: item.face,
+                                            target: liveRecord[item.mid].target,
+                                            data,
+                                        },
+                                        LiveType.LiveBroadcast,
+                                        liveMsg,
+                                    );
                             }
                         }
                     }
@@ -1444,9 +1063,13 @@ class ComRegister {
                 }
                 if (currentLiveRecordKeys.length > currentLiveSubs.length) {
                     // 创建Set
-                    const setCurrentLiveSubs = new Set(currentLiveSubs.map((sub) => sub.uid));
+                    const setCurrentLiveSubs = new Set(
+                        currentLiveSubs.map((sub) => sub.uid),
+                    );
                     // 找出 currentLiveRecordKeys中比currentLiveSubs 多的元素
-                    const extraInCurrentLiveSubs = currentLiveRecordKeys.filter((key) => !setCurrentLiveSubs.has(key));
+                    const extraInCurrentLiveSubs = currentLiveRecordKeys.filter(
+                        (key) => !setCurrentLiveSubs.has(key),
+                    );
                     // 遍历 extraInCurrentLiveSubs
                     for (const subUID of extraInCurrentLiveSubs) {
                         // 删除记录
@@ -1470,17 +1093,29 @@ class ComRegister {
                                 // 定义开播通知语
                                 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}`)
+                                            .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);
+                                await this.sendLiveNotifyCard(
+                                    {
+                                        username: item.uname,
+                                        userface: item.face,
+                                        target: liveRecord[item.mid].target,
+                                        data,
+                                    },
+                                    LiveType.LiveBroadcast,
+                                    liveStartMsg,
+                                );
                                 // 改变开播状态
                                 liveRecord[item.mid].liveStatus = 1;
                                 // 结束
@@ -1498,17 +1133,29 @@ class ComRegister {
                                         // 定义直播中通知消息
                                         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}`)
+                                                    .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);
+                                        this.sendLiveNotifyCard(
+                                            {
+                                                username: item.uname,
+                                                userface: item.face,
+                                                target: liveRecord[item.mid].target,
+                                                data,
+                                            },
+                                            LiveType.LiveBroadcast,
+                                            liveMsg,
+                                        );
                                     }
                                 }
                             }
@@ -1516,38 +1163,71 @@ class ComRegister {
                     }
                 }
                 // 找出liveRecord中liveStatus为1但liveUsers中没有的元素
-                const extraInLiveRecord = currentLiveRecordKeys.filter((key) => !liveUsers.items.some((item) => item.mid === Number(key)));
+                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 liveRoomInfo = await this.useLiveRoomInfo(
+                        masterInfo.roomId.toString(),
+                    );
                     // 设置开播时间
                     liveRoomInfo.live_time = liveRecord[subUID].liveTime;
                     // 定义下播播通知语
                     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}`)
+                                .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);
+                    this.sendLiveNotifyCard(
+                        {
+                            username: masterInfo.username,
+                            userface: masterInfo.userface,
+                            target: liveRecord[subUID].target,
+                            data: liveRoomInfo,
+                        },
+                        LiveType.StopBroadcast,
+                        liveEndMsg,
+                    );
                 }
-            }
-            finally {
+            } finally {
                 // 执行完方法体不论如何都把flag设置为true
                 flag = true;
             }
         };
-    }
+    } */
+    // TODO:WordCloud
+    /* // 定义获取弹幕权重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;
+        }; */
     async liveDetectWithListener(roomId, target) {
         // 定义开播时间
         let liveTime;
@@ -1564,6 +1244,7 @@ class ComRegister {
         // biome-ignore lint/suspicious/noExplicitAny: <explanation>
         let liveRoomInfo;
         let masterInfo;
+        let watchedNum;
         // 找到频道/群组对应的
         const liveGuardBuyPushTargetArr = target.map((channel) => {
             // 获取符合条件的target
@@ -1579,17 +1260,20 @@ class ComRegister {
         // 定义定时推送函数
         const pushAtTimeFunc = async () => {
             // 判断是否信息是否获取成功
-            if (!(await useMasterAndLiveRoomInfo())) {
+            if (!(await useMasterAndLiveRoomInfo(type_1.LiveType.LiveBroadcast))) {
                 // 未获取成功，直接返回
                 return this.sendPrivateMsg("获取直播间信息失败，推送直播卡片失败！");
             }
             // 设置开播时间
             liveTime = liveRoomInfo.live_time;
+            // 获取watched
+            const watched = watchedNum?.toString() || '暂未获取到';
             // 设置直播中消息
             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;
             // 发送直播通知卡片
@@ -1598,28 +1282,10 @@ class ComRegister {
                 userface: masterInfo.userface,
                 target,
                 data: liveRoomInfo,
-            }, LiveType.LiveBroadcast, liveMsg);
+            }, type_1.LiveType.LiveBroadcast, watched, liveMsg);
         };
-        // TODO:WordCloud
-        /* // 定义获取弹幕权重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;
-        }; */
         // 定义直播间信息获取函数
-        const useMasterAndLiveRoomInfo = async () => {
+        const useMasterAndLiveRoomInfo = async (liveType) => {
             // 定义函数是否执行成功flag
             let flag = true;
             // 获取直播间信息
@@ -1637,7 +1303,7 @@ class ComRegister {
                 return flag;
             }
             // 获取主播信息(需要满足flag为true，liveRoomInfo.uid有值)
-            masterInfo = await this.useMasterInfo(liveRoomInfo.uid).catch(() => {
+            masterInfo = await this.useMasterInfo(liveRoomInfo.uid, masterInfo, liveType).catch(() => {
                 // 设置flag为false
                 flag = false;
                 // 返回空
@@ -1646,19 +1312,8 @@ class ComRegister {
             // 返回信息
             return flag;
         };
-        // 判断是否信息是否获取成功
-        if (!(await useMasterAndLiveRoomInfo())) {
-            // 未获取成功，直接返回
-            return this.sendPrivateMsg("获取直播间信息失败，启动直播间弹幕检测失败！");
-        }
         // 构建消息处理函数
         const handler = {
-            onOpen: () => {
-                this.logger.info("直播间连接成功");
-            },
-            onClose: () => {
-                this.logger.info("直播间连接已断开");
-            },
             onIncomeDanmu: ({ body }) => {
                 // 保存消息到数组
                 currentLiveDanmakuArr.push(body.content);
@@ -1667,6 +1322,10 @@ class ComRegister {
                 // 保存消息到数组
                 currentLiveDanmakuArr.push(body.content);
             },
+            onWatchedChange: ({ body }) => {
+                // 保存观看人数到变量
+                watchedNum = body.num;
+            },
             onGuardBuy: ({ body }) => {
                 // 定义消息
                 const content = `${body.user.uname}加入了大航海（${body.gift_name}）`;
@@ -1680,7 +1339,7 @@ class ComRegister {
                 // 设置开播状态为true
                 liveStatus = true;
                 // 判断是否信息是否获取成功
-                if (!(await useMasterAndLiveRoomInfo())) {
+                if (!(await useMasterAndLiveRoomInfo(type_1.LiveType.StartBroadcasting))) {
                     // 设置开播状态为false
                     liveStatus = false;
                     // 未获取成功，直接返回
@@ -1688,11 +1347,14 @@ class ComRegister {
                 }
                 // 设置开播时间
                 liveTime = liveRoomInfo.live_time;
+                // 获取当前粉丝数
+                const follower = 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;
                 // 推送开播通知
@@ -1701,7 +1363,7 @@ class ComRegister {
                     userface: masterInfo.userface,
                     target,
                     data: liveRoomInfo,
-                }, LiveType.StartBroadcasting, liveStartMsg);
+                }, type_1.LiveType.StartBroadcasting, follower, liveStartMsg);
                 // 判断定时器是否已开启
                 if (!pushAtTimeTimer) {
                     // 开始直播，开启定时器
@@ -1712,17 +1374,20 @@ class ComRegister {
                 // 将直播状态设置为false
                 liveStatus = false;
                 // 判断是否信息是否获取成功
-                if (!(await useMasterAndLiveRoomInfo())) {
+                if (!(await useMasterAndLiveRoomInfo(type_1.LiveType.StopBroadcast))) {
                     // 未获取成功，直接返回
                     return this.sendPrivateMsg("获取直播间信息失败，推送直播下播卡片失败！");
                 }
                 // 更改直播时长
                 liveRoomInfo.live_time = liveTime;
+                // 获取粉丝数变化
+                const followerChange = masterInfo.liveFollowerChange.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({
@@ -1730,7 +1395,7 @@ class ComRegister {
                     userface: masterInfo.userface,
                     target,
                     data: liveRoomInfo,
-                }, LiveType.StopBroadcast, liveEndMsg);
+                }, type_1.LiveType.StopBroadcast, followerChange, liveEndMsg);
                 // 关闭定时推送定时器
                 pushAtTimeTimer();
                 // 将推送定时器变量置空
@@ -1739,15 +1404,23 @@ class ComRegister {
         };
         // 启动直播间弹幕监测
         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?.toString() || '暂未获取到';
             // 定义直播中通知消息
             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;
             // 发送直播通知卡片
@@ -1757,7 +1430,7 @@ class ComRegister {
                     userface: masterInfo.userface,
                     target,
                     data: liveRoomInfo,
-                }, LiveType.LiveBroadcast, liveMsg);
+                }, type_1.LiveType.LiveBroadcast, watched, liveMsg);
             }
             // 正在直播，开启定时器
             // 判断定时器是否已开启
@@ -1777,38 +1450,6 @@ class ComRegister {
         }
         return table ? table : "没有订阅任何UP";
     }
-    async checkIfNeedSub(liveSub, dynamicSub, session, 
-    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-    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];
-        }
-        // 只订阅动态
-        return [false, true];
-    }
     updateSubNotifier() {
         // 更新控制台提示
         if (this.subNotifier)
@@ -1990,14 +1631,15 @@ class ComRegister {
                     // 发送提示
                     this.logger.warn(`UID:${sub.uid} 用户没有开通直播间，无法订阅直播！`);
                 }
-                //
+                // 直播类型模式匹配
                 const liveDetectModeSelector = {
                     API: async () => {
                         // 判断是否已开启直播检测
                         if (!this.liveDispose) {
                             // 未开启直播检测
                             // 开启直播检测并保存销毁函数
-                            this.liveDispose = await this.liveDetectWithAPI();
+                            // this.liveDispose = await this.liveDetectWithAPI();
+                            this.logger.warn("API模式暂时不可用");
                         }
                     },
                     WS: async () => {
@@ -2028,147 +1670,6 @@ class ComRegister {
             });
         }
     }
-    async loadSubFromDatabase() {
-        // 从数据库中获取数据
-        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);
-            /* 判断数据库是否被篡改 */
-            // 获取用户信息
-            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-            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;
-                    }
-                    default: {
-                        await deleteSub();
-                        // PrivateMsg
-                        await this.sendPrivateMsg(`UID:${sub.uid} 数据出现问题，自动取消订阅`);
-                        // log
-                        this.logger.info(`UID:${sub.uid} 数据出现问题，自动取消订阅`);
-                        return;
-                    }
-                }
-            }
-            // 检测房间号是否被篡改
-            if (sub.live &&
-                // biome-ignore lint/suspicious/noDoubleEquals: <explanation>
-                (!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,
-                dynamic: sub.dynamic === 1,
-                liveDispose: null,
-            };
-            // 定义直播模式监测器
-            const liveDetectModeSelector = {
-                API: async () => {
-                    // 判断是否已开启直播检测
-                    if (!this.liveDispose) {
-                        // 未开启直播检测
-                        // 开启直播检测并保存销毁函数
-                        this.liveDispose = await this.liveDetectWithAPI();
-                    }
-                },
-                WS: async () => {
-                    // 判断订阅直播数是否超过限制
-                    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++;
-                        // 订阅直播，开始循环检测
-                        await this.liveDetectWithListener(sub.room_id, target);
-                    }
-                },
-            };
-            // 判断是否订阅直播
-            if (sub.live) {
-                // 启动直播监测
-                await liveDetectModeSelector[this.config.liveDetectMode]();
-            }
-            // 保存新订阅对象
-            this.subManager.push(subManagerItem);
-        }
-    }
     checkIfDynamicDetectIsNeeded() {
         // 检查是否有订阅对象需要动态监测
         if (this.subManager.some((sub) => sub.dynamic))
@@ -2183,136 +1684,6 @@ 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;
-                    // 判断直播检测方式
-                    switch (this.config.liveDetectMode) {
-                        case "API": {
-                            msg = "请手动删除订阅，并重启插件";
-                            break;
-                        }
-                        case "WS": {
-                            // 取消直播监听
-                            this.ctx.bl.closeListener(sub.roomId);
-                        }
-                    }
-                    // 如果没有对这个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();
-            switch (this.config.liveDetectMode) {
-                case "API": {
-                    break;
-                }
-                case "WS": {
-                    // 停止直播检测
-                    this.ctx.bl.closeListener(sub.roomId);
-                }
-            }
-            // 从数据库中删除订阅
-            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) {
             // 数据库中有数据
@@ -2350,7 +1721,6 @@ class ComRegister {
             masterAccount: 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"),