yz-yuki-plugin 2.0.7-8 → 2.0.8-0

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

@@ -60,6 +60,7 @@ class BiliTask {
     async processBiliData(biliPushData, biliConfigData, uidMap, dynamicList) {
         let getDataRandomDelay = biliConfigData?.getDataRandomDelay || 8000; // 获取相邻up动态数据的随机延时间隔
         const requestedDataOfUids = new Map(); // 存放已请求的 uid 映射
+        const printedList = new Set(); // 已打印的动态列表
         for (let chatType in biliPushData) {
             // 遍历 group 和 private
             if (!uidMap.has(chatType)) {
@@ -71,44 +72,50 @@ class BiliTask {
             for (let chatId in biliPushData[chatType]) {
                 const subUpsOfChat = Array.prototype.slice.call(biliPushData[chatType][chatId] || []);
                 for (let subInfoOfup of subUpsOfChat) {
+                    const { uid, bot_id, name, type } = subInfoOfup;
                     let resp;
                     // 检查是否已经请求过该 uid
-                    if (requestedDataOfUids.has(subInfoOfup.uid)) {
-                        resp = requestedDataOfUids.get(subInfoOfup.uid); // 从已请求的映射中获取响应数据
-                        const dynamicData = resp.data?.items || [];
-                        dynamicList[subInfoOfup.uid] = dynamicData;
-                    }
-                    else {
-                        resp = await this.hendleEventDynamicData(subInfoOfup.uid);
+                    if (!requestedDataOfUids.has(uid)) {
+                        if (!printedList.has(uid)) {
+                            logger.info(`正在检测B站动态 [ ${name} : ${uid} ]`);
+                            printedList.add(uid);
+                        }
+                        resp = await this.hendleEventDynamicData(uid);
                         if (resp) {
                             if (resp.code === 0) {
-                                requestedDataOfUids.set(subInfoOfup.uid, resp); // 将响应数据存储到映射中
+                                requestedDataOfUids.set(uid, resp); // 将响应数据存储到映射中
                                 const dynamicData = resp.data?.items || [];
-                                dynamicList[subInfoOfup.uid] = dynamicData;
+                                dynamicList[uid] = dynamicData;
                             }
                             else if (resp.code === -352) {
-                                logger.error(`获取 ${subInfoOfup.uid} 动态失败，resCode：-352，请待下次任务自动重试`);
+                                logger.error(`获取 ${uid} 动态失败，resCode：-352，请待下次任务自动重试`);
                                 return;
                             }
                             else if (resp.code !== 0) {
-                                logger.error(`获取 ${subInfoOfup.uid} 动态失败，resCode：${resp.code}，请待下次任务自动重试`);
+                                logger.error(`获取 ${uid} 动态失败，resCode：${resp.code}，请待下次任务自动重试`);
                                 return;
                             }
                         }
                         else {
-                            logger.error(`获取 ${subInfoOfup.uid} 动态失败，无响应数据，请待下次任务自动重试`);
+                            logger.error(`获取 ${uid} 动态失败，无响应数据，请待下次任务自动重试`);
                             return;
                         }
                     }
-                    const chatIds = Array.from(new Set([...Object((chatTypeMap.get(subInfoOfup.uid) && chatTypeMap.get(subInfoOfup.uid).chatIds) || []), chatId]));
-                    const bot_id = subInfoOfup.bot_id || [];
-                    const { name, type } = subInfoOfup;
-                    chatTypeMap.set(subInfoOfup.uid, { chatIds, bot_id, upName: name, type });
+                    if (!chatTypeMap.has(uid)) {
+                        chatTypeMap.set(uid, new Map());
+                    }
+                    const botChatMap = chatTypeMap.get(uid);
+                    if (!botChatMap?.has(bot_id)) {
+                        botChatMap?.set(bot_id, new Map());
+                    }
+                    const chatMap = botChatMap?.get(bot_id);
+                    chatMap?.set(chatId, { upName: name, types: type });
                     await this.randomDelay(2000, getDataRandomDelay); // 随机延时
                 }
             }
         }
         requestedDataOfUids.clear(); // 清空已请求的 uid 映射
+        printedList.clear(); // 清空已打印的动态列表
     }
     /**
      * 构建uid对应动态数据映射
@@ -120,35 +127,30 @@ class BiliTask {
      */
     async makeUidDynamicDataMap(uidMap, dynamicList, now, dynamicTimeRange, biliConfigData, messageMap) {
         for (let [chatType, chatTypeMap] of uidMap) {
-            for (let [key, value] of chatTypeMap) {
-                const tempDynamicList = dynamicList[key] || [];
+            for (let [upUid, bot_idMap] of chatTypeMap) {
+                const tempDynamicList = dynamicList[upUid] || [];
                 const willPushDynamicList = [];
-                const printedList = new Set(); // 已打印的动态列表
                 for (let dynamicItem of tempDynamicList) {
                     let author = dynamicItem?.modules?.module_author || {};
-                    if (!printedList.has(author?.mid)) {
-                        logger.info(`正在检测B站动态 [ ${author?.name} : ${author?.mid} ]`);
-                        printedList.add(author?.mid);
-                    }
                     if (!author?.pub_ts)
                         continue; // 如果动态没有发布时间，跳过当前循环
                     if (Number(now - author.pub_ts) > dynamicTimeRange) {
                         logger.debug(`超过间隔，跳过  [ ${author?.name} : ${author?.mid} ] ${author?.pub_time} 的动态`);
                         continue;
                     } // 如果超过推送时间间隔，跳过当前循环
-                    if (dynamicItem.type === 'DYNAMIC_TYPE_FORWARD' && !biliConfigData.pushTransmit)
-                        continue; // 如果关闭了转发动态的推送，跳过当前循环
+                    if (dynamicItem?.type === 'DYNAMIC_TYPE_FORWARD' && !biliConfigData.pushTransmit) {
+                        continue;
+                    } // 如果关闭了转发动态的推送，跳过当前循环
                     willPushDynamicList.push(dynamicItem);
                 }
-                printedList.clear();
-                const pushMapInfo = value || {}; // 获取当前 uid 对应的推送信息
-                const { chatIds, bot_id, upName, type } = pushMapInfo;
                 // 遍历待推送的动态数组，发送动态消息
-                for (let pushDynamicData of willPushDynamicList) {
-                    if (chatIds && chatIds.length) {
-                        for (let chatId of chatIds) {
-                            if (type && type.length && !type.includes(pushDynamicData.type))
-                                continue; // 如果禁用了某类型的动态推送，跳过当前循环
+                for (let [bot_id, chatIdMap] of bot_idMap) {
+                    for (let [chatId, subUpInfo] of chatIdMap) {
+                        const { upName, types } = subUpInfo;
+                        for (let pushDynamicData of willPushDynamicList) {
+                            if (types && types.length > 0 && !types.includes(pushDynamicData.type)) {
+                                continue;
+                            } // 如果禁用了某类型的动态推送，跳过当前循环
                             await this.makeDynamicMessageMap(chatId, bot_id, upName, pushDynamicData, biliConfigData, chatType, messageMap); // 发送动态消息
                             await this.randomDelay(1000, 2000); // 随机延时1-2秒
                         }
@@ -378,65 +380,119 @@ class BiliTask {
     async sendDynamicMessage(messageMap, biliConfigData) {
         let liveAtAll = !!biliConfigData.liveAtAll === true ? true : false; // 直播动态是否@全体成员，默认false
         let liveAtAllCD = biliConfigData.liveAtAllCD || 1800; // 直播动态@全体成员 冷却时间CD，默认 30 分钟
+        let forwardSendDynamic = biliConfigData.forwardSendDynamic === 0 || biliConfigData.forwardSendDynamic === false ? false : true; // 转发动态是否合并发送，默认 true
         // 直播动态@全体成员的群组/好友列表，默认空数组，为空则不进行@全体成员操作
         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}`);
+                    // 区分群聊和私聊
+                    let markKey = chatType === 'group' ? this.groupKey : this.privateKey;
+                    if (!LogMark.has('1')) {
+                        global?.logger?.mark('优纪插件: B站动态执行推送');
+                        LogMark.add('1');
+                    }
+                    let liveAtAllMark = await Redis.get(`${markKey}${chatId}:liveAtAllMark`); // 直播动态@全体成员标记，默认 0
+                    const hasLiveDynamic = messageCombinationList.some(m => m.dynamicType === 'DYNAMIC_TYPE_LIVE_RCMD');
+                    // 如果开启了直播动态@全体成员
+                    if (liveAtAll && !liveAtAllMark && hasLiveDynamic && liveAtAllGroupList.has(String(chatId))) {
+                        try {
+                            await this.sendMsgApi(chatId, bot_id, chatType, [Segment.at('all')]);
+                            await Redis.set(`${markKey}${chatId}:liveAtAllMark`, 1, { EX: liveAtAllCD }); // 设置直播动态@全体成员标记为 1
                         }
-                        const sendMarkKey = `${markKey}${chatId}:${dynamicUUid_str}`;
-                        if (sended) {
-                            continue; // 如果已经发送过，则直接跳过
+                        catch (error) {
+                            logger.error(`直播动态发送@全体成员失败，请检查 <机器人> 是否有 [管理员权限] 或 [聊天平台是否支持] ：${error}`);
+                            let liveAtAllErrMsg = !!biliConfigData.liveAtAllErrMsg === false ? false : true; // 直播动态@全体成员失败是否发送错误提示消息，默认 false
+                            if (liveAtAllErrMsg) {
+                                await this.sendMsgApi(chatId, bot_id, chatType, ['直播动态发送@全体成员失败，请检查权限或平台是否支持']);
+                            }
                         }
-                        if (!LogMark.has('1')) {
-                            global?.logger?.mark('优纪插件: B站动态执行推送');
-                            LogMark.add('1');
+                    }
+                    // 统计图片数量和文字长度
+                    let imageCount = 0;
+                    let textLength = 0;
+                    for (const messageCombination of messageCombinationList) {
+                        const { messages } = messageCombination;
+                        for (const msg of messages) {
+                            if (typeof msg === 'object' && msg.type === 'image') {
+                                imageCount++;
+                            }
+                            else if (typeof msg === 'string') {
+                                textLength += msg.length;
+                            }
                         }
-                        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
+                    }
+                    // 满足条件才使用合并转发
+                    const useForward = imageCount > (biliConfigData?.maxPicsForSingleMsg ?? 2) || textLength > (biliConfigData?.maxTextLengthForSingleMsg ?? 300);
+                    if (forwardSendDynamic && useForward) {
+                        const forwardNodes = [];
+                        // 合并所有消息
+                        const forwardSendMardKeyList = [];
+                        forwardNodes.push({
+                            nickname: '优纪酱',
+                            user_id: String(80000000),
+                            message: ['有新的B站动态了~'],
+                            time: Date.now()
+                        });
+                        for (const messageCombination of messageCombinationList) {
+                            const { sendMode, dynamicUUid_str, dynamicType, messages } = messageCombination;
+                            const sendMarkKey = `${markKey}${chatId}:${dynamicUUid_str}`;
+                            // 原子性设置标记，防止并发重复
+                            const setResult = await Redis.set(sendMarkKey, '1', { NX: true, EX: 3600 * 72 });
+                            if (!setResult) {
+                                continue; // 已有标记，跳过
                             }
-                            catch (error) {
-                                logger.error(`直播动态发送@全体成员失败，请检查 <机器人> 是否有 [管理员权限] 或 [聊天平台是否支持] ：${error}`);
-                                let liveAtAllErrMsg = !!biliConfigData.liveAtAllErrMsg === false ? false : true; // 直播动态@全体成员失败是否发送错误提示消息，默认 false
-                                if (liveAtAllErrMsg) {
-                                    await this.sendMessageApi(chatId, bot_id, chatType, ['直播动态发送@全体成员失败，请检查权限或平台是否支持']);
-                                }
+                            forwardSendMardKeyList.push(sendMarkKey); // 收集合并转发的标记键
+                            // 每条动态一个 node
+                            forwardNodes.push({
+                                nickname: '匿名消息',
+                                user_id: String(80000000),
+                                message: messages,
+                                time: Date.now()
+                            });
+                        }
+                        // 尝试合并转发动态
+                        if ((await this.sendMsgApi(chatId, bot_id, chatType, '优纪酱B站动态通知~')) &&
+                            (await this.sendForwardMsgApi(chatId, bot_id, chatType, forwardNodes))) {
+                            await this.randomDelay(1000, 2000);
+                            continue; // 合并转发成功，跳过后续单条发送逻辑
+                        }
+                        else {
+                            for (const sendMarkKey of forwardSendMardKeyList) {
+                                await Redis.del(sendMarkKey); // 发送消息失败，删除合并转发成功标记
                             }
                         }
+                    }
+                    // 合并转发失败，回退为原有方式
+                    for (const messageCombination of messageCombinationList) {
+                        const { sendMode, dynamicUUid_str, dynamicType, messages } = messageCombination;
+                        const sendMarkKey = `${markKey}${chatId}:${dynamicUUid_str}`;
+                        // 原子性设置标记，防止并发重复
+                        const setResult = await Redis.set(sendMarkKey, '1', { NX: true, EX: 3600 * 72 });
+                        if (!setResult) {
+                            continue; // 已有标记，跳过
+                        }
+                        let sendSuccess = true;
                         if (sendMode === 'SINGLE') {
-                            let allSent = true;
                             for (let i = 0; i < messages.length; i++) {
-                                if (!(await this.sendMessageApi(chatId, bot_id, chatType, messages[i]))) {
-                                    allSent = false;
-                                    break; // 如果有任何一条消息发送失败，停止发送后续消息
+                                if (!(await this.sendMsgApi(chatId, bot_id, chatType, messages[i]))) {
+                                    sendSuccess = false;
+                                    break;
                                 }
                             }
-                            if (allSent) {
-                                await Redis.set(sendMarkKey, '1', { EX: 3600 * 72 }); // 发送成功后设置标记
-                                await this.randomDelay(1000, 2000); // 随机延时1-2秒
+                            if (!sendSuccess) {
+                                await Redis.del(sendMarkKey); // 失败删除标记
+                            }
+                            else {
+                                await this.randomDelay(1000, 2000);
                             }
                         }
                         else if (sendMode === 'MERGE') {
-                            if (await this.sendMessageApi(chatId, bot_id, chatType, messages)) {
-                                await Redis.set(sendMarkKey, '1', { EX: 3600 * 72 }); // 发送成功后设置标记
+                            if (!(await this.sendMsgApi(chatId, bot_id, chatType, messages))) {
+                                await Redis.del(sendMarkKey); // 失败删除标记
                             }
+                            await this.randomDelay(1000, 2000);
                         }
                     }
                 }
@@ -451,7 +507,7 @@ class BiliTask {
      * @param chatType 聊天类型
      * @param message 消息内容
      */
-    async sendMessageApi(chatId, bot_id, chatType, message) {
+    async sendMsgApi(chatId, bot_id, chatType, message) {
         try {
             if (chatType === 'group') {
                 await (Bot[bot_id] ?? Bot)?.pickGroup(String(chatId)).sendMsg(message); // 发送群聊
@@ -466,6 +522,30 @@ class BiliTask {
             return false; // 发送失败
         }
     }
+    /**
+     * 发送合并转发消息
+     * @param chatId 聊天 ID
+     * @param bot_id 机器人 ID
+     * @param chatType 聊天类型
+     * @param message 消息内容
+     * @returns 是否发送成功
+     */
+    async sendForwardMsgApi(chatId, bot_id, chatType, forwardNodes) {
+        const forwardMsg = await Bot.makeForwardMsg(forwardNodes);
+        try {
+            if (chatType === 'group') {
+                await (Bot[bot_id] ?? Bot)?.pickGroup(String(chatId)).sendMsg(forwardMsg); // 发送群聊合并转发
+            }
+            else if (chatType === 'private') {
+                await (Bot[bot_id] ?? Bot)?.pickFriend(String(chatId)).sendMsg(forwardMsg); // 发送好友私聊合并转发
+            }
+            return true; // 发送成功
+        }
+        catch (error) {
+            global?.logger?.error(`${chatType === 'group' ? '群聊' : '私聊'} ${chatId} 合并转发消息发送失败：${JSON.stringify(error)}`);
+            return false; // 发送失败
+        }
+    }
     /**
      * 随机延时
      * @param min 最小延时时间

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

@@ -72,7 +72,7 @@ class WeiboQuery {
         /**动态详情链接 */
         let detail_url = `https://weibo.com/${info?.user?.id}/${info?.bid}`;
         /* 构造动态渲染数据 *************************** */
-        let pics = [];
+        let pics = [], video_pics_list;
         let formatData = { data: {} };
         /**头像 */
         formatData.data.face = face_url;
@@ -85,12 +85,17 @@ class WeiboQuery {
         formatData.data.type = type;
         switch (type) {
             case 'DYNAMIC_TYPE_AV':
+                video_pics_list = info?.pics ? info?.pics : info?.page_info?.page_pic?.url ? [{ large: { url: info.page_info.page_pic.url } }] : [];
+                pics =
+                    video_pics_list.map((img) => {
+                        return { url: img?.large?.url, width: Number(img?.large?.geo?.width), height: Number(img?.large?.geo?.height) };
+                    }) || [];
                 formatData.data.title = info?.page_info?.title || '';
                 formatData.data.content = this.parseRichTextNodes(info?.text);
                 formatData.data.url = detail_url;
                 formatData.data.pubTs = moment(created_time).format('YYYY年MM月DD日 HH:mm:ss');
                 formatData.data.category = '视频动态';
-                formatData.data.pics = info?.page_info?.page_pic?.url ? [{ url: info.page_info.page_pic.url }] : [];
+                formatData.data.pics = pics;
                 break;
             case 'DYNAMIC_TYPE_DRAW':
                 let raw_pics_list = retweeted ? info?.retweeted_status?.pics || [] : info?.pics || [];
@@ -182,7 +187,7 @@ class WeiboQuery {
         /**图片高清资源链接*/
         pic_urls = [], 
         /**图片*/
-        pics = [];
+        pics = [], video_pics_list;
         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;
@@ -205,24 +210,42 @@ class WeiboQuery {
         /**动态发布时间 */
         let created_time = this.getDynamicCreatetDate(raw_post);
         let detail_url = `https://weibo.com/${info?.user?.id}/${info?.bid}`;
-        let title = `微博【${upName}】动态推送：\n`;
-        const dynamicPicCountLimit = setData.pushPicCountLimit || 3;
+        let msg_meta = `微博【${upName}】动态推送：`;
+        const dynamicPicCountLimit = setData.pushPicCountLimit || 9;
+        function formatNumber(num) {
+            if (num >= 10000) {
+                return `${(num / 10000).toFixed(1)}万`;
+            }
+            return num.toString();
+        }
         switch (dynamicType) {
             case 'DYNAMIC_TYPE_AV':
                 if (!info)
                     return;
-                let cover_img_url = info?.page_info?.page_pic?.url;
-                let cover_img = Segment.image(cover_img_url, false, 15000, { referer: 'https://weibo.com' });
-                title = `微博【${upName}】视频动态推送：\n`;
+                video_pics_list = info?.pics ? info?.pics : info?.page_info?.page_pic?.url ? [{ large: { url: info.page_info.page_pic.url } }] : [];
+                pic_urls = video_pics_list.map(img => img?.large?.url);
+                for (const pic_url of pic_urls) {
+                    const temp = Segment.image(pic_url, false, 15000, { referer: 'https://weibo.com' });
+                    pics.push(temp);
+                }
+                msg_meta = `微博【${upName}】视频动态推送：`;
                 msg = [
-                    title,
-                    `-----------------------------\n`,
-                    `标题：${info?.page_info?.title || ''}\n`,
-                    `${this.filterText(info?.text)}\n`,
-                    `链接：${detail_url}\n`,
-                    `时间：${created_time ? moment(created_time).format('YYYY年MM月DD日 HH:mm:ss') : ''}`
+                    msg_meta,
+                    `\n--------------------`,
+                    `\n${info?.page_info?.title || ''}`, //标题
+                    `\n--------------------`,
+                    `\n正文：`,
+                    `\n${this.filterText(info?.text)}`,
+                    `\n--------------------`,
+                    `\n投稿：${created_time ? moment(created_time).format('YYYY年MM月DD日 HH:mm:ss') : ''}`,
+                    `\n--------------------`,
+                    ...(info?.comments_count != null
+                        ? [
+                            `\n${formatNumber(info?.attitudes_count)}点赞 • ${formatNumber(info?.comments_count)}评论 • ${formatNumber(info?.reposts_count)}转发\n--------------------`
+                        ]
+                        : []),
+                    `\n链接：${detail_url}`
                 ];
-                pics = [cover_img];
                 return { msg, pics, dynamicType };
             case 'DYNAMIC_TYPE_DRAW':
                 raw_pics_list = retweeted ? info?.retweeted_status?.pics || [] : info?.pics || [];
@@ -235,13 +258,21 @@ class WeiboQuery {
                     const temp = Segment.image(pic_url, false, 15000, { referer: 'https://weibo.com' });
                     pics.push(temp);
                 }
-                title = `微博【${upName}】图文动态推送：\n`;
+                msg_meta = `微博【${upName}】图文动态推送：`;
                 msg = [
-                    title,
-                    `-----------------------------\n`,
-                    `${this.dynamicContentLimit(this.filterText(info?.text), setData)}\n`,
-                    `链接：${detail_url}\n`,
-                    `时间：${created_time ? moment(created_time).format('YYYY年MM月DD日 HH:mm:ss') : ''}`
+                    msg_meta,
+                    `\n--------------------`,
+                    `\n正文：`,
+                    `\n${this.dynamicContentLimit(this.filterText(info?.text), setData)}`,
+                    `\n--------------------`,
+                    `\n投稿：${created_time ? moment(created_time).format('YYYY年MM月DD日 HH:mm:ss') : ''}`,
+                    `\n--------------------`,
+                    ...(info?.comments_count != null
+                        ? [
+                            `\n${formatNumber(info?.attitudes_count)}点赞 • ${formatNumber(info?.comments_count)}评论 • ${formatNumber(info?.reposts_count)}转发\n--------------------`
+                        ]
+                        : []),
+                    `\n链接：${detail_url}`
                 ];
                 return { msg, pics, dynamicType };
             case 'DYNAMIC_TYPE_ARTICLE':
@@ -255,13 +286,21 @@ class WeiboQuery {
                     const temp = Segment.image(pic_url, false, 15000, { referer: 'https://weibo.com' });
                     pics.push(temp);
                 }
-                title = `微博【${upName}】文章动态推送：\n`;
+                msg_meta = `微博【${upName}】文章动态推送：`;
                 msg = [
-                    title,
-                    `-----------------------------\n`,
-                    `正文：${this.dynamicContentLimit(this.filterText(info?.text), setData)}\n`,
-                    `链接：${detail_url}\n`,
-                    `时间：${created_time ? moment(created_time).format('YYYY年MM月DD日 HH:mm:ss') : ''}`
+                    msg_meta,
+                    `\n--------------------`,
+                    `\n正文：`,
+                    `\n${this.dynamicContentLimit(this.filterText(info?.text), setData)}`,
+                    `\n--------------------`,
+                    `\n投稿：${created_time ? moment(created_time).format('YYYY年MM月DD日 HH:mm:ss') : ''}`,
+                    `\n--------------------`,
+                    ...(info?.comments_count != null
+                        ? [
+                            `\n${formatNumber(info?.attitudes_count)}点赞 • ${formatNumber(info?.comments_count)}评论 • ${formatNumber(info?.reposts_count)}转发\n--------------------`
+                        ]
+                        : []),
+                    `\n链接：${detail_url}`
                 ];
                 return { msg, pics, dynamicType };
             case 'DYNAMIC_TYPE_FORWARD':
@@ -280,14 +319,22 @@ class WeiboQuery {
                 else {
                     return 'continue';
                 }
-                title = `微博【${upName}】转发动态推送：\n`;
+                msg_meta = `微博【${upName}】转发动态推送：`;
                 msg = [
-                    title,
-                    `-----------------------------\n`,
-                    `${this.dynamicContentLimit(this.filterText(info?.text), setData)}\n`,
-                    `链接：${detail_url}\n`,
-                    `时间：${created_time ? moment(created_time).format('YYYY年MM月DD日 HH:mm:ss') : ''}\n`,
-                    '\n---以下为转发内容---\n',
+                    msg_meta,
+                    `\n--------------------`,
+                    `\n正文：`,
+                    `\n${this.dynamicContentLimit(this.filterText(info?.text), setData)}`,
+                    `\n--------------------`,
+                    `\n投稿：${created_time ? moment(created_time).format('YYYY年MM月DD日 HH:mm:ss') : ''}`,
+                    `\n--------------------`,
+                    ...(info?.comments_count != null
+                        ? [
+                            `\n${formatNumber(info?.attitudes_count)}点赞 • ${formatNumber(info?.comments_count)}评论 • ${formatNumber(info?.reposts_count)}转发\n--------------------`
+                        ]
+                        : []),
+                    `\n链接：${detail_url}\n`,
+                    '\n>>>>以下为转发内容<<<<\n',
                     ...origContent
                 ];
                 return { msg, pics, dynamicType };
@@ -298,9 +345,9 @@ class WeiboQuery {
     }
     // 限制文字模式下动态内容的字数和行数
     static dynamicContentLimit(content, setData) {
-        const lines = content.split('\n');
-        const lengthLimit = setData.pushContentLenLimit || 100;
-        const lineLimit = setData.pushContentLineLimit || 5;
+        const lines = String(content).split('\n');
+        const lengthLimit = setData.pushContentLenLimit || 1000;
+        const lineLimit = setData.pushContentLineLimit || 100;
         // 限制行数
         if (lines.length > lineLimit) {
             lines.length = lineLimit;