koishi-plugin-codex-reset 0.1.4 → 0.1.5

package/README.md

@@ -26,7 +26,9 @@
 
 日历、月度统计及右侧动态仅展示已确认且日期不晚于今天的事件，不展示预告。日期优先使用实际发生日期，缺失时使用北京时间的确认日期；两者均缺失时不展示，不使用预计时间窗口代替实际日期。
 
-首次轮询只建立本地基线，不会把 API 返回的历史事件全部推送；后续轮询只处理新增事件或 `announced` → `confirmed` 的状态变化。插件重启后会重新建立基线。
+首次安装时的第一份快照只建立基线，不会把历史事件全部推送。插件将已见事件状态和待发送通知保存在 Koishi 工作目录的 `data/codex-reset/` 中；重启后继续去重并重试未成功的目标。API 暂时漏掉旧事件、随后又补回时，也不会把它再次当作新事件。只有最近 48 小时内发布的预告或确认事件才会新建推送；超过 48 小时仍未送达的通知会放弃。更改 API 地址或推送目标后会建立新的基线。
+
+图片生成最多同时进行 2 项，新的图片任务至少间隔 3 秒；历史图片超过 120 条事件时会提示缩小查询范围。图片中的长篇来源文字会截短。API 响应上限为 4 MiB。
 
 ## 安装
 

package/lib/calendar.js

@@ -150,7 +150,8 @@ function renderCalendarGrid(month, marks, selectedDate, today) {
     return cells.join('');
 }
 function renderPostCard(event, post) {
-    const text = post.text || post.originalText;
+    const originalText = post.text || post.originalText;
+    const text = originalText.length > 500 ? `${originalText.slice(0, 500)}…` : originalText;
     const avatar = TIBO_AVATAR
         ? `<img class="avatar-image" src="${TIBO_AVATAR}" alt="">`
         : '<span class="avatar-fallback">T</span>';
@@ -174,7 +175,7 @@ function renderDetails(events) {
         const statusClass = event.status === 'confirmed' ? 'confirmed-state' : 'announced-state';
         return `<section class="event-group">
       <div class="event-state ${statusClass}"><span class="state-icon">${event.status === 'confirmed' ? '✓' : '◷'}</span>${status}</div>
-      <h2>${escapeHtml(event.title)}</h2>
+      <h2>${escapeHtml(event.title.slice(0, 200))}</h2>
       ${renderPostCard(event, post)}
     </section>`;
     }).join('');

package/lib/event.js

@@ -44,7 +44,8 @@ function renderSourcePost(summary) {
     const avatar = (0, calendar_1.getTiboAvatarDataUri)()
         ? `<img class="avatar-image" src="${(0, calendar_1.getTiboAvatarDataUri)()}" alt="">`
         : '<span class="avatar-fallback">T</span>';
-    const text = post.text || post.originalText;
+    const originalText = post.text || post.originalText;
+    const text = originalText.length > 500 ? `${originalText.slice(0, 500)}…` : originalText;
     const publishedAt = Date.parse(post.publishedAt);
     const time = Number.isFinite(publishedAt) ? formatDateTime(publishedAt) : '时间未知';
     return `<article class="post-card">
@@ -120,7 +121,7 @@ function renderLatestResetHtml(summary, now = new Date()) {
     </section>
     <section class="source">
       <header class="source-header"><h2>事件来源</h2><span>北京时间</span></header>
-      <h2 class="event-title">${escapeHtml(event.title)}</h2>
+      <h2 class="event-title">${escapeHtml(event.title.slice(0, 200))}</h2>
       ${renderSourcePost(summary)}
       <p class="source-note">${escapeHtml(event.scope ? `范围：${event.scope}` : '公开来源帖子记录')}</p>
       <div class="mark">RESET MONITOR</div>

package/lib/history.js

@@ -20,8 +20,8 @@ function parseTimestamp(value) {
 }
 function eventTimestamp(event) {
     const values = [
-        event.confirmedAt,
         event.occurredOn ? `${event.occurredOn}T12:00:00+08:00` : null,
+        event.confirmedAt,
         event.schedule?.from,
         event.createdAt,
     ];
@@ -43,7 +43,9 @@ function filterHistoryEvents(events, now = new Date(), range = 1) {
         day: 'numeric',
     }).formatToParts(now);
     const values = Object.fromEntries(parts.map((part) => [part.type, part.value]));
-    const cutoff = Date.UTC(Number(values.year), Number(values.month) - 1 - months, Number(values.day), -8);
+    const targetMonth = new Date(Date.UTC(Number(values.year), Number(values.month) - 1 - months, 1));
+    const lastDay = new Date(Date.UTC(targetMonth.getUTCFullYear(), targetMonth.getUTCMonth() + 1, 0)).getUTCDate();
+    const cutoff = Date.UTC(targetMonth.getUTCFullYear(), targetMonth.getUTCMonth(), Math.min(Number(values.day), lastDay), -8);
     const current = now.getTime();
     return events.filter((event) => {
         const timestamp = eventTimestamp(event);
@@ -89,7 +91,8 @@ function renderPostPreview(event) {
     const post = event.posts[0];
     if (!post)
         return '<div class="post-preview empty">暂无来源帖子内容</div>';
-    const text = post.text || post.originalText;
+    const originalText = post.text || post.originalText;
+    const text = originalText.length > 500 ? `${originalText.slice(0, 500)}…` : originalText;
     const avatar = (0, calendar_1.getTiboAvatarDataUri)()
         ? `<img class="avatar-image" src="${(0, calendar_1.getTiboAvatarDataUri)()}" alt="">`
         : '<span class="avatar-fallback">T</span>';
@@ -105,13 +108,13 @@ function renderPostPreview(event) {
 function renderTimelineItem(event) {
     const timestamp = eventTimestamp(event);
     const statusClass = event.status === 'confirmed' ? 'confirmed' : 'announced';
-    const schedule = event.schedule?.label ? `<div class="schedule">时间：${escapeHtml(event.schedule.label)}</div>` : '';
+    const schedule = event.schedule?.label ? `<div class="schedule">时间：${escapeHtml(event.schedule.label.slice(0, 150))}</div>` : '';
     return `<article class="timeline-item">
     <div class="timeline-date"><strong>${escapeHtml(dateLabel(timestamp))}</strong><span>${escapeHtml(timeLabel(timestamp))}</span></div>
     <div class="timeline-dot ${statusClass}"></div>
     <div class="event-card">
       <div class="event-meta"><span class="type-label">${typeLabel(event)}</span><span class="status ${statusClass}">${statusLabel(event)}</span></div>
-      <h2>${escapeHtml(event.title)}</h2>
+      <h2>${escapeHtml(event.title.slice(0, 200))}</h2>
       ${schedule}
       ${renderPostPreview(event)}
     </div>

package/lib/index.js

@@ -3,12 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Config = exports.inject = exports.name = void 0;
 exports.apply = apply;
 const koishi_1 = require("koishi");
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
 const calendar_1 = require("./calendar");
 const history_1 = require("./history");
 const event_1 = require("./event");
 const probability_1 = require("./probability");
 const stats_1 = require("./stats");
 exports.name = 'codex-reset';
+const MAX_NOTIFICATION_AGE_MS = 48 * 60 * 60 * 1000;
+const MAX_PENDING_AGE_MS = 48 * 60 * 60 * 1000;
+const MAX_API_RESPONSE_BYTES = 4 * 1024 * 1024;
+const MAX_HISTORY_EVENTS = 120;
+const MAX_CONCURRENT_RENDERS = 2;
+const RENDER_START_INTERVAL_MS = 3000;
+class RenderBusyError extends Error {
+}
 exports.inject = {
     optional: ['puppeteer'],
 };
@@ -125,36 +136,85 @@ function isSnapshot(value) {
 function eventSummary(event) {
     const kind = event.type === 'direct_reset' ? 'Codex 额度重置' : 'Codex 重置卡发放';
     const status = event.status === 'announced' ? '预告' : '已确认';
-    const scope = event.scope ? `（范围：${event.scope}）` : '';
-    const schedule = event.schedule?.label ? `\n时间：${event.schedule.label}` : '';
-    const source = event.posts[0]?.url ? `\n来源：${event.posts[0].url}` : '';
+    const scope = event.scope ? `（范围：${event.scope.slice(0, 200)}）` : '';
+    let schedule = '';
+    if (event.status === 'announced' && event.schedule?.label) {
+        schedule = `\n预计时间：${event.schedule.label.slice(0, 200)}`;
+    }
+    else if (event.status === 'confirmed' && event.occurredOn) {
+        schedule = `\n发生日期：${event.occurredOn}（北京时间）`;
+    }
+    else if (event.status === 'confirmed' && event.confirmedAt) {
+        const confirmedAt = new Intl.DateTimeFormat('zh-CN', {
+            timeZone: 'Asia/Shanghai', dateStyle: 'medium', timeStyle: 'short',
+        }).format(new Date(event.confirmedAt));
+        schedule = `\n确认时间：${confirmedAt}`;
+    }
+    const source = event.posts[0]?.url ? `\n来源：${event.posts[0].url.slice(0, 500)}` : '';
     return `${kind}${status}${scope}${schedule}${source}`;
 }
-async function sendToTargets(ctx, targets, content) {
-    let sent = 0;
-    const sentBindings = new Set();
+function stageKeys(event) {
+    return [`id:${event.status}:${event.id}`];
+}
+function isRecent(timestamp, now) {
+    return Number.isFinite(timestamp) && timestamp <= now + 5 * 60 * 1000 && now - timestamp <= MAX_NOTIFICATION_AGE_MS;
+}
+function isRecentEventDay(value, now) {
+    const timestamp = Date.parse(`${value}T12:00:00+08:00`);
+    // occurredOn has day precision. Today's noon may still be in the future
+    // when a morning confirmation arrives.
+    return Number.isFinite(timestamp) && timestamp <= now + 12 * 60 * 60 * 1000
+        && now - timestamp <= MAX_NOTIFICATION_AGE_MS;
+}
+function isFreshNotification(event, now, wasAnnounced) {
+    if (event.status === 'announced')
+        return isRecent(Date.parse(event.createdAt), now);
+    // A fresh confirmation can be attached to a much older reset. Never revive
+    // that historical event merely because the API filled in confirmedAt today.
+    if (event.occurredOn && !isRecentEventDay(event.occurredOn, now))
+        return false;
+    if (!event.occurredOn && event.schedule?.through
+        && now - Date.parse(event.schedule.through) > MAX_NOTIFICATION_AGE_MS)
+        return false;
+    if (event.confirmedAt)
+        return isRecent(Date.parse(event.confirmedAt), now);
+    if (event.occurredOn)
+        return isRecentEventDay(event.occurredOn, now);
+    return (wasAnnounced || isRecent(Date.parse(event.createdAt), now))
+        && isRecent(Date.parse(event.updatedAt), now);
+}
+async function sendToTargets(ctx, targets, content, deliveredBindings, onDelivered) {
+    const delivered = new Set(deliveredBindings);
+    let complete = true;
     for (const target of targets) {
         const channelId = target.channelId?.trim();
         if (!channelId)
             continue;
         const bots = [...ctx.bots].filter((bot) => !target.platform?.trim() || bot.platform === target.platform.trim());
-        for (const bot of bots) {
-            // A blank-platform target already covers explicit platform targets. Send only once
-            // per platform/channel binding, while still trying another bot if the first fails.
-            const key = `${bot.platform}\u0000${channelId}`;
-            if (sentBindings.has(key))
+        if (!bots.length)
+            complete = false;
+        for (const platform of new Set(bots.map((bot) => bot.platform))) {
+            const key = `${platform}\u0000${channelId}`;
+            if (delivered.has(key))
                 continue;
-            try {
-                await bot.sendMessage(channelId, content);
-                sentBindings.add(key);
-                sent++;
-            }
-            catch (error) {
-                ctx.logger('codex-reset').warn(`发送到 ${bot.platform}:${target.channelId} 失败：${error instanceof Error ? error.message : String(error)}`);
+            for (const bot of bots.filter((candidate) => candidate.platform === platform)) {
+                try {
+                    await bot.sendMessage(channelId, content);
+                }
+                catch (error) {
+                    ctx.logger('codex-reset').warn(`发送到 ${bot.platform}:${target.channelId} 失败：${error instanceof Error ? error.message : String(error)}`);
+                    continue;
+                }
+                delivered.add(key);
+                deliveredBindings.push(key);
+                await onDelivered();
+                break;
             }
+            if (!delivered.has(key))
+                complete = false;
         }
     }
-    return sent;
+    return complete;
 }
 class CodexResetMonitor {
     ctx;
@@ -163,9 +223,21 @@ class CodexResetMonitor {
     etag = null;
     pollPromise = null;
     disposed = false;
+    statePath;
+    stateLoaded;
+    seenStages = new Set();
+    pending = new Map();
+    initialized = false;
+    activeRenders = 0;
+    nextRenderAllowedAt = 0;
     constructor(ctx, config) {
         this.ctx = ctx;
         this.config = config;
+        const instanceId = (0, node_crypto_1.createHash)('sha256')
+            .update(JSON.stringify({ apiUrl: config.apiUrl, targets: config.targets }))
+            .digest('hex').slice(0, 16);
+        this.statePath = (0, node_path_1.join)(ctx.baseDir, 'data', 'codex-reset', `${instanceId}.json`);
+        this.stateLoaded = this.loadState();
     }
     get currentSnapshot() {
         return this.snapshot;
@@ -196,16 +268,22 @@ class CodexResetMonitor {
     }
     async performPoll() {
         try {
+            await this.stateLoaded;
             const result = await this.fetchSnapshot();
-            if (result.notModified || !result.snapshot)
-                return;
-            const previous = this.snapshot;
-            this.snapshot = result.snapshot;
-            this.etag = result.etag ?? this.etag;
-            // The API returns a complete, mutable snapshot. The first fetch is a baseline.
-            if (!previous)
-                return;
-            await this.notifyChanges(previous, result.snapshot);
+            if (!result.notModified && result.snapshot) {
+                this.snapshot = result.snapshot;
+                this.etag = result.etag ?? this.etag;
+                if (!this.initialized) {
+                    // A fresh installation starts with the entire current snapshot as its baseline.
+                    for (const event of result.snapshot.events)
+                        this.markSeen(event);
+                    this.initialized = true;
+                }
+                else {
+                    this.captureChanges(result.snapshot, Date.now());
+                }
+            }
+            await this.flushPending();
         }
         catch (error) {
             this.ctx.logger('codex-reset').warn(`获取 AIHOT 重置事件失败：${error instanceof Error ? error.message : String(error)}`);
@@ -216,36 +294,149 @@ class CodexResetMonitor {
         const browser = this.ctx.puppeteer;
         if (!snapshot || !browser)
             return null;
-        return (0, calendar_1.renderCalendarImage)(browser, snapshot.events);
+        return this.withRenderSlot(() => (0, calendar_1.renderCalendarImage)(browser, snapshot.events));
     }
     async createHistoryImage(events, now = new Date()) {
         const snapshot = await this.ensureSnapshot();
         const browser = this.ctx.puppeteer;
         if (!snapshot || !browser)
             return null;
-        return (0, history_1.renderHistoryImage)(browser, events ?? snapshot.events, now);
+        return this.withRenderSlot(() => (0, history_1.renderHistoryImage)(browser, events ?? snapshot.events, now));
     }
     async createProbabilityImage(summary) {
         const browser = this.ctx.puppeteer;
         if (!browser)
             return null;
-        return (0, probability_1.renderProbabilityImage)(browser, summary);
+        return this.withRenderSlot(() => (0, probability_1.renderProbabilityImage)(browser, summary));
     }
     async createLatestResetImage(summary, now = new Date()) {
         const browser = this.ctx.puppeteer;
         if (!browser)
             return null;
-        return (0, event_1.renderLatestResetImage)(browser, summary, now);
+        return this.withRenderSlot(() => (0, event_1.renderLatestResetImage)(browser, summary, now));
+    }
+    async withRenderSlot(render) {
+        const now = Date.now();
+        if (this.activeRenders >= MAX_CONCURRENT_RENDERS || now < this.nextRenderAllowedAt) {
+            throw new RenderBusyError('图片生成任务较多');
+        }
+        this.nextRenderAllowedAt = now + RENDER_START_INTERVAL_MS;
+        this.activeRenders++;
+        try {
+            return await render();
+        }
+        finally {
+            this.activeRenders--;
+        }
+    }
+    async loadState() {
+        try {
+            const state = JSON.parse(await (0, promises_1.readFile)(this.statePath, 'utf8'));
+            if (!isRecord(state) || state.version !== 1 || !Array.isArray(state.seenStages) || !Array.isArray(state.pending)) {
+                throw new Error('状态文件格式无效');
+            }
+            this.initialized = state.initialized === true;
+            for (const key of state.seenStages) {
+                if (typeof key === 'string')
+                    this.seenStages.add(key);
+            }
+            for (const item of state.pending) {
+                if (!isRecord(item) || typeof item.key !== 'string' || typeof item.message !== 'string'
+                    || typeof item.createdAt !== 'number' || !Array.isArray(item.deliveredBindings))
+                    continue;
+                this.pending.set(item.key, {
+                    key: item.key,
+                    message: item.message,
+                    createdAt: item.createdAt,
+                    deliveredBindings: item.deliveredBindings.filter((key) => typeof key === 'string'),
+                });
+            }
+        }
+        catch (error) {
+            if (isRecord(error) && error.code === 'ENOENT')
+                return;
+            this.ctx.logger('codex-reset').warn(`读取推送状态失败，将重新建立基线：${error instanceof Error ? error.message : String(error)}`);
+        }
     }
-    async fetchSnapshot(ignoreEtag = false) {
+    async saveState() {
+        const state = {
+            version: 1,
+            initialized: this.initialized,
+            seenStages: [...this.seenStages],
+            pending: [...this.pending.values()],
+        };
+        const temporaryPath = `${this.statePath}.${process.pid}.tmp`;
+        try {
+            await (0, promises_1.mkdir)((0, node_path_1.dirname)(this.statePath), { recursive: true });
+            await (0, promises_1.writeFile)(temporaryPath, JSON.stringify(state), 'utf8');
+            await (0, promises_1.rename)(temporaryPath, this.statePath);
+        }
+        catch (error) {
+            this.ctx.logger('codex-reset').warn(`保存推送状态失败：${error instanceof Error ? error.message : String(error)}`);
+            throw error;
+        }
+    }
+    markSeen(event) {
+        for (const key of stageKeys(event))
+            this.seenStages.add(key);
+    }
+    captureChanges(current, now) {
+        for (const event of current.events) {
+            const keys = stageKeys(event);
+            const alreadySeen = keys.some((key) => this.seenStages.has(key));
+            const wasAnnounced = this.seenStages.has(`id:announced:${event.id}`);
+            this.markSeen(event);
+            if (alreadySeen || !isFreshNotification(event, now, wasAnnounced))
+                continue;
+            if (event.status === 'announced' && !this.config.pushAnnouncements)
+                continue;
+            if (event.status === 'confirmed' && !this.config.pushConfirmedResets)
+                continue;
+            const message = event.status === 'announced'
+                ? `📢 Codex 重置预告\n${eventSummary(event)}`
+                : `✅ Codex 重置事件\n${eventSummary(event)}`;
+            if (!this.config.targets.length) {
+                this.ctx.logger('codex-reset').info(`检测到新事件，但未配置推送目标：\n${message}`);
+                continue;
+            }
+            const key = keys[0];
+            this.pending.set(key, { key, message, createdAt: now, deliveredBindings: [] });
+        }
+    }
+    async flushPending() {
+        // Persist the observed stages and queue before sending. This also repairs
+        // a previous write failure when the next API response is 304.
+        await this.saveState();
+        let changed = false;
+        for (const [key, item] of this.pending) {
+            if (Date.now() - item.createdAt > MAX_PENDING_AGE_MS) {
+                this.ctx.logger('codex-reset').warn(`推送超过 48 小时仍未完成，已放弃：${key}`);
+                this.pending.delete(key);
+                changed = true;
+                continue;
+            }
+            const content = this.config.mentionAll
+                ? [(0, koishi_1.h)('at', { type: 'all' }), koishi_1.h.text(`\n${item.message}`)]
+                : item.message;
+            const deliveredCount = item.deliveredBindings.length;
+            const complete = await sendToTargets(this.ctx, this.config.targets, content, item.deliveredBindings, () => this.saveState());
+            if (complete)
+                this.pending.delete(key);
+            if (complete || deliveredCount !== item.deliveredBindings.length)
+                changed = true;
+        }
+        if (changed)
+            await this.saveState();
+    }
+    async fetchSnapshot() {
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), this.config.requestTimeout);
         try {
             const headers = {
                 Accept: 'application/json',
-                'User-Agent': 'koishi-plugin-codex-reset/0.1.3',
+                'User-Agent': 'koishi-plugin-codex-reset/0.1.5',
             };
-            if (!ignoreEtag && this.etag && this.snapshot)
+            if (this.etag && this.snapshot)
                 headers['If-None-Match'] = this.etag;
             const response = await fetch(this.config.apiUrl, {
                 method: 'GET',
@@ -256,12 +447,29 @@ class CodexResetMonitor {
                 return { snapshot: null, etag: this.etag, notModified: true };
             }
             if (response.status === 304)
-                return this.fetchSnapshot(true);
-            if (!response.ok) {
-                const detail = (await response.text()).slice(0, 300).replace(/\s+/g, ' ');
-                throw new Error(`HTTP ${response.status}${detail ? `：${detail}` : ''}`);
+                throw new Error('服务端在没有本地快照时返回了 304');
+            if (!response.ok)
+                throw new Error(`HTTP ${response.status}`);
+            const declaredLength = Number(response.headers.get('content-length'));
+            if (declaredLength > MAX_API_RESPONSE_BYTES)
+                throw new Error('API 响应超过 4 MiB');
+            if (!response.body)
+                throw new Error('API 响应没有内容');
+            const reader = response.body.getReader();
+            const chunks = [];
+            let size = 0;
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                size += value.byteLength;
+                if (size > MAX_API_RESPONSE_BYTES) {
+                    await reader.cancel();
+                    throw new Error('API 响应超过 4 MiB');
+                }
+                chunks.push(value);
             }
-            const body = await response.json();
+            const body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
             if (!isSnapshot(body))
                 throw new Error('响应格式不符合 Codex 重置 API v1');
             return {
@@ -274,29 +482,6 @@ class CodexResetMonitor {
             clearTimeout(timeout);
         }
     }
-    async notifyChanges(previous, current) {
-        const previousById = new Map(previous.events.map((event) => [event.id, event]));
-        const messages = [];
-        for (const event of current.events) {
-            const oldEvent = previousById.get(event.id);
-            if (event.status === 'announced' && this.config.pushAnnouncements && !oldEvent) {
-                messages.push(`📢 Codex 重置预告\n${eventSummary(event)}`);
-            }
-            if (event.status === 'confirmed' && this.config.pushConfirmedResets && (!oldEvent || oldEvent.status === 'announced')) {
-                messages.push(`✅ Codex 重置事件\n${eventSummary(event)}`);
-            }
-        }
-        for (const message of messages) {
-            if (!this.config.targets.length) {
-                this.ctx.logger('codex-reset').info(`检测到新事件，但未配置推送目标：\n${message}`);
-                continue;
-            }
-            const content = this.config.mentionAll
-                ? [(0, koishi_1.h)('at', { type: 'all' }), koishi_1.h.text(`\n${message}`)]
-                : message;
-            await sendToTargets(this.ctx, this.config.targets, content);
-        }
-    }
 }
 function apply(ctx, config) {
     const monitor = new CodexResetMonitor(ctx, config);
@@ -321,6 +506,8 @@ function apply(ctx, config) {
             return koishi_1.h.image(image, 'image/png');
         }
         catch (error) {
+            if (error instanceof RenderBusyError)
+                return (0, stats_1.formatProbability)(summary);
             ctx.logger('codex-reset').warn(`生成概率卡片失败：${error instanceof Error ? error.message : String(error)}`);
             return (0, stats_1.formatProbability)(summary);
         }
@@ -344,6 +531,8 @@ function apply(ctx, config) {
             return koishi_1.h.image(image, 'image/png');
         }
         catch (error) {
+            if (error instanceof RenderBusyError)
+                return (0, stats_1.formatLatestReset)(snapshot, now);
             ctx.logger('codex-reset').warn(`生成最近重置卡片失败：${error instanceof Error ? error.message : String(error)}`);
             return (0, stats_1.formatLatestReset)(snapshot, now);
         }
@@ -360,6 +549,8 @@ function apply(ctx, config) {
             return koishi_1.h.image(image, 'image/png');
         }
         catch (error) {
+            if (error instanceof RenderBusyError)
+                return '图片生成任务较多，请稍后再试。';
             ctx.logger('codex-reset').warn(`生成日历图片失败：${error instanceof Error ? error.message : String(error)}`);
             return '日历图片生成失败，请检查 Puppeteer 服务和中文字体。';
         }
@@ -379,12 +570,16 @@ function apply(ctx, config) {
                 ? 'all'
                 : Math.max(1, Math.min(120, Math.floor(Math.abs(range ?? 1))));
             const events = (0, history_1.filterHistoryEvents)(snapshot.events, now, historyRange);
+            if (events.length > MAX_HISTORY_EVENTS)
+                return `历史事件超过 ${MAX_HISTORY_EVENTS} 条，请缩小查询的月份范围。`;
             const image = await monitor.createHistoryImage(events, now);
             if (!image)
                 return '暂时无法生成历史时间线图片，请稍后再试。';
             return koishi_1.h.image(image, 'image/png');
         }
         catch (error) {
+            if (error instanceof RenderBusyError)
+                return '图片生成任务较多，请稍后再试。';
             ctx.logger('codex-reset').warn(`生成历史时间线图片失败：${error instanceof Error ? error.message : String(error)}`);
             return '历史时间线图片生成失败，请检查 Puppeteer 服务和中文字体。';
         }

package/lib/stats.js

@@ -54,16 +54,16 @@ function percentage(value) {
     return `${(value * 100).toFixed(value < 0.1 ? 1 : 0)}%`;
 }
 function eventTimestamp(event) {
-    if (event.confirmedAt) {
-        const timestamp = Date.parse(event.confirmedAt);
-        if (Number.isFinite(timestamp))
-            return { timestamp, approximate: false };
-    }
     if (event.occurredOn) {
         const timestamp = Date.parse(`${event.occurredOn}T12:00:00+08:00`);
         if (Number.isFinite(timestamp))
             return { timestamp, approximate: true };
     }
+    if (event.confirmedAt) {
+        const timestamp = Date.parse(event.confirmedAt);
+        if (Number.isFinite(timestamp))
+            return { timestamp, approximate: false };
+    }
     for (const value of [event.schedule?.from, event.createdAt]) {
         const timestamp = parseTimestamp(value);
         if (timestamp !== null)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koishi-plugin-codex-reset",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Monitor AIHOT Codex reset events and notify Koishi channels.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",