koishi-plugin-share-links-analysis 0.7.2 → 0.8.0

package/lib/core.d.ts

@@ -1,6 +1,6 @@
 import { Context, Session } from 'koishi';
 import { Link, PluginConfig, ParsedInfo } from './types';
-export declare const parsers_str: ("bilibili" | "xiaohongshu" | "twitter" | "xiaoheihe")[];
+export declare const parsers_str: ("bilibili" | "xiaohongshu" | "twitter" | "xiaoheihe" | "youtube")[];
 /**
  * 从文本中解析出所有支持的链接
  * @param content 消息内容

package/lib/core.js

@@ -42,8 +42,9 @@ const Bilibili = __importStar(require("./parsers/bilibili"));
 const Xiaohongshu = __importStar(require("./parsers/xiaohongshu"));
 const Twitter = __importStar(require("./parsers/twitter"));
 const Xiaoheihe = __importStar(require("./parsers/xiaoheihe"));
+const Youtube = __importStar(require("./parsers/youtube"));
 // 定义所有支持的解析器
-const parsers = [Bilibili, Xiaohongshu, Twitter, Xiaoheihe];
+const parsers = [Bilibili, Xiaohongshu, Twitter, Xiaoheihe, Youtube];
 exports.parsers_str = parsers.map(p => p.name);
 /**
  * 从文本中解析出所有支持的链接
@@ -69,8 +70,7 @@ function resolveLinks(content) {
 async function processLink(ctx, config, link, session) {
     for (const parser of parsers) {
         if (parser.name == link.platform) {
-            if (config.logLevel == "full")
-                ctx.logger('share-links-analysis').info(`解析平台：${parser.name}，链接：${link.url}`);
+            ctx.logger('share-links-analysis').debug(`解析平台：${parser.name}，链接：${link.url}`);
             return await parser.process(ctx, config, link, session);
         }
     }

package/lib/index.js

@@ -1,11 +1,45 @@
 "use strict";
 // src/index.ts
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Config = exports.usage = exports.inject = exports.name = void 0;
 exports.apply = apply;
 const koishi_1 = require("koishi");
 const core_1 = require("./core");
 const utils_1 = require("./utils");
+const fs = __importStar(require("node:fs"));
 exports.name = 'share-links-analysis';
 exports.inject = {
     required: ['BiliBiliVideo', 'database', 'puppeteer'],
@@ -39,6 +73,11 @@ exports.Config = koishi_1.Schema.intersect([
         sendFiles: koishi_1.Schema.boolean().default(true).description("是否发送文件（视频等）"),
         sendLinks: koishi_1.Schema.boolean().default(false).description("是否附加直链（仅对合并发送有效）"),
     }).description("基础设置"),
+    koishi_1.Schema.object({
+        enableCache: koishi_1.Schema.boolean().default(true).description("开启缓存（包括解析结果缓存和资源文件缓存）"),
+        cacheExpiration: koishi_1.Schema.number().default(24).description("缓存过期时间（小时）。设置为 0 则不过期。"),
+        autoCleanInterval: koishi_1.Schema.number().default(1).description("自动清理过期缓存的检查间隔（小时）。"),
+    }).description("缓存设置"),
     koishi_1.Schema.object({
         format: koishi_1.Schema.string().role('textarea').default(`{title}
 {cover}
@@ -54,6 +93,9 @@ exports.Config = koishi_1.Schema.intersect([
         useNumeral: koishi_1.Schema.boolean().default(true).description("使用格式化数字 (如 10000 -> 1万)"),
         showError: koishi_1.Schema.boolean().default(false).description("当链接被阻止时提醒发送者"),
     }).description("高级解析设置"),
+    koishi_1.Schema.object({
+        youtubeCookie: koishi_1.Schema.string().role('textarea').description("[YouTube 专用] 手动填入 Cookie 字符串。使用已登录账号的 Cookie 可大幅降低被拦截概率。<br>获取方式：浏览器F12 -> 网络 -> 刷新YouTube首页 -> 查看请求头中的 `cookie` 字段。"),
+    }).description("YouTube 设置"),
     koishi_1.Schema.object({
         proxy: koishi_1.Schema.string().description("代理设置"),
         proxy_settings: koishi_1.Schema.object(Object.fromEntries(core_1.parsers_str.map(parser => [parser, koishi_1.Schema.boolean().default(false).description(`对${parser}使用代理`)]))),
@@ -68,22 +110,17 @@ exports.Config = koishi_1.Schema.intersect([
     }).description('跨环境路径映射设置'),
     koishi_1.Schema.object({
         userAgent: koishi_1.Schema.string().description("所有 API 请求所用的 User-Agent").default("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36"),
-        logLevel: koishi_1.Schema.union([
-            koishi_1.Schema.const('none').description('不记录'),
-            koishi_1.Schema.const('link_only').description('仅记录视频直链'),
-            koishi_1.Schema.const('full').description('记录完整调试信息'),
-        ]).role('radio').default('none').description("选择后台日志记录等级"),
+        debug: koishi_1.Schema.boolean().default(false).description("开启调试模式 (输出详细日志)"),
     }).description("调试设置"),
 ]);
 function apply(ctx, config) {
-    // @ts-ignore
+    // 数据库模型定义
     ctx.model.extend('sla_cookie_cache', {
         platform: 'string', // 平台名称，如 'xiaohongshu'
         cookie: 'text', // 存储的 cookie 字符串
     }, {
         primary: 'platform' // 使用平台名称作为主键
     });
-    // @ts-ignore
     ctx.model.extend('sla_group_settings', {
         guildId: 'string',
         custom_parsers: 'json',
@@ -91,6 +128,59 @@ function apply(ctx, config) {
     }, {
         primary: 'guildId',
     });
+    // 解析结果缓存
+    ctx.model.extend('sla_parse_cache', {
+        key: 'string', // platform + ':' + id
+        data: 'json',
+        created_at: 'double',
+    }, { primary: 'key' });
+    // 资源文件缓存 (hash)
+    ctx.model.extend('sla_file_cache', {
+        hash: 'string', // URL MD5
+        path: 'string', // 本地绝对路径
+        url: 'string',
+        created_at: 'double',
+    }, { primary: 'hash' });
+    const logger = ctx.logger('share-links-analysis');
+    // 根据配置设置日志等级
+    if (config.debug) {
+        logger.level = 3; // Debug Level
+    }
+    // 清理缓存函数
+    const cleanExpiredCache = async () => {
+        if (!config.enableCache || config.cacheExpiration <= 0)
+            return;
+        const now = Date.now();
+        const threshold = now - config.cacheExpiration * 60 * 60 * 1000;
+        // 清理解析缓存
+        await ctx.database.remove('sla_parse_cache', {
+            created_at: { $lt: threshold }
+        });
+        // 清理文件缓存
+        const expiredFiles = await ctx.database.get('sla_file_cache', {
+            created_at: { $lt: threshold }
+        });
+        for (const file of expiredFiles) {
+            try {
+                if (fs.existsSync(file.path)) {
+                    await fs.promises.unlink(file.path);
+                }
+            }
+            catch (e) {
+                logger.warn(`删除过期文件失败 ${file.path}: ${e}`);
+            }
+        }
+        await ctx.database.remove('sla_file_cache', {
+            created_at: { $lt: threshold }
+        });
+        if (expiredFiles.length > 0) {
+            logger.info(`已自动清理 ${expiredFiles.length} 个过期文件。`);
+        }
+    };
+    // 设置定时清理
+    if (config.enableCache && config.autoCleanInterval > 0) {
+        ctx.setInterval(cleanExpiredCache, config.autoCleanInterval * 60 * 60 * 1000);
+    }
     // 注册指令
     const cmd = ctx.command('share', '分享解析插件配置', { authority: 1 })
         .action(async ({ session }) => {
@@ -115,12 +205,9 @@ function apply(ctx, config) {
             if (!value)
                 return '请输入正确的模式';
             const mode = value.trim().toLowerCase() === 'true';
-            // @ts-ignore
             const data = await ctx.database.get('sla_group_settings', session.guildId);
-            // @ts-ignore
             const final_parsers = { ...data[0]?.custom_parsers, ...{ [parser]: mode } };
             const record = { guildId: session.guildId, custom_parsers: final_parsers };
-            // @ts-ignore
             await ctx.database.upsert('sla_group_settings', [record]);
         }
         await session.execute('share');
@@ -134,7 +221,6 @@ function apply(ctx, config) {
         if (value) {
             const mode = value.trim().toLowerCase() === 'true';
             const record = { guildId: session.guildId, nsfw_enabled: mode };
-            // @ts-ignore
             await ctx.database.upsert('sla_group_settings', [record]);
         }
         await session.execute('share');
@@ -145,11 +231,25 @@ function apply(ctx, config) {
             return '该指令只能在群组中使用。';
         if (!await (0, utils_1.isUserAdmin)(session, session.userId))
             return '权限不足';
-        // @ts-ignore
         await ctx.database.remove('sla_group_settings', { guildId: session.guildId });
         return '已重置为全局默认设置。';
     });
-    const logger = ctx.logger('share-links-analysis');
+    // 清除缓存指令
+    cmd.subcommand('.clean', '清除所有缓存和文件', { authority: 3 })
+        .action(async ({ session }) => {
+        await ctx.database.remove('sla_parse_cache', {});
+        const allFiles = await ctx.database.get('sla_file_cache', {});
+        for (const file of allFiles) {
+            try {
+                if (fs.existsSync(file.path)) {
+                    await fs.promises.unlink(file.path);
+                }
+            }
+            catch { }
+        }
+        await ctx.database.remove('sla_file_cache', {});
+        return '缓存及对应文件已清理。';
+    });
     const lastProcessedUrls = {};
     ctx.on('ready', async () => {
         logger.info('插件已启动，执行插件初始化');
@@ -168,8 +268,7 @@ function apply(ctx, config) {
             if (session.guildId) {
                 const settings = await (0, utils_1.getEffectiveSettings)(ctx, session.guildId, config);
                 if (!settings.parsers[link.platform]) {
-                    if (config.logLevel == "full")
-                        ctx.logger('share-links-analysis').info(`根据策略，该链接已被阻止解析：平台：${link.platform}，链接：${link.url}`);
+                    logger.debug(`根据策略，该链接已被阻止解析：平台：${link.platform}，链接：${link.url}`);
                     if (config.showError)
                         await session.send(`根据策略，该链接已被阻止解析：平台：${link.platform}`);
                     continue;
@@ -177,8 +276,7 @@ function apply(ctx, config) {
             }
             else {
                 if (!config.default_parsers[link.platform]) {
-                    if (config.logLevel == "full")
-                        ctx.logger('share-links-analysis').info(`根据策略，该链接已被阻止解析：平台：${link.platform}，链接：${link.url}`);
+                    logger.debug(`根据策略，该链接已被阻止解析：平台：${link.platform}，链接：${link.url}`);
                     if (config.showError)
                         await session.send(`根据策略，该链接已被阻止解析：平台：${link.platform}`);
                     continue;
@@ -192,36 +290,66 @@ function apply(ctx, config) {
             if (!lastProcessedUrls[channelId])
                 lastProcessedUrls[channelId] = {};
             if (now - (lastProcessedUrls[channelId][link.url] || 0) < config.Min_Interval * 1000) {
-                if (config.logLevel === 'full')
-                    logger.info(`链接 ${link.url} 在冷却时间内，跳过处理。`);
+                logger.debug(`链接 ${link.url} 在冷却时间内，跳过处理。`);
                 continue;
             }
             if (config.waitTip_Switch) {
                 await session.send(config.waitTip_Switch);
             }
-            const result = await (0, core_1.processLink)(ctx, config, link, session);
+            // === 缓存逻辑 ===
+            let result = null;
+            const cacheKey = `${link.platform}:${link.id}`;
+            if (config.enableCache) {
+                const cached = await ctx.database.get('sla_parse_cache', cacheKey);
+                // 检查是否存在且未过期
+                if (cached.length > 0) {
+                    const entry = cached[0];
+                    const isExpired = config.cacheExpiration > 0 && (Date.now() - entry.created_at > config.cacheExpiration * 60 * 60 * 1000);
+                    if (!isExpired) {
+                        logger.debug(`使用缓存解析结果: ${cacheKey}`);
+                        result = entry.data;
+                    }
+                    else {
+                        // 过期删除
+                        await ctx.database.remove('sla_parse_cache', { key: cacheKey });
+                    }
+                }
+            }
+            // 缓存未命中，执行解析
+            if (!result) {
+                result = await (0, core_1.processLink)(ctx, config, link, session);
+                // 写入缓存
+                if (result && config.enableCache) {
+                    await ctx.database.upsert('sla_parse_cache', [{
+                            key: cacheKey,
+                            data: result,
+                            created_at: Date.now()
+                        }]);
+                }
+            }
+            // === 缓存逻辑结束 ===
             if (result) {
                 lastProcessedUrls[channelId][link.url] = now;
-                await sendResult(session, config, result, logger);
+                await sendResult(ctx, session, config, result, logger);
             }
             linkCount++;
         }
     });
 }
-async function sendResult(session, config, result, logger) {
+async function sendResult(ctx, session, config, result, logger) {
     if (!session.channel) {
-        await (0, utils_1.sendResult_plain)(session, config, result, logger);
+        await (0, utils_1.sendResult_plain)(ctx, session, config, result, logger);
         return;
     }
     switch (config.useForward) {
         case "plain":
-            await (0, utils_1.sendResult_plain)(session, config, result, logger);
+            await (0, utils_1.sendResult_plain)(ctx, session, config, result, logger);
             return;
         case 'forward':
-            await (0, utils_1.sendResult_forward)(session, config, result, logger, false);
+            await (0, utils_1.sendResult_forward)(ctx, session, config, result, logger, false);
             return;
         case "mixed":
-            await (0, utils_1.sendResult_forward)(session, config, result, logger, true);
+            await (0, utils_1.sendResult_forward)(ctx, session, config, result, logger, true);
             return;
     }
 }

package/lib/parsers/bilibili.js

@@ -92,9 +92,7 @@ async function process(ctx, config, link, session) {
             if (locationHeader) {
                 finalUrl = locationHeader;
             }
-            else if (config.logLevel === 'full') {
-                logger.debug(`解析短链接时发生网络错误或未找到跳转地址: ${e.message}`);
-            }
+            logger.debug(`解析短链接时发生网络错误或未找到跳转地址: ${e.message}`);
         }
         if (finalUrl && (finalUrl.includes('b23.tv') || finalUrl.includes('bilibili.com/'))) {
             const urlObj = new URL(finalUrl);
@@ -122,8 +120,7 @@ async function process(ctx, config, link, session) {
             }
         }
         if (finalUrl) {
-            if (config.logLevel === 'full')
-                logger.info(`短链接解析成功，指向: ${finalUrl}`);
+            logger.debug(`短链接解析成功，指向: ${finalUrl}`);
             const matchedLinks = match(finalUrl);
             if (matchedLinks.length > 0 && matchedLinks[0].type === 'video') {
                 videoId = matchedLinks[0].id;
@@ -143,8 +140,7 @@ async function process(ctx, config, link, session) {
         logger.warn(`无法从链接 ${link.url} 中解析出有效的B站视频ID。`);
         return null;
     }
-    if (config.logLevel === 'full')
-        logger.info(`获取视频信息，ID: ${videoId}`);
+    logger.debug(`获取视频信息，ID: ${videoId}`);
     const idType = videoId.startsWith('BV') ? 'bvid' : 'aid';
     const infoUrl = `https://api.bilibili.com/x/web-interface/view?${idType}=${videoId}`;
     try {
@@ -158,14 +154,12 @@ async function process(ctx, config, link, session) {
         const data = info.data;
         // --- 获取视频直链 ---
         let videoUrl = null;
-        if (config.logLevel === 'full')
-            logger.info(`尝试获取视频流，bvid: ${data.bvid}`);
+        logger.debug(`尝试获取视频流，bvid: ${data.bvid}`);
         try {
             const videoStream = await ctx.BiliBiliVideo.getBilibiliVideoStream(data.aid, data.bvid, data.pages[0].cid, config.Video_ClarityPriority === '1' ? 32 : 80, 'html5', 1);
             if (videoStream?.data?.durl?.[0]?.url) {
                 videoUrl = videoStream.data.durl[0].url;
-                if (config.logLevel === 'full')
-                    logger.info(`成功获取视频流，bvid: ${data.bvid}`);
+                logger.debug(`成功获取视频流，bvid: ${data.bvid}`);
             }
         }
         catch (e) {

package/lib/parsers/twitter.js

@@ -68,7 +68,7 @@ async function process(ctx, config, link, session) {
         return null;
     }
     try {
-        logger.info(`🔍 解析推文: ${apiUrl}`);
+        logger.debug(`🔍 解析推文: ${apiUrl}`);
         const tweetData = await ctx.http.get(apiUrl, {
             headers: {
                 'User-Agent': config.userAgent,

package/lib/parsers/xiaohongshu.js

@@ -113,8 +113,7 @@ async function init(ctx, config) {
         const filteredCookies = finalCookies.filter((c) => c.name !== 'acw_tc');
         // 使用过滤后的 cookie 数组来生成字符串
         const cookieString = filteredCookies.map((c) => `${c.name}=${c.value}`).join('; ');
-        // @ts-ignore
-        await ctx.database.upsert('sla_cookie_cache', [{ platform: platformId, cookie: cookieString }]);
+        await ctx.database.upsert('sla_cookie_cache', [{ platform: exports.name, cookie: cookieString }]);
         logger.info('成功执行两步刷新策略并缓存了小红书 Cookie！');
         return true;
     }
@@ -145,22 +144,20 @@ async function process(ctx, config, link, session) {
         const decodedUrl = link.url.replace(/&/g, '&');
         const originalUrl = new URL(decodedUrl);
         token = originalUrl.searchParams.get('xsec_token');
-        if (token && config.logLevel === 'full') {
-            logger.info(`成功从分享链接中提取 xsec_token。`);
+        if (token) {
+            logger.debug(`成功从分享链接中提取 xsec_token。`);
         }
-        else if (config.logLevel === 'full') {
+        else {
             logger.debug(`分享链接中未找到 xsec_token: ${link.url}`);
         }
     }
     catch (e) {
-        if (config.logLevel === 'full')
-            logger.debug(`解析分享链接URL失败: ${link.url}`);
+        logger.debug(`解析分享链接URL失败: ${link.url}`);
     }
     let finalUrl = link.url;
     // 步骤二：如果是短链接，获取其跳转后的基础地址
     if (link.url.includes('xhslink.com')) {
-        if (config.logLevel === 'full')
-            logger.info(`小红书短链接解析：尝试获取 ${link.url} 的最终地址`);
+        logger.debug(`小红书短链接解析：尝试获取 ${link.url} 的最终地址`);
         try {
             await ctx.http(link.url, {
                 method: 'GET',
@@ -172,8 +169,7 @@ async function process(ctx, config, link, session) {
             const location = e.response?.headers?.location;
             if (location) {
                 finalUrl = location;
-                if (config.logLevel === 'full')
-                    logger.info(`短链接解析成功，跳转地址: ${finalUrl}`);
+                logger.debug(`短链接解析成功，跳转地址: ${finalUrl}`);
             }
             else {
                 logger.error(`解析短链接时发生网络错误: ${e.message}`);
@@ -198,12 +194,9 @@ async function process(ctx, config, link, session) {
         logger.error(`构建最终请求URL失败: ${finalUrl}`);
         return null;
     }
-    if (config.logLevel === 'full')
-        logger.info(`正在抓取小红书页面: ${urlToFetch}`);
+    logger.debug(`正在抓取小红书页面: ${urlToFetch}`);
     try {
-        // @ts-ignore
-        const dbCache = await ctx.database.get('sla_cookie_cache', platformId);
-        // @ts-ignore
+        const dbCache = await ctx.database.get('sla_cookie_cache', exports.name);
         let currentCookie = (dbCache && dbCache.length > 0) ? dbCache[0].cookie : '';
         const requestHeaders = {
             'User-Agent': config.userAgent,
@@ -236,14 +229,10 @@ async function process(ctx, config, link, session) {
         let coverUrl = undefined;
         const images = [];
         if (noteData.type === 'video' && noteData.video) {
-            if (config.logLevel === 'full') {
-                logger.info(`[XHS Video Debug] 发现视频笔记，视频数据对象: \n${JSON.stringify(noteData.video, null, 2)}`);
-            }
+            logger.debug(`[XHS Video Debug] 发现视频笔记，视频数据对象: \n${JSON.stringify(noteData.video, null, 2)}`);
             if (noteData.video.media?.stream?.h264?.[0]?.masterUrl) {
                 videoUrl = noteData.video.media.stream.h264[0].masterUrl;
-                if (config.logLevel === 'full') {
-                    logger.info(`[XHS Video Debug] 已提取视频链接: ${videoUrl}`);
-                }
+                logger.debug(`[XHS Video Debug] 已提取视频链接: ${videoUrl}`);
             }
             else {
                 logger.warn('[XHS Video Debug] 未能从预期路径 `note.video.media.stream.h264[0].masterUrl` 找到视频链接。');

package/lib/parsers/youtube.d.ts

@@ -0,0 +1,10 @@
+import { Context, Session } from 'koishi';
+import { Link, ParsedInfo, PluginConfig } from '../types';
+export declare const name = "youtube";
+export declare function match(content: string): Link[];
+/**
+ * 初始化：尝试获取 Cookie
+ * 策略：优先 Puppeteer (最稳)，失败则回退到 HTTP 请求 (利用插件自身的代理设置)
+ */
+export declare function init(ctx: Context, config: PluginConfig): Promise<boolean>;
+export declare function process(ctx: Context, config: PluginConfig, link: Link, session: Session): Promise<ParsedInfo | null>;

package/lib/parsers/youtube.js

@@ -0,0 +1,298 @@
+"use strict";
+// src/parsers/youtube.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.name = void 0;
+exports.match = match;
+exports.init = init;
+exports.process = process;
+const utils_1 = require("../utils");
+const ytdl_core_1 = __importDefault(require("@distube/ytdl-core"));
+exports.name = "youtube";
+// 匹配规则：支持普通视频、短链接 (youtu.be)、Shorts 以及 Embed 链接
+const linkRules = [
+    {
+        pattern: /https?:\/\/(?:www\.|m\.)?youtube\.com\/watch\?v=([\w-]{11})/gi,
+        type: "video",
+    },
+    {
+        pattern: /https?:\/\/youtu\.be\/([\w-]{11})/gi,
+        type: "video",
+    },
+    {
+        pattern: /https?:\/\/(?:www\.|m\.)?youtube\.com\/shorts\/([\w-]{11})/gi,
+        type: "shorts",
+    },
+    {
+        pattern: /https?:\/\/(?:www\.|m\.)?youtube\.com\/(?:v|embed)\/([\w-]{11})/gi,
+        type: "video",
+    }
+];
+function match(content) {
+    const results = [];
+    const seen = new Set();
+    for (const rule of linkRules) {
+        let match;
+        while ((match = rule.pattern.exec(content)) !== null) {
+            const id = match[1];
+            const url = `https://www.youtube.com/watch?v=${id}`;
+            if (seen.has(url))
+                continue;
+            seen.add(url);
+            results.push({
+                platform: exports.name,
+                type: rule.type,
+                id,
+                url,
+            });
+        }
+    }
+    return results;
+}
+/**
+ * 初始化：尝试获取 Cookie
+ * 策略：优先 Puppeteer (最稳)，失败则回退到 HTTP 请求 (利用插件自身的代理设置)
+ */
+async function init(ctx, config) {
+    const logger = ctx.logger('share-links-analysis:youtube');
+    // 1. 检查是否已配置手动 Cookie
+    if (config.youtubeCookie && config.youtubeCookie.trim().length > 0) {
+        logger.info('检测到配置文件中已填写手动 Cookie，将优先使用该 Cookie，跳过自动刷新。');
+        // 可选：将配置的 Cookie 同步到数据库，或者在 process 中直接读取配置
+        // 这里我们选择不写入数据库，而是每次 process 时直接读配置，方便用户随时修改
+        return true;
+    }
+    // 2. 自动获取逻辑 (仅当未配置手动 Cookie 时执行)
+    let cookieString = '';
+    // --- 策略 A: 尝试 Puppeteer (受全局 puppeteer 配置影响) ---
+    if (ctx.puppeteer) {
+        logger.info('尝试通过 Puppeteer 获取 Cookie...');
+        let page = null;
+        try {
+            page = await ctx.puppeteer.page();
+            await page.setUserAgent(config.userAgent);
+            // Puppeteer 只能走全局代理或 Chrome 参数代理，无法在这里动态设置
+            await page.goto('https://www.youtube.com', {
+                waitUntil: 'domcontentloaded',
+                timeout: 15000
+            });
+            // 尝试点击同意 (针对欧盟IP)
+            try {
+                const consentButton = await page.$('button[aria-label*="Accept"]');
+                if (consentButton)
+                    await consentButton.click();
+            }
+            catch (e) { }
+            const cookies = await page.cookies();
+            if (cookies.length > 0) {
+                cookieString = cookies.map((c) => `${c.name}=${c.value}`).join('; ');
+                logger.info(`Puppeteer 成功: 获取到 ${cookies.length} 个 Cookie`);
+            }
+        }
+        catch (error) {
+            logger.warn(`Puppeteer 获取失败: ${error.message}`);
+        }
+        finally {
+            if (page)
+                await page.close();
+        }
+    }
+    // --- 策略 B: 如果 Puppeteer 失败，尝试 HTTP 回退 (使用插件独立代理) ---
+    if (!cookieString) {
+        logger.info('尝试通过 HTTP 请求回退获取 Cookie...');
+        try {
+            // 构造请求头
+            const headers = {
+                'User-Agent': config.userAgent,
+                'Accept-Language': 'en-US,en;q=0.9',
+            };
+            // 创建一个专用的 http 实例，显式应用插件配置的 proxy
+            // 这样才能确保 request 走你在插件里填写的代理，而不是 Koishi 全局代理
+            const http = config.proxy
+                ? ctx.http.extend({ proxy: config.proxy })
+                : ctx.http;
+            const res = await http('https://www.youtube.com', {
+                method: 'HEAD',
+                headers: headers,
+                redirect: 'manual'
+            });
+            let setCookie = [];
+            // 兼容处理 Headers: 标准 API (Node 18+) 或 Polyfill
+            if (res.headers && typeof res.headers.getSetCookie === 'function') {
+                setCookie = res.headers.getSetCookie();
+            }
+            else if (res.headers && typeof res.headers.get === 'function') {
+                // 降级：部分环境可能没有 getSetCookie
+                const raw = res.headers.get('set-cookie');
+                if (raw)
+                    setCookie = [raw];
+            }
+            else if (res.headers && Array.isArray(res.headers['set-cookie'])) {
+                // 兼容旧版 axios 风格返回
+                setCookie = res.headers['set-cookie'];
+            }
+            if (setCookie && setCookie.length > 0) {
+                cookieString = setCookie.map(str => str.split(';')[0]).join('; ');
+                logger.info(`HTTP 回退成功: 获取到 Cookie 字符串`);
+            }
+            else {
+                logger.warn('HTTP 请求未返回 Set-Cookie 头');
+            }
+        }
+        catch (error) {
+            logger.warn(`HTTP 回退失败: ${error.message}`);
+        }
+    }
+    // --- 写入数据库 ---
+    if (cookieString) {
+        await ctx.database.upsert('sla_cookie_cache', [{ platform: exports.name, cookie: cookieString }]);
+        return true;
+    }
+    else {
+        logger.error('所有策略均失败，无法获取 YouTube Cookie。');
+        return false;
+    }
+}
+// 辅助函数：解析 Cookie 字符串
+function parseCookieString(cookieString) {
+    if (!cookieString)
+        return [];
+    return cookieString.split(';').map(pair => {
+        const parts = pair.split('=');
+        // 处理 value 中可能包含 = 的情况
+        const name = parts.shift();
+        const value = parts.join('=');
+        if (name && value)
+            return { name: name.trim(), value: value.trim() };
+        return null;
+    }).filter((c) => c !== null);
+}
+async function process(ctx, config, link, session) {
+    const logger = ctx.logger(`share-links-analysis:${exports.name}`);
+    const videoUrl = `https://www.youtube.com/watch?v=${link.id}`;
+    // 修复 2: 提升变量作用域，确保 catch 块能访问
+    let cookieString = '';
+    try {
+        // 1. 准备 Cookie
+        // 优先级：配置的手动 Cookie > 数据库缓存的自动 Cookie
+        if (config.youtubeCookie && config.youtubeCookie.trim().length > 0) {
+            cookieString = config.youtubeCookie.trim();
+            logger.debug('使用配置文件中的手动 Cookie。');
+        }
+        else {
+            const dbCache = await ctx.database.get('sla_cookie_cache', exports.name);
+            cookieString = (dbCache && dbCache.length > 0) ? dbCache[0].cookie : '';
+            if (cookieString)
+                logger.debug('使用数据库缓存的自动 Cookie。');
+        }
+        if (!cookieString) {
+            logger.debug('无 Cookie，将尝试裸连解析（风险较高）。');
+        }
+        else {
+            logger.debug('已加载 Cookie，准备解析。');
+        }
+        const cookies = parseCookieString(cookieString);
+        // 2. 创建 Agent (ytdl 专用)
+        // 无论 Puppeteer 是否有代理，这里必须使用插件配置的代理来请求视频流
+        let agent;
+        if (config.proxy) {
+            // 使用 createProxyAgent 同时处理 代理 和 Cookie
+            // 注意：@distube/ytdl-core 4.x+ 支持此方法
+            if (typeof ytdl_core_1.default.createProxyAgent === 'function') {
+                logger.debug(`使用代理: ${config.proxy}`);
+                agent = ytdl_core_1.default.createProxyAgent({ uri: config.proxy }, cookies);
+            }
+            else {
+                // 如果版本较旧没有 createProxyAgent，回退到普通 Agent (代理会失效)
+                logger.warn('ytdl.createProxyAgent 不存在，将忽略代理设置。请更新 @distube/ytdl-core');
+                agent = ytdl_core_1.default.createAgent(cookies);
+            }
+        }
+        else {
+            // 无代理，直接使用 createAgent
+            agent = ytdl_core_1.default.createAgent(cookies);
+        }
+        // 3. 获取视频信息
+        logger.debug(`正在解析 YouTube 视频: ${link.id}`);
+        // 尝试获取信息
+        // 为了提高成功率，我们允许 ytdl 尝试使用不同的内置客户端 (如 Android, iOS)
+        // 注意：@distube/ytdl-core 会自动处理客户端回退，但我们可以显式传参
+        const info = await ytdl_core_1.default.getInfo(videoUrl, {
+            agent, // 将正确的 Agent 传递给顶层选项
+            requestOptions: {
+                headers: {
+                    'User-Agent': config.userAgent,
+                    // 确保 headers 里也带上 Cookie，增加成功率
+                    'Cookie': cookieString
+                }
+            }
+        });
+        const details = info.videoDetails;
+        // 4. 提取元数据
+        const title = details.title;
+        const authorName = details.author.name;
+        const description = details.description || '';
+        // 获取最高分辨率的封面
+        const thumbnails = details.thumbnails;
+        const coverUrl = thumbnails.length > 0 ? thumbnails[thumbnails.length - 1].url : undefined;
+        const views = (0, utils_1.numeral)(parseInt(details.viewCount), config);
+        const likes = details.likes ? (0, utils_1.numeral)(details.likes, config) : '未知';
+        const statsString = `观看: ${views} | 点赞: ${likes}`;
+        // 5. 选择最佳视频流
+        // 优先寻找 MP4 封装且包含音视频的格式 (兼容性最好)
+        let format = ytdl_core_1.default.chooseFormat(info.formats, {
+            quality: 'highest',
+            filter: (f) => f.container === 'mp4' && f.hasAudio && f.hasVideo
+        });
+        // 如果找不到 MP4 合流，尝试任意音视频合流
+        if (!format) {
+            logger.debug('未找到 MP4 合流格式，尝试查找任意音视频合流...');
+            try {
+                format = ytdl_core_1.default.chooseFormat(info.formats, {
+                    quality: 'highest',
+                    filter: 'audioandvideo'
+                });
+            }
+            catch (e) { }
+        }
+        // 6. 构建文件列表
+        const files = [];
+        if (format && format.url) {
+            // 只有当存在有效链接时才添加
+            files.push({ type: 'video', url: format.url });
+        }
+        else {
+            logger.warn('未找到合适的视频流格式。');
+        }
+        // 7. 构建正文
+        const mainbody = (0, utils_1.escapeHtml)(description);
+        return {
+            platform: exports.name,
+            title: title,
+            authorName: authorName,
+            mainbody: mainbody,
+            coverUrl: coverUrl,
+            files: files,
+            sourceUrl: videoUrl,
+            stats: statsString,
+        };
+    }
+    catch (error) {
+        if (error.message.includes('Sign in') || error.message.includes('429')) {
+            const tip = cookieString
+                ? '当前 Cookie 可能已失效，请更新配置中的 Cookie。'
+                : '请在插件配置中填入已登录账号的 YouTube Cookie。';
+            await session.send(`YouTube 解析被拦截：${tip}`);
+            logger.warn(`解析拦截: ${error.message}`);
+        }
+        else if (error.message.includes('Private video')) {
+            await session.send('解析失败：私享视频。');
+        }
+        else {
+            logger.error(`解析异常: ${error.message}`);
+        }
+        return null;
+    }
+}

package/lib/types.d.ts

@@ -27,18 +27,22 @@ export interface PluginConfig {
     usingLocal: boolean;
     sendFiles: boolean;
     sendLinks: boolean;
+    enableCache: boolean;
+    cacheExpiration: number;
+    autoCleanInterval: number;
     format: string;
     parseLimit: number;
     useNumeral: boolean;
     showError: boolean;
+    youtubeCookie?: string;
     proxy: string;
-    proxy_settings: object;
-    default_parsers: object;
+    proxy_settings: Record<string, boolean>;
+    default_parsers: Record<string, boolean>;
     allow_sensitive: boolean;
     onebotReadDir: string;
     localDownloadDir: string;
     userAgent: string;
-    logLevel: 'none' | 'link_only' | 'full';
+    debug: boolean;
 }
 export interface BilibiliVideoInfo {
     data: {
@@ -79,6 +83,32 @@ declare module 'koishi' {
         BiliBiliVideo: any;
         puppeteer?: any;
     }
+    interface Tables {
+        sla_parse_cache: SlaParseCache;
+        sla_file_cache: SlaFileCache;
+        sla_cookie_cache: SlaCookieCache;
+        sla_group_settings: SlaGroupSettings;
+    }
+}
+export interface SlaParseCache {
+    key: string;
+    data: ParsedInfo;
+    created_at: number;
+}
+export interface SlaFileCache {
+    hash: string;
+    path: string;
+    url: string;
+    created_at: number;
+}
+export interface SlaCookieCache {
+    platform: string;
+    cookie: string;
+}
+export interface SlaGroupSettings {
+    guildId: string;
+    custom_parsers: Record<string, boolean>;
+    nsfw_enabled: boolean;
 }
 export interface XhsImageInfo {
     imageScene: string;

package/lib/utils.d.ts

@@ -1,5 +1,8 @@
 import { ParsedInfo, PluginConfig } from './types';
 import { Context, Logger, Session } from "koishi";
+import { Agent as HttpAgent } from 'http';
+import { Agent as HttpsAgent } from 'https';
+import 'koishi-plugin-adapter-onebot';
 /**
  * 将数字格式化为易读的字符串（如 万、亿）
  * @param num 数字
@@ -9,11 +12,12 @@ import { Context, Logger, Session } from "koishi";
 export declare function numeral(num: number, config: PluginConfig): string;
 export declare function escapeHtml(str: string): string;
 export declare function unescapeHtml(str: string): string;
+export declare function getProxyAgent(proxy: string | undefined, url: string): HttpAgent | HttpsAgent | undefined;
 export declare function getFileSize(url: string, proxy: string | undefined, userAgent: string | undefined, logger: Logger): Promise<number | null>;
 export declare function getEffectiveSettings(ctx: Context, guildId: string | undefined, config: PluginConfig): Promise<{
-    parsers: any;
-    nsfw: any;
+    parsers: Record<string, boolean>;
+    nsfw: boolean;
 }>;
 export declare function isUserAdmin(session: Session, userId: string): Promise<boolean>;
-export declare function sendResult_plain(session: Session, config: PluginConfig, result: ParsedInfo, logger: Logger): Promise<void>;
-export declare function sendResult_forward(session: Session, config: PluginConfig, result: ParsedInfo, logger: Logger, mixed_sending?: boolean): Promise<void>;
+export declare function sendResult_plain(ctx: Context, session: Session, config: PluginConfig, result: ParsedInfo, logger: Logger): Promise<void>;
+export declare function sendResult_forward(ctx: Context, session: Session, config: PluginConfig, result: ParsedInfo, logger: Logger, mixed_sending?: boolean): Promise<void>;

package/lib/utils.js

@@ -39,6 +39,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.numeral = numeral;
 exports.escapeHtml = escapeHtml;
 exports.unescapeHtml = unescapeHtml;
+exports.getProxyAgent = getProxyAgent;
 exports.getFileSize = getFileSize;
 exports.getEffectiveSettings = getEffectiveSettings;
 exports.isUserAdmin = isUserAdmin;
@@ -53,6 +54,8 @@ const url_1 = require("url");
 const http_proxy_agent_1 = require("http-proxy-agent");
 const https_proxy_agent_1 = require("https-proxy-agent");
 const fs = __importStar(require("node:fs"));
+const crypto_1 = require("crypto");
+require("koishi-plugin-adapter-onebot");
 /**
  * 将数字格式化为易读的字符串（如 万、亿）
  * @param num 数字
@@ -122,14 +125,50 @@ function parseHtmlToSegments(html) {
     }
     return segments;
 }
-async function downloadAndMapUrl(url, proxy, userAgent, localDownloadDir, onebotReadDir, logger) {
+async function downloadAndMapUrl(ctx, url, proxy, userAgent, localDownloadDir, onebotReadDir, logger, enableCache) {
     await fs.promises.mkdir(localDownloadDir, { recursive: true });
+    // 1. 计算 Hash
+    const hash = (0, crypto_1.createHash)('md5').update(url).digest('hex');
     const u = new url_1.URL(url);
     const ext = path_1.default.extname(u.pathname).split('?')[0] || '.bin';
-    const safeFilename = `${Date.now()}_${Math.random().toString(36).substring(2, 10)}${ext}`;
+    // 如果开启缓存，先查库
+    if (enableCache) {
+        try {
+            const cached = await ctx.database.get('sla_file_cache', hash);
+            if (cached.length > 0) {
+                const cachedPath = cached[0].path;
+                if (fs.existsSync(cachedPath)) {
+                    const filename = path_1.default.basename(cachedPath);
+                    const onebotPath = path_1.default.posix.join(onebotReadDir, filename);
+                    logger.debug(`缓存命中: ${url} -> ${cachedPath}`);
+                    return `file://${onebotPath}`;
+                }
+                else {
+                    // 数据库有记录但文件不存在，删除记录
+                    await ctx.database.remove('sla_file_cache', { hash });
+                }
+            }
+        }
+        catch (e) {
+            logger.warn(`读取文件缓存失败，将重新下载: ${e}`);
+        }
+    }
+    // 2. 生成文件名 (使用 Hash 以实现去重)
+    const safeFilename = `${hash}${ext}`;
     const actualPath = path_1.default.join(localDownloadDir, safeFilename);
     const onebotPath = path_1.default.posix.join(onebotReadDir, safeFilename);
     const fileUrl = `file://${onebotPath}`;
+    // 3. 检查本地文件是否存在 (双重保险，或者应对未清理的情况)
+    if (enableCache && fs.existsSync(actualPath)) {
+        // 补写数据库
+        await ctx.database.upsert('sla_file_cache', [{
+                hash,
+                path: actualPath,
+                url,
+                created_at: Date.now()
+            }]);
+        return fileUrl;
+    }
     return new Promise((resolve, reject) => {
         const agent = getProxyAgent(proxy, url);
         const headers = {
@@ -144,7 +183,7 @@ async function downloadAndMapUrl(url, proxy, userAgent, localDownloadDir, onebot
             if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
                 req.destroy();
                 logger.debug(`重定向: ${url} -> ${res.headers.location}`);
-                downloadAndMapUrl(res.headers.location, proxy, userAgent, localDownloadDir, onebotReadDir, logger)
+                downloadAndMapUrl(ctx, res.headers.location, proxy, userAgent, localDownloadDir, onebotReadDir, logger, enableCache)
                     .then(resolve)
                     .catch(reject);
                 return;
@@ -163,8 +202,22 @@ async function downloadAndMapUrl(url, proxy, userAgent, localDownloadDir, onebot
             }
             const pipelineAsync = (0, util_1.promisify)(stream_1.pipeline);
             pipelineAsync(res, (0, fs_1.createWriteStream)(actualPath))
-                .then(() => {
+                .then(async () => {
                 logger.debug(`下载成功: ${url} -> ${fileUrl}`);
+                // 下载成功，写入数据库缓存
+                if (enableCache) {
+                    try {
+                        await ctx.database.upsert('sla_file_cache', [{
+                                hash,
+                                path: actualPath,
+                                url,
+                                created_at: Date.now()
+                            }]);
+                    }
+                    catch (dbErr) {
+                        logger.warn(`写入文件缓存数据库失败: ${dbErr}`);
+                    }
+                }
                 resolve(fileUrl);
             })
                 .catch((err) => {
@@ -287,13 +340,10 @@ async function getEffectiveSettings(ctx, guildId, config) {
             nsfw: config.allow_sensitive
         };
     }
-    // @ts-ignore
     const data = await ctx.database.get('sla_group_settings', guildId);
     const record = data[0];
     // 合并：自定义设置覆盖默认
-    // @ts-ignore
     const effectiveParsers = { ...config.default_parsers, ...record?.custom_parsers ? record.custom_parsers : {} };
-    // @ts-ignore
     const nsfw_enabled = record?.nsfw_enabled ? record.nsfw_enabled : config.allow_sensitive;
     return {
         parsers: effectiveParsers,
@@ -303,7 +353,7 @@ async function getEffectiveSettings(ctx, guildId, config) {
 async function isUserAdmin(session, userId) {
     if (!session.guildId)
         return false;
-    // @ts-ignore
+    // 使用 (session.user as any) 来规避类型检查，同时保留可选链以防 user 为空
     if (session.user?.authority >= 3)
         return true;
     try {
@@ -322,10 +372,8 @@ async function isUserAdmin(session, userId) {
         return true;
     }
 }
-async function sendResult_plain(session, config, result, logger) {
-    if (config.logLevel === 'full') {
-        logger.info('进入普通发送');
-    }
+async function sendResult_plain(ctx, session, config, result, logger) {
+    logger.debug('进入普通发送');
     const localDownloadDir = config.localDownloadDir;
     const onebotReadDir = config.onebotReadDir;
     let mediaCoverUrl = result.coverUrl;
@@ -333,15 +381,14 @@ async function sendResult_plain(session, config, result, logger) {
     let proxy = undefined;
     if (config.proxy_settings[result.platform]) {
         proxy = config.proxy;
-        logger.info("正在使用代理");
+        logger.debug("正在使用代理");
     }
     // --- 下载封面 ---
     if (result.coverUrl) {
         if (config.usingLocal) {
             try {
-                mediaCoverUrl = await downloadAndMapUrl(result.coverUrl, proxy, config.userAgent, localDownloadDir, onebotReadDir, logger);
-                if (config.logLevel === 'full')
-                    logger.info(`封面已下载: ${mediaCoverUrl}`);
+                mediaCoverUrl = await downloadAndMapUrl(ctx, result.coverUrl, proxy, config.userAgent, localDownloadDir, onebotReadDir, logger, config.enableCache);
+                logger.debug(`封面已下载: ${mediaCoverUrl}`);
             }
             catch (e) {
                 logger.warn(`封面下载失败: ${result.coverUrl}`, e);
@@ -360,10 +407,9 @@ async function sendResult_plain(session, config, result, logger) {
             const remoteUrl = match[1];
             if (config.usingLocal) {
                 try {
-                    const localUrl = await downloadAndMapUrl(remoteUrl, proxy, config.userAgent, localDownloadDir, onebotReadDir, logger);
+                    const localUrl = await downloadAndMapUrl(ctx, remoteUrl, proxy, config.userAgent, localDownloadDir, onebotReadDir, logger, config.enableCache);
                     urlMap[remoteUrl] = localUrl;
-                    if (config.logLevel === 'full')
-                        logger.info(`正文图片已下载: ${localUrl}`);
+                    logger.debug(`正文图片已下载: ${localUrl}`);
                 }
                 catch (e) {
                     logger.warn(`正文图片下载失败: ${remoteUrl}`, e);
@@ -389,9 +435,7 @@ async function sendResult_plain(session, config, result, logger) {
     message = message.replace(/{stats}/g, escapeHtml(result.stats || ''));
     // 清理空行
     const cleanMessage = message.split('\n').filter(line => line.trim() !== '' || line.includes('<')).join('\n');
-    if (config.logLevel === 'full') {
-        logger.info(`解析结果: \n ${JSON.stringify(result, null, 2)}`);
-    }
+    logger.debug(`解析结果: \n ${JSON.stringify(result, null, 2)}`);
     const sendPromises = [];
     // 发送主消息
     if (cleanMessage) {
@@ -409,19 +453,17 @@ async function sendResult_plain(session, config, result, logger) {
                 const maxBytes = config.Max_size * 1024 * 1024;
                 if (sizeBytes !== null && sizeBytes > maxBytes) {
                     shouldSend = false;
-                    if (config.logLevel !== 'none') {
-                        const sizeMB = (sizeBytes / (1024 * 1024)).toFixed(2);
-                        const maxMB = config.Max_size.toFixed(2);
-                        sendPromises.push(session.send(`文件大小超限 (${sizeMB} MB > ${maxMB} MB)`));
-                        logger.info(`文件大小超限 (${sizeMB} MB > ${maxMB} MB)，跳过: ${remoteUrl}`);
-                    }
+                    const sizeMB = (sizeBytes / (1024 * 1024)).toFixed(2);
+                    const maxMB = config.Max_size.toFixed(2);
+                    sendPromises.push(session.send(`文件大小超限 (${sizeMB} MB > ${maxMB} MB)`));
+                    logger.info(`文件大小超限 (${sizeMB} MB > ${maxMB} MB)，跳过: ${remoteUrl}`);
                 }
             }
             if (shouldSend) {
                 try {
                     let localUrl = remoteUrl;
                     if (config.usingLocal)
-                        localUrl = await downloadAndMapUrl(remoteUrl, proxy, config.userAgent, localDownloadDir, onebotReadDir, logger);
+                        localUrl = await downloadAndMapUrl(ctx, remoteUrl, proxy, config.userAgent, localDownloadDir, onebotReadDir, logger, config.enableCache);
                     if (!localUrl)
                         continue;
                     let element = null;
@@ -438,14 +480,10 @@ async function sendResult_plain(session, config, result, logger) {
                     }
                     if (element) {
                         sendPromises.push(session.send(element));
-                        if (config.logLevel === 'link_only') {
-                            logger.info(`${type} 直链 (${result.platform}): ${remoteUrl}`);
-                        }
-                        if (config.logLevel === 'full') {
-                            const size = await getFileSize(remoteUrl, proxy, config.userAgent, logger);
-                            const sizeMB = size ? (size / (1024 * 1024)).toFixed(2) : 'unknown';
-                            logger.info(`${type} 已发送 (${sizeMB} MB): ${localUrl}`);
-                        }
+                        logger.debug(`${type} 直链 (${result.platform}): ${remoteUrl}`);
+                        const size = await getFileSize(remoteUrl, proxy, config.userAgent, logger);
+                        const sizeMB = size ? (size / (1024 * 1024)).toFixed(2) : 'unknown';
+                        logger.debug(`${type} 已发送 (${sizeMB} MB): ${localUrl}`);
                     }
                 }
                 catch (e) {
@@ -456,10 +494,8 @@ async function sendResult_plain(session, config, result, logger) {
     }
     await Promise.all(sendPromises);
 }
-async function sendResult_forward(session, config, result, logger, mixed_sending = false) {
-    if (config.logLevel === 'full') {
-        logger.info(mixed_sending ? '进入混合发送' : '进入合并发送');
-    }
+async function sendResult_forward(ctx, session, config, result, logger, mixed_sending = false) {
+    logger.debug(mixed_sending ? '进入混合发送' : '进入合并发送');
     const localDownloadDir = config.localDownloadDir;
     const onebotReadDir = config.onebotReadDir;
     let mediaCoverUrl = result.coverUrl;
@@ -473,7 +509,7 @@ async function sendResult_forward(session, config, result, logger, mixed_sending
     if (result.coverUrl) {
         if (config.usingLocal) {
             try {
-                mediaCoverUrl = await downloadAndMapUrl(result.coverUrl, proxy, config.userAgent, localDownloadDir, onebotReadDir, logger);
+                mediaCoverUrl = await downloadAndMapUrl(ctx, result.coverUrl, proxy, config.userAgent, localDownloadDir, onebotReadDir, logger, config.enableCache);
             }
             catch (e) {
                 logger.warn('封面下载失败', e);
@@ -491,7 +527,7 @@ async function sendResult_forward(session, config, result, logger, mixed_sending
         await Promise.all(imgUrls.map(async (url) => {
             if (config.usingLocal) {
                 try {
-                    urlMap[url] = await downloadAndMapUrl(url, proxy, config.userAgent, localDownloadDir, onebotReadDir, logger);
+                    urlMap[url] = await downloadAndMapUrl(ctx, url, proxy, config.userAgent, localDownloadDir, onebotReadDir, logger, config.enableCache);
                 }
                 catch (e) {
                     logger.warn(`正文图片下载失败: ${url}`, e);
@@ -507,7 +543,7 @@ async function sendResult_forward(session, config, result, logger, mixed_sending
             mediaMainbody = mediaMainbody.replace(new RegExp(escaped, 'g'), local);
         }
     }
-    // === 主消息（不含媒体文件）===
+    // === 主消息 ===
     let message = config.format;
     message = message.replace(/{title}/g, result.title || '');
     message = message.replace(/{authorName}/g, result.authorName || '');
@@ -555,7 +591,7 @@ async function sendResult_forward(session, config, result, logger, mixed_sending
             }
         });
     }
-    // --- 处理 files 中的所有媒体 ---
+    // --- 处理 files ---
     const extraSendPromises = [];
     if (config.sendFiles && Array.isArray(result.files)) {
         for (const file of result.files) {
@@ -568,30 +604,28 @@ async function sendResult_forward(session, config, result, logger, mixed_sending
                 const maxBytes = config.Max_size * 1024 * 1024;
                 if (sizeBytes !== null && sizeBytes > maxBytes) {
                     shouldInclude = false;
-                    if (config.logLevel !== 'none') {
-                        const sizeMB = (sizeBytes / (1024 * 1024)).toFixed(2);
-                        const maxMB = config.Max_size.toFixed(2);
-                        forwardNodes.push({
-                            type: 'node',
-                            data: {
-                                user_id: session.selfId,
-                                nickname: '分享助手',
-                                content: {
-                                    type: 'text', data: {
-                                        text: `文件大小超限 (${sizeMB} MB > ${maxMB} MB)`
-                                    }
+                    const sizeMB = (sizeBytes / (1024 * 1024)).toFixed(2);
+                    const maxMB = config.Max_size.toFixed(2);
+                    forwardNodes.push({
+                        type: 'node',
+                        data: {
+                            user_id: session.selfId,
+                            nickname: '分享助手',
+                            content: {
+                                type: 'text', data: {
+                                    text: `文件大小超限 (${sizeMB} MB > ${maxMB} MB)`
                                 }
                             }
-                        });
-                        logger.info(`文件大小超限 (${sizeMB} MB > ${maxMB} MB)，跳过: ${remoteUrl}`);
-                    }
+                        }
+                    });
+                    logger.info(`文件大小超限 (${sizeMB} MB > ${maxMB} MB)，跳过: ${remoteUrl}`);
                 }
             }
             if (shouldInclude) {
                 try {
                     let localUrl = remoteUrl;
                     if (config.usingLocal)
-                        localUrl = await downloadAndMapUrl(remoteUrl, proxy, config.userAgent, localDownloadDir, onebotReadDir, logger);
+                        localUrl = await downloadAndMapUrl(ctx, remoteUrl, proxy, config.userAgent, localDownloadDir, onebotReadDir, logger, config.enableCache);
                     if (!localUrl)
                         continue;
                     if (!mixed_sending) {
@@ -631,9 +665,7 @@ async function sendResult_forward(session, config, result, logger, mixed_sending
                             extraSendPromises.push(session.send(element));
                         }
                     }
-                    if (config.logLevel === 'link_only') {
-                        logger.info(`${type} 直链 (${result.platform}): ${remoteUrl}`);
-                    }
+                    logger.debug(`${type} 直链 (${result.platform}): ${remoteUrl}`);
                 }
                 catch (e) {
                     logger.warn(`${type} 下载失败: ${remoteUrl}`, e);
@@ -656,9 +688,7 @@ async function sendResult_forward(session, config, result, logger, mixed_sending
     }
     if (forwardNodes.length === 0 && extraSendPromises.length === 0)
         return;
-    if (config.logLevel === 'full') {
-        logger.info(`解析结果: \n ${JSON.stringify(result, null, 2)}`);
-    }
+    logger.debug(`解析结果: \n ${JSON.stringify(result, null, 2)}`);
     if (!(session.onebot && session.onebot._request))
         throw new Error("Onebot is not defined");
     const promises = [];

package/package.json

@@ -2,7 +2,7 @@
   "name": "koishi-plugin-share-links-analysis",
   "description": "自用插件",
   "license": "MIT",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [