koishi-plugin-bilibili-notify 3.1.7-alpha.3 → 3.2.0-alpha.0

package/lib/biliAPI.d.ts

@@ -28,6 +28,7 @@ declare class BiliAPI extends Service {
     decrypt(text: string): string;
     getTheUserWhoIsLiveStreaming(): Promise<any>;
     getLiveRoomInfoStreamKey(roomId: string): Promise<any>;
+    getLiveRoomInfoByUids(uids: string[]): Promise<any>;
     getServerUTCTime(): Promise<number>;
     getTimeNow(): Promise<any>;
     getAllGroup(): Promise<any>;

package/lib/biliAPI.js

@@ -48,6 +48,7 @@ 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";
+const GET_LIVE_ROOMS_INFO = "https://api.live.bilibili.com/room/v1/Room/get_status_info_by_uids";
 class BiliAPI extends koishi_1.Service {
     static inject = ["database", "notifier"];
     jar;
@@ -130,6 +131,14 @@ class BiliAPI extends koishi_1.Service {
         // 返回data
         return data;
     }
+    async getLiveRoomInfoByUids(uids) {
+        // 构建查询参数
+        const params = uids.map((uid) => `uids[]=${uid}`).join("&");
+        // 获取直播间信息
+        const { data } = await this.client.get(`${GET_LIVE_ROOMS_INFO}?${params}`);
+        // 返回数据
+        return data;
+    }
     async getServerUTCTime() {
         const { data } = await this.client.get(GET_SERVER_UTC_TIME);
         const regex = /Date\.UTC\((.*?)\)/;
@@ -581,6 +590,14 @@ __decorate([
         },
     })
 ], BiliAPI.prototype, "getLiveRoomInfoStreamKey", null);
+__decorate([
+    (0, utils_1.Retry)({
+        attempts: 3,
+        onFailure(error, attempts) {
+            this.logger.error(`getLiveRoomInfoByUids() 第${attempts}次失败: ${error.message}`);
+        },
+    })
+], BiliAPI.prototype, "getLiveRoomInfoByUids", null);
 __decorate([
     (0, utils_1.Retry)({
         attempts: 3,

package/lib/comRegister.d.ts

@@ -2,7 +2,7 @@ import { type Bot, type Context, type FlatPick, type Logger, Schema } from "kois
 import type { Notifier } from "@koishijs/plugin-notifier";
 import type { LoginBili } from "./database";
 import { CronJob } from "cron";
-import { LiveType, type MasterInfo, PushType, type Result, type SubItem, type SubManager, type Target } from "./type";
+import { type LiveStatus, LiveType, type MasterInfo, PushType, type Result, type SubItem, type SubManager, type Target } from "./type";
 declare class ComRegister {
     static inject: string[];
     qqRelatedBotList: Array<string>;
@@ -15,12 +15,14 @@ declare class ComRegister {
     ctx: Context;
     subManager: SubManager;
     dynamicTimelineManager: Map<string, number>;
+    liveStatusManager: Map<string, LiveStatus>;
     loginDBData: FlatPick<LoginBili, "dynamic_group_id">;
     privateBot: Bot<Context>;
     dynamicJob: CronJob;
+    liveJob: CronJob;
     constructor(ctx: Context, config: ComRegister.Config);
     init(config: ComRegister.Config): Promise<void>;
-    initDynamicTimelineManager(): void;
+    initManager(): void;
     getBot(pf: string): Bot<Context, any>;
     sendPrivateMsg(content: string): Promise<void>;
     sendPrivateMsgAndRebootService(): Promise<void>;
@@ -32,14 +34,22 @@ declare class ComRegister {
     debug_dynamicDetect(): (...args: any[]) => void;
     useMasterInfo(uid: string, masterInfo: MasterInfo, liveType: LiveType): Promise<MasterInfo>;
     useLiveRoomInfo(roomId: string): Promise<any>;
+    sendLiveNotifyCard(liveType: LiveType, followerDisplay: string, liveInfo: {
+        liveRoomInfo: any;
+        masterInfo: MasterInfo;
+        cardStyle: SubItem["card"];
+    }, target: Target, liveNotifyMsg: string): Promise<void>;
     liveDetectWithListener(roomId: string, target: Target, cardStyle: SubItem["card"]): Promise<void>;
+    liveDetectWithAPI(): Promise<(...args: any[]) => void>;
     subShow(): string;
     updateSubNotifier(): void;
     checkIfLoginInfoIsLoaded(): Promise<unknown>;
     subUserInBili(mid: string): Promise<Result>;
     loadSubFromConfig(subs: ComRegister.Config["sub"]): Promise<Result>;
     checkIfDynamicDetectIsNeeded(): void;
+    checkIfLiveDetectIsNeeded(): void;
     enableDynamicDetect(): void;
+    enableLiveDetect(): Promise<void>;
     checkIfIsLogin(): Promise<boolean>;
 }
 declare namespace ComRegister {
@@ -72,6 +82,7 @@ declare namespace ComRegister {
             masterAccount: string;
             masterAccountGuildId: string;
         };
+        liveDetectType: string;
         restartPush: boolean;
         pushTime: number;
         pushImgsInDynamic: boolean;

package/lib/comRegister.js

@@ -43,12 +43,16 @@ class ComRegister {
     subManager = [];
     // 动态时间线管理器
     dynamicTimelineManager = new Map();
+    // 直播状态管理器
+    liveStatusManager = new Map();
     // 检查登录数据库是否有数据
     loginDBData;
     // 机器人实例
     privateBot;
     // 动态检测销毁函数
     dynamicJob;
+    // 直播检测销毁函数
+    liveJob;
     // 构造函数
     constructor(ctx, config) {
         // 将ctx赋值给类属性
@@ -310,10 +314,12 @@ class ComRegister {
                 return;
             }
         }
-        // 整理dynamicTimelineManager
-        this.initDynamicTimelineManager();
+        // 初始化管理器
+        this.initManager();
         // 检查是否需要动态监测
         this.checkIfDynamicDetectIsNeeded();
+        // 检查是否需要直播监测(仅API模式)
+        this.checkIfLiveDetectIsNeeded();
         // 在控制台中显示订阅对象
         this.updateSubNotifier();
         // 注册插件销毁函数
@@ -324,15 +330,30 @@ class ComRegister {
             // 销毁动态监测
             if (this.dynamicJob)
                 this.dynamicJob.stop();
+            // 销毁直播监测
+            if (this.liveJob)
+                this.liveJob.stop();
         });
         // logger
         this.logger.info("插件初始化完毕！");
     }
-    initDynamicTimelineManager() {
+    initManager() {
         for (const sub of this.subManager) {
             if (sub.dynamic) {
                 this.dynamicTimelineManager.set(sub.uid, Math.floor(luxon_1.DateTime.now().toSeconds()));
             }
+            if (sub.live) {
+                this.liveStatusManager.set(sub.uid, {
+                    roomId: sub.roomId,
+                    live: false,
+                    liveRoomInfo: undefined,
+                    masterInfo: undefined,
+                    watchedNum: "0",
+                    liveStartTime: "",
+                    liveStartTimeInit: false,
+                    push: 0,
+                });
+            }
         }
     }
     // biome-ignore lint/suspicious/noExplicitAny: <explanation>
@@ -574,7 +595,7 @@ class ComRegister {
                     // 判断动态发布时间是否大于时间线
                     if (timeline < postTime) {
                         // 获取订阅对象
-                        const sub = this.subManager.find(sub => sub.uid === uid);
+                        const sub = this.subManager.find((sub) => sub.uid === uid);
                         // 推送该条动态
                         const buffer = await (0, utils_1.withRetry)(async () => {
                             // 渲染图片
@@ -749,7 +770,7 @@ class ComRegister {
                         // logger
                         this.logger.info("需要推送该条动态，开始推送...");
                         // 获取订阅对象
-                        const sub = this.subManager.find(sub => sub.uid === uid);
+                        const sub = this.subManager.find((sub) => sub.uid === uid);
                         // logger
                         this.logger.info("开始渲染推送卡片...");
                         // 推送该条动态
@@ -904,6 +925,24 @@ class ComRegister {
         // 返回
         return data;
     }
+    async sendLiveNotifyCard(liveType, followerDisplay, liveInfo, target, liveNotifyMsg) {
+        // 生成图片
+        const buffer = await (0, utils_1.withRetry)(async () => {
+            // 获取直播通知卡片
+            return await this.ctx.gi.generateLiveImg(liveInfo.liveRoomInfo, liveInfo.masterInfo.username, liveInfo.masterInfo.userface, followerDisplay, liveType, liveInfo.cardStyle.enable ? liveInfo.cardStyle : undefined);
+        }, 1).catch((e) => {
+            this.logger.error(`liveDetect generateLiveImg() 推送卡片生成失败，原因：${e.message}`);
+        });
+        // 发送私聊消息并重启服务
+        if (!buffer)
+            return await this.sendPrivateMsgAndStopService();
+        // 推送直播信息
+        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);
+    }
     async liveDetectWithListener(roomId, target, cardStyle) {
         // 定义开播时间
         let liveTime;
@@ -922,24 +961,6 @@ class ComRegister {
         let masterInfo;
         let watchedNum;
         // 定义发送直播通知卡片方法
-        const sendLiveNotifyCard = async (liveType, followerDisplay, liveNotifyMsg) => {
-            // 生成图片
-            const buffer = await (0, utils_1.withRetry)(async () => {
-                // 获取直播通知卡片
-                return await this.ctx.gi.generateLiveImg(liveRoomInfo, masterInfo.username, masterInfo.userface, followerDisplay, liveType, cardStyle.enable ? cardStyle : undefined);
-            }, 1).catch((e) => {
-                this.logger.error(`liveDetect generateLiveImg() 推送卡片生成失败，原因：${e.message}`);
-            });
-            // 发送私聊消息并重启服务
-            if (!buffer)
-                return await this.sendPrivateMsgAndStopService();
-            // 推送直播信息
-            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);
-        };
         // 找到频道/群组对应的
         const liveGuardBuyPushTargetArr = target.map((channel) => {
             // 获取符合条件的target
@@ -959,6 +980,15 @@ class ComRegister {
                 // 未获取成功，直接返回
                 return this.sendPrivateMsg("获取直播间信息失败，推送直播卡片失败！");
             }
+            // 判断是否已经下播
+            if (liveRoomInfo.live_status === 0) {
+                // 设置开播状态为false
+                liveStatus = false;
+                // 清除定时器
+                pushAtTimeTimer?.();
+                // 发送私聊消息
+                await this.sendPrivateMsg("直播间已下播，定时推送已停止！与直播间的连接可能已断开，请使用指令 sys restart 重启插件");
+            }
             // 设置开播时间
             liveTime = liveRoomInfo.live_time;
             // 获取watched
@@ -973,7 +1003,11 @@ class ComRegister {
                     .replace("-link", `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`)
                 : null;
             // 发送直播通知卡片
-            await sendLiveNotifyCard(type_1.LiveType.LiveBroadcast, watched, liveMsg);
+            await this.sendLiveNotifyCard(type_1.LiveType.LiveBroadcast, watched, {
+                liveRoomInfo,
+                masterInfo,
+                cardStyle,
+            }, target, liveMsg);
         };
         // 定义直播间信息获取函数
         const useMasterAndLiveRoomInfo = async (liveType) => {
@@ -1053,7 +1087,11 @@ class ComRegister {
                         .replace("-link", `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`)
                     : null;
                 // 推送开播通知
-                await sendLiveNotifyCard(type_1.LiveType.StartBroadcasting, follower, liveStartMsg);
+                await this.sendLiveNotifyCard(type_1.LiveType.StartBroadcasting, follower, {
+                    liveRoomInfo,
+                    masterInfo,
+                    cardStyle,
+                }, target, liveStartMsg);
                 // 判断定时器是否已开启
                 if (!pushAtTimeTimer) {
                     // 开始直播，开启定时器
@@ -1095,7 +1133,11 @@ class ComRegister {
                         .replace("\\n", "\n")
                     : null;
                 // 推送通知卡片
-                await sendLiveNotifyCard(type_1.LiveType.StopBroadcast, followerChange, liveEndMsg);
+                await this.sendLiveNotifyCard(type_1.LiveType.StopBroadcast, followerChange, {
+                    liveRoomInfo,
+                    masterInfo,
+                    cardStyle,
+                }, target, liveEndMsg);
                 // 关闭定时推送定时器
                 pushAtTimeTimer();
                 // 将推送定时器变量置空
@@ -1126,7 +1168,11 @@ class ComRegister {
                 : null;
             // 发送直播通知卡片
             if (this.config.restartPush) {
-                await sendLiveNotifyCard(type_1.LiveType.LiveBroadcast, watched, liveMsg);
+                await this.sendLiveNotifyCard(type_1.LiveType.LiveBroadcast, watched, {
+                    liveRoomInfo,
+                    masterInfo,
+                    cardStyle,
+                }, target, liveMsg);
             }
             // 正在直播，开启定时器，判断定时器是否已开启
             if (!pushAtTimeTimer) {
@@ -1137,6 +1183,231 @@ class ComRegister {
             liveStatus = true;
         }
     }
+    async liveDetectWithAPI() {
+        // 定义直播间信息获取函数
+        const useMasterAndLiveRoomInfo = async (liveType, liveStatus) => {
+            // 定义函数是否执行成功flag
+            let flag = true;
+            // 获取直播间信息
+            liveStatus.liveRoomInfo = await this.useLiveRoomInfo(liveStatus.roomId).catch(() => {
+                // 设置flag为false
+                flag = false;
+                // 返回空
+                return null;
+            });
+            // 判断是否成功获取信息
+            if (!flag || !liveStatus.liveRoomInfo?.uid) {
+                // 上一步未成功
+                flag = false;
+                // 返回flag
+                return flag;
+            }
+            // 获取主播信息(需要满足flag为true，liveRoomInfo.uid有值)
+            liveStatus.masterInfo = await this.useMasterInfo(liveStatus.liveRoomInfo.uid, liveStatus.masterInfo, liveType).catch(() => {
+                // 设置flag为false
+                flag = false;
+                // 返回空
+                return null;
+            });
+            // 返回信息
+            return flag;
+        };
+        const uids = [];
+        for (const [uid] of this.liveStatusManager.entries()) {
+            uids.push(uid);
+        }
+        // 初始化
+        // 发送请求
+        const { data } = (await this.ctx.ba.getLiveRoomInfoByUids(uids));
+        for (const item of Object.values(data)) {
+            // 将用户uid转换为string
+            const uid = item.uid.toString();
+            // 获取用户直播状态
+            const liveStatus = this.liveStatusManager.get(uid);
+            // 获取用户sub
+            const sub = this.subManager.find((sub) => sub.uid === uid);
+            // 判断直播状态
+            if (item.live_status === 1) {
+                // 将直播状态改为true
+                liveStatus.live = true;
+                // 初始化主播和直播间信息
+                await useMasterAndLiveRoomInfo(type_1.LiveType.FirstLiveBroadcast, liveStatus);
+                // 设置直播中消息
+                const liveMsg = this.config.customLive
+                    ? this.config.customLive
+                        .replace("-name", liveStatus.masterInfo.username)
+                        .replace("-time", await this.ctx.gi.getTimeDifference(liveStatus.liveStartTime))
+                        .replace("-watched", "暂未获取到")
+                        .replace("\\n", "\n")
+                        .replace("-link", `https://live.bilibili.com/${liveStatus.liveRoomInfo.short_id === 0 ? liveStatus.liveRoomInfo.room_id : liveStatus.liveRoomInfo.short_id}`)
+                    : null;
+                // 发送直播通知卡片
+                await this.sendLiveNotifyCard(type_1.LiveType.LiveBroadcast, "暂未获取到", {
+                    liveRoomInfo: liveStatus.liveRoomInfo,
+                    masterInfo: liveStatus.masterInfo,
+                    cardStyle: sub.card,
+                }, sub.target, liveMsg);
+            }
+            else {
+                useMasterAndLiveRoomInfo(type_1.LiveType.NotLiveBroadcast, liveStatus);
+            }
+        }
+        // 定义函数
+        const handler = async () => {
+            // 发送请求
+            const { data } = (await this.ctx.ba.getLiveRoomInfoByUids(uids));
+            // 进行处理
+            for (const item of Object.values(data)) {
+                // 将用户uid转换为string
+                const uid = item.uid.toString();
+                // 获取用户直播状态
+                const liveStatus = this.liveStatusManager.get(uid);
+                // 获取sub
+                const sub = this.subManager.find((sub) => sub.uid === uid);
+                // 如果未找到sub直接返回
+                if (!sub)
+                    return;
+                // 判断当前状态和之前状态是否相同
+                switch (item.live_status) {
+                    case 0:
+                    case 2: {
+                        // 未开播状态
+                        if (liveStatus.live === true) {
+                            // 现在下播了，发送下播通知
+                            // 判断信息是否获取成功
+                            if (!(await useMasterAndLiveRoomInfo(type_1.LiveType.StopBroadcast, liveStatus))) {
+                                // 未获取成功，直接返回
+                                return await this.sendPrivateMsg("获取直播间信息失败，推送直播下播卡片失败！");
+                            }
+                            // 更改直播时长
+                            if (liveStatus.liveStartTimeInit) {
+                                // 设置直播时长
+                                liveStatus.liveRoomInfo.live_time = liveStatus.liveStartTime;
+                                // 直播时间初始化改为false
+                                liveStatus.liveStartTimeInit = false;
+                            }
+                            // 获取粉丝数变化
+                            const followerChange = (() => {
+                                // 获取直播关注变化值
+                                const liveFollowerChangeNum = liveStatus.masterInfo.liveFollowerChange;
+                                // 判断是否大于0
+                                if (liveFollowerChangeNum > 0) {
+                                    // 大于0则加+
+                                    return liveFollowerChangeNum >= 10_000
+                                        ? `+${liveFollowerChangeNum.toFixed(1)}万`
+                                        : `+${liveFollowerChangeNum}`;
+                                }
+                                // 小于0
+                                return liveFollowerChangeNum <= -10_000
+                                    ? `${liveFollowerChangeNum.toFixed(1)}万`
+                                    : liveFollowerChangeNum.toString();
+                            })();
+                            // 定义下播播通知语
+                            const liveEndMsg = this.config.customLiveEnd
+                                ? this.config.customLiveEnd
+                                    .replace("-name", liveStatus.masterInfo.username)
+                                    .replace("-time", await this.ctx.gi.getTimeDifference(liveStatus.liveStartTime))
+                                    .replace("-follower_change", followerChange)
+                                    .replace("\\n", "\n")
+                                : null;
+                            // 推送通知卡片
+                            await this.sendLiveNotifyCard(type_1.LiveType.StopBroadcast, followerChange, {
+                                liveRoomInfo: liveStatus.liveRoomInfo,
+                                masterInfo: liveStatus.masterInfo,
+                                cardStyle: sub.card,
+                            }, sub.target, liveEndMsg);
+                            // 更改直播状态
+                            liveStatus.live = false;
+                        }
+                        // 还未开播
+                        break;
+                    }
+                    case 1: {
+                        // 开播状态
+                        if (liveStatus.live === false) {
+                            // 开播了
+                            // 判断信息是否获取成功
+                            if (!(await useMasterAndLiveRoomInfo(type_1.LiveType.StopBroadcast, liveStatus))) {
+                                // 未获取成功，直接返回
+                                return await this.sendPrivateMsg("获取直播间信息失败，推送直播下播卡片失败！");
+                            }
+                            // 设置开播时间
+                            liveStatus.liveStartTime = liveStatus.liveRoomInfo.live_time;
+                            // 设置开播时间初始化状态
+                            liveStatus.liveStartTimeInit = true;
+                            // 获取当前粉丝数
+                            const follower = liveStatus.masterInfo.liveOpenFollowerNum >= 10_000
+                                ? `${(liveStatus.masterInfo.liveOpenFollowerNum / 10000).toFixed(1)}万`
+                                : liveStatus.masterInfo.liveOpenFollowerNum.toString();
+                            // 定义开播通知语
+                            const liveStartMsg = this.config.customLiveStart
+                                ? this.config.customLiveStart
+                                    .replace("-name", liveStatus.masterInfo.username)
+                                    .replace("-time", await this.ctx.gi.getTimeDifference(liveStatus.liveStartTime))
+                                    .replace("-follower", follower)
+                                    .replace("\\n", "\n")
+                                    .replace("-link", `https://live.bilibili.com/${liveStatus.liveRoomInfo.short_id === 0 ? liveStatus.liveRoomInfo.room_id : liveStatus.liveRoomInfo.short_id}`)
+                                : null;
+                            // 推送开播通知
+                            await this.sendLiveNotifyCard(type_1.LiveType.StartBroadcasting, follower, {
+                                liveRoomInfo: liveStatus.liveRoomInfo,
+                                masterInfo: liveStatus.masterInfo,
+                                cardStyle: sub.card,
+                            }, sub.target, liveStartMsg);
+                            // 设置开播状态为true
+                            liveStatus.live = true;
+                        }
+                        if (liveStatus.live === true) {
+                            // 还在直播
+                            if (liveStatus.push < (this.config.pushTime * 60 * 60) / 10) {
+                                // push++
+                                liveStatus.push++;
+                                // 结束本次循环
+                                break;
+                            }
+                            // 判断是否信息是否获取成功
+                            if (!(await useMasterAndLiveRoomInfo(type_1.LiveType.LiveBroadcast, liveStatus))) {
+                                // 未获取成功，直接返回
+                                return this.sendPrivateMsg("获取直播间信息失败，推送直播卡片失败！");
+                            }
+                            // 判断是否需要设置开播时间
+                            if (!liveStatus.liveStartTimeInit) {
+                                // 设置开播时间
+                                liveStatus.liveStartTime = liveStatus.liveRoomInfo.live_time;
+                                // 设置开播时间初始化状态
+                                liveStatus.liveStartTimeInit = true;
+                            }
+                            // 获取watched
+                            const watched = "暂未获取到";
+                            // 设置直播中消息
+                            const liveMsg = this.config.customLive
+                                ? this.config.customLive
+                                    .replace("-name", liveStatus.masterInfo.username)
+                                    .replace("-time", await this.ctx.gi.getTimeDifference(liveStatus.liveStartTime))
+                                    .replace("-watched", watched)
+                                    .replace("\\n", "\n")
+                                    .replace("-link", `https://live.bilibili.com/${liveStatus.liveRoomInfo.short_id === 0 ? liveStatus.liveRoomInfo.room_id : liveStatus.liveRoomInfo.short_id}`)
+                                : null;
+                            // 发送直播通知卡片
+                            await this.sendLiveNotifyCard(type_1.LiveType.LiveBroadcast, watched, {
+                                liveRoomInfo: liveStatus.liveRoomInfo,
+                                masterInfo: liveStatus.masterInfo,
+                                cardStyle: sub.card,
+                            }, sub.target, liveMsg);
+                            // push归零
+                            liveStatus.push = 0;
+                        }
+                        // 结束
+                        break;
+                    }
+                    default:
+                        break;
+                }
+            }
+        };
+        // 返回一个闭包函数
+        return (0, utils_1.withLock)(handler);
+    }
     subShow() {
         // 在控制台中显示订阅对象
         let table = "";
@@ -1185,8 +1456,7 @@ class ComRegister {
         // 获取关注分组信息
         const checkGroupIsReady = async () => {
             // 判断是否有数据
-            if (this.loginDBData.dynamic_group_id === "" ||
-                this.loginDBData.dynamic_group_id === null) {
+            if (!this.loginDBData?.dynamic_group_id) {
                 // 没有数据，没有创建分组，尝试创建分组
                 const createGroupData = await this.ctx.ba.createGroup("订阅");
                 // 如果分组已创建，则获取分组id
@@ -1370,7 +1640,7 @@ class ComRegister {
             if (userInfoCode !== 0)
                 return { code: userInfoCode, msg: userInfoMsg };
             // 判断是否需要订阅直播
-            if (sub.live) {
+            if (this.config.liveDetectType === "WS" && sub.live) {
                 // 检查roomid是否存在
                 if (!userInfoData.live_room) {
                     // 用户没有开通直播间，无法订阅直播
@@ -1414,17 +1684,39 @@ class ComRegister {
     }
     checkIfDynamicDetectIsNeeded() {
         // 检查是否有订阅对象需要动态监测
-        if (this.subManager.some((sub) => sub.dynamic))
+        if (this.dynamicTimelineManager.size > 0) {
+            // 启动动态监测
             this.enableDynamicDetect();
+        }
+    }
+    checkIfLiveDetectIsNeeded() {
+        // 判断直播监测类型
+        if (this.config.liveDetectType === "API") {
+            // 检查是否有订阅对象需要直播监测
+            if (this.liveStatusManager.size > 0) {
+                // 启动直播监测
+                this.enableLiveDetect();
+            }
+        }
     }
     enableDynamicDetect() {
         // 定义Job
         this.dynamicJob = new cron_1.CronJob("*/2 * * * *", this.config.dynamicDebugMode
             ? this.debug_dynamicDetect()
             : this.dynamicDetect());
+        // logger
+        this.logger.info("动态监测已开启");
         // 开始动态监测
         this.dynamicJob.start();
     }
+    async enableLiveDetect() {
+        // 定义Job
+        this.liveJob = new cron_1.CronJob("*/10 * * * * *", await this.liveDetectWithAPI());
+        // logger
+        this.logger.info("直播监测已开启");
+        // 开始直播监测
+        this.liveJob.start();
+    }
     async checkIfIsLogin() {
         if ((await this.ctx.database.get("loginBili", 1)).length !== 0) {
             // 数据库中有数据
@@ -1469,6 +1761,7 @@ class ComRegister {
             masterAccount: koishi_1.Schema.string(),
             masterAccountGuildId: koishi_1.Schema.string(),
         }),
+        liveDetectType: koishi_1.Schema.string(),
         restartPush: koishi_1.Schema.boolean().required(),
         pushTime: koishi_1.Schema.number().required(),
         pushImgsInDynamic: koishi_1.Schema.boolean().required(),

package/lib/index.d.ts

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

package/lib/index.js

@@ -126,6 +126,7 @@ class ServerManager extends koishi_1.Service {
             const cr = this.ctx.plugin(comRegister_1.default, {
                 sub: globalConfig.sub,
                 master: globalConfig.master,
+                liveDetectType: globalConfig.liveDetectType,
                 restartPush: globalConfig.restartPush,
                 pushTime: globalConfig.pushTime,
                 pushImgsInDynamic: globalConfig.pushImgsInDynamic,
@@ -320,6 +321,10 @@ exports.Config = koishi_1.Schema.object({
         .default(false)
         .description("是否推送动态中的图片，默认不开启。开启后会单独推送动态中的图片"),
     live: koishi_1.Schema.object({}).description("直播推送设置"),
+    liveDetectType: koishi_1.Schema.union(["WS", "API"])
+        .role("radio")
+        .default("WS")
+        .description("直播检测方式，WS为连接到B站弹幕服务器，API为通过轮询发送请求监测，默认使用WS检测"),
     restartPush: koishi_1.Schema.boolean()
         .default(true)
         .description("插件重启后，如果订阅的主播正在直播，是否进行一次推送，默认开启"),

package/lib/type/index.d.ts

@@ -156,6 +156,47 @@ export type Dynamic = {
     type: string;
     visible: boolean;
 };
+export type Live = {
+    code: number;
+    message: string;
+    msg: string;
+    data: {
+        [key: string]: {
+            title: string;
+            room_id: number;
+            uid: number;
+            online: number;
+            live_time: number;
+            live_status: number;
+            short_id: number;
+            area: number;
+            area_name: string;
+            area_v2_id: number;
+            area_v2_name: string;
+            area_v2_parent_name: string;
+            area_v2_parent_id: number;
+            uname: string;
+            face: string;
+            tag_name: string;
+            tags: string;
+            cover_from_user: string;
+            keyframe: string;
+            lock_till: string;
+            hidden_till: string;
+            broadcast_type: number;
+        };
+    };
+};
+export type LiveStatus = {
+    live: boolean;
+    roomId: string;
+    liveRoomInfo: any;
+    masterInfo: MasterInfo;
+    watchedNum: string;
+    liveStartTimeInit: boolean;
+    liveStartTime: string;
+    push: number;
+};
 export type AllDynamicInfo = {
     code: number;
     message: string;

package/package.json

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

package/readme.md

@@ -247,6 +247,8 @@ uid为必填参数，为要推送的UP主的UID，index为可选参数，为要
 - ver 3.1.7-alpha.1 修复：启用自定义卡片样式后取消仍是自定义样式；
 - ver 3.1.7-alpha.2 修复：`liveDetect generateLiveImg() 推送卡片生成失败，原因：Cannot read properties of undefined (reading 'cardColorStart')`；
 - ver 3.1.7-alpha.3 修复：推送视频类动态报错；
+- ver 3.1.7 修复：第一次使用插件报错 `TypeError: Cannot read properties of undefined (reading 'dynamic_group_id')`
+- ver 3.2.0-alpha.0 新增：直播检测 `API` 模式； 优化：提升直播检测 `WS` 模式使用体验；
 
 ## 交流群