koishi-plugin-bilibili-notify 2.0.0-alpha.9 → 2.0.0

package/lib/biliAPI.d.ts

@@ -26,6 +26,7 @@ declare class BiliAPI extends Service {
     }): Promise<string>;
     encrypt(text: string): string;
     decrypt(text: string): string;
+    getLiveRoomInfoStreamKey(roomId: string): Promise<any>;
     getServerUTCTime(): Promise<number>;
     getTimeNow(): Promise<any>;
     getAllGroup(): Promise<any>;

package/lib/biliAPI.js

@@ -41,6 +41,8 @@ const MODIFY_GROUP_MEMBER = 'https://api.bilibili.com/x/relation/tags/addUsers';
 const GET_ALL_GROUP = 'https://api.bilibili.com/x/relation/tags';
 const COPY_USER_TO_GROUP = 'https://api.bilibili.com/x/relation/tags/copyUsers';
 const GET_RELATION_GROUP_DETAIL = 'https://api.bilibili.com/x/relation/tag';
+// 直播
+const GET_LIVE_ROOM_INFO_STREAM_KEY = 'https://api.live.bilibili.com/xlive/web-room/v1/index/getDanmuInfo';
 class BiliAPI extends koishi_1.Service {
     static inject = ['database', 'notifier'];
     jar;
@@ -103,6 +105,17 @@ class BiliAPI extends koishi_1.Service {
         return decrypted.toString();
     }
     // BA API
+    async getLiveRoomInfoStreamKey(roomId) {
+        try {
+            // 获取直播间信息流密钥
+            const { data } = await this.client.get(`${GET_LIVE_ROOM_INFO_STREAM_KEY}?id=${roomId}`);
+            // 返回data
+            return data;
+        }
+        catch (e) {
+            throw new Error('网络异常，本次请求失败！');
+        }
+    }
     async getServerUTCTime() {
         try {
             const { data } = await this.client.get(GET_SERVER_UTC_TIME);

package/lib/comRegister.d.ts

@@ -1,8 +1,14 @@
 import { Bot, Context, FlatPick, Logger, Schema, Session } from "koishi";
 import { Notifier } from "@koishijs/plugin-notifier";
 import { LoginBili } from "./database";
+type ChannelIdArr = Array<{
+    channelId: string;
+    dynamic: boolean;
+    live: boolean;
+    atAll: boolean;
+}>;
 type TargetItem = {
-    idArr: Array<string>;
+    channelIdArr: ChannelIdArr;
     platform: string;
 };
 type Target = Array<TargetItem>;
@@ -30,17 +36,15 @@ declare class ComRegister {
     loginDBData: FlatPick<LoginBili, "dynamic_group_id">;
     privateBot: Bot<Context>;
     dynamicDispose: Function;
-    sendMsgFunc: (bot: Bot<Context, any>, guild: string, content: any) => Promise<void>;
+    sendMsgFunc: (bot: Bot<Context, any>, channelId: string, content: any) => Promise<void>;
     constructor(ctx: Context, config: ComRegister.Config);
-    splitMultiPlatformStr(str: string): Array<{
-        idArr: Array<string>;
-        platform: string;
-    }>;
+    init(ctx: Context, config: ComRegister.Config): Promise<void>;
+    splitMultiPlatformStr(str: string): Target;
     getBot(ctx: Context, pf: string): Bot<Context, any>;
     sendPrivateMsg(content: string): Promise<void>;
     sendPrivateMsgAndRebootService(ctx: Context): Promise<void>;
     sendPrivateMsgAndStopService(ctx: Context): Promise<void>;
-    sendMsg(ctx: Context, targets: Target, content: any): Promise<void>;
+    sendMsg(ctx: Context, targets: Target, content: any, live?: boolean): Promise<void>;
     dynamicDetect(ctx: Context): () => Promise<void>;
     debug_dynamicDetect(ctx: Context): () => Promise<void>;
     liveDetect(ctx: Context, roomId: string, target: Target): () => Promise<void>;
@@ -52,7 +56,10 @@ declare class ComRegister {
         flag: boolean;
         msg: string;
     }>;
-    getSubFromDatabase(ctx: Context): Promise<void>;
+    loadSubFromConfig(ctx: Context, subs: ComRegister.Config["sub"]): Promise<void>;
+    loadSubFromDatabase(ctx: Context): Promise<void>;
+    checkIfDynamicDetectIsNeeded(ctx: Context): void;
+    enableDynamicDetect(ctx: Context): void;
     unsubSingle(ctx: Context, id: string, type: number): string;
     checkIfUserIsTheLastOneWhoSubDyn(): void;
     unsubAll(ctx: Context, uid: string): void;
@@ -60,6 +67,20 @@ declare class ComRegister {
 }
 declare namespace ComRegister {
     interface Config {
+        sub: Array<{
+            uid: string;
+            dynamic: boolean;
+            live: boolean;
+            target: Array<{
+                channelIdArr: Array<{
+                    channelId: string;
+                    dynamic: boolean;
+                    live: boolean;
+                    atAll: boolean;
+                }>;
+                platform: string;
+            }>;
+        }>;
         master: {
             enable: boolean;
             platform: string;
@@ -69,7 +90,6 @@ declare namespace ComRegister {
         unlockSubLimits: boolean;
         automaticResend: boolean;
         changeMasterInfoApi: boolean;
-        liveStartAtAll: boolean;
         restartPush: boolean;
         pushTime: number;
         liveLoopTime: number;

package/lib/comRegister.js

@@ -37,56 +37,9 @@ class ComRegister {
     sendMsgFunc;
     // 构造函数
     constructor(ctx, config) {
-        this.logger = ctx.logger('cr');
-        this.config = config;
-        // 拿到私人机器人实例
-        this.privateBot = ctx.bots.find(bot => bot.platform === config.master.platform);
-        if (!this.privateBot) {
-            ctx.notifier.create({
-                content: '您未配置私人机器人，将无法向您推送机器人状态！'
-            });
-            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 (bot, guild, content) => {
-                // 多次尝试发送消息
-                const attempts = 3;
-                for (let i = 0; i < attempts; i++) {
-                    try {
-                        // 发送消息
-                        await bot.sendMessage(guild, content);
-                        // 防止消息发送速度过快被忽略
-                        await ctx.sleep(500);
-                        // 成功发送消息，跳出循环
-                        break;
-                    }
-                    catch (e) {
-                        if (i === attempts - 1) { // 已尝试三次
-                            this.logger.error(`发送群组ID:${guild}消息失败！原因: ` + e.message);
-                            console.log(e);
-                            this.sendPrivateMsg(`发送群组ID:${guild}消息失败，请查看日志`);
-                        }
-                    }
-                }
-            };
-        }
-        else {
-            this.sendMsgFunc = async (bot, guild, content) => {
-                try {
-                    // 发送消息
-                    await bot.sendMessage(guild, content);
-                }
-                catch (e) {
-                    this.logger.error(`发送群组ID:${guild}消息失败！原因: ` + e.message);
-                    await this.sendPrivateMsg(`发送群组ID:${guild}消息失败，请查看日志`);
-                }
-            };
-        }
+        // 初始化
+        this.init(ctx, config);
+        // 注册指令
         const statusCom = ctx.command('status', '插件状态相关指令', { permissions: ['authority:5'] });
         statusCom.subcommand('.dyn', '查看动态监测运行状态')
             .usage('查看动态监测运行状态')
@@ -198,7 +151,7 @@ class ComRegister {
                         // 销毁定时器
                         this.loginTimer();
                         // 订阅之前的订阅
-                        await this.getSubFromDatabase(ctx);
+                        await this.loadSubFromDatabase(ctx);
                         // 清除控制台通知
                         ctx.ba.disposeNotifier();
                         // 发送成功登录推送
@@ -265,12 +218,7 @@ class ComRegister {
                     // id--
                     this.num--;
                     // 判断是否还有动态订阅
-                    if (this.dynamicDispose && !this.subManager.find((sub) => sub.dynamic === true)) { // 没有动态订阅
-                        // 将动态检测关闭
-                        this.dynamicDispose();
-                        // 将动态监测置为空
-                        this.dynamicDispose = null;
-                    }
+                    this.checkIfUserIsTheLastOneWhoSubDyn();
                     // 发送成功通知
                     await session.send('已取消订阅该用户');
                     // 更新控制台提示
@@ -292,13 +240,14 @@ class ComRegister {
             return subTable;
         });
         biliCom
-            .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]+)*\.[A-Za-z0-9]+(?:,[A-Za-z0-9]+)*)*$/ })
+            .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')
-            .usage('订阅用户动态和直播通知，若需要订阅直播请加上-l，需要订阅动态则加上-d。若没有加任何参数，之后会向你单独询问，尖括号中为必选参数，中括号为可选参数，目标群号若不填，则默认为当前群聊')
-            .example('bili sub 1194210119 目标QQ群号(实验性) -l -d 订阅UID为1194210119的UP主的动态和直播')
-            .action(async ({ session, options }, mid) => {
+            .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)) {
@@ -317,73 +266,98 @@ class ComRegister {
             // 判断是否订阅对象存在
             if (!subUserData.flag)
                 return '订阅对象失败，请稍后重试！';
-            let target;
-            // 判断是否使用多平台功能
-            if (options.multiplatform) {
-                // 分割字符串，赋值给target
-                target = this.splitMultiPlatformStr(options.multiplatform);
+            // 定义目标变量
+            let target = [];
+            // 判断是否使用了多群组推送
+            if (groupId.length > 0) {
+                // 定义channelIdArr
+                const channelIdArr = [];
+                // 遍历输入的群组
+                groupId.forEach(group => {
+                    channelIdArr.push({
+                        channelId: group,
+                        dynamic: true,
+                        live: true,
+                        atAll: options.atAll
+                    });
+                });
+                target.push({
+                    channelIdArr,
+                    platform: session.event.platform
+                });
             }
-            if (target) {
-                target.forEach(async ({ idArr, platform }, index) => {
-                    if (idArr.length > 0) { // 输入了推送群号或频道号
-                        // 拿到对应的bot
-                        const bot = this.getBot(ctx, platform);
-                        // 判断是否配置了对应平台的机器人
-                        if (!ctx.bots.some(bot => bot.platform === platform)) {
-                            await session.send('您未配置对应平台的机器人，不能在该平台进行订阅操作');
-                        }
-                        // 判断是否需要加入的群全部推送
-                        if (idArr[0] !== 'all') {
-                            // 定义满足条件的群组数组
-                            const targetArr = [];
-                            // 获取机器人加入的群组
-                            const guildList = await bot.getGuildList();
-                            // 遍历target数组
-                            for (const id of idArr) {
-                                // 定义是否加入群组标志
-                                let flag = false;
-                                // 遍历群组
-                                for (const guild of guildList.data) {
-                                    // 获取频道列表
-                                    const channelList = await bot.getChannelList(guild.id);
-                                    // 判断机器人是否加入群聊或频道
-                                    if (channelList.data.some(channel => channel.id === id)) {
-                                        // 加入群聊或频道
-                                        targetArr.push(id);
-                                        // 设置标志位为true
-                                        flag = true;
-                                        // 结束循环
-                                        break;
+            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(ctx, 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}，无法对该群或频道进行推送`);
                                     }
                                 }
-                                if (!flag) {
-                                    // 不满足条件发送错误提示
-                                    await session.send(`您的机器未加入${id}，无法对该群或频道进行推送`);
+                                // 判断targetArr是否为空
+                                if (target.length === 0) {
+                                    // 为空则默认为当前环境
+                                    target = [{ channelIdArr: [{ channelId: session.event.channel.id, dynamic: true, live: true, atAll: options.atAll ? options.atAll : false }], platform: session.event.platform }];
+                                    // 没有满足条件的群组或频道
+                                    await session.send('没有满足条件的群组或频道，默认订阅到当前聊天环境');
                                 }
+                                // 将符合条件的群组添加到target中
+                                target[index].channelIdArr = targetArr;
                             }
-                            // 判断targetArr是否为空
-                            if (target.length === 0) {
-                                // 为空则默认为当前环境
-                                target = [{ idArr: [session.event.channel.id], platform: session.event.platform }];
-                                // 没有满足条件的群组或频道
-                                await session.send('没有满足条件的群组或频道，默认订阅到当前聊天环境');
-                            }
-                            // 将符合条件的群组添加到target中
-                            target[index].idArr = targetArr;
+                            // 如果为all则全部推送，不需要进行处理
+                        }
+                        else {
+                            // 未填写群号或频道号，默认为当前环境
+                            target = [{ channelIdArr: [{ channelId: session.event.channel.id, dynamic: true, live: true, atAll: options.atAll ? options.atAll : false }], platform: session.event.platform }];
+                            // 发送提示消息
+                            await session.send('没有填写群号或频道号，默认订阅到当前聊天环境');
                         }
-                        // 如果为all则全部推送，不需要进行修改
-                    }
-                    else {
-                        // 未填写群号或频道号，默认为当前环境
-                        target = [{ idArr: [session.event.channel.id], platform: session.event.platform }];
-                        // 发送提示消息
-                        await session.send('没有填写群号或频道号，默认订阅到当前聊天环境');
                     }
-                });
-            }
-            else {
-                // 用户直接订阅，将当前环境赋值给target
-                target = [{ idArr: [session.event.channel.id], platform: session.event.platform }];
+                }
+                else {
+                    // 用户直接订阅，将当前环境赋值给target
+                    target = [{ channelIdArr: [{ channelId: session.event.channel.id, dynamic: true, live: true, atAll: options.atAll ? options.atAll : false }], platform: session.event.platform }];
+                }
             }
             // 定义外围变量                
             let content;
@@ -465,13 +439,7 @@ class ComRegister {
             if (dynamicMsg) {
                 // 判断是否开启动态监测
                 if (!this.dynamicDispose) {
-                    // 开启动态监测
-                    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);
-                    }
+                    this.enableDynamicDetect(ctx);
                 }
                 // 发送订阅消息通知
                 await session.send(`订阅${userData.info.uname}动态通知`);
@@ -481,7 +449,6 @@ class ComRegister {
                 uid: mid,
                 room_id: roomId,
                 dynamic: dynamicMsg ? 1 : 0,
-                video: 1,
                 live: liveMsg ? 1 : 0,
                 target: JSON.stringify(target),
                 platform: session.event.platform,
@@ -503,23 +470,6 @@ class ComRegister {
             // 新增订阅展示到控制台
             this.updateSubNotifier(ctx);
         });
-        /* 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, this.subManager[index].platform), config.liveLoopTime * 1000)
-                // 保存销毁函数
-                this.subManager[index].liveDispose = dispose
-            }) */
         biliCom
             .subcommand('.status <roomId:string>', '查询主播当前直播状态', { hidden: true })
             .usage('查询主播当前直播状态')
@@ -574,10 +524,74 @@ class ComRegister {
             await session.send('已发送消息，如未收到则说明您的机器人不支持发送私聊消息或您的信息填写有误');
         });
     }
+    async init(ctx, config) {
+        // 设置logger
+        this.logger = ctx.logger('cr');
+        // 将config设置给类属性
+        this.config = config;
+        // 拿到私人机器人实例
+        this.privateBot = ctx.bots.find(bot => bot.platform === config.master.platform);
+        if (!this.privateBot) {
+            ctx.notifier.create({
+                content: '您未配置私人机器人，将无法向您推送机器人状态！'
+            });
+            this.logger.error('您未配置私人机器人，将无法向您推送机器人状态！');
+        }
+        // 检查登录数据库是否有数据
+        this.loginDBData = (await ctx.database.get('loginBili', 1, ['dynamic_group_id']))[0];
+        // 从配置获取订阅
+        config.sub && await this.loadSubFromConfig(ctx, config.sub);
+        // 从数据库获取订阅
+        await this.loadSubFromDatabase(ctx);
+        // 判断消息发送方式
+        if (config.automaticResend) {
+            this.sendMsgFunc = async (bot, channelId, content) => {
+                // 多次尝试发送消息
+                const attempts = 3;
+                for (let i = 0; i < attempts; i++) {
+                    try {
+                        // 发送消息
+                        await bot.sendMessage(channelId, content);
+                        // 防止消息发送速度过快被忽略
+                        await ctx.sleep(500);
+                        // 成功发送消息，跳出循环
+                        break;
+                    }
+                    catch (e) {
+                        if (i === attempts - 1) { // 已尝试三次
+                            this.logger.error(`发送群组ID:${channelId}消息失败！原因: ` + e.message);
+                            console.log(e);
+                            this.sendPrivateMsg(`发送群组ID:${channelId}消息失败，请查看日志`);
+                        }
+                    }
+                }
+            };
+        }
+        else {
+            this.sendMsgFunc = async (bot, guild, content) => {
+                try {
+                    // 发送消息
+                    await bot.sendMessage(guild, content);
+                }
+                catch (e) {
+                    this.logger.error(`发送群组ID:${guild}消息失败！原因: ` + e.message);
+                    await this.sendPrivateMsg(`发送群组ID:${guild}消息失败，请查看日志`);
+                }
+            };
+        }
+        // 检查是否需要动态监测
+        this.checkIfDynamicDetectIsNeeded(ctx);
+        // 在控制台中显示订阅对象
+        this.updateSubNotifier(ctx);
+    }
     splitMultiPlatformStr(str) {
         return str.split(';').map(cv => cv.split('.')).map(([idStr, platform]) => {
-            const idArr = idStr.split(',');
-            return { idArr, 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, atAll };
+            });
+            return { channelIdArr, platform };
         });
     }
     getBot(ctx, pf) {
@@ -636,31 +650,58 @@ class ComRegister {
         // 结束
         return;
     }
-    async sendMsg(ctx, targets, content) {
+    async sendMsg(ctx, targets, content, live) {
         for (const target of targets) {
             // 获取机器人实例
             const bot = this.getBot(ctx, target.platform);
             // 定义需要发送的数组
             let sendArr = [];
             // 判断是否需要推送所有机器人加入的群
-            if (target.idArr[0] === 'all') {
+            if (target.channelIdArr[0].channelId === 'all') {
                 // 获取所有guild
                 for (const guild of (await bot.getGuildList()).data) {
-                    sendArr.push(guild.id);
+                    sendArr.push({
+                        channelId: guild.id,
+                        dynamic: target.channelIdArr[0].dynamic,
+                        live: target.channelIdArr[0].live,
+                        atAll: target.channelIdArr[0].atAll
+                    });
                 }
             }
             else {
-                sendArr = target.idArr;
+                sendArr = target.channelIdArr;
             }
-            // 循环给每个群组发送
-            for (const guild of sendArr) {
-                await this.sendMsgFunc(bot, guild, content);
+            // 判断是否是直播开播推送，如果是则需要进一步判断是否需要艾特群体成员
+            if (live) {
+                // 直播开播推送，判断是否需要艾特全体成员
+                for (const channel of sendArr) {
+                    // 判断是否需要推送直播消息
+                    if (channel.live) {
+                        await this.sendMsgFunc(bot, channel.channelId, content);
+                    }
+                    // 判断是否需要艾特全体成员
+                    if (channel.atAll) {
+                        await this.sendMsgFunc(bot, channel.channelId, (0, jsx_runtime_1.jsx)("at", { type: "all" }));
+                    }
+                }
+            }
+            else {
+                for (const channel of sendArr) {
+                    // 判断是否需要推送动态消息和直播消息
+                    if (channel.dynamic || channel.live) {
+                        await this.sendMsgFunc(bot, channel.channelId, content);
+                    }
+                }
             }
         }
     }
     dynamicDetect(ctx) {
+        // 检测初始化变量
         let detectSetup = true;
+        // 更新基线
         let updateBaseline;
+        // 第一条动态的动态ID
+        let dynamicIdStr;
         // 相当于锁的作用，防止上一个循环没处理完
         let flag = true;
         // 返回一个闭包函数
@@ -757,14 +798,23 @@ class ComRegister {
                     // 寻找关注的UP主的动态
                     this.subManager.forEach(async (sub) => {
                         // 判断是否是订阅的UP主
-                        if (sub.uid == upUID) {
-                            // 订阅该UP主，推送该动态
+                        if (sub.dynamic && sub.uid == upUID) { // 订阅该UP主，推送该动态
+                            // 判断更新动态是否为1条
+                            if (updateNum === 1) {
+                                // 判断dynamicIdStr是否有值，是否与当前动态ID一致
+                                if (dynamicIdStr && dynamicIdStr === items[num].id_str) {
+                                    // 重复动态，不再推送，直接返回
+                                    return;
+                                }
+                                // 存储该动态ID
+                                dynamicIdStr = items[num].id_str;
+                            }
                             // 定义变量
                             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 upName = items[num].modules.module_author.name;
+                            const dynamicId = items[num].id_str;
                             // 推送该条动态
                             const attempts = 3;
                             for (let i = 0; i < attempts; i++) {
@@ -829,8 +879,12 @@ class ComRegister {
         };
     }
     debug_dynamicDetect(ctx) {
+        // 检测初始化变量
         let detectSetup = true;
+        // 更新基线
         let updateBaseline;
+        // 第一条动态的动态ID
+        let dynamicIdStr;
         // 相当于锁的作用，防止上一个循环没处理完
         let flag = true;
         // 返回一个闭包函数
@@ -940,14 +994,23 @@ class ComRegister {
                     this.subManager.forEach(async (sub) => {
                         console.log(`当前订阅UP主：${sub.uid}`);
                         // 判断是否是订阅的UP主
-                        if (sub.uid == upUID) {
-                            // 订阅该UP主，推送该动态
+                        if (sub.dynamic && sub.uid == upUID) { // 订阅该UP主，推送该动态
+                            // 判断更新动态是否为1条
+                            if (updateNum === 1) {
+                                // 判断dynamicIdStr是否有值，是否与当前动态ID一致
+                                if (dynamicIdStr && dynamicIdStr === items[num].id_str) {
+                                    // 重复动态，不再推送，直接返回
+                                    return;
+                                }
+                                // 存储该动态ID
+                                dynamicIdStr = items[num].id_str;
+                            }
                             // 定义变量
                             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 upName = items[num].modules.module_author.name;
+                            const dynamicId = items[num].id_str;
                             console.log(`UP主名称：${upName}，动态ID：${dynamicId}`);
                             // 推送该条动态
                             const attempts = 3;
@@ -1022,7 +1085,7 @@ class ComRegister {
         // 相当于锁的作用，防止上一个循环没处理完
         let flag = true;
         // 定义发送直播通知卡片方法
-        const sendLiveNotifyCard = async (data, liveType, liveNotifyMsg, atAll) => {
+        const sendLiveNotifyCard = async (data, liveType, liveNotifyMsg) => {
             // 定义变量
             let pic;
             let buffer;
@@ -1049,12 +1112,21 @@ class ComRegister {
             // 推送直播信息
             // 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" }), liveNotifyMsg && liveNotifyMsg] });
-                return await this.sendMsg(ctx, target, pic + msg);
+                // 只有在开播时才艾特全体成员
+                if (liveType === LiveType.StartBroadcasting) {
+                    return await this.sendMsg(ctx, target, pic + (liveNotifyMsg ?? ''), true);
+                }
+                // 正常不需要艾特全体成员
+                return await this.sendMsg(ctx, target, pic + (liveNotifyMsg ?? ''));
             }
             // 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" }), liveNotifyMsg && liveNotifyMsg] });
-            await this.sendMsg(ctx, target, pic + msg);
+            const msg = (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, 'image/png'), liveNotifyMsg || ''] });
+            // 只有在开播时才艾特全体成员
+            if (liveType === LiveType.StartBroadcasting) {
+                return await this.sendMsg(ctx, target, msg, true);
+            }
+            // 正常不需要艾特全体成员
+            return await this.sendMsg(ctx, target, msg);
         };
         // 定义获取主播信息方法
         let useMasterInfo;
@@ -1122,9 +1194,14 @@ class ComRegister {
                     if (data.live_status === 1) { // 当前正在直播
                         // 设置开播时间
                         liveTime = data.live_time;
+                        // 设置直播中消息
+                        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}`) : null;
                         // 发送直播通知卡片
                         if (this.config.restartPush)
-                            sendLiveNotifyCard(data, LiveType.LiveBroadcast);
+                            sendLiveNotifyCard(data, LiveType.LiveBroadcast, liveMsg);
                         // 改变开播状态
                         open = true;
                     } // 未开播，直接返回
@@ -1140,9 +1217,9 @@ class ComRegister {
                             // 下播了将定时器清零
                             timer = 0;
                             // 定义下播通知消息
-                            const liveEndMsg = this.config.customLiveEnd
+                            const liveEndMsg = this.config.customLiveEnd ? this.config.customLiveEnd
                                 .replace('-name', username)
-                                .replace('-time', await ctx.gi.getTimeDifference(liveTime));
+                                .replace('-time', await ctx.gi.getTimeDifference(liveTime)) : null;
                             // 更改直播时长
                             data.live_time = liveTime;
                             // 发送@全体成员通知
@@ -1175,20 +1252,13 @@ class ComRegister {
                                     }
                                 }
                             }
-                            // 定义开播通知语
-                            const liveStartMsg = this.config.customLiveStart
+                            // 定义开播通知语                            
+                            const liveStartMsg = this.config.customLiveStart ? this.config.customLiveStart
                                 .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);
-                            }
+                                .replace('-link', `https://live.bilibili.com/${data.short_id === 0 ? data.room_id : data.short_id}`) : null;
+                            // 发送消息
+                            await sendLiveNotifyCard(data, LiveType.StartBroadcasting, liveStartMsg);
                         }
                         else { // 还在直播
                             if (this.config.pushTime > 0) {
@@ -1201,7 +1271,7 @@ class ComRegister {
                                     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}`) : '';
+                                        .replace('-link', `https://live.bilibili.com/${data.short_id === 0 ? data.room_id : data.short_id}`) : null;
                                     // 发送直播通知卡片
                                     sendLiveNotifyCard(data, LiveType.LiveBroadcast, liveMsg);
                                 }
@@ -1380,7 +1450,67 @@ class ComRegister {
         // 订阅成功
         return { flag: true, msg: '用户订阅成功' };
     }
-    async getSubFromDatabase(ctx) {
+    async loadSubFromConfig(ctx, subs) {
+        for (const sub of subs) {
+            // 定义Data
+            let data;
+            // 定义直播销毁函数
+            let liveDispose;
+            // 判断是否需要订阅直播
+            if (sub.live) {
+                // 获取用户信息
+                let content;
+                // 设置重试次数
+                const attempts = 3;
+                for (let i = 0; i < attempts; i++) {
+                    try {
+                        // 获取用户信息
+                        content = await ctx.ba.getUserInfo(sub.uid);
+                        // 成功则跳出循环
+                        break;
+                    }
+                    catch (e) {
+                        this.logger.error('getSubFromDatabase() getUserInfo() 发生了错误，错误为：' + e.message);
+                        if (i === attempts - 1) { // 已尝试三次
+                            // 发送私聊消息并重启服务
+                            return await this.sendPrivateMsgAndStopService(ctx);
+                        }
+                    }
+                }
+                // 获取data
+                data = content.data;
+                // 检查roomid是否存在
+                if (!data.live_room) {
+                    // 用户没有开通直播间，无法订阅直播
+                    sub.live = false;
+                    // 发送提示
+                    this.logger.warn(`UID:${sub.uid} 用户没有开通直播间，无法订阅直播！`);
+                }
+                // 判断是否订阅直播
+                if (sub.live) {
+                    // 订阅直播
+                    liveDispose = ctx.setInterval(this.liveDetect(ctx, data.live_room.roomid, sub.target), this.config.liveLoopTime * 1000);
+                }
+            }
+            // 在B站中订阅该对象
+            const subInfo = await this.subUserInBili(ctx, sub.uid);
+            // 判断订阅是否成功
+            if (!subInfo.flag)
+                this.logger.warn(subInfo.msg);
+            // 将该订阅添加到sm中
+            this.subManager.push({
+                id: +sub.uid,
+                uid: sub.uid,
+                roomId: sub.live ? data.live_room.roomid : '',
+                target: sub.target,
+                platform: '',
+                live: sub.live,
+                dynamic: sub.dynamic,
+                liveDispose
+            });
+        }
+    }
+    async loadSubFromDatabase(ctx) {
         // 判断登录信息是否已加载完毕
         await this.checkIfLoginInfoIsLoaded(ctx);
         // 如果未登录，则直接返回
@@ -1478,6 +1608,7 @@ class ComRegister {
                 this.logger.info(`UID:${sub.uid} 房间号被篡改，自动取消订阅`);
                 // Send msg
                 await this.sendPrivateMsg(`UID:${sub.uid} 房间号被篡改，自动取消订阅`);
+                // 直接返回
                 return;
             }
             // 构建订阅对象
@@ -1487,19 +1618,20 @@ class ComRegister {
                 roomId: sub.room_id,
                 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) {
                 // 判断订阅直播数是否超过限制
                 if (!this.config.unlockSubLimits && liveSubNum >= 3) {
+                    // 将live改为false
                     subManagerItem.live = false;
                     // log
                     this.logger.warn(`UID:${sub.uid} 订阅直播数超过限制，自动取消订阅`);
                     // 发送错误消息
-                    this.sendPrivateMsg(`UID:${sub.uid} 订阅直播数超过限制，自动取消订阅`);
+                    await this.sendPrivateMsg(`UID:${sub.uid} 订阅直播数超过限制，自动取消订阅`);
                 }
                 else {
                     // 直播订阅数+1
@@ -1513,18 +1645,20 @@ class ComRegister {
             // 保存新订阅对象
             this.subManager.push(subManagerItem);
         }
+    }
+    checkIfDynamicDetectIsNeeded(ctx) {
         // 检查是否有订阅对象需要动态监测
-        if (this.subManager.some(sub => sub.dynamic)) {
-            // 开始动态监测
-            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 */);
-            }
+        if (this.subManager.some(sub => sub.dynamic))
+            this.enableDynamicDetect(ctx);
+    }
+    enableDynamicDetect(ctx) {
+        // 开始动态监测
+        if (this.config.dynamicDebugMode) {
+            this.dynamicDispose = ctx.setInterval(this.debug_dynamicDetect(ctx), this.config.dynamicLoopTime * 1000);
+        }
+        else {
+            this.dynamicDispose = ctx.setInterval(this.dynamicDetect(ctx), this.config.dynamicLoopTime * 1000);
         }
-        // 在控制台中显示订阅对象
-        this.updateSubNotifier(ctx);
     }
     unsubSingle(ctx, id /* UID或RoomId */, type /* 0取消Live订阅，1取消Dynamic订阅 */) {
         // 定义返回消息
@@ -1607,7 +1741,7 @@ class ComRegister {
         }
     }
     checkIfUserIsTheLastOneWhoSubDyn() {
-        if (this.subManager.some(sub => sub.dynamic)) {
+        if (this.dynamicDispose && !this.subManager.some(sub => sub.dynamic)) {
             // 停止动态监测
             this.dynamicDispose();
             this.dynamicDispose = null;
@@ -1644,6 +1778,20 @@ class ComRegister {
 }
 (function (ComRegister) {
     ComRegister.Config = koishi_1.Schema.object({
+        sub: koishi_1.Schema.array(koishi_1.Schema.object({
+            uid: koishi_1.Schema.string().description('订阅用户UID'),
+            dynamic: koishi_1.Schema.boolean().description('是否订阅用户动态'),
+            live: koishi_1.Schema.boolean().description('是否订阅用户直播'),
+            target: koishi_1.Schema.array(koishi_1.Schema.object({
+                channelIdArr: koishi_1.Schema.array(koishi_1.Schema.object({
+                    channelId: koishi_1.Schema.string().description('频道/群组号'),
+                    dynamic: koishi_1.Schema.boolean().description('该频道/群组是否推送动态信息'),
+                    live: koishi_1.Schema.boolean().description('该频道/群组是否推送直播通知'),
+                    atAll: koishi_1.Schema.boolean().description('推送开播通知时是否艾特全体成员')
+                })).description('频道/群组信息'),
+                platform: koishi_1.Schema.string().description('推送平台')
+            })).description('订阅用户需要发送的频道/群组信息')
+        })).role('table').description('手动输入订阅信息，方便自定义订阅内容，这里的订阅内容不会存入数据库。uid: 订阅用户UID，dynamic: 是否需要订阅动态，live: 是否需要订阅直播'),
         master: koishi_1.Schema.object({
             enable: koishi_1.Schema.boolean(),
             platform: koishi_1.Schema.string(),
@@ -1653,7 +1801,6 @@ class ComRegister {
         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(),
         pushTime: koishi_1.Schema.number().required(),
         liveLoopTime: koishi_1.Schema.number().default(10),

package/lib/database.d.ts

@@ -10,7 +10,6 @@ export interface Bilibili {
     uid: string;
     room_id: string;
     dynamic: number;
-    video: number;
     live: number;
     target: string;
     platform: string;

package/lib/database.js

@@ -10,7 +10,6 @@ function apply(ctx) {
         uid: 'string',
         room_id: 'string',
         dynamic: 'unsigned',
-        video: 'unsigned',
         live: 'unsigned',
         target: 'string',
         platform: 'string',

package/lib/generateImg.js

@@ -176,7 +176,7 @@ class GenerateImg extends koishi_1.Service {
                                 </div>
                                 ${this.giConfig.hideDesc ? '' : `<p class="card-text">${data.description ? data.description : '这个主播很懒，什么都简介都没写'}</p>`}
                                 <p class="card-link">
-                                    <span>人气：${data.online > 10000 ? `${(data.online / 10000).toFixed(1)}万` : data.online}</span>
+                                    ${liveStatus !== 3 ? `<span>人气：${data.online > 10000 ? `${(data.online / 10000).toFixed(1)}万` : data.online}</span>` : ''}
                                     <span>分区名称：${data.area_name}</span>
                                 </p>
                                 <p class="card-link">

package/lib/index.d.ts

@@ -15,6 +15,21 @@ export interface Config {
     automaticResend: boolean;
     renderType: 'render' | 'page';
     userAgent: string;
+    subTitle: {};
+    sub: Array<{
+        uid: string;
+        dynamic: boolean;
+        live: boolean;
+        target: Array<{
+            channelIdArr: Array<{
+                channelId: string;
+                dynamic: boolean;
+                live: boolean;
+                atAll: boolean;
+            }>;
+            platform: string;
+        }>;
+    }>;
     dynamic: {};
     dynamicUrl: boolean;
     dynamicCheckNumber: number;

package/lib/index.js

@@ -93,6 +93,21 @@ exports.Config = koishi_1.Schema.object({
     userAgent: koishi_1.Schema.string()
         .required()
         .description('设置请求头User-Agen，请求出现-352时可以尝试修改，UA获取方法可参考：https://blog.csdn.net/qq_44503987/article/details/104929111'),
+    subTitle: koishi_1.Schema.object({}).description('手动订阅'),
+    sub: koishi_1.Schema.array(koishi_1.Schema.object({
+        uid: koishi_1.Schema.string().description('订阅用户UID'),
+        dynamic: koishi_1.Schema.boolean().description('是否订阅用户动态'),
+        live: koishi_1.Schema.boolean().description('是否订阅用户直播'),
+        target: koishi_1.Schema.array(koishi_1.Schema.object({
+            channelIdArr: koishi_1.Schema.array(koishi_1.Schema.object({
+                channelId: koishi_1.Schema.string().description('频道/群组号'),
+                dynamic: koishi_1.Schema.boolean().description('该频道/群组是否推送动态信息'),
+                live: koishi_1.Schema.boolean().description('该频道/群组是否推送直播通知'),
+                atAll: koishi_1.Schema.boolean().description('推送开播通知时是否艾特全体成员')
+            })).description('频道/群组信息'),
+            platform: koishi_1.Schema.string().description('推送平台')
+        })).description('订阅用户需要发送的频道/群组信息')
+    })).role('table').description('手动输入订阅信息，方便自定义订阅内容，这里的订阅内容不会存入数据库。uid: 订阅用户UID，dynamic: 是否需要订阅动态，live: 是否需要订阅直播'),
     dynamic: koishi_1.Schema.object({}).description('动态推送设置'),
     dynamicUrl: koishi_1.Schema.boolean()
         .default(false)
@@ -290,6 +305,7 @@ class ServerManager extends koishi_1.Service {
             });
             // CR = ComRegister
             const cr = this.ctx.plugin(comRegister_1.default, {
+                sub: globalConfig.sub,
                 master: globalConfig.master,
                 unlockSubLimits: globalConfig.unlockSubLimits,
                 automaticResend: globalConfig.automaticResend,
@@ -298,6 +314,7 @@ class ServerManager extends koishi_1.Service {
                 restartPush: globalConfig.restartPush,
                 pushTime: globalConfig.pushTime,
                 customLiveStart: globalConfig.customLiveStart,
+                customLive: globalConfig.customLive,
                 customLiveEnd: globalConfig.customLiveEnd,
                 dynamicCheckNumber: globalConfig.dynamicCheckNumber,
                 dynamicLoopTime: this.dynamicLoopTime,
@@ -341,9 +358,9 @@ class ServerManager extends koishi_1.Service {
         await this.disposePlugin();
         // 隔一秒启动插件
         return new Promise(resolve => {
-            this.ctx.setTimeout(async () => {
+            this.ctx.setTimeout(() => {
                 try {
-                    await this.registerPlugin();
+                    this.registerPlugin();
                 }
                 catch (e) {
                     this.logger.error('重启插件失败', e);
@@ -359,7 +376,7 @@ function apply(ctx, config) {
     globalConfig = config;
     // 设置提示
     ctx.notifier.create({
-        content: '从2.0.0-alpha.7以前版本更新需重新订阅'
+        content: '从2.0.0-alpha.9以前版本更新需重新订阅'
     });
     ctx.notifier.create({
         content: '请使用Auth插件创建超级管理员账号，没有权限将无法使用该插件提供的指令。'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-bilibili-notify",
   "description": "Koishi bilibili notify plugin",
-  "version": "2.0.0-alpha.9",
+  "version": "2.0.0",
   "contributors": [
     "Akokko <admin@akokko.com>"
   ],

package/{README.md → readme.md}

@@ -53,15 +53,19 @@
 
 订阅UP主：订阅你想要推送的UP主
 
-- 使用指令 `bili sub <uid>` 订阅需要订阅的UP主
+- 使用指令 `bili sub <uid> [...groupId]` 订阅需要订阅的UP主
 - 参数说明：
   - `uid` 为必填参数，为 `up主` 的  `uid` 
-- 选项说明：`bili sub <uid>` 有三个选项：-l -d -m
+  - `groupId` 为可选参数，为需要推送的群号/频道号，可输入多个群号
+- 选项说明：`bili sub <uid>` 有四个选项：-l -d -m -a
   - `-l` 为订阅UP主直播间，包括直播开播通知，定时推送直播内容，下播通知
   - `-d` 为订阅UP主动态推送，目前实现推送的动态类型有：普通图文动态，转发动态，直播预约动态
-  - `-m` 为多平台动态推送，格式为：群号/频道号,群号/频道号,群号/频道号.平台名;群号/频道号,群号/频道号.平台号
+  - `-m` 为多平台动态推送，格式为：群号/频道号,群号/频道号,群号/频道号.平台名;群号/频道号,群号/频道号.平台号。如果群号/频道号为 `all` 代表推送该平台下的所有群聊或/频道。在群号/频道号后加 `@` 则代表这个群聊/频道需要@全体成员。订阅TG群组时请使用 `bili sub xxx -m "xxxxxxx"` 这样的格式
+  - `-a` 为是否艾特全体成员，对 `-m` 参数不生效
+  
   例如：
-  `-m 3247293,324389,89874324.qq;EDBWIUBIU.qqguild;79324792,3247892.onebot`
+  `-m 3247293,324389,89874324.qq;EDBWIUBIU.qqguild;79324792,3247892.onebot` 代表推送QQ下3247293,324389,89874324这三个群聊，QQ频道下EDBWIUBIU这个频道，Onebot平台下79324792,3247892这两个群聊
+  `-m 3247293,324389@,89874324.qq` 代表推送QQ下3247293,324389,89874324这三个群聊，其中群聊324389需要艾特全体成员
   所有分隔符均为英文符号
 
 - 例如：
@@ -69,6 +73,7 @@
   - `bili sub 1194210119 -d` 订阅UID为1194210119的UP主动态推送
   - `bili sub 1194210119 -l` 订阅UID为1194210119的UP主直播间
   - `bili sub 1194210119 -m 3247293,324389,89874324.qq;all.onebot;EHUIWDBUAWD.qqguild` 订阅UID为1194210119的UP主，向群号为3247293，324389，89874324的QQ群，所有onebot平台下的群聊，频道号为EHUIWDBUAWD的QQ频道平台进行推送
+  - `bili sub 1194210119 -a` 订阅UID为1194210119的UP主动态推送和直播间并艾特全体成员
 
 取消订阅UP主：取消订阅不需要推送的UP主
 
@@ -191,6 +196,21 @@
 - ver 2.0.0-alpha.7 重构：现已支持同一UP多平台推送
 - ver 2.0.0-alpha.8 新增：重新订阅提示
 - ver 2.0.0-alpha.9 修复：订阅反复提示未加入群组的bug，实际已加入
+- ver 2.0.0-alpha.10 新增：可对每个群聊针对性设置是否艾特全体成员 优化：直播下播通知
+- ver 2.0.0-alpha.11 回档：订阅时可直接接收群号/频道号  修复：直播过程推送消息不成功的bug
+- ver 2.0.0-alpha.12 更改：开启艾特全体成员后，只有在开播时才艾特全体成员
+- ver 2.0.0-alpha.13 修复：无法对TG群组的特殊频道号进行订阅处理；提示 `您未配置对应平台的机器人，不能在该平台进行订阅操作` 仍进行订阅操作
+- ver 2.0.0-alpha.14 修复：订阅TG群组时提示输入无效
+- ver 2.0.0-alpha.15 新增：手动订阅功能  修复：一些潜在的bug
+- ver 2.0.0-alpha.16 优化：手动订阅功能
+- ver 2.0.0-alpha.17 修复：直接订阅当前环境不会推送
+- ver 2.0.0-alpha.18 修复：手动订阅无法推送直播通知；自定义直播中通知语不会发送
+- ver 2.0.0-alpha.19 修复：开播通知后带false；下播通知卡片人气位置显示false
+- ver 2.0.0-alpha.20 修复：直播推送失败 `Error with request send_group_msg`
+- ver 2.0.0-alpha.21 修复：在某些场景下仍会出现 `2.0.0-alpha.19` 和 `2.0.0-alpha.20` 版本已修复的问题
+- ver 2.0.0-alpha.22 移除：不需要的服务
+- ver 2.0.0-alpha.23 优化：将艾特全体成员消息单独发送
+- ver 2.0.0 修复：只订阅直播也会将该UP主的动态进行推送、推送过的动态过一段时间又会再次推送
 
 ## 交流群