koishi-plugin-wordpress-notifier 2.9.0 → 2.9.3

package/lib/index.js

@@ -1,1982 +1,163 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Config = exports.name = exports.inject = void 0;
+exports.schema = exports.inject = exports.name = void 0;
 exports.apply = apply;
 const koishi_1 = require("koishi");
-exports.inject = ['database', 'http'];
-exports.name = 'wordpress-notifier';
-// 全局常量
-const CONSTANTS = {
-    // 消息相关
-    MAX_MESSAGE_LENGTH: 500,
-    MAX_TITLE_LENGTH: 60,
-    MAX_USERNAME_LENGTH: 50,
-    MAX_POST_TITLE_DISPLAY_LENGTH: 40,
-    // 缓存相关
-    CACHE_EXPIRY: 60 * 60 * 1000, // 1小时
-    // HTTP请求相关
-    HTTP_TIMEOUT: 10000, // 10秒
-    MAX_RETRIES: 2,
-    RETRY_DELAY: 1000, // 1秒
-    API_RATE_LIMIT: 1000, // API请求频率限制（毫秒），每秒最多1次
-    // 失败队列相关
-    MAX_PUSH_RETRIES: 3,
-    PUSH_RETRY_INTERVAL: 5 * 60 * 1000, // 5分钟
-    // 清理相关
-    DEFAULT_CLEAN_DAYS: 30,
-    // QQ适配器相关
-    QQ_ADAPTERS: ['qq', 'onebot', 'milky', 'satori'],
-    // 安全过滤相关
-    SENSITIVE_WORDS: [
-        // 常见敏感词列表（示例）
-        '敏感词1', '敏感词2', '敏感词3',
-        // 可以根据实际需求扩展
-    ],
-    SENSITIVE_REPLACEMENT: '***', // 敏感词替换为***
-};
-// API 请求速率控制变量
-let lastRequestTime = 0;
-// 数据库连接状态
-let databaseConnected = true;
-let lastDatabaseCheck = 0;
-const DATABASE_CHECK_INTERVAL = 30000; // 30秒检查一次数据库连接
-// 推送失败统计
-let consecutiveFailureCount = 0;
-let lastFailureTime = 0;
-const FAILURE_RESET_INTERVAL = 60 * 60 * 1000; // 1小时内无失败则重置计数
-// 数据库版本
-const DATABASE_VERSION = '2.0.0'; // 当前数据库结构版本
-const runtimeStats = {
-    pushSuccessCount: 0,
-    pushFailureCount: 0,
-    apiCallCount: 0,
-    apiSuccessCount: 0,
-    apiFailureCount: 0,
-    lastResetTime: Date.now()
-};
-// 更新 API 调用统计
-function updateApiStats(success) {
-    runtimeStats.apiCallCount++;
-    if (success) {
-        runtimeStats.apiSuccessCount++;
-    }
-    else {
-        runtimeStats.apiFailureCount++;
-    }
-}
-// 更新推送统计
-function updatePushStats(success) {
-    if (success) {
-        runtimeStats.pushSuccessCount++;
-    }
-    else {
-        runtimeStats.pushFailureCount++;
-    }
-}
-exports.Config = koishi_1.Schema.object({
-    // 多站点配置
-    sites: koishi_1.Schema.array(koishi_1.Schema.object({
-        id: koishi_1.Schema.string().description('站点唯一标识（如 "blog"、"news" 等）'),
-        name: koishi_1.Schema.string().description('站点名称（用于显示）'),
-        url: koishi_1.Schema.string().description('WordPress 网站地址（例如：https://your-wordpress-site.com）'),
-        interval: koishi_1.Schema.number().default(3600000).description('检查间隔（毫秒，默认 1 小时）'),
-        targets: koishi_1.Schema.array(koishi_1.Schema.string()).description('推送目标（群号或 QQ 号）'),
-        enableAutoPush: koishi_1.Schema.boolean().default(true).description('是否启用自动推送'),
-        enableUpdatePush: koishi_1.Schema.boolean().default(false).description('是否启用文章更新推送'),
-        enableUserPush: koishi_1.Schema.boolean().default(false).description('是否启用新用户注册推送'),
-        mentionAll: koishi_1.Schema.boolean().default(false).description('是否 @全体成员'),
-        maxArticles: koishi_1.Schema.number().default(5).description('每次最多推送的文章数量'),
-        username: koishi_1.Schema.string().default('').description('WordPress 用户名（用于 Basic 认证，与应用程序密码配合使用）'),
-        applicationPassword: koishi_1.Schema.string().default('').description('WordPress 应用程序密码（用于 Basic 认证，例如：hGR2sPFuYnclxHc4AvJq cUtB）'),
-        // 站点特定的推送模板配置
-        pushTemplate: koishi_1.Schema.object({
-            showExcerpt: koishi_1.Schema.boolean().default(false).description('是否显示文章摘要'),
-            dateFormat: koishi_1.Schema.string().default('YYYY-MM-DD HH:mm').description('日期格式，支持 YYYY-MM-DD HH:mm 等格式'),
-            linkPosition: koishi_1.Schema.union(['top', 'bottom', 'none']).default('bottom').description('链接位置：顶部、底部或不显示'),
-            showAuthor: koishi_1.Schema.boolean().default(false).description('是否显示文章作者')
-        }).description('推送模板配置')
-    })).description('多站点配置列表').default([
-        {
-            id: 'default',
-            name: '默认站点',
-            url: 'https://your-wordpress-site.com',
-            interval: 3600000,
-            targets: [],
-            enableAutoPush: true,
-            enableUpdatePush: false,
-            enableUserPush: false,
-            mentionAll: false,
-            maxArticles: 5,
-            username: '',
-            applicationPassword: '',
-            pushTemplate: {
-                showExcerpt: false,
-                dateFormat: 'YYYY-MM-DD HH:mm',
-                linkPosition: 'bottom',
-                showAuthor: false
-            }
-        }
-    ]),
-    superAdmins: koishi_1.Schema.array(koishi_1.Schema.string()).default([]).description('超级管理员 QQ 号列表'),
-    // 全局推送失败通知配置
-    failureNotification: koishi_1.Schema.object({
-        enable: koishi_1.Schema.boolean().default(true).description('是否启用推送失败通知'),
-        threshold: koishi_1.Schema.number().default(3).description('连续失败阈值，达到此值时发送通知'),
-        notificationTargets: koishi_1.Schema.array(koishi_1.Schema.string()).default([]).description('通知目标（超级管理员 QQ 号），留空则使用 superAdmins')
-    }).description('推送失败通知配置')
+const wordpress_1 = require("./wordpress");
+const push_1 = require("./push");
+const storage_1 = require("./storage");
+const commands_1 = require("./commands");
+const schedule_1 = require("./schedule");
+exports.name = 'wordpress-push';
+exports.inject = ['database'];
+exports.schema = koishi_1.Schema.object({
+    wordpressUrl: koishi_1.Schema.string().required().description('WordPress 网站地址'),
+    apiEndpoint: koishi_1.Schema.string().default('/wp-json/wp/v2').description('REST API 端点'),
+    authType: koishi_1.Schema.union(['none', 'basic', 'application-password']).default('none').description('认证方式'),
+    username: koishi_1.Schema.string().description('认证用户名'),
+    password: koishi_1.Schema.string().description('认证密码'),
+    checkInterval: koishi_1.Schema.number().default(30).min(5).max(1440).description('检查间隔 (分钟)'),
+    enableAutoPush: koishi_1.Schema.boolean().default(true).description('自动推送开关'),
+    enableUpdatePush: koishi_1.Schema.boolean().default(true).description('文章更新推送开关'),
+    enableUserRegisterPush: koishi_1.Schema.boolean().default(false).description('用户注册推送开关'),
+    defaultGroups: koishi_1.Schema.array(koishi_1.Schema.string()).description('默认推送群聊列表'),
+    allowAtAll: koishi_1.Schema.boolean().default(false).description('是否允许@全体成员'),
+    messageType: koishi_1.Schema.union(['text', 'card']).default('text').description('消息类型：text（文本）或 card（卡片）'),
+    signatureKey: koishi_1.Schema.string().description('卡片消息签名密钥'),
+    adminUserId: koishi_1.Schema.string().description('管理员用户 ID，用于接收推送失败告警'),
+    superAdminUserIds: koishi_1.Schema.array(koishi_1.Schema.string()).description('超级管理员 QQ 号码列表，拥有最高权限'),
+    pushStartTime: koishi_1.Schema.number().default(9).min(0).max(23).description('允许推送的开始时间 (小时)'),
+    pushEndTime: koishi_1.Schema.number().default(22).min(0).max(23).description('允许推送的结束时间 (小时)')
 });
 function apply(ctx, config) {
-    ctx.logger.info('WordPress 推送插件已加载');
-    // 修复 MySQL 自增主键问题，使用正确的模型配置
-    // 确保 id 字段被正确设置为自增主键，并且在插入时不会被设置为 NULL
-    // 显式指定 nullable: false 约束以适配 MySQL 特有要求
-    ctx.model.extend('wordpress_post_updates', {
-        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: { type: 'integer', nullable: false },
-        siteId: { type: 'string', nullable: false },
-        userId: { type: 'integer', nullable: false },
-        pushedAt: { type: 'timestamp', nullable: false }
-    }, {
-        primary: 'id',
-        autoInc: true,
-        unique: ['siteId', 'userId'] // 每个站点的用户 ID 唯一
-    });
-    // 配置存储表
-    ctx.model.extend('wordpress_config', {
-        id: { type: 'string', nullable: false },
-        key: { type: 'string', nullable: false },
-        value: { type: 'string', nullable: false },
-        updatedAt: { type: 'timestamp', nullable: false }
-    }, {
-        primary: 'id',
-        unique: ['key']
-    });
-    // 版本记录表
-    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('数据库表配置完成，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 字段设置为 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('开始加载持久化配置...');
-            // 确保数据库连接正常
-            const connected = await ensureDatabaseConnection();
-            if (!connected) {
-                ctx.logger.warn('数据库连接异常，跳过加载持久化配置');
-                return;
-            }
-            // 使用分页查询，每次最多获取 100 条记录
-            const configRecords = await ctx.database.get('wordpress_config', {}, {
-                limit: 100
-            });
-            ctx.logger.info(`找到 ${configRecords.length} 条持久化配置记录`);
-            for (const record of configRecords) {
-                try {
-                    const value = JSON.parse(record.value);
-                    if (record.key in config) {
-                        // 添加类型断言，确保类型安全
-                        config[record.key] = value;
-                        ctx.logger.info(`已加载持久化配置: ${record.key} = ${JSON.stringify(value)}`);
-                    }
-                    else {
-                        ctx.logger.warn(`未知的配置键: ${record.key}`);
-                    }
-                }
-                catch (error) {
-                    ctx.logger.error(`解析配置值失败，键: ${record.key}，错误: ${error}`);
-                }
-            }
-            ctx.logger.info('持久化配置加载完成');
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            ctx.logger.error(`加载持久化配置失败: ${errorMessage}`);
-            ctx.logger.error(`错误栈：${error instanceof Error ? error.stack : '无'}`);
-            // 发生错误时，不抛出异常，确保插件继续运行
-            // 使用默认配置
-            ctx.logger.warn('使用默认配置继续运行，持久化配置将在下次保存时重新创建');
-        }
-    }
-    // 保存配置到数据库
-    async function saveConfig(key, value) {
-        try {
-            ctx.logger.info(`保存配置到数据库: ${key} = ${JSON.stringify(value)}`);
-            // 确保数据库连接正常
-            const connected = await ensureDatabaseConnection();
-            if (!connected) {
-                ctx.logger.warn('数据库连接异常，跳过保存配置');
-                return;
-            }
-            // 检查配置是否已存在
-            const existingRecords = await ctx.database.get('wordpress_config', { key });
-            if (existingRecords.length > 0) {
-                // 更新现有配置
-                await ctx.database.remove('wordpress_config', { key });
-            }
-            // 创建新配置记录，只保存指定的键值对
-            await ctx.database.create('wordpress_config', {
-                key,
-                value: JSON.stringify(value),
-                updatedAt: new Date()
-            });
-            ctx.logger.info(`配置保存成功: ${key}`);
-        }
-        catch (error) {
-            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 {
+        validateConfig(config);
+    }
+    catch (error) {
+        ctx.logger.error('Configuration validation failed:', error);
+        return;
+    }
+    // 确保配置默认值
+    config.apiEndpoint = config.apiEndpoint || '/wp-json/wp/v2';
+    config.checkInterval = config.checkInterval || 30;
+    config.enableAutoPush = config.enableAutoPush ?? true;
+    config.enableUpdatePush = config.enableUpdatePush ?? true;
+    config.enableUserRegisterPush = config.enableUserRegisterPush ?? false;
+    config.allowAtAll = config.allowAtAll ?? false;
+    config.messageType = config.messageType || 'text';
+    // 服务实例
+    let storageService;
+    let wordpressService;
+    let pushService;
+    let commandService;
+    let scheduleService;
+    // 初始化核心服务（包括命令注册）
+    function initializeCoreServices() {
+        try {
+            ctx.logger.info('Initializing WordPress push plugin core services...');
+            // 1. 初始化 WordPress 服务（仅依赖配置）
+            wordpressService = new wordpress_1.WordPressService(ctx, config);
+            ctx.logger.info('WordPressService initialized successfully');
+            // 2. 初始化存储服务（依赖数据库）
+            storageService = new storage_1.StorageService(ctx, config);
+            ctx.logger.info('StorageService initialized successfully');
+            // 3. 初始化推送服务（依赖存储服务）
+            pushService = new push_1.PushService(ctx, config, storageService);
+            ctx.logger.info('PushService initialized successfully');
+            // 4. 初始化定时任务服务（依赖所有其他服务）
+            scheduleService = new schedule_1.ScheduleService(ctx, config, wordpressService, storageService, pushService);
+            ctx.logger.info('ScheduleService initialized successfully');
+            // 5. 初始化命令服务（依赖 WordPress、存储服务和定时任务服务）
+            // 命令注册需要在插件加载时完成，不能等到 ready 事件
+            commandService = new commands_1.CommandService(ctx, config, wordpressService, storageService, scheduleService);
+            ctx.logger.info('CommandService initialized successfully - commands registered');
+            ctx.logger.info('WordPress 推送插件核心服务初始化完成');
+        }
+        catch (error) {
+            ctx.logger.error('Failed to initialize WordPress push plugin core services:', error);
+            // 清理已初始化的服务
+            cleanupServices();
+        }
+    }
+    // 初始化默认群组配置
+    async function initializeDefaultGroups() {
+        if (config.defaultGroups && config.defaultGroups.length > 0) {
+            ctx.logger.info(`Initializing default push config for ${config.defaultGroups.length} groups...`);
+            for (const groupId of config.defaultGroups) {
                 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(),
-        user: new Map()
-    };
-    // 检查缓存是否有效
-    function isCacheValid(timestamp) {
-        const now = Date.now();
-        return now - timestamp < CONSTANTS.CACHE_EXPIRY;
-    }
-    // 清理过期缓存
-    function cleanExpiredCache() {
-        const now = Date.now();
-        // 清理文章格式化缓存
-        for (const [key, value] of formatCache.post.entries()) {
-            if (now - value.timestamp >= CONSTANTS.CACHE_EXPIRY) {
-                formatCache.post.delete(key);
-            }
-        }
-        // 清理用户格式化缓存
-        for (const [key, value] of formatCache.user.entries()) {
-            if (now - value.timestamp >= CONSTANTS.CACHE_EXPIRY) {
-                formatCache.user.delete(key);
-            }
-        }
-    }
-    // 定期清理过期缓存，绑定到 ctx 生命周期
-    const cacheCleanupTimer = ctx.setInterval(cleanExpiredCache, CONSTANTS.CACHE_EXPIRY);
-    // 健壮获取 QQ Bot 实例，兼容多种适配器，优先选择 QQ 官方 bot
-    function getValidBot() {
-        // 支持的 QQ 相关适配器列表，'qq' 为 QQ 官方 bot
-        const qqAdapters = CONSTANTS.QQ_ADAPTERS;
-        // ctx.bots 是对象，需转换为数组后遍历
-        const botList = Object.values(ctx.bots);
-        // 筛选已连接的 Bot
-        const connectedBots = botList.filter(bot => {
-            // 检查 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) {
-            ctx.logger.warn('没有已连接的 Bot 实例');
-            return null;
-        }
-        // 1. 优先选择 QQ 官方 bot（platform === 'qq'）
-        for (const bot of connectedBots) {
-            if (bot.platform === 'qq') {
-                ctx.logger.info(`选择 QQ 官方 bot: ${bot.selfId || 'unknown'}`);
-                return bot;
-            }
-        }
-        // 2. 其次选择其他 QQ 适配器 Bot
-        for (const bot of connectedBots) {
-            if (bot.platform && qqAdapters.includes(bot.platform)) {
-                ctx.logger.info(`选择其他 QQ 适配器 Bot: ${bot.platform} - ${bot.selfId || 'unknown'}`);
-                return bot;
-            }
-        }
-        // 3. 最后选择任何可用的已连接 Bot
-        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: now,
-            expireAt,
-            siteConfig
-        };
-        failedPushQueue.push(item);
-        ctx.logger.info(`添加到失败队列，类型: ${type}，目标数: ${targets.length}，队列长度: ${failedPushQueue.length}`);
-    }
-    // 处理失败队列
-    async function processFailedQueue() {
-        if (failedPushQueue.length === 0) {
-            return;
-        }
-        ctx.logger.info(`开始处理失败队列，队列长度: ${failedPushQueue.length}`);
-        const bot = getValidBot();
-        if (!bot) {
-            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);
-                continue;
-            }
-            try {
-                ctx.logger.info(`重试推送，类型: ${item.type}，重试次数: ${item.retries + 1}/${MAX_RETRIES}`);
-                // 根据类型格式化消息
-                let message;
-                if (item.type === 'post' || item.type === 'update') {
-                    message = formatPostMessage(item.data, true, item.type === 'update', item.siteConfig);
-                }
-                else {
-                    message = formatUserMessage(item.data, true, item.siteConfig);
-                }
-                // 推送到所有目标
-                for (const target of item.targets) {
-                    try {
-                        await bot.sendMessage(target, message);
-                        ctx.logger.info(`重试推送成功，类型: ${item.type}，目标: ${target}`);
-                    }
-                    catch (error) {
-                        ctx.logger.error(`重试推送失败，类型: ${item.type}，目标: ${target}，错误: ${error}`);
-                    }
-                }
-                // 推送成功，从队列中移除
-                itemsToRemove.push(i);
-                ctx.logger.info(`推送成功，从失败队列中移除，类型: ${item.type}`);
-            }
-            catch (error) {
-                ctx.logger.error(`处理失败队列项失败，类型: ${item.type}，错误: ${error}`);
-                item.retries++;
-            }
-        }
-        // 移除处理完成的项（从后往前移除，避免索引错乱）
-        for (let i = itemsToRemove.length - 1; i >= 0; i--) {
-            failedPushQueue.splice(itemsToRemove[i], 1);
-        }
-        ctx.logger.info(`失败队列处理完成，剩余队列长度: ${failedPushQueue.length}`);
-    }
-    // 定期处理失败队列，绑定到 ctx 生命周期
-    const failedQueueTimer = ctx.setInterval(processFailedQueue, RETRY_INTERVAL);
-    // 通用权限检查函数，检查用户是否为超级管理员
-    function checkSuperAdmin(session) {
-        // 检查是否为超级管理员
-        if (!session || !session.userId) {
-            ctx.logger.warn('匿名用户尝试调用需要权限的命令');
-            return { valid: false, message: '您不是超级管理员，无法执行此命令' };
-        }
-        // 获取当前用户的QQ号（兼容不同平台格式，如 onebot:123456789 -> 123456789）
-        const userId = session.userId.replace(/^\w+:/, '');
-        // 检查当前用户是否在插件配置的超级管理员列表中
-        if (!config.superAdmins || !config.superAdmins.includes(userId)) {
-            ctx.logger.warn(`非超级管理员 ${userId} 尝试调用需要权限的命令`);
-            return { valid: false, message: '您不是超级管理员，无法执行此命令' };
-        }
-        // 权限检查通过，继续执行命令
-        return { valid: true, userId };
-    }
-    // 检查数据库连接状态
-    async function checkDatabaseConnection() {
-        const now = Date.now();
-        // 避免频繁检查，30秒内只检查一次
-        if (now - lastDatabaseCheck < DATABASE_CHECK_INTERVAL && databaseConnected) {
-            return true;
-        }
-        try {
-            ctx.logger.info('开始检查数据库连接状态...');
-            // 执行一个简单的数据库查询来测试连接
-            await ctx.database.get('wordpress_config', {}, { limit: 1 });
-            ctx.logger.info('数据库连接正常');
-            databaseConnected = true;
-            lastDatabaseCheck = now;
-            return true;
-        }
-        catch (error) {
-            ctx.logger.error(`数据库连接异常: ${error}`);
-            databaseConnected = false;
-            lastDatabaseCheck = now;
-            return false;
-        }
-    }
-    // 确保数据库连接正常
-    async function ensureDatabaseConnection() {
-        const connected = await checkDatabaseConnection();
-        if (!connected) {
-            ctx.logger.warn('数据库连接异常，暂停推送任务');
-            // 记录失败
-            recordPushFailure('数据库连接异常');
-            // 等待3秒后再次尝试
-            await new Promise(resolve => setTimeout(resolve, 3000));
-            return await checkDatabaseConnection();
-        }
-        return true;
-    }
-    // 记录推送失败并发送通知
-    async function recordPushFailure(reason) {
-        const now = Date.now();
-        // 检查是否需要重置失败计数
-        if (now - lastFailureTime > FAILURE_RESET_INTERVAL) {
-            consecutiveFailureCount = 0;
-        }
-        // 增加失败计数
-        consecutiveFailureCount++;
-        lastFailureTime = now;
-        ctx.logger.error(`推送失败，原因: ${reason}，连续失败次数: ${consecutiveFailureCount}`);
-        // 检查是否需要发送通知
-        if (config.failureNotification.enable &&
-            consecutiveFailureCount >= config.failureNotification.threshold) {
-            await sendFailureNotification(reason);
-        }
-    }
-    // 发送失败通知
-    async function sendFailureNotification(reason) {
-        try {
-            const bot = getValidBot();
-            if (!bot) {
-                ctx.logger.error('无法发送失败通知，没有可用的 Bot 实例');
-                return;
-            }
-            // 确定通知目标
-            const notificationTargets = config.failureNotification.notificationTargets.length > 0
-                ? config.failureNotification.notificationTargets
-                : config.superAdmins;
-            if (notificationTargets.length === 0) {
-                ctx.logger.warn('无法发送失败通知，未配置通知目标');
-                return;
-            }
-            // 构建通知消息
-            const message = `🚨 WordPress 推送插件告警\n\n` +
-                `📅 时间: ${new Date().toLocaleString()}\n` +
-                `❌ 连续失败次数: ${consecutiveFailureCount}\n` +
-                `🔍 失败原因: ${reason}\n` +
-                `🌐 站点数: ${config.sites.length}\n` +
-                `📡 总推送目标数: ${config.sites.reduce((total, site) => total + site.targets.length, 0)}\n\n` +
-                `请及时检查插件状态和相关配置！`;
-            // 发送通知
-            for (const target of notificationTargets) {
-                try {
-                    await bot.sendMessage(target, message);
-                    ctx.logger.info(`已向 ${target} 发送推送失败通知`);
-                }
-                catch (error) {
-                    ctx.logger.error(`发送通知到 ${target} 失败: ${error}`);
-                }
-            }
-            // 重置失败计数
-            consecutiveFailureCount = 0;
-        }
-        catch (error) {
-            ctx.logger.error(`发送失败通知时发生错误: ${error}`);
-        }
-    }
-    // 重置失败计数
-    function resetFailureCount() {
-        consecutiveFailureCount = 0;
-        lastFailureTime = 0;
-        ctx.logger.info('推送失败计数已重置');
-    }
-    // 检查数据库表结构的函数
-    async function checkAndFixTableStructure() {
-        try {
-            ctx.logger.info('开始检查数据库表结构...');
-            ctx.logger.info('所有群聊现在共用一个文章标记，不再区分群聊');
-            ctx.logger.info('wordpress_group_pushes 表已不再使用，已移除相关功能');
-            // 尝试获取一些记录来验证表结构是否正确
-            try {
-                ctx.logger.info('验证 wordpress_post_updates 表结构...');
-                const testPostUpdate = await ctx.database.get('wordpress_post_updates', {}, {
-                    limit: 1
-                });
-                ctx.logger.info(`wordpress_post_updates 表验证成功，现有记录数：${testPostUpdate.length}`);
-            }
-            catch (error) {
-                ctx.logger.warn(`wordpress_post_updates 表可能结构不正确，尝试重新初始化...`);
-                // 尝试删除旧表并重新初始化
-                try {
-                    ctx.logger.info('尝试删除旧的 wordpress_post_updates 表...');
-                    await ctx.database.drop('wordpress_post_updates');
-                    ctx.logger.info('旧表删除成功，重新初始化表结构...');
-                    // 重新扩展模型
-                    ctx.model.extend('wordpress_post_updates', {
-                        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.logger.info('wordpress_post_updates 表重新初始化成功');
-                }
-                catch (dropError) {
-                    ctx.logger.warn(`删除旧表失败，可能表不存在：${dropError}`);
-                }
-            }
-            try {
-                ctx.logger.info('验证 wordpress_user_registrations 表结构...');
-                const testUserRegistration = await ctx.database.get('wordpress_user_registrations', {}, {
-                    limit: 1
-                });
-                ctx.logger.info(`wordpress_user_registrations 表验证成功，现有记录数：${testUserRegistration.length}`);
-            }
-            catch (error) {
-                ctx.logger.warn(`wordpress_user_registrations 表可能结构不正确，尝试重新初始化...`);
-                // 尝试删除旧表并重新初始化
-                try {
-                    ctx.logger.info('尝试删除旧的 wordpress_user_registrations 表...');
-                    await ctx.database.drop('wordpress_user_registrations');
-                    ctx.logger.info('旧表删除成功，重新初始化表结构...');
-                    // 重新扩展模型
-                    ctx.model.extend('wordpress_user_registrations', {
-                        id: { type: 'integer', nullable: false },
-                        siteId: { type: 'string', nullable: false },
-                        userId: { type: 'integer', nullable: false },
-                        pushedAt: { type: 'timestamp', nullable: false }
-                    }, {
-                        primary: 'id',
-                        autoInc: true,
-                        unique: ['siteId', 'userId'] // 每个站点的用户 ID 唯一
+                    await storageService.setPushConfig({
+                        groupId,
+                        enabled: true,
+                        enableUpdatePush: config.enableUpdatePush || true,
+                        enableAtAll: config.allowAtAll || false,
+                        lastPushTime: new Date()
                     });
-                    ctx.logger.info('wordpress_user_registrations 表重新初始化成功');
-                }
-                catch (dropError) {
-                    ctx.logger.warn(`删除旧表失败，可能表不存在：${dropError}`);
-                }
-            }
-            try {
-                ctx.logger.info('验证 wordpress_config 表结构...');
-                const testConfig = await ctx.database.get('wordpress_config', {}, {
-                    limit: 1
-                });
-                ctx.logger.info(`wordpress_config 表验证成功，现有记录数：${testConfig.length}`);
-            }
-            catch (error) {
-                ctx.logger.warn(`wordpress_config 表可能结构不正确，尝试重新初始化...`);
-                // 尝试删除旧表并重新初始化
-                try {
-                    ctx.logger.info('尝试删除旧的 wordpress_config 表...');
-                    await ctx.database.drop('wordpress_config');
-                    ctx.logger.info('旧表删除成功，重新初始化表结构...');
-                    // 重新扩展模型
-                    ctx.model.extend('wordpress_config', {
-                        id: { type: 'string', nullable: false },
-                        key: { type: 'string', nullable: false },
-                        value: { type: 'string', nullable: false },
-                        updatedAt: { type: 'timestamp', nullable: false }
-                    }, {
-                        primary: 'id',
-                        unique: ['key']
-                    });
-                    ctx.logger.info('wordpress_config 表重新初始化成功');
-                }
-                catch (dropError) {
-                    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) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            ctx.logger.error(`检查表结构失败：${errorMessage}`);
-            ctx.logger.error(`错误栈：${error instanceof Error ? error.stack : '无'}`);
-        }
-    }
-    // 通用HTTP请求包装函数，添加超时和重试机制
-    async function httpRequest(url, config = {}, maxRetries = CONSTANTS.MAX_RETRIES) {
-        const requestConfig = {
-            ...config,
-            timeout: CONSTANTS.HTTP_TIMEOUT, // 10秒超时
-        };
-        let retries = 0;
-        while (retries <= maxRetries) {
-            try {
-                // API 请求频率控制
-                const now = Date.now();
-                const timeSinceLastRequest = now - lastRequestTime;
-                if (timeSinceLastRequest < CONSTANTS.API_RATE_LIMIT) {
-                    const waitTime = CONSTANTS.API_RATE_LIMIT - timeSinceLastRequest;
-                    ctx.logger.info(`API 请求频率限制，等待 ${waitTime}ms 后继续请求`);
-                    await new Promise(resolve => setTimeout(resolve, waitTime));
+                    ctx.logger.info(`Default push config initialized for group: ${groupId}`);
                 }
-                // 更新上次请求时间
-                lastRequestTime = Date.now();
-                ctx.logger.info(`HTTP请求: ${url} (尝试 ${retries + 1}/${maxRetries + 1})`);
-                const response = await ctx.http.get(url, requestConfig);
-                ctx.logger.info(`HTTP请求成功: ${url}`);
-                return response;
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                ctx.logger.warn(`HTTP请求失败 (${retries + 1}/${maxRetries + 1}): ${errorMessage}`);
-                retries++;
-                if (retries > maxRetries) {
-                    ctx.logger.error(`HTTP请求最终失败，已达到最大重试次数: ${url}`);
-                    // 记录推送失败
-                    recordPushFailure(`API请求失败: ${errorMessage}`);
-                    return null;
+                catch (error) {
+                    ctx.logger.error(`Failed to initialize default push config for group ${groupId}:`, error);
                 }
-                // 重试前等待
-                await new Promise(resolve => setTimeout(resolve, CONSTANTS.RETRY_DELAY));
-            }
-        }
-        return null;
-    }
-    async function fetchLatestPosts(site) {
-        try {
-            const url = `${site.url}/wp-json/wp/v2/posts?per_page=${site.maxArticles}&orderby=date&order=desc`;
-            ctx.logger.info(`正在获取站点 ${site.id} (${site.name}) 的文章: ${url}`);
-            // 准备请求配置，添加认证头（如果配置了用户名和应用程序密码）
-            const requestConfig = {};
-            if (site.username && site.applicationPassword) {
-                // 处理WordPress应用程序密码，移除空格（WordPress生成的应用密码格式为：hGR2 sPFu Yncl xHc4 AvJq cUtB）
-                const username = site.username;
-                const password = site.applicationPassword.replace(/\s+/g, ''); // 移除所有空格
-                const auth = Buffer.from(`${username}:${password}`).toString('base64');
-                requestConfig.headers = {
-                    Authorization: `Basic ${auth}`
-                };
-            }
-            const response = await httpRequest(url, requestConfig);
-            if (!response) {
-                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 { success: true, data: response, error: '' };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            const fullErrorMessage = `获取站点 ${site.id} (${site.name}) 的 WordPress 文章失败: ${errorMessage}`;
-            ctx.logger.error(fullErrorMessage);
-            // 记录失败
-            recordPushFailure(`获取站点 ${site.id} (${site.name}) 的文章失败: ${errorMessage}`);
-            return { success: false, data: [], error: fullErrorMessage };
-        }
-    }
-    async function fetchLatestUsers(site) {
-        try {
-            // 修改API请求，添加_fields参数明确请求注册日期字段
-            // WordPress REST API 默认可能不会返回注册日期，需要明确请求
-            const fields = 'id,name,slug,date,date_registered,registered_date,created_at,registeredAt,email,roles,url,description,link,avatar_urls';
-            const url = `${site.url}/wp-json/wp/v2/users?per_page=${site.maxArticles}&orderby=registered_date&order=desc&_fields=${fields}`;
-            ctx.logger.info(`正在获取站点 ${site.id} (${site.name}) 的用户: ${url}`);
-            // 准备请求配置，添加认证头（如果配置了用户名和应用程序密码）
-            const requestConfig = {};
-            if (site.username && site.applicationPassword) {
-                // 处理WordPress应用程序密码，移除空格（WordPress生成的应用密码格式为：hGR2 sPFu Yncl xHc4 AvJq cUtB）
-                const username = site.username;
-                const password = site.applicationPassword.replace(/\s+/g, ''); // 移除所有空格
-                const auth = Buffer.from(`${username}:${password}`).toString('base64');
-                requestConfig.headers = {
-                    Authorization: `Basic ${auth}`
-                };
-            }
-            const response = await httpRequest(url, requestConfig);
-            if (!response) {
-                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 { success: false, data: [], error: errorMessage };
-            }
-            ctx.logger.info(`成功获取站点 ${site.id} (${site.name}) 的 ${response.length} 位用户`);
-            // 添加调试日志，查看API返回的实际数据结构
-            if (response.length > 0) {
-                ctx.logger.info(`用户数据示例: ${JSON.stringify(response[0], null, 2)}`);
-                // 打印所有可能的日期相关字段
-                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 { success: true, data: response, error: '' };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            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 { success: false, data: [], error: fullErrorMessage };
-        }
-    }
-    async function fetchUpdatedPosts(site) {
-        try {
-            const url = `${site.url}/wp-json/wp/v2/posts?per_page=${site.maxArticles}&orderby=modified&order=desc`;
-            ctx.logger.info(`正在获取站点 ${site.id} (${site.name}) 的更新文章: ${url}`);
-            // 准备请求配置，添加认证头（如果配置了用户名和应用程序密码）
-            const requestConfig = {};
-            if (site.username && site.applicationPassword) {
-                // 处理WordPress应用程序密码，移除空格（WordPress生成的应用密码格式为：hGR2 sPFu Yncl xHc4 AvJq cUtB）
-                const username = site.username;
-                const password = site.applicationPassword.replace(/\s+/g, ''); // 移除所有空格
-                const auth = Buffer.from(`${username}:${password}`).toString('base64');
-                requestConfig.headers = {
-                    Authorization: `Basic ${auth}`
-                };
-            }
-            const response = await httpRequest(url, requestConfig);
-            if (!response) {
-                const errorMessage = `获取站点 ${site.id} (${site.name}) 的 WordPress 更新文章失败，已达到最大重试次数`;
-                ctx.logger.error(errorMessage);
-                // 记录失败
-                recordPushFailure(`获取站点 ${site.id} (${site.name}) 的更新文章失败`);
-                return { success: false, data: [], error: errorMessage };
-            }
-            ctx.logger.info(`成功获取站点 ${site.id} (${site.name}) 的 ${response.length} 篇更新文章`);
-            return { success: true, data: response, error: '' };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            const fullErrorMessage = `获取站点 ${site.id} (${site.name}) 的 WordPress 更新文章失败: ${errorMessage}`;
-            ctx.logger.error(fullErrorMessage);
-            // 记录失败
-            recordPushFailure(`获取站点 ${site.id} (${site.name}) 的更新文章失败: ${errorMessage}`);
-            return { success: false, data: [], error: fullErrorMessage };
-        }
-    }
-    async function isUserPushed(siteId, userId) {
-        try {
-            // 确保数据库连接正常
-            const connected = await ensureDatabaseConnection();
-            if (!connected) {
-                ctx.logger.warn('数据库连接异常，跳过检查用户推送记录');
-                return false;
-            }
-            ctx.logger.info(`检查用户是否已推送，站点 ID: ${siteId}，用户 ID: ${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;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            ctx.logger.error(`检查用户推送记录失败：${errorMessage}`);
-            ctx.logger.error(`错误栈：${error instanceof Error ? error.stack : '无'}`);
-            // 发生错误时，默认返回 false，避免阻塞推送流程
-            return false;
-        }
-    }
-    async function getPostUpdateRecord(siteId, postId) {
-        try {
-            // 确保数据库连接正常
-            const connected = await ensureDatabaseConnection();
-            if (!connected) {
-                ctx.logger.warn('数据库连接异常，跳过获取文章更新记录');
-                return null;
-            }
-            ctx.logger.info(`获取文章更新记录，站点 ID: ${siteId}，文章 ID: ${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;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            ctx.logger.error(`获取文章更新记录失败：${errorMessage}`);
-            ctx.logger.error(`错误栈：${error instanceof Error ? error.stack : '无'}`);
-            // 发生错误时，返回 null，避免阻塞推送流程
-            return null;
-        }
-    }
-    async function markUserAsPushed(siteId, userId) {
-        try {
-            // 确保数据库连接正常
-            const connected = await ensureDatabaseConnection();
-            if (!connected) {
-                ctx.logger.warn('数据库连接异常，跳过标记用户推送记录');
-                return;
-            }
-            ctx.logger.info(`开始标记用户已推送，站点 ID: ${siteId}，用户 ID: ${userId}`);
-            // 创建新记录，不手动指定id，让数据库自动生成
-            const newRecord = {
-                siteId,
-                userId: parseInt(userId),
-                pushedAt: new Date()
-            };
-            ctx.logger.info(`准备创建用户推送记录：${JSON.stringify(newRecord)}`);
-            await ctx.database.create('wordpress_user_registrations', newRecord);
-            ctx.logger.info(`已成功标记站点 ${siteId} 用户 ${userId} 为已推送`);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            if (errorMessage.includes('UNIQUE constraint failed')) {
-                ctx.logger.warn(`用户推送记录已存在，跳过重复插入：站点 ${siteId} 用户 ${userId}`);
-                ctx.logger.warn(`完整错误信息：${errorMessage}`);
-            }
-            else {
-                ctx.logger.error(`标记用户推送记录失败：${errorMessage}`);
-                ctx.logger.error(`错误栈：${error instanceof Error ? error.stack : '无'}`);
-                ctx.logger.error(`插入参数：siteId=${siteId}, userId=${userId}`);
-                // 非约束冲突错误，不抛出，确保插件继续运行
             }
         }
     }
-    async function updatePostUpdateRecord(siteId, postId, modifiedDate) {
+    // 清理服务
+    function cleanupServices() {
+        ctx.logger.info('Cleaning up WordPress push plugin services...');
         try {
-            // 确保数据库连接正常
-            const connected = await ensureDatabaseConnection();
-            if (!connected) {
-                ctx.logger.warn('数据库连接异常，跳过更新文章更新记录');
-                return;
-            }
-            ctx.logger.info(`开始更新文章更新记录，站点 ID: ${siteId}，文章 ID: ${postId}，修改时间: ${modifiedDate}`);
-            const record = await getPostUpdateRecord(siteId, postId);
-            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: parseInt(postId) });
-                ctx.logger.info(`已删除旧记录，站点 ID: ${siteId}，文章 ID: ${postId}`);
+            if (scheduleService) {
+                scheduleService.dispose();
+                ctx.logger.info('ScheduleService disposed successfully');
             }
-            // 创建新记录，不指定 id 字段，让数据库自动生成
-            const newRecord = {
-                siteId,
-                postId: parseInt(postId),
-                lastModified: modifiedDate,
-                pushedAt: new Date()
-            };
-            ctx.logger.info(`准备创建新记录，站点 ID: ${siteId}，文章 ID: ${postId}，记录内容: ${JSON.stringify(newRecord)}`);
-            await ctx.database.create('wordpress_post_updates', newRecord);
-            ctx.logger.info(`已成功更新文章更新记录，站点 ID: ${siteId}，文章 ID: ${postId}`);
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            ctx.logger.error(`更新文章更新记录失败，站点 ID: ${siteId}，文章 ID: ${postId}`);
-            ctx.logger.error(`错误信息: ${errorMessage}`);
-            ctx.logger.error(`错误栈: ${error instanceof Error ? error.stack : '无'}`);
-            // 不再抛出错误，确保推送流程继续运行
-            // 发生错误时，默认返回，避免阻塞推送流程
-            ctx.logger.warn(`更新文章更新记录失败，但推送流程将继续运行，站点 ID: ${siteId}，文章 ID: ${postId}`);
-        }
-    }
-    // 1. 新增强清洗函数：针对性解决敏感字符问题
-    function sanitizeContent(content) {
-        let sanitized = content
-            .replace(/<[^>]*>/g, '') // 移除所有 HTML 标签
-            .replace(/[\x00-\x1F\x7F]/g, '') // 移除不可见控制符，QQ 接口明确禁止
-            .replace(/\u3000/g, ' ') // 全角空格转半角空格，解决适配器编码缺陷
-            .replace(/\s+/g, ' ') // 标准化所有空白符为单个半角空格
-            .trim(); // 移除首尾空格
-        // 添加敏感词过滤
-        sanitized = filterSensitiveWords(sanitized);
-        return sanitized;
-    }
-    // 敏感词过滤函数
-    function filterSensitiveWords(content) {
-        let filteredContent = content;
-        let hasSensitiveWords = false;
-        // 遍历敏感词列表进行替换
-        for (const word of CONSTANTS.SENSITIVE_WORDS) {
-            if (filteredContent.includes(word)) {
-                hasSensitiveWords = true;
-                const regex = new RegExp(word, 'gi'); // 不区分大小写
-                filteredContent = filteredContent.replace(regex, CONSTANTS.SENSITIVE_REPLACEMENT);
-            }
-        }
-        // 如果检测到敏感词，记录日志
-        if (hasSensitiveWords) {
-            ctx.logger.info('消息内容包含敏感词，已进行过滤处理');
-            // 仅记录处理信息，不记录具体内容，保护隐私
-        }
-        return filteredContent;
-    }
-    function formatPostMessage(post, mention = false, isUpdate = false, siteConfig) {
-        // 使用默认站点配置或传入的站点配置
-        const configToUse = siteConfig || config.sites[0];
-        if (!configToUse) {
-            ctx.logger.error('无可用的站点配置');
-            return '';
-        }
-        // 生成缓存键，包含推送模板配置信息
-        const cacheKey = `post_${post.id}_${mention}_${isUpdate}_${configToUse.mentionAll}_${JSON.stringify(configToUse.pushTemplate)}`;
-        // 检查缓存
-        const cached = formatCache.post.get(cacheKey);
-        if (cached && isCacheValid(cached.timestamp)) {
-            ctx.logger.info(`使用缓存的文章消息格式，文章 ID: ${post.id}`);
-            return cached.value;
-        }
-        // 使用统一的强清洗函数
-        let title = sanitizeContent(post.title.rendered);
-        // 严格截断标题为最大长度
-        if (title.length > CONSTANTS.MAX_TITLE_LENGTH) {
-            title = title.substring(0, CONSTANTS.MAX_TITLE_LENGTH - 3) + '...';
-        }
-        // 根据配置格式化日期
-        const formatDate = (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');
-            const hours = String(date.getHours()).padStart(2, '0');
-            const minutes = String(date.getMinutes()).padStart(2, '0');
-            // 根据配置的日期格式进行替换
-            let formattedDate = configToUse.pushTemplate.dateFormat
-                .replace('YYYY', year.toString())
-                .replace('MM', month)
-                .replace('DD', day)
-                .replace('HH', hours)
-                .replace('mm', minutes);
-            return formattedDate;
-        };
-        const date = formatDate(post.date);
-        // 链接强制编码
-        const encodedLink = encodeURI(post.link);
-        // 构建 @全体成员 文本（适配 QQ 官方 bot 和其他适配器）
-        const atAllText = mention && configToUse.mentionAll ? '@全体成员 ' : '';
-        // 只使用一个极简表情
-        const messageType = isUpdate ? '📝' : '📰';
-        // 构建消息内容
-        let messageParts = [];
-        // 添加头部
-        messageParts.push(`${messageType} ${atAllText}${date} - ${title}`);
-        // 根据配置添加作者
-        if (configToUse.pushTemplate.showAuthor && post.author) {
-            messageParts.push(`👤 作者: ${post.author}`);
-        }
-        // 根据配置添加摘要
-        if (configToUse.pushTemplate.showExcerpt && post.excerpt) {
-            let excerpt = sanitizeContent(post.excerpt.rendered);
-            // 截断摘要长度
-            if (excerpt.length > 100) {
-                excerpt = excerpt.substring(0, 97) + '...';
-            }
-            if (excerpt) {
-                messageParts.push(`📄 摘要: ${excerpt}`);
-            }
-        }
-        // 根据配置添加链接
-        if (configToUse.pushTemplate.linkPosition === 'top') {
-            messageParts.unshift(`🔗 ${encodedLink}`);
-        }
-        else if (configToUse.pushTemplate.linkPosition === 'bottom') {
-            messageParts.push(`🔗 ${encodedLink}`);
-        }
-        // 合并消息部分
-        let message = messageParts.join('\n');
-        // 双级长度控制：整体消息兜底最大长度
-        if (message.length > CONSTANTS.MAX_MESSAGE_LENGTH) {
-            message = message.substring(0, CONSTANTS.MAX_MESSAGE_LENGTH - 3) + '...';
-            ctx.logger.warn(`文章消息超长，已截断，文章 ID: ${post.id}`);
+            ctx.logger.error('Error disposing ScheduleService:', error);
         }
-        // 缓存结果
-        formatCache.post.set(cacheKey, {
-            value: message,
-            timestamp: Date.now()
-        });
-        // 直接返回纯字符串，跳过适配器复杂编码
-        return message;
     }
-    function formatUserMessage(user, mention = false, siteConfig) {
-        // 使用默认站点配置或传入的站点配置
-        const configToUse = siteConfig || config.sites[0];
-        if (!configToUse) {
-            ctx.logger.error('无可用的站点配置');
-            return '';
+    // 验证配置
+    function validateConfig(config) {
+        if (!config.wordpressUrl) {
+            throw new Error('WordPress URL is required');
         }
-        // 生成缓存键
-        const cacheKey = `user_${user.id}_${mention}_${configToUse.mentionAll}`;
-        // 检查缓存
-        const cached = formatCache.user.get(cacheKey);
-        if (cached && isCacheValid(cached.timestamp)) {
-            ctx.logger.info(`使用缓存的用户消息格式，用户 ID: ${user.id}`);
-            return cached.value;
+        // 验证认证配置
+        if ((config.authType === 'basic' || config.authType === 'application-password') && (!config.username || !config.password)) {
+            throw new Error(`Authentication type ${config.authType} requires both username and password`);
         }
-        // 使用统一的强清洗函数
-        let username = sanitizeContent(user.name);
-        // 严格截断用户名为最大长度
-        if (username.length > CONSTANTS.MAX_USERNAME_LENGTH) {
-            username = username.substring(0, CONSTANTS.MAX_USERNAME_LENGTH - 3) + '...';
-        }
-        // 安全处理日期，避免显示 "Invalid Date"，自定义格式
-        let registerDate = '未知时间';
-        try {
-            ctx.logger.info(`正在处理用户 ${username} 的注册日期`);
-            // 尝试所有可能的日期字段，按优先级排序
-            const dateFields = [
-                'registered_date',
-                'user_registered',
-                'date_registered',
-                'created_at',
-                'registeredAt',
-                'date'
-            ];
-            let dateStr;
-            // 遍历所有可能的日期字段
-            for (const field of dateFields) {
-                if (user[field]) {
-                    dateStr = user[field];
-                    ctx.logger.info(`找到日期字段 ${field}: ${dateStr}`);
-                    break;
-                }
-            }
-            // 如果没有找到已知字段，尝试打印所有字段以便调试
-            if (!dateStr) {
-                ctx.logger.info(`用户 ${username} 的所有字段: ${JSON.stringify(Object.keys(user))}`);
-                ctx.logger.info(`用户 ${username} 的原始数据: ${JSON.stringify(user)}`);
-            }
-            if (dateStr) {
-                // 使用统一的时间处理工具函数
-                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');
-                    const hours = String(date.getHours()).padStart(2, '0');
-                    const minutes = String(date.getMinutes()).padStart(2, '0');
-                    registerDate = `${year}-${month}-${day} ${hours}:${minutes}`;
-                    ctx.logger.info(`格式化后的日期: ${registerDate}`);
+        // 验证群聊 ID 格式
+        if (config.defaultGroups) {
+            for (const groupId of config.defaultGroups) {
+                if (!groupId || typeof groupId !== 'string' || !/^[a-zA-Z0-9_-]+$/.test(groupId)) {
+                    throw new Error(`Invalid group ID format: ${groupId}`);
                 }
             }
         }
-        catch (error) {
-            // 捕获任何异常，确保消息能正常生成
-            ctx.logger.error(`处理用户 ${username} 日期时出错: ${error}`);
-        }
-        // 构建 @全体成员 文本（适配 QQ 官方 bot 和其他适配器）
-        const atAllText = mention && configToUse.mentionAll ? '@全体成员 ' : '';
-        // 只使用一个极简表情
-        const messageType = '👤';
-        // 构建核心消息内容，严格控制格式和换行
-        // 格式：[表情] [@全体] 新用户注册 - [用户名]
-        //       注册时间: [时间]
-        let message = `${messageType} ${atAllText}新用户注册 - ${username}\n注册时间: ${registerDate}`;
-        // 严格控制整体消息长度为最大长度
-        if (message.length > CONSTANTS.MAX_MESSAGE_LENGTH) {
-            message = message.substring(0, CONSTANTS.MAX_MESSAGE_LENGTH - 3) + '...';
-            ctx.logger.warn(`用户消息超长，已截断，用户 ID: ${user.id}`);
+        // 验证 WordPress URL 格式
+        if (!/^https?:\/\//i.test(config.wordpressUrl)) {
+            throw new Error('WordPress URL must start with http:// or https://');
         }
-        // 缓存结果
-        formatCache.user.set(cacheKey, {
-            value: message,
-            timestamp: Date.now()
-        });
-        // 直接返回纯字符串，跳过适配器复杂编码
-        return message;
     }
-    async function pushNewPosts() {
-        const bot = getValidBot();
-        if (!bot) {
-            ctx.logger.error('没有可用的 Bot 实例');
-            recordPushFailure('没有可用的 Bot 实例');
-            return;
-        }
-        // 修复 Bot 标识 undefined 问题
-        const botId = bot.selfId || 'unknown';
-        ctx.logger.info(`使用 bot ${bot.platform}:${botId} 进行推送`);
-        // 遍历所有站点
-        for (const site of config.sites) {
-            ctx.logger.info(`开始处理站点: ${site.id} (${site.name})`);
-            // 推送新文章
-            if (site.enableAutoPush) {
-                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, String(post.id));
-                        const hasPushed = !!postRecord;
-                        ctx.logger.info(`检查结果: 站点 ${site.id} 文章 ${post.id} 是否已推送：${hasPushed ? '是' : '否'}`);
-                        if (!hasPushed) {
-                            // 推送到该站点的所有目标群聊
-                            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 = formatPostMessage(post, site.mentionAll, false, site);
-                                    ctx.logger.info(`准备推送新文章到目标: ${stringTarget}`);
-                                    await bot.sendMessage(stringTarget, message);
-                                    ctx.logger.info(`已推送新文章到 ${stringTarget}: ${post.title.rendered}`);
-                                }
-                                catch (error) {
-                                    const errorMessage = error instanceof Error ? error.message : String(error);
-                                    ctx.logger.error(`推送新文章到 ${target} 失败: ${errorMessage}`);
-                                    ctx.logger.error(`错误详情: ${JSON.stringify(error)}`);
-                                    failedTargets.push(target);
-                                    // 记录推送失败
-                                    recordPushFailure(`推送消息失败到 ${target}: ${errorMessage}`);
-                                }
-                            }
-                            // 如果有失败的目标，添加到失败队列
-                            if (failedTargets.length > 0) {
-                                addToFailedQueue('post', post, failedTargets, site);
-                            }
-                            // 标记文章已推送（所有群聊共用一个标记）
-                            await updatePostUpdateRecord(site.id, String(post.id), new Date(post.modified));
-                            ctx.logger.info(`已标记站点 ${site.id} 文章 ${post.id} 为已推送，所有群聊将不再推送此文章`);
-                        }
-                        else {
-                            ctx.logger.info(`跳过推送: 站点 ${site.id} 文章 ${post.id} 已推送过，所有群聊将不再推送`);
-                        }
-                    }
-                }
-            }
-            // 推送文章更新
-            if (site.enableUpdatePush) {
-                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, String(post.id));
-                        const postModifiedDate = new Date(post.modified);
-                        // 检查文章是否有更新
-                        if (updateRecord && postModifiedDate > new Date(updateRecord.lastModified)) {
-                            ctx.logger.info(`站点 ${site.id} 文章 ${post.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 = formatPostMessage(post, site.mentionAll, true, site);
-                                    ctx.logger.info(`准备推送文章更新到目标: ${stringTarget}`);
-                                    await bot.sendMessage(stringTarget, message);
-                                    ctx.logger.info(`已推送文章更新到 ${stringTarget}: ${post.title.rendered}`);
-                                }
-                                catch (error) {
-                                    const errorMessage = error instanceof Error ? error.message : String(error);
-                                    ctx.logger.error(`推送文章更新到 ${target} 失败: ${errorMessage}`);
-                                    ctx.logger.error(`错误详情: ${JSON.stringify(error)}`);
-                                    failedTargets.push(target);
-                                    // 记录推送失败
-                                    recordPushFailure(`推送文章更新失败到 ${target}: ${errorMessage}`);
-                                }
-                            }
-                            // 如果有失败的目标，添加到失败队列
-                            if (failedTargets.length > 0) {
-                                addToFailedQueue('update', post, failedTargets, site);
-                            }
-                            // 更新文章更新记录（所有群聊共用一个标记）
-                            await updatePostUpdateRecord(site.id, String(post.id), postModifiedDate);
-                            ctx.logger.info(`已更新站点 ${site.id} 文章 ${post.id} 的推送记录，所有群聊将使用此更新时间作为新的推送基准`);
-                        }
-                    }
-                }
-            }
-            // 推送新用户注册
-            if (site.enableUserPush) {
-                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, 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);
-                                    ctx.logger.info(`已推送新用户到 ${stringTarget}: ${user.name}`);
-                                }
-                                catch (error) {
-                                    const errorMessage = error instanceof Error ? error.message : String(error);
-                                    ctx.logger.error(`推送新用户到 ${target} 失败: ${errorMessage}`);
-                                    ctx.logger.error(`错误详情: ${JSON.stringify(error)}`);
-                                    failedTargets.push(target);
-                                    // 记录推送失败
-                                    recordPushFailure(`推送新用户失败到 ${target}: ${errorMessage}`);
-                                }
-                            }
-                            // 如果有失败的目标，添加到失败队列
-                            if (failedTargets.length > 0) {
-                                addToFailedQueue('user', user, failedTargets, site);
-                            }
-                            // 标记用户已推送
-                            await markUserAsPushed(site.id, String(user.id));
-                        }
-                    }
-                }
-            }
-        }
-    }
-    ctx.command('wordpress.latest [siteId]', '查看最新文章，可选站点 ID')
-        .action(async ({ session }, siteId) => {
-        ctx.logger.info(`命令 wordpress.latest 被调用，站点 ID: ${siteId || '默认'}`);
-        // 选择站点
-        const targetSite = siteId
-            ? config.sites.find(site => site.id === siteId)
-            : config.sites[0];
-        if (!targetSite) {
-            return `未找到站点 ID: ${siteId}`;
-        }
-        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} 暂无文章`;
-        }
-        // 动态添加文章，确保消息长度不超过500字符
-        let message = `📰 ${targetSite.name} 最新文章：\n`;
-        let addedCount = 0;
-        for (const post of posts) {
-            const title = sanitizeContent(post.title.rendered);
-            // 自定义日期格式，避免过长
-            const date = new Date(post.date);
-            const formattedDate = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;
-            const encodedLink = encodeURI(post.link);
-            // 截断标题，避免单条过长
-            const truncatedTitle = title.length > CONSTANTS.MAX_POST_TITLE_DISPLAY_LENGTH ? title.substring(0, CONSTANTS.MAX_POST_TITLE_DISPLAY_LENGTH - 3) + '...' : title;
-            // 单篇文章的消息片段
-            const postMessage = `${truncatedTitle}\n📅 ${formattedDate}\n🔗 ${encodedLink}\n`;
-            // 检查添加后是否超过500字符，如果超过则停止添加
-            if (message.length + postMessage.length > 500) {
-                break;
-            }
-            message += postMessage;
-            addedCount++;
-        }
-        // 如果有更多文章未显示，添加提示
-        if (addedCount < posts.length) {
-            message += `... 共 ${posts.length} 篇文章，显示前 ${addedCount} 篇`;
-        }
-        ctx.logger.info(`准备返回消息，长度: ${message.length}，显示 ${addedCount}/${posts.length} 篇文章`);
-        return message;
-    });
-    ctx.command('wordpress.list [siteId]', '查看文章列表，可选站点 ID')
-        .action(async (_, siteId) => {
-        ctx.logger.info(`命令 wordpress.list 被调用，站点 ID: ${siteId || '默认'}`);
-        // 选择站点
-        const targetSite = siteId
-            ? config.sites.find(site => site.id === siteId)
-            : config.sites[0];
-        if (!targetSite) {
-            return `未找到站点 ID: ${siteId}`;
-        }
-        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} 暂无文章`;
-        }
-        // 使用数组拼接消息，便于控制格式和长度
-        const messageParts = [`📚 ${targetSite.name} 文章列表：`];
-        for (const post of posts) {
-            const title = sanitizeContent(post.title.rendered);
-            // 截断标题，避免单条过长
-            const truncatedTitle = title.length > 50 ? title.substring(0, 47) + '...' : title;
-            messageParts.push(`${post.id}. ${truncatedTitle}`);
-        }
-        let message = messageParts.join('\n');
-        // 长度验证，超过 500 字符则精简
-        if (message.length > 500) {
-            ctx.logger.warn(`消息过长，长度: ${message.length}，将进行精简`);
-            // 只保留前10篇文章
-            const shortParts = messageParts.slice(0, 11); // 1个标题 + 10篇文章
-            shortParts.push('... 更多文章请查看完整列表');
-            message = shortParts.join('\n');
-        }
-        ctx.logger.info(`准备返回消息，长度: ${message.length}`);
-        return message;
-    });
-    ctx.command('wordpress.push', '手动推送最新文章')
-        .action(async () => {
-        ctx.logger.info('命令 wordpress.push 被调用');
-        await pushNewPosts();
-        return '已检查并推送最新文章';
-    });
-    ctx.command('wordpress.status [siteId]', '查看插件状态，可选站点 ID')
-        .action(({ session }, siteId) => {
-        ctx.logger.info(`命令 wordpress.status 被调用，站点 ID: ${siteId || '所有'}`);
-        // 获取当前群号，如果有的话
-        const currentGroup = session?.channelId || '未知群聊';
-        if (siteId) {
-            // 显示单个站点状态
-            const targetSite = config.sites.find(site => site.id === siteId);
-            if (!targetSite) {
-                return `未找到站点 ID: ${siteId}`;
-            }
-            // 使用数组拼接消息，便于控制格式和长度
-            const messageParts = [
-                `📊 WordPress 插件状态 - ${targetSite.name}`,
-                `🌐 站点: ${targetSite.url}`,
-                `⏰ 间隔: ${targetSite.interval / 1000} 秒`,
-                `🎯 推送目标: ${targetSite.targets.join(', ') || '无'}`,
-                `🔔 自动推送: ${targetSite.enableAutoPush ? '开启' : '关闭'}`,
-                `🔄 更新推送: ${targetSite.enableUpdatePush ? '开启' : '关闭'}`,
-                `👤 用户推送: ${targetSite.enableUserPush ? '开启' : '关闭'}`,
-                `📢 @全体: ${targetSite.mentionAll ? '开启' : '关闭'}`,
-                `📝 最多推送: ${targetSite.maxArticles} 篇`
-            ];
-            // 合并为单行文本，统一换行符
-            let message = messageParts.join('\n');
-            // 长度验证，超过 500 字符则精简
-            if (message.length > 500) {
-                ctx.logger.warn(`消息过长，长度: ${message.length}，将进行精简`);
-                message = messageParts.slice(0, 5).join('\n') + '\n... 更多配置请查看完整状态';
-            }
-            ctx.logger.info(`准备返回消息，长度: ${message.length}`);
-            // 直接返回纯字符串，跳过适配器复杂编码
-            return message;
-        }
-        else {
-            // 显示所有站点状态
-            let message = '📊 WordPress 插件状态\n\n';
-            config.sites.forEach((site, index) => {
-                const siteMessage = `站点 ${index + 1}: ${site.name} (${site.id})\n` +
-                    `🌐 URL: ${site.url}\n` +
-                    `⏰ 间隔: ${site.interval / 1000} 秒\n` +
-                    `🎯 目标: ${site.targets.join(', ') || '无'}\n` +
-                    `🔔 自动: ${site.enableAutoPush ? '开启' : '关闭'}\n` +
-                    `🔄 更新: ${site.enableUpdatePush ? '开启' : '关闭'}\n` +
-                    `👤 用户: ${site.enableUserPush ? '开启' : '关闭'}\n\n`;
-                // 检查添加后是否超过500字符
-                if (message.length + siteMessage.length > 500) {
-                    message += '... 更多站点请使用站点 ID 查看详细状态';
-                    return false;
-                }
-                message += siteMessage;
-            });
-            ctx.logger.info(`准备返回消息，长度: ${message.length}`);
-            return message;
-        }
-    });
-    ctx.command('wordpress.site.toggle-update <siteId>', '切换指定站点的文章更新推送开关')
-        .action(async ({ session }, siteId) => {
-        // 检查权限
-        const authResult = checkSuperAdmin(session);
-        if (!authResult.valid) {
-            return authResult.message;
-        }
-        ctx.logger.info(`命令 wordpress.site.toggle-update 被调用，站点 ID: ${siteId}`);
-        // 查找站点
-        const site = config.sites.find(s => s.id === siteId);
-        if (!site) {
-            return `未找到站点 ID: ${siteId}`;
-        }
-        // 切换开关
-        site.enableUpdatePush = !site.enableUpdatePush;
-        await saveSiteConfig(siteId, site);
-        return `站点 ${site.name} 的文章更新推送已${site.enableUpdatePush ? '开启' : '关闭'}`;
-    });
-    ctx.command('wordpress.site.toggle-user <siteId>', '切换指定站点的新用户注册推送开关')
-        .action(async ({ session }, siteId) => {
-        // 检查权限
-        const authResult = checkSuperAdmin(session);
-        if (!authResult.valid) {
-            return authResult.message;
-        }
-        ctx.logger.info(`命令 wordpress.site.toggle-user 被调用，站点 ID: ${siteId}`);
-        // 查找站点
-        const site = config.sites.find(s => s.id === siteId);
-        if (!site) {
-            return `未找到站点 ID: ${siteId}`;
-        }
-        // 切换开关
-        site.enableUserPush = !site.enableUserPush;
-        await saveSiteConfig(siteId, site);
-        return `站点 ${site.name} 的新用户注册推送已${site.enableUserPush ? '开启' : '关闭'}`;
-    });
-    ctx.command('wordpress.site.toggle <siteId>', '切换指定站点的自动推送开关')
-        .action(async ({ session }, siteId) => {
-        // 检查权限
-        const authResult = checkSuperAdmin(session);
-        if (!authResult.valid) {
-            return authResult.message;
-        }
-        ctx.logger.info(`命令 wordpress.site.toggle 被调用，站点 ID: ${siteId}`);
-        // 查找站点
-        const site = config.sites.find(s => s.id === siteId);
-        if (!site) {
-            return `未找到站点 ID: ${siteId}`;
-        }
-        // 切换开关
-        site.enableAutoPush = !site.enableAutoPush;
-        await saveSiteConfig(siteId, site);
-        return `站点 ${site.name} 的自动推送已${site.enableAutoPush ? '开启' : '关闭'}`;
-    });
-    ctx.command('wordpress.site.mention <siteId>', '切换指定站点的 @全体成员 开关')
-        .action(async ({ session }, siteId) => {
-        // 检查权限
-        const authResult = checkSuperAdmin(session);
-        if (!authResult.valid) {
-            return authResult.message;
-        }
-        ctx.logger.info(`命令 wordpress.site.mention 被调用，站点 ID: ${siteId}`);
-        // 查找站点
-        const site = config.sites.find(s => s.id === siteId);
-        if (!site) {
-            return `未找到站点 ID: ${siteId}`;
-        }
-        // 切换开关
-        site.mentionAll = !site.mentionAll;
-        await saveSiteConfig(siteId, site);
-        return `站点 ${site.name} 的 @全体成员 已${site.mentionAll ? '开启' : '关闭'}`;
-    });
-    ctx.command('wordpress.site.set-url <siteId> <url>', '修改指定站点的 WordPress 地址')
-        .action(async ({ session }, siteId, url) => {
-        // 检查权限
-        const authResult = checkSuperAdmin(session);
-        if (!authResult.valid) {
-            return authResult.message;
-        }
-        ctx.logger.info(`命令 wordpress.site.set-url 被调用，站点 ID: ${siteId}，新地址：${url}`);
-        // 查找站点
-        const site = config.sites.find(s => s.id === siteId);
-        if (!site) {
-            return `未找到站点 ID: ${siteId}`;
-        }
-        // 修改站点地址
-        site.url = url;
-        await saveSiteConfig(siteId, site);
-        ctx.logger.info(`站点 ${site.name} 的地址已修改为：${url}`);
-        return `站点 ${site.name} 的 WordPress 地址已修改为：${url}`;
-    });
-    ctx.command('wordpress.pushed', '查看已推送的文章列表')
-        .action(async () => {
-        ctx.logger.info('命令 wordpress.pushed 被调用');
-        // 获取已推送的文章记录，使用 wordpress_post_updates 表
-        const records = await ctx.database.get('wordpress_post_updates', {}, {
-            sort: {
-                pushedAt: 'desc'
-            }
-        });
-        if (records.length === 0) {
-            return '暂无已推送文章记录';
-        }
-        // 使用数组拼接消息，便于控制格式和长度
-        const messageParts = ['📋 已推送文章列表（按时间倒序）：'];
-        for (const record of records) {
-            // 自定义时间格式，避免特殊分隔符
-            const formattedDate = new Date(record.pushedAt);
-            const dateStr = `${formattedDate.getFullYear()}-${String(formattedDate.getMonth() + 1).padStart(2, '0')}-${String(formattedDate.getDate()).padStart(2, '0')} ${String(formattedDate.getHours()).padStart(2, '0')}:${String(formattedDate.getMinutes()).padStart(2, '0')}`;
-            messageParts.push(`${record.id}. 文章 ID: ${record.postId}`);
-            messageParts.push(`📅 推送时间: ${dateStr}`);
-            messageParts.push(''); // 空行分隔
-        }
-        let message = messageParts.join('\n');
-        // 长度验证，超过 500 字符则精简，符合 QQ 接口限制
-        if (message.length > 500) {
-            ctx.logger.warn(`消息过长，长度: ${message.length}，将进行精简`);
-            message = messageParts.slice(0, 8).join('\n') + '\n... 更多记录请查看完整列表';
-        }
-        return message;
-    });
-    ctx.command('wordpress.clean [days]', '清理指定天数前的推送记录（默认 30 天）')
-        .action(async ({ session }, days) => {
-        // 检查权限
-        const authResult = checkSuperAdmin(session);
-        if (!authResult.valid) {
-            return authResult.message;
-        }
-        ctx.logger.info(`命令 wordpress.clean 被调用，天数：${days || '默认'}，调用者：${authResult.userId}`);
-        // 设置默认天数
-        const daysToKeep = days ? parseInt(days) : CONSTANTS.DEFAULT_CLEAN_DAYS;
-        if (isNaN(daysToKeep) || daysToKeep <= 0 || daysToKeep > 365) {
-            return '请输入有效的天数（1-365天）';
-        }
-        // 计算清理时间点
-        const cutoffDate = new Date();
-        cutoffDate.setDate(cutoffDate.getDate() - daysToKeep);
-        // 批量删除旧记录，使用条件删除减少数据库请求次数
-        let result = 0;
-        // 批量删除 wordpress_post_updates 中的旧记录
-        try {
-            // 使用分页查询，每次处理 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 += 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 {
-            // 使用分页查询，每次处理 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;
-                }
-                // 过滤需要删除的记录
-                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}`);
-        }
-    });
-    ctx.command('wordpress.stats', '查看插件运行指标统计')
-        .action(() => {
-        ctx.logger.info('命令 wordpress.stats 被调用');
-        // 计算 API 调用成功率
-        const apiSuccessRate = runtimeStats.apiCallCount > 0
-            ? (runtimeStats.apiSuccessCount / runtimeStats.apiCallCount * 100).toFixed(2)
-            : '0.00';
-        // 计算推送成功率
-        const pushSuccessRate = (runtimeStats.pushSuccessCount + runtimeStats.pushFailureCount) > 0
-            ? (runtimeStats.pushSuccessCount / (runtimeStats.pushSuccessCount + runtimeStats.pushFailureCount) * 100).toFixed(2)
-            : '0.00';
-        // 计算统计时间范围
-        const startTime = new Date(runtimeStats.lastResetTime);
-        const formattedStartTime = `${startTime.getFullYear()}-${String(startTime.getMonth() + 1).padStart(2, '0')}-${String(startTime.getDate()).padStart(2, '0')} ${String(startTime.getHours()).padStart(2, '0')}:${String(startTime.getMinutes()).padStart(2, '0')}`;
-        // 构建统计消息
-        const messageParts = [
-            '📊 WordPress 插件运行统计',
-            `📅 统计开始时间: ${formattedStartTime}`,
-            `📈 API 调用: ${runtimeStats.apiCallCount} 次`,
-            `✅ API 成功: ${runtimeStats.apiSuccessCount} 次`,
-            `❌ API 失败: ${runtimeStats.apiFailureCount} 次`,
-            `📊 API 成功率: ${apiSuccessRate}%`,
-            `📤 推送成功: ${runtimeStats.pushSuccessCount} 次`,
-            `📥 推送失败: ${runtimeStats.pushFailureCount} 次`,
-            `📊 推送成功率: ${pushSuccessRate}%`
-        ];
-        let message = messageParts.join('\n');
-        // 长度验证，超过 500 字符则精简
-        if (message.length > 500) {
-            ctx.logger.warn(`消息过长，长度: ${message.length}，将进行精简`);
-            message = messageParts.slice(0, 6).join('\n') + '\n... 更多统计信息请查看完整数据';
-        }
-        return message;
-    });
-    ctx.command('wordpress.health', '查看插件健康状态')
-        .action(async () => {
-        ctx.logger.info('命令 wordpress.health 被调用');
-        // 检查数据库连接
-        const dbConnected = await checkDatabaseConnection();
-        // 检查 Bot 在线状态
-        const bot = getValidBot();
-        const botOnline = !!bot;
-        // 检查 API 可达性（尝试访问第一个站点的 API）
-        let apiReachable = false;
-        if (config.sites.length > 0) {
-            const firstSite = config.sites[0];
+    // 生命周期管理
+    ctx.on('ready', async () => {
+        ctx.logger.info('WordPress 推送插件 is ready');
+        // 插件就绪后执行异步初始化操作
+        if (storageService) {
+            // 1. 初始化默认推送配置
+            await initializeDefaultGroups();
+            // 2. 执行清理操作
             try {
-                const url = `${firstSite.url}/wp-json/wp/v2/posts?per_page=1`;
-                const response = await ctx.http.get(url, {
-                    timeout: 5000
-                });
-                apiReachable = true;
+                await storageService.cleanup();
+                ctx.logger.info('Initial cleanup completed');
             }
             catch (error) {
-                ctx.logger.warn(`API 可达性检查失败: ${error}`);
+                ctx.logger.error('Error during initial cleanup:', error);
             }
         }
-        // 构建健康状态消息
-        const messageParts = [
-            '🏥 WordPress 插件健康状态',
-            `🗄️ 数据库连接: ${dbConnected ? '✅ 正常' : '❌ 异常'}`,
-            `🤖 Bot 在线状态: ${botOnline ? '✅ 在线' : '❌ 离线'}`,
-            `🌐 API 可达性: ${apiReachable ? '✅ 可达' : '❌ 不可达'}`
-        ];
-        // 添加站点状态
-        if (config.sites.length > 0) {
-            messageParts.push('\n📋 站点状态:');
-            config.sites.forEach((site, index) => {
-                if (index < 3) { // 只显示前3个站点
-                    messageParts.push(`${index + 1}. ${site.name}: ${site.enableAutoPush ? '✅ 启用' : '❌ 禁用'}`);
-                }
-            });
-            if (config.sites.length > 3) {
-                messageParts.push(`... 共 ${config.sites.length} 个站点`);
-            }
-        }
-        let message = messageParts.join('\n');
-        // 长度验证，超过 500 字符则精简
-        if (message.length > 500) {
-            ctx.logger.warn(`消息过长，长度: ${message.length}，将进行精简`);
-            message = messageParts.slice(0, 5).join('\n') + '\n... 更多健康状态信息请查看完整数据';
-        }
-        return message;
     });
-    ctx.command('wordpress', 'WordPress 推送插件菜单')
-        .action(() => {
-        ctx.logger.info('命令 wordpress 被调用');
-        // 使用数组拼接消息，便于控制格式和长度
-        const messageParts = [
-            '📚 WordPress 推送插件菜单：',
-            '🔹 /wordpress.status - 查看插件状态',
-            '🔹 /wordpress.latest - 查看最新文章',
-            '🔹 /wordpress.list - 查看文章列表',
-            '🔹 /wordpress.push - 手动推送最新文章',
-            '🔹 /wordpress.set-url <url> - 修改 WordPress 站点地址',
-            '🔹 /wordpress.pushed - 查看已推送文章列表',
-            '🔹 /wordpress.clean [days] - 清理旧推送记录',
-            '🔹 /wordpress.toggle - 切换自动推送开关（仅超级管理员）',
-            '🔹 /wordpress.toggle-update - 切换文章更新推送开关（仅超级管理员）',
-            '🔹 /wordpress.toggle-user - 切换新用户注册推送开关（仅超级管理员）',
-            '🔹 /wordpress.mention - 切换 @全体 开关（仅超级管理员）',
-            '💡 提示：所有命令都需要加 / 前缀'
-        ];
-        let message = messageParts.join('\n');
-        ctx.logger.info(`准备返回消息，长度: ${message.length}`);
-        return message;
-    });
-    // 为每个站点设置独立的定时任务，绑定到 ctx 生命周期
-    const siteTimers = [];
-    config.sites.forEach(site => {
-        const timer = ctx.setInterval(() => {
-            try {
-                pushNewPosts();
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                ctx.logger.error(`站点 ${site.id} 定时任务执行失败：${errorMessage}`);
-                ctx.logger.error(`错误栈：${error instanceof Error ? error.stack : '无'}`);
-                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 插件资源清理完成');
+    ctx.on('dispose', async () => {
+        ctx.logger.info('WordPress 推送插件 is disposing...');
+        cleanupServices();
+        ctx.logger.info('WordPress 推送插件 has been disposed');
     });
+    // 立即初始化核心服务（包括命令注册）
+    initializeCoreServices();
 }