koishi-plugin-bilibili-notify 3.0.3 → 3.0.5-alpha.0

package/lib/comRegister.js

@@ -12,6 +12,7 @@ const qrcode_1 = __importDefault(require("qrcode"));
 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 {
@@ -252,6 +253,24 @@ class ComRegister {
             }
             return table;
         });
+        biliCom
+            .subcommand(".dyn <uid:string> [index:number]", "手动推送一条动态信息", {
+            hidden: true,
+        })
+            .usage("手动推送一条动态信息")
+            .example("bili dyn 233 1 手动推送UID为233用户空间的第一条动态信息")
+            .action(async ({ session }, uid, index) => {
+            // 获取index
+            const i = (index && index - 1) || 0;
+            // 获取动态
+            const content = await this.ctx.ba.getUserSpaceDynamic(uid);
+            // 获取动态内容
+            const item = content.data.items[i];
+            // 生成图片
+            const buffer = await this.ctx.gi.generateDynamicImg(item);
+            // 发送图片
+            await session.send(koishi_1.h.image(buffer, "image/png"));
+        });
     }
     async init(config) {
         // 设置logger
@@ -481,16 +500,16 @@ class ComRegister {
     dynamicDetect() {
         // 检测初始化变量
         let detectSetup = true;
-        // 更新基线
-        let updateBaseline;
+        // 时间线
+        let timeline;
         // 第一条动态的动态ID
         let dynamicIdStr1st;
-        // 第二条动态的动态ID
-        let dynamicIdStr2nd;
         // 定义handler
         const handler = async () => {
-            // 检测启动初始化
+            // 动态监测启动初始化
             if (detectSetup) {
+                // logger
+                this.logger.info("动态监测初始化中...");
                 // 使用withRetry函数进行重试
                 const content = await (0, utils_1.withRetry)(async () => {
                     // 获取动态内容
@@ -505,24 +524,23 @@ class ComRegister {
                 // 判断获取动态信息是否成功
                 if (content.code !== 0)
                     return;
-                // 设置更新基线
-                updateBaseline = content.data.update_baseline;
                 // 设置第一条动态的动态ID
                 dynamicIdStr1st = content.data?.items[0]?.id_str || "0";
-                // 判断第二条动态是否存在
-                if (content.data?.items[1]) {
-                    // 设置第二条动态的动态ID
-                    dynamicIdStr2nd = content.data.items[1].id_str;
-                }
+                // 设置时间线
+                timeline =
+                    content.data?.items[0]?.modules.module_author.pub_ts ||
+                        luxon_1.DateTime.now().toSeconds();
                 // 设置初始化为false
                 detectSetup = false;
+                // logger
+                this.logger.info("动态监测初始化完毕！");
                 // 初始化完成
                 return;
             }
             // 使用withRetry函数进行重试
             const content = await (0, utils_1.withRetry)(async () => {
                 // 获取动态内容
-                return (await this.ctx.ba.getAllDynamic(updateBaseline));
+                return (await this.ctx.ba.getAllDynamic());
             }, 1).catch((e) => {
                 // logger
                 this.logger.error(`dynamicDetect getAllDynamic() 发生了错误，错误为：${e.message}`);
@@ -574,87 +592,86 @@ class ComRegister {
                     }
                 }
             }
-            // 获取数据内容
-            const data = content.data;
-            // 更新基线
-            updateBaseline = data.update_baseline;
-            // 有新动态内容
-            const items = data.items;
+            const items = content.data.items;
             // 检查更新的动态
             for (const item of items) {
-                // 动态ID如果一致则结束循环
-                if (item.id_str === dynamicIdStr1st)
-                    break;
-                if (item.id_str === dynamicIdStr2nd)
-                    break;
                 // 没有动态内容则直接跳过
                 if (!item)
                     continue;
-                // 从动态数据中取出UP主名称、UID和动态ID
-                const upUID = item.modules.module_author.mid.toString();
-                const upName = item.modules.module_author.name;
+                // 获取动态ID
                 const dynamicId = item.id_str;
-                // 寻找关注的UP主的动态
-                for (const sub of this.subManager) {
-                    // 判断是否是订阅的UP主
-                    if (sub.dynamic && sub.uid === upUID) {
-                        // 订阅该UP主，推送该动态
-                        // 推送该条动态
-                        const buffer = await (0, utils_1.withRetry)(async () => {
-                            // 渲染图片
-                            return await this.ctx.gi.generateDynamicImg(item, sub.card);
-                        }, 1).catch(async (e) => {
-                            // 直播开播动态，不做处理
-                            if (e.message === "直播开播动态，不做处理")
-                                return;
-                            if (e.message === "出现关键词，屏蔽该动态") {
-                                // 如果需要发送才发送
-                                if (this.config.filter.notify) {
-                                    await this.sendMsg(sub.target, `${upName}发布了一条含有屏蔽关键字的动态`);
+                // 动态ID如果一致则结束循环
+                if (dynamicId === dynamicIdStr1st)
+                    break;
+                // 判断动态时间戳是否大于时间线
+                if (item.modules.module_author.pub_ts > timeline) {
+                    // 从动态数据中取出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) {
+                            // 订阅该UP主，推送该动态
+                            // 推送该条动态
+                            const buffer = await (0, utils_1.withRetry)(async () => {
+                                // 渲染图片
+                                return await this.ctx.gi.generateDynamicImg(item, sub.card);
+                            }, 1).catch(async (e) => {
+                                // 直播开播动态，不做处理
+                                if (e.message === "直播开播动态，不做处理")
+                                    return;
+                                if (e.message === "出现关键词，屏蔽该动态") {
+                                    // 如果需要发送才发送
+                                    if (this.config.filter.notify) {
+                                        await this.sendMsg(sub.target, `${upName}发布了一条含有屏蔽关键字的动态`);
+                                    }
+                                    return;
                                 }
-                                return;
-                            }
-                            if (e.message === "已屏蔽转发动态") {
-                                if (this.config.filter.notify) {
-                                    await this.sendMsg(sub.target, `${upName}转发了一条动态，已屏蔽`);
+                                if (e.message === "已屏蔽转发动态") {
+                                    if (this.config.filter.notify) {
+                                        await this.sendMsg(sub.target, `${upName}转发了一条动态，已屏蔽`);
+                                    }
+                                    return;
                                 }
-                                return;
-                            }
-                            // 未知错误
-                            this.logger.error(`dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：${e.message}`);
-                            // 发送私聊消息并重启服务
-                            await this.sendPrivateMsgAndStopService();
-                        });
-                        // 判断是否执行成功，未执行成功直接返回
-                        if (!buffer)
-                            continue;
-                        // 判断是否需要发送URL
-                        const dUrl = this.config.dynamicUrl
-                            ? `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}`
-                            : "";
-                        // logger
-                        this.logger.info("推送动态中...");
-                        // 发送推送卡片
-                        await this.sendMsg(sub.target, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, "image/png"), dUrl] }));
-                        // 判断是否需要发送动态中的图片
-                        if (this.config.pushImgsInDynamic) {
-                            // 判断是否为图文动态，且存在draw
-                            if (item.type === "DYNAMIC_TYPE_DRAW" &&
-                                item.modules.module_dynamic.major?.draw) {
-                                for (const img of item.modules.module_dynamic.major.draw
-                                    .items) {
-                                    await this.sendMsg(sub.target, (0, jsx_runtime_1.jsx)("img", { src: img.src, alt: "\u52A8\u6001\u56FE\u7247" }));
+                                // 未知错误
+                                this.logger.error(`dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：${e.message}`);
+                                // 发送私聊消息并重启服务
+                                await this.sendPrivateMsgAndStopService();
+                            });
+                            // 判断是否执行成功，未执行成功直接返回
+                            if (!buffer)
+                                continue;
+                            // 判断是否需要发送URL
+                            const dUrl = this.config.dynamicUrl
+                                ? `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}`
+                                : "";
+                            // logger
+                            this.logger.info("推送动态中...");
+                            // 发送推送卡片
+                            await this.sendMsg(sub.target, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, "image/png"), dUrl] }));
+                            // 判断是否需要发送动态中的图片
+                            if (this.config.pushImgsInDynamic) {
+                                // 判断是否为图文动态，且存在draw
+                                if (item.type === "DYNAMIC_TYPE_DRAW" &&
+                                    item.modules.module_dynamic.major?.draw) {
+                                    for (const img of item.modules.module_dynamic.major.draw
+                                        .items) {
+                                        await this.sendMsg(sub.target, (0, jsx_runtime_1.jsx)("img", { src: img.src, alt: "\u52A8\u6001\u56FE\u7247" }));
+                                    }
                                 }
                             }
+                            // logger
+                            this.logger.info("动态推送完毕！");
                         }
-                        // logger
-                        this.logger.info("动态推送完毕！");
                     }
                 }
             }
             // 更新本次请求第一条动态的动态ID
-            dynamicIdStr1st = items[0]?.id_str || "0";
-            dynamicIdStr2nd = items[1]?.id_str || "0";
+            dynamicIdStr1st = items[0].id_str;
+            // 更新时间线
+            timeline =
+                items[0].modules.module_author.pub_ts || luxon_1.DateTime.now().toSeconds();
         };
         // 返回一个闭包函数
         return (0, utils_1.withLock)(handler);
@@ -662,16 +679,18 @@ class ComRegister {
     debug_dynamicDetect() {
         // 检测初始化变量
         let detectSetup = true;
-        // 更新基线
-        let updateBaseline;
+        // 时间线
+        let timeline;
         // 第一条动态的动态ID
         let dynamicIdStr1st;
-        let dynamicIdStr2nd;
         // 定义handler
         const handler = async () => {
-            this.logger.info(`初始化状态：${detectSetup}`);
-            // 检测启动初始化
+            // 动态监测启动初始化
             if (detectSetup) {
+                // logger
+                this.logger.info("动态监测初始化中...");
+                // logger
+                this.logger.info("正在获取动态信息...");
                 // 使用withRetry函数进行重试
                 const content = await (0, utils_1.withRetry)(async () => {
                     // 获取动态内容
@@ -681,40 +700,48 @@ class ComRegister {
                     this.logger.error(`dynamicDetect getAllDynamic() 发生了错误，错误为：${e.message}`);
                 });
                 // content不存在则直接返回
-                if (!content)
+                if (!content) {
+                    // logger
+                    this.logger.info("获取动态信息失败！");
                     return;
+                }
                 // 判断获取动态信息是否成功
-                if (content.code !== 0)
+                if (content.code !== 0) {
+                    // logger
+                    this.logger.info("获取动态信息失败！");
                     return;
-                // 设置更新基线
-                updateBaseline = content.data.update_baseline;
-                this.logger.info(`更新基线：${updateBaseline}`);
+                }
                 // 设置第一条动态的动态ID
-                dynamicIdStr1st = content.data.items[0]?.id_str || "0";
-                dynamicIdStr2nd = content.data.items[1]?.id_str || "0";
-                this.logger.info(`第一条动态ID：${dynamicIdStr1st}`);
-                this.logger.info(`第二条动态ID：${dynamicIdStr2nd}`);
+                dynamicIdStr1st = content.data?.items[0]?.id_str || "0";
+                // logger
+                this.logger.info(`获取到第一条动态ID:${dynamicIdStr1st}`);
+                // 设置时间线
+                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("动态监测初始化完毕！");
                 // 初始化完成
-                this.logger.info("动态检测初始化完成");
                 return;
             }
-            this.logger.info(`更新基线：${updateBaseline}`);
-            this.logger.info(`第一条动态ID：${dynamicIdStr1st}`);
-            this.logger.info(`第二条动态ID：${dynamicIdStr2nd}`);
-            this.logger.info("获取动态内容中...");
+            // logger
+            this.logger.info("正在获取动态信息...");
             // 使用withRetry函数进行重试
             const content = await (0, utils_1.withRetry)(async () => {
                 // 获取动态内容
-                return (await this.ctx.ba.getAllDynamic(updateBaseline));
+                return (await this.ctx.ba.getAllDynamic());
             }, 1).catch((e) => {
                 // logger
                 this.logger.error(`dynamicDetect getAllDynamic() 发生了错误，错误为：${e.message}`);
             });
             // content不存在则直接返回
             if (!content) {
-                this.logger.error("获取动态内容失败");
+                // logger
+                this.logger.info("获取动态信息失败！");
                 return;
             }
             // 判断获取动态内容是否成功
@@ -761,100 +788,127 @@ class ComRegister {
                     }
                 }
             }
-            this.logger.error("获取动态内容成功，开始检测动态");
-            // 获取数据内容
-            const data = content.data;
-            // 更新基线
-            updateBaseline = data.update_baseline;
-            this.logger.info(`更新基线：${updateBaseline}`);
-            // 有新动态内容
-            const items = data.items;
+            // logger
+            this.logger.info("成功获取动态信息！开始检查更新的动态...");
+            // 获取动态内容
+            const items = content.data.items;
             // 检查更新的动态
             for (const item of items) {
+                // 没有动态内容则直接跳过
+                if (!item) {
+                    // logger
+                    this.logger.info("动态内容为空，跳过该动态");
+                    continue;
+                }
+                // 获取动态ID
+                const dynamicId = item.id_str;
+                // logger
+                this.logger.info(`当前动态ID:${dynamicId}`);
+                this.logger.info(`上一次获取到第一条动态ID:${dynamicId}`);
                 // 动态ID如果一致则结束循环
-                if (item.id_str === dynamicIdStr1st ||
-                    item.id_str === dynamicIdStr2nd) {
+                if (dynamicId === dynamicIdStr1st) {
                     // logger
-                    this.logger.info("动态ID与上次检测第一条一致，结束循环");
-                    this.logger.info("动态检测结束");
-                    // 结束循环
+                    this.logger.info("动态ID与上一次获取第一条一致，结束循环");
                     break;
                 }
-                // 没有动态内容则直接跳过
-                if (!item)
-                    continue;
-                // 从动态数据中取出UP主名称、UID和动态ID
-                const upUID = item.modules.module_author.mid.toString();
-                const upName = item.modules.module_author.name;
-                const dynamicId = item.id_str;
-                // 寻找关注的UP主的动态
-                for (const sub of this.subManager) {
-                    // 判断是否是订阅的UP主
-                    if (sub.dynamic && sub.uid === upUID) {
-                        // 订阅该UP主，推送该动态
-                        this.logger.info(`寻找到需要推送的动态，订阅的UP主：${upName}(${upUID})，动态ID：${dynamicId}`);
-                        this.logger.info("渲染推送卡片中...");
-                        // 推送该条动态
-                        const buffer = await (0, utils_1.withRetry)(async () => {
-                            // 渲染图片
-                            return await this.ctx.gi.generateDynamicImg(item, sub.card);
-                        }, 1).catch(async (e) => {
-                            // 直播开播动态，不做处理
-                            if (e.message === "直播开播动态，不做处理")
-                                return;
-                            if (e.message === "出现关键词，屏蔽该动态") {
-                                // 如果需要发送才发送
-                                if (this.config.filter.notify) {
-                                    await this.sendMsg(sub.target, `${upName}发布了一条含有屏蔽关键字的动态`);
+                // logger
+                this.logger.info(`当前动态时间线:${item.modules.module_author.pub_ts}`);
+                this.logger.info(`上一次获取到第一条动态时间线:${timeline}`);
+                // 判断动态时间戳是否大于时间线
+                if (item.modules.module_author.pub_ts > timeline) {
+                    // logger
+                    this.logger.info("动态时间线大于上一次获取到第一条动态时间线，开始判断是否是订阅的UP主...");
+                    // 从动态数据中取出UP主名称、UID
+                    const upUID = item.modules.module_author.mid.toString();
+                    const upName = item.modules.module_author.name;
+                    // logger
+                    this.logger.info(`当前动态UP主UID:${upUID}，UP主名称:${upName}`);
+                    // 寻找关注的UP主的动态
+                    for (const sub of this.subManager) {
+                        // 判断是否是订阅的UP主
+                        if (sub.dynamic && sub.uid === upUID) {
+                            // logger：订阅该UP主，推送该动态
+                            this.logger.info("订阅该UP主，开始推送该动态...");
+                            // logger
+                            this.logger.info("开始生成推送卡片...");
+                            // 推送该条动态
+                            const buffer = await (0, utils_1.withRetry)(async () => {
+                                // 渲染图片
+                                return await this.ctx.gi.generateDynamicImg(item, sub.card);
+                            }, 1).catch(async (e) => {
+                                // 直播开播动态，不做处理
+                                if (e.message === "直播开播动态，不做处理")
+                                    return;
+                                if (e.message === "出现关键词，屏蔽该动态") {
+                                    // 如果需要发送才发送
+                                    if (this.config.filter.notify) {
+                                        await this.sendMsg(sub.target, `${upName}发布了一条含有屏蔽关键字的动态`);
+                                    }
+                                    return;
                                 }
-                                return;
-                            }
-                            if (e.message === "已屏蔽转发动态") {
-                                if (this.config.filter.notify) {
-                                    await this.sendMsg(sub.target, `${upName}转发了一条动态，已屏蔽`);
+                                if (e.message === "已屏蔽转发动态") {
+                                    if (this.config.filter.notify) {
+                                        await this.sendMsg(sub.target, `${upName}转发了一条动态，已屏蔽`);
+                                    }
+                                    return;
                                 }
-                                return;
+                                // 未知错误
+                                this.logger.error(`dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：${e.message}`);
+                                // 发送私聊消息并重启服务
+                                await this.sendPrivateMsgAndStopService();
+                            });
+                            // 判断是否执行成功，未执行成功直接返回
+                            if (!buffer) {
+                                // logger
+                                this.logger.info("推送卡片生成失败，或该动态为屏蔽动态，跳过该动态！");
+                                // 结束循环
+                                continue;
                             }
-                            // 未知错误
-                            this.logger.error(`dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：${e.message}`);
-                            // 发送私聊消息并重启服务
-                            await this.sendPrivateMsgAndStopService();
-                        });
-                        // 判断是否执行成功，未执行成功直接返回
-                        if (!buffer) {
-                            this.logger.error("渲染推送卡片失败");
-                            // 下一条
-                            continue;
-                        }
-                        // 判断是否需要发送URL
-                        const dUrl = this.config.dynamicUrl
-                            ? `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}`
-                            : "";
-                        // logger
-                        this.logger.info("推送动态中...");
-                        // 发送推送卡片
-                        await this.sendMsg(sub.target, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, "image/png"), dUrl] }));
-                        // 判断是否需要发送动态中的图片
-                        if (this.config.pushImgsInDynamic) {
-                            // 判断是否为图文动态，且存在draw
-                            if (item.type === "DYNAMIC_TYPE_DRAW" &&
-                                item.modules.module_dynamic.major?.draw) {
-                                this.logger.info("推送动态图片中...");
-                                for (const img of item.modules.module_dynamic.major.draw
-                                    .items) {
-                                    await this.sendMsg(sub.target, (0, jsx_runtime_1.jsx)("img", { src: img.src, alt: "\u52A8\u6001\u56FE\u7247" }));
+                            // 定义动态链接
+                            let dUrl = "";
+                            // 判断是否需要发送URL
+                            if (this.config.dynamicUrl) {
+                                // logger
+                                this.logger.info("生成动态链接中...");
+                                // 生成动态链接
+                                dUrl = `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}`;
+                            }
+                            // logger
+                            this.logger.info("推送动态中...");
+                            // 发送推送卡片
+                            await this.sendMsg(sub.target, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, "image/png"), dUrl] }));
+                            // logger
+                            this.logger.info("动态推送完毕！");
+                            // 判断是否需要发送动态中的图片
+                            if (this.config.pushImgsInDynamic) {
+                                // logger
+                                this.logger.info("开始推送动态中的图片...");
+                                // 判断是否为图文动态，且存在draw
+                                if (item.type === "DYNAMIC_TYPE_DRAW" &&
+                                    item.modules.module_dynamic.major?.draw) {
+                                    for (const img of item.modules.module_dynamic.major.draw
+                                        .items) {
+                                        await this.sendMsg(sub.target, (0, jsx_runtime_1.jsx)("img", { src: img.src, alt: "\u52A8\u6001\u56FE\u7247" }));
+                                    }
                                 }
-                                this.logger.info("动态图片推送完毕！");
+                                // logger
+                                this.logger.info("图片推送完毕！");
                             }
+                            // logger
+                            this.logger.info("动态推送完毕！");
                         }
-                        // logger
-                        this.logger.info("动态推送完毕！");
                     }
                 }
             }
             // 更新本次请求第一条动态的动态ID
-            dynamicIdStr1st = items[0]?.id_str || "0";
-            dynamicIdStr2nd = items[1]?.id_str || "0";
+            dynamicIdStr1st = items[0].id_str;
+            // logger
+            this.logger.info(`更新本次请求第一条动态的动态ID:${dynamicIdStr1st}`);
+            // 更新时间线
+            timeline =
+                items[0].modules.module_author.pub_ts || luxon_1.DateTime.now().toSeconds();
+            // logger
+            this.logger.info(`更新时间线:${timeline}`);
         };
         // 返回一个闭包函数
         return (0, utils_1.withLock)(handler);

package/lib/generateImg.d.ts

@@ -8,6 +8,7 @@ declare class GenerateImg extends Service {
     static inject: string[];
     giConfig: GenerateImg.Config;
     constructor(ctx: Context, config: GenerateImg.Config);
+    compressImage(buffer: Buffer): Promise<Buffer>;
     imgHandler(html: string): Promise<Buffer<ArrayBufferLike>>;
     generateLiveImg(data: any, username: string, userface: string, followerDisplay: string, liveStatus: number, { cardColorStart, cardColorEnd, cardBasePlateColor, cardBasePlateBorder, }: {
         cardColorStart?: string;
@@ -15,7 +16,7 @@ declare class GenerateImg extends Service {
         cardBasePlateColor?: string;
         cardBasePlateBorder?: string;
     }): Promise<Buffer<ArrayBufferLike>>;
-    generateDynamicImg(data: any, { cardColorStart, cardColorEnd, cardBasePlateColor, cardBasePlateBorder, }: {
+    generateDynamicImg(data: any, { cardColorStart, cardColorEnd, cardBasePlateColor, cardBasePlateBorder, }?: {
         cardColorStart?: string;
         cardColorEnd?: string;
         cardBasePlateColor?: string;

package/lib/generateImg.js

@@ -1,7 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const koishi_1 = require("koishi");
 const luxon_1 = require("luxon");
+const imagemin_1 = __importDefault(require("imagemin"));
+const imagemin_pngquant_1 = __importDefault(require("imagemin-pngquant"));
 const node_path_1 = require("node:path");
 const node_url_1 = require("node:url");
 const utils_1 = require("./utils");
@@ -29,6 +34,25 @@ class GenerateImg extends koishi_1.Service {
         super(ctx, "gi");
         this.giConfig = config;
     }
+    async compressImage(buffer) {
+        return await (0, utils_1.withRetry)(async () => {
+            const compressedBuffer = await imagemin_1.default.buffer(buffer, {
+                plugins: [
+                    (0, imagemin_pngquant_1.default)({
+                        quality: [0.6, 0.8],
+                        speed: 4,
+                    }),
+                ],
+            });
+            if (compressedBuffer.length >= buffer.length) {
+                return buffer;
+            }
+            return Buffer.from(compressedBuffer);
+        }, 1).catch((e) => {
+            this.ctx.logger.error(`压缩图片失败: ${e.message}`);
+            return buffer;
+        });
+    }
     async imgHandler(html) {
         const htmlPath = `file://${__dirname.replaceAll("\\", "/")}/page/0.html`;
         const page = await this.ctx.puppeteer.page();
@@ -47,7 +71,7 @@ class GenerateImg extends koishi_1.Service {
         });
         await elementHandle.dispose();
         await page.close();
-        return buffer;
+        return this.compressImage(buffer);
     }
     async generateLiveImg(
     // biome-ignore lint/suspicious/noExplicitAny: <explanation>
@@ -216,7 +240,7 @@ class GenerateImg extends koishi_1.Service {
     }
     async generateDynamicImg(
     // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-    data, { cardColorStart = this.giConfig.cardColorStart, cardColorEnd = this.giConfig.cardColorEnd, cardBasePlateColor = this.giConfig.cardBasePlateColor, cardBasePlateBorder = this.giConfig.cardBasePlateBorder, }) {
+    data, { cardColorStart = this.giConfig.cardColorStart, cardColorEnd = this.giConfig.cardColorEnd, cardBasePlateColor = this.giConfig.cardBasePlateColor, cardBasePlateBorder = this.giConfig.cardBasePlateBorder, } = {}) {
         // module_author
         const module_author = data.modules.module_author;
         const avatarUrl = module_author.face;

package/lib/type/index.d.ts

@@ -70,6 +70,7 @@ export type AllDynamicInfo = {
                     mid: number;
                     name: string;
                     face: string;
+                    pub_ts: number;
                 };
                 module_dynamic: {
                     major: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-bilibili-notify",
   "description": "Koishi bilibili notify plugin",
-  "version": "3.0.3",
+  "version": "3.0.5-alpha.0",
   "contributors": [
     "Akokko <admin@akokko.com>"
   ],
@@ -30,6 +30,8 @@
     "axios": "^1.7.9",
     "axios-cookiejar-support": "^5.0.5",
     "blive-message-listener": "^0.5.0",
+    "imagemin": "^9.0.1",
+    "imagemin-pngquant": "^10.0.0",
     "jsdom": "^24.1.3",
     "luxon": "^3.5.0",
     "md5": "^2.3.0",
@@ -39,6 +41,7 @@
   },
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
+    "@types/imagemin": "^9",
     "@types/luxon": "^3.4.2",
     "@types/md5": "^2.3.5",
     "@types/qrcode": "^1.5.5",

package/readme.md

@@ -27,7 +27,7 @@
 
 ## 注意事项
 
-0. 动态监测，当您订阅之后，会在您设置的dynamicLoopTime(默认为2分钟)之后才会开启监测。如果您需要测试则需要等待您设置的dynamicLoopTime的时间之后再发送测试动态
+0. 由于 `3.0.2` 动态监测定时器更换为cron定时任务，如果需要测试动态监测功能是否正常，可以通过控制台日志输出观察，打印 `动态监测初始化完毕！` 后，可进行测试
 
 1. 此插件依赖于 `database` 和 `puppeteer` 服务，同时受权限控制，需要具备 `authority:3` 及以上的权限才能使用本插件提供的指令，你可以参考下方配置登录插件中的方法得到一个超级管理员账号（具有 `authority:5` 的最高权限） 
 
@@ -38,6 +38,7 @@
    [权限管理](https://koishi.chat/zh-CN/manual/usage/customize.html)
 
 3. 指令使用方法请参考 `help bili`，子命令使用方法请加 `-h` ，例如 `bili login -h`
+
 4. 登录方式为二维码，输入命令 `bili login` 之后扫码登录，您的登录凭证将存储在您的本地数据库，并由您自己填写的密钥加密，所以请保管好你的密钥
 
 ## 安装
@@ -63,6 +64,12 @@
 
 - 使用指令 `bili ll`
 
+推送指定UP主指定动态：
+
+- 使用指令 `bili dyn <uid> [index]`
+
+uid为必填参数，为要推送的UP主的UID，index为可选参数，为要推送的动态排序，不应超过15，不填默认第一条。例如要推送UID为 `233` 的UP主的第九条动态 `bili dyn 233 9`
+
 插件的启动、停止和重启
 
 - 使用指令 `sys`
@@ -219,6 +226,8 @@
 - ver 3.0.1 修复：动态推送过程中，如果上一次请求的第一条动态被删除，可能导致动态重复推送(本次修复并不能完全保障不重复推送，如果第一条和第二条都被删除则可能会出现重复推送)； 新增：配置项 `subTimeout` 设置订阅超时时间
 - ver 3.0.2 优化：动态监测，新增依赖服务 `cron`
 - ver 3.0.3 移除：配置项 `dynamicLoopTime` ，动态循环时间将不再可选，默认为两分钟
+- ver 3.0.4 优化：动态监测，增加时间判断，防止出现重复推送问题； 由于 `3.0.2` 动态监测定时器更换为cron定时任务，如果需要测试动态监测功能是否正常，可以通过控制台日志输出观察，打印 `动态监测初始化完毕！` 后，可进行测试
+- ver 3.0.5-alpha.0 优化：推送卡片渲染，压缩图片； 新增：指令 `bili dyn` 可用于推送指定UP主指定动态
 
 ## 交流群
 
@@ -227,7 +236,9 @@
 ## 感谢
 
 [koishijs](https://github.com/koishijs/koishi) 感谢官方提供的插件开发框架, 以及技术指导
+
 [blive-message-listener](https://github.com/ddiu8081/blive-message-listener) 感谢 `ddiu8081` 提供简单方便的B站直播监听依赖
+
 [bilibili-API-collect](https://github.com/SocialSisterYi/bilibili-API-collect) 感谢 `SocialSisterYi` 提供B站API参考
 
 ## License