koishi-plugin-share-links-analysis 0.1.0 → 0.1.1

package/lib/core.d.ts

@@ -1,5 +1,5 @@
 import { Context } from 'koishi';
-import { Link, PluginConfig, ProcessedLink } from './types';
+import { Link, PluginConfig, ParsedInfo } from './types';
 /**
  * 从文本中解析出所有支持的链接
  * @param content 消息内容
@@ -13,4 +13,4 @@ export declare function resolveLinks(content: string): Link[];
  * @param link 解析出的链接对象
  * @returns 处理后的链接结果，如果失败则返回 null
  */
-export declare function processLink(ctx: Context, config: PluginConfig, link: Link): Promise<ProcessedLink | null>;
+export declare function processLink(ctx: Context, config: PluginConfig, link: Link): Promise<ParsedInfo | null>;

package/lib/core.js

@@ -1,4 +1,5 @@
 "use strict";
+// src/core.ts
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/lib/index.d.ts

@@ -5,6 +5,6 @@ export declare const inject: {
     required: string[];
     optional: string[];
 };
-export declare const usage = "\n\u5F00\u542F\u63D2\u4EF6\u540E\uFF0C\u5373\u53EF\u81EA\u52A8\u89E3\u6790\u5206\u4EAB\u94FE\u63A5\n\u5411Bot\u53D1\u9001B\u7AD9\u3001\u5C0F\u7EA2\u4E66\u7B49\u652F\u6301\u5E73\u53F0\u7684\u5206\u4EAB\u94FE\u63A5\uFF0C\u4F1A\u8FD4\u56DE\u56FE\u6587\u4FE1\u606F\u4E0E\u89C6\u9891\u3002\n\nB\u7AD9\u77ED\u94FE\u63A5(b23.tv)\u89E3\u6790\u9700\u8981 puppeteer \u670D\u52A1\u652F\u6301\uFF0C\u8BF7\u786E\u4FDD\u5DF2\u5B89\u88C5\u5E76\u542F\u7528\u8BE5\u63D2\u4EF6\u3002\n";
+export declare const usage = "\n\u5F00\u542F\u63D2\u4EF6\u540E\uFF0C\u5373\u53EF\u81EA\u52A8\u89E3\u6790\u5206\u4EAB\u94FE\u63A5\u3002\n\u5411Bot\u53D1\u9001B\u7AD9\u3001\u5C0F\u7EA2\u4E66\u7B49\u652F\u6301\u5E73\u53F0\u7684\u5206\u4EAB\u94FE\u63A5\uFF0C\u4F1A\u8FD4\u56DE\u56FE\u6587\u4FE1\u606F\u4E0E\u89C6\u9891\u3002\n\u60A8\u53EF\u4EE5\u5728\u63D2\u4EF6\u914D\u7F6E\u4E2D\u4E3A\u4E0D\u540C\u5E73\u53F0\u5206\u522B\u8BBE\u7F6E\u8FD4\u56DE\u7684\u56FE\u6587\u6D88\u606F\u683C\u5F0F\u3002\n";
 export declare const Config: Schema<PluginConfig>;
 export declare function apply(ctx: Context, config: PluginConfig): void;

package/lib/index.js

@@ -1,91 +1,76 @@
 "use strict";
+// src/index.ts
 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");
-// 这是插件的元数据
 exports.name = 'share-links-analysis';
 exports.inject = {
     required: ['BiliBiliVideo'],
-    optional: ['puppeteer'], // 【修改】将 puppeteer 作为可选依赖注入
+    optional: ['puppeteer'],
 };
 exports.usage = `
-开启插件后，即可自动解析分享链接
+开启插件后，即可自动解析分享链接。
 向Bot发送B站、小红书等支持平台的分享链接，会返回图文信息与视频。
-
-B站短链接(b23.tv)解析需要 puppeteer 服务支持，请确保已安装并启用该插件。
+您可以在插件配置中为不同平台分别设置返回的图文消息格式。
 `;
+// 配置文件
 exports.Config = koishi_1.Schema.intersect([
     koishi_1.Schema.object({
-        linktextParsing: koishi_1.Schema.boolean().default(true).description("是否返回图文数据。`开启后，才发送视频数据的图文解析。`"),
-        VideoParsing_ToLink: koishi_1.Schema.union([
-            koishi_1.Schema.const('1').description('不返回视频/视频直链'),
-            koishi_1.Schema.const('2').description('仅返回视频'),
-            koishi_1.Schema.const('3').description('仅返回视频直链'),
-            koishi_1.Schema.const('4').description('返回视频和视频直链'),
-            koishi_1.Schema.const('5').description('返回视频，仅在日志记录视频直链'),
-        ]).role('radio').default('2').description("是否返回` 视频/视频直链 `"),
         Video_ClarityPriority: koishi_1.Schema.union([
-            koishi_1.Schema.const('1').description('低清晰度优先（低清晰度的视频发得快一点）'),
-            koishi_1.Schema.const('2').description('高清晰度优先（建议在B站观看高画质视频）'),
+            koishi_1.Schema.const('1').description('低清晰度优先'),
+            koishi_1.Schema.const('2').description('高清晰度优先'),
         ]).role('radio').default('1').description("发送的视频清晰度优先策略"),
-        Maximumduration: koishi_1.Schema.number().default(25).description("允许解析的视频最大时长（分钟）`超过这个时长就不会发送视频`").min(1),
-        Maximumduration_tip: koishi_1.Schema.union([
-            koishi_1.Schema.const('不返回文字提示').description('不返回文字提示'),
-            koishi_1.Schema.string().description('返回文字提示（请在右侧填写文字内容）').default('视频太长啦！还是去B站看吧~'),
-        ]).description("对过长视频的文字提示内容").default('视频太长啦！还是去B站看吧~'),
-        MinimumTimeInterval: koishi_1.Schema.number().default(180).description("若干`秒`内不再处理相同链接 `防止多bot互相触发导致的刷屏/性能浪费`").min(1),
+        Maximumduration: koishi_1.Schema.number().default(25).description("允许解析的视频最大时长（分钟）").min(1),
+        Maximumduration_tip: koishi_1.Schema.string().default('视频太长啦！还是去平台官网看吧~').description("对过长视频的文字提示内容"),
+        MinimumTimeInterval: koishi_1.Schema.number().default(180).description("若干秒内不再处理相同链接，防止刷屏").min(1),
         waitTip_Switch: koishi_1.Schema.union([
             koishi_1.Schema.const(false).description('不返回文字提示'),
-            koishi_1.Schema.string().description('返回文字提示（请在右侧填写文字内容）'),
+            koishi_1.Schema.string().description('返回文字提示'),
         ]).description("是否返回等待提示。开启后，会发送`等待提示语`").default(false),
     }).description("基础设置"),
     koishi_1.Schema.object({
-        BVnumberParsing: koishi_1.Schema.boolean().default(true).description("是否允许根据`独立的BV号`解析视频 `开启后，可以通过视频的BV号解析视频。`"),
-        parseLimit: koishi_1.Schema.number().default(3).description("单对话多链接解析上限").hidden(),
-        useNumeral: koishi_1.Schema.boolean().default(true).description("使用格式化数字 (如 10000 -> 1万)").hidden(),
-        showError: koishi_1.Schema.boolean().default(false).description("当链接不正确时提醒发送者").hidden(),
+        format: koishi_1.Schema.string().role('textarea').default(`{title}
+{cover}
+作者：{authorName}
+简介：{description}
+{stats}
+{images}
+{video}`).description('统一主输出格式。<br/>可用占位符: `{title}`, `{cover}`, `{authorName}`, `{description}`, `{stats}`, `{sourceUrl}`, `{images}`, `{video}`, `{videoUrl}`'),
+    }).description("格式化模板"),
+    koishi_1.Schema.object({
+        bilibiliStatsFormat: koishi_1.Schema.string().role('textarea').default('播放: {播放} | 弹幕: {弹幕} | 点赞: {点赞} | 硬币: {硬币} | 收藏: {收藏}')
+            .description('Bilibili 链接的数据统计格式。<br/>可用占位符: `{播放}`, `{弹幕}`, `{点赞}`, `{硬币}`, `{收藏}`'),
+        xiaohongshuStatsFormat: koishi_1.Schema.string().role('textarea').default('点赞: {点赞} | 收藏: {收藏} | 评论: {评论}')
+            .description('小红书链接的数据统计格式。<br/>可用占位符: `{点赞}`, `{收藏}`, `{评论}`'),
+    }).description("数据格式化"),
+    koishi_1.Schema.object({
+        parseLimit: koishi_1.Schema.number().default(3).description("单对话多链接解析上限"),
+        useNumeral: koishi_1.Schema.boolean().default(true).description("使用格式化数字 (如 10000 -> 1万)"),
+        showError: koishi_1.Schema.boolean().default(false).description("当链接不正确时提醒发送者"),
         bVideoIDPreference: koishi_1.Schema.union([
             koishi_1.Schema.const("bv").description("BV 号"),
             koishi_1.Schema.const("av").description("AV 号"),
-        ]).default("bv").description("B站ID 偏好").hidden(),
-        bVideoImage: koishi_1.Schema.boolean().default(true).description("显示封面"),
-        bVideoOwner: koishi_1.Schema.boolean().default(true).description("显示 UP 主"),
-        bVideoDesc: koishi_1.Schema.boolean().default(false).description("显示简介`有的简介真的很长`"),
-        bVideoStat: koishi_1.Schema.boolean().default(true).description("显示状态（*三连数据*）"),
-        bVideoExtraStat: koishi_1.Schema.boolean().default(true).description("显示额外状态（*弹幕&观看*）"),
-        bVideoShowLink: koishi_1.Schema.boolean().default(false).description("显示视频链接`开启可能会导致其他bot循环解析`"),
-    }).description("B站内容解析设置"),
-    koishi_1.Schema.object({
-        xhsCover: koishi_1.Schema.boolean().default(true).description("显示首图/封面"),
-        xhsAuthor: koishi_1.Schema.boolean().default(true).description("显示作者"),
-        xhsDesc: koishi_1.Schema.boolean().default(true).description("显示简介"),
-        xhsStat: koishi_1.Schema.boolean().default(true).description("显示状态（*点赞、收藏、评论*）"),
-    }).description("小红书内容解析设置"),
+        ]).default("bv").description("B站ID 偏好"),
+    }).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"),
-        loggerinfo: koishi_1.Schema.boolean().default(false).description("日志调试输出 `日常使用无需开启`"),
+        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("选择后台日志记录等级"),
     }).description("调试设置"),
 ]);
-// 主插件逻辑
 function apply(ctx, config) {
     const logger = ctx.logger('share-links-analysis');
     const lastProcessedUrls = {};
     ctx.middleware(async (session, next) => {
-        if (!session.content || !session.channelId) {
+        if (!session.content || !session.channelId)
             return next();
-        }
-        let content = session.content;
+        const content = session.content.replace(/\\/g, '');
         const channelId = session.channelId;
-        if (config.BVnumberParsing) {
-            const bvPattern = /(?:^|\s)(BV[1-9A-HJ-NP-Za-km-z]{10})(?:\s|$)/g;
-            const bvMatches = content.match(bvPattern);
-            if (bvMatches) {
-                const urls = bvMatches.map(bv => `https://www.bilibili.com/video/${bv.trim()}`);
-                content += '\n' + urls.join('\n');
-            }
-        }
         const links = (0, core_1.resolveLinks)(content);
         if (links.length === 0)
             return next();
@@ -96,11 +81,10 @@ function apply(ctx, config) {
                 break;
             }
             const now = Date.now();
-            if (!lastProcessedUrls[channelId]) {
+            if (!lastProcessedUrls[channelId])
                 lastProcessedUrls[channelId] = {};
-            }
             if (now - (lastProcessedUrls[channelId][link.url] || 0) < config.MinimumTimeInterval * 1000) {
-                if (config.loggerinfo)
+                if (config.logLevel === 'full')
                     logger.info(`链接 ${link.url} 在冷却时间内，跳过处理。`);
                 continue;
             }
@@ -117,44 +101,45 @@ function apply(ctx, config) {
             }
             linkCount++;
         }
-        return next();
     });
 }
 async function sendResult(session, config, result, logger) {
-    if (config.linktextParsing && result.text) {
-        let message = result.text;
-        if (!config.bVideoShowLink && result.sourceUrl) {
-            message = message.replace(new RegExp(result.sourceUrl + '\\n?$'), '');
+    let message = config.format;
+    message = message.replace(/{title}/g, result.title || '');
+    message = message.replace(/{authorName}/g, result.authorName || '');
+    message = message.replace(/{description}/g, result.description ? result.description : '');
+    message = message.replace(/{sourceUrl}/g, result.sourceUrl || '');
+    message = message.replace(/{cover}/g, result.coverUrl ? koishi_1.h.image(result.coverUrl).toString() : '');
+    const imagesText = result.images ? result.images.map(img => koishi_1.h.image(img).toString()).join('\n') : '';
+    message = message.replace(/{images}/g, imagesText);
+    message = message.replace(/{stats}/g, result.stats || '');
+    // 【修复】只要 videoUrl 存在就处理，仅当 duration 明确超长时才替换为提示
+    if (result.videoUrl) {
+        // 仅当 duration 是有效数字且超长时，才显示提示
+        if (typeof result.duration === 'number' && result.duration > config.Maximumduration * 60) {
+            const tip = config.Maximumduration_tip || '';
+            message = message.replace(/{video}/g, tip);
+            message = message.replace(/{videoUrl}/g, '');
         }
-        await session.send(koishi_1.h.quote(session.messageId) + message);
-    }
-    if (result.videoUrl && result.duration) {
-        if (result.duration > config.Maximumduration * 60) {
-            if (config.Maximumduration_tip && config.Maximumduration_tip !== '不返回文字提示') {
-                await session.send(config.Maximumduration_tip);
+        else {
+            // 正常发送视频和链接
+            message = message.replace(/{video}/g, koishi_1.h.video(result.videoUrl).toString());
+            message = message.replace(/{videoUrl}/g, result.videoUrl);
+            if (config.logLevel === 'link_only' || config.logLevel === 'full') {
+                logger.info(`视频直链 (${result.platform}): ${result.videoUrl}`);
             }
-            return;
         }
     }
-    if (result.videoUrl && config.VideoParsing_ToLink !== '1') {
-        switch (config.VideoParsing_ToLink) {
-            case '2':
-                await session.send(koishi_1.h.video(result.videoUrl));
-                break;
-            case '3':
-                await session.send(koishi_1.h.text(result.videoUrl));
-                break;
-            case '4':
-                await session.send(koishi_1.h.text(result.videoUrl));
-                await session.send(koishi_1.h.video(result.videoUrl));
-                break;
-            case '5':
-                logger.info(`视频直链: ${result.videoUrl}`);
-                await session.send(koishi_1.h.video(result.videoUrl));
-                break;
-        }
+    else {
+        // 没有视频则移除占位符
+        message = message.replace(/{video}/g, '');
+        message = message.replace(/{videoUrl}/g, '');
+    }
+    const cleanMessage = message.split('\n').filter(line => line.trim() !== '' || line.includes('<')).join('\n');
+    if (cleanMessage) {
+        await session.send(koishi_1.h.quote(session.messageId) + cleanMessage);
     }
-    if (config.loggerinfo) {
+    if (config.logLevel === 'full') {
         logger.info(`解析结果: \n ${JSON.stringify(result, null, 2)}`);
     }
 }

package/lib/parsers/bilibili.d.ts

@@ -1,7 +1,7 @@
 import { Context } from 'koishi';
-import { Link, ProcessedLink, PluginConfig } from '../types';
+import { Link, ParsedInfo, PluginConfig } from '../types';
 /**
- * 在文本中匹配B站链接
+ * 在文本中匹配B站链接 (长链/短链/纯BV号)
  * @param content 消息内容
  * @returns 匹配到的链接对象数组
  */
@@ -13,4 +13,4 @@ export declare function match(content: string): Link[];
  * @param link 匹配到的链接对象
  * @returns 处理后的标准格式对象
  */
-export declare function process(ctx: Context, config: PluginConfig, link: Link): Promise<ProcessedLink | null>;
+export declare function process(ctx: Context, config: PluginConfig, link: Link): Promise<ParsedInfo | null>;

package/lib/parsers/bilibili.js

@@ -1,33 +1,48 @@
 "use strict";
+// src/parsers/bilibili.ts
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.match = match;
 exports.process = process;
-const koishi_1 = require("koishi");
 const utils_1 = require("../utils");
 /**
- * 在文本中匹配B站链接
+ * 在文本中匹配B站链接 (长链/短链/纯BV号)
  * @param content 消息内容
  * @returns 匹配到的链接对象数组
  */
 function match(content) {
+    const results = [];
+    // 匹配标准长链接和短链接
     const linkRegex = [
-        { pattern: /(https?:\/\/)?bilibili\.com\/video\/([ab]v[0-9a-zA-Z]+)/i, type: "video" },
-        { pattern: /(https?:\/\/)?b23\.tv\/([0-9a-zA-Z]+)/i, type: "short" },
+        { pattern: /(https?:\/\/)?(www\.bilibili\.com\/video\/([ab]v[0-9a-zA-Z]+))/i, type: "video" },
+        { pattern: /(https?:\/\/)?(b23\.tv\/[0-9a-zA-Z]+)/i, type: "short" },
     ];
-    const results = [];
     for (const rule of linkRegex) {
         const matches = [...content.matchAll(new RegExp(rule.pattern, 'gi'))];
         for (const matchArr of matches) {
             if (matchArr[2]) {
+                // 强制将所有链接格式化为 https 开头
+                const formattedUrl = `https://${matchArr[2]}`;
                 results.push({
                     platform: 'bilibili',
                     type: rule.type,
-                    id: matchArr[2], // 捕获组2是ID
-                    url: matchArr[0] // 完整匹配的URL
+                    id: rule.type === 'video' ? matchArr[3] : matchArr[2],
+                    url: formattedUrl
                 });
             }
         }
     }
+    // 匹配独立的 BV 号
+    const bvPattern = /(?<![a-zA-Z0-9/])(BV[1-9A-HJ-NP-Za-km-z]{10})(?![a-zA-Z0-9])/gi;
+    const bvMatches = [...content.matchAll(bvPattern)];
+    for (const matchArr of bvMatches) {
+        const videoId = matchArr[1];
+        results.push({
+            platform: 'bilibili',
+            type: 'video',
+            id: videoId,
+            url: `https://www.bilibili.com/video/${videoId}`
+        });
+    }
     return results;
 }
 /**
@@ -41,50 +56,46 @@ async function process(ctx, config, link) {
     const logger = ctx.logger('share-links-analysis:bilibili');
     let videoId = link.id;
     let videoIdType = link.type;
-    // 如果是短链接，需要解析出真实ID
     if (link.type === 'short') {
         let finalUrl = '';
-        // 【方案一】优先使用原始插件的轻量级解析方案
-        logger.info(`B站短链接解析：尝试使用轻量级HTTP方案解析 ${link.url}`);
+        logger.info(`B站短链接解析：尝试解析 ${link.url}`);
         try {
             const response = await ctx.http(link.url, {
                 method: 'GET',
                 headers: { 'User-Agent': config.userAgent },
                 redirect: 'manual',
             });
-            // 【修正】使用 .get('location') 的标准方法来获取响应头
             const locationHeader = response.headers.get('location');
+            if (locationHeader)
+                finalUrl = locationHeader;
+        }
+        catch (e) {
+            const locationHeader = e.response?.headers?.location;
             if (locationHeader) {
                 finalUrl = locationHeader;
-                logger.info(`轻量级方案成功 (方式A：获取响应头)，短链接指向: ${finalUrl}`);
             }
-            else if (response.data) {
-                const match = String(response.data).match(/<a\s+.*?href="([^"]*)"/i);
-                if (match && match[1]) {
-                    finalUrl = match[1];
-                    logger.info(`轻量级方案成功 (方式B：解析响应体)，短链接指向: ${finalUrl}`);
-                }
+            else if (config.logLevel === 'full') {
+                logger.debug(`解析短链接时发生网络错误或未找到跳转地址: ${e.message}`);
             }
         }
-        catch (e) {
-            // 正常情况下这里不应再触发，仅作为网络错误等意外情况的捕获
-            const message = e instanceof Error ? e.message : String(e);
-            logger.error(`轻量级HTTP请求失败: ${message}`);
+        if (finalUrl && (finalUrl.includes('b23.tv') || finalUrl.includes('bilibili.com/'))) {
+            const urlObj = new URL(finalUrl);
+            if (urlObj.hostname === 'b23.tv' || (urlObj.hostname === 'bilibili.com' && !urlObj.pathname.startsWith('/video/'))) {
+                logger.warn(`标准HTTP解析方案未能解析到最终视频链接，仍然是短链接或非视频页: ${finalUrl}。切换至后备方案。`);
+                finalUrl = '';
+            }
         }
-        // 【方案二】如果轻量级方案失败，并且安装了Puppeteer，则使用它作为后备
         if (!finalUrl && ctx.puppeteer) {
-            logger.warn(`轻量级方案解析失败，切换至Puppeteer后备方案: ${link.url}`);
+            logger.info(`标准解析方案失败或结果无效，切换至Puppeteer后备方案: ${link.url}`);
             let page = null;
             try {
                 page = await ctx.puppeteer.page();
                 await page.setUserAgent(config.userAgent);
                 await page.goto(link.url, { waitUntil: 'networkidle0' });
-                finalUrl = page.url(); // 获取跳转后的最终URL
-                logger.info(`Puppeteer方案成功，短链接指向: ${finalUrl}`);
+                finalUrl = page.url();
             }
             catch (e) {
-                const message = e instanceof Error ? e.message : String(e);
-                logger.error(`Puppeteer方案解析短链接 ${link.url} 失败: ${message}`);
+                logger.error(`Puppeteer方案解析短链接 ${link.url} 失败: ${e.message}`);
                 return null;
             }
             finally {
@@ -92,86 +103,83 @@ async function process(ctx, config, link) {
                     await page.close();
             }
         }
-        else if (!finalUrl && !ctx.puppeteer) {
-            logger.error('轻量级方案解析短链接失败，且未安装或启用Puppeteer服务，无法继续解析。');
-            return null;
-        }
-        // 从最终解析出的URL里提取视频ID
-        const matchedLinks = match(finalUrl);
-        if (matchedLinks.length > 0 && matchedLinks[0].type === 'video') {
-            videoId = matchedLinks[0].id;
-            videoIdType = 'video';
+        if (finalUrl) {
+            if (config.logLevel === 'full')
+                logger.info(`短链接解析成功，指向: ${finalUrl}`);
+            const matchedLinks = match(finalUrl);
+            if (matchedLinks.length > 0 && matchedLinks[0].type === 'video') {
+                videoId = matchedLinks[0].id;
+                videoIdType = 'video';
+            }
+            else {
+                logger.warn(`在最终链接中未找到有效的视频ID: ${finalUrl}`);
+                return null;
+            }
         }
         else {
-            logger.warn(`在最终链接中未找到有效的视频ID: ${finalUrl}`);
+            logger.error('短链接解析失败，且无后备方案。');
             return null;
         }
     }
-    // 如果最终没能得到视频ID，则解析失败
     if (videoIdType !== 'video' || !videoId) {
         logger.warn(`无法从链接 ${link.url} 中解析出有效的B站视频ID。`);
         return null;
     }
-    logger.info(`获取视频信息，ID: ${videoId}`);
+    if (config.logLevel === 'full')
+        logger.info(`获取视频信息，ID: ${videoId}`);
     const idType = videoId.startsWith('BV') ? 'bvid' : 'aid';
     const infoUrl = `https://api.bilibili.com/x/web-interface/view?${idType}=${videoId}`;
-    let info;
     try {
-        info = await ctx.http.get(infoUrl, {
+        const info = await ctx.http.get(infoUrl, {
             headers: { 'User-Agent': config.userAgent }
         });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        logger.error(`获取B站视频信息失败，ID ${videoId}: ${message}`);
-        return null;
-    }
-    if (!info || !info.data) {
-        logger.warn(`B站API未返回有效数据，ID ${videoId}。响应: ${JSON.stringify(info)}`);
-        return null;
-    }
-    const data = info.data;
-    // --- 格式化图文消息 ---
-    let text = `${data.title}\n`;
-    if (config.bVideoImage)
-        text += koishi_1.h.image(data.pic) + '\n';
-    if (config.bVideoOwner)
-        text += `UP主： ${data.owner.name}\n`;
-    if (config.bVideoDesc && data.desc)
-        text += `简介：${data.desc}\n`;
-    if (config.bVideoStat) {
-        text += `点赞: ${(0, utils_1.numeral)(data.stat.like, config)} | 硬币: ${(0, utils_1.numeral)(data.stat.coin, config)} | 收藏: ${(0, utils_1.numeral)(data.stat.favorite, config)}\n`;
-    }
-    if (config.bVideoExtraStat) {
-        text += `播放: ${(0, utils_1.numeral)(data.stat.view, config)} | 弹幕: ${(0, utils_1.numeral)(data.stat.danmaku, config)}\n`;
-    }
-    const sourceUrl = `https://www.bilibili.com/video/${data.bvid}`;
-    if (config.bVideoShowLink) {
-        text += sourceUrl;
-    }
-    // --- 获取视频直链 ---
-    let videoUrl = null;
-    if (config.VideoParsing_ToLink !== '1') {
-        logger.info(`尝试获取视频流，bvid: ${data.bvid}`);
+        if (!info || !info.data) {
+            logger.warn(`B站API未返回有效数据，ID ${videoId}。响应: ${JSON.stringify(info)}`);
+            return null;
+        }
+        const data = info.data;
+        // --- 获取视频直链 ---
+        let videoUrl = null;
+        if (config.logLevel === 'full')
+            logger.info(`尝试获取视频流，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;
-                logger.info(`成功获取视频流，bvid: ${data.bvid}`);
-            }
-            else {
-                logger.warn(`未能获取视频流，bvid: ${data.bvid}。API返回的流数据无效。响应: ${JSON.stringify(videoStream)}`);
+                if (config.logLevel === 'full')
+                    logger.info(`成功获取视频流，bvid: ${data.bvid}`);
             }
         }
         catch (e) {
-            const message = e instanceof Error ? e.message : String(e);
-            logger.error(`通过BiliBiliVideo服务获取视频流失败，bvid: ${data.bvid}: ${message}`);
+            logger.error(`通过BiliBiliVideo服务获取视频流失败，bvid: ${data.bvid}: ${e.message}`);
         }
+        // 在解析器内部格式化 stats 字符串
+        const stats = {
+            '播放': (0, utils_1.numeral)(data.stat.view, config),
+            '弹幕': (0, utils_1.numeral)(data.stat.danmaku, config),
+            '点赞': (0, utils_1.numeral)(data.stat.like, config),
+            '硬币': (0, utils_1.numeral)(data.stat.coin, config),
+            '收藏': (0, utils_1.numeral)(data.stat.favorite, config),
+        };
+        let statsString = config.bilibiliStatsFormat;
+        // 【修复】使用类型安全的方式遍历对象，防止 TypeScript 报错
+        Object.keys(stats).forEach(key => {
+            statsString = statsString.replace(`{${key}}`, stats[key]);
+        });
+        return {
+            platform: 'bilibili',
+            title: data.title,
+            authorName: data.owner.name,
+            description: data.desc,
+            coverUrl: data.pic,
+            videoUrl: videoUrl,
+            duration: data.duration,
+            sourceUrl: `https://www.bilibili.com/video/${data.bvid}`,
+            stats: statsString, // 【修改】传入格式化后的字符串
+        };
+    }
+    catch (error) {
+        logger.error(`获取或处理B站视频信息失败，ID ${videoId}: ${error.message}`);
+        return null;
     }
-    return {
-        text: text.trim(),
-        videoUrl: videoUrl,
-        duration: data.duration,
-        sourceUrl: sourceUrl,
-    };
 }

package/lib/parsers/xiaohongshu.d.ts

@@ -1,5 +1,5 @@
 import { Context } from 'koishi';
-import { Link, ProcessedLink, PluginConfig } from '../types';
+import { Link, ParsedInfo, PluginConfig } from '../types';
 /**
  * 在文本中匹配小红书链接 (长链接或短链接)
  * @param content 消息内容
@@ -13,4 +13,4 @@ export declare function match(content: string): Link[];
  * @param link 匹配到的链接对象
  * @returns 处理后的标准格式对象
  */
-export declare function process(ctx: Context, config: PluginConfig, link: Link): Promise<ProcessedLink | null>;
+export declare function process(ctx: Context, config: PluginConfig, link: Link): Promise<ParsedInfo | null>;

package/lib/parsers/xiaohongshu.js

@@ -1,8 +1,8 @@
 "use strict";
+// src/parsers/xiaohongshu.ts
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.match = match;
 exports.process = process;
-const koishi_1 = require("koishi");
 const cheerio_1 = require("cheerio");
 const utils_1 = require("../utils");
 /**
@@ -11,7 +11,6 @@ const utils_1 = require("../utils");
  * @returns 匹配到的链接对象数组
  */
 function match(content) {
-    // 正则表达式匹配包含查询参数的完整URL
     const urlRegex = /https?:\/\/(?:www\.xiaohongshu\.com\/discovery\/item\/[A-Za-z0-9]+|xhslink\.com\/[A-Za-z0-9]+)\??[^ \n\r]*/g;
     const matches = content.match(urlRegex);
     if (!matches)
@@ -19,7 +18,7 @@ function match(content) {
     return matches.map(url => ({
         platform: 'xiaohongshu',
         type: 'note',
-        id: url.split('/').pop().split('?')[0], // 获取纯ID
+        id: url.split('/').pop().split('?')[0],
         url: url
     }));
 }
@@ -35,25 +34,26 @@ async function process(ctx, config, link) {
     // 步骤一：从原始分享链接中提取 xsec_token
     let token = null;
     try {
-        // 【修正】解码URL中的HTML实体, 主要是 & -> &
+        // 解码URL中的HTML实体, 主要是 & -> &
         const decodedUrl = link.url.replace(/&/g, '&');
         const originalUrl = new URL(decodedUrl);
         token = originalUrl.searchParams.get('xsec_token');
-        if (token) {
+        if (token && config.logLevel === 'full') {
             logger.info(`成功从分享链接中提取 xsec_token。`);
         }
-        else {
-            logger.warn(`分享链接中未找到 xsec_token: ${link.url}`);
+        else if (config.logLevel === 'full') {
+            logger.debug(`分享链接中未找到 xsec_token: ${link.url}`);
         }
     }
     catch (e) {
-        logger.warn(`解析分享链接URL失败: ${link.url}`);
-        // 即使URL解析失败，也继续尝试，因为短链接可能没有参数
+        if (config.logLevel === 'full')
+            logger.debug(`解析分享链接URL失败: ${link.url}`);
     }
     let finalUrl = link.url;
     // 步骤二：如果是短链接，获取其跳转后的基础地址
     if (link.url.includes('xhslink.com')) {
-        logger.info(`小红书短链接解析：尝试获取 ${link.url} 的最终地址`);
+        if (config.logLevel === 'full')
+            logger.info(`小红书短链接解析：尝试获取 ${link.url} 的最终地址`);
         try {
             const response = await ctx.http(link.url, {
                 method: 'GET',
@@ -63,14 +63,16 @@ async function process(ctx, config, link) {
             const location = response.headers.get('location');
             if (location) {
                 finalUrl = location;
-                logger.info(`短链接解析成功，跳转地址: ${finalUrl}`);
+                if (config.logLevel === 'full')
+                    logger.info(`短链接解析成功，跳转地址: ${finalUrl}`);
             }
         }
         catch (e) {
             const location = e.response?.headers?.location;
             if (location) {
                 finalUrl = location;
-                logger.info(`短链接解析成功，跳转地址: ${finalUrl}`);
+                if (config.logLevel === 'full')
+                    logger.info(`短链接解析成功，跳转地址: ${finalUrl}`);
             }
             else {
                 logger.error(`解析短链接时发生网络错误: ${e.message}`);
@@ -97,8 +99,8 @@ async function process(ctx, config, link) {
         logger.error(`构建最终请求URL失败: ${finalUrl}`);
         return null;
     }
-    // 步骤四：获取最终页面的HTML并解析
-    logger.info(`正在抓取小红书页面: ${urlToFetch}`);
+    if (config.logLevel === 'full')
+        logger.info(`正在抓取小红书页面: ${urlToFetch}`);
     try {
         const html = await ctx.http.get(urlToFetch, {
             headers: { 'User-Agent': config.userAgent }
@@ -109,61 +111,67 @@ async function process(ctx, config, link) {
             logger.error('在页面中未找到 __INITIAL_STATE__ 数据块，可能是token无效或小红书策略变更。');
             return null;
         }
-        const jsonStr = scriptContent
-            .replace(/window\.__INITIAL_STATE__\s*=\s*/, '')
-            .replace(/undefined/g, 'null');
+        const jsonStr = scriptContent.replace(/window\.__INITIAL_STATE__\s*=\s*/, '').replace(/undefined/g, 'null');
         const pageData = JSON.parse(jsonStr);
-        const noteData = Object.values(pageData.note.noteDetailMap)[0].note;
-        // 【修改】完全重构图文消息的构建逻辑，严格对齐B站风格
-        let text = '';
+        const noteKey = Object.keys(pageData.note.noteDetailMap)[0];
+        if (!noteKey) {
+            logger.error('无法在页面数据中找到笔记详情。');
+            return null;
+        }
+        const noteData = pageData.note.noteDetailMap[noteKey].note;
+        // --- 构建结构化数据 ---
         let videoUrl = null;
-        // 1. 标题 (去除方括号)
-        text += `${noteData.title}\n`;
+        let coverUrl = undefined;
+        const images = [];
         if (noteData.type === 'video' && noteData.video) {
-            videoUrl = noteData.video.media.stream.h264[0].masterUrl;
-            // 2. 封面 (仅视频笔记)
-            if (config.xhsCover && noteData.imageList && noteData.imageList.length > 0) {
-                const coverUrl = noteData.imageList[0].infoList.find(i => i.imageScene === 'WB_DETAIL_SHARE')?.url || noteData.imageList[0].infoList[1]?.url;
-                if (coverUrl)
-                    text += koishi_1.h.image(coverUrl) + '\n';
+            if (config.logLevel === 'full') {
+                logger.info(`[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}`);
+                }
+            }
+            else {
+                logger.warn('[XHS Video Debug] 未能从预期路径 `note.video.media.stream.h264[0].masterUrl` 找到视频链接。');
+            }
+            if (noteData.imageList && noteData.imageList.length > 0) {
+                coverUrl = noteData.imageList[0].infoList.find(i => i.imageScene === 'WB_DETAIL_SHARE')?.url || noteData.imageList[0].infoList[1]?.url;
             }
         }
-        // 3. 作者信息 (统一使用“UP主”)
-        if (config.xhsAuthor) {
-            text += `UP主：${noteData.user.nickname}\n`;
-        }
-        // 4. 简介 (添加“简介：”前缀)
-        if (config.xhsDesc) {
-            text += `简介：${noteData.desc}\n`;
-        }
-        // 5. 图片列表 (仅图文笔记)
-        if (noteData.type === 'normal' && Array.isArray(noteData.imageList)) {
-            const images = [];
+        else if (noteData.type === 'normal' && Array.isArray(noteData.imageList)) {
             noteData.imageList.forEach((img) => {
                 const imageUrl = img.infoList.find((i) => i.imageScene === 'WB_DETAIL_SHARE')?.url || img.infoList[1]?.url || img.url_default;
                 if (imageUrl) {
-                    images.push(koishi_1.h.image(imageUrl).toString());
+                    images.push(imageUrl);
                 }
             });
-            text += images.join('\n');
-            text += '\n'; // 在图片后添加一个换行
-        }
-        // 6. 互动数据 (去除emoji，使用“|”分割)
-        if (config.xhsStat && noteData.interactInfo) {
-            const likes = (0, utils_1.numeral)(parseInt(noteData.interactInfo.likedCount), config);
-            const favorites = (0, utils_1.numeral)(parseInt(noteData.interactInfo.collectedCount), config);
-            const comments = (0, utils_1.numeral)(parseInt(noteData.interactInfo.commentCount), config);
-            text += `点赞：${likes} | 收藏：${favorites} | 评论：${comments}`;
         }
+        const stats = {
+            '点赞': (0, utils_1.numeral)(parseInt(noteData.interactInfo.likedCount), config),
+            '收藏': (0, utils_1.numeral)(parseInt(noteData.interactInfo.collectedCount), config),
+            '评论': (0, utils_1.numeral)(parseInt(noteData.interactInfo.commentCount), config),
+        };
+        let statsString = config.xiaohongshuStatsFormat;
+        Object.keys(stats).forEach(key => {
+            statsString = statsString.replace(`{${key}}`, stats[key]);
+        });
         return {
-            text: text.trim(),
+            platform: 'xiaohongshu',
+            title: noteData.title,
+            authorName: noteData.user.nickname,
+            description: noteData.desc.trim(),
+            coverUrl: coverUrl,
             videoUrl: videoUrl,
-            duration: (videoUrl && noteData.video) ? noteData.video.media.duration : null,
+            duration: (videoUrl && noteData.video?.media?.duration) ? noteData.video.media.duration / 1000 : null,
+            sourceUrl: urlToFetch,
+            stats: statsString,
+            images: images.length > 0 ? images : undefined,
         };
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        logger.error(`抓取或解析小红书页面时失败: ${message}`);
+        logger.error(`抓取或解析小红书页面时失败: ${error.message}`);
         return null;
     }
 }

package/lib/types.d.ts

@@ -4,37 +4,33 @@ export interface Link {
     id: string;
     url: string;
 }
-export interface ProcessedLink {
-    text: string;
-    videoUrl: string | null;
-    duration: number | null;
-    sourceUrl?: string;
+export interface ParsedInfo {
+    platform: 'bilibili' | 'xiaohongshu';
+    title: string;
+    authorName: string;
+    description?: string;
+    coverUrl?: string;
+    videoUrl?: string | null;
+    duration?: number | null;
+    sourceUrl: string;
+    stats: string;
+    images?: string[];
 }
 export interface PluginConfig {
-    linktextParsing: boolean;
-    VideoParsing_ToLink: '1' | '2' | '3' | '4' | '5';
     Video_ClarityPriority: '1' | '2';
-    BVnumberParsing: boolean;
     Maximumduration: number;
     Maximumduration_tip: string;
     MinimumTimeInterval: number;
     waitTip_Switch: false | string;
+    format: string;
+    bilibiliStatsFormat: string;
+    xiaohongshuStatsFormat: string;
     parseLimit: number;
     useNumeral: boolean;
     showError: boolean;
     bVideoIDPreference: 'bv' | 'av';
-    bVideoImage: boolean;
-    bVideoOwner: boolean;
-    bVideoDesc: boolean;
-    bVideoStat: boolean;
-    bVideoExtraStat: boolean;
-    bVideoShowLink: boolean;
     userAgent: string;
-    loggerinfo: boolean;
-    xhsCover: boolean;
-    xhsDesc: boolean;
-    xhsAuthor: boolean;
-    xhsStat: boolean;
+    logLevel: 'none' | 'link_only' | 'full';
 }
 export interface BilibiliVideoInfo {
     data: {

package/package.json

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