@anyul/koishi-plugin-rss 5.0.0-beta → 5.0.2

package/README.md

@@ -661,8 +661,36 @@ npm run dev
 
 # 构建
 npm run build
+
+# 运行测试
+npm test
+
+# 生成覆盖率报告
+npm run test:coverage
+
+# 监听模式（开发时使用）
+npm run test:watch
 ```
 
+### 测试
+
+本项目拥有完善的测试套件，包含 165+ 个测试用例，覆盖核心功能模块。
+
+**测试覆盖率**：
+- 语句覆盖率: 90.83%
+- 分支覆盖率: 74.86%
+- 函数覆盖率: 97.43%
+- 行覆盖率: 90.21%
+
+**测试范围**：
+- ✅ 工具函数测试（日期解析、URL处理、内容清理）
+- ✅ HTTP 请求测试（RequestManager、createHttpFunction）
+- ✅ 错误处理测试（友好错误消息、错误类型识别）
+- ✅ 日志系统测试（debug输出、级别过滤）
+- ✅ 集成测试（真实HTTP请求、代理配置）
+
+详见 [TESTING.md](./TESTING.md) 了解更多测试信息。
+
 ## 💬 致谢
 
 本项目基于以下优秀的开源项目：

package/lib/commands/error-handler.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 命令错误处理中间件
+ * 提供统一的错误处理和用户友好的错误消息
+ */
+import { Context } from 'koishi';
+import { Config } from '../types';
+/**
+ * 命令执行结果
+ */
+export interface CommandResult {
+    success: boolean;
+    message: string;
+    error?: any;
+}
+/**
+ * 命令错误类型
+ */
+export declare enum CommandErrorType {
+    PERMISSION_DENIED = "PERMISSION_DENIED",
+    INVALID_ARGUMENT = "INVALID_ARGUMENT",
+    NOT_FOUND = "NOT_FOUND",
+    ALREADY_EXISTS = "ALREADY_EXISTS",
+    NETWORK_ERROR = "NETWORK_ERROR",
+    INTERNAL_ERROR = "INTERNAL_ERROR"
+}
+/**
+ * 命令错误类
+ */
+export declare class CommandError extends Error {
+    type: CommandErrorType;
+    details?: any;
+    constructor(type: CommandErrorType, message: string, details?: any);
+}
+/**
+ * 包装命令执行，提供统一的错误处理
+ */
+export declare function executeCommand(ctx: Context, config: Config, operationName: string, handler: () => Promise<string>): Promise<string>;
+/**
+ * 创建权限检查错误
+ */
+export declare function permissionDenied(customMessage?: string): CommandError;
+/**
+ * 创建参数错误
+ */
+export declare function invalidArgument(message: string): CommandError;
+/**
+ * 创建未找到错误
+ */
+export declare function notFound(resource: string): CommandError;
+/**
+ * 创建已存在错误
+ */
+export declare function alreadyExists(resource: string): CommandError;

package/lib/commands/error-handler.js

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * 命令错误处理中间件
+ * 提供统一的错误处理和用户友好的错误消息
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandError = exports.CommandErrorType = void 0;
+exports.executeCommand = executeCommand;
+exports.permissionDenied = permissionDenied;
+exports.invalidArgument = invalidArgument;
+exports.notFound = notFound;
+exports.alreadyExists = alreadyExists;
+const koishi_1 = require("koishi");
+const error_handler_1 = require("../utils/error-handler");
+const logger = new koishi_1.Logger('rss-owl-command');
+/**
+ * 命令错误类型
+ */
+var CommandErrorType;
+(function (CommandErrorType) {
+    CommandErrorType["PERMISSION_DENIED"] = "PERMISSION_DENIED";
+    CommandErrorType["INVALID_ARGUMENT"] = "INVALID_ARGUMENT";
+    CommandErrorType["NOT_FOUND"] = "NOT_FOUND";
+    CommandErrorType["ALREADY_EXISTS"] = "ALREADY_EXISTS";
+    CommandErrorType["NETWORK_ERROR"] = "NETWORK_ERROR";
+    CommandErrorType["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+})(CommandErrorType || (exports.CommandErrorType = CommandErrorType = {}));
+/**
+ * 命令错误类
+ */
+class CommandError extends Error {
+    type;
+    details;
+    constructor(type, message, details) {
+        super(message);
+        this.type = type;
+        this.details = details;
+        this.name = 'CommandError';
+    }
+}
+exports.CommandError = CommandError;
+/**
+ * 包装命令执行，提供统一的错误处理
+ */
+async function executeCommand(ctx, config, operationName, handler) {
+    try {
+        return await handler();
+    }
+    catch (error) {
+        // 如果是 CommandError，使用自定义消息
+        if (error instanceof CommandError) {
+            logError(config, operationName, error);
+            return formatCommandError(error);
+        }
+        // 其他错误使用友好错误消息
+        logError(config, operationName, error);
+        const friendlyMessage = (0, error_handler_1.getFriendlyErrorMessage)(error, operationName);
+        return `${operationName}失败: ${friendlyMessage}`;
+    }
+}
+/**
+ * 记录命令错误
+ */
+function logError(config, operation, error) {
+    if (config.debug === 'details' || config.debug === 'error') {
+        logger.error(`[${operation}]`, error);
+    }
+}
+/**
+ * 格式化命令错误消息
+ */
+function formatCommandError(error) {
+    switch (error.type) {
+        case CommandErrorType.PERMISSION_DENIED:
+            return error.message;
+        case CommandErrorType.INVALID_ARGUMENT:
+            return `参数错误: ${error.message}`;
+        case CommandErrorType.NOT_FOUND:
+            return `未找到: ${error.message}`;
+        case CommandErrorType.ALREADY_EXISTS:
+            return `已存在: ${error.message}`;
+        case CommandErrorType.NETWORK_ERROR:
+            return `网络错误: ${error.message}`;
+        default:
+            return error.message || '操作失败，请稍后重试';
+    }
+}
+/**
+ * 创建权限检查错误
+ */
+function permissionDenied(customMessage) {
+    return new CommandError(CommandErrorType.PERMISSION_DENIED, customMessage || '权限不足');
+}
+/**
+ * 创建参数错误
+ */
+function invalidArgument(message) {
+    return new CommandError(CommandErrorType.INVALID_ARGUMENT, message);
+}
+/**
+ * 创建未找到错误
+ */
+function notFound(resource) {
+    return new CommandError(CommandErrorType.NOT_FOUND, resource);
+}
+/**
+ * 创建已存在错误
+ */
+function alreadyExists(resource) {
+    return new CommandError(CommandErrorType.ALREADY_EXISTS, resource);
+}

package/lib/commands/rss-subscribe.d.ts

@@ -0,0 +1,11 @@
+/**
+ * RSS 订阅命令
+ * 处理 RSS 订阅的添加、删除、列表、关注等操作
+ */
+import { Context } from 'koishi';
+import { Config } from '../types';
+import { RssItemProcessor } from '../core/item-processor';
+/**
+ * 注册 RSS 订阅命令
+ */
+export declare function registerRssSubscribeCommand(ctx: Context, config: Config, processor: RssItemProcessor, getRssDataLocal: (url: string, arg: any) => Promise<any[]>, parseRssItem: (item: any, arg: any, authorId: string | number) => Promise<string>, parseQuickUrlLocal: (url: string) => string, parsePubDateLocal: (pubDate: any) => Date): void;

package/lib/commands/rss-subscribe.js

@@ -0,0 +1,323 @@
+"use strict";
+/**
+ * RSS 订阅命令
+ * 处理 RSS 订阅的添加、删除、列表、关注等操作
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRssSubscribeCommand = registerRssSubscribeCommand;
+const constants_1 = require("../constants");
+const feeder_1 = require("../core/feeder");
+const common_1 = require("../utils/common");
+const logger_1 = require("../utils/logger");
+const utils_1 = require("./utils");
+const error_handler_1 = require("./error-handler");
+/**
+ * 注册 RSS 订阅命令
+ */
+function registerRssSubscribeCommand(ctx, config, processor, getRssDataLocal, parseRssItem, parseQuickUrlLocal, parsePubDateLocal) {
+    const usage = 'RSS 订阅命令\n' +
+        '用法:\n' +
+        '  rsso <url>              - 订阅 RSS\n' +
+        '  rsso -l                 - 查看订阅列表\n' +
+        '  rsso -r <id>            - 删除订阅\n' +
+        '  rsso -p <id>            - 拉取最新内容\n' +
+        '  rsso -f <id>            - 关注订阅\n';
+    ctx.guild()
+        .command('rssowl <url:text>', '*订阅 RSS 链接*')
+        .alias('rsso')
+        .usage(usage)
+        .option('list', '-l [content] 查看订阅列表(详情)')
+        .option('remove', '-r <content> [订阅id|关键字] *删除订阅*')
+        .option('removeAll', '*删除全部订阅*')
+        .option('follow', '-f <content> [订阅id|关键字] 关注订阅，在该订阅更新时提醒你')
+        .option('followAll', '<content> [订阅id|关键字] **在该订阅更新时提醒所有人**')
+        .option('target', '<content> [群组id] **跨群订阅**')
+        .option('arg', '-a <content> 自定义配置')
+        .option('template', '-i <content> 消息模板[content(文字模板)|default(图片模板)],更多见readme')
+        .option('title', '-t <content> 自定义命名')
+        .option('pull', '-p <content> [订阅id|关键字]拉取订阅id最后更新')
+        .option('force', '强行写入')
+        .option('daily', '-d <content>')
+        .option('test', '-T 测试')
+        .option('quick', '-q [content] 查询快速订阅列表')
+        .example('rsso https://hub.slarker.me/qqorw')
+        .action(async ({ session, options }, url) => {
+        return (0, error_handler_1.executeCommand)(ctx, config, '订阅', () => handleRssCommand(ctx, config, processor, session, options, url, getRssDataLocal, parseRssItem, parseQuickUrlLocal, parsePubDateLocal));
+    });
+}
+/**
+ * 处理 RSS 订阅命令
+ */
+async function handleRssCommand(ctx, config, processor, session, options, url, getRssDataLocal, parseRssItem, parseQuickUrlLocal, parsePubDateLocal) {
+    const { guildId, platform, authorId, authority } = (0, utils_1.extractSessionInfo)(session);
+    (0, logger_1.debug)(config, options, 'options', 'info');
+    (0, logger_1.debug)(config, `${platform}:${authorId}:${guildId}`, '', 'info');
+    // 处理快速订阅查询
+    if (options?.quick !== undefined) {
+        return handleQuickList(options.quick);
+    }
+    // 沙盒环境提示
+    if (platform.includes('sandbox') && !options.test && url) {
+        session.send('沙盒中无法推送更新，但RSS依然会被订阅，建议使用 -T 选项进行测试');
+    }
+    // 获取当前订阅列表
+    const rssList = await ctx.database.get('rssOwl', { platform, guildId });
+    // 处理列表选项
+    if (options?.list !== undefined) {
+        return handleList(rssList, options.list, parsePubDateLocal);
+    }
+    // 处理删除选项
+    if (options?.remove) {
+        return handleRemove(ctx, rssList, options.remove, authority);
+    }
+    // 处理删除全部选项
+    if (options?.removeAll) {
+        return handleRemoveAll(ctx, rssList, authority);
+    }
+    // 处理关注选项
+    if (options?.follow) {
+        return handleFollow(ctx, rssList, options.follow, authorId);
+    }
+    // 处理全员关注选项
+    if (options?.followAll) {
+        return handleFollowAll(ctx, rssList, options.followAll, authority);
+    }
+    // 处理拉取选项
+    if (options?.pull) {
+        return handlePull(ctx, config, rssList, options.pull, parseRssItem, getRssDataLocal, parseQuickUrlLocal, parsePubDateLocal, feeder_1.mixinArg);
+    }
+    // 处理订阅 URL
+    if (url) {
+        return handleSubscribe(ctx, config, session, rssList, url, options, platform, guildId, authorId, authority, getRssDataLocal, parseRssItem, parseQuickUrlLocal, parsePubDateLocal, feeder_1.formatArg);
+    }
+    return '用法: rsso <url> 或 rsso -l 查看订阅列表';
+}
+/**
+ * 处理快速订阅列表查询
+ */
+function handleQuickList(quick) {
+    if (quick === '') {
+        return '输入 rsso -q [id] 查询详情\n' +
+            constants_1.quickList.map((v, i) => `${i + 1}.${v.name}`).join('\n');
+    }
+    const index = parseInt(quick) - 1;
+    if (index < 0 || index >= constants_1.quickList.length) {
+        return '无效的 ID';
+    }
+    const quickObj = constants_1.quickList[index];
+    return `${quickObj.name}\n${quickObj.detail}\n` +
+        `例:rsso -T ${quickObj.example}\n(${(0, common_1.parseQuickUrl)(quickObj.example, '', [])})`;
+}
+/**
+ * 处理列表查询
+ */
+function handleList(rssList, listOption, parsePubDateLocal) {
+    (0, logger_1.debug)(config, rssList, 'rssList', 'info');
+    if (rssList.length === 0) {
+        return '当前没有任何订阅';
+    }
+    // 简单列表
+    if (listOption === '') {
+        return rssList.map((v, i) => `${i + 1}. ${v.title} [${v.id}]`).join('\n');
+    }
+    // 详细列表
+    const rssItem = (0, feeder_1.findRssItem)(rssList, listOption);
+    if (!rssItem) {
+        throw (0, error_handler_1.notFound)('未找到该订阅');
+    }
+    const lastPubDate = rssItem.lastPubDate
+        ? parsePubDateLocal(rssItem.lastPubDate).toLocaleString('zh-CN', { hour12: false })
+        : '未知';
+    return `标题: ${rssItem.title}\n` +
+        `链接: ${rssItem.url}\n` +
+        `更新时间: ${lastPubDate}`;
+}
+/**
+ * 处理删除订阅
+ */
+async function handleRemove(ctx, rssList, identifier, authority) {
+    const authCheck = (0, utils_1.checkAuthority)(authority, ctx.config.basic.authority);
+    if (!authCheck.success) {
+        throw (0, error_handler_1.permissionDenied)();
+    }
+    const rssItem = (0, feeder_1.findRssItem)(rssList, identifier);
+    if (!rssItem) {
+        throw (0, error_handler_1.notFound)('未找到该订阅');
+    }
+    await ctx.database.remove('rssOwl', rssItem.id);
+    return '删除成功';
+}
+/**
+ * 处理删除全部订阅
+ */
+async function handleRemoveAll(ctx, rssList, authority) {
+    const authCheck = (0, utils_1.checkAuthority)(authority, ctx.config.basic.authority);
+    if (!authCheck.success) {
+        throw (0, error_handler_1.permissionDenied)();
+    }
+    await ctx.database.remove('rssOwl', { platform, guildId });
+    return '删除成功';
+}
+/**
+ * 处理关注订阅
+ */
+async function handleFollow(ctx, rssList, identifier, authorId) {
+    const rssItem = (0, feeder_1.findRssItem)(rssList, identifier);
+    if (!rssItem) {
+        throw (0, error_handler_1.notFound)('未找到该订阅');
+    }
+    if (!rssItem.followers) {
+        rssItem.followers = [];
+    }
+    if (rssItem.followers.includes(authorId)) {
+        return '已经关注过了';
+    }
+    rssItem.followers.push(authorId);
+    await ctx.database.set('rssOwl', { id: rssItem.id }, { followers: rssItem.followers });
+    return '关注成功';
+}
+/**
+ * 处理全员关注
+ */
+async function handleFollowAll(ctx, rssList, identifier, authority) {
+    const authCheck = (0, utils_1.checkAuthority)(authority, ctx.config.basic.advancedAuthority);
+    if (!authCheck.success) {
+        throw (0, error_handler_1.permissionDenied)();
+    }
+    const rssItem = (0, feeder_1.findRssItem)(rssList, identifier);
+    if (!rssItem) {
+        throw (0, error_handler_1.notFound)('未找到该订阅');
+    }
+    if (!rssItem.followers) {
+        rssItem.followers = [];
+    }
+    rssItem.followers.push('all');
+    await ctx.database.set('rssOwl', { id: rssItem.id }, { followers: rssItem.followers });
+    return '关注成功';
+}
+/**
+ * 处理拉取最新内容
+ */
+async function handlePull(ctx, config, rssList, identifier, parseRssItem, getRssDataLocal, parseQuickUrlLocal, parsePubDateLocal, mixinArg) {
+    const rssItem = (0, feeder_1.findRssItem)(rssList, identifier);
+    if (!rssItem) {
+        throw (0, error_handler_1.notFound)('未找到该订阅');
+    }
+    const arg = mixinArg(rssItem.arg || {});
+    const rssItemList = (await Promise.all(rssItem.url.split('|')
+        .map((url) => parseQuickUrlLocal(url))
+        .map(async (url) => await getRssDataLocal(url, arg)))).flat(1);
+    let itemArray = rssItemList.sort((a, b) => parsePubDateLocal(b.pubDate).getTime() - parsePubDateLocal(a.pubDate).getTime());
+    if (arg.reverse) {
+        itemArray = itemArray.reverse();
+    }
+    const maxItem = arg.forceLength || 1;
+    const messageList = await Promise.all(itemArray
+        .filter((v, i) => i < maxItem)
+        .map(i => parseRssItem(i, { ...rssItem, ...arg }, rssItem.author)));
+    return messageList.join('');
+}
+/**
+ * 处理新订阅
+ */
+async function handleSubscribe(ctx, config, session, rssList, url, options, platform, guildId, authorId, authority, getRssDataLocal, parseRssItem, parseQuickUrlLocal, parsePubDateLocal, formatArg) {
+    // 检查是否已存在
+    if (rssList.find(i => i.url === url)) {
+        throw new Error('该订阅已存在');
+    }
+    const arg = formatArg(options);
+    let targetPlatform = platform;
+    let targetGuildId = guildId;
+    // 处理跨群订阅
+    if (options?.target) {
+        const authCheck = (0, utils_1.checkAuthority)(authority, config.basic.advancedAuthority);
+        if (!authCheck.success) {
+            throw (0, error_handler_1.permissionDenied)();
+        }
+        const target = (0, utils_1.parseTarget)(options.target);
+        if (!target) {
+            throw new Error('请输入正确的群号，格式为 platform:guildId 或 platform：guildId');
+        }
+        targetPlatform = target.platform;
+        targetGuildId = target.guildId;
+    }
+    let title = options?.title || '';
+    url = parseQuickUrlLocal(url);
+    url = (0, common_1.ensureUrlProtocol)(url);
+    // 获取 RSS 数据
+    const rssItemList = await getRssDataLocal(url, arg);
+    // 测试模式
+    if (options.test) {
+        return handleTestMode(rssItemList, arg, title, config, parseRssItem, authorId);
+    }
+    // 获取标题
+    if (!title) {
+        title = rssItemList[0]?.rss?.channel?.title;
+        if (!title) {
+            throw new Error('无法获取标题，请使用 -t 指定标题');
+        }
+    }
+    // 检查权限（force 模式）
+    if (options.force && authority < config.basic.authority) {
+        throw (0, error_handler_1.permissionDenied)();
+    }
+    // 检查去重
+    if (config.basic.urlDeduplication && rssList.find(i => i.rssId === title)) {
+        throw new Error(`订阅已存在: ${title}`);
+    }
+    // 创建订阅项
+    const lastPubDate = parsePubDateLocal(rssItemList[0]?.pubDate);
+    const rssItem = {
+        url,
+        platform: targetPlatform,
+        guildId: targetGuildId,
+        author: authorId,
+        rssId: rssItemList[0]?.rss?.channel?.title || title,
+        arg,
+        title,
+        lastPubDate,
+        lastContent: [],
+        followers: [],
+        firstime: lastPubDate
+    };
+    await ctx.database.create('rssOwl', rssItem);
+    // 首次加载
+    if (config.basic.firstLoad && arg.firstLoad !== false && rssItemList.length > 0) {
+        await loadInitialItems(ctx, rssItemList, rssItem, targetPlatform, targetGuildId, parsePubDateLocal, parseRssItem);
+    }
+    return `订阅成功: ${title}`;
+}
+/**
+ * 处理测试模式
+ */
+async function handleTestMode(rssItemList, arg, title, config, parseRssItem, authorId) {
+    const testItem = rssItemList[0];
+    if (!testItem) {
+        throw new Error('未获取到数据');
+    }
+    const testArg = {
+        ...arg,
+        url: title || testItem.rss.channel.title,
+        title: title || testItem.rss.channel.title
+    };
+    if (!testArg.template) {
+        testArg.template = config.basic.defaultTemplate;
+    }
+    const msg = await parseRssItem(testItem, testArg, authorId);
+    return msg;
+}
+/**
+ * 加载初始条目
+ */
+async function loadInitialItems(ctx, rssItemList, rssItem, targetPlatform, targetGuildId, parsePubDateLocal, parseRssItem) {
+    let itemArray = rssItemList.sort((a, b) => parsePubDateLocal(b.pubDate).getTime() - parsePubDateLocal(a.pubDate).getTime());
+    if (rssItem.arg.reverse) {
+        itemArray = itemArray.reverse();
+    }
+    const maxItem = rssItem.arg.forceLength || 1;
+    const messageList = await Promise.all(itemArray
+        .filter((v, i) => i < maxItem)
+        .map(i => parseRssItem(i, { ...rssItem, ...rssItem.arg }, rssItem.author)));
+    const message = messageList.join('');
+    await ctx.broadcast([`${targetPlatform}:${targetGuildId}`], message);
+}

package/lib/commands/utils.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 命令辅助函数
+ * 提供命令共享的工具函数
+ */
+import { Context, Session } from 'koishi';
+import { Config } from '../types';
+/**
+ * 命令执行上下文
+ */
+export interface CommandContext {
+    ctx: Context;
+    session: Session;
+    config: Config;
+}
+/**
+ * 会话信息提取
+ */
+export interface SessionInfo {
+    guildId: string;
+    platform: string;
+    authorId: string;
+    authority: number;
+}
+/**
+ * 从会话中提取信息
+ */
+export declare function extractSessionInfo(session: Session): SessionInfo;
+/**
+ * 命令错误处理包装器
+ * 统一处理命令执行中的错误
+ */
+export declare function withCommandErrorHandling(config: Config, operation: string, handler: () => Promise<string>): Promise<string>;
+/**
+ * 权限检查辅助函数
+ */
+export declare function checkAuthority(authority: number, required: number, customMessage?: string): {
+    success: boolean;
+    message?: string;
+};
+/**
+ * 解析目标群组
+ */
+export declare function parseTarget(target: string): {
+    platform: string;
+    guildId: string;
+} | null;
+/**
+ * 验证 URL 格式
+ */
+export declare function isValidUrl(url: string): boolean;

package/lib/commands/utils.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * 命令辅助函数
+ * 提供命令共享的工具函数
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractSessionInfo = extractSessionInfo;
+exports.withCommandErrorHandling = withCommandErrorHandling;
+exports.checkAuthority = checkAuthority;
+exports.parseTarget = parseTarget;
+exports.isValidUrl = isValidUrl;
+const error_handler_1 = require("../utils/error-handler");
+const logger_1 = require("../utils/logger");
+/**
+ * 从会话中提取信息
+ */
+function extractSessionInfo(session) {
+    const { id: guildId } = session.event.guild;
+    const { platform } = session.event;
+    const { id: authorId } = session.event.user;
+    const { authority } = session.user;
+    return { guildId, platform, authorId, authority };
+}
+/**
+ * 命令错误处理包装器
+ * 统一处理命令执行中的错误
+ */
+function withCommandErrorHandling(config, operation, handler) {
+    return handler().catch((error) => {
+        (0, logger_1.debug)(config, error, `${operation} error`, 'error');
+        return Promise.resolve(`${operation}失败: ${(0, error_handler_1.getFriendlyErrorMessage)(error, operation)}`);
+    });
+}
+/**
+ * 权限检查辅助函数
+ */
+function checkAuthority(authority, required, customMessage) {
+    if (authority >= required) {
+        return { success: true };
+    }
+    return {
+        success: false,
+        message: customMessage || '权限不足'
+    };
+}
+/**
+ * 解析目标群组
+ */
+function parseTarget(target) {
+    const parts = target.split(/[:：]/);
+    if (parts.length !== 2) {
+        return null;
+    }
+    return {
+        platform: parts[0],
+        guildId: parts[1]
+    };
+}
+/**
+ * 验证 URL 格式
+ */
+function isValidUrl(url) {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/lib/config.js

@@ -24,6 +24,8 @@ exports.Config = koishi_1.Schema.object({
         autoSplitImage: koishi_1.Schema.boolean().description('垂直拆分大尺寸图片，解决部分适配器发不出长图的问题').default(true),
         cacheDir: koishi_1.Schema.string().description('File模式时使用的缓存路径').default('data/cache/rssOwl'),
         replaceDir: koishi_1.Schema.string().description('缓存替换路径，仅在使用docker部署时需要设置').default(''),
+        maxImageSize: koishi_1.Schema.number().description('图片最大文件大小限制（MB），超出限制的图片将被跳过').default(30),
+        maxVideoSize: koishi_1.Schema.number().description('视频最大文件大小限制（MB），超出限制的视频将被跳过').default(30),
     }).description('基础设置'),
     template: koishi_1.Schema.object({
         bodyWidth: koishi_1.Schema.number().description('puppeteer图片的宽度(px)，较低的值可能导致排版错误，仅在非custom的模板生效').default(600),
@@ -92,6 +94,18 @@ exports.Config = koishi_1.Schema.object({
         maxInputLength: koishi_1.Schema.number().description('发送给 AI 的最大字数限制').default(2000),
         timeout: koishi_1.Schema.number().description('AI 请求超时时间(毫秒)').default(30000),
     }).description('AI 摘要设置'),
+    cache: koishi_1.Schema.object({
+        enabled: koishi_1.Schema.boolean().description('启用消息缓存').default(true),
+        maxSize: koishi_1.Schema.number().description('最大缓存消息条数').default(100),
+    }).description('消息缓存设置'),
     // customUrlEnable:Schema.boolean().description('开发中：允许使用自定义规则对网页进行提取，用于对非RSS链接抓取').default(false).experimental(),
-    debug: koishi_1.Schema.union(["disable", "error", "info", "details"]).default("disable"),
+    debug: koishi_1.Schema.union(["disable", "error", "info", "details"]).default("disable").description('调试级别'),
+    logging: koishi_1.Schema.object({
+        structured: koishi_1.Schema.boolean().description('启用结构化日志（JSON格式）').default(false),
+        includeTimestamp: koishi_1.Schema.boolean().description('包含时间戳').default(true),
+        includeLevel: koishi_1.Schema.boolean().description('包含日志级别').default(true),
+        includeModule: koishi_1.Schema.boolean().description('包含模块名').default(true),
+        includeContext: koishi_1.Schema.boolean().description('包含额外上下文信息').default(false),
+        contextFields: koishi_1.Schema.array(koishi_1.Schema.string()).description('要包含的上下文字段（如 guildId, platform 等）').default([]),
+    }).description('日志设置'),
 });