koishi-plugin-bilibili-videolink-analysis 1.1.20 → 1.1.22

package/lib/index.js

@@ -118,6 +118,7 @@ exports.Config = Schema.intersect([
 
             Schema.object({
                 isfigure: Schema.boolean().default(false).description("是否开启合并转发 `仅支持 onebot 适配器` 其他平台开启 无效").experimental(),
+                filebuffer: Schema.boolean().default(true).description("是否将视频链接下载后再发送 （以解决部分onebot协议端的问题）<br>否则使用视频直链发送").experimental(),
                 middleware: Schema.boolean().default(false).description("前置中间件模式"),
                 userAgent: Schema.string().description("所有 API 请求所用的 User-Agent").default("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36"),
             }).description("调试设置"),
@@ -455,7 +456,6 @@ display: none !important;
         return false; // 没有处理过
     }
 
-    //解析视频并返回
     async function processVideoFromLink(session, config, ctx, lastProcessedUrls, logger, ret, options = { video: true }) {
         const lastretUrl = extractLastUrl(ret);
 
@@ -464,11 +464,44 @@ display: none !important;
             await session.send(config.waitTip_Switch);
         }
 
-        let responseElements = []; // 用于存储所有要发送的元素
+        let videoElements = []; // 用于存储视频相关元素
+        let textElements = []; // 用于存储图文解析元素
         let shouldPerformTextParsing = config.linktextParsing; // 默认根据配置决定是否进行图文解析
-        //let videoTooLong = false; // 标记视频是否太长
+        let isLongVideo = false; // 标记视频是否过长
 
-        // 视频/链接解析 - 先检查视频时长
+        // 先进行图文解析
+        if (shouldPerformTextParsing) {
+            let fullText;
+            if (config.bVideoShowLink) {
+                fullText = ret; // 发送完整信息
+            } else {
+                // 去掉最后一个链接
+                fullText = ret.replace(lastretUrl, '');
+            }
+
+            // 分割文本
+            const textParts = fullText.split('${~~~}');
+
+            // 循环处理每个分割后的部分
+            for (const part of textParts) {
+                const trimmedPart = part.trim(); // 去除首尾空格
+                if (trimmedPart) { // 确保不是空字符串
+                    // 使用 h.parse 解析文本为消息元素
+                    const parsedElements = h.parse(trimmedPart);
+
+                    // 创建 message 元素
+                    const messageElement = h('message', {
+                        userId: session.userId,
+                        nickname: session.author?.nickname || session.username,
+                    }, parsedElements);
+
+                    // 添加 message 元素到 textElements
+                    textElements.push(messageElement);
+                }
+            }
+        }
+
+        // 视频/链接解析
         if (config.VideoParsing_ToLink) {
             const fullAPIurl = `http://api.xingzhige.cn/API/b_parse/?url=${encodeURIComponent(lastretUrl)}`;
 
@@ -487,7 +520,7 @@ display: none !important;
                         const videoDurationMinutes = videoDurationSeconds / 60;
 
                         if (videoDurationMinutes > config.Maximumduration) {
-                            //videoTooLong = true;
+                            isLongVideo = true;
 
                             // 根据 Maximumduration_tip 的值决定行为
                             if (config.Maximumduration_tip === 'return') {
@@ -497,41 +530,75 @@ display: none !important;
                                 // 返回文字提示
                                 if (config.Maximumduration_tip.tipcontent) {
                                     if (config.Maximumduration_tip.tipanalysis) {
-                                        await responseElements.push(h.text(config.Maximumduration_tip.tipcontent))
+                                        videoElements.push(h.text(config.Maximumduration_tip.tipcontent));
                                     } else {
                                         await session.send(config.Maximumduration_tip.tipcontent);
                                     }
                                 }
+
                                 // 决定是否进行图文解析
                                 shouldPerformTextParsing = config.Maximumduration_tip.tipanalysis === true;
+
+                                // 如果不进行图文解析，清空已准备的文本元素
+                                if (!shouldPerformTextParsing) {
+                                    textElements = [];
+                                }
                             }
                         } else {
                             // 视频时长在允许范围内，处理视频
-                            const videoUrl = video.url;
-                            logInfo(videoUrl);
+                            let videoData = video.url;  // 使用新变量名，避免覆盖原始URL
+                            logInfo(videoData);
+
+                            if (config.filebuffer) {
+                                try {
+                                    const videoFileBuffer = await ctx.http.file(video.url);
+                                    logInfo(videoFileBuffer);
+
+                                    // 检查文件类型
+                                    if (videoFileBuffer && videoFileBuffer.data) {
+                                        // 将ArrayBuffer转换为Buffer
+                                        const buffer = Buffer.from(videoFileBuffer.data);
+
+                                        // 获取MIME类型
+                                        const mimeType = videoFileBuffer.type || videoFileBuffer.mime || 'video/mp4';
+
+                                        // 创建data URI
+                                        const base64Data = buffer.toString('base64');
+                                        videoData = `data:${mimeType};base64,${base64Data}`;
+
+                                        logInfo("成功使用 ctx.http.file 将视频URL 转换为data URI格式");
+                                    } else {
+                                        logInfo("文件数据无效，使用原始URL");
+                                    }
+                                } catch (error) {
+                                    logger.error("获取视频文件失败:", error);
+                                    // 出错时继续使用原始URL
+                                }
+                            }
 
-                            if (videoUrl) {
+                            if (videoData) {
                                 if (options.link) {
-                                    responseElements.push(h.text(videoUrl));
+                                    // 如果是链接选项，仍然使用原始URL
+                                    videoElements.push(h.text(video.url));
                                 } else if (options.audio) {
-                                    responseElements.push(h.audio(videoUrl));
+                                    videoElements.push(h.audio(videoData));
                                 } else {
                                     switch (config.VideoParsing_ToLink) {
                                         case '1':
                                             break;
                                         case '2':
-                                            responseElements.push(h.video(videoUrl));
+                                            videoElements.push(h.video(videoData));
                                             break;
                                         case '3':
-                                            responseElements.push(h.text(videoUrl));
+                                            videoElements.push(h.text(video.url));
                                             break;
                                         case '4':
-                                            responseElements.push(h.text(videoUrl));
-                                            responseElements.push(h.video(videoUrl));
+                                            videoElements.push(h.text(video.url));
+                                            videoElements.push(h.video(videoData));
                                             break;
                                         case '5':
-                                            logger.info(videoUrl);
-                                            responseElements.push(h.video(videoUrl));
+                                            logger.info(video.url);
+                                            videoElements.push(h.video(videoData));
                                             break;
                                         default:
                                             break;
@@ -540,6 +607,7 @@ display: none !important;
                             } else {
                                 throw new Error("解析视频直链失败");
                             }
+
                         }
                     } else {
                         throw new Error("获取播放数据失败");
@@ -552,40 +620,20 @@ display: none !important;
             }
         }
 
-        // 图文解析 - 根据 shouldPerformTextParsing 决定是否执行
-        if (shouldPerformTextParsing) {
-            let fullText;
-            if (config.bVideoShowLink) {
-                fullText = ret; // 发送完整信息
-            } else {
-                // 去掉最后一个链接
-                fullText = ret.replace(lastretUrl, '');
-            }
-
-            // 分割文本
-            const textParts = fullText.split('${~~~}');
-
-            // 循环处理每个分割后的部分
-            for (const part of textParts) {
-                const trimmedPart = part.trim(); // 去除首尾空格
-                if (trimmedPart) { // 确保不是空字符串
-                    // 使用 h.parse 解析文本为消息元素
-                    const parsedElements = h.parse(trimmedPart);
-
-                    // 创建 message 元素
-                    const messageElement = h('message', {
-                        userId: session.userId,
-                        nickname: session.author?.nickname || session.username,
-                    }, parsedElements);
+        // 准备发送的所有元素
+        let allElements = [];
 
-                    // 添加 message 元素到 responseElements
-                    responseElements.push(messageElement);
-                }
-            }
+        // 根据视频是否过长决定发送顺序
+        if (isLongVideo) {
+            // 过长视频：先发送过长提示（已在上面处理），然后是图文解析（如果启用）
+            allElements = [...textElements, ...videoElements];
+        } else {
+            // 正常视频：先发送图文解析，然后是视频元素
+            allElements = [...textElements, ...videoElements];
         }
 
         // 如果没有任何元素要发送，则直接返回
-        if (responseElements.length === 0) {
+        if (allElements.length === 0) {
             return;
         }
 
@@ -595,15 +643,43 @@ display: none !important;
 
             // 创建 figure 元素
             const figureContent = h('figure', {
-                children: responseElements // 直接使用 responseElements
+                children: allElements
             });
-            logInfo(JSON.stringify(figureContent, null, 2));
+
+            // 创建一个用于日志的深拷贝对象，避免修改原始对象
+            const logObject = JSON.parse(JSON.stringify(figureContent));
+
+            // 递归处理对象，截断长字符串
+            function truncateLongStrings(obj, maxLength = 150) {
+                if (!obj) return obj;
+
+                if (typeof obj === 'string' && obj.length > maxLength) {
+                    return obj.substring(0, maxLength) + '... [截断剩余' + (obj.length - maxLength) + '字符]';
+                }
+
+                if (Array.isArray(obj)) {
+                    return obj.map(item => truncateLongStrings(item, maxLength));
+                }
+
+                if (typeof obj === 'object') {
+                    const newObj = {};
+                    for (const key in obj) {
+                        newObj[key] = truncateLongStrings(obj[key], maxLength);
+                    }
+                    return newObj;
+                }
+
+                return obj;
+            }
+
+            // 截断长字符串后再打印
+            logInfo(JSON.stringify(truncateLongStrings(logObject), null, 2));
 
             // 发送合并转发消息
             await session.send(figureContent);
         } else {
             // 没有启用合并转发，按顺序发送所有元素
-            for (const element of responseElements) {
+            for (const element of allElements) {
                 await session.send(element);
             }
         }

package/package.json

@@ -2,7 +2,7 @@
   "name": "koishi-plugin-bilibili-videolink-analysis",
   "description": "[<ruby>Bilibili视频解析<rp>（</rp><rt>点我查看食用方法</rt><rp>）</rp></ruby>](https://www.npmjs.com/package/koishi-plugin-bilibili-videolink-analysis)解析B站链接（支持小程序卡片）支持搜索点播功能！灵感来自完美的 [bili-parser](/market?keyword=bili-parser) ！",
   "license": "MIT",
-  "version": "1.1.20",
+  "version": "1.1.22",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [