koishi-plugin-wordpress-notifier 2.8.4 → 2.9.0

package/README.md

@@ -389,6 +389,19 @@ npm install
 
 ## 版本历史
 
+### 2.8.5 (2026-02-19)
+
+- 🐛 修复 MySQL 主键约束错误 (ER_PRIMARY_CANT_HAVE_NULL)
+
+**核心修复**
+- ✅ 增强 `checkAndFixTableStructure` 函数，添加对 `wordpress_version` 表的验证和修复逻辑
+- ✅ 确保所有数据库表的主键约束正确设置，避免 NULL 值问题
+- ✅ 优化表结构初始化过程，确保所有表都能正确创建和初始化
+
+**稳定性提升**
+- ✅ 提高插件在 MySQL 数据库环境下的稳定性
+- ✅ 增强数据库表结构异常情况下的恢复能力
+
 ### 2.8.4 (2026-02-19)
 
 - 🔧 版本更新和文档完善

package/lib/index.d.ts

@@ -10,12 +10,12 @@ declare module 'koishi' {
     }
 }
 export interface WordPressVersionRecord {
-    id: number;
+    id: string;
     version: string;
     updatedAt: Date;
 }
 export interface WordPressConfigRecord {
-    id: number;
+    id: string;
     key: string;
     value: string;
     updatedAt: Date;
@@ -50,7 +50,7 @@ export interface Config {
     };
 }
 export interface WordPressPost {
-    id: number;
+    id: string;
     title: {
         rendered: string;
     };
@@ -60,12 +60,12 @@ export interface WordPressPost {
     excerpt: {
         rendered: string;
     };
-    author: number;
-    categories: number[];
-    tags: number[];
+    author: string;
+    categories: string[];
+    tags: string[];
 }
 export interface WordPressUser {
-    id: number;
+    id: string;
     name: string;
     slug: string;
     date?: string;

package/lib/index.js

@@ -129,22 +129,23 @@ function apply(ctx, config) {
     ctx.logger.info('WordPress 推送插件已加载');
     // 修复 MySQL 自增主键问题，使用正确的模型配置
     // 确保 id 字段被正确设置为自增主键，并且在插入时不会被设置为 NULL
+    // 显式指定 nullable: false 约束以适配 MySQL 特有要求
     ctx.model.extend('wordpress_post_updates', {
-        id: 'integer',
-        siteId: 'string',
-        postId: 'integer',
-        lastModified: 'timestamp',
-        pushedAt: 'timestamp'
+        id: { type: 'integer', nullable: false },
+        siteId: { type: 'string', nullable: false },
+        postId: { type: 'integer', nullable: false },
+        lastModified: { type: 'timestamp', nullable: false },
+        pushedAt: { type: 'timestamp', nullable: false }
     }, {
         primary: 'id',
         autoInc: true,
         unique: ['siteId', 'postId'] // 每个站点的文章 ID 唯一
     });
     ctx.model.extend('wordpress_user_registrations', {
-        id: 'integer',
-        siteId: 'string',
-        userId: 'integer',
-        pushedAt: 'timestamp'
+        id: { type: 'integer', nullable: false },
+        siteId: { type: 'string', nullable: false },
+        userId: { type: 'integer', nullable: false },
+        pushedAt: { type: 'timestamp', nullable: false }
     }, {
         primary: 'id',
         autoInc: true,
@@ -152,43 +153,108 @@ function apply(ctx, config) {
     });
     // 配置存储表
     ctx.model.extend('wordpress_config', {
-        id: 'integer',
-        key: 'string',
-        value: 'string',
-        updatedAt: 'timestamp'
+        id: { type: 'string', nullable: false },
+        key: { type: 'string', nullable: false },
+        value: { type: 'string', nullable: false },
+        updatedAt: { type: 'timestamp', nullable: false }
     }, {
         primary: 'id',
-        autoInc: true,
         unique: ['key']
     });
     // 版本记录表
     ctx.model.extend('wordpress_version', {
-        id: 'integer',
-        version: 'string',
-        updatedAt: 'timestamp'
+        id: { type: 'string', nullable: false },
+        version: { type: 'string', nullable: false },
+        updatedAt: { type: 'timestamp', nullable: false }
     }, {
         primary: 'id',
-        autoInc: true,
         unique: ['version']
     });
     ctx.logger.info('数据库表配置完成，autoInc: true 已启用，确保插入操作不手动指定 id 字段');
+    // 时间处理工具函数
+    function parseWPDate(dateStr) {
+        if (!dateStr) {
+            return null;
+        }
+        try {
+            const date = new Date(dateStr);
+            if (isNaN(date.getTime())) {
+                return null;
+            }
+            return date;
+        }
+        catch (error) {
+            ctx.logger.warn(`解析日期失败: ${dateStr}, 错误: ${error}`);
+            return null;
+        }
+    }
     // 为所有数据库操作添加详细日志，便于诊断自增主键问题
     ctx.on('ready', async () => {
         ctx.logger.info('WordPress 推送插件已就绪，开始初始化推送任务');
         ctx.logger.info('数据库表配置：');
-        ctx.logger.info('wordpress_post_updates: id 字段设置为 autoInc: true');
-        ctx.logger.info('wordpress_user_registrations: id 字段设置为 autoInc: true');
+        ctx.logger.info('wordpress_post_updates: id 字段设置为 autoIncrement: true');
+        ctx.logger.info('wordpress_user_registrations: id 字段设置为 autoIncrement: true');
         ctx.logger.info('wordpress_config: 配置持久化存储表');
         ctx.logger.info('wordpress_version: 数据库版本记录表');
         ctx.logger.info('所有群聊共用一个文章标记，不再区分群聊');
         // 检查并修复数据库表结构问题
         await checkAndFixTableStructure();
+        // 检查和更新数据库版本
+        await checkAndUpdateDatabaseVersion();
         // 加载持久化配置
         await loadPersistentConfig();
         // 执行初始推送
         await pushNewPosts();
     });
-    // 加载持久化配置
+    // 检查和更新数据库版本
+    async function checkAndUpdateDatabaseVersion() {
+        try {
+            ctx.logger.info('开始检查数据库版本...');
+            // 确保数据库连接正常
+            const connected = await ensureDatabaseConnection();
+            if (!connected) {
+                ctx.logger.warn('数据库连接异常，跳过版本检查');
+                return;
+            }
+            // 检查现有版本记录
+            const versionRecords = await ctx.database.get('wordpress_version', {}, { limit: 1 });
+            if (versionRecords.length === 0) {
+                // 首次安装，创建版本记录
+                await ctx.database.create('wordpress_version', {
+                    id: '1',
+                    version: DATABASE_VERSION,
+                    updatedAt: new Date()
+                });
+                ctx.logger.info(`数据库版本初始化完成，当前版本: ${DATABASE_VERSION}`);
+            }
+            else {
+                const currentVersion = versionRecords[0].version;
+                if (currentVersion !== DATABASE_VERSION) {
+                    // 版本不一致，执行升级逻辑
+                    ctx.logger.info(`数据库版本更新，从 ${currentVersion} 升级到 ${DATABASE_VERSION}`);
+                    // 这里可以添加具体的升级逻辑，例如：
+                    // 1. 表结构变更
+                    // 2. 数据迁移
+                    // 3. 配置更新
+                    // 更新版本记录
+                    await ctx.database.remove('wordpress_version', { id: versionRecords[0].id });
+                    await ctx.database.create('wordpress_version', {
+                        id: versionRecords[0].id,
+                        version: DATABASE_VERSION,
+                        updatedAt: new Date()
+                    });
+                    ctx.logger.info(`数据库版本升级完成，当前版本: ${DATABASE_VERSION}`);
+                }
+                else {
+                    ctx.logger.info(`数据库版本检查完成，当前版本: ${DATABASE_VERSION} (最新)`);
+                }
+            }
+        }
+        catch (error) {
+            ctx.logger.error(`检查数据库版本失败: ${error}`);
+        }
+    }
+    // 加载持久化配置，使用分页查询避免内存溢出
     async function loadPersistentConfig() {
         try {
             ctx.logger.info('开始加载持久化配置...');
@@ -198,7 +264,10 @@ function apply(ctx, config) {
                 ctx.logger.warn('数据库连接异常，跳过加载持久化配置');
                 return;
             }
-            const configRecords = await ctx.database.get('wordpress_config', {});
+            // 使用分页查询，每次最多获取 100 条记录
+            const configRecords = await ctx.database.get('wordpress_config', {}, {
+                limit: 100
+            });
             ctx.logger.info(`找到 ${configRecords.length} 条持久化配置记录`);
             for (const record of configRecords) {
                 try {
@@ -243,7 +312,7 @@ function apply(ctx, config) {
                 // 更新现有配置
                 await ctx.database.remove('wordpress_config', { key });
             }
-            // 创建新配置记录
+            // 创建新配置记录，只保存指定的键值对
             await ctx.database.create('wordpress_config', {
                 key,
                 value: JSON.stringify(value),
@@ -255,6 +324,47 @@ function apply(ctx, config) {
             ctx.logger.error(`保存配置失败，键: ${key}，错误: ${error}`);
         }
     }
+    // 保存单个站点配置
+    async function saveSiteConfig(siteId, siteConfig) {
+        try {
+            ctx.logger.info(`保存单个站点配置: ${siteId} = ${JSON.stringify(siteConfig)}`);
+            // 确保数据库连接正常
+            const connected = await ensureDatabaseConnection();
+            if (!connected) {
+                ctx.logger.warn('数据库连接异常，跳过保存站点配置');
+                return;
+            }
+            // 获取当前所有站点配置
+            const sitesConfigKey = 'sites';
+            const existingSitesConfig = await ctx.database.get('wordpress_config', { key: sitesConfigKey });
+            let currentSites = [];
+            if (existingSitesConfig.length > 0) {
+                try {
+                    currentSites = JSON.parse(existingSitesConfig[0].value);
+                }
+                catch (error) {
+                    ctx.logger.error(`解析现有站点配置失败: ${error}`);
+                    currentSites = [];
+                }
+            }
+            // 查找站点是否已存在
+            const siteIndex = currentSites.findIndex(site => site.id === siteId);
+            if (siteIndex >= 0) {
+                // 更新现有站点
+                currentSites[siteIndex] = siteConfig;
+            }
+            else {
+                // 添加新站点
+                currentSites.push(siteConfig);
+            }
+            // 保存更新后的站点配置
+            await saveConfig(sitesConfigKey, currentSites);
+            ctx.logger.info(`站点配置保存成功: ${siteId}`);
+        }
+        catch (error) {
+            ctx.logger.error(`保存站点配置失败，站点 ID: ${siteId}，错误: ${error}`);
+        }
+    }
     // 缓存对象，用于存储高频格式化结果，有效期1小时
     const formatCache = {
         post: new Map(),
@@ -281,8 +391,8 @@ function apply(ctx, config) {
             }
         }
     }
-    // 定期清理过期缓存
-    setInterval(cleanExpiredCache, CONSTANTS.CACHE_EXPIRY);
+    // 定期清理过期缓存，绑定到 ctx 生命周期
+    const cacheCleanupTimer = ctx.setInterval(cleanExpiredCache, CONSTANTS.CACHE_EXPIRY);
     // 健壮获取 QQ Bot 实例，兼容多种适配器，优先选择 QQ 官方 bot
     function getValidBot() {
         // 支持的 QQ 相关适配器列表，'qq' 为 QQ 官方 bot
@@ -293,8 +403,9 @@ function apply(ctx, config) {
         const connectedBots = botList.filter(bot => {
             // 检查 Bot 是否已连接
             // 不同适配器可能有不同的状态属性
-            // 由于TypeScript类型限制，我们使用更通用的检查方式
-            return true; // 暂时返回所有Bot，实际项目中需要根据具体适配器实现状态检查
+            // 尝试检查常见的状态属性
+            const status = String(bot.status || '');
+            return status === 'online' || status === 'connected' || status === '';
         });
         ctx.logger.info(`找到 ${connectedBots.length} 个已连接的 Bot，总 Bot 数: ${botList.length}`);
         if (connectedBots.length === 0) {
@@ -319,18 +430,53 @@ function apply(ctx, config) {
         ctx.logger.info(`选择可用的已连接 Bot: ${connectedBots[0].platform} - ${connectedBots[0].selfId || 'unknown'}`);
         return connectedBots[0];
     }
+    // 检查 Bot 是否有发送消息的权限
+    async function checkBotPermission(bot, target) {
+        try {
+            // 不同适配器可能有不同的权限检查方法
+            // 这里使用通用的检查方法，尝试发送一条空消息或检查权限
+            // 注意：这种方法可能会在某些适配器上失败，所以需要捕获异常
+            // 检查 Bot 是否有 sendMessage 方法
+            if (!bot.sendMessage) {
+                ctx.logger.warn(`Bot 实例没有 sendMessage 方法: ${bot.platform}:${bot.selfId || 'unknown'}`);
+                return false;
+            }
+            // 检查 Bot 是否在线
+            if (bot.status && bot.status !== 'online' && bot.status !== 'connected') {
+                ctx.logger.warn(`Bot 不在线: ${bot.platform}:${bot.selfId || 'unknown'}，状态: ${bot.status}`);
+                return false;
+            }
+            // 对于 QQ 官方 bot，检查是否有权限发送消息
+            if (bot.platform === 'qq') {
+                // QQ 官方 bot 可能有专门的权限检查方法
+                // 这里暂时返回 true，实际项目中需要根据具体适配器实现权限检查
+                return true;
+            }
+            // 对于其他适配器，尝试发送一条测试消息或检查权限
+            // 这里暂时返回 true，实际项目中需要根据具体适配器实现权限检查
+            return true;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            ctx.logger.error(`检查 Bot 权限失败: ${errorMessage}`);
+            return false;
+        }
+    }
     const failedPushQueue = [];
     const MAX_RETRIES = CONSTANTS.MAX_PUSH_RETRIES;
     const RETRY_INTERVAL = CONSTANTS.PUSH_RETRY_INTERVAL; // 5分钟
     // 添加到失败队列
     function addToFailedQueue(type, data, targets, siteConfig) {
+        const now = new Date();
+        const expireAt = new Date(now.getTime() + 24 * 60 * 60 * 1000); // 24小时过期
         const item = {
             id: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
             type,
             data,
             targets,
             retries: 0,
-            createdAt: new Date(),
+            createdAt: now,
+            expireAt,
             siteConfig
         };
         failedPushQueue.push(item);
@@ -347,9 +493,16 @@ function apply(ctx, config) {
             ctx.logger.error('没有可用的 Bot 实例，无法处理失败队列');
             return;
         }
+        const now = new Date();
         const itemsToRemove = [];
         for (let i = 0; i < failedPushQueue.length; i++) {
             const item = failedPushQueue[i];
+            // 检查是否过期
+            if (now > item.expireAt) {
+                ctx.logger.warn(`任务已过期，放弃推送，类型: ${item.type}，创建时间: ${item.createdAt}`);
+                itemsToRemove.push(i);
+                continue;
+            }
             if (item.retries >= MAX_RETRIES) {
                 ctx.logger.warn(`达到最大重试次数，放弃推送，类型: ${item.type}，创建时间: ${item.createdAt}`);
                 itemsToRemove.push(i);
@@ -390,8 +543,8 @@ function apply(ctx, config) {
         }
         ctx.logger.info(`失败队列处理完成，剩余队列长度: ${failedPushQueue.length}`);
     }
-    // 定期处理失败队列
-    setInterval(processFailedQueue, RETRY_INTERVAL);
+    // 定期处理失败队列，绑定到 ctx 生命周期
+    const failedQueueTimer = ctx.setInterval(processFailedQueue, RETRY_INTERVAL);
     // 通用权限检查函数，检查用户是否为超级管理员
     function checkSuperAdmin(session) {
         // 检查是否为超级管理员
@@ -532,11 +685,11 @@ function apply(ctx, config) {
                     ctx.logger.info('旧表删除成功，重新初始化表结构...');
                     // 重新扩展模型
                     ctx.model.extend('wordpress_post_updates', {
-                        id: 'integer',
-                        siteId: 'string',
-                        postId: 'integer',
-                        lastModified: 'timestamp',
-                        pushedAt: 'timestamp'
+                        id: { type: 'integer', nullable: false },
+                        siteId: { type: 'string', nullable: false },
+                        postId: { type: 'integer', nullable: false },
+                        lastModified: { type: 'timestamp', nullable: false },
+                        pushedAt: { type: 'timestamp', nullable: false }
                     }, {
                         primary: 'id',
                         autoInc: true,
@@ -564,10 +717,10 @@ function apply(ctx, config) {
                     ctx.logger.info('旧表删除成功，重新初始化表结构...');
                     // 重新扩展模型
                     ctx.model.extend('wordpress_user_registrations', {
-                        id: 'integer',
-                        siteId: 'string',
-                        userId: 'integer',
-                        pushedAt: 'timestamp'
+                        id: { type: 'integer', nullable: false },
+                        siteId: { type: 'string', nullable: false },
+                        userId: { type: 'integer', nullable: false },
+                        pushedAt: { type: 'timestamp', nullable: false }
                     }, {
                         primary: 'id',
                         autoInc: true,
@@ -595,13 +748,12 @@ function apply(ctx, config) {
                     ctx.logger.info('旧表删除成功，重新初始化表结构...');
                     // 重新扩展模型
                     ctx.model.extend('wordpress_config', {
-                        id: 'integer',
-                        key: 'string',
-                        value: 'string',
-                        updatedAt: 'timestamp'
+                        id: { type: 'string', nullable: false },
+                        key: { type: 'string', nullable: false },
+                        value: { type: 'string', nullable: false },
+                        updatedAt: { type: 'timestamp', nullable: false }
                     }, {
                         primary: 'id',
-                        autoInc: true,
                         unique: ['key']
                     });
                     ctx.logger.info('wordpress_config 表重新初始化成功');
@@ -610,6 +762,35 @@ function apply(ctx, config) {
                     ctx.logger.warn(`删除旧表失败，可能表不存在：${dropError}`);
                 }
             }
+            try {
+                ctx.logger.info('验证 wordpress_version 表结构...');
+                const testVersion = await ctx.database.get('wordpress_version', {}, {
+                    limit: 1
+                });
+                ctx.logger.info(`wordpress_version 表验证成功，现有记录数：${testVersion.length}`);
+            }
+            catch (error) {
+                ctx.logger.warn(`wordpress_version 表可能结构不正确，尝试重新初始化...`);
+                // 尝试删除旧表并重新初始化
+                try {
+                    ctx.logger.info('尝试删除旧的 wordpress_version 表...');
+                    await ctx.database.drop('wordpress_version');
+                    ctx.logger.info('旧表删除成功，重新初始化表结构...');
+                    // 重新扩展模型
+                    ctx.model.extend('wordpress_version', {
+                        id: { type: 'string', nullable: false },
+                        version: { type: 'string', nullable: false },
+                        updatedAt: { type: 'timestamp', nullable: false }
+                    }, {
+                        primary: 'id',
+                        unique: ['version']
+                    });
+                    ctx.logger.info('wordpress_version 表重新初始化成功');
+                }
+                catch (dropError) {
+                    ctx.logger.warn(`删除旧表失败，可能表不存在：${dropError}`);
+                }
+            }
             ctx.logger.info('表结构检查和修复完成');
         }
         catch (error) {
@@ -675,18 +856,22 @@ function apply(ctx, config) {
             }
             const response = await httpRequest(url, requestConfig);
             if (!response) {
-                ctx.logger.error(`获取站点 ${site.id} (${site.name}) 的 WordPress 文章失败，已达到最大重试次数`);
-                return [];
+                const errorMessage = `获取站点 ${site.id} (${site.name}) 的 WordPress 文章失败，已达到最大重试次数`;
+                ctx.logger.error(errorMessage);
+                // 记录失败
+                recordPushFailure(`获取站点 ${site.id} (${site.name}) 的文章失败: ${errorMessage}`);
+                return { success: false, data: [], error: errorMessage };
             }
             ctx.logger.info(`成功获取站点 ${site.id} (${site.name}) 的 ${response.length} 篇文章`);
-            return response;
+            return { success: true, data: response, error: '' };
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            ctx.logger.error(`获取站点 ${site.id} (${site.name}) 的 WordPress 文章失败: ${errorMessage}`);
+            const fullErrorMessage = `获取站点 ${site.id} (${site.name}) 的 WordPress 文章失败: ${errorMessage}`;
+            ctx.logger.error(fullErrorMessage);
             // 记录失败
             recordPushFailure(`获取站点 ${site.id} (${site.name}) 的文章失败: ${errorMessage}`);
-            return [];
+            return { success: false, data: [], error: fullErrorMessage };
         }
     }
     async function fetchLatestUsers(site) {
@@ -709,12 +894,13 @@ function apply(ctx, config) {
             }
             const response = await httpRequest(url, requestConfig);
             if (!response) {
-                ctx.logger.error(`获取站点 ${site.id} (${site.name}) 的 WordPress 用户失败，已达到最大重试次数`);
+                const errorMessage = `获取站点 ${site.id} (${site.name}) 的 WordPress 用户失败，已达到最大重试次数`;
+                ctx.logger.error(errorMessage);
                 ctx.logger.error(`WordPress REST API 的 users 端点需要认证才能访问，请在站点配置中添加 WordPress 用户名和应用程序密码`);
                 // 记录失败
                 recordPushFailure(`获取站点 ${site.id} (${site.name}) 的用户失败: API 认证失败`);
                 // 返回空数组，确保插件继续运行
-                return [];
+                return { success: false, data: [], error: errorMessage };
             }
             ctx.logger.info(`成功获取站点 ${site.id} (${site.name}) 的 ${response.length} 位用户`);
             // 添加调试日志，查看API返回的实际数据结构
@@ -724,16 +910,17 @@ function apply(ctx, config) {
                 const user = response[0];
                 ctx.logger.info(`用户日期字段: date=${user.date}, date_registered=${user.date_registered}, registered_date=${user.registered_date}, created_at=${user.created_at}`);
             }
-            return response;
+            return { success: true, data: response, error: '' };
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            ctx.logger.error(`获取站点 ${site.id} (${site.name}) 的 WordPress 用户失败: ${errorMessage}`);
+            const fullErrorMessage = `获取站点 ${site.id} (${site.name}) 的 WordPress 用户失败: ${errorMessage}`;
+            ctx.logger.error(fullErrorMessage);
             ctx.logger.error(`WordPress REST API 的 users 端点需要认证才能访问，请在站点配置中添加 WordPress 用户名和应用程序密码`);
             // 记录失败
             recordPushFailure(`获取站点 ${site.id} (${site.name}) 的用户失败: ${errorMessage}`);
             // 返回空数组，确保插件继续运行
-            return [];
+            return { success: false, data: [], error: fullErrorMessage };
         }
     }
     async function fetchUpdatedPosts(site) {
@@ -753,20 +940,22 @@ function apply(ctx, config) {
             }
             const response = await httpRequest(url, requestConfig);
             if (!response) {
-                ctx.logger.error(`获取站点 ${site.id} (${site.name}) 的 WordPress 更新文章失败，已达到最大重试次数`);
+                const errorMessage = `获取站点 ${site.id} (${site.name}) 的 WordPress 更新文章失败，已达到最大重试次数`;
+                ctx.logger.error(errorMessage);
                 // 记录失败
                 recordPushFailure(`获取站点 ${site.id} (${site.name}) 的更新文章失败`);
-                return [];
+                return { success: false, data: [], error: errorMessage };
             }
             ctx.logger.info(`成功获取站点 ${site.id} (${site.name}) 的 ${response.length} 篇更新文章`);
-            return response;
+            return { success: true, data: response, error: '' };
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            ctx.logger.error(`获取站点 ${site.id} (${site.name}) 的 WordPress 更新文章失败: ${errorMessage}`);
+            const fullErrorMessage = `获取站点 ${site.id} (${site.name}) 的 WordPress 更新文章失败: ${errorMessage}`;
+            ctx.logger.error(fullErrorMessage);
             // 记录失败
             recordPushFailure(`获取站点 ${site.id} (${site.name}) 的更新文章失败: ${errorMessage}`);
-            return [];
+            return { success: false, data: [], error: fullErrorMessage };
         }
     }
     async function isUserPushed(siteId, userId) {
@@ -778,7 +967,7 @@ function apply(ctx, config) {
                 return false;
             }
             ctx.logger.info(`检查用户是否已推送，站点 ID: ${siteId}，用户 ID: ${userId}`);
-            const record = await ctx.database.get('wordpress_user_registrations', { siteId, userId });
+            const record = await ctx.database.get('wordpress_user_registrations', { siteId, userId: parseInt(userId) });
             const result = record.length > 0;
             ctx.logger.info(`检查结果：站点 ${siteId} 用户 ${userId} 已推送：${result ? '是' : '否'}`);
             return result;
@@ -800,7 +989,7 @@ function apply(ctx, config) {
                 return null;
             }
             ctx.logger.info(`获取文章更新记录，站点 ID: ${siteId}，文章 ID: ${postId}`);
-            const records = await ctx.database.get('wordpress_post_updates', { siteId, postId });
+            const records = await ctx.database.get('wordpress_post_updates', { siteId, postId: parseInt(postId) });
             const result = records.length > 0 ? records[0] : null;
             ctx.logger.info(`获取结果：站点 ${siteId} 文章 ${postId} 更新记录：${result ? '找到' : '未找到'}`);
             return result;
@@ -825,7 +1014,7 @@ function apply(ctx, config) {
             // 创建新记录，不手动指定id，让数据库自动生成
             const newRecord = {
                 siteId,
-                userId,
+                userId: parseInt(userId),
                 pushedAt: new Date()
             };
             ctx.logger.info(`准备创建用户推送记录：${JSON.stringify(newRecord)}`);
@@ -859,13 +1048,13 @@ function apply(ctx, config) {
             if (record) {
                 ctx.logger.info(`发现现有记录，站点 ID: ${siteId}，文章 ID: ${postId}，上次修改时间: ${record.lastModified}`);
                 // Koishi database API 不支持 update 方法，使用 remove + create 代替
-                await ctx.database.remove('wordpress_post_updates', { siteId, postId });
+                await ctx.database.remove('wordpress_post_updates', { siteId, postId: parseInt(postId) });
                 ctx.logger.info(`已删除旧记录，站点 ID: ${siteId}，文章 ID: ${postId}`);
             }
             // 创建新记录，不指定 id 字段，让数据库自动生成
             const newRecord = {
                 siteId,
-                postId,
+                postId: parseInt(postId),
                 lastModified: modifiedDate,
                 pushedAt: new Date()
             };
@@ -937,7 +1126,11 @@ function apply(ctx, config) {
         }
         // 根据配置格式化日期
         const formatDate = (dateString) => {
-            const date = new Date(dateString);
+            // 使用统一的时间处理工具函数
+            const date = parseWPDate(dateString);
+            if (!date) {
+                return '未知时间';
+            }
             const year = date.getFullYear();
             const month = String(date.getMonth() + 1).padStart(2, '0');
             const day = String(date.getDate()).padStart(2, '0');
@@ -1049,10 +1242,9 @@ function apply(ctx, config) {
                 ctx.logger.info(`用户 ${username} 的原始数据: ${JSON.stringify(user)}`);
             }
             if (dateStr) {
-                // 尝试解析日期，使用自定义格式：年-月-日 时:分
-                const date = new Date(dateStr);
-                ctx.logger.info(`解析日期 ${dateStr} 结果: ${date.toString()}`);
-                if (!isNaN(date.getTime())) {
+                // 使用统一的时间处理工具函数
+                const date = parseWPDate(dateStr);
+                if (date) {
                     const year = date.getFullYear();
                     const month = String(date.getMonth() + 1).padStart(2, '0');
                     const day = String(date.getDate()).padStart(2, '0');
@@ -1103,14 +1295,21 @@ function apply(ctx, config) {
             ctx.logger.info(`开始处理站点: ${site.id} (${site.name})`);
             // 推送新文章
             if (site.enableAutoPush) {
-                const posts = await fetchLatestPosts(site);
+                const postsResult = await fetchLatestPosts(site);
+                if (!postsResult.success) {
+                    ctx.logger.error(`获取站点 ${site.id} (${site.name}) 的文章失败: ${postsResult.error}`);
+                    // 记录失败
+                    recordPushFailure(`获取站点 ${site.id} (${site.name}) 的文章失败: ${postsResult.error}`);
+                    continue;
+                }
+                const posts = postsResult.data;
                 ctx.logger.info(`站点 ${site.id} (${site.name}) 开始检查 ${posts.length} 篇文章是否需要推送`);
                 if (posts.length > 0) {
                     for (const post of posts) {
                         ctx.logger.info(`正在处理文章: ${post.id} - ${post.title.rendered}`);
                         ctx.logger.info(`文章 ID: ${post.id}, 发布时间: ${post.date}, 修改时间: ${post.modified}`);
                         // 检查文章是否已推送过（所有群聊共用一个标记）
-                        const postRecord = await getPostUpdateRecord(site.id, post.id);
+                        const postRecord = await getPostUpdateRecord(site.id, String(post.id));
                         const hasPushed = !!postRecord;
                         ctx.logger.info(`检查结果: 站点 ${site.id} 文章 ${post.id} 是否已推送：${hasPushed ? '是' : '否'}`);
                         if (!hasPushed) {
@@ -1121,6 +1320,13 @@ function apply(ctx, config) {
                                     ctx.logger.info(`正在处理目标: ${target}`);
                                     // 直接使用原始目标字符串，不进行数字转换，避免丢失平台前缀等信息
                                     const stringTarget = target;
+                                    // 检查 Bot 是否有发送消息的权限
+                                    const hasPermission = await checkBotPermission(bot, stringTarget);
+                                    if (!hasPermission) {
+                                        ctx.logger.warn(`Bot 没有权限向 ${stringTarget} 发送消息，跳过推送`);
+                                        failedTargets.push(target);
+                                        continue;
+                                    }
                                     const message = formatPostMessage(post, site.mentionAll, false, site);
                                     ctx.logger.info(`准备推送新文章到目标: ${stringTarget}`);
                                     await bot.sendMessage(stringTarget, message);
@@ -1140,7 +1346,7 @@ function apply(ctx, config) {
                                 addToFailedQueue('post', post, failedTargets, site);
                             }
                             // 标记文章已推送（所有群聊共用一个标记）
-                            await updatePostUpdateRecord(site.id, post.id, new Date(post.modified));
+                            await updatePostUpdateRecord(site.id, String(post.id), new Date(post.modified));
                             ctx.logger.info(`已标记站点 ${site.id} 文章 ${post.id} 为已推送，所有群聊将不再推送此文章`);
                         }
                         else {
@@ -1151,10 +1357,17 @@ function apply(ctx, config) {
             }
             // 推送文章更新
             if (site.enableUpdatePush) {
-                const posts = await fetchUpdatedPosts(site);
+                const postsResult = await fetchUpdatedPosts(site);
+                if (!postsResult.success) {
+                    ctx.logger.error(`获取站点 ${site.id} (${site.name}) 的更新文章失败: ${postsResult.error}`);
+                    // 记录失败
+                    recordPushFailure(`获取站点 ${site.id} (${site.name}) 的更新文章失败: ${postsResult.error}`);
+                    continue;
+                }
+                const posts = postsResult.data;
                 if (posts.length > 0) {
                     for (const post of posts) {
-                        const updateRecord = await getPostUpdateRecord(site.id, post.id);
+                        const updateRecord = await getPostUpdateRecord(site.id, String(post.id));
                         const postModifiedDate = new Date(post.modified);
                         // 检查文章是否有更新
                         if (updateRecord && postModifiedDate > new Date(updateRecord.lastModified)) {
@@ -1165,6 +1378,13 @@ function apply(ctx, config) {
                                 try {
                                     ctx.logger.info(`正在处理目标: ${target}`);
                                     const stringTarget = target;
+                                    // 检查 Bot 是否有发送消息的权限
+                                    const hasPermission = await checkBotPermission(bot, stringTarget);
+                                    if (!hasPermission) {
+                                        ctx.logger.warn(`Bot 没有权限向 ${stringTarget} 发送消息，跳过推送`);
+                                        failedTargets.push(target);
+                                        continue;
+                                    }
                                     const message = formatPostMessage(post, site.mentionAll, true, site);
                                     ctx.logger.info(`准备推送文章更新到目标: ${stringTarget}`);
                                     await bot.sendMessage(stringTarget, message);
@@ -1184,7 +1404,7 @@ function apply(ctx, config) {
                                 addToFailedQueue('update', post, failedTargets, site);
                             }
                             // 更新文章更新记录（所有群聊共用一个标记）
-                            await updatePostUpdateRecord(site.id, post.id, postModifiedDate);
+                            await updatePostUpdateRecord(site.id, String(post.id), postModifiedDate);
                             ctx.logger.info(`已更新站点 ${site.id} 文章 ${post.id} 的推送记录，所有群聊将使用此更新时间作为新的推送基准`);
                         }
                     }
@@ -1192,16 +1412,30 @@ function apply(ctx, config) {
             }
             // 推送新用户注册
             if (site.enableUserPush) {
-                const users = await fetchLatestUsers(site);
+                const usersResult = await fetchLatestUsers(site);
+                if (!usersResult.success) {
+                    ctx.logger.error(`获取站点 ${site.id} (${site.name}) 的用户失败: ${usersResult.error}`);
+                    // 记录失败
+                    recordPushFailure(`获取站点 ${site.id} (${site.name}) 的用户失败: ${usersResult.error}`);
+                    continue;
+                }
+                const users = usersResult.data;
                 if (users.length > 0) {
                     for (const user of users) {
-                        if (!(await isUserPushed(site.id, user.id))) {
+                        if (!(await isUserPushed(site.id, String(user.id)))) {
                             const failedTargets = [];
                             for (const target of site.targets) {
                                 try {
                                     ctx.logger.info(`正在处理目标: ${target}`);
                                     // 直接使用原始目标字符串，与新文章推送逻辑保持一致
                                     const stringTarget = target;
+                                    // 检查 Bot 是否有发送消息的权限
+                                    const hasPermission = await checkBotPermission(bot, stringTarget);
+                                    if (!hasPermission) {
+                                        ctx.logger.warn(`Bot 没有权限向 ${stringTarget} 发送消息，跳过推送`);
+                                        failedTargets.push(target);
+                                        continue;
+                                    }
                                     const message = formatUserMessage(user, site.mentionAll, site);
                                     ctx.logger.info(`准备推送新用户到目标: ${stringTarget}`);
                                     await bot.sendMessage(stringTarget, message);
@@ -1221,7 +1455,7 @@ function apply(ctx, config) {
                                 addToFailedQueue('user', user, failedTargets, site);
                             }
                             // 标记用户已推送
-                            await markUserAsPushed(site.id, user.id);
+                            await markUserAsPushed(site.id, String(user.id));
                         }
                     }
                 }
@@ -1238,7 +1472,12 @@ function apply(ctx, config) {
         if (!targetSite) {
             return `未找到站点 ID: ${siteId}`;
         }
-        const posts = await fetchLatestPosts(targetSite);
+        const postsResult = await fetchLatestPosts(targetSite);
+        if (!postsResult.success) {
+            ctx.logger.error(`获取最新文章失败: ${postsResult.error}`);
+            return `获取文章失败: ${postsResult.error}`;
+        }
+        const posts = postsResult.data;
         if (posts.length === 0) {
             ctx.logger.info(`站点 ${targetSite.id} 没有找到文章`);
             return `站点 ${targetSite.name} 暂无文章`;
@@ -1280,7 +1519,12 @@ function apply(ctx, config) {
         if (!targetSite) {
             return `未找到站点 ID: ${siteId}`;
         }
-        const posts = await fetchLatestPosts(targetSite);
+        const postsResult = await fetchLatestPosts(targetSite);
+        if (!postsResult.success) {
+            ctx.logger.error(`获取文章列表失败: ${postsResult.error}`);
+            return `获取文章失败: ${postsResult.error}`;
+        }
+        const posts = postsResult.data;
         if (posts.length === 0) {
             return `站点 ${targetSite.name} 暂无文章`;
         }
@@ -1381,7 +1625,7 @@ function apply(ctx, config) {
         }
         // 切换开关
         site.enableUpdatePush = !site.enableUpdatePush;
-        await saveConfig('sites', config.sites);
+        await saveSiteConfig(siteId, site);
         return `站点 ${site.name} 的文章更新推送已${site.enableUpdatePush ? '开启' : '关闭'}`;
     });
     ctx.command('wordpress.site.toggle-user <siteId>', '切换指定站点的新用户注册推送开关')
@@ -1399,7 +1643,7 @@ function apply(ctx, config) {
         }
         // 切换开关
         site.enableUserPush = !site.enableUserPush;
-        await saveConfig('sites', config.sites);
+        await saveSiteConfig(siteId, site);
         return `站点 ${site.name} 的新用户注册推送已${site.enableUserPush ? '开启' : '关闭'}`;
     });
     ctx.command('wordpress.site.toggle <siteId>', '切换指定站点的自动推送开关')
@@ -1417,7 +1661,7 @@ function apply(ctx, config) {
         }
         // 切换开关
         site.enableAutoPush = !site.enableAutoPush;
-        await saveConfig('sites', config.sites);
+        await saveSiteConfig(siteId, site);
         return `站点 ${site.name} 的自动推送已${site.enableAutoPush ? '开启' : '关闭'}`;
     });
     ctx.command('wordpress.site.mention <siteId>', '切换指定站点的 @全体成员 开关')
@@ -1435,7 +1679,7 @@ function apply(ctx, config) {
         }
         // 切换开关
         site.mentionAll = !site.mentionAll;
-        await saveConfig('sites', config.sites);
+        await saveSiteConfig(siteId, site);
         return `站点 ${site.name} 的 @全体成员 已${site.mentionAll ? '开启' : '关闭'}`;
     });
     ctx.command('wordpress.site.set-url <siteId> <url>', '修改指定站点的 WordPress 地址')
@@ -1453,7 +1697,7 @@ function apply(ctx, config) {
         }
         // 修改站点地址
         site.url = url;
-        await saveConfig('sites', config.sites);
+        await saveSiteConfig(siteId, site);
         ctx.logger.info(`站点 ${site.name} 的地址已修改为：${url}`);
         return `站点 ${site.name} 的 WordPress 地址已修改为：${url}`;
     });
@@ -1497,8 +1741,8 @@ function apply(ctx, config) {
         ctx.logger.info(`命令 wordpress.clean 被调用，天数：${days || '默认'}，调用者：${authResult.userId}`);
         // 设置默认天数
         const daysToKeep = days ? parseInt(days) : CONSTANTS.DEFAULT_CLEAN_DAYS;
-        if (isNaN(daysToKeep) || daysToKeep <= 0) {
-            return '请输入有效的天数';
+        if (isNaN(daysToKeep) || daysToKeep <= 0 || daysToKeep > 365) {
+            return '请输入有效的天数（1-365天）';
         }
         // 计算清理时间点
         const cutoffDate = new Date();
@@ -1507,46 +1751,84 @@ function apply(ctx, config) {
         let result = 0;
         // 批量删除 wordpress_post_updates 中的旧记录
         try {
-            // 先获取需要删除的记录数量
-            const updateRecords = await ctx.database.get('wordpress_post_updates', {});
-            const updateRecordsToRemove = updateRecords.filter(record => {
-                return new Date(record.pushedAt) < cutoffDate;
-            });
-            if (updateRecordsToRemove.length > 0) {
-                // 使用批量删除方式（假设数据库API支持）
-                // 由于Koishi数据库API可能不直接支持日期条件删除，我们使用id列表进行批量操作
-                const idsToRemove = updateRecordsToRemove.map(record => record.id);
-                // 尝试使用更高效的批量删除方式
-                // 注意：具体实现取决于Koishi数据库API的支持情况
-                for (const id of idsToRemove) {
-                    await ctx.database.remove('wordpress_post_updates', { id });
+            // 使用分页查询，每次处理 100 条记录，避免内存溢出
+            let processed = 0;
+            let hasMore = true;
+            const queryBatchSize = 100;
+            while (hasMore) {
+                // 分页查询记录
+                const updateRecords = await ctx.database.get('wordpress_post_updates', {}, {
+                    limit: queryBatchSize,
+                    offset: processed
+                });
+                if (updateRecords.length === 0) {
+                    hasMore = false;
+                    break;
+                }
+                // 过滤需要删除的记录
+                const recordsToRemove = updateRecords.filter(record => {
+                    return new Date(record.pushedAt) < cutoffDate;
+                });
+                if (recordsToRemove.length === 0) {
+                    processed += updateRecords.length;
+                    continue;
+                }
+                // 批量删除，每批最多删除 10 条记录
+                const deleteBatchSize = 10;
+                for (let i = 0; i < recordsToRemove.length; i += deleteBatchSize) {
+                    const batch = recordsToRemove.slice(i, i + deleteBatchSize);
+                    // 并行删除，提高效率
+                    await Promise.all(batch.map(record => ctx.database.remove('wordpress_post_updates', { id: record.id })));
                 }
-                result += updateRecordsToRemove.length;
-                ctx.logger.info(`批量删除了 ${updateRecordsToRemove.length} 条 wordpress_post_updates 旧记录`);
+                result += recordsToRemove.length;
+                processed += updateRecords.length;
+                ctx.logger.info(`已处理 ${processed} 条记录，删除了 ${recordsToRemove.length} 条旧记录`);
+                // 避免数据库压力过大，每批处理后稍作延迟
+                await new Promise(resolve => setTimeout(resolve, 100));
             }
+            ctx.logger.info(`批量删除 wordpress_post_updates 旧记录完成，共删除 ${result} 条记录`);
         }
         catch (error) {
             ctx.logger.error(`批量删除 wordpress_post_updates 旧记录失败: ${error}`);
         }
         // 批量删除 wordpress_user_registrations 中的旧记录
         try {
-            // 先获取需要删除的记录数量
-            const userRecords = await ctx.database.get('wordpress_user_registrations', {});
-            const userRecordsToRemove = userRecords.filter(record => {
-                return new Date(record.pushedAt) < cutoffDate;
-            });
-            if (userRecordsToRemove.length > 0) {
-                // 使用批量删除方式（假设数据库API支持）
-                // 由于Koishi数据库API可能不直接支持日期条件删除，我们使用id列表进行批量操作
-                const idsToRemove = userRecordsToRemove.map(record => record.id);
-                // 尝试使用更高效的批量删除方式
-                // 注意：具体实现取决于Koishi数据库API的支持情况
-                for (const id of idsToRemove) {
-                    await ctx.database.remove('wordpress_user_registrations', { id });
+            // 使用分页查询，每次处理 100 条记录，避免内存溢出
+            let processed = 0;
+            let hasMore = true;
+            const queryBatchSize = 100;
+            while (hasMore) {
+                // 分页查询记录
+                const userRecords = await ctx.database.get('wordpress_user_registrations', {}, {
+                    limit: queryBatchSize,
+                    offset: processed
+                });
+                if (userRecords.length === 0) {
+                    hasMore = false;
+                    break;
                 }
-                result += userRecordsToRemove.length;
-                ctx.logger.info(`批量删除了 ${userRecordsToRemove.length} 条 wordpress_user_registrations 旧记录`);
+                // 过滤需要删除的记录
+                const recordsToRemove = userRecords.filter(record => {
+                    return new Date(record.pushedAt) < cutoffDate;
+                });
+                if (recordsToRemove.length === 0) {
+                    processed += userRecords.length;
+                    continue;
+                }
+                // 批量删除，每批最多删除 10 条记录
+                const deleteBatchSize = 10;
+                for (let i = 0; i < recordsToRemove.length; i += deleteBatchSize) {
+                    const batch = recordsToRemove.slice(i, i + deleteBatchSize);
+                    // 并行删除，提高效率
+                    await Promise.all(batch.map(record => ctx.database.remove('wordpress_user_registrations', { id: record.id })));
+                }
+                result += recordsToRemove.length;
+                processed += userRecords.length;
+                ctx.logger.info(`已处理 ${processed} 条记录，删除了 ${recordsToRemove.length} 条旧记录`);
+                // 避免数据库压力过大，每批处理后稍作延迟
+                await new Promise(resolve => setTimeout(resolve, 100));
             }
+            ctx.logger.info(`批量删除 wordpress_user_registrations 旧记录完成，共删除 ${result} 条记录`);
         }
         catch (error) {
             ctx.logger.error(`批量删除 wordpress_user_registrations 旧记录失败: ${error}`);
@@ -1659,9 +1941,10 @@ function apply(ctx, config) {
         ctx.logger.info(`准备返回消息，长度: ${message.length}`);
         return message;
     });
-    // 为每个站点设置独立的定时任务
+    // 为每个站点设置独立的定时任务，绑定到 ctx 生命周期
+    const siteTimers = [];
     config.sites.forEach(site => {
-        ctx.setInterval(() => {
+        const timer = ctx.setInterval(() => {
             try {
                 pushNewPosts();
             }
@@ -1672,5 +1955,28 @@ function apply(ctx, config) {
                 ctx.logger.warn('定时任务将在下一个周期继续执行');
             }
         }, site.interval);
+        siteTimers.push(timer);
+    });
+    // 绑定到 ctx 生命周期，插件卸载时清理所有定时器
+    ctx.on('dispose', () => {
+        ctx.logger.info('WordPress 插件开始清理资源...');
+        // 清理缓存清理定时器
+        if (typeof cacheCleanupTimer === 'function') {
+            cacheCleanupTimer();
+            ctx.logger.info('缓存清理定时器已清理');
+        }
+        // 清理失败队列定时器
+        if (typeof failedQueueTimer === 'function') {
+            failedQueueTimer();
+            ctx.logger.info('失败队列定时器已清理');
+        }
+        // 清理站点定时任务
+        siteTimers.forEach((timer, index) => {
+            if (typeof timer === 'function') {
+                timer();
+                ctx.logger.info(`站点定时任务 ${index + 1} 已清理`);
+            }
+        });
+        ctx.logger.info('WordPress 插件资源清理完成');
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koishi-plugin-wordpress-notifier",
-  "version": "2.8.4",
+  "version": "2.9.0",
   "description": "WordPress 文章自动推送到 QQ",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",