koishi-plugin-video-parser-all 0.9.5 → 0.9.7

package/lib/index.js

@@ -7,6 +7,7 @@ exports.Config = exports.name = void 0;
 exports.apply = apply;
 const koishi_1 = require("koishi");
 const axios_1 = __importDefault(require("axios"));
+const fast_xml_parser_1 = require("fast-xml-parser");
 exports.name = 'video-parser-all';
 exports.Config = koishi_1.Schema.intersect([
     koishi_1.Schema.object({
@@ -16,7 +17,7 @@ exports.Config = koishi_1.Schema.intersect([
         debug: koishi_1.Schema.boolean().default(false).description('开启调试模式，在控制台输出详细日志'),
     }).description('基础设置'),
     koishi_1.Schema.object({
-        unifiedMessageFormat: koishi_1.Schema.string().role('textarea').default(`标题：\${标题}\n作者：\${作者}\n简介：\${简介}\n点赞：\${点赞数}\n收藏：\${收藏数}\n转发：\${转发数}\n播放：\${播放数}\n评论：\${评论数}`).description('统一消息格式，可用变量：${标题} ${作者} ${简介} ${点赞数} ${收藏数} ${转发数} ${播放数} ${评论数} ${视频时长} ${发布时间} ${图片数量} ${作者ID} ${封面}'),
+        unifiedMessageFormat: koishi_1.Schema.string().role('textarea').default(`标题：${'标题'}\n作者：${'作者'}\n简介：${'简介'}\n点赞：${'点赞数'}\n收藏：${'收藏数'}\n转发：${'转发数'}\n播放：${'播放数'}\n评论：${'评论数'}\n图片数量：${'图片数量'}`).description('统一消息格式，可用变量：${标题} ${作者} ${简介} ${点赞数} ${收藏数} ${转发数} ${播放数} ${评论数} ${视频时长} ${发布时间} ${图片数量} ${作者ID} ${封面}'),
     }).description('消息格式设置'),
     koishi_1.Schema.object({
         showImageText: koishi_1.Schema.boolean().default(true).description('是否发送解析后的文字内容'),
@@ -30,7 +31,7 @@ exports.Config = koishi_1.Schema.intersect([
     }).description('网络与 API 设置'),
     koishi_1.Schema.object({
         ignoreSendError: koishi_1.Schema.boolean().default(true).description('忽略消息发送失败，避免插件崩溃'),
-        retryTimes: koishi_1.Schema.number().min(0).default(3).description('API 请求重试次数（同时用于消息发送重试）'),
+        retryTimes: koishi_1.Schema.number().min(0).default(3).description('API 请求及消息发送失败时的重试次数'),
         retryInterval: koishi_1.Schema.number().min(0).default(1000).description('重试间隔（毫秒，同时用于消息发送重试）'),
     }).description('错误与重试设置'),
     koishi_1.Schema.object({
@@ -41,7 +42,7 @@ exports.Config = koishi_1.Schema.intersect([
         unsupportedPlatformText: koishi_1.Schema.string().default('不支持该平台链接').description('不支持的平台提示'),
         invalidLinkText: koishi_1.Schema.string().default('无效的视频链接').description('无效链接提示（parse 指令）'),
         parseErrorPrefix: koishi_1.Schema.string().default('❌ 解析失败：').description('解析失败消息前缀'),
-        parseErrorItemFormat: koishi_1.Schema.string().default('【${url}】: ${msg}').description('每条解析失败格式，可用 ${url} ${msg}'),
+        parseErrorItemFormat: koishi_1.Schema.string().default('【${url}】: ${msg}').description('每条解析失败格式，可用 ${url}（链接）和 ${msg}（错误信息）'),
     }).description('界面文字设置'),
 ]);
 const logger = new koishi_1.Logger(exports.name);
@@ -85,6 +86,87 @@ function getErrorMessage(error) {
         return error.message;
     return String(error);
 }
+const xmlParser = new fast_xml_parser_1.XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: '@_',
+    allowBooleanAttributes: true,
+    trimValues: true,
+    parseTagValue: false,
+    isArray: (name) => name === 'item' || name === 'picture',
+});
+function extractUrlsFromXml(xml) {
+    const urls = [];
+    try {
+        const parsed = xmlParser.parse(xml);
+        const msg = parsed?.msg;
+        if (!msg)
+            return urls;
+        if (msg.source && typeof msg.source === 'object') {
+            const sourceUrl = msg.source['@_url'];
+            if (sourceUrl && typeof sourceUrl === 'string')
+                urls.push(sourceUrl);
+        }
+        const items = Array.isArray(msg.item) ? msg.item : (msg.item ? [msg.item] : []);
+        for (const item of items) {
+            const pictures = Array.isArray(item.picture) ? item.picture : (item.picture ? [item.picture] : []);
+            for (const pic of pictures) {
+                if (pic['@_cover'] && typeof pic['@_cover'] === 'string')
+                    urls.push(pic['@_cover']);
+            }
+            if (item.title && typeof item.title === 'string') {
+                const match = item.title.match(/https?:\/\/[^\s<>"']+/i);
+                if (match)
+                    urls.push(match[0]);
+            }
+            if (item.summary && typeof item.summary === 'string') {
+                const matches = item.summary.match(/https?:\/\/[^\s<>"']+/gi);
+                if (matches)
+                    urls.push(...matches);
+            }
+        }
+    }
+    catch (err) {
+        debugLog('WARN', `解析 XML 卡片失败: ${getErrorMessage(err)}`);
+    }
+    return urls;
+}
+function extractAllUrlsFromMessage(session) {
+    const urls = [];
+    const content = session.content?.trim() || '';
+    if (content) {
+        const textUrls = extractUrl(content);
+        urls.push(...textUrls);
+    }
+    if (session.elements) {
+        for (const elem of session.elements) {
+            if (elem.type === 'xml' && elem.data) {
+                const xmlUrls = extractUrlsFromXml(elem.data);
+                urls.push(...xmlUrls);
+            }
+            else if (elem.type === 'json' && elem.data) {
+                try {
+                    const json = JSON.parse(elem.data);
+                    const extractFromObject = (obj) => {
+                        if (!obj || typeof obj !== 'object')
+                            return;
+                        for (const val of Object.values(obj)) {
+                            if (typeof val === 'string') {
+                                const match = val.match(/https?:\/\/[^\s<>"']+/gi);
+                                if (match)
+                                    urls.push(...match);
+                            }
+                            else if (typeof val === 'object')
+                                extractFromObject(val);
+                        }
+                    };
+                    extractFromObject(json);
+                }
+                catch { }
+            }
+        }
+    }
+    return [...new Set(urls)];
+}
 function extractUrl(content) {
     const urlMatches = content.match(/https?:\/\/[^\s\"\'\>]+/gi) || [];
     return urlMatches.filter(url => {
@@ -137,9 +219,9 @@ async function resolveShortUrl(url) {
                 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
                 'Referer': 'https://www.baidu.com/',
             },
-            validateStatus: status => true
+            validateStatus: status => status >= 200 && status < 400,
         });
-        const finalUrl = res.request.res?.responseUrl || url;
+        const finalUrl = res.request?.res?.responseUrl || url;
         return cleanUrl(finalUrl);
     }
     catch (e) {
@@ -152,7 +234,9 @@ function formatDuration(seconds) {
     const h = Math.floor(seconds / 3600);
     const m = Math.floor((seconds % 3600) / 60);
     const s = Math.floor(seconds % 60);
-    return `${h.toString().padStart(2, '0')}:${m.toString().padStart(2, '0')}:${s.toString().padStart(2, '0')}`;
+    if (h > 0)
+        return `${h}:${m.toString().padStart(2, '0')}:${s.toString().padStart(2, '0')}`;
+    return `${m}:${s.toString().padStart(2, '0')}`;
 }
 function formatPublishTime(ms) {
     if (!ms)
@@ -185,7 +269,7 @@ function parseApiResponse(raw, maxDescLen) {
     }
     const authorObj = data.author;
     let author = '', uid = '', avatar = '';
-    if (typeof authorObj === 'object' && authorObj) {
+    if (authorObj && typeof authorObj === 'object') {
         author = authorObj.name || authorObj.author || '';
         uid = String(authorObj.id || data.uid || '');
         avatar = authorObj.avatar || data.avatar || '';
@@ -200,12 +284,12 @@ function parseApiResponse(raw, maxDescLen) {
     const cover = data.cover || '';
     let video = '';
     let videos = [];
-    if (data.video_backup?.length) {
+    if (Array.isArray(data.video_backup) && data.video_backup.length) {
         const bestQ = pickBestQuality(data.video_backup);
         videos = bestQ;
         video = bestQ[0]?.url || data.url || '';
     }
-    else if (data.videos?.length) {
+    else if (Array.isArray(data.videos) && data.videos.length) {
         video = data.videos[0]?.url || '';
         videos = data.videos.map((v) => ({ quality: v.accept?.[0] || 'unknown', url: v.url }));
     }
@@ -221,14 +305,14 @@ function parseApiResponse(raw, maxDescLen) {
         url: data.music?.url || ''
     };
     const stats = extra.statistics || {};
-    const like = Number(data.like || stats.digg_count || 0);
-    const comment = Number(stats.comment_count || 0);
-    const collect = Number(stats.collect_count || 0);
-    const share = Number(stats.share_count || 0);
-    const play = Number(stats.play_count || 0);
+    const like = Number(data.like ?? stats.digg_count ?? 0);
+    const comment = Number(stats.comment_count ?? 0);
+    const collect = Number(stats.collect_count ?? 0);
+    const share = Number(stats.share_count ?? 0);
+    const play = Number(stats.play_count ?? 0);
     let duration = 0;
     if (data.duration) {
-        duration = typeof data.duration === 'string' ? parseInt(data.duration) : data.duration;
+        duration = typeof data.duration === 'string' ? parseInt(data.duration, 10) : data.duration;
         if (duration > 1000000)
             duration = Math.floor(duration / 1000);
     }
@@ -237,7 +321,7 @@ function parseApiResponse(raw, maxDescLen) {
     }
     let publishTime = 0;
     if (data.time) {
-        publishTime = typeof data.time === 'number' ? data.time : parseInt(data.time);
+        publishTime = typeof data.time === 'number' ? data.time : parseInt(data.time, 10);
         if (publishTime < 1000000000000)
             publishTime *= 1000;
     }
@@ -277,7 +361,7 @@ function generateFormattedText(p, format) {
             for (const match of varMatches) {
                 const varName = match.replace(/\$\{|\}/g, '');
                 const val = vars[varName];
-                if (val !== undefined && val !== '') {
+                if (val && val !== '0') {
                     allEmpty = false;
                     break;
                 }
@@ -304,6 +388,8 @@ function buildForwardNode(session, content, botName) {
         messageContent = [koishi_1.h.text(String(content))];
     return (0, koishi_1.h)('node', { user: { nickname: botName.substring(0, 15), user_id: session.selfId } }, messageContent);
 }
+const urlCache = new Map();
+const CACHE_TTL = 10 * 60 * 1000;
 function apply(ctx, config) {
     debugEnabled = config.debug || false;
     debugLog('INFO', '插件初始化开始');
@@ -323,7 +409,14 @@ function apply(ctx, config) {
         }
     });
     async function fetchApi(url) {
+        const cacheKey = url;
+        const cached = urlCache.get(cacheKey);
+        if (cached && cached.expire > Date.now()) {
+            debugLog('DEBUG', `使用缓存: ${url}`);
+            return cached.data;
+        }
         debugLog('INFO', `调用API解析: ${url}`);
+        let lastError = null;
         for (let i = 0; i <= config.retryTimes; i++) {
             try {
                 const res = await http.get('https://api.bugpk.com/api/short_videos', {
@@ -332,17 +425,21 @@ function apply(ctx, config) {
                 });
                 debugLog('DEBUG', `API响应: ${JSON.stringify(res.data)}`);
                 if (res.data && (res.data.code === 200 || res.data.code === 0)) {
-                    return parseApiResponse(res.data, config.maxDescLength);
+                    const parsed = parseApiResponse(res.data, config.maxDescLength);
+                    urlCache.set(cacheKey, { data: parsed, expire: Date.now() + CACHE_TTL });
+                    return parsed;
                 }
                 throw new Error(res.data?.msg || '解析失败');
             }
             catch (error) {
-                debugLog('ERROR', `第${i + 1}次请求失败: ${getErrorMessage(error)}`);
-                if (i < config.retryTimes)
-                    await delay(config.retryInterval * (i + 1));
+                lastError = error instanceof Error ? error : new Error(String(error));
+                debugLog('ERROR', `第${i + 1}次请求失败: ${lastError.message}`);
+                if (i < config.retryTimes) {
+                    await delay(config.retryInterval);
+                }
             }
         }
-        throw new Error('API请求全部失败');
+        throw lastError || new Error('API请求全部失败');
     }
     async function parseUrl(url) {
         const realUrl = await resolveShortUrl(url);
@@ -350,13 +447,14 @@ function apply(ctx, config) {
         if (!platform) {
             return { success: false, msg: texts.unsupportedPlatformText };
         }
-        for (const candidate of [url, realUrl]) {
+        const candidates = [realUrl, url];
+        for (const candidate of [...new Set(candidates)]) {
             try {
                 const info = await fetchApi(candidate);
                 return { success: true, data: info };
             }
             catch (error) {
-                debugLog('ERROR', `候选链接解析失败: ${candidate}`);
+                debugLog('ERROR', `候选链接解析失败: ${candidate}`, getErrorMessage(error));
             }
         }
         return { success: false, msg: '解析失败' };
@@ -368,27 +466,29 @@ function apply(ctx, config) {
         const text = generateFormattedText(result.data, config.unifiedMessageFormat);
         return { success: true, data: { text, parsed: result.data } };
     }
-    /**
-     * 发送消息（支持超时与重试），重试次数与间隔与API重试配置绑定
-     */
     async function sendWithTimeout(session, content, customRetries) {
         const maxRetries = customRetries ?? config.retryTimes ?? 3;
         const retryDelay = config.retryInterval || 1000;
+        let timeoutId = null;
         for (let attempt = 0; attempt <= maxRetries; attempt++) {
             try {
-                if (config.videoSendTimeout <= 0) {
-                    // 无超时限制，直接发送
-                    return await session.send(content);
+                let sendPromise = session.send(content);
+                if (config.videoSendTimeout > 0) {
+                    const timeoutPromise = new Promise((_, reject) => {
+                        timeoutId = setTimeout(() => reject(new Error('发送超时')), config.videoSendTimeout);
+                    });
+                    const result = await Promise.race([sendPromise, timeoutPromise]);
+                    if (timeoutId)
+                        clearTimeout(timeoutId);
+                    return result;
                 }
                 else {
-                    // 设置超时竞争
-                    return await Promise.race([
-                        session.send(content),
-                        new Promise((_, reject) => setTimeout(() => reject(new Error('发送超时')), config.videoSendTimeout))
-                    ]);
+                    return await sendPromise;
                 }
             }
             catch (err) {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
                 const errMsg = getErrorMessage(err);
                 debugLog('ERROR', `第${attempt + 1}次发送失败: ${errMsg}`);
                 if (attempt < maxRetries) {
@@ -396,7 +496,6 @@ function apply(ctx, config) {
                     await delay(retryDelay);
                 }
                 else {
-                    // 最后一次失败，根据配置决定是否抛出
                     if (!config.ignoreSendError)
                         throw err;
                     return null;
@@ -406,18 +505,28 @@ function apply(ctx, config) {
         return null;
     }
     async function flush(session, urls) {
+        const uniqueUrls = [...new Set(urls)];
         const items = [];
         const errors = [];
-        for (const url of urls) {
-            const res = await processSingleUrl(url);
-            if (res.success) {
-                items.push(res.data);
-            }
-            else {
-                const item = texts.parseErrorItemFormat
-                    .replace(/\$\{url\}/g, url.length > 50 ? url.slice(0, 50) + '...' : url)
-                    .replace(/\$\{msg\}/g, res.msg);
-                errors.push(item);
+        const concurrency = 3;
+        const chunks = [];
+        for (let i = 0; i < uniqueUrls.length; i += concurrency) {
+            chunks.push(uniqueUrls.slice(i, i + concurrency));
+        }
+        for (const chunk of chunks) {
+            const results = await Promise.all(chunk.map(url => processSingleUrl(url)));
+            for (let idx = 0; idx < results.length; idx++) {
+                const res = results[idx];
+                if (res.success) {
+                    items.push(res.data);
+                }
+                else {
+                    const url = chunk[idx];
+                    const item = texts.parseErrorItemFormat
+                        .replace(/\$\{url\}/g, url.length > 50 ? url.slice(0, 50) + '...' : url)
+                        .replace(/\$\{msg\}/g, res.msg);
+                    errors.push(item);
+                }
             }
         }
         if (errors.length) {
@@ -440,7 +549,7 @@ function apply(ctx, config) {
                     await delay(300);
                 }
             }
-            if (p.cover && p.type !== 'live_photo') {
+            if (p.cover && p.type !== 'live_photo' && !(p.type === 'live' && (p.live_photo?.length || p.images?.length))) {
                 if (enableForward)
                     forwardMessages.push(buildForwardNode(session, koishi_1.h.image(p.cover), botName));
                 else {
@@ -448,7 +557,7 @@ function apply(ctx, config) {
                     await delay(300);
                 }
             }
-            if (p.video && config.showVideoFile && (p.type === 'video' || p.type === 'live')) {
+            if (p.video && config.showVideoFile && (p.type === 'video' || (p.type === 'live' && !p.live_photo?.length && !p.images?.length))) {
                 const videoMsg = koishi_1.h.video(p.video);
                 if (enableForward) {
                     forwardMessages.push(buildForwardNode(session, videoMsg, botName));
@@ -458,44 +567,35 @@ function apply(ctx, config) {
                     await delay(500);
                 }
             }
-            if (p.type === 'image' || p.type === 'live_photo') {
-                const imageUrls = p.images?.length ? p.images : [];
+            if (p.type === 'image' || p.type === 'live_photo' || (p.type === 'live' && (p.live_photo?.length || p.images?.length))) {
+                const imageUrls = p.images?.length ? p.images : (p.live_photo?.map(lp => lp.image) ?? []);
                 if (enableForward) {
-                    for (const url of imageUrls) {
-                        forwardMessages.push(buildForwardNode(session, koishi_1.h.image(url), botName));
+                    for (const imgUrl of imageUrls) {
+                        forwardMessages.push(buildForwardNode(session, koishi_1.h.image(imgUrl), botName));
                     }
                 }
                 else {
-                    for (const url of imageUrls) {
-                        await sendWithTimeout(session, koishi_1.h.image(url)).catch(() => { });
+                    for (const imgUrl of imageUrls) {
+                        await sendWithTimeout(session, koishi_1.h.image(imgUrl)).catch(() => { });
                         await delay(200);
                     }
                 }
             }
         }
         if (enableForward && forwardMessages.length) {
-            // 合并转发发送时也使用重试机制，失败后降级逐条发送
             const forwardMsg = (0, koishi_1.h)('message', { forward: true }, forwardMessages.slice(0, 100));
-            try {
-                await sendWithTimeout(session, forwardMsg, config.retryTimes); // 使用相同的重试次数
-            }
-            catch {
+            await sendWithTimeout(session, forwardMsg, config.retryTimes).catch(() => {
                 debugLog('ERROR', '合并转发发送最终失败，降级为逐条发送');
                 for (const node of forwardMessages) {
-                    try {
-                        await sendWithTimeout(session, node.data.content);
-                        await delay(300);
-                    }
-                    catch { }
+                    sendWithTimeout(session, node.data.content).catch(() => { });
                 }
-            }
+            });
         }
     }
     ctx.on('message', async (session) => {
         if (!config.enable)
             return;
-        const content = session.content?.trim() || '';
-        const urls = extractUrl(content);
+        const urls = extractAllUrlsFromMessage(session);
         if (!urls.length)
             return;
         if (config.showWaitingTip) {
@@ -514,5 +614,12 @@ function apply(ctx, config) {
         }
         await flush(session, us);
     });
+    setInterval(() => {
+        const now = Date.now();
+        for (const [key, { expire }] of urlCache.entries()) {
+            if (expire <= now)
+                urlCache.delete(key);
+        }
+    }, 60000);
     debugLog('INFO', '插件初始化完成');
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-video-parser-all",
-  "description": "Koishi 全平台视频解析插件，支持抖音/快手/B站/微博/小红书/剪映/YouTube/TikTok等20+平台",
-  "version": "0.9.5",
+  "description": "Koishi 全平台视频解析插件，支持抖音/快手/B站/微博/小红书/剪映/YouTube/TikTok等20+平台，新增XML卡片链接提取",
+  "version": "0.9.7",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -57,7 +57,8 @@
     "typescript": "^5.3.3"
   },
   "dependencies": {
-    "axios": "^1.6.8",
+    "axios": "^1.16.1",
+    "fast-xml-parser": "^4.5.6",
     "stream": "^0.0.3"
   },
   "peerDependencies": {
@@ -75,4 +76,4 @@
   "engines": {
     "node": ">=16.0.0"
   }
-}
+}

package/readme.md

@@ -3,24 +3,26 @@
 ## 项目介绍 (Project Introduction)
 
 ### 中文
-这是一个为 Koishi 机器人框架开发的**全平台视频/图集解析插件**，使用统一API接口，支持自动识别并解析抖音、快手、B站、小红书、微博、YouTube、TikTok、剪映、AcFun、知乎、虎牙等20+主流平台的短视频/图集链接。核心特性：
+这是一个为 Koishi 机器人框架开发的**全平台视频/图集解析插件**，使用统一API接口，支持自动识别并解析抖音、快手、B站、小红书、微博、YouTube、TikTok、剪映、AcFun、知乎、虎牙等20+主流平台的短视频/图集/实况链接。核心特性：
 - 🌐 统一API解析，覆盖20+热门平台，无需繁琐配置
-- 🤖 自动识别链接来源，即丢即用
+- 🤖 自动识别链接来源，即丢即用，并支持解析 XML 卡片消息中的链接（如 QQ/OneBot 平台的分享卡片）
 - 🎨 完全自定义的解析结果格式，支持多项变量替换，变量无值自动隐藏行
 - 🐛 内置Debug调试模式，可详细记录所有操作与API交互日志
 - 📤 支持OneBot平台消息合并转发，优化多图文展示体验
 - 💬 所有提示文案均可自定义，适配多语言场景
 - 🔁 消息发送支持自动重试，与API重试配置联动，增强稳定性
+- 🚀 内置内存缓存，避免短时间内重复解析同一链接；并发控制，防止资源耗尽
 
 ### English
-This is a **multi-platform video/image parsing plugin** developed for the Koishi bot framework, using a unified API interface to automatically recognize and parse short video/image links from 20+ mainstream platforms such as Douyin, Kuaishou, Bilibili, Xiaohongshu, Weibo, YouTube, TikTok, Jianying, AcFun, Zhihu, Huya and more. Core features:
+This is a **multi-platform video/image parsing plugin** developed for the Koishi bot framework, using a unified API interface to automatically recognize and parse short video/image/live photo links from 20+ mainstream platforms such as Douyin, Kuaishou, Bilibili, Xiaohongshu, Weibo, YouTube, TikTok, Jianying, AcFun, Zhihu, Huya and more. Core features:
 - 🌐 Unified API parsing, covering 20+ popular platforms without complex configuration
-- 🤖 Auto-detection of link sources, just drop & go
+- 🤖 Auto-detection of link sources, drop & go, and support for extracting links from XML card messages (e.g., share cards on QQ/OneBot)
 - 🎨 Fully customizable parsing result format with variable substitutions, empty variables hide the line automatically
 - 🐛 Built-in Debug mode, recording detailed operations and API interaction logs
 - 📤 Support OneBot message forwarding for better image/video display
 - 💬 All prompt texts are customizable for multilingual scenarios
 - 🔁 Message sending supports automatic retries, linked with API retry configuration for improved stability
+- 🚀 Built-in memory cache to avoid repeated parsing of the same URL; concurrency control to prevent resource exhaustion
 
 ## 项目仓库 (Repository)
 - GitHub: `https://github.com/Minecraft-1314/koishi-plugin-video-parser-all`
@@ -45,7 +47,7 @@ This is a **multi-platform video/image parsing plugin** developed for the Koishi
 ### 统一消息格式
 | 配置项 | 类型 | 默认值 | 说明 |
 |--------|------|--------|------|
-| `unifiedMessageFormat` | string | `标题：${标题}\n作者：${作者}\n简介：${简介}\n点赞：${点赞数}\n收藏：${收藏数}\n转发：${转发数}\n播放：${播放数}\n评论：${评论数}` | 自定义解析结果的输出格式，支持变量替换。某行所有变量为空时自动隐藏该行 |
+| `unifiedMessageFormat` | string | `标题：${标题}\n作者：${作者}\n简介：${简介}\n点赞：${点赞数}\n收藏：${收藏数}\n转发：${转发数}\n播放：${播放数}\n评论：${评论数}\n图片数量：${图片数量}` | 自定义解析结果的输出格式，支持变量替换。某行所有变量为空（或为"0"）时自动隐藏该行 |
 
 ### 内容显示设置
 | 配置项 | 类型 | 默认值 | 说明 |
@@ -83,7 +85,7 @@ This is a **multi-platform video/image parsing plugin** developed for the Koishi
 | `parseErrorItemFormat` | string | 【${url}】: ${msg} | 每条解析失败的展示格式，可用 ${url}（链接）和 ${msg}（错误信息） |
 
 ## 支持的变量 (Supported Variables)
-在 `unifiedMessageFormat` 中可使用以下变量进行自定义格式化，某行所有变量均为空时该行不显示：
+在 `unifiedMessageFormat` 中可使用以下变量进行自定义格式化，某行所有变量均为空（或为"0"）时该行不显示：
 
 | 变量名 | 说明 | 适用平台 |
 |--------|------|----------|
@@ -97,11 +99,11 @@ This is a **multi-platform video/image parsing plugin** developed for the Koishi
 | `${播放数}` | 播放量 | 部分平台 |
 | `${评论数}` | 评论数量 | 所有平台 |
 | `${发布时间}` | 发布时间（格式化） | 所有平台 |
-| `${图片数量}` | 图集图片数量（live_photo 或 images 的数量） | 图集 |
+| `${图片数量}` | 图集/实况图片数量 | 图集/实况 |
 | `${作者ID}` | 作者唯一标识ID | 部分平台 |
 | `${封面}` | 封面图片地址 | 所有平台 |
 
-> 注：部分变量可能因平台API返回数据不同而显示为空，空值行会自动隐藏。
+> 注：部分变量可能因平台API返回数据不同而显示为空，某行所有变量为空（或为"0"）时该行会自动隐藏。
 
 ## 支持的平台 (Supported Platforms)
 | 平台名称 | 关键词识别 | 解析能力 |