koishi-plugin-music-parser-all 0.0.1

package/lib/index.d.ts

@@ -0,0 +1,142 @@
+import { Context, Schema } from 'koishi';
+declare module 'koishi' {
+    interface Context {
+        downloads?: {
+            download(url: string, dest: string, options?: Record<string, unknown>): Promise<string>;
+        };
+    }
+}
+export declare const name = "music-parser-all";
+export declare const Config: Schema<{
+    enable?: boolean | null | undefined;
+    botName?: string | null | undefined;
+    showWaitingTip?: boolean | null | undefined;
+    debug?: boolean | null | undefined;
+    platformEnabled?: ({
+        netease?: boolean | null | undefined;
+        kuwo?: boolean | null | undefined;
+        qqmusic?: boolean | null | undefined;
+        qishui?: boolean | null | undefined;
+    } & import("cosmokit").Dict) | null | undefined;
+} & import("cosmokit").Dict & {
+    unifiedMessageFormat?: string | null | undefined;
+} & {
+    showMusicText?: boolean | null | undefined;
+    showCoverImage?: boolean | null | undefined;
+    showMusicVoice?: boolean | null | undefined;
+    showMusicVoiceFile?: boolean | null | undefined;
+    forceDownloadMusicVoice?: boolean | null | undefined;
+    forceDownloadImage?: boolean | null | undefined;
+} & {
+    maxLyricLength?: number | null | undefined;
+    maxConcurrent?: number | null | undefined;
+    downloadConcurrency?: number | null | undefined;
+    mediaDownloadTimeout?: number | null | undefined;
+    maxMediaSize?: number | null | undefined;
+    downloadEngine?: "internal" | "aria2" | "downloads" | null | undefined;
+    aria2Host?: string | null | undefined;
+    aria2Port?: number | null | undefined;
+    aria2Secret?: string | null | undefined;
+    resumeDownload?: boolean | null | undefined;
+} & {
+    timeout?: number | null | undefined;
+    videoSendTimeout?: number | null | undefined;
+    userAgent?: string | null | undefined;
+    proxy?: ({
+        enabled?: boolean | null | undefined;
+        protocol?: "http" | "https" | null | undefined;
+        host?: string | null | undefined;
+        port?: number | null | undefined;
+        auth?: ({
+            username?: string | null | undefined;
+            password?: string | null | undefined;
+        } & import("cosmokit").Dict) | null | undefined;
+    } & import("cosmokit").Dict) | null | undefined;
+    customHeaders?: ({
+        name?: string | null | undefined;
+        value?: string | null | undefined;
+    } & import("cosmokit").Dict)[] | null | undefined;
+} & {
+    ignoreSendError?: boolean | null | undefined;
+    retryTimes?: number | null | undefined;
+    retryInterval?: number | null | undefined;
+    enableForward?: boolean | null | undefined;
+} & {
+    deduplicationInterval?: number | null | undefined;
+    cacheTTL?: number | null | undefined;
+    cacheDir?: string | null | undefined;
+} & {
+    waitingTipText?: string | null | undefined;
+    unsupportedPlatformText?: string | null | undefined;
+    invalidLinkText?: string | null | undefined;
+    parseErrorPrefix?: string | null | undefined;
+    parseErrorItemFormat?: string | null | undefined;
+}, {
+    enable: boolean;
+    botName: string;
+    showWaitingTip: boolean;
+    debug: boolean;
+    platformEnabled: Schemastery.ObjectT<{
+        netease: Schema<boolean, boolean>;
+        kuwo: Schema<boolean, boolean>;
+        qqmusic: Schema<boolean, boolean>;
+        qishui: Schema<boolean, boolean>;
+    }>;
+} & import("cosmokit").Dict & {
+    unifiedMessageFormat: string;
+} & {
+    showMusicText: boolean;
+    showCoverImage: boolean;
+    showMusicVoice: boolean;
+    showMusicVoiceFile: boolean;
+    forceDownloadMusicVoice: boolean;
+    forceDownloadImage: boolean;
+} & {
+    maxLyricLength: number;
+    maxConcurrent: number;
+    downloadConcurrency: number;
+    mediaDownloadTimeout: number;
+    maxMediaSize: number;
+    downloadEngine: "internal" | "aria2" | "downloads";
+    aria2Host: string;
+    aria2Port: number;
+    aria2Secret: string;
+    resumeDownload: boolean;
+} & {
+    timeout: number;
+    videoSendTimeout: number;
+    userAgent: string;
+    proxy: Schemastery.ObjectT<{
+        enabled: Schema<boolean, boolean>;
+        protocol: Schema<"http" | "https", "http" | "https">;
+        host: Schema<string, string>;
+        port: Schema<number, number>;
+        auth: Schema<Schemastery.ObjectS<{
+            username: Schema<string, string>;
+            password: Schema<string, string>;
+        }>, Schemastery.ObjectT<{
+            username: Schema<string, string>;
+            password: Schema<string, string>;
+        }>>;
+    }>;
+    customHeaders: Schemastery.ObjectT<{
+        name: Schema<string, string>;
+        value: Schema<string, string>;
+    }>[];
+} & {
+    ignoreSendError: boolean;
+    retryTimes: number;
+    retryInterval: number;
+    enableForward: boolean;
+} & {
+    deduplicationInterval: number;
+    cacheTTL: number;
+    cacheDir: string;
+} & {
+    waitingTipText: string;
+    unsupportedPlatformText: string;
+    invalidLinkText: string;
+    parseErrorPrefix: string;
+    parseErrorItemFormat: string;
+}>;
+export declare function apply(ctx: Context, config: any): void;

package/lib/index.js

@@ -0,0 +1,835 @@
+"use strict";
+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.apply = apply;
+const koishi_1 = require("koishi");
+const axios_1 = __importDefault(require("axios"));
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const promises_2 = require("stream/promises");
+const crypto_1 = require("crypto");
+class SimpleLRUCache {
+    constructor(max, ttlMs) {
+        this.max = max;
+        this.ttlMs = ttlMs;
+        this.map = new Map();
+    }
+    get(key) {
+        const entry = this.map.get(key);
+        if (!entry)
+            return undefined;
+        if (Date.now() > entry.expireAt) {
+            this.map.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    set(key, value) {
+        this.map.delete(key);
+        while (this.map.size >= this.max) {
+            const k = this.map.keys().next().value;
+            if (k === undefined)
+                break;
+            this.map.delete(k);
+        }
+        this.map.set(key, { value, expireAt: Date.now() + this.ttlMs });
+    }
+    clear() {
+        this.map.clear();
+    }
+}
+class ConcurrencyLimiter {
+    constructor(max) {
+        this.max = max;
+        this.running = 0;
+        this.queue = [];
+    }
+    async acquire() {
+        if (this.running < this.max) {
+            this.running++;
+            return;
+        }
+        return new Promise(resolve => {
+            this.queue.push(() => {
+                this.running++;
+                resolve();
+            });
+        });
+    }
+    release() {
+        this.running--;
+        const next = this.queue.shift();
+        if (next)
+            next();
+    }
+}
+exports.name = 'music-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('解析时显示等待提示'),
+        debug: koishi_1.Schema.boolean().default(false).description('开启调试日志'),
+        platformEnabled: koishi_1.Schema.object({
+            netease: koishi_1.Schema.boolean().default(true).description('网易云音乐'),
+            kuwo: koishi_1.Schema.boolean().default(true).description('酷我音乐'),
+            qqmusic: koishi_1.Schema.boolean().default(true).description('QQ音乐'),
+            qishui: koishi_1.Schema.boolean().default(true).description('汽水音乐'),
+        }).description('各平台解析开关'),
+    }).description('基本设置'),
+    koishi_1.Schema.object({
+        unifiedMessageFormat: koishi_1.Schema.string().role('textarea').default('歌名：${name}\n歌手：${artist}\n专辑：${album}\n音质：${level}\n歌词：${lyric}').description('文字格式，支持变量，空行自动隐藏'),
+    }).description('消息格式'),
+    koishi_1.Schema.object({
+        showMusicText: koishi_1.Schema.boolean().default(true).description('发送文字内容'),
+        showCoverImage: koishi_1.Schema.boolean().default(true).description('发送封面图片'),
+        showMusicVoice: koishi_1.Schema.boolean().default(false).description('音乐链接以语音形式发送'),
+        showMusicVoiceFile: koishi_1.Schema.boolean().default(true).description('音乐链接是否以语音形式发送（关闭则只发送链接）'),
+        forceDownloadMusicVoice: koishi_1.Schema.boolean().default(false).description('强制下载音乐语音'),
+        forceDownloadImage: koishi_1.Schema.boolean().default(false).description('强制下载封面图片'),
+    }).description('媒体发送与音乐语音'),
+    koishi_1.Schema.object({
+        maxLyricLength: koishi_1.Schema.number().min(0).step(1).default(500).description('歌词长度上限（0不限制）'),
+        maxConcurrent: koishi_1.Schema.number().min(1).step(1).default(3).description('解析最大并发数'),
+        downloadConcurrency: koishi_1.Schema.number().min(1).step(1).default(3).description('下载线程数'),
+        mediaDownloadTimeout: koishi_1.Schema.number().min(0).step(1).default(120000).description('统一下载超时 (ms)'),
+        maxMediaSize: koishi_1.Schema.number().min(0).step(1).default(0).description('最大下载文件大小 (MB)，0 为不限制'),
+        downloadEngine: koishi_1.Schema.union([
+            koishi_1.Schema.const('internal').description('内置下载'),
+            koishi_1.Schema.const('aria2').description('aria2 下载'),
+            koishi_1.Schema.const('downloads').description('downloads 服务下载'),
+        ]).default('internal').description('下载引擎'),
+        aria2Host: koishi_1.Schema.string().default('127.0.0.1').description('aria2 RPC 地址'),
+        aria2Port: koishi_1.Schema.number().default(6800).description('aria2 RPC 端口'),
+        aria2Secret: koishi_1.Schema.string().default('').description('aria2 RPC 密钥'),
+        resumeDownload: koishi_1.Schema.boolean().default(true).description('启用断点续传（仅 aria2 模式）'),
+    }).description('性能与限制'),
+    koishi_1.Schema.object({
+        timeout: koishi_1.Schema.number().min(0).step(1).default(180000).description('API 请求超时 (ms)'),
+        videoSendTimeout: koishi_1.Schema.number().min(0).step(1).default(180000).description('消息发送超时 (ms)'),
+        userAgent: koishi_1.Schema.string().default('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36').description('User-Agent'),
+        proxy: koishi_1.Schema.object({
+            enabled: koishi_1.Schema.boolean().default(false).description('启用代理'),
+            protocol: koishi_1.Schema.union([
+                koishi_1.Schema.const('http').description('HTTP'),
+                koishi_1.Schema.const('https').description('HTTPS'),
+            ]).default('http').description('协议'),
+            host: koishi_1.Schema.string().default('127.0.0.1').description('地址'),
+            port: koishi_1.Schema.number().default(7890).description('端口'),
+            auth: koishi_1.Schema.object({
+                username: koishi_1.Schema.string().default('').description('用户名'),
+                password: koishi_1.Schema.string().default('').description('密码'),
+            }).description('认证'),
+        }).description('HTTP/HTTPS 代理'),
+        customHeaders: koishi_1.Schema.array(koishi_1.Schema.object({
+            name: koishi_1.Schema.string().required().description('头名称'),
+            value: koishi_1.Schema.string().required().description('头值'),
+        })).default([]).description('自定义请求头'),
+    }).description('网络与请求'),
+    koishi_1.Schema.object({
+        ignoreSendError: koishi_1.Schema.boolean().default(true).description('忽略发送失败'),
+        retryTimes: koishi_1.Schema.number().min(0).step(1).default(3).description('重试次数'),
+        retryInterval: koishi_1.Schema.number().min(0).step(1).default(1000).description('重试间隔 (ms)'),
+        enableForward: koishi_1.Schema.boolean().default(false).description('合并转发（OneBot/Satori）'),
+    }).description('发送与重试'),
+    koishi_1.Schema.object({
+        deduplicationInterval: koishi_1.Schema.number().min(0).step(1).default(180).description('去重间隔 (s)'),
+        cacheTTL: koishi_1.Schema.number().min(0).step(1).default(600).description('缓存时间 (s)'),
+        cacheDir: koishi_1.Schema.string().default('./temp_cache_music').description('统一临时目录'),
+    }).description('缓存与临时文件'),
+    koishi_1.Schema.object({
+        waitingTipText: koishi_1.Schema.string().default('正在解析音乐，请稍候...').description('等待提示'),
+        unsupportedPlatformText: koishi_1.Schema.string().default('暂不支持该平台音乐链接').description('不支持提示'),
+        invalidLinkText: koishi_1.Schema.string().default('无效的音乐链接').description('无效链接提示'),
+        parseErrorPrefix: koishi_1.Schema.string().default('❌ 解析失败：').description('错误前缀'),
+        parseErrorItemFormat: koishi_1.Schema.string().default('【${url}】: ${msg}').description('错误格式'),
+    }).description('界面文本'),
+]);
+const logger = new koishi_1.Logger(exports.name);
+let debugEnabled = false;
+function debugLog(level, ...args) {
+    if (!debugEnabled)
+        return;
+    logger.info(`[${new Date().toISOString()}] [${level}] ${args.map(a => typeof a === 'object' ? JSON.stringify(a) : String(a)).join(' ')}`);
+}
+const BUILTIN_LINK_RULES = [
+    { pattern: /https?:\/\/(?:music\.163\.com\/(?:#\/)?song\?id=\d{3,}|163cn\.tv\/[A-Za-z0-9]+|y\.music\.163\.com\/m\/song\?id=\d{3,})[^\s]*/gi, type: 'netease' },
+    { pattern: /https?:\/\/www\.kuwo\.cn\/play_detail\/\d+[^\s]*/gi, type: 'kuwo' },
+    { pattern: /https?:\/\/y\.qq\.com\/n\/ryqq\/songDetail\/[A-Za-z0-9]+[^\s]*/gi, type: 'qqmusic' },
+    { pattern: /https?:\/\/i\.y\.qq\.com\/v8\/playsong\.html\?songid=\d+[^\s]*/gi, type: 'qqmusic' },
+    { pattern: /https?:\/\/qishui\.douyin\.com\/s\/[A-Za-z0-9]+[^\s]*/gi, type: 'qishui' },
+];
+function linkTypeParser(content, customRules = []) {
+    content = content.replace(/\\\//g, '/');
+    const allRules = [...BUILTIN_LINK_RULES, ...customRules];
+    const matches = [];
+    const seen = new Set();
+    for (const rule of allRules) {
+        let match;
+        rule.pattern.lastIndex = 0;
+        while ((match = rule.pattern.exec(content)) !== null) {
+            const url = match[0];
+            if (seen.has(url))
+                continue;
+            seen.add(url);
+            matches.push({ type: rule.type, url, id: match[1] || url });
+        }
+    }
+    return matches;
+}
+function extractAllUrlsFromMessage(session, customRules) {
+    const content = session.content?.trim() || '';
+    const matchedLinks = linkTypeParser(content, customRules);
+    const cardsContent = [];
+    if (session.elements) {
+        for (const elem of session.elements) {
+            if (elem.type === 'xml' && elem.data)
+                cardsContent.push(elem.data);
+            else if (elem.type === 'json' && elem.data) {
+                try {
+                    const json = JSON.parse(elem.data);
+                    const extract = (obj) => {
+                        if (!obj || typeof obj !== 'object')
+                            return;
+                        for (const val of Object.values(obj)) {
+                            if (typeof val === 'string')
+                                cardsContent.push(val);
+                            else if (typeof val === 'object')
+                                extract(val);
+                        }
+                    };
+                    extract(json);
+                }
+                catch { }
+            }
+        }
+    }
+    for (const cardContent of cardsContent) {
+        matchedLinks.push(...linkTypeParser(cardContent, customRules));
+    }
+    const seen = new Set();
+    const result = [];
+    for (const link of matchedLinks) {
+        if (!seen.has(link.url)) {
+            seen.add(link.url);
+            result.push(link);
+        }
+    }
+    return result;
+}
+function cleanUrl(url) {
+    try {
+        url = url.replace(/&amp;/g, '&');
+        const urlObj = new URL(url);
+        if (urlObj.protocol === 'http:')
+            urlObj.protocol = 'https:';
+        if (urlObj.hostname.includes('music.163.com') || urlObj.hostname.includes('163cn.tv')) {
+            ['userid', 'app_version', 'hdsuffix'].forEach(p => urlObj.searchParams.delete(p));
+            return urlObj.origin + urlObj.pathname + (urlObj.search ? '?' + urlObj.search : '');
+        }
+        return urlObj.toString();
+    }
+    catch {
+        return url.replace(/&amp;/g, '&').replace(/\?.*/, '');
+    }
+}
+const API_ENDPOINTS = {
+    netease: 'https://api.bugpk.com/api/163_music',
+    kuwo: 'https://api.bugpk.com/api/kuwo',
+    qqmusic: 'https://api.bugpk.com/api/qqmusic',
+    qishui: 'https://api.bugpk.com/api/qsmusic',
+};
+async function fetchMusicApi(type, url, config, http) {
+    const apiUrl = API_ENDPOINTS[type];
+    if (!apiUrl)
+        throw new Error(`不支持的平台: ${type}`);
+    const params = { url: cleanUrl(url) };
+    if (type === 'netease')
+        params.type = 'json';
+    const res = await http.get(apiUrl, { params });
+    if (res.data && (res.data.code === 200 || res.data.code === 0)) {
+        return res.data.data;
+    }
+    throw new Error(res.data?.msg || `API返回错误码: ${res.data?.code}`);
+}
+function parseMusicResponse(rawData, type, maxLyricLen) {
+    debugLog('DEBUG', `解析原始数据 [${type}]:`, rawData);
+    switch (type) {
+        case 'netease':
+            return {
+                type: 'netease',
+                name: rawData.name || '',
+                artist: rawData.ar_name || '',
+                album: rawData.al_name || '',
+                cover: rawData.pic || '',
+                musicUrl: rawData.url || '',
+                lyric: (rawData.lyric || '').slice(0, maxLyricLen),
+                level: rawData.level || '',
+                size: rawData.size || '',
+            };
+        case 'kuwo':
+            return {
+                type: 'kuwo',
+                name: rawData.title || '',
+                artist: rawData.artist || '',
+                album: rawData.album || '',
+                cover: rawData.pic || rawData.albumpic || '',
+                musicUrl: rawData.music_url || '',
+                lyric: (rawData.lyrics_url || '').slice(0, maxLyricLen),
+                level: '',
+                size: '',
+            };
+        case 'qqmusic':
+            return {
+                type: 'qqmusic',
+                name: rawData.name || '',
+                artist: rawData.author || '',
+                album: rawData.album || '',
+                cover: rawData.cover || '',
+                musicUrl: rawData.url || '',
+                lyric: (rawData.lrc_data || '').slice(0, maxLyricLen),
+                level: '',
+                size: '',
+            };
+        case 'qishui':
+            const cover = Array.isArray(rawData.artistsmedium_avatar_url) ? rawData.artistsmedium_avatar_url[0] : '';
+            return {
+                type: 'qishui',
+                name: rawData.albumname || '',
+                artist: rawData.artistsname || '',
+                album: rawData.albumname || '',
+                cover: cover,
+                musicUrl: rawData.url || '',
+                lyric: (rawData.lyric || '').slice(0, maxLyricLen),
+                level: rawData.Format || '',
+                size: rawData.Size || '',
+            };
+        default:
+            throw new Error('未知平台类型');
+    }
+}
+function generateFormattedText(p, format) {
+    const vars = {
+        name: p.name,
+        artist: p.artist,
+        album: p.album,
+        cover: p.cover,
+        music_url: p.musicUrl,
+        lyric: p.lyric,
+        level: p.level || '未知',
+        size: p.size || '未知',
+    };
+    const formatVarRegex = /\$\{([^}]+)\}/g;
+    const lines = format.split('\n');
+    const resultLines = [];
+    for (const line of lines) {
+        const varMatches = line.match(formatVarRegex);
+        if (varMatches && varMatches.length > 0) {
+            let allEmpty = true;
+            for (const match of varMatches) {
+                const varName = match.slice(2, -1);
+                const val = vars[varName];
+                if (val && val !== '0') {
+                    allEmpty = false;
+                    break;
+                }
+            }
+            if (allEmpty)
+                continue;
+        }
+        let newLine = line;
+        for (const [key, value] of Object.entries(vars)) {
+            newLine = newLine.replace(new RegExp(`\\$\\{${key}\\}`, 'g'), value);
+        }
+        resultLines.push(newLine);
+    }
+    return resultLines.join('\n').trim();
+}
+const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+function buildForwardNode(session, content, botName) {
+    let messageContent;
+    if (Array.isArray(content))
+        messageContent = content;
+    else if (content && typeof content === 'object' && content.type)
+        messageContent = [content];
+    else
+        messageContent = [koishi_1.h.text(String(content))];
+    return (0, koishi_1.h)('node', { user: { nickname: botName.substring(0, 15), user_id: session.selfId } }, messageContent);
+}
+function getErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (error && typeof error === 'object' && 'message' in error)
+        return String(error.message);
+    return String(error);
+}
+function apply(ctx, config) {
+    debugEnabled = config.debug || false;
+    debugLog('INFO', '音乐解析插件启动');
+    const dedupCache = new SimpleLRUCache(1000, config.deduplicationInterval * 1000);
+    const cacheTTL = (config.cacheTTL || 600) * 1000;
+    const urlCacheLocal = new SimpleLRUCache(500, cacheTTL);
+    const contentDedupCache = new SimpleLRUCache(1000, config.deduplicationInterval * 1000);
+    function contentFingerprint(p) {
+        return [p.type, p.name, p.artist, p.album, p.musicUrl].map(v => String(v ?? '')).join('::');
+    }
+    const texts = {
+        waitingTipText: config.waitingTipText || '正在解析音乐，请稍候...',
+        unsupportedPlatformText: config.unsupportedPlatformText || '暂不支持该平台音乐链接',
+        invalidLinkText: config.invalidLinkText || '无效的音乐链接',
+        parseErrorPrefix: config.parseErrorPrefix || '❌ 解析失败：',
+        parseErrorItemFormat: config.parseErrorItemFormat || '【${url}】: ${msg}',
+    };
+    const proxyConfig = config.proxy || {};
+    const cacheDir = config.cacheDir || './temp_cache_music';
+    const downloadLimiter = new ConcurrencyLimiter(config.downloadConcurrency || 3);
+    const mediaDownloadTimeout = config.mediaDownloadTimeout ?? 120000;
+    const maxMediaSize = config.maxMediaSize ?? 0;
+    const downloadEngine = config.downloadEngine || 'internal';
+    let aria2 = null;
+    if (downloadEngine === 'aria2') {
+        try {
+            const Aria2 = require('aria2');
+            aria2 = new Aria2({
+                host: config.aria2Host || '127.0.0.1',
+                port: config.aria2Port || 6800,
+                secure: false,
+                secret: config.aria2Secret || '',
+                path: '/jsonrpc'
+            });
+            aria2.open();
+            logger.info('aria2 连接成功');
+        }
+        catch (e) {
+            logger.warn('aria2 连接失败，回退到内置下载');
+        }
+    }
+    async function downloadFile(url, timeout, maxSize, filePrefix, fileExts) {
+        if (!url)
+            throw new Error('链接为空');
+        await promises_1.default.mkdir(cacheDir, { recursive: true });
+        const ext = fileExts.find(e => new RegExp('\\.' + e + '(\\?|$)', 'i').test(url)) || fileExts[0];
+        const fileName = `${filePrefix}_${Date.now()}_${(0, crypto_1.randomBytes)(4).toString('hex')}.${ext}`;
+        const filePath = path_1.default.resolve(cacheDir, fileName);
+        if (downloadEngine === 'downloads' && ctx.downloads) {
+            try {
+                const dest = await ctx.downloads.download(url, path_1.default.join(cacheDir, fileName), {
+                    headers: { 'User-Agent': config.userAgent },
+                    timeout
+                });
+                const stat = await promises_1.default.stat(dest);
+                if (maxSize > 0 && stat.size > maxSize * 1024 * 1024) {
+                    await promises_1.default.unlink(dest).catch(() => { });
+                    throw new Error(`文件过大(${Math.round(stat.size / 1024 / 1024)}MB)，超过限制(${maxSize}MB)`);
+                }
+                return dest;
+            }
+            catch (e) {
+                debugLog('ERROR', `downloads 下载失败，回退内置下载: ${getErrorMessage(e)}`);
+            }
+        }
+        else if (downloadEngine === 'aria2' && aria2 && config.resumeDownload) {
+            try {
+                const gid = await aria2.call('aria2.addUri', [url], {
+                    dir: cacheDir,
+                    out: fileName,
+                    split: 4,
+                    continue: true,
+                    maxConnectionPerServer: 5,
+                    timeout: timeout / 1000,
+                    maxFileNotFound: 5,
+                    maxTries: 5,
+                    retryWait: 2,
+                    header: [`User-Agent: ${config.userAgent}`, `Referer: https://www.baidu.com/`]
+                });
+                let completed = false;
+                const ariaStartTime = Date.now();
+                while (!completed) {
+                    if (Date.now() - ariaStartTime > timeout) {
+                        await aria2.call('aria2.remove', gid).catch(() => { });
+                        throw new Error('aria2下载超时');
+                    }
+                    const status = await aria2.call('aria2.tellStatus', gid);
+                    if (status.status === 'complete') {
+                        completed = true;
+                    }
+                    else if (status.status === 'error' || status.status === 'removed') {
+                        throw new Error('aria2下载失败');
+                    }
+                    else {
+                        await delay(1000);
+                    }
+                }
+                const stat = await promises_1.default.stat(filePath);
+                if (maxSize > 0 && stat.size > maxSize * 1024 * 1024) {
+                    await promises_1.default.unlink(filePath).catch(() => { });
+                    throw new Error(`文件过大(${Math.round(stat.size / 1024 / 1024)}MB)，超过限制(${maxSize}MB)`);
+                }
+                return filePath;
+            }
+            catch (e) {
+                debugLog('ERROR', `aria2下载失败，回退内置下载: ${getErrorMessage(e)}`);
+            }
+        }
+        const writer = (0, fs_1.createWriteStream)(filePath);
+        let response;
+        try {
+            response = await http({
+                method: 'GET',
+                url,
+                responseType: 'stream',
+                timeout,
+                headers: { 'User-Agent': config.userAgent, 'Referer': 'https://www.baidu.com/' },
+                maxRedirects: 5,
+                validateStatus: (status) => status >= 200 && status < 300,
+            });
+        }
+        catch (e) {
+            writer.destroy();
+            await promises_1.default.unlink(filePath).catch(() => { });
+            throw new Error(`下载失败: ${getErrorMessage(e)}`);
+        }
+        const maxSizeBytes = maxSize * 1024 * 1024;
+        const contentLength = Number(response.headers['content-length'] || 0);
+        if (maxSizeBytes > 0 && contentLength > maxSizeBytes) {
+            writer.destroy();
+            await promises_1.default.unlink(filePath).catch(() => { });
+            throw new Error(`文件过大(${Math.round(contentLength / 1024 / 1024)}MB)，超过限制(${maxSize}MB)`);
+        }
+        try {
+            await (0, promises_2.pipeline)(response.data, writer);
+            return filePath;
+        }
+        catch (e) {
+            await promises_1.default.unlink(filePath).catch(() => { });
+            throw new Error(`写入文件失败: ${getErrorMessage(e)}`);
+        }
+    }
+    async function sendMedia(session, url, type, forceDownload, showFile) {
+        if (!url)
+            return;
+        await downloadLimiter.acquire();
+        try {
+            const sendLink = async () => { await sendWithTimeout(session, `${type === 'audio' ? '音乐' : '封面'}链接：${url}`).catch(() => { }); };
+            const extMap = {
+                image: ['png', 'jpg', 'jpeg', 'gif', 'webp'],
+                audio: ['mp3', 'm4a', 'flac', 'wav', 'ogg', 'aac']
+            };
+            const prefixMap = { image: 'img', audio: 'music' };
+            const sendFunc = type === 'audio' ? koishi_1.h.audio : koishi_1.h.image;
+            if (forceDownload) {
+                try {
+                    const localPath = await downloadFile(url, mediaDownloadTimeout, maxMediaSize, prefixMap[type], extMap[type]);
+                    try {
+                        await sendWithTimeout(session, sendFunc(`file://${localPath}`));
+                    }
+                    finally {
+                        await promises_1.default.unlink(localPath).catch(() => { });
+                    }
+                    return;
+                }
+                catch (e) {
+                    debugLog('ERROR', `强制下载${type}失败，尝试URL发送:`, getErrorMessage(e));
+                    try {
+                        await sendWithTimeout(session, sendFunc(url));
+                    }
+                    catch {
+                        await sendLink();
+                    }
+                }
+                return;
+            }
+            if (!showFile) {
+                await sendLink();
+                return;
+            }
+            try {
+                await sendWithTimeout(session, sendFunc(url));
+            }
+            catch {
+                try {
+                    const localPath = await downloadFile(url, mediaDownloadTimeout, maxMediaSize, prefixMap[type], extMap[type]);
+                    try {
+                        await sendWithTimeout(session, sendFunc(`file://${localPath}`));
+                    }
+                    finally {
+                        await promises_1.default.unlink(localPath).catch(() => { });
+                    }
+                }
+                catch {
+                    await sendLink();
+                }
+            }
+        }
+        finally {
+            downloadLimiter.release();
+        }
+    }
+    async function flush(session, matches) {
+        debugLog('INFO', `开始解析 ${matches.length} 个链接`);
+        const items = [];
+        const errors = [];
+        const limiter = new ConcurrencyLimiter(config.maxConcurrent || 3);
+        const promises = matches.map(async (match) => {
+            await limiter.acquire();
+            try {
+                const platformEnabled = config.platformEnabled?.[match.type] ?? true;
+                if (!platformEnabled) {
+                    debugLog('INFO', `平台 ${match.type} 已禁用，跳过链接: ${match.url}`);
+                    return;
+                }
+                if (config.deduplicationInterval > 0) {
+                    const lastTime = dedupCache.get(match.url);
+                    if (lastTime && (Date.now() - lastTime < config.deduplicationInterval * 1000)) {
+                        debugLog('INFO', `跳过重复链接: ${match.url}`);
+                        const shortUrl = match.url.length > 50 ? match.url.slice(0, 50) + '...' : match.url;
+                        await sendWithTimeout(session, `链接 ${shortUrl} 在最近 ${config.deduplicationInterval} 秒内已解析过，已跳过。`).catch(() => { });
+                        return;
+                    }
+                }
+                debugLog('INFO', `解析链接: ${match.url} (${match.type})`);
+                const result = await processSingleUrl(match.url, match.type);
+                if (result.success) {
+                    if (config.deduplicationInterval > 0) {
+                        const fp = contentFingerprint(result.data.parsed);
+                        const lastDedup = contentDedupCache.get(fp);
+                        if (lastDedup && (Date.now() - lastDedup < config.deduplicationInterval * 1000)) {
+                            debugLog('INFO', `跳过重复内容: ${match.url}`);
+                            return;
+                        }
+                        contentDedupCache.set(fp, Date.now());
+                        dedupCache.set(match.url, Date.now());
+                    }
+                    items.push(result.data);
+                }
+                else {
+                    const item = texts.parseErrorItemFormat.replace(/\$\{url\}/g, match.url.length > 50 ? match.url.slice(0, 50) + '...' : match.url).replace(/\$\{msg\}/g, result.msg);
+                    errors.push(item);
+                }
+            }
+            finally {
+                limiter.release();
+            }
+        });
+        await Promise.all(promises);
+        if (errors.length)
+            await sendWithTimeout(session, `${texts.parseErrorPrefix}\n${errors.join('\n')}`);
+        if (!items.length)
+            return;
+        const enableForward = config.enableForward && (session.platform === 'onebot' || session.platform === 'satori');
+        const botName = config.botName || '音乐解析机器人';
+        if (enableForward) {
+            const forwardMessages = [];
+            for (const item of items) {
+                const p = item.parsed;
+                const text = item.text;
+                if (text && config.showMusicText)
+                    forwardMessages.push(buildForwardNode(session, text, botName));
+                if (p.cover && config.showCoverImage)
+                    forwardMessages.push(buildForwardNode(session, koishi_1.h.image(p.cover), botName));
+                if (p.musicUrl && config.showMusicVoice)
+                    forwardMessages.push(buildForwardNode(session, koishi_1.h.audio(p.musicUrl), botName));
+            }
+            if (forwardMessages.length) {
+                try {
+                    await sendWithTimeout(session, (0, koishi_1.h)('message', { forward: true }, forwardMessages.slice(0, 100)), config.retryTimes);
+                }
+                catch (err) {
+                    debugLog('ERROR', '合并转发失败，降级逐条发送:', err);
+                    for (const node of forwardMessages) {
+                        await sendWithTimeout(session, node.data.content).catch(() => { });
+                        await delay(300);
+                    }
+                }
+            }
+        }
+        else {
+            for (const item of items) {
+                const p = item.parsed;
+                const text = item.text;
+                if (text && config.showMusicText) {
+                    await sendWithTimeout(session, text);
+                    await delay(300);
+                }
+                if (p.cover && config.showCoverImage) {
+                    await sendMedia(session, p.cover, 'image', config.forceDownloadImage, true).catch(() => { });
+                    await delay(300);
+                }
+                if (p.musicUrl && config.showMusicVoice) {
+                    await sendMedia(session, p.musicUrl, 'audio', config.forceDownloadMusicVoice, config.showMusicVoiceFile).catch(() => { });
+                    await delay(500);
+                }
+            }
+        }
+        debugLog('INFO', '处理完成');
+    }
+    async function processSingleUrl(url, type) {
+        const cacheKey = url;
+        const cached = urlCacheLocal.get(cacheKey);
+        if (cached && cached.expire > Date.now()) {
+            const text = generateFormattedText(cached.data, config.unifiedMessageFormat);
+            return { success: true, data: { text, parsed: cached.data } };
+        }
+        for (let attempt = 0; attempt <= config.retryTimes; attempt++) {
+            try {
+                const data = await fetchMusicApi(type, url, config, http);
+                const parsed = parseMusicResponse(data, type, config.maxLyricLength);
+                urlCacheLocal.set(cacheKey, { data: parsed, expire: Date.now() + cacheTTL });
+                const text = generateFormattedText(parsed, config.unifiedMessageFormat);
+                return { success: true, data: { text, parsed } };
+            }
+            catch (error) {
+                const errMsg = getErrorMessage(error);
+                debugLog('ERROR', `解析尝试 ${attempt + 1} 失败: ${errMsg}`);
+                if (attempt < config.retryTimes)
+                    await delay(config.retryInterval);
+                else
+                    return { success: false, msg: errMsg, url };
+            }
+        }
+        return { success: false, msg: texts.unsupportedPlatformText, url };
+    }
+    async function sendWithTimeout(session, content, customRetries) {
+        const maxRetries = customRetries ?? config.retryTimes ?? 3;
+        const retryDelay = config.retryInterval || 1000;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                let sendPromise = session.send(content);
+                if (config.videoSendTimeout > 0) {
+                    const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('发送超时')), config.videoSendTimeout));
+                    return await Promise.race([sendPromise, timeoutPromise]);
+                }
+                else {
+                    return await sendPromise;
+                }
+            }
+            catch (err) {
+                const errMsg = getErrorMessage(err);
+                debugLog('ERROR', `发送失败尝试 ${attempt + 1}: ${errMsg}`);
+                if (attempt < maxRetries)
+                    await delay(retryDelay);
+                else if (!config.ignoreSendError)
+                    throw err;
+            }
+        }
+        return null;
+    }
+    const axiosConfig = {
+        timeout: config.timeout,
+        headers: {
+            'User-Agent': config.userAgent,
+            'Referer': 'https://www.baidu.com/',
+        }
+    };
+    if (proxyConfig.enabled && proxyConfig.host) {
+        axiosConfig.proxy = {
+            protocol: proxyConfig.protocol || 'http',
+            host: proxyConfig.host,
+            port: proxyConfig.port || 7890,
+            auth: proxyConfig.auth?.username ? {
+                username: proxyConfig.auth.username,
+                password: proxyConfig.auth.password || ''
+            } : undefined
+        };
+    }
+    const customHeaders = config.customHeaders || [];
+    const http = axios_1.default.create(axiosConfig);
+    http.interceptors.request.use((config) => {
+        for (const h of customHeaders) {
+            if (h.name && h.value)
+                config.headers[h.name] = h.value;
+        }
+        return config;
+    });
+    ctx.on('message', async (session) => {
+        if (!config.enable)
+            return;
+        if (/^\s*parse\b/i.test(session.content || ''))
+            return;
+        if (session.subtype === 'file_upload')
+            return;
+        if (session.elements?.some(elem => elem.type === 'file' || elem.type === 'folder'))
+            return;
+        if (session.selfId === session.userId)
+            return;
+        const matches = extractAllUrlsFromMessage(session, []);
+        if (!matches.length)
+            return;
+        debugLog('INFO', `检测到 ${matches.length} 个音乐链接`);
+        if (config.showWaitingTip) {
+            try {
+                await sendWithTimeout(session, texts.waitingTipText);
+            }
+            catch (e) {
+                debugLog('WARN', '等待提示发送失败:', e);
+            }
+        }
+        await flush(session, matches);
+    });
+    ctx.command('music <url>', '手动解析音乐').action(async ({ session }, url) => {
+        if (!url) {
+            await sendWithTimeout(session, texts.invalidLinkText);
+            return;
+        }
+        const matches = linkTypeParser(url, []);
+        if (!matches.length) {
+            await sendWithTimeout(session, texts.invalidLinkText);
+            return;
+        }
+        if (config.showWaitingTip) {
+            try {
+                await sendWithTimeout(session, texts.waitingTipText);
+            }
+            catch { }
+        }
+        await flush(session, matches);
+    });
+    const tempCleanupInterval = setInterval(async () => {
+        try {
+            const files = await promises_1.default.readdir(cacheDir);
+            const now = Date.now();
+            for (const file of files) {
+                if ((file.startsWith('music_') || file.startsWith('img_')) &&
+                    (file.match(/\.(mp3|m4a|flac|wav|ogg|aac|png|jpg|jpeg|gif|webp)$/i))) {
+                    const filePath = path_1.default.join(cacheDir, file);
+                    const stats = await promises_1.default.stat(filePath);
+                    if (now - stats.mtimeMs > 3600000) {
+                        await promises_1.default.unlink(filePath).catch(() => { });
+                    }
+                }
+            }
+        }
+        catch (e) {
+            if (e?.code !== 'ENOENT')
+                debugLog('WARN', '清理临时文件失败:', e);
+        }
+    }, 3600000);
+    ctx.on('dispose', () => {
+        clearInterval(tempCleanupInterval);
+        if (aria2)
+            aria2.close();
+        urlCacheLocal.clear();
+        dedupCache.clear();
+        debugLog('INFO', '音乐解析插件已卸载');
+    });
+    process.on('beforeExit', async () => {
+        try {
+            const files = await promises_1.default.readdir(cacheDir);
+            for (const file of files) {
+                if ((file.startsWith('music_') || file.startsWith('img_')) &&
+                    (file.match(/\.(mp3|m4a|flac|wav|ogg|aac|png|jpg|jpeg|gif|webp)$/i))) {
+                    await promises_1.default.unlink(path_1.default.join(cacheDir, file)).catch(() => { });
+                }
+            }
+        }
+        catch (e) {
+            if (e?.code !== 'ENOENT')
+                debugLog('WARN', '退出清理临时文件失败:', e);
+        }
+    });
+    debugLog('INFO', '音乐解析插件初始化完成');
+}

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "koishi-plugin-music-parser-all",
+  "description": "Koishi 全平台音乐解析插件，支持网易云音乐/酷我音乐/QQ音乐/汽水音乐等平台",
+  "version": "0.0.1",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w",
+    "clean": "rimraf lib"
+  },
+  "keywords": [
+    "chatbot",
+    "koishi",
+    "plugin",
+    "music",
+    "parser",
+    "netease",
+    "kuwo",
+    "qqmusic",
+    "qishui",
+    "音频解析",
+    "音乐解析",
+    "多平台",
+    "网易云音乐",
+    "酷我音乐",
+    "QQ音乐",
+    "汽水音乐"
+  ],
+  "devDependencies": {
+    "@koishijs/client": "^5.30.4",
+    "@koishijs/scripts": "^4.6.2",
+    "rimraf": "^5.0.5",
+    "typescript": "^5.3.3"
+  },
+  "dependencies": {
+    "axios": "^1.16.1"
+  },
+  "peerDependencies": {
+    "@koishijs/plugin-console": "^5.30.4",
+    "koishi": "^4.18.7",
+    "koishi-plugin-downloads": "^1.0.0",
+    "koishi-plugin-silk": "^1.0.0",
+    "koishi-plugin-ffmpeg": "^1.0.0",
+    "aria2": "^4.1.2"
+  },
+  "peerDependenciesMeta": {
+    "koishi-plugin-downloads": {
+      "optional": true
+    },
+    "koishi-plugin-silk": {
+      "optional": true
+    },
+    "koishi-plugin-ffmpeg": {
+      "optional": true
+    },
+    "aria2": {
+      "optional": true
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Minecraft-1314/koishi-plugin-music-parser-all.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Minecraft-1314/koishi-plugin-music-parser-all/issues"
+  },
+  "homepage": "https://github.com/Minecraft-1314/koishi-plugin-music-parser-all#readme",
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}

package/readme.md

@@ -0,0 +1,199 @@
+# koishi-plugin-video-parser-all
+
+## 项目介绍 (Project Introduction)
+
+### 中文
+这是一个为 Koishi 机器人框架开发的**全平台视频/图集解析插件**，使用统一API接口，支持自动识别并解析抖音、快手、B站、小红书、微博、YouTube、TikTok、剪映、AcFun、知乎、虎牙、绿洲、视频号等20+主流平台的短视频/图集/实况链接。
+
+### 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/live photo links from 20+ mainstream platforms such as Douyin, Kuaishou, Bilibili, Xiaohongshu, Weibo, YouTube, TikTok, Jianying, AcFun, Zhihu, Huya, Oasis, WeChat Channels and more.
+
+## 项目仓库 (Repository)
+- GitHub: `https://github.com/Minecraft-1314/koishi-plugin-video-parser-all`
+- Issues: `https://github.com/Minecraft-1314/koishi-plugin-video-parser-all/issues`
+
+## 核心指令 (Core Commands)
+
+| 指令 (Command) | 说明 (Description) | 示例 (Example) |
+|----------------|--------------------|----------------|
+| `parse <url>` | 手动解析指定的视频/图集链接 | `parse https://v.douyin.com/xxxx/` |
+
+## 配置项说明 (Configuration)
+
+### 基本设置
+| 配置项 | 类型 | 默认值 | 说明 |
+|--------|------|--------|------|
+| `enable` | boolean | true | 启用插件 |
+| `botName` | string | 视频解析机器人 | 合并转发中的昵称 |
+| `showWaitingTip` | boolean | true | 显示等待提示 |
+| `debug` | boolean | false | Debug 日志 |
+| `platformEnabled` | object | 全开 | 各平台开关 |
+
+### 消息格式
+| 配置项 | 类型 | 默认值 | 说明 |
+|--------|------|--------|------|
+| `unifiedMessageFormat` | string | 见预设 | 文字格式，支持变量，空行自动隐藏 |
+
+### 媒体发送
+| 配置项 | 类型 | 默认值 | 说明 |
+|--------|------|--------|------|
+| `showImageText` | boolean | true | 发送文字内容 |
+| `showCoverImage` | boolean | true | 发送封面图片 |
+| `showMusicCover` | boolean | true | 发送音乐封面 |
+| `showImageFile` | boolean | true | 封面/图片是否以图片形式发送（关闭则只发送链接） |
+| `showVideoFile` | boolean | true | 视频是否以视频形式发送（关闭则只发送链接） |
+| `forceDownloadImage` | boolean | false | 强制下载封面/图片 |
+| `forceDownloadVideo` | boolean | false | 强制下载视频 |
+
+### 音乐语音（需 silk 和 ffmpeg）
+| 配置项 | 类型 | 默认值 | 说明 |
+|--------|------|--------|------|
+| `showMusicVoice` | boolean | false | 音乐链接以语音发送 |
+| `showMusicVoiceFile` | boolean | true | 音乐链接是否以语音形式发送（关闭则只发送链接） |
+| `forceDownloadMusicVoice` | boolean | false | 强制下载音乐语音 |
+
+### 性能与限制
+| 配置项 | 类型 | 默认值 | 说明 |
+|--------|------|--------|------|
+| `maxDescLength` | number | 200 | 简介长度上限 |
+| `maxConcurrent` | number | 3 | 解析最大并发数 |
+| `downloadConcurrency` | number | 3 | 下载线程数 |
+| `mediaDownloadTimeout` | number | 120000 | 统一下载超时 (ms) |
+| `maxMediaSize` | number | 0 | 最大下载文件大小 (MB)，0 为不限制 |
+| `downloadEngine` | string | internal | 下载引擎（internal / aria2 / downloads） |
+| `aria2Host` | string | 127.0.0.1 | aria2 RPC 地址 |
+| `aria2Port` | number | 6800 | aria2 RPC 端口 |
+| `aria2Secret` | string |  | aria2 RPC 密钥 |
+| `resumeDownload` | boolean | true | 启用断点续传（仅 aria2） |
+
+### 网络与请求
+| 配置项 | 类型 | 默认值 | 说明 |
+|--------|------|--------|------|
+| `timeout` | number | 180000 | API 超时 (ms) |
+| `videoSendTimeout` | number | 180000 | 发送超时 (ms) |
+| `userAgent` | string | 见预设 | User-Agent |
+| `proxy` | object | ... | HTTP/HTTPS 代理 |
+| `customHeaders` | array | [] | 自定义请求头 |
+
+### 发送与重试
+| 配置项 | 类型 | 默认值 | 说明 |
+|--------|------|--------|------|
+| `ignoreSendError` | boolean | true | 忽略发送失败 |
+| `retryTimes` | number | 3 | 重试次数 |
+| `retryInterval` | number | 1000 | 重试间隔 (ms) |
+| `enableForward` | boolean | false | 合并转发（OneBot/Satori） |
+
+### 缓存与临时文件
+| 配置项 | 类型 | 默认值 | 说明 |
+|--------|------|--------|------|
+| `deduplicationInterval` | number | 180 | 去重间隔 (s) |
+| `cacheTTL` | number | 600 | 缓存时间 (s) |
+| `cacheDir` | string | ./temp_cache | 统一临时目录 |
+
+### API 与平台
+| 配置项 | 类型 | 默认值 | 说明 |
+|--------|------|--------|------|
+| `platformDedicatedFirst` | object | 全关 | 优先专属 API |
+| `customApis` | array | [] | 覆盖内置平台 API |
+| `customPlatforms` | array | [] | 自定义新平台 |
+| `globalFieldMapping` | string | 预设 | 全局字段映射 JSON |
+
+### 界面文本
+| 配置项 | 类型 | 默认值 | 说明 |
+|--------|------|--------|------|
+| `waitingTipText` | string | 正在解析... | 等待提示 |
+| `unsupportedPlatformText` | string | 不支持该平台 | 不支持提示 |
+| `invalidLinkText` | string | 无效链接 | 无效链接提示 |
+| `parseErrorPrefix` | string | ❌ 解析失败： | 错误前缀 |
+| `parseErrorItemFormat` | string | ... | 错误格式 |
+
+## 支持的变量 (Supported Variables)
+在 `unifiedMessageFormat` 中可使用以下变量，空行自动隐藏：
+
+| 变量名 | 说明 |
+|--------|------|
+| `${标题}` | 视频/图集标题 |
+| `${作者}` | 作者名称 |
+| `${简介}` | 内容简介 |
+| `${视频时长}` | 视频时长（时:分:秒） |
+| `${点赞数}` | 点赞数量 |
+| `${收藏数}` | 收藏数量 |
+| `${转发数}` | 转发/分享数量 |
+| `${播放数}` | 播放量 |
+| `${评论数}` | 评论数量 |
+| `${发布时间}` | 发布时间（格式化） |
+| `${图片数量}` | 图集/实况图片数量 |
+| `${作者ID}` | 作者唯一标识ID |
+| `${视频链接}` | 视频原始链接 |
+| `${音乐标题}` | 音乐标题 |
+| `${音乐作者}` | 音乐作者 |
+
+## 依赖说明 (Dependencies)
+### 音乐语音（可选）
+若启用 `showMusicVoice`，请安装：
+- `koishi-plugin-silk`：silk 编解码
+- `koishi-plugin-ffmpeg`：音频重采样
+### aria2 下载引擎（可选）
+若启用 `downloadEngine: 'aria2'`，请安装并启动 aria2 服务，并安装 npm 包 `aria2`：
+- 安装 aria2 服务端：https://github.com/aria2/aria2
+- 安装 npm 客户端：`npm install aria2`
+- 启动 RPC：`aria2c --enable-rpc --rpc-listen-all=true --rpc-allow-origin-all`
+未满足条件时自动降级为内置下载，不影响正常使用。
+### downloads 服务（可选）
+若启用 `downloadEngine: 'downloads'`，请安装可选依赖 `koishi-plugin-downloads`，失败时回退到内置下载。
+
+## 支持的平台 (Supported Platforms)
+| 平台名称 | 关键词识别 | 解析能力 |
+|----------|------------|----------|
+| 哔哩哔哩 (B站) | bilibili, b23.tv, bilibili.com | 视频 |
+| 抖音 | douyin, v.douyin.com | 短视频、图集、实况 |
+| 快手 | kuaishou, v.kuaishou.com | 短视频、图集 |
+| 小红书 | xiaohongshu, xhslink.com | 图文、视频 |
+| 微博 | weibo, video.weibo.com | 视频、图集 |
+| 剪映 / 即梦 | jianying, jimeng.jianying.com | 视频模板 |
+| 今日头条 / 西瓜视频 | toutiao, ixigua.com | 短视频 |
+| AcFun（A站） | acfun, acfun.cn | 视频 |
+| 知乎 | zhihu, zhihu.com | 视频、回答 |
+| 微视 | weishi, weishi.qq.com | 短视频 |
+| 虎牙 | huya, huya.com | 直播、视频 |
+| YouTube（油管） | youtube, youtu.be | 视频 |
+| TikTok（国际版抖音） | tiktok, tiktok.com | 短视频 |
+| 好看视频 | haokan, haokan.baidu.com | 短视频 |
+| 美拍 | meipai, meipai.com | 短视频 |
+| Twitter / X | twitter, x.com | 视频、图文 |
+| Instagram | instagram, instagram.com | 图文、Reels |
+| 豆包 | doubao (doubao.com/video) | 视频 |
+| 皮皮搞笑 | pipigx, h5.pipigx.com | 短视频 |
+| 皮皮虾 | pipixia, h5.pipix.com | 短视频 |
+| 最右 | zuiyou, xiaochuankeji.cn | 短视频 |
+| 梨视频 | video.li, pearvideo.com | 短视频 |
+| 全民直播 | quanmin (quanmin.tv) | 直播 |
+| 绿洲 (Oasis) | oasis.weibo.com | 视频、图文 |
+| 视频号 (WeChat Channels) | channels.weixin.qq.com, weixin.qq.com/sph/ | 短视频 |
+| 🔧 自定义平台 | 通过 `customPlatforms` 添加 | 取决于 API |
+
+## 项目贡献者 (Contributors)
+
+| 贡献者 (Contributor) | 贡献内容 (Contribution) |
+|----------------------|-------------------------|
+| Minecraft-1314 | 插件完整开发 (Complete plugin development) |
+| ShiraiKuroko003 | 修复消息格式设置问题并且PR-1.2.5版本已修复 |
+| cyavb | 提交功能建议-给自定义API添加KEY认证-已修复 |
+| Keep785 | 提交Bug-无法正常关闭发送封面-已修复<br>提交Bug-解析问题-已修复 |
+| dzt2008 + Apricityx | 提交Bug-会对非支持视频平台URL进行误解析-已修复 |
+| JH-Ahua | BugPk-Api 支持 |
+| shangxue | 灵感来源 |
+
+（欢迎通过 Issues 或 PR 加入贡献者列表）
+
+## 许可协议 (License)
+
+本项目采用 MIT 许可证，详情参见 [LICENSE](LICENSE) 文件。
+
+This project is licensed under the MIT License, see the [LICENSE](LICENSE) file for details.
+
+## 支持我们 (Support Us)
+
+如果这个项目对您有帮助，欢迎点亮右上角的 Star ⭐ 支持我们！
+
+If this project is helpful to you, please feel free to star it in the upper right corner ⭐ to support us!