@anyul/koishi-plugin-rss 5.0.2 → 5.0.4

package/lib/core/feeder.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findRssItem = findRssItem;
 exports.getLastContent = getLastContent;
@@ -10,12 +43,19 @@ exports.stopFeeder = stopFeeder;
 const koishi_1 = require("koishi");
 const logger_1 = require("../utils/logger");
 const common_1 = require("../utils/common");
-const media_1 = require("../utils/media");
 const parser_1 = require("./parser");
 const constants_1 = require("../constants");
-const message_cache_1 = require("../utils/message-cache");
 let interval = null;
+let queueInterval = null;
 function findRssItem(rssList, keyword) {
+    // 优先匹配列表索引（用户看到的序号 1, 2, 3...）
+    if (typeof keyword === 'number' || /^\d+$/.test(String(keyword))) {
+        const listIndex = parseInt(String(keyword)) - 1; // 转换为数组索引（0-based）
+        if (listIndex >= 0 && listIndex < rssList.length) {
+            return rssList[listIndex];
+        }
+    }
+    // 其他匹配方式：按 rssId、url、title 等
     let index = ((rssList.findIndex(i => i.rssId === +keyword) + 1) ||
         (rssList.findIndex(i => i.url == keyword) + 1) ||
         (rssList.findIndex(i => i.url.indexOf(keyword) + 1) + 1) ||
@@ -28,13 +68,23 @@ function getLastContent(item, config) {
     return { ...obj, description: String(obj?.description).replaceAll(/\s/g, '') };
 }
 function formatArg(options, config) {
-    let { arg, template } = options;
+    let { arg, template, auth } = options;
+    // 特殊处理：提取完整的 proxyAgent URL
+    let proxyAgentUrl;
+    if (arg && arg.includes('proxyAgent:')) {
+        const match = arg.match(/proxyAgent:([^,]+)/);
+        if (match) {
+            proxyAgentUrl = match[1];
+            // 从 arg 中移除 proxyAgent，避免被 split(":") 破坏
+            arg = arg.replace(/proxyAgent:[^,]+/, '').replace(/^,|,$/g, '').replace(/,,/g, ',');
+        }
+    }
     let json = Object.assign({}, ...(arg?.split(',')?.map((i) => ({ [i.split(":")[0]]: i.split(":")[1] })) || []));
-    let key = ["forceLength", "reverse", "timeout", "interval", "merge", "maxRssItem", "firstLoad", "bodyWidth", "bodyPadding", "proxyAgent", "auth"];
+    let key = ["forceLength", "reverse", "timeout", "interval", "merge", "maxRssItem", "firstLoad", "bodyWidth", "bodyPadding", "filter", "block"];
     let booleanKey = ['firstLoad', "reverse", 'merge'];
     let numberKey = ['forceLength', "timeout", 'interval', 'maxRssItem', 'bodyWidth', 'bodyPadding'];
     let falseContent = ['false', 'null', ''];
-    json = Object.assign({}, ...Object.keys(json).filter((i) => key.some((key) => key == i)).map((key) => ({ [key]: booleanKey.some((bkey) => bkey == key) ? falseContent.some((c) => c == json[key]) : numberKey.some((nkey) => nkey == key) ? (+json[key]) : json[key] })));
+    json = Object.assign({}, ...Object.keys(json).filter((i) => key.some((key) => key == i)).map((key) => ({ [key]: booleanKey.some((bkey) => bkey == key) ? !falseContent.some((c) => c == json[key]) : numberKey.some((nkey) => nkey == key) ? (+json[key]) : json[key] })));
     if (template && config.template) {
         json['template'] = template;
     }
@@ -48,25 +98,26 @@ function formatArg(options, config) {
         json.filter = json.filter.split("/");
     if (json.block && typeof json.block === 'string')
         json.block = json.block.split("/");
-    // Proxy Argument Parsing
-    if (json.proxyAgent) {
-        if (['false', 'none', ''].includes(String(json.proxyAgent))) {
+    // Proxy Argument Parsing (使用提取的完整 URL)
+    if (proxyAgentUrl) {
+        if (['false', 'none', ''].includes(String(proxyAgentUrl))) {
             json.proxyAgent = { enabled: false };
         }
-        else if (typeof json.proxyAgent === 'string') {
+        else if (typeof proxyAgentUrl === 'string') {
             // Parse string proxy: socks5://127.0.0.1:7890
-            let protocolMatch = json.proxyAgent.match(/^(http|https|socks5)/);
+            let protocolMatch = proxyAgentUrl.match(/^(http|https|socks5)/);
             let protocol = protocolMatch ? protocolMatch[1] : 'http';
-            let hostMatch = json.proxyAgent.match(/:\/\/([^:\/]+)/);
+            let hostMatch = proxyAgentUrl.match(/:\/\/([^:\/]+)/);
             let host = hostMatch ? hostMatch[1] : '';
-            let portMatch = json.proxyAgent.match(/:(\d+)/);
+            let portMatch = proxyAgentUrl.match(/:(\d+)/);
             let port = portMatch ? parseInt(portMatch[1]) : 7890;
-            let proxyAgent = { enabled: true, protocol, host, port };
-            if (json.auth) {
-                let [username, password] = json.auth.split("/");
-                proxyAgent.auth = { username, password };
+            let proxyAgentObj = { enabled: true, protocol, host, port };
+            // Use auth from options if provided
+            if (auth) {
+                let [username, password] = auth.split("/");
+                proxyAgentObj.auth = { username, password };
             }
-            json.proxyAgent = proxyAgent;
+            json.proxyAgent = proxyAgentObj;
         }
     }
     return json;
@@ -148,9 +199,11 @@ function mixinArg(arg, config) {
     (0, logger_1.debug)(config, `[DEBUG_PROXY] mixinArg return: ${JSON.stringify(res.proxyAgent)}`, 'mixin', 'details');
     return res;
 }
+/**
+ * 生产者：抓取 RSS，发现新消息，存入队列
+ */
 async function feeder(deps, processor) {
-    const { ctx, config, $http } = deps;
-    // debug(config, "feeder run", 'debug');
+    const { ctx, config, $http, queueManager } = deps;
     // Use type assertion for custom table
     const rssList = await ctx.database.get('rssOwl', {});
     if (!rssList || rssList.length === 0)
@@ -275,8 +328,9 @@ async function feeder(deps, processor) {
             }
             (0, logger_1.debug)(config, `${rssItem.title}: Found ${rssItemArray.length} new items`, 'feeder', 'info');
             (0, logger_1.debug)(config, rssItemArray.map(i => i.title), '', 'info');
-            // 6. Process Items (Generate Messages)
+            // 6. 生成消息并添加到队列（生产者核心逻辑）
             const itemsToSend = [...rssItemArray].reverse();
+            // 生成所有消息
             const messageList = (await Promise.all(itemsToSend.map(async (i) => await processor.parseRssItem(i, { ...rssItem, ...arg }, rssItem.author)))).filter(m => m); // Filter empty messages
             if (messageList.length === 0) {
                 (0, logger_1.debug)(config, `${rssItem.title}: Items found but parsed to empty messages`, 'feeder', 'info');
@@ -284,7 +338,7 @@ async function feeder(deps, processor) {
                 await ctx.database.set('rssOwl', { id: rssItem.id }, { lastPubDate, arg: originalArg, lastContent: { itemArray: currentContent } });
                 continue;
             }
-            // 7. Construct Final Message
+            // 7. 构建最终消息
             let message = "";
             const shouldMerge = arg.merge === true || config.basic?.merge === '一直合并' || (config.basic?.merge === '有多条更新时合并' && messageList.length > 1);
             // Check for video merge requirement
@@ -300,78 +354,28 @@ async function feeder(deps, processor) {
                 const mentions = rssItem.followers.map((id) => `<at ${id === 'all' ? 'type="all"' : `id="${id}"`}/>`).join(" ");
                 message += `<message>${mentions}</message>`;
             }
-            // 8. Send Broadcast
-            try {
-                (0, logger_1.debug)(config, `Sending update for ${rssItem.title} to ${rssItem.platform}:${rssItem.guildId}`, 'feeder', 'details');
-                // Koishi broadcast 会自动查找可用的 bot，无需手动检查
-                // author 字段兼容用户ID和bot selfId两种格式
-                // 发送消息
-                try {
-                    await ctx.broadcast([`${rssItem.platform}:${rssItem.guildId}`], message);
-                    (0, logger_1.debug)(config, `更新成功:${rssItem.title}`, '', 'info');
-                }
-                catch (sendError) {
-                    // OneBot retcode 1200: 不支持的消息格式（通常是视频）
-                    if (sendError.code?.toString?.() === '1200' || sendError.message?.includes('1200')) {
-                        (0, logger_1.debug)(config, `消息格式不被支持，尝试清理视频元素后重试: ${rssItem.title}`, 'feeder', 'info');
-                        // 移除 video 元素，保留视频链接
-                        const fallbackMessage = message
-                            .replace(/<video[^>]*>.*?<\/video>/gis, (match) => {
-                            // 提取视频 URL
-                            const srcMatch = match.match(/src=["']([^"']+)["']/);
-                            if (srcMatch) {
-                                return `\n🎬 视频: ${srcMatch[1]}\n`;
-                            }
-                            return '\n[视频不支持]\n';
-                        });
-                        try {
-                            await ctx.broadcast([`${rssItem.platform}:${rssItem.guildId}`], fallbackMessage);
-                            (0, logger_1.debug)(config, `降级发送成功:${rssItem.title}`, '', 'info');
-                        }
-                        catch (retryError) {
-                            (0, logger_1.debug)(config, `降级发送也失败: ${retryError.message}`, 'feeder', 'error');
-                            throw retryError;
-                        }
-                    }
-                    else {
-                        throw sendError;
-                    }
-                }
-                // 缓存最终发送的消息
-                if (config.cache?.enabled && messageList.length > 0) {
-                    const cache = (0, message_cache_1.getMessageCache)();
-                    if (cache) {
-                        // 缓存每条消息的最终形式
-                        for (let i = 0; i < itemsToSend.length && i < messageList.length; i++) {
-                            const item = itemsToSend[i];
-                            const finalMsg = messageList[i];
-                            try {
-                                await cache.addMessage({
-                                    rssId: rssItem.rssId.toString(),
-                                    guildId: rssItem.guildId,
-                                    platform: rssItem.platform,
-                                    title: item.title || '',
-                                    content: item.description || '',
-                                    link: item.link || '',
-                                    pubDate: (0, common_1.parsePubDate)(config, item.pubDate),
-                                    imageUrl: item.enclosure?.url || '',
-                                    videoUrl: '',
-                                    finalMessage: finalMsg // 缓存最终发送的消息
-                                });
-                            }
-                            catch (err) {
-                                (0, logger_1.debug)(config, `缓存消息失败: ${err.message}`, 'cache', 'info');
-                            }
-                        }
-                    }
-                }
-            }
-            catch (err) {
-                (0, logger_1.debug)(config, `RSS推送失败 [${rssItem.title}]: ${err.message}`, 'feeder', 'error');
-                console.error(`RSS推送失败 [${rssItem.title}]: ${err.message}`);
-                // 即使发送失败，也要更新数据库状态，避免无限重试
-            }
-            // 9. Update Database State
+            // 8. 添加任务到队列（关键变更：不再直接发送）
+            const taskContent = {
+                message,
+                originalItem: itemsToSend[0],
+                isDowngraded: false,
+                title: itemsToSend[0]?.title,
+                description: itemsToSend[0]?.description,
+                link: itemsToSend[0]?.link,
+                pubDate: (0, common_1.parsePubDate)(config, itemsToSend[0]?.pubDate),
+                imageUrl: itemsToSend[0]?.enclosure?.url
+            };
+            await queueManager.addTask({
+                subscribeId: String(rssItem.id),
+                rssId: rssItem.rssId || rssItem.title,
+                uid: itemsToSend[0]?.link || itemsToSend[0]?.guid || `${Date.now()}`,
+                guildId: rssItem.guildId,
+                platform: rssItem.platform,
+                content: taskContent
+            });
+            (0, logger_1.debug)(config, `✓ 已添加到发送队列: ${rssItem.title}`, 'feeder', 'info');
+            // 9. 更新数据库状态（关键：无论发送是否成功，都更新 lastPubDate）
+            // 这样即使 Bot 掉线，重启后也不会重复发送旧消息
             await ctx.database.set('rssOwl', { id: rssItem.id }, {
                 lastPubDate,
                 arg: originalArg,
@@ -383,21 +387,35 @@ async function feeder(deps, processor) {
         }
     }
 }
-function startFeeder(ctx, config, $http, processor) {
-    const deps = { ctx, config, $http };
+function startFeeder(ctx, config, $http, processor, queueManager) {
+    const deps = { ctx, config, $http, queueManager };
     // Initial run
     feeder(deps, processor).catch(err => console.error("Initial feeder run failed:", err));
+    // 启动生产者定时器（抓取 RSS）
     const refreshInterval = (config.basic?.refresh || 600) * 1000;
     interval = setInterval(async () => {
         if (config.basic?.imageMode === 'File') {
-            await (0, media_1.delCache)(config);
+            const { delCache } = await Promise.resolve().then(() => __importStar(require('../utils/media')));
+            await delCache(config);
         }
         await feeder(deps, processor);
     }, refreshInterval);
+    // 启动消费者定时器（处理发送队列）
+    // 频率更高，确保消息快速发送
+    const queueProcessInterval = 30 * 1000; // 每 30 秒处理一次队列
+    queueInterval = setInterval(async () => {
+        await queueManager.processQueue();
+    }, queueProcessInterval);
+    // 立即处理一次队列（启动时）
+    queueManager.processQueue().catch(err => console.error("Initial queue processing failed:", err));
 }
 function stopFeeder() {
     if (interval) {
         clearInterval(interval);
         interval = null;
     }
+    if (queueInterval) {
+        clearInterval(queueInterval);
+        queueInterval = null;
+    }
 }

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

@@ -0,0 +1,119 @@
+/**
+ * 消息发送队列管理器
+ * 实现可靠的消息推送，支持重试、降级和错误处理
+ */
+import { Context } from 'koishi';
+import { Config } from '../types';
+export type QueueStatus = 'PENDING' | 'RETRY' | 'FAILED' | 'SUCCESS';
+/**
+ * 队列任务接口
+ */
+export interface QueueTask {
+    id?: number;
+    subscribeId: string;
+    rssId: string;
+    uid: string;
+    guildId: string;
+    platform: string;
+    content: QueueTaskContent;
+    status: QueueStatus;
+    retryCount: number;
+    nextRetryTime?: Date;
+    createdAt: Date;
+    updatedAt: Date;
+    failReason?: string;
+}
+/**
+ * 队列任务内容
+ */
+export interface QueueTaskContent {
+    message: string;
+    originalItem?: any;
+    isDowngraded?: boolean;
+    title?: string;
+    description?: string;
+    link?: string;
+    pubDate?: Date;
+    imageUrl?: string;
+}
+/**
+ * 消息发送队列管理器
+ */
+export declare class NotificationQueueManager {
+    private ctx;
+    private config;
+    private processing;
+    private maxRetries;
+    private batchSize;
+    private backoffDelays;
+    constructor(ctx: Context, config: Config);
+    /**
+     * 添加任务到队列
+     */
+    addTask(task: Omit<QueueTask, 'id' | 'status' | 'retryCount' | 'createdAt' | 'updatedAt'>): Promise<QueueTask>;
+    /**
+     * 处理队列中的任务
+     */
+    processQueue(): Promise<void>;
+    /**
+     * 获取待处理任务
+     */
+    private getPendingTasks;
+    /**
+     * 处理单个任务
+     */
+    private processTask;
+    /**
+     * 发送消息（带降级机制）
+     */
+    private sendMessage;
+    /**
+     * 处理发送错误
+     */
+    private handleSendError;
+    /**
+     * 判断是否为永久性错误
+     */
+    private isFatalError;
+    /**
+     * 降级消息（移除媒体元素）
+     */
+    private downgradeMessage;
+    /**
+     * 标记任务为成功
+     */
+    private markTaskSuccess;
+    /**
+     * 标记任务为重试
+     */
+    private markTaskRetry;
+    /**
+     * 更新任务为降级重试
+     */
+    private updateTaskForDowngrade;
+    /**
+     * 标记任务为失败
+     */
+    private markTaskFailed;
+    /**
+     * 缓存成功发送的消息
+     */
+    private cacheMessage;
+    /**
+     * 获取队列统计信息
+     */
+    getStats(): Promise<{
+        pending: number;
+        retry: number;
+        failed: number;
+        success: number;
+    }>;
+    /**
+     * 重试失败的任务
+     */
+    retryFailedTasks(taskId?: number): Promise<number>;
+    /**
+     * 清理旧的成功任务
+     */
+    cleanupSuccessTasks(olderThanHours?: number): Promise<number>;
+}