yz-yuki-plugin 2.0.6-1 → 2.0.6-11

package/.puppeteerrc.cjs

@@ -1,4 +1,44 @@
+const os = require('os');
+const { existsSync } = require('fs');
+const { execSync } = require('child_process');
+const arch = os.arch();
+
+let skipDownload = false;
+let executablePath;
+
+if (['linux', 'android'].includes(process.platform))
+  for (const item of ['chromium', 'chromium-browser', 'chrome', 'google-chrome'])
+    try {
+      const chromiumPath = execSync(`command -v ${item}`).toString().trim();
+      if (chromiumPath && existsSync(chromiumPath)) {
+        executablePath = chromiumPath;
+        break;
+      }
+    } catch (err) {}
+
+/**
+ * @type {string} 浏览器 "可执行文件路径" 列表，可根据需要自行修改或添加
+ */
+if (!executablePath)
+  for (const item of [
+    // Windows
+    'C:/Program Files/Google/Chrome/Application/chrome.exe',
+    'C:/Program Files (x86)/Microsoft/Edge/Application/msedge.exe',
+    // macOS
+    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+    '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge'
+  ])
+    if (existsSync(item)) {
+      executablePath = item;
+      break;
+    }
+
+if (executablePath || arch == 'arm64' || arch == 'aarch64') {
+  (typeof logger != 'undefined' ? logger : console).info(`[Chromium] ${executablePath}`);
+  skipDownload = true;
+}
+
 /**
  * @type {import("puppeteer").Configuration}
  */
-module.exports = require('jsxp/.puppeteerrc');
+module.exports = { skipDownload, executablePath };

package/CHANGELOG.md

@@ -1,6 +1,8 @@
 # 2.0.6
+* 优化消息发送
 * 优化文字动态图片资源的发送
 * 依赖升级
+* 新增哔哩直播动态@全体成员功能，开启前请检查机器人管理员权限和所在聊天类型是否支持
 
 # 2.0.5
 * 优化ck

package/README.md

@@ -8,6 +8,29 @@
 
 [![访问量](https://profile-counter.glitch.me/yuki-plugin/count.svg)](https://github.com/snowtafir/yuki-plugin)
 
+
+# 🚩运行环境：
+1. 系统：
+* windows 10/11+，
+* Linux推荐：CentOS Stream 8 +, Debian 12+, Fedora 35+
+
+2. node v22+ 下载地址：https://nodejs.org/zh-cn/download/
+
+3. 推荐使用chrome或chromium浏览器，其他浏览器可能存在兼容性问题。
+* chrome 浏览器 v131+  win_x64下载地址：https://www.google.cn/chrome/
+* chromium 浏览器 v128+ Linux/win手动下载安装：https://download-chromium.appspot.com
+
+> linux命令行安装chromiun浏览器：
+```sh
+sudo apt-get install chromium-browser # Ubuntu/Debian
+sudo dnf install chromium # Fedora
+sudo yum install chromium # CentOS Stream 8
+
+#查看版本
+chromium-browser --version
+```
+> 注意，如果windows下手动安装chromium浏览器，或安装了其他修改版chrome浏览器，出现找不到浏览器，需要手动将`可执行文件路径`添加到 [./.puppeteerrc.cjs](./.puppeteerrc.cjs) 的路径列表中。
+
 # 🌰一、安装插件
 
 ## 选择安装方式

package/defaultConfig/bilibili/config.yaml

@@ -1,7 +1,7 @@
 # b站推送，1 开启 0 关闭，保留添加的相关数据，但是不再推送
 pushStatus: 1
 
-# 检测b站动态的周期，Cron表达式，作用域共6位，具体方法浏览器搜索 “node-schedule cron表达式”，示例：
+# 检测b站动态的冷却时间 CD，Cron表达式，作用域共6位，具体方法浏览器搜索 “node-schedule cron表达式”，示例：
 # "*/15  * * * *" #每15min检测一次
 # "*/31  * * * *" #每31min检测一次
 # "0 5,35 * * * *" #每小时固定第5分0秒、第35分0秒检测一次，共2次/h
@@ -58,3 +58,16 @@ noSplitHeight: 7500
 
 # 动态卡片分页截图高度，默认8000px（仅填数字，无需填入单位），请勿设置过大或过小。启用分片截图时生效。
 splitHeight: 8000
+
+# 直播动态是否@全体成员，默认 0 关闭，1 开启。开启前请检查 <机器人> 是否有 [管理员权限] 或 [聊天平台是否支持]，某些聊天平台或类型不支持@全体成员，如qq官方机器人等。
+liveAtAll: 0
+
+# 直播动态@全体成员的群组/聊天/私聊列表，默认为空即不在任何群于推送直播动态中执行@全体成员。开启liveAtAll后才会生效。
+liveAtAllGroupList:
+  - 1234567890 # 示例群号
+
+# 直播动态@全体成员的共享冷却时间CD，单位秒，默认 1800 秒（30分钟），即每个群聊30分钟内不论多少条直播动态，只会@一次。注意，qq群有 @全体成员 10次/日 的限制，所以请合理设置。
+liveAtAllCD: 1800
+
+# 直播动态@全体成员失败时是否发送错误消息，默认 1 发送，0 不发送。开启liveAtAll后才会生效。
+liveAtAllErrMsg: 1

package/defaultConfig/weibo/config.yaml

@@ -1,7 +1,7 @@
 # 微博推送，1 开启 0 关闭，保留添加的相关数据，但是不再推送
 pushStatus: 1
 
-# 检测微博动态的周期，Cron表达式，作用域共6位，具体方法浏览器搜索 “node-schedule cron表达式”，示例：
+# 检测微博动态的冷却时间 CD，Cron表达式，作用域共6位，具体方法浏览器搜索 “node-schedule cron表达式”，示例：
 # "*/15  * * * *" #每15min检测一次
 # "*/31  * * * *" #每31min检测一次
 # "0 5,35 * * * *" #每小时固定第5分0秒、第35分0秒检测一次，共2次/h

package/lib/apps/weibo.js

@@ -1,8 +1,8 @@
 import { Messages } from 'yunzaijs';
-import { WeiboQuery } from '../models/weibo/weibo.query.js';
-import { WeiboTask } from '../models/weibo/weibo.task.js';
+import { WeiboQuery } from '../models/weibo/weibo.main.query.js';
+import { WeiboTask } from '../models/weibo/weibo.main.task.js';
 import Config from '../utils/config.js';
-import { WeiboGetWebData } from '../models/weibo/weibo.get.web.data.js';
+import { WeiboGetWebData } from '../models/weibo/weibo.main.get.web.data.js';
 
 const message = new Messages('message');
 let weiboPushData = Config.getConfigData('config', 'weibo', 'push');
@@ -58,7 +58,7 @@ message.use(async (e) => {
         }
         const userInfo = data.userInfo || {};
         let name = uid;
-        if (userInfo && userInfo.length !== 0) {
+        if (userInfo.length !== 0) {
             name = userInfo.screen_name || uid;
         }
         // 添加新的推送数据

package/lib/index.js

@@ -5,7 +5,7 @@ import path from 'path';
 import { _paths } from './utils/paths.js';
 import * as index$1 from './apps/index.js';
 import { BiliTask } from './models/bilibili/bilibili.main.task.js';
-import { WeiboTask } from './models/weibo/weibo.task.js';
+import { WeiboTask } from './models/weibo/weibo.main.task.js';
 
 const yukiPluginVersion = Config.getPackageJsonKey('version', path.join(_paths.pluginPath, 'package.json'));
 let biliConfigData = Config.getConfigData('config', 'bilibili', 'config');

package/lib/models/bilibili/bilibili.main.query.js

@@ -395,7 +395,8 @@ class BiliQuery {
         const BiliDrawDynamicLinkUrl = 'https://m.bilibili.com/dynamic/';
         let desc, msg = [], pics = [], author, majorType, content, dynamicTitle;
         let title = `B站【${upName}】动态推送：\n`;
-        switch (data.type) {
+        let dynamicType = data.type;
+        switch (dynamicType) {
             case 'DYNAMIC_TYPE_AV':
                 // 处理视频动态
                 desc = data?.modules?.module_dynamic?.major?.archive;
@@ -412,7 +413,7 @@ class BiliQuery {
                     `时间：${author ? moment(author.pub_ts * 1000).format('YYYY年MM月DD日 HH:mm:ss') : ''}`
                 ];
                 pics = [Segment.image(desc?.cover)];
-                return { msg, pics };
+                return { msg, pics, dynamicType };
             case 'DYNAMIC_TYPE_WORD':
                 // 处理文字动态
                 author = data?.modules?.module_author;
@@ -442,7 +443,7 @@ class BiliQuery {
                     `链接：${BiliDrawDynamicLinkUrl}${data.id_str}\n`,
                     `时间：${author ? moment(author.pub_ts * 1000).format('YYYY年MM月DD日 HH:mm:ss') : ''}`
                 ];
-                return { msg, pics };
+                return { msg, pics, dynamicType };
             case 'DYNAMIC_TYPE_DRAW':
                 // 处理图文动态
                 author = data?.modules?.module_author;
@@ -488,7 +489,7 @@ class BiliQuery {
                     `链接：${BiliDrawDynamicLinkUrl}${data.id_str}\n`,
                     `时间：${author ? moment(author.pub_ts * 1000).format('YYYY年MM月DD日 HH:mm:ss') : ''}`
                 ];
-                return { msg, pics };
+                return { msg, pics, dynamicType };
             case 'DYNAMIC_TYPE_ARTICLE':
                 // 处理文章动态
                 author = data?.modules?.module_author;
@@ -531,7 +532,7 @@ class BiliQuery {
                     `链接：${this.formatUrl(desc.jump_url)}\n`,
                     `时间：${author ? moment(author.pub_ts * 1000).format('YYYY年MM月DD日 HH:mm:ss') : ''}`
                 ];
-                return { msg, pics };
+                return { msg, pics, dynamicType };
             case 'DYNAMIC_TYPE_FORWARD':
                 // 处理转发动态
                 author = data?.modules?.module_author;
@@ -561,7 +562,7 @@ class BiliQuery {
                     '\n---以下为转发内容---\n',
                     ...origContent
                 ];
-                return { msg, pics };
+                return { msg, pics, dynamicType };
             case 'DYNAMIC_TYPE_LIVE_RCMD':
                 // 处理直播动态
                 desc = data?.modules?.module_dynamic?.major?.live_rcmd?.content;
@@ -574,7 +575,7 @@ class BiliQuery {
                 title = `B站【${upName}】直播动态推送：\n`;
                 msg = [title, `-----------------------------\n`, `标题：${desc.title}\n`, `链接：https:${desc.link}`];
                 pics = [Segment.image(desc.cover)];
-                return { msg, pics };
+                return { msg, pics, dynamicType };
             default:
                 // 处理未定义的动态类型
                 global?.logger?.mark(`未处理的B站推送【${upName}】：${data.type}`);

package/lib/models/bilibili/bilibili.main.task.js

@@ -33,15 +33,22 @@ class BiliTask {
         }
         return resjson;
     }
+    /**
+     * 执行动态推送任务
+     */
     async runTask() {
         let biliConfigData = await Config.getUserConfig('bilibili', 'config');
         let biliPushData = await Config.getUserConfig('bilibili', 'push');
         let interval = biliConfigData?.interval || 7200;
+        logger.debug(`当前B站功能配置：${JSON.stringify(biliConfigData)}`);
         const uidMap = new Map(); // 存放group 和 private 对应所属 uid 与推送信息的映射
         const dynamicList = {}; // 存放获取的所有动态，键为 uid，值为动态数组
         await this.processBiliData(biliPushData, biliConfigData, uidMap, dynamicList);
         let now = Date.now() / 1000; // 时间戳（秒）
-        await this.pushDynamicMessages(uidMap, dynamicList, now, interval, biliConfigData);
+        // 定义待推送动态消息映射
+        const messageMap = new Map();
+        await this.makeUidDynamicDataMap(uidMap, dynamicList, now, interval, biliConfigData, messageMap);
+        await this.sendDynamicMessage(messageMap, biliConfigData);
     }
     /**
      * 处理Bilibili数据，获取动态列表并构建 uid 映射
@@ -101,17 +108,17 @@ class BiliTask {
                 }
             }
         }
-        requestedDataOfUids.clear(); // 清空已请求的映射
+        requestedDataOfUids.clear(); // 清空已请求的 uid 映射
     }
     /**
-     * 推送动态消息
+     * 构建uid对应动态数据映射
      * @param uidMap uid 映射
      * @param dynamicList 动态列表
      * @param now 当前时间戳
      * @param interval 推送间隔时间
      * @param biliConfigData Bilibili配置数据
      */
-    async pushDynamicMessages(uidMap, dynamicList, now, interval, biliConfigData) {
+    async makeUidDynamicDataMap(uidMap, dynamicList, now, interval, biliConfigData, messageMap) {
         for (let [chatType, chatTypeMap] of uidMap) {
             for (let [key, value] of chatTypeMap) {
                 const tempDynamicList = dynamicList[key] || [];
@@ -142,7 +149,7 @@ class BiliTask {
                         for (let chatId of chatIds) {
                             if (type && type.length && !type.includes(pushDynamicData.type))
                                 continue; // 如果禁用了某类型的动态推送，跳过当前循环
-                            await this.sendDynamic(chatId, bot_id, upName, pushDynamicData, biliConfigData, chatType); // 发送动态消息
+                            await this.makeDynamicMessageMap(chatId, bot_id, upName, pushDynamicData, biliConfigData, chatType, messageMap); // 发送动态消息
                             await this.randomDelay(1000, 2000); // 随机延时1-2秒
                         }
                     }
@@ -151,15 +158,15 @@ class BiliTask {
         }
     }
     /**
-     * 发送动态消息
+     * 渲染构建待发送的动态消息数据的映射数组
      * @param chatId 聊天 ID
      * @param bot_id 机器人 ID
-     * @param upName 用户名
+     * @param upName up主用户名
      * @param pushDynamicData 推送动态数据
      * @param biliConfigData 哔哩配置数据
      * @param chatType 聊天类型
      */
-    async sendDynamic(chatId, bot_id, upName, pushDynamicData, biliConfigData, chatType) {
+    async makeDynamicMessageMap(chatId, bot_id, upName, pushDynamicData, biliConfigData, chatType, messageMap) {
         const id_str = pushDynamicData.id_str;
         let sended = null, markKey = '';
         if (chatType === 'group') {
@@ -172,7 +179,9 @@ class BiliTask {
         }
         if (sended)
             return; // 如果已经发送过，则直接返回
-        if (!!biliConfigData.pushMsgMode) {
+        // 判断推送内容模式
+        let pushMsgMode = !!biliConfigData.pushMsgMode === false ? 'TEXT' : 'PIC'; // 是否启用图文模式，默认为 PIC 截图模式
+        if (pushMsgMode === 'PIC') {
             const { data, uid } = await BiliQuery.formatDynamicData(pushDynamicData); // 处理动态数据
             const extentData = { ...data };
             const eval2 = eval;
@@ -200,43 +209,31 @@ class BiliTask {
             };
             let imgs = await this.renderDynamicCard(uid, renderData, ScreenshotOptionsData);
             if (!imgs)
-                return;
-            Redis.set(`${markKey}${chatId}:${id_str}`, '1', { EX: 3600 * 72 }); // 设置已发送标记
-            logger?.mark('优纪插件：B站动态执行推送');
-            for (let i = 0; i < imgs.length; i++) {
-                const image = imgs[i];
-                await this.sendMessage(chatId, bot_id, chatType, Segment.image(image));
-                await this.randomDelay(1000, 2000); // 随机延时1-2秒
-            }
-            await new Promise(resolve => setTimeout(resolve, 1000)); // 休眠1秒
+                return; // 如果渲染失败，则直接返回
+            await this.addMessageToMap(messageMap, chatType, bot_id, chatId, 'SINGLE', id_str, extentData?.type, imgs.map(img => Segment.image(img)));
         }
         else {
             const dynamicMsg = await BiliQuery.formatTextDynamicData(upName, pushDynamicData, false, biliConfigData); // 构建图文动态消息
-            Redis.set(`${markKey}${chatId}:${id_str}`, '1', { EX: 3600 * 72 }); // 设置已发送标记
             if (dynamicMsg === undefined || dynamicMsg === 'continue') {
                 return 'return'; // 如果动态消息构建失败，则直接返回
             }
-            if (biliConfigData.banWords.length > 0) {
-                const banWords = new RegExp(biliConfigData.banWords.join('|'), 'g'); // 构建屏蔽关键字正则表达式
+            const getBanWords = biliConfigData?.banWords;
+            if (getBanWords && Array.isArray(getBanWords) && getBanWords.length > 0) {
+                const banWords = new RegExp(getBanWords.join('|'), 'g'); // 构建屏蔽关键字正则表达式
                 if (banWords.test(dynamicMsg.msg.join(''))) {
                     return 'return'; // 如果动态消息包含屏蔽关键字，则直接返回
                 }
             }
             let mergeTextPic = !!biliConfigData.mergeTextPic === false ? false : true; // 是否合并文本和图片，默认为 true
-            if (mergeTextPic) {
+            //开启了合并文本和图片
+            if (mergeTextPic === true) {
                 const mergeMsg = [...dynamicMsg.msg, ...dynamicMsg.pics];
-                await this.sendMessage(chatId, bot_id, chatType, mergeMsg);
+                await this.addMessageToMap(messageMap, chatType, bot_id, chatId, 'MERGE', id_str, dynamicMsg.dynamicType, mergeMsg);
             }
             else {
-                await this.sendMessage(chatId, bot_id, chatType, dynamicMsg.msg);
-                const pics = dynamicMsg.pics;
-                if (pics && pics.length > 0) {
-                    for (let i = 0; i < pics.length; i++) {
-                        await this.sendMessage(chatId, bot_id, chatType, pics[i]);
-                        await this.randomDelay(1000, 2000); // 随机延时1-2秒
-                    }
-                }
-                await new Promise(resolve => setTimeout(resolve, 1000));
+                //不合并文本和图片
+                await this.addMessageToMap(messageMap, chatType, bot_id, chatId, 'MERGE', id_str, dynamicMsg.dynamicType, dynamicMsg.msg);
+                await this.addMessageToMap(messageMap, chatType, bot_id, chatId, 'SINGLE', id_str, dynamicMsg.dynamicType, dynamicMsg.pics);
             }
         }
     }
@@ -317,13 +314,105 @@ class BiliTask {
         }
     }
     /**
-     * 发送消息
+     * 收集消息映射
+     * @param messageMap 消息映射
+     * @param chatType 聊天类型
+     * @param bot_id 机器人 ID
+     * @param chatId 聊天 ID
+     * @param sendMode 发送模式: SINGLE 逐条发送，MERGE 合并发送
+     * @param dynamicUUid_str 动态 UUID
+     * @param dynamicType 动态类型
+     * @param message 消息内容
+     */
+    async addMessageToMap(messageMap, chatType, bot_id, chatId, sendMode, dynamicUUid_str, dynamicType, messages) {
+        if (!messageMap.has(chatType)) {
+            messageMap.set(chatType, new Map());
+        }
+        const botMap = messageMap.get(chatType);
+        if (!botMap?.has(bot_id)) {
+            botMap?.set(bot_id, new Map());
+        }
+        const chatMap = botMap?.get(bot_id);
+        if (!chatMap?.has(chatId)) {
+            chatMap?.set(chatId, []);
+        }
+        chatMap?.get(chatId)?.push({ sendMode, dynamicUUid_str, dynamicType, messages });
+    }
+    /**
+     * 推送动态消息
+     * @param messageMap 消息映射
+     * @param biliConfigData 哔哩配置数据
+     */
+    async sendDynamicMessage(messageMap, biliConfigData) {
+        let liveAtAll = !!biliConfigData.liveAtAll === true ? true : false; // 直播动态是否@全体成员，默认false
+        let liveAtAllCD = biliConfigData.liveAtAllCD || 1800; // 直播动态@全体成员 冷却时间CD，默认 30 分钟
+        // 直播动态@全体成员的群组/好友列表，默认空数组，为空则不进行@全体成员操作
+        let liveAtAllGroupList = new Set(Array.isArray(biliConfigData?.liveAtAllGroupList) ? Array.from(biliConfigData.liveAtAllGroupList).map(item => String(item)) : []);
+        const LogMark = new Set(); // 日志mark
+        for (const [chatType, botMap] of messageMap) {
+            for (const [bot_id, chatMap] of botMap) {
+                for (const [chatId, messageCombinationList] of chatMap) {
+                    // 遍历组合消息
+                    for (const messageCombination of messageCombinationList) {
+                        const { sendMode, dynamicUUid_str, dynamicType, messages } = messageCombination;
+                        let sended = null;
+                        let markKey = '';
+                        if (chatType === 'group') {
+                            markKey = this.groupKey;
+                            sended = await Redis.get(`${markKey}${chatId}:${dynamicUUid_str}`);
+                        }
+                        else if (chatType === 'private') {
+                            markKey = this.privateKey;
+                            sended = await Redis.get(`${markKey}${chatId}:${dynamicUUid_str}`);
+                        }
+                        const sendMarkKey = `${markKey}${chatId}:${dynamicUUid_str}`;
+                        if (sended) {
+                            continue; // 如果已经发送过，则直接跳过
+                        }
+                        if (!LogMark.has('1')) {
+                            global?.logger?.mark('优纪插件: B站动态执行推送');
+                            LogMark.add('1');
+                        }
+                        let liveAtAllMark = await Redis.get(`${markKey}${chatId}:liveAtAllMark`); // 直播动态@全体成员标记，默认 0
+                        // 如果开启了直播动态@全体成员
+                        if (liveAtAll && !liveAtAllMark && dynamicType === 'DYNAMIC_TYPE_LIVE_RCMD' && liveAtAllGroupList.has(String(chatId))) {
+                            try {
+                                await this.sendMessageApi(chatId, bot_id, chatType, [Segment.at('all')]);
+                                await Redis.set(`${markKey}${chatId}:liveAtAllMark`, 1, { EX: liveAtAllCD }); // 设置直播动态@全体成员标记为 1
+                            }
+                            catch (error) {
+                                logger.error(`直播动态发送@全体成员失败，请检查 <机器人> 是否有 [管理员权限] 或 [聊天平台是否支持] ：${error}`);
+                                let liveAtAllErrMsg = !!biliConfigData.liveAtAllErrMsg === false ? false : true; // 直播动态@全体成员失败是否发送错误提示消息，默认 false
+                                if (liveAtAllErrMsg) {
+                                    await this.sendMessageApi(chatId, bot_id, chatType, ['直播动态发送@全体成员失败，请检查权限或平台是否支持']);
+                                }
+                            }
+                        }
+                        if (sendMode === 'SINGLE') {
+                            for (let i = 0; i < messages.length; i++) {
+                                await this.sendMessageApi(chatId, bot_id, chatType, messages[i]);
+                            }
+                            await Redis.set(sendMarkKey, '1', { EX: 3600 * 72 }); // 发送成功后设置标记
+                            await this.randomDelay(1000, 2000); // 随机延时1-2秒
+                        }
+                        else if (sendMode === 'MERGE') {
+                            await this.sendMessageApi(chatId, bot_id, chatType, messages);
+                            await Redis.set(sendMarkKey, '1', { EX: 3600 * 72 }); // 发送成功后设置标记
+                        }
+                    }
+                }
+            }
+        }
+        LogMark.clear(); // 清空日志mark
+    }
+    /**
+     * 发送消息api
      * @param chatId 聊天 ID
      * @param bot_id 机器人 ID
      * @param chatType 聊天类型
      * @param message 消息内容
      */
-    async sendMessage(chatId, bot_id, chatType, message) {
+    async sendMessageApi(chatId, bot_id, chatType, message) {
         if (chatType === 'group') {
             await (Bot[bot_id] ?? Bot)
                 ?.pickGroup(String(chatId))

package/lib/models/bilibili/bilibili.risk.w_webid.js

@@ -7,7 +7,8 @@ import { readSyncCookie, cookieWithBiliTicket } from './bilibili.main.models.js'
 async function getWebId(uid) {
     const w_webid_key = 'Yz:yuki:bili:w_webid';
     const w_webid = await Redis.get(w_webid_key);
-    if (w_webid) {
+    const keyTTL = await Redis.ttl(w_webid_key);
+    if (w_webid && keyTTL < 259200) {
         return String(w_webid);
     }
     else {
@@ -28,8 +29,10 @@ async function getWebId(uid) {
             const decoded__RENDER_DATA__JsonString = decodeURIComponent(__RENDER_DATA__[1]);
             const accessIdRegex = /"access_id":"(.*?)"/;
             const access_id = decoded__RENDER_DATA__JsonString.match(accessIdRegex);
-            if (access_id && access_id[1]) {
-                await Redis.set(w_webid_key, access_id[1], { EX: 43197 * 1000 });
+            const ExpirationTimeRegex = /document.getElementById\("__RENDER_DATA__"\).*?setTimeout\(function\(\)\s*{window.location.reload\(true\);},\s*(\d+)\s*\*\s*(\d+)\);<\/script>/;
+            const ExpirationTime = htmlContent.match(ExpirationTimeRegex);
+            if (access_id && access_id[1] && ExpirationTime && ExpirationTime[1]) {
+                await Redis.set(w_webid_key, access_id[1], { EX: Number(ExpirationTime[1]) });
                 return String(access_id[1]);
             }
             else {

package/lib/models/weibo/{weibo.get.web.data.js → weibo.main.get.web.data.js}

@@ -1,6 +1,6 @@
 import axios from 'axios';
-import { WeiboApi } from './weibo.api.js';
-import { WeiboQuery } from './weibo.query.js';
+import { WeiboApi } from './weibo.main.api.js';
+import { WeiboQuery } from './weibo.main.query.js';
 
 class WeiboGetWebData {
     e;

package/lib/models/weibo/{weibo.query.js → weibo.main.query.js}

@@ -1,6 +1,6 @@
 import moment from 'moment';
 import fetch from 'node-fetch';
-import { WeiboApi } from './weibo.api.js';
+import { WeiboApi } from './weibo.main.api.js';
 import { Segment } from 'yunzaijs';
 import { JSDOM } from 'jsdom';
 
@@ -29,9 +29,12 @@ class WeiboQuery {
         else if (raw_post?.mblog?.pics) {
             return 'DYNAMIC_TYPE_DRAW';
         }
-        else {
+        else if (!raw_post?.mblog?.pics && String(raw_post?.mblog?.text).trim().length > 0) {
             return 'DYNAMIC_TYPE_ARTICLE';
         }
+        else {
+            return 'DYNAMIC_TYPE_UNKNOWN';
+        }
     }
     /**筛选正文 */
     static filterText(raw_text) {
@@ -77,6 +80,7 @@ class WeiboQuery {
         formatData.data.name = nick_name;
         /**头像框 */
         formatData.data.pendant = '';
+        /**生成日期 */
         formatData.data.created = moment().format('YYYY年MM月DD日 HH:mm:ss');
         formatData.data.type = type;
         switch (type) {
@@ -182,7 +186,7 @@ class WeiboQuery {
         let info = raw_post?.mblog || raw_post;
         let retweeted = info && info.retweeted_status ? true : false; //是否为转发动态
         let pic_num = retweeted ? info?.retweeted_status?.pic_num : info?.pic_num;
-        let type = this.MakeCategory(raw_post);
+        let dynamicType = this.MakeCategory(raw_post);
         /**获取动态全文 */
         if (info?.isLongText || pic_num > 9) {
             const res = await fetch(`https://m.weibo.cn/detail/${info.mid}`, { headers: WeiboApi.WEIBO_HEADERS });
@@ -203,7 +207,7 @@ class WeiboQuery {
         let detail_url = `https://weibo.com/${info?.user?.id}/${info?.bid}`;
         let title = `微博【${upName}】动态推送：\n`;
         const dynamicPicCountLimit = setData.pushPicCountLimit || 3;
-        switch (type) {
+        switch (dynamicType) {
             case 'DYNAMIC_TYPE_AV':
                 if (!info)
                     return;
@@ -219,7 +223,7 @@ class WeiboQuery {
                     `时间：${created_time ? moment(created_time).format('YYYY年MM月DD日 HH:mm:ss') : ''}`
                 ];
                 pics = [cover_img];
-                return { msg, pics };
+                return { msg, pics, dynamicType };
             case 'DYNAMIC_TYPE_DRAW':
                 raw_pics_list = retweeted ? info?.retweeted_status?.pics || [] : info?.pics || [];
                 if (!info && !raw_pics_list)
@@ -239,7 +243,7 @@ class WeiboQuery {
                     `链接：${detail_url}\n`,
                     `时间：${created_time ? moment(created_time).format('YYYY年MM月DD日 HH:mm:ss') : ''}`
                 ];
-                return { msg, pics };
+                return { msg, pics, dynamicType };
             case 'DYNAMIC_TYPE_ARTICLE':
                 if (!info)
                     return;
@@ -259,7 +263,7 @@ class WeiboQuery {
                     `链接：${detail_url}\n`,
                     `时间：${created_time ? moment(created_time).format('YYYY年MM月DD日 HH:mm:ss') : ''}`
                 ];
-                return { msg, pics };
+                return { msg, pics, dynamicType };
             case 'DYNAMIC_TYPE_FORWARD':
                 if (!info)
                     return;
@@ -286,9 +290,9 @@ class WeiboQuery {
                     '\n---以下为转发内容---\n',
                     ...origContent
                 ];
-                return { msg, pics };
+                return { msg, pics, dynamicType };
             default:
-                logger?.mark(`未处理的微博推送【${upName}】：${type}`);
+                logger?.mark(`未处理的微博推送【${upName}】：${dynamicType}`);
                 return 'continue';
         }
     }

package/lib/models/weibo/{weibo.task.js → weibo.main.task.js}

@@ -2,8 +2,8 @@ import QRCode from 'qrcode';
 import { Redis, Segment, Bot } from 'yunzaijs';
 import Config from '../../utils/config.js';
 import { renderPage } from '../../utils/image.js';
-import { WeiboGetWebData } from './weibo.get.web.data.js';
-import { WeiboQuery } from './weibo.query.js';
+import { WeiboGetWebData } from './weibo.main.get.web.data.js';
+import { WeiboQuery } from './weibo.main.query.js';
 
 class WeiboTask {
     taskName;
@@ -15,15 +15,22 @@ class WeiboTask {
         this.groupKey = 'Yz:yuki:weibo:upPush:group:';
         this.privateKey = 'Yz:yuki:weibo:upPush:private:';
     }
+    /**
+     * 执行动态推送任务
+     */
     async runTask() {
         let weiboConfigData = await Config.getUserConfig('weibo', 'config');
         let weiboPushData = await Config.getUserConfig('weibo', 'push');
         let interval = weiboConfigData.interval || 7200; // 推送间隔时间，单位为秒，默认2小时
+        logger.debug(`当前微博功能配置：${JSON.stringify(weiboConfigData)}`);
         const uidMap = new Map(); // 存放group 和 private 对应所属 uid 与推送信息的映射
         const dynamicList = {}; // 存放获取的所有动态，键为 uid，值为动态数组
         await this.processWeiboData(weiboPushData, uidMap, dynamicList);
         let now = Date.now() / 1000; // 当前时间戳（秒）
-        await this.pushDynamicMessages(uidMap, dynamicList, now, interval, weiboConfigData);
+        // 定义待推送动态消息映射
+        const messageMap = new Map();
+        await this.makeUidDynamicDataMap(uidMap, dynamicList, now, interval, weiboConfigData, messageMap);
+        await this.sendDynamicMessage(messageMap, weiboConfigData);
     }
     /**
      * 处理微博数据，获取动态列表并构建 uid 映射
@@ -70,14 +77,14 @@ class WeiboTask {
         requestedDataOfUids.clear(); // 清空已请求的映射
     }
     /**
-     * 推送动态消息
+     * 构建uid对应动态数据映射
      * @param uidMap uid 映射
      * @param dynamicList 动态列表
      * @param now 当前时间戳
      * @param interval 推送间隔时间
      * @param weiboConfigData 微博配置数据
      */
-    async pushDynamicMessages(uidMap, dynamicList, now, interval, weiboConfigData) {
+    async makeUidDynamicDataMap(uidMap, dynamicList, now, interval, weiboConfigData, messageMap) {
         for (let [chatType, chatTypeMap] of uidMap) {
             for (let [key, value] of chatTypeMap) {
                 const tempDynamicList = dynamicList[key] || [];
@@ -109,7 +116,7 @@ class WeiboTask {
                         for (let chatId of chatIds) {
                             if (type && type.length && !type.includes(pushDynamicData.type))
                                 continue; // 如果禁用了某类型的动态推送，跳过当前循环
-                            await this.sendDynamic(chatId, bot_id, upName, pushDynamicData, weiboConfigData, chatType); // 发送动态消息
+                            await this.makeDynamicMessageMap(chatId, bot_id, upName, pushDynamicData, weiboConfigData, chatType, messageMap); // 发送动态消息
                             await this.randomDelay(1000, 2000); // 随机延时1-2秒
                         }
                     }
@@ -118,15 +125,16 @@ class WeiboTask {
         }
     }
     /**
-     * 发送动态消息
+     * 渲染构建待发送的动态消息数据的映射数组
      * @param chatId 聊天 ID
      * @param bot_id 机器人 ID
-     * @param upName 用户名
+     * @param upName 博主用户名
      * @param pushDynamicData 推送动态数据
      * @param weiboConfigData 微博配置数据
      * @param chatType 聊天类型
+     * @param messageMap 待发送的动态消息映射
      */
-    async sendDynamic(chatId, bot_id, upName, pushDynamicData, weiboConfigData, chatType) {
+    async makeDynamicMessageMap(chatId, bot_id, upName, pushDynamicData, weiboConfigData, chatType, messageMap) {
         const id_str = WeiboQuery.getDynamicId(pushDynamicData); // 获取动态 ID
         let sended = null, markKey = '';
         if (chatType === 'group') {
@@ -167,43 +175,31 @@ class WeiboTask {
             };
             let imgs = await this.renderDynamicCard(uid, renderData, ScreenshotOptionsData);
             if (!imgs)
-                return;
-            Redis.set(`${markKey}${chatId}:${id_str}`, '1', { EX: 3600 * 72 }); // 设置已发送标记
-            global?.logger?.mark('优纪插件：微博动态执行推送');
-            for (let i = 0; i < imgs.length; i++) {
-                const image = imgs[i];
-                await this.sendMessage(chatId, bot_id, chatType, Segment.image(image));
-                await this.randomDelay(1000, 2000); // 随机延时1-2秒
-            }
-            await new Promise(resolve => setTimeout(resolve, 1000));
+                return; // 如果渲染失败，则直接返回
+            await this.addMessageToMap(messageMap, chatType, bot_id, chatId, 'SINGLE', id_str, extentData?.type, imgs.map(img => Segment.image(img)));
         }
         else {
             const dynamicMsg = await WeiboQuery.formatTextDynamicData(upName, pushDynamicData, false, weiboConfigData); //构建文字动态消息
-            Redis.set(`${markKey}${chatId}:${id_str}`, '1', { EX: 3600 * 72 }); // 设置已发送标记
             if (dynamicMsg === undefined || dynamicMsg === 'continue') {
                 return 'return'; // 如果动态消息构建失败或内部资源获取失败，则直接返回
             }
-            if (weiboConfigData.banWords.length > 0) {
-                const banWords = new RegExp(weiboConfigData.banWords.join('|'), 'g'); // 构建屏蔽关键字正则表达式
+            const getBanWords = weiboConfigData?.banWords;
+            if (getBanWords && Array.isArray(getBanWords) && getBanWords.length > 0) {
+                const banWords = new RegExp(getBanWords.join('|'), 'g'); // 构建屏蔽关键字正则表达式
                 if (banWords.test(dynamicMsg.msg.join(''))) {
                     return 'return'; // 如果动态消息包含屏蔽关键字，则直接返回
                 }
             }
             let mergeTextPic = !!weiboConfigData.mergeTextPic === false ? false : true; // 是否合并文字和图片，默认为 true
-            if (mergeTextPic) {
+            //开启了合并文本和图片
+            if (mergeTextPic === true) {
                 const mergeMsg = [...dynamicMsg.msg, ...dynamicMsg.pics];
-                await this.sendMessage(chatId, bot_id, chatType, mergeMsg);
+                await this.addMessageToMap(messageMap, chatType, bot_id, chatId, 'MERGE', id_str, dynamicMsg.dynamicType, mergeMsg);
             }
             else {
-                await this.sendMessage(chatId, bot_id, chatType, dynamicMsg.msg);
-                const pics = dynamicMsg.pics;
-                if (pics && pics.length > 0) {
-                    for (let i = 0; i < pics.length; i++) {
-                        await this.sendMessage(chatId, bot_id, chatType, pics[i]);
-                        await this.randomDelay(1000, 2000); // 随机延时1-2秒
-                    }
-                }
-                await new Promise(resolve => setTimeout(resolve, 1000));
+                //不合并文本和图片
+                await this.addMessageToMap(messageMap, chatType, bot_id, chatId, 'MERGE', id_str, dynamicMsg.dynamicType, dynamicMsg.msg);
+                await this.addMessageToMap(messageMap, chatType, bot_id, chatId, 'SINGLE', id_str, dynamicMsg.dynamicType, dynamicMsg.pics);
             }
         }
     }
@@ -284,13 +280,86 @@ class WeiboTask {
         }
     }
     /**
-     * 发送消息
+     * 收集消息映射
+     * @param messageMap 消息映射
+     * @param chatType 聊天类型
+     * @param bot_id 机器人 ID
+     * @param chatId 聊天 ID
+     * @param sendMode 发送模式: SINGLE 逐条发送，MERGE 合并发送
+     * @param dynamicUUid_str 动态 UUID
+     * @param dynamicType 动态类型
+     * @param message 消息内容
+     */
+    async addMessageToMap(messageMap, chatType, bot_id, chatId, sendMode, dynamicUUid_str, dynamicType, messages) {
+        if (!messageMap.has(chatType)) {
+            messageMap.set(chatType, new Map());
+        }
+        const botMap = messageMap.get(chatType);
+        if (!botMap?.has(bot_id)) {
+            botMap?.set(bot_id, new Map());
+        }
+        const chatMap = botMap?.get(bot_id);
+        if (!chatMap?.has(chatId)) {
+            chatMap?.set(chatId, []);
+        }
+        chatMap?.get(chatId)?.push({ sendMode, dynamicUUid_str, dynamicType, messages });
+    }
+    /**
+     * 推送动态消息
+     * @param messageMap 消息映射
+     * @param biliConfigData 微博配置数据
+     */
+    async sendDynamicMessage(messageMap, weiboConfigData) {
+        const LogMark = new Set(); // 日志mark
+        for (const [chatType, botMap] of messageMap) {
+            for (const [bot_id, chatMap] of botMap) {
+                for (const [chatId, messageCombinationList] of chatMap) {
+                    // 遍历组合消息
+                    for (const messageCombination of messageCombinationList) {
+                        const { sendMode, dynamicUUid_str, dynamicType, messages } = messageCombination;
+                        let sended = null;
+                        let markKey = '';
+                        if (chatType === 'group') {
+                            markKey = this.groupKey;
+                            sended = await Redis.get(`${markKey}${chatId}:${dynamicUUid_str}`);
+                        }
+                        else if (chatType === 'private') {
+                            markKey = this.privateKey;
+                            sended = await Redis.get(`${markKey}${chatId}:${dynamicUUid_str}`);
+                        }
+                        const sendMarkKey = `${markKey}${chatId}:${dynamicUUid_str}`;
+                        if (sended) {
+                            continue; // 如果已经发送过，则直接跳过
+                        }
+                        if (!LogMark.has('1')) {
+                            global?.logger?.mark('优纪插件: B站动态执行推送');
+                            LogMark.add('1');
+                        }
+                        if (sendMode === 'SINGLE') {
+                            for (let i = 0; i < messages.length; i++) {
+                                await this.sendMessageApi(chatId, bot_id, chatType, messages[i]);
+                            }
+                            await Redis.set(sendMarkKey, '1', { EX: 3600 * 72 }); // 发送成功后设置标记
+                            await this.randomDelay(1000, 2000); // 随机延时1-2秒
+                        }
+                        else if (sendMode === 'MERGE') {
+                            await this.sendMessageApi(chatId, bot_id, chatType, messages);
+                            await Redis.set(sendMarkKey, '1', { EX: 3600 * 72 }); // 发送成功后设置标记
+                        }
+                    }
+                }
+            }
+        }
+        LogMark.clear(); // 清空日志mark
+    }
+    /**
+     * 发送消息api
      * @param chatId 聊天 ID
      * @param bot_id 机器人 ID
      * @param chatType 聊天类型
      * @param message 消息内容
      */
-    async sendMessage(chatId, bot_id, chatType, message) {
+    async sendMessageApi(chatId, bot_id, chatType, message) {
         if (chatType === 'group') {
             await (Bot[bot_id] ?? Bot)
                 ?.pickGroup(String(chatId))

package/lib/utils/image.js

@@ -15,11 +15,11 @@ class Image extends Picture {
         // 继承父类实例
         super();
         // 父类已经实例化组件渲染对象
-        //this.Com;
+        //this.component;
         // 父类已经实例化启动 Puppeteer
-        //this.Pup.start();
+        //this.puppeteer.start();
         // 初始化 YukiPuppeteerRender 实例
-        this.yukiPuppeteerRender = new YukiPuppeteerRender(this.Pup);
+        this.yukiPuppeteerRender = new YukiPuppeteerRender(this.puppeteer);
     }
     /**
      * 实例方法，用于执行实际的渲染和截图操作
@@ -34,7 +34,7 @@ class Image extends Picture {
         // 根据组件名称获取对应的 React 组件
         const Page = index[page];
         // 调用 yukiPuppeteerRender 进行截图操作
-        return this.yukiPuppeteerRender.yukiScreenshot(this.Com.compile({
+        return this.yukiPuppeteerRender.yukiScreenshot(this.component.compile({
             path: page,
             name: `${uid}.html`,
             component: React.createElement(Page, { ...props }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yz-yuki-plugin",
-  "version": "2.0.6-1",
+  "version": "2.0.6-11",
   "description": "优纪插件，yunzaijs 关于 微博推送、B站推送 等功能的拓展插件",
   "author": "snowtafir",
   "type": "module",
@@ -31,12 +31,12 @@
     "debug": "^4.3.6",
     "jsdom": "^25.0.1",
     "json5": "^2.2.3",
-    "jsxp": "^1.0.4",
+    "jsxp": "^1.1.2",
     "lodash": "^4.17.21",
     "md5": "^2.3.0",
     "moment": "^2.30.1",
     "node-fetch": "^3.3.2",
-    "puppeteer": "^23.10.1",
+    "puppeteer": "^24.1.0",
     "qrcode": "^1.5.4",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
@@ -60,23 +60,24 @@
     "axios": "^1.7.9",
     "chokidar": "^4.0.1",
     "husky": "^9.1.6",
+    "icqq": "^0.6.10",
     "jsdom": "^24.1.1",
     "json5": "^2.2.3",
-    "jsxp": "^1.0.4",
+    "jsxp": "^1.1.2",
     "lodash": "^4.17.21",
-    "lvyjs": "^0.2.6",
+    "lvyjs": "^0.2.14",
     "md5": "^2.3.0",
     "node-fetch": "^3.3.2",
     "postcss": "^8.4.47",
     "prettier": "^3.4.2",
-    "puppeteer": "^23.10.1",
+    "puppeteer": "^24.1.0",
     "qrcode": "^1.5.4",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "redis": "^4.7.0",
     "tailwindcss": "^3.4.14",
     "ts-node": "^10.9.2",
-    "tsx": "^4.19.0",
+    "tsx": "^4.19.2",
     "typescript": "^5.5.4",
     "yaml": "^2.6.1",
     "yunzaijs": "^1.0.0-rc.5"
@@ -106,6 +107,6 @@
     "registry": "https://registry.npmjs.org"
   },
   "engines": {
-    "node": ">=16.14.0"
+    "node": ">=20"
   }
 }