@anyul/koishi-plugin-rss 5.2.2 → 5.2.3

package/lib/commands/subscription-management.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSubscriptionManagementCommands = registerSubscriptionManagementCommands;
+const error_handler_1 = require("../utils/error-handler");
+const error_tracker_1 = require("../utils/error-tracker");
+const logger_1 = require("../utils/logger");
+const utils_1 = require("./utils");
+function registerSubscriptionManagementCommands(deps) {
+    registerListCommand(deps);
+    registerRemoveCommand(deps);
+    registerPullCommand(deps);
+    registerFollowCommand(deps);
+}
+function registerListCommand(deps) {
+    deps.ctx.guild()
+        .command('rssowl.list [id:number]', '查看订阅列表')
+        .alias('rsso.list')
+        .usage(`查看订阅列表
+
+用法:
+  rsso.list              - 查看所有订阅
+  rsso.list 1            - 查看订阅 #1 的详情（使用列表序号）
+    `)
+        .example('rsso.list')
+        .action(async ({ session }, id) => {
+        const { guildId, platform } = (0, utils_1.extractSessionInfo)(session);
+        const rssList = await getGuildSubscriptions(deps.ctx, platform, guildId);
+        if (id === undefined) {
+            if (rssList.length === 0)
+                return '当前没有任何订阅';
+            return rssList.map((item, index) => {
+                const isCrossGroup = item.platform !== platform || item.guildId !== guildId;
+                return `${index + 1}. ${item.title}${isCrossGroup ? ' [跨群]' : ''} [ID:${item.id}]`;
+            }).join('\n');
+        }
+        const rssItem = getSubscriptionByIndex(rssList, id);
+        if (!rssItem)
+            return getSubscriptionNotFoundMessage(id, rssList.length);
+        const followers = rssItem.followers?.length > 0 ? rssItem.followers.join(', ') : '无';
+        const pushTarget = `${rssItem.platform}:${rssItem.guildId}`;
+        const isCrossGroup = rssItem.platform !== platform || rssItem.guildId !== guildId;
+        const targetInfo = isCrossGroup
+            ? `📤 推送目标: ${pushTarget} (跨群订阅)`
+            : `📤 推送目标: ${pushTarget} (本群)`;
+        return `📰 订阅详情 [序号:${id} | ID:${rssItem.id}]
+标题: ${rssItem.title}
+链接: ${rssItem.url}
+类型: ${rssItem.arg?.type || 'RSS'}
+模板: ${rssItem.arg?.template || deps.config.basic.defaultTemplate}
+${targetInfo}
+更新时间: ${rssItem.lastPubDate ? deps.parsePubDate(rssItem.lastPubDate).toLocaleString('zh-CN', { hour12: false }) : '未知'}
+关注者: ${followers}`;
+    });
+}
+function registerRemoveCommand(deps) {
+    deps.ctx.guild()
+        .command('rssowl.remove <id:number>', '删除订阅')
+        .alias('rsso.remove')
+        .usage(`删除订阅
+
+用法:
+  rsso.remove 1           - 删除订阅 #1（使用列表序号）
+  rsso.remove --all       - 删除全部订阅（需要权限）
+    `)
+        .option('all', '--all 删除全部订阅')
+        .example('rsso.remove 1')
+        .action(async ({ session, options }, id) => {
+        const { guildId, platform, authority } = (0, utils_1.extractSessionInfo)(session);
+        if (options.all) {
+            const authorityCheck = (0, utils_1.checkAuthority)(authority, deps.config.basic.authority, `权限不足！当前权限: ${authority}，需要权限: ${deps.config.basic.authority} 或以上`);
+            if (!authorityCheck.success)
+                return authorityCheck.message;
+            await deps.ctx.database.remove('rssOwl', { platform, guildId });
+            return '✅ 已删除全部订阅';
+        }
+        const rssList = await getGuildSubscriptions(deps.ctx, platform, guildId);
+        const rssItem = getSubscriptionByIndex(rssList, id);
+        if (!rssItem)
+            return getSubscriptionNotFoundMessage(id, rssList.length);
+        await deps.ctx.database.remove('rssOwl', { id: rssItem.id });
+        return `✅ 已删除订阅: ${rssItem.title}`;
+    });
+}
+function registerPullCommand(deps) {
+    deps.ctx.guild()
+        .command('rssowl.pull <id:number>', '拉取订阅最新内容')
+        .alias('rsso.pull')
+        .usage(`拉取订阅最新内容
+
+用法:
+  rsso.pull 1             - 拉取订阅 #1 的最新更新（使用列表序号）
+    `)
+        .example('rsso.pull 1')
+        .action(async ({ session }, id) => {
+        const { guildId, platform } = (0, utils_1.extractSessionInfo)(session);
+        const rssList = await getGuildSubscriptions(deps.ctx, platform, guildId);
+        const rssItem = getSubscriptionByIndex(rssList, id);
+        if (!rssItem)
+            return getSubscriptionNotFoundMessage(id, rssList.length);
+        const logContext = {
+            ...(0, utils_1.buildCommandLogContext)(session, 'rsso.pull', 'pull'),
+            subscriptionIndex: id,
+            subscribeId: String(rssItem.id),
+            rssId: rssItem.rssId || rssItem.title,
+            url: rssItem.url,
+        };
+        try {
+            const arg = deps.mixinArg(rssItem.arg || {});
+            const rssItemList = (await Promise.all(String(rssItem.url).split('|')
+                .map(url => deps.parseQuickUrl(url))
+                .map(async (url) => await deps.getRssData(url, arg)))).flat(1);
+            let itemArray = rssItemList.sort((a, b) => deps.parsePubDate(b.pubDate).getTime() - deps.parsePubDate(a.pubDate).getTime());
+            if (arg.reverse)
+                itemArray = itemArray.reverse();
+            const maxItem = arg.forceLength || 1;
+            const messageList = await Promise.all(itemArray
+                .filter((_, index) => index < maxItem)
+                .map(async (item) => await deps.parseRssItem(item, { ...rssItem, ...arg }, rssItem.author)));
+            return messageList.join('');
+        }
+        catch (error) {
+            const normalizedError = (0, error_handler_1.normalizeError)(error);
+            (0, logger_1.debug)(deps.config, normalizedError, 'pull error', 'error', logContext);
+            (0, error_tracker_1.trackError)(normalizedError, logContext);
+            return `拉取失败: ${(0, error_handler_1.getFriendlyErrorMessage)(error, '获取订阅数据')}`;
+        }
+    });
+}
+function registerFollowCommand(deps) {
+    deps.ctx.guild()
+        .command('rssowl.follow <id:number>', '关注订阅')
+        .alias('rsso.follow')
+        .usage(`关注订阅，在该订阅更新时提醒你
+
+用法:
+  rsso.follow 1           - 关注订阅 #1（仅提醒你）
+  rsso.follow 1 --all     - 关注订阅 #1（提醒所有人，需要高级权限）
+    `)
+        .option('all', '--all 提醒所有人')
+        .example('rsso.follow 1')
+        .action(async ({ session, options }, id) => {
+        const { guildId, platform, authorId, authority } = (0, utils_1.extractSessionInfo)(session);
+        const rssList = await getGuildSubscriptions(deps.ctx, platform, guildId);
+        const rssItem = getSubscriptionByIndex(rssList, id);
+        if (!rssItem)
+            return getSubscriptionNotFoundMessage(id, rssList.length);
+        const followers = Array.isArray(rssItem.followers) ? [...rssItem.followers] : [];
+        if (options.all) {
+            const authorityCheck = (0, utils_1.checkAuthority)(authority, deps.config.basic.advancedAuthority, `权限不足！当前权限: ${authority}，需要权限: ${deps.config.basic.advancedAuthority} 或以上`);
+            if (!authorityCheck.success)
+                return authorityCheck.message;
+            if (followers.includes('all'))
+                return '已经设置全员提醒';
+            followers.push('all');
+            await deps.ctx.database.set('rssOwl', { id: rssItem.id }, { followers });
+            return '✅ 已设置全员提醒';
+        }
+        if (followers.includes(authorId))
+            return '已经关注过了';
+        followers.push(authorId);
+        await deps.ctx.database.set('rssOwl', { id: rssItem.id }, { followers });
+        return '✅ 关注成功';
+    });
+}
+async function getGuildSubscriptions(ctx, platform, guildId) {
+    return ctx.database.get('rssOwl', { platform, guildId });
+}
+function getSubscriptionByIndex(rssList, id) {
+    const listIndex = id - 1;
+    if (listIndex < 0 || listIndex >= rssList.length)
+        return null;
+    return rssList[listIndex];
+}
+function getSubscriptionNotFoundMessage(id, total) {
+    return `❌ 序号 ${id} 不存在\n当前共有 ${total} 个订阅\n\n使用 rsso.list 查看完整列表`;
+}

package/lib/commands/utils.d.ts

@@ -21,15 +21,23 @@ export interface SessionInfo {
     authorId: string;
     authority: number;
 }
+export interface ParseTargetsResult {
+    targets: string[];
+    invalidTarget?: string;
+}
 /**
  * 从会话中提取信息
  */
 export declare function extractSessionInfo(session: Session): SessionInfo;
+/**
+ * 构建命令日志上下文
+ */
+export declare function buildCommandLogContext(session: Session, command?: string, operation?: string): Record<string, any>;
 /**
  * 命令错误处理包装器
  * 统一处理命令执行中的错误
  */
-export declare function withCommandErrorHandling(config: Config, operation: string, handler: () => Promise<string>): Promise<string>;
+export declare function withCommandErrorHandling(config: Config, operation: string, handler: () => Promise<string>, context?: Record<string, any>): Promise<string>;
 /**
  * 权限检查辅助函数
  */
@@ -44,6 +52,10 @@ export declare function parseTarget(target: string): {
     platform: string;
     guildId: string;
 } | null;
+/**
+ * 解析多个推送目标
+ */
+export declare function parseTargets(targetInput?: string): ParseTargetsResult;
 /**
  * 验证 URL 格式
  */

package/lib/commands/utils.js

@@ -5,11 +5,14 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractSessionInfo = extractSessionInfo;
+exports.buildCommandLogContext = buildCommandLogContext;
 exports.withCommandErrorHandling = withCommandErrorHandling;
 exports.checkAuthority = checkAuthority;
 exports.parseTarget = parseTarget;
+exports.parseTargets = parseTargets;
 exports.isValidUrl = isValidUrl;
 const error_handler_1 = require("../utils/error-handler");
+const error_tracker_1 = require("../utils/error-tracker");
 const logger_1 = require("../utils/logger");
 /**
  * 从会话中提取信息
@@ -21,13 +24,30 @@ function extractSessionInfo(session) {
     const { authority } = session.user;
     return { guildId, platform, authorId, authority };
 }
+/**
+ * 构建命令日志上下文
+ */
+function buildCommandLogContext(session, command, operation) {
+    const sessionInfo = extractSessionInfo(session);
+    const context = {
+        ...sessionInfo,
+        userId: sessionInfo.authorId,
+    };
+    if (command)
+        context.command = command;
+    if (operation)
+        context.operation = operation;
+    return context;
+}
 /**
  * 命令错误处理包装器
  * 统一处理命令执行中的错误
  */
-function withCommandErrorHandling(config, operation, handler) {
+function withCommandErrorHandling(config, operation, handler, context) {
     return handler().catch((error) => {
-        (0, logger_1.debug)(config, error, `${operation} error`, 'error');
+        const normalizedError = (0, error_handler_1.normalizeError)(error);
+        (0, logger_1.debug)(config, normalizedError, `${operation} error`, 'error', context);
+        (0, error_tracker_1.trackError)(normalizedError, context);
         return Promise.resolve(`${operation}失败: ${(0, error_handler_1.getFriendlyErrorMessage)(error, operation)}`);
     });
 }
@@ -56,6 +76,27 @@ function parseTarget(target) {
         guildId: parts[1]
     };
 }
+/**
+ * 解析多个推送目标
+ */
+function parseTargets(targetInput) {
+    if (!targetInput) {
+        return { targets: [] };
+    }
+    const targets = targetInput
+        .split(/[;,，；]/)
+        .map(target => target.trim())
+        .filter(Boolean);
+    for (const target of targets) {
+        if (!parseTarget(target)) {
+            return {
+                targets: [],
+                invalidTarget: target,
+            };
+        }
+    }
+    return { targets };
+}
 /**
  * 验证 URL 格式
  */

package/lib/config.js

@@ -164,6 +164,16 @@ exports.Config = koishi_1.Schema.object({
         enabled: koishi_1.Schema.boolean().description('启用消息缓存').default(true),
         maxSize: koishi_1.Schema.number().description('最大缓存消息条数').default(100),
     }).description('消息缓存设置'),
+    security: koishi_1.Schema.object({
+        enabled: koishi_1.Schema.boolean().description('启用安全检查（建议开启）').default(false),
+        allowInternalAccess: koishi_1.Schema.boolean().description('允许访问内网 IP 地址（如本地部署的 RSSHub）').default(false),
+        whitelist: koishi_1.Schema.array(koishi_1.Schema.string()).description('URL 白名单域名').default([]),
+        blacklist: koishi_1.Schema.array(koishi_1.Schema.string()).description('URL 黑名单域名').default([]),
+        allowHttp: koishi_1.Schema.boolean().description('允许 HTTP 协议').default(true),
+        allowHttps: koishi_1.Schema.boolean().description('允许 HTTPS 协议').default(true),
+        sanitizeHtml: koishi_1.Schema.boolean().description('启用 RSS 原始 HTML 内容清理').default(true),
+        maxCacheSize: koishi_1.Schema.number().description('AI 摘要缓存最大条数').default(1000),
+    }).description('安全设置'),
     // customUrlEnable:Schema.boolean().description('开发中：允许使用自定义规则对网页进行提取，用于对非RSS链接抓取').default(false).experimental(),
     debug: koishi_1.Schema.union(["disable", "error", "info", "details"]).default("disable").description('调试级别'),
     logging: koishi_1.Schema.object({
@@ -173,5 +183,14 @@ exports.Config = koishi_1.Schema.object({
         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([]),
+        sanitizeLogs: koishi_1.Schema.boolean().description('自动脱敏日志中的敏感信息').default(true),
     }).description('日志设置'),
+    errorTracking: koishi_1.Schema.object({
+        enabled: koishi_1.Schema.boolean().description('启用错误追踪').default(false),
+        dsn: koishi_1.Schema.string().role('secret').description('Sentry DSN').default(''),
+        environment: koishi_1.Schema.string().description('错误追踪环境').default('production'),
+        release: koishi_1.Schema.string().description('错误追踪版本号').default('5.0.0-beta'),
+        tracesSampleRate: koishi_1.Schema.number().min(0).max(1).description('性能追踪采样率').default(0.1),
+        profilesSampleRate: koishi_1.Schema.number().min(0).max(1).description('性能分析采样率').default(0.1),
+    }).description('错误追踪设置'),
 });

package/lib/core/ai.d.ts

@@ -5,7 +5,21 @@ import { Config } from '../types';
 export declare class AiSummaryCache {
     private cache;
     private ttl;
-    constructor(ttl?: number);
+    private maxSize;
+    private accessOrder;
+    constructor(ttl?: number, maxSize?: number);
+    /**
+     * 触发 LRU 淘汰，移除最久未访问的条目
+     */
+    private evictIfNeeded;
+    /**
+     * 更新访问顺序（LRU）
+     */
+    private updateAccessOrder;
+    /**
+     * 从访问顺序中移除指定键
+     */
+    private removeAccessOrder;
     /**
      * 生成缓存键（基于内容的哈希）
      */
@@ -37,7 +51,7 @@ export declare class AiSummaryCache {
 /**
  * 初始化 AI 摘要缓存
  */
-export declare function initAiCache(ttl?: number): void;
+export declare function initAiCache(ttl?: number, maxSize?: number): void;
 /**
  * 生成单条 AI 摘要（带缓存和降级）
  */

package/lib/core/ai.js

@@ -58,8 +58,53 @@ const config_1 = require("../config");
 class AiSummaryCache {
     cache = new Map();
     ttl; // 缓存过期时间（毫秒）
-    constructor(ttl = 24 * 60 * 60 * 1000) {
+    maxSize; // 最大缓存条数
+    accessOrder = [];
+    constructor(ttl = 24 * 60 * 60 * 1000, maxSize = 1000) {
         this.ttl = ttl;
+        this.maxSize = maxSize;
+    }
+    /**
+     * 触发 LRU 淘汰，移除最久未访问的条目
+     */
+    evictIfNeeded() {
+        // 如果缓存未达到最大限制，不需要淘汰
+        // 注意：这里用 > 而不是 >=，确保添加新项后不会超过限制
+        while (this.cache.size >= this.maxSize && this.accessOrder.length > 0) {
+            const oldestKey = this.accessOrder.shift();
+            if (oldestKey && this.cache.has(oldestKey)) {
+                this.cache.delete(oldestKey);
+            }
+            // 防止死循环，如果 accessOrder 为空但 cache 仍满，随机删除一个
+            if (this.accessOrder.length === 0 && this.cache.size >= this.maxSize) {
+                const randomKey = this.cache.keys().next().value;
+                if (randomKey) {
+                    this.cache.delete(randomKey);
+                }
+                break;
+            }
+        }
+    }
+    /**
+     * 更新访问顺序（LRU）
+     */
+    updateAccessOrder(key) {
+        // 从当前位置移除（如果存在）
+        const index = this.accessOrder.indexOf(key);
+        if (index > -1) {
+            this.accessOrder.splice(index, 1);
+        }
+        // 添加到末尾（最近访问）
+        this.accessOrder.push(key);
+    }
+    /**
+     * 从访问顺序中移除指定键
+     */
+    removeAccessOrder(key) {
+        const index = this.accessOrder.indexOf(key);
+        if (index > -1) {
+            this.accessOrder.splice(index, 1);
+        }
     }
     /**
      * 生成缓存键（基于内容的哈希）
@@ -82,8 +127,12 @@ class AiSummaryCache {
         // 检查是否过期
         if (Date.now() - entry.timestamp > this.ttl) {
             this.cache.delete(key);
+            this.removeAccessOrder(key);
             return null;
         }
+        // 更新访问顺序（LRU）
+        this.updateAccessOrder(key);
+        entry.lastAccess = Date.now();
         return entry.summary;
     }
     /**
@@ -91,10 +140,24 @@ class AiSummaryCache {
      */
     set(title, content, summary) {
         const key = this.generateKey(title, content);
+        // 如果已存在，更新访问顺序并更新时间戳
+        if (this.cache.has(key)) {
+            this.updateAccessOrder(key);
+            const entry = this.cache.get(key);
+            entry.summary = summary;
+            entry.timestamp = Date.now();
+            entry.lastAccess = Date.now();
+            return;
+        }
+        // 如果是新条目，先检查是否需要淘汰
+        this.evictIfNeeded();
         this.cache.set(key, {
             summary,
-            timestamp: Date.now()
+            timestamp: Date.now(),
+            lastAccess: Date.now()
         });
+        // 添加到访问顺序
+        this.accessOrder.push(key);
     }
     /**
      * 清除过期缓存
@@ -104,6 +167,7 @@ class AiSummaryCache {
         for (const [key, entry] of this.cache.entries()) {
             if (now - entry.timestamp > this.ttl) {
                 this.cache.delete(key);
+                this.removeAccessOrder(key);
             }
         }
     }
@@ -112,6 +176,7 @@ class AiSummaryCache {
      */
     clear() {
         this.cache.clear();
+        this.accessOrder = [];
     }
     /**
      * 获取缓存统计
@@ -129,10 +194,12 @@ let globalCache = null;
 /**
  * 初始化 AI 摘要缓存
  */
-function initAiCache(ttl) {
+function initAiCache(ttl, maxSize) {
     if (!globalCache) {
-        globalCache = new AiSummaryCache(ttl);
-        (0, logger_1.debug)({ debug: 'info' }, 'AI 摘要缓存已初始化', 'AI-Cache', 'info');
+        // 使用配置中的 maxSize 或默认值 1000
+        const defaultMaxSize = 1000;
+        globalCache = new AiSummaryCache(ttl, maxSize || defaultMaxSize);
+        (0, logger_1.debug)({ debug: 'info' }, `AI 摘要缓存已初始化 (TTL: ${ttl || 24 * 60 * 60 * 1000}ms, MaxSize: ${maxSize || defaultMaxSize})`, 'AI-Cache', 'info');
     }
 }
 /**
@@ -235,7 +302,7 @@ async function getAiSummary(config, title, contentHtml) {
         return '';
     // 初始化缓存（如果还没初始化）
     if (!globalCache) {
-        initAiCache();
+        initAiCache(undefined, config.security?.maxCacheSize);
     }
     // 清洗内容
     const plainText = cleanHtmlContent(contentHtml, config.ai.maxInputLength);

package/lib/core/feeder.d.ts

@@ -17,4 +17,4 @@ export declare function mixinArg(arg: any, config: Config): rssArg;
  */
 export declare function feeder(deps: FeederDependencies, processor: RssItemProcessor): Promise<void>;
 export declare function startFeeder(ctx: Context, config: Config, $http: any, processor: RssItemProcessor, queueManager: NotificationQueueManager): void;
-export declare function stopFeeder(): void;
+export declare function stopFeeder(config?: Config): void;