koishi-plugin-bilibili-notify 3.1.4-alpha.0 → 3.1.5-alpha.0

package/lib/comRegister.d.ts

@@ -1,6 +1,7 @@
 import { type Bot, type Context, type FlatPick, type Logger, Schema } from "koishi";
 import type { Notifier } from "@koishijs/plugin-notifier";
 import type { LoginBili } from "./database";
+import { CronJob } from "cron";
 import { LiveType, type MasterInfo, PushType, type Result, type SubItem, type SubManager, type Target } from "./type";
 declare class ComRegister {
     static inject: string[];
@@ -13,11 +14,13 @@ declare class ComRegister {
     subNotifier: Notifier;
     ctx: Context;
     subManager: SubManager;
+    dynamicTimelineManager: Map<string, number>;
     loginDBData: FlatPick<LoginBili, "dynamic_group_id">;
     privateBot: Bot<Context>;
-    dynamicDispose: () => void;
+    dynamicJob: CronJob;
     constructor(ctx: Context, config: ComRegister.Config);
     init(config: ComRegister.Config): Promise<void>;
+    initDynamicTimelineManager(): void;
     getBot(pf: string): Bot<Context, any>;
     sendPrivateMsg(content: string): Promise<void>;
     sendPrivateMsgAndRebootService(): Promise<void>;
@@ -41,7 +44,6 @@ declare class ComRegister {
 }
 declare namespace ComRegister {
     interface Config {
-        subLoadTimeout: number;
         sub: Array<{
             uid: string;
             dynamic: boolean;

package/lib/comRegister.js

@@ -8,16 +8,15 @@ const jsx_runtime_1 = require("@satorijs/element/jsx-runtime");
 const koishi_1 = require("koishi");
 // 外部依赖：qrcode
 const qrcode_1 = __importDefault(require("qrcode"));
+const cron_1 = require("cron");
 // Utils
 const utils_1 = require("./utils");
 // Types
 const type_1 = require("./type");
 const luxon_1 = require("luxon");
-// TODO:WorlCloud
-// import { Segment, useDefault } from "segmentit";
 class ComRegister {
     // 必须服务
-    static inject = ["ba", "gi", "database", "bl", "sm", "cron"];
+    static inject = ["ba", "gi", "database", "bl", "sm"];
     // 定义数组：QQ相关bot
     qqRelatedBotList = [
         "qq",
@@ -42,12 +41,14 @@ class ComRegister {
     ctx;
     // 订阅管理器
     subManager = [];
+    // 动态时间线管理器
+    dynamicTimelineManager = new Map();
     // 检查登录数据库是否有数据
     loginDBData;
     // 机器人实例
     privateBot;
     // 动态检测销毁函数
-    dynamicDispose;
+    dynamicJob;
     // 构造函数
     constructor(ctx, config) {
         // 将ctx赋值给类属性
@@ -63,7 +64,7 @@ class ComRegister {
             .usage("查看动态监测运行状态")
             .example("status dyn")
             .action(() => {
-            if (this.dynamicDispose) {
+            if (this.dynamicJob?.isActive) {
                 return "动态监测正在运行";
             }
             return "动态监测未运行";
@@ -309,6 +310,8 @@ class ComRegister {
                 return;
             }
         }
+        // 整理dynamicTimelineManager
+        this.initDynamicTimelineManager();
         // 检查是否需要动态监测
         this.checkIfDynamicDetectIsNeeded();
         // 在控制台中显示订阅对象
@@ -319,12 +322,19 @@ class ComRegister {
             if (this.loginTimer)
                 this.loginTimer();
             // 销毁动态监测
-            if (this.dynamicDispose)
-                this.dynamicDispose();
+            if (this.dynamicJob)
+                this.dynamicJob.stop();
         });
         // logger
         this.logger.info("插件初始化完毕！");
     }
+    initDynamicTimelineManager() {
+        for (const sub of this.subManager) {
+            if (sub.dynamic) {
+                this.dynamicTimelineManager[sub.uid] = Math.floor(luxon_1.DateTime.now().toSeconds());
+            }
+        }
+    }
     // biome-ignore lint/suspicious/noExplicitAny: <explanation>
     getBot(pf) {
         return this.ctx.bots.find((bot) => bot.platform === pf);
@@ -487,47 +497,10 @@ class ComRegister {
         await pushTypePatternMatching[type]();
     }
     dynamicDetect() {
-        // 检测初始化变量
-        let detectSetup = true;
-        // 时间线
-        let timeline;
-        // 当前推送动态时间线
-        let currentTimeline;
-        // 动态ID
-        let dynId;
         // 定义handler
         const handler = async () => {
-            // 动态监测启动初始化
-            if (detectSetup) {
-                // logger
-                this.logger.info("动态监测初始化中...");
-                // 使用withRetry函数进行重试
-                const content = await (0, utils_1.withRetry)(async () => {
-                    // 获取动态内容
-                    return (await this.ctx.ba.getAllDynamic());
-                }, 1).catch((e) => {
-                    // logger
-                    this.logger.error(`dynamicDetect getAllDynamic() 发生了错误，错误为：${e.message}`);
-                });
-                // content不存在则直接返回
-                if (!content)
-                    return;
-                // 判断获取动态信息是否成功
-                if (content.code !== 0)
-                    return;
-                // 设置第一条动态的动态ID
-                dynId = content.data?.items[0]?.id_str || "0";
-                // 设置时间线
-                timeline =
-                    content.data?.items[0]?.modules.module_author.pub_ts ||
-                        luxon_1.DateTime.now().toSeconds();
-                // 设置初始化为false
-                detectSetup = false;
-                // logger
-                this.logger.info("动态监测初始化完毕！");
-                // 初始化完成
-                return;
-            }
+            // 定义本次请求推送的动态
+            const currentPushDyn = {};
             // 使用withRetry函数进行重试
             const content = await (0, utils_1.withRetry)(async () => {
                 // 获取动态内容
@@ -589,23 +562,19 @@ class ComRegister {
                 // 没有动态内容则直接跳过
                 if (!item)
                     continue;
-                // 获取动态ID
-                const dynamicId = item.id_str;
-                // 动态ID如果一致则结束循环
-                if (dynamicId === dynId)
-                    break;
                 // 获取动态发布时间
                 const postTime = item.modules.module_author.pub_ts;
-                // timeline已超过或与当前动态时间戳相同，则后面的动态不需要推送
-                if (postTime <= timeline)
-                    break;
                 // 从动态数据中取出UP主名称、UID
-                const upUID = item.modules.module_author.mid.toString();
-                const upName = item.modules.module_author.name;
-                // 寻找关注的UP主的动态
-                for (const sub of this.subManager) {
-                    // 判断是否是订阅的UP主
-                    if (sub.dynamic && sub.uid === upUID) {
+                const uid = item.modules.module_author.mid.toString();
+                const name = item.modules.module_author.name;
+                // 判断是否存在时间线
+                if (this.dynamicTimelineManager.has(uid)) {
+                    // 寻找关注的UP主
+                    const timeline = this.dynamicTimelineManager.get(uid);
+                    // 判断动态发布时间是否大于时间线
+                    if (timeline < postTime) {
+                        // 获取订阅对象
+                        const sub = this.subManager[uid];
                         // 推送该条动态
                         const buffer = await (0, utils_1.withRetry)(async () => {
                             // 渲染图片
@@ -617,19 +586,19 @@ class ComRegister {
                             if (e.message === "出现关键词，屏蔽该动态") {
                                 // 如果需要发送才发送
                                 if (this.config.filter.notify) {
-                                    await this.broadcastToTargets(sub.target, `${upName}发布了一条含有屏蔽关键字的动态`, type_1.PushType.Dynamic);
+                                    await this.broadcastToTargets(sub.target, `${name}发布了一条含有屏蔽关键字的动态`, type_1.PushType.Dynamic);
                                 }
                                 return;
                             }
                             if (e.message === "已屏蔽转发动态") {
                                 if (this.config.filter.notify) {
-                                    await this.broadcastToTargets(sub.target, `${upName}转发了一条动态，已屏蔽`, type_1.PushType.Dynamic);
+                                    await this.broadcastToTargets(sub.target, `${name}转发了一条动态，已屏蔽`, type_1.PushType.Dynamic);
                                 }
                                 return;
                             }
                             if (e.message === "已屏蔽专栏动态") {
                                 if (this.config.filter.notify) {
-                                    await this.broadcastToTargets(sub.target, `${upName}投稿了一条专栏，已屏蔽`, type_1.PushType.Dynamic);
+                                    await this.broadcastToTargets(sub.target, `${name}投稿了一条专栏，已屏蔽`, type_1.PushType.Dynamic);
                                 }
                                 return;
                             }
@@ -646,11 +615,11 @@ class ComRegister {
                         // 判断是否需要发送URL
                         if (this.config.dynamicUrl) {
                             if (item.type === "DYNAMIC_TYPE_AV") {
-                                dUrl = `${upName}发布了新视频：${item.modules.module_dynamic.major.archive.jump_url}`;
+                                dUrl = `${name}发布了新视频：${item.modules.module_dynamic.major.archive.jump_url}`;
                             }
                             else {
                                 // 生成动态链接
-                                dUrl = `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}`;
+                                dUrl = `${name}发布了一条动态：https://t.bilibili.com/${item.id_str}`;
                             }
                         }
                         // logger
@@ -668,82 +637,31 @@ class ComRegister {
                                 }
                             }
                         }
-                        // 设置timeline
-                        currentTimeline = postTime;
+                        // 将当前动态存入currentPushDyn
+                        currentPushDyn[uid] = item;
                         // logger
                         this.logger.info("动态推送完毕！");
                     }
                 }
             }
-            // 更新时间线
-            if (currentTimeline) {
-                timeline = currentTimeline;
-                currentTimeline = null;
-            }
-            // 设置动态ID
-            if (items[0].id_str && items[0].id_str !== dynId) {
-                dynId = items[0].id_str;
+            // 遍历currentPushDyn
+            for (const uid in currentPushDyn) {
+                // 获取动态发布时间
+                const postTime = currentPushDyn[uid].modules.module_author.pub_ts;
+                // 更新当前时间线
+                this.dynamicTimelineManager.set(uid, postTime);
             }
         };
         // 返回一个闭包函数
         return (0, utils_1.withLock)(handler);
     }
     debug_dynamicDetect() {
-        // 检测初始化变量
-        let detectSetup = true;
-        // 时间线
-        let timeline;
-        // 当前推送动态时间线
-        let currentTimeline;
-        // 动态ID
-        let dynId;
         // 定义handler
         const handler = async () => {
-            // 动态监测启动初始化
-            if (detectSetup) {
-                // logger
-                this.logger.info("动态监测初始化中...");
-                // logger
-                this.logger.info("正在获取动态信息...");
-                // 使用withRetry函数进行重试
-                const content = await (0, utils_1.withRetry)(async () => {
-                    // 获取动态内容
-                    return (await this.ctx.ba.getAllDynamic());
-                }, 1).catch((e) => {
-                    // logger
-                    this.logger.error(`dynamicDetect getAllDynamic() 发生了错误，错误为：${e.message}`);
-                });
-                // content不存在则直接返回
-                if (!content) {
-                    // logger
-                    this.logger.info("获取动态信息失败！");
-                    return;
-                }
-                // 判断获取动态信息是否成功
-                if (content.code !== 0) {
-                    // logger
-                    this.logger.info("获取动态信息失败！");
-                    return;
-                }
-                // 设置第一条动态的动态ID
-                dynId = content.data?.items[0]?.id_str || "0";
-                // logger
-                this.logger.info(`获取到第一条动态ID:${dynId}`);
-                // 设置时间线
-                timeline =
-                    content.data?.items[0]?.modules.module_author.pub_ts ||
-                        luxon_1.DateTime.now().toSeconds();
-                // logger
-                this.logger.info(`获取到时间线信息:${timeline}`);
-                // 设置初始化为false
-                detectSetup = false;
-                // logger
-                this.logger.info("动态监测初始化完毕！");
-                // 初始化完成
-                return;
-            }
+            // 定义本次请求推送的动态
+            const currentPushDyn = {};
             // logger
-            this.logger.info("正在获取动态信息...");
+            this.logger.info("开始获取动态信息...");
             // 使用withRetry函数进行重试
             const content = await (0, utils_1.withRetry)(async () => {
                 // 获取动态内容
@@ -753,11 +671,8 @@ class ComRegister {
                 this.logger.error(`dynamicDetect getAllDynamic() 发生了错误，错误为：${e.message}`);
             });
             // content不存在则直接返回
-            if (!content) {
-                // logger
-                this.logger.info("获取动态信息失败！");
+            if (!content)
                 return;
-            }
             // 判断获取动态内容是否成功
             if (content.code !== 0) {
                 switch (content.code) {
@@ -803,65 +718,37 @@ class ComRegister {
                 }
             }
             // logger
-            this.logger.info("成功获取动态信息！开始检查更新的动态...");
+            this.logger.info("获取动态信息成功！开始处理动态信息...");
             // 获取动态内容
             const items = content.data.items;
             // 检查更新的动态
             for (const item of items) {
                 // 没有动态内容则直接跳过
-                if (!item) {
-                    // logger
-                    this.logger.info("动态内容为空，跳过该动态");
+                if (!item)
                     continue;
-                }
-                // 获取动态ID
-                const dynamicId = item.id_str;
-                // logger
-                this.logger.info(`当前动态ID:${dynamicId}`);
-                this.logger.info(`上次第一条推送的动态ID:${dynId}`);
-                // 动态ID如果一致则结束循环
-                if (dynamicId === dynId) {
-                    // logger
-                    this.logger.info("动态ID与上次第一条推送动态一致，结束循环");
-                    // 结束循环
-                    break;
-                }
                 // 获取动态发布时间
                 const postTime = item.modules.module_author.pub_ts;
-                // logger
-                this.logger.info(`当前动态时间线:${postTime}`);
-                // logger
-                this.logger.info(`上一次获取到第一条动态时间线:${timeline}`);
-                // logger
-                this.logger.info(`当前动态发布时间：${luxon_1.DateTime.fromSeconds(postTime).toFormat("yyyy-MM-dd HH:mm:ss")}`);
-                // logger
-                this.logger.info(`上一次获取到第一条动态发布时间：${luxon_1.DateTime.fromSeconds(timeline).toFormat("yyyy-MM-dd HH:mm:ss")}`);
-                // timeline已超过或与当前动态时间戳相同，则后面的动态不需要推送
-                if (postTime <= timeline) {
-                    // logger
-                    this.logger.info("当前动态时间戳已小于等于上一次获取到第一条动态时间线，更晚发布的动态无需监测");
-                    // 结束本次监测
-                    break;
-                }
-                // logger
-                this.logger.info("动态时间线大于最后推送动态时间线，开始判断是否是订阅的UP主...");
                 // 从动态数据中取出UP主名称、UID
-                const upUID = item.modules.module_author.mid.toString();
-                const upName = item.modules.module_author.name;
+                const uid = item.modules.module_author.mid.toString();
+                const name = item.modules.module_author.name;
                 // logger
-                this.logger.info(`当前动态UP主UID:${upUID}，UP主名称:${upName}`);
-                // 定义是否是订阅的UP主flag
-                let isSubscribed = false;
-                // 寻找关注的UP主的动态
-                for (const sub of this.subManager) {
-                    // 判断是否是订阅的UP主
-                    if (sub.dynamic && sub.uid === upUID) {
-                        // 将flag设置为true
-                        isSubscribed = true;
-                        // logger：订阅该UP主，推送该动态
-                        this.logger.info("订阅该UP主，开始推送该动态...");
+                this.logger.info(`获取到动态信息，UP主：${name}，UID：${uid}，动态发布时间：${luxon_1.DateTime.fromSeconds(postTime).toFormat("yyyy-MM-dd HH:mm:ss")}`);
+                // 判断是否存在时间线
+                if (this.dynamicTimelineManager.has(uid)) {
+                    // logger
+                    this.logger.info("订阅该UP主，判断动态时间线...");
+                    // 寻找关注的UP主
+                    const timeline = this.dynamicTimelineManager.get(uid);
+                    // logger
+                    this.logger.info(`上次推送时间线：${luxon_1.DateTime.fromSeconds(timeline).toFormat("yyyy-MM-dd HH:mm:ss")}`);
+                    // 判断动态发布时间是否大于时间线
+                    if (timeline < postTime) {
+                        // logger
+                        this.logger.info("需要推送该条动态，开始推送...");
+                        // 获取订阅对象
+                        const sub = this.subManager[uid];
                         // logger
-                        this.logger.info("开始生成推送卡片...");
+                        this.logger.info("开始渲染推送卡片...");
                         // 推送该条动态
                         const buffer = await (0, utils_1.withRetry)(async () => {
                             // 渲染图片
@@ -873,13 +760,19 @@ class ComRegister {
                             if (e.message === "出现关键词，屏蔽该动态") {
                                 // 如果需要发送才发送
                                 if (this.config.filter.notify) {
-                                    await this.broadcastToTargets(sub.target, `${upName}发布了一条含有屏蔽关键字的动态`, type_1.PushType.Dynamic);
+                                    await this.broadcastToTargets(sub.target, `${name}发布了一条含有屏蔽关键字的动态`, type_1.PushType.Dynamic);
                                 }
                                 return;
                             }
                             if (e.message === "已屏蔽转发动态") {
                                 if (this.config.filter.notify) {
-                                    await this.broadcastToTargets(sub.target, `${upName}转发了一条动态，已屏蔽`, type_1.PushType.Dynamic);
+                                    await this.broadcastToTargets(sub.target, `${name}转发了一条动态，已屏蔽`, type_1.PushType.Dynamic);
+                                }
+                                return;
+                            }
+                            if (e.message === "已屏蔽专栏动态") {
+                                if (this.config.filter.notify) {
+                                    await this.broadcastToTargets(sub.target, `${name}投稿了一条专栏，已屏蔽`, type_1.PushType.Dynamic);
                                 }
                                 return;
                             }
@@ -889,25 +782,26 @@ class ComRegister {
                             await this.sendPrivateMsgAndStopService();
                         });
                         // 判断是否执行成功，未执行成功直接返回
-                        if (!buffer) {
-                            // logger
-                            this.logger.info("推送卡片生成失败，或该动态为屏蔽动态，跳过该动态！");
-                            // 结束循环
+                        if (!buffer)
                             continue;
-                        }
+                        // logger
+                        this.logger.info("渲染推送卡片成功！");
                         // 定义动态链接
                         let dUrl = "";
                         // 判断是否需要发送URL
                         if (this.config.dynamicUrl) {
                             // logger
-                            this.logger.info("生成动态链接中...");
+                            this.logger.info("需要发送动态链接，开始生成链接...");
+                            // 判断动态类型
                             if (item.type === "DYNAMIC_TYPE_AV") {
-                                dUrl = `${upName}发布了新视频：${item.modules.module_dynamic.major.archive.jump_url}`;
+                                dUrl = `${name}发布了新视频：${item.modules.module_dynamic.major.archive.jump_url}`;
                             }
                             else {
                                 // 生成动态链接
-                                dUrl = `${upName}发布了一条动态：https://t.bilibili.com/${item.id_str}`;
+                                dUrl = `${name}发布了一条动态：https://t.bilibili.com/${item.id_str}`;
                             }
+                            // logger
+                            this.logger.info("动态链接生成成功！");
                         }
                         // logger
                         this.logger.info("推送动态中...");
@@ -916,7 +810,7 @@ class ComRegister {
                         // 判断是否需要发送动态中的图片
                         if (this.config.pushImgsInDynamic) {
                             // logger
-                            this.logger.info("开始推送动态中的图片...");
+                            this.logger.info("需要发送动态中的图片，开始发送...");
                             // 判断是否为图文动态，且存在draw
                             if (item.type === "DYNAMIC_TYPE_DRAW" &&
                                 item.modules.module_dynamic.major?.draw) {
@@ -926,39 +820,28 @@ class ComRegister {
                                 }
                             }
                             // logger
-                            this.logger.info("图片推送完毕！");
+                            this.logger.info("动态中的图片发送完毕！");
                         }
-                        // 设置timeline
-                        currentTimeline = postTime;
+                        // 将当前动态存入currentPushDyn
+                        currentPushDyn[uid] = item;
                         // logger
                         this.logger.info("动态推送完毕！");
                     }
                 }
-                if (!isSubscribed) {
-                    // logger
-                    this.logger.info("不是关注的UP主，跳过该动态");
-                }
             }
-            // 更新时间线
-            if (currentTimeline) {
-                timeline = currentTimeline;
-                currentTimeline = null;
-                // logger
-                this.logger.info(`更新时间线:${timeline}`);
-            }
-            else {
-                this.logger.info("时间线无需更新！");
-            }
-            // 更新动态ID
-            if (items[0].id_str && items[0].id_str !== dynId) {
-                dynId = items[0].id_str;
+            // logger
+            this.logger.info("动态信息处理完毕！");
+            // 遍历currentPushDyn
+            for (const uid in currentPushDyn) {
+                // 获取动态发布时间
+                const postTime = currentPushDyn[uid].modules.module_author.pub_ts;
+                // 更新当前时间线
+                this.dynamicTimelineManager.set(uid, postTime);
                 // logger
-                this.logger.info(`更新动态ID:${dynId}`);
+                this.logger.info(`更新时间线成功，UP主：${uid}，时间线：${luxon_1.DateTime.fromSeconds(postTime).toFormat("yyyy-MM-dd HH:mm:ss")}`);
             }
             // logger
-            this.logger.info(`时间线格式化:${luxon_1.DateTime.fromSeconds(timeline).toFormat("yyyy-MM-dd HH:mm:ss")}`);
-            // logger
-            this.logger.info("动态监测完成，等待下一次检测...");
+            this.logger.info(`本次推送动态数量：${Object.keys(currentPushDyn).length}`);
         };
         // 返回一个闭包函数
         return (0, utils_1.withLock)(handler);
@@ -1529,10 +1412,12 @@ class ComRegister {
             this.enableDynamicDetect();
     }
     enableDynamicDetect() {
-        // 开始动态监测
-        this.dynamicDispose = this.ctx.cron("*/2 * * * *", this.config.dynamicDebugMode
+        // 定义Job
+        this.dynamicJob = new cron_1.CronJob("*/2 * * * *", this.config.dynamicDebugMode
             ? this.debug_dynamicDetect()
             : this.dynamicDetect());
+        // 开始动态监测
+        this.dynamicJob.start();
     }
     async checkIfIsLogin() {
         if ((await this.ctx.database.get("loginBili", 1)).length !== 0) {
@@ -1548,7 +1433,6 @@ class ComRegister {
 }
 (function (ComRegister) {
     ComRegister.Config = koishi_1.Schema.object({
-        subLoadTimeout: koishi_1.Schema.number(),
         sub: koishi_1.Schema.array(koishi_1.Schema.object({
             uid: koishi_1.Schema.string().description("订阅用户UID"),
             dynamic: koishi_1.Schema.boolean().description("是否订阅用户动态"),

package/lib/index.d.ts

@@ -22,7 +22,6 @@ export interface Config {
     basicSettings: {};
     userAgent: string;
     subTitle: {};
-    subLoadTimeout: number;
     sub: Array<{
         name: string;
         uid: string;

package/lib/index.js

@@ -46,7 +46,7 @@ const Database = __importStar(require("./database"));
 const generateImg_1 = __importDefault(require("./generateImg"));
 const biliAPI_1 = __importDefault(require("./biliAPI"));
 const blive_1 = __importDefault(require("./blive"));
-exports.inject = ["puppeteer", "database", "notifier", "cron"];
+exports.inject = ["puppeteer", "database", "notifier"];
 exports.name = "bilibili-notify";
 let globalConfig;
 class ServerManager extends koishi_1.Service {
@@ -124,7 +124,6 @@ class ServerManager extends koishi_1.Service {
             });
             // CR = ComRegister
             const cr = this.ctx.plugin(comRegister_1.default, {
-                subLoadTimeout: globalConfig.subLoadTimeout,
                 sub: globalConfig.sub,
                 master: globalConfig.master,
                 restartPush: globalConfig.restartPush,
@@ -257,9 +256,6 @@ exports.Config = koishi_1.Schema.object({
         .required()
         .description("设置请求头User-Agen，请求出现-352时可以尝试修改，UA获取方法可参考：https://blog.csdn.net/qq_44503987/article/details/104929111"),
     subTitle: koishi_1.Schema.object({}).description("订阅配置"),
-    subLoadTimeout: koishi_1.Schema.number()
-        .default(10)
-        .description("订阅加载超时时间，单位为秒，默认10秒"),
     sub: koishi_1.Schema.array(koishi_1.Schema.object({
         name: koishi_1.Schema.string().description("订阅用户昵称，只是给你自己看的(相当于备注)，可填可不填"),
         uid: koishi_1.Schema.string().required().description("订阅用户UID"),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-bilibili-notify",
   "description": "Koishi bilibili notify plugin",
-  "version": "3.1.4-alpha.0",
+  "version": "3.1.5-alpha.0",
   "contributors": [
     "Akokko <admin@akokko.com>"
   ],
@@ -30,11 +30,11 @@
     "axios": "^1.7.9",
     "axios-cookiejar-support": "^5.0.5",
     "blive-message-listener": "^0.5.0",
+    "cron": "^4.3.0",
     "jsdom": "^24.1.3",
     "luxon": "^3.5.0",
     "md5": "^2.3.0",
     "qrcode": "^1.5.4",
-    "segmentit": "^2.0.3",
     "tough-cookie": "^4.1.4"
   },
   "devDependencies": {
@@ -44,7 +44,6 @@
     "@types/qrcode": "^1.5.5",
     "@types/tough-cookie": "^4.0.5",
     "globals": "^15.14.0",
-    "koishi-plugin-cron": "^3.1.0",
     "koishi-plugin-puppeteer": "^3.9.0"
   },
   "koishi": {
@@ -52,8 +51,7 @@
       "required": [
         "database",
         "puppeteer",
-        "notifier",
-        "cron"
+        "notifier"
       ]
     },
     "description": {

package/readme.md

@@ -237,6 +237,7 @@ uid为必填参数，为要推送的UP主的UID，index为可选参数，为要
 - ver 3.1.2-alpha.0 重构：对消息发送模块进行小型重构，多群多平台推送将不再支持艾特全体成员，仅单平台单群聊支持； 移除：群聊 `all` 选项
 - ver 3.1.3-alpha.0 移除：订阅超时； 新增：屏蔽专栏动态功能； 优化：改进了加载插件的错误提示；
 - ver 3.1.4-alpha.0 修复：动态只推送视频； 优化：动态视频链接将直接发送为视频链接；
+- ver 3.1.5-alpha.0 修复：潜在动态推送bug； 优化：现在动态监测无需等待，当插件初始化完成即开始监测、移除多余依赖、移除对 `cron` 服务的依赖、移除选项 `超时订阅`
 
 ## 交流群
 
@@ -250,6 +251,8 @@ uid为必填参数，为要推送的UP主的UID，index为可选参数，为要
 
 [bilibili-API-collect](https://github.com/SocialSisterYi/bilibili-API-collect) 感谢 `SocialSisterYi` 提供B站API参考
 
+[bilibili-dynamic-mirai-plugin](https://github.com/Colter23/bilibili-dynamic-mirai-plugin) 感谢 `Colter23` 提供推送卡片灵感参考
+
 ## License
 
 MIT