koishi-plugin-video-parser-all 0.5.2 → 0.5.4

package/lib/index.d.ts

@@ -61,4 +61,32 @@ 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,
+    DOUYIN_PARSE_FAILED = 5001,
+    XIAOHONGSHU_PARSE_FAILED = 5002,
+    BILIBILI_PARSE_FAILED = 5003,
+    KUAISHOU_PARSE_FAILED = 5004,
+    WEIBO_PARSE_FAILED = 5005
+}
+export declare const ErrorMessageMap: Record<ErrorCode, string>;
 export declare function apply(ctx: Context, config: any): void;

package/lib/index.js

@@ -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.Config = exports.name = void 0;
+exports.ErrorMessageMap = exports.ErrorCode = exports.Config = exports.name = void 0;
 exports.apply = apply;
 const koishi_1 = require("koishi");
 const axios_1 = __importDefault(require("axios"));
@@ -22,7 +22,7 @@ exports.Config = koishi_1.Schema.intersect([
         sameLinkInterval: koishi_1.Schema.number().min(0).default(180).description('相同链接重复解析间隔（秒）'),
     }).description('基础设置'),
     koishi_1.Schema.object({
-        unifiedMessageFormat: koishi_1.Schema.string().role('textarea').default('标题：${标题}\n作者：${作者}\n简介：${简介}\n时长：${视频时长}\n点赞：${点赞数}\n投币：${投币数}\n收藏：${收藏数}\n转发：${转发数}\n播放：${播放数}\n评论：${评论数}\n音乐：${音乐名}').description('统一消息格式（B站会显示投币，其他平台自动隐藏；无法获取的变量会自动隐藏）'),
+        unifiedMessageFormat: koishi_1.Schema.string().role('textarea').default('标题：${标题}\n作者：${作者}\n简介：${简介}\n时长：${视频时长}\n点赞：${点赞数}\n投币：${投币数}\n收藏：${收藏数}\n转发：${转发数}\n播放：${播放数}\n评论：${评论数}\n音乐：${音乐名}').description('统一消息格式（无法获取的变量会自动隐藏）\n变量介绍：\n${标题} - 内容标题\n${作者} - 作者名称\n${简介} - 内容简介\n${视频时长} - 视频时长\n${点赞数} - 点赞数量\n${投币数} - 投币数量（仅B站）\n${收藏数} - 收藏数量\n${转发数} - 转发/分享数量\n${播放数} - 播放数量\n${评论数} - 评论数量\n${音乐名} - 背景音乐名称'),
     }).description('统一消息格式'),
     koishi_1.Schema.object({
         showImageText: koishi_1.Schema.boolean().default(true).description('显示图文内容'),
@@ -38,29 +38,84 @@ 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(0).description('API请求重试次数'),
-        retryInterval: koishi_1.Schema.number().min(0).default(0).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).description('启用合并转发（仅OneBot平台）'),
-        downloadVideoBeforeSend: koishi_1.Schema.boolean().default(false).description('发送前先下载视频（避免链接失效）'),
+        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为不使用多线程，1-10为启用对应线程数）'),
-    }).description('发送方式设置（说明：视频大小超过限制将只发送链接；多线程下载可提升速度但可能增加服务器负载）'),
+    }).description('发送方式设置'),
     koishi_1.Schema.object({
         messageBufferDelay: koishi_1.Schema.number().min(0).default(0).description('消息缓冲延迟（毫秒，批量处理链接）'),
     }).description('消息处理设置'),
     koishi_1.Schema.object({
         autoClearCacheInterval: koishi_1.Schema.number().min(0).default(0).description('自动清理缓存间隔（分钟，0为关闭）'),
-    }).description('缓存清理设置（说明：开启自动清理可定期删除过期的临时视频文件和解析缓存）'),
+    }).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[ErrorCode["DOUYIN_PARSE_FAILED"] = 5001] = "DOUYIN_PARSE_FAILED";
+    ErrorCode[ErrorCode["XIAOHONGSHU_PARSE_FAILED"] = 5002] = "XIAOHONGSHU_PARSE_FAILED";
+    ErrorCode[ErrorCode["BILIBILI_PARSE_FAILED"] = 5003] = "BILIBILI_PARSE_FAILED";
+    ErrorCode[ErrorCode["KUAISHOU_PARSE_FAILED"] = 5004] = "KUAISHOU_PARSE_FAILED";
+    ErrorCode[ErrorCode["WEIBO_PARSE_FAILED"] = 5005] = "WEIBO_PARSE_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]: '合并转发失败',
+    [ErrorCode.DOUYIN_PARSE_FAILED]: '抖音链接解析失败',
+    [ErrorCode.XIAOHONGSHU_PARSE_FAILED]: '小红书链接解析失败',
+    [ErrorCode.BILIBILI_PARSE_FAILED]: 'B站链接解析失败',
+    [ErrorCode.KUAISHOU_PARSE_FAILED]: '快手链接解析失败',
+    [ErrorCode.WEIBO_PARSE_FAILED]: '微博链接解析失败',
+};
 const processed = new Map();
 const linkBuffer = new Map();
 const logger = new koishi_1.Logger(exports.name);
 const PLATFORM_KEYWORDS = {
     bilibili: ['bilibili', 'b23', 'B站', 'www.bilibili.com', 'm.bilibili.com', '哔哩哔哩', 'bilibili.com/opus', 'bilibili.com/video', 'b23.tv', 't.bilibili.com', 'bilibili.com/bangumi'],
     kuaishou: ['kuaishou', '快手', 'v.kuaishou.com', 'www.kuaishou.com', 'kwimgs.com', 'kuaishou.com/app'],
-    xiaohongshu: ['xiaohongshu', '小红书', 'xhslink.com', 'xiaohongshu.com', 'xhscdn.com', 'xiaohongshu.com/explore', 'xhslink.com/'],
+    xiaohongshu: ['xiaohongshu', '小红书', 'xhslink.com', 'xiaohongshu.com', 'xhscdn.com', 'xiaohongshu.com/explore', 'xhslink.com/', 'xiaohongshu.com/discovery/item'],
     weibo: ['weibo', '微博', 'weibo.com', 'video.weibo.com', 'm.weibo.cn', 'weibo.com/tv/show', 'weibo.com/feed'],
     toutiao: ['toutiao', '今日头条', 'm.toutiao.com', 'toutiao.com', 'ixigua.com', 'toutiao.com/video', 'ixigua.com/i'],
     pipigx: ['pipigx', '皮皮搞笑', 'h5.pipigx.com', 'ippzone.com', 'pipigx.com/share'],
@@ -79,9 +134,20 @@ const API_CONFIG = {
     pipixia: 'https://api.bugpk.com/api/ppx',
     zuiyou: 'https://api.bugpk.com/api/zuiyou'
 };
+const PLATFORM_ERROR_CODE_MAP = {
+    douyin: ErrorCode.DOUYIN_PARSE_FAILED,
+    xiaohongshu: ErrorCode.XIAOHONGSHU_PARSE_FAILED,
+    bilibili: ErrorCode.BILIBILI_PARSE_FAILED,
+    kuaishou: ErrorCode.KUAISHOU_PARSE_FAILED,
+    weibo: ErrorCode.WEIBO_PARSE_FAILED,
+    toutiao: ErrorCode.API_RETURN_ERROR,
+    pipigx: ErrorCode.API_RETURN_ERROR,
+    pipixia: ErrorCode.API_RETURN_ERROR,
+    zuiyou: ErrorCode.API_RETURN_ERROR
+};
 const VARIABLE_MAPPING = {
     '标题': ['title', 'Title', 'TITLE'],
-    '作者': ['author', 'name', 'Author', 'Name'],
+    '作者': ['author.name', 'author', 'name', 'Author', 'Name'],
     '简介': ['desc', 'description', 'Desc', 'Description', 'content', 'Content'],
     '视频时长': ['duration', 'Duration', 'time', 'Time'],
     '点赞数': ['like', 'Like', 'attitudes_count', 'digg_count', 'praise'],
@@ -92,6 +158,10 @@ const VARIABLE_MAPPING = {
     '评论数': ['comment', 'Comment', 'comments_count', 'comment_count', 'discuss'],
     '音乐名': ['music.title', 'music_name', 'audio_name', 'sound_name']
 };
+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;
@@ -156,11 +226,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')) {
-            throw new Error('不支持音频');
+            return { filePath: '', code: ErrorCode.UNSUPPORTED_CONTENT_TYPE };
         }
         const fileSize = await getFileSize(url, userAgent);
         if (maxSize > 0 && fileSize > maxSize) {
-            throw new Error(`视频大小${fileSize}MB超过限制${maxSize}MB`);
+            return { filePath: '', code: ErrorCode.VIDEO_SIZE_EXCEEDED };
         }
         if (threads <= 0 || fileSize === 0) {
             const response = await (0, axios_1.default)({
@@ -174,7 +244,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;
+            return { filePath, code: ErrorCode.SUCCESS };
         }
         const totalSize = fileSize * 1024 * 1024;
         const chunkSize = Math.ceil(totalSize / threads);
@@ -200,7 +270,7 @@ async function downloadVideo(url, filename, userAgent, maxSize, threads) {
             fs_1.default.unlinkSync(result.filePath);
         }
         writeStream.end();
-        return filePath;
+        return { filePath, code: ErrorCode.SUCCESS };
     }
     catch (error) {
         if (fs_1.default.existsSync(filePath)) {
@@ -213,7 +283,7 @@ async function downloadVideo(url, filename, userAgent, maxSize, threads) {
             }
             catch (e) { }
         });
-        throw error;
+        return { filePath: '', code: ErrorCode.VIDEO_DOWNLOAD_FAILED };
     }
 }
 function extractUrl(content) {
@@ -249,19 +319,41 @@ function getPlatformType(url) {
         return 'zuiyou';
     return null;
 }
+function cleanUrl(url) {
+    try {
+        // 处理HTML实体编码
+        url = url.replace(/&amp;/g, '&');
+        const urlObj = new URL(url);
+        if (urlObj.hostname.includes('xiaohongshu.com')) {
+            urlObj.searchParams.delete('source');
+            urlObj.searchParams.delete('xhsshare');
+            urlObj.searchParams.delete('xsec_token');
+            urlObj.searchParams.delete('xsec_source');
+            return urlObj.origin + urlObj.pathname + urlObj.search;
+        }
+        if (urlObj.hostname.includes('douyin.com') || urlObj.hostname.includes('v.douyin.com')) {
+            return urlObj.origin + urlObj.pathname;
+        }
+        return url;
+    }
+    catch (e) {
+        // 处理HTML实体编码
+        return url.replace(/&amp;/g, '&');
+    }
+}
 async function resolveShortUrl(url) {
     try {
         const res = await axios_1.default.head(url, {
-            timeout: 5000,
-            maxRedirects: 5,
+            timeout: 10000,
+            maxRedirects: 10,
             headers: {
                 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
             }
         });
-        return res.request.res?.responseUrl || url;
+        return cleanUrl(res.request.res?.responseUrl || url);
     }
     catch (e) {
-        return url;
+        return cleanUrl(url);
     }
 }
 function formatDuration(input) {
@@ -328,9 +420,9 @@ function parseData(rawResponse, maxDescLength, platform) {
             stat[varName] = value;
         }
     });
-    let type = 'video';
+    let type = data.type || 'video';
     const title = findValueInObject(data, ['title']) || '无标题';
-    const author = findValueInObject(data, ['author', 'name']) || '未知作者';
+    const author = findValueInObject(data, ['author.name', 'author']) || '未知作者';
     const desc = (findValueInObject(data, ['desc', 'description', 'content']) || title).toString().slice(0, maxDescLength);
     const cover = findValueInObject(data, ['cover', 'imgurl', 'pic', 'thumbnail']) || '';
     let images = findValueInObject(data, ['imgurl', 'images', 'pics']) || [];
@@ -344,24 +436,23 @@ function parseData(rawResponse, maxDescLength, platform) {
         findValueInObject(data, ['video_url'])
     ];
     let video = '';
-    for (const url of videoUrls) {
-        if (url && typeof url === 'string' && url.trim() !== '') {
-            video = url;
-            break;
+    if (Array.isArray(videoUrls[2])) {
+        video = videoUrls[2][0]?.url || '';
+    }
+    else {
+        for (const url of videoUrls) {
+            if (url && typeof url === 'string' && url.trim() !== '') {
+                video = url;
+                break;
+            }
         }
     }
     const durationValue = findValueInObject(data, ['duration']);
     const duration = typeof durationValue === 'number' ? durationValue : parseInt(durationValue) || 0;
     const durationFormatted = formatDuration(durationValue || 0);
-    const dataType = findValueInObject(data, ['type']);
-    if (dataType === 'image' || (images.length > 0 && !video)) {
-        type = 'image';
-    }
-    if (video && (video.endsWith('.m4a') || video.endsWith('.mp3'))) {
-        video = '';
-    }
+    const live_photo = data.live_photo || [];
     return {
-        type,
+        type: type,
         rawData: rawResponse,
         title,
         author,
@@ -371,7 +462,8 @@ function parseData(rawResponse, maxDescLength, platform) {
         video,
         duration,
         durationFormatted,
-        stat
+        stat,
+        live_photo
     };
 }
 function generateFormattedText(platform, parseData, config) {
@@ -401,6 +493,9 @@ function generateFormattedText(platform, parseData, config) {
         }
     });
     result = validLines.join('\n').trim();
+    if (!result) {
+        result = `标题：${parseData.title}\n作者：${parseData.author}\n简介：${parseData.desc}`;
+    }
     return result;
 }
 function clearAllCache() {
@@ -443,58 +538,139 @@ function apply(ctx, config) {
         timeout: config.timeout,
         headers: { 'User-Agent': config.userAgent || 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36' }
     });
+    async function parseWithRetry(url, platform, retryTimes) {
+        let lastError = null;
+        for (let i = 0; i <= retryTimes; i++) {
+            try {
+                const res = await http.get(API_CONFIG[platform], {
+                    params: { url },
+                    timeout: config.timeout
+                });
+                return res.data;
+            }
+            catch (error) {
+                lastError = error;
+                if (i < retryTimes) {
+                    await delay(config.retryInterval);
+                }
+            }
+        }
+        throw lastError;
+    }
     async function parse(url) {
-        const realUrl = await resolveShortUrl(url);
+        let realUrl = await resolveShortUrl(url);
+        realUrl = cleanUrl(realUrl);
         const platform = getPlatformType(realUrl);
         if (!platform) {
-            logger.error(`不支持该平台: ${platform || '未知'}, URL: ${url}`);
-            return { data: null, msg: '不支持该平台链接' };
+            const code = ErrorCode.UNSUPPORTED_PLATFORM;
+            const msg = getErrorInfo(code, url);
+            logger.error(`[${code}] ${exports.ErrorMessageMap[code]}: ${url}`);
+            return { data: null, code, msg };
         }
         const apiUrl = API_CONFIG[platform];
         if (!apiUrl) {
-            logger.error(`未配置该平台API: ${platform}, URL: ${url}`);
-            return { data: null, msg: '该平台暂未配置解析接口' };
+            const code = ErrorCode.PLATFORM_API_NOT_CONFIGURED;
+            const msg = getErrorInfo(code, platform);
+            logger.error(`[${code}] ${exports.ErrorMessageMap[code]}: ${platform}`);
+            return { data: null, code, msg };
         }
         try {
-            const res = await http.get(apiUrl, {
-                params: { url: realUrl },
-                timeout: config.timeout
-            });
-            if (res.data.code !== 200 && res.data.code !== 0) {
-                logger.error(`API返回错误: ${platform}, URL: ${url}, 错误: ${res.data.msg || '未知错误'}`);
-                return { data: null, msg: res.data.msg || '解析失败' };
+            const resData = await parseWithRetry(realUrl, platform, config.retryTimes);
+            // 正确的成功判断逻辑：code为200或0，或者msg包含"解析成功"
+            const isSuccess = resData.code === 200 || resData.code === 0 ||
+                (resData.msg && resData.msg.includes('解析成功'));
+            if (!isSuccess) {
+                const apiErrorMsg = resData.msg || '解析失败';
+                const platformCode = PLATFORM_ERROR_CODE_MAP[platform] || ErrorCode.API_RETURN_ERROR;
+                let detailedMsg = apiErrorMsg;
+                if (apiErrorMsg.includes('无法识别解析类型') || apiErrorMsg.includes('未找到有效内容')) {
+                    detailedMsg = `链接格式不支持或内容已失效：${apiErrorMsg}`;
+                }
+                const code = platformCode;
+                const msg = getErrorInfo(code, detailedMsg);
+                logger.error(`[${code}] API返回错误: ${platform}, URL: ${url}, 错误: ${apiErrorMsg}`);
+                return { data: null, code, msg };
+            }
+            try {
+                const parseResult = parseData(resData, config.maxDescLength, platform);
+                // 修正内容判断逻辑：支持live类型和live_photo
+                const hasValidContent = parseResult.video ||
+                    (parseResult.images && parseResult.images.length > 0) ||
+                    (parseResult.live_photo && parseResult.live_photo.length > 0) ||
+                    parseResult.type === 'live';
+                if (!hasValidContent) {
+                    const code = ErrorCode.NO_VIDEO_FOUND;
+                    const msg = getErrorInfo(code, '链接有效但未找到视频/图片内容（可能是直播、私密内容或已删除）');
+                    logger.warn(`[${code}] 解析成功但无有效内容: ${platform}, URL: ${url}`);
+                    return { data: null, code, msg };
+                }
+                logger.info(`[${ErrorCode.SUCCESS}] ${platform}解析成功: ${url}`);
+                return {
+                    data: parseResult,
+                    code: ErrorCode.SUCCESS,
+                    msg: getErrorInfo(ErrorCode.SUCCESS)
+                };
+            }
+            catch (parseError) {
+                const errorMsg = getErrorMessage(parseError);
+                const code = ErrorCode.API_DATA_PARSE_FAILED;
+                const msg = getErrorInfo(code, errorMsg);
+                logger.error(`[${code}] 解析数据失败: ${platform}, URL: ${url}, 错误: ${errorMsg}`);
+                return { data: null, code, msg };
             }
-            const parseResult = parseData(res.data, config.maxDescLength, platform);
-            return { data: parseResult, msg: `${platform}解析成功` };
         }
         catch (error) {
-            logger.error(`解析请求失败: ${platform}, URL: ${url}, 错误: ${getErrorMessage(error)}`);
-            return { data: null, msg: '解析失败，请稍后重试' };
+            const errorMsg = getErrorMessage(error);
+            let code = ErrorCode.UNKNOWN_ERROR;
+            if (errorMsg.includes('timeout')) {
+                code = ErrorCode.REQUEST_TIMEOUT;
+            }
+            else if (errorMsg.includes('Network') || errorMsg.includes('network')) {
+                code = ErrorCode.NETWORK_ERROR;
+            }
+            else {
+                code = ErrorCode.NETWORK_ERROR;
+            }
+            const msg = getErrorInfo(code, errorMsg);
+            logger.error(`[${code}] 解析请求失败: ${platform}, URL: ${url}, 错误: ${errorMsg}`);
+            return { data: null, code, 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) {
-            return { data: null, msg: '请勿重复解析' };
+            const code = ErrorCode.DUPLICATE_PARSE;
+            const msg = getErrorInfo(code);
+            return { data: null, code, msg };
         }
         processed.set(hash, now);
         const result = await parse(url);
         if (!result.data)
-            return { data: null, msg: result.msg };
+            return { data: null, code: result.code, msg: result.msg };
         const parseData = result.data;
         const platform = getPlatformType(url);
         const text = generateFormattedText(platform, parseData, config);
         return {
-            data: { text, cover: parseData.cover, images: parseData.images, video: parseData.video, type: parseData.type },
-            msg: 'ok'
+            data: {
+                text,
+                cover: parseData.cover,
+                images: parseData.images,
+                video: parseData.video,
+                type: parseData.type,
+                live_photo: parseData.live_photo
+            },
+            code: ErrorCode.SUCCESS,
+            msg: getErrorInfo(ErrorCode.SUCCESS)
         };
     }
     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}`);
                 if (!config.ignoreSendError)
-                    logger.error('发送消息失败:', err.message);
+                    return null;
                 return null;
             });
         }
@@ -502,8 +678,11 @@ function apply(ctx, config) {
             session.send(content),
             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}`);
             if (!config.ignoreSendError)
-                logger.error('发送消息超时:', err.message);
+                return null;
             return null;
         });
     }
@@ -516,43 +695,32 @@ function apply(ctx, config) {
             linkBuffer.delete(key);
         }
         const items = [];
-        const errs = [];
+        const errors = [];
         for (const url of urls) {
             const result = await processSingleUrl(session, url);
             if (result.data) {
                 items.push(result.data);
             }
             else {
-                errs.push(`【${url.slice(0, 22)}...】：${result.msg}`);
-                logger.error(`解析失败: ${url}, 原因: ${result.msg}`);
+                errors.push({ url, code: result.code, msg: result.msg });
+                logger.error(`[${result.code}] 解析失败: ${url}, 原因: ${result.msg}`);
             }
         }
-        if (errs.length) {
-            logger.error(`解析失败数量: ${errs.length}, 示例: ${errs[0]}`);
-        }
-        const enableForward = config.enableForward && session.platform === 'onebot';
-        const forwardMessages = [];
-        const botName = config.botName || '视频解析机器人';
-        if (errs.length) {
-            const errorMsg = `⚠ 部分解析失败\n${errs.join('\n')}`;
-            if (enableForward) {
-                forwardMessages.push(buildForwardNode(session, errorMsg, botName));
-            }
-            else {
-                await sendTimeout(session, errorMsg);
-                await delay(600);
-            }
+        if (errors.length > 0) {
+            const errorLines = errors.map(err => `【${err.url}】: ${err.msg}`);
+            const errorMsg = `❌ 解析失败列表（共${errors.length}个链接）：\n${errorLines.join('\n')}`;
+            logger.error(`解析失败数量: ${errors.length}, 错误码列表: ${errors.map(e => e.code).join(', ')}`);
+            await sendTimeout(session, errorMsg);
+            await delay(500);
         }
         if (items.length === 0) {
-            const failMsg = `❌ 全部解析失败\n${errs.join('\n')}`;
-            if (enableForward) {
-                forwardMessages.push(buildForwardNode(session, failMsg, botName));
-            }
-            else {
-                await sendTimeout(session, failMsg);
-            }
+            const failMsg = getErrorInfo(ErrorCode.UNKNOWN_ERROR, '所有链接均解析失败，请检查链接是否有效或稍后重试');
+            await sendTimeout(session, `⚠ ${failMsg}`);
             return;
         }
+        const enableForward = config.enableForward && session.platform === 'onebot';
+        const forwardMessages = [];
+        const botName = config.botName || '视频解析机器人';
         for (const item of items) {
             try {
                 if (enableForward) {
@@ -565,28 +733,60 @@ function apply(ctx, config) {
                             forwardMessages.push(buildForwardNode(session, koishi_1.h.image(item.images[i]), botName));
                         }
                     }
+                    if (item.type === 'live' || item.type === 'live_photo') {
+                        if (item.live_photo?.length) {
+                            for (let i = 0; i < item.live_photo.length && forwardMessages.length < 100; i++) {
+                                const liveItem = item.live_photo[i];
+                                forwardMessages.push(buildForwardNode(session, koishi_1.h.image(liveItem.image), botName));
+                                if (liveItem.video) {
+                                    try {
+                                        const videoElem = koishi_1.h.video(liveItem.video);
+                                        forwardMessages.push(buildForwardNode(session, videoElem, botName));
+                                    }
+                                    catch (e) {
+                                        forwardMessages.push(buildForwardNode(session, koishi_1.h.text(`视频链接: ${liveItem.video}`), botName));
+                                    }
+                                }
+                            }
+                        }
+                        else if (item.images?.length) {
+                            for (let i = 0; i < item.images.length && forwardMessages.length < 100; i++) {
+                                forwardMessages.push(buildForwardNode(session, koishi_1.h.image(item.images[i]), botName));
+                            }
+                        }
+                    }
                     if (item.video && config.showVideoFile && forwardMessages.length < 100) {
                         let videoElem;
                         try {
                             if (config.downloadVideoBeforeSend) {
                                 const filename = crypto_1.default.createHash('md5').update(item.video).digest('hex');
-                                const filePath = await downloadVideo(item.video, filename, config.userAgent, config.maxVideoSize, config.downloadThreads);
-                                videoElem = koishi_1.h.file(filePath);
+                                const downloadResult = await downloadVideo(item.video, filename, config.userAgent, config.maxVideoSize, config.downloadThreads);
+                                if (downloadResult.code !== ErrorCode.SUCCESS) {
+                                    const errorMsg = getErrorInfo(downloadResult.code);
+                                    forwardMessages.push(buildForwardNode(session, koishi_1.h.text(`${errorMsg}\n链接：${item.video}`), botName));
+                                }
+                                else {
+                                    videoElem = koishi_1.h.file(downloadResult.filePath);
+                                    forwardMessages.push(buildForwardNode(session, videoElem, botName));
+                                }
                             }
                             else {
                                 const fileSize = await getFileSize(item.video, config.userAgent);
                                 if (config.maxVideoSize > 0 && fileSize > config.maxVideoSize) {
-                                    videoElem = koishi_1.h.text(`视频大小${fileSize}MB超过限制${config.maxVideoSize}MB，仅发送链接：${item.video}`);
+                                    const code = ErrorCode.VIDEO_SIZE_EXCEEDED;
+                                    const errorMsg = getErrorInfo(code, `${fileSize}MB超过限制${config.maxVideoSize}MB`);
+                                    videoElem = koishi_1.h.text(`${errorMsg}，仅发送链接：${item.video}`);
                                 }
                                 else {
                                     videoElem = koishi_1.h.video(item.video);
                                 }
                             }
-                            forwardMessages.push(buildForwardNode(session, videoElem, botName));
                         }
                         catch (error) {
-                            logger.error(`视频处理失败: ${getErrorMessage(error)}`);
-                            forwardMessages.push(buildForwardNode(session, koishi_1.h.text(`视频处理失败：${getErrorMessage(error)}\n链接：${item.video}`), botName));
+                            const errorMsg = getErrorMessage(error);
+                            const code = ErrorCode.VIDEO_DOWNLOAD_FAILED;
+                            logger.error(`[${code}] 视频处理失败: ${errorMsg}`);
+                            forwardMessages.push(buildForwardNode(session, koishi_1.h.text(getErrorInfo(code, errorMsg) + `\n链接：${item.video}`), botName));
                         }
                     }
                 }
@@ -595,7 +795,28 @@ function apply(ctx, config) {
                         await sendTimeout(session, item.text);
                         await delay(300);
                     }
-                    if (item.type === 'image' && item.images?.length) {
+                    if (item.type === 'live' || item.type === 'live_photo') {
+                        if (item.live_photo?.length) {
+                            for (const liveItem of item.live_photo) {
+                                await sendTimeout(session, koishi_1.h.image(liveItem.image));
+                                await delay(200);
+                                if (liveItem.video) {
+                                    try {
+                                        await sendTimeout(session, koishi_1.h.video(liveItem.video));
+                                    }
+                                    catch (e) {
+                                        await sendTimeout(session, koishi_1.h.text(`Live Photo 视频链接: ${liveItem.video}`));
+                                    }
+                                    await delay(300);
+                                }
+                            }
+                        }
+                        else if (item.images?.length) {
+                            const imgMsg = (0, koishi_1.h)('message', ...item.images.map((url) => koishi_1.h.image(url)));
+                            await sendTimeout(session, imgMsg);
+                        }
+                    }
+                    else if (item.type === 'image' && item.images?.length) {
                         const imgMsg = (0, koishi_1.h)('message', ...item.images.map((url) => koishi_1.h.image(url)));
                         await sendTimeout(session, imgMsg);
                     }
@@ -609,13 +830,22 @@ function apply(ctx, config) {
                                 let videoElem;
                                 if (config.downloadVideoBeforeSend) {
                                     const filename = crypto_1.default.createHash('md5').update(item.video).digest('hex');
-                                    const filePath = await downloadVideo(item.video, filename, config.userAgent, config.maxVideoSize, config.downloadThreads);
-                                    videoElem = koishi_1.h.file(filePath);
+                                    const downloadResult = await downloadVideo(item.video, filename, config.userAgent, config.maxVideoSize, config.downloadThreads);
+                                    if (downloadResult.code !== ErrorCode.SUCCESS) {
+                                        const errorMsg = getErrorInfo(downloadResult.code);
+                                        await sendTimeout(session, koishi_1.h.text(`${errorMsg}\n链接：${item.video}`));
+                                        continue;
+                                    }
+                                    else {
+                                        videoElem = koishi_1.h.file(downloadResult.filePath);
+                                    }
                                 }
                                 else {
                                     const fileSize = await getFileSize(item.video, config.userAgent);
                                     if (config.maxVideoSize > 0 && fileSize > config.maxVideoSize) {
-                                        videoElem = koishi_1.h.text(`视频大小${fileSize}MB超过限制${config.maxVideoSize}MB，仅发送链接：${item.video}`);
+                                        const code = ErrorCode.VIDEO_SIZE_EXCEEDED;
+                                        const errorMsg = getErrorInfo(code, `${fileSize}MB超过限制${config.maxVideoSize}MB`);
+                                        videoElem = koishi_1.h.text(`${errorMsg}，仅发送链接：${item.video}`);
                                     }
                                     else {
                                         videoElem = koishi_1.h.video(item.video);
@@ -624,8 +854,10 @@ function apply(ctx, config) {
                                 await sendTimeout(session, videoElem);
                             }
                             catch (error) {
-                                logger.error(`视频处理失败: ${getErrorMessage(error)}`);
-                                await sendTimeout(session, koishi_1.h.text(`视频处理失败：${getErrorMessage(error)}\n链接：${item.video}`));
+                                const errorMsg = getErrorMessage(error);
+                                const code = ErrorCode.VIDEO_DOWNLOAD_FAILED;
+                                logger.error(`[${code}] 视频处理失败: ${errorMsg}`);
+                                await sendTimeout(session, koishi_1.h.text(getErrorInfo(code, errorMsg) + `\n链接：${item.video}`));
                             }
                         }
                     }
@@ -633,8 +865,10 @@ function apply(ctx, config) {
                 }
             }
             catch (error) {
-                logger.error(`处理内容失败: ${getErrorMessage(error)}`);
-                await sendTimeout(session, `❌ 处理${item.type}内容失败: ${getErrorMessage(error)}`);
+                const errorMsg = getErrorMessage(error);
+                const code = ErrorCode.UNKNOWN_ERROR;
+                logger.error(`[${code}] 处理内容失败: ${errorMsg}`);
+                await sendTimeout(session, koishi_1.h.text(getErrorInfo(code, `处理${item.type}内容失败: ${errorMsg}`)));
             }
         }
         if (enableForward && forwardMessages.length) {
@@ -644,7 +878,9 @@ function apply(ctx, config) {
                 await sendTimeout(session, forwardMsg);
             }
             catch (error) {
-                logger.error(`合并转发失败: ${getErrorMessage(error)}`);
+                const errorMsg = getErrorMessage(error);
+                const code = ErrorCode.FORWARD_MESSAGE_FAILED;
+                logger.error(`[${code}] 合并转发失败: ${errorMsg}`);
                 for (const node of forwardMessages) {
                     await sendTimeout(session, node.data.content);
                     await delay(500);
@@ -687,21 +923,25 @@ function apply(ctx, config) {
     });
     ctx.command('parse <url>', '手动解析视频链接')
         .action(async ({ session }, url) => {
-        if (!url)
-            return '请输入视频链接';
+        if (!url) {
+            const code = ErrorCode.INVALID_URL;
+            return getErrorInfo(code, '请输入视频链接');
+        }
         let urls = extractUrl(url);
         if (urls.length === 0 && hasPlatformKeyword(url)) {
             const allLinks = url.match(/https?:\/\/[^\s\"\'\>\]]+/gi) || [];
             urls = allLinks.filter((u) => getPlatformType(u));
         }
-        if (urls.length === 0)
-            return '不支持该链接';
+        if (urls.length === 0) {
+            const code = ErrorCode.UNSUPPORTED_PLATFORM;
+            return getErrorInfo(code, '不支持该链接');
+        }
         await flush(session, urls);
     });
     ctx.command('clear-cache', '清空解析缓存与临时文件')
         .action(() => {
         clearAllCache();
-        return '✅ 解析缓存已清空';
+        return getErrorInfo(ErrorCode.SUCCESS, '解析缓存已清空');
     });
     setInterval(() => {
         const now = Date.now();
@@ -720,18 +960,24 @@ function apply(ctx, config) {
                 const stat = fs_1.default.statSync(path_1.default.join(tempDir, file));
                 if (now - stat.mtimeMs > 3600000) {
                     fs_1.default.unlinkSync(path_1.default.join(tempDir, file));
+                    logger.info(`清理过期临时文件: ${file}`);
                 }
             }
             catch (error) {
-                logger.error(`清理临时文件失败: ${file}, ${getErrorMessage(error)}`);
+                const errorMsg = getErrorMessage(error);
+                logger.error(`[${ErrorCode.UNKNOWN_ERROR}] 清理临时文件失败: ${file}, ${errorMsg}`);
             }
         });
     }, 1800000);
     if (config.autoClearCacheInterval > 0) {
         setInterval(() => {
             clearAllCache();
+            logger.info(getErrorInfo(ErrorCode.SUCCESS, '自动清理缓存完成'));
         }, config.autoClearCacheInterval * 60000);
     }
-    process.on('exit', clearAllCache);
-    logger.info('视频解析插件已加载');
+    process.on('exit', () => {
+        clearAllCache();
+        logger.info(getErrorInfo(ErrorCode.SUCCESS, '进程退出，已清理缓存'));
+    });
+    logger.info(getErrorInfo(ErrorCode.SUCCESS, '视频解析插件已加载'));
 }

package/package.json

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

package/readme.md

@@ -8,7 +8,6 @@
 - 🎨 自定义解析结果格式、返回内容类型（封面/链接/视频）
 - ⚡ 内置防重复解析、接口重试、自动缓存清理等实用功能
 - 📤 支持 OneBot 平台消息合并转发，优化展示体验
-- 🔌 内置多套解析 API，自动降级容错，提升解析成功率
 
 ### 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:
@@ -16,7 +15,6 @@ This is a **video parsing plugin** developed for the Koishi bot framework, suppo
 - 🎨 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
-- 🔌 Multiple built-in parsing APIs with automatic failover
 
 ## 项目仓库 (Repository)
 - GitHub: `https://github.com/Minecraft-1314/koishi-plugin-video-parser-all`
@@ -76,8 +74,6 @@ This is a **video parsing plugin** developed for the Koishi bot framework, suppo
 |----------------------|-------------------------|
 | Minecraft-1314 | 插件完整开发 (Complete plugin development) |
 | JH-Ahua | BugPk-Api 支持 |
-| 素颜API | 素颜API 支持 |
-| 星之阁API | 星之阁API 支持 |
 | （欢迎提交 PR 加入贡献者列表） | （Welcome to submit PR to join the contributor list） |
 
 ## 许可协议 (License)