koishi-plugin-bilibili-notify 3.1.0 → 3.1.2-alpha.0

package/lib/comRegister.d.ts

@@ -24,6 +24,7 @@ declare class ComRegister {
     sendPrivateMsgAndRebootService(): Promise<void>;
     sendPrivateMsgAndStopService(): Promise<void>;
     sendMessageWithRetry(bot: Bot<Context>, channelId: string, content: any): Promise<void>;
+    getGroupsThatMeetCriteria(targets: Target, type: PushType): string[];
     broadcastToTargets(targets: Target, content: any, type: PushType): Promise<void>;
     dynamicDetect(): (...args: any[]) => void;
     debug_dynamicDetect(): (...args: any[]) => void;
@@ -73,7 +74,6 @@ declare namespace ComRegister {
             masterAccount: string;
             masterAccountGuildId: string;
         };
-        liveDetectMode: "API" | "WS";
         restartPush: boolean;
         pushTime: number;
         pushImgsInDynamic: boolean;

package/lib/comRegister.js

@@ -422,82 +422,93 @@ class ComRegister {
             await this.sendPrivateMsg(`发送群组ID:${channelId}消息失败，请查看日志`);
         });
     }
-    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-    async broadcastToTargets(targets, content, type) {
-        for (const target of targets) {
-            // 获取机器人实例
-            const bot = this.getBot(target.platform);
-            // 定义需要发送的数组
-            let channelArr = [];
-            // 判断是否需要推送所有机器人加入的群
-            if (target.channelArr[0].channelId === "all") {
-                // 获取所有guild
-                for (const guild of (await bot.getGuildList()).data) {
-                    channelArr.push({
-                        channelId: guild.id,
-                        dynamic: target.channelArr[0].dynamic,
-                        live: target.channelArr[0].live,
-                        liveGuardBuy: target.channelArr[0].liveGuardBuy,
-                        atAll: target.channelArr[0].atAll,
-                    });
+    getGroupsThatMeetCriteria(targets, type) {
+        // 定义数组
+        const pushArr = [];
+        // 判断类型
+        if (type === type_1.PushType.Live || type === type_1.PushType.StartBroadcasting) {
+            for (const target of targets) {
+                for (const channel of target.channelArr) {
+                    if (channel.live) {
+                        pushArr.push(`${target.platform}:${channel.channelId}`);
+                    }
                 }
             }
-            else {
-                channelArr = target.channelArr;
-            }
-            // 模式匹配
-            const pushTypePatternMatching = {
-                [type_1.PushType.Live]: async () => {
-                    for (const channel of channelArr) {
-                        // 判断是否需要推送动态消息
-                        if (channel.live) {
-                            await this.sendMessageWithRetry(bot, channel.channelId, content);
-                        }
-                        // 延迟发送
-                        await this.ctx.sleep(500);
-                    }
-                },
-                [type_1.PushType.Dynamic]: async () => {
-                    for (const channel of channelArr) {
-                        // 判断是否需要推送动态消息
-                        if (channel.live) {
-                            await this.sendMessageWithRetry(bot, channel.channelId, content);
-                        }
-                        // 延迟发送
-                        await this.ctx.sleep(500);
-                    }
-                },
-                [type_1.PushType.StartBroadcasting]: async () => {
-                    // 直播开播推送，判断是否需要艾特全体成员
-                    for (const channel of channelArr) {
-                        // 判断是否需要推送直播消息
-                        if (channel.live) {
-                            await this.sendMessageWithRetry(bot, channel.channelId, content);
-                        }
-                        // 判断是否需要艾特全体成员
-                        if (channel.atAll) {
-                            await this.sendMessageWithRetry(bot, channel.channelId, (0, jsx_runtime_1.jsx)("at", { type: "all" }));
-                        }
-                        // 延迟发送
-                        await this.ctx.sleep(500);
+            return pushArr;
+        }
+        if (type === type_1.PushType.Dynamic) {
+            for (const target of targets) {
+                for (const channel of target.channelArr) {
+                    if (channel.dynamic) {
+                        pushArr.push(`${target.platform}:${channel.channelId}`);
                     }
-                },
-                [type_1.PushType.LiveGuardBuy]: async () => {
-                    // 直播守护购买推送，判断是否需要艾特全体成员
-                    for (const channel of channelArr) {
-                        // 判断是否需要推送直播消息
-                        if (channel.liveGuardBuy) {
-                            await this.sendMessageWithRetry(bot, channel.channelId, content);
-                        }
-                        // 延迟发送
-                        await this.ctx.sleep(500);
+                }
+            }
+            return pushArr;
+        }
+        if (type === type_1.PushType.LiveGuardBuy) {
+            for (const target of targets) {
+                for (const channel of target.channelArr) {
+                    if (channel.liveGuardBuy) {
+                        pushArr.push(`${target.platform}:${channel.channelId}`);
                     }
                 }
-            };
-            // 推送
-            await pushTypePatternMatching[type]();
+            }
+            return pushArr;
         }
     }
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    async broadcastToTargets(targets, content, type) {
+        // 不止一个目标平台或一个目标频道
+        if (targets.length !== 1 || targets[0].channelArr.length !== 1) {
+            // 直接使用broadcast
+            const pushArr = this.getGroupsThatMeetCriteria(targets, type);
+            // logger
+            this.logger.info(`推送消息到 ${pushArr.length} 个目标频道，目标频道为：${pushArr.join(", ")}`);
+            // 推送消息
+            await (0, utils_1.withRetry)(async () => {
+                await this.ctx.broadcast(pushArr, content);
+            }, 1);
+            // 结束
+            return;
+        }
+        // 获取目标
+        const targetChannel = targets[0].channelArr[0];
+        // 获取机器人实例
+        const bot = this.getBot(targets[0].platform);
+        // 模式匹配
+        const pushTypePatternMatching = {
+            [type_1.PushType.Live]: async () => {
+                if (targetChannel.live) {
+                    // 直接推送
+                    await this.sendMessageWithRetry(bot, targetChannel.channelId, content);
+                }
+            },
+            [type_1.PushType.Dynamic]: async () => {
+                if (targetChannel.dynamic) {
+                    await this.sendMessageWithRetry(bot, targetChannel.channelId, content);
+                }
+            },
+            [type_1.PushType.StartBroadcasting]: async () => {
+                // 判断是否需要推送直播消息
+                if (targetChannel.live) {
+                    await this.sendMessageWithRetry(bot, targetChannel.channelId, content);
+                }
+                // 判断是否需要艾特全体成员
+                if (targetChannel.atAll) {
+                    await this.sendMessageWithRetry(bot, targetChannel.channelId, (0, jsx_runtime_1.jsx)("at", { type: "all" }));
+                }
+            },
+            [type_1.PushType.LiveGuardBuy]: async () => {
+                // 判断是否需要推送直播消息
+                if (targetChannel.liveGuardBuy) {
+                    await this.sendMessageWithRetry(bot, targetChannel.channelId, content);
+                }
+            },
+        };
+        // 推送
+        await pushTypePatternMatching[type]();
+    }
     dynamicDetect() {
         // 检测初始化变量
         let detectSetup = true;
@@ -604,67 +615,71 @@ class ComRegister {
                 // 动态ID如果一致则结束循环
                 if (dynamicId === dynamicIdStr1st)
                     break;
-                // 判断动态时间戳是否大于时间线
-                if (item.modules.module_author.pub_ts > timeline) {
-                    // 从动态数据中取出UP主名称、UID
-                    const upUID = item.modules.module_author.mid.toString();
-                    const upName = item.modules.module_author.name;
-                    // 寻找关注的UP主的动态
-                    for (const sub of this.subManager) {
-                        // 判断是否是订阅的UP主
-                        if (sub.uid === upUID && sub.dynamic) {
-                            // 订阅该UP主，推送该动态
-                            // 推送该条动态
-                            const buffer = await (0, utils_1.withRetry)(async () => {
-                                // 渲染图片
-                                return await this.ctx.gi.generateDynamicImg(item, sub.card);
-                            }, 1).catch(async (e) => {
-                                // 直播开播动态，不做处理
-                                if (e.message === "直播开播动态，不做处理")
-                                    return;
-                                if (e.message === "出现关键词，屏蔽该动态") {
-                                    // 如果需要发送才发送
-                                    if (this.config.filter.notify) {
-                                        await this.broadcastToTargets(sub.target, `${upName}发布了一条含有屏蔽关键字的动态`, type_1.PushType.Dynamic);
-                                    }
-                                    return;
+                // 获取动态发布时间
+                const postTime = item.modules.module_author.pub_ts;
+                // timeline已超过或与当前动态时间戳相同，则后面的动态不需要推送
+                if (postTime <= timeline)
+                    break;
+                // 从动态数据中取出UP主名称、UID
+                const upUID = item.modules.module_author.mid.toString();
+                const upName = item.modules.module_author.name;
+                // 寻找关注的UP主的动态
+                for (const sub of this.subManager) {
+                    // 判断是否是订阅的UP主
+                    if (sub.dynamic && sub.uid === upUID) {
+                        // 推送该条动态
+                        const buffer = await (0, utils_1.withRetry)(async () => {
+                            // 渲染图片
+                            return await this.ctx.gi.generateDynamicImg(item, sub.card);
+                        }, 1).catch(async (e) => {
+                            // 直播开播动态，不做处理
+                            if (e.message === "直播开播动态，不做处理")
+                                return;
+                            if (e.message === "出现关键词，屏蔽该动态") {
+                                // 如果需要发送才发送
+                                if (this.config.filter.notify) {
+                                    await this.broadcastToTargets(sub.target, `${upName}发布了一条含有屏蔽关键字的动态`, type_1.PushType.Dynamic);
                                 }
-                                if (e.message === "已屏蔽转发动态") {
-                                    if (this.config.filter.notify) {
-                                        await this.broadcastToTargets(sub.target, `${upName}转发了一条动态，已屏蔽`, type_1.PushType.Dynamic);
-                                    }
-                                    return;
+                                return;
+                            }
+                            if (e.message === "已屏蔽转发动态") {
+                                if (this.config.filter.notify) {
+                                    await this.broadcastToTargets(sub.target, `${upName}转发了一条动态，已屏蔽`, type_1.PushType.Dynamic);
                                 }
-                                // 未知错误
-                                this.logger.error(`dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：${e.message}`);
-                                // 发送私聊消息并重启服务
-                                await this.sendPrivateMsgAndStopService();
-                            });
-                            // 判断是否执行成功，未执行成功直接返回
-                            if (!buffer)
-                                continue;
-                            // 判断是否需要发送URL
-                            const dUrl = this.config.dynamicUrl
-                                ? `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}`
-                                : "";
-                            // logger
-                            this.logger.info("推送动态中...");
-                            // 发送推送卡片
-                            await this.broadcastToTargets(sub.target, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, "image/jpeg"), dUrl] }), type_1.PushType.Dynamic);
-                            // 判断是否需要发送动态中的图片
-                            if (this.config.pushImgsInDynamic) {
-                                // 判断是否为图文动态，且存在draw
-                                if (item.type === "DYNAMIC_TYPE_DRAW" &&
-                                    item.modules.module_dynamic.major?.draw) {
-                                    for (const img of item.modules.module_dynamic.major.draw
-                                        .items) {
-                                        await this.broadcastToTargets(sub.target, (0, jsx_runtime_1.jsx)("img", { src: img.src, alt: "\u52A8\u6001\u56FE\u7247" }), type_1.PushType.Dynamic);
-                                    }
+                                return;
+                            }
+                            // 未知错误
+                            this.logger.error(`dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：${e.message}`);
+                            // 发送私聊消息并重启服务
+                            await this.sendPrivateMsgAndStopService();
+                        });
+                        // 判断是否执行成功，未执行成功直接返回
+                        if (!buffer)
+                            continue;
+                        // 定义动态链接
+                        let dUrl = "";
+                        // 判断是否需要发送URL
+                        if (this.config.dynamicUrl) {
+                            // 生成动态链接
+                            dUrl = `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}`;
+                        }
+                        // logger
+                        this.logger.info("推送动态中...");
+                        // 发送推送卡片
+                        await this.broadcastToTargets(sub.target, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, "image/jpeg"), dUrl] }), type_1.PushType.Dynamic);
+                        // 判断是否需要发送动态中的图片
+                        if (this.config.pushImgsInDynamic) {
+                            // 判断是否为图文动态，且存在draw
+                            if (item.type === "DYNAMIC_TYPE_DRAW" &&
+                                item.modules.module_dynamic.major?.draw) {
+                                for (const img of item.modules.module_dynamic.major.draw
+                                    .items) {
+                                    await this.broadcastToTargets(sub.target, (0, jsx_runtime_1.jsx)("img", { src: img.src, alt: "\u52A8\u6001\u56FE\u7247" }), type_1.PushType.Dynamic);
                                 }
                             }
-                            // logger
-                            this.logger.info("动态推送完毕！");
                         }
+                        // logger
+                        this.logger.info("动态推送完毕！");
                     }
                 }
             }
@@ -812,93 +827,104 @@ class ComRegister {
                     this.logger.info("动态ID与上一次获取第一条一致，结束循环");
                     break;
                 }
+                // 获取动态发布时间
+                const postTime = item.modules.module_author.pub_ts;
+                // logger
+                this.logger.info(`当前动态时间线:${postTime}`);
                 // logger
-                this.logger.info(`当前动态时间线:${item.modules.module_author.pub_ts}`);
                 this.logger.info(`上一次获取到第一条动态时间线:${timeline}`);
-                // 判断动态时间戳是否大于时间线
-                if (item.modules.module_author.pub_ts > timeline) {
-                    // logger
-                    this.logger.info("动态时间线大于上一次获取到第一条动态时间线，开始判断是否是订阅的UP主...");
-                    // 从动态数据中取出UP主名称、UID
-                    const upUID = item.modules.module_author.mid.toString();
-                    const upName = item.modules.module_author.name;
+                // logger
+                this.logger.info(`当前动态发布时间：${luxon_1.DateTime.fromSeconds(postTime).toFormat("yyyy-MM-dd HH:mm:ss")}`);
+                // logger
+                this.logger.info(`上一次获取到第一条动态发布时间：${luxon_1.DateTime.fromSeconds(timeline).toFormat("yyyy-MM-dd HH:mm:ss")}`);
+                // timeline已超过或与当前动态时间戳相同，则后面的动态不需要推送
+                if (postTime <= timeline) {
                     // logger
-                    this.logger.info(`当前动态UP主UID:${upUID}，UP主名称:${upName}`);
-                    // 寻找关注的UP主的动态
-                    for (const sub of this.subManager) {
-                        // 判断是否是订阅的UP主
-                        if (sub.dynamic && sub.uid === upUID) {
-                            // logger：订阅该UP主，推送该动态
-                            this.logger.info("订阅该UP主，开始推送该动态...");
-                            // logger
-                            this.logger.info("开始生成推送卡片...");
-                            // 推送该条动态
-                            const buffer = await (0, utils_1.withRetry)(async () => {
-                                // 渲染图片
-                                return await this.ctx.gi.generateDynamicImg(item, sub.card);
-                            }, 1).catch(async (e) => {
-                                // 直播开播动态，不做处理
-                                if (e.message === "直播开播动态，不做处理")
-                                    return;
-                                if (e.message === "出现关键词，屏蔽该动态") {
-                                    // 如果需要发送才发送
-                                    if (this.config.filter.notify) {
-                                        await this.broadcastToTargets(sub.target, `${upName}发布了一条含有屏蔽关键字的动态`, type_1.PushType.Dynamic);
-                                    }
-                                    return;
-                                }
-                                if (e.message === "已屏蔽转发动态") {
-                                    if (this.config.filter.notify) {
-                                        await this.broadcastToTargets(sub.target, `${upName}转发了一条动态，已屏蔽`, type_1.PushType.Dynamic);
-                                    }
-                                    return;
+                    this.logger.info("当前动态时间戳已小于等于上一次获取到第一条动态时间线，更晚发布的动态无需监测");
+                    // 结束本次监测
+                    break;
+                }
+                // logger
+                this.logger.info("动态时间线大于上一次获取到第一条动态时间线，开始判断是否是订阅的UP主...");
+                // 从动态数据中取出UP主名称、UID
+                const upUID = item.modules.module_author.mid.toString();
+                const upName = item.modules.module_author.name;
+                // logger
+                this.logger.info(`当前动态UP主UID:${upUID}，UP主名称:${upName}`);
+                // 寻找关注的UP主的动态
+                for (const sub of this.subManager) {
+                    // 判断是否是订阅的UP主
+                    if (sub.dynamic && sub.uid === upUID) {
+                        // logger：订阅该UP主，推送该动态
+                        this.logger.info("订阅该UP主，开始推送该动态...");
+                        // logger
+                        this.logger.info("开始生成推送卡片...");
+                        // 推送该条动态
+                        const buffer = await (0, utils_1.withRetry)(async () => {
+                            // 渲染图片
+                            return await this.ctx.gi.generateDynamicImg(item, sub.card);
+                        }, 1).catch(async (e) => {
+                            // 直播开播动态，不做处理
+                            if (e.message === "直播开播动态，不做处理")
+                                return;
+                            if (e.message === "出现关键词，屏蔽该动态") {
+                                // 如果需要发送才发送
+                                if (this.config.filter.notify) {
+                                    await this.broadcastToTargets(sub.target, `${upName}发布了一条含有屏蔽关键字的动态`, type_1.PushType.Dynamic);
                                 }
-                                // 未知错误
-                                this.logger.error(`dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：${e.message}`);
-                                // 发送私聊消息并重启服务
-                                await this.sendPrivateMsgAndStopService();
-                            });
-                            // 判断是否执行成功，未执行成功直接返回
-                            if (!buffer) {
-                                // logger
-                                this.logger.info("推送卡片生成失败，或该动态为屏蔽动态，跳过该动态！");
-                                // 结束循环
-                                continue;
+                                return;
                             }
-                            // 定义动态链接
-                            let dUrl = "";
-                            // 判断是否需要发送URL
-                            if (this.config.dynamicUrl) {
-                                // logger
-                                this.logger.info("生成动态链接中...");
-                                // 生成动态链接
-                                dUrl = `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}`;
+                            if (e.message === "已屏蔽转发动态") {
+                                if (this.config.filter.notify) {
+                                    await this.broadcastToTargets(sub.target, `${upName}转发了一条动态，已屏蔽`, type_1.PushType.Dynamic);
+                                }
+                                return;
                             }
+                            // 未知错误
+                            this.logger.error(`dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：${e.message}`);
+                            // 发送私聊消息并重启服务
+                            await this.sendPrivateMsgAndStopService();
+                        });
+                        // 判断是否执行成功，未执行成功直接返回
+                        if (!buffer) {
                             // logger
-                            this.logger.info("推送动态中...");
-                            // 发送推送卡片
-                            await this.broadcastToTargets(sub.target, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, "image/jpeg"), dUrl] }), type_1.PushType.Dynamic);
+                            this.logger.info("推送卡片生成失败，或该动态为屏蔽动态，跳过该动态！");
+                            // 结束循环
+                            continue;
+                        }
+                        // 定义动态链接
+                        let dUrl = "";
+                        // 判断是否需要发送URL
+                        if (this.config.dynamicUrl) {
+                            // logger
+                            this.logger.info("生成动态链接中...");
+                            // 生成动态链接
+                            dUrl = `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}`;
+                        }
+                        // logger
+                        this.logger.info("推送动态中...");
+                        // 发送推送卡片
+                        await this.broadcastToTargets(sub.target, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, "image/jpeg"), dUrl] }), type_1.PushType.Dynamic);
+                        // 判断是否需要发送动态中的图片
+                        if (this.config.pushImgsInDynamic) {
                             // logger
-                            this.logger.info("动态推送完毕！");
-                            // 判断是否需要发送动态中的图片
-                            if (this.config.pushImgsInDynamic) {
-                                // logger
-                                this.logger.info("开始推送动态中的图片...");
-                                // 判断是否为图文动态，且存在draw
-                                if (item.type === "DYNAMIC_TYPE_DRAW" &&
-                                    item.modules.module_dynamic.major?.draw) {
-                                    for (const img of item.modules.module_dynamic.major.draw
-                                        .items) {
-                                        await this.broadcastToTargets(sub.target, (0, jsx_runtime_1.jsx)("img", { src: img.src, alt: "\u52A8\u6001\u56FE\u7247" }), type_1.PushType.Dynamic);
-                                    }
+                            this.logger.info("开始推送动态中的图片...");
+                            // 判断是否为图文动态，且存在draw
+                            if (item.type === "DYNAMIC_TYPE_DRAW" &&
+                                item.modules.module_dynamic.major?.draw) {
+                                for (const img of item.modules.module_dynamic.major.draw
+                                    .items) {
+                                    await this.broadcastToTargets(sub.target, (0, jsx_runtime_1.jsx)("img", { src: img.src, alt: "\u52A8\u6001\u56FE\u7247" }), type_1.PushType.Dynamic);
                                 }
-                                // logger
-                                this.logger.info("图片推送完毕！");
                             }
                             // logger
-                            this.logger.info("动态推送完毕！");
+                            this.logger.info("图片推送完毕！");
                         }
+                        // logger
+                        this.logger.info("动态推送完毕！");
                     }
+                    // logger
+                    this.logger.info("不是关注的UP主，跳过该动态");
                 }
             }
             // 更新本次请求第一条动态的动态ID
@@ -910,6 +936,10 @@ class ComRegister {
                 items[0].modules.module_author.pub_ts || luxon_1.DateTime.now().toSeconds();
             // logger
             this.logger.info(`更新时间线:${timeline}`);
+            // logger
+            this.logger.info(`时间线格式化:${luxon_1.DateTime.fromSeconds(timeline).toFormat("yyyy-MM-dd HH:mm:ss")}`);
+            // logger
+            this.logger.info("动态监测完成，等待下一次检测...");
         };
         // 返回一个闭包函数
         return (0, utils_1.withLock)(handler);
@@ -998,7 +1028,9 @@ class ComRegister {
             // 推送直播信息
             const msg = ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, "image/jpeg"), liveNotifyMsg || ""] }));
             // 只有在开播时才艾特全体成员
-            return await this.broadcastToTargets(target, msg, liveType === type_1.LiveType.StartBroadcasting ? type_1.PushType.StartBroadcasting : type_1.PushType.Live);
+            return await this.broadcastToTargets(target, msg, liveType === type_1.LiveType.StartBroadcasting
+                ? type_1.PushType.StartBroadcasting
+                : type_1.PushType.Live);
         };
         // 找到频道/群组对应的
         const liveGuardBuyPushTargetArr = target.map((channel) => {
@@ -1552,10 +1584,6 @@ class ComRegister {
             masterAccount: koishi_1.Schema.string(),
             masterAccountGuildId: koishi_1.Schema.string(),
         }),
-        liveDetectMode: koishi_1.Schema.union([
-            koishi_1.Schema.const("API"),
-            koishi_1.Schema.const("WS"),
-        ]).required(),
         restartPush: koishi_1.Schema.boolean().required(),
         pushTime: koishi_1.Schema.number().required(),
         pushImgsInDynamic: koishi_1.Schema.boolean().required(),

package/lib/index.d.ts

@@ -44,7 +44,6 @@ export interface Config {
     dynamicUrl: boolean;
     pushImgsInDynamic: boolean;
     live: {};
-    liveDetectMode: "API" | "WS";
     restartPush: boolean;
     pushTime: number;
     customLiveStart: string;

package/lib/index.js

@@ -127,7 +127,6 @@ class ServerManager extends koishi_1.Service {
                 subLoadTimeout: globalConfig.subLoadTimeout,
                 sub: globalConfig.sub,
                 master: globalConfig.master,
-                liveDetectMode: globalConfig.liveDetectMode,
                 restartPush: globalConfig.restartPush,
                 pushTime: globalConfig.pushTime,
                 pushImgsInDynamic: globalConfig.pushImgsInDynamic,
@@ -325,15 +324,6 @@ exports.Config = koishi_1.Schema.object({
         .default(false)
         .description("是否推送动态中的图片，默认不开启。开启后会单独推送动态中的图片"),
     live: koishi_1.Schema.object({}).description("直播推送设置"),
-    liveDetectMode: koishi_1.Schema.union([
-        koishi_1.Schema.const("WS").description("WebSocket模式：连接到对应的直播间，可推送弹幕消息，开播下播响应最快，但对订阅数有限制"),
-        koishi_1.Schema.const("API")
-            .description("API模式：请求对应直播间API，无法获取弹幕消息，开播下播响应慢，理论可无限订阅")
-            .deprecated(),
-    ])
-        .role("radio")
-        .description("直播检测模式")
-        .default("WS"),
     restartPush: koishi_1.Schema.boolean()
         .default(true)
         .description("插件重启后，如果订阅的主播正在直播，是否进行一次推送，默认开启"),

package/lib/type/index.d.ts

@@ -5,13 +5,14 @@ export declare enum LiveType {
     StopBroadcast = 3,
     FirstLiveBroadcast = 4
 }
-export type ChannelArr = Array<{
+export type Channel = {
     channelId: string;
     dynamic: boolean;
     live: boolean;
     liveGuardBuy: boolean;
     atAll: boolean;
-}>;
+};
+export type ChannelArr = Array<Channel>;
 export type TargetItem = {
     channelArr: ChannelArr;
     platform: string;

package/package.json

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

package/readme.md

@@ -233,6 +233,8 @@ uid为必填参数，为要推送的UP主的UID，index为可选参数，为要
 - ver 3.1.0-alpha.0 修复：新插件在第一次订阅时提示 `订阅失败，错误信息：该分组已经存在`； 移除：消息重发功能； 重构：将消息发送模式改为 `broadcast`
 - ver 3.1.0-alpha.1 修复：无法发送 `@全体成员` 消息，将消息发送模式改回
 - ver 3.1.0 修复：订阅某位UP主直播和动态后，某些群聊只开启推送直播也会推送动态
+- ver 3.1.1-alpha.0 修复：稿件重投后，会将之前日期的动态一起推送； 优化：加强动态debug输出； 移除：不必要选项 `live.liveDetectMode`
+- ver 3.1.2-alpha.0 重构：对消息发送模块进行小型重构，多群多平台推送将不再支持艾特全体成员，仅单平台单群聊支持； 移除：群聊 `all` 选项
 
 ## 交流群