@anyul/koishi-plugin-rss 5.2.2 → 5.2.4

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

@@ -0,0 +1,118 @@
+"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.NotificationQueueSender = void 0;
+exports.downgradeQueueMessage = downgradeQueueMessage;
+const error_handler_1 = require("../utils/error-handler");
+const error_tracker_1 = require("../utils/error-tracker");
+const notification_queue_retry_1 = require("./notification-queue-retry");
+function downgradeQueueMessage(content) {
+    if (content.isDowngraded) {
+        return {
+            ...content,
+            isDowngraded: true,
+        };
+    }
+    const downgradedMessage = content.message.replace(/<video[^>]*>.*?<\/video>/gis, (match) => {
+        const srcMatch = match.match(/src=["']([^"']+)["']/);
+        if (srcMatch) {
+            return `\n🎬 视频: ${srcMatch[1]}\n`;
+        }
+        return '\n[视频不支持]\n';
+    });
+    return {
+        ...content,
+        message: downgradedMessage,
+        isDowngraded: true,
+    };
+}
+class NotificationQueueSender {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async sendMessage(task) {
+        const { guildId, platform, content } = task;
+        const target = `${platform}:${guildId}`;
+        const taskDebug = this.deps.createTaskDebug(task);
+        try {
+            await this.deps.ctx.broadcast([target], content.message);
+            taskDebug(`消息发送成功: ${target}`, 'queue', 'details');
+        }
+        catch (sendError) {
+            if ((0, notification_queue_retry_1.isQueueDowngradeError)(sendError) && !content.isDowngraded) {
+                taskDebug('检测到 OneBot 1200 错误，尝试降级处理', 'queue', 'info', { errorCode: '1200' });
+            }
+            throw sendError;
+        }
+    }
+    async downgradeMessage(content) {
+        return downgradeQueueMessage(content);
+    }
+    async cacheMessage(task) {
+        if (!this.deps.config.cache?.enabled) {
+            return;
+        }
+        const taskDebug = this.deps.createTaskDebug(task);
+        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) {
+            const normalizedError = (0, error_handler_1.normalizeError)(err);
+            taskDebug(`缓存消息失败: ${normalizedError.message}`, 'cache', 'info');
+            (0, error_tracker_1.trackError)(normalizedError, {
+                ...this.deps.buildTaskLogContext(task),
+                operation: 'cacheMessage',
+            });
+        }
+    }
+}
+exports.NotificationQueueSender = NotificationQueueSender;

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

@@ -0,0 +1,19 @@
+import { Context } from 'koishi';
+import { NewQueueTask, QueueCreateResult, QueueStats, QueueTask, QueueTaskContent, QueueTaskIdentity } from './notification-queue-types';
+export declare const RSS_NOTIFICATION_QUEUE_TABLE = "rss_notification_queue";
+export declare class NotificationQueueStore {
+    private ctx;
+    private batchSize;
+    constructor(ctx: Context, batchSize: number);
+    findTaskByIdentity(identity: QueueTaskIdentity): Promise<QueueTask | null>;
+    createTask(task: NewQueueTask): Promise<QueueCreateResult>;
+    getPendingTasks(): Promise<QueueTask[]>;
+    markTaskSuccess(taskId: number): Promise<void>;
+    markTaskRetry(task: QueueTask, nextTime: Date, reason: string): Promise<void>;
+    updateTaskForDowngrade(task: QueueTask, content: QueueTaskContent): Promise<void>;
+    markTaskFailed(taskId: number, reason: string): Promise<void>;
+    recoverRetryTasksWithoutNextRetryTime(): Promise<number>;
+    getStats(): Promise<QueueStats>;
+    retryFailedTasks(taskId?: number): Promise<number>;
+    cleanupSuccessTasks(olderThanHours?: number): Promise<number>;
+}

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

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationQueueStore = exports.RSS_NOTIFICATION_QUEUE_TABLE = void 0;
+exports.RSS_NOTIFICATION_QUEUE_TABLE = 'rss_notification_queue';
+class NotificationQueueStore {
+    ctx;
+    batchSize;
+    constructor(ctx, batchSize) {
+        this.ctx = ctx;
+        this.batchSize = batchSize;
+    }
+    async findTaskByIdentity(identity) {
+        const tasks = await this.ctx.database.get(exports.RSS_NOTIFICATION_QUEUE_TABLE, identity);
+        if (!tasks.length) {
+            return null;
+        }
+        return [...tasks].sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime())[0];
+    }
+    async createTask(task) {
+        const existingTask = await this.findTaskByIdentity({
+            subscribeId: task.subscribeId,
+            uid: task.uid,
+            guildId: task.guildId,
+            platform: task.platform,
+        });
+        if (existingTask) {
+            return {
+                task: existingTask,
+                created: false,
+            };
+        }
+        const queueTask = {
+            ...task,
+            status: 'PENDING',
+            retryCount: 0,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+        const createdTask = await this.ctx.database.create(exports.RSS_NOTIFICATION_QUEUE_TABLE, queueTask);
+        return {
+            task: {
+                ...queueTask,
+                ...createdTask,
+            },
+            created: true,
+        };
+    }
+    async getPendingTasks() {
+        const now = new Date();
+        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);
+    }
+    async markTaskSuccess(taskId) {
+        await this.ctx.database.set(exports.RSS_NOTIFICATION_QUEUE_TABLE, { id: taskId }, {
+            status: 'SUCCESS',
+            nextRetryTime: null,
+            failReason: null,
+            updatedAt: new Date(),
+        });
+    }
+    async markTaskRetry(task, nextTime, reason) {
+        await this.ctx.database.set(exports.RSS_NOTIFICATION_QUEUE_TABLE, { id: task.id }, {
+            status: 'RETRY',
+            nextRetryTime: nextTime,
+            retryCount: (task.retryCount || 0) + 1,
+            failReason: reason,
+            updatedAt: new Date(),
+        });
+    }
+    async updateTaskForDowngrade(task, content) {
+        await this.ctx.database.set(exports.RSS_NOTIFICATION_QUEUE_TABLE, { id: task.id }, {
+            content,
+            status: 'RETRY',
+            nextRetryTime: new Date(),
+            retryCount: (task.retryCount || 0) + 1,
+            failReason: null,
+            updatedAt: new Date(),
+        });
+    }
+    async markTaskFailed(taskId, reason) {
+        await this.ctx.database.set(exports.RSS_NOTIFICATION_QUEUE_TABLE, { id: taskId }, {
+            status: 'FAILED',
+            nextRetryTime: null,
+            failReason: reason,
+            updatedAt: new Date(),
+        });
+    }
+    async recoverRetryTasksWithoutNextRetryTime() {
+        const retryTasks = await this.ctx.database.get(exports.RSS_NOTIFICATION_QUEUE_TABLE, { status: 'RETRY' }, { limit: this.batchSize });
+        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 }, {
+                status: 'RETRY',
+                nextRetryTime: new Date(),
+                updatedAt: new Date(),
+            });
+        }
+        return invalidTasks.length;
+    }
+    async getStats() {
+        const allTasks = await this.ctx.database.get(exports.RSS_NOTIFICATION_QUEUE_TABLE, {});
+        return {
+            pending: allTasks.filter((task) => task.status === 'PENDING').length,
+            retry: allTasks.filter((task) => task.status === 'RETRY').length,
+            failed: allTasks.filter((task) => task.status === 'FAILED').length,
+            success: allTasks.filter((task) => task.status === 'SUCCESS').length,
+        };
+    }
+    async retryFailedTasks(taskId) {
+        const where = taskId ? { id: taskId } : { status: 'FAILED' };
+        const tasks = await this.ctx.database.get(exports.RSS_NOTIFICATION_QUEUE_TABLE, where);
+        const failedTasks = tasks.filter(task => task.status === 'FAILED');
+        for (const task of failedTasks) {
+            await this.ctx.database.set(exports.RSS_NOTIFICATION_QUEUE_TABLE, { id: task.id }, {
+                status: 'PENDING',
+                retryCount: 0,
+                nextRetryTime: null,
+                failReason: null,
+                updatedAt: new Date(),
+            });
+        }
+        return failedTasks.length;
+    }
+    async cleanupSuccessTasks(olderThanHours = 24) {
+        const cutoffTime = new Date(Date.now() - olderThanHours * 60 * 60 * 1000);
+        const tasks = await this.ctx.database.get(exports.RSS_NOTIFICATION_QUEUE_TABLE, { status: 'SUCCESS', 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-types.d.ts

@@ -0,0 +1,49 @@
+export type QueueStatus = 'PENDING' | 'RETRY' | 'FAILED' | 'SUCCESS';
+/**
+ * 队列任务内容
+ */
+export interface QueueTaskContent {
+    message: string;
+    originalItem?: any;
+    isDowngraded?: boolean;
+    title?: string;
+    description?: string;
+    link?: string;
+    pubDate?: Date;
+    imageUrl?: string;
+}
+/**
+ * 队列任务接口
+ */
+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 | null;
+}
+export type NewQueueTask = Omit<QueueTask, 'id' | 'status' | 'retryCount' | 'createdAt' | 'updatedAt'>;
+export interface QueueTaskIdentity {
+    subscribeId: string;
+    uid: string;
+    guildId: string;
+    platform: string;
+}
+export interface QueueCreateResult {
+    task: QueueTask;
+    created: boolean;
+}
+export interface QueueStats {
+    pending: number;
+    retry: number;
+    failed: number;
+    success: number;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,41 +1,7 @@
-/**
- * 消息发送队列管理器
- * 实现可靠的消息推送，支持重试、降级和错误处理
- */
 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;
-}
+import { NewQueueTask, QueueStats, QueueTask } from './notification-queue-types';
+export type { QueueStatus, QueueTask, QueueTaskContent, QueueTaskIdentity, QueueCreateResult } from './notification-queue-types';
 /**
  * 消息发送队列管理器
  */
@@ -43,30 +9,30 @@ export declare class NotificationQueueManager {
     private ctx;
     private config;
     private processing;
-    private maxRetries;
+    private recovered;
     private batchSize;
+    private maxRetries;
+    private cleanupHours;
+    private store;
+    private sender;
     private backoffDelays;
     constructor(ctx: Context, config: Config);
+    private buildTaskLogContext;
+    private createTaskDebug;
     /**
      * 添加任务到队列
      */
-    addTask(task: Omit<QueueTask, 'id' | 'status' | 'retryCount' | 'createdAt' | 'updatedAt'>): Promise<QueueTask>;
+    addTask(task: NewQueueTask): Promise<QueueTask>;
+    isProcessing(): boolean;
+    private ensureRecovered;
     /**
      * 处理队列中的任务
      */
     processQueue(): Promise<void>;
-    /**
-     * 获取待处理任务
-     */
-    private getPendingTasks;
     /**
      * 处理单个任务
      */
     private processTask;
-    /**
-     * 发送消息（带降级机制）
-     */
-    private sendMessage;
     /**
      * 处理发送错误
      */
@@ -79,35 +45,10 @@ export declare class NotificationQueueManager {
      * 降级消息（移除媒体元素）
      */
     private downgradeMessage;
-    /**
-     * 标记任务为成功
-     */
-    private markTaskSuccess;
-    /**
-     * 标记任务为重试
-     */
-    private markTaskRetry;
-    /**
-     * 更新任务为降级重试
-     */
-    private updateTaskForDowngrade;
-    /**
-     * 标记任务为失败
-     */
-    private markTaskFailed;
-    /**
-     * 缓存成功发送的消息
-     */
-    private cacheMessage;
     /**
      * 获取队列统计信息
      */
-    getStats(): Promise<{
-        pending: number;
-        retry: number;
-        failed: number;
-        success: number;
-    }>;
+    getStats(): Promise<QueueStats>;
     /**
      * 重试失败的任务
      */