koishi-plugin-wordpress-notifier 2.8.0 → 2.8.2

package/lib/index.js

@@ -18,6 +18,7 @@ const CONSTANTS = {
     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分钟
@@ -25,19 +26,104 @@ const CONSTANTS = {
     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({
-    wordpressUrl: koishi_1.Schema.string().description('WordPress 网站地址（例如：https://example.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）'),
-    superAdmins: koishi_1.Schema.array(koishi_1.Schema.string()).default([]).description('超级管理员 QQ 号列表')
+    // 多站点配置
+    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('推送失败通知配置')
 });
 function apply(ctx, config) {
     ctx.logger.info('WordPress 推送插件已加载');
@@ -45,22 +131,24 @@ function apply(ctx, config) {
     // 确保 id 字段被正确设置为自增主键，并且在插入时不会被设置为 NULL
     ctx.model.extend('wordpress_post_updates', {
         id: 'integer',
+        siteId: 'string',
         postId: 'integer',
         lastModified: 'timestamp',
         pushedAt: 'timestamp'
     }, {
         primary: 'id',
         autoInc: true,
-        unique: ['postId']
+        unique: ['siteId', 'postId'] // 每个站点的文章 ID 唯一
     });
     ctx.model.extend('wordpress_user_registrations', {
         id: 'integer',
+        siteId: 'string',
         userId: 'integer',
         pushedAt: 'timestamp'
     }, {
         primary: 'id',
         autoInc: true,
-        unique: ['userId']
+        unique: ['siteId', 'userId'] // 每个站点的用户 ID 唯一
     });
     // 配置存储表
     ctx.model.extend('wordpress_config', {
@@ -73,6 +161,16 @@ function apply(ctx, config) {
         autoInc: true,
         unique: ['key']
     });
+    // 版本记录表
+    ctx.model.extend('wordpress_version', {
+        id: 'integer',
+        version: 'string',
+        updatedAt: 'timestamp'
+    }, {
+        primary: 'id',
+        autoInc: true,
+        unique: ['version']
+    });
     ctx.logger.info('数据库表配置完成，autoInc: true 已启用，确保插入操作不手动指定 id 字段');
     // 为所有数据库操作添加详细日志，便于诊断自增主键问题
     ctx.on('ready', async () => {
@@ -81,6 +179,7 @@ function apply(ctx, config) {
         ctx.logger.info('wordpress_post_updates: id 字段设置为 autoInc: true');
         ctx.logger.info('wordpress_user_registrations: id 字段设置为 autoInc: true');
         ctx.logger.info('wordpress_config: 配置持久化存储表');
+        ctx.logger.info('wordpress_version: 数据库版本记录表');
         ctx.logger.info('所有群聊共用一个文章标记，不再区分群聊');
         // 检查并修复数据库表结构问题
         await checkAndFixTableStructure();
@@ -93,6 +192,12 @@ function apply(ctx, config) {
     async function loadPersistentConfig() {
         try {
             ctx.logger.info('开始加载持久化配置...');
+            // 确保数据库连接正常
+            const connected = await ensureDatabaseConnection();
+            if (!connected) {
+                ctx.logger.warn('数据库连接异常，跳过加载持久化配置');
+                return;
+            }
             const configRecords = await ctx.database.get('wordpress_config', {});
             ctx.logger.info(`找到 ${configRecords.length} 条持久化配置记录`);
             for (const record of configRecords) {
@@ -114,13 +219,24 @@ function apply(ctx, config) {
             ctx.logger.info('持久化配置加载完成');
         }
         catch (error) {
-            ctx.logger.error(`加载持久化配置失败: ${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) {
@@ -207,14 +323,15 @@ function apply(ctx, config) {
     const MAX_RETRIES = CONSTANTS.MAX_PUSH_RETRIES;
     const RETRY_INTERVAL = CONSTANTS.PUSH_RETRY_INTERVAL; // 5分钟
     // 添加到失败队列
-    function addToFailedQueue(type, data, targets) {
+    function addToFailedQueue(type, data, targets, siteConfig) {
         const item = {
             id: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
             type,
             data,
             targets,
             retries: 0,
-            createdAt: new Date()
+            createdAt: new Date(),
+            siteConfig
         };
         failedPushQueue.push(item);
         ctx.logger.info(`添加到失败队列，类型: ${type}，目标数: ${targets.length}，队列长度: ${failedPushQueue.length}`);
@@ -243,10 +360,10 @@ function apply(ctx, config) {
                 // 根据类型格式化消息
                 let message;
                 if (item.type === 'post' || item.type === 'update') {
-                    message = formatPostMessage(item.data, true, item.type === 'update');
+                    message = formatPostMessage(item.data, true, item.type === 'update', item.siteConfig);
                 }
                 else {
-                    message = formatUserMessage(item.data, true);
+                    message = formatUserMessage(item.data, true, item.siteConfig);
                 }
                 // 推送到所有目标
                 for (const target of item.targets) {
@@ -292,6 +409,106 @@ function apply(ctx, config) {
         // 权限检查通过，继续执行命令
         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 {
@@ -308,7 +525,27 @@ function apply(ctx, config) {
             }
             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: 'integer',
+                        postId: 'integer',
+                        lastModified: 'timestamp',
+                        pushedAt: 'timestamp'
+                    }, {
+                        primary: 'id',
+                        autoInc: true,
+                        unique: ['postId']
+                    });
+                    ctx.logger.info('wordpress_post_updates 表重新初始化成功');
+                }
+                catch (dropError) {
+                    ctx.logger.warn(`删除旧表失败，可能表不存在：${dropError}`);
+                }
             }
             try {
                 ctx.logger.info('验证 wordpress_user_registrations 表结构...');
@@ -319,7 +556,57 @@ function apply(ctx, config) {
             }
             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: 'integer',
+                        userId: 'integer',
+                        pushedAt: 'timestamp'
+                    }, {
+                        primary: 'id',
+                        autoInc: true,
+                        unique: ['userId']
+                    });
+                    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: 'integer',
+                        key: 'string',
+                        value: 'string',
+                        updatedAt: 'timestamp'
+                    }, {
+                        primary: 'id',
+                        autoInc: true,
+                        unique: ['key']
+                    });
+                    ctx.logger.info('wordpress_config 表重新初始化成功');
+                }
+                catch (dropError) {
+                    ctx.logger.warn(`删除旧表失败，可能表不存在：${dropError}`);
+                }
             }
             ctx.logger.info('表结构检查和修复完成');
         }
@@ -338,6 +625,16 @@ function apply(ctx, config) {
         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));
+                }
+                // 更新上次请求时间
+                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}`);
@@ -349,6 +646,8 @@ function apply(ctx, config) {
                 retries++;
                 if (retries > maxRetries) {
                     ctx.logger.error(`HTTP请求最终失败，已达到最大重试次数: ${url}`);
+                    // 记录推送失败
+                    recordPushFailure(`API请求失败: ${errorMessage}`);
                     return null;
                 }
                 // 重试前等待
@@ -357,16 +656,16 @@ function apply(ctx, config) {
         }
         return null;
     }
-    async function fetchLatestPosts() {
+    async function fetchLatestPosts(site) {
         try {
-            const url = `${config.wordpressUrl}/wp-json/wp/v2/posts?per_page=${config.maxArticles}&orderby=date&order=desc`;
-            ctx.logger.info(`正在获取文章: ${url}`);
+            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 (config.username && config.applicationPassword) {
+            if (site.username && site.applicationPassword) {
                 // 处理WordPress应用程序密码，移除空格（WordPress生成的应用密码格式为：hGR2 sPFu Yncl xHc4 AvJq cUtB）
-                const username = config.username;
-                const password = config.applicationPassword.replace(/\s+/g, ''); // 移除所有空格
+                const username = site.username;
+                const password = site.applicationPassword.replace(/\s+/g, ''); // 移除所有空格
                 const auth = Buffer.from(`${username}:${password}`).toString('base64');
                 requestConfig.headers = {
                     Authorization: `Basic ${auth}`
@@ -374,30 +673,33 @@ function apply(ctx, config) {
             }
             const response = await httpRequest(url, requestConfig);
             if (!response) {
-                ctx.logger.error(`获取 WordPress 文章失败，已达到最大重试次数`);
+                ctx.logger.error(`获取站点 ${site.id} (${site.name}) 的 WordPress 文章失败，已达到最大重试次数`);
                 return [];
             }
-            ctx.logger.info(`成功获取 ${response.length} 篇文章`);
+            ctx.logger.info(`成功获取站点 ${site.id} (${site.name}) 的 ${response.length} 篇文章`);
             return response;
         }
         catch (error) {
-            ctx.logger.error(`获取 WordPress 文章失败: ${error}`);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            ctx.logger.error(`获取站点 ${site.id} (${site.name}) 的 WordPress 文章失败: ${errorMessage}`);
+            // 记录失败
+            recordPushFailure(`获取站点 ${site.id} (${site.name}) 的文章失败: ${errorMessage}`);
             return [];
         }
     }
-    async function fetchLatestUsers() {
+    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 = `${config.wordpressUrl}/wp-json/wp/v2/users?per_page=${config.maxArticles}&orderby=registered_date&order=desc&_fields=${fields}`;
-            ctx.logger.info(`正在获取用户: ${url}`);
+            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 (config.username && config.applicationPassword) {
+            if (site.username && site.applicationPassword) {
                 // 处理WordPress应用程序密码，移除空格（WordPress生成的应用密码格式为：hGR2 sPFu Yncl xHc4 AvJq cUtB）
-                const username = config.username;
-                const password = config.applicationPassword.replace(/\s+/g, ''); // 移除所有空格
+                const username = site.username;
+                const password = site.applicationPassword.replace(/\s+/g, ''); // 移除所有空格
                 const auth = Buffer.from(`${username}:${password}`).toString('base64');
                 requestConfig.headers = {
                     Authorization: `Basic ${auth}`
@@ -405,12 +707,14 @@ function apply(ctx, config) {
             }
             const response = await httpRequest(url, requestConfig);
             if (!response) {
-                ctx.logger.error(`获取 WordPress 用户失败，已达到最大重试次数`);
-                ctx.logger.error(`WordPress REST API 的 users 端点需要认证才能访问，请在插件配置中添加 WordPress 用户名和应用程序密码`);
+                ctx.logger.error(`获取站点 ${site.id} (${site.name}) 的 WordPress 用户失败，已达到最大重试次数`);
+                ctx.logger.error(`WordPress REST API 的 users 端点需要认证才能访问，请在站点配置中添加 WordPress 用户名和应用程序密码`);
+                // 记录失败
+                recordPushFailure(`获取站点 ${site.id} (${site.name}) 的用户失败: API 认证失败`);
                 // 返回空数组，确保插件继续运行
                 return [];
             }
-            ctx.logger.info(`成功获取 ${response.length} 位用户`);
+            ctx.logger.info(`成功获取站点 ${site.id} (${site.name}) 的 ${response.length} 位用户`);
             // 添加调试日志，查看API返回的实际数据结构
             if (response.length > 0) {
                 ctx.logger.info(`用户数据示例: ${JSON.stringify(response[0], null, 2)}`);
@@ -421,22 +725,25 @@ function apply(ctx, config) {
             return response;
         }
         catch (error) {
-            ctx.logger.error(`获取 WordPress 用户失败: ${error}`);
-            ctx.logger.error(`WordPress REST API 的 users 端点需要认证才能访问，请在插件配置中添加 WordPress 用户名和应用程序密码`);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            ctx.logger.error(`获取站点 ${site.id} (${site.name}) 的 WordPress 用户失败: ${errorMessage}`);
+            ctx.logger.error(`WordPress REST API 的 users 端点需要认证才能访问，请在站点配置中添加 WordPress 用户名和应用程序密码`);
+            // 记录失败
+            recordPushFailure(`获取站点 ${site.id} (${site.name}) 的用户失败: ${errorMessage}`);
             // 返回空数组，确保插件继续运行
             return [];
         }
     }
-    async function fetchUpdatedPosts() {
+    async function fetchUpdatedPosts(site) {
         try {
-            const url = `${config.wordpressUrl}/wp-json/wp/v2/posts?per_page=${config.maxArticles}&orderby=modified&order=desc`;
-            ctx.logger.info(`正在获取更新文章: ${url}`);
+            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 (config.username && config.applicationPassword) {
+            if (site.username && site.applicationPassword) {
                 // 处理WordPress应用程序密码，移除空格（WordPress生成的应用密码格式为：hGR2 sPFu Yncl xHc4 AvJq cUtB）
-                const username = config.username;
-                const password = config.applicationPassword.replace(/\s+/g, ''); // 移除所有空格
+                const username = site.username;
+                const password = site.applicationPassword.replace(/\s+/g, ''); // 移除所有空格
                 const auth = Buffer.from(`${username}:${password}`).toString('base64');
                 requestConfig.headers = {
                     Authorization: `Basic ${auth}`
@@ -444,23 +751,34 @@ function apply(ctx, config) {
             }
             const response = await httpRequest(url, requestConfig);
             if (!response) {
-                ctx.logger.error(`获取 WordPress 更新文章失败，已达到最大重试次数`);
+                ctx.logger.error(`获取站点 ${site.id} (${site.name}) 的 WordPress 更新文章失败，已达到最大重试次数`);
+                // 记录失败
+                recordPushFailure(`获取站点 ${site.id} (${site.name}) 的更新文章失败`);
                 return [];
             }
-            ctx.logger.info(`成功获取 ${response.length} 篇更新文章`);
+            ctx.logger.info(`成功获取站点 ${site.id} (${site.name}) 的 ${response.length} 篇更新文章`);
             return response;
         }
         catch (error) {
-            ctx.logger.error(`获取 WordPress 更新文章失败: ${error}`);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            ctx.logger.error(`获取站点 ${site.id} (${site.name}) 的 WordPress 更新文章失败: ${errorMessage}`);
+            // 记录失败
+            recordPushFailure(`获取站点 ${site.id} (${site.name}) 的更新文章失败: ${errorMessage}`);
             return [];
         }
     }
-    async function isUserPushed(userId) {
+    async function isUserPushed(siteId, userId) {
         try {
-            ctx.logger.info(`检查用户是否已推送，用户 ID: ${userId}`);
-            const record = await ctx.database.get('wordpress_user_registrations', { userId });
+            // 确保数据库连接正常
+            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 });
             const result = record.length > 0;
-            ctx.logger.info(`检查结果：用户 ${userId} 已推送：${result ? '是' : '否'}`);
+            ctx.logger.info(`检查结果：站点 ${siteId} 用户 ${userId} 已推送：${result ? '是' : '否'}`);
             return result;
         }
         catch (error) {
@@ -471,12 +789,18 @@ function apply(ctx, config) {
             return false;
         }
     }
-    async function getPostUpdateRecord(postId) {
+    async function getPostUpdateRecord(siteId, postId) {
         try {
-            ctx.logger.info(`获取文章更新记录，文章 ID: ${postId}`);
-            const records = await ctx.database.get('wordpress_post_updates', { postId });
+            // 确保数据库连接正常
+            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 });
             const result = records.length > 0 ? records[0] : null;
-            ctx.logger.info(`获取结果：文章 ${postId} 更新记录：${result ? '找到' : '未找到'}`);
+            ctx.logger.info(`获取结果：站点 ${siteId} 文章 ${postId} 更新记录：${result ? '找到' : '未找到'}`);
             return result;
         }
         catch (error) {
@@ -487,72 +811,116 @@ function apply(ctx, config) {
             return null;
         }
     }
-    async function markUserAsPushed(userId) {
+    async function markUserAsPushed(siteId, userId) {
         try {
-            ctx.logger.info(`开始标记用户已推送，用户 ID: ${userId}`);
+            // 确保数据库连接正常
+            const connected = await ensureDatabaseConnection();
+            if (!connected) {
+                ctx.logger.warn('数据库连接异常，跳过标记用户推送记录');
+                return;
+            }
+            ctx.logger.info(`开始标记用户已推送，站点 ID: ${siteId}，用户 ID: ${userId}`);
             // 创建新记录，不手动指定id，让数据库自动生成
             const newRecord = {
+                siteId,
                 userId,
                 pushedAt: new Date()
             };
             ctx.logger.info(`准备创建用户推送记录：${JSON.stringify(newRecord)}`);
             await ctx.database.create('wordpress_user_registrations', newRecord);
-            ctx.logger.info(`已成功标记用户 ${userId} 为已推送`);
+            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(`用户推送记录已存在，跳过重复插入：用户 ${userId}`);
+                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(`插入参数：userId=${userId}`);
+                ctx.logger.error(`插入参数：siteId=${siteId}, userId=${userId}`);
                 // 非约束冲突错误，不抛出，确保插件继续运行
             }
         }
     }
-    async function updatePostUpdateRecord(postId, modifiedDate) {
+    async function updatePostUpdateRecord(siteId, postId, modifiedDate) {
         try {
-            ctx.logger.info(`开始更新文章更新记录，文章 ID: ${postId}，修改时间: ${modifiedDate}`);
-            const record = await getPostUpdateRecord(postId);
+            // 确保数据库连接正常
+            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: ${postId}，上次修改时间: ${record.lastModified}`);
+                ctx.logger.info(`发现现有记录，站点 ID: ${siteId}，文章 ID: ${postId}，上次修改时间: ${record.lastModified}`);
                 // Koishi database API 不支持 update 方法，使用 remove + create 代替
-                await ctx.database.remove('wordpress_post_updates', { postId });
-                ctx.logger.info(`已删除旧记录，文章 ID: ${postId}`);
+                await ctx.database.remove('wordpress_post_updates', { siteId, postId });
+                ctx.logger.info(`已删除旧记录，站点 ID: ${siteId}，文章 ID: ${postId}`);
             }
-            // 创建新记录
+            // 创建新记录，不指定 id 字段，让数据库自动生成
             const newRecord = {
+                siteId,
                 postId,
                 lastModified: modifiedDate,
                 pushedAt: new Date()
             };
-            ctx.logger.info(`准备创建新记录，文章 ID: ${postId}，记录内容: ${JSON.stringify(newRecord)}`);
+            ctx.logger.info(`准备创建新记录，站点 ID: ${siteId}，文章 ID: ${postId}，记录内容: ${JSON.stringify(newRecord)}`);
             await ctx.database.create('wordpress_post_updates', newRecord);
-            ctx.logger.info(`已成功更新文章更新记录，文章 ID: ${postId}`);
+            ctx.logger.info(`已成功更新文章更新记录，站点 ID: ${siteId}，文章 ID: ${postId}`);
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            ctx.logger.error(`更新文章更新记录失败，文章 ID: ${postId}`);
+            ctx.logger.error(`更新文章更新记录失败，站点 ID: ${siteId}，文章 ID: ${postId}`);
             ctx.logger.error(`错误信息: ${errorMessage}`);
             ctx.logger.error(`错误栈: ${error instanceof Error ? error.stack : '无'}`);
-            throw error;
+            // 不再抛出错误，确保推送流程继续运行
+            // 发生错误时，默认返回，避免阻塞推送流程
+            ctx.logger.warn(`更新文章更新记录失败，但推送流程将继续运行，站点 ID: ${siteId}，文章 ID: ${postId}`);
         }
     }
     // 1. 新增强清洗函数：针对性解决敏感字符问题
     function sanitizeContent(content) {
-        return 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 formatPostMessage(post, mention = false, isUpdate = false) {
-        // 生成缓存键
-        const cacheKey = `post_${post.id}_${mention}_${isUpdate}_${config.mentionAll}`;
+    // 敏感词过滤函数
+    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)) {
@@ -565,7 +933,7 @@ function apply(ctx, config) {
         if (title.length > CONSTANTS.MAX_TITLE_LENGTH) {
             title = title.substring(0, CONSTANTS.MAX_TITLE_LENGTH - 3) + '...';
         }
-        // 自定义时间格式：年-月-日 时:分
+        // 根据配置格式化日期
         const formatDate = (dateString) => {
             const date = new Date(dateString);
             const year = date.getFullYear();
@@ -573,19 +941,50 @@ function apply(ctx, config) {
             const day = String(date.getDate()).padStart(2, '0');
             const hours = String(date.getHours()).padStart(2, '0');
             const minutes = String(date.getMinutes()).padStart(2, '0');
-            return `${year}-${month}-${day} ${hours}:${minutes}`;
+            // 根据配置的日期格式进行替换
+            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 && config.mentionAll ? '@全体成员 ' : '';
+        const atAllText = mention && configToUse.mentionAll ? '@全体成员 ' : '';
         // 只使用一个极简表情
         const messageType = isUpdate ? '📝' : '📰';
-        // 构建核心消息内容，严格控制格式
-        // 格式：[表情] [@全体] [时间] - [标题]
-        //       [链接]
-        let message = `${messageType} ${atAllText}${date} - ${title}\n${encodedLink}`;
+        // 构建消息内容
+        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) + '...';
@@ -599,9 +998,15 @@ function apply(ctx, config) {
         // 直接返回纯字符串，跳过适配器复杂编码
         return message;
     }
-    function formatUserMessage(user, mention = false) {
+    function formatUserMessage(user, mention = false, siteConfig) {
+        // 使用默认站点配置或传入的站点配置
+        const configToUse = siteConfig || config.sites[0];
+        if (!configToUse) {
+            ctx.logger.error('无可用的站点配置');
+            return '';
+        }
         // 生成缓存键
-        const cacheKey = `user_${user.id}_${mention}_${config.mentionAll}`;
+        const cacheKey = `user_${user.id}_${mention}_${configToUse.mentionAll}`;
         // 检查缓存
         const cached = formatCache.user.get(cacheKey);
         if (cached && isCacheValid(cached.timestamp)) {
@@ -661,7 +1066,7 @@ function apply(ctx, config) {
             ctx.logger.error(`处理用户 ${username} 日期时出错: ${error}`);
         }
         // 构建 @全体成员 文本（适配 QQ 官方 bot 和其他适配器）
-        const atAllText = mention && config.mentionAll ? '@全体成员 ' : '';
+        const atAllText = mention && configToUse.mentionAll ? '@全体成员 ' : '';
         // 只使用一个极简表情
         const messageType = '👤';
         // 构建核心消息内容，严格控制格式和换行
@@ -685,138 +1090,159 @@ function apply(ctx, config) {
         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} 进行推送`);
-        // 推送新文章
-        if (config.enableAutoPush) {
-            const posts = await fetchLatestPosts();
-            ctx.logger.info(`开始检查 ${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(post.id);
-                    const hasPushed = !!postRecord;
-                    ctx.logger.info(`检查结果: 文章 ${post.id} 是否已推送：${hasPushed ? '是' : '否'}`);
-                    if (!hasPushed) {
-                        // 推送到所有目标群聊
-                        const failedTargets = [];
-                        for (const target of config.targets) {
-                            try {
-                                ctx.logger.info(`正在处理目标: ${target}`);
-                                // 直接使用原始目标字符串，不进行数字转换，避免丢失平台前缀等信息
-                                const stringTarget = target;
-                                const message = formatPostMessage(post, true, false);
-                                ctx.logger.info(`准备推送新文章到目标: ${stringTarget}`);
-                                await bot.sendMessage(stringTarget, message);
-                                ctx.logger.info(`已推送新文章到 ${stringTarget}: ${post.title.rendered}`);
+        // 遍历所有站点
+        for (const site of config.sites) {
+            ctx.logger.info(`开始处理站点: ${site.id} (${site.name})`);
+            // 推送新文章
+            if (site.enableAutoPush) {
+                const posts = await fetchLatestPosts(site);
+                ctx.logger.info(`站点 ${site.id} (${site.name}) 开始检查 ${posts.length} 篇文章是否需要推送`);
+                if (posts.length > 0) {
+                    for (const post of posts) {
+                        ctx.logger.info(`正在处理文章: ${post.id} - ${post.title.rendered}`);
+                        ctx.logger.info(`文章 ID: ${post.id}, 发布时间: ${post.date}, 修改时间: ${post.modified}`);
+                        // 检查文章是否已推送过（所有群聊共用一个标记）
+                        const postRecord = await getPostUpdateRecord(site.id, post.id);
+                        const 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;
+                                    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}`);
+                                }
                             }
-                            catch (error) {
-                                ctx.logger.error(`推送新文章到 ${target} 失败: ${error}`);
-                                ctx.logger.error(`错误详情: ${JSON.stringify(error)}`);
-                                failedTargets.push(target);
+                            // 如果有失败的目标，添加到失败队列
+                            if (failedTargets.length > 0) {
+                                addToFailedQueue('post', post, failedTargets, site);
                             }
+                            // 标记文章已推送（所有群聊共用一个标记）
+                            await updatePostUpdateRecord(site.id, post.id, new Date(post.modified));
+                            ctx.logger.info(`已标记站点 ${site.id} 文章 ${post.id} 为已推送，所有群聊将不再推送此文章`);
                         }
-                        // 如果有失败的目标，添加到失败队列
-                        if (failedTargets.length > 0) {
-                            addToFailedQueue('post', post, failedTargets);
+                        else {
+                            ctx.logger.info(`跳过推送: 站点 ${site.id} 文章 ${post.id} 已推送过，所有群聊将不再推送`);
                         }
-                        // 标记文章已推送（所有群聊共用一个标记）
-                        await updatePostUpdateRecord(post.id, new Date(post.modified));
-                        ctx.logger.info(`已标记文章 ${post.id} 为已推送，所有群聊将不再推送此文章`);
-                    }
-                    else {
-                        ctx.logger.info(`跳过推送: 文章 ${post.id} 已推送过，所有群聊将不再推送`);
                     }
                 }
             }
-        }
-        // 推送文章更新
-        if (config.enableUpdatePush) {
-            const posts = await fetchUpdatedPosts();
-            if (posts.length > 0) {
-                for (const post of posts) {
-                    const updateRecord = await getPostUpdateRecord(post.id);
-                    const postModifiedDate = new Date(post.modified);
-                    // 检查文章是否有更新
-                    if (updateRecord && postModifiedDate > new Date(updateRecord.lastModified)) {
-                        ctx.logger.info(`文章 ${post.id} 有更新，准备推送更新通知`);
-                        // 推送到所有目标群聊
-                        const failedTargets = [];
-                        for (const target of config.targets) {
-                            try {
-                                ctx.logger.info(`正在处理目标: ${target}`);
-                                const stringTarget = target;
-                                const message = formatPostMessage(post, true, true);
-                                ctx.logger.info(`准备推送文章更新到目标: ${stringTarget}`);
-                                await bot.sendMessage(stringTarget, message);
-                                ctx.logger.info(`已推送文章更新到 ${stringTarget}: ${post.title.rendered}`);
+            // 推送文章更新
+            if (site.enableUpdatePush) {
+                const posts = await fetchUpdatedPosts(site);
+                if (posts.length > 0) {
+                    for (const post of posts) {
+                        const updateRecord = await getPostUpdateRecord(site.id, 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;
+                                    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}`);
+                                }
                             }
-                            catch (error) {
-                                ctx.logger.error(`推送文章更新到 ${target} 失败: ${error}`);
-                                ctx.logger.error(`错误详情: ${JSON.stringify(error)}`);
-                                failedTargets.push(target);
+                            // 如果有失败的目标，添加到失败队列
+                            if (failedTargets.length > 0) {
+                                addToFailedQueue('update', post, failedTargets, site);
                             }
+                            // 更新文章更新记录（所有群聊共用一个标记）
+                            await updatePostUpdateRecord(site.id, post.id, postModifiedDate);
+                            ctx.logger.info(`已更新站点 ${site.id} 文章 ${post.id} 的推送记录，所有群聊将使用此更新时间作为新的推送基准`);
                         }
-                        // 如果有失败的目标，添加到失败队列
-                        if (failedTargets.length > 0) {
-                            addToFailedQueue('update', post, failedTargets);
-                        }
-                        // 更新文章更新记录（所有群聊共用一个标记）
-                        await updatePostUpdateRecord(post.id, postModifiedDate);
-                        ctx.logger.info(`已更新文章 ${post.id} 的推送记录，所有群聊将使用此更新时间作为新的推送基准`);
                     }
                 }
             }
-        }
-        // 推送新用户注册
-        if (config.enableUserPush) {
-            const users = await fetchLatestUsers();
-            if (users.length > 0) {
-                for (const user of users) {
-                    if (!(await isUserPushed(user.id))) {
-                        const failedTargets = [];
-                        for (const target of config.targets) {
-                            try {
-                                ctx.logger.info(`正在处理目标: ${target}`);
-                                // 直接使用原始目标字符串，与新文章推送逻辑保持一致
-                                const stringTarget = target;
-                                const message = formatUserMessage(user, true);
-                                ctx.logger.info(`准备推送新用户到目标: ${stringTarget}`);
-                                await bot.sendMessage(stringTarget, message);
-                                ctx.logger.info(`已推送新用户到 ${stringTarget}: ${user.name}`);
+            // 推送新用户注册
+            if (site.enableUserPush) {
+                const users = await fetchLatestUsers(site);
+                if (users.length > 0) {
+                    for (const user of users) {
+                        if (!(await isUserPushed(site.id, user.id))) {
+                            const failedTargets = [];
+                            for (const target of site.targets) {
+                                try {
+                                    ctx.logger.info(`正在处理目标: ${target}`);
+                                    // 直接使用原始目标字符串，与新文章推送逻辑保持一致
+                                    const stringTarget = target;
+                                    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}`);
+                                }
                             }
-                            catch (error) {
-                                ctx.logger.error(`推送新用户到 ${target} 失败: ${error}`);
-                                ctx.logger.error(`错误详情: ${JSON.stringify(error)}`);
-                                failedTargets.push(target);
+                            // 如果有失败的目标，添加到失败队列
+                            if (failedTargets.length > 0) {
+                                addToFailedQueue('user', user, failedTargets, site);
                             }
+                            // 标记用户已推送
+                            await markUserAsPushed(site.id, user.id);
                         }
-                        // 如果有失败的目标，添加到失败队列
-                        if (failedTargets.length > 0) {
-                            addToFailedQueue('user', user, failedTargets);
-                        }
-                        // 标记用户已推送
-                        await markUserAsPushed(user.id);
                     }
                 }
             }
         }
     }
-    ctx.command('wordpress.latest', '查看最新文章')
-        .action(async ({ session }) => {
-        ctx.logger.info('命令 wordpress.latest 被调用');
-        const posts = await fetchLatestPosts();
+    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 posts = await fetchLatestPosts(targetSite);
         if (posts.length === 0) {
-            ctx.logger.info('没有找到文章');
-            return '暂无文章';
+            ctx.logger.info(`站点 ${targetSite.id} 没有找到文章`);
+            return `站点 ${targetSite.name} 暂无文章`;
         }
         // 动态添加文章，确保消息长度不超过500字符
-        let message = '📰 最新文章：\n';
+        let message = `📰 ${targetSite.name} 最新文章：\n`;
         let addedCount = 0;
         for (const post of posts) {
             const title = sanitizeContent(post.title.rendered);
@@ -842,15 +1268,22 @@ function apply(ctx, config) {
         ctx.logger.info(`准备返回消息，长度: ${message.length}，显示 ${addedCount}/${posts.length} 篇文章`);
         return message;
     });
-    ctx.command('wordpress.list', '查看文章列表')
-        .action(async () => {
-        ctx.logger.info('命令 wordpress.list 被调用');
-        const posts = await fetchLatestPosts();
+    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 posts = await fetchLatestPosts(targetSite);
         if (posts.length === 0) {
-            return '暂无文章';
+            return `站点 ${targetSite.name} 暂无文章`;
         }
         // 使用数组拼接消息，便于控制格式和长度
-        const messageParts = ['📚 文章列表：'];
+        const messageParts = [`📚 ${targetSite.name} 文章列表：`];
         for (const post of posts) {
             const title = sanitizeContent(post.title.rendered);
             // 截断标题，避免单条过长
@@ -875,97 +1308,152 @@ function apply(ctx, config) {
         await pushNewPosts();
         return '已检查并推送最新文章';
     });
-    ctx.command('wordpress.status', '查看插件状态')
-        .action(({ session }) => {
-        ctx.logger.info('命令 wordpress.status 被调用');
+    ctx.command('wordpress.status [siteId]', '查看插件状态，可选站点 ID')
+        .action(({ session }, siteId) => {
+        ctx.logger.info(`命令 wordpress.status 被调用，站点 ID: ${siteId || '所有'}`);
         // 获取当前群号，如果有的话
         const currentGroup = session?.channelId || '未知群聊';
-        // 推送目标仅显示本群
-        const targetText = `🎯 推送目标: ${currentGroup}`;
-        // 使用数组拼接消息，便于控制格式和长度
-        const messageParts = [
-            '📊 WordPress 插件状态',
-            `🌐 站点: ${config.wordpressUrl}`,
-            `⏰ 间隔: ${config.interval / 1000} 秒`,
-            targetText,
-            `🔔 自动推送: ${config.enableAutoPush ? '开启' : '关闭'}`,
-            `🔄 更新推送: ${config.enableUpdatePush ? '开启' : '关闭'}`,
-            `👤 用户推送: ${config.enableUserPush ? '开启' : '关闭'}`,
-            `📢 @全体: ${config.mentionAll ? '开启' : '关闭'}`,
-            `📝 最多推送: ${config.maxArticles} 篇`
-        ];
-        // 合并为单行文本，统一换行符
-        let message = messageParts.join('\n');
-        // 长度验证，超过 500 字符则精简
-        if (message.length > 500) {
-            ctx.logger.warn(`消息过长，长度: ${message.length}，将进行精简`);
-            message = messageParts.slice(0, 5).join('\n') + '\n... 更多配置请查看完整状态';
+        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.logger.info(`准备返回消息，长度: ${message.length}`);
-        // 直接返回纯字符串，跳过适配器复杂编码
-        return message;
     });
-    ctx.command('wordpress.toggle-update', '切换文章更新推送开关')
-        .action(async ({ session }) => {
+    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.toggle-update 被调用');
-        config.enableUpdatePush = !config.enableUpdatePush;
-        await saveConfig('enableUpdatePush', config.enableUpdatePush);
-        return `文章更新推送已${config.enableUpdatePush ? '开启' : '关闭'}`;
+        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 saveConfig('sites', config.sites);
+        return `站点 ${site.name} 的文章更新推送已${site.enableUpdatePush ? '开启' : '关闭'}`;
     });
-    ctx.command('wordpress.toggle-user', '切换新用户注册推送开关')
-        .action(async ({ session }) => {
+    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.toggle-user 被调用');
-        config.enableUserPush = !config.enableUserPush;
-        await saveConfig('enableUserPush', config.enableUserPush);
-        return `新用户注册推送已${config.enableUserPush ? '开启' : '关闭'}`;
+        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 saveConfig('sites', config.sites);
+        return `站点 ${site.name} 的新用户注册推送已${site.enableUserPush ? '开启' : '关闭'}`;
     });
-    ctx.command('wordpress.toggle', '切换自动推送开关')
-        .action(async ({ session }) => {
+    ctx.command('wordpress.site.toggle <siteId>', '切换指定站点的自动推送开关')
+        .action(async ({ session }, siteId) => {
         // 检查权限
         const authResult = checkSuperAdmin(session);
         if (!authResult.valid) {
             return authResult.message;
         }
-        ctx.logger.info('命令 wordpress.toggle 被调用');
-        config.enableAutoPush = !config.enableAutoPush;
-        await saveConfig('enableAutoPush', config.enableAutoPush);
-        return `自动推送已${config.enableAutoPush ? '开启' : '关闭'}`;
+        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 saveConfig('sites', config.sites);
+        return `站点 ${site.name} 的自动推送已${site.enableAutoPush ? '开启' : '关闭'}`;
     });
-    ctx.command('wordpress.mention', '切换 @全体成员 开关')
-        .action(async ({ session }) => {
+    ctx.command('wordpress.site.mention <siteId>', '切换指定站点的 @全体成员 开关')
+        .action(async ({ session }, siteId) => {
         // 检查权限
         const authResult = checkSuperAdmin(session);
         if (!authResult.valid) {
             return authResult.message;
         }
-        ctx.logger.info('命令 wordpress.mention 被调用');
-        config.mentionAll = !config.mentionAll;
-        await saveConfig('mentionAll', config.mentionAll);
-        return `@全体 已${config.mentionAll ? '开启' : '关闭'}`;
+        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 saveConfig('sites', config.sites);
+        return `站点 ${site.name} 的 @全体成员 已${site.mentionAll ? '开启' : '关闭'}`;
     });
-    ctx.command('wordpress.set-url <url>', '修改 WordPress 站点地址')
-        .action(async ({ session }, url) => {
+    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.set-url 被调用，调用者：${authResult.userId}，新地址：${url}`);
+        ctx.logger.info(`命令 wordpress.site.set-url 被调用，站点 ID: ${siteId}，新地址：${url}`);
+        // 查找站点
+        const site = config.sites.find(s => s.id === siteId);
+        if (!site) {
+            return `未找到站点 ID: ${siteId}`;
+        }
         // 修改站点地址
-        config.wordpressUrl = url;
-        await saveConfig('wordpressUrl', config.wordpressUrl);
-        ctx.logger.info(`站点地址已修改为：${url}`);
-        return `WordPress 站点地址已修改为：${url}`;
+        site.url = url;
+        await saveConfig('sites', config.sites);
+        ctx.logger.info(`站点 ${site.name} 的地址已修改为：${url}`);
+        return `站点 ${site.name} 的 WordPress 地址已修改为：${url}`;
     });
     ctx.command('wordpress.pushed', '查看已推送的文章列表')
         .action(async () => {
@@ -1061,8 +1549,90 @@ function apply(ctx, config) {
         catch (error) {
             ctx.logger.error(`批量删除 wordpress_user_registrations 旧记录失败: ${error}`);
         }
-        ctx.logger.info(`已清理 ${result} 条 ${daysToKeep} 天前的推送记录`);
-        return `已清理 ${result} 条 ${daysToKeep} 天前的推送记录`;
+    });
+    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];
+            try {
+                const url = `${firstSite.url}/wp-json/wp/v2/posts?per_page=1`;
+                const response = await ctx.http.get(url, {
+                    timeout: 5000
+                });
+                apiReachable = true;
+            }
+            catch (error) {
+                ctx.logger.warn(`API 可达性检查失败: ${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(() => {
@@ -1087,15 +1657,18 @@ function apply(ctx, config) {
         ctx.logger.info(`准备返回消息，长度: ${message.length}`);
         return message;
     });
-    ctx.setInterval(() => {
-        try {
-            pushNewPosts();
-        }
-        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('定时任务将在下一个周期继续执行');
-        }
-    }, config.interval);
+    // 为每个站点设置独立的定时任务
+    config.sites.forEach(site => {
+        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);
+    });
 }