yz-yuki-plugin 2.0.6-0 → 2.0.6-10

package/.puppeteerrc.cjs

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

package/CHANGELOG.md

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

package/README.md

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

package/defaultConfig/bilibili/config.yaml

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

package/defaultConfig/weibo/config.yaml

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

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

package/lib/index.js

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

package/lib/models/bilibili/bilibili.main.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;
                 }
             });
@@ -374,6 +395,7 @@ class BiliQuery {
         const BiliDrawDynamicLinkUrl = 'https://m.bilibili.com/dynamic/';
         let desc, msg = [], pics = [], author, majorType, content, dynamicTitle;
         let title = `B站【${upName}】动态推送：\n`;
+        let dynamicType = data.type;
         switch (data.type) {
             case 'DYNAMIC_TYPE_AV':
                 // 处理视频动态
@@ -391,7 +413,7 @@ class BiliQuery {
                     `时间：${author ? moment(author.pub_ts * 1000).format('YYYY年MM月DD日 HH:mm:ss') : ''}`
                 ];
                 pics = [Segment.image(desc?.cover)];
-                return { msg, pics };
+                return { msg, pics, dynamicType };
             case 'DYNAMIC_TYPE_WORD':
                 // 处理文字动态
                 author = data?.modules?.module_author;
@@ -421,7 +443,7 @@ class BiliQuery {
                     `链接：${BiliDrawDynamicLinkUrl}${data.id_str}\n`,
                     `时间：${author ? moment(author.pub_ts * 1000).format('YYYY年MM月DD日 HH:mm:ss') : ''}`
                 ];
-                return { msg, pics };
+                return { msg, pics, dynamicType };
             case 'DYNAMIC_TYPE_DRAW':
                 // 处理图文动态
                 author = data?.modules?.module_author;
@@ -467,7 +489,7 @@ class BiliQuery {
                     `链接：${BiliDrawDynamicLinkUrl}${data.id_str}\n`,
                     `时间：${author ? moment(author.pub_ts * 1000).format('YYYY年MM月DD日 HH:mm:ss') : ''}`
                 ];
-                return { msg, pics };
+                return { msg, pics, dynamicType };
             case 'DYNAMIC_TYPE_ARTICLE':
                 // 处理文章动态
                 author = data?.modules?.module_author;
@@ -510,7 +532,7 @@ class BiliQuery {
                     `链接：${this.formatUrl(desc.jump_url)}\n`,
                     `时间：${author ? moment(author.pub_ts * 1000).format('YYYY年MM月DD日 HH:mm:ss') : ''}`
                 ];
-                return { msg, pics };
+                return { msg, pics, dynamicType };
             case 'DYNAMIC_TYPE_FORWARD':
                 // 处理转发动态
                 author = data?.modules?.module_author;
@@ -540,7 +562,7 @@ class BiliQuery {
                     '\n---以下为转发内容---\n',
                     ...origContent
                 ];
-                return { msg, pics };
+                return { msg, pics, dynamicType };
             case 'DYNAMIC_TYPE_LIVE_RCMD':
                 // 处理直播动态
                 desc = data?.modules?.module_dynamic?.major?.live_rcmd?.content;
@@ -553,10 +575,10 @@ class BiliQuery {
                 title = `B站【${upName}】直播动态推送：\n`;
                 msg = [title, `-----------------------------\n`, `标题：${desc.title}\n`, `链接：https:${desc.link}`];
                 pics = [Segment.image(desc.cover)];
-                return { msg, pics };
+                return { msg, pics, dynamicType };
             default:
                 // 处理未定义的动态类型
-                (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';
@@ -37,6 +37,7 @@ class BiliTask {
         let biliConfigData = await Config.getUserConfig('bilibili', 'config');
         let biliPushData = await Config.getUserConfig('bilibili', 'push');
         let interval = biliConfigData?.interval || 7200;
+        logger.debug(`当前B站功能配置：${JSON.stringify(biliConfigData)}`);
         const uidMap = new Map(); // 存放group 和 private 对应所属 uid 与推送信息的映射
         const dynamicList = {}; // 存放获取的所有动态，键为 uid，值为动态数组
         await this.processBiliData(biliPushData, biliConfigData, uidMap, dynamicList);
@@ -59,6 +60,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 +151,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}`);
@@ -162,6 +173,11 @@ 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) {
             const { data, uid } = await BiliQuery.formatDynamicData(pushDynamicData); // 处理动态数据
             const extentData = { ...data };
@@ -192,7 +208,17 @@ class BiliTask {
             if (!imgs)
                 return;
             Redis.set(`${markKey}${chatId}:${id_str}`, '1', { EX: 3600 * 72 }); // 设置已发送标记
-            (logger ?? Bot.logger)?.mark('优纪插件：B站动态执行推送');
+            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));
@@ -203,24 +229,52 @@ 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) {
-                const banWords = new RegExp(biliConfigData.banWords.join('|'), 'g'); // 构建屏蔽关键字正则表达式
+            const getBanWords = biliConfigData?.banWords;
+            if (getBanWords && Array.isArray(getBanWords) && getBanWords.length > 0) {
+                const banWords = new RegExp(getBanWords.join('|'), 'g'); // 构建屏蔽关键字正则表达式
                 if (banWords.test(dynamicMsg.msg.join(''))) {
                     return 'return'; // 如果动态消息包含屏蔽关键字，则直接返回
                 }
             }
-            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 === 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);
+            }
+            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 new Promise(resolve => setTimeout(resolve, 1000));
         }
     }
     /**
@@ -312,7 +366,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 +374,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/bilibili/bilibili.risk.w_webid.js

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

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

@@ -1,7 +1,6 @@
 import axios from 'axios';
-import { Bot } from 'yunzaijs';
-import { WeiboApi } from './weibo.api.js';
-import { WeiboQuery } from './weibo.query.js';
+import { WeiboApi } from './weibo.main.api.js';
+import { WeiboQuery } from './weibo.main.query.js';
 
 class WeiboGetWebData {
     e;
@@ -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 → weibo.main.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 { WeiboApi } from './weibo.main.api.js';
+import { Segment } from 'yunzaijs';
 import { JSDOM } from 'jsdom';
 
 class WeiboQuery {
@@ -29,9 +29,12 @@ class WeiboQuery {
         else if (raw_post?.mblog?.pics) {
             return 'DYNAMIC_TYPE_DRAW';
         }
-        else {
+        else if (!raw_post?.mblog?.pics && String(raw_post?.mblog?.text).trim().length > 0) {
             return 'DYNAMIC_TYPE_ARTICLE';
         }
+        else {
+            return 'DYNAMIC_TYPE_UNKNOWN';
+        }
     }
     /**筛选正文 */
     static filterText(raw_text) {
@@ -77,6 +80,7 @@ class WeiboQuery {
         formatData.data.name = nick_name;
         /**头像框 */
         formatData.data.pendant = '';
+        /**生成日期 */
         formatData.data.created = moment().format('YYYY年MM月DD日 HH:mm:ss');
         formatData.data.type = type;
         switch (type) {
@@ -195,7 +199,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 → weibo.main.task.js}

@@ -1,9 +1,9 @@
 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';
-import { WeiboQuery } from './weibo.query.js';
+import { WeiboGetWebData } from './weibo.main.get.web.data.js';
+import { WeiboQuery } from './weibo.main.query.js';
 
 class WeiboTask {
     taskName;
@@ -19,6 +19,7 @@ class WeiboTask {
         let weiboConfigData = await Config.getUserConfig('weibo', 'config');
         let weiboPushData = await Config.getUserConfig('weibo', 'push');
         let interval = weiboConfigData.interval || 7200; // 推送间隔时间，单位为秒，默认2小时
+        logger.debug(`当前微博功能配置：${JSON.stringify(weiboConfigData)}`);
         const uidMap = new Map(); // 存放group 和 private 对应所属 uid 与推送信息的映射
         const dynamicList = {}; // 存放获取的所有动态，键为 uid，值为动态数组
         await this.processWeiboData(weiboPushData, uidMap, dynamicList);
@@ -39,6 +40,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 +129,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 +170,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,24 +181,32 @@ 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) {
-                const banWords = new RegExp(weiboConfigData.banWords.join('|'), 'g'); // 构建屏蔽关键字正则表达式
+            const getBanWords = weiboConfigData?.banWords;
+            if (getBanWords && Array.isArray(getBanWords) && getBanWords.length > 0) {
+                const banWords = new RegExp(getBanWords.join('|'), 'g'); // 构建屏蔽关键字正则表达式
                 if (banWords.test(dynamicMsg.msg.join(''))) {
                     return 'return'; // 如果动态消息包含屏蔽关键字，则直接返回
                 }
             }
-            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 +298,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 +306,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

@@ -15,11 +15,11 @@ class Image extends Picture {
         // 继承父类实例
         super();
         // 父类已经实例化组件渲染对象
-        //this.Com;
+        //this.component;
         // 父类已经实例化启动 Puppeteer
-        //this.Pup.start();
+        //this.puppeteer.start();
         // 初始化 YukiPuppeteerRender 实例
-        this.yukiPuppeteerRender = new YukiPuppeteerRender(this.Pup);
+        this.yukiPuppeteerRender = new YukiPuppeteerRender(this.puppeteer);
     }
     /**
      * 实例方法，用于执行实际的渲染和截图操作
@@ -34,7 +34,7 @@ class Image extends Picture {
         // 根据组件名称获取对应的 React 组件
         const Page = index[page];
         // 调用 yukiPuppeteerRender 进行截图操作
-        return this.yukiPuppeteerRender.yukiScreenshot(this.Com.compile({
+        return this.yukiPuppeteerRender.yukiScreenshot(this.component.compile({
             path: page,
             name: `${uid}.html`,
             component: React.createElement(Page, { ...props }),
@@ -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-10",
   "description": "优纪插件，yunzaijs 关于 微博推送、B站推送 等功能的拓展插件",
   "author": "snowtafir",
   "type": "module",
@@ -31,12 +31,12 @@
     "debug": "^4.3.6",
     "jsdom": "^25.0.1",
     "json5": "^2.2.3",
-    "jsxp": "^1.0.4",
+    "jsxp": "^1.1.2",
     "lodash": "^4.17.21",
     "md5": "^2.3.0",
     "moment": "^2.30.1",
     "node-fetch": "^3.3.2",
-    "puppeteer": "^23.10.1",
+    "puppeteer": "^24.1.0",
     "qrcode": "^1.5.4",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
@@ -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",
@@ -59,23 +60,24 @@
     "axios": "^1.7.9",
     "chokidar": "^4.0.1",
     "husky": "^9.1.6",
+    "icqq": "^0.6.10",
     "jsdom": "^24.1.1",
     "json5": "^2.2.3",
-    "jsxp": "^1.0.4",
+    "jsxp": "^1.1.2",
     "lodash": "^4.17.21",
-    "lvyjs": "^0.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": "^24.1.0",
     "qrcode": "^1.5.4",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "redis": "^4.7.0",
     "tailwindcss": "^3.4.14",
     "ts-node": "^10.9.2",
-    "tsx": "^4.19.0",
+    "tsx": "^4.19.2",
     "typescript": "^5.5.4",
     "yaml": "^2.6.1",
     "yunzaijs": "^1.0.0-rc.5"
@@ -105,6 +107,6 @@
     "registry": "https://registry.npmjs.org"
   },
   "engines": {
-    "node": ">=16.14.0"
+    "node": ">=20"
   }
 }