koishi-plugin-hhs-huatu 1.3.13 → 1.3.14

package/lib/index.js

@@ -1352,7 +1352,6 @@ var Config = import_koishi2.Schema.intersect([
     ]).description("点数模式").default("periodic"),
     pointsDefault: import_koishi2.Schema.number().description("会员默认初始点数").default(200),
     pointsRefreshCycleDays: import_koishi2.Schema.number().description("刷新周期（天数），默认每30天刷新一次").default(30).min(1).max(365),
-    pointsRefreshCheckTime: import_koishi2.Schema.string().description("每天检查并执行刷新的时刻（HH:MM，24小时制，本地时区）。实际刷新发生在「周期到期后的第一个该时刻」。").default("00:05"),
     pointsRefreshAmount: import_koishi2.Schema.number().description("每次刷新恢复的点数").default(200),
     pointsRefreshIncludeNonMember: import_koishi2.Schema.boolean().description("刷新范围是否包括非会员").default(false)
   }).description("点数控制设置"),
@@ -1934,7 +1933,6 @@ __name(formatOpusQuota, "formatOpusQuota");
 // src/membershipSystem.ts
 var MIN_TIER = 1;
 var MAX_TIER = 5;
-var POINTS_REFRESH_TOLERANCE = 1e3;
 var MembershipSystem = class {
   constructor(ctx, config) {
     this.ctx = ctx;
@@ -1944,15 +1942,13 @@ var MembershipSystem = class {
     this.loadUserDataFromDB();
     this.setupCleanupTask();
     this.setupReminderTask();
-    this.setupPointsRefreshTask();
-    ctx.accept(["membershipEnabled", "memberCleanupEnabled", "memberCleanupTime", "memberExpiryReminderEnabled", "memberReminderTime", "memberReminderHours", "pointsEnabled", "pointsMode", "pointsRefreshCycleDays", "pointsRefreshCheckTime"], () => {
+    ctx.accept(["membershipEnabled", "memberCleanupEnabled", "memberCleanupTime", "memberExpiryReminderEnabled", "memberReminderTime", "memberReminderHours"], () => {
       ctx.logger.info("会员系统配置已更新，重新安排定时任务");
       if (this.config.membershipEnabled && Object.keys(this.userData).length === 0) {
         this.loadUserDataFromDB().catch((err) => this.ctx.logger.error("动态加载用户数据失败", err));
       }
       this.setupCleanupTask();
       this.setupReminderTask();
-      this.setupPointsRefreshTask();
     });
   }
   static {
@@ -1965,14 +1961,9 @@ var MembershipSystem = class {
   // 定时任务取消函数
   cleanupTimerDispose = null;
   reminderTimerDispose = null;
-  pointsRefreshTimerDispose = null;
-  // 点数刷新的周期锚点：上次刷新**计划**的检查点（永远对齐到每日检查时刻）；0 表示尚未初始化。
-  // 周期 = 锚点 + pointsRefreshCycleDays，因此周期天然对齐检查点、不会因手动刷新或补刷而漂移。
-  pointsRefreshAnchor = 0;
-  // 上次点数刷新的**实际**执行时刻（事实记录）：手动刷新、停机补刷时可能与锚点不同。
-  pointsRefreshLastActualAt = 0;
-  // 库中记录仍是旧语义（lastUsed = 实际刷新时刻），加载后需要回写一次
-  pointsRefreshStateNeedsMigration = false;
+  // 上一版本的全局刷新时间，仅用于迁移旧数据
+  legacyPointsRefreshTime = 0;
+  pointsRefreshLocks = /* @__PURE__ */ new Map();
   // 确保导入文件夹存在
   ensureImportDir() {
     try {
@@ -2000,6 +1991,8 @@ var MembershipSystem = class {
       dailyLimit: "unsigned",
       lastDrawTime: "unsigned",
       points: "integer",
+      pointsRefreshAt: "unsigned",
+      pointsLastRefreshedAt: "unsigned",
       nai5DailyUsage: "unsigned",
       nai5Bucket: "unsigned",
       nai5BucketDay: "unsigned",
@@ -2030,10 +2023,7 @@ var MembershipSystem = class {
       let loadedCount = 0;
       for (const row of rows) {
         if (row.visitorId === "_system_points_refresh") {
-          const actualAt = row.lastUsed || 0;
-          this.pointsRefreshAnchor = actualAt > 0 ? this.alignToCheck(actualAt - POINTS_REFRESH_TOLERANCE) : 0;
-          this.pointsRefreshLastActualAt = row.lastDrawTime || actualAt || 0;
-          this.pointsRefreshStateNeedsMigration = (row.lastUsed || 0) !== this.pointsRefreshAnchor || (row.lastDrawTime || 0) !== this.pointsRefreshLastActualAt;
+          this.legacyPointsRefreshTime = row.lastUsed || 0;
           continue;
         }
         loadedCount++;
@@ -2045,6 +2035,8 @@ var MembershipSystem = class {
           dailyLimit: row.dailyLimit,
           lastDrawTime: row.lastDrawTime,
           points: row.points,
+          pointsRefreshAt: row.pointsRefreshAt || 0,
+          pointsLastRefreshedAt: row.pointsLastRefreshedAt || 0,
           nai5DailyUsage: row.nai5DailyUsage || 0,
           nai5Bucket: row.nai5Bucket || 0,
           nai5BucketDay: row.nai5BucketDay || 0,
@@ -2054,19 +2046,7 @@ var MembershipSystem = class {
       this.ctx.logger.info(`会员系统数据从数据库加载成功，共 ${loadedCount} 条记录`);
       await this.loadCardsFromDB();
       await this.migrateLegacyMembers();
-      try {
-        await this.checkAndCatchUpPointsRefresh();
-      } catch (err) {
-        this.ctx.logger.error("点数刷新补刷失败", err);
-      }
-      if (this.config.pointsEnabled && this.config.pointsMode === "periodic") {
-        if (this.pointsRefreshStateNeedsMigration) {
-          await this.savePointsRefreshState();
-          this.pointsRefreshStateNeedsMigration = false;
-          this.ctx.logger.info(`点数刷新状态已迁移为周期锚点制：锚点 ${this.formatRefreshAnchor()}，上次实际刷新 ${this.formatLastRefreshTime()}`);
-        }
-        this.ctx.logger.info(`点数刷新计划：周期锚点 ${this.formatRefreshAnchor()}，上次实际刷新 ${this.formatLastRefreshTime()}，下次刷新 ${this.formatNextRefreshTime()}（${this.getDaysUntilNextRefresh()} 天后）`);
-      }
+      await this.migratePointsRefreshPlans();
     } catch (err) {
       this.ctx.logger.error("从数据库加载会员系统数据失败", err);
     }
@@ -2115,7 +2095,24 @@ var MembershipSystem = class {
       this.ctx.logger.info(`会员等级迁移完成：已为 ${migrated} 位存量会员生成 Lv1 会员卡`);
     }
   }
-  // 将指定用户的所有卡同步到数据库（先删后建，卡数量小，简单可靠）
+  /**
+   * 将旧版全局刷新时间迁移为用户级刷新计划。
+   * 迁移只补字段，不改变当前点数、会员卡或使用记录。
+   */
+  async migratePointsRefreshPlans() {
+    if (!this.legacyPointsRefreshTime || this.config.pointsMode !== "periodic") return;
+    const cycleMs = (this.config.pointsRefreshCycleDays || 30) * 24 * 60 * 60 * 1e3;
+    let changed = false;
+    for (const userId in this.userData) {
+      const user = this.userData[userId];
+      const tier = this.computeActiveTier(user.cards || []);
+      const isInScope = tier > 0 || this.config.pointsRefreshIncludeNonMember;
+      if (!isInScope || user.pointsRefreshAt) continue;
+      user.pointsRefreshAt = this.legacyPointsRefreshTime + cycleMs;
+      changed = true;
+    }
+    if (changed) await this.saveUserData();
+  }
   async syncCardsToDB(userId) {
     try {
       const user = this.userData[userId];
@@ -2155,25 +2152,9 @@ var MembershipSystem = class {
       this.ctx.logger.error("批量保存会员卡数据失败", err);
     }
   }
-  // 保存点数刷新状态（周期锚点 + 上次实际刷新时刻）到元数据行
-  async savePointsRefreshState() {
-    try {
-      await this.ctx.database.upsert("hhs_huatu_user", [{
-        visitorId: "_system_points_refresh",
-        isMember: false,
-        membershipExpiry: 0,
-        dailyUsage: 0,
-        // lastUsed 在该行语义 = 周期锚点（对齐到检查点）
-        lastUsed: this.pointsRefreshAnchor,
-        dailyLimit: 0,
-        // lastDrawTime 在该行语义 = 上次实际刷新时刻
-        lastDrawTime: this.pointsRefreshLastActualAt,
-        points: 0,
-        nai5DailyUsage: 0
-      }], ["visitorId"]);
-    } catch (err) {
-      this.ctx.logger.error("保存点数刷新状态失败", err);
-    }
+  /** 旧版全局刷新记录仅保留用于读取迁移，不再写入。 */
+  async saveLastPointsRefreshTime() {
+    return;
   }
   // 将单个用户数据同步到数据库
   async syncUserToDB(userId) {
@@ -2189,6 +2170,8 @@ var MembershipSystem = class {
         dailyLimit: user.dailyLimit,
         lastDrawTime: user.lastDrawTime || 0,
         points: user.points || 0,
+        pointsRefreshAt: user.pointsRefreshAt || 0,
+        pointsLastRefreshedAt: user.pointsLastRefreshedAt || 0,
         nai5DailyUsage: user.nai5DailyUsage || 0,
         nai5Bucket: user.nai5Bucket || 0,
         nai5BucketDay: user.nai5BucketDay || 0,
@@ -2214,6 +2197,8 @@ var MembershipSystem = class {
           dailyLimit: user.dailyLimit,
           lastDrawTime: user.lastDrawTime || 0,
           points: user.points || 0,
+          pointsRefreshAt: user.pointsRefreshAt || 0,
+          pointsLastRefreshedAt: user.pointsLastRefreshedAt || 0,
           nai5DailyUsage: user.nai5DailyUsage || 0,
           nai5Bucket: user.nai5Bucket || 0,
           nai5BucketDay: user.nai5BucketDay || 0,
@@ -2385,6 +2370,7 @@ var MembershipSystem = class {
         if (this.config.pointsMode === "periodic") {
           const refreshAmount = this.getTierBenefit(safeTier).pointsRefresh;
           user.points = refreshAmount;
+          user.pointsRefreshAt = now + (this.config.pointsRefreshCycleDays || 30) * 24 * 60 * 60 * 1e3;
           this.ctx.logger.info(`[会员系统] 用户 ${userId} 首次成为 Lv${safeTier} 会员，点数已初始化为 ${refreshAmount}`);
         } else if (!user.points) {
           user.points = this.config.pointsDefault || 200;
@@ -2510,6 +2496,7 @@ var MembershipSystem = class {
   async deductPoints(userId, amount) {
     if (!this.config.pointsEnabled || amount <= 0) return 0;
     this.ensureUserData(userId);
+    await this.ensurePointsFresh(userId);
     const user = this.userData[userId];
     const currentPoints = user.points || 0;
     if (currentPoints < amount) {
@@ -2525,6 +2512,7 @@ var MembershipSystem = class {
   async refundPoints(userId, amount) {
     if (!this.config.pointsEnabled || amount <= 0) return;
     this.ensureUserData(userId);
+    await this.ensurePointsFresh(userId);
     const user = this.userData[userId];
     user.points = (user.points || 0) + amount;
     await this.syncUserToDB(userId);
@@ -2547,6 +2535,7 @@ var MembershipSystem = class {
     let updatedCount = 0;
     const now = Date.now();
     for (const userId in this.userData) {
+      await this.ensurePointsFresh(userId);
       const user = this.userData[userId];
       if (membersOnly && (!user.isMember || user.membershipExpiry < now)) {
         continue;
@@ -2565,245 +2554,70 @@ var MembershipSystem = class {
     const message = updatedCount > 0 ? `✅ 成功为 ${updatedCount} 位用户${action} ${Math.abs(amount)} 点数` : `⚠️ 没有符合条件的用户`;
     return { count: updatedCount, message };
   }
-  /**
-   * 刷新点数（定期任务 / 手动触发）。
-   * 等级制度下按刷新时刻的生效等级取刷新量：Lv1 = pointsRefreshAmount，Lv2-Lv5 = 各档 pointsRefresh；
-   * 非会员若在刷新范围内，刷为 Lv1 档值（与现有行为一致）。
-   * @param tierFilter 指定生效等级时仅刷新该等级会员；缺省刷新全部范围
-   */
+  /** 确保用户在读取或扣除点数前完成到期的惰性刷新。 */
+  async ensurePointsFresh(userId) {
+    if (!this.config.pointsEnabled || this.config.pointsMode !== "periodic") return;
+    this.ensureUserData(userId);
+    const running = this.pointsRefreshLocks.get(userId);
+    if (running) return running;
+    const task = this.refreshUserPointsIfDue(userId).finally(() => {
+      if (this.pointsRefreshLocks.get(userId) === task) this.pointsRefreshLocks.delete(userId);
+    });
+    this.pointsRefreshLocks.set(userId, task);
+    return task;
+  }
+  async refreshUserPointsIfDue(userId) {
+    const user = this.userData[userId];
+    const now = Date.now();
+    const cycleMs = (this.config.pointsRefreshCycleDays || 30) * 24 * 60 * 60 * 1e3;
+    const tier = this.getActiveTier(userId);
+    const inScope = tier > 0 || this.config.pointsRefreshIncludeNonMember;
+    if (!user.pointsRefreshAt) {
+      if (!inScope) return;
+      user.pointsRefreshAt = now + cycleMs;
+      await this.syncUserToDB(userId);
+      return;
+    }
+    if (user.pointsRefreshAt > now || !inScope) return;
+    const plannedAt = user.pointsRefreshAt;
+    user.points = this.getTierBenefit(tier > 0 ? tier : 1).pointsRefresh;
+    user.pointsLastRefreshedAt = now;
+    do {
+      user.pointsRefreshAt += cycleMs;
+    } while (user.pointsRefreshAt <= now);
+    await this.syncUserToDB(userId);
+    this.ctx.logger.info(`[会员系统] 用户 ${userId} 惰性刷新点数：${plannedAt} → ${user.pointsRefreshAt}`);
+  }
+  /** 手动刷新点数，不改变用户自动刷新计划。 */
   async refreshPoints(tierFilter) {
     if (!this.config.pointsEnabled || this.config.pointsMode !== "periodic") {
       return { count: 0, message: "点数刷新未启用或不是周期模式" };
     }
     let refreshedCount = 0;
-    const now = Date.now();
     for (const userId in this.userData) {
-      const user = this.userData[userId];
-      let tier = this.computeActiveTier(user.cards || []);
-      if (tier > 1 && this.config.tierEnabled === false) tier = 1;
-      const isActive = tier > 0;
-      if (!this.config.pointsRefreshIncludeNonMember && !isActive) {
-        continue;
-      }
+      const tier = this.getActiveTier(userId);
+      if (tier <= 0 && !this.config.pointsRefreshIncludeNonMember) continue;
       if (tierFilter !== void 0 && tier !== tierFilter) continue;
+      await this.ensurePointsFresh(userId);
+      const user = this.userData[userId];
       user.points = this.getTierBenefit(tier > 0 ? tier : 1).pointsRefresh;
+      await this.syncUserToDB(userId);
       refreshedCount++;
     }
-    this.pointsRefreshLastActualAt = now;
-    await this.savePointsRefreshState();
-    if (refreshedCount > 0) {
-      await this.saveUserData();
-    }
     const scope = tierFilter !== void 0 ? `Lv${tierFilter} 会员` : "用户";
-    const message = refreshedCount > 0 ? `✅ 点数刷新完成，共刷新 ${refreshedCount} 位${scope}的点数（按各自生效等级）` : "⚠️ 没有符合条件的用户需要刷新点数";
+    const message = refreshedCount > 0 ? `✅ 已手动刷新 ${refreshedCount} 位${scope}的点数，自动刷新计划未改变` : "⚠️ 没有符合条件的用户需要刷新点数";
     this.ctx.logger.info(message);
     return { count: refreshedCount, message };
   }
-  // ========== 点数刷新：权威时刻推导（展示与执行共用，避免两套口径） ==========
-  /** 周期毫秒数 */
-  getPointsRefreshCycleMs() {
-    return (this.config.pointsRefreshCycleDays || 30) * 24 * 60 * 60 * 1e3;
-  }
-  /** 每日检查时刻（HH:MM，默认 00:05）；配置非法时回落 00:05 */
-  getCheckTimeParts() {
-    const raw = String(this.config.pointsRefreshCheckTime || "00:05").trim();
-    const m = raw.match(/^(\d{1,2}):(\d{1,2})$/);
-    if (!m) return { hour: 0, minute: 5 };
-    const hour = Number(m[1]);
-    const minute = Number(m[2]);
-    if (!Number.isInteger(hour) || !Number.isInteger(minute) || hour < 0 || hour > 23 || minute < 0 || minute > 59) {
-      return { hour: 0, minute: 5 };
-    }
-    return { hour, minute };
-  }
-  /** 指定日期（本地时区）的检查点时刻 */
-  checkPointOfDay(timestamp) {
-    const { hour, minute } = this.getCheckTimeParts();
-    const d = new Date(timestamp);
-    return new Date(d.getFullYear(), d.getMonth(), d.getDate(), hour, minute, 0, 0).getTime();
-  }
-  /** 首个 ≥ timestamp 的检查点 */
-  alignToCheck(timestamp) {
-    const check = this.checkPointOfDay(timestamp);
-    return check < timestamp ? check + 24 * 60 * 60 * 1e3 : check;
-  }
-  /** 最近一个 ≤ timestamp 的检查点 */
-  lastCheckPointAtOrBefore(timestamp) {
-    const check = this.checkPointOfDay(timestamp);
-    return check > timestamp ? check - 24 * 60 * 60 * 1e3 : check;
-  }
-  /**
-   * 下次刷新的**计划**时刻（毫秒）；0 表示尚未初始化（首次运行，将在下一个检查点刷新）。
-   * 计划时刻可能已经过去（例如停机漏检、或运维把锚点设到了过去），此时由 isPointsRefreshOverdue() 反映。
-   */
-  getPointsRefreshPlan() {
-    if (this.pointsRefreshAnchor === 0) return 0;
-    return this.alignToCheck(this.pointsRefreshAnchor + this.getPointsRefreshCycleMs());
-  }
-  /**
-   * 下次刷新**实际**会发生的时刻（毫秒时间戳）；-1 表示未启用周期刷新。
-   * 展示（会员 -u / 会员调试 -s）与执行判定都以这里为准：
-   * - 尚未初始化（锚点 0）→ 下一个检查点（首次刷新）
-   * - 计划时刻还没到 → 计划时刻
-   * - 计划已过（停机漏检 / 手动把锚点设到过去）→ 下一个检查点（届时会补刷）
-   */
-  getNextRefreshTime() {
+  getNextPointsRefreshAt(userId) {
     if (!this.config.pointsEnabled || this.config.pointsMode !== "periodic") return -1;
-    const now = Date.now();
-    const plan = this.getPointsRefreshPlan();
-    if (plan === 0) return this.alignToCheck(now);
-    return plan <= now + POINTS_REFRESH_TOLERANCE ? this.alignToCheck(now + POINTS_REFRESH_TOLERANCE) : plan;
-  }
-  /** 是否已逾期（计划刷新时刻已过但尚未刷新）：仅在停机漏检或手动把锚点设到过去时成立 */
-  isPointsRefreshOverdue() {
-    const plan = this.getPointsRefreshPlan();
-    if (plan === 0) return false;
-    return Date.now() + POINTS_REFRESH_TOLERANCE >= plan;
-  }
-  // 把时间戳格式化为本地时区的 YYYY-MM-DD HH:mm（不依赖 locale，输出稳定）
-  formatTimeValue(timestamp) {
-    const d = new Date(timestamp);
-    const p = /* @__PURE__ */ __name((n) => String(n).padStart(2, "0"), "p");
-    return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
-  }
-  /** 下次刷新时刻的展示文本（如 2026-11-05 00:05）；未启用周期刷新时返回空串 */
-  formatNextRefreshTime() {
-    const t = this.getNextRefreshTime();
-    return t < 0 ? "" : this.formatTimeValue(t);
-  }
-  /** 上次**实际**刷新时刻的展示文本；从未刷新过时返回「尚未记录」 */
-  formatLastRefreshTime() {
-    return this.pointsRefreshLastActualAt === 0 ? "尚未记录" : this.formatTimeValue(this.pointsRefreshLastActualAt);
-  }
-  /** 周期锚点的展示文本；尚未初始化时返回「尚未初始化」 */
-  formatRefreshAnchor() {
-    return this.pointsRefreshAnchor === 0 ? "尚未初始化" : this.formatTimeValue(this.pointsRefreshAnchor);
-  }
-  /** 下次刷新**计划**时刻的展示文本（可能已过去）；尚未初始化时返回「尚未初始化」 */
-  formatRefreshPlanTime() {
-    const plan = this.getPointsRefreshPlan();
-    return plan === 0 ? "尚未初始化" : this.formatTimeValue(plan);
-  }
-  /** 距离下次刷新的天数（用于「N 天后」文案） */
-  getDaysUntilNextRefresh() {
-    const next = this.getNextRefreshTime();
-    if (next < 0) return -1;
-    return Math.max(0, Math.ceil((next - Date.now()) / (24 * 60 * 60 * 1e3)));
-  }
-  /**
-   * 刷新完成后推进周期锚点：锚点 = 本次刷新所属的检查点（取本次刷新时刻附近的检查点），
-   * 而不是"实际执行时刻"。因此：
-   * - 正常在检查点触发 → 锚点就是该检查点，周期保持对齐；
-   * - 停机补刷（白天启动）→ 锚点仍是当天的检查点，周期不会漂移到白天；
-   * - 定时器早/晚几十毫秒触发 → 仍归到同一个检查点，不会退/进一天。
-   */
-  advanceAnchorAfterRefresh() {
-    this.pointsRefreshAnchor = this.lastCheckPointAtOrBefore(Date.now() + POINTS_REFRESH_TOLERANCE);
-  }
-  /**
-   * 停机漏检补刷（S1）：启动加载完成后若计划时刻已过（说明实例在检查点离线），立即补刷一次，
-   * 并把锚点推进到"本次补刷所属的检查点"。返回是否执行了补刷。
-   */
-  async checkAndCatchUpPointsRefresh() {
-    if (!this.config.membershipEnabled || !this.config.pointsEnabled || this.config.pointsMode !== "periodic") return false;
-    if (!this.isPointsRefreshOverdue()) return false;
-    const plan = this.getPointsRefreshPlan();
-    this.ctx.logger.info(`检测到点数刷新计划已逾期（计划 ${this.formatTimeValue(plan)}，当前 ${this.formatTimeValue(Date.now())}），正在补刷...`);
-    const result = await this.refreshPoints();
-    this.advanceAnchorAfterRefresh();
-    await this.savePointsRefreshState();
-    this.ctx.logger.info(`点数刷新补刷完成：${result.message}；周期锚点推进至 ${this.formatTimeValue(this.pointsRefreshAnchor)}，下次刷新 ${this.formatTimeValue(this.getNextRefreshTime())}`);
-    return true;
-  }
-  // ========== 点数刷新：运维接口（查看 / 设置锚点与计划时刻，均不触发刷新） ==========
-  /** 周期锚点时间戳（0 = 尚未初始化） */
-  getPointsRefreshAnchor() {
-    return this.pointsRefreshAnchor;
-  }
-  /** 下次刷新的计划时刻（可能已过）；0 = 尚未初始化 */
-  getPointsRefreshPlanTime() {
-    return this.getPointsRefreshPlan();
-  }
-  /** 上次实际刷新时刻 */
-  getPointsRefreshLastActualAt() {
-    return this.pointsRefreshLastActualAt;
-  }
-  /**
-   * 解析运维输入的时间：
-   * - `now`：当前时刻
-   * - `+Nd` / `+Nh` / `+Nm`：相对当前时刻 N 天/小时/分钟
-   * - `YYYY-MM-DD`：该日期（dateOnly=true，调用方按"当天的检查点"解释）
-   * - `YYYY-MM-DD HH:mm` / `YYYY-MM-DDTHH:mm`：精确到分
-   * 解析失败返回 null。
-   */
-  parseRefreshTimeInput(input) {
-    const s = String(input ?? "").trim();
-    if (!s) return null;
-    const now = Date.now();
-    if (s === "now" || s === "现在") return { timestamp: now, dateOnly: false };
-    const rel = s.match(/^\+(\d+)([dhm])$/i);
-    if (rel) {
-      const n = Number(rel[1]);
-      const unit = rel[2].toLowerCase();
-      const unitMs = unit === "d" ? 864e5 : unit === "h" ? 36e5 : 6e4;
-      return { timestamp: now + n * unitMs, dateOnly: false };
-    }
-    const abs = s.match(/^(\d{4})-(\d{1,2})-(\d{1,2})(?:[ T](\d{1,2}):(\d{1,2}))?$/);
-    if (abs) {
-      const year = Number(abs[1]);
-      const month = Number(abs[2]);
-      const day = Number(abs[3]);
-      const hour = abs[4] ? Number(abs[4]) : 0;
-      const minute = abs[5] ? Number(abs[5]) : 0;
-      if (month < 1 || month > 12 || day < 1 || day > 31 || hour > 23 || minute > 59) return null;
-      const d = new Date(year, month - 1, day, hour, minute, 0, 0);
-      if (d.getFullYear() !== year || d.getMonth() !== month - 1 || d.getDate() !== day) return null;
-      return { timestamp: d.getTime(), dateOnly: !abs[4] };
-    }
-    return null;
+    return this.userData[userId]?.pointsRefreshAt || 0;
   }
-  /**
-   * 设置周期锚点（不触发刷新）。
-   * - 输入仅日期 → 取该日期的检查点
-   * - 输入含时间 → 取"最近一个 ≤ 该时刻的检查点"
-   */
-  async setPointsRefreshAnchor(input) {
-    if (!this.config.pointsEnabled || this.config.pointsMode !== "periodic") return "❌ 未启用周期刷新，无法设置周期锚点";
-    const parsed = this.parseRefreshTimeInput(input);
-    if (!parsed) return `❌ 时间格式无法识别：${input}（支持 now、+5d、2026-11-01、2026-11-01 00:05）`;
-    const anchor = parsed.dateOnly ? this.checkPointOfDay(parsed.timestamp) : this.lastCheckPointAtOrBefore(parsed.timestamp);
-    this.pointsRefreshAnchor = anchor;
-    await this.savePointsRefreshState();
-    this.ctx.logger.info(`[会员系统] 周期锚点被设置为 ${this.formatTimeValue(anchor)}（输入：${input}）`);
-    const next = this.getNextRefreshTime();
-    return `✅ 周期锚点已设为 ${this.formatTimeValue(anchor)}（已对齐检查点）
-下次刷新：${this.formatTimeValue(next)}（${this.getDaysUntilNextRefresh()}天后）${this.isPointsRefreshOverdue() ? "\n⚠️ 该计划已逾期，将在下一个检查点自动补刷（也可用 -f 立即刷新）" : ""}`;
-  }
-  /** 直接指定下次刷新时刻（不触发刷新）：取"首个 ≥ 该时刻的检查点"，锚点由它反推 */
-  async setPointsRefreshNextAt(input) {
-    if (!this.config.pointsEnabled || this.config.pointsMode !== "periodic") return "❌ 未启用周期刷新，无法设置下次刷新时刻";
-    const parsed = this.parseRefreshTimeInput(input);
-    if (!parsed) return `❌ 时间格式无法识别：${input}（支持 now、+5d、2026-11-01、2026-11-01 00:05）`;
-    const nextAt = parsed.dateOnly ? this.checkPointOfDay(parsed.timestamp) : this.alignToCheck(parsed.timestamp);
-    const anchor = nextAt - this.getPointsRefreshCycleMs();
-    if (anchor <= 0) return "❌ 目标时刻过于久远，无法反推周期锚点";
-    this.pointsRefreshAnchor = anchor;
-    await this.savePointsRefreshState();
-    this.ctx.logger.info(`[会员系统] 下次刷新时刻被设置为 ${this.formatTimeValue(nextAt)}（输入：${input}）`);
-    return `✅ 下次刷新已设为 ${this.formatTimeValue(nextAt)}（周期锚点反推为 ${this.formatTimeValue(anchor)}）
-本次设置不会立即刷新点数，如需立即刷新请加 -f`;
-  }
-  /** 重开一个周期：以当前检查点为锚点（不触发刷新） */
-  async resetPointsRefreshCycle() {
-    if (!this.config.pointsEnabled || this.config.pointsMode !== "periodic") return "❌ 未启用周期刷新，无法重置周期";
-    const anchor = this.lastCheckPointAtOrBefore(Date.now() + POINTS_REFRESH_TOLERANCE);
-    this.pointsRefreshAnchor = anchor;
-    await this.savePointsRefreshState();
-    this.ctx.logger.info(`[会员系统] 周期已重置，锚点 ${this.formatTimeValue(anchor)}`);
-    const next = this.getNextRefreshTime();
-    return `✅ 刷新周期已重置，周期锚点：${this.formatTimeValue(anchor)}
-下次刷新：${this.formatTimeValue(next)}（${this.getDaysUntilNextRefresh()}天后）
-本次操作不会立即刷新点数，如需立即刷新请加 -f`;
+  getDaysUntilNextRefresh(userId) {
+    if (!this.config.pointsEnabled || this.config.pointsMode !== "periodic") return -1;
+    const at = userId ? this.getNextPointsRefreshAt(userId) : 0;
+    if (!at) return 0;
+    return Math.max(0, Math.ceil((at - Date.now()) / (24 * 60 * 60 * 1e3)));
   }
   /**
    * 从 JSON 文件导入数据到数据库。
@@ -3050,39 +2864,7 @@ var MembershipSystem = class {
       scheduleReminder();
     }
   }
-  // 设置点数刷新定时任务（每天在配置的检查时刻检查一次是否需要刷新）
-  setupPointsRefreshTask() {
-    if (this.pointsRefreshTimerDispose) {
-      this.pointsRefreshTimerDispose();
-      this.pointsRefreshTimerDispose = null;
-    }
-    if (this.config.membershipEnabled && this.config.pointsEnabled && this.config.pointsMode === "periodic") {
-      const cycleDays = this.config.pointsRefreshCycleDays || 30;
-      const { hour, minute } = this.getCheckTimeParts();
-      const checkTime = `${String(hour).padStart(2, "0")}:${String(minute).padStart(2, "0")}`;
-      const scheduleDailyCheck = /* @__PURE__ */ __name(() => {
-        const delay = this.getDelayUntilTime(checkTime);
-        this.ctx.logger.info(`点数刷新检查任务已安排，将在 ${new Date(Date.now() + delay).toLocaleString()} 检查（检查时刻 ${checkTime}，刷新周期 ${cycleDays} 天）`);
-        this.pointsRefreshTimerDispose = this.ctx.setTimeout(async () => {
-          const firstRun = this.pointsRefreshAnchor === 0;
-          if (firstRun || this.isPointsRefreshOverdue()) {
-            this.ctx.logger.info(firstRun ? "点数刷新尚未初始化，正在执行首次刷新..." : `已达到刷新周期 (${cycleDays} 天)，正在执行点数刷新...`);
-            await this.refreshPoints();
-            this.advanceAnchorAfterRefresh();
-            await this.savePointsRefreshState();
-            this.ctx.logger.info(`本轮刷新完成，周期锚点 ${this.formatTimeValue(this.pointsRefreshAnchor)}，下次刷新 ${this.formatTimeValue(this.getNextRefreshTime())}`);
-          } else {
-            const remainDays = this.getDaysUntilNextRefresh();
-            if (this.config.debugLog) {
-              this.ctx.logger.info(`点数刷新检查：距离下次刷新还有 ${remainDays} 天（${this.formatTimeValue(this.getNextRefreshTime())}）`);
-            }
-          }
-          scheduleDailyCheck();
-        }, delay);
-      }, "scheduleDailyCheck");
-      scheduleDailyCheck();
-    }
-  }
+  // 点数刷新采用按用户惰性执行，不注册全局定时任务。
   // 给所有有效会员卡增加天数（按卡粒度，每张有效卡独立延长）。
   // @param tierFilter 指定生效等级时仅操作该等级会员；缺省操作全部会员
   async addDaysToAllMembers(days, tierFilter) {
@@ -3124,6 +2906,8 @@ var MembershipSystem = class {
         lastUsed: Date.now(),
         dailyLimit: this.config.nonMemberDailyLimit,
         points: 0,
+        pointsRefreshAt: 0,
+        pointsLastRefreshedAt: 0,
         nai5DailyUsage: 0,
         nai5Bucket: 0,
         nai5BucketDay: 0,
@@ -5482,6 +5266,7 @@ function registerMember(ctx, config, runtime) {
       return "您没有权限设置会员状态";
     }
     membershipSystem.checkAndResetDailyUsage(targetId);
+    await membershipSystem.ensurePointsFresh(targetId);
     if (options2.refreshPoints) {
       if (!config.pointsEnabled) {
         return "点数控制未启用";
@@ -5609,10 +5394,12 @@ nai5/nai5c 今日免费：${benefit.nai5DailyLimit} 次，已用 ${nai5Used} 次
         pointsInfo = `
 点数余额：${points}`;
         if (config.pointsMode === "periodic") {
-          const remainDaysRefresh = membershipSystem.getDaysUntilNextRefresh();
-          if (remainDaysRefresh >= 0) {
+          const refreshAt = membershipSystem.getNextPointsRefreshAt(targetId);
+          const remainDaysRefresh = membershipSystem.getDaysUntilNextRefresh(targetId);
+          if (refreshAt > 0) {
+            const refreshDate = new Date(refreshAt).toLocaleString();
             pointsInfo += `
-下次点数刷新时间：${membershipSystem.formatNextRefreshTime()}（${remainDaysRefresh}天后，Lv${activeTier} 档刷新为 ${benefit.pointsRefresh} 点）`;
+下次点数刷新时间：${refreshDate}（约${remainDaysRefresh}天后，Lv${activeTier} 档刷新为 ${benefit.pointsRefresh} 点）`;
           }
         }
       }
@@ -5625,10 +5412,11 @@ nai5/nai5c 今日免费：${benefit.nai5DailyLimit} 次，已用 ${nai5Used} 次
         pointsInfo = `
 点数余额：${user.points || 0}`;
         if (config.pointsMode === "periodic" && config.pointsRefreshIncludeNonMember) {
-          const remainDaysRefresh = membershipSystem.getDaysUntilNextRefresh();
-          if (remainDaysRefresh >= 0) {
+          const refreshAt = membershipSystem.getNextPointsRefreshAt(targetId);
+          if (refreshAt > 0) {
+            const refreshDate = new Date(refreshAt).toLocaleString();
             pointsInfo += `
-下次点数刷新时间：${membershipSystem.formatNextRefreshTime()}（${remainDaysRefresh}天后）`;
+下次点数刷新时间：${refreshDate}（约${membershipSystem.getDaysUntilNextRefresh(targetId)}天后）`;
           }
         }
       }
@@ -5647,7 +5435,7 @@ nai5/nai5c 今日免费：${benefit.nai5DailyLimit} 次，已用 ${nai5Used} 次
     }
   });
   if (config.memberDebugCommandEnabled) {
-    ctx.command("novelai.member-debug", "会员系统调试指令", { authority: config.memberDebugCommandAuthLv }).alias("会员调试").option("cleanup", "-c 立即执行会员信息清理").option("remind", "-r 立即执行会员到期提醒").option("status", "-s 查看定时任务状态").option("resetUsage", "-u <userId:string> 重置指定用户的使用次数").option("addDaysAll", "-a <days:number> 给会员增加天数（配合 -t 仅操作指定等级）").option("tier", "-t <tier:number> 指定生效等级（Lv1-Lv5），缺省对所有会员操作").option("refreshPoints", "-f 立即执行点数刷新（只补发点数，不改变周期；配合 -t 仅刷新指定等级）").option("setAnchor", '--set-anchor <value:string> 设置周期锚点（now | +5d | 2026-11-01 | "2026-11-01 00:05"），只重排计划不刷新').option("setNextAt", "--set-next-at <value:string> 直接指定下次刷新时刻（同上格式），只重排计划不刷新").option("resetCycle", "--reset-cycle 以当前检查点为锚点重开一个刷新周期（不刷新点数）").option("addPoints", "--add-points <amount:number> 给会员加点数（配合 -t 仅操作指定等级）").option("subPoints", "--sub-points <amount:number> 给会员减点数（配合 -t 仅操作指定等级）").option("setPoints", "--set-points <value:string> 设置指定用户点数，格式: 用户ID:点数").option("addBucket", "--add-bucket [days:number] 给会员赠送免费次数（发福利：每人按各自档位每日额度 × 天数到账，受 7 天上限约束；配合 -t 指定等级、--bucket-user 指定单人）").option("bucketUser", "--bucket-user <userId:string> 配合 --add-bucket 仅给指定用户赠送").option("setBucket", "--set-bucket <value:string> 设置指定用户免费次数余额，格式: 用户ID:次数").option("importData", "--import 从 JSON 文件导入数据").action(async ({ session, options: options2 }) => {
+    ctx.command("novelai.member-debug", "会员系统调试指令", { authority: config.memberDebugCommandAuthLv }).alias("会员调试").option("cleanup", "-c 立即执行会员信息清理").option("remind", "-r 立即执行会员到期提醒").option("status", "-s 查看定时任务状态").option("resetUsage", "-u <userId:string> 重置指定用户的使用次数").option("addDaysAll", "-a <days:number> 给会员增加天数（配合 -t 仅操作指定等级）").option("tier", "-t <tier:number> 指定生效等级（Lv1-Lv5），缺省对所有会员操作").option("refreshPoints", "-f 立即手动刷新点数（不改变自动刷新计划，配合 -t 仅刷新指定等级）").option("addPoints", "--add-points <amount:number> 给会员加点数（配合 -t 仅操作指定等级）").option("subPoints", "--sub-points <amount:number> 给会员减点数（配合 -t 仅操作指定等级）").option("setPoints", "--set-points <value:string> 设置指定用户点数，格式: 用户ID:点数").option("addBucket", "--add-bucket [days:number] 给会员赠送免费次数（发福利：每人按各自档位每日额度 × 天数到账，受 7 天上限约束；配合 -t 指定等级、--bucket-user 指定单人）").option("bucketUser", "--bucket-user <userId:string> 配合 --add-bucket 仅给指定用户赠送").option("setBucket", "--set-bucket <value:string> 设置指定用户免费次数余额，格式: 用户ID:次数").option("importData", "--import 从 JSON 文件导入数据").action(async ({ session, options: options2 }) => {
       if (!config.membershipEnabled) {
         return "会员系统未启用";
       }
@@ -5819,24 +5607,16 @@ nai5 已使用：${user.nai5DailyUsage || 0} 次` : "";
 `;
           statusMsg += `✅ 点数控制：已启用
 `;
-          statusMsg += `   点数模式：${config.pointsMode === "periodic" ? "按周期刷新" : "永久点数"}
+          statusMsg += `   点数模式：${config.pointsMode === "periodic" ? "按周期惰性刷新" : "永久点数"}
 `;
           if (config.pointsMode === "periodic") {
             statusMsg += `   刷新周期：${config.pointsRefreshCycleDays || 30} 天
-`;
-            statusMsg += `   刷新检查时刻：${config.pointsRefreshCheckTime || "00:05"}
 `;
             statusMsg += `   刷新点数：${config.pointsRefreshAmount || 200}
 `;
-            statusMsg += `   刷新范围：${config.pointsRefreshIncludeNonMember ? "所有用户" : "仅会员"}
+            statusMsg += `   刷新触发：用户发生点数相关操作时按用户惰性执行
 `;
-            statusMsg += `   周期锚点：${membershipSystem.formatRefreshAnchor()}
-`;
-            statusMsg += `   上次实际刷新：${membershipSystem.formatLastRefreshTime()}
-`;
-            const nextDays = membershipSystem.getDaysUntilNextRefresh();
-            const planLabel = membershipSystem.formatRefreshPlanTime();
-            statusMsg += `   下次刷新：${membershipSystem.formatNextRefreshTime()}（${nextDays}天后，计划 ${planLabel}）${membershipSystem.isPointsRefreshOverdue() ? " ⚠️ 已逾期，将在下个检查点补刷" : ""}
+            statusMsg += `   刷新范围：${config.pointsRefreshIncludeNonMember ? "所有用户" : "仅会员"}
 `;
           }
           statusMsg += `   默认点数：${config.pointsDefault || 200}
@@ -5867,27 +5647,6 @@ nai5 已使用：${user.nai5DailyUsage || 0} 次` : "";
         await membershipSystem.checkAndRemindExpiringMembers();
         return "✅ 提醒完成！请查看控制台日志获取详细信息。";
       }
-      if (options2.setAnchor !== void 0) {
-        if (!config.pointsEnabled || config.pointsMode !== "periodic") {
-          return "❌ 未启用周期刷新，无法设置周期锚点";
-        }
-        const result = await membershipSystem.setPointsRefreshAnchor(options2.setAnchor);
-        return result;
-      }
-      if (options2.setNextAt !== void 0) {
-        if (!config.pointsEnabled || config.pointsMode !== "periodic") {
-          return "❌ 未启用周期刷新，无法设置下次刷新时刻";
-        }
-        const result = await membershipSystem.setPointsRefreshNextAt(options2.setNextAt);
-        return result;
-      }
-      if (options2.resetCycle) {
-        if (!config.pointsEnabled || config.pointsMode !== "periodic") {
-          return "❌ 未启用周期刷新，无法重置周期";
-        }
-        const result = await membershipSystem.resetPointsRefreshCycle();
-        return result;
-      }
       if (options2.refreshPoints) {
         if (!config.pointsEnabled) {
           return "❌ 点数控制未启用";
@@ -5897,12 +5656,8 @@ nai5 已使用：${user.nai5DailyUsage || 0} 次` : "";
         }
         const refreshScope = debugTierFilter !== void 0 ? `Lv${debugTierFilter} 会员` : "所有会员";
         await session.send(`正在为${refreshScope}执行点数刷新...`);
-        const overdueBefore = membershipSystem.isPointsRefreshOverdue();
         const result = await membershipSystem.refreshPoints(debugTierFilter);
-        const note = overdueBefore ? `
-ℹ️ 本次刷新不改变周期锚点（${membershipSystem.formatRefreshAnchor()}），下次刷新仍为 ${membershipSystem.formatNextRefreshTime()}；如需立即重开周期请用 --reset-cycle` : `
-ℹ️ 周期不受影响，下次刷新仍为 ${membershipSystem.formatNextRefreshTime()}（${membershipSystem.getDaysUntilNextRefresh()}天后）`;
-        return result.message + note;
+        return result.message;
       }
       if (options2.addPoints !== void 0) {
         if (!config.pointsEnabled) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-hhs-huatu",
   "description": "Generate images by diffusion models",
-  "version": "1.3.13",
+  "version": "1.3.14",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [