koishi-plugin-stock 2.0.5 → 2.0.7

package/README.md

@@ -57,6 +57,19 @@ npm install koishi-plugin-stock
 
 ## 更新日志
 
+### v2.0.7
+- 新增定时广播任务失败重试机制：当网络中断导致消息发送失败时，自动开启 3 次重试，每次间隔 1 分钟
+- 引入任务时效性检查：重试过程中若达到该任务的下一个执行时间点，则自动取消当前重试，防止消息堆积
+
+### v2.0.6
+- 优化定时任务触发逻辑：改用 `Intl` API 获取确切的上海时区时间，解决部分环境下时区偏移导致的触发失败问题
+- 增强时间格式容错：自动处理 `9:30` vs `09:30` 以及全角冒号等配置问题
+- 完善节假日 API：增加对 Cloudflare 拦截页面的防御逻辑，请求失败时自动回退到基础周末检查，确保任务触发稳定性
+- 改进日志输出：在 `info` 级别增加关键任务触发和跳过的日志，方便诊断问题
+
+### v2.0.5
+- 使用标准 Koishi 配置注释、每个配置分类上壳有中文注释，更清晰地区分配置组
+
 ### v2.0.4
 - 实现 Koishi 业界标准的配置分组，每个配置项打上对应的 role 标签，在插件设置页中形成可折叠的分组
 

package/lib/index.js

@@ -40,6 +40,7 @@ exports.Config = koishi_1.Schema.object({
 });
 function apply(ctx, config) {
     const logger = ctx.logger('stock');
+    const retryQueue = [];
     // 插件启动日志
     logger.info('stock 插件已加载');
     logger.info(`当前配置: broadcastTasks=${config.broadcastTasks?.length || 0} 个任务`);
@@ -48,142 +49,185 @@ function apply(ctx, config) {
             logger.info(`任务 ${idx + 1}: times=${task.times}, type=${task.type}, targetIds=${task.targetIds}, content=${task.content}`);
         });
     }
+    // 核心广播执行函数
+    async function performBroadcast(task, isRetry = false) {
+        const label = isRetry ? '[重试广播]' : '[初始广播]';
+        try {
+            if (!task.targetIds || typeof task.targetIds !== 'string') {
+                logger.warn(`${label} 任务配置不完整: targetIds 字段无效`);
+                return false;
+            }
+            const targetIds = task.targetIds.split(/[，,]/).map(id => id.trim()).filter(id => id);
+            if (targetIds.length === 0) {
+                logger.warn(`${label} 任务目标列表为空: ${task.content}`);
+                return false;
+            }
+            logger.info(`${label} 正在执行: ${task.content} -> ${targetIds.join(',')} (${task.type})`);
+            let message = '';
+            // 1. 获取内容
+            if (task.content === '活跃市值') {
+                try {
+                    const responseText = await ctx.http.get('http://stock.svip886.com/api/indexes', { responseType: 'text' });
+                    message = `📊 定时广播 - 指数看板：\n\n${responseText}`;
+                }
+                catch (apiErr) {
+                    logger.error(`${label} 获取活跃市值 API 失败`, apiErr);
+                    return false;
+                }
+            }
+            else if (task.content === '涨停看板' || task.content === '跌停看板') {
+                try {
+                    const apiType = task.content === '涨停看板' ? 'limit_up' : 'limit_down';
+                    const imageUrl = `http://stock.svip886.com/api/${apiType}.png`;
+                    const imageBuffer = await ctx.http.get(imageUrl, { responseType: 'arraybuffer' });
+                    const base64Image = Buffer.from(imageBuffer).toString('base64');
+                    message = `🔔 定时广播 - ${task.content}：\n<img src="data:image/png;base64,${base64Image}" />`;
+                }
+                catch (apiErr) {
+                    logger.error(`${label} 获取${task.content}图片 API 失败`, apiErr);
+                    return false;
+                }
+            }
+            if (!message)
+                return false;
+            // 2. 发送消息
+            const bot = ctx.bots.find(b => b.status === 'online' || b.status === 1) || ctx.bots[0];
+            if (!bot) {
+                logger.error(`${label} 无可用机器人实例`);
+                return false;
+            }
+            let allSuccess = true;
+            for (const targetId of targetIds) {
+                try {
+                    if (task.type === 'private') {
+                        await bot.sendPrivateMessage(targetId, message);
+                    }
+                    else {
+                        await bot.sendMessage(targetId, message);
+                    }
+                }
+                catch (err) {
+                    logger.error(`${label} 发送失败 (${targetId}): ${err.message}`);
+                    allSuccess = false;
+                }
+            }
+            return allSuccess;
+        }
+        catch (error) {
+            logger.error(`${label} 执行过程发生严重错误`, error);
+            return false;
+        }
+    }
+    // 获取任务的下一个执行时间点
+    function getNextScheduledTime(task, currentTime) {
+        const times = task.times.split(/[，,]/).map(s => {
+            let time = s.trim();
+            if (/^\d:\d{2}$/.test(time))
+                time = '0' + time;
+            return time;
+        }).sort();
+        const currentIndex = times.indexOf(currentTime);
+        if (currentIndex === -1)
+            return times[0]; // 如果当前时间不在列表里，假设下一个是第一个
+        return times[(currentIndex + 1) % times.length];
+    }
     // 定时任务逻辑
     let lastCheckedMinute = '';
     ctx.setInterval(async () => {
         const now = new Date();
-        // 手动调整时区：UTC+8（中国时间）
-        const localTime = new Date(now.getTime() + 8 * 60 * 60 * 1000);
-        const hours = localTime.getUTCHours().toString().padStart(2, '0');
-        const minutes = localTime.getUTCMinutes().toString().padStart(2, '0');
-        const currentTime = `${hours}:${minutes}`;
-        // 每分钟的第一次执行时打印当前时间
+        const nowTimestamp = now.getTime();
+        const chinaTimeStr = now.toLocaleTimeString('zh-CN', {
+            timeZone: 'Asia/Shanghai',
+            hour12: false,
+            hour: '2-digit',
+            minute: '2-digit'
+        });
+        const currentTime = chinaTimeStr.replace('：', ':');
         if (config.enableDebugLog && currentTime !== lastCheckedMinute) {
-            logger.info(`[定时任务检查] 当前时间: ${currentTime}`);
+            logger.info(`[定时任务检查] 当前时间: ${currentTime} (上海时区)`);
+        }
+        // --- 1. 处理重试队列 ---
+        for (let i = retryQueue.length - 1; i >= 0; i--) {
+            const item = retryQueue[i];
+            // 检查是否达到1分钟间隔
+            if (nowTimestamp - item.lastAttemptTimestamp < 60000)
+                continue;
+            // 检查是否超过了下次执行时间
+            const nextTime = getNextScheduledTime(item.task, item.originalTime);
+            // 如果当前时间已经达到了该任务的下一个预定时间，或者已经跨天了，则取消重试
+            if (nextTime && (currentTime === nextTime || (currentTime > nextTime && item.originalTime < nextTime))) {
+                logger.warn(`[重试取消] 任务 ${item.task.content} (${item.originalTime}) 已过期或达到下个周期`);
+                retryQueue.splice(i, 1);
+                continue;
+            }
+            item.retryCount++;
+            item.lastAttemptTimestamp = nowTimestamp;
+            logger.info(`[开始重试] 任务 ${item.task.content} (原定于 ${item.originalTime}), 第 ${item.retryCount}/3 次重试`);
+            const success = await performBroadcast(item.task, true);
+            if (success) {
+                logger.info(`[重试成功] 任务 ${item.task.content} 已成功补发`);
+                retryQueue.splice(i, 1);
+            }
+            else if (item.retryCount >= 3) {
+                logger.error(`[重试失败] 任务 ${item.task.content} 已达到最大重试次数，放弃`);
+                retryQueue.splice(i, 1);
+            }
         }
+        // --- 2. 处理初始任务 ---
         if (currentTime === lastCheckedMinute)
             return;
         if (!config.broadcastTasks || config.broadcastTasks.length === 0)
             return;
-        // 检查当前时间是否有任务
         const activeTasks = config.broadcastTasks.filter(t => {
-            if (!t.times || typeof t.times !== 'string') {
-                logger.warn(`跳过配置不正确的任务: times 字段无效`);
+            if (!t.times || typeof t.times !== 'string')
                 return false;
-            }
-            const times = t.times.split(',').map(s => s.trim()).filter(s => s);
-            const isMatch = times.includes(currentTime);
-            if (config.enableDebugLog && isMatch) {
-                logger.info(`[时间匹配] ${currentTime} 在列表 [${times.join(',')}] 中`);
-            }
-            return isMatch;
+            const times = t.times.split(/[，,]/).map(s => {
+                let time = s.trim();
+                if (/^\d:\d{2}$/.test(time))
+                    time = '0' + time;
+                return time;
+            }).filter(s => s);
+            return times.includes(currentTime);
         });
-        if (activeTasks.length === 0)
+        if (activeTasks.length === 0) {
+            if (currentTime !== lastCheckedMinute)
+                lastCheckedMinute = currentTime;
             return;
-        lastCheckedMinute = currentTime;
-        if (config.enableDebugLog) {
-            logger.info(`[任务触发] 检测到定时任务: ${currentTime}, 共有 ${activeTasks.length} 个待执行任务`);
         }
+        lastCheckedMinute = currentTime;
+        logger.info(`[任务触发] 命中 ${activeTasks.length} 个广播任务 (时间: ${currentTime})`);
         try {
-            // 检查是否为交易日（基本周末检查 + 节假日API）
-            const day = localTime.getUTCDay();
-            const isWeekend = (day === 0 || day === 6);
-            const year = localTime.getUTCFullYear();
-            const month = (localTime.getUTCMonth() + 1).toString().padStart(2, '0');
-            const date = localTime.getUTCDate().toString().padStart(2, '0');
-            const dateStr = `${year}-${month}-${date}`;
+            const shanghaiDate = new Date(now.toLocaleString('en-US', { timeZone: 'Asia/Shanghai' }));
+            const isWeekend = (shanghaiDate.getDay() === 0 || shanghaiDate.getDay() === 6);
+            const year = shanghaiDate.getFullYear();
+            const month = (shanghaiDate.getMonth() + 1).toString().padStart(2, '0');
+            const day = shanghaiDate.getDate().toString().padStart(2, '0');
+            const dateStr = `${year}-${month}-${day}`;
             let tradingDay = !isWeekend;
             try {
-                logger.debug(`正在检查交易日状态: ${dateStr}`);
                 const holidayData = await ctx.http.get(`https://timor.tech/api/holiday/info/${dateStr}`);
-                if (holidayData && holidayData.type) {
-                    // type: 0 工作日, 1 周末, 2 节日, 3 调休
+                if (holidayData && typeof holidayData === 'object' && holidayData.type) {
                     const typeCode = holidayData.type.type;
                     tradingDay = (typeCode === 0 || typeCode === 3);
-                    logger.info(`节假日API返回类型: ${typeCode} (${holidayData.type.name}), 交易日状态: ${tradingDay}`);
                 }
             }
             catch (e) {
-                logger.warn(`节假日API请求失败，将使用基础周末检查: ${e.message}`);
+                logger.warn(`节假日API请求失败: ${e.message}`);
             }
             if (!tradingDay) {
-                logger.info(`当前非交易日，跳过广播任务`);
+                logger.info(`[定时任务跳过] ${dateStr} 非交易日`);
                 return;
             }
             for (const task of activeTasks) {
-                try {
-                    // 验证配置完整性
-                    if (!task.targetIds || typeof task.targetIds !== 'string') {
-                        logger.warn(`任务配置不完整: targetIds 字段无效或为空, 内容: ${task.content}`);
-                        continue;
-                    }
-                    const targetIds = task.targetIds.split(',').map(id => id.trim()).filter(id => id);
-                    if (targetIds.length === 0) {
-                        logger.warn(`任务目标列表为空: ${task.content}，原始值: ${task.targetIds}`);
-                        continue;
-                    }
-                    logger.info(`正在执行广播任务: ${task.content} -> ${targetIds.join(',')} (${task.type})`);
-                    let message = '';
-                    if (task.content === '活跃市值') {
-                        try {
-                            logger.info(`开始获取活跃市值数据...`);
-                            const responseText = await ctx.http.get('http://stock.svip886.com/api/indexes', { responseType: 'text' });
-                            message = `📊 定时广播 - 指数看板：\n\n${responseText}`;
-                            logger.info(`活跃市值数据获取成功, 信息长度: ${message.length}`);
-                        }
-                        catch (apiErr) {
-                            logger.error('获取活跃市值 API 失败', apiErr);
-                            continue;
-                        }
-                    }
-                    else if (task.content === '涨停看板' || task.content === '跌停看板') {
-                        try {
-                            const apiType = task.content === '涨停看板' ? 'limit_up' : 'limit_down';
-                            const imageUrl = `http://stock.svip886.com/api/${apiType}.png`;
-                            logger.info(`开始下载图片: ${imageUrl}`);
-                            const imageBuffer = await ctx.http.get(imageUrl, { responseType: 'arraybuffer' });
-                            logger.info(`图片下载成功, 大小: ${imageBuffer.byteLength} bytes`);
-                            const base64Image = Buffer.from(imageBuffer).toString('base64');
-                            message = `🔔 定时广播 - ${task.content}：\n<img src="data:image/png;base64,${base64Image}" />`;
-                            logger.info(`图片base64编码成功, 信息长度: ${message.length}`);
-                        }
-                        catch (apiErr) {
-                            logger.error(`获取${task.content}图片 API 失败`, apiErr);
-                            continue;
-                        }
-                    }
-                    else {
-                        logger.warn(`不支持的广播内容类型: ${task.content}`);
-                        continue;
-                    }
-                    if (!message) {
-                        logger.warn(`未能生成消息内容: ${task.content}`);
-                        continue;
-                    }
-                    const bot = ctx.bots.find(b => b.status === 'online' || b.status === 1) || ctx.bots[0];
-                    if (!bot) {
-                        logger.error(`无可用机器人实例，总有 ${ctx.bots.length} 个机器人`);
-                        continue;
-                    }
-                    logger.info(`找到机器人: ${bot.platform}, 开始向 ${targetIds.length} 个目标发送`);
-                    for (const targetId of targetIds) {
-                        try {
-                            logger.info(`将发送给 ${targetId}, 类型: ${task.type}`);
-                            if (task.type === 'private') {
-                                await bot.sendPrivateMessage(targetId, message);
-                            }
-                            else {
-                                await bot.sendMessage(targetId, message);
-                            }
-                            logger.info(`广播任务发送成功: ${task.content} -> ${targetId}`);
-                        }
-                        catch (err) {
-                            logger.error(`广播任务发送失败 (${targetId}): ${task.content}`, err);
-                        }
-                    }
-                }
-                catch (error) {
-                    logger.error(`定时广播任务执行失败: ${task.content}`, error);
+                const success = await performBroadcast(task);
+                if (!success) {
+                    logger.warn(`[任务入队] 任务 ${task.content} 执行失败，加入重试队列`);
+                    retryQueue.push({
+                        task,
+                        originalTime: currentTime,
+                        retryCount: 0,
+                        lastAttemptTimestamp: nowTimestamp
+                    });
                 }
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koishi-plugin-stock",
-  "version": "2.0.5",
+  "version": "2.0.7",
   "description": "A Koishi plugin that fetches stock data and provides market analysis, including active market cap, stock alerts, limit-up board, and stock selection features with configurable blacklists for each command.",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",