yz-yuki-plugin 2.0.6-0 → 2.0.6-2

package/README.md

@@ -8,6 +8,28 @@
 
 [![访问量](https://profile-counter.glitch.me/yuki-plugin/count.svg)](https://github.com/snowtafir/yuki-plugin)
 
+
+# 🚩运行环境：
+1. 系统：
+* windows 10/11+，
+* Linux推荐：Ubuntu 24.04.1 LTS+, 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
+```
+
 # 🌰一、安装插件
 
 ## 选择安装方式

package/defaultConfig/bilibili/config.yaml

@@ -44,6 +44,9 @@ banWords:
 # 设置B站动态消息模式 0 文字模式 1 图片模式
 pushMsgMode: 1
 
+# 文字模式时，文字消息与图片附件是否合并在一起发送，默认 1 合并，0 不合并。如果合并时图片过多导致发送失败，可设置为 0 单独发送图片。
+mergeTextPic: 1
+
 # 是否启用九宫格样式：默认 1 启用，0 不启用。此为最高优先级，九宫格为动态模式，特定大小/长宽比的图片资源将会动态启用九宫格/四宫格/无宫格样式。
 boxGrid: 1
 

package/defaultConfig/weibo/config.yaml

@@ -34,6 +34,9 @@ banWords:
 # 设置微博动态消息模式 0 文字模式 1 图片模式
 pushMsgMode: 1
 
+# 文字模式时，文字消息与图片附件是否合并在一起发送，默认 1 合并，0 不合并。如果合并时图片过多导致发送失败，可设置为 0 单独发送图片。
+mergeTextPic: 1
+
 # 是否启用九宫格样式：默认 1 启用，0 不启用。此为最高优先级，九宫格为动态模式，特定大小/长宽比的图片资源将会动态启用九宫格/四宫格/无宫格样式。
 boxGrid: 1
 

package/lib/apps/bilibili.js

@@ -1,6 +1,6 @@
 import JSON from 'json5';
 import lodash from 'lodash';
-import { Messages, Bot, Redis } from 'yunzaijs';
+import { Messages, Redis } from 'yunzaijs';
 import { BiliQuery } from '../models/bilibili/bilibili.main.query.js';
 import { BiliTask } from '../models/bilibili/bilibili.main.task.js';
 import Config from '../utils/config.js';
@@ -63,7 +63,7 @@ message.use(async (e) => {
             logger.mark(`yuki-plugin addDynamicSub Failed：${JSON.stringify(res.data)}`);
         }
         const { has_more, items } = data || {};
-        let infoName;
+        let infoName = '';
         if (code === 0 && has_more === false) {
             e.reply(`检测到该uid的主页空间动态内容为空，\n执行uid：${uid} 校验...`);
             const resp = await new BiliGetWebData(e).getBilibiUserInfoByUid(uid);
@@ -87,7 +87,7 @@ message.use(async (e) => {
                 e.reply(`昵称：${infoName} \nuid：${uid} 校验成功！`);
             }
         }
-        let name;
+        let name = '';
         if (Array.isArray(items)) {
             if (items.length > 0) {
                 name = items[0].modules?.module_author?.name || uid;
@@ -170,27 +170,31 @@ message.use(async (e) => {
     if (e.isMaster) {
         try {
             const token = await applyLoginQRCode(e);
-            let biliLoginCk = await pollLoginQRCode(e, token);
-            if (lodash.trim(biliLoginCk).length != 0) {
-                await saveLoginCookie(e, biliLoginCk);
-                e.reply(`get bilibili LoginCk：成功！`);
-                const result = await postGateway(biliLoginCk); //激活ck
-                const { code, data } = await result.data; // 解析校验结果
-                switch (code) {
-                    case 0:
-                        (logger ?? Bot.logger)?.mark(`优纪插件：获取biliLoginCK，Gateway校验成功：${JSON.stringify(data)}`);
-                        break;
-                    default:
-                        (logger ?? Bot.logger)?.mark(`优纪插件：获取biliLoginCK，Gateway校验失败：${JSON.stringify(data)}`);
-                        break;
+            if (token) {
+                let biliLoginCk = await pollLoginQRCode(e, token);
+                if (biliLoginCk) {
+                    if (lodash.trim(biliLoginCk).length != 0) {
+                        await saveLoginCookie(e, biliLoginCk);
+                        e.reply(`get bilibili LoginCk：成功！`);
+                        const result = await postGateway(biliLoginCk); //激活ck
+                        const { code, data } = await result.data; // 解析校验结果
+                        switch (code) {
+                            case 0:
+                                global?.logger?.mark(`优纪插件：获取biliLoginCK，Gateway校验成功：${JSON.stringify(data)}`);
+                                break;
+                            default:
+                                global?.logger?.mark(`优纪插件：获取biliLoginCK，Gateway校验失败：${JSON.stringify(data)}`);
+                                break;
+                        }
+                    }
+                    else {
+                        e.reply(`get bilibili LoginCk：失败X﹏X`);
+                    }
                 }
             }
-            else {
-                e.reply(`get bilibili LoginCk：失败X﹏X`);
-            }
         }
         catch (Error) {
-            (logger ?? Bot.logger)?.info(`yuki-plugin Login bilibili Failed：${Error}`);
+            global?.logger?.info(`yuki-plugin Login bilibili Failed：${Error}`);
         }
     }
     else {
@@ -263,10 +267,10 @@ message.use(async (e) => {
             const { code, data } = await result.data; // 解析校验结果
             switch (code) {
                 case 0:
-                    (logger ?? Bot.logger)?.mark(`优纪插件：绑定localCK，Gateway校验成功：${JSON.stringify(data)}`);
+                    global?.logger?.mark(`优纪插件：绑定localCK，Gateway校验成功：${JSON.stringify(data)}`);
                     break;
                 default:
-                    (logger ?? Bot.logger)?.mark(`优纪插件：绑定localCK，Gateway校验失败：${JSON.stringify(data)}`);
+                    global?.logger?.mark(`优纪插件：绑定localCK，Gateway校验失败：${JSON.stringify(data)}`);
                     break;
             }
         }
@@ -336,7 +340,7 @@ message.use(async (e) => {
     }
     catch (error) {
         e.reply(`~yuki-plugin:\n临时b站ck刷新失败X﹏X\n请重启bot(手动或发送指令 #重启)后重试`);
-        (logger ?? Bot.logger)?.mark(`优纪插件：B站临时ck刷新error：${error}`);
+        global?.logger?.mark(`优纪插件：B站临时ck刷新error：${error}`);
     }
 }, [/^(#|\/)(yuki|优纪)?刷新(b站|B站|bili|bilibili|哔哩|哔哩哔哩)临时(ck|CK|cookie|COOKIE)$/]);
 /** 订阅的全部b站推送列表 */

package/lib/apps/weibo.js

@@ -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/models/bilibili/bilibili.main.models.js

@@ -6,7 +6,7 @@ import { promisify } from 'node:util';
 import path from 'path';
 import QRCode from 'qrcode';
 import YAML from 'yaml';
-import { Segment, Bot, Redis } from 'yunzaijs';
+import { Segment, Redis } from 'yunzaijs';
 import { renderPage } from '../../utils/image.js';
 import { _paths } from '../../utils/paths.js';
 import BiliApi from './bilibili.main.api.js';
@@ -29,10 +29,10 @@ async function applyLoginQRCode(e) {
     if (!response.ok) {
         throw new Error(`获取B站登录二维码URL网络请求失败，状态码: ${response.status}`);
     }
-    const res = await response.json();
+    const res = (await response.json());
     if (res?.code === 0) {
-        const qrcodeKey = res.data.qrcode_key;
-        const qrcodeUrl = res.data.url;
+        const qrcodeKey = res?.data?.qrcode_key;
+        const qrcodeUrl = res?.data?.url;
         let loginUrlQrcodeData = await QRCode.toDataURL(`${qrcodeUrl}`);
         const LoginPropsData = {
             data: { url: loginUrlQrcodeData }
@@ -76,9 +76,9 @@ async function pollLoginQRCode(e, qrcodeKey) {
     if (!response.ok) {
         throw new Error(`处理B站登录token网络请求失败，状态码: ${response.status}`);
     }
-    const data = await response.json();
+    const data = (await response.json());
     if (data.code === 0) {
-        if (data.data.code === 0) {
+        if (data?.data?.code === 0) {
             // 登录成功，获取 cookie
             const LoginCookie = response.headers.get('set-cookie');
             let loginCk = '';
@@ -93,20 +93,20 @@ async function pollLoginQRCode(e, qrcodeKey) {
             e.reply(`~B站登陆成功~`);
             return loginCk;
         }
-        else if (data.data.code === 86101) {
+        else if (data?.data?.code === 86101) {
             // 未扫码
             // 继续轮询
             await new Promise(resolve => setTimeout(resolve, 2000));
-            (logger ?? Bot.logger)?.mark(`优纪插件：扫码B站登录：未扫码，轮询中...`);
+            global?.logger?.mark(`优纪插件：扫码B站登录：未扫码，轮询中...`);
             return pollLoginQRCode(e, qrcodeKey);
         }
-        else if (data.data.code === 86090) {
+        else if (data?.data?.code === 86090) {
             // 已扫码未确认
             // 继续轮询
             await new Promise(resolve => setTimeout(resolve, 2000));
             return pollLoginQRCode(e, qrcodeKey);
         }
-        else if (data.data.code === 86038) {
+        else if (data?.data?.code === 86038) {
             // 二维码已失效
             e.reply('B站登陆二维码已失效');
             return null;
@@ -135,7 +135,7 @@ async function checkBiliLogin(e) {
             redirect: 'follow'
         });
         const resData = await res.json();
-        Bot?.logger?.debug(`B站验证登录状态:${JSON.stringify(resData)}`);
+        global?.logger?.debug(`B站验证登录状态:${JSON.stringify(resData)}`);
         if (resData.code === 0) {
             let uname = resData.data?.uname;
             let mid = resData.data?.mid;
@@ -455,8 +455,13 @@ async function cookieWithBiliTicket(cookie) {
         try {
             const csrf = await readSavedCookieItems(cookie, ['bili_jct'], false);
             const { ticket, ttl } = await getBiliTicket(csrf);
-            await Redis.set(BiliJctKey, ticket, { EX: ttl });
-            return cookie + `;bili_ticket=${ticket};`;
+            if (ticket && ttl) {
+                await Redis.set(BiliJctKey, ticket, { EX: ttl });
+                return cookie + `;bili_ticket=${ticket};`;
+            }
+            else {
+                return cookie;
+            }
         }
         catch (error) {
             logger?.error(`${error}`);

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

@@ -1,5 +1,5 @@
 import moment from 'moment';
-import { Bot, Segment } from 'yunzaijs';
+import { Segment } from 'yunzaijs';
 import { readSyncCookie, cookieWithBiliTicket } from './bilibili.main.models.js';
 import BiliApi from './bilibili.main.api.js';
 import axios from 'axios';
@@ -100,30 +100,36 @@ class BiliQuery {
                     formatData.data.title = desc?.title;
                     // 文章内容过长，则尝试获取全文
                     if (desc?.summary?.text?.length >= 480) {
-                        const { readInfo, articleType } = await this.getFullArticleContent(this.formatUrl(desc?.jump_url));
-                        // 文章链接类型为 cv（旧类型） 或者 opus（新类型）
-                        if (articleType === 'cv') {
-                            formatData.data.content = this.praseFullOldTypeArticleContent(readInfo?.content);
-                            if (String(formatData.data.content).length < 100) {
-                                formatData.data.content = this.parseRichTextNodes(desc?.summary?.rich_text_nodes || desc?.summary?.text) || '';
-                                formatData.data.pics = pics;
+                        const fullArticleContent = await this.getFullArticleContent(this.formatUrl(desc?.jump_url));
+                        if (fullArticleContent) {
+                            const { readInfo, articleType } = fullArticleContent;
+                            // 文章链接类型为 cv（旧类型） 或者 opus（新类型）
+                            if (articleType === 'cv') {
+                                formatData.data.content = this.praseFullOldTypeArticleContent(readInfo?.content);
+                                if (String(formatData.data.content).length < 100) {
+                                    formatData.data.content = this.parseRichTextNodes(desc?.summary?.rich_text_nodes || desc?.summary?.text) || '';
+                                    formatData.data.pics = pics;
+                                }
+                                else {
+                                    formatData.data.pics = [];
+                                }
                             }
-                            else {
-                                formatData.data.pics = [];
+                            else if (articleType === 'opus') {
+                                const FullNewTypeArticleContent = this.praseFullNewTypeArticleContent(readInfo?.paragraphs);
+                                if (FullNewTypeArticleContent) {
+                                    const { content, img } = FullNewTypeArticleContent;
+                                    formatData.data.content = content;
+                                    formatData.data.pics = img && img.length > 0 ? img : pics;
+                                    if (content && content.length < 100) {
+                                        formatData.data.content = this.parseRichTextNodes(desc?.summary?.rich_text_nodes || desc?.summary?.text);
+                                    }
+                                }
                             }
-                        }
-                        else if (articleType === 'opus') {
-                            const { content, img } = this.praseFullNewTypeArticleContent(readInfo?.paragraphs);
-                            formatData.data.content = content;
-                            formatData.data.pics = img && img.length > 0 ? img : pics;
-                            if (content && content.length < 100) {
-                                formatData.data.content = this.parseRichTextNodes(desc?.summary?.rich_text_nodes || desc?.summary?.text);
+                            else {
+                                formatData.data.content = this.parseRichTextNodes(desc?.summary?.rich_text_nodes || desc?.summary?.text) || '';
+                                formatData.data.pics = pics;
                             }
                         }
-                        else {
-                            formatData.data.content = this.parseRichTextNodes(desc?.summary?.rich_text_nodes || desc?.summary?.text) || '';
-                            formatData.data.pics = pics;
-                        }
                     }
                     else {
                         formatData.data.content = this.parseRichTextNodes(desc?.summary?.rich_text_nodes || desc?.summary?.text) || '';
@@ -208,7 +214,7 @@ class BiliQuery {
                         return `<span class="bili-rich-text-module topic" href="${jumpUrl}">${node?.text}</span>`;
                     case 'RICH_TEXT_NODE_TYPE_TEXT':
                         // 正文将 \n 替换为 <br> 以实现换行
-                        return node.text.replace(/\n/g, '<br>');
+                        return node?.text?.replace(/\n/g, '<br>') || '';
                     case 'RICH_TEXT_NODE_TYPE_AT':
                         // 处理 @ 类型，使用官方的HTML标签写法
                         return `<span data-module="desc" data-type="at" data-oid="${node?.rid}" class="bili-rich-text-module at">${node?.text}</span>`;
@@ -287,8 +293,19 @@ class BiliQuery {
         });
         return content;
     }
-    /**解析新版完整文章内容
-     * @param paragraphs - MODULE_TYPE_CONTENT 类型文章的段落数组
+    /**
+     * 解析新版完整文章内容，将其转换为HTML格式的正文和图片数组。
+     * 该方法处理的是 MODULE_TYPE_CONTENT 类型的文章，文章内容由多个段落组成。
+     * 每个段落可能包含不同类型的内容，如正文、图片、链接、表情等。
+     *
+     * @param paragraphs - MODULE_TYPE_CONTENT 类型文章的段落数组，每个段落是一个对象。
+     *                     每个段落对象包含一个 para_type 属性，用于标识段落类型（1表示正文，2表示图片）。
+     *                     正文段落中可能包含多个 nodes，每个 node 表示一段文本或一个富文本元素。
+     *                     图片段落中包含一个 pic 对象，其中 pics 是图片信息的数组。
+     * @returns 返回一个对象，包含两个属性：
+     *          - content: string 类型，解析后的HTML格式的正文字符串。
+     *          - img: array 类型，包含图片信息的对象数组，每个对象有 url、width 和 height 属性。
+     *          如果输入的 paragraphs 不是数组，则返回 null。
      */
     static praseFullNewTypeArticleContent = (paragraphs) => {
         if (Array.isArray(paragraphs)) {
@@ -300,54 +317,58 @@ class BiliQuery {
                 switch (item.para_type) {
                     case 1:
                         // 处理正文
-                        content += item.text.nodes
-                            .map((node) => {
-                            let nodeType = node.type;
-                            if (nodeType === 'TEXT_NODE_TYPE_RICH') {
-                                let richType = node?.rich?.type;
-                                switch (richType) {
-                                    case 'RICH_TEXT_NODE_TYPE_TOPIC':
-                                        // 确保链接以 https:// 开头
-                                        let jumpUrl = node?.rich?.jump_url;
-                                        if (jumpUrl && !jumpUrl.startsWith('http://') && !jumpUrl.startsWith('https://')) {
-                                            jumpUrl = `https://${jumpUrl}`;
-                                        }
-                                        return `<span class="bili-rich-text-module topic" href="${jumpUrl}">${node?.rich?.text}</span>`;
-                                    case 'RICH_TEXT_NODE_TYPE_TEXT':
-                                        // 正文将 \n 替换为 <br> 以实现换行
-                                        return node?.rich?.text.replace(/\n/g, '<br>');
-                                    case 'RICH_TEXT_NODE_TYPE_AT':
-                                        // 处理 @ 类型，使用官方的HTML标签写法
-                                        return `<span data-module="desc" data-type="at" data-oid="${node?.rich?.rid}" class="bili-rich-text-module at">${node?.rich?.text}</span>`;
-                                    case 'RICH_TEXT_NODE_TYPE_LOTTERY':
-                                        // 处理互动抽奖类型，使用官方的HTML标签写法
-                                        return `<span data-module="desc" data-type="lottery" data-oid="${node?.rich?.rid}" class="bili-rich-text-module lottery">${node?.rich?.text}</span>`;
-                                    case 'RICH_TEXT_NODE_TYPE_WEB':
-                                        // 处理 RICH_TEXT_NODE_TYPE_WEB 类型，直接拼接 text 属性
-                                        return node?.rich?.text;
-                                    case 'RICH_TEXT_NODE_TYPE_EMOJI':
-                                        // 处理表情类型，使用 img 标签显示表情
-                                        const emoji = node?.rich?.emoji;
-                                        return `<img src="${emoji?.icon_url}" alt="${emoji?.text}" title="${emoji?.text}" style="vertical-align: middle; width: ${emoji?.size}em; height: ${emoji?.size}em;">`;
-                                    case 'RICH_TEXT_NODE_TYPE_GOODS':
-                                        // 处理商品推广类型，使用官方的HTML标签写法
-                                        const goods_url = node?.rich?.jump_url;
-                                        return `<span data-module="desc" data-type="goods" data-url="${goods_url}" data-oid="${node?.rich?.rid}" class="bili-rich-text-module goods ${node?.rich?.icon_name}">&ZeroWidthSpace;${node?.rich?.text}</span>`;
-                                    default:
-                                        return node;
+                        if (item.text?.nodes) {
+                            content += item.text.nodes
+                                .map((node) => {
+                                let nodeType = node.type;
+                                if (nodeType === 'TEXT_NODE_TYPE_RICH') {
+                                    let richType = node?.rich?.type;
+                                    switch (richType) {
+                                        case 'RICH_TEXT_NODE_TYPE_TOPIC':
+                                            // 确保链接以 https:// 开头
+                                            let jumpUrl = node?.rich?.jump_url;
+                                            if (jumpUrl && !jumpUrl.startsWith('http://') && !jumpUrl.startsWith('https://')) {
+                                                jumpUrl = `https://${jumpUrl}`;
+                                            }
+                                            return `<span class="bili-rich-text-module topic" href="${jumpUrl}">${node?.rich?.text}</span>`;
+                                        case 'RICH_TEXT_NODE_TYPE_TEXT':
+                                            // 正文将 \n 替换为 <br> 以实现换行
+                                            return node?.rich?.text.replace(/\n/g, '<br>');
+                                        case 'RICH_TEXT_NODE_TYPE_AT':
+                                            // 处理 @ 类型，使用官方的HTML标签写法
+                                            return `<span data-module="desc" data-type="at" data-oid="${node?.rich?.rid}" class="bili-rich-text-module at">${node?.rich?.text}</span>`;
+                                        case 'RICH_TEXT_NODE_TYPE_LOTTERY':
+                                            // 处理互动抽奖类型，使用官方的HTML标签写法
+                                            return `<span data-module="desc" data-type="lottery" data-oid="${node?.rich?.rid}" class="bili-rich-text-module lottery">${node?.rich?.text}</span>`;
+                                        case 'RICH_TEXT_NODE_TYPE_WEB':
+                                            // 处理 RICH_TEXT_NODE_TYPE_WEB 类型，直接拼接 text 属性
+                                            return node?.rich?.text;
+                                        case 'RICH_TEXT_NODE_TYPE_EMOJI':
+                                            // 处理表情类型，使用 img 标签显示表情
+                                            const emoji = node?.rich?.emoji;
+                                            return `<img src="${emoji?.icon_url}" alt="${emoji?.text}" title="${emoji?.text}" style="vertical-align: middle; width: ${emoji?.size}em; height: ${emoji?.size}em;">`;
+                                        case 'RICH_TEXT_NODE_TYPE_GOODS':
+                                            // 处理商品推广类型，使用官方的HTML标签写法
+                                            const goods_url = node?.rich?.jump_url;
+                                            return `<span data-module="desc" data-type="goods" data-url="${goods_url}" data-oid="${node?.rich?.rid}" class="bili-rich-text-module goods ${node?.rich?.icon_name}">&ZeroWidthSpace;${node?.rich?.text}</span>`;
+                                        default:
+                                            return node;
+                                    }
                                 }
-                            }
-                            else if (nodeType === 'TEXT_NODE_TYPE_WORD') {
-                                return `${node?.word?.words}<br>`;
-                            }
-                        })
-                            .join('');
+                                else if (nodeType === 'TEXT_NODE_TYPE_WORD') {
+                                    return `${node?.word?.words}<br>`;
+                                }
+                            })
+                                .join('');
+                        }
                         break;
                     case 2:
                         // 处理图片
-                        img = img.concat(item?.pic?.pics.map((item) => {
-                            return { url: item?.url, width: item?.width, height: item?.height };
-                        }) || []);
+                        if (item?.pic?.pics) {
+                            img = img.concat(item?.pic?.pics.map((item) => {
+                                return { url: item?.url, width: item?.width, height: item?.height };
+                            }) || []);
+                        }
                         break;
                 }
             });
@@ -556,7 +577,7 @@ class BiliQuery {
                 return { msg, pics };
             default:
                 // 处理未定义的动态类型
-                (Bot.logger ?? logger)?.mark(`未处理的B站推送【${upName}】：${data.type}`);
+                global?.logger?.mark(`未处理的B站推送【${upName}】：${data.type}`);
                 return 'continue';
         }
     }

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

@@ -1,5 +1,5 @@
 import QRCode from 'qrcode';
-import { Redis, Bot, Segment } from 'yunzaijs';
+import { Redis, Segment, Bot } from 'yunzaijs';
 import Config from '../../utils/config.js';
 import { renderPage } from '../../utils/image.js';
 import { BiliGetWebData } from './bilibili.main.get.web.data.js';
@@ -59,6 +59,8 @@ class BiliTask {
                 uidMap.set(chatType, new Map());
             }
             const chatTypeMap = uidMap.get(chatType); // 建立当前 chatType (group 或 private) 的 uid 映射
+            if (chatTypeMap === undefined)
+                continue; // 如果 chatTypeMap 未定义，跳过此次循环
             for (let chatId in biliPushData[chatType]) {
                 const subUpsOfChat = Array.prototype.slice.call(biliPushData[chatType][chatId] || []);
                 for (let subInfoOfup of subUpsOfChat) {
@@ -148,10 +150,18 @@ class BiliTask {
             }
         }
     }
-    /*发送动态*/
+    /**
+     * 发送动态消息
+     * @param chatId 聊天 ID
+     * @param bot_id 机器人 ID
+     * @param upName 用户名
+     * @param pushDynamicData 推送动态数据
+     * @param biliConfigData 哔哩配置数据
+     * @param chatType 聊天类型
+     */
     async sendDynamic(chatId, bot_id, upName, pushDynamicData, biliConfigData, chatType) {
         const id_str = pushDynamicData.id_str;
-        let sended, markKey;
+        let sended = null, markKey = '';
         if (chatType === 'group') {
             markKey = this.groupKey;
             sended = await Redis.get(`${markKey}${chatId}:${id_str}`);
@@ -192,7 +202,7 @@ class BiliTask {
             if (!imgs)
                 return;
             Redis.set(`${markKey}${chatId}:${id_str}`, '1', { EX: 3600 * 72 }); // 设置已发送标记
-            (logger ?? Bot.logger)?.mark('优纪插件：B站动态执行推送');
+            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));
@@ -203,7 +213,7 @@ class BiliTask {
         else {
             const dynamicMsg = await BiliQuery.formatTextDynamicData(upName, pushDynamicData, false, biliConfigData); // 构建图文动态消息
             Redis.set(`${markKey}${chatId}:${id_str}`, '1', { EX: 3600 * 72 }); // 设置已发送标记
-            if (dynamicMsg == 'continue') {
+            if (dynamicMsg === undefined || dynamicMsg === 'continue') {
                 return 'return'; // 如果动态消息构建失败，则直接返回
             }
             if (biliConfigData.banWords.length > 0) {
@@ -212,15 +222,22 @@ class BiliTask {
                     return 'return'; // 如果动态消息包含屏蔽关键字，则直接返回
                 }
             }
-            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秒
+            let mergeTextPic = !!biliConfigData.mergeTextPic === false ? false : true; // 是否合并文本和图片，默认为 true
+            if (mergeTextPic) {
+                const mergeMsg = [...dynamicMsg.msg, ...dynamicMsg.pics];
+                await this.sendMessage(chatId, bot_id, chatType, 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 new Promise(resolve => setTimeout(resolve, 1000));
         }
     }
     /**
@@ -312,7 +329,7 @@ class BiliTask {
                 ?.pickGroup(String(chatId))
                 .sendMsg(message) // 发送群聊
                 .catch((error) => {
-                (logger ?? Bot.logger)?.error(`群组[${chatId}]推送失败：${JSON.stringify(error)}`);
+                global?.logger?.error(`群组[${chatId}]推送失败：${JSON.stringify(error)}`);
             });
         }
         else if (chatType === 'private') {
@@ -320,7 +337,7 @@ class BiliTask {
                 ?.pickFriend(String(chatId))
                 .sendMsg(message)
                 .catch((error) => {
-                (logger ?? Bot.logger)?.error(`用户[${chatId}]推送失败：${JSON.stringify(error)}`);
+                global?.logger?.error(`用户[${chatId}]推送失败：${JSON.stringify(error)}`);
             }); // 发送好友私聊
         }
     }

package/lib/models/weibo/weibo.get.web.data.js

@@ -1,5 +1,4 @@
 import axios from 'axios';
-import { Bot } from 'yunzaijs';
 import { WeiboApi } from './weibo.api.js';
 import { WeiboQuery } from './weibo.query.js';
 
@@ -48,7 +47,7 @@ class WeiboGetWebData {
             return data.cards.filter(WeiboQuery.filterCardTypeCustom);
         }
         catch (error) {
-            (logger ?? Bot.logger)?.mark('微博推送：Error fetching sub list:', error);
+            global?.logger?.mark('微博推送：Error fetching sub list:', error);
             return [];
         }
     }

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

@@ -1,7 +1,7 @@
 import moment from 'moment';
 import fetch from 'node-fetch';
 import { WeiboApi } from './weibo.api.js';
-import { Bot, Segment } from 'yunzaijs';
+import { Segment } from 'yunzaijs';
 import { JSDOM } from 'jsdom';
 
 class WeiboQuery {
@@ -195,7 +195,7 @@ class WeiboQuery {
                 }
             }
             catch (err) {
-                (logger ?? Bot.logger)?.mark(`优纪插件：获取微博动态全文出错：https://m.weibo.cn/detail/${info?.mid}`);
+                global?.logger?.mark(`优纪插件：获取微博动态全文出错：https://m.weibo.cn/detail/${info?.mid}`);
             }
         }
         /**动态发布时间 */

package/lib/models/weibo/weibo.task.js

@@ -1,5 +1,5 @@
 import QRCode from 'qrcode';
-import { Redis, Bot, Segment } from 'yunzaijs';
+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';
@@ -39,6 +39,8 @@ class WeiboTask {
                 uidMap.set(chatType, new Map());
             }
             const chatTypeMap = uidMap.get(chatType); // 建立当前 chatType (group 或 private) 的 uid 映射
+            if (chatTypeMap === undefined)
+                continue; // 如果 chatTypeMap 未定义，跳过此次循环
             for (let chatId in weiboPushData[chatType]) {
                 const subUpsOfChat = Array.prototype.slice.call(weiboPushData[chatType][chatId] || []);
                 for (let subInfoOfup of subUpsOfChat) {
@@ -126,7 +128,7 @@ class WeiboTask {
      */
     async sendDynamic(chatId, bot_id, upName, pushDynamicData, weiboConfigData, chatType) {
         const id_str = WeiboQuery.getDynamicId(pushDynamicData); // 获取动态 ID
-        let sended, markKey;
+        let sended = null, markKey = '';
         if (chatType === 'group') {
             markKey = this.groupKey;
             sended = await Redis.get(`${markKey}${chatId}:${id_str}`);
@@ -167,7 +169,7 @@ class WeiboTask {
             if (!imgs)
                 return;
             Redis.set(`${markKey}${chatId}:${id_str}`, '1', { EX: 3600 * 72 }); // 设置已发送标记
-            (logger ?? Bot.logger)?.mark('优纪插件：微博动态执行推送');
+            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));
@@ -178,7 +180,7 @@ class WeiboTask {
         else {
             const dynamicMsg = await WeiboQuery.formatTextDynamicData(upName, pushDynamicData, false, weiboConfigData); //构建文字动态消息
             Redis.set(`${markKey}${chatId}:${id_str}`, '1', { EX: 3600 * 72 }); // 设置已发送标记
-            if (dynamicMsg == 'continue') {
+            if (dynamicMsg === undefined || dynamicMsg === 'continue') {
                 return 'return'; // 如果动态消息构建失败或内部资源获取失败，则直接返回
             }
             if (weiboConfigData.banWords.length > 0) {
@@ -187,15 +189,22 @@ class WeiboTask {
                     return 'return'; // 如果动态消息包含屏蔽关键字，则直接返回
                 }
             }
-            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秒
+            let mergeTextPic = !!weiboConfigData.mergeTextPic === false ? false : true; // 是否合并文字和图片，默认为 true
+            if (mergeTextPic) {
+                const mergeMsg = [...dynamicMsg.msg, ...dynamicMsg.pics];
+                await this.sendMessage(chatId, bot_id, chatType, 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 new Promise(resolve => setTimeout(resolve, 1000));
         }
     }
     /**
@@ -287,7 +296,7 @@ class WeiboTask {
                 ?.pickGroup(String(chatId))
                 .sendMsg(message) // 发送群聊
                 .catch(error => {
-                (logger ?? Bot.logger)?.error(`群组[${chatId}]推送失败：${JSON.stringify(error)}`);
+                global?.logger?.error(`群组[${chatId}]推送失败：${JSON.stringify(error)}`);
             });
         }
         else if (chatType === 'private') {
@@ -295,7 +304,7 @@ class WeiboTask {
                 ?.pickFriend(String(chatId))
                 .sendMsg(message)
                 .catch(error => {
-                (logger ?? Bot.logger)?.error(`用户[${chatId}]推送失败：${JSON.stringify(error)}`);
+                global?.logger?.error(`用户[${chatId}]推送失败：${JSON.stringify(error)}`);
             }); // 发送好友私聊
         }
     }

package/lib/utils/config.js

@@ -1,6 +1,6 @@
 import * as fs from 'fs';
 import YAML from 'yaml';
-import chokidar from 'chokidar';
+import * as chokidar from 'chokidar';
 import lodash from 'lodash';
 import path from 'path';
 import { _paths } from './paths.js';

package/lib/utils/image.js

@@ -43,7 +43,7 @@ class Image extends Picture {
     }
 }
 // 存储单例实例
-let instance = null;
+let instance;
 // 存储任务队列
 const queue = [];
 // 标记当前是否有任务正在处理

package/lib/utils/puppeteer.render.js

@@ -47,6 +47,8 @@ class YukiPuppeteerRender {
                 await page.addStyleTag({ content: Options.addStyle });
             }
             const boundingBox = await element.boundingBox(); // 获取内容区域的边界框信息
+            if (!boundingBox)
+                return false;
             const num = Options?.isSplit ? Math.ceil(boundingBox.height / pageHeight) : 1; // 根据是否需要分片，计算分片数量，默认为 1
             pageHeight = Math.round(boundingBox.height / num); //动态调整分片高度，防止过短影响观感。
             await page.setViewport({ width: boundingBox.width + 50, height: pageHeight + 100 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yz-yuki-plugin",
-  "version": "2.0.6-0",
+  "version": "2.0.6-2",
   "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.0.8",
     "lodash": "^4.17.21",
     "md5": "^2.3.0",
     "moment": "^2.30.1",
     "node-fetch": "^3.3.2",
-    "puppeteer": "^23.10.1",
+    "puppeteer": "^23.11.1",
     "qrcode": "^1.5.4",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
@@ -46,6 +46,7 @@
   },
   "devDependencies": {
     "@types/chalk": "2.2.0",
+    "@types/chokidar": "2.1.7",
     "@types/jsdom": "^21.1.7",
     "@types/lodash": "^4.17.7",
     "@types/md5": "^2.3.5",
@@ -61,21 +62,21 @@
     "husky": "^9.1.6",
     "jsdom": "^24.1.1",
     "json5": "^2.2.3",
-    "jsxp": "^1.0.4",
+    "jsxp": "^1.0.8",
     "lodash": "^4.17.21",
-    "lvyjs": "^0.1.4",
+    "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": "^23.11.1",
     "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"