yz-yuki-plugin 2.0.6-10 → 2.0.6-11

package/CHANGELOG.md

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

package/defaultConfig/bilibili/config.yaml

@@ -68,3 +68,6 @@ liveAtAllGroupList:
 
 # 直播动态@全体成员的共享冷却时间CD，单位秒，默认 1800 秒（30分钟），即每个群聊30分钟内不论多少条直播动态，只会@一次。注意，qq群有 @全体成员 10次/日 的限制，所以请合理设置。
 liveAtAllCD: 1800
+
+# 直播动态@全体成员失败时是否发送错误消息，默认 1 发送，0 不发送。开启liveAtAll后才会生效。
+liveAtAllErrMsg: 1

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

@@ -396,7 +396,7 @@ class BiliQuery {
         let desc, msg = [], pics = [], author, majorType, content, dynamicTitle;
         let title = `B站【${upName}】动态推送：\n`;
         let dynamicType = data.type;
-        switch (data.type) {
+        switch (dynamicType) {
             case 'DYNAMIC_TYPE_AV':
                 // 处理视频动态
                 desc = data?.modules?.module_dynamic?.major?.archive;

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

@@ -33,6 +33,9 @@ class BiliTask {
         }
         return resjson;
     }
+    /**
+     * 执行动态推送任务
+     */
     async runTask() {
         let biliConfigData = await Config.getUserConfig('bilibili', 'config');
         let biliPushData = await Config.getUserConfig('bilibili', 'push');
@@ -42,7 +45,10 @@ class BiliTask {
         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 映射
@@ -102,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] || [];
@@ -143,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秒
                         }
                     }
@@ -152,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') {
@@ -173,12 +179,9 @@ class BiliTask {
         }
         if (sended)
             return; // 如果已经发送过，则直接返回
-        let liveAtAll = !!biliConfigData.liveAtAll === true ? true : false; // 直播动态是否@全体成员，默认false
-        let liveAtAllCD = biliConfigData.liveAtAllCD || 1800; // 直播动态@全体成员 冷却时间CD，默认 30 分钟
-        let liveAtAllMark = await Redis.get(`${markKey}${chatId}:liveAtAllMark`); // 直播动态@全体成员标记，默认 0
-        // 直播动态@全体成员的群组列表，默认空数组，为空则不进行@全体成员操作
-        let liveAtAllGroupList = new Set(Array.isArray(biliConfigData?.liveAtAllGroupList) ? Array.from(biliConfigData.liveAtAllGroupList).map(item => String(item)) : []);
-        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;
@@ -206,29 +209,11 @@ class BiliTask {
             };
             let imgs = await this.renderDynamicCard(uid, renderData, ScreenshotOptionsData);
             if (!imgs)
-                return;
-            Redis.set(`${markKey}${chatId}:${id_str}`, '1', { EX: 3600 * 72 }); // 设置已发送标记
-            global?.logger?.mark('优纪插件：B站动态执行推送');
-            if (liveAtAll && !liveAtAllMark && extentData?.type === 'DYNAMIC_TYPE_LIVE_RCMD' && liveAtAllGroupList.has(String(chatId))) {
-                try {
-                    await this.sendMessage(chatId, bot_id, chatType, Segment.at('all'));
-                    await Redis.set(`${markKey}${chatId}:liveAtAllMark`, 1, { EX: liveAtAllCD }); // 设置直播动态@全体成员标记为 1
-                }
-                catch (error) {
-                    logger.error(`直播动态发送@全体成员失败，请检查 <机器人> 是否有 [管理员权限] 或 [聊天平台是否支持] ：${error}`);
-                    await this.sendMessage(chatId, bot_id, chatType, ['直播动态发送@全体成员失败，请检查权限或平台是否支持']);
-                }
-            }
-            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'; // 如果动态消息构建失败，则直接返回
             }
@@ -240,40 +225,15 @@ class BiliTask {
                 }
             }
             let mergeTextPic = !!biliConfigData.mergeTextPic === false ? false : true; // 是否合并文本和图片，默认为 true
+            //开启了合并文本和图片
             if (mergeTextPic === true) {
                 const mergeMsg = [...dynamicMsg.msg, ...dynamicMsg.pics];
-                if (liveAtAll && !liveAtAllMark && dynamicMsg.dynamicType === 'DYNAMIC_TYPE_LIVE_RCMD' && liveAtAllGroupList.has(String(chatId))) {
-                    try {
-                        await this.sendMessage(chatId, bot_id, chatType, Segment.at('all'));
-                        await Redis.set(`${markKey}${chatId}:liveAtAllMark`, 1, { EX: liveAtAllCD }); // 设置直播动态@全体成员标记为 1
-                    }
-                    catch (error) {
-                        global?.logger.error(`直播动态发送@全体成员失败，请检查 <机器人> 是否有 [管理员权限] 或 [聊天平台是否支持] ：${error}`);
-                        await this.sendMessage(chatId, bot_id, chatType, ['直播动态发送@全体成员失败，请检查权限或平台是否支持']);
-                    }
-                }
-                await this.sendMessage(chatId, bot_id, chatType, mergeMsg);
+                await this.addMessageToMap(messageMap, chatType, bot_id, chatId, 'MERGE', id_str, dynamicMsg.dynamicType, mergeMsg);
             }
             else {
-                if (liveAtAll && !liveAtAllMark && dynamicMsg.dynamicType === 'DYNAMIC_TYPE_LIVE_RCMD' && liveAtAllGroupList.has(String(chatId))) {
-                    try {
-                        await this.sendMessage(chatId, bot_id, chatType, Segment.at('all'));
-                        await Redis.set(`${markKey}${chatId}:liveAtAllMark`, 1, { EX: liveAtAllCD }); // 设置直播动态@全体成员标记为 1
-                    }
-                    catch (error) {
-                        global?.logger.error(`直播动态发送@全体成员失败，请检查 <机器人> 是否有 [管理员权限] 或 [聊天平台是否支持] ：${error}`);
-                        await this.sendMessage(chatId, bot_id, chatType, ['直播动态发送@全体成员失败，请检查权限或平台是否支持']);
-                    }
-                }
-                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);
             }
         }
     }
@@ -354,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/weibo/weibo.main.query.js

@@ -186,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 });
@@ -207,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;
@@ -223,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)
@@ -243,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;
@@ -263,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;
@@ -290,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.main.task.js

@@ -15,6 +15,9 @@ 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');
@@ -24,7 +27,10 @@ class WeiboTask {
         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 映射
@@ -71,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] || [];
@@ -110,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秒
                         }
                     }
@@ -119,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') {
@@ -168,19 +175,11 @@ 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'; // 如果动态消息构建失败或内部资源获取失败，则直接返回
             }
@@ -192,20 +191,15 @@ class WeiboTask {
                 }
             }
             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);
             }
         }
     }
@@ -286,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yz-yuki-plugin",
-  "version": "2.0.6-10",
+  "version": "2.0.6-11",
   "description": "优纪插件，yunzaijs 关于 微博推送、B站推送 等功能的拓展插件",
   "author": "snowtafir",
   "type": "module",