koishi-plugin-bilibili-notify 3.0.0-alpha.0 → 3.0.0-alpha.10

package/lib/comRegister.js

@@ -42,8 +42,10 @@ class ComRegister {
     loginDBData;
     // 机器人实例
     privateBot;
-    // 动态销毁函数
+    // 动态检测销毁函数
     dynamicDispose;
+    // 直播检测销毁函数
+    liveDispose;
     // 发送消息方式
     sendMsgFunc;
     // 构造函数
@@ -163,6 +165,8 @@ class ComRegister {
                             }]);
                         // 销毁定时器
                         this.loginTimer();
+                        // 订阅手动订阅中的订阅
+                        await this.loadSubFromConfig(config.sub);
                         // 订阅之前的订阅
                         await this.loadSubFromDatabase();
                         // 清除控制台通知
@@ -173,7 +177,6 @@ class ComRegister {
                         await session.execute('bili show');
                         // 开启cookies刷新检测
                         ctx.ba.enableRefreshCookiesDetect();
-                        return;
                     }
                 }
                 finally {
@@ -437,10 +440,23 @@ class ComRegister {
                 this.logger.error('bili sub指令 getMasterInfo() 发生了错误，错误为：' + e.message);
                 return '订阅出错啦，请重试';
             }
+            const liveDetectModeSelector = {
+                API: async () => {
+                    // 判断是否已开启直播检测
+                    if (!this.liveDispose) { // 未开启直播检测
+                        // 开启直播检测并保存销毁函数
+                        this.liveDispose = await this.liveDetectWithAPI();
+                    }
+                },
+                WS: async () => {
+                    // 连接到服务器
+                    await this.liveDetectWithListener(roomId, target);
+                }
+            };
             // 订阅直播
             if (liveMsg) {
-                // 连接到服务器
-                this.liveDetectWithListener(roomId, target);
+                // 判断直播订阅方式
+                await liveDetectModeSelector[this.config.liveDetectMode]();
                 // 发送订阅消息通知
                 await session.send(`订阅${userData.info.uname}直播通知`);
             }
@@ -448,6 +464,7 @@ class ComRegister {
             if (dynamicMsg) {
                 // 判断是否开启动态监测
                 if (!this.dynamicDispose) {
+                    // 开启动态监测
                     this.enableDynamicDetect();
                 }
                 // 发送订阅消息通知
@@ -583,6 +600,14 @@ class ComRegister {
         }
         // 检查登录数据库是否有数据
         this.loginDBData = (await this.ctx.database.get('loginBili', 1, ['dynamic_group_id']))[0];
+        // 判断登录信息是否已加载完毕
+        await this.checkIfLoginInfoIsLoaded();
+        // 如果未登录，则直接返回
+        if (!(await this.checkIfIsLogin())) {
+            // log
+            this.logger.info(`账号未登录，请登录`);
+            return;
+        }
         // 从配置获取订阅
         config.sub && await this.loadSubFromConfig(config.sub);
         // 从数据库获取订阅
@@ -705,8 +730,12 @@ class ComRegister {
         }
     }
     dynamicDetect() {
+        // 检测初始化变量
         let detectSetup = true;
+        // 更新基线
         let updateBaseline;
+        // 第一条动态的动态ID
+        let dynamicIdStr;
         // 相当于锁的作用，防止上一个循环没处理完
         let flag = true;
         // 返回一个闭包函数
@@ -803,14 +832,23 @@ class ComRegister {
                     // 寻找关注的UP主的动态
                     this.subManager.forEach(async (sub) => {
                         // 判断是否是订阅的UP主
-                        if (sub.uid == upUID) {
-                            // 订阅该UP主，推送该动态
+                        if (sub.dynamic && sub.uid == upUID) { // 订阅该UP主，推送该动态
+                            // 判断更新动态是否为1条
+                            if (updateNum === 1) {
+                                // 判断dynamicIdStr是否有值，是否与当前动态ID一致
+                                if (dynamicIdStr && dynamicIdStr === items[num].id_str) {
+                                    // 重复动态，不再推送，直接返回
+                                    return;
+                                }
+                                // 存储该动态ID
+                                dynamicIdStr = items[num].id_str;
+                            }
                             // 定义变量
                             let pic;
                             let buffer;
                             // 从动态数据中取出UP主名称和动态ID
-                            const upName = content.data.items[num].modules.module_author.name;
-                            const dynamicId = content.data.items[num].id_str;
+                            const upName = items[num].modules.module_author.name;
+                            const dynamicId = items[num].id_str;
                             // 推送该条动态
                             const attempts = 3;
                             for (let i = 0; i < attempts; i++) {
@@ -875,8 +913,12 @@ class ComRegister {
         };
     }
     debug_dynamicDetect() {
+        // 检测初始化变量
         let detectSetup = true;
+        // 更新基线
         let updateBaseline;
+        // 第一条动态的动态ID
+        let dynamicIdStr;
         // 相当于锁的作用，防止上一个循环没处理完
         let flag = true;
         // 返回一个闭包函数
@@ -986,14 +1028,23 @@ class ComRegister {
                     this.subManager.forEach(async (sub) => {
                         console.log(`当前订阅UP主：${sub.uid}`);
                         // 判断是否是订阅的UP主
-                        if (sub.uid == upUID) {
-                            // 订阅该UP主，推送该动态
+                        if (sub.dynamic && sub.uid == upUID) { // 订阅该UP主，推送该动态
+                            // 判断更新动态是否为1条
+                            if (updateNum === 1) {
+                                // 判断dynamicIdStr是否有值，是否与当前动态ID一致
+                                if (dynamicIdStr && dynamicIdStr === items[num].id_str) {
+                                    // 重复动态，不再推送，直接返回
+                                    return;
+                                }
+                                // 存储该动态ID
+                                dynamicIdStr = items[num].id_str;
+                            }
                             // 定义变量
                             let pic;
                             let buffer;
                             // 从动态数据中取出UP主名称和动态ID
-                            const upName = content.data.items[num].modules.module_author.name;
-                            const dynamicId = content.data.items[num].id_str;
+                            const upName = items[num].modules.module_author.name;
+                            const dynamicId = items[num].id_str;
                             console.log(`UP主名称：${upName}，动态ID：${dynamicId}`);
                             // 推送该条动态
                             const attempts = 3;
@@ -1130,21 +1181,13 @@ class ComRegister {
     }
     async liveDetectWithAPI() {
         // 定义变量：第一次订阅
-        let firstSubscription = true;
+        let liveDetectSetup = 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;
@@ -1176,10 +1219,18 @@ class ComRegister {
             try {
                 // 获取正在直播对象
                 const liveUsers = await this.ctx.ba.getTheUserWhoIsLiveStreaming();
-                // 判断是否是第一次订阅
-                if (firstSubscription) {
+                // 判断是否是初始化直播监测
+                if (liveDetectSetup) {
                     // 将第一次订阅置为false
-                    firstSubscription = false;
+                    liveDetectSetup = false;
+                    // 初始化subRecord
+                    this.subManager.forEach(sub => {
+                        // 判断是否订阅直播
+                        if (sub.live) {
+                            // 将该订阅添加到subRecord中
+                            liveRecord[sub.uid] = { liveStatus: 0, liveTime: '', target: sub.target };
+                        }
+                    });
                     // 先判断是否有UP主正在直播
                     if (liveUsers.count > 0) {
                         // 遍历liveUsers
@@ -1190,6 +1241,8 @@ class ComRegister {
                                 const data = await useLiveStatus(item.room_id.toString());
                                 // 设置开播时间
                                 liveRecord[item.mid].liveTime = data.live_time;
+                                // 改变开播状态
+                                liveRecord[item.mid].liveStatus = 1;
                                 // 设置直播中消息
                                 const liveMsg = this.config.customLive ? this.config.customLive
                                     .replace('-name', item.uname)
@@ -1203,8 +1256,6 @@ class ComRegister {
                                         target: liveRecord[item.mid].target,
                                         data
                                     }, LiveType.LiveBroadcast, liveMsg);
-                                // 改变开播状态
-                                liveRecord[item.mid].liveStatus = 1;
                             }
                         });
                     }
@@ -1312,6 +1363,8 @@ class ComRegister {
                     const masterInfo = await this.useMasterInfo(subUID);
                     // 获取直播间消息
                     const liveRoomInfo = await this.useLiveRoomInfo(masterInfo.roomId.toString());
+                    // 设置开播时间
+                    liveRoomInfo.live_time = liveRecord[subUID].liveTime;
                     // 定义下播播通知语                            
                     const liveEndMsg = this.config.customLiveEnd ? this.config.customLiveEnd
                         .replace('-name', masterInfo.username)
@@ -1340,10 +1393,21 @@ class ComRegister {
         // 定义弹幕存放数组
         const currentLiveDanmakuArr = [];
         const temporaryLiveDanmakuArr = [];
+        // 定义开播状态
+        let liveStatus = false;
         // 处理target
+        // 定义channelIdArr总长度
+        let channelIdArrLen = 0;
+        // 定义数据
+        let liveRoomInfo;
+        let masterInfo;
         // 找到频道/群组对应的
-        const newTarget = target.map(channel => {
+        const danmakuPushTargetArr = target.map(channel => {
+            // 获取符合条件的target
             const liveDanmakuArr = channel.channelIdArr.filter(channelId => channelId.liveDanmaku);
+            // 将当前liveDanmakuArr的长度+到channelIdArrLen中
+            channelIdArrLen += liveDanmakuArr.length;
+            // 返回符合的target
             return {
                 channelIdArr: liveDanmakuArr,
                 platform: channel.platform
@@ -1351,11 +1415,14 @@ class ComRegister {
         });
         // 定义定时推送函数
         const pushAtTimeFunc = async () => {
-            // 获取直播间信息
-            const liveRoomInfo = await this.useLiveRoomInfo(roomId);
-            // 获取主播信息
-            const masterInfo = await this.useMasterInfo(liveRoomInfo.uid);
-            // 定义直播中通知消息
+            // 判断是否信息是否获取成功
+            if (!(await useMasterAndLiveRoomInfo())) {
+                // 未获取成功，直接返回
+                return this.sendPrivateMsg('获取直播间信息失败，推送直播卡片失败！');
+            }
+            // 设置开播时间
+            liveTime = liveRoomInfo.live_time;
+            // 设置直播中消息
             const liveMsg = this.config.customLive ? this.config.customLive
                 .replace('-name', masterInfo.username)
                 .replace('-time', await this.ctx.gi.getTimeDifference(liveTime))
@@ -1364,24 +1431,58 @@ class ComRegister {
             await this.sendLiveNotifyCard({
                 username: masterInfo.username,
                 userface: masterInfo.userface,
-                target: newTarget,
+                target,
                 data: liveRoomInfo
             }, LiveType.LiveBroadcast, liveMsg);
         };
         // 定义弹幕推送函数
         const danmakuPushFunc = () => {
             // 判断数组是否有内容
-            if (temporaryLiveDanmakuArr.length > 0) {
+            if (channelIdArrLen > 0 && temporaryLiveDanmakuArr.length > 0) {
                 // 发送消息
-                this.sendMsg(newTarget, temporaryLiveDanmakuArr.join('\n'));
+                this.sendMsg(danmakuPushTargetArr, temporaryLiveDanmakuArr.join('\n'));
                 // 将临时消息数组清空
                 temporaryLiveDanmakuArr.length = 0;
             }
         };
-        // 获取直播间信息
-        const liveRoomInfo = await this.useLiveRoomInfo(roomId);
-        // 获取主播信息
-        const masterInfo = await this.useMasterInfo(liveRoomInfo.uid);
+        // 定义直播间信息获取函数
+        const useMasterAndLiveRoomInfo = async () => {
+            // 定义flag
+            let flag = true;
+            // 判断是否已存在值
+            if (liveRoomInfo && masterInfo && liveTime) {
+                // 所有值均已存在，不需要再获取信息
+                return flag;
+            }
+            // 获取直播间信息
+            liveRoomInfo = await this.useLiveRoomInfo(roomId).catch(() => {
+                // 设置flag为false
+                flag = false;
+                // 返回空
+                return null;
+            });
+            // 判断是否成功获取信息
+            if (!flag || !liveRoomInfo || !liveRoomInfo.uid) {
+                // 上一步未成功
+                flag = false;
+                // 返回flag
+                return flag;
+            }
+            // 获取主播信息(需要满足flag为true，liveRoomInfo.uid有值)
+            masterInfo = await this.useMasterInfo(liveRoomInfo.uid).catch(() => {
+                // 设置flag为false
+                flag = false;
+                // 返回空
+                return null;
+            });
+            // 返回信息
+            return flag;
+        };
+        // 判断是否信息是否获取成功
+        if (!(await useMasterAndLiveRoomInfo())) {
+            // 未获取成功，直接返回
+            return this.sendPrivateMsg('获取直播间信息失败，启动直播间弹幕检测失败！');
+        }
         // 构建消息处理函数
         const handler = {
             onOpen: () => {
@@ -1411,49 +1512,67 @@ class ComRegister {
                 temporaryLiveDanmakuArr.push(content);
             },
             onLiveStart: async () => {
-                // 获取直播间信息
-                const liveRoomInfo = await this.useLiveRoomInfo(roomId);
-                // 获取主播信息
-                const masterInfo = await this.useMasterInfo(liveRoomInfo.uid);
-                // 定义下播通知消息
-                const liveEndMsg = this.config.customLiveEnd ? this.config.customLiveEnd
+                // 判断是否已经开播
+                if (liveStatus)
+                    return;
+                // 设置开播状态为true
+                liveStatus = true;
+                // 判断是否信息是否获取成功
+                if (!(await useMasterAndLiveRoomInfo())) {
+                    // 设置开播状态为false
+                    liveStatus = false;
+                    // 未获取成功，直接返回
+                    return await this.sendPrivateMsg('获取直播间信息失败，推送直播开播卡片失败！');
+                }
+                // 设置开播时间
+                liveTime = liveRoomInfo.live_time;
+                // 定义开播通知语                            
+                const liveStartMsg = this.config.customLiveStart ? this.config.customLiveStart
                     .replace('-name', masterInfo.username)
-                    .replace('-time', await this.ctx.gi.getTimeDifference(liveTime)) : null;
-                // 更改直播时长
-                liveRoomInfo.live_time = liveTime;
-                // 推送下播通知
+                    .replace('-time', await this.ctx.gi.getTimeDifference(liveTime))
+                    .replace('-link', `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`) : null;
+                // 推送开播通知
                 await this.sendLiveNotifyCard({
                     username: masterInfo.username,
                     userface: masterInfo.userface,
-                    target: newTarget,
+                    target,
                     data: liveRoomInfo
-                }, LiveType.StopBroadcast, liveEndMsg);
+                }, LiveType.StartBroadcasting, liveStartMsg);
+                // 判断定时器是否已开启
+                if (!pushAtTimeTimer) {
+                    // 开始直播，开启定时器
+                    pushAtTimeTimer = this.ctx.setInterval(pushAtTimeFunc, this.config.pushTime * 1000 * 60 * 60);
+                }
             },
             onLiveEnd: async () => {
-                // 获取直播间消息
-                const liveRoomInfo = await this.useLiveRoomInfo(roomId);
-                // 获取主播信息
-                const masterInfo = await this.useMasterInfo(liveRoomInfo.uid);
-                // 关闭定时推送定时器
-                pushAtTimeTimer();
-                // 将推送定时器变量置空
-                pushAtTimeTimer = null;
+                // 判断是否信息是否获取成功
+                if (!(await useMasterAndLiveRoomInfo())) {
+                    // 未获取成功，直接返回
+                    return this.sendPrivateMsg('获取直播间信息失败，推送直播下播卡片失败！');
+                }
+                // 更改直播时长
+                liveRoomInfo.live_time = liveTime;
                 // 定义下播播通知语                            
                 const liveEndMsg = this.config.customLiveEnd ? this.config.customLiveEnd
                     .replace('-name', masterInfo.username)
-                    .replace('-time', await this.ctx.gi.getTimeDifference(liveTime))
-                    .replace('-link', `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`) : null;
+                    .replace('-time', await this.ctx.gi.getTimeDifference(liveTime)) : null;
                 // 推送通知卡片
                 await this.sendLiveNotifyCard({
                     username: masterInfo.username,
                     userface: masterInfo.userface,
-                    target: newTarget,
+                    target,
                     data: liveRoomInfo
-                }, LiveType.StartBroadcasting, liveEndMsg);
+                }, LiveType.StopBroadcast, liveEndMsg);
+                // 关闭定时推送定时器
+                pushAtTimeTimer();
+                // 将推送定时器变量置空
+                pushAtTimeTimer = null;
+                // 将直播状态设置为false
+                liveStatus = false;
             }
         };
         // 启动直播间弹幕监测
-        this.ctx.bl.startLiveRoomListener(roomId, handler, danmakuPushFunc);
+        await this.ctx.bl.startLiveRoomListener(roomId, handler, danmakuPushFunc);
         // 判断直播状态
         if (liveRoomInfo.live_status === 1) {
             // 设置开播时间
@@ -1468,12 +1587,18 @@ class ComRegister {
                 await this.sendLiveNotifyCard({
                     username: masterInfo.username,
                     userface: masterInfo.userface,
-                    target: newTarget,
+                    target,
                     data: liveRoomInfo
                 }, LiveType.LiveBroadcast, liveMsg);
             }
             // 正在直播，开启定时器
-            pushAtTimeTimer = this.ctx.setInterval(pushAtTimeFunc, this.config.pushTime * 1000 * 60 * 60);
+            // 判断定时器是否已开启
+            if (!pushAtTimeTimer) {
+                // 开始直播，开启定时器
+                pushAtTimeTimer = this.ctx.setInterval(pushAtTimeFunc, this.config.pushTime * 1000 * 60 * 60);
+            }
+            // 设置直播状态为true
+            liveStatus = true;
         }
     }
     subShow() {
@@ -1657,7 +1782,7 @@ class ComRegister {
                         break;
                     }
                     catch (e) {
-                        this.logger.error('getSubFromDatabase() getUserInfo() 发生了错误，错误为：' + e.message);
+                        this.logger.error('loadSubFromConfig() getUserInfo() 发生了错误，错误为：' + e.message);
                         if (i === attempts - 1) { // 已尝试三次
                             // 发送私聊消息并重启服务
                             return await this.sendPrivateMsgAndStopService();
@@ -1673,10 +1798,24 @@ class ComRegister {
                     // 发送提示
                     this.logger.warn(`UID:${sub.uid} 用户没有开通直播间，无法订阅直播！`);
                 }
+                // 
+                const liveDetectModeSelector = {
+                    API: async () => {
+                        // 判断是否已开启直播检测
+                        if (!this.liveDispose) { // 未开启直播检测
+                            // 开启直播检测并保存销毁函数
+                            this.liveDispose = await this.liveDetectWithAPI();
+                        }
+                    },
+                    WS: async () => {
+                        // 连接到服务器
+                        await this.liveDetectWithListener(data.live_room.roomid, sub.target);
+                    }
+                };
                 // 判断是否订阅直播
                 if (sub.live) {
-                    // 订阅直播
-                    this.liveDetectWithListener(data.live_room.roomid, sub.target);
+                    // 启动直播监测
+                    await liveDetectModeSelector[this.config.liveDetectMode]();
                 }
             }
             // 在B站中订阅该对象
@@ -1697,17 +1836,6 @@ class ComRegister {
         }
     }
     async loadSubFromDatabase() {
-        // 判断登录信息是否已加载完毕
-        await this.checkIfLoginInfoIsLoaded();
-        // 如果未登录，则直接返回
-        if (!(await this.checkIfIsLogin())) {
-            // log
-            this.logger.info(`账号未登录，请登录`);
-            return;
-        }
-        // 已存在订阅管理对象，不再进行订阅操作
-        if (this.subManager.length !== 0)
-            return;
         // 从数据库中获取数据
         const subData = await this.ctx.database.get('bilibili', { id: { $gt: 0 } });
         // 定义变量：订阅直播数
@@ -1808,23 +1936,37 @@ class ComRegister {
                 dynamic: sub.dynamic === 1 ? true : false,
                 liveDispose: null
             };
+            // 定义直播模式监测器
+            const liveDetectModeSelector = {
+                API: async () => {
+                    // 判断是否已开启直播检测
+                    if (!this.liveDispose) { // 未开启直播检测
+                        // 开启直播检测并保存销毁函数
+                        this.liveDispose = await this.liveDetectWithAPI();
+                    }
+                },
+                WS: async () => {
+                    // 判断订阅直播数是否超过限制
+                    if (!this.config.unlockSubLimits && liveSubNum >= 3) {
+                        // 将live改为false
+                        subManagerItem.live = false;
+                        // log
+                        this.logger.warn(`UID:${sub.uid} 订阅直播数超过限制，自动取消订阅`);
+                        // 发送错误消息
+                        await this.sendPrivateMsg(`UID:${sub.uid} 订阅直播数超过限制，自动取消订阅`);
+                    }
+                    else {
+                        // 直播订阅数+1
+                        liveSubNum++;
+                        // 订阅直播，开始循环检测
+                        await this.liveDetectWithListener(sub.room_id, target);
+                    }
+                }
+            };
             // 判断是否订阅直播
             if (sub.live) {
-                // 判断订阅直播数是否超过限制
-                if (!this.config.unlockSubLimits && liveSubNum >= 3) {
-                    // 将live改为false
-                    subManagerItem.live = false;
-                    // log
-                    this.logger.warn(`UID:${sub.uid} 订阅直播数超过限制，自动取消订阅`);
-                    // 发送错误消息
-                    await this.sendPrivateMsg(`UID:${sub.uid} 订阅直播数超过限制，自动取消订阅`);
-                }
-                else {
-                    // 直播订阅数+1
-                    liveSubNum++;
-                    // 订阅直播，开始循环检测
-                    this.liveDetectWithListener(sub.room_id, target);
-                }
+                // 启动直播监测
+                await liveDetectModeSelector[this.config.liveDetectMode]();
             }
             // 保存新订阅对象
             this.subManager.push(subManagerItem);
@@ -1874,6 +2016,17 @@ class ComRegister {
                     }
                     // 取消订阅
                     sub.live = false;
+                    // 判断直播检测方式
+                    switch (this.config.liveDetectMode) {
+                        case 'API': {
+                            msg = '请手动删除订阅，并重启插件';
+                            break;
+                        }
+                        case 'WS': {
+                            // 取消直播监听
+                            this.ctx.bl.closeListener(sub.roomId);
+                        }
+                    }
                     // 如果没有对这个UP的任何订阅，则移除
                     if (checkIfNoSubExist(sub)) {
                         // 从管理对象中移除
@@ -1932,6 +2085,15 @@ class ComRegister {
         this.subManager.filter(sub => sub.uid === uid).map(async (sub, i) => {
             // 判断是否还存在订阅了动态的对象，不存在则停止动态监测
             this.checkIfUserIsTheLastOneWhoSubDyn();
+            switch (this.config.liveDetectMode) {
+                case "API": {
+                    break;
+                }
+                case "WS": {
+                    // 停止直播检测
+                    this.ctx.bl.closeListener(sub.roomId);
+                }
+            }
             // 从数据库中删除订阅
             await this.ctx.database.remove('bilibili', { uid: this.subManager[i].uid });
             // 将该订阅对象从订阅管理对象中移除
@@ -1979,6 +2141,10 @@ class ComRegister {
         }),
         unlockSubLimits: koishi_1.Schema.boolean().required(),
         automaticResend: koishi_1.Schema.boolean().required(),
+        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(),
         liveLoopTime: koishi_1.Schema.number().default(10),

package/lib/generateImg.js

@@ -176,7 +176,7 @@ class GenerateImg extends koishi_1.Service {
                                 </div>
                                 ${this.giConfig.hideDesc ? '' : `<p class="card-text">${data.description ? data.description : '这个主播很懒，什么都简介都没写'}</p>`}
                                 <p class="card-link">
-                                    ${liveStatus !== 3 ? `<span>人气：${data.online > 10000 ? `${(data.online / 10000).toFixed(1)}万` : data.online}</span>` : ''}
+                                    <span>人气：${data.online > 10000 ? `${(data.online / 10000).toFixed(1)}万` : data.online}</span>
                                     <span>分区名称：${data.area_name}</span>
                                 </p>
                                 <p class="card-link">
@@ -1432,7 +1432,7 @@ class GenerateImg extends koishi_1.Service {
             }
             case 3: {
                 titleStatus = '下播啦';
-                liveTime = `直播时长：${await this.getTimeDifference(time)}`;
+                liveTime = `开播时间：${time}`;
                 cover = true;
                 break;
             }
@@ -1455,7 +1455,7 @@ class GenerateImg extends koishi_1.Service {
         const seconds = differenceInSeconds % 60;
         // 返回格式化的字符串
         return days ?
-            `${days} 天 ${hours}小时${minutes.toString().padStart(2, '0')}分${seconds.toString().padStart(2, '0')}秒` :
+            `${days}天${hours}小时${minutes.toString().padStart(2, '0')}分${seconds.toString().padStart(2, '0')}秒` :
             `${hours}小时${minutes.toString().padStart(2, '0')}分${seconds.toString().padStart(2, '0')}秒`;
     }
     unixTimestampToString(timestamp) {

package/lib/index.d.ts

@@ -6,6 +6,17 @@ declare module 'koishi' {
         sm: ServerManager;
     }
 }
+declare class ServerManager extends Service {
+    servers: ForkScope[];
+    renderType: number;
+    dynamicLoopTime: number;
+    constructor(ctx: Context);
+    protected start(): void | Promise<void>;
+    registerPlugin: () => boolean;
+    disposePlugin: () => Promise<boolean>;
+    restartPlugin: () => Promise<boolean>;
+}
+export declare function apply(ctx: Context, config: Config): void;
 export interface Config {
     require: {};
     key: string;
@@ -36,6 +47,7 @@ export interface Config {
     dynamicCheckNumber: number;
     dynamicLoopTime: '1分钟' | '2分钟' | '3分钟' | '5分钟' | '10分钟' | '20分钟';
     live: {};
+    liveDetectMode: 'API' | 'WS';
     restartPush: boolean;
     pushTime: number;
     danmakuPushTime: number;
@@ -54,15 +66,4 @@ export interface Config {
     dynamicDebugMode: boolean;
 }
 export declare const Config: Schema<Config>;
-declare class ServerManager extends Service {
-    servers: ForkScope[];
-    renderType: number;
-    dynamicLoopTime: number;
-    constructor(ctx: Context);
-    protected start(): void | Promise<void>;
-    registerPlugin: () => boolean;
-    disposePlugin: () => Promise<boolean>;
-    restartPlugin: () => Promise<boolean>;
-}
-export declare function apply(ctx: Context, config: Config): void;
 export {};