@anyul/koishi-plugin-rss 5.0.2 → 5.0.4

package/lib/core/notification-queue.js

@@ -0,0 +1,352 @@
+"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.NotificationQueueManager = void 0;
+const logger_1 = require("../utils/logger");
+/**
+ * 消息发送队列管理器
+ */
+class NotificationQueueManager {
+    ctx;
+    config;
+    processing = false;
+    maxRetries = 5;
+    batchSize = 10;
+    // 指数退避时间（秒）：10s, 30s, 1m, 5m, 10m
+    backoffDelays = [10, 30, 60, 300, 600];
+    constructor(ctx, config) {
+        this.ctx = ctx;
+        this.config = config;
+    }
+    /**
+     * 添加任务到队列
+     */
+    async addTask(task) {
+        const queueTask = {
+            ...task,
+            status: 'PENDING',
+            retryCount: 0,
+            createdAt: new Date(),
+            updatedAt: new Date()
+        };
+        await this.ctx.database.create('rss_notification_queue', queueTask);
+        (0, logger_1.debug)(this.config, `任务已加入队列: [${task.rssId}] ${task.content.title}`, 'queue', 'info');
+        return queueTask;
+    }
+    /**
+     * 处理队列中的任务
+     */
+    async processQueue() {
+        if (this.processing) {
+            (0, logger_1.debug)(this.config, '队列正在处理中，跳过本次', 'queue', 'details');
+            return;
+        }
+        this.processing = true;
+        try {
+            // 1. 查找待处理任务
+            const tasks = await this.getPendingTasks();
+            if (tasks.length === 0) {
+                return;
+            }
+            (0, logger_1.debug)(this.config, `开始处理 ${tasks.length} 个待发送任务`, 'queue', 'info');
+            // 2. 逐个处理任务
+            for (const task of tasks) {
+                await this.processTask(task);
+            }
+        }
+        catch (err) {
+            (0, logger_1.debug)(this.config, `队列处理异常: ${err.message}`, 'queue', 'error');
+            console.error('Queue processing error:', err);
+        }
+        finally {
+            this.processing = false;
+        }
+    }
+    /**
+     * 获取待处理任务
+     */
+    async getPendingTasks() {
+        const now = new Date();
+        // 获取所有 PENDING 状态的任务
+        const pendingTasks = await this.ctx.database.get('rss_notification_queue', { status: 'PENDING' }, { limit: this.batchSize });
+        // 获取到达重试时间的 RETRY 状态任务
+        const retryTasks = await this.ctx.database.get('rss_notification_queue', { 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);
+    }
+    /**
+     * 处理单个任务
+     */
+    async processTask(task) {
+        (0, logger_1.debug)(this.config, `处理任务 [${task.rssId}] ${task.content.title} (重试${task.retryCount}次)`, 'queue', 'details');
+        try {
+            // 尝试发送消息
+            await this.sendMessage(task);
+            // 发送成功：标记为 SUCCESS
+            await this.markTaskSuccess(task.id);
+            (0, logger_1.debug)(this.config, `✓ 任务发送成功: [${task.rssId}] ${task.content.title}`, 'queue', 'info');
+            // 写入缓存
+            await this.cacheMessage(task);
+        }
+        catch (error) {
+            // 进入错误处理流程
+            await this.handleSendError(task, error);
+        }
+    }
+    /**
+     * 发送消息（带降级机制）
+     */
+    async sendMessage(task) {
+        const { guildId, platform, content } = task;
+        const target = `${platform}:${guildId}`;
+        try {
+            // 第一次尝试：发送原始消息
+            await this.ctx.broadcast([target], content.message);
+            (0, logger_1.debug)(this.config, `消息发送成功: ${target}`, 'queue', 'details');
+        }
+        catch (sendError) {
+            // OneBot retcode 1200: 不支持的消息格式（通常是视频）
+            const isOneBot1200 = sendError.code?.toString?.() === '1200' || sendError.message?.includes('1200');
+            if (isOneBot1200 && !content.isDowngraded) {
+                (0, logger_1.debug)(this.config, `检测到 OneBot 1200 错误，尝试降级处理`, 'queue', 'info');
+                throw { ...sendError, isMediaError: true, requiresDowngrade: true };
+            }
+            throw sendError;
+        }
+    }
+    /**
+     * 处理发送错误
+     */
+    async handleSendError(task, error) {
+        const errorMsg = error.message || 'Unknown error';
+        // 1. 永久性错误 (Fatal) - 不需要重试
+        if (this.isFatalError(error)) {
+            await this.markTaskFailed(task.id, errorMsg);
+            (0, logger_1.debug)(this.config, `✗ 永久性失败，放弃重试: [${task.rssId}] ${task.content.title} - ${errorMsg}`, 'queue', 'error');
+            return;
+        }
+        // 2. 降级重试 (Downgrade) - 针对媒体格式错误
+        if (error.requiresDowngrade && !task.content.isDowngraded) {
+            const downgradedContent = await this.downgradeMessage(task.content);
+            await this.updateTaskForDowngrade(task.id, downgradedContent);
+            (0, logger_1.debug)(this.config, `→ 消息已降级，立即重试: [${task.rssId}] ${task.content.title}`, 'queue', 'info');
+            return;
+        }
+        // 3. 暂时性错误 (Transient) - 使用指数退避
+        const delay = this.backoffDelays[task.retryCount] || this.backoffDelays[this.backoffDelays.length - 1];
+        const nextTime = new Date(Date.now() + delay * 1000);
+        await this.markTaskRetry(task.id, nextTime, errorMsg);
+        (0, logger_1.debug)(this.config, `→ 任务将在 ${Math.ceil(delay / 60)} 分钟后重试: [${task.rssId}] ${task.content.title}`, 'queue', 'info');
+    }
+    /**
+     * 判断是否为永久性错误
+     */
+    isFatalError(error) {
+        const errorCode = error.code || error.retcode;
+        // 群组不存在 / 账号不在群内
+        if (errorCode === 'UnknownGroup' || errorCode === 'GROUP_NOT_FOUND') {
+            return true;
+        }
+        // 账号被封禁 / 被拉黑
+        if (errorCode === 'UserBlock' || errorCode === 'BANNED') {
+            return true;
+        }
+        // 权限不足
+        if (errorCode === 'PermissionDenied' || errorCode === 'NO_PERMISSION') {
+            return true;
+        }
+        // 超过最大重试次数
+        // 这个判断在调用处处理
+        return false;
+    }
+    /**
+     * 降级消息（移除媒体元素）
+     */
+    async downgradeMessage(content) {
+        // 移除 video 元素，保留视频链接
+        let downgradedMessage = content.message.replace(/<video[^>]*>.*?<\/video>/gis, (match) => {
+            const srcMatch = match.match(/src=["']([^"']+)["']/);
+            if (srcMatch) {
+                return `\n🎬 视频: ${srcMatch[1]}\n`;
+            }
+            return '\n[视频不支持]\n';
+        });
+        // 移除 img 元素，保留图片链接（可选）
+        // downgradedMessage = downgradedMessage.replace(/<img[^>]*>/gis, (match: string) => {
+        //   const srcMatch = match.match(/src=["']([^"']+)["']/)
+        //   if (srcMatch) {
+        //     return `\n🖼️ 图片: ${srcMatch[1]}\n`
+        //   }
+        //   return '\n[图片不支持]\n'
+        // })
+        return {
+            ...content,
+            message: downgradedMessage,
+            isDowngraded: true
+        };
+    }
+    /**
+     * 标记任务为成功
+     */
+    async markTaskSuccess(taskId) {
+        await this.ctx.database.set('rss_notification_queue', { id: taskId }, {
+            status: 'SUCCESS',
+            updatedAt: new Date()
+        });
+        // 可选：定期清理成功任务，避免数据库膨胀
+        // await this.ctx.database.remove(('rss_notification_queue' as any), { id: taskId })
+    }
+    /**
+     * 标记任务为重试
+     */
+    async markTaskRetry(taskId, nextTime, reason) {
+        await this.ctx.database.set('rss_notification_queue', { id: taskId }, {
+            status: 'RETRY',
+            nextRetryTime: nextTime,
+            retryCount: this.ctx.database.get('rss_notification_queue', { id: taskId }).then((tasks) => {
+                return (tasks[0]?.retryCount || 0) + 1;
+            }),
+            failReason: reason,
+            updatedAt: new Date()
+        });
+    }
+    /**
+     * 更新任务为降级重试
+     */
+    async updateTaskForDowngrade(taskId, newContent) {
+        // 获取当前任务
+        const tasks = await this.ctx.database.get('rss_notification_queue', { id: taskId });
+        if (tasks.length === 0)
+            return;
+        const currentTask = tasks[0];
+        await this.ctx.database.set('rss_notification_queue', { id: taskId }, {
+            content: newContent,
+            status: 'RETRY',
+            nextRetryTime: new Date(), // 立即重试
+            retryCount: currentTask.retryCount + 1,
+            updatedAt: new Date()
+        });
+    }
+    /**
+     * 标记任务为失败
+     */
+    async markTaskFailed(taskId, reason) {
+        await this.ctx.database.set('rss_notification_queue', { id: taskId }, {
+            status: 'FAILED',
+            failReason: reason,
+            updatedAt: new Date()
+        });
+    }
+    /**
+     * 缓存成功发送的消息
+     */
+    async cacheMessage(task) {
+        if (!this.config.cache?.enabled) {
+            return;
+        }
+        const { getMessageCache } = await Promise.resolve().then(() => __importStar(require('../utils/message-cache')));
+        const cache = getMessageCache();
+        if (!cache) {
+            return;
+        }
+        try {
+            await cache.addMessage({
+                rssId: task.rssId,
+                guildId: task.guildId,
+                platform: task.platform,
+                title: task.content.title || '',
+                content: task.content.description || '',
+                link: task.content.link || '',
+                pubDate: task.content.pubDate || new Date(),
+                imageUrl: task.content.imageUrl || '',
+                videoUrl: '',
+                finalMessage: task.content.message
+            });
+        }
+        catch (err) {
+            (0, logger_1.debug)(this.config, `缓存消息失败: ${err.message}`, 'cache', 'info');
+        }
+    }
+    /**
+     * 获取队列统计信息
+     */
+    async getStats() {
+        const allTasks = await this.ctx.database.get('rss_notification_queue', {});
+        return {
+            pending: allTasks.filter((t) => t.status === 'PENDING').length,
+            retry: allTasks.filter((t) => t.status === 'RETRY').length,
+            failed: allTasks.filter((t) => t.status === 'FAILED').length,
+            success: allTasks.filter((t) => t.status === 'SUCCESS').length
+        };
+    }
+    /**
+     * 重试失败的任务
+     */
+    async retryFailedTasks(taskId) {
+        const where = taskId ? { id: taskId } : { status: 'FAILED' };
+        const tasks = await this.ctx.database.get('rss_notification_queue', where);
+        for (const task of tasks) {
+            await this.ctx.database.set('rss_notification_queue', { id: task.id }, {
+                status: 'PENDING',
+                retryCount: 0,
+                failReason: null,
+                updatedAt: new Date()
+            });
+        }
+        (0, logger_1.debug)(this.config, `已重置 ${tasks.length} 个失败任务为 PENDING 状态`, 'queue', 'info');
+        return tasks.length;
+    }
+    /**
+     * 清理旧的成功任务
+     */
+    async cleanupSuccessTasks(olderThanHours = 24) {
+        const cutoffTime = new Date(Date.now() - olderThanHours * 60 * 60 * 1000);
+        const tasks = await this.ctx.database.get('rss_notification_queue', { status: 'SUCCESS', updatedAt: { $lt: cutoffTime } });
+        for (const task of tasks) {
+            await this.ctx.database.remove('rss_notification_queue', { id: task.id });
+        }
+        (0, logger_1.debug)(this.config, `已清理 ${tasks.length} 个旧的成功任务`, 'queue', 'info');
+        return tasks.length;
+    }
+}
+exports.NotificationQueueManager = NotificationQueueManager;

package/lib/core/renderer.js

@@ -148,7 +148,8 @@ async function renderHtml2Image(ctx, config, $http, htmlContent, arg) {
         // 使用 domcontentloaded 避免等待视频等慢速资源
         await page.setContent(htmlContent, { waitUntil: 'domcontentloaded', timeout: 15000 });
         if (!config.basic.autoSplitImage) {
-            const image = await page.screenshot({ type: "png" });
+            // 使用 fullPage: true 让截图高度自适应实际内容
+            const image = await page.screenshot({ type: "png", fullPage: true });
             // assets 模式
             if (config.basic.imageMode === 'assets' && ctx.assets) {
                 try {

package/lib/database.js

@@ -34,4 +34,22 @@ function setupDatabase(ctx) {
     }, {
         autoInc: true
     });
+    // 消息发送队列表 - 用于可靠的消息推送
+    ctx.model.extend('rss_notification_queue', {
+        id: "integer",
+        subscribeId: "string", // 关联的订阅ID（rssOwl表的id）
+        rssId: "string", // 订阅源标识（用于显示）
+        uid: "string", // 消息唯一标识 (guid 或 link)
+        guildId: "string", // 目标群组
+        platform: "string", // 目标平台
+        content: "json", // 序列化后的消息内容
+        status: "string", // 状态: PENDING | RETRY | FAILED | SUCCESS
+        retryCount: "integer", // 当前重试次数 (默认0)
+        nextRetryTime: "timestamp", // 下次重试时间
+        createdAt: "timestamp", // 创建时间
+        updatedAt: "timestamp", // 最后更新时间
+        failReason: "text", // 失败原因
+    }, {
+        autoInc: true
+    });
 }