@anyul/koishi-plugin-rss 5.3.4 → 5.3.10

package/lib/commands/index.js

@@ -287,7 +287,7 @@ async function handleCacheList(cmdCtx, args, config) {
     }
 }
 async function handleCacheMessage(cmdCtx, args, config) {
-    const { cache, logContext } = cmdCtx;
+    const { logContext } = cmdCtx;
     const realId = parseInt(args[0]);
     if (!realId || realId < 1) {
         return '请提供真实 ID\n用法: rsso.cache message <ID>\n示例: rsso.cache message 42\n💡 提示：使用 "rsso.cache list" 查看方括号中的真实 ID';

package/lib/commands/subscription-create.d.ts

@@ -1,4 +1,5 @@
 import { Context } from 'koishi';
+import { SubscriptionStore } from '../core/subscription-store';
 import type { Config } from '../types';
 export interface QuickListItem {
     prefix: string;
@@ -20,6 +21,7 @@ export declare function resolveQuickItem(input: string, quickList: QuickListItem
 export interface SubscriptionCreateCommandDeps {
     ctx: Context;
     config: Config;
+    store: SubscriptionStore;
     usage: string;
     quickList: QuickListItem[];
     parseQuickUrl: (url: string) => string;

package/lib/commands/subscription-create.js

@@ -71,7 +71,7 @@ function registerSubscriptionCreateCommand(deps) {
         if (!(0, utils_1.isValidUrl)((0, common_1.ensureUrlProtocol)(url))) {
             return '❌ URL 格式不正确，请以 http:// 或 https:// 开头';
         }
-        const rssList = await deps.ctx.database.get('rssOwl', { platform, guildId });
+        const rssList = await deps.store.findByGuild(platform, guildId);
         if (rssList.find(item => item.url === url))
             return '❌ 该订阅已存在';
         const rawArg = deps.formatArg(options);
@@ -137,7 +137,7 @@ function registerSubscriptionCreateCommand(deps) {
             else if (deps.config.basic.urlDeduplication && rssList.find(item => item.rssId === rssItem.rssId)) {
                 return `❌ 订阅已存在: ${rssItem.rssId}`;
             }
-            await deps.ctx.database.create('rssOwl', rssItem);
+            await deps.store.create(rssItem);
             if (deps.config.basic.firstLoad && arg.firstLoad !== false && rssItemList.length > 0) {
                 let itemArray = rssItemList.sort((a, b) => deps.parsePubDate(b.pubDate).getTime() - deps.parsePubDate(a.pubDate).getTime());
                 if (arg.reverse)

package/lib/commands/subscription-edit.d.ts

@@ -1,7 +1,9 @@
 import { Context } from 'koishi';
+import { SubscriptionStore } from '../core/subscription-store';
 import type { Config } from '../types';
 export interface SubscriptionEditCommandDeps {
     ctx: Context;
     config: Config;
+    store: SubscriptionStore;
 }
 export declare function registerSubscriptionEditCommand(deps: SubscriptionEditCommandDeps): void;

package/lib/commands/subscription-edit.js

@@ -37,7 +37,7 @@ function registerSubscriptionEditCommand(deps) {
         .example('rsso.edit 1 -t "新标题"')
         .action(async ({ session, options }, id) => {
         const { guildId, platform, authority } = (0, utils_1.extractSessionInfo)(session);
-        const rssList = await deps.ctx.database.get('rssOwl', { platform, guildId });
+        const rssList = await deps.store.findByGuild(platform, guildId);
         const listIndex = id - 1;
         if (listIndex < 0 || listIndex >= rssList.length) {
             return `❌ 序号 ${id} 不存在\n当前共有 ${rssList.length} 个订阅\n\n使用 rsso.list 查看完整列表`;
@@ -62,7 +62,7 @@ function registerSubscriptionEditCommand(deps) {
         if (options.test) {
             return buildEditPreview(rssItem, id, options, parseResult.targets);
         }
-        return saveSubscriptionChanges(deps.ctx, rssItem, id, options, parseResult.targets);
+        return saveSubscriptionChanges(deps.store, rssItem, id, options, parseResult.targets);
     });
 }
 function buildEditPreview(rssItem, id, options, parsedTargets) {
@@ -90,7 +90,7 @@ function buildEditPreview(rssItem, id, options, parsedTargets) {
     testOutput += '\n⚠️ 测试模式：不会保存修改\n去掉 --test 选项保存更改';
     return testOutput;
 }
-async function saveSubscriptionChanges(ctx, rssItem, id, options, parsedTargets) {
+async function saveSubscriptionChanges(store, rssItem, id, options, parsedTargets) {
     const updates = {};
     if (options.title)
         updates.title = options.title;
@@ -114,7 +114,7 @@ async function saveSubscriptionChanges(ctx, rssItem, id, options, parsedTargets)
                 const [newPlatform, newGuildId] = parsedTargets[0].split(/[:：]/);
                 updates.platform = newPlatform;
                 updates.guildId = newGuildId;
-                await ctx.database.set('rssOwl', rssItem.id, updates);
+                await store.update(rssItem.id, updates);
                 let result = `✅ 订阅已更新 [序号:${id} | ID:${rssItem.id}]\n\n`;
                 if (options.title)
                     result += `标题: ${rssItem.title} → ${options.title}\n`;
@@ -131,14 +131,10 @@ async function saveSubscriptionChanges(ctx, rssItem, id, options, parsedTargets)
             let result = `✅ 订阅已更新 [序号:${id} | ID:${rssItem.id}]\n\n`;
             result += `已创建 ${parsedTargets.length} 个推送目标:\n\n`;
             result += `1. 原订阅 (本群): ${originalTarget}\n`;
-            await ctx.database.set('rssOwl', rssItem.id, updates);
+            await store.update(rssItem.id, updates);
             for (let i = 0; i < parsedTargets.length; i++) {
                 const [newPlatform, newGuildId] = parsedTargets[i].split(/[:：]/);
-                const existing = await ctx.database.get('rssOwl', {
-                    platform: newPlatform,
-                    guildId: newGuildId,
-                    url: rssItem.url
-                });
+                const existing = await store.findByGuildAndUrl(newPlatform, newGuildId, rssItem.url);
                 if (existing.length > 0) {
                     result += `${i + 2}. ⚠️ ${newPlatform}:${newGuildId} (订阅已存在，已跳过)\n`;
                     continue;
@@ -149,7 +145,7 @@ async function saveSubscriptionChanges(ctx, rssItem, id, options, parsedTargets)
                     platform: newPlatform,
                     guildId: newGuildId,
                 };
-                const created = await ctx.database.create('rssOwl', newSubscription);
+                const created = await store.create(newSubscription);
                 result += `${i + 2}. ✅ ${newPlatform}:${newGuildId} (新订阅ID: ${created.id})\n`;
             }
             if (options.title)
@@ -159,7 +155,7 @@ async function saveSubscriptionChanges(ctx, rssItem, id, options, parsedTargets)
             result += '\n💡 提示: 可以使用 rsso.list 查看所有订阅';
             return result.trim();
         }
-        await ctx.database.set('rssOwl', rssItem.id, updates);
+        await store.update(rssItem.id, updates);
         let result = `✅ 订阅已更新 [序号:${id} | ID:${rssItem.id}]\n\n`;
         if (options.title)
             result += `标题: ${rssItem.title} → ${options.title}\n`;

package/lib/commands/subscription-management.d.ts

@@ -1,8 +1,10 @@
 import { Context } from 'koishi';
+import { SubscriptionStore } from '../core/subscription-store';
 import type { Config } from '../types';
 export interface SubscriptionCommandDeps {
     ctx: Context;
     config: Config;
+    store: SubscriptionStore;
     parsePubDate: (pubDate: any) => Date;
     parseQuickUrl: (url: string) => string;
     getRssData: (url: string, arg: any) => Promise<any[]>;

package/lib/commands/subscription-management.js

@@ -23,7 +23,7 @@ function registerListCommand(deps) {
         .example('rsso.list')
         .action(async ({ session }, id) => {
         const { guildId, platform } = (0, utils_1.extractSessionInfo)(session);
-        const rssList = await getGuildSubscriptions(deps.ctx, platform, guildId);
+        const rssList = await getGuildSubscriptions(deps.store, platform, guildId);
         if (id === undefined) {
             if (rssList.length === 0)
                 return '当前没有任何订阅';
@@ -69,14 +69,14 @@ function registerRemoveCommand(deps) {
             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 });
+            await deps.store.removeAllByGuild(platform, guildId);
             return '✅ 已删除全部订阅';
         }
-        const rssList = await getGuildSubscriptions(deps.ctx, platform, guildId);
+        const rssList = await getGuildSubscriptions(deps.store, platform, guildId);
         const rssItem = getSubscriptionByIndex(rssList, id);
         if (!rssItem)
             return getSubscriptionNotFoundMessage(id, rssList.length);
-        await deps.ctx.database.remove('rssOwl', { id: rssItem.id });
+        await deps.store.remove(rssItem.id);
         return `✅ 已删除订阅: ${rssItem.title}`;
     });
 }
@@ -92,7 +92,7 @@ function registerPullCommand(deps) {
         .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 rssList = await getGuildSubscriptions(deps.store, platform, guildId);
         const rssItem = getSubscriptionByIndex(rssList, id);
         if (!rssItem)
             return getSubscriptionNotFoundMessage(id, rssList.length);
@@ -138,7 +138,7 @@ function registerFollowCommand(deps) {
         .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 rssList = await getGuildSubscriptions(deps.store, platform, guildId);
         const rssItem = getSubscriptionByIndex(rssList, id);
         if (!rssItem)
             return getSubscriptionNotFoundMessage(id, rssList.length);
@@ -150,18 +150,18 @@ function registerFollowCommand(deps) {
             if (followers.includes('all'))
                 return '💡 已经设置全员提醒';
             followers.push('all');
-            await deps.ctx.database.set('rssOwl', { id: rssItem.id }, { followers });
+            await deps.store.update(rssItem.id, { followers });
             return '✅ 已设置全员提醒';
         }
         if (followers.includes(authorId))
             return '💡 已经关注过了';
         followers.push(authorId);
-        await deps.ctx.database.set('rssOwl', { id: rssItem.id }, { followers });
+        await deps.store.update(rssItem.id, { followers });
         return '✅ 关注成功';
     });
 }
-async function getGuildSubscriptions(ctx, platform, guildId) {
-    return ctx.database.get('rssOwl', { platform, guildId });
+async function getGuildSubscriptions(store, platform, guildId) {
+    return store.findByGuild(platform, guildId);
 }
 function getSubscriptionByIndex(rssList, id) {
     const listIndex = id - 1;

package/lib/commands/web-monitor.d.ts

@@ -1,4 +1,5 @@
 import { Context } from 'koishi';
+import { SubscriptionStore } from '../core/subscription-store';
 import type { Config, TemplateType, rssArg } from '../types';
 type DebugType = 'disable' | 'error' | 'info' | 'details';
 type HtmlMonitorArg = rssArg & {
@@ -21,6 +22,7 @@ interface WatchCommandOptions {
 export interface WebMonitorCommandDeps {
     ctx: Context;
     config: Config;
+    store: SubscriptionStore;
     debug: (message: any, name?: string, type?: DebugType, context?: Record<string, any>) => void;
     mixinArg: (arg: Record<string, any>) => rssArg;
     getRssData: (url: string, arg: Record<string, any>) => Promise<any[]>;

package/lib/commands/web-monitor.js

@@ -55,7 +55,7 @@ HTML 网页监控功能，使用 CSS 选择器提取内容
                     return '❌ 未找到符合选择器的元素';
                 return buildItemsPreview(items, `找到 ${items.length} 个元素:`, true);
             }
-            const rssList = await deps.ctx.database.get('rssOwl', { platform, guildId });
+            const rssList = await deps.store.findByGuild(platform, guildId);
             if (rssList.find(item => item.url === normalizedUrl))
                 return '❌ 该订阅已存在';
             const htmlItems = await deps.getRssData(normalizedUrl, arg);
@@ -77,7 +77,7 @@ HTML 网页监控功能，使用 CSS 选择器提取内容
             if (deps.config.basic.urlDeduplication && rssList.find(item => item.rssId === rssItem.rssId)) {
                 return `❌ 订阅已存在: ${rssItem.rssId}`;
             }
-            await deps.ctx.database.create('rssOwl', rssItem);
+            await deps.store.create(rssItem);
             if (deps.config.basic.firstLoad && arg.firstLoad !== false && htmlItems.length > 0) {
                 await broadcastInitialItems(deps, `${platform}:${guildId}`, htmlItems, rssItem);
             }

package/lib/config.js

@@ -54,10 +54,12 @@ exports.Config = koishi_1.Schema.object({
         maxRssItem: koishi_1.Schema.number().description('限制更新时的最大推送数量上限，超出上限时较早的更新会被忽略').default(10),
         firstLoad: koishi_1.Schema.boolean().description('首次订阅时是否发送最后的更新').default(true),
         urlDeduplication: koishi_1.Schema.boolean().description('同群组中不允许重复添加相同订阅').default(true),
-        resendUpdataContent: koishi_1.Schema.union(['disable', 'latest', 'all']).description('当内容更新时再次发送').default('disable').experimental(),
+        resendUpdatedContent: koishi_1.Schema.union(['disable', 'latest', 'all']).description('当内容更新时再次发送').default('disable'),
+        resendUpdataContent: koishi_1.Schema.union(['disable', 'latest', 'all']).description('（已弃用，请使用 resendUpdatedContent）').hidden().deprecated(),
         imageMode: koishi_1.Schema.union(['base64', 'File', 'assets']).description('图片发送模式<br>\`base64\` Base64格式（兼容性好但容易超长）<br>\`File\` 本地文件（不支持沙盒环境）<br>\`assets\` Assets服务（推荐，需安装assets-xxx插件并配置）').default('base64'),
         videoMode: koishi_1.Schema.union(['filter', 'href', 'base64', 'File', 'assets']).description('视频发送模式（iframe标签内的视频无法处理）<br>\`filter\` 过滤视频，含有视频的推送将不会被发送<br>\`href\` 使用视频网络地址直接发送<br>\`base64\` 下载后以base64格式发送<br>\`File\` 下载后以文件发送<br>\`assets\` 上传到assets服务（需安装assets-xxx插件并配置）').default('href'),
-        margeVideo: koishi_1.Schema.boolean().default(false).description('以合并消息发送视频'),
+        mergeVideo: koishi_1.Schema.boolean().default(false).description('以合并消息发送视频'),
+        margeVideo: koishi_1.Schema.boolean().description('（已弃用，请使用 mergeVideo）').hidden().deprecated(),
         usePoster: koishi_1.Schema.boolean().default(false).description('加载视频封面'),
         autoSplitImage: koishi_1.Schema.boolean().description('垂直拆分大尺寸图片，解决部分适配器发不出长图的问题').default(true),
         cacheDir: koishi_1.Schema.string().description('File模式时使用的缓存路径').default('data/cache/rssOwl'),

package/lib/core/feeder.js

@@ -53,6 +53,12 @@ Object.defineProperty(exports, "findRssItem", { enumerable: true, get: function
 Object.defineProperty(exports, "getLastContent", { enumerable: true, get: function () { return feeder_runtime_2.getLastContent; } });
 let interval = null;
 let queueInterval = null;
+let cleanupInterval = null;
+// 重入栅栏：feeder() 单轮可能跑很久（订阅多 + 网络/tdl 慢），
+// 若耗时超过 refreshInterval，下一次 interval tick 会并发启动第二个 feeder()，
+// 导致同一消息被重复入队（addTask 的读-写去重非原子）→ 重复推送。
+// 仿照 NotificationQueueManager.processQueue 的 processing 标志，单轮串行。
+let feederRunning = false;
 function shouldSkipByInterval(rssItem, arg, originalArg) {
     if (!rssItem.arg.interval)
         return false;
@@ -174,11 +180,36 @@ async function feeder(deps, processor) {
     }
 }
 function startFeeder(ctx, config, $http, processor, queueManager) {
+    // 幂等清理：若上一实例的 interval 尚未清理（未走 dispose 就再次 startFeeder），
+    // 先清掉旧句柄，避免 ghost 定时器泄漏。
+    if (interval) {
+        clearInterval(interval);
+        interval = null;
+    }
+    if (queueInterval) {
+        clearInterval(queueInterval);
+        queueInterval = null;
+    }
+    if (cleanupInterval) {
+        clearInterval(cleanupInterval);
+        cleanupInterval = null;
+    }
     const deps = { ctx, config, $http, queueManager };
     const lifecycleDebug = (0, logger_1.createDebugWithContext)(config, { lifecycle: 'feeder' });
     const queueRuntimeConfig = (0, notification_queue_retry_1.getQueueRuntimeConfig)(config);
+    // 受重入栅栏保护的 feeder 运行：避免上一轮未跑完时下一轮并发启动
+    const runFeederGuarded = () => {
+        if (feederRunning) {
+            (0, logger_1.debug)(config, 'feeder 上一轮仍在运行，跳过本次 tick', 'feeder', 'details', { skipped: true });
+            return Promise.resolve();
+        }
+        feederRunning = true;
+        return feeder(deps, processor).finally(() => {
+            feederRunning = false;
+        });
+    };
     // Initial run
-    feeder(deps, processor).catch(err => {
+    runFeederGuarded().catch(err => {
         const normalizedError = (0, error_handler_1.normalizeError)(err);
         lifecycleDebug(`Initial feeder run failed: ${normalizedError.message}`, 'feeder', 'error', {
             operation: 'initial-feeder-run',
@@ -191,7 +222,7 @@ function startFeeder(ctx, config, $http, processor, queueManager) {
             const { delCache } = await Promise.resolve().then(() => __importStar(require('../utils/media')));
             await delCache(config);
         }
-        await feeder(deps, processor);
+        await runFeederGuarded();
     }, refreshInterval);
     // 启动消费者定时器（处理发送队列）
     // 频率更高，确保消息快速发送
@@ -199,6 +230,20 @@ function startFeeder(ctx, config, $http, processor, queueManager) {
     queueInterval = setInterval(async () => {
         await queueManager.processQueue();
     }, queueProcessInterval);
+    // 启动清理定时器：周期性删除过期的 SUCCESS/FAILED 任务，
+    // 防止 rss_notification_queue 表无限膨胀拖慢查询（此前只手动命令清理）。
+    // 每小时一次，cleanupHours 控制具体保留时长。
+    cleanupInterval = setInterval(async () => {
+        try {
+            await queueManager.runAutomaticCleanup();
+        }
+        catch (err) {
+            const normalizedError = (0, error_handler_1.normalizeError)(err);
+            lifecycleDebug(`自动清理失败: ${normalizedError.message}`, 'queue', 'error', {
+                operation: 'automatic-cleanup',
+            });
+        }
+    }, 60 * 60 * 1000);
     // 立即处理一次队列（启动时）
     queueManager.processQueue().catch(err => {
         const normalizedError = (0, error_handler_1.normalizeError)(err);
@@ -220,6 +265,12 @@ function stopFeeder(config) {
         clearInterval(queueInterval);
         queueInterval = null;
     }
+    if (cleanupInterval) {
+        clearInterval(cleanupInterval);
+        cleanupInterval = null;
+    }
+    // 复位栅栏：避免上一轮未跑完就 stopFeeder 后，下次 startFeeder 时栅栏卡死
+    feederRunning = false;
     if (config) {
         const lifecycleDebug = (0, logger_1.createDebugWithContext)(config, { lifecycle: 'feeder' });
         lifecycleDebug('Feeder stopped', 'feeder', 'info');

package/lib/core/notification-queue-store.d.ts

@@ -16,4 +16,11 @@ export declare class NotificationQueueStore {
     getStats(): Promise<QueueStats>;
     retryFailedTasks(taskId?: number): Promise<number>;
     cleanupSuccessTasks(olderThanHours?: number): Promise<number>;
+    /**
+     * 清理旧的 FAILED 任务。
+     *
+     * 与 SUCCESS 对称：FAILED 任务此前只进不出（无清理命令、无定时器），
+     * 长期运行会无限堆积，拖慢 getStats / getPendingTasks 的全表查询。
+     */
+    cleanupFailedTasks(olderThanHours?: number): Promise<number>;
 }

package/lib/core/notification-queue-store.js

@@ -46,13 +46,18 @@ class NotificationQueueStore {
         };
     }
     async getPendingTasks() {
-        const now = new Date();
+        const now = Date.now();
         const pendingTasks = await this.ctx.database.get(exports.RSS_NOTIFICATION_QUEUE_TABLE, { status: 'PENDING' }, { limit: this.batchSize });
         const retryTasks = await this.ctx.database.get(exports.RSS_NOTIFICATION_QUEUE_TABLE, { status: 'RETRY' }, { limit: this.batchSize });
-        const readyRetryTasks = retryTasks.filter(task => task.nextRetryTime && new Date(task.nextRetryTime) <= now);
-        return [...pendingTasks, ...readyRetryTasks]
-            .sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime())
-            .slice(0, this.batchSize);
+        const readyRetryTasks = retryTasks.filter(task => task.nextRetryTime && new Date(task.nextRetryTime).getTime() <= now);
+        // PENDING 优先于 RETRY：避免一个持续高频失败的源因其 RETRY 任务 createdAt 较老
+        // 而长期占用 batchSize 槽位，把新订阅的新消息饿死（延迟数分钟才发）。
+        // 各组内部仍按 createdAt 升序（先入先出）。
+        const byCreatedAsc = (a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime();
+        return [
+            ...pendingTasks.sort(byCreatedAsc),
+            ...readyRetryTasks.sort(byCreatedAsc),
+        ].slice(0, this.batchSize);
     }
     async markTaskSuccess(taskId) {
         await this.ctx.database.set(exports.RSS_NOTIFICATION_QUEUE_TABLE, { id: taskId }, {
@@ -90,7 +95,10 @@ class NotificationQueueStore {
         });
     }
     async recoverRetryTasksWithoutNextRetryTime() {
-        const retryTasks = await this.ctx.database.get(exports.RSS_NOTIFICATION_QUEUE_TABLE, { status: 'RETRY' }, { limit: this.batchSize });
+        // 不限制 limit：损坏的 RETRY 任务可能 > batchSize（老版本升级 / DB 手工修改），
+        // 若只修前 batchSize 条，剩余的会因 nextRetryTime 永远为空而既不重试也不失败，永久卡住。
+        // 本操作幂等（只修 nextRetryTime 为空的），可安全重复执行。
+        const retryTasks = await this.ctx.database.get(exports.RSS_NOTIFICATION_QUEUE_TABLE, { status: 'RETRY' });
         const invalidTasks = retryTasks.filter(task => !task.nextRetryTime);
         for (const task of invalidTasks) {
             await this.ctx.database.set(exports.RSS_NOTIFICATION_QUEUE_TABLE, { id: task.id }, {
@@ -133,5 +141,19 @@ class NotificationQueueStore {
         }
         return tasks.length;
     }
+    /**
+     * 清理旧的 FAILED 任务。
+     *
+     * 与 SUCCESS 对称：FAILED 任务此前只进不出（无清理命令、无定时器），
+     * 长期运行会无限堆积，拖慢 getStats / getPendingTasks 的全表查询。
+     */
+    async cleanupFailedTasks(olderThanHours = 168) {
+        const cutoffTime = new Date(Date.now() - olderThanHours * 60 * 60 * 1000);
+        const tasks = await this.ctx.database.get(exports.RSS_NOTIFICATION_QUEUE_TABLE, { status: 'FAILED', updatedAt: { $lt: cutoffTime } });
+        for (const task of tasks) {
+            await this.ctx.database.remove(exports.RSS_NOTIFICATION_QUEUE_TABLE, { id: task.id });
+        }
+        return tasks.length;
+    }
 }
 exports.NotificationQueueStore = NotificationQueueStore;

package/lib/core/notification-queue.d.ts

@@ -57,4 +57,14 @@ export declare class NotificationQueueManager {
      * 清理旧的成功任务
      */
     cleanupSuccessTasks(olderThanHours?: number): Promise<number>;
+    /**
+     * 自动清理：周期性删除过期的 SUCCESS / FAILED 任务。
+     *
+     * SUCCESS 用 cleanupHours，FAILED 用 7×cleanupHours（失败记录保留更久便于排查，
+     * 但仍需回收，否则永久堆积拖慢全表查询）。供 feeder 定时器调用。
+     */
+    runAutomaticCleanup(): Promise<{
+        success: number;
+        failed: number;
+    }>;
 }

package/lib/core/notification-queue.js

@@ -211,5 +211,23 @@ class NotificationQueueManager {
         });
         return cleanupCount;
     }
+    /**
+     * 自动清理：周期性删除过期的 SUCCESS / FAILED 任务。
+     *
+     * SUCCESS 用 cleanupHours，FAILED 用 7×cleanupHours（失败记录保留更久便于排查，
+     * 但仍需回收，否则永久堆积拖慢全表查询）。供 feeder 定时器调用。
+     */
+    async runAutomaticCleanup() {
+        const success = await this.store.cleanupSuccessTasks(this.cleanupHours);
+        // FAILED 保留时长为 SUCCESS 的 7 倍（默认 7 天），兼顾排查与回收
+        const failed = await this.store.cleanupFailedTasks(this.cleanupHours * 7);
+        if (success > 0 || failed > 0) {
+            (0, logger_1.debug)(this.config, `自动清理：${success} 个成功任务、${failed} 个失败任务`, 'queue', 'info', {
+                cleanupSuccess: success,
+                cleanupFailed: failed,
+            });
+        }
+        return { success, failed };
+    }
 }
 exports.NotificationQueueManager = NotificationQueueManager;

package/lib/core/parser.js

@@ -76,7 +76,7 @@ async function getRssData(ctx, config, $http, url, arg) {
                     try {
                         await page.waitForSelector(arg.waitSelector, { timeout: 5000 });
                     }
-                    catch (e) { }
+                    catch { }
                 }
                 else if (arg.waitFor) {
                     await new Promise(r => setTimeout(r, arg.waitFor));
@@ -93,7 +93,7 @@ async function getRssData(ctx, config, $http, url, arg) {
                 try {
                     await page.close();
                 }
-                catch (e) { /* 忽略页面已关闭的错误 */ }
+                catch { /* 忽略页面已关闭的错误 */ }
             }
         }
         else {
@@ -113,7 +113,7 @@ async function getRssData(ctx, config, $http, url, arg) {
                 rssData = JSON.parse(rssData);
                 isJson = true;
             }
-            catch (e) { /* ignore */ }
+            catch { /* ignore */ }
         }
         if (isJson) {
             (0, logger_1.debug)(config, rssData, 'JSON Feed Response', 'details');
@@ -178,7 +178,7 @@ async function getRssData(ctx, config, $http, url, arg) {
                     try {
                         link = new URL(link, url).href;
                     }
-                    catch (e) { }
+                    catch { }
                 }
                 // 3. 提取内容
                 const description = arg.textOnly ? $el.text().trim() : ($el.html() || '').trim();
@@ -217,7 +217,7 @@ async function getRssData(ctx, config, $http, url, arg) {
         }
         else if (rssJson.feed) {
             // Atom
-            let rss = { channel: {} };
+            const rss = { channel: {} };
             let item = rssJson.feed.entry.map(i => ({
                 ...i,
                 title: (0, common_1.parseContent)(i.title),

package/lib/core/renderer.js

@@ -137,7 +137,7 @@ async function preprocessHtmlImages(ctx, config, $http, htmlContent, arg) {
     return $.html();
 }
 async function renderHtml2Image(ctx, config, $http, htmlContent, arg) {
-    let page = await ctx.puppeteer.page();
+    const page = await ctx.puppeteer.page();
     try {
         (0, logger_1.debug)(config, htmlContent, 'htmlContent', 'details');
         const initialViewportHeight = 2000;
@@ -265,15 +265,15 @@ async function renderHtml2Image(ctx, config, $http, htmlContent, arg) {
             return koishi_1.h.image(image, 'image/png');
         }
         let height = actualHeight;
-        let width = clipWidth;
-        let x = clipX;
-        let y = clipY;
+        const width = clipWidth;
+        const x = clipX;
+        const y = clipY;
         // 保守处理：如果高度异常，使用更小的值
         if (height > 5000) {
             (0, logger_1.debug)(config, `检测到异常高度 ${height}，进行裁剪`, 'height warn', 'info');
             height = Math.min(height, 2000);
         }
-        let size = 10000;
+        const size = 10000;
         (0, logger_1.debug)(config, [height, width, x, y], 'pptr img size', 'details');
         const split = Math.ceil(height / size);
         if (!split) {
@@ -298,7 +298,7 @@ async function renderHtml2Image(ctx, config, $http, htmlContent, arg) {
         const reduceY = (index) => Math.floor(height / split * index);
         // 最后一份使用完整高度减去前面所有份的高度，确保覆盖全部内容
         const reduceHeight = (index) => index === split - 1 ? height - reduceY(index) : Math.floor(height / split);
-        let imgData = await Promise.all(Array.from({ length: split }, async (v, i) => await page.screenshot({
+        const imgData = await Promise.all(Array.from({ length: split }, async (v, i) => await page.screenshot({
             type: "png",
             clip: {
                 x,
@@ -329,6 +329,6 @@ async function renderHtml2Image(ctx, config, $http, htmlContent, arg) {
         try {
             await page.close();
         }
-        catch (e) { /* 忽略页面已关闭的错误 */ }
+        catch { /* 忽略页面已关闭的错误 */ }
     }
 }

package/lib/core/search-format.d.ts

@@ -1,3 +1,3 @@
 import { SearchResponse } from './search-types';
 export declare function formatSearchResults(response: SearchResponse): string;
-export declare function buildPromptWithSearchContext(originalPrompt: string, searchResults: SearchResponse, searchQuery: string): string;
+export declare function buildPromptWithSearchContext(originalPrompt: string, searchResults: SearchResponse, _searchQuery: string): string;

package/lib/core/search-format.js

@@ -21,7 +21,7 @@ function formatSearchResults(response) {
     });
     return lines.join('\n');
 }
-function buildPromptWithSearchContext(originalPrompt, searchResults, searchQuery) {
+function buildPromptWithSearchContext(originalPrompt, searchResults, _searchQuery) {
     if (!searchResults.success || searchResults.results.length === 0) {
         return originalPrompt;
     }

package/lib/core/subscription-store.d.ts

@@ -0,0 +1,44 @@
+import { Context } from 'koishi';
+import type { RssOwlRow } from '../types';
+/**
+ * 订阅数据访问仓储（Repository）。
+ *
+ * 设计目的：`rssOwl` 是订阅核心表，原本被命令层（subscription-create /
+ * subscription-edit / subscription-management / web-monitor）的 15 处
+ * 直接 `ctx.database.*('rssOwl', ...)` 调用散落访问，违反「命令层只复用
+ * 核心函数」的分层约定。本类作为该表的唯一封装，命令层通过依赖注入拿到
+ * 实例，不再直接触碰 `ctx.database`，与 `NotificationQueueStore` /
+ * `MessageCacheManager` 的既有分层保持一致。
+ *
+ * 注意：feeder（`core/feeder.ts`）也在核心层直接读写 `rssOwl`，那是核心层
+ * 对自身数据的合法访问，不强制走本仓储；强制收口会破坏 feeder 作为纯函数
+ * 的可测试性（见 5.3.8 的 disposed 评估取舍）。
+ */
+export declare class SubscriptionStore {
+    private ctx;
+    constructor(ctx: Context);
+    /**
+     * 按群组查询订阅列表（命令层最常用的读取入口）。
+     */
+    findByGuild(platform: string, guildId: string): Promise<RssOwlRow[]>;
+    /**
+     * 按 群组 + URL 查询（用于编辑推送目标时判断目标群是否已有同源订阅）。
+     */
+    findByGuildAndUrl(platform: string, guildId: string, url: string): Promise<RssOwlRow[]>;
+    /**
+     * 创建一条订阅，返回含生成主键的完整行。
+     */
+    create(data: Partial<RssOwlRow>): Promise<RssOwlRow>;
+    /**
+     * 按主键更新任意字段。
+     */
+    update(id: number, patch: Partial<RssOwlRow>): Promise<void>;
+    /**
+     * 按主键删除单条订阅。
+     */
+    remove(id: number): Promise<void>;
+    /**
+     * 删除某个群组的全部订阅（rsso.remove --all）。
+     */
+    removeAllByGuild(platform: string, guildId: string): Promise<void>;
+}