koishi-plugin-bilibili-notify 2.0.0 → 3.0.0-alpha.1

package/lib/biliAPI.d.ts

@@ -26,6 +26,21 @@ declare class BiliAPI extends Service {
     }): Promise<string>;
     encrypt(text: string): string;
     decrypt(text: string): string;
+    getTheUserWhoIsLiveStreaming(): Promise<{
+        count: number;
+        group: string;
+        items: [
+            {
+                face: string;
+                is_reserve_recall: boolean;
+                jump_url: string;
+                mid: number;
+                room_id: number;
+                title: string;
+                uname: string;
+            }
+        ];
+    }>;
     getLiveRoomInfoStreamKey(roomId: string): Promise<any>;
     getServerUTCTime(): Promise<number>;
     getTimeNow(): Promise<any>;
@@ -54,6 +69,7 @@ declare class BiliAPI extends Service {
     createNewClient(): void;
     getTimeOfUTC8(): number;
     getCookies(): string;
+    getCookiesForHeader(): Promise<string>;
     getLoginInfoIsLoaded(): boolean;
     getLoginInfoFromDB(): Promise<{
         cookies: any;

package/lib/biliAPI.js

@@ -34,6 +34,8 @@ const GET_LIVE_ROOM_INFO = 'https://api.live.bilibili.com/room/v1/Room/get_info'
 const GET_MASTER_INFO = 'https://api.live.bilibili.com/live_user/v1/Master/info';
 const GET_TIME_NOW = 'https://api.bilibili.com/x/report/click/now';
 const GET_SERVER_UTC_TIME = 'https://interface.bilibili.com/serverdate.js';
+// 最近更新UP
+const GET_LATEST_UPDATED_UPS = 'https://api.bilibili.com/x/polymer/web-dynamic/v1/portal';
 // 操作
 const MODIFY_RELATION = 'https://api.bilibili.com/x/relation/modify';
 const CREATE_GROUP = 'https://api.bilibili.com/x/relation/tag/create';
@@ -105,6 +107,17 @@ class BiliAPI extends koishi_1.Service {
         return decrypted.toString();
     }
     // BA API
+    async getTheUserWhoIsLiveStreaming() {
+        try {
+            // 获取直播间信息流密钥
+            const { data: { live_users } } = await this.client.get(GET_LATEST_UPDATED_UPS);
+            // 返回data
+            return live_users;
+        }
+        catch (e) {
+            throw new Error('网络异常，本次请求失败！');
+        }
+    }
     async getLiveRoomInfoStreamKey(roomId) {
         try {
             // 获取直播间信息流密钥
@@ -375,6 +388,21 @@ class BiliAPI extends koishi_1.Service {
         const cookies = JSON.stringify(this.jar.serializeSync().cookies);
         return cookies;
     }
+    async getCookiesForHeader() {
+        try {
+            // 获取cookies对象
+            const cookies = this.jar.serializeSync().cookies;
+            // 将每个 cookie 对象转换为 "key=value" 形式，并用 "; " 连接起来
+            const cookieHeader = cookies
+                .map(cookie => `${cookie.key}=${cookie.value}`)
+                .join('; ');
+            return cookieHeader;
+        }
+        catch (e) {
+            console.error("无效的 JSON 格式：", e);
+            return "";
+        }
+    }
     getLoginInfoIsLoaded() {
         return this.loginInfoIsLoaded;
     }

package/lib/blive.d.ts

@@ -0,0 +1,23 @@
+import { Awaitable, Context, Schema, Service } from "koishi";
+import { type MsgHandler } from 'blive-message-listener';
+declare module 'koishi' {
+    interface Context {
+        bl: BLive;
+    }
+}
+declare class BLive extends Service {
+    static inject: string[];
+    private listenerRecord;
+    private timerRecord;
+    constructor(ctx: Context);
+    protected stop(): Awaitable<void>;
+    startLiveRoomListener(roomId: string, handler: MsgHandler, pushOnceEveryTens: () => void): Promise<void>;
+    closeListener(roomId: string): void;
+}
+declare namespace BLive {
+    interface Config {
+        danmakuPushTime: number;
+    }
+    const Config: Schema<Config>;
+}
+export default BLive;

package/lib/blive.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const koishi_1 = require("koishi");
+const blive_message_listener_1 = require("blive-message-listener");
+class BLive extends koishi_1.Service {
+    // 必要服务
+    static inject = ['ba'];
+    // 定义类属性
+    listenerRecord = {};
+    timerRecord = {};
+    constructor(ctx) {
+        super(ctx, 'bl');
+    }
+    // 注册插件dispose逻辑
+    stop() {
+        // 清除所有监听器
+        for (const key of Object.keys(this.listenerRecord)) {
+            this.closeListener(key);
+        }
+    }
+    async startLiveRoomListener(roomId, handler, pushOnceEveryTens) {
+        // 获取cookieStr
+        const cookiesStr = await this.ctx.ba.getCookiesForHeader();
+        // 获取自身信息
+        const mySelfInfo = await this.ctx.ba.getMyselfInfo();
+        // 创建实例并保存到Record中
+        this.listenerRecord[roomId] = (0, blive_message_listener_1.startListen)(parseInt(roomId), handler, {
+            ws: {
+                headers: {
+                    Cookie: cookiesStr
+                },
+                uid: mySelfInfo.data.mid
+            }
+        });
+        // 默认30s推送一次弹幕消息到群组并将dispose函数保存到Record中
+        this.timerRecord[roomId] = this.ctx.setInterval(pushOnceEveryTens, this.config.danmakuPushTime * 1000 * 60);
+    }
+    closeListener(roomId) {
+        // 判断直播间监听器是否关闭
+        if (!this.listenerRecord || !this.listenerRecord[roomId] || !this.listenerRecord[roomId].closed) {
+            // 输出logger
+            this.logger.info('直播间监听器无需关闭');
+        }
+        // 判断消息发送定时器是否关闭
+        if (!this.timerRecord || !this.timerRecord[roomId]) {
+            // 输出logger
+            this.logger.info('消息发送定时器无需关闭');
+        }
+        // 关闭直播间监听器
+        this.listenerRecord[roomId].close();
+        // 关闭消息发送定时器
+        this.timerRecord[roomId]();
+        // 判断是否关闭成功
+        if (this.listenerRecord[roomId].closed) {
+            // 删除直播间监听器
+            delete this.listenerRecord[roomId];
+            // 删除消息发送定时器
+            delete this.timerRecord[roomId];
+            // 输出logger
+            this.logger.info('直播间监听已关闭');
+            // 直接返回 
+            return;
+        }
+        // 未关闭成功
+        this.logger.warn('直播间监听未成功关闭');
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (BLive) {
+    BLive.Config = koishi_1.Schema.object({
+        danmakuPushTime: koishi_1.Schema.number().required()
+    });
+})(BLive || (BLive = {}));
+exports.default = BLive;

package/lib/comRegister.d.ts

@@ -1,6 +1,12 @@
 import { Bot, Context, FlatPick, Logger, Schema, Session } from "koishi";
 import { Notifier } from "@koishijs/plugin-notifier";
 import { LoginBili } from "./database";
+declare enum LiveType {
+    NotLiveBroadcast = 0,
+    StartBroadcasting = 1,
+    LiveBroadcast = 2,
+    StopBroadcast = 3
+}
 type ChannelIdArr = Array<{
     channelId: string;
     dynamic: boolean;
@@ -47,7 +53,19 @@ declare class ComRegister {
     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>;
+    sendLiveNotifyCard(ctx: Context, info: {
+        username: string;
+        userface: string;
+        target: Target;
+        data: any;
+    }, liveType: LiveType, liveNotifyMsg?: string): Promise<void>;
+    useMasterInfo(ctx: Context, uid: string): Promise<{
+        username: string;
+        userface: string;
+    }>;
+    useLiveRoomInfo(ctx: Context, roomId: string): Promise<any>;
+    liveDetectWithAPI(ctx: Context): Promise<() => Promise<void>>;
+    liveDetectWithListener(ctx: Context, roomId: string, target: Target): void;
     subShow(): string;
     checkIfNeedSub(liveSub: boolean, dynamicSub: boolean, session: Session, liveRoomData: any): Promise<Array<boolean>>;
     updateSubNotifier(ctx: Context): void;

package/lib/comRegister.js

@@ -18,7 +18,7 @@ var LiveType;
     LiveType[LiveType["StopBroadcast"] = 3] = "StopBroadcast";
 })(LiveType || (LiveType = {}));
 class ComRegister {
-    static inject = ['ba', 'gi', 'database', 'sm'];
+    static inject = ['ba', 'gi', 'database', 'bl', 'sm'];
     qqRelatedBotList = ['qq', 'onebot', 'red', 'satori', 'chronocat'];
     logger;
     config;
@@ -430,8 +430,8 @@ class ComRegister {
             let liveDispose;
             // 订阅直播
             if (liveMsg) {
-                // 开始循环检测
-                liveDispose = ctx.setInterval(this.liveDetect(ctx, roomId, target), config.liveLoopTime * 1000);
+                // 连接到服务器
+                this.liveDetectWithListener(ctx, roomId, target);
                 // 发送订阅消息通知
                 await session.send(`订阅${userData.info.uname}直播通知`);
             }
@@ -1075,137 +1075,148 @@ class ComRegister {
             }
         };
     }
-    liveDetect(ctx, roomId, target) {
-        let firstSubscription = true;
-        let timer = 0;
-        let open = false;
-        let liveTime;
-        let username;
-        let userface;
-        // 相当于锁的作用，防止上一个循环没处理完
-        let flag = true;
-        // 定义发送直播通知卡片方法
-        const sendLiveNotifyCard = async (data, liveType, liveNotifyMsg) => {
-            // 定义变量
-            let pic;
-            let buffer;
-            // 多次尝试生成图片
-            const attempts = 3;
-            for (let i = 0; i < attempts; i++) {
-                try {
-                    // 获取直播通知卡片
-                    const { pic: picv, buffer: bufferv } = await ctx.gi.generateLiveImg(data, username, userface, liveType);
-                    // 赋值
-                    pic = picv;
-                    buffer = bufferv;
-                    // 成功则跳出循环
-                    break;
-                }
-                catch (e) {
-                    if (i === attempts - 1) { // 已尝试三次
-                        this.logger.error('liveDetect generateLiveImg() 推送卡片生成失败，原因：' + e.message);
-                        // 发送私聊消息并重启服务
-                        return await this.sendPrivateMsgAndStopService(ctx);
-                    }
-                }
+    // 定义发送直播通知卡片方法
+    async sendLiveNotifyCard(ctx, info, liveType, liveNotifyMsg) {
+        // 定义变量
+        let pic;
+        let buffer;
+        // 多次尝试生成图片
+        const attempts = 3;
+        for (let i = 0; i < attempts; i++) {
+            try {
+                // 获取直播通知卡片
+                const { pic: picv, buffer: bufferv } = await ctx.gi.generateLiveImg(info.data, info.username, info.userface, liveType);
+                // 赋值
+                pic = picv;
+                buffer = bufferv;
+                // 成功则跳出循环
+                break;
             }
-            // 推送直播信息
-            // pic 存在，使用的是render模式
-            if (pic) {
-                // 只有在开播时才艾特全体成员
-                if (liveType === LiveType.StartBroadcasting) {
-                    return await this.sendMsg(ctx, target, pic + (liveNotifyMsg ?? ''), true);
+            catch (e) {
+                if (i === attempts - 1) { // 已尝试三次
+                    this.logger.error('liveDetect generateLiveImg() 推送卡片生成失败，原因：' + e.message);
+                    // 发送私聊消息并重启服务
+                    return await this.sendPrivateMsgAndStopService(ctx);
                 }
-                // 正常不需要艾特全体成员
-                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'), liveNotifyMsg || ''] });
+        }
+        // 推送直播信息
+        // pic 存在，使用的是render模式
+        if (pic) {
             // 只有在开播时才艾特全体成员
             if (liveType === LiveType.StartBroadcasting) {
-                return await this.sendMsg(ctx, target, msg, true);
+                return await this.sendMsg(ctx, info.target, pic + (liveNotifyMsg ?? ''), true);
             }
             // 正常不需要艾特全体成员
-            return await this.sendMsg(ctx, target, msg);
-        };
-        // 定义获取主播信息方法
-        let useMasterInfo;
-        if (this.config.changeMasterInfoApi) {
-            useMasterInfo = async (uid) => {
-                const { data } = await ctx.ba.getUserInfo(uid);
-                username = data.name;
-                userface = data.face;
-            };
+            return await this.sendMsg(ctx, info.target, pic + (liveNotifyMsg ?? ''));
         }
-        else {
-            useMasterInfo = async (uid) => {
-                const { data: { info } } = await ctx.ba.getMasterInfo(uid);
-                username = info.uname;
-                userface = info.face;
-            };
+        // 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) {
+            return await this.sendMsg(ctx, info.target, msg, true);
+        }
+        // 正常不需要艾特全体成员
+        return await this.sendMsg(ctx, info.target, msg);
+    }
+    // 定义获取主播信息方法
+    async useMasterInfo(ctx, uid) {
+        const { data: { info } } = await ctx.ba.getMasterInfo(uid);
+        return { username: info.name, userface: info.face };
+    }
+    async useLiveRoomInfo(ctx, roomId) {
+        // 发送请求获取直播间信息
+        let content;
+        const attempts = 3;
+        for (let i = 0; i < attempts; i++) {
+            try {
+                // 发送请求获取room信息
+                content = await ctx.ba.getLiveRoomInfo(roomId);
+                // 成功则跳出循环
+                break;
+            }
+            catch (e) {
+                this.logger.error('liveDetect getLiveRoomInfo 发生了错误，错误为：' + e.message);
+                if (i === attempts - 1) { // 已尝试三次
+                    // 发送私聊消息并重启服务
+                    return await this.sendPrivateMsgAndStopService(ctx);
+                }
+            }
         }
+        return content.data;
+    }
+    /* liveDetect(
+        ctx: Context,
+        roomId: string,
+        target: Target
+    ) {
+        let firstSubscription: boolean = true;
+        let timer: number = 0;
+        let open: boolean = false;
+        let liveTime: string;
+        let username: string
+        let userface: string
+        // 相当于锁的作用，防止上一个循环没处理完
+        let flag: boolean = true
+
         return async () => {
             // 如果flag为false则说明前面的代码还未执行完，则直接返回
-            if (!flag)
-                return;
-            flag = false;
+            if (!flag) return
+            flag = false
             // 无论是否执行成功都要释放锁
             try {
                 // 发送请求检测直播状态
-                let content;
-                const attempts = 3;
+                let content: any
+                const attempts = 3
                 for (let i = 0; i < attempts; i++) {
                     try {
                         // 发送请求获取room信息
-                        content = await ctx.ba.getLiveRoomInfo(roomId);
+                        content = await ctx.ba.getLiveRoomInfo(roomId)
                         // 成功则跳出循环
-                        break;
-                    }
-                    catch (e) {
-                        this.logger.error('liveDetect getLiveRoomInfo 发生了错误，错误为：' + e.message);
+                        break
+                    } catch (e) {
+                        this.logger.error('liveDetect getLiveRoomInfo 发生了错误，错误为：' + e.message)
                         if (i === attempts - 1) { // 已尝试三次
                             // 发送私聊消息并重启服务
-                            return await this.sendPrivateMsgAndStopService(ctx);
+                            return await this.sendPrivateMsgAndStopService(ctx)
                         }
                     }
                 }
-                const { data } = content;
+                const { data } = content
                 // 判断是否是第一次订阅
                 if (firstSubscription) {
-                    firstSubscription = false;
+                    firstSubscription = false
                     // 获取主播信息
-                    const attempts = 3;
+                    const attempts = 3
                     for (let i = 0; i < attempts; i++) {
                         try {
                             // 发送请求获取主播信息
-                            await useMasterInfo(data.uid);
+                            await useMasterInfo(data.uid)
                             // 成功则跳出循环
-                            break;
-                        }
-                        catch (e) {
-                            this.logger.error('liveDetect getMasterInfo() 发生了错误，错误为：' + e.message);
+                            break
+                        } catch (e) {
+                            this.logger.error('liveDetect getMasterInfo() 发生了错误，错误为：' + e.message)
                             if (i === attempts - 1) { // 已尝试三次
                                 // 发送私聊消息并重启服务
-                                return await this.sendPrivateMsgAndStopService(ctx);
+                                return await this.sendPrivateMsgAndStopService(ctx)
                             }
                         }
                     }
                     // 判断直播状态
                     if (data.live_status === 1) { // 当前正在直播
                         // 设置开播时间
-                        liveTime = data.live_time;
+                        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;
+                            .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, liveMsg);
+                        if (this.config.restartPush) sendLiveNotifyCard(data, LiveType.LiveBroadcast, liveMsg)
                         // 改变开播状态
-                        open = true;
+                        open = true
                     } // 未开播，直接返回
-                    return;
+                    return
                 }
                 // 检查直播状态
                 switch (data.live_status) {
@@ -1213,67 +1224,65 @@ class ComRegister {
                     case 2: { // 状态 0 和 2 说明未开播
                         if (open) { // 之前开播，现在下播了
                             // 更改直播状态
-                            open = false;
+                            open = false
                             // 下播了将定时器清零
-                            timer = 0;
+                            timer = 0
                             // 定义下播通知消息
                             const liveEndMsg = this.config.customLiveEnd ? this.config.customLiveEnd
                                 .replace('-name', username)
-                                .replace('-time', await ctx.gi.getTimeDifference(liveTime)) : null;
+                                .replace('-time', await ctx.gi.getTimeDifference(liveTime)) : null
                             // 更改直播时长
-                            data.live_time = liveTime;
-                            // 发送@全体成员通知
-                            await sendLiveNotifyCard(data, LiveType.StopBroadcast, liveEndMsg);
+                            data.live_time = liveTime
+                            // 推送下播通知
+                            await sendLiveNotifyCard(data, LiveType.StopBroadcast, liveEndMsg)
                         }
                         // 未进循环，还未开播，继续循环
-                        break;
+                        break
                     }
                     case 1: {
                         if (!open) { // 之前未开播，现在开播了
                             // 更改直播状态
-                            open = true;
+                            open = true
                             // 设置开播时间
-                            liveTime = data.live_time;
+                            liveTime = data.live_time
                             // 获取主播信息
-                            const attempts = 3;
+                            const attempts = 3
                             for (let i = 0; i < attempts; i++) {
                                 try {
                                     // 主播信息不会变，开播时刷新一次即可
                                     // 发送请求获取主播信息
-                                    await useMasterInfo(data.uid);
+                                    await useMasterInfo(data.uid)
                                     // 成功则跳出循环
-                                    break;
-                                }
-                                catch (e) {
-                                    this.logger.error('liveDetect open getMasterInfo() 发生了错误，错误为：' + e.message);
+                                    break
+                                } catch (e) {
+                                    this.logger.error('liveDetect open getMasterInfo() 发生了错误，错误为：' + e.message)
                                     if (i === attempts - 1) { // 已尝试三次
                                         // 发送私聊消息并重启服务
-                                        return await this.sendPrivateMsgAndStopService(ctx);
+                                        return await this.sendPrivateMsgAndStopService(ctx)
                                     }
                                 }
                             }
-                            // 定义开播通知语                            
+                            // 定义开播通知语
                             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}`) : null;
+                                .replace('-link', `https://live.bilibili.com/${data.short_id === 0 ? data.room_id : data.short_id}`) : null
                             // 发送消息
-                            await sendLiveNotifyCard(data, LiveType.StartBroadcasting, liveStartMsg);
-                        }
-                        else { // 还在直播
+                            await sendLiveNotifyCard(data, LiveType.StartBroadcasting, liveStartMsg)
+                        } else { // 还在直播
                             if (this.config.pushTime > 0) {
-                                timer++;
+                                timer++
                                 // 开始记录时间
                                 if (timer >= (6 * 60 * this.config.pushTime)) { // 到时间推送直播消息
                                     // 到时间重新计时
-                                    timer = 0;
+                                    timer = 0
                                     // 定义直播中通知消息
                                     const liveMsg = this.config.customLive ? this.config.customLive
                                         .replace('-name', username)
                                         .replace('-time', await ctx.gi.getTimeDifference(liveTime))
-                                        .replace('-link', `https://live.bilibili.com/${data.short_id === 0 ? data.room_id : data.short_id}`) : null;
+                                        .replace('-link', `https://live.bilibili.com/${data.short_id === 0 ? data.room_id : data.short_id}`) : null
                                     // 发送直播通知卡片
-                                    sendLiveNotifyCard(data, LiveType.LiveBroadcast, liveMsg);
+                                    sendLiveNotifyCard(data, LiveType.LiveBroadcast, liveMsg)
                                 }
                             }
                             // 否则继续循环
@@ -1281,12 +1290,299 @@ class ComRegister {
                     }
                 }
             }
+            finally {
+                // 执行完方法体不论如何都把flag设置为true
+                flag = true
+            }
+        }
+    } */
+    async liveDetectWithAPI(ctx) {
+        // 定义变量：第一次订阅
+        let firstSubscription = true;
+        // 定义变量：timer计时器
+        let timer = 0;
+        // 相当于锁的作用，防止上一个循环没处理完
+        let flag = true;
+        // 定义订阅对象Record 0未开播 1正在直播 2轮播中
+        const liveRecord = {};
+        // 初始化subRecord
+        this.subManager.forEach(sub => {
+            // 判断是否订阅直播
+            if (sub.live) {
+                // 将该订阅添加到subRecord中
+                liveRecord[sub.uid] = { liveStatus: 0, liveTime: '', target: sub.target };
+            }
+        });
+        // 定义函数: 发送请求获取直播状态
+        const useLiveStatus = async (roomId) => {
+            let content;
+            const attempts = 3;
+            for (let i = 0; i < attempts; i++) {
+                try {
+                    // 发送请求获取room信息
+                    content = await ctx.ba.getLiveRoomInfo(roomId);
+                    // 成功则跳出循环
+                    break;
+                }
+                catch (e) {
+                    this.logger.error('liveDetect getLiveRoomInfo 发生了错误，错误为：' + e.message);
+                    if (i === attempts - 1) { // 已尝试三次
+                        // 发送私聊消息并重启服务
+                        return await this.sendPrivateMsgAndStopService(ctx);
+                    }
+                }
+            }
+            // 返回data
+            return content.data;
+        };
+        return async () => {
+            // 如果flag为false则说明前面的代码还未执行完，则直接返回
+            if (!flag)
+                return;
+            // 将标志位置为false
+            flag = false;
+            try {
+                // 获取正在直播对象
+                const liveUsers = await ctx.ba.getTheUserWhoIsLiveStreaming();
+                // 判断是否是第一次订阅
+                if (firstSubscription) {
+                    // 将第一次订阅置为false
+                    firstSubscription = false;
+                    // 先判断是否有UP主正在直播
+                    if (liveUsers.count > 0) {
+                        // 遍历liveUsers
+                        liveUsers.items.forEach(async (item) => {
+                            // 判断是否有订阅对象正在直播
+                            if (liveRecord[item.mid]) {
+                                // 获取当前用户直播间信息
+                                const data = await useLiveStatus(item.room_id.toString());
+                                // 设置开播时间
+                                liveRecord[item.mid].liveTime = data.live_time;
+                                // 设置直播中消息
+                                const liveMsg = this.config.customLive ? this.config.customLive
+                                    .replace('-name', item.uname)
+                                    .replace('-time', await 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(ctx, {
+                                        username: item.uname,
+                                        userface: item.face,
+                                        target: liveRecord[item.mid].target,
+                                        data
+                                    }, LiveType.LiveBroadcast, liveMsg);
+                                // 改变开播状态
+                                liveRecord[item.mid].liveStatus = 1;
+                            }
+                        });
+                    }
+                    // 没有正在直播的订阅对象，直接返回
+                    return;
+                }
+                // 获取当前订阅直播的数量
+                const currentLiveSubs = this.subManager.filter(sub => sub.live);
+                // 获取当前liveRecord里的订阅数量
+                const currentLiveRecordKeys = Object.keys(liveRecord);
+                // 判断是否能匹配双方数量
+                if (currentLiveRecordKeys.length < currentLiveSubs.length) {
+                    // 遍历currentLiveSubs
+                    for (const sub of currentLiveSubs) {
+                        // 判断liveRecord中缺少了哪些订阅
+                        if (!liveRecord[sub.uid]) {
+                            // 获取当前用户直播间信息
+                            const data = await useLiveStatus(sub.roomId.toString());
+                            switch (data.live_status) {
+                                case 0:
+                                case 2: { // 未开播
+                                    // 添加到liveRecord中
+                                    liveRecord[sub.uid] = { liveStatus: 0, liveTime: '', target: sub.target };
+                                    // break
+                                    break;
+                                }
+                                case 1: { //正在直播
+                                    // 添加到liveRecord中
+                                    liveRecord[sub.uid] = { liveStatus: 1, liveTime: data.live_time, target: sub.target };
+                                }
+                            }
+                        }
+                    }
+                }
+                if (currentLiveRecordKeys.length > currentLiveSubs.length) {
+                    // 创建Set
+                    const setCurrentLiveSubs = new Set(currentLiveSubs.map(sub => sub.uid));
+                    // 找出 currentLiveRecordKeys中比currentLiveSubs 多的元素
+                    const extraInCurrentLiveSubs = currentLiveRecordKeys.filter(key => !setCurrentLiveSubs.has(key));
+                    // 遍历 extraInCurrentLiveSubs 
+                    for (const subUID of extraInCurrentLiveSubs) {
+                        // 删除记录
+                        delete liveRecord[subUID];
+                    }
+                }
+                // 遍历liveUsers
+                liveUsers.items.forEach(async (item) => {
+                    // 判断是否有正在直播的订阅对象
+                    if (liveRecord[item.mid]) { // 有正在直播的订阅对象
+                        // 获取当前用户直播间信息
+                        const data = await useLiveStatus(item.room_id.toString());
+                        // 判断开播状态
+                        switch (liveRecord[item.mid].liveStatus) {
+                            case 0: { // 之前未开播，现在开播了
+                                // 设置开播时间
+                                liveRecord[item.mid].liveTime = data.live_time;
+                                // 定义开播通知语                            
+                                const liveStartMsg = this.config.customLiveStart ? this.config.customLiveStart
+                                    .replace('-name', item.uname)
+                                    .replace('-time', await 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(ctx, {
+                                        username: item.uname,
+                                        userface: item.face,
+                                        target: liveRecord[item.mid].target,
+                                        data
+                                    }, LiveType.LiveBroadcast, liveStartMsg);
+                                // 改变开播状态
+                                liveRecord[item.mid].liveStatus = 1;
+                                // 结束
+                                break;
+                            }
+                            case 1: { // 仍在直播
+                                if (this.config.pushTime > 0) {
+                                    timer++;
+                                    // 开始记录时间
+                                    if (timer >= (6 * 60 * this.config.pushTime)) { // 到时间推送直播消息
+                                        // 到时间重新计时
+                                        timer = 0;
+                                        // 定义直播中通知消息
+                                        const liveMsg = this.config.customLive ? this.config.customLive
+                                            .replace('-name', item.uname)
+                                            .replace('-time', await 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(ctx, {
+                                            username: item.uname,
+                                            userface: item.face,
+                                            target: liveRecord[item.mid].target,
+                                            data
+                                        }, LiveType.LiveBroadcast, liveMsg);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                });
+            }
             finally {
                 // 执行完方法体不论如何都把flag设置为true
                 flag = true;
             }
         };
     }
+    liveDetectWithListener(ctx, roomId, target) {
+        // 定义开播时间
+        let liveTime;
+        // 定义定时推送定时器
+        let pushAtTimeTimer;
+        // 定义弹幕存放数组
+        const currentLiveDanmakuArr = [];
+        const temporaryLiveDanmakuArr = [];
+        // 定义定时推送函数
+        const pushAtTime = async () => {
+            // 获取直播间信息
+            const liveRoomInfo = await this.useLiveRoomInfo(ctx, roomId);
+            // 获取主播信息
+            const masterInfo = await this.useMasterInfo(ctx, liveRoomInfo.uid);
+            // 定义直播中通知消息
+            const liveMsg = this.config.customLive ? this.config.customLive
+                .replace('-name', masterInfo.username)
+                .replace('-time', await ctx.gi.getTimeDifference(liveTime))
+                .replace('-link', `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`) : null;
+            // 发送直播通知卡片
+            await this.sendLiveNotifyCard(liveRoomInfo, {
+                username: masterInfo.username,
+                userface: masterInfo.userface,
+                target,
+                data: liveRoomInfo
+            }, LiveType.LiveBroadcast, liveMsg);
+        };
+        // 定义10秒推送函数
+        const pushOnceEveryTenS = () => {
+            // 判断数组是否有内容
+            if (temporaryLiveDanmakuArr.length > 0) {
+                // 发送消息
+                this.sendMsg(ctx, target, temporaryLiveDanmakuArr.join('\n'));
+                // 将临时消息数组清空
+                temporaryLiveDanmakuArr.length = 0;
+            }
+        };
+        // 构建消息处理函数
+        const handler = {
+            onOpen: () => {
+                this.logger.info('直播间连接成功');
+            },
+            onClose: () => {
+                this.logger.info('直播间连接已断开');
+            },
+            onIncomeDanmu: ({ body }) => {
+                // 处理消息，只需要UP主名字和消息内容
+                const content = `${body.user.uname}：${body.content}`;
+                // 保存消息到数组
+                currentLiveDanmakuArr.push(content);
+                temporaryLiveDanmakuArr.push(content);
+            },
+            onIncomeSuperChat: (msg) => {
+                console.log(msg.id, msg.body);
+            },
+            onLiveStart: async () => {
+                // 获取直播间信息
+                const liveRoomInfo = await this.useLiveRoomInfo(ctx, roomId);
+                // 获取主播信息
+                const masterInfo = await this.useMasterInfo(ctx, liveRoomInfo.uid);
+                // 定义下播通知消息
+                const liveEndMsg = this.config.customLiveEnd ? this.config.customLiveEnd
+                    .replace('-name', masterInfo.username)
+                    .replace('-time', await ctx.gi.getTimeDifference(liveTime)) : null;
+                // 更改直播时长
+                liveRoomInfo.live_time = liveTime;
+                // 推送下播通知
+                await this.sendLiveNotifyCard(liveRoomInfo, {
+                    username: masterInfo.username,
+                    userface: masterInfo.userface,
+                    target,
+                    data: liveRoomInfo
+                }, LiveType.StopBroadcast, liveEndMsg);
+                // 关闭定时器
+                pushAtTimeTimer();
+                // 定时器变量置空
+                pushAtTimeTimer = null;
+            },
+            onLiveEnd: async () => {
+                // 获取直播间消息
+                const liveRoomInfo = await this.useLiveRoomInfo(ctx, roomId);
+                // 获取主播信息
+                const masterInfo = await this.useMasterInfo(ctx, liveRoomInfo.uid);
+                // 设置开播时间
+                liveTime = liveRoomInfo.live_time;
+                // 开启推送定时器
+                pushAtTimeTimer = ctx.setInterval(pushAtTime, 3600 * 1000);
+                // 定义开播通知语                            
+                const liveStartMsg = this.config.customLiveStart ? this.config.customLiveStart
+                    .replace('-name', masterInfo.username)
+                    .replace('-time', await ctx.gi.getTimeDifference(liveTime))
+                    .replace('-link', `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`) : null;
+                // 推送通知卡片
+                await this.sendLiveNotifyCard(ctx, {
+                    username: masterInfo.username,
+                    userface: masterInfo.userface,
+                    target,
+                    data: liveRoomInfo
+                }, LiveType.StartBroadcasting, liveStartMsg);
+            }
+        };
+        // 启动直播间弹幕监测
+        ctx.bl.startLiveRoomListener(roomId, handler, pushOnceEveryTenS);
+    }
     subShow() {
         // 在控制台中显示订阅对象
         let table = ``;
@@ -1489,7 +1785,7 @@ class ComRegister {
                 // 判断是否订阅直播
                 if (sub.live) {
                     // 订阅直播
-                    liveDispose = ctx.setInterval(this.liveDetect(ctx, data.live_room.roomid, sub.target), this.config.liveLoopTime * 1000);
+                    this.liveDetectWithListener(ctx, data.live_room.roomid, sub.target);
                 }
             }
             // 在B站中订阅该对象
@@ -1637,9 +1933,7 @@ class ComRegister {
                     // 直播订阅数+1
                     liveSubNum++;
                     // 订阅直播，开始循环检测
-                    const dispose = ctx.setInterval(this.liveDetect(ctx, sub.room_id, target), this.config.liveLoopTime * 1000);
-                    // 保存销毁函数
-                    subManagerItem.liveDispose = dispose;
+                    this.liveDetectWithListener(ctx, sub.room_id, target);
                 }
             }
             // 保存新订阅对象

package/lib/index.d.ts

@@ -39,6 +39,7 @@ export interface Config {
     liveStartAtAll: boolean;
     restartPush: boolean;
     pushTime: number;
+    danmakuPushTime: number;
     customLiveStart: string;
     customLive: string;
     customLiveEnd: string;

package/lib/index.js

@@ -47,6 +47,7 @@ const Database = __importStar(require("./database"));
 // import Service
 const generateImg_1 = __importDefault(require("./generateImg"));
 const biliAPI_1 = __importDefault(require("./biliAPI"));
+const blive_1 = __importDefault(require("./blive"));
 exports.inject = ['puppeteer', 'database', 'notifier'];
 exports.name = 'bilibili-notify';
 let globalConfig;
@@ -138,7 +139,13 @@ exports.Config = koishi_1.Schema.object({
         .max(12)
         .step(0.5)
         .default(1)
-        .description('设定隔多长时间推送一次直播状态，单位为小时，默认为一小时'),
+        .description('设定间隔多长时间推送一次直播状态，单位为小时，默认为一小时'),
+    danmakuPushTime: koishi_1.Schema.number()
+        .min(0)
+        .max(10)
+        .step(0.5)
+        .default(0.5)
+        .description('设定间隔多长时间推送一次弹幕消息，单位为分钟，默认为半分钟'),
     customLiveStart: koishi_1.Schema.string()
         .default('-name开播啦 -link')
         .description('自定义开播提示语，-name代表UP昵称，-link代表直播间链接（如果使用的是QQ官方机器人，请不要使用）。例如-name开播啦，会发送为xxxUP开播啦'),
@@ -322,8 +329,13 @@ class ServerManager extends koishi_1.Service {
                 filter: globalConfig.filter,
                 dynamicDebugMode: globalConfig.dynamicDebugMode
             });
+            // BL = BLive
+            const bl = this.ctx.plugin(blive_1.default, {
+                danmakuPushTime: globalConfig.danmakuPushTime
+            });
             // 添加服务
             this.servers.push(ba);
+            this.servers.push(bl);
             this.servers.push(gi);
             this.servers.push(cr);
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-bilibili-notify",
   "description": "Koishi bilibili notify plugin",
-  "version": "2.0.0",
+  "version": "3.0.0-alpha.1",
   "contributors": [
     "Akokko <admin@akokko.com>"
   ],
@@ -29,6 +29,7 @@
   "dependencies": {
     "axios": "^1.7.9",
     "axios-cookiejar-support": "^5.0.5",
+    "blive-message-listener": "^0.5.0",
     "jsdom": "^24.1.3",
     "luxon": "^3.5.0",
     "md5": "^2.3.0",

package/readme.md

@@ -210,7 +210,9 @@
 - 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主的动态进行推送、推送过的动态过一段时间又会再次推送
+
+- ver 3.0.0-alpha.0 重构：直播  新增：直播弹幕推送到群
+- ver 3.0.0-alpha.1 修复：只订阅直播也会将该UP主的动态进行推送、推送过的动态过一段时间又会再次推送
 
 ## 交流群