npm - koishi-plugin-video-parser-all - Versions diffs - 0.6.9 → 0.7.0 - Mend

koishi-plugin-video-parser-all 0.6.9 → 0.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/lib/index.d.ts CHANGED Viewed

@@ -61,27 +61,4 @@ export declare const Config: Schema<{
 } & {
     autoClearCacheInterval: number;
 }>;
-export declare enum ErrorCode {
-    SUCCESS = 0,
-    UNKNOWN_ERROR = 1000,
-    UNSUPPORTED_PLATFORM = 1001,
-    PLATFORM_API_NOT_CONFIGURED = 1002,
-    REQUEST_TIMEOUT = 1003,
-    NETWORK_ERROR = 1004,
-    DUPLICATE_PARSE = 1005,
-    INVALID_URL = 1006,
-    API_RETURN_ERROR = 2000,
-    API_DATA_PARSE_FAILED = 2001,
-    API_EMPTY_RESPONSE = 2002,
-    API_INVALID_RESPONSE = 2003,
-    VIDEO_DOWNLOAD_FAILED = 3000,
-    VIDEO_SIZE_EXCEEDED = 3001,
-    UNSUPPORTED_CONTENT_TYPE = 3002,
-    NO_VIDEO_FOUND = 3003,
-    NO_IMAGE_FOUND = 3004,
-    MESSAGE_SEND_FAILED = 4000,
-    MESSAGE_SEND_TIMEOUT = 4001,
-    FORWARD_MESSAGE_FAILED = 4002
-}
-export declare const ErrorMessageMap: Record<ErrorCode, string>;
 export declare function apply(ctx: Context, config: any): void;

package/lib/index.js CHANGED Viewed

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorMessageMap = exports.ErrorCode = exports.Config = exports.name = void 0;
+exports.Config = exports.name = void 0;
 exports.apply = apply;
 const koishi_1 = require("koishi");
 const axios_1 = __importDefault(require("axios"));
@@ -15,12 +15,12 @@ const worker_threads_1 = require("worker_threads");
 exports.name = 'video-parser-all';
 exports.Config = koishi_1.Schema.intersect([
     koishi_1.Schema.object({
-        enable: koishi_1.Schema.boolean().default(true),
-        botName: koishi_1.Schema.string().default('视频解析机器人'),
-        showWaitingTip: koishi_1.Schema.boolean().default(true),
-        waitingTipText: koishi_1.Schema.string().default('正在解析视频，请稍候...'),
-        sameLinkInterval: koishi_1.Schema.number().min(0).default(180),
-    }),
+        enable: koishi_1.Schema.boolean().default(true).description('是否启用视频解析插件'),
+        botName: koishi_1.Schema.string().default('视频解析机器人').description('机器人显示名称'),
+        showWaitingTip: koishi_1.Schema.boolean().default(true).description('解析时显示等待提示'),
+        waitingTipText: koishi_1.Schema.string().default('正在解析视频，请稍候...').description('等待提示文本内容'),
+        sameLinkInterval: koishi_1.Schema.number().min(0).default(180).description('相同链接重复解析间隔（秒）'),
+    }).description('基础设置'),
     koishi_1.Schema.object({
         unifiedMessageFormat: koishi_1.Schema.string().role('textarea').default(`标题：${'${标题}'}
 作者：${'${作者}'}
@@ -42,83 +42,38 @@ IP属地：${'${IP属地}'}
 直播间ID：${'${直播间ID}'}
 直播间状态：${'${直播间状态}'}
 图片数量：${'${图片数量}'}
-作者ID：${'${作者ID}'}`),
-    }),
+作者ID：${'${作者ID}'}`).description('统一消息格式'),
+    }).description('统一消息格式'),
     koishi_1.Schema.object({
-        showImageText: koishi_1.Schema.boolean().default(true),
-        showVideoFile: koishi_1.Schema.boolean().default(true),
-    }),
+        showImageText: koishi_1.Schema.boolean().default(true).description('显示图文内容'),
+        showVideoFile: koishi_1.Schema.boolean().default(true).description('发送视频文件（关闭则只发链接）'),
+    }).description('内容显示设置'),
     koishi_1.Schema.object({
-        maxDescLength: koishi_1.Schema.number().default(200),
-    }),
+        maxDescLength: koishi_1.Schema.number().default(200).description('简介内容最大长度（字符）'),
+    }).description('内容长度限制'),
     koishi_1.Schema.object({
-        timeout: koishi_1.Schema.number().min(0).default(180000),
-        videoSendTimeout: koishi_1.Schema.number().min(0).default(0),
-        userAgent: koishi_1.Schema.string().default('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36'),
-    }),
+        timeout: koishi_1.Schema.number().min(0).default(180000).description('API请求超时时间（毫秒）'),
+        videoSendTimeout: koishi_1.Schema.number().min(0).default(0).description('视频发送超时时间（毫秒，0为不限制）'),
+        userAgent: koishi_1.Schema.string().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('请求UA标识'),
+    }).description('网络与API设置'),
     koishi_1.Schema.object({
-        ignoreSendError: koishi_1.Schema.boolean().default(true),
-        retryTimes: koishi_1.Schema.number().min(0).default(3),
-        retryInterval: koishi_1.Schema.number().min(0).default(1000),
-    }),
+        ignoreSendError: koishi_1.Schema.boolean().default(true).description('忽略发送失败错误'),
+        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({
-        enableForward: koishi_1.Schema.boolean().default(false),
-        downloadVideoBeforeSend: koishi_1.Schema.boolean().default(false),
-        maxVideoSize: koishi_1.Schema.number().min(0).default(0),
-        downloadThreads: koishi_1.Schema.number().min(0).max(10).default(0),
-    }),
+        enableForward: koishi_1.Schema.boolean().default(false).description('启用合并转发（仅OneBot平台）'),
+        downloadVideoBeforeSend: koishi_1.Schema.boolean().default(false).description('发送前先下载视频'),
+        maxVideoSize: koishi_1.Schema.number().min(0).default(0).description('最大视频大小限制（MB，0为不限制）'),
+        downloadThreads: koishi_1.Schema.number().min(0).max(10).default(0).description('多线程下载线程数（0为不使用多线程）'),
+    }).description('发送方式设置'),
     koishi_1.Schema.object({
-        messageBufferDelay: koishi_1.Schema.number().min(0).default(0),
-    }),
+        messageBufferDelay: koishi_1.Schema.number().min(0).default(0).description('消息缓冲延迟（毫秒）'),
+    }).description('消息处理设置'),
     koishi_1.Schema.object({
-        autoClearCacheInterval: koishi_1.Schema.number().min(0).default(0),
-    }),
+        autoClearCacheInterval: koishi_1.Schema.number().min(0).default(0).description('自动清理缓存间隔（分钟，0为关闭）'),
+    }).description('缓存清理设置'),
 ]);
-var ErrorCode;
-(function (ErrorCode) {
-    ErrorCode[ErrorCode["SUCCESS"] = 0] = "SUCCESS";
-    ErrorCode[ErrorCode["UNKNOWN_ERROR"] = 1000] = "UNKNOWN_ERROR";
-    ErrorCode[ErrorCode["UNSUPPORTED_PLATFORM"] = 1001] = "UNSUPPORTED_PLATFORM";
-    ErrorCode[ErrorCode["PLATFORM_API_NOT_CONFIGURED"] = 1002] = "PLATFORM_API_NOT_CONFIGURED";
-    ErrorCode[ErrorCode["REQUEST_TIMEOUT"] = 1003] = "REQUEST_TIMEOUT";
-    ErrorCode[ErrorCode["NETWORK_ERROR"] = 1004] = "NETWORK_ERROR";
-    ErrorCode[ErrorCode["DUPLICATE_PARSE"] = 1005] = "DUPLICATE_PARSE";
-    ErrorCode[ErrorCode["INVALID_URL"] = 1006] = "INVALID_URL";
-    ErrorCode[ErrorCode["API_RETURN_ERROR"] = 2000] = "API_RETURN_ERROR";
-    ErrorCode[ErrorCode["API_DATA_PARSE_FAILED"] = 2001] = "API_DATA_PARSE_FAILED";
-    ErrorCode[ErrorCode["API_EMPTY_RESPONSE"] = 2002] = "API_EMPTY_RESPONSE";
-    ErrorCode[ErrorCode["API_INVALID_RESPONSE"] = 2003] = "API_INVALID_RESPONSE";
-    ErrorCode[ErrorCode["VIDEO_DOWNLOAD_FAILED"] = 3000] = "VIDEO_DOWNLOAD_FAILED";
-    ErrorCode[ErrorCode["VIDEO_SIZE_EXCEEDED"] = 3001] = "VIDEO_SIZE_EXCEEDED";
-    ErrorCode[ErrorCode["UNSUPPORTED_CONTENT_TYPE"] = 3002] = "UNSUPPORTED_CONTENT_TYPE";
-    ErrorCode[ErrorCode["NO_VIDEO_FOUND"] = 3003] = "NO_VIDEO_FOUND";
-    ErrorCode[ErrorCode["NO_IMAGE_FOUND"] = 3004] = "NO_IMAGE_FOUND";
-    ErrorCode[ErrorCode["MESSAGE_SEND_FAILED"] = 4000] = "MESSAGE_SEND_FAILED";
-    ErrorCode[ErrorCode["MESSAGE_SEND_TIMEOUT"] = 4001] = "MESSAGE_SEND_TIMEOUT";
-    ErrorCode[ErrorCode["FORWARD_MESSAGE_FAILED"] = 4002] = "FORWARD_MESSAGE_FAILED";
-})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));
-exports.ErrorMessageMap = {
-    [ErrorCode.SUCCESS]: '操作成功',
-    [ErrorCode.UNKNOWN_ERROR]: '未知错误',
-    [ErrorCode.UNSUPPORTED_PLATFORM]: '不支持该平台链接',
-    [ErrorCode.PLATFORM_API_NOT_CONFIGURED]: '该平台暂未配置解析接口',
-    [ErrorCode.REQUEST_TIMEOUT]: '请求超时',
-    [ErrorCode.NETWORK_ERROR]: '网络请求失败',
-    [ErrorCode.DUPLICATE_PARSE]: '请勿重复解析',
-    [ErrorCode.INVALID_URL]: '无效的链接格式',
-    [ErrorCode.API_RETURN_ERROR]: 'API返回错误',
-    [ErrorCode.API_DATA_PARSE_FAILED]: '数据解析异常',
-    [ErrorCode.API_EMPTY_RESPONSE]: 'API返回空数据',
-    [ErrorCode.API_INVALID_RESPONSE]: 'API返回无效格式',
-    [ErrorCode.VIDEO_DOWNLOAD_FAILED]: '视频下载失败',
-    [ErrorCode.VIDEO_SIZE_EXCEEDED]: '视频大小超过限制',
-    [ErrorCode.UNSUPPORTED_CONTENT_TYPE]: '不支持的内容类型',
-    [ErrorCode.NO_VIDEO_FOUND]: '未找到视频内容',
-    [ErrorCode.NO_IMAGE_FOUND]: '未找到图片内容',
-    [ErrorCode.MESSAGE_SEND_FAILED]: '消息发送失败',
-    [ErrorCode.MESSAGE_SEND_TIMEOUT]: '消息发送超时',
-    [ErrorCode.FORWARD_MESSAGE_FAILED]: '合并转发失败',
-};
 const processed = new Map();
 const linkBuffer = new Map();
 const logger = new koishi_1.Logger(exports.name);
@@ -167,10 +122,6 @@ const VARIABLE_MAPPING = {
     '图片数量': ['count', 'data.count', 'item.count', 'images.length', 'data.images.length', 'data.item.count'],
     '作者ID': ['userId', 'userID', 'author_id', 'data.userId', 'item.userID', 'author.mid', 'user.mid', 'data.item.userID', 'data.author_id', 'data.user.mid', 'author.id', 'uid', 'short_id', 'data.author.id']
 };
-function getErrorInfo(code, detail) {
-    const baseMsg = exports.ErrorMessageMap[code] || exports.ErrorMessageMap[ErrorCode.UNKNOWN_ERROR];
-    return detail ? `[错误码: ${code}] ${baseMsg}：${detail}` : `[错误码: ${code}] ${baseMsg}`;
-}
 function getErrorMessage(error) {
     if (error instanceof Error)
         return error.message;
@@ -199,7 +150,7 @@ async function downloadVideoThread(workerData) {
         worker.on('error', reject);
         worker.on('exit', (code) => {
             if (code !== 0)
-                reject(new Error(`Worker stopped with exit code ${code}`));
+                reject(new Error(`下载线程异常退出，代码：${code}`));
         });
     });
 }
@@ -235,11 +186,11 @@ async function downloadVideo(url, filename, userAgent, maxSize, threads) {
     const filePath = path_1.default.join(dir, `${filename}.mp4`);
     try {
         if (url.endsWith('.m4a') || url.endsWith('.mp3')) {
-            return { filePath: '', code: ErrorCode.UNSUPPORTED_CONTENT_TYPE };
+            return { filePath: '', success: false };
         }
         const fileSize = await getFileSize(url, userAgent);
         if (maxSize > 0 && fileSize > maxSize) {
-            return { filePath: '', code: ErrorCode.VIDEO_SIZE_EXCEEDED };
+            return { filePath: '', success: false };
         }
         if (threads <= 0 || fileSize === 0) {
             const response = await (0, axios_1.default)({
@@ -253,7 +204,7 @@ async function downloadVideo(url, filename, userAgent, maxSize, threads) {
             });
             const writeStream = fs_1.default.createWriteStream(filePath);
             await (0, promises_1.pipeline)(response.data, writeStream);
-            return { filePath, code: ErrorCode.SUCCESS };
+            return { filePath, success: true };
         }
         const totalSize = fileSize * 1024 * 1024;
         const chunkSize = Math.ceil(totalSize / threads);
@@ -279,7 +230,7 @@ async function downloadVideo(url, filename, userAgent, maxSize, threads) {
             fs_1.default.unlinkSync(result.filePath);
         }
         writeStream.end();
-        return { filePath, code: ErrorCode.SUCCESS };
+        return { filePath, success: true };
     }
     catch (error) {
         if (fs_1.default.existsSync(filePath)) {
@@ -292,7 +243,8 @@ async function downloadVideo(url, filename, userAgent, maxSize, threads) {
             }
             catch (e) { }
         });
-        return { filePath: '', code: ErrorCode.VIDEO_DOWNLOAD_FAILED };
+        logger.error(`视频下载失败: ${getErrorMessage(error)}`);
+        return { filePath: '', success: false };
     }
 }
 function extractUrl(content) {
@@ -463,6 +415,7 @@ function parseData(rawResponse, maxDescLength) {
     const root = rawResponse || {};
     const data = root.data || root.result || root || {};
     const stat = {};
+    let totalImageCount = 0;
     Object.entries(VARIABLE_MAPPING).forEach(([varName, keys]) => {
         let value = findValueInObject(data, keys) || findValueInObject(root, keys);
         if (varName === '图片数量' && value === undefined) {
@@ -478,12 +431,13 @@ function parseData(rawResponse, maxDescLength) {
                     break;
                 }
             }
+            totalImageCount = imgCount;
             const cover = data.cover || data.video?.fm || data.imgurl || data.pic || data.thumbnail || data.cover_url ||
                 data.item?.cover || root.cover || data.live?.cover || data.live?.keyframe || '';
             if (cover && imgCount > 0) {
                 imgCount = imgSources.find(source => Array.isArray(source))?.filter(i => i && typeof i === 'string' && i !== cover).length || 0;
             }
-            value = imgCount;
+            value = totalImageCount;
         }
         if (value !== undefined && value !== null && value !== '' && value !== 0) {
             stat[varName] = value;
@@ -590,6 +544,7 @@ function parseData(rawResponse, maxDescLength) {
         duration,
         durationFormatted,
         stat,
+        totalImageCount,
         live_photo,
         h_w,
         jx: data.jx || null,
@@ -717,82 +672,67 @@ function apply(ctx, config) {
         realUrl = cleanUrl(realUrl);
         const platform = getPlatformType(realUrl);
         if (!platform) {
-            const code = ErrorCode.UNSUPPORTED_PLATFORM;
-            const msg = getErrorInfo(code, url);
-            logger.error(`[${code}] ${exports.ErrorMessageMap[code]}: ${url}`);
-            return { data: null, code, msg };
+            logger.error(`不支持的平台链接: ${url}`);
+            return { data: null, success: false, msg: '不支持该平台链接' };
         }
         const apiUrl = API_CONFIG[platform];
         if (!apiUrl) {
-            const code = ErrorCode.PLATFORM_API_NOT_CONFIGURED;
-            const msg = getErrorInfo(code, platform);
-            logger.error(`[${code}] ${exports.ErrorMessageMap[code]}: ${platform}`);
-            return { data: null, code, msg };
+            logger.error(`该平台暂未配置解析接口: ${platform}`);
+            return { data: null, success: false, msg: '该平台暂未配置解析接口' };
         }
         try {
             const resData = await parseWithRetry(realUrl, platform, config.retryTimes);
             if (!resData || Object.keys(resData).length === 0) {
-                const code = ErrorCode.API_EMPTY_RESPONSE;
-                const msg = getErrorInfo(code, 'API返回空数据');
-                logger.error(`[${code}] ${url}`);
-                return { data: null, code, msg };
+                logger.error(`API返回空数据: ${url}`);
+                return { data: null, success: false, msg: '解析失败，API返回空数据' };
             }
             const isSuccess = resData.code === 0 || resData.code === 200 || resData.code === 1 ||
                 (resData.msg && (resData.msg.includes('解析成功') || resData.msg.includes('success') || resData.msg.includes('请求成功') || resData.msg === 'video' || resData.msg === 'cv' || resData.msg === 'live')) ||
                 !!resData.data || !!resData.result || !!resData.video || !!resData.images || !!resData.imgurl;
             if (!isSuccess) {
                 const apiErrorMsg = resData.msg || resData.error || '解析失败';
-                const code = ErrorCode.API_RETURN_ERROR;
-                const msg = getErrorInfo(code, apiErrorMsg);
-                logger.error(`[${code}] API返回错误: ${url}, 错误: ${apiErrorMsg}`);
-                return { data: null, code, msg };
+                logger.error(`API返回错误: ${url} - ${apiErrorMsg}`);
+                return { data: null, success: false, msg: `解析失败: ${apiErrorMsg}` };
             }
             try {
                 const parseResult = parseData(resData, config.maxDescLength);
-                logger.info(`[${ErrorCode.SUCCESS}] 解析成功: ${url}`);
+                logger.info(`解析成功: ${url}`);
                 return {
                     data: parseResult,
-                    code: ErrorCode.SUCCESS,
-                    msg: getErrorInfo(ErrorCode.SUCCESS)
+                    success: true,
+                    msg: '解析成功'
                 };
             }
             catch (parseError) {
                 const errorMsg = getErrorMessage(parseError);
-                const code = ErrorCode.API_DATA_PARSE_FAILED;
-                const msg = getErrorInfo(code, errorMsg);
-                logger.error(`[${code}] 解析数据失败: ${url}, 错误: ${errorMsg}`);
-                return { data: null, code, msg };
+                logger.error(`解析数据失败: ${url} - ${errorMsg}`);
+                return { data: null, success: false, msg: `解析数据失败: ${errorMsg}` };
             }
         }
         catch (error) {
             const errorMsg = getErrorMessage(error);
-            let code = ErrorCode.UNKNOWN_ERROR;
+            let msg = '未知错误';
             if (errorMsg.includes('timeout')) {
-                code = ErrorCode.REQUEST_TIMEOUT;
+                msg = '请求超时';
             }
             else if (errorMsg.includes('Network') || errorMsg.includes('network') || errorMsg.includes('404') || errorMsg.includes('500')) {
-                code = ErrorCode.NETWORK_ERROR;
+                msg = '网络请求失败';
             }
-            else {
-                code = ErrorCode.NETWORK_ERROR;
-            }
-            const msg = getErrorInfo(code, errorMsg);
-            logger.error(`[${code}] 解析请求失败: ${url}, 错误: ${errorMsg}`);
-            return { data: null, code, msg };
+            logger.error(`解析请求失败: ${url} - ${errorMsg}`);
+            return { data: null, success: false, msg };
         }
     }
     async function processSingleUrl(session, url) {
         const hash = crypto_1.default.createHash('md5').update(url).digest('hex');
         const now = Date.now();
         if (processed.get(hash) && now - processed.get(hash) < config.sameLinkInterval * 1000) {
-            const code = ErrorCode.DUPLICATE_PARSE;
-            const msg = getErrorInfo(code);
-            return { data: null, code, msg };
+            logger.warn(`相同链接重复解析: ${url}`);
+            return { data: null, success: false, msg: '请勿重复解析相同链接' };
         }
         processed.set(hash, now);
         const result = await parse(url);
-        if (!result.data)
-            return { data: null, code: result.code, msg: result.msg };
+        if (!result.success)
+            return { data: null, success: false, msg: result.msg };
         const parseData = result.data;
         const text = generateFormattedText(parseData, config);
         return {
@@ -802,21 +742,22 @@ function apply(ctx, config) {
                 images: parseData.images,
                 video: parseData.video,
                 type: parseData.type,
+                totalImageCount: parseData.totalImageCount,
                 live_photo: parseData.live_photo,
                 h_w: parseData.h_w,
                 quality_urls: parseData.quality_urls,
                 default_quality: parseData.default_quality,
                 download_url: parseData.download_url
             },
-            code: ErrorCode.SUCCESS,
-            msg: getErrorInfo(ErrorCode.SUCCESS)
+            success: true,
+            msg: '处理成功'
         };
     }
     async function sendTimeout(session, content) {
         if (config.videoSendTimeout <= 0) {
             return session.send(content).catch((err) => {
                 const errorMsg = getErrorMessage(err);
-                logger.error(`[${ErrorCode.MESSAGE_SEND_FAILED}] 发送消息失败: ${errorMsg}`);
+                logger.error(`发送消息失败: ${errorMsg}`);
                 if (!config.ignoreSendError)
                     return null;
                 return null;
@@ -827,8 +768,7 @@ function apply(ctx, config) {
             new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), config.videoSendTimeout))
         ]).catch((err) => {
             const errorMsg = getErrorMessage(err);
-            const code = errorMsg.includes('timeout') ? ErrorCode.MESSAGE_SEND_TIMEOUT : ErrorCode.MESSAGE_SEND_FAILED;
-            logger.error(`[${code}] 发送消息失败: ${errorMsg}`);
+            logger.error(`发送消息超时: ${errorMsg}`);
             if (!config.ignoreSendError)
                 return null;
             return null;
@@ -846,7 +786,7 @@ function apply(ctx, config) {
         const errors = [];
         for (const url of urls) {
             const result = await processSingleUrl(session, url);
-            if (result.data) {
+            if (result.success) {
                 items.push(result.data);
             }
             else {
@@ -879,7 +819,7 @@ function apply(ctx, config) {
                             if (config.downloadVideoBeforeSend) {
                                 const filename = crypto_1.default.createHash('md5').update(item.video).digest('hex');
                                 const dl = await downloadVideo(item.video, filename, config.userAgent, config.maxVideoSize, config.downloadThreads);
-                                if (dl.code === ErrorCode.SUCCESS) {
+                                if (dl.success) {
                                     forwardMessages.push(buildForwardNode(session, koishi_1.h.file(dl.filePath), botName));
                                 }
                                 else {
@@ -895,7 +835,7 @@ function apply(ctx, config) {
                         }
                     }
                     if ((item.type === '图集' || item.type === 'image') && item.images?.length) {
-                        forwardMessages.push(buildForwardNode(session, `📸 图集内容（共${item.images.length}张）`, botName));
+                        forwardMessages.push(buildForwardNode(session, `📸 图集内容（共${item.totalImageCount}张）`, botName));
                         for (const img of item.images) {
                             forwardMessages.push(buildForwardNode(session, koishi_1.h.image(img), botName));
                         }
@@ -920,7 +860,7 @@ function apply(ctx, config) {
                         await delay(500);
                     }
                     if ((item.type === '图集' || item.type === 'image') && item.images?.length) {
-                        await sendTimeout(session, `📸 图集内容（共${item.images.length}张）`);
+                        await sendTimeout(session, `📸 图集内容（共${item.totalImageCount}张）`);
                         await delay(300);
                         for (const img of item.images) {
                             await sendTimeout(session, koishi_1.h.image(img));
@@ -929,7 +869,9 @@ function apply(ctx, config) {
                     }
                 }
             }
-            catch (e) { }
+            catch (e) {
+                logger.error(`处理消息发送失败: ${getErrorMessage(e)}`);
+            }
         }
         if (enableForward && forwardMessages.length) {
             try {
@@ -956,13 +898,15 @@ function apply(ctx, config) {
     });
     ctx.command('parse <url>', '手动解析视频').action(async ({ session }, url) => {
         const us = extractUrl(url);
-        if (!us.length)
-            return getErrorInfo(ErrorCode.INVALID_URL);
+        if (!us.length) {
+            await sendTimeout(session, '无效的视频链接');
+            return;
+        }
         await flush(session, us);
     });
-    ctx.command('clear-cache', '清空缓存').action(() => {
+    ctx.command('clear-cache', '清空缓存').action(async ({ session }) => {
         clearAllCache();
-        return '✅ 缓存已清空';
+        await sendTimeout(session, '✅ 缓存已清空');
     });
     setInterval(() => {
         const now = Date.now();
@@ -974,5 +918,5 @@ function apply(ctx, config) {
             logger.info('自动清理缓存完成');
         }, config.autoClearCacheInterval * 60 * 1000);
     }
-    logger.info('✅ 视频解析插件已启动');
+    logger.info('视频解析插件已启动');
 }

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-video-parser-all",
   "description": "Koishi 全平台视频解析插件，支持抖音/快手/B站/小红书/微博/今日头条/皮皮搞笑/皮皮虾/最右视频链接解析",
-  "version": "0.6.9",
+  "version": "0.7.0",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [

package/readme.md CHANGED Viewed

@@ -3,18 +3,18 @@
 ## 项目介绍 (Project Introduction)
 ### 中文
-这是一个为 Koishi 机器人框架开发的**视频解析插件**，支持自动识别并解析抖音、快手、B站、小红书、微博、今日头条、西瓜视频、皮皮搞笑、皮皮虾、最右等主流平台的短视频链接。核心特性：
-- 🚀 自动识别多平台视频，无需手动指定平台
-- 🎨 自定义解析结果格式、返回内容类型（封面/链接/视频）
+这是一个为 Koishi 机器人框架开发的**多平台视频/图集解析插件**，支持自动识别并解析抖音、快手、B站、小红书、微博、今日头条、皮皮搞笑、皮皮虾、最右等主流平台的短视频/图集链接。核心特性：
+- 🚀 自动识别多平台链接，无需手动指定平台
+- 🎨 自定义解析结果格式，支持丰富的变量替换
 - ⚡ 内置防重复解析、接口重试、自动缓存清理等实用功能
 - 📤 支持 OneBot 平台消息合并转发，优化展示体验
 ### English
-This is a **video parsing plugin** developed for the Koishi bot framework, supporting automatic recognition and parsing of short video links from mainstream platforms such as Douyin, Kuaishou, Bilibili, Xiaohongshu, Weibo, Toutiao, Pipi Funny, Pipi Shrimp, and Zuiyou. Core features:
-- 🚀 Automatically recognizes videos from multiple platforms, no need to manually specify the platform.
-- 🎨 Customize the parsing result format and return content type (cover/link/video)
-- ⚡ Built-in duplicate prevention, retry logic, auto cache cleanup
-- 📤 Support OneBot message forwarding for better display experience
+This is a **multi-platform video/image parsing plugin** developed for the Koishi bot framework, supporting automatic recognition and parsing of short video/image links from mainstream platforms such as Douyin, Kuaishou, Bilibili, Xiaohongshu, Weibo, Toutiao, Pipi Funny, Pipi Shrimp, and Zuiyou. Core features:
+- 🚀 Automatically recognizes multi-platform links without manual platform specification
+- 🎨 Customizable parsing result format with rich variable substitution support
+- ⚡ Built-in duplicate parsing prevention, API retry logic, and automatic cache cleanup
+- 📤 Support OneBot platform message forwarding for better display experience
 ## 项目仓库 (Repository)
 - GitHub: `https://github.com/Minecraft-1314/koishi-plugin-video-parser-all`
@@ -24,49 +24,107 @@ This is a **video parsing plugin** developed for the Koishi bot framework, suppo
 | 指令 (Command) | 说明 (Description) | 示例 (Example) |
 |----------------|--------------------|----------------|
-| `parse <url>` | 手动解析指定的视频链接 | `parse https://v.douyin.com/xxxx/` |
-| `clear-cache` | 清理解析缓存和临时下载文件 | `clear-cache` |
+| `parse <url>` | 手动解析指定的视频/图集链接 | `parse https://v.douyin.com/xxxx/` |
+| `clear-cache` | 清理解析缓存和临时下载的视频文件 | `clear-cache` |
 ## 配置项说明 (Configuration)
-| 配置项 (Config Item) | 类型 (Type) | 默认值 (Default) | 说明 (Description) |
-|----------------------|-------------|------------------|--------------------|
-| `enable` | boolean | true | 是否启用插件 |
+### 基础设置
+| 配置项 | 类型 | 默认值 | 说明 |
+|--------|------|--------|------|
+| `enable` | boolean | true | 是否启用视频解析插件 |
 | `botName` | string | 视频解析机器人 | 合并转发消息中显示的机器人名称 |
-| `showWaitingTip` | boolean | true | 解析时是否显示等待提示 |
-| `waitingTipText` | string | 正在解析视频，请稍候... | 等待提示文本 |
-| `sameLinkInterval` | number | 180 | 相同链接解析间隔（秒），防止重复解析 |
-| `maxVideoSize` | number | 50 | 最大视频下载大小（MB），0 表示不限制 |
-| `downloadThreads` | number | 4 | 视频下载线程数，0 表示使用单线程 |
-| `platformEnable.bilibili` | boolean | true | 启用B站解析（含番剧、BV号直解析） |
-| `platformEnable.douyin` | boolean | true | 启用抖音解析 |
-| `platformEnable.kuaishou` | boolean | true | 启用快手解析 |
-| `platformEnable.xigua` | boolean | true | 启用西瓜视频解析 |
-| `platformEnable.xiaohongshu` | boolean | true | 启用小红书解析 |
-| `platformEnable.weibo` | boolean | true | 启用微博解析 |
-| `platformEnable.toutiao` | boolean | true | 启用今日头条解析 |
-| `platformEnable.pipigx` | boolean | true | 启用皮皮搞笑解析 |
-| `platformEnable.pipixia` | boolean | true | 启用皮皮虾解析 |
-| `platformEnable.zuiyou` | boolean | true | 启用最右解析 |
-| `platformFormat.bilibili` | string | 标题：${标题}\nUP主：${作者}\n简介：${简介}\n时长：${视频时长}\n点赞：${点赞数}\n投币：${投币数}\n收藏：${收藏数}\n转发：${转发数} | B站解析结果格式，支持变量替换 |
-| `platformFormat.douyin` | string | 标题：${标题}\n作者：${作者}\n点赞：${点赞数}\n收藏：${收藏数}\n转发：${转发数} | 抖音解析结果格式，支持变量替换 |
-| `platformFormat.kuaishou` | string | 标题：${标题}\n作者：${作者}\n点赞：${点赞数}\n播放：${播放数}\n转发：${转发数} | 快手解析结果格式，支持变量替换 |
-| `platformFormat.xigua` | string | 标题：${标题}\n播放：${播放数}\n点赞：${点赞数}\n视频大小：${视频大小}MB | 西瓜视频解析结果格式，支持变量替换 |
-| `showImageText` | boolean | true | 是否显示解析后的文本与封面图 |
-| `showVideoUrl` | boolean | false | 是否显示无水印视频直链 |
-| `showVideoFile` | boolean | true | 是否发送视频文件（关闭则仅显示链接） |
-| `maxDescLength` | number | 200 | 简介最大字符长度，超出部分自动截断 |
-| `timeout` | number | 180000 | API 请求超时时间（毫秒） |
-| `videoSendTimeout` | number | 0 | 视频消息发送超时时间（毫秒），0表示不限制 |
-| `userAgent` | string | Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36 | API请求使用的User-Agent |
-| `bilibiliAccessKey` | string | "" | B站大会员access_key（解析大会员视频/番剧必填） |
-| `ignoreSendError` | boolean | true | 忽略消息发送错误，避免插件崩溃 |
-| `retryTimes` | number | 0 | API解析失败时的重试次数 |
-| `retryInterval` | number | 0 | 每次重试的间隔时间（毫秒） |
-| `enableForward` | boolean | false | 启用OneBot平台的合并转发功能 |
-| `downloadVideoBeforeSend` | boolean | false | 发送前下载视频到本地，再发送文件（仅OneBot） |
-| `messageBufferDelay` | number | 0 | 消息缓冲延迟，合并短时间内的多个解析请求（秒） |
-| `autoClearCacheInterval` | number | 0 | 自动清理缓存和临时视频文件的间隔（分钟），0表示不自动清理 |
+| `showWaitingTip` | boolean | true | 解析时显示等待提示 |
+| `waitingTipText` | string | 正在解析视频，请稍候... | 等待提示文本内容 |
+| `sameLinkInterval` | number | 180 | 相同链接重复解析间隔（秒），防止频繁解析 |
+### 统一消息格式
+| 配置项 | 类型 | 默认值 | 说明 |
+|--------|------|--------|------|
+| `unifiedMessageFormat` | string | 详见下方变量说明 | 自定义解析结果的输出格式，支持变量替换 |
+### 内容显示设置
+| 配置项 | 类型 | 默认值 | 说明 |
+|--------|------|--------|------|
+| `showImageText` | boolean | true | 是否显示解析后的图文内容 |
+| `showVideoFile` | boolean | true | 是否发送视频文件（关闭则只发送视频链接） |
+### 内容长度限制
+| 配置项 | 类型 | 默认值 | 说明 |
+|--------|------|--------|------|
+| `maxDescLength` | number | 200 | 简介内容最大长度（字符），超出部分自动截断 |
+### 网络与API设置
+| 配置项 | 类型 | 默认值 | 说明 |
+|--------|------|--------|------|
+| `timeout` | number | 180000 | API请求超时时间（毫秒） |
+| `videoSendTimeout` | number | 0 | 视频消息发送超时时间（毫秒，0为不限制） |
+| `userAgent` | string | Chrome 124 UA | API请求使用的User-Agent标识 |
+### 错误与重试设置
+| 配置项 | 类型 | 默认值 | 说明 |
+|--------|------|--------|------|
+| `ignoreSendError` | boolean | true | 忽略消息发送失败错误，避免插件崩溃 |
+| `retryTimes` | number | 3 | API请求失败时的重试次数 |
+| `retryInterval` | number | 1000 | 每次重试的间隔时间（毫秒） |
+### 发送方式设置
+| 配置项 | 类型 | 默认值 | 说明 |
+|--------|------|--------|------|
+| `enableForward` | boolean | false | 启用合并转发功能（仅OneBot平台） |
+| `downloadVideoBeforeSend` | boolean | false | 发送前先下载视频到本地（再发送文件） |
+| `maxVideoSize` | number | 0 | 最大视频下载大小限制（MB，0为不限制） |
+| `downloadThreads` | number | 0 | 多线程下载线程数（0为单线程，最大10） |
+### 消息处理设置
+| 配置项 | 类型 | 默认值 | 说明 |
+|--------|------|--------|------|
+| `messageBufferDelay` | number | 0 | 消息缓冲延迟（毫秒），合并短时间内的解析请求 |
+### 缓存清理设置
+| 配置项 | 类型 | 默认值 | 说明 |
+|--------|------|--------|------|
+| `autoClearCacheInterval` | number | 0 | 自动清理缓存间隔（分钟，0为关闭自动清理） |
+## 支持的变量 (Supported Variables)
+在 `unifiedMessageFormat` 中可使用以下变量进行自定义格式化：
+| 变量名 | 说明 | 适用平台 |
+|--------|------|----------|
+| `${标题}` | 视频/图集标题 | 所有平台 |
+| `${作者}` | 作者/UP主/发布者名称 | 所有平台 |
+| `${简介}` | 内容简介/描述 | 部分平台 |
+| `${视频时长}` | 视频时长 | 部分平台 |
+| `${点赞数}` | 点赞数量 | 所有平台 |
+| `${投币数}` | 投币数量 | 部分平台 |
+| `${收藏数}` | 收藏数量 | 所有平台 |
+| `${转发数}` | 转发/分享数量 | 所有平台 |
+| `${播放数}` | 播放量 | 部分平台 |
+| `${评论数}` | 评论数量 | 所有平台 |
+| `${IP属地}` | 作者IP属地 | 部分平台 |
+| `${发布时间}` | 发布时间（格式化） | 所有平台 |
+| `${粉丝数}` | 作者粉丝数量 | 部分平台 |
+| `${在线人数}` | 直播间在线人数 | 部分平台 |
+| `${关注数}` | 关注数 | 部分平台 |
+| `${文件大小}` | 文件大小（MB） | 部分平台 |
+| `${直播间地址}` | 直播间链接 | 部分平台 |
+| `${直播间ID}` | 直播间ID | 部分平台 |
+| `${直播间状态}` | 直播间状态（直播中/未开播） | 部分平台 |
+| `${图片数量}` | 图集图片数量 | 部分平台 |
+| `${作者ID}` | 作者唯一标识ID | 部分平台 |
+## 支持的平台 (Supported Platforms)
+| 平台名称 | 关键词识别 | 解析能力 |
+|----------|------------|----------|
+| 哔哩哔哩 (B站) | bilibili、b23、B站 | 视频、番剧、直播、图集 |
+| 抖音 | douyin、v.douyin.com | 短视频、图集、直播 |
+| 快手 | kuaishou、v.kuaishou.com | 短视频、图集 |
+| 小红书 | xiaohongshu、xhslink.com | 笔记、图集、视频 |
+| 微博 | weibo、video.weibo.com | 视频、图集 |
+| 今日头条 | toutiao、ixigua.com | 短视频 |
+| 皮皮搞笑 | pipigx、h5.pipigx.com | 短视频 |
+| 皮皮虾 | pipixia、h5.pipix.com | 短视频 |
+| 最右 | zuiyou、xiaochuankeji.cn | 短视频 |
 ## 项目贡献者 (Contributors)