koishi-plugin-anime-schedule 1.1.2 → 1.1.3

package/lib/data/anilist-match.js

@@ -59,7 +59,11 @@ function matchByTitle(target, candidates) {
             continue;
         const startMs = startMsOf(candidate);
         const dayGap = startMs !== null && beginMs !== null ? Math.abs(startMs - beginMs) / DAY : null;
-        if (dayGap !== null && dayGap > exports.MAX_DAY_GAP)
+        // 标题相等只说明是同一部作品，不能排除同名续作；首播日期缺失时无法校验，直接放弃，
+        // 否则「第 2 期」这类同名条目会被错配到前一季。
+        if (dayGap === null)
+            continue;
+        if (dayGap > exports.MAX_DAY_GAP)
             continue;
         const nodes = (candidate.airingSchedule?.nodes ?? []).filter((node) => typeof node.airingAt === 'number');
         const first = nodes.length

package/lib/handlers.js

@@ -380,13 +380,9 @@ async function commandSubList(deps, session) {
         const upcoming = await digest.upcomingAirings(tids, 31);
         // `upcomingAirings` 会滤掉已播完的作品，故单独查询一次用于标注「已播完」
         const finished = new Set(await digest.finishedSubscriptionTids(tids));
-        const names = new Map();
+        const names = await digest.resolveSubscriptionNames(tids);
         const nextOf = new Map();
         const todayOf = new Map();
-        for (const row of rows) {
-            const resolved = await digest.resolveSubscriptionName(row.tid);
-            names.set(row.tid, resolved ?? row.title ?? row.tid);
-        }
         for (const item of upcoming) {
             if (!nextOf.has(item.tid))
                 nextOf.set(item.tid, item);
@@ -508,7 +504,8 @@ async function commandSubClear(deps, session) {
 /** 查询订阅作品未来若干天的播出计划 */
 async function commandNext(deps, session, daysText) {
     const { config, digest } = deps;
-    const days = (0, utils_1.clamp)(Number.parseInt(daysText ?? '7', 10) || 7, 1, 31);
+    const parsed = Number.parseInt(daysText ?? '7', 10);
+    const days = (0, utils_1.clamp)(Number.isFinite(parsed) ? parsed : 7, 1, 31);
     try {
         const rows = await digest.listSubscriptions(platformOf(session), channelOf(session));
         if (!rows.length)
@@ -545,7 +542,7 @@ function commandOff(deps, session, kindText) {
     return togglePush(deps, session, kindText, false);
 }
 async function togglePush(deps, session, kindText, enabled) {
-    const { config, digest } = deps;
+    const { ctx, config, digest } = deps;
     if (!session.guildId)
         return constants_1.RESPONSES.needGuild;
     const raw = (kindText ?? '').trim().toLowerCase();
@@ -569,6 +566,13 @@ async function togglePush(deps, session, kindText, enabled) {
                 enabled: true,
             });
         }
+        else if (existing.botId !== session.selfId || existing.guildId !== session.guildId) {
+            // 机器人换号或频道迁移后，开播提醒要能找到当前机器人；顺手刷新归属信息
+            await ctx.database.set('anime_channel', {
+                platform: platformOf(session),
+                channelId: channelOf(session),
+            }, { botId: session.selfId, guildId: session.guildId });
+        }
         await digest.setKinds(platformOf(session), channelOf(session), kind === 'daily' ? { dailyEnabled: enabled }
             : kind === 'night' ? { nightEnabled: enabled }
                 : kind === 'weekly' ? { weeklyEnabled: enabled }
@@ -592,11 +596,13 @@ async function commandStatus(deps, session) {
     try {
         const channel = await digest.getChannel(platformOf(session), channelOf(session));
         const subscriptions = await digest.listSubscriptions(platformOf(session), channelOf(session));
+        const dayStart = (0, time_1.getDayStartMs)((0, time_1.today)(digest.timeZone), digest.timeZone);
+        // 只取今天的记录；以前是全量取回再在内存里过滤，推送记录攒久后会越来越慢
         const dispatches = await ctx.database.get('anime_dispatch', {
             platform: platformOf(session),
             channelId: channelOf(session),
+            dispatchedAt: { $gte: dayStart, $lt: dayStart + 86400000 },
         });
-        const dayStart = (0, time_1.getDayStartMs)((0, time_1.today)(digest.timeZone), digest.timeZone);
         const formatText = config.output.format === 'image'
             ? `图片 (${config.output.layout === 'list' ? '卡片列表' : '时间表'})`
             : `纯文本${config.output.useForward ? ' (合并转发)' : ''}`;
@@ -611,7 +617,7 @@ async function commandStatus(deps, session) {
             `订阅番剧: ${subscriptions.length} 部${config.subscription.maxPerChannel > 0 ? ` (上限 ${config.subscription.maxPerChannel})` : ''}`,
             `开播提醒: ${config.push.updateReminderEnabled ? `开，提前 ${config.push.updateLookaheadMinutes} 分钟` : '关'}`,
             // 按记录时间统计：`sub`（开播提醒）的去重键里带的是时刻而不是日期，不能靠键判断
-            `今日推送记录: ${dispatches.filter((row) => row.dispatchedAt >= dayStart && row.dispatchedAt < dayStart + 86400000).length} 条`,
+            `今日推送记录: ${dispatches.length} 条`,
         ].join('\n');
     }
     catch (error) {

package/lib/services/airing.d.ts

@@ -44,6 +44,14 @@ export declare class AiringStatusService {
     /** 无需预热（缓存只在内存里），保留此方法让调用方写法统一 */
     ensure(): Promise<void>;
     private isFresh;
+    /**
+     * 标题缓存键。
+     *
+     * 不能只用折叠标题：`normalizeTitle` 会删掉「第 2 期」这类季别，不同季的同名作品
+     * 会命中同一个 ID。把开播日期（取 `beginMs`，缺失时用 `broadcastMs`）按天拼进去，
+     * 同名但不同季/不同年的作品就能区分开。
+     */
+    private titleKey;
     /**
      * 按标题给缺失 `aniList` ID 的条目补一个 ID：补上就用 AniList 的逐話時刻排期，搜不到返回
      * null 让调用方退回周期推算。结果（含「搜不到」）在进程内缓存。

package/lib/services/airing.js

@@ -79,8 +79,22 @@ class AiringStatusService {
     ensure() {
         return Promise.resolve();
     }
-    isFresh(entry, ttlDays) {
-        return Date.now() - entry.cachedAt < ttlDays * 24 * 60 * 60 * 1000;
+    isFresh(entry, ttlDays, now = Date.now()) {
+        return now - entry.cachedAt < Math.max(0, ttlDays) * 24 * 60 * 60 * 1000;
+    }
+    /**
+     * 标题缓存键。
+     *
+     * 不能只用折叠标题：`normalizeTitle` 会删掉「第 2 期」这类季别，不同季的同名作品
+     * 会命中同一个 ID。把开播日期（取 `beginMs`，缺失时用 `broadcastMs`）按天拼进去，
+     * 同名但不同季/不同年的作品就能区分开。
+     */
+    titleKey(target) {
+        const title = (0, anilist_match_1.normalizeTitle)(target.title);
+        if (!title)
+            return '';
+        const anchor = target.beginMs ?? target.broadcastMs ?? null;
+        return anchor === null ? title : `${title}@${Math.floor(anchor / 86400000)}`;
     }
     /**
      * 按标题给缺失 `aniList` ID 的条目补一个 ID：补上就用 AniList 的逐話時刻排期，搜不到返回
@@ -88,7 +102,7 @@ class AiringStatusService {
      * 校验交给 `matchByTitle`：标题相等 + 首播日期相近，缺一不可。
      */
     async resolveByTitle(target) {
-        const key = (0, anilist_match_1.normalizeTitle)(target.title);
+        const key = this.titleKey(target);
         if (!key)
             return null;
         const cached = this.idByTitle.get(key);
@@ -123,7 +137,10 @@ class AiringStatusService {
             return payload?.data?.Page?.media ?? [];
         }
         catch (error) {
-            return this.handleRequestError(error) ? null : [];
+            // 只有「成功响应但没有候选」才是 []；网络/解析失败必须返回 null，
+            // 否则会被 resolveByTitle 当成「确定搜不到」永久写入 idByTitle。
+            this.handleRequestError(error);
+            return null;
         }
     }
     /**
@@ -147,7 +164,7 @@ class AiringStatusService {
             }
             // 过期条目先返回旧值，避免一次请求失败就没有数据可用
             result.set(id, cached);
-            if (!this.isFresh(cached, ttlDays))
+            if (!this.isFresh(cached, ttlDays, now))
                 wanted.push(id);
         }
         if (!wanted.length)

package/lib/services/digest.d.ts

@@ -280,6 +280,8 @@ export declare class DigestService {
      * @param limit 返回条数上限，`<= 0` 表示不限制
      */
     search(keyword: string, limit?: number): Promise<DigestItem[]>;
+    /** 按条目 ID 批量解析作品名；订阅列表一次取完，避免逐条串行请求 */
+    resolveSubscriptionNames(tids: string[]): Promise<Map<string, string | null>>;
     /** 按条目 ID 解析作品名；同时接受 `253104` 与 `bgm:253104` 两种写法 */
     resolveSubscriptionName(tid: string): Promise<string | null>;
 }

package/lib/services/digest.js

@@ -1328,19 +1328,36 @@ class DigestService {
             return this.toItem(candidate, entry.bangumiId !== null ? subjects.get(entry.bangumiId) : undefined);
         });
     }
+    /** 按条目 ID 批量解析作品名；订阅列表一次取完，避免逐条串行请求 */
+    async resolveSubscriptionNames(tids) {
+        await this.prepare();
+        const result = new Map();
+        const entries = new Map();
+        const idByTid = new Map();
+        for (const tid of new Set(tids)) {
+            const matched = BGM_TID_RE.exec(tid) ?? BGM_ID_RE.exec(tid);
+            if (!matched) {
+                result.set(tid, null);
+                continue;
+            }
+            const id = Number(matched[1]);
+            const entry = this.index.bySubjectId(id);
+            if (!entry) {
+                result.set(tid, null);
+                continue;
+            }
+            entries.set(tid, entry);
+            idByTid.set(tid, id);
+        }
+        const subjects = await this.localizer.localizeByIds([...new Set(idByTid.values())], false);
+        for (const [tid, entry] of entries) {
+            result.set(tid, this.toItem({ entry, atMs: this.nextAirMs(entry, Date.now()), episode: 1 }, subjects.get(idByTid.get(tid))).name);
+        }
+        return result;
+    }
     /** 按条目 ID 解析作品名；同时接受 `253104` 与 `bgm:253104` 两种写法 */
     async resolveSubscriptionName(tid) {
-        await this.prepare();
-        const matched = BGM_TID_RE.exec(tid) ?? BGM_ID_RE.exec(tid);
-        if (!matched)
-            return null;
-        const id = Number(matched[1]);
-        const entry = this.index.bySubjectId(id);
-        if (!entry)
-            return null;
-        // 只是为了拿一个展示用的名字，不需要逐集档期
-        const subjects = await this.localizer.localizeByIds([id]);
-        return this.toItem({ entry, atMs: this.nextAirMs(entry, Date.now()), episode: 1 }, subjects.get(id)).name;
+        return (await this.resolveSubscriptionNames([tid])).get(tid) ?? null;
     }
 }
 exports.DigestService = DigestService;

package/lib/services/info.js

@@ -398,10 +398,16 @@ exports.InfoService = InfoService;
 function flattenSummary(summary) {
     if (!summary)
         return '';
-    return summary
+    const lines = summary
         .replace(/\r\n?/g, '\n')
         .split('\n')
         .map((line) => line.trim())
-        .filter(Boolean)
-        .join('');
+        .filter(Boolean);
+    // 中文/日文换行处不需要空格；英文单词在源文本里被折行时则需要补一个，
+    // 否则「the story」会被拼成「thestory」。
+    return lines.reduce((text, line) => {
+        if (!text)
+            return line;
+        return `${text}${/[!-~]$/.test(text) && /^[A-Za-z0-9]/.test(line) ? ' ' : ''}${line}`;
+    }, '');
 }

package/lib/services/localizer.d.ts

@@ -45,6 +45,10 @@ export declare class Localizer {
     private loadPromise;
     private dirty;
     private flushTimer;
+    /** 正在进行的写盘；并发调用共享同一个 Promise，避免两个 tmp 文件互相覆盖 */
+    private flushing;
+    /** 上一次写盘是否失败：失败后不立即重排定时器，避免磁盘故障时每 3 秒刷一条警告 */
+    private writeFailed;
     /** 本次构建里评分过期、等出图之后在后台补取的条目 */
     private readonly pendingScores;
     private refreshingScores;
@@ -54,8 +58,15 @@ export declare class Localizer {
     /** 确保磁盘缓存已读取（重复调用只读一次） */
     ensure(): Promise<void>;
     load(): Promise<void>;
-    /** 把缓存写回磁盘，写入前按时间淘汰最旧的一半 */
+    /**
+     * 把缓存写回磁盘。
+     *
+     * 同一时刻只允许一个写盘：`save()` 与 3 秒防抖可能同时触发，两个写操作会争用同一个
+     * `.tmp` 文件。`dirty` 只在写入成功后才保持 `false`；失败时重新置位，等下一次
+     * `scheduleFlush()` 或 `save()` 再试，避免一次磁盘抖动就让本次更新永久丢失。
+     */
     private flush;
+    private writeCache;
     /** 延迟合并写入，避免每次命中都落盘 */
     private scheduleFlush;
     /** 主动落盘，插件卸载与调度结束后调用 */

package/lib/services/localizer.js

@@ -60,6 +60,10 @@ class Localizer {
     loadPromise = null;
     dirty = false;
     flushTimer = null;
+    /** 正在进行的写盘；并发调用共享同一个 Promise，避免两个 tmp 文件互相覆盖 */
+    flushing = null;
+    /** 上一次写盘是否失败：失败后不立即重排定时器，避免磁盘故障时每 3 秒刷一条警告 */
+    writeFailed = false;
     /** 本次构建里评分过期、等出图之后在后台补取的条目 */
     pendingScores = new Set();
     refreshingScores = false;
@@ -115,10 +119,27 @@ class Localizer {
         })();
         return this.loadPromise;
     }
-    /** 把缓存写回磁盘，写入前按时间淘汰最旧的一半 */
-    async flush() {
+    /**
+     * 把缓存写回磁盘。
+     *
+     * 同一时刻只允许一个写盘：`save()` 与 3 秒防抖可能同时触发，两个写操作会争用同一个
+     * `.tmp` 文件。`dirty` 只在写入成功后才保持 `false`；失败时重新置位，等下一次
+     * `scheduleFlush()` 或 `save()` 再试，避免一次磁盘抖动就让本次更新永久丢失。
+     */
+    flush() {
+        if (this.flushing)
+            return this.flushing;
         if (!this.dirty)
-            return;
+            return Promise.resolve();
+        this.flushing = this.writeCache().finally(() => {
+            this.flushing = null;
+            // 写盘快照之后又有新条目：补一次合并写盘；失败时不自动重排，等下一次 save/schedule
+            if (this.dirty && !this.writeFailed)
+                this.scheduleFlush();
+        });
+        return this.flushing;
+    }
+    async writeCache() {
         this.dirty = false;
         if (this.memory.size > constants_1.LOCALIZE_CACHE_MAX_ENTRIES) {
             const sorted = [...this.memory.entries()].sort((a, b) => a[1].cachedAt - b[1].cachedAt);
@@ -134,8 +155,12 @@ class Localizer {
             await fs_1.promises.mkdir((0, path_1.dirname)(this.cachePath), { recursive: true });
             await fs_1.promises.writeFile(temp, JSON.stringify(payload), 'utf8');
             await fs_1.promises.rename(temp, this.cachePath);
+            this.writeFailed = false;
         }
         catch (error) {
+            // 写入期间可能又有新条目进来；失败后也保持 dirty，交给下一次写盘重试
+            this.dirty = true;
+            this.writeFailed = true;
             this.logger.warn('[localize] 写入本地化缓存失败:', error);
             await fs_1.promises.rm(temp, { force: true }).catch(() => undefined);
         }
@@ -157,6 +182,9 @@ class Localizer {
             this.flushTimer = null;
         }
         await this.flush();
+        // 写盘期间又产生了新条目：等当前写盘结束后再补一次
+        if (this.dirty && !this.flushing)
+            await this.flush();
     }
     /**
      * 标题、封面与首末集日期是否还能用。这几项基本不变，只受 `cacheTtlDays` 管。
@@ -204,8 +232,10 @@ class Localizer {
             result.set(id, cached);
             if (this.needsScoreRefresh(cached))
                 this.pendingScores.add(id);
-            // 只有展示数据过期、或这次要档期而缓存里没有档期时才阻塞构建
-            if (!this.isDisplayFresh(cached) || (wantEpisodeTimes && cached.hasEpisodeTimes === false)) {
+            // 只有展示数据过期、或这次要档期而缓存里没有档期时才阻塞构建。
+            // 404 占位记录带 `hasEpisodeTimes:false`，但它的 TTL 内不该反复重试，由 isDisplayFresh 决定。
+            if (!this.isDisplayFresh(cached)
+                || (wantEpisodeTimes && !cached.missing && cached.hasEpisodeTimes === false)) {
                 wanted.push(id);
                 previous.set(id, cached);
             }
@@ -219,7 +249,7 @@ class Localizer {
             //
             // 已经取过档期的条目**不重复取**——评分每天刷新，而档期是另一笔请求，跟着一起重发
             // 会让请求量凭空翻倍。只有「没取过」或「这次确实缺它」才补。
-            const needsTimes = wantEpisodeTimes && !(stale && stale.hasEpisodeTimes !== false);
+            const needsTimes = wantEpisodeTimes && !(stale && stale.hasEpisodeTimes === true);
             const subject = await this.fetchSubject(id);
             const times = needsTimes && subject && resolveEpisodeTotal(subject)
                 ? await this.fetchEpisodeTimes(id)
@@ -291,17 +321,22 @@ class Localizer {
             const subject = await this.fetchSubject(id);
             if (!subject)
                 return;
+            // fetchSubject 是 await 点：期间 `localizeByIds` 可能刚写入更完整的档期字段。
+            // 这里必须基于「最新的一份」合并，不能拿请求前的快照整体覆盖。
+            const current = this.memory.get(id);
+            if (!current || current.missing || !this.needsScoreRefresh(current))
+                return;
             ok++;
             this.memory.set(id, {
-                ...stale,
+                ...current,
                 title: subject.name_cn?.trim() || subject.name,
                 coverUrl: subject.images?.large ?? subject.images?.common ?? '',
                 score: computeScore(subject.rating),
                 ratingTotal: typeof subject.rating?.total === 'number' ? subject.rating.total : null,
                 totalEpisodes: resolveEpisodeTotal(subject),
-                hasEpisodeTimes: stale.hasEpisodeTimes,
-                firstAirMs: stale.firstAirMs,
-                lastAirMs: stale.lastAirMs,
+                hasEpisodeTimes: current.hasEpisodeTimes,
+                firstAirMs: current.firstAirMs,
+                lastAirMs: current.lastAirMs,
                 cachedAt: Date.now(),
                 scoreCachedAt: Date.now(),
             });

package/lib/services/scheduler.js

@@ -63,7 +63,8 @@ class Scheduler {
         try {
             const due = this.dueKinds(now);
             const reminder = this.config.push.updateReminderEnabled && this.reminderDue(now);
-            // 没有到期的推送就不碰数据库：清理与落盘每天各跑一次即可，否则 tick 每分钟一次 DELETE
+            // 没有到期的推送就不碰数据库：清理与落盘只在真正有推送/提醒的轮次里跑。
+            // 提醒默认每 10 分钟轮询一次，因此缓存落盘与过期记录清理也随之变成约 10 分钟一次。
             if (!due.length && !reminder)
                 return;
             for (const kind of due)
@@ -200,7 +201,9 @@ class Scheduler {
             : kind === 'night' ? 'nightEnabled'
                 : kind === 'weekly' ? 'weeklyEnabled'
                     : 'seasonEnabled';
-        return this.ctx.database.get('anime_channel', { [field]: true });
+        const rows = await this.ctx.database.get('anime_channel', { [field]: true });
+        // `enabled` 是后加的字段，老数据的 null 不能被当成「已关闭」；显式 false 才跳过。
+        return rows.filter((row) => row.enabled !== false);
     }
     /**
      * 订阅作品的开播提醒。场次由周期规则推算，与定时列表推送面向不同时间点，也不受频道的列表

package/lib/utils/index.d.ts

@@ -7,7 +7,7 @@ import type { Logger } from 'koishi';
  * 不展开就只能看到「fetch failed」，无法判断是 DNS、连接超时还是被重置。
  */
 export declare function errorMessage(error: unknown): string;
-/** 读取 HTTP 错误的状态码，取不到时返回 null */
+/** 读取 HTTP 错误的状态码，取不到时返回 null。兼容 `response.status`、直接 `status` 与 `cause` 链 */
 export declare function errorStatus(error: unknown): number | null;
 /**
  * 这个错误是不是「超时」（包括 undici 的连接超时与响应超时）。

package/lib/utils/index.js

@@ -57,13 +57,22 @@ function errorName(error) {
         return String(error.name ?? '');
     return '';
 }
-/** 读取 HTTP 错误的状态码，取不到时返回 null */
+/** 读取 HTTP 错误的状态码，取不到时返回 null。兼容 `response.status`、直接 `status` 与 `cause` 链 */
 function errorStatus(error) {
-    if (!error || typeof error !== 'object')
-        return null;
-    const response = error.response;
-    const status = response?.status;
-    return typeof status === 'number' ? status : null;
+    let current = error;
+    for (let depth = 0; depth < MAX_CAUSE_DEPTH; depth++) {
+        if (!current || typeof current !== 'object')
+            break;
+        const direct = current.status;
+        if (typeof direct === 'number')
+            return direct;
+        const response = current.response;
+        const status = response?.status;
+        if (typeof status === 'number')
+            return status;
+        current = current.cause;
+    }
+    return null;
 }
 /**
  * 这个错误是不是「超时」（包括 undici 的连接超时与响应超时）。

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-anime-schedule",
   "description": "番剧时间表与订阅提醒：提供日 / 周 / 季三表，支持定时推送、指定订阅、搜索和详情展示",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "@napi-rs/canvas": "^1.0.10",
-    "bangumi-data": "^0.3.233"
+    "bangumi-data": "^0.3.234"
   },
   "koishi": {
     "description": {