koishi-plugin-codex-reset 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 lumia1998
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,57 @@
+# koishi-plugin-codex-reset
+
+监控 [AIHOT Codex 重置 API](https://aihot.news/api/v1/codex-resets) 的 Koishi 插件。
+
+## 功能
+
+- 定时轮询 AIHOT 的 Codex / ChatGPT Work 重置事件快照。
+- 支持推送新的重置预告、已确认的全员重置和重置卡事件。
+- 目标支持平台 + 频道配置，例如 `onebot` + `123456789`。
+- `codex probability` / `重置概率`：基于历史快照计算经验概率。
+- `codex event` / `最近重置`：统计上一次已确认重置距今多少小时。
+- `codex calendar` / `重置日历`：生成本月的 PNG 日历图片，右侧详情固定为命令执行当天。
+- `codex history` / `重置历史`：生成公开重置事件的历史时间线图片。
+- 日历中的 Tibo 头像作为本地资源随插件发布，不依赖用户访问 X 或运行时下载图片。
+
+## 命令
+
+命令目前都不接收额外参数：
+
+- `codex probability`，别名 `重置概率`：读取当前 API 快照，统计历史事件日率，并估算未来 24 小时和 7 天出现公开重置事件的概率。
+- `codex event`，别名 `最近重置`：显示上一次已确认重置发生时间、距今小时数、类型和事件名称。
+- `codex calendar`，别名 `重置日历`：发送本月日历 PNG；右侧详情固定显示命令执行当天（北京时间）的事件。
+- `codex history`，别名 `重置历史`：发送按北京时间排列的历史重置时间线 PNG。
+
+日历和历史时间线命令需要安装并启用 `koishi-plugin-puppeteer`；概率、日历和历史命令都可以在配置中单独关闭。
+
+首次轮询只建立本地基线，不会把 API 返回的历史事件全部推送；后续轮询只处理新增事件或 `announced` → `confirmed` 的状态变化。插件重启后会重新建立基线。
+
+## 安装
+
+```bash
+npm install koishi-plugin-codex-reset
+```
+
+如果需要日历或历史时间线图片，再安装并启用 `koishi-plugin-puppeteer`。不安装 Puppeteer 时，监控、最近重置和概率分析仍然可以使用，图片命令会给出提示。
+
+## 配置
+
+- `监控接口地址`：监控 API 地址，默认 `https://aihot.news/api/v1/codex-resets`。
+- `监控间隔`：轮询间隔，单位为秒，默认 300 秒。
+- `请求超时时间`：单次 API 请求超时时间，单位为毫秒，默认 15000 毫秒。
+- `推送目标`：推送目标表，填写“平台”和“频道或群组 ID”；平台留空会按频道尝试在线 Bot，同一平台/频道只发送一次。
+- `推送重置预告`：是否推送预告。
+- `推送已确认重置`：是否推送已确认的重置/重置卡事件。
+- `艾特全体`：推送通知时是否艾特全体，默认关闭；需要目标平台支持全体艾特。
+- `启用重置概率命令`：是否启用概率命令。
+- `启用重置日历命令`：是否启用日历图片命令。
+- `启用重置历史命令`：是否启用历史时间线图片命令。
+
+API 是只读公开接口，不需要 API Key。插件使用 `ETag` 条件请求，并保留来源链接。请遵守 [AIHOT 公开使用规则](https://aihot.news/terms)：公开可访问不等于自动获得对外商业使用、镜像或转售授权。
+
+## 开发
+
+```bash
+npm install
+npm test
+```

package/lib/calendar.d.ts

@@ -0,0 +1,23 @@
+import type { CodexResetEvent } from './types';
+export declare function getTiboAvatarDataUri(): string;
+export interface CalendarPage {
+    setViewport(options: {
+        width: number;
+        height: number;
+        deviceScaleFactor?: number;
+    }): Promise<void>;
+    setContent(content: string, options?: {
+        waitUntil?: string;
+        timeout?: number;
+    }): Promise<void>;
+    screenshot(options: {
+        type: 'png';
+        fullPage: true;
+    }): Promise<Uint8Array>;
+    close(): Promise<void>;
+}
+export interface CalendarBrowser {
+    page(): Promise<CalendarPage>;
+}
+export declare function renderCalendarHtml(events: CodexResetEvent[], now?: Date): string;
+export declare function renderCalendarImage(browser: CalendarBrowser, events: CodexResetEvent[], now?: Date): Promise<Buffer>;

package/lib/calendar.js

@@ -0,0 +1,300 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTiboAvatarDataUri = getTiboAvatarDataUri;
+exports.renderCalendarHtml = renderCalendarHtml;
+exports.renderCalendarImage = renderCalendarImage;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const MONTH_NAMES = [
+    '一月', '二月', '三月', '四月', '五月', '六月',
+    '七月', '八月', '九月', '十月', '十一月', '十二月',
+];
+const WEEK_NAMES = ['一', '二', '三', '四', '五', '六', '日'];
+const DAY_MS = 24 * 60 * 60 * 1000;
+function getTiboAvatarDataUri() {
+    const candidates = [
+        (0, node_path_1.join)(__dirname, '..', 'resources', 'tibo-avatar.jpg'),
+        (0, node_path_1.join)(process.cwd(), 'resources', 'tibo-avatar.jpg'),
+    ];
+    for (const file of candidates) {
+        if ((0, node_fs_1.existsSync)(file)) {
+            return `data:image/jpeg;base64,${(0, node_fs_1.readFileSync)(file).toString('base64')}`;
+        }
+    }
+    return '';
+}
+const TIBO_AVATAR = getTiboAvatarDataUri();
+function pad(value) {
+    return String(value).padStart(2, '0');
+}
+function dateKey(year, month, day) {
+    return `${year}-${pad(month + 1)}-${pad(day)}`;
+}
+function parseDateKey(value) {
+    const match = value.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+    if (!match)
+        return null;
+    const [, year, month, day] = match.map(Number);
+    const result = new Date(Date.UTC(year, month - 1, day));
+    if (Number.isNaN(result.getTime()))
+        return null;
+    if (result.getUTCFullYear() !== year || result.getUTCMonth() !== month - 1 || result.getUTCDate() !== day)
+        return null;
+    return result;
+}
+function timestampDateKey(value) {
+    if (!value)
+        return null;
+    return value.match(/^(\d{4}-\d{2}-\d{2})/)?.[1] ?? null;
+}
+function beijingDateKey(now) {
+    const parts = new Intl.DateTimeFormat('en-US', {
+        timeZone: 'Asia/Shanghai',
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+    }).formatToParts(now);
+    const values = Object.fromEntries(parts.map((part) => [part.type, part.value]));
+    return `${values.year}-${values.month}-${values.day}`;
+}
+function monthStart(date, offset = 0) {
+    return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + offset, 1));
+}
+function escapeHtml(value) {
+    return value
+        .replaceAll('&', '&')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&#39;');
+}
+function getEventDateRange(event) {
+    if (event.status === 'confirmed' && event.occurredOn)
+        return [event.occurredOn, event.occurredOn];
+    const from = timestampDateKey(event.schedule?.from) ?? timestampDateKey(event.confirmedAt) ?? timestampDateKey(event.createdAt);
+    if (!from)
+        return null;
+    const through = timestampDateKey(event.schedule?.through) ?? from;
+    return [from, through];
+}
+function buildMonthMarks(events, start) {
+    const end = monthStart(start, 1);
+    const marks = new Map();
+    for (const event of events) {
+        const range = getEventDateRange(event);
+        const from = range ? parseDateKey(range[0]) : null;
+        const through = range ? parseDateKey(range[1]) : null;
+        if (!from || !through || through < from)
+            continue;
+        const cursor = new Date(Math.max(start.getTime(), from.getTime()));
+        const last = new Date(Math.min(end.getTime() - DAY_MS, through.getTime()));
+        while (cursor <= last) {
+            const key = dateKey(cursor.getUTCFullYear(), cursor.getUTCMonth(), cursor.getUTCDate());
+            const list = marks.get(key) ?? [];
+            list.push({ event, type: event.type, status: event.status, label: event.label });
+            marks.set(key, list);
+            cursor.setUTCDate(cursor.getUTCDate() + 1);
+        }
+    }
+    return marks;
+}
+function formatDateHeader(value) {
+    const date = parseDateKey(value);
+    if (!date)
+        return { day: value, year: '' };
+    return {
+        day: `${date.getUTCMonth() + 1} 月 ${date.getUTCDate()} 日`,
+        year: String(date.getUTCFullYear()),
+    };
+}
+function formatPublishedAt(value) {
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime()))
+        return '';
+    const parts = new Intl.DateTimeFormat('zh-CN', {
+        timeZone: 'Asia/Shanghai',
+        month: 'numeric',
+        day: 'numeric',
+        hour: '2-digit',
+        minute: '2-digit',
+    }).formatToParts(date);
+    const values = Object.fromEntries(parts.map((part) => [part.type, part.value]));
+    return `${values.month}/${values.day} ${values.hour}:${values.minute} 发布`;
+}
+function renderDayCell(date, month, marks, selectedDate, today) {
+    const key = dateKey(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+    const inMonth = date.getUTCMonth() === month.getUTCMonth();
+    const dayMarks = marks.get(key) ?? [];
+    const classes = ['day'];
+    if (!inMonth)
+        classes.push('outside');
+    if (key === selectedDate)
+        classes.push('selected');
+    if (key === today)
+        classes.push('today');
+    if (dayMarks.some((mark) => mark.type === 'direct_reset'))
+        classes.push('has-reset');
+    if (dayMarks.some((mark) => mark.type === 'reset_credit'))
+        classes.push('has-credit');
+    const labels = dayMarks.map((mark) => `${mark.label}（${mark.status === 'confirmed' ? '已确认' : '预告'}）`).join('、');
+    const marksHtml = dayMarks.slice(0, 2).map((mark) => {
+        const label = mark.type === 'direct_reset' ? '全员重置' : '发重置卡';
+        const className = mark.type === 'direct_reset' ? 'reset-mark' : 'credit-mark';
+        return `<span class="${className}">${label}</span>`;
+    }).join('');
+    return `<div class="${classes.join(' ')}" aria-label="${escapeHtml(labels)}">
+    <span class="number">${date.getUTCDate()}</span>
+    ${key === today ? '<span class="today-dot"></span>' : ''}
+    <div class="marks">${marksHtml}</div>
+  </div>`;
+}
+function renderCalendarGrid(month, marks, selectedDate, today) {
+    const firstDayOffset = (month.getUTCDay() + 6) % 7;
+    const daysInMonth = new Date(Date.UTC(month.getUTCFullYear(), month.getUTCMonth() + 1, 0)).getUTCDate();
+    const cellCount = Math.ceil((firstDayOffset + daysInMonth) / 7) * 7;
+    const firstCell = new Date(Date.UTC(month.getUTCFullYear(), month.getUTCMonth(), 1 - firstDayOffset));
+    const cells = [];
+    for (let index = 0; index < cellCount; index++) {
+        const date = new Date(firstCell.getTime() + index * DAY_MS);
+        cells.push(renderDayCell(date, month, marks, selectedDate, today));
+    }
+    return cells.join('');
+}
+function renderPostCard(event, post) {
+    const text = post.text || post.originalText;
+    const schedule = event.schedule?.label ? `<div class="schedule">原预告：${escapeHtml(event.schedule.label)}</div>` : '';
+    const avatar = TIBO_AVATAR
+        ? `<img class="avatar-image" src="${TIBO_AVATAR}" alt="">`
+        : '<span class="avatar-fallback">T</span>';
+    return `<article class="post-card">
+    <div class="post-head">
+      <div class="avatar">${avatar}</div>
+      <div class="author"><strong>Tibo</strong><span>@thsottiaux</span></div>
+      <time>${escapeHtml(formatPublishedAt(post.publishedAt))}</time>
+    </div>
+    <p class="post-text">${escapeHtml(text)}</p>
+    ${schedule}
+    <div class="post-foot">${escapeHtml(post.stage)}</div>
+  </article>`;
+}
+function renderDetails(selectedDate, marks) {
+    const header = formatDateHeader(selectedDate);
+    const selectedEvents = [...new Map((marks.get(selectedDate) ?? []).map((mark) => [mark.event.id, mark.event])).values()];
+    const groups = selectedEvents.map((event) => {
+        const status = event.status === 'confirmed' ? '已重置' : '待确认';
+        const statusClass = event.status === 'confirmed' ? 'confirmed-state' : 'announced-state';
+        const posts = event.posts.slice(0, 3).map((post) => renderPostCard(event, post)).join('');
+        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>
+      ${posts || '<div class="post-card empty-post">暂无来源帖子内容</div>'}
+    </section>`;
+    }).join('');
+    return `<aside class="details-pane">
+    <div class="details-header"><h2>${header.day}</h2><span>${header.year}</span></div>
+    <div class="details-body">${groups || '<div class="empty-state">这一天没有记录</div>'}</div>
+  </aside>`;
+}
+function renderCalendarHtml(events, now = new Date()) {
+    const today = beijingDateKey(now);
+    const todayDate = parseDateKey(today) ?? new Date();
+    const month = monthStart(todayDate);
+    const marks = buildMonthMarks(events, month);
+    // A static image has no interactive selection. The detail pane always represents
+    // the Beijing calendar date on which the command was invoked.
+    const selectedDate = today;
+    const monthEvents = [...new Map([...marks.values()].flat().map((mark) => [mark.event.id, mark.event])).values()];
+    const resetCount = monthEvents.filter((event) => event.type === 'direct_reset').length;
+    const creditCount = monthEvents.filter((event) => event.type === 'reset_credit').length;
+    const monthLabel = `${month.getUTCFullYear()} 年 ${MONTH_NAMES[month.getUTCMonth()]}`;
+    return `<!doctype html>
+<html lang="zh-CN">
+<head>
+  <meta charset="utf-8">
+  <style>
+    * { box-sizing: border-box; }
+    body { margin: 0; padding: 16px; background: #f5f6f4; color: #25313a; font-family: Inter, "Microsoft YaHei", "Noto Sans CJK SC", sans-serif; }
+    .calendar-card { width: 1248px; min-height: 578px; display: grid; grid-template-columns: 1.46fr 1fr; overflow: hidden; border: 1px solid #d2dadd; border-radius: 14px; background: #fff; }
+    .calendar-pane { padding: 30px 24px 22px; }
+    .calendar-header { display: flex; justify-content: space-between; align-items: flex-start; padding: 0 0 18px; }
+    .calendar-header h1 { margin: 0; font-size: 23px; line-height: 1.3; letter-spacing: .2px; }
+    .month-summary { margin-top: 20px; color: #617079; font-size: 12px; }
+    .calendar-nav { display: flex; align-items: center; gap: 22px; padding-top: 3px; color: #617079; font-size: 11px; }
+    .calendar-nav .arrow { color: #617079; font-size: 20px; font-weight: 300; line-height: 1; }
+    .weekday-row, .calendar-grid { display: grid; grid-template-columns: repeat(7, 1fr); gap: 4px; }
+    .weekday-row { margin-bottom: 6px; color: #65737b; font-size: 12px; text-align: center; }
+    .weekday-row span { padding: 8px 0; }
+    .calendar-grid { grid-auto-rows: 70px; }
+    .day { position: relative; min-width: 0; padding: 11px 12px 7px; border: 1px solid transparent; border-radius: 10px; background: #fafafa; }
+    .day.outside { color: #adb6b9; background: #fcfcfc; }
+    .day.selected { border-color: #147487; background: #edf7f6; box-shadow: inset 0 0 0 1px rgba(20, 116, 135, .12); }
+    .day.has-reset { background: #eef6f2; }
+    .day.has-credit { background: #f7f3ec; }
+    .day.selected.has-reset, .day.selected.has-credit { background: #e8f3f2; }
+    .number { display: inline-block; font-size: 14px; line-height: 1; }
+    .outside .number { color: #aeb7ba; }
+    .today-dot { position: absolute; top: 11px; right: 13px; width: 4px; height: 4px; border-radius: 50%; background: #147487; }
+    .marks { display: flex; flex-direction: column; gap: 2px; margin-top: 12px; overflow: hidden; }
+    .marks span { overflow: hidden; color: #347465; font-size: 9px; line-height: 1.2; text-overflow: ellipsis; white-space: nowrap; }
+    .marks .credit-mark { color: #967044; }
+    .outside .marks span { color: #b6d0c9; }
+    .outside .marks .credit-mark { color: #cbbda6; }
+    .calendar-note { margin-top: 18px; color: #617079; font-size: 11px; }
+    .details-pane { min-width: 0; padding: 26px 24px 20px; border-left: 1px solid #d9dfe0; }
+    .details-header { display: flex; justify-content: space-between; align-items: center; padding: 0 0 17px; border-bottom: 1px solid #d9dfe0; }
+    .details-header h2 { margin: 0; font-size: 18px; }
+    .details-header span { color: #65737b; font-size: 11px; }
+    .details-body { padding-top: 18px; }
+    .event-group + .event-group { margin-top: 22px; }
+    .event-state { display: flex; align-items: center; gap: 7px; margin-bottom: 12px; font-size: 11px; font-weight: 700; }
+    .confirmed-state { color: #29735f; }
+    .announced-state { color: #98713d; }
+    .state-icon { font-size: 16px; font-weight: 500; }
+    .event-group h2 { margin: 0 0 16px; font-size: 18px; line-height: 1.35; }
+    .post-card { margin-bottom: 12px; padding: 16px; border: 1px solid #d2dadd; border-radius: 13px; background: #fff; }
+    .post-head { display: flex; align-items: center; min-width: 0; }
+    .avatar { display: grid; flex: 0 0 auto; width: 36px; height: 36px; place-items: center; overflow: hidden; border-radius: 50%; background: linear-gradient(145deg, #a57954, #d3aa7d); color: #fff; font-size: 18px; font-weight: 700; }
+    .avatar-image { display: block; width: 100%; height: 100%; object-fit: cover; }
+    .avatar-fallback { display: block; }
+    .author { display: flex; flex-direction: column; margin-left: 9px; line-height: 1.25; }
+    .author strong { font-size: 13px; }
+    .author span { color: #6f7d83; font-size: 10px; }
+    .post-head time { margin-left: auto; color: #6f7d83; font-size: 10px; }
+    .post-text { margin: 14px 0 10px; color: #27343c; font-size: 14px; line-height: 1.65; }
+    .schedule { margin: 0 0 10px; color: #08768b; font-size: 11px; }
+    .post-foot { color: #6f7d83; font-size: 10px; }
+    .empty-state, .empty-post { color: #7a888d; font-size: 13px; text-align: center; }
+    .empty-state { padding: 56px 0; }
+    .empty-post { padding: 24px 12px; }
+  </style>
+</head>
+<body>
+  <main class="calendar-card">
+    <section class="calendar-pane">
+      <header class="calendar-header">
+        <div><h1>${monthLabel}</h1><div class="month-summary">本月：${resetCount} 条全员重置&nbsp;&nbsp;·&nbsp;&nbsp;${creditCount} 张重置卡</div></div>
+        <div class="calendar-nav"><span>回到最近</span><span class="arrow">‹</span><span class="arrow">›</span></div>
+      </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>
+    </section>
+    ${renderDetails(selectedDate, marks)}
+  </main>
+</body>
+</html>`;
+}
+async function renderCalendarImage(browser, events, now = new Date()) {
+    let page = null;
+    try {
+        page = await browser.page();
+        await page.setViewport({ width: 1280, height: 620, deviceScaleFactor: 1 });
+        await page.setContent(renderCalendarHtml(events, now), { waitUntil: 'domcontentloaded', timeout: 15000 });
+        const image = await page.screenshot({ type: 'png', fullPage: true });
+        return Buffer.from(image);
+    }
+    finally {
+        if (page)
+            await page.close();
+    }
+}

package/lib/history.d.ts

@@ -0,0 +1,4 @@
+import type { CodexResetEvent } from './types';
+import { CalendarBrowser } from './calendar';
+export declare function renderHistoryHtml(events: CodexResetEvent[], now?: Date): string;
+export declare function renderHistoryImage(browser: CalendarBrowser, events: CodexResetEvent[], now?: Date): Promise<Buffer>;

package/lib/history.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderHistoryHtml = renderHistoryHtml;
+exports.renderHistoryImage = renderHistoryImage;
+const calendar_1 = require("./calendar");
+function escapeHtml(value) {
+    return value
+        .replaceAll('&', '&')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&#39;');
+}
+function parseTimestamp(value) {
+    if (!value)
+        return null;
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp) ? timestamp : null;
+}
+function eventTimestamp(event) {
+    const values = [
+        event.confirmedAt,
+        event.occurredOn ? `${event.occurredOn}T12:00:00+08:00` : null,
+        event.schedule?.from,
+        event.createdAt,
+    ];
+    for (const value of values) {
+        const timestamp = parseTimestamp(value);
+        if (timestamp !== null)
+            return timestamp;
+    }
+    return 0;
+}
+function dateLabel(timestamp) {
+    const parts = new Intl.DateTimeFormat('zh-CN', {
+        timeZone: 'Asia/Shanghai',
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+    }).formatToParts(new Date(timestamp));
+    const values = Object.fromEntries(parts.map((part) => [part.type, part.value]));
+    return `${Number(values.year)}年${Number(values.month)}月${Number(values.day)}日`;
+}
+function timeLabel(timestamp) {
+    return new Intl.DateTimeFormat('zh-CN', {
+        timeZone: 'Asia/Shanghai',
+        hour: '2-digit',
+        minute: '2-digit',
+        hour12: false,
+    }).format(new Date(timestamp));
+}
+function formatGeneratedAt(now) {
+    return new Intl.DateTimeFormat('zh-CN', {
+        timeZone: 'Asia/Shanghai',
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        hour12: false,
+    }).format(now);
+}
+function typeLabel(event) {
+    return event.type === 'direct_reset' ? '全员重置' : '重置卡';
+}
+function statusLabel(event) {
+    return event.status === 'confirmed' ? '已确认' : '预告';
+}
+function renderPostPreview(event) {
+    const post = event.posts[0];
+    if (!post)
+        return '<div class="post-preview empty">暂无来源帖子内容</div>';
+    const text = post.text || post.originalText;
+    const avatar = (0, calendar_1.getTiboAvatarDataUri)()
+        ? `<img class="avatar-image" src="${(0, calendar_1.getTiboAvatarDataUri)()}" alt="">`
+        : '<span class="avatar-fallback">T</span>';
+    return `<div class="post-preview">
+    <div class="post-head">
+      <div class="avatar">${avatar}</div>
+      <div class="author"><strong>Tibo</strong><span>@thsottiaux</span></div>
+      <time>${escapeHtml(timeLabel(parseTimestamp(post.publishedAt) ?? eventTimestamp(event)))} 发布</time>
+    </div>
+    <p>${escapeHtml(text)}</p>
+  </div>`;
+}
+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>` : '';
+    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>
+      ${schedule}
+      ${renderPostPreview(event)}
+    </div>
+  </article>`;
+}
+function renderHistoryHtml(events, now = new Date()) {
+    const sorted = [...events].sort((a, b) => eventTimestamp(b) - eventTimestamp(a));
+    const confirmed = events.filter((event) => event.status === 'confirmed');
+    const directResetCount = confirmed.filter((event) => event.type === 'direct_reset').length;
+    const resetCreditCount = confirmed.filter((event) => event.type === 'reset_credit').length;
+    const announcedCount = events.filter((event) => event.status === 'announced').length;
+    const firstTimestamp = sorted.at(-1) ? eventTimestamp(sorted.at(-1)) : now.getTime();
+    const lastTimestamp = sorted[0] ? eventTimestamp(sorted[0]) : now.getTime();
+    const period = `${dateLabel(firstTimestamp)} 至 ${dateLabel(lastTimestamp)}`;
+    return `<!doctype html>
+<html lang="zh-CN">
+<head>
+  <meta charset="utf-8">
+  <style>
+    * { box-sizing: border-box; }
+    html, body { margin: 0; padding: 0; background: #f4f6f5; color: #27343c; font-family: "Microsoft YaHei", "Noto Sans CJK SC", Arial, sans-serif; }
+    body { padding: 24px; }
+    .history-shell { max-width: 1280px; margin: 0 auto; padding: 28px 30px 34px; border: 1px solid #d2dadd; border-radius: 16px; background: #fff; }
+    .page-header { display: flex; align-items: flex-start; justify-content: space-between; padding-bottom: 20px; border-bottom: 1px solid #e0e5e6; }
+    .eyebrow { color: #08768b; font-size: 12px; letter-spacing: .08em; }
+    h1 { margin: 7px 0 8px; font-size: 28px; line-height: 1.2; }
+    .subtitle { margin: 0; color: #6f7d83; font-size: 13px; }
+    .generated { color: #6f7d83; font-size: 11px; text-align: right; line-height: 1.6; }
+    .layout { display: grid; grid-template-columns: minmax(0, 1fr) 286px; gap: 28px; padding-top: 26px; }
+    .timeline { position: relative; }
+    .timeline::before { content: ""; position: absolute; left: 112px; top: 16px; bottom: 16px; width: 1px; background: #cbd7d9; }
+    .timeline-item { position: relative; display: grid; grid-template-columns: 94px 36px minmax(0, 1fr); gap: 0; margin-bottom: 18px; }
+    .timeline-date { padding-top: 17px; padding-right: 14px; text-align: right; line-height: 1.5; }
+    .timeline-date strong { display: block; color: #27343c; font-size: 11px; white-space: nowrap; }
+    .timeline-date span { color: #89969a; font-size: 10px; }
+    .timeline-dot { position: relative; z-index: 1; width: 12px; height: 12px; margin: 22px auto 0; border: 3px solid #fff; border-radius: 50%; background: #08768b; box-shadow: 0 0 0 1px #08768b; }
+    .timeline-dot.announced { background: #b8863b; box-shadow: 0 0 0 1px #b8863b; }
+    .event-card { padding: 15px 17px 16px; border: 1px solid #d2dadd; border-radius: 13px; background: #fff; }
+    .event-meta { display: flex; gap: 7px; align-items: center; margin-bottom: 7px; }
+    .type-label, .status { display: inline-block; padding: 3px 7px; border-radius: 999px; font-size: 10px; }
+    .type-label { color: #08768b; background: #edf7f8; }
+    .status.confirmed { color: #177255; background: #edf8f1; }
+    .status.announced { color: #8b6426; background: #fbf4e6; }
+    .event-card h2 { margin: 0 0 10px; font-size: 17px; line-height: 1.35; }
+    .schedule { margin-bottom: 10px; color: #08768b; font-size: 11px; }
+    .post-preview { padding: 11px 12px; border: 1px solid #e0e5e6; border-radius: 10px; background: #fbfcfc; }
+    .post-preview.empty { color: #89969a; font-size: 12px; }
+    .post-head { display: flex; align-items: center; min-width: 0; }
+    .avatar { display: grid; flex: 0 0 auto; width: 28px; height: 28px; place-items: center; overflow: hidden; border-radius: 50%; background: linear-gradient(145deg, #a57954, #d3aa7d); color: #fff; font-size: 14px; font-weight: 700; }
+    .avatar-image { display: block; width: 100%; height: 100%; object-fit: cover; }
+    .avatar-fallback { display: block; }
+    .author { display: flex; flex-direction: column; margin-left: 8px; line-height: 1.2; }
+    .author strong { font-size: 11px; }
+    .author span { color: #89969a; font-size: 9px; }
+    .post-head time { margin-left: auto; color: #89969a; font-size: 10px; }
+    .post-preview p { margin: 10px 0 0; color: #27343c; font-size: 12px; line-height: 1.55; }
+    .summary { align-self: start; padding: 18px; border: 1px solid #d2dadd; border-radius: 13px; background: #fbfcfc; }
+    .summary h2 { margin: 0 0 15px; font-size: 17px; }
+    .summary-period { margin-bottom: 18px; color: #6f7d83; font-size: 11px; line-height: 1.5; }
+    .stat { display: flex; align-items: baseline; justify-content: space-between; padding: 11px 0; border-top: 1px solid #e0e5e6; }
+    .stat span { color: #6f7d83; font-size: 12px; }
+    .stat strong { color: #27343c; font-size: 22px; }
+    .summary-note { margin: 17px 0 0; color: #89969a; font-size: 10px; line-height: 1.6; }
+    .empty { padding: 54px 0; color: #89969a; text-align: center; }
+  </style>
+</head>
+<body>
+  <main class="history-shell">
+    <header class="page-header">
+      <div><div class="eyebrow">CODEX RESET MONITOR</div><h1>Codex 重置历史</h1><p class="subtitle">按北京时间排列的公开重置事件时间线</p></div>
+      <div class="generated">生成时间<br>${escapeHtml(formatGeneratedAt(now))}</div>
+    </header>
+    <div class="layout">
+      <section class="timeline">
+        ${sorted.length ? sorted.map(renderTimelineItem).join('') : '<div class="empty">暂无历史事件</div>'}
+      </section>
+      <aside class="summary">
+        <h2>历史概览</h2>
+        <div class="summary-period">统计区间<br>${escapeHtml(period)}</div>
+        <div class="stat"><span>事件总数</span><strong>${events.length}</strong></div>
+        <div class="stat"><span>已确认</span><strong>${confirmed.length}</strong></div>
+        <div class="stat"><span>全员重置</span><strong>${directResetCount}</strong></div>
+        <div class="stat"><span>重置卡</span><strong>${resetCreditCount}</strong></div>
+        <div class="stat"><span>待确认预告</span><strong>${announcedCount}</strong></div>
+        <p class="summary-note">数据来自 AIHOT 公开快照。时间线仅展示公开事件，不代表账户一定获得重置。</p>
+      </aside>
+    </div>
+  </main>
+</body>
+</html>`;
+}
+async function renderHistoryImage(browser, events, now = new Date()) {
+    let page = null;
+    try {
+        page = await browser.page();
+        await page.setViewport({ width: 1280, height: 800, deviceScaleFactor: 1 });
+        await page.setContent(renderHistoryHtml(events, now), { waitUntil: 'domcontentloaded', timeout: 15000 });
+        const image = await page.screenshot({ type: 'png', fullPage: true });
+        return Buffer.from(image);
+    }
+    finally {
+        if (page)
+            await page.close();
+    }
+}

package/lib/index.d.ts

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

package/lib/index.js

@@ -0,0 +1,364 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = exports.inject = exports.name = void 0;
+exports.apply = apply;
+const koishi_1 = require("koishi");
+const calendar_1 = require("./calendar");
+const history_1 = require("./history");
+const stats_1 = require("./stats");
+exports.name = 'codex-reset';
+exports.inject = {
+    optional: ['puppeteer'],
+};
+exports.Config = koishi_1.Schema.object({
+    apiUrl: koishi_1.Schema.string()
+        .default('https://aihot.news/api/v1/codex-resets')
+        .description('监控接口地址。通常不需要修改。'),
+    pollInterval: koishi_1.Schema.number()
+        .min(60)
+        .default(300)
+        .description('监控间隔，单位为秒。AIHOT 推荐约 5 分钟轮询一次。'),
+    requestTimeout: koishi_1.Schema.number()
+        .min(5000)
+        .default(15000)
+        .description('请求超时时间，单位为毫秒。'),
+    targets: koishi_1.Schema.array(koishi_1.Schema.object({
+        platform: koishi_1.Schema.string()
+            .default('')
+            .description('平台，例如 onebot、discord。留空时会尝试所有在线 Bot。'),
+        channelId: koishi_1.Schema.string()
+            .required()
+            .description('频道或群组 ID。建议同时填写平台，避免多账号重复发送。'),
+    })).role('table').default([]).description('推送目标列表。'),
+    pushAnnouncements: koishi_1.Schema.boolean()
+        .default(true)
+        .description('发现新的重置预告时推送。'),
+    pushConfirmedResets: koishi_1.Schema.boolean()
+        .default(true)
+        .description('发现重置或重置卡已确认时推送。'),
+    mentionAll: koishi_1.Schema.boolean()
+        .default(false)
+        .description('推送通知时是否艾特全体。需要平台和频道支持全体艾特。'),
+    enableProbabilityCommand: koishi_1.Schema.boolean()
+        .default(true)
+        .description('启用 codex-reset.probability（别名：重置概率）。'),
+    enableCalendarCommand: koishi_1.Schema.boolean()
+        .default(true)
+        .description('启用日历图片命令，需要 Puppeteer 服务生成 PNG。'),
+    enableHistoryCommand: koishi_1.Schema.boolean()
+        .default(true)
+        .description('启用历史时间线图片命令，需要 Puppeteer 服务生成 PNG。'),
+}).i18n({
+    'zh-CN': {
+        apiUrl: '监控接口地址',
+        pollInterval: '监控间隔',
+        requestTimeout: '请求超时时间',
+        targets: {
+            $description: '推送目标',
+            platform: '平台',
+            channelId: '频道或群组 ID',
+        },
+        pushAnnouncements: '推送重置预告',
+        pushConfirmedResets: '推送已确认重置',
+        mentionAll: '艾特全体',
+        enableProbabilityCommand: '启用重置概率命令',
+        enableCalendarCommand: '启用重置日历命令',
+        enableHistoryCommand: '启用重置历史命令',
+    },
+});
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isDateTime(value) {
+    return typeof value === 'string' && Number.isFinite(Date.parse(value));
+}
+function isDateKey(value) {
+    if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value))
+        return false;
+    const [year, month, day] = value.split('-').map(Number);
+    const date = new Date(Date.UTC(year, month - 1, day));
+    return date.getUTCFullYear() === year
+        && date.getUTCMonth() === month - 1
+        && date.getUTCDate() === day;
+}
+function isResetEvent(value) {
+    if (!isRecord(value))
+        return false;
+    if (typeof value.id !== 'string' || typeof value.label !== 'string' || typeof value.title !== 'string' || typeof value.scope !== 'string')
+        return false;
+    if (value.type !== 'direct_reset' && value.type !== 'reset_credit')
+        return false;
+    if (value.status !== 'announced' && value.status !== 'confirmed')
+        return false;
+    if (value.confirmationBasis !== null && value.confirmationBasis !== 'source_post' && value.confirmationBasis !== 'receipt_review')
+        return false;
+    if (typeof value.url !== 'string')
+        return false;
+    if (!isDateTime(value.createdAt) || !isDateTime(value.updatedAt))
+        return false;
+    if (value.confirmedAt !== null && !isDateTime(value.confirmedAt))
+        return false;
+    if (value.occurredOn !== null && !isDateKey(value.occurredOn))
+        return false;
+    if (value.schedule !== null) {
+        if (!isRecord(value.schedule)
+            || !['exact', 'approximate', 'deadline', 'date', 'window'].includes(String(value.schedule.precision))
+            || !isDateTime(value.schedule.from)
+            || !isDateTime(value.schedule.through)
+            || typeof value.schedule.label !== 'string')
+            return false;
+    }
+    if (!Array.isArray(value.posts))
+        return false;
+    return value.posts.every((post) => {
+        if (!isRecord(post))
+            return false;
+        return typeof post.id === 'string'
+            && isDateTime(post.publishedAt)
+            && typeof post.stage === 'string'
+            && typeof post.text === 'string'
+            && typeof post.originalText === 'string'
+            && typeof post.url === 'string';
+    });
+}
+function isSnapshot(value) {
+    if (!isRecord(value))
+        return false;
+    return value.schemaVersion === 1
+        && value.timezone === 'Asia/Shanghai'
+        && isDateTime(value.historyFrom)
+        && typeof value.count === 'number'
+        && (value.checkedAt === null || isDateTime(value.checkedAt))
+        && Array.isArray(value.events)
+        && value.events.every(isResetEvent);
+}
+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}` : '';
+    return `${kind}${status}${scope}${schedule}${source}`;
+}
+async function sendToTargets(ctx, targets, content) {
+    let sent = 0;
+    const sentBindings = new Set();
+    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))
+                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)}`);
+            }
+        }
+    }
+    return sent;
+}
+class CodexResetMonitor {
+    ctx;
+    config;
+    snapshot = null;
+    etag = null;
+    pollPromise = null;
+    disposed = false;
+    constructor(ctx, config) {
+        this.ctx = ctx;
+        this.config = config;
+    }
+    get currentSnapshot() {
+        return this.snapshot;
+    }
+    get hasPuppeteer() {
+        return Boolean(this.ctx.puppeteer);
+    }
+    async ensureSnapshot() {
+        if (!this.snapshot)
+            await this.poll();
+        return this.snapshot;
+    }
+    async poll() {
+        if (this.disposed)
+            return;
+        if (this.pollPromise)
+            return this.pollPromise;
+        this.pollPromise = this.performPoll();
+        try {
+            await this.pollPromise;
+        }
+        finally {
+            this.pollPromise = null;
+        }
+    }
+    dispose() {
+        this.disposed = true;
+    }
+    async performPoll() {
+        try {
+            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);
+        }
+        catch (error) {
+            this.ctx.logger('codex-reset').warn(`获取 AIHOT 重置事件失败：${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async createCalendarImage() {
+        const snapshot = await this.ensureSnapshot();
+        const browser = this.ctx.puppeteer;
+        if (!snapshot || !browser)
+            return null;
+        return (0, calendar_1.renderCalendarImage)(browser, snapshot.events);
+    }
+    async createHistoryImage() {
+        const snapshot = await this.ensureSnapshot();
+        const browser = this.ctx.puppeteer;
+        if (!snapshot || !browser)
+            return null;
+        return (0, history_1.renderHistoryImage)(browser, snapshot.events);
+    }
+    async fetchSnapshot(ignoreEtag = false) {
+        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.0',
+            };
+            if (!ignoreEtag && this.etag && this.snapshot)
+                headers['If-None-Match'] = this.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 };
+            }
+            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}` : ''}`);
+            }
+            const body = await response.json();
+            if (!isSnapshot(body))
+                throw new Error('响应格式不符合 Codex 重置 API v1');
+            return {
+                snapshot: body,
+                etag: response.headers.get('etag'),
+                notModified: false,
+            };
+        }
+        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;
+            }
+            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);
+    ctx.on('ready', () => {
+        void monitor.poll();
+        ctx.setInterval(() => void monitor.poll(), config.pollInterval * 1000);
+    });
+    ctx.on('dispose', () => monitor.dispose());
+    ctx.command('codex probability', '分析 Codex 重置事件的历史概率')
+        .alias('codex-reset.probability')
+        .alias('重置概率')
+        .action(async () => {
+        if (!config.enableProbabilityCommand)
+            return '重置概率命令已关闭。';
+        const snapshot = await monitor.ensureSnapshot();
+        if (!snapshot)
+            return '暂时无法获取 Codex 重置事件数据，请稍后再试。';
+        return (0, stats_1.formatProbability)((0, stats_1.analyzeProbability)(snapshot));
+    });
+    ctx.command('codex event', '查看上一次 Codex 重置距今多久')
+        .alias('codex-reset.event')
+        .alias('最近重置')
+        .action(async () => {
+        const snapshot = await monitor.ensureSnapshot();
+        if (!snapshot)
+            return '暂时无法获取 Codex 重置事件数据，请稍后再试。';
+        return (0, stats_1.formatLatestReset)(snapshot);
+    });
+    ctx.command('codex calendar', '发送本月的 Codex 重置日历图片')
+        .alias('codex-reset.calendar')
+        .alias('重置日历')
+        .action(async () => {
+        if (!config.enableCalendarCommand)
+            return '重置日历命令已关闭。';
+        if (!monitor.hasPuppeteer)
+            return '发送日历图片需要先安装并启用 koishi-plugin-puppeteer。';
+        try {
+            const image = await monitor.createCalendarImage();
+            if (!image)
+                return '暂时无法生成日历图片，请稍后再试。';
+            return koishi_1.h.image(image, 'image/png');
+        }
+        catch (error) {
+            ctx.logger('codex-reset').warn(`生成日历图片失败：${error instanceof Error ? error.message : String(error)}`);
+            return '日历图片生成失败，请检查 Puppeteer 服务和中文字体。';
+        }
+    });
+    ctx.command('codex history', '发送 Codex 重置历史时间线图片')
+        .alias('codex-reset.history')
+        .alias('重置历史')
+        .action(async () => {
+        if (!config.enableHistoryCommand)
+            return '重置历史命令已关闭。';
+        if (!monitor.hasPuppeteer)
+            return '发送历史时间线图片需要先安装并启用 koishi-plugin-puppeteer。';
+        try {
+            const image = await monitor.createHistoryImage();
+            if (!image)
+                return '暂时无法生成历史时间线图片，请稍后再试。';
+            return koishi_1.h.image(image, 'image/png');
+        }
+        catch (error) {
+            ctx.logger('codex-reset').warn(`生成历史时间线图片失败：${error instanceof Error ? error.message : String(error)}`);
+            return '历史时间线图片生成失败，请检查 Puppeteer 服务和中文字体。';
+        }
+    });
+}

package/lib/stats.d.ts

@@ -0,0 +1,26 @@
+import type { CodexResetEvent, CodexResetsResponse } from './types';
+export interface ProbabilitySummary {
+    confirmedCount: number;
+    directResetCount: number;
+    resetCreditCount: number;
+    announcedCount: number;
+    activeDays: number;
+    observedDays: number;
+    dailyEventDayRate: number;
+    next24hProbability: number;
+    next7dProbability: number;
+    lastConfirmedDate: string | null;
+}
+export interface LatestResetSummary {
+    event: CodexResetEvent;
+    timestamp: number;
+    approximate: boolean;
+}
+export declare function findLatestConfirmedReset(response: CodexResetsResponse, now?: Date): LatestResetSummary | null;
+export declare function formatLatestReset(response: CodexResetsResponse, now?: Date): string;
+/**
+ * Estimate event-day probabilities from the public historical snapshot.
+ * This is deliberately an empirical Poisson estimate, not an official forecast.
+ */
+export declare function analyzeProbability(response: CodexResetsResponse, now?: Date): ProbabilitySummary;
+export declare function formatProbability(summary: ProbabilitySummary): string;

package/lib/stats.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findLatestConfirmedReset = findLatestConfirmedReset;
+exports.formatLatestReset = formatLatestReset;
+exports.analyzeProbability = analyzeProbability;
+exports.formatProbability = formatProbability;
+const DAY_MS = 24 * 60 * 60 * 1000;
+function dateKeyFromTimestamp(value) {
+    if (!value)
+        return null;
+    const match = value.match(/^(\d{4}-\d{2}-\d{2})/);
+    return match?.[1] ?? null;
+}
+function validDateKey(value) {
+    if (!value || !/^\d{4}-\d{2}-\d{2}$/.test(value))
+        return false;
+    const [year, month, day] = value.split('-').map(Number);
+    const date = new Date(Date.UTC(year, month - 1, day));
+    return date.getUTCFullYear() === year
+        && date.getUTCMonth() === month - 1
+        && date.getUTCDate() === day;
+}
+function normalizedDateKey(value) {
+    return validDateKey(value) ? value : null;
+}
+function eventDateKey(event) {
+    return normalizedDateKey(event.occurredOn)
+        ?? normalizedDateKey(dateKeyFromTimestamp(event.confirmedAt))
+        ?? normalizedDateKey(dateKeyFromTimestamp(event.schedule?.from))
+        ?? normalizedDateKey(dateKeyFromTimestamp(event.createdAt));
+}
+function parseTimestamp(value) {
+    if (!value)
+        return null;
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp) ? timestamp : null;
+}
+function dateKeyTimestamp(value) {
+    const timestamp = Date.parse(`${value}T00:00:00+08:00`);
+    return Number.isFinite(timestamp) ? timestamp : null;
+}
+function inclusiveDays(start, end) {
+    const startTime = parseTimestamp(start);
+    const endTime = parseTimestamp(end);
+    if (startTime === null || endTime === null || endTime < startTime)
+        return 1;
+    return Math.max(1, Math.floor((endTime - startTime) / DAY_MS) + 1);
+}
+function percentage(value) {
+    if (!Number.isFinite(value))
+        return '—';
+    if (value < 0.01)
+        return '<1%';
+    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 };
+    }
+    for (const value of [event.schedule?.from, event.createdAt]) {
+        const timestamp = parseTimestamp(value);
+        if (timestamp !== null)
+            return { timestamp, approximate: true };
+    }
+    return null;
+}
+function findLatestConfirmedReset(response, now = new Date()) {
+    const nowTimestamp = now.getTime();
+    return response.events
+        .filter((event) => event.status === 'confirmed')
+        .map((event) => {
+        const value = eventTimestamp(event);
+        return value ? { event, ...value } : null;
+    })
+        .filter((value) => value !== null && value.timestamp <= nowTimestamp)
+        .sort((a, b) => b.timestamp - a.timestamp)[0] ?? null;
+}
+function formatLatestReset(response, now = new Date()) {
+    const latest = findLatestConfirmedReset(response, now);
+    if (!latest)
+        return '暂时没有已确认的 Codex 重置事件。';
+    const elapsedHours = Math.max(0, (now.getTime() - latest.timestamp) / (60 * 60 * 1000));
+    const elapsed = elapsedHours < 1
+        ? `约 ${Math.max(1, Math.round(elapsedHours * 60))} 分钟前`
+        : `约 ${Math.round(elapsedHours * 10) / 10} 小时前`;
+    const date = new Intl.DateTimeFormat('zh-CN', {
+        timeZone: 'Asia/Shanghai',
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        hour12: false,
+    }).format(new Date(latest.timestamp));
+    const type = latest.event.type === 'direct_reset' ? '全员重置' : '重置卡';
+    const approximate = latest.approximate ? '（时间按公开日期估算）' : '';
+    return [
+        '最近一次 Codex 重置',
+        `上一次重置：${elapsed}${approximate}`,
+        `发生时间：${date}（北京时间）`,
+        `类型：${type}`,
+        `事件：${latest.event.title}`,
+    ].join('\n');
+}
+/**
+ * Estimate event-day probabilities from the public historical snapshot.
+ * This is deliberately an empirical Poisson estimate, not an official forecast.
+ */
+function analyzeProbability(response, now = new Date()) {
+    const historyStart = parseTimestamp(response.historyFrom) ?? Number.NEGATIVE_INFINITY;
+    const nowTimestamp = now.getTime();
+    const confirmed = response.events.filter((event) => {
+        if (event.status !== 'confirmed')
+            return false;
+        const date = eventDateKey(event);
+        const timestamp = date ? dateKeyTimestamp(date) : null;
+        return timestamp !== null && timestamp >= historyStart && timestamp <= nowTimestamp;
+    });
+    const announcedCount = response.events.filter((event) => event.status === 'announced').length;
+    const activeDates = new Set(confirmed.map(eventDateKey).filter((value) => Boolean(value)));
+    const latest = now.toISOString();
+    const observedDays = inclusiveDays(response.historyFrom, latest);
+    const dailyEventDayRate = activeDates.size / observedDays;
+    return {
+        confirmedCount: confirmed.length,
+        directResetCount: confirmed.filter((event) => event.type === 'direct_reset').length,
+        resetCreditCount: confirmed.filter((event) => event.type === 'reset_credit').length,
+        announcedCount,
+        activeDays: activeDates.size,
+        observedDays,
+        dailyEventDayRate,
+        next24hProbability: 1 - Math.exp(-dailyEventDayRate),
+        next7dProbability: 1 - Math.exp(-dailyEventDayRate * 7),
+        lastConfirmedDate: [...activeDates].sort().at(-1) ?? null,
+    };
+}
+function formatProbability(summary) {
+    const lines = [
+        'Codex 重置事件概率分析（历史统计）',
+        `样本：${summary.observedDays} 天，已确认事件 ${summary.confirmedCount} 条，发生过事件的日期 ${summary.activeDays} 天。`,
+        `其中：全员重置 ${summary.directResetCount} 条，重置卡 ${summary.resetCreditCount} 条，待确认预告 ${summary.announcedCount} 条。`,
+    ];
+    if (summary.confirmedCount === 0 || summary.activeDays === 0) {
+        lines.push('有效样本不足，暂时无法估算概率。');
+    }
+    else {
+        lines.push(`历史事件日率：${(summary.dailyEventDayRate * 100).toFixed(2)}%/天。`);
+        lines.push(`未来 24 小时至少出现一个公开重置事件的粗略概率：${percentage(summary.next24hProbability)}。`);
+        lines.push(`未来 7 天至少出现一个公开重置事件的粗略概率：${percentage(summary.next7dProbability)}。`);
+        lines.push(`最近确认日期：${summary.lastConfirmedDate ?? '未知'}。`);
+    }
+    lines.push('说明：这是基于 AIHOT 当前历史快照的经验估计，不是官方预测，也不代表你的账户一定会获得重置。');
+    return lines.join('\n');
+}

package/lib/types.d.ts

@@ -0,0 +1,56 @@
+export type ResetEventType = 'direct_reset' | 'reset_credit';
+export type ResetEventStatus = 'announced' | 'confirmed';
+export interface ResetSchedule {
+    precision: 'exact' | 'approximate' | 'deadline' | 'date' | 'window';
+    from: string;
+    through: string;
+    label: string;
+}
+export interface ResetPost {
+    id: string;
+    publishedAt: string;
+    stage: string;
+    text: string;
+    originalText: string;
+    url: string;
+}
+export interface CodexResetEvent {
+    id: string;
+    type: ResetEventType;
+    label: string;
+    status: ResetEventStatus;
+    title: string;
+    scope: string;
+    createdAt: string;
+    updatedAt: string;
+    confirmedAt: string | null;
+    occurredOn: string | null;
+    confirmationBasis: 'source_post' | 'receipt_review' | null;
+    schedule: ResetSchedule | null;
+    posts: ResetPost[];
+    url: string;
+}
+export interface CodexResetsResponse {
+    schemaVersion: 1;
+    timezone: 'Asia/Shanghai';
+    checkedAt: string | null;
+    historyFrom: string;
+    count: number;
+    events: CodexResetEvent[];
+}
+export interface TargetConfig {
+    platform: string;
+    channelId: string;
+}
+export interface Config {
+    apiUrl: string;
+    pollInterval: number;
+    requestTimeout: number;
+    targets: TargetConfig[];
+    pushAnnouncements: boolean;
+    pushConfirmedResets: boolean;
+    mentionAll: boolean;
+    enableProbabilityCommand: boolean;
+    enableCalendarCommand: boolean;
+    enableHistoryCommand: boolean;
+}

package/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "koishi-plugin-codex-reset",
+  "version": "0.1.0",
+  "description": "Monitor AIHOT Codex reset events and notify Koishi channels.",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "resources",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "koishi",
+    "koishi-plugin",
+    "codex",
+    "openai",
+    "reset"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lumia1998/koishi-plugin-codex-reset.git"
+  },
+  "homepage": "https://github.com/lumia1998/koishi-plugin-codex-reset#readme",
+  "bugs": {
+    "url": "https://github.com/lumia1998/koishi-plugin-codex-reset/issues"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "test": "npm run build && node --test tests/*.test.cjs"
+  },
+  "peerDependencies": {
+    "koishi": ">=4.18.0",
+    "koishi-plugin-puppeteer": "*"
+  },
+  "peerDependenciesMeta": {
+    "koishi-plugin-puppeteer": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "koishi": "^4.18.9",
+    "typescript": "^5.7.0"
+  }
+}