koishi-plugin-bilibili-notify 3.0.0-alpha.22 → 3.0.0-alpha.24

package/lib/biliAPI.d.ts

@@ -26,21 +26,7 @@ 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;
-            }
-        ];
-    }>;
+    getTheUserWhoIsLiveStreaming(): Promise<any>;
     getLiveRoomInfoStreamKey(roomId: string): Promise<any>;
     getServerUTCTime(): Promise<number>;
     getTimeNow(): Promise<any>;

package/lib/biliAPI.js

@@ -120,9 +120,9 @@ class BiliAPI extends koishi_1.Service {
     // BA API
     async getTheUserWhoIsLiveStreaming() {
         // 获取直播间信息流密钥
-        const { data: { live_users }, } = await this.client.get(GET_LATEST_UPDATED_UPS);
+        const { data } = await this.client.get(GET_LATEST_UPDATED_UPS);
         // 返回data
-        return live_users;
+        return data;
     }
     async getLiveRoomInfoStreamKey(roomId) {
         // 获取直播间信息流密钥

package/lib/blive.js

@@ -33,7 +33,7 @@ class BLive extends koishi_1.Service {
             },
         });
         // logger
-        this.logger.info(`${roomId}直播间弹幕监听已开启`);
+        this.logger.info(`${roomId}直播间监听已开启`);
     }
     closeListener(roomId) {
         // 判断直播间监听器是否关闭

package/lib/comRegister.d.ts

@@ -26,8 +26,8 @@ declare class ComRegister {
     sendPrivateMsgAndRebootService(): Promise<void>;
     sendPrivateMsgAndStopService(): Promise<void>;
     sendMsg(targets: Target, content: any, live?: boolean): Promise<void>;
-    dynamicDetect(): () => Promise<void>;
-    debug_dynamicDetect(): () => Promise<void>;
+    dynamicDetect(): (...args: any[]) => void;
+    debug_dynamicDetect(): (...args: any[]) => void;
     sendLiveNotifyCard(info: {
         username: string;
         userface: string;

package/lib/comRegister.js

@@ -213,6 +213,44 @@ class ComRegister {
             // 发送提示
             await session.send("已发送消息，如未收到则说明您的机器人不支持发送私聊消息或您的信息填写有误");
         });
+        biliCom
+            .subcommand(".ll")
+            .usage("展示当前正在直播的订阅对象")
+            .example("bili ll")
+            .action(async () => {
+            // 获取liveUsers
+            const { data: { live_users }, } = (await ctx.ba.getTheUserWhoIsLiveStreaming());
+            // 定义当前正在直播且订阅的UP主列表
+            const subLiveUsers = [];
+            // 获取当前订阅的UP主
+            for (const sub of this.subManager) {
+                // 定义开播标志位
+                let onLive = false;
+                // 遍历liveUsers
+                for (const user of live_users.items) {
+                    // 判断是否是订阅直播的UP
+                    if (user.mid.toString() === sub.uid && sub.live) {
+                        // 设置标志位为true
+                        onLive = true;
+                        // break
+                        break;
+                    }
+                }
+                // 判断是否未开播
+                subLiveUsers.push({
+                    uid: Number.parseInt(sub.uid),
+                    uname: sub.uname,
+                    onLive,
+                });
+            }
+            // 定义table字符串
+            let table = "";
+            // 遍历liveUsers
+            for (const user of subLiveUsers) {
+                table += `[UID:${user.uid}] 「${user.uname}」 ${user.onLive ? "正在直播" : "未开播"}\n`;
+            }
+            return table;
+        });
     }
     async init(config) {
         // 设置logger
@@ -256,11 +294,7 @@ class ComRegister {
             bot, channelId, 
             // biome-ignore lint/suspicious/noExplicitAny: <explanation>
             content) => {
-                try {
-                    // 发送消息
-                    await bot.sendMessage(channelId, content);
-                }
-                catch (e) {
+                (0, utils_1.withRetry)(async () => await bot.sendMessage(channelId, content), 0).catch(async (e) => {
                     if (e.message === "this._request is not a function") {
                         // 2S之后重新发送消息
                         this.ctx.setTimeout(async () => {
@@ -272,7 +306,7 @@ class ComRegister {
                     // 打印错误信息
                     this.logger.error(`发送群组ID:${channelId}消息失败！原因: ${e.message}`);
                     await this.sendPrivateMsg(`发送群组ID:${channelId}消息失败，请查看日志`);
-                }
+                });
             };
         }
         // 检查登录数据库是否有数据
@@ -441,190 +475,180 @@ class ComRegister {
         let updateBaseline;
         // 第一条动态的动态ID
         let dynamicIdStr;
-        // 相当于锁的作用，防止上一个循环没处理完
-        let flag = true;
-        // 返回一个闭包函数
-        return async () => {
-            // 判断上一个循环是否完成
-            if (!flag)
+        // 定义handler
+        const handler = async () => {
+            // 检测启动初始化
+            if (detectSetup) {
+                // 获取动态信息
+                const data = (await this.ctx.ba.getAllDynamic());
+                // 判断获取动态信息是否成功
+                if (data.code !== 0)
+                    return;
+                // 设置更新基线
+                updateBaseline = data.data.update_baseline;
+                // 设置初始化为false
+                detectSetup = false;
+                // 初始化完成
                 return;
-            flag = false;
-            // 无论是否执行成功都要释放锁
+            }
+            // 获取用户所有动态数据
+            let updateNum;
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+            let content;
             try {
-                // 检测启动初始化
-                if (detectSetup) {
-                    // 获取动态信息
-                    const data = (await this.ctx.ba.getAllDynamic());
-                    // 判断获取动态信息是否成功
-                    if (data.code !== 0)
-                        return;
-                    // 设置更新基线
-                    updateBaseline = data.data.update_baseline;
-                    // 设置初始化为false
-                    detectSetup = false;
-                    // 初始化完成
+                // 查询是否有新动态
+                const data = await this.ctx.ba.hasNewDynamic(updateBaseline);
+                updateNum = data.data.update_num;
+                // 没有新动态或获取动态信息失败直接返回
+                if (updateNum <= 0 || data.code !== 0)
                     return;
-                }
-                // 获取用户所有动态数据
-                let updateNum;
-                // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-                let content;
-                try {
-                    // 查询是否有新动态
-                    const data = await this.ctx.ba.hasNewDynamic(updateBaseline);
-                    updateNum = data.data.update_num;
-                    // 没有新动态或获取动态信息失败直接返回
-                    if (updateNum <= 0 || data.code !== 0)
-                        return;
-                    // 获取动态内容
-                    content = (await this.ctx.ba.getAllDynamic(updateBaseline));
-                }
-                catch (e) {
-                    return this.logger.error(`dynamicDetect getUserSpaceDynamic() 发生了错误，错误为：${e.message}`);
-                }
-                // 判断获取动态内容是否成功
-                if (content.code !== 0) {
-                    switch (content.code) {
-                        case -101: {
-                            // 账号未登录
-                            // 输出日志
-                            this.logger.error("账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件");
-                            // 发送私聊消息
-                            await this.sendPrivateMsg("账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件");
-                            // 停止服务
-                            await this.ctx.sm.disposePlugin();
-                            // 结束循环
-                            break;
-                        }
-                        case -352: {
-                            // 风控
-                            // 输出日志
-                            this.logger.error("账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件");
-                            // 发送私聊消息
-                            await this.sendPrivateMsg("账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件");
-                            // 停止服务
-                            await this.ctx.sm.disposePlugin();
-                            // 结束循环
-                            break;
-                        }
-                        case 4101128:
-                        case 4101129: {
-                            // 获取动态信息错误
-                            // 输出日志
-                            this.logger.error(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`);
-                            // 发送私聊消息
-                            await this.sendPrivateMsg(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`); // 未知错误
-                            // 结束循环
-                            break;
-                        }
-                        default: {
-                            // 未知错误
-                            // 发送私聊消息
-                            await this.sendPrivateMsg(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`); // 未知错误
-                            // 结束循环
-                            break;
-                        }
+                // 获取动态内容
+                content = (await this.ctx.ba.getAllDynamic(updateBaseline));
+            }
+            catch (e) {
+                return this.logger.error(`dynamicDetect getUserSpaceDynamic() 发生了错误，错误为：${e.message}`);
+            }
+            // 判断获取动态内容是否成功
+            if (content.code !== 0) {
+                switch (content.code) {
+                    case -101: {
+                        // 账号未登录
+                        // 输出日志
+                        this.logger.error("账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件");
+                        // 发送私聊消息
+                        await this.sendPrivateMsg("账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件");
+                        // 停止服务
+                        await this.ctx.sm.disposePlugin();
+                        // 结束循环
+                        break;
+                    }
+                    case -352: {
+                        // 风控
+                        // 输出日志
+                        this.logger.error("账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件");
+                        // 发送私聊消息
+                        await this.sendPrivateMsg("账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件");
+                        // 停止服务
+                        await this.ctx.sm.disposePlugin();
+                        // 结束循环
+                        break;
+                    }
+                    case 4101128:
+                    case 4101129: {
+                        // 获取动态信息错误
+                        // 输出日志
+                        this.logger.error(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`);
+                        // 发送私聊消息
+                        await this.sendPrivateMsg(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`); // 未知错误
+                        // 结束循环
+                        break;
+                    }
+                    default: {
+                        // 未知错误
+                        // 发送私聊消息
+                        await this.sendPrivateMsg(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`); // 未知错误
+                        // 结束循环
+                        break;
                     }
                 }
-                // 获取数据内容
-                const data = content.data;
-                // 更新基线
-                updateBaseline = data.update_baseline;
-                // 有新动态内容
-                const items = data.items;
-                // 检查更新的动态
-                for (let num = updateNum - 1; num >= 0; num--) {
-                    // 没有动态内容则直接跳过
-                    if (!items[num])
-                        continue;
-                    // 从动态数据中取出UP主名称、UID和动态ID
-                    const upUID = items[num].modules.module_author.mid;
-                    // 寻找关注的UP主的动态
-                    for (const sub of this.subManager) {
-                        // 判断是否是订阅的UP主
-                        // biome-ignore lint/suspicious/noDoubleEquals: <explanation>
-                        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;
+            }
+            // 获取数据内容
+            const data = content.data;
+            // 更新基线
+            updateBaseline = data.update_baseline;
+            // 有新动态内容
+            const items = data.items;
+            // 检查更新的动态
+            for (let num = updateNum - 1; num >= 0; num--) {
+                // 没有动态内容则直接跳过
+                if (!items[num])
+                    continue;
+                // 从动态数据中取出UP主名称、UID和动态ID
+                const upUID = items[num].modules.module_author.mid;
+                // 寻找关注的UP主的动态
+                for (const sub of this.subManager) {
+                    // 判断是否是订阅的UP主
+                    // biome-ignore lint/suspicious/noDoubleEquals: <explanation>
+                    if (sub.dynamic && sub.uid == upUID) {
+                        // 订阅该UP主，推送该动态
+                        // 判断更新动态是否为1条
+                        if (updateNum === 1) {
+                            // 判断dynamicIdStr是否有值，是否与当前动态ID一致
+                            if (dynamicIdStr && dynamicIdStr === items[num].id_str) {
+                                // 重复动态，不再推送，直接返回
+                                return;
                             }
-                            // 定义变量
-                            let pic;
-                            let buffer;
-                            // 从动态数据中取出UP主名称和动态ID
-                            const upName = items[num].modules.module_author.name;
-                            const dynamicId = items[num].id_str;
-                            // 推送该条动态
-                            const attempts = 3;
-                            for (let i = 0; i < attempts; i++) {
-                                // 获取动态推送图片
-                                try {
-                                    // 渲染图片
-                                    const { pic: gimgPic, buffer: gimgBuffer } = await this.ctx.gi.generateDynamicImg(items[num]);
-                                    // 赋值
-                                    pic = gimgPic;
-                                    buffer = gimgBuffer;
-                                    // 成功则跳出循环
-                                    break;
-                                }
-                                catch (e) {
-                                    // 直播开播动态，不做处理
-                                    if (e.message === "直播开播动态，不做处理")
-                                        return;
-                                    if (e.message === "出现关键词，屏蔽该动态") {
-                                        // 如果需要发送才发送
-                                        if (this.config.filter.notify) {
-                                            await this.sendMsg(sub.target, `${upName}发布了一条含有屏蔽关键字的动态`);
-                                        }
-                                        return;
-                                    }
-                                    if (e.message === "已屏蔽转发动态") {
-                                        if (this.config.filter.notify) {
-                                            await this.sendMsg(sub.target, `${upName}发布了一条转发动态，已屏蔽`);
-                                        }
-                                        return;
+                            // 存储该动态ID
+                            dynamicIdStr = items[num].id_str;
+                        }
+                        // 定义变量
+                        let pic;
+                        let buffer;
+                        // 从动态数据中取出UP主名称和动态ID
+                        const upName = items[num].modules.module_author.name;
+                        const dynamicId = items[num].id_str;
+                        // 推送该条动态
+                        const attempts = 3;
+                        for (let i = 0; i < attempts; i++) {
+                            // 获取动态推送图片
+                            try {
+                                // 渲染图片
+                                const { pic: gimgPic, buffer: gimgBuffer } = await this.ctx.gi.generateDynamicImg(items[num]);
+                                // 赋值
+                                pic = gimgPic;
+                                buffer = gimgBuffer;
+                                // 成功则跳出循环
+                                break;
+                            }
+                            catch (e) {
+                                // 直播开播动态，不做处理
+                                if (e.message === "直播开播动态，不做处理")
+                                    return;
+                                if (e.message === "出现关键词，屏蔽该动态") {
+                                    // 如果需要发送才发送
+                                    if (this.config.filter.notify) {
+                                        await this.sendMsg(sub.target, `${upName}发布了一条含有屏蔽关键字的动态`);
                                     }
-                                    // 未知错误
-                                    if (i === attempts - 1) {
-                                        this.logger.error(`dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：${e.message}`);
-                                        // 发送私聊消息并重启服务
-                                        return await this.sendPrivateMsgAndStopService();
+                                    return;
+                                }
+                                if (e.message === "已屏蔽转发动态") {
+                                    if (this.config.filter.notify) {
+                                        await this.sendMsg(sub.target, `${upName}发布了一条转发动态，已屏蔽`);
                                     }
+                                    return;
+                                }
+                                // 未知错误
+                                if (i === attempts - 1) {
+                                    this.logger.error(`dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：${e.message}`);
+                                    // 发送私聊消息并重启服务
+                                    return await this.sendPrivateMsgAndStopService();
                                 }
                             }
-                            // 判断是否需要发送URL
-                            const dUrl = this.config.dynamicUrl
-                                ? `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}`
-                                : "";
-                            // 如果pic存在，则直接返回pic
-                            if (pic) {
-                                this.logger.info("推送动态中，使用render模式");
-                                // pic存在，使用的是render模式
-                                await this.sendMsg(sub.target, pic + dUrl);
-                            }
-                            else if (buffer) {
-                                this.logger.info("推送动态中，使用page模式");
-                                // pic不存在，说明使用的是page模式
-                                await this.sendMsg(sub.target, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, "image/png"), dUrl] }));
-                            }
-                            else {
-                                this.logger.info(`${items[num].modules.module_author.name}发布了一条动态，但是推送失败`);
-                            }
+                        }
+                        // 判断是否需要发送URL
+                        const dUrl = this.config.dynamicUrl
+                            ? `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}`
+                            : "";
+                        // 如果pic存在，则直接返回pic
+                        if (pic) {
+                            this.logger.info("推送动态中，使用render模式");
+                            // pic存在，使用的是render模式
+                            await this.sendMsg(sub.target, pic + dUrl);
+                        }
+                        else if (buffer) {
+                            this.logger.info("推送动态中，使用page模式");
+                            // pic不存在，说明使用的是page模式
+                            await this.sendMsg(sub.target, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, "image/png"), dUrl] }));
+                        }
+                        else {
+                            this.logger.info(`${items[num].modules.module_author.name}发布了一条动态，但是推送失败`);
                         }
                     }
                 }
             }
-            finally {
-                flag = true;
-            }
         };
+        // 返回一个闭包函数
+        return (0, utils_1.withLock)(handler);
     }
     debug_dynamicDetect() {
         // 检测初始化变量
@@ -633,205 +657,195 @@ class ComRegister {
         let updateBaseline;
         // 第一条动态的动态ID
         let dynamicIdStr;
-        // 相当于锁的作用，防止上一个循环没处理完
-        let flag = true;
-        // 返回一个闭包函数
-        return async () => {
-            // 判断上一个循环是否完成
-            if (!flag)
+        // 定义处理逻辑
+        const handler = async () => {
+            console.log(`初始化状态：${detectSetup}`);
+            // 检测启动初始化
+            if (detectSetup) {
+                // 获取动态信息
+                const data = (await this.ctx.ba.getAllDynamic());
+                // 判断获取动态信息是否成功
+                if (data.code !== 0)
+                    return;
+                console.log(`更新基线：${data.data.update_baseline}`);
+                // 设置更新基线
+                updateBaseline = data.data.update_baseline;
+                // 设置初始化为false
+                detectSetup = false;
+                // 初始化完成
                 return;
-            flag = false;
-            // 无论是否执行成功都要释放锁
+            }
+            // 获取用户所有动态数据
+            let updateNum;
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+            let content;
             try {
-                console.log(`初始化状态：${detectSetup}`);
-                // 检测启动初始化
-                if (detectSetup) {
-                    // 获取动态信息
-                    const data = (await this.ctx.ba.getAllDynamic());
-                    // 判断获取动态信息是否成功
-                    if (data.code !== 0)
-                        return;
-                    console.log(`更新基线：${data.data.update_baseline}`);
-                    // 设置更新基线
-                    updateBaseline = data.data.update_baseline;
-                    // 设置初始化为false
-                    detectSetup = false;
-                    // 初始化完成
+                // 查询是否有新动态
+                const data = await this.ctx.ba.hasNewDynamic(updateBaseline);
+                updateNum = data.data.update_num;
+                // biome-ignore lint/style/noUnusedTemplateLiteral: <explanation>
+                console.log(`获取是否有新动态：`);
+                console.log(data);
+                // 没有新动态或获取动态信息失败直接返回
+                if (updateNum <= 0 || data.code !== 0)
                     return;
-                }
-                // 获取用户所有动态数据
-                let updateNum;
-                // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-                let content;
-                try {
-                    // 查询是否有新动态
-                    const data = await this.ctx.ba.hasNewDynamic(updateBaseline);
-                    updateNum = data.data.update_num;
-                    // biome-ignore lint/style/noUnusedTemplateLiteral: <explanation>
-                    console.log(`获取是否有新动态：`);
-                    console.log(data);
-                    // 没有新动态或获取动态信息失败直接返回
-                    if (updateNum <= 0 || data.code !== 0)
-                        return;
-                    // 获取动态内容
-                    content = (await this.ctx.ba.getAllDynamic(updateBaseline));
-                    console.log("获取动态内容：");
-                    console.log(content.data.items[0]);
-                }
-                catch (e) {
-                    return this.logger.error(`dynamicDetect getUserSpaceDynamic() 发生了错误，错误为：${e.message}`);
-                }
-                // 判断获取动态内容是否成功
-                if (content.code !== 0) {
-                    switch (content.code) {
-                        case -101: {
-                            // 账号未登录
-                            // 输出日志
-                            this.logger.error("账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件");
-                            // 发送私聊消息
-                            await this.sendPrivateMsg("账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件");
-                            // 停止服务
-                            await this.ctx.sm.disposePlugin();
-                            // 结束循环
-                            break;
-                        }
-                        case -352: {
-                            // 风控
-                            // 输出日志
-                            this.logger.error("账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件");
-                            // 发送私聊消息
-                            await this.sendPrivateMsg("账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件");
-                            // 停止服务
-                            await this.ctx.sm.disposePlugin();
-                            // 结束循环
-                            break;
-                        }
-                        case 4101128:
-                        case 4101129: {
-                            // 获取动态信息错误
-                            // 输出日志
-                            this.logger.error(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`);
-                            // 发送私聊消息
-                            await this.sendPrivateMsg(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`); // 未知错误
-                            // 结束循环
-                            break;
-                        }
-                        default: {
-                            // 未知错误
-                            // 发送私聊消息
-                            await this.sendPrivateMsg(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`); // 未知错误
-                            // 结束循环
-                            break;
-                        }
+                // 获取动态内容
+                content = (await this.ctx.ba.getAllDynamic(updateBaseline));
+                console.log("获取动态内容：");
+                console.log(content.data.items[0]);
+            }
+            catch (e) {
+                return this.logger.error(`dynamicDetect getUserSpaceDynamic() 发生了错误，错误为：${e.message}`);
+            }
+            // 判断获取动态内容是否成功
+            if (content.code !== 0) {
+                switch (content.code) {
+                    case -101: {
+                        // 账号未登录
+                        // 输出日志
+                        this.logger.error("账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件");
+                        // 发送私聊消息
+                        await this.sendPrivateMsg("账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件");
+                        // 停止服务
+                        await this.ctx.sm.disposePlugin();
+                        // 结束循环
+                        break;
+                    }
+                    case -352: {
+                        // 风控
+                        // 输出日志
+                        this.logger.error("账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件");
+                        // 发送私聊消息
+                        await this.sendPrivateMsg("账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件");
+                        // 停止服务
+                        await this.ctx.sm.disposePlugin();
+                        // 结束循环
+                        break;
+                    }
+                    case 4101128:
+                    case 4101129: {
+                        // 获取动态信息错误
+                        // 输出日志
+                        this.logger.error(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`);
+                        // 发送私聊消息
+                        await this.sendPrivateMsg(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`); // 未知错误
+                        // 结束循环
+                        break;
+                    }
+                    default: {
+                        // 未知错误
+                        // 发送私聊消息
+                        await this.sendPrivateMsg(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`); // 未知错误
+                        // 结束循环
+                        break;
                     }
                 }
-                // 获取数据内容
-                const data = content.data;
-                // 更新基线
-                updateBaseline = data.update_baseline;
-                console.log(`更新基线：${updateBaseline}`);
-                // 有新动态内容
-                const items = data.items;
-                // 检查更新的动态
-                for (let num = updateNum - 1; num >= 0; num--) {
-                    // 有更新动态
-                    console.log("有更新动态");
-                    // 没有动态内容则直接跳过
-                    if (!items[num])
-                        continue;
-                    // 从动态数据中取出UP主名称、UID和动态ID
-                    const upName = content.data.items[num].modules.module_author.name;
-                    const upUID = items[num].modules.module_author.mid;
-                    const dynamicId = content.data.items[num].id_str;
-                    console.log(`寻找关注的UP主，当前动态UP主：${upName}，UID：${upUID}，动态ID：${dynamicId}`);
-                    // 寻找关注的UP主的动态
-                    for (const sub of this.subManager) {
-                        console.log(`当前订阅UP主：${sub.uid}`);
-                        // 判断是否是订阅的UP主
-                        // biome-ignore lint/suspicious/noDoubleEquals: <explanation>
-                        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;
+            }
+            // 获取数据内容
+            const data = content.data;
+            // 更新基线
+            updateBaseline = data.update_baseline;
+            console.log(`更新基线：${updateBaseline}`);
+            // 有新动态内容
+            const items = data.items;
+            // 检查更新的动态
+            for (let num = updateNum - 1; num >= 0; num--) {
+                // 有更新动态
+                console.log("有更新动态");
+                // 没有动态内容则直接跳过
+                if (!items[num])
+                    continue;
+                // 从动态数据中取出UP主名称、UID和动态ID
+                const upName = content.data.items[num].modules.module_author.name;
+                const upUID = items[num].modules.module_author.mid;
+                const dynamicId = content.data.items[num].id_str;
+                console.log(`寻找关注的UP主，当前动态UP主：${upName}，UID：${upUID}，动态ID：${dynamicId}`);
+                // 寻找关注的UP主的动态
+                for (const sub of this.subManager) {
+                    console.log(`当前订阅UP主：${sub.uid}`);
+                    // 判断是否是订阅的UP主
+                    // biome-ignore lint/suspicious/noDoubleEquals: <explanation>
+                    if (sub.dynamic && sub.uid == upUID) {
+                        // 订阅该UP主，推送该动态
+                        // 判断更新动态是否为1条
+                        if (updateNum === 1) {
+                            // 判断dynamicIdStr是否有值，是否与当前动态ID一致
+                            if (dynamicIdStr && dynamicIdStr === items[num].id_str) {
+                                // 重复动态，不再推送，直接返回
+                                return;
                             }
-                            // 定义变量
-                            let pic;
-                            let buffer;
-                            // 从动态数据中取出UP主名称和动态ID
-                            const upName = items[num].modules.module_author.name;
-                            const dynamicId = items[num].id_str;
-                            console.log(`UP主名称：${upName}，动态ID：${dynamicId}`);
-                            // 推送该条动态
-                            const attempts = 3;
-                            for (let i = 0; i < attempts; i++) {
-                                // 获取动态推送图片
-                                try {
-                                    // 渲染图片
-                                    const { pic: gimgPic, buffer: gimgBuffer } = await this.ctx.gi.generateDynamicImg(items[num]);
-                                    // 赋值
-                                    pic = gimgPic;
-                                    buffer = gimgBuffer;
-                                    // 成功则跳出循环
-                                    break;
-                                }
-                                catch (e) {
-                                    // 直播开播动态，不做处理
-                                    if (e.message === "直播开播动态，不做处理")
-                                        return;
-                                    if (e.message === "出现关键词，屏蔽该动态") {
-                                        // 如果需要发送才发送
-                                        if (this.config.filter.notify) {
-                                            await this.sendMsg(sub.target, `${upName}发布了一条含有屏蔽关键字的动态`);
-                                        }
-                                        return;
-                                    }
-                                    if (e.message === "已屏蔽转发动态") {
-                                        if (this.config.filter.notify) {
-                                            await this.sendMsg(sub.target, `${upName}发布了一条转发动态，已屏蔽`);
-                                        }
-                                        return;
+                            // 存储该动态ID
+                            dynamicIdStr = items[num].id_str;
+                        }
+                        // 定义变量
+                        let pic;
+                        let buffer;
+                        // 从动态数据中取出UP主名称和动态ID
+                        const upName = items[num].modules.module_author.name;
+                        const dynamicId = items[num].id_str;
+                        console.log(`UP主名称：${upName}，动态ID：${dynamicId}`);
+                        // 推送该条动态
+                        const attempts = 3;
+                        for (let i = 0; i < attempts; i++) {
+                            // 获取动态推送图片
+                            try {
+                                // 渲染图片
+                                const { pic: gimgPic, buffer: gimgBuffer } = await this.ctx.gi.generateDynamicImg(items[num]);
+                                // 赋值
+                                pic = gimgPic;
+                                buffer = gimgBuffer;
+                                // 成功则跳出循环
+                                break;
+                            }
+                            catch (e) {
+                                // 直播开播动态，不做处理
+                                if (e.message === "直播开播动态，不做处理")
+                                    return;
+                                if (e.message === "出现关键词，屏蔽该动态") {
+                                    // 如果需要发送才发送
+                                    if (this.config.filter.notify) {
+                                        await this.sendMsg(sub.target, `${upName}发布了一条含有屏蔽关键字的动态`);
                                     }
-                                    // 未知错误
-                                    if (i === attempts - 1) {
-                                        this.logger.error(`dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：${e.message}`);
-                                        // 发送私聊消息并重启服务
-                                        return await this.sendPrivateMsgAndStopService();
+                                    return;
+                                }
+                                if (e.message === "已屏蔽转发动态") {
+                                    if (this.config.filter.notify) {
+                                        await this.sendMsg(sub.target, `${upName}发布了一条转发动态，已屏蔽`);
                                     }
+                                    return;
+                                }
+                                // 未知错误
+                                if (i === attempts - 1) {
+                                    this.logger.error(`dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：${e.message}`);
+                                    // 发送私聊消息并重启服务
+                                    return await this.sendPrivateMsgAndStopService();
                                 }
                             }
-                            // 判断是否需要发送URL
-                            const dUrl = this.config.dynamicUrl
-                                ? `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}`
-                                : "";
-                            // 如果pic存在，则直接返回pic
-                            if (pic) {
-                                this.logger.info("推送动态中，使用render模式");
-                                // pic存在，使用的是render模式
-                                await this.sendMsg(sub.target, pic + dUrl);
-                            }
-                            else if (buffer) {
-                                this.logger.info("推送动态中，使用page模式");
-                                // pic不存在，说明使用的是page模式
-                                await this.sendMsg(sub.target, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, "image/png"), dUrl] }));
-                            }
-                            else {
-                                this.logger.info(`${items[num].modules.module_author.name}发布了一条动态，但是推送失败`);
-                            }
+                        }
+                        // 判断是否需要发送URL
+                        const dUrl = this.config.dynamicUrl
+                            ? `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}`
+                            : "";
+                        // 如果pic存在，则直接返回pic
+                        if (pic) {
+                            this.logger.info("推送动态中，使用render模式");
+                            // pic存在，使用的是render模式
+                            await this.sendMsg(sub.target, pic + dUrl);
+                        }
+                        else if (buffer) {
+                            this.logger.info("推送动态中，使用page模式");
+                            // pic不存在，说明使用的是page模式
+                            await this.sendMsg(sub.target, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, "image/png"), dUrl] }));
+                        }
+                        else {
+                            this.logger.info(`${items[num].modules.module_author.name}发布了一条动态，但是推送失败`);
                         }
                     }
                 }
             }
-            finally {
-                flag = true;
-            }
         };
+        // 加工handler并返回
+        return (0, utils_1.withLock)(handler);
     }
     // 定义发送直播通知卡片方法
     async sendLiveNotifyCard(info, liveType, followerDisplay, liveNotifyMsg) {
@@ -1372,6 +1386,7 @@ class ComRegister {
             this.subManager.push({
                 id: +sub.uid,
                 uid: sub.uid,
+                uname: data.name,
                 roomId: sub.live ? data.live_room.roomid : "",
                 target: sub.target,
                 platform: "",

package/lib/generateImg.d.ts

@@ -41,6 +41,8 @@ declare namespace GenerateImg {
         removeBorder: boolean;
         cardColorStart: string;
         cardColorEnd: string;
+        cardBasePlateColor: string;
+        cardBasePlateBorder: string;
         enableLargeFont: boolean;
         font: string;
         hideDesc: boolean;

package/lib/generateImg.js

@@ -70,9 +70,9 @@ class GenerateImg extends koishi_1.Service {
                         width: 100%;
                         height: auto;
                         box-shadow: 0 4px 8px 0 rgba(0, 0, 0, 0.2);
-                        padding: 15px;
+                        padding: ${this.giConfig.cardBasePlateBorder};
                         border-radius: 10px;
-                        background-color: #FFF5EE;
+                        background-color: ${this.giConfig.cardBasePlateColor};
                     }
         
                     .card {
@@ -575,7 +575,7 @@ class GenerateImg extends koishi_1.Service {
         // 判断是否开启大字体模式
         let style;
         if (this.giConfig.enableLargeFont) {
-            style = `
+            style = /* css */ `
             @font-face {
                 font-family: "Custom Font";
                 src: url(${fontURL});
@@ -605,9 +605,9 @@ class GenerateImg extends koishi_1.Service {
                 width: 100%;
                 height: auto;
                 box-shadow: 0 4px 8px 0 rgba(0, 0, 0, 0.2);
-                padding: 15px;
+                padding: ${this.giConfig.cardBasePlateBorder};
                 border-radius: 10px;
-                background-color: #FFF5EE;
+                background-color: ${this.giConfig.cardBasePlateColor};
             }
 
             .card {
@@ -940,7 +940,7 @@ class GenerateImg extends koishi_1.Service {
             `;
         }
         else {
-            style = `
+            style = /* css */ `
             @font-face {
                 font-family: "Custom Font";
                 src: url(${fontURL});
@@ -970,9 +970,9 @@ class GenerateImg extends koishi_1.Service {
                 width: 100%;
                 height: auto;
                 box-shadow: 0 4px 8px 0 rgba(0, 0, 0, 0.2);
-                padding: 15px;
+                padding: ${this.giConfig.cardBasePlateBorder};
                 border-radius: 10px;
-                background-color: #FFF5EE;
+                background-color: ${this.giConfig.cardBasePlateColor};
             }
     
             .card {
@@ -1521,6 +1521,8 @@ class GenerateImg extends koishi_1.Service {
         removeBorder: koishi_1.Schema.boolean(),
         cardColorStart: koishi_1.Schema.string(),
         cardColorEnd: koishi_1.Schema.string(),
+        cardBasePlateColor: koishi_1.Schema.string(),
+        cardBasePlateBorder: koishi_1.Schema.string(),
         enableLargeFont: koishi_1.Schema.boolean(),
         font: koishi_1.Schema.string(),
         hideDesc: koishi_1.Schema.boolean(),

package/lib/index.d.ts

@@ -10,6 +10,18 @@ declare class ServerManager extends Service {
     servers: ForkScope[];
     renderType: number;
     dynamicLoopTime: number;
+    renderTypePatternMatching: {
+        render: number;
+        page: number;
+    };
+    dynamicLoopTimePatternMatching: {
+        "1\u5206\u949F": number;
+        "2\u5206\u949F": number;
+        "3\u5206\u949F": number;
+        "5\u5206\u949F": number;
+        "10\u5206\u949F": number;
+        "20\u5206\u949F": number;
+    };
     constructor(ctx: Context);
     protected start(): void | Promise<void>;
     registerPlugin: () => boolean;
@@ -57,6 +69,8 @@ export interface Config {
     removeBorder: boolean;
     cardColorStart: string;
     cardColorEnd: string;
+    cardBasePlateColor: string;
+    cardBasePlateBorder: string;
     enableLargeFont: boolean;
     font: string;
     filter: {};

package/lib/index.js

@@ -56,6 +56,20 @@ class ServerManager extends koishi_1.Service {
     renderType;
     // 动态循环时间
     dynamicLoopTime;
+    // 定义渲染类型模式匹配
+    renderTypePatternMatching = {
+        render: 0,
+        page: 1,
+    };
+    // 定义具体时间模式匹配
+    dynamicLoopTimePatternMatching = {
+        "1分钟": 60,
+        "2分钟": 120,
+        "3分钟": 180,
+        "5分钟": 300,
+        "10分钟": 600,
+        "20分钟": 1200,
+    };
     constructor(ctx) {
         super(ctx, "sm");
         // 插件运行相关指令
@@ -99,35 +113,10 @@ class ServerManager extends koishi_1.Service {
     start() {
         // 加载配置
         // 根据用户设置的渲染模式设置
-        switch (globalConfig.renderType) {
-            case "render":
-                this.renderType = 0;
-                break;
-            case "page":
-                this.renderType = 1;
-                break;
-        }
+        this.renderType = this.renderTypePatternMatching[globalConfig.renderType];
         // 转换为具体时间
-        switch (globalConfig.dynamicLoopTime) {
-            case "1分钟":
-                this.dynamicLoopTime = 60;
-                break;
-            case "2分钟":
-                this.dynamicLoopTime = 120;
-                break;
-            case "3分钟":
-                this.dynamicLoopTime = 180;
-                break;
-            case "5分钟":
-                this.dynamicLoopTime = 300;
-                break;
-            case "10分钟":
-                this.dynamicLoopTime = 600;
-                break;
-            case "20分钟":
-                this.dynamicLoopTime = 1200;
-                break;
-        }
+        this.dynamicLoopTime =
+            this.dynamicLoopTimePatternMatching[globalConfig.dynamicLoopTime];
         // 注册插件
         if (!this.registerPlugin()) {
             this.logger.error("插件启动失败");
@@ -151,6 +140,8 @@ class ServerManager extends koishi_1.Service {
                 removeBorder: globalConfig.removeBorder,
                 cardColorStart: globalConfig.cardColorStart,
                 cardColorEnd: globalConfig.cardColorEnd,
+                cardBasePlateColor: globalConfig.cardBasePlateColor,
+                cardBasePlateBorder: globalConfig.cardBasePlateBorder,
                 hideDesc: globalConfig.hideDesc,
                 enableLargeFont: globalConfig.enableLargeFont,
                 font: globalConfig.font,
@@ -387,6 +378,14 @@ exports.Config = koishi_1.Schema.object({
         .pattern(/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/)
         .default("#F9CCDF")
         .description("推送卡片的结束渐变背景色，请填入16进制颜色代码，参考网站：https://colorate.azurewebsites.net/"),
+    cardBasePlateColor: koishi_1.Schema.string()
+        .pattern(/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/)
+        .default("#FFF5EE")
+        .description("推送卡片底板颜色，请填入16进制颜色代码"),
+    cardBasePlateBorder: koishi_1.Schema.string()
+        .pattern(/\d*\.?\d+(?:px|em|rem|%|vh|vw|vmin|vmax)/)
+        .default("15px")
+        .description("推送卡片底板边框宽度，请填入css单位，例如1px，12.5rem，100%"),
     enableLargeFont: koishi_1.Schema.boolean()
         .default(false)
         .description("是否开启动态推送卡片大字体模式，默认为小字体。小字体更漂亮，但阅读比较吃力，大字体更易阅读，但相对没这么好看"),

package/lib/type/index.d.ts

@@ -20,6 +20,7 @@ export type Target = Array<TargetItem>;
 export type SubItem = {
     id: number;
     uid: string;
+    uname: string;
     roomId: string;
     target: Target;
     platform: string;
@@ -35,3 +36,17 @@ export type MasterInfo = {
     liveEndFollowerNum: number;
     liveFollowerChange: number;
 };
+export type LiveUsersItem = {
+    face: string;
+    is_reserve_recall: boolean;
+    jump_url: string;
+    mid: number;
+    room_id: number;
+    title: string;
+    uname: string;
+};
+export type LiveUsers = {
+    count: number;
+    group: string;
+    items: Array<LiveUsersItem>;
+};

package/package.json

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

package/readme.md

@@ -59,6 +59,10 @@
 
 - 使用指令 `bili list`
 
+查看目前订阅直播的UP主们的直播情况：
+
+- 使用指令 `bili ll`
+
 插件的启动、停止和重启
 
 - 使用指令 `sys`
@@ -202,6 +206,8 @@
 - ver 3.0.0-alpha.20 优化：订阅配置中开关选项默认为关闭
 - ver 3.0.0-alpha.21 优化：部分代码； 新增：更新插件后，由于机器人还未启动，已开始发送消息报错 `this._request is not a function` ，新增报错后自动重新发送消息的功能
 - ver 3.0.0-alpha.22 优化：订阅配置展示优化
+- ver 3.0.0-alpha.23 新增：指令 `bili ll` 可以查看当前订阅直播的UP主们的开播情况
+- ver 3.0.0-alpha.24 新增：配置项，`cardBasePlateColor` 和 `cardBasePlateBorder`，分别设置卡片底板颜色和底板边框宽度； 优化：部分代码结构
 
 ## 交流群