koishi-plugin-bilibili-notify 1.3.5 → 1.3.6-beta.0

package/lib/biliAPI.js

@@ -3,8 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
 /* eslint-disable @typescript-eslint/no-namespace */
-/* eslint-disable @typescript-eslint/ban-types */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 const koishi_1 = require("koishi");
 const axios_1 = __importDefault(require("axios"));
@@ -154,7 +155,8 @@ class BiliAPI extends koishi_1.Service {
             throw new Error('网络异常，本次请求失败！');
         }
     }
-    disposeNotifier() { this.loginNotifier && this.loginNotifier.dispose(); }
+    disposeNotifier() { if (this.loginNotifier)
+        this.loginNotifier.dispose(); }
     getRandomUserAgent() {
         const userAgents = [
             'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36',
@@ -271,7 +273,8 @@ class BiliAPI extends koishi_1.Service {
     }
     enableRefreshCookiesDetect() {
         // 判断之前是否启动检测
-        this.refreshCookieTimer && this.refreshCookieTimer();
+        if (this.refreshCookieTimer)
+            this.refreshCookieTimer();
         // Open scheduled tasks and check if token need refresh
         this.refreshCookieTimer = this.ctx.setInterval(async () => {
             // 从数据库获取登录信息

package/lib/comRegister.d.ts

@@ -6,6 +6,7 @@ declare class ComRegister {
     config: ComRegister.Config;
     loginTimer: Function;
     num: number;
+    rebootCount: number;
     subNotifier: Notifier;
     subManager: {
         id: number;
@@ -30,7 +31,8 @@ declare class ComRegister {
     constructor(ctx: Context, config: ComRegister.Config);
     getTheCorrespondingBotBasedOnTheSession(session: Session): Bot<Context, any>;
     sendPrivateMsg(bot: Bot<Context>, content: string): Promise<void>;
-    sendPrivateMsgAndRebootService(ctx: Context, bot: Bot<Context>, content: string): Promise<void>;
+    sendPrivateMsgAndRebootService(ctx: Context, bot: Bot<Context>): Promise<void>;
+    sendPrivateMsgAndStopService(ctx: Context, bot: Bot<Context>): Promise<void>;
     sendMsg(targets: Array<string>, bot: Bot<Context>, content: any): Promise<void>;
     dynamicDetect(ctx: Context, bot: Bot<Context>, uid: string, guildId: Array<string>): () => Promise<void>;
     debug_dynamicDetect(ctx: Context, bot: Bot<Context>, uid: string, guildId: Array<string>): () => Promise<void>;

package/lib/comRegister.js

@@ -4,13 +4,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const jsx_runtime_1 = require("@satorijs/element/jsx-runtime");
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
 /* eslint-disable @typescript-eslint/no-namespace */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/ban-types */
 const koishi_1 = require("koishi");
 // 导入qrcode
 const qrcode_1 = __importDefault(require("qrcode"));
-const jimp_1 = __importDefault(require("jimp"));
+const jimp_1 = require("jimp");
 var LiveType;
 (function (LiveType) {
     LiveType[LiveType["NotLiveBroadcast"] = 0] = "NotLiveBroadcast";
@@ -23,6 +24,7 @@ class ComRegister {
     config;
     loginTimer;
     num = 0;
+    rebootCount = 0;
     subNotifier;
     subManager = [];
     // QQ群机器人
@@ -260,7 +262,8 @@ class ComRegister {
                 await session.send(koishi_1.h.image(buffer, 'image/png'));
             });
             // 检查之前是否存在登录定时器
-            this.loginTimer && this.loginTimer();
+            if (this.loginTimer)
+                this.loginTimer();
             // 设置flag
             let flag = true;
             // 发起登录请求检查登录状态
@@ -363,7 +366,8 @@ class ComRegister {
                 }
             }));
             // 未订阅该用户，无需取消订阅
-            !exist && session.send('未订阅该用户，无需取消订阅');
+            if (!exist)
+                session.send('未订阅该用户，无需取消订阅');
         });
         biliCom
             .subcommand('.show', '展示订阅对象')
@@ -707,7 +711,7 @@ class ComRegister {
                 // 获得对应bot
                 const bot = this.getTheCorrespondingBotBasedOnTheSession(session)
                 // 发送提示消息，重启服务
-                await this.sendPrivateMsgAndRebootService(ctx, bot, '测试biliAPI等服务自动重启功能')
+                await this.sendPrivateMsgAndStopService(ctx, bot, '测试biliAPI等服务自动重启功能')
             }) */
         /* biliCom
             .subcommand('.sendall', '测试给机器人加入的所有群发送消息', { hidden: true })
@@ -780,23 +784,47 @@ class ComRegister {
             }
         }
     }
-    async sendPrivateMsgAndRebootService(ctx, bot, content) {
-        await this.sendPrivateMsg(bot, content);
+    async sendPrivateMsgAndRebootService(ctx, bot) {
+        // 判断重启次数是否超过三次
+        if (this.rebootCount >= 3) {
+            // logger
+            this.logger.error('已重启插件三次，请检查机器人状态后使用指令 sys start 启动插件');
+            // 重启失败，发送消息
+            await this.sendPrivateMsg(bot, '已重启插件三次，请检查机器人状态后使用指令 sys start 启动插件');
+            // 关闭插件
+            await ctx.sm.disposePlugin();
+            // 结束
+            return;
+        }
+        // 重启次数+1
+        this.rebootCount++;
+        // logger
+        this.logger.info('插件出现未知错误，正在重启插件');
         // 重启插件
-        const flag = await ctx.sm.restartPlugin(true /* 非人为重启，需要计数 */);
+        const flag = await ctx.sm.restartPlugin();
         // 判断是否重启成功
         if (flag) {
             this.logger.info('重启插件成功');
         }
         else {
             // logger
-            this.logger.error('已重启插件三次，请检查机器人状态后手动重启');
+            this.logger.error('重启插件失败，请检查机器人状态后使用指令 sys start 启动插件');
             // 重启失败，发送消息
-            await this.sendPrivateMsg(bot, '已重启插件三次，请检查机器人状态后手动重启');
+            await this.sendPrivateMsg(bot, '重启插件失败，请检查机器人状态后使用指令 sys start 启动插件');
             // 关闭插件
             await ctx.sm.disposePlugin();
         }
     }
+    async sendPrivateMsgAndStopService(ctx, bot) {
+        // 发送消息
+        await this.sendPrivateMsg(bot, '插件发生未知错误，请检查机器人状态后使用指令 sys start 启动插件');
+        // logger
+        this.logger.error('插件发生未知错误，请检查机器人状态后使用指令 sys start 启动插件');
+        // 关闭插件
+        await ctx.sm.disposePlugin();
+        // 结束
+        return;
+    }
     async sendMsg(targets, bot, content) {
         // 定义需要发送的数组
         let sendArr = [];
@@ -818,299 +846,331 @@ class ComRegister {
     dynamicDetect(ctx, bot, uid, guildId) {
         let firstSubscription = true;
         let timePoint;
+        // 相当于锁的作用，防止上一个循环没处理完
+        let flag = true;
         return async () => {
-            // 第一次订阅判断
-            if (firstSubscription) {
-                // 设置第一次的时间点
-                timePoint = ctx.ba.getTimeOfUTC8();
-                // 设置第一次为false
-                firstSubscription = false;
+            // 判断上一个循环是否完成
+            if (!flag)
                 return;
-            }
-            // 获取用户空间动态数据
-            let content;
+            flag = false;
+            // 无论是否执行成功都要释放锁
             try {
-                content = await ctx.ba.getUserSpaceDynamic(uid);
-            }
-            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(bot, '账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件');
-                        // 停止服务
-                        await ctx.sm.disposePlugin();
-                        // 结束循环
-                        break;
-                    }
-                    case -352: { // 风控
-                        // 输出日志
-                        this.logger.error('账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件');
-                        // 发送私聊消息
-                        await this.sendPrivateMsg(bot, '账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件');
-                        // 停止服务
-                        await ctx.sm.disposePlugin();
-                        // 结束循环
-                        break;
-                    }
-                    case 4101128:
-                    case 4101129: { // 获取动态信息错误
-                        // 输出日志
-                        this.logger.error('获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message);
-                        // 发送私聊消息
-                        await this.sendPrivateMsg(bot, '获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
-                        // 结束循环
-                        break;
-                    }
-                    default: { // 未知错误
-                        // 发送私聊消息
-                        await this.sendPrivateMsg(bot, '获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
-                        // 取消订阅
-                        this.unsubAll(ctx, bot, uid);
-                        // 结束循环
-                        break;
-                    }
+                // 第一次订阅判断
+                if (firstSubscription) {
+                    // 设置第一次的时间点
+                    timePoint = ctx.ba.getTimeOfUTC8();
+                    // 设置第一次为false
+                    firstSubscription = false;
+                    return;
                 }
-            }
-            // 获取数据内容
-            const items = content.data.items;
-            // 定义方法：更新时间点为最新发布动态的发布时间
-            const updatePoint = (num) => {
-                switch (num) {
-                    case 1: {
-                        if (items[0].modules.module_tag) { // 存在置顶动态
-                            timePoint = items[num].modules.module_author.pub_ts;
+                // 获取用户空间动态数据
+                let content;
+                try {
+                    content = await ctx.ba.getUserSpaceDynamic(uid);
+                }
+                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(bot, '账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件');
+                            // 停止服务
+                            await ctx.sm.disposePlugin();
+                            // 结束循环
+                            break;
+                        }
+                        case -352: { // 风控
+                            // 输出日志
+                            this.logger.error('账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件');
+                            // 发送私聊消息
+                            await this.sendPrivateMsg(bot, '账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件');
+                            // 停止服务
+                            await ctx.sm.disposePlugin();
+                            // 结束循环
+                            break;
+                        }
+                        case 4101128:
+                        case 4101129: { // 获取动态信息错误
+                            // 输出日志
+                            this.logger.error('获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message);
+                            // 发送私聊消息
+                            await this.sendPrivateMsg(bot, '获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
+                            // 结束循环
+                            break;
+                        }
+                        default: { // 未知错误
+                            // 发送私聊消息
+                            await this.sendPrivateMsg(bot, '获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
+                            // 取消订阅
+                            this.unsubAll(ctx, bot, uid);
+                            // 结束循环
+                            break;
                         }
-                        break;
                     }
-                    case 0: timePoint = items[num].modules.module_author.pub_ts;
                 }
-            };
-            // 发送请求 默认只查看配置文件规定数量的数据
-            for (let num = this.config.dynamicCheckNumber - 1; num >= 0; num--) {
-                // 没有动态内容则直接跳过
-                if (!items[num])
-                    continue;
-                // 寻找发布时间比时间点更晚的动态
-                if (items[num].modules.module_author.pub_ts > timePoint) {
-                    // 定义变量
-                    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 attempts = 3;
-                    for (let i = 0; i < attempts; i++) {
-                        // 获取动态推送图片
-                        try {
-                            // 渲染图片
-                            const { pic: gimgPic, buffer: gimgBuffer } = await ctx.gi.generateDynamicImg(items[num]);
-                            // 赋值
-                            pic = gimgPic;
-                            buffer = gimgBuffer;
-                            // 成功则跳出循环
+                // 获取数据内容
+                const items = content.data.items;
+                // 定义方法：更新时间点为最新发布动态的发布时间
+                const updatePoint = (num) => {
+                    switch (num) {
+                        case 1: {
+                            if (items[0].modules.module_tag) { // 存在置顶动态
+                                timePoint = items[num].modules.module_author.pub_ts;
+                            }
                             break;
                         }
-                        catch (e) {
-                            // 直播开播动态，不做处理
-                            if (e.message === '直播开播动态，不做处理')
-                                return updatePoint(num);
-                            if (e.message === '出现关键词，屏蔽该动态') {
-                                // 如果需要发送才发送
-                                this.config.filter.notify && await this.sendMsg(guildId, bot, `${upName}发布了一条含有屏蔽关键字的动态`);
-                                return updatePoint(num);
-                            }
-                            if (e.message === '已屏蔽转发动态') {
-                                this.config.filter.notify && await this.sendMsg(guildId, bot, `${upName}发布了一条转发动态，已屏蔽`);
-                                return updatePoint(num);
+                        case 0: timePoint = items[num].modules.module_author.pub_ts;
+                    }
+                };
+                // 发送请求 默认只查看配置文件规定数量的数据
+                for (let num = this.config.dynamicCheckNumber - 1; num >= 0; num--) {
+                    // 没有动态内容则直接跳过
+                    if (!items[num])
+                        continue;
+                    // 寻找发布时间比时间点更晚的动态
+                    if (items[num].modules.module_author.pub_ts > timePoint) {
+                        // 定义变量
+                        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 attempts = 3;
+                        for (let i = 0; i < attempts; i++) {
+                            // 获取动态推送图片
+                            try {
+                                // 渲染图片
+                                const { pic: gimgPic, buffer: gimgBuffer } = await ctx.gi.generateDynamicImg(items[num]);
+                                // 赋值
+                                pic = gimgPic;
+                                buffer = gimgBuffer;
+                                // 成功则跳出循环
+                                break;
                             }
-                            // 未知错误
-                            if (i === attempts - 1) {
-                                this.logger.error('dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：' + e.message);
-                                // 发送私聊消息并重启服务
-                                return await this.sendPrivateMsgAndRebootService(ctx, bot, '插件可能出现某些未知错误，请尝试重启插件，如果仍然发生该错误，请带着日志向作者反馈');
+                            catch (e) {
+                                // 直播开播动态，不做处理
+                                if (e.message === '直播开播动态，不做处理')
+                                    return updatePoint(num);
+                                if (e.message === '出现关键词，屏蔽该动态') {
+                                    // 如果需要发送才发送
+                                    if (this.config.filter.notify) {
+                                        await this.sendMsg(guildId, bot, `${upName}发布了一条含有屏蔽关键字的动态`);
+                                    }
+                                    return updatePoint(num);
+                                }
+                                if (e.message === '已屏蔽转发动态') {
+                                    if (this.config.filter.notify) {
+                                        await this.sendMsg(guildId, bot, `${upName}发布了一条转发动态，已屏蔽`);
+                                    }
+                                    return updatePoint(num);
+                                }
+                                // 未知错误
+                                if (i === attempts - 1) {
+                                    this.logger.error('dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：' + e.message);
+                                    // 发送私聊消息并重启服务
+                                    return await this.sendPrivateMsgAndStopService(ctx, bot);
+                                }
                             }
                         }
+                        // 判断是否需要发送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(guildId, bot, pic + (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: dUrl }));
+                        }
+                        else if (buffer) {
+                            this.logger.info('推送动态中，使用page模式');
+                            // pic不存在，说明使用的是page模式
+                            await this.sendMsg(guildId, bot, (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 + '发布了一条动态，但是推送失败');
+                        }
+                        // 更新时间点
+                        updatePoint(num);
                     }
-                    // 判断是否需要发送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(guildId, bot, pic + (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: dUrl }));
-                    }
-                    else if (buffer) {
-                        this.logger.info('推送动态中，使用page模式');
-                        // pic不存在，说明使用的是page模式
-                        await this.sendMsg(guildId, bot, (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 + '发布了一条动态，但是推送失败');
-                    }
-                    // 更新时间点
-                    updatePoint(num);
                 }
             }
+            finally {
+                flag = true;
+            }
         };
     }
     debug_dynamicDetect(ctx, bot, uid, guildId) {
         let firstSubscription = true;
         let timePoint;
+        // 相当于锁的作用，防止上一个循环没处理完
+        let flag = true;
         return async () => {
-            // 第一次订阅判断
-            if (firstSubscription) {
-                this.logger.info(`UID：${uid}-动态监测开始`);
-                // 设置第一次的时间点
-                timePoint = ctx.ba.getTimeOfUTC8();
-                // 设置第一次为false
-                firstSubscription = false;
+            // 判断上一个循环是否完成
+            if (!flag)
                 return;
-            }
-            this.logger.info(`UID：${uid}-获取动态信息中`);
-            // 获取用户空间动态数据
-            let content;
+            flag = false;
+            // 无论是否执行成功都要释放锁
             try {
-                content = await ctx.ba.getUserSpaceDynamic(uid);
-            }
-            catch (e) {
-                return this.logger.error(`UID：${uid}-dynamicDetect getUserSpaceDynamic() 发生了错误，错误为：${e.message}`);
-            }
-            this.logger.info(`UID：${uid}-判断动态信息是否正确`);
-            // 判断是否出现其他问题
-            if (content.code !== 0) {
-                switch (content.code) {
-                    case -101: { // 账号未登录
-                        // 输出日志
-                        this.logger.error('账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件');
-                        // 发送私聊消息
-                        await this.sendPrivateMsg(bot, '账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件');
-                        // 停止服务
-                        await ctx.sm.disposePlugin();
-                        // 结束循环
-                        break;
-                    }
-                    case -352: { // 风控
-                        // 输出日志
-                        this.logger.error('账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件');
-                        // 发送私聊消息
-                        await this.sendPrivateMsg(bot, '账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件');
-                        // 停止服务
-                        await ctx.sm.disposePlugin();
-                        // 结束循环
-                        break;
-                    }
-                    case 4101128:
-                    case 4101129: { // 获取动态信息错误
-                        // 输出日志
-                        this.logger.error('获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message);
-                        // 发送私聊消息
-                        await this.sendPrivateMsg(bot, '获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
-                        // 结束循环
-                        break;
-                    }
-                    default: { // 未知错误
-                        // 发送私聊消息
-                        await this.sendPrivateMsg(bot, '获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
-                        // 取消订阅
-                        this.unsubAll(ctx, bot, uid);
-                        // 结束循环
-                        break;
-                    }
+                // 第一次订阅判断
+                if (firstSubscription) {
+                    this.logger.info(`UID：${uid}-动态监测开始`);
+                    // 设置第一次的时间点
+                    timePoint = ctx.ba.getTimeOfUTC8();
+                    // 设置第一次为false
+                    firstSubscription = false;
+                    return;
                 }
-            }
-            // 获取数据内容
-            const items = content.data.items;
-            this.logger.info(`UID：${uid}-获取到的动态信息：${items.map(v => v.basic.rid_str).join('、')}`);
-            // 定义方法：更新时间点为最新发布动态的发布时间
-            const updatePoint = (num) => {
-                switch (num) {
-                    case 1: {
-                        if (items[0].modules.module_tag) { // 存在置顶动态
-                            timePoint = items[num].modules.module_author.pub_ts;
+                this.logger.info(`UID：${uid}-获取动态信息中`);
+                // 获取用户空间动态数据
+                let content;
+                try {
+                    content = await ctx.ba.getUserSpaceDynamic(uid);
+                }
+                catch (e) {
+                    return this.logger.error(`UID：${uid}-dynamicDetect getUserSpaceDynamic() 发生了错误，错误为：${e.message}`);
+                }
+                this.logger.info(`UID：${uid}-判断动态信息是否正确`);
+                // 判断是否出现其他问题
+                if (content.code !== 0) {
+                    switch (content.code) {
+                        case -101: { // 账号未登录
+                            // 输出日志
+                            this.logger.error('账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件');
+                            // 发送私聊消息
+                            await this.sendPrivateMsg(bot, '账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件');
+                            // 停止服务
+                            await ctx.sm.disposePlugin();
+                            // 结束循环
+                            break;
+                        }
+                        case -352: { // 风控
+                            // 输出日志
+                            this.logger.error('账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件');
+                            // 发送私聊消息
+                            await this.sendPrivateMsg(bot, '账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件');
+                            // 停止服务
+                            await ctx.sm.disposePlugin();
+                            // 结束循环
+                            break;
+                        }
+                        case 4101128:
+                        case 4101129: { // 获取动态信息错误
+                            // 输出日志
+                            this.logger.error('获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message);
+                            // 发送私聊消息
+                            await this.sendPrivateMsg(bot, '获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
+                            // 结束循环
+                            break;
+                        }
+                        default: { // 未知错误
+                            // 发送私聊消息
+                            await this.sendPrivateMsg(bot, '获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
+                            // 取消订阅
+                            this.unsubAll(ctx, bot, uid);
+                            // 结束循环
+                            break;
                         }
-                        break;
                     }
-                    case 0: timePoint = items[num].modules.module_author.pub_ts;
                 }
-            };
-            // 发送请求 默认只查看配置文件规定数量的数据
-            for (let num = this.config.dynamicCheckNumber - 1; num >= 0; num--) {
-                // 没有动态内容则直接跳过
-                if (!items[num])
-                    continue;
-                // 寻找发布时间比时间点更晚的动态
-                if (items[num].modules.module_author.pub_ts > timePoint) {
-                    this.logger.info(`UID：${uid}-即将推送的动态：${items[num].basic.rid_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 attempts = 3;
-                    this.logger.info(`UID：${uid}-尝试渲染推送图片`);
-                    for (let i = 0; i < attempts; i++) {
-                        // 获取动态推送图片
-                        try {
-                            // 渲染图片
-                            const { pic: gimgPic, buffer: gimgBuffer } = await ctx.gi.generateDynamicImg(items[num]);
-                            // 赋值
-                            pic = gimgPic;
-                            buffer = gimgBuffer;
-                            // 成功则跳出循环
+                // 获取数据内容
+                const items = content.data.items;
+                this.logger.info(`UID：${uid}-获取到的动态信息：${items.map(v => v.basic.rid_str).join('、')}`);
+                // 定义方法：更新时间点为最新发布动态的发布时间
+                const updatePoint = (num) => {
+                    switch (num) {
+                        case 1: {
+                            if (items[0].modules.module_tag) { // 存在置顶动态
+                                timePoint = items[num].modules.module_author.pub_ts;
+                            }
                             break;
                         }
-                        catch (e) {
-                            // 直播开播动态，不做处理
-                            if (e.message === '直播开播动态，不做处理')
-                                return updatePoint(num);
-                            if (e.message === '出现关键词，屏蔽该动态') {
-                                // 如果需要发送才发送
-                                this.config.filter.notify && await this.sendMsg(guildId, bot, `${upName}发布了一条含有屏蔽关键字的动态`);
-                                return updatePoint(num);
-                            }
-                            if (e.message === '已屏蔽转发动态') {
-                                this.config.filter.notify && await this.sendMsg(guildId, bot, `${upName}发布了一条转发动态，已屏蔽`);
-                                return updatePoint(num);
+                        case 0: timePoint = items[num].modules.module_author.pub_ts;
+                    }
+                };
+                // 发送请求 默认只查看配置文件规定数量的数据
+                for (let num = this.config.dynamicCheckNumber - 1; num >= 0; num--) {
+                    // 没有动态内容则直接跳过
+                    if (!items[num])
+                        continue;
+                    // 寻找发布时间比时间点更晚的动态
+                    if (items[num].modules.module_author.pub_ts > timePoint) {
+                        this.logger.info(`UID：${uid}-即将推送的动态：${items[num].basic.rid_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 attempts = 3;
+                        this.logger.info(`UID：${uid}-尝试渲染推送图片`);
+                        for (let i = 0; i < attempts; i++) {
+                            // 获取动态推送图片
+                            try {
+                                // 渲染图片
+                                const { pic: gimgPic, buffer: gimgBuffer } = await ctx.gi.generateDynamicImg(items[num]);
+                                // 赋值
+                                pic = gimgPic;
+                                buffer = gimgBuffer;
+                                // 成功则跳出循环
+                                break;
                             }
-                            // 未知错误
-                            if (i === attempts - 1) {
-                                this.logger.error('dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：' + e.message);
-                                // 发送私聊消息并重启服务
-                                return await this.sendPrivateMsgAndRebootService(ctx, bot, '插件可能出现某些未知错误，请尝试重启插件，如果仍然发生该错误，请带着日志向作者反馈');
+                            catch (e) {
+                                // 直播开播动态，不做处理
+                                if (e.message === '直播开播动态，不做处理')
+                                    return updatePoint(num);
+                                if (e.message === '出现关键词，屏蔽该动态') {
+                                    // 如果需要发送才发送
+                                    if (this.config.filter.notify) {
+                                        await this.sendMsg(guildId, bot, `${upName}发布了一条含有屏蔽关键字的动态`);
+                                    }
+                                    return updatePoint(num);
+                                }
+                                if (e.message === '已屏蔽转发动态') {
+                                    if (this.config.filter.notify) {
+                                        await this.sendMsg(guildId, bot, `${upName}发布了一条转发动态，已屏蔽`);
+                                    }
+                                    return updatePoint(num);
+                                }
+                                // 未知错误
+                                if (i === attempts - 1) {
+                                    this.logger.error('dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：' + e.message);
+                                    // 发送私聊消息并重启服务
+                                    return await this.sendPrivateMsgAndStopService(ctx, bot);
+                                }
                             }
                         }
+                        this.logger.info(`UID：${uid}-尝试推送动态卡片`);
+                        // 判断是否需要发送URL
+                        const dUrl = this.config.dynamicUrl ? `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}` : '';
+                        // 如果pic存在，则直接返回pic
+                        if (pic) {
+                            this.logger.info(`UID：${uid}-推送动态中，使用render模式`);
+                            // pic存在，使用的是render模式
+                            await this.sendMsg(guildId, bot, pic + (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: dUrl }));
+                        }
+                        else if (buffer) {
+                            this.logger.info(`UID：${uid}-推送动态中，使用page模式`);
+                            // pic不存在，说明使用的是page模式
+                            await this.sendMsg(guildId, bot, (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 + '发布了一条动态，但是推送失败');
+                        }
+                        // 更新时间点
+                        updatePoint(num);
+                        this.logger.info(`UID：${uid}-推送动态完成`);
                     }
-                    this.logger.info(`UID：${uid}-尝试推送动态卡片`);
-                    // 判断是否需要发送URL
-                    const dUrl = this.config.dynamicUrl ? `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}` : '';
-                    // 如果pic存在，则直接返回pic
-                    if (pic) {
-                        this.logger.info(`UID：${uid}-推送动态中，使用render模式`);
-                        // pic存在，使用的是render模式
-                        await this.sendMsg(guildId, bot, pic + (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: dUrl }));
-                    }
-                    else if (buffer) {
-                        this.logger.info(`UID：${uid}-推送动态中，使用page模式`);
-                        // pic不存在，说明使用的是page模式
-                        await this.sendMsg(guildId, bot, (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 + '发布了一条动态，但是推送失败');
-                    }
-                    // 更新时间点
-                    updatePoint(num);
-                    this.logger.info(`UID：${uid}-推送动态完成`);
                 }
             }
+            finally {
+                flag = true;
+            }
         };
     }
     liveDetect(ctx, bot, roomId, guildId) {
@@ -1145,7 +1205,8 @@ class ComRegister {
                     catch (e) {
                         if (i === attempts - 1) { // 已尝试三次
                             this.logger.error('liveDetect generateLiveImg() 推送卡片生成失败，原因：' + e.message);
-                            return await this.sendPrivateMsgAndRebootService(ctx, bot, '插件可能出现某些未知错误，请尝试重启插件，如果仍然发生该错误，请带着日志向作者反馈');
+                            // 发送私聊消息并重启服务
+                            return await this.sendPrivateMsgAndStopService(ctx, bot);
                         }
                     }
                 }
@@ -1180,7 +1241,8 @@ class ComRegister {
                     catch (e) {
                         if (i === attempts - 1) { // 已尝试三次
                             this.logger.error('liveDetect generateLiveImg() 推送卡片生成失败，原因：' + e.message);
-                            return await this.sendPrivateMsgAndRebootService(ctx, bot, '插件可能出现某些未知错误，请尝试重启插件，如果仍然发生该错误，请带着日志向作者反馈');
+                            // 发送私聊消息并重启服务
+                            return await this.sendPrivateMsgAndStopService(ctx, bot);
                         }
                     }
                 }
@@ -1212,11 +1274,12 @@ class ComRegister {
             };
         }
         return async () => {
+            // 如果flag为false则说明前面的代码还未执行完，则直接返回
+            if (!flag)
+                return;
+            flag = false;
+            // 无论是否执行成功都要释放锁
             try {
-                // 如果flag为false则说明前面的代码还未执行完，则直接返回
-                if (!flag)
-                    return;
-                flag = false;
                 // 发送请求检测直播状态
                 let content;
                 const attempts = 3;
@@ -1230,7 +1293,8 @@ class ComRegister {
                     catch (e) {
                         this.logger.error('liveDetect getLiveRoomInfo 发生了错误，错误为：' + e.message);
                         if (i === attempts - 1) { // 已尝试三次
-                            return await this.sendPrivateMsgAndRebootService(ctx, bot, '插件可能出现某些未知错误，请尝试重启插件，如果仍然发生该错误，请带着日志向作者反馈');
+                            // 发送私聊消息并重启服务
+                            return await this.sendPrivateMsgAndStopService(ctx, bot);
                         }
                     }
                 }
@@ -1250,7 +1314,8 @@ class ComRegister {
                         catch (e) {
                             this.logger.error('liveDetect getMasterInfo() 发生了错误，错误为：' + e.message);
                             if (i === attempts - 1) { // 已尝试三次
-                                return await this.sendPrivateMsgAndRebootService(ctx, bot, '插件可能出现某些未知错误，请尝试重启插件，如果仍然发生该错误，请带着日志向作者反馈');
+                                // 发送私聊消息并重启服务
+                                return await this.sendPrivateMsgAndStopService(ctx, bot);
                             }
                         }
                     }
@@ -1282,8 +1347,8 @@ class ComRegister {
                             let resizedImage;
                             // Jimp无法处理Webp格式，直接跳过
                             try {
-                                resizedImage = await jimp_1.default.read(userface).then(async (image) => {
-                                    return await image.resize(100, 100).getBufferAsync(jimp_1.default.MIME_PNG);
+                                resizedImage = await jimp_1.Jimp.read(userface).then(async (image) => {
+                                    return await image.resize({ w: 100, h: 100 }).getBuffer(jimp_1.JimpMime.png);
                                 });
                             }
                             catch (e) {
@@ -1317,7 +1382,8 @@ class ComRegister {
                                 catch (e) {
                                     this.logger.error('liveDetect open getMasterInfo() 发生了错误，错误为：' + e.message);
                                     if (i === attempts - 1) { // 已尝试三次
-                                        return await this.sendPrivateMsgAndRebootService(ctx, bot, '插件可能出现某些未知错误，请尝试重启插件，如果仍然发生该错误，请带着日志向作者反馈');
+                                        // 发送私聊消息并重启服务
+                                        return await this.sendPrivateMsgAndStopService(ctx, bot);
                                     }
                                 }
                             }
@@ -1403,7 +1469,8 @@ class ComRegister {
     }
     updateSubNotifier(ctx) {
         // 更新控制台提示
-        this.subNotifier && this.subNotifier.dispose();
+        if (this.subNotifier)
+            this.subNotifier.dispose();
         // 获取订阅信息
         const subInfo = this.subShow();
         // 定义table
@@ -1525,7 +1592,8 @@ class ComRegister {
                 catch (e) {
                     this.logger.error('getSubFromDatabase() getUserInfo() 发生了错误，错误为：' + e.message);
                     if (i === attempts - 1) { // 已尝试三次
-                        return await this.sendPrivateMsgAndRebootService(ctx, bot, '你的网络可能出现了某些问题，请检查后重启插件');
+                        // 发送私聊消息并重启服务
+                        return await this.sendPrivateMsgAndStopService(ctx, bot);
                     }
                 }
             }
@@ -1628,7 +1696,8 @@ class ComRegister {
                     if (index === -1)
                         return '未订阅该用户，无需取消订阅';
                     // 取消订阅
-                    this.subManager[index].live && this.subManager[index].liveDispose();
+                    if (this.subManager[index].live)
+                        this.subManager[index].liveDispose();
                     this.subManager[index].liveDispose = null;
                     this.subManager[index].live = false;
                     // 如果没有对这个UP的任何订阅，则移除
@@ -1647,7 +1716,8 @@ class ComRegister {
                     if (index === -1)
                         return '未订阅该用户，无需取消订阅';
                     // 取消订阅
-                    this.subManager[index].dynamic && this.subManager[index].dynamicDispose();
+                    if (this.subManager[index].dynamic)
+                        this.subManager[index].dynamicDispose();
                     this.subManager[index].dynamicDispose = null;
                     this.subManager[index].dynamic = false;
                     // 如果没有对这个UP的任何订阅，则移除

package/lib/index.d.ts

@@ -42,12 +42,11 @@ declare class ServerManager extends Service {
     servers: ForkScope[];
     renderType: number;
     dynamicLoopTime: number;
-    restartCount: number;
     constructor(ctx: Context);
     protected start(): void | Promise<void>;
     registerPlugin: () => Promise<boolean>;
     disposePlugin: () => Promise<boolean>;
-    restartPlugin: (count?: boolean) => Promise<boolean>;
+    restartPlugin: () => Promise<boolean>;
 }
 export declare function apply(ctx: Context, config: Config): void;
 export {};

package/lib/index.js

@@ -28,7 +28,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Config = exports.name = exports.inject = void 0;
 exports.apply = apply;
-/* eslint-disable @typescript-eslint/ban-types */
+/* eslint-disable @typescript-eslint/no-empty-object-type */
 const koishi_1 = require("koishi");
 // import plugins
 // import Authority from './authority'
@@ -178,8 +178,6 @@ class ServerManager extends koishi_1.Service {
     renderType;
     // 动态循环时间
     dynamicLoopTime;
-    // 重启次数
-    restartCount = 0;
     constructor(ctx) {
         super(ctx, 'sm');
         // 插件运行相关指令
@@ -313,29 +311,25 @@ class ServerManager extends koishi_1.Service {
         // 成功返回true
         return true;
     };
-    restartPlugin = async (count /* 是否需要计数 */) => {
+    restartPlugin = async () => {
         // 如果没有服务则返回false
         if (this.servers.length === 0)
             return false;
-        // 如果需要计数
-        if (count) {
-            // 重启次数大于等于3次
-            if (this.restartCount >= 3)
-                return false;
-            // 重启次数+1
-            this.restartCount++;
-        }
         // 停用插件
         await this.disposePlugin();
         // 隔一秒启动插件
-        await new Promise(resolve => {
+        return new Promise(resolve => {
             this.ctx.setTimeout(async () => {
-                await this.registerPlugin();
-                resolve('ok');
+                try {
+                    await this.registerPlugin();
+                }
+                catch (e) {
+                    this.logger.error('重启插件失败', e);
+                    resolve(false);
+                }
+                resolve(true);
             }, 1000);
         });
-        // 成功返回true
-        return true;
     };
 }
 function apply(ctx, config) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-bilibili-notify",
   "description": "Koishi bilibili notify plugin",
-  "version": "1.3.5",
+  "version": "1.3.6-beta.0",
   "contributors": [
     "Akokko <admin@akokko.com>"
   ],
@@ -27,25 +27,25 @@
     "koishi": "^4.17.5"
   },
   "dependencies": {
-    "axios": "^1.7.0-beta.1",
-    "axios-cookiejar-support": "^5.0.2",
-    "jimp": "^0.22.12",
-    "jsdom": "^24.0.0",
-    "luxon": "^3.4.4",
+    "axios": "^1.7.7",
+    "axios-cookiejar-support": "^5.0.3",
+    "jimp": "^1.6.0",
+    "jsdom": "^24.1.3",
+    "luxon": "^3.5.0",
     "md5": "^2.3.0",
-    "qrcode": "^1.5.3",
+    "qrcode": "^1.5.4",
     "tough-cookie": "^4.1.4"
   },
   "devDependencies": {
-    "@eslint/js": "^9.6.0",
-    "@types/luxon": "^3",
-    "@types/md5": "^2",
-    "@types/qrcode": "^1",
-    "@types/tough-cookie": "^4",
-    "eslint": "9.x",
-    "globals": "^15.6.0",
-    "koishi-plugin-puppeteer": "^3.8.4",
-    "typescript-eslint": "^7.14.1"
+    "@eslint/js": "^9.12.0",
+    "@types/luxon": "^3.4.2",
+    "@types/md5": "^2.3.5",
+    "@types/qrcode": "^1.5.5",
+    "@types/tough-cookie": "^4.0.5",
+    "eslint": "^9.12.0",
+    "globals": "^15.11.0",
+    "koishi-plugin-puppeteer": "^3.9.0",
+    "typescript-eslint": "^7.18.0"
   },
   "koishi": {
     "service": {

package/readme.md

@@ -171,6 +171,8 @@
 - ver 1.3.3 新增直播推送人气信息展示
 - ver 1.3.4 新增消息推送失败是否自动重发的选项，修复了一些潜在的bug
 - ver 1.3.5 动态监测循环时间新增20分钟选项
+- ver 1.3.6-alpha.0 修复bug：无限重复的报错提示
+- ver 1.3.6-beta.0 取消出错自动重启插件功能
 
 ## 交流群