koishi-plugin-codex-reset 0.1.4 → 0.1.6

package/README.md

@@ -24,9 +24,15 @@
 
 概率、最近重置、日历和历史时间线命令始终启用；安装并启用 `koishi-plugin-puppeteer` 后会发送对应图片，没有 Puppeteer 时概率和最近重置会回退为纯文本，日历和历史时间线会提示安装 Puppeteer。
 
-日历、月度统计及右侧动态仅展示已确认且日期不晚于今天的事件，不展示预告。日期优先使用实际发生日期，缺失时使用北京时间的确认日期；两者均缺失时不展示，不使用预计时间窗口代替实际日期。
-
-首次轮询只建立本地基线，不会把 API 返回的历史事件全部推送；后续轮询只处理新增事件或 `announced` → `confirmed` 的状态变化。插件重启后会重新建立基线。
+日历、月度统计及右侧动态仅展示已确认且日期不晚于今天的事件，不展示预告。日期优先使用实际发生日期，缺失时使用北京时间的确认日期；两者均缺失时不展示，不使用预计时间窗口代替实际日期。
+
+首次安装时的第一份快照只建立基线，不会把历史事件全部推送。插件将已见事件状态和待发送通知保存在 Koishi 工作目录的 `data/codex-reset/` 中；重启后继续去重并重试未成功的目标。API 暂时漏掉旧事件、随后又补回时，也不会把它再次当作新事件。只有最近 48 小时内发布的预告或确认事件才会新建推送；超过 48 小时仍未送达的通知会放弃。更改 API 地址或推送目标后会建立新的基线。
+
+从 0.1.6 起，需要启用 Koishi 数据库服务（例如 SQLite、MySQL 或 PostgreSQL）。完整 API 快照、ETag、最近同步时间和下次允许请求的时间保存在 `codex_reset_cache` 表中，相同 API 地址共用一份记录。所有查询命令只读数据库，不直接请求上游；首次同步尚未成功时会提示稍后再试。重启、重载插件后仍可查询已保存的数据，并继续遵守冷却时间。同步失败时保留上次成功的数据，可能暂时不是最新状态。
+
+后台默认每 660 秒同步一次；旧配置小于 660 秒时，实际请求也不会快于 660 秒。请求前先保存冷却时间，收到 HTTP 429 或 503 时遵循 `Retry-After`（也支持响应正文的 `retryAfter` 秒数），冷却期间不会因重启或手动查询再次请求。数据库写入失败时不会继续发起新的上游请求。
+
+图片生成最多同时进行 2 项，新的图片任务至少间隔 3 秒；历史图片超过 120 条事件时会提示缩小查询范围。图片中的长篇来源文字会截短。API 响应上限为 4 MiB。
 
 ## 安装
 
@@ -34,12 +40,12 @@
 npm install koishi-plugin-codex-reset
 ```
 
-如果需要概率卡片、最近重置卡片、日历或历史时间线图片，再安装并启用 `koishi-plugin-puppeteer`。不安装 Puppeteer 时，监控、最近重置和概率分析仍然可以使用，概率与最近重置命令回退为纯文本，日历和历史命令会给出提示。
+先在 Koishi 中启用一个数据库插件，再启用本插件；如果已经使用数据库服务，无需另建数据库。如果需要概率卡片、最近重置卡片、日历或历史时间线图片，再安装并启用 `koishi-plugin-puppeteer`。不安装 Puppeteer 时，监控、最近重置和概率分析仍然可以使用，概率与最近重置命令回退为纯文本，日历和历史命令会给出提示。
 
 ## 配置
 
 - `监控接口地址`：监控 API 地址，默认 `https://aihot.news/api/v1/codex-resets`。
-- `监控间隔`：轮询间隔，单位为秒，默认 300 秒。
+- `监控间隔`：轮询间隔，单位为秒，默认 660 秒（11 分钟）。实际请求间隔至少 660 秒，并遵守服务端更长的缓存及重试等待时间。
 - `请求超时时间`：单次 API 请求超时时间，单位为毫秒，默认 15000 毫秒。
 - `推送目标`：推送目标表，填写“平台”和“频道或群组 ID”；平台留空会按频道尝试在线 Bot，同一平台/频道只发送一次。
 - `推送重置预告`：是否推送预告。

package/lib/cache.d.ts

@@ -0,0 +1,36 @@
+import type { Context } from 'koishi';
+import type { CodexResetsResponse } from './types';
+export declare const MIN_POLL_INTERVAL_MS = 660000;
+export interface SnapshotCache {
+    id: string;
+    snapshot: CodexResetsResponse | null;
+    etag: string | null;
+    fetchedAt: number;
+    nextFetchAt: number;
+    requestId: string;
+}
+declare module 'koishi' {
+    interface Tables {
+        codex_reset_cache: SnapshotCache;
+    }
+}
+export interface FetchResult {
+    snapshot: CodexResetsResponse | null;
+    etag: string | null;
+    notModified: boolean;
+    maxAgeMs: number;
+}
+export declare class SnapshotRequestError extends Error {
+    readonly retryAfterMs: number;
+    constructor(message: string, retryAfterMs: number);
+}
+export declare function extendCacheModel(ctx: Context): void;
+export declare class SnapshotStore {
+    private readonly ctx;
+    private readonly validate;
+    private readonly id;
+    constructor(ctx: Context, apiUrl: string, validate: (value: unknown) => value is CodexResetsResponse);
+    read(): Promise<SnapshotCache>;
+    refresh(intervalMs: number, timeoutMs: number, fetchSnapshot: (cache: SnapshotCache) => Promise<FetchResult>): Promise<SnapshotCache>;
+    private performRefresh;
+}

package/lib/cache.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnapshotStore = exports.SnapshotRequestError = exports.MIN_POLL_INTERVAL_MS = void 0;
+exports.extendCacheModel = extendCacheModel;
+const node_crypto_1 = require("node:crypto");
+// Leave a little room beyond AIHOT's ten-minute full-history limit.
+exports.MIN_POLL_INTERVAL_MS = 660_000;
+const TABLE = 'codex_reset_cache';
+const inFlight = new WeakMap();
+class SnapshotRequestError extends Error {
+    retryAfterMs;
+    constructor(message, retryAfterMs) {
+        super(message);
+        this.retryAfterMs = retryAfterMs;
+    }
+}
+exports.SnapshotRequestError = SnapshotRequestError;
+function extendCacheModel(ctx) {
+    ctx.model.extend(TABLE, {
+        id: 'string',
+        snapshot: { type: 'json', nullable: true, initial: null },
+        etag: { type: 'string', nullable: true, initial: null },
+        fetchedAt: { type: 'double', initial: 0 },
+        nextFetchAt: { type: 'double', initial: 0 },
+        requestId: { type: 'string', initial: '' },
+    }, { primary: 'id' });
+}
+class SnapshotStore {
+    ctx;
+    validate;
+    id;
+    constructor(ctx, apiUrl, validate) {
+        this.ctx = ctx;
+        this.validate = validate;
+        // Targets do not affect API data or the upstream request quota.
+        this.id = (0, node_crypto_1.createHash)('sha256').update(new URL(apiUrl).href).digest('hex');
+    }
+    async read() {
+        let [cache] = await this.ctx.database.get(TABLE, this.id);
+        if (!cache) {
+            try {
+                cache = await this.ctx.database.create(TABLE, { id: this.id });
+            }
+            catch (error) {
+                // Another instance may have created the same API cache concurrently.
+                const existing = await this.ctx.database.get(TABLE, this.id);
+                cache = existing[0];
+                if (!cache)
+                    throw error;
+            }
+        }
+        if (!this.validate(cache.snapshot))
+            return { ...cache, snapshot: null, etag: null };
+        return cache;
+    }
+    refresh(intervalMs, timeoutMs, fetchSnapshot) {
+        const root = this.ctx.root ?? this.ctx;
+        let requests = inFlight.get(root);
+        if (!requests)
+            inFlight.set(root, requests = new Map());
+        const pending = requests.get(this.id);
+        if (pending)
+            return pending;
+        const request = this.performRefresh(intervalMs, timeoutMs, fetchSnapshot)
+            .finally(() => requests.delete(this.id));
+        requests.set(this.id, request);
+        return request;
+    }
+    async performRefresh(intervalMs, timeoutMs, fetchSnapshot) {
+        const cache = await this.read();
+        const now = Date.now();
+        if (now < cache.nextFetchAt)
+            return cache;
+        const delay = Math.max(exports.MIN_POLL_INTERVAL_MS, intervalMs);
+        const requestId = (0, node_crypto_1.randomUUID)();
+        // Reserve the next request before network I/O. A restart or another plugin
+        // instance must observe this reservation, even if the request fails.
+        await this.ctx.database.set(TABLE, {
+            id: this.id,
+            nextFetchAt: cache.nextFetchAt,
+            requestId: cache.requestId,
+        }, {
+            requestId,
+            nextFetchAt: now + Math.max(delay, timeoutMs + 1000),
+        });
+        const reserved = await this.read();
+        if (reserved.requestId !== requestId)
+            return reserved;
+        try {
+            const result = await fetchSnapshot(cache);
+            await this.ctx.database.set(TABLE, { id: this.id, requestId }, {
+                snapshot: result.notModified ? cache.snapshot : result.snapshot,
+                etag: result.etag,
+                fetchedAt: Date.now(),
+                nextFetchAt: Math.max(now + delay, Date.now() + result.maxAgeMs),
+            });
+        }
+        catch (error) {
+            const retryAfterMs = error instanceof SnapshotRequestError ? error.retryAfterMs : 0;
+            await this.ctx.database.set(TABLE, { id: this.id, requestId }, {
+                nextFetchAt: Date.now() + Math.max(delay, retryAfterMs),
+            });
+            throw error;
+        }
+        return this.read();
+    }
+}
+exports.SnapshotStore = SnapshotStore;

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('');
@@ -269,7 +270,7 @@ function renderCalendarHtml(events, now = new Date()) {
       </header>
       <div class="weekday-row">${WEEK_NAMES.map((name) => `<span>${name}</span>`).join('')}</div>
       <div class="calendar-grid">${renderCalendarGrid(month, marks, selectedDate, today)}</div>
-      <div class="calendar-note">仅显示已确认事件；按北京时间记录实际发生日期，缺失时按确认日期展示；不含预告。</div>
+      <div class="calendar-note">仅显示已确认事件；按北京时间记录实际发生日期，缺失时按确认日期展示；不含预告。</div>
     </section>
     ${renderDetails(events)}
   </main>

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.d.ts

@@ -2,8 +2,10 @@ import { Context, Schema } from 'koishi';
 import type { Config as PluginConfig } from './types';
 export declare const name = "codex-reset";
 export declare const inject: {
+    required: string[];
     optional: string[];
 };
 export type Config = PluginConfig;
+export type { SnapshotCache } from './cache';
 export declare const Config: Schema<Config>;
 export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -3,13 +3,26 @@ 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 cache_1 = require("./cache");
 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 = {
+    required: ['database'],
     optional: ['puppeteer'],
 };
 exports.Config = koishi_1.Schema.object({
@@ -18,8 +31,8 @@ exports.Config = koishi_1.Schema.object({
         .description('监控接口地址。通常不需要修改。'),
     pollInterval: koishi_1.Schema.number()
         .min(60)
-        .default(300)
-        .description('监控间隔，单位为秒。AIHOT 推荐约 5 分钟轮询一次。'),
+        .default(660)
+        .description('监控间隔，单位为秒，默认 660 秒。兼容旧配置，实际请求间隔至少 660 秒；重启后继续遵守已保存的冷却时间。'),
     requestTimeout: koishi_1.Schema.number()
         .min(5000)
         .default(15000)
@@ -125,58 +138,122 @@ 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;
     config;
-    snapshot = null;
-    etag = null;
+    snapshots;
     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;
-    }
-    get currentSnapshot() {
-        return this.snapshot;
+        this.snapshots = new cache_1.SnapshotStore(ctx, config.apiUrl, isSnapshot);
+        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 hasPuppeteer() {
         return Boolean(this.ctx.puppeteer);
     }
     async ensureSnapshot() {
-        if (!this.snapshot)
-            await this.poll();
-        return this.snapshot;
+        // Commands only read the database. A missing snapshot must not turn every
+        // user command into another upstream request during a rate-limit window.
+        try {
+            return (await this.snapshots.read()).snapshot;
+        }
+        catch (error) {
+            this.ctx.logger('codex-reset').warn(`读取重置数据失败：${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
     }
     async poll() {
         if (this.disposed)
@@ -191,21 +268,35 @@ class CodexResetMonitor {
             this.pollPromise = null;
         }
     }
+    async start() {
+        await this.poll();
+        if (!this.disposed) {
+            this.ctx.setInterval(() => this.poll(), Math.max(cache_1.MIN_POLL_INTERVAL_MS, this.config.pollInterval * 1000));
+        }
+    }
     dispose() {
         this.disposed = true;
     }
     async performPoll() {
         try {
-            const result = await this.fetchSnapshot();
-            if (result.notModified || !result.snapshot)
+            await this.stateLoaded;
+            if (this.disposed)
                 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)
+            const cache = await this.snapshots.refresh(this.config.pollInterval * 1000, this.config.requestTimeout, (cached) => this.fetchSnapshot(cached));
+            if (this.disposed)
                 return;
-            await this.notifyChanges(previous, result.snapshot);
+            if (cache.snapshot) {
+                if (!this.initialized) {
+                    // A fresh installation starts with the entire current snapshot as its baseline.
+                    for (const event of cache.snapshot.events)
+                        this.markSeen(event);
+                    this.initialized = true;
+                }
+                else {
+                    this.captureChanges(cache.snapshot, Date.now());
+                }
+            }
+            await this.flushPending();
         }
         catch (error) {
             this.ctx.logger('codex-reset').warn(`获取 AIHOT 重置事件失败：${error instanceof Error ? error.message : String(error)}`);
@@ -216,94 +307,224 @@ 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 fetchSnapshot(ignoreEtag = false) {
+    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 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(cache) {
         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.6',
             };
-            if (!ignoreEtag && this.etag && this.snapshot)
-                headers['If-None-Match'] = this.etag;
+            if (cache.etag && cache.snapshot)
+                headers['If-None-Match'] = cache.etag;
             const response = await fetch(this.config.apiUrl, {
                 method: 'GET',
                 headers,
                 signal: controller.signal,
             });
-            if (response.status === 304 && this.snapshot) {
-                return { snapshot: null, etag: this.etag, notModified: true };
+            const maxAgeMs = Math.max(0, ...Array.from((response.headers.get('cache-control') ?? '').matchAll(/(?:^|[,\s])(?:s-maxage|max-age)=(\d+)/gi), (match) => Number(match[1]) * 1000).filter(Number.isFinite));
+            if (response.status === 304 && cache.snapshot) {
+                return { snapshot: null, etag: response.headers.get('etag') ?? cache.etag, notModified: true, maxAgeMs };
             }
             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.status === 429 || response.status === 503) {
+                const retryAfter = response.headers.get('retry-after');
+                let retryAfterMs = 0;
+                if (retryAfter) {
+                    retryAfterMs = /^\d+$/.test(retryAfter.trim())
+                        ? Number(retryAfter) * 1000
+                        : Date.parse(retryAfter) - Date.now();
+                }
+                try {
+                    const problem = await this.readResponseBody(response);
+                    if (isRecord(problem) && typeof problem.retryAfter === 'number' && Number.isFinite(problem.retryAfter)) {
+                        retryAfterMs = Math.max(Number.isFinite(retryAfterMs) ? retryAfterMs : 0, problem.retryAfter * 1000);
+                    }
+                }
+                catch {
+                    // An HTML or malformed error body must still honor Retry-After.
+                }
+                retryAfterMs = Math.max(cache_1.MIN_POLL_INTERVAL_MS, Number.isFinite(retryAfterMs) ? retryAfterMs : 0);
+                throw new cache_1.SnapshotRequestError(`HTTP ${response.status}，至少等待 ${Math.ceil(retryAfterMs / 1000)} 秒后重试`, retryAfterMs);
             }
-            const body = await response.json();
+            if (!response.ok)
+                throw new Error(`HTTP ${response.status}`);
+            const body = await this.readResponseBody(response);
             if (!isSnapshot(body))
                 throw new Error('响应格式不符合 Codex 重置 API v1');
             return {
                 snapshot: body,
                 etag: response.headers.get('etag'),
                 notModified: false,
+                maxAgeMs,
             };
         }
         finally {
             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;
+    async readResponseBody(response) {
+        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');
             }
-            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);
+            chunks.push(value);
         }
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
     }
 }
 function apply(ctx, config) {
+    (0, cache_1.extendCacheModel)(ctx);
     const monitor = new CodexResetMonitor(ctx, config);
-    ctx.on('ready', () => {
-        void monitor.poll();
-        ctx.setInterval(() => void monitor.poll(), config.pollInterval * 1000);
-    });
+    ctx.on('ready', () => monitor.start());
     ctx.on('dispose', () => monitor.dispose());
     ctx.command('codex.probability', '分析 Codex 重置事件的历史概率')
         .alias('重置概率')
@@ -321,6 +542,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 +567,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 +585,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 +606,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.6",
   "description": "Monitor AIHOT Codex reset events and notify Koishi channels.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -44,6 +44,7 @@
     }
   },
   "devDependencies": {
+    "@minatojs/driver-sqlite": "4.7.0",
     "@types/node": "^22.0.0",
     "koishi": "^4.18.9",
     "typescript": "^5.7.0"