koishi-plugin-video-parser-all 0.8.1 → 0.8.3

package/lib/index.d.ts

@@ -3,9 +3,6 @@ export declare const name = "video-parser-all";
 export declare const Config: Schema<{
     enable?: boolean | null | undefined;
     botName?: string | null | undefined;
-    showWaitingTip?: boolean | null | undefined;
-    waitingTipText?: string | null | undefined;
-    sameLinkInterval?: number | null | undefined;
     debug?: boolean | null | undefined;
     debugFile?: boolean | null | undefined;
 } & import("cosmokit").Dict & {
@@ -13,7 +10,7 @@ export declare const Config: Schema<{
 } & {
     showImageText?: boolean | null | undefined;
     showVideoFile?: boolean | null | undefined;
-} & {
+    sendLivePhotoVideos?: boolean | null | undefined;
     maxDescLength?: number | null | undefined;
 } & {
     timeout?: number | null | undefined;
@@ -32,12 +29,17 @@ export declare const Config: Schema<{
     messageBufferDelay?: number | null | undefined;
 } & {
     autoClearCacheInterval?: number | null | undefined;
+} & {
+    waitingTipText?: string | null | undefined;
+    duplicateLinkText?: string | null | undefined;
+    unsupportedPlatformText?: string | null | undefined;
+    invalidLinkText?: string | null | undefined;
+    cacheClearedText?: string | null | undefined;
+    parseErrorPrefix?: string | null | undefined;
+    parseErrorItemFormat?: string | null | undefined;
 }, {
     enable: boolean;
     botName: string;
-    showWaitingTip: boolean;
-    waitingTipText: string;
-    sameLinkInterval: number;
     debug: boolean;
     debugFile: boolean;
 } & import("cosmokit").Dict & {
@@ -45,7 +47,7 @@ export declare const Config: Schema<{
 } & {
     showImageText: boolean;
     showVideoFile: boolean;
-} & {
+    sendLivePhotoVideos: boolean;
     maxDescLength: number;
 } & {
     timeout: number;
@@ -64,5 +66,13 @@ export declare const Config: Schema<{
     messageBufferDelay: number;
 } & {
     autoClearCacheInterval: number;
+} & {
+    waitingTipText: string;
+    duplicateLinkText: string;
+    unsupportedPlatformText: string;
+    invalidLinkText: string;
+    cacheClearedText: string;
+    parseErrorPrefix: string;
+    parseErrorItemFormat: string;
 }>;
 export declare function apply(ctx: Context, config: any): void;

package/lib/index.js

@@ -10,54 +10,57 @@ const axios_1 = __importDefault(require("axios"));
 const crypto_1 = __importDefault(require("crypto"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const url_1 = require("url");
 const promises_1 = require("stream/promises");
 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).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('相同链接重复解析间隔（秒）'),
-        debug: koishi_1.Schema.boolean().default(false).description('开启调试模式'),
-        debugFile: koishi_1.Schema.boolean().default(false).description('调试日志写入文件'),
+        botName: koishi_1.Schema.string().default('视频解析机器人').description('合并转发消息中显示的机器人名称'),
+        debug: koishi_1.Schema.boolean().default(false).description('开启调试模式（详细日志输出至控制台）'),
+        debugFile: koishi_1.Schema.boolean().default(false).description('调试日志同时写入本地 debug.log 文件'),
     }).description('基础设置'),
     koishi_1.Schema.object({
-        unifiedMessageFormat: koishi_1.Schema.string().role('textarea').default(`标题：${'${标题}'}
-作者：${'${作者}'}
-点赞：${'${点赞数}'}
-链接：${'${视频链接}'}`).description('统一消息格式'),
-    }).description('统一消息格式'),
+        unifiedMessageFormat: koishi_1.Schema.string().role('textarea').default(`标题：\${标题}\n作者：\${作者}\n点赞：\${点赞数}\n视频链接：\${视频链接}`).description('统一消息格式，可用变量：${标题} ${作者} ${简介} ${视频时长} ${点赞数} ${收藏数} ${转发数} ${播放数} ${评论数} ${发布时间} ${图片数量} ${作者ID} ${视频链接} ${封面} ${音乐作者} ${音乐标题}'),
+    }).description('消息格式设置'),
     koishi_1.Schema.object({
-        showImageText: koishi_1.Schema.boolean().default(true).description('显示图文内容'),
-        showVideoFile: koishi_1.Schema.boolean().default(true).description('发送视频文件（关闭则只发链接）'),
+        showImageText: koishi_1.Schema.boolean().default(true).description('是否发送解析后的文字内容'),
+        showVideoFile: koishi_1.Schema.boolean().default(true).description('是否发送视频文件（关闭则只发送视频链接）'),
+        sendLivePhotoVideos: koishi_1.Schema.boolean().default(true).description('发送实况图集时是否附带短视频'),
+        maxDescLength: koishi_1.Schema.number().default(200).description('简介内容最大长度（字符），超出自动截断'),
     }).description('内容显示设置'),
     koishi_1.Schema.object({
-        maxDescLength: koishi_1.Schema.number().default(200).description('简介内容最大长度（字符）'),
-    }).description('内容长度限制'),
+        timeout: koishi_1.Schema.number().min(0).default(180000).description('API 请求超时（毫秒）'),
+        videoSendTimeout: koishi_1.Schema.number().min(0).default(60000).description('视频消息发送超时（毫秒，0 为不限制）'),
+        userAgent: koishi_1.Schema.string().default('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36').description('API 请求 UA'),
+    }).description('网络与 API 设置'),
     koishi_1.Schema.object({
-        timeout: koishi_1.Schema.number().min(0).default(180000).description('API请求超时时间（毫秒）'),
-        videoSendTimeout: koishi_1.Schema.number().min(0).default(60000).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).description('忽略发送失败错误'),
-        retryTimes: koishi_1.Schema.number().min(0).default(3).description('API请求重试次数'),
-        retryInterval: koishi_1.Schema.number().min(0).default(1000).description('重试间隔时间（毫秒）'),
+        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).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为不使用多线程）'),
+        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).description('消息缓冲延迟（毫秒）'),
-    }).description('消息处理设置'),
+    }).description('消息缓冲'),
+    koishi_1.Schema.object({
+        autoClearCacheInterval: koishi_1.Schema.number().min(0).default(0).description('自动清理缓存间隔（分钟，0 为关闭）'),
+    }).description('缓存清理'),
     koishi_1.Schema.object({
-        autoClearCacheInterval: koishi_1.Schema.number().min(0).default(0).description('自动清理缓存间隔（分钟，0为关闭）'),
-    }).description('缓存清理设置'),
+        waitingTipText: koishi_1.Schema.string().default('正在解析视频，请稍候...').description('解析等待提示'),
+        duplicateLinkText: koishi_1.Schema.string().default('请勿重复解析相同链接').description('重复链接提示'),
+        unsupportedPlatformText: koishi_1.Schema.string().default('不支持该平台链接').description('不支持的平台提示'),
+        invalidLinkText: koishi_1.Schema.string().default('无效的视频链接').description('无效链接提示（parse 指令）'),
+        cacheClearedText: koishi_1.Schema.string().default('✅ 缓存已清空').description('缓存清理提示'),
+        parseErrorPrefix: koishi_1.Schema.string().default('❌ 解析失败：').description('解析失败消息前缀'),
+        parseErrorItemFormat: koishi_1.Schema.string().default('【${url}】: ${msg}').description('每条解析失败格式，可用 ${url} ${msg}'),
+    }).description('界面文字设置'),
 ]);
 const processed = new Map();
 const linkBuffer = new Map();
@@ -111,7 +114,6 @@ const PLATFORM_KEYWORDS = {
     doubao: ['doubao', 'doubao.com'],
     jimeng: ['jimeng', 'jimeng.ai'],
 };
-const PLATFORM_TYPES = Object.keys(PLATFORM_KEYWORDS);
 function getErrorMessage(error) {
     if (error instanceof Error)
         return error.message;
@@ -262,96 +264,139 @@ async function resolveShortUrl(url) {
         return cleanUrl(url);
     }
 }
-function formatDuration(input) {
-    if (!input || input === 0 || input === '0' || input === '00:00')
+function formatDuration(seconds) {
+    if (!seconds || seconds <= 0)
         return '00:00:00';
-    if (typeof input === 'string') {
-        if (input.includes(':')) {
-            const parts = input.split(':');
-            if (parts.length === 2)
-                return `00:${parts[0].padStart(2, '0')}:${parts[1].padStart(2, '0')}`;
-            if (parts.length === 3)
-                return `${parts[0].padStart(2, '0')}:${parts[1].padStart(2, '0')}:${parts[2].padStart(2, '0')}`;
-            return '00:00:00';
-        }
-        input = Number(input);
-    }
-    const seconds = Math.floor(Number(input));
-    if (isNaN(seconds) || seconds <= 0 || seconds > 315360000)
-        return '00:00:00';
-    const hours = Math.floor(seconds / 3600);
-    const minutes = Math.floor((seconds % 3600) / 60);
-    const secs = Math.floor(seconds % 60);
-    return `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
+    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')}`;
 }
-function formatPublishTime(value) {
-    if (!value)
-        return '';
-    const str = String(value).trim();
-    if (value === 'ctime')
+function formatPublishTime(ms) {
+    if (!ms)
         return '';
-    if (/^\d{10}$/.test(str))
-        value = Number(str) * 1000;
-    if (/^\d{10,}$/.test(str) && Number(str) > 1e12) {
-        if (Number(str) > 1e15)
-            value = Number(str) / 1000;
+    const d = new Date(ms);
+    const y = d.getFullYear(), mo = (d.getMonth() + 1).toString().padStart(2, '0'), day = d.getDate().toString().padStart(2, '0'), H = d.getHours().toString().padStart(2, '0'), i = d.getMinutes().toString().padStart(2, '0');
+    return `${y}年${mo}月${day}日 ${H}:${i}`;
+}
+function pickBestQuality(videoBackup) {
+    if (!Array.isArray(videoBackup))
+        return [];
+    return videoBackup
+        .map(v => ({ quality: v.quality || v.label, url: v.url, bit_rate: v.bit_rate || 0 }))
+        .sort((a, b) => (b.bit_rate || 0) - (a.bit_rate || 0));
+}
+function parseApiResponse(raw, maxDescLen) {
+    debugLog('DEBUG', '原始API返回数据:', raw);
+    const data = raw?.data || {};
+    const extra = data.extra || {};
+    let type = data.type || '';
+    if (!type) {
+        if (data.images?.length > 0 && !data.url)
+            type = 'image';
+        else if (data.live_photo?.length > 0)
+            type = 'live_photo';
+        else if (raw.msg === 'live' || data.live)
+            type = 'live';
+        else
+            type = 'video';
     }
-    try {
-        const d = new Date(/^\d+$/.test(str) ? Number(str) : str);
-        if (isNaN(d.getTime()))
-            return str;
-        const y = d.getFullYear(), m = (d.getMonth() + 1).toString().padStart(2, '0'), d_ = d.getDate().toString().padStart(2, '0'), H = d.getHours().toString().padStart(2, '0'), i = d.getMinutes().toString().padStart(2, '0');
-        const parts = [];
-        if (y > 2000)
-            parts.push(`${y}年`);
-        if (m)
-            parts.push(`${m}月`);
-        if (d_)
-            parts.push(`${d_}日`);
-        if (H && i)
-            parts.push(`${H}:${i}`);
-        return parts.join(' ').trim();
+    const authorObj = data.author;
+    let author = '', uid = '', avatar = '';
+    if (typeof authorObj === 'object' && authorObj) {
+        author = authorObj.name || authorObj.author || '';
+        uid = String(authorObj.id || data.uid || '');
+        avatar = authorObj.avatar || data.avatar || '';
     }
-    catch {
-        return str;
+    else {
+        author = data.author || data.auther || '';
+        uid = String(data.uid || '');
+        avatar = data.avatar || '';
     }
-}
-function parseApiResponse(rawResponse) {
-    const data = rawResponse?.data || {};
-    return {
-        author: data.author || '',
-        uid: data.uid || '',
-        avatar: data.avatar || '',
-        like: Number(data.like) || 0,
-        time: Number(data.time) || 0,
-        title: data.title || '',
-        cover: data.cover || '',
-        url: data.url || '',
-        music: data.music ? {
-            author: data.music.author || '',
-            avatar: data.music.avatar || '',
-            title: data.music.title || ''
-        } : undefined
+    const title = data.title || '';
+    const desc = (data.desc || data.description || '').slice(0, maxDescLen);
+    const cover = data.cover || '';
+    let video = '';
+    let videos = [];
+    if (data.video_backup?.length) {
+        const bestQ = pickBestQuality(data.video_backup);
+        videos = bestQ;
+        video = bestQ[0]?.url || data.url || '';
+    }
+    else if (data.videos?.length) {
+        video = data.videos[0]?.url || '';
+        videos = data.videos.map((v) => ({ quality: v.accept?.[0] || 'unknown', url: v.url }));
+    }
+    else {
+        video = data.url || '';
+    }
+    const images = Array.isArray(data.images) ? data.images : [];
+    const live_photo = Array.isArray(data.live_photo) ? data.live_photo : [];
+    const music = {
+        title: data.music?.title || data.music?.name || '',
+        author: data.music?.author || data.music?.artist || '',
+        cover: data.music?.cover || '',
+        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);
+    let duration = 0;
+    if (data.duration) {
+        duration = typeof data.duration === 'string' ? parseInt(data.duration) : data.duration;
+        if (duration > 1000000)
+            duration = Math.floor(duration / 1000);
+    }
+    else if (extra.duration_ms) {
+        duration = Math.floor(extra.duration_ms / 1000);
+    }
+    let publishTime = 0;
+    if (data.time) {
+        publishTime = typeof data.time === 'number' ? data.time : parseInt(data.time);
+        if (publishTime < 1000000000000)
+            publishTime *= 1000;
+    }
+    else if (extra.create_time) {
+        publishTime = extra.create_time * 1000;
+    }
+    const result = {
+        type, title, desc, author, uid, avatar, cover,
+        video, videos, images, live_photo, music,
+        like, comment, collect, share, play,
+        duration, publishTime
+    };
+    debugLog('DEBUG', '解析后的数据:', result);
+    return result;
 }
-function generateFormattedText(info, config) {
-    const format = config.unifiedMessageFormat || `标题：${'${标题}'}\n作者：${'${作者}'}\n点赞：${'${点赞数}'}\n链接：${'${视频链接}'}`;
+function generateFormattedText(p, format) {
     const vars = {
-        '标题': info.title,
-        '作者': info.author,
-        '点赞数': String(info.like),
-        '作者ID': info.uid,
-        '视频链接': info.url,
-        '发布时间': info.time ? formatPublishTime(info.time) : '',
-        '封面': info.cover,
-        '音乐作者': info.music?.author || '',
-        '音乐封面': info.music?.avatar || '',
+        '标题': p.title,
+        '作者': p.author,
+        '简介': p.desc,
+        '视频时长': p.duration > 0 ? formatDuration(p.duration) : '',
+        '点赞数': String(p.like),
+        '收藏数': String(p.collect),
+        '转发数': String(p.share),
+        '播放数': String(p.play),
+        '评论数': String(p.comment),
+        '发布时间': p.publishTime ? formatPublishTime(p.publishTime) : '',
+        '图片数量': String(p.images.length || p.live_photo.length),
+        '作者ID': p.uid,
+        '视频链接': p.video,
+        '封面': p.cover,
+        '音乐作者': p.music.author || '',
+        '音乐标题': p.music.title || '',
     };
     let result = format;
     for (const [key, value] of Object.entries(vars)) {
-        result = result.replace(new RegExp('\\$\\{' + key + '\\}', 'g'), value);
+        result = result.replace(new RegExp(`\\$\\{${key}\\}`, 'g'), value);
     }
-    return result.replace(/^\s*\n/gm, '').trim();
+    const final = result.replace(/^\s*\n/gm, '').trim();
+    debugLog('DEBUG', '生成格式化文本:', final);
+    return final;
 }
 function clearAllCache() {
     processed.clear();
@@ -382,16 +427,27 @@ function buildForwardNode(session, content, botName) {
 function apply(ctx, config) {
     initDebug(config.debug, config.debugFile);
     debugLog('INFO', '插件初始化开始');
+    debugLog('INFO', '当前配置:', config);
+    const texts = {
+        waitingTipText: config.waitingTipText || '正在解析视频，请稍候...',
+        duplicateLinkText: config.duplicateLinkText || '请勿重复解析相同链接',
+        unsupportedPlatformText: config.unsupportedPlatformText || '不支持该平台链接',
+        invalidLinkText: config.invalidLinkText || '无效的视频链接',
+        cacheClearedText: config.cacheClearedText || '✅ 缓存已清空',
+        parseErrorPrefix: config.parseErrorPrefix || '❌ 解析失败：',
+        parseErrorItemFormat: config.parseErrorItemFormat || '【${url}】: ${msg}',
+    };
     clearAllCache();
     const http = axios_1.default.create({
         timeout: config.timeout,
         headers: {
-            'User-Agent': config.userAgent,
+            'User-Agent': config.userAgent || 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
             'Referer': 'https://www.baidu.com/',
             'Content-Type': 'application/x-www-form-urlencoded'
         }
     });
-    async function parseViaApi(url) {
+    async function fetchApi(url) {
+        debugLog('INFO', `调用API解析: ${url}`);
         for (let i = 0; i <= config.retryTimes; i++) {
             try {
                 const res = await http.get('https://api.bugpk.com/api/short_videos', {
@@ -399,8 +455,9 @@ function apply(ctx, config) {
                     timeout: config.timeout
                 });
                 debugLog('INFO', `API响应: code=${res.data?.code}, msg=${res.data?.msg}`);
+                debugLog('DEBUG', 'API完整响应:', res.data);
                 if (res.data && (res.data.code === 200 || res.data.code === 0)) {
-                    return parseApiResponse(res.data);
+                    return parseApiResponse(res.data, config.maxDescLength);
                 }
                 throw new Error(res.data?.msg || '解析失败');
             }
@@ -413,59 +470,53 @@ function apply(ctx, config) {
         throw new Error('API请求全部失败');
     }
     async function parseUrl(url) {
-        debugLog('INFO', `解析链接: ${url}`);
-        let realUrl = await resolveShortUrl(url);
-        realUrl = cleanUrl(realUrl);
-        debugLog('DEBUG', `实际URL: ${realUrl}`);
+        debugLog('INFO', `开始解析链接: ${url}`);
+        const realUrl = await resolveShortUrl(url);
+        debugLog('DEBUG', `重定向后的URL: ${realUrl}`);
         const platform = getPlatformType(realUrl);
         if (!platform) {
             debugLog('WARN', `不支持的平台: ${realUrl}`);
-            return { info: null, success: false, msg: '不支持该平台链接' };
+            return { success: false, msg: texts.unsupportedPlatformText };
         }
-        try {
-            const info = await parseViaApi(realUrl);
-            debugLog('INFO', `解析成功: ${info.title}`);
-            return { info, success: true, msg: '解析成功' };
-        }
-        catch (error) {
-            debugLog('ERROR', `解析失败: ${getErrorMessage(error)}`);
-            return { info: null, success: false, msg: getErrorMessage(error) };
+        const candidates = [url, realUrl];
+        let lastError = null;
+        for (const candidate of candidates) {
+            try {
+                const info = await fetchApi(candidate);
+                debugLog('INFO', `解析成功: ${info.title}`);
+                return { success: true, data: info };
+            }
+            catch (error) {
+                lastError = getErrorMessage(error);
+                debugLog('ERROR', `候选链接解析失败: ${candidate} => ${lastError}`);
+            }
         }
+        return { success: false, msg: lastError || '解析失败' };
     }
     async function processSingleUrl(session, url) {
+        debugLog('INFO', `处理单个URL: ${url}, 用户: ${session.userId}`);
         const hash = crypto_1.default.createHash('md5').update(url).digest('hex');
         const now = Date.now();
         const last = processed.get(hash);
         if (last && (now - last) < config.sameLinkInterval * 1000) {
             debugLog('WARN', `重复解析: ${url}`);
-            return { success: false, msg: '请勿重复解析相同链接' };
+            return { success: false, msg: texts.duplicateLinkText };
         }
         processed.set(hash, now);
         const result = await parseUrl(url);
-        if (!result.info)
-            return { success: false, msg: result.msg };
-        const text = generateFormattedText(result.info, config);
-        return {
-            success: true,
-            data: {
-                text,
-                cover: result.info.cover,
-                video: result.info.url,
-                music: result.info.music,
-                author: result.info.author,
-                uid: result.info.uid,
-                avatar: result.info.avatar,
-                like: result.info.like,
-                title: result.info.title
-            }
-        };
+        if (!result.success)
+            return result;
+        const text = generateFormattedText(result.data, config.unifiedMessageFormat);
+        return { success: true, data: { text, parsed: result.data } };
     }
     async function sendWithTimeout(session, content) {
+        debugLog('DEBUG', `发送消息: ${JSON.stringify(content)}`);
         if (config.videoSendTimeout <= 0) {
             try {
                 return await session.send(content);
             }
             catch (err) {
+                debugLog('ERROR', `发送消息失败: ${getErrorMessage(err)}`);
                 if (!config.ignoreSendError)
                     throw err;
                 return null;
@@ -478,6 +529,7 @@ function apply(ctx, config) {
             ]);
         }
         catch (err) {
+            debugLog('ERROR', `发送消息超时或失败: ${getErrorMessage(err)}`);
             if (!config.ignoreSendError)
                 throw err;
             return null;
@@ -494,79 +546,123 @@ function apply(ctx, config) {
         const items = [];
         const errors = [];
         for (const url of urls) {
-            const result = await processSingleUrl(session, url);
-            if (result.success)
-                items.push(result.data);
-            else
-                errors.push({ url, msg: result.msg });
+            const res = await processSingleUrl(session, 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);
+            }
         }
-        if (errors.length > 0) {
-            const errorMsg = `❌ 解析失败：\n${errors.map((e) => `【${e.url.slice(0, 50)}...】: ${e.msg}`).join('\n')}`;
-            await sendWithTimeout(session, errorMsg).catch(() => { });
+        if (errors.length) {
+            await sendWithTimeout(session, `${texts.parseErrorPrefix}\n${errors.join('\n')}`).catch(() => { });
             await delay(500);
         }
-        if (items.length === 0)
+        if (!items.length)
             return;
         const enableForward = config.enableForward && session.platform === 'onebot';
         const botName = config.botName || '视频解析机器人';
         const forwardMessages = [];
         for (const item of items) {
-            try {
-                if (enableForward) {
-                    if (item.text)
-                        forwardMessages.push(buildForwardNode(session, item.text, botName));
-                    if (item.cover)
-                        forwardMessages.push(buildForwardNode(session, koishi_1.h.image(item.cover), botName));
-                    if (item.video && config.showVideoFile) {
-                        if (config.downloadVideoBeforeSend) {
-                            const fname = crypto_1.default.createHash('md5').update(item.video).digest('hex');
-                            const dl = await downloadVideo(item.video, fname, config.userAgent, config.maxVideoSize, config.downloadThreads);
-                            if (dl.success)
-                                forwardMessages.push(buildForwardNode(session, koishi_1.h.file(dl.filePath), botName));
-                            else
-                                forwardMessages.push(buildForwardNode(session, koishi_1.h.video(item.video), botName));
+            const p = item.parsed;
+            const text = item.text;
+            debugLog('INFO', `开始发送内容，类型: ${p.type}, 标题: ${p.title}`);
+            if (text && config.showImageText) {
+                debugLog('DEBUG', '发送文本消息');
+                if (enableForward)
+                    forwardMessages.push(buildForwardNode(session, text, botName));
+                else {
+                    await sendWithTimeout(session, text);
+                    await delay(300);
+                }
+            }
+            if (p.cover && p.type !== 'live_photo') {
+                debugLog('DEBUG', '发送封面图片:', p.cover);
+                if (enableForward)
+                    forwardMessages.push(buildForwardNode(session, koishi_1.h.image(p.cover), botName));
+                else {
+                    await sendWithTimeout(session, koishi_1.h.image(p.cover)).catch(() => { });
+                    await delay(300);
+                }
+            }
+            if (p.video && config.showVideoFile && (p.type === 'video' || p.type === 'live')) {
+                const sendVideo = async () => {
+                    if (config.downloadVideoBeforeSend) {
+                        const fname = crypto_1.default.createHash('md5').update(p.video).digest('hex');
+                        const dl = await downloadVideo(p.video, fname, config.userAgent, config.maxVideoSize, config.downloadThreads);
+                        if (dl.success) {
+                            const fileUrl = (0, url_1.pathToFileURL)(dl.filePath).href;
+                            debugLog('INFO', `视频下载成功，发送文件: ${fileUrl}`);
+                            return koishi_1.h.file(fileUrl);
                         }
-                        else
-                            forwardMessages.push(buildForwardNode(session, koishi_1.h.video(item.video), botName));
                     }
+                    debugLog('INFO', `发送视频链接: ${p.video}`);
+                    return koishi_1.h.video(p.video);
+                };
+                if (enableForward) {
+                    const vMsg = await sendVideo();
+                    forwardMessages.push(buildForwardNode(session, vMsg, botName));
                 }
                 else {
-                    if (item.text) {
-                        await sendWithTimeout(session, item.text);
-                        await delay(300);
+                    try {
+                        const vMsg = await sendVideo();
+                        await sendWithTimeout(session, vMsg);
                     }
-                    if (item.cover) {
-                        await sendWithTimeout(session, koishi_1.h.image(item.cover)).catch(() => { });
-                        await delay(300);
+                    catch (e) {
+                        debugLog('ERROR', `发送视频失败: ${getErrorMessage(e)}，尝试直接发送链接`);
+                        try {
+                            await sendWithTimeout(session, koishi_1.h.video(p.video));
+                        }
+                        catch { }
                     }
-                    if (item.video && config.showVideoFile) {
+                    await delay(500);
+                }
+            }
+            if (p.type === 'image' || p.type === 'live_photo') {
+                const mediaList = [];
+                if (p.type === 'live_photo' && p.live_photo?.length) {
+                    debugLog('INFO', `发送实况图集，共 ${p.live_photo.length} 张`);
+                    for (const lp of p.live_photo) {
+                        if (lp.image)
+                            mediaList.push({ type: 'image', url: lp.image });
+                        if (lp.video && config.sendLivePhotoVideos)
+                            mediaList.push({ type: 'video', url: lp.video });
+                    }
+                }
+                else if (p.images?.length) {
+                    debugLog('INFO', `发送图集，共 ${p.images.length} 张`);
+                    p.images.forEach(url => mediaList.push({ type: 'image', url }));
+                }
+                if (enableForward) {
+                    for (const m of mediaList) {
+                        const msg = m.type === 'image' ? koishi_1.h.image(m.url) : koishi_1.h.video(m.url);
+                        forwardMessages.push(buildForwardNode(session, msg, botName));
+                    }
+                }
+                else {
+                    for (const m of mediaList) {
+                        debugLog('DEBUG', `发送${m.type}: ${m.url}`);
                         try {
-                            if (config.downloadVideoBeforeSend) {
-                                const fname = crypto_1.default.createHash('md5').update(item.video).digest('hex');
-                                const dl = await downloadVideo(item.video, fname, config.userAgent, config.maxVideoSize, config.downloadThreads);
-                                await sendWithTimeout(session, dl.success ? koishi_1.h.file(dl.filePath) : koishi_1.h.video(item.video));
-                            }
-                            else {
-                                await sendWithTimeout(session, koishi_1.h.video(item.video));
-                            }
+                            await sendWithTimeout(session, m.type === 'image' ? koishi_1.h.image(m.url) : koishi_1.h.video(m.url));
+                            await delay(200);
                         }
-                        catch {
-                            try {
-                                await sendWithTimeout(session, koishi_1.h.video(item.video));
-                            }
-                            catch { }
+                        catch (e) {
+                            debugLog('ERROR', `发送${m.type}失败: ${getErrorMessage(e)}`);
                         }
-                        await delay(500);
                     }
                 }
             }
-            catch (e) { }
         }
         if (enableForward && forwardMessages.length) {
+            debugLog('INFO', `合并转发消息，共 ${forwardMessages.length} 条`);
             try {
                 await sendWithTimeout(session, (0, koishi_1.h)('message', { forward: true }, forwardMessages.slice(0, 100)));
             }
-            catch {
+            catch (e) {
+                debugLog('ERROR', `合并转发失败，降级逐条发送: ${getErrorMessage(e)}`);
                 for (const node of forwardMessages) {
                     try {
                         await sendWithTimeout(session, node.data.content);
@@ -581,28 +677,33 @@ function apply(ctx, config) {
         if (!config.enable)
             return;
         const content = session.content?.trim() || '';
+        debugLog('INFO', `收到消息: "${content}"`);
         const urls = extractUrl(content);
-        if (!urls.length)
+        if (!urls.length) {
+            debugLog('DEBUG', '消息中未检测到平台链接');
             return;
+        }
+        debugLog('INFO', '检测到链接:', urls);
         if (config.showWaitingTip) {
             try {
-                await sendWithTimeout(session, config.waitingTipText);
+                await sendWithTimeout(session, texts.waitingTipText);
             }
             catch { }
         }
         await flush(session, urls);
     });
     ctx.command('parse <url>', '手动解析视频').action(async ({ session }, url) => {
+        debugLog('INFO', `手动解析指令: ${url}`);
         const us = extractUrl(url);
         if (!us.length) {
-            await sendWithTimeout(session, '无效的视频链接');
+            await sendWithTimeout(session, texts.invalidLinkText);
             return;
         }
         await flush(session, us);
     });
     ctx.command('clear-cache', '清空缓存').action(async ({ session }) => {
         clearAllCache();
-        await sendWithTimeout(session, '✅ 缓存已清空');
+        await sendWithTimeout(session, texts.cacheClearedText);
     });
     setInterval(() => {
         const now = Date.now();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-video-parser-all",
   "description": "Koishi 全平台视频解析插件，支持抖音/快手/B站/微博/小红书/剪映/YouTube/TikTok等20+平台",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [

package/readme.md

@@ -3,22 +3,24 @@
 ## 项目介绍 (Project Introduction)
 
 ### 中文
-这是一个为 Koishi 机器人框架开发的**全平台视频/图集解析插件**，使用统一API接口，支持自动识别并解析抖音、快手、B站、小红书、微博、YouTube、TikTok、剪映、AcFun、知乎、虎牙等20+主流平台的短视频/图集链接。核心特性：
+这是一个为 Koishi 机器人框架开发的**全平台视频/图集解析插件**，使用统一API接口，支持自动识别并解析抖音、快手、B站、小红书、微博、YouTube、TikTok、剪映、AcFun、知乎、虎牙等20+主流平台的短视频/图集/实况链接。核心特性：
 - 🌐 统一API解析，覆盖20+热门平台，无需繁琐配置
 - 🤖 自动识别链接来源，即丢即用
-- 🎨 完全自定义的解析结果格式，支持20+丰富变量替换
+- 🎨 完全自定义的解析结果格式，支持多项变量替换
 - 🐛 内置Debug调试模式，可详细记录所有操作与API交互日志
 - ⚡ 防重复解析、API重试、本地视频下载、多线程加速等实用功能
 - 📤 支持OneBot平台消息合并转发，优化多图文展示体验
+- 🧹 内置手动/自动双模式缓存清理，自动删除临时视频与冗余缓存
 
 ### 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
-- 🎨 Fully customizable parsing result format with 20+ variable substitutions
+- 🎨 Fully customizable parsing result format with variable substitutions
 - 🐛 Built-in Debug mode, recording detailed operations and API interaction logs
 - ⚡ Duplicate parsing prevention, API retry, local video download, multithread acceleration
 - 📤 Support OneBot message forwarding for better image/video display
+- 🧹 Manual & automatic cache cleaning, auto delete temporary videos and redundant cache
 
 ## 项目仓库 (Repository)
 - GitHub: `https://github.com/Minecraft-1314/koishi-plugin-video-parser-all`
@@ -54,6 +56,7 @@ This is a **multi-platform video/image parsing plugin** developed for the Koishi
 |--------|------|--------|------|
 | `showImageText` | boolean | true | 是否显示解析后的图文内容 |
 | `showVideoFile` | boolean | true | 是否发送视频文件（关闭则只发送视频链接） |
+| `sendLivePhotoVideos` | boolean | true | 是否发送实况图片附带的短视频（仅 live_photo 类型） |
 
 ### 内容长度限制
 | 配置项 | 类型 | 默认值 | 说明 |
@@ -92,38 +95,40 @@ This is a **multi-platform video/image parsing plugin** developed for the Koishi
 |--------|------|--------|------|
 | `autoClearCacheInterval` | number | 0 | 自动清理缓存间隔（分钟，0为关闭自动清理） |
 
+## 缓存机制说明 (Cache Mechanism)
+- 临时视频默认存放目录：项目根目录 `temp_videos`
+- 支持定时自动清空缓存、手动执行 `clear-cache` 一键清理
+- 自动清理过期解析记录、残留分段下载文件，避免磁盘占用
+
 ## 支持的变量 (Supported Variables)
 在 `unifiedMessageFormat` 中可使用以下变量进行自定义格式化：
 
 | 变量名 | 说明 | 适用平台 |
 |--------|------|----------|
 | `${标题}` | 视频/图集标题 | 所有平台 |
-| `${作者}` | 作者/UP主/发布者名称 | 所有平台 |
-| `${简介}` | 内容简介/描述 | 部分平台 |
-| `${视频时长}` | 视频时长 | 部分平台 |
+| `${作者}` | 作者/发布者名称 | 所有平台 |
+| `${简介}` | 内容简介/描述 | 所有平台 |
+| `${视频时长}` | 视频时长（时:分:秒） | 视频/实况 |
 | `${点赞数}` | 点赞数量 | 所有平台 |
-| `${投币数}` | 投币数量 | 部分平台 (B站) |
 | `${收藏数}` | 收藏数量 | 所有平台 |
 | `${转发数}` | 转发/分享数量 | 所有平台 |
 | `${播放数}` | 播放量 | 部分平台 |
 | `${评论数}` | 评论数量 | 所有平台 |
-| `${IP属地}` | 作者IP属地 | 部分平台 |
 | `${发布时间}` | 发布时间（格式化） | 所有平台 |
-| `${粉丝数}` | 作者粉丝数量 | 部分平台 |
-| `${在线人数}` | 直播间在线人数 | 部分平台 |
-| `${关注数}` | 关注数 | 部分平台 |
-| `${文件大小}` | 文件大小（MB） | 部分平台 |
-| `${直播间地址}` | 直播间链接 | 部分平台 |
-| `${直播间ID}` | 直播间ID | 部分平台 |
-| `${直播间状态}` | 直播间状态（直播中/未开播） | 部分平台 |
-| `${图片数量}` | 图集图片数量 | 部分平台 |
+| `${图片数量}` | 图集/实况图片数量 | 图集/实况 |
 | `${作者ID}` | 作者唯一标识ID | 部分平台 |
+| `${视频链接}` | 视频直链地址 | 视频/实况 |
+| `${封面}` | 封面图片地址 | 所有平台 |
+| `${音乐作者}` | 背景音乐作者 | 部分平台 |
+| `${音乐标题}` | 背景音乐标题 | 部分平台 |
+
+> 注：部分变量可能因平台API返回数据不同而显示为空，请根据实际情况自定义格式。
 
 ## 支持的平台 (Supported Platforms)
 | 平台名称 | 关键词识别 | 解析能力 |
 |----------|------------|----------|
-| 哔哩哔哩 (B站) | bilibili, b23.tv, bilibili.com | 视频、直播、图文 |
-| 抖音 | douyin, v.douyin.com | 短视频、图集 |
+| 哔哩哔哩 (B站) | bilibili, b23.tv, bilibili.com | 视频（不含番剧/直播/图文） |
+| 抖音 | douyin, v.douyin.com | 短视频、图集、实况 |
 | 快手 | kuaishou, v.kuaishou.com | 短视频、图集 |
 | 小红书 | xiaohongshu, xhslink.com | 图文、视频 |
 | 微博 | weibo, video.weibo.com | 视频、图集 |