koishi-plugin-message-counter-qq 2.6.21

package/lib/index.js

@@ -0,0 +1,2299 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  inject: () => inject,
+  name: () => name,
+  usage: () => usage
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi = require("koishi");
+var import_path = __toESM(require("path"));
+var fs = __toESM(require("fs/promises"));
+var import_fs = require("fs");
+var crypto = __toESM(require("crypto"));
+var assetsDir = import_path.default.resolve(__dirname, "..", "assets");
+var fallbackBase64 = [""];
+var name = "message-counter-qq";
+var inject = {
+  required: ["database", "cron"],
+  optional: ["markdownToImage", "puppeteer", "canvas"]
+};
+var usage = `## 📝 注意事项
+
+- 这是 QQ 群专用版本，只统计 QQ 群聊消息
+- 只统计 \`GROUP_MESSAGE_CREATE\`，不统计 \`GROUP_AT_MESSAGE_CREATE\`
+- 当前群排行榜为空时，通常表示今日暂无消息，或群主未允许机器人接收全量群消息
+- 初始化需权限等级 3
+- 依赖 database 与 cron 服务
+- 生成图片时，需 puppeteer 提供 canvas 支持
+
+## 🔍 关键指令
+
+### \`消息统计.查询 [指定用户]\`
+
+查询指定用户的发言次数信息（次数[排名]）。若不带任何选项，则显示所有时段的数据。
+
+**选项:**
+
+| 参数 | 说明 |
+|------|------|
+| \`-d, --day\` | 今日发言次数[排名] |
+| \`--yd, --yesterday\` | 昨日发言次数[排名] |
+| \`-w, --week\` | 本周发言次数[排名] |
+| \`-m, --month\` | 本月发言次数[排名] |
+| \`-y, --year\` | 今年发言次数[排名] |
+| \`-t, --total\` | 总发言次数[排名] |
+| \`--dag\` | 跨群今日发言次数[排名] |
+| \`--ydag\` | 跨群昨日发言次数[排名] |
+| \`--wag\` | 跨群本周发言次数[排名] |
+| \`--mag\` | 跨群本月发言次数[排名] |
+| \`--yag\` | 跨群本年发言次数[排名] |
+| \`-a, --across\` | 跨群总发言次数[排名] |
+
+### \`消息统计.排行榜 [显示的人数]\`
+
+发言排行榜。默认为今日发言榜。
+
+**选项:**
+
+| 参数 | 说明 |
+|------|------|
+| \`--yd, --yesterday\` | 昨日发言排行榜 |
+| \`-w\` | 本周发言排行榜 |
+| \`-m\` | 本月发言排行榜 |
+| \`-y\` | 今年发言排行榜 |
+| \`-t\` | 总发言排行榜 |
+| \`--dag\` | 跨群今日发言排行榜 |
+| \`--ydag\` | 跨群昨日发言排行榜 |
+| \`--wag\` | 跨群本周发言排行榜 |
+| \`--mag\` | 跨群本月发言排行榜 |
+| \`--yag\` | 跨群今年发言排行榜 |
+| \`--dragon\` | 跨群总发言排行榜（圣龙王榜） |
+| \`--whites\` | 白名单，只显示白名单用户 |
+| \`--blacks\` | 黑名单，不显示黑名单用户 |
+
+### \`消息统计.上传柱状条背景\`
+
+- 为自己上传一张自定义的水平柱状条背景图片
+- 新图片会覆盖旧的图片。若上传失败，旧图片也会被删除
+- 使用此指令时需附带图片
+
+### \`消息统计.重载资源\`
+
+- 实时重载用户图标、柱状条背景和字体文件，使其更改即时生效（需要权限等级 2）
+
+### \`消息统计.清理缓存\`
+
+- 清理过期的头像缓存文件，以释放磁盘空间（需要权限等级 3）
+- 用户更换头像后，旧的头像缓存会变成“孤儿缓存”。此指令可以安全地移除它们。
+
+## 🎨 自定义水平柱状图样式
+
+- 重载插件或使用 \`消息统计.重载资源\` 指令可使新增的文件立即生效。
+
+### 1. 用户图标
+
+- 在 \`data/messageCounter/icons\` 文件夹下添加用户图标
+- 文件名格式为 \`用户ID.png\`（例：\`1234567890.png\`）
+- 支持多图标，文件名格式为 \`用户ID-1.png\`, \`用户ID-2.png\`
+
+### 2. 柱状条背景
+
+- **推荐方式**：使用 \`消息统计.上传柱状条背景\` 指令
+- **手动方式**：在 \`data/messageCounter/barBgImgs\` 文件夹下添加背景图片
+- 支持多背景（随机选用），文件名格式为 \`用户ID-1.png\` 等
+- 建议尺寸 850x50 像素，文件名 \`用户ID.png\`
+
+### 3. 自定义字体
+
+- 插件启动时，会自动将内置字体 \`HarmonyOS_Sans_Medium.ttf\` 拷贝到 \`data/messageCounter/fonts/\` 目录下。
+- 您可以将自己喜爱的字体文件放入此文件夹，并在配置项的“字体设置”中填入该字体的文件名称（不带后缀）。
+
+---
+
+`;
+var logger = new import_koishi.Logger("messageCounterQQ");
+var FONT_OPTIONS = {
+  TITLE: "HarmonyOS_Sans_Medium",
+  NICKNAME: "HarmonyOS_Sans_Medium"
+};
+var Config = import_koishi.Schema.intersect([
+  // --- 核心功能 ---
+  import_koishi.Schema.object({
+    isBotMessageTrackingEnabled: import_koishi.Schema.boolean().default(false).description("是否统计 Bot 自己发送的消息。")
+  }).description("核心功能"),
+  // --- 排行榜设置 ---
+  import_koishi.Schema.object({
+    defaultMaxDisplayCount: import_koishi.Schema.number().min(0).default(20).description("排行榜默认显示的人数。设置为 0 则显示所有。"),
+    isTimeInfoSupplementEnabled: import_koishi.Schema.boolean().default(true).description("是否在排行榜标题中显示生成时间。"),
+    isUserMessagePercentageVisible: import_koishi.Schema.boolean().default(true).description("是否在排行榜中显示用户的消息数占比。"),
+    hiddenUserIdsInLeaderboard: import_koishi.Schema.array(String).role("table").description("全局隐藏的用户 ID 列表，在所有用户排行榜中生效。"),
+    hiddenChannelIdsInLeaderboard: import_koishi.Schema.array(String).role("table").description("全局隐藏的频道 ID 列表，在群排行榜中生效。")
+  }).description("排行榜设置"),
+  // --- 图片生成 ---
+  import_koishi.Schema.intersect([
+    import_koishi.Schema.object({
+      isTextToImageConversionEnabled: import_koishi.Schema.boolean().default(false).description(
+        "是否将文本排行榜转为 Markdown 图片（依赖 `markdownToImage` 服务）。"
+      ),
+      isLeaderboardToHorizontalBarChartConversionEnabled: import_koishi.Schema.boolean().default(false).description("是否将排行榜渲染为水平柱状图（依赖 `puppeteer` 服务）。")
+    }).description("图片生成"),
+    // 仅在开启柱状图功能时显示以下详细选项
+    import_koishi.Schema.union([
+      import_koishi.Schema.intersect([
+        import_koishi.Schema.object({
+          isLeaderboardToHorizontalBarChartConversionEnabled: import_koishi.Schema.const(true).required(),
+          imageType: import_koishi.Schema.union(["png", "jpeg", "webp"]).default("png").description(`生成的柱状图图片格式。`)
+        }).description("柱状图基础设置"),
+        import_koishi.Schema.object({
+          chartViewportWidth: import_koishi.Schema.number().min(1).default(1080).description(
+            "渲染页面的视口宽度（像素）。此值会影响图片清晰度及背景图的展示。"
+          ),
+          deviceScaleFactor: import_koishi.Schema.number().min(0.1).max(4).step(0.1).default(1).description(
+            "设备像素比 (DPR)。更高的值可生成更清晰的图片（如 2 倍图），但会增加文件体积。"
+          ),
+          waitUntil: import_koishi.Schema.union([
+            "load",
+            "domcontentloaded",
+            "networkidle0",
+            "networkidle2"
+          ]).default("networkidle0").description(
+            "页面加载等待策略，影响图片生成速度和稳定性。`networkidle0` 最稳定。"
+          )
+        }).description("渲染与性能"),
+        import_koishi.Schema.object({
+          avatarCacheTTL: import_koishi.Schema.number().default(86400).description(
+            "头像缓存有效期（秒）。设置为 0 则永不刷新。过短的有效期会增加网络请求。"
+          ),
+          avatarFailureCacheTTL: import_koishi.Schema.number().default(300).description(
+            "头像获取失败后的重试间隔（秒）。期间将使用默认头像，避免频繁请求无效链接。"
+          )
+        }).description("缓存设置"),
+        import_koishi.Schema.object({
+          shouldMoveIconToBarEndLeft: import_koishi.Schema.boolean().default(true).description(
+            "是否将自定义图标显示在进度条的末端。关闭则显示在用户名旁。"
+          ),
+          showStarInChart: import_koishi.Schema.boolean().default(true).description(
+            "是否在图表中对触发指令的用户/群聊名称前添加 ★ 以高亮显示。"
+          ),
+          horizontalBarBackgroundOpacity: import_koishi.Schema.number().min(0).max(1).step(0.05).default(0.6).description("自定义背景图在进度条区域的不透明度。"),
+          horizontalBarBackgroundFullOpacity: import_koishi.Schema.number().min(0).max(1).step(0.05).default(0).description("自定义背景图在整行背景区域的不透明度。")
+        }).description("样式定制"),
+        import_koishi.Schema.object({
+          maxBarBgWidth: import_koishi.Schema.number().min(0).default(850).description("允许上传的背景图最大宽度（像素）。0为不限制。"),
+          maxBarBgHeight: import_koishi.Schema.number().min(0).default(50).description("允许上传的背景图最大高度（像素）。0为不限制。"),
+          maxBarBgSize: import_koishi.Schema.number().min(0).default(5).description("允许上传的背景图最大体积（MB）。0为不限制。")
+        }).description("上传限制"),
+        // 背景设置（条件化）
+        import_koishi.Schema.intersect([
+          import_koishi.Schema.object({
+            backgroundType: import_koishi.Schema.union([
+              import_koishi.Schema.const("none").description("默认渐变"),
+              import_koishi.Schema.const("api").description("API 获取"),
+              import_koishi.Schema.const("css").description("自定义 CSS")
+            ]).default("none").description("图片整体背景类型。")
+          }),
+          import_koishi.Schema.union([
+            import_koishi.Schema.object({
+              backgroundType: import_koishi.Schema.const("api").required(),
+              apiBackgroundConfig: import_koishi.Schema.object({
+                apiUrl: import_koishi.Schema.string().description("获取背景图的 API 地址。").required(),
+                apiKey: import_koishi.Schema.string().role("secret").description("API 的访问凭证（可选）。"),
+                responseType: import_koishi.Schema.union(["binary", "url", "base64"]).default("binary").description("API 返回的数据类型。")
+              }).description("API 背景配置").collapse()
+            }),
+            import_koishi.Schema.object({
+              backgroundType: import_koishi.Schema.const("css").required(),
+              backgroundValue: import_koishi.Schema.string().role("textarea", { rows: [2, 4] }).default(
+                `html {
+  background: linear-gradient(135deg, #f6f8f9 0%, #e5ebee 100%);
+}`
+              ).description(
+                "自定义背景的 CSS 代码。建议使用 `html` 选择器来设置背景。"
+              )
+            }),
+            import_koishi.Schema.object({})
+          ])
+        ]).description("背景设置"),
+        import_koishi.Schema.object({
+          chartTitleFont: import_koishi.Schema.string().default(FONT_OPTIONS.TITLE).description(
+            `标题字体。填写 'data/messageCounter/fonts' 目录中的字体文件名（不含后缀）。`
+          ),
+          chartNicknameFont: import_koishi.Schema.string().default(FONT_OPTIONS.NICKNAME).description(
+            `昵称与计数字体。填写 'data/messageCounter/fonts' 目录中的字体文件名（不含后缀），或使用通用字体名称。`
+          )
+        }).description("字体设置")
+      ]),
+      import_koishi.Schema.object({})
+    ])
+  ]),
+  // --- 自动推送 ---
+  import_koishi.Schema.intersect([
+    import_koishi.Schema.object({
+      autoPush: import_koishi.Schema.boolean().default(false).description("是否启用定时自动推送排行榜功能。")
+    }).description("自动推送"),
+    import_koishi.Schema.union([
+      import_koishi.Schema.intersect([
+        import_koishi.Schema.object({
+          autoPush: import_koishi.Schema.const(true).required(),
+          shouldSendDailyLeaderboardAtMidnight: import_koishi.Schema.boolean().default(true).description("每日 0 点自动发送昨日排行榜。"),
+          shouldSendWeeklyLeaderboard: import_koishi.Schema.boolean().default(false).description("每周一 0 点自动发送上周排行榜。"),
+          shouldSendMonthlyLeaderboard: import_koishi.Schema.boolean().default(false).description("每月一日 0 点自动发送上月排行榜。"),
+          shouldSendYearlyLeaderboard: import_koishi.Schema.boolean().default(false).description("每年一日 0 点自动发送去年排行榜。"),
+          dailyScheduledTimers: import_koishi.Schema.array(String).role("table").description(
+            "其他定时发送今日排行榜的时间点（24小时制，如 `08:00`）。"
+          )
+        }).description("推送时机"),
+        import_koishi.Schema.object({
+          pushChannelIds: import_koishi.Schema.array(String).role("table").description("需要接收自动推送的频道 ID 列表。"),
+          shouldSendLeaderboardNotificationsToAllChannels: import_koishi.Schema.boolean().default(false).description(
+            "是否向机器人所在的所有群聊推送（可能造成打扰，请谨慎开启）。"
+          ),
+          excludedLeaderboardChannels: import_koishi.Schema.array(String).role("table").description(
+            "当“向所有群聊推送”开启时，此处指定的频道将不会收到推送。"
+          )
+        }).description("推送目标"),
+        import_koishi.Schema.object({
+          isGeneratingRankingListPromptVisible: import_koishi.Schema.boolean().default(true).description("发送排行榜前，是否先发送一条“正在生成”的提示消息。"),
+          leaderboardGenerationWaitTime: import_koishi.Schema.number().min(0).default(3).description("发送提示消息后，等待多少秒再发送排行榜图片。"),
+          delayBetweenGroupPushesInSeconds: import_koishi.Schema.number().min(0).default(5).description(
+            "批量推送时，每个群之间的基础发送延迟（秒），以防风控。"
+          ),
+          groupPushDelayRandomizationSeconds: import_koishi.Schema.number().min(0).default(10).description(
+            "在基础延迟之上，增加一个随机波动范围（秒），以模拟人工操作。"
+          )
+        }).description("推送行为")
+      ]),
+      import_koishi.Schema.object({})
+    ])
+  ])
+]);
+var periodMapping = {
+  today: { field: "todayPostCount", name: "今日" },
+  yesterday: { field: "yesterdayPostCount", name: "昨日" },
+  week: { field: "thisWeekPostCount", name: "本周" },
+  month: { field: "thisMonthPostCount", name: "本月" },
+  year: { field: "thisYearPostCount", name: "今年" },
+  total: { field: "totalPostCount", name: "总" }
+};
+async function apply(ctx, config) {
+  const PROCESSED = Symbol("message-counter.processed");
+  const dataRoot = import_path.default.join(ctx.baseDir, "data");
+  const messageCounterRoot = import_path.default.join(dataRoot, "messageCounter");
+  const iconsPath = import_path.default.join(messageCounterRoot, "icons");
+  const barBgImgsPath = import_path.default.join(messageCounterRoot, "barBgImgs");
+  const fontsPath = import_path.default.join(messageCounterRoot, "fonts");
+  const avatarsPath = import_path.default.join(messageCounterRoot, "avatars");
+  const emptyHtmlPath = import_path.default.join(messageCounterRoot, "emptyHtml.html").replace(/\\/g, "/");
+  const oldIconsPath = import_path.default.join(dataRoot, "messageCounterIcons");
+  const oldBarBgImgsPath = import_path.default.join(dataRoot, "messageCounterBarBgImgs");
+  await fs.mkdir(fontsPath, { recursive: true });
+  await fs.mkdir(iconsPath, { recursive: true });
+  await fs.mkdir(barBgImgsPath, { recursive: true });
+  await fs.mkdir(avatarsPath, { recursive: true });
+  await migrateFolder(oldIconsPath, iconsPath);
+  await migrateFolder(oldBarBgImgsPath, barBgImgsPath);
+  try {
+    await fs.access(emptyHtmlPath, import_fs.constants.F_OK);
+  } catch {
+    await fs.writeFile(emptyHtmlPath, "");
+    logger.info(`已创建空的渲染模板文件: emptyHtml.html`);
+  }
+  try {
+    const fallbackJson = await fs.readFile(
+      import_path.default.join(assetsDir, "fallbackBase64.json"),
+      "utf-8"
+    );
+    fallbackBase64 = JSON.parse(fallbackJson);
+  } catch (error) {
+    logger.warn("无法加载 fallbackBase64.json，将使用空的回退头像。", error);
+  }
+  const fontFiles = ["HarmonyOS_Sans_Medium.ttf"];
+  for (const fontFile of fontFiles) {
+    await copyAssetIfNotExists(
+      import_path.default.join(assetsDir, "fonts"),
+      fontsPath,
+      fontFile
+    );
+  }
+  const avatarCache = /* @__PURE__ */ new Map();
+  let iconCache = [];
+  let barBgImgCache = [];
+  let fontFilesCache = [];
+  ctx.model.extend(
+    "message_counter_records",
+    {
+      // id: "unsigned",
+      channelId: "string",
+      channelName: "string",
+      userId: "string",
+      username: "string",
+      userAvatar: "string",
+      todayPostCount: "unsigned",
+      thisWeekPostCount: "unsigned",
+      thisMonthPostCount: "unsigned",
+      thisYearPostCount: "unsigned",
+      totalPostCount: "unsigned",
+      yesterdayPostCount: "unsigned"
+    },
+    {
+      primary: ["channelId", "userId"]
+    }
+  );
+  ctx.model.extend(
+    "message_counter_state",
+    {
+      key: "string",
+      value: "timestamp"
+    },
+    { primary: "key" }
+  );
+  const channelCtx = ctx.channel();
+  ctx.on("ready", async () => {
+    await reloadIconCache();
+    await reloadBarBgImgCache();
+    await reloadFontCache();
+    await initializeResetStates();
+    await checkForMissedResets();
+    if (config.autoPush) {
+      if (config.shouldSendLeaderboardNotificationsToAllChannels) {
+        logger.warn(
+          "[自动推送] QQ 群版本不支持“向所有群聊推送”，请改为在 pushChannelIds 中手动填写群 openid。"
+        );
+      }
+      if (config.shouldSendDailyLeaderboardAtMidnight) {
+        const task = ctx.cron(
+          "1 0 * * *",
+          () => generateAndPushLeaderboard("yesterday")
+        );
+        scheduledTasks.push(task);
+        logger.info("[自动推送] 已设置每日 00:01 推送昨日排行榜的任务。");
+      }
+      (config.dailyScheduledTimers || []).forEach((time) => {
+        const match = /^([0-1]?[0-9]|2[0-3]):([0-5]?[0-9])$/.exec(time);
+        if (match) {
+          const [_, hour, minute] = match;
+          const cron = `${minute} ${hour} * * *`;
+          const task = ctx.cron(
+            cron,
+            () => generateAndPushLeaderboard("today")
+          );
+          scheduledTasks.push(task);
+          logger.info(`[自动推送] 已设置每日 ${time} 推送今日排行榜的任务。`);
+        } else {
+          logger.warn(
+            `[自动推送] 无效的时间格式: "${time}"，已跳过。请使用 "HH:mm" 格式。`
+          );
+        }
+      });
+    }
+    const resetTask = ctx.cron("0 0 * * *", async () => {
+      const now = /* @__PURE__ */ new Date();
+      const dayOfMonth = now.getDate();
+      const month = now.getMonth();
+      const dayOfWeek = now.getDay();
+      if (config.autoPush && config.shouldSendYearlyLeaderboard && dayOfMonth === 1 && month === 0) {
+        await generateAndPushLeaderboard("year");
+      }
+      if (config.autoPush && config.shouldSendMonthlyLeaderboard && dayOfMonth === 1) {
+        await generateAndPushLeaderboard("month");
+      }
+      if (config.autoPush && config.shouldSendWeeklyLeaderboard && dayOfWeek === 1) {
+        await generateAndPushLeaderboard("week");
+      }
+      await resetCounter("todayPostCount", "今日发言榜已成功置空！", "daily");
+      if (dayOfWeek === 1) {
+        await resetCounter(
+          "thisWeekPostCount",
+          "本周发言榜已成功置空！",
+          "weekly"
+        );
+      }
+      if (dayOfMonth === 1) {
+        await resetCounter(
+          "thisMonthPostCount",
+          "本月发言榜已成功置空！",
+          "monthly"
+        );
+      }
+      if (dayOfMonth === 1 && month === 0) {
+        await resetCounter(
+          "thisYearPostCount",
+          "今年发言榜已成功置空！",
+          "yearly"
+        );
+      }
+    });
+    scheduledTasks.push(resetTask);
+    logger.info("已设置统一的推送与数据重置任务（每日、周、月、年）。");
+  });
+  ctx.on("dispose", () => {
+    scheduledTasks.forEach((task) => task());
+    avatarCache.clear();
+    iconCache = [];
+    barBgImgCache = [];
+    fontFilesCache = [];
+    logger.info("所有已安排的任务和缓存都已清除。");
+  });
+  channelCtx.middleware(async (session, next) => {
+    const qqEventType = session.qq?.t;
+    if (session[PROCESSED]) return next();
+    if (session.platform !== "qq" || qqEventType !== "GROUP_MESSAGE_CREATE") {
+      return next();
+    }
+    if (!session.userId || !session.channelId || session.author?.isBot) {
+      return next();
+    }
+    session[PROCESSED] = true;
+    const { userId, channelId, author } = session;
+    const sessionChannelName = session.event.channel?.name;
+    const username = session.qq?.author?.username || author?.nick || author?.name || userId;
+    const userAvatar = author?.avatar;
+    try {
+      const channelName = sessionChannelName || (channelId ? await getChannelName(session.bot, channelId) : channelId);
+      await ctx.database.upsert(
+        "message_counter_records",
+        (row) => [
+          {
+            channelId,
+            userId,
+            username,
+            userAvatar: userAvatar || row.userAvatar,
+            channelName: channelName || row.channelName,
+            todayPostCount: import_koishi.$.add(row.todayPostCount, 1),
+            thisWeekPostCount: import_koishi.$.add(row.thisWeekPostCount, 1),
+            thisMonthPostCount: import_koishi.$.add(row.thisMonthPostCount, 1),
+            thisYearPostCount: import_koishi.$.add(row.thisYearPostCount, 1),
+            totalPostCount: import_koishi.$.add(row.totalPostCount, 1)
+          }
+        ],
+        ["channelId", "userId"]
+      );
+    } catch (error) {
+      logger.error(
+        "Failed to update message count for user %s in channel %s:",
+        userId,
+        channelId,
+        error
+      );
+    }
+    return next();
+  }, true);
+  if (config.isBotMessageTrackingEnabled) {
+    logger.warn("QQ 群版本只统计 GROUP_MESSAGE_CREATE，已忽略 Bot 自身消息统计配置。");
+  }
+  ctx.command("消息统计", "查看消息统计帮助").action(({ session }) => session?.execute(`help 消息统计`));
+  ctx.command("消息统计.初始化", "初始化", { authority: 3 }).action(async ({ session }) => {
+    if (!session) return;
+    await session.send("正在清空所有发言记录，请稍候...");
+    await ctx.database.remove("message_counter_records", {});
+    await session.send("所有发言记录已清空！");
+  });
+  ctx.command(
+    "消息统计.查询 [targetUser:text]",
+    "查询指定用户的发言次数信息"
+  ).userFields(["id", "name"]).option("yesterday", "--yd 昨日发言").option("day", "-d 今日发言").option("week", "-w 本周发言").option("month", "-m 本月发言").option("year", "-y 今年发言").option("total", "-t 总发言").option("ydag", "跨群昨日发言").option("dag", "跨群今日发言").option("wag", "跨群本周发言").option("mag", "跨群本月发言").option("yag", "跨群本年发言").option("across", "-a 跨群总发言").action(async ({ session, options }, targetUser) => {
+    const optionKeys = [
+      "day",
+      "week",
+      "month",
+      "year",
+      "total",
+      "yesterday",
+      "dag",
+      "wag",
+      "mag",
+      "yag",
+      "ydag",
+      "across"
+    ];
+    const selectedOptions = {};
+    let noOptionSelected = true;
+    for (const key of optionKeys) {
+      if (options[key]) {
+        selectedOptions[key] = true;
+        noOptionSelected = false;
+      }
+    }
+    if (noOptionSelected) {
+      for (const key of optionKeys) {
+        selectedOptions[key] = true;
+      }
+    }
+    let channelId = session?.channelId;
+    let userId = session?.userId;
+    let targetUserRecord = [];
+    if (targetUser) {
+      if (session) targetUser = await replaceAtTags(session, targetUser);
+      const match = targetUser.match(/<at id="([^"]+)"/);
+      if (match) userId = match[1];
+    }
+    targetUserRecord = await ctx.database.get("message_counter_records", {
+      channelId,
+      userId
+    });
+    if (targetUserRecord.length === 0) return `被查询对象无任何发言记录。`;
+    const channelUsers = await ctx.database.get("message_counter_records", {
+      channelId
+    });
+    const allUsers = await ctx.database.get("message_counter_records", {});
+    const channelStats = [];
+    const acrossStats = [];
+    const accumulate = /* @__PURE__ */ __name((records) => records.reduce(
+      (sums, user) => {
+        for (const key in periodMapping) {
+          sums[periodMapping[key].field] = (sums[periodMapping[key].field] || 0) + user[periodMapping[key].field];
+        }
+        return sums;
+      },
+      {}
+    ), "accumulate");
+    const channelTotals = accumulate(channelUsers);
+    const acrossTotals = accumulate(allUsers);
+    const getRank = /* @__PURE__ */ __name((records, field, uid) => {
+      const sorted = [...records].sort((a, b) => b[field] - a[field]);
+      const index = sorted.findIndex((u) => u.userId === uid);
+      return index !== -1 ? index + 1 : null;
+    }, "getRank");
+    const getAcrossRank = /* @__PURE__ */ __name((records, field, uid) => {
+      const userTotals = records.reduce((acc, cur) => {
+        acc[cur.userId] = (acc[cur.userId] || 0) + cur[field];
+        return acc;
+      }, {});
+      const sorted = Object.entries(userTotals).sort(([, a], [, b]) => b - a);
+      const index = sorted.findIndex(([id]) => id === uid);
+      return index !== -1 ? index + 1 : null;
+    }, "getAcrossRank");
+    const getAcrossCount = /* @__PURE__ */ __name((records, field, uid) => {
+      return records.filter((r) => r.userId === uid).reduce((sum, r) => sum + r[field], 0);
+    }, "getAcrossCount");
+    channelStats.push({
+      label: "昨日",
+      count: targetUserRecord[0].yesterdayPostCount,
+      total: channelTotals.yesterdayPostCount,
+      rank: getRank(channelUsers, "yesterdayPostCount", userId),
+      enabled: selectedOptions.yesterday
+    });
+    channelStats.push({
+      label: "今日",
+      count: targetUserRecord[0].todayPostCount,
+      total: channelTotals.todayPostCount,
+      rank: getRank(channelUsers, "todayPostCount", userId),
+      enabled: selectedOptions.day
+    });
+    channelStats.push({
+      label: "本周",
+      count: targetUserRecord[0].thisWeekPostCount,
+      total: channelTotals.thisWeekPostCount,
+      rank: getRank(channelUsers, "thisWeekPostCount", userId),
+      enabled: selectedOptions.week
+    });
+    channelStats.push({
+      label: "本月",
+      count: targetUserRecord[0].thisMonthPostCount,
+      total: channelTotals.thisMonthPostCount,
+      rank: getRank(channelUsers, "thisMonthPostCount", userId),
+      enabled: selectedOptions.month
+    });
+    channelStats.push({
+      label: "全年",
+      count: targetUserRecord[0].thisYearPostCount,
+      total: channelTotals.thisYearPostCount,
+      rank: getRank(channelUsers, "thisYearPostCount", userId),
+      enabled: selectedOptions.year
+    });
+    channelStats.push({
+      label: "总计",
+      count: targetUserRecord[0].totalPostCount,
+      total: channelTotals.totalPostCount,
+      rank: getRank(channelUsers, "totalPostCount", userId),
+      enabled: selectedOptions.total
+    });
+    acrossStats.push({
+      label: "昨日",
+      count: getAcrossCount(allUsers, "yesterdayPostCount", userId),
+      total: acrossTotals.yesterdayPostCount,
+      rank: getAcrossRank(allUsers, "yesterdayPostCount", userId),
+      enabled: selectedOptions.ydag
+    });
+    acrossStats.push({
+      label: "今日",
+      count: getAcrossCount(allUsers, "todayPostCount", userId),
+      total: acrossTotals.todayPostCount,
+      rank: getAcrossRank(allUsers, "todayPostCount", userId),
+      enabled: selectedOptions.dag
+    });
+    acrossStats.push({
+      label: "本周",
+      count: getAcrossCount(allUsers, "thisWeekPostCount", userId),
+      total: acrossTotals.thisWeekPostCount,
+      rank: getAcrossRank(allUsers, "thisWeekPostCount", userId),
+      enabled: selectedOptions.wag
+    });
+    acrossStats.push({
+      label: "本月",
+      count: getAcrossCount(allUsers, "thisMonthPostCount", userId),
+      total: acrossTotals.thisMonthPostCount,
+      rank: getAcrossRank(allUsers, "thisMonthPostCount", userId),
+      enabled: selectedOptions.mag
+    });
+    acrossStats.push({
+      label: "全年",
+      count: getAcrossCount(allUsers, "thisYearPostCount", userId),
+      total: acrossTotals.thisYearPostCount,
+      rank: getAcrossRank(allUsers, "thisYearPostCount", userId),
+      enabled: selectedOptions.yag
+    });
+    acrossStats.push({
+      label: "总计",
+      count: getAcrossCount(allUsers, "totalPostCount", userId),
+      total: acrossTotals.totalPostCount,
+      rank: getAcrossRank(allUsers, "totalPostCount", userId),
+      enabled: selectedOptions.across
+    });
+    const formatPercentage = /* @__PURE__ */ __name((count, total) => {
+      if (total === 0) return "(0%)";
+      const percentage = count / total * 100;
+      const numStr = percentage % 1 === 0 ? String(percentage) : percentage.toFixed(2);
+      return `(${numStr}%)`;
+    }, "formatPercentage");
+    const formatStatsTable = /* @__PURE__ */ __name((title, stats) => {
+      const activeStats = stats.filter((s) => s.enabled && s.count > 0);
+      if (activeStats.length === 0) return "";
+      const counts = activeStats.map((s) => String(s.count));
+      const percents = activeStats.map(
+        (s) => formatPercentage(s.count, s.total)
+      );
+      const maxCountWidth = Math.max(0, ...counts.map((s) => s.length));
+      const maxPercentWidth = Math.max(0, ...percents.map((s) => s.length));
+      let table = `${title}
+`;
+      for (const row of activeStats) {
+        const label = row.label.padEnd(2, "　");
+        const countStr = String(row.count).padStart(maxCountWidth, " ");
+        const percentStr = formatPercentage(row.count, row.total).padEnd(
+          maxPercentWidth,
+          " "
+        );
+        const rankStr = row.rank ? `#${row.rank}` : "#-";
+        table += `${label} ${countStr}  ${percentStr}  ${rankStr}
+`;
+      }
+      return table;
+    }, "formatStatsTable");
+    const channelTable = formatStatsTable("群发言", channelStats);
+    const acrossTable = formatStatsTable("跨群发言", acrossStats);
+    const body = [channelTable, acrossTable].filter(Boolean).join("\n");
+    if (!body) return `被查询对象在指定时段内无发言记录。`;
+    const timestamp = (/* @__PURE__ */ new Date()).toLocaleString("sv-SE", {
+      timeZone: "Asia/Shanghai"
+    });
+    const header = `${timestamp}
+${targetUserRecord[0].username}
+
+`;
+    const message = header + body;
+    if (config.isTextToImageConversionEnabled && ctx.markdownToImage) {
+      try {
+        const imageBuffer = await ctx.markdownToImage.convertToImage(message);
+        return import_koishi.h.image(imageBuffer, `image/${config.imageType}`);
+      } catch (error) {
+        logger.warn("生成图片失败，将回退到文本输出:", error);
+      }
+    }
+    return message;
+  });
+  ctx.command("消息统计.排行榜 [limit:number]", "用户发言排行榜").userFields(["id", "name"]).option("whites", "<users:text> 白名单，用空格、逗号等分隔").option("blacks", "<users:text> 黑名单，用空格、逗号等分隔").option("yesterday", "--yd").option("day", "-d").option("week", "-w").option("month", "-m").option("year", "-y").option("total", "-t").option("ydag", "跨群昨日").option("dag", "跨群今日").option("wag", "跨群本周").option("mag", "跨群本月").option("yag", "跨群本年").option("dragon", "圣龙王榜 (跨群总榜)").action(async ({ session, options }, limit) => {
+    if (!session) return;
+    const number = limit ?? config.defaultMaxDisplayCount;
+    if (typeof number !== "number" || isNaN(number) || number < 0) {
+      return "请输入大于等于 0 的数字作为排行榜显示人数。";
+    }
+    const whites = parseList(options?.whites);
+    const blacks = [
+      ...parseList(options?.blacks),
+      ...config.hiddenUserIdsInLeaderboard
+    ];
+    const period = getPeriodFromOptions(options, "today");
+    const isAcross = isAcrossChannel(options);
+    const { field, name: periodName } = periodMapping[period];
+    const scopeName = isAcross ? "跨群" : "本群";
+    const rankTitle = `${scopeName}${periodName}发言排行榜`;
+    const rankTimeTitle = getCurrentBeijingTime();
+    let records;
+    if (isAcross) {
+      records = await ctx.database.get("message_counter_records", {});
+    } else {
+      records = await ctx.database.get("message_counter_records", {
+        channelId: session.channelId
+      });
+    }
+    const filteredRecords = filterRecordsByWhitesAndBlacks(
+      records,
+      "userId",
+      whites,
+      blacks
+    );
+    if (filteredRecords.length === 0) {
+      if (isAcross) {
+        return "当前范围内暂无发言记录。";
+      }
+      return "当前群暂无可用排行数据。今日可能没有消息，或群主尚未允许机器人接收全量群消息。";
+    }
+    const userPostCounts = {};
+    const userInfo = {};
+    let totalCount = 0;
+    for (const record of filteredRecords) {
+      const count = record[field];
+      userPostCounts[record.userId] = (userPostCounts[record.userId] || 0) + count;
+      if (!userInfo[record.userId]) {
+        userInfo[record.userId] = {
+          username: record.username,
+          avatar: record.userAvatar || `https://q1.qlogo.cn/g?b=qq&nk=${record.userId}&s=640`
+        };
+      }
+      totalCount += count;
+    }
+    const sortedUsers = Object.entries(userPostCounts).sort(
+      ([, a], [, b]) => b - a
+    );
+    const rankingData = prepareRankingData(
+      sortedUsers,
+      userInfo,
+      totalCount,
+      number,
+      session.userId
+    );
+    return renderLeaderboard({
+      rankTimeTitle,
+      rankTitle,
+      rankingData
+    });
+  });
+  ctx.command(
+    "消息统计.上传柱状条背景",
+    "上传/更新自定义的水平柱状条背景图"
+  ).action(async ({ session }) => {
+    if (!session || !session.userId) {
+      return "无法获取用户信息，请稍后再试。";
+    }
+    if (!session.content) {
+      return "请在发送指令的同时附带一张图片。新图片将会覆盖旧的背景。";
+    }
+    const imageElements = import_koishi.h.select(session.content, "img");
+    if (imageElements.length === 0) {
+      return "请在发送指令的同时附带一张图片。新图片将会覆盖旧的背景。";
+    }
+    const { userId } = session;
+    const cleanupOldBackground = /* @__PURE__ */ __name(async () => {
+      try {
+        const allFiles = await fs.readdir(barBgImgsPath);
+        const userFiles = allFiles.filter(
+          (file) => file.startsWith(`${userId}.`)
+        );
+        if (userFiles.length > 0) {
+          await Promise.all(
+            userFiles.map(
+              (file) => fs.unlink(import_path.default.join(barBgImgsPath, file))
+            )
+          );
+        }
+      } catch (error) {
+        if (error.code !== "ENOENT") {
+          logger.warn(`清理用户 ${userId} 的旧背景图时出错:`, error);
+        }
+      }
+    }, "cleanupOldBackground");
+    try {
+      const imageUrl = imageElements[0].attrs.src;
+      if (!imageUrl) {
+        throw new Error("未能从消息中提取图片 URL。");
+      }
+      const buffer = Buffer.from(
+        await ctx.http.get(imageUrl, { responseType: "arraybuffer" })
+      );
+      const imageSizeInMB = buffer.byteLength / 1024 / 1024;
+      if (config.maxBarBgSize > 0 && imageSizeInMB > config.maxBarBgSize) {
+        throw new Error(
+          `图片文件过大（${imageSizeInMB.toFixed(2)}MB），请上传小于 ${config.maxBarBgSize}MB 的图片。`
+        );
+      }
+      if (ctx.canvas) {
+        try {
+          const image = await ctx.canvas.loadImage(buffer);
+          if (config.maxBarBgWidth > 0 && image.naturalWidth > config.maxBarBgWidth || config.maxBarBgHeight > 0 && image.naturalHeight > config.maxBarBgHeight) {
+            throw new Error(
+              `图片尺寸（${image.naturalWidth}x${image.naturalHeight}）超出限制（最大 ${config.maxBarBgWidth}x${config.maxBarBgHeight}）。
+建议尺寸为 850x50 像素。`
+            );
+          }
+        } catch (error) {
+          logger.error("解析图片尺寸失败:", error);
+          throw new Error(
+            "无法解析图片尺寸，请尝试使用其他标准图片格式（如 PNG, JPEG）。"
+          );
+        }
+      } else {
+        logger.warn("Canvas 服务未启用，跳过背景图尺寸检查。");
+      }
+      await cleanupOldBackground();
+      const newFileName = `${userId}.png`;
+      const newFilePath = import_path.default.join(barBgImgsPath, newFileName);
+      await fs.writeFile(newFilePath, buffer);
+      await reloadBarBgImgCache();
+      return "您的自定义柱状条背景已成功更新！";
+    } catch (error) {
+      logger.error(`为用户 ${userId} 上传背景图失败:`, error);
+      await cleanupOldBackground();
+      await reloadBarBgImgCache();
+      const userMessage = error instanceof Error ? error.message : "图片保存时发生未知错误，请联系管理员。";
+      return `图片上传失败: ${userMessage}
+您之前的自定义背景（如有）已被移除。`;
+    }
+  });
+  ctx.command("消息统计.重载资源", "重载图标、背景和字体资源", {
+    authority: 2
+  }).action(async ({ session }) => {
+    if (!session) return;
+    await session.send("正在重新加载用户图标、背景图片和字体文件缓存...");
+    await reloadIconCache();
+    await reloadBarBgImgCache();
+    await reloadFontCache();
+    return `资源重载完毕！
+- 已加载 ${iconCache.length} 个用户图标。
+- 已加载 ${barBgImgCache.length} 个柱状条背景图片。
+- 已加载 ${fontFilesCache.length} 个字体文件。`;
+  });
+  ctx.command("消息统计.清理缓存", "清理过期的头像缓存文件", {
+    authority: 3
+  }).option(
+    "days",
+    "-d <days:number> 清理超过指定天数未使用的缓存文件 (默认: 30)"
+  ).action(async ({ session, options }) => {
+    if (!session) return;
+    const days = options.days ?? 30;
+    if (typeof days !== "number" || days < 0) {
+      return "请输入一个有效的天数（大于等于0）。";
+    }
+    await session.send(`正在开始清理 ${days} 天前的头像缓存，请稍候...`);
+    const cacheDir = avatarsPath;
+    let deletedCount = 0;
+    let totalFreedSize = 0;
+    const now = Date.now();
+    const expirationTime = now - days * 24 * 60 * 60 * 1e3;
+    try {
+      const files = await fs.readdir(cacheDir);
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        const filePath = import_path.default.join(cacheDir, file);
+        try {
+          const stats = await fs.stat(filePath);
+          const content = await fs.readFile(filePath, "utf-8");
+          const entry = JSON.parse(content);
+          if (entry.timestamp < expirationTime) {
+            await fs.unlink(filePath);
+            deletedCount++;
+            totalFreedSize += stats.size;
+          }
+        } catch (error) {
+          logger.warn(`处理缓存文件 ${file} 时出错，已跳过:`, error);
+        }
+      }
+      const freedSizeFormatted = formatBytes(totalFreedSize);
+      return `缓存清理完成！
+- 共删除 ${deletedCount} 个过期缓存文件。
+- 释放磁盘空间约 ${freedSizeFormatted}。`;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return "头像缓存目录不存在，无需清理。";
+      }
+      logger.error("清理头像缓存时发生未知错误:", error);
+      return "清理过程中发生错误，请查看控制台日志。";
+    }
+  });
+  async function patchAndGetUsableFontPath(filePath) {
+    let buffer;
+    try {
+      buffer = await fs.readFile(filePath);
+    } catch (readError) {
+      logger.warn(
+        `读取字体文件 "${import_path.default.basename(filePath)}" 失败，已跳过。错误: ${readError.message}`
+      );
+      return filePath;
+    }
+    if (buffer.length < 12) return filePath;
+    const numTables = buffer.readUInt16BE(4);
+    for (let i = 0; i < numTables; i++) {
+      const recordOffset = 12 + i * 16;
+      if (recordOffset + 16 > buffer.length) break;
+      if (buffer.toString("ascii", recordOffset, recordOffset + 4) === "vhea") {
+        const tableOffset = buffer.readUInt32BE(recordOffset + 8);
+        if (tableOffset + 4 > buffer.length) break;
+        const version = buffer.readUInt32BE(tableOffset);
+        const INCORRECT_VERSION = 65537;
+        if (version === INCORRECT_VERSION) {
+          const parsedPath = import_path.default.parse(filePath);
+          const patchedFilename = `${parsedPath.name}-patched${parsedPath.ext}`;
+          const patchedFilePath = import_path.default.join(parsedPath.dir, patchedFilename);
+          try {
+            await fs.access(patchedFilePath);
+            return patchedFilePath;
+          } catch (e) {
+            logger.info(
+              `检测到字体 "${import_path.default.basename(
+                filePath
+              )}" 不规范，正在创建修复版本 "${patchedFilename}"...`
+            );
+            const CORRECT_VERSION = 65536;
+            buffer.writeUInt32BE(CORRECT_VERSION, tableOffset);
+            try {
+              await fs.writeFile(patchedFilePath, buffer);
+              logger.success(
+                `已成功创建修复后的字体文件 "${patchedFilename}"。`
+              );
+              return patchedFilePath;
+            } catch (writeError) {
+              logger.warn(`创建修复字体副本失败: ${writeError.message}`);
+              return filePath;
+            }
+          }
+        }
+        break;
+      }
+    }
+    return filePath;
+  }
+  __name(patchAndGetUsableFontPath, "patchAndGetUsableFontPath");
+  function formatBytes(bytes, decimals = 2) {
+    if (bytes === 0) return "0 Bytes";
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + " " + sizes[i];
+  }
+  __name(formatBytes, "formatBytes");
+  async function generateAndPushLeaderboard(period) {
+    const pushPeriodConfig = {
+      today: { field: "todayPostCount", name: "今日" },
+      yesterday: { field: "yesterdayPostCount", name: "昨日" },
+      week: { field: "thisWeekPostCount", name: "上周" },
+      month: { field: "thisMonthPostCount", name: "上月" },
+      year: { field: "thisYearPostCount", name: "去年" }
+    };
+    const { field, name: periodName } = pushPeriodConfig[period];
+    logger.info(`[自动推送] 开始执行 ${periodName} 发言排行榜推送任务。`);
+    const scopeName = "本群";
+    const rankTimeTitle = getCurrentBeijingTime();
+    const targetChannels = /* @__PURE__ */ new Set();
+    const qqBot = ctx.bots.find((bot) => bot.platform === "qq" && bot.status === 1);
+    for (const channelId of config.pushChannelIds || []) {
+      if (channelId.includes(":")) {
+        targetChannels.add(channelId);
+      } else if (qqBot) {
+        targetChannels.add(`qq:${channelId}`);
+      } else {
+        logger.warn(
+          `[自动推送] 无法处理配置的群 openid: ${channelId}，当前没有在线 QQ 机器人。`
+        );
+      }
+    }
+    const excluded = new Set(config.excludedLeaderboardChannels || []);
+    for (const id of Array.from(targetChannels)) {
+      const separatorIdx = id.indexOf(":");
+      const unprefixedId = separatorIdx !== -1 ? id.substring(separatorIdx + 1) : id;
+      if (excluded.has(id) || excluded.has(unprefixedId)) {
+        targetChannels.delete(id);
+      }
+    }
+    if (targetChannels.size === 0) {
+      logger.info("[自动推送] 没有配置任何需要推送的频道，任务结束。");
+      return;
+    }
+    logger.info(`[自动推送] 将向 ${targetChannels.size} 个频道进行推送。`);
+    for (const prefixedChannelId of targetChannels) {
+      try {
+        const platformSeparatorIndex = prefixedChannelId.indexOf(":");
+        const channelId = platformSeparatorIndex === -1 ? prefixedChannelId : prefixedChannelId.substring(platformSeparatorIndex + 1);
+        const records = await ctx.database.get("message_counter_records", {
+          channelId
+        });
+        if (records.length === 0) {
+          logger.info(
+            `[自动推送] 频道 ${prefixedChannelId} 无发言记录，跳过。`
+          );
+          continue;
+        }
+        const userPostCounts = {};
+        const userInfo = {};
+        let totalCount = 0;
+        for (const record of records) {
+          const count = record[field] || 0;
+          userPostCounts[record.userId] = (userPostCounts[record.userId] || 0) + count;
+          if (!userInfo[record.userId]) {
+            userInfo[record.userId] = {
+              username: record.username,
+              avatar: record.userAvatar || `https://q1.qlogo.cn/g?b=qq&nk=${record.userId}&s=640`
+            };
+          }
+          totalCount += count;
+        }
+        const sortedUsers = Object.entries(userPostCounts).filter(([, count]) => count > 0).sort(([, a], [, b]) => b - a);
+        if (sortedUsers.length === 0) {
+          logger.info(
+            `[自动推送] 频道 ${prefixedChannelId} 在 ${periodName} 榜单上无有效数据，跳过。`
+          );
+          continue;
+        }
+        const rankingData = prepareRankingData(
+          sortedUsers,
+          userInfo,
+          totalCount,
+          config.defaultMaxDisplayCount
+        );
+        if (config.isGeneratingRankingListPromptVisible) {
+          try {
+            await ctx.broadcast(
+              [prefixedChannelId],
+              `正在为本群生成${periodName}发言排行榜...`
+            );
+          } catch (e) {
+          }
+          await (0, import_koishi.sleep)(config.leaderboardGenerationWaitTime * 1e3);
+        }
+        const rankTitle = `${scopeName}${periodName}发言排行榜`;
+        const renderedMessage = await renderLeaderboard({
+          rankTimeTitle,
+          rankTitle,
+          rankingData
+        });
+        await ctx.broadcast([prefixedChannelId], renderedMessage);
+        logger.success(
+          `[自动推送] 已成功向频道 ${prefixedChannelId} 推送${periodName}排行榜。`
+        );
+        const randomDelay = Math.random() * config.groupPushDelayRandomizationSeconds;
+        const delay = (config.delayBetweenGroupPushesInSeconds + randomDelay) * 1e3;
+        if (delay > 0) {
+          await (0, import_koishi.sleep)(delay);
+        }
+      } catch (error) {
+        logger.error(
+          `[自动推送] 向频道 ${prefixedChannelId} 推送时发生错误:`,
+          error
+        );
+      }
+    }
+    logger.info(`[自动推送] 所有推送任务执行完毕。`);
+  }
+  __name(generateAndPushLeaderboard, "generateAndPushLeaderboard");
+  const scheduledTasks = [];
+  async function initializeResetStates() {
+    logger.info("正在初始化并验证发言计数器的重置状态...");
+    const now = /* @__PURE__ */ new Date();
+    const state = await ctx.database.get("message_counter_state", {});
+    const stateMap = new Map(state.map((s) => [s.key, s.value]));
+    const periods = [
+      "daily",
+      "weekly",
+      "monthly",
+      "yearly"
+    ];
+    for (const period of periods) {
+      const key = `last_${period}_reset`;
+      if (!stateMap.has(key)) {
+        let baselineDate;
+        switch (period) {
+          case "daily":
+            baselineDate = /* @__PURE__ */ new Date();
+            baselineDate.setHours(0, 0, 0, 0);
+            break;
+          case "weekly":
+            baselineDate = new Date(now);
+            baselineDate.setDate(now.getDate() - (now.getDay() + 6) % 7);
+            baselineDate.setHours(0, 0, 0, 0);
+            break;
+          case "monthly":
+            baselineDate = new Date(now.getFullYear(), now.getMonth(), 1);
+            baselineDate.setHours(0, 0, 0, 0);
+            break;
+          case "yearly":
+            baselineDate = new Date(now.getFullYear(), 0, 1);
+            baselineDate.setHours(0, 0, 0, 0);
+            break;
+        }
+        await ctx.database.upsert("message_counter_state", [
+          { key, value: baselineDate }
+        ]);
+        logger.info(
+          `已为 '${period}' 周期初始化重置状态，基准时间：${baselineDate.toISOString()}`
+        );
+      }
+    }
+    logger.info("所有周期的重置状态已验证完毕。");
+  }
+  __name(initializeResetStates, "initializeResetStates");
+  async function isResetDue(period) {
+    const now = /* @__PURE__ */ new Date();
+    const state = await ctx.database.get("message_counter_state", {
+      key: `last_${period}_reset`
+    });
+    const lastReset = state.length ? new Date(state[0].value) : /* @__PURE__ */ new Date(0);
+    let periodStart;
+    switch (period) {
+      case "daily":
+        periodStart = /* @__PURE__ */ new Date();
+        periodStart.setHours(0, 0, 0, 0);
+        break;
+      case "weekly":
+        periodStart = new Date(now);
+        periodStart.setDate(now.getDate() - (now.getDay() + 6) % 7);
+        periodStart.setHours(0, 0, 0, 0);
+        break;
+      case "monthly":
+        periodStart = new Date(now.getFullYear(), now.getMonth(), 1);
+        periodStart.setHours(0, 0, 0, 0);
+        break;
+      case "yearly":
+        periodStart = new Date(now.getFullYear(), 0, 1);
+        periodStart.setHours(0, 0, 0, 0);
+        break;
+    }
+    return lastReset < periodStart;
+  }
+  __name(isResetDue, "isResetDue");
+  async function checkForMissedResets() {
+    logger.info("正在检查错过的计数器重置任务...");
+    const jobDefinitions = [
+      {
+        period: "daily",
+        field: "todayPostCount",
+        message: "已补上错过的每日发言榜重置！"
+      },
+      {
+        period: "weekly",
+        field: "thisWeekPostCount",
+        message: "已补上错过的每周发言榜重置！"
+      },
+      {
+        period: "monthly",
+        field: "thisMonthPostCount",
+        message: "已补上错过的每月发言榜重置！"
+      },
+      {
+        period: "yearly",
+        field: "thisYearPostCount",
+        message: "已补上错过的每年发言榜重置！"
+      }
+    ];
+    for (const job of jobDefinitions) {
+      if (await isResetDue(job.period)) {
+        logger.info(`检测到错过的 ${job.period} 重置任务，正在执行...`);
+        await resetCounter(job.field, job.message, job.period);
+      }
+    }
+    logger.info("错过的计数器重置任务检查完毕。");
+  }
+  __name(checkForMissedResets, "checkForMissedResets");
+  async function resetCounter(field, message, period) {
+    if (field === "todayPostCount") {
+      logger.info("正在更新昨日发言数...");
+      await ctx.database.set("message_counter_records", {}, (row) => ({
+        yesterdayPostCount: row.todayPostCount
+      }));
+      logger.success("更新昨日发言数完成。");
+    }
+    await ctx.database.set("message_counter_records", {}, { [field]: 0 });
+    logger.success(message);
+    await ctx.database.upsert("message_counter_state", [
+      {
+        key: `last_${period}_reset`,
+        value: /* @__PURE__ */ new Date()
+      }
+    ]);
+    logger.success(`已更新 ${period} 周期的最后重置时间。`);
+  }
+  __name(resetCounter, "resetCounter");
+  function formatPercentageForDisplay(count, total) {
+    if (total === 0) {
+      return "(0%)";
+    }
+    const percentage = count / total * 100;
+    const formattedNumber = parseFloat(percentage.toFixed(2));
+    return `(${formattedNumber}%)`;
+  }
+  __name(formatPercentageForDisplay, "formatPercentageForDisplay");
+  async function getAvatarAsBase64(url) {
+    if (!url) {
+      return fallbackBase64[0];
+    }
+    const now = Date.now();
+    const successTtl = config.avatarCacheTTL * 1e3;
+    const failureTtl = config.avatarFailureCacheTTL * 1e3;
+    const isEntryExpired = /* @__PURE__ */ __name((entry) => {
+      const isFallback = entry.base64 === fallbackBase64[0];
+      const ttl = isFallback ? failureTtl : successTtl;
+      if (ttl === 0 && !isFallback) return false;
+      return now - entry.timestamp >= ttl;
+    }, "isEntryExpired");
+    if (avatarCache.has(url)) {
+      const entry = avatarCache.get(url);
+      if (!isEntryExpired(entry)) {
+        return entry.base64;
+      }
+    }
+    const hash = crypto.createHash("md5").update(url).digest("hex");
+    const cacheFilePath = import_path.default.join(avatarsPath, `${hash}.json`);
+    try {
+      const cachedFile = await fs.readFile(cacheFilePath, "utf-8");
+      const entry = JSON.parse(cachedFile);
+      if (!isEntryExpired(entry)) {
+        avatarCache.set(url, entry);
+        return entry.base64;
+      }
+    } catch (error) {
+    }
+    let finalBase64 = fallbackBase64[0];
+    try {
+      if (!ctx.canvas) {
+        throw new Error("Canvas service is not available.");
+      }
+      const buffer = await ctx.http.get(url, {
+        responseType: "arraybuffer",
+        timeout: 5e3
+      });
+      const image = await ctx.canvas.loadImage(buffer);
+      const canvas = await ctx.canvas.createCanvas(50, 50);
+      const context = canvas.getContext("2d");
+      context.drawImage(image, 0, 0, 50, 50);
+      finalBase64 = (await canvas.toBuffer("image/png")).toString("base64");
+    } catch (error) {
+      logger.warn(
+        `获取或处理头像失败 (URL: ${url})，将使用默认头像并缓存失败状态:`,
+        error.message || error
+      );
+    }
+    const newEntry = {
+      base64: finalBase64,
+      timestamp: now
+    };
+    try {
+      await fs.writeFile(cacheFilePath, JSON.stringify(newEntry));
+      avatarCache.set(url, newEntry);
+    } catch (cacheError) {
+      logger.error(
+        `无法写入头像缓存文件 (Path: ${cacheFilePath}):`,
+        cacheError
+      );
+    }
+    return newEntry.base64;
+  }
+  __name(getAvatarAsBase64, "getAvatarAsBase64");
+  async function reloadIconCache() {
+    iconCache = await loadAssetsFromFolder(iconsPath);
+    logger.info(`已加载 ${iconCache.length} 个用户图标。`);
+  }
+  __name(reloadIconCache, "reloadIconCache");
+  async function reloadBarBgImgCache() {
+    barBgImgCache = await loadAssetsFromFolder(barBgImgsPath);
+    logger.info(`已加载 ${barBgImgCache.length} 个柱状图背景图片。`);
+  }
+  __name(reloadBarBgImgCache, "reloadBarBgImgCache");
+  async function reloadFontCache() {
+    try {
+      await fs.access(fontsPath);
+      const files = await fs.readdir(fontsPath);
+      const usableFontBasenames = /* @__PURE__ */ new Set();
+      for (const file of files) {
+        if (file.toLowerCase().includes("-patched.")) {
+          continue;
+        }
+        const lowerCaseFile = file.toLowerCase();
+        if (lowerCaseFile.endsWith(".ttf") || lowerCaseFile.endsWith(".otf")) {
+          const filePath = import_path.default.join(fontsPath, file);
+          const usablePath = await patchAndGetUsableFontPath(filePath);
+          usableFontBasenames.add(import_path.default.basename(usablePath));
+        } else if (lowerCaseFile.endsWith(".woff2") || lowerCaseFile.endsWith(".woff")) {
+          usableFontBasenames.add(file);
+        }
+      }
+      fontFilesCache = [...usableFontBasenames];
+      logger.info(`已加载 ${fontFilesCache.length} 个可用字体文件。`);
+    } catch (error) {
+      logger.warn(`无法读取或重载字体目录 ${fontsPath}:`, error);
+      fontFilesCache = [];
+    }
+  }
+  __name(reloadFontCache, "reloadFontCache");
+  async function migrateFolder(oldPath, newPath) {
+    try {
+      await fs.access(oldPath, import_fs.constants.F_OK);
+      logger.info(`检测到旧资源文件夹: ${oldPath}，将迁移至: ${newPath}`);
+      const files = await fs.readdir(oldPath);
+      for (const file of files) {
+        const oldFile = import_path.default.join(oldPath, file);
+        const newFile = import_path.default.join(newPath, file);
+        try {
+          await fs.rename(oldFile, newFile);
+        } catch (renameError) {
+          if (renameError.code !== "EEXIST") {
+            logger.warn(`迁移文件 ${file} 失败:`, renameError);
+          }
+        }
+      }
+      await (0, import_koishi.sleep)(100);
+      await fs.rmdir(oldPath);
+      logger.info(`旧资源文件夹 ${oldPath} 迁移成功并已删除。`);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        logger.warn(`处理旧文件夹 ${oldPath} 时出错:`, error);
+      }
+    }
+  }
+  __name(migrateFolder, "migrateFolder");
+  async function copyAssetIfNotExists(sourceDir, destDir, filename) {
+    const destPath = import_path.default.join(destDir, filename);
+    try {
+      await fs.access(destPath, import_fs.constants.F_OK);
+    } catch {
+      const sourcePath = import_path.default.join(sourceDir, filename);
+      try {
+        await fs.access(sourcePath, import_fs.constants.F_OK);
+      } catch {
+        logger.warn(`插件资源文件未找到，无法拷贝: ${filename}`);
+        return;
+      }
+      await fs.copyFile(sourcePath, destPath);
+      logger.info(`已拷贝资源文件 ${filename} 到 ${destDir}`);
+    }
+  }
+  __name(copyAssetIfNotExists, "copyAssetIfNotExists");
+  function generateFontFacesCSS(fontFiles2) {
+    let css = "";
+    for (const file of fontFiles2) {
+      const rawFontName = import_path.default.parse(file).name.replace(/-patched$/i, "");
+      const ext = import_path.default.parse(file).ext.toLowerCase();
+      let format;
+      switch (ext) {
+        case ".woff2":
+          format = "woff2";
+          break;
+        case ".woff":
+          format = "woff";
+          break;
+        case ".ttf":
+          format = "truetype";
+          break;
+        case ".otf":
+          format = "opentype";
+          break;
+        default:
+          continue;
+      }
+      const fontUrl = `fonts/${file}`;
+      css += `
+        @font-face {
+          font-family: '${rawFontName}';
+          src: url("${fontUrl}") format('${format}');
+        }
+      `;
+    }
+    return css;
+  }
+  __name(generateFontFacesCSS, "generateFontFacesCSS");
+  async function loadAssetsFromFolder(folderPath) {
+    const assetData = [];
+    try {
+      await fs.access(folderPath, import_fs.constants.R_OK);
+      const files = await fs.readdir(folderPath);
+      for (const file of files) {
+        const userId = import_path.default.parse(file).name.split("-")[0].trim();
+        const filePath = import_path.default.join(folderPath, file);
+        try {
+          const fileData = await fs.readFile(filePath);
+          assetData.push({ userId, base64: fileData.toString("base64") });
+        } catch (readError) {
+          logger.warn(`Failed to read asset file ${filePath}:`, readError);
+        }
+      }
+    } catch (err) {
+      logger.warn(`Error accessing asset folder ${folderPath}:`, err);
+    }
+    return assetData;
+  }
+  __name(loadAssetsFromFolder, "loadAssetsFromFolder");
+  function aggregateChannelData(records, field) {
+    const channelPostCounts = {};
+    const channelInfo = {};
+    let totalCount = 0;
+    for (const record of records) {
+      const count = record[field] || 0;
+      channelPostCounts[record.channelId] = (channelPostCounts[record.channelId] || 0) + count;
+      if (!channelInfo[record.channelId]) {
+        channelInfo[record.channelId] = {
+          channelName: record.channelName || `群聊${record.channelId}`
+        };
+      }
+      totalCount += count;
+    }
+    return { channelPostCounts, channelInfo, totalCount };
+  }
+  __name(aggregateChannelData, "aggregateChannelData");
+  function prepareChannelRankingData(sortedChannels, channelInfo, totalCount, limit, currentChannelId) {
+    const topChannels = sortedChannels.slice(0, limit);
+    const isCurrentInTop = currentChannelId && topChannels.some(([channelId]) => channelId === currentChannelId);
+    if (currentChannelId && !isCurrentInTop) {
+      const currentChannelData = sortedChannels.find(
+        ([channelId]) => channelId === currentChannelId
+      );
+      if (currentChannelData) {
+        topChannels.push(currentChannelData);
+      }
+    }
+    return topChannels.map(([channelId, count]) => ({
+      // 增加★高亮当前群聊
+      name: (channelId === currentChannelId ? "★" : "") + (channelInfo[channelId]?.channelName || `群聊${channelId}`),
+      // 使用 channelId 作为 RankingData 的 userId 和头像源
+      userId: channelId,
+      avatar: `https://p.qlogo.cn/gh/${channelId === "#" ? "426230045" : channelId}/${channelId === "#" ? "426230045" : channelId}/100`,
+      // QQ群头像URL格式
+      count,
+      percentage: calculatePercentage(count, totalCount)
+    }));
+  }
+  __name(prepareChannelRankingData, "prepareChannelRankingData");
+  function _getChartBaseStyles() {
+    return `
+      html {
+        min-height: 100%;
+      }
+
+      body {
+        font-family: sans-serif;
+        margin: 0;
+        padding: 20px;
+        width: 100%;
+        min-height: 100%;
+        box-sizing: border-box;
+      }
+
+    .ranking-title {
+      text-align: center;
+      margin-bottom: 20px;
+      color: #333;
+      font-style: normal;
+    }
+
+      /* 预加载字体用，不显示 */
+      .font-preload {
+        display: none;
+      }
+    `;
+  }
+  __name(_getChartBaseStyles, "_getChartBaseStyles");
+  async function _prepareBackgroundStyle(config2) {
+    if (config2.backgroundType === "api" && config2.apiBackgroundConfig?.apiUrl) {
+      try {
+        const { apiUrl, apiKey, responseType } = config2.apiBackgroundConfig;
+        const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : {};
+        let backgroundImage;
+        switch (responseType) {
+          case "url": {
+            const response = await ctx.http.get(apiUrl, { headers });
+            const imageUrl = typeof response === "string" ? response : response?.url;
+            if (!imageUrl || typeof imageUrl !== "string") {
+              throw new Error(
+                'API response for "url" type is not a valid string.'
+              );
+            }
+            backgroundImage = `url('${imageUrl}')`;
+            break;
+          }
+          case "base64": {
+            const response = await ctx.http.get(apiUrl, { headers });
+            const base64Data = typeof response === "string" ? response : response?.data;
+            if (!base64Data || typeof base64Data !== "string") {
+              throw new Error(
+                'API response for "base64" type is not a valid string.'
+              );
+            }
+            const prefix = base64Data.startsWith("data:image") ? "" : "data:image/png;base64,";
+            backgroundImage = `url('${prefix}${base64Data}')`;
+            break;
+          }
+          case "binary":
+          default: {
+            const responseBuffer = await ctx.http.get(apiUrl, {
+              headers,
+              responseType: "arraybuffer"
+            });
+            const base64 = Buffer.from(responseBuffer).toString("base64");
+            backgroundImage = `url('data:image/png;base64,${base64}')`;
+            break;
+          }
+        }
+        return `html {
+          background-image: ${backgroundImage};
+          background-size: cover;
+          background-position: center;
+          background-repeat: no-repeat;
+        }`;
+      } catch (error) {
+        logger.error("获取 API 背景图失败，将使用默认背景:", error);
+      }
+    }
+    if (config2.backgroundType === "css" && config2.backgroundValue) {
+      return config2.backgroundValue;
+    }
+    return `html {
+      background: linear-gradient(135deg, #f6f8f9 0%, #e5ebee 100%);
+    }`;
+  }
+  __name(_prepareBackgroundStyle, "_prepareBackgroundStyle");
+  function _getClientScript() {
+    return `
+      async ({ rankingData, iconData, barBgImgs, config }) => {
+        // --- 主绘制函数 ---
+        async function drawRanking() {
+          const maxCount = rankingData.reduce((max, item) => Math.max(max, item.count), 0) || 1;
+          const userNum = rankingData.length;
+          const userAvatarSize = 50;
+          const tableWidth = 200 + 7 * 100; // 固定宽度
+          const canvasHeight = 50 * userNum;
+
+          const canvas = document.getElementById('rankingCanvas');
+          let context = canvas.getContext('2d');
+
+          // 根据最大计数的文本宽度动态调整画布宽度，以防数字溢出
+          context.font = \`30px "\${config.chartNicknameFont}", HarmonyOS_Sans_Medium, "Microsoft YaHei", sans-serif\`;
+          // 找到拥有最大发言数的条目，因为它的文本通常最长
+          const maxCountData = rankingData.find(d => d.count === maxCount) || rankingData[0] || { count: 1, percentage: 0 };
+          let maxCountText = maxCount.toString();
+          if (config.isUserMessagePercentageVisible && maxCountData) {
+              const percentage = maxCountData.percentage;
+              let percentageStr = percentage < 0.01 && percentage > 0 ? '<0.01' : percentage.toFixed(percentage < 1 ? 2 : 0);
+              maxCountText += \` ( \${percentageStr}%)\`;
+          }
+          const maxCountTextWidth = context.measureText(maxCountText).width;
+
+          // 最长进度条的宽度是固定的
+          const maxBarWidth = 150 + 700; // 进度条区域总宽度
+
+          // 计算最终画布宽度：头像(50) + 进度条(850) + 文本与进度条间距(10) + 文本宽度 + 右侧留白(20)
+          // 头像左侧的空白由页面 body 的 padding 提供
+          canvas.width = 50 + maxBarWidth + 10 + maxCountTextWidth + 20;
+          canvas.height = canvasHeight;
+
+          // 重新获取上下文，因为尺寸变化会重置状态
+          context = canvas.getContext('2d');
+
+          // 按顺序绘制图层
+          await drawRankingBars(context, maxCount, userAvatarSize, tableWidth); // 传递动态的 canvas.width
+          await drawAvatars(context, userAvatarSize);
+          drawVerticalLines(context, canvas.height, tableWidth); // 竖线仍然可以按旧的固定宽度绘制，不影响主体
+        }
+
+        // --- 核心绘图逻辑 ---
+
+        async function drawRankingBars(context, maxCount, userAvatarSize, canvasWidth) { // 接收 canvasWidth
+          for (const [index, data] of rankingData.entries()) {
+            const countBarWidth = 150 + (700 * data.count) / maxCount;
+            const countBarX = 50; // 头像宽度
+            const countBarY = 50 * index;
+
+            let avgColor = await getAverageColor(data.avatarBase64);
+            const colorWithOpacity = addOpacityToColor(avgColor, 0.5);
+
+            // 绘制底色进度条
+            context.fillStyle = avgColor;
+            context.fillRect(countBarX, countBarY, countBarWidth, userAvatarSize);
+
+            // 绘制自定义背景图
+            const userBarBgImgs = findAssets(data.userId, barBgImgs, 'barBgImgBase64');
+            if (userBarBgImgs.length > 0) {
+              const randomBarBgImgBase64 = userBarBgImgs[Math.floor(Math.random() * userBarBgImgs.length)];
+              avgColor = await drawCustomBarBackground(context, randomBarBgImgBase64, countBarX, countBarY, countBarWidth, userAvatarSize, canvasWidth); // 传递 canvasWidth
+            }
+
+            // 绘制剩余部分灰色背景
+            const remainingBarX = countBarX + countBarWidth;
+            // 确保灰色背景能填满到画布最右侧，减去文本区域
+            context.fillStyle = colorWithOpacity;
+            context.fillRect(remainingBarX, countBarY, canvasWidth - remainingBarX, userAvatarSize);
+
+            // 绘制文本和图标
+            await drawTextAndIcons(context, data, index, avgColor, countBarX, countBarY, countBarWidth, userAvatarSize);
+          }
+        }
+
+        async function drawCustomBarBackground(context, base64, x, y, barWidth, barHeight, canvasWidth) { // 接收 canvasWidth
+            return new Promise(async (resolve) => {
+                const barBgImg = new Image();
+                barBgImg.src = "data:image/png;base64," + base64;
+                barBgImg.onload = async () => {
+                    context.save();
+                    // 绘制整行背景（如果透明度 > 0）
+                    if (config.horizontalBarBackgroundFullOpacity > 0) {
+                        context.globalAlpha = config.horizontalBarBackgroundFullOpacity;
+                        context.drawImage(barBgImg, x, y, canvasWidth - x, barHeight); // 填充到画布右侧
+                    }
+                    // 绘制进度条区域背景
+                    context.globalAlpha = config.horizontalBarBackgroundOpacity;
+                    context.drawImage(barBgImg, 0, 0, barWidth, barHeight, x, y, barWidth, barHeight);
+                    context.restore();
+                    const newAvgColor = await getAverageColor(base64);
+                    resolve(newAvgColor);
+                };
+                barBgImg.onerror = async () => {
+                    const originalColor = await getAverageColor(base64);
+                    resolve(originalColor); // 发生错误则返回原始颜色
+                }
+            });
+        }
+
+        async function drawTextAndIcons(context, data, index, avgColor, barX, barY, barWidth, barHeight) {
+            // 字体栈包含了用户选择的字体、插件内置字体和通用字体，以确保兼容性。
+            context.font = \`30px "\${config.chartNicknameFont}", HarmonyOS_Sans_Medium, "Microsoft YaHei", sans-serif\`;
+            const textY = barY + barHeight / 2 + 10.5;
+
+
+            // 绘制发言次数和百分比
+            let countText = data.count.toString();
+            if (config.isUserMessagePercentageVisible) {
+                const percentage = data.percentage;
+                let percentageStr = percentage < 0.01 && percentage > 0 ? '<0.01' : percentage.toFixed(percentage < 1 ? 2 : 0);
+                countText += \` ( \${percentageStr}%)\`;
+            }
+
+            const countTextWidth = context.measureText(countText).width;
+            const countTextX = barX + barWidth + 10;
+
+            if (countTextX + countTextWidth > context.canvas.width - 5) {
+                context.fillStyle = chooseColorAdjustmentMethod(avgColor);
+                context.textAlign = "right";
+                context.fillText(countText, barX + barWidth - 10, textY);
+            } else {
+                context.fillStyle = "rgba(0, 0, 0, 1)";
+                context.textAlign = "left";
+                context.fillText(countText, countTextX, textY);
+            }
+
+            // 绘制用户名（带截断）
+            context.fillStyle = chooseColorAdjustmentMethod(avgColor);
+            context.textAlign = "left"; // 重置对齐方式，以防被上一部分修改
+
+            let nameText = data.name;
+            const maxNameWidth = barWidth - 60;
+            if (context.measureText(nameText).width > maxNameWidth) {
+                const ellipsis = "...";
+                while (context.measureText(nameText + ellipsis).width > maxNameWidth && nameText.length > 0) {
+                    nameText = nameText.slice(0, -1);
+                }
+                nameText += ellipsis;
+            }
+            const nameTextX = barX + 10;
+            context.fillText(nameText, nameTextX, textY);
+
+            // 绘制用户自定义图标
+            const userIcons = findAssets(data.userId, iconData, 'iconBase64');
+            if (userIcons.length > 0) {
+                await drawUserIcons(context, userIcons, {
+                    nameText: data.name, // 传递原始nameText用于计算位置
+                    nameTextX: context.measureText(nameText).width + nameTextX,
+                    barX: barX,
+                    barWidth: barWidth,
+                    textY: textY
+                });
+            }
+        }
+
+        async function drawUserIcons(context, icons, positions) {
+            const { nameTextX, barX, barWidth, textY } = positions;
+
+            // 使用 Promise.all 等待所有图片加载和绘制
+            await Promise.all(icons.map((iconBase64, i) => {
+                return new Promise((resolve, reject) => {
+                    const icon = new Image();
+                    icon.src = "data:image/png;base64," + iconBase64;
+                    icon.onload = () => {
+                        const iconSize = 40;
+                        const iconY = textY - 30;
+                        let iconX = config.shouldMoveIconToBarEndLeft
+                            ? barX + barWidth - (iconSize * (i + 1))
+                            : nameTextX + (iconSize * i) + 5;
+                        context.drawImage(icon, iconX, iconY, iconSize, iconSize);
+                        resolve(); // 图片绘制成功
+                    };
+                    icon.onerror = () => {
+                        resolve(); // 即使单个图标加载失败，也继续执行，不中断整个排行榜生成
+                    };
+                });
+            }));
+        }
+
+        async function drawAvatars(context, userAvatarSize) {
+          for (const [index, data] of rankingData.entries()) {
+            const image = new Image();
+            image.src = "data:image/png;base64," + data.avatarBase64;
+            // onload不是必需的，因为图片已是base64，但为了健壮性可以保留
+            await new Promise(resolve => {
+                image.onload = () => {
+                    context.drawImage(image, 0, 50 * index, userAvatarSize, userAvatarSize);
+                    resolve();
+                };
+                image.onerror = resolve; // 即使加载失败也继续
+            });
+          }
+        }
+
+        function drawVerticalLines(context, canvasHeight, tableWidth) {
+            context.fillStyle = "rgba(0, 0, 0, 0.12)";
+            const verticalLineWidth = 3;
+            const firstLineX = 200;
+            for (let i = 0; i < 8; i++) {
+                context.fillRect(firstLineX + 100 * i, 0, verticalLineWidth, canvasHeight);
+            }
+        }
+
+
+        // --- 辅助工具函数 ---
+
+        function findAssets(userId, assetList, key) {
+          return assetList
+            .filter(data => data.userId === userId)
+            .map(data => data[key]);
+        }
+
+        function addOpacityToColor(color, opacity) {
+          const opacityHex = Math.round(opacity * 255).toString(16).padStart(2, "0");
+          return \`\${color}\${opacityHex}\`;
+        }
+
+        function chooseColorAdjustmentMethod(hexcolor) {
+            const rgb = hexToRgb(hexcolor)
+            const yiqBrightness = calculateYiqBrightness(rgb)
+            if (yiqBrightness > 0.2 && yiqBrightness < 0.8) {
+                return adjustColorHsl(hexcolor)
+            } else {
+                return adjustColorYiq(hexcolor)
+            }
+        }
+
+        function calculateYiqBrightness(rgb) {
+            return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1000 / 255
+        }
+
+        function adjustColorYiq(hexcolor) {
+            const rgb = hexToRgb(hexcolor)
+            const yiqBrightness = calculateYiqBrightness(rgb)
+            return yiqBrightness >= 0.8 ? "#000000" : "#FFFFFF"
+        }
+
+        function adjustColorHsl(hexcolor) {
+            const rgb = hexToRgb(hexcolor)
+            let hsl = rgbToHsl(rgb.r, rgb.g, rgb.b)
+            hsl.l = hsl.l < 0.5 ? hsl.l + 0.3 : hsl.l - 0.3
+            hsl.s = hsl.s < 0.5 ? hsl.s + 0.3 : hsl.s - 0.3
+            const contrastRgb = hslToRgb(hsl.h, hsl.s, hsl.l)
+            return rgbToHex(contrastRgb.r, contrastRgb.g, contrastRgb.b)
+        }
+
+        function hexToRgb(hex) {
+            const sanitizedHex = String(hex).replace("#", "")
+            const bigint = parseInt(sanitizedHex, 16)
+            const r = (bigint >> 16) & 255
+            const g = (bigint >> 8) & 255
+            const b = bigint & 255
+            return {r, g, b}
+        }
+
+        function rgbToHsl(r, g, b) {
+            r /= 255, g /= 255, b /= 255
+            const max = Math.max(r, g, b), min = Math.min(r, g, b)
+            let h, s, l = (max + min) / 2
+            if (max === min) {
+                h = s = 0
+            } else {
+                const d = max - min
+                s = l > 0.5 ? d / (2 - max - min) : d / (max + min)
+                switch (max) {
+                    case r: h = (g - b) / d + (g < b ? 6 : 0); break
+                    case g: h = (b - r) / d + 2; break
+                    case b: h = (r - g) / d + 4; break
+                }
+                h /= 6
+            }
+            return {h, s, l}
+        }
+
+        function hslToRgb(h, s, l) {
+            let r, g, b
+            if (s === 0) {
+                r = g = b = l
+            } else {
+                const hue2rgb = (p, q, t) => {
+                    if (t < 0) t += 1
+                    if (t > 1) t -= 1
+                    if (t < 1 / 6) return p + (q - p) * 6 * t
+                    if (t < 1 / 2) return q
+                    if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6
+                    return p
+                }
+                const q = l < 0.5 ? l * (1 + s) : l + s - l * s
+                const p = 2 * l - q
+                r = hue2rgb(p, q, h + 1 / 3)
+                g = hue2rgb(p, q, h)
+                b = hue2rgb(p, q, h - 1 / 3)
+            }
+            return { r: Math.round(r * 255), g: Math.round(g * 255), b: Math.round(b * 255) }
+        }
+
+        function rgbToHex(r, g, b) {
+            const toHex = c => {
+                const hex = c.toString(16)
+                return hex.length === 1 ? "0" + hex : hex
+            }
+            return \`#\${toHex(r)}\${toHex(g)}\${toHex(b)}\`
+        }
+
+        async function getAverageColor(base64) {
+            const image = new Image();
+            image.src = "data:image/png;base64," + base64;
+            await new Promise(r => image.onload = r);
+
+            const canvas = document.createElement('canvas');
+            const ctx = canvas.getContext("2d", { willReadFrequently: true });
+            canvas.width = image.width; canvas.height = image.height;
+            ctx.drawImage(image, 0, 0);
+
+            const data = ctx.getImageData(0, 0, image.width, image.height).data;
+            let r = 0, g = 0, b = 0;
+
+            for (let i = 0; i < data.length; i += 4) {
+                r += data[i]; g += data[i+1]; b += data[i+2];
+            }
+            const count = data.length / 4;
+            r = ~~(r / count); g = ~~(g / count); b = ~~(b / count);
+
+            return \`#\${r.toString(16).padStart(2, "0")}\${g.toString(16).padStart(2, "0")}\${b.toString(16).padStart(2, "0")}\`;
+        }
+
+        // --- 启动绘制 ---
+        await drawRanking();
+      }
+    `;
+  }
+  __name(_getClientScript, "_getClientScript");
+  function _getChartHtmlContent(params) {
+    const {
+      rankTimeTitle,
+      rankTitle,
+      data,
+      iconCache: iconCache2,
+      barBgImgCache: barBgImgCache2,
+      backgroundStyle,
+      fontFacesCSS,
+      chartConfig
+    } = params;
+    const clientData = {
+      rankingData: data,
+      iconData: iconCache2.map((d) => ({
+        userId: d.userId,
+        iconBase64: d.base64
+      })),
+      barBgImgs: barBgImgCache2.map((d) => ({
+        userId: d.userId,
+        barBgImgBase64: d.base64
+      })),
+      config: chartConfig
+    };
+    return `
+      <!DOCTYPE html>
+      <html lang="zh-CN">
+      <head>
+          <meta charset="UTF--8">
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+          <title>排行榜</title>
+          <style>${_getChartBaseStyles()}</style>
+          <style>${backgroundStyle}</style>
+          <style>${fontFacesCSS}</style>
+          <style>
+            .ranking-title { font-family: "${chartConfig.chartTitleFont}", "Microsoft YaHei", sans-serif; }
+          </style>
+      </head>
+      <body>
+          <h1 class="ranking-title">${rankTimeTitle}</h1>
+          <h1 class="ranking-title">${rankTitle}</h1>
+          <div class="font-preload">
+            <span style="font-family: '${chartConfig.chartNicknameFont}';">预加载</span>
+            <span style="font-family: '${chartConfig.chartTitleFont}';">预加载</span>
+          </div>
+          <canvas id="rankingCanvas"></canvas>
+          <script>
+            // 立即执行的异步函数，用于绘制图表
+            (async () => {
+              const drawFunction = ${_getClientScript()};
+              await drawFunction(${JSON.stringify(clientData)});
+            })();
+          </script>
+      </body>
+      </html>
+    `;
+  }
+  __name(_getChartHtmlContent, "_getChartHtmlContent");
+  async function generateRankingChart({
+    rankTimeTitle,
+    rankTitle,
+    data
+  }, {
+    iconCache: iconCache2,
+    barBgImgCache: barBgImgCache2,
+    fontFilesCache: fontFilesCache2,
+    emptyHtmlPath: emptyHtmlPath2
+  }) {
+    if (!ctx.puppeteer) {
+      throw new Error("Puppeteer 服务未启用，无法生成图表。");
+    }
+    const browser = ctx.puppeteer.browser;
+    if (!browser) {
+      throw new Error("Puppeteer 浏览器实例不可用。");
+    }
+    const page = await browser.newPage();
+    try {
+      const fontFaces = generateFontFacesCSS(fontFilesCache2);
+      const backgroundStyle = await _prepareBackgroundStyle(config);
+      const chartConfigForClient = {
+        shouldMoveIconToBarEndLeft: config.shouldMoveIconToBarEndLeft,
+        horizontalBarBackgroundOpacity: config.horizontalBarBackgroundOpacity,
+        horizontalBarBackgroundFullOpacity: config.horizontalBarBackgroundFullOpacity,
+        isUserMessagePercentageVisible: config.isUserMessagePercentageVisible,
+        chartTitleFont: config.chartTitleFont,
+        chartNicknameFont: config.chartNicknameFont
+      };
+      const htmlContent = _getChartHtmlContent({
+        rankTimeTitle,
+        rankTitle,
+        data,
+        iconCache: iconCache2,
+        barBgImgCache: barBgImgCache2,
+        backgroundStyle,
+        fontFacesCSS: fontFaces,
+        chartConfig: chartConfigForClient
+      });
+      const pageUrl = emptyHtmlPath2.includes(":") ? `file:///${emptyHtmlPath2}` : `file://${emptyHtmlPath2}`;
+      await page.goto(pageUrl, { waitUntil: "load" });
+      await page.setContent(import_koishi.h.unescape(htmlContent), {
+        waitUntil: config.waitUntil
+      });
+      const calculatedWidth = await page.evaluate(() => {
+        const canvas = document.getElementById(
+          "rankingCanvas"
+        );
+        const bodyPadding = 40;
+        return canvas ? canvas.width + bodyPadding : 1080;
+      });
+      await page.setViewport({
+        // 使用客户端计算出的宽度，但确保不小于用户在配置中设定的值
+        width: Math.max(config.chartViewportWidth, Math.ceil(calculatedWidth)),
+        // 高度在这里是次要的，因为 fullPage: true 会自动调整，但设置一个合理的值可以避免潜在问题
+        height: 256,
+        deviceScaleFactor: config.deviceScaleFactor
+      });
+      const imageBuffer = await page.screenshot({
+        type: config.imageType,
+        fullPage: true
+      });
+      return imageBuffer;
+    } catch (error) {
+      logger.error("生成排行榜图表时发生错误:", error);
+      throw error;
+    } finally {
+      await page.close();
+    }
+  }
+  __name(generateRankingChart, "generateRankingChart");
+  function getUserRankAndRecord(getDragons, userId, postCountType) {
+    if (getDragons.length === 0) {
+      return;
+    }
+    const aggregatedUserRecords = getDragons.reduce((acc, user) => {
+      if (!acc[user.userId]) {
+        acc[user.userId] = {
+          userId: user.userId,
+          postCountAll: 0,
+          username: user.username
+        };
+      }
+      let postCount = 0;
+      switch (postCountType) {
+        case "todayPostCount":
+          postCount = user.todayPostCount;
+          break;
+        case "thisWeekPostCount":
+          postCount = user.thisWeekPostCount;
+          break;
+        case "thisMonthPostCount":
+          postCount = user.thisMonthPostCount;
+          break;
+        case "thisYearPostCount":
+          postCount = user.thisYearPostCount;
+          break;
+        case "totalPostCount":
+          postCount = user.totalPostCount;
+          break;
+        case "yesterdayPostCount":
+          postCount = user.yesterdayPostCount;
+          break;
+        default:
+          postCount = user.todayPostCount;
+          break;
+      }
+      acc[user.userId].postCountAll += postCount;
+      return acc;
+    }, {});
+    const sortedUserRecords = Object.values(aggregatedUserRecords).sort(
+      (a, b) => b.postCountAll - a.postCountAll
+    );
+    const userIndex = sortedUserRecords.findIndex(
+      (user) => user.userId === userId
+    );
+    const userRecord = sortedUserRecords[userIndex];
+    const acrossRank = userIndex + 1;
+    return { acrossRank, userRecord };
+  }
+  __name(getUserRankAndRecord, "getUserRankAndRecord");
+  function getSortedDragons(records) {
+    const dragonsMap = {};
+    for (const dragon of records) {
+      const { userId, totalPostCount } = dragon;
+      const key = `${userId}`;
+      dragonsMap[key] = (dragonsMap[key] || 0) + totalPostCount;
+    }
+    return Object.entries(dragonsMap).sort((a, b) => b[1] - a[1]);
+  }
+  __name(getSortedDragons, "getSortedDragons");
+  async function replaceAtTags(session, content) {
+    const atRegex = /<at id="([^"]+)"(?: name="([^"]*)")?\/>/g;
+    let match;
+    while ((match = atRegex.exec(content)) !== null) {
+      const userId = match[1];
+      const name2 = match[2];
+      if (!name2) {
+        let userName = "未知用户";
+        try {
+          if (typeof session.bot?.getChannelMember === "function" && session.channelId) {
+            const channelMember = await session.bot.getChannelMember(
+              session.channelId,
+              userId
+            );
+            if (channelMember && channelMember.user && channelMember.user.name) {
+              userName = channelMember.user.name;
+            }
+          }
+        } catch (error) {
+          logger.error(error);
+        }
+        const newAtTag = `<at id="${userId}" name="${userName}"/>`;
+        content = content.replace(match[0], newAtTag);
+      }
+    }
+    return content;
+  }
+  __name(replaceAtTags, "replaceAtTags");
+  async function getChannelName(bot, channelId) {
+    if (bot.platform === "qq") {
+      return void 0;
+    }
+    try {
+      const channel = await bot.getChannel(channelId);
+      return channel?.name;
+    } catch (error) {
+      logger.warn(`Failed to get channelId name for ${channelId}:`, error);
+      return void 0;
+    }
+  }
+  __name(getChannelName, "getChannelName");
+  function parseList(str) {
+    if (!str) return [];
+    return str.split(/[\s,，、]+/).filter(Boolean);
+  }
+  __name(parseList, "parseList");
+  function getPeriodFromOptions(options, fallback) {
+    if (options?.yesterday || options?.ydag) return "yesterday";
+    if (options?.day || options?.dag) return "today";
+    if (options?.week || options?.wag) return "week";
+    if (options?.month || options?.mag) return "month";
+    if (options?.year || options?.yag) return "year";
+    if (options?.total || options?.across || options?.dragon) return "total";
+    return fallback;
+  }
+  __name(getPeriodFromOptions, "getPeriodFromOptions");
+  function isAcrossChannel(options) {
+    return ["ydag", "dag", "wag", "mag", "yag", "across", "dragon"].some(
+      (opt) => options?.[opt]
+    );
+  }
+  __name(isAcrossChannel, "isAcrossChannel");
+  function filterRecordsByWhitesAndBlacks(records, key, whites, blacks) {
+    let result = records;
+    if (whites.length > 0) {
+      result = result.filter((r) => whites.includes(r[key]));
+    }
+    if (blacks.length > 0) {
+      result = result.filter((r) => !blacks.includes(r[key]));
+    }
+    return result;
+  }
+  __name(filterRecordsByWhitesAndBlacks, "filterRecordsByWhitesAndBlacks");
+  function prepareRankingData(sortedUsers, userInfo, totalCount, limit, requesterId) {
+    const topUsers = sortedUsers.slice(0, limit);
+    const isRequesterInTop = requesterId && topUsers.some(([userId]) => userId === requesterId);
+    if (requesterId && !isRequesterInTop) {
+      const requesterData = sortedUsers.find(
+        ([userId]) => userId === requesterId
+      );
+      if (requesterData) {
+        topUsers.push(requesterData);
+      }
+    }
+    return topUsers.map(([userId, count]) => ({
+      // 增加★高亮指令发送者
+      name: (userId === requesterId ? "★" : "") + userInfo[userId].username,
+      userId,
+      avatar: userInfo[userId].avatar,
+      count,
+      percentage: calculatePercentage(count, totalCount)
+    }));
+  }
+  __name(prepareRankingData, "prepareRankingData");
+  function calculatePercentage(number, total) {
+    if (total === 0) return 0;
+    return number / total * 100;
+  }
+  __name(calculatePercentage, "calculatePercentage");
+  function getCurrentBeijingTime() {
+    return (/* @__PURE__ */ new Date()).toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" });
+  }
+  __name(getCurrentBeijingTime, "getCurrentBeijingTime");
+  async function renderLeaderboard({
+    rankTimeTitle,
+    rankTitle,
+    rankingData
+  }) {
+    if (config.isLeaderboardToHorizontalBarChartConversionEnabled) {
+      if (!ctx.puppeteer) {
+        logger.warn("Puppeteer service is not enabled. Falling back to text.");
+      } else {
+        try {
+          const chartReadyData = rankingData.map((item) => {
+            const newItem = { ...item };
+            if (!config.showStarInChart && newItem.name.startsWith("★")) {
+              newItem.name = newItem.name.substring(1);
+            }
+            return newItem;
+          });
+          await Promise.all(
+            chartReadyData.map(async (item) => {
+              item.avatarBase64 = await getAvatarAsBase64(item.avatar);
+            })
+          );
+          const imageBuffer = await generateRankingChart(
+            { rankTimeTitle, rankTitle, data: chartReadyData },
+            { iconCache, barBgImgCache, fontFilesCache, emptyHtmlPath }
+          );
+          return import_koishi.h.image(imageBuffer, `image/${config.imageType}`);
+        } catch (error) {
+          logger.error("Failed to generate leaderboard chart:", error);
+        }
+      }
+    }
+    if (config.isTextToImageConversionEnabled) {
+      if (!ctx.markdownToImage) {
+        logger.warn(
+          "markdownToImage service is not enabled. Falling back to text."
+        );
+      } else {
+        const markdown = formatLeaderboardAsMarkdown(
+          rankTimeTitle,
+          rankTitle,
+          rankingData,
+          config.isUserMessagePercentageVisible
+        );
+        const imageBuffer = await ctx.markdownToImage.convertToImage(markdown);
+        return import_koishi.h.image(imageBuffer, `image/${config.imageType}`);
+      }
+    }
+    return formatLeaderboardAsText(
+      rankTimeTitle,
+      rankTitle,
+      rankingData,
+      config.isUserMessagePercentageVisible
+    );
+  }
+  __name(renderLeaderboard, "renderLeaderboard");
+  function formatLeaderboardAsMarkdown(title, subtitle, data, showPercentage) {
+    let result = `# ${title}
+## ${subtitle}
+
+`;
+    data.forEach((item, index) => {
+      const percentageStr = showPercentage ? ` (${Math.round(item.percentage)}%)` : "";
+      result += `${index + 1}. **${item.name}**: ${item.count} 次${percentageStr}
+`;
+    });
+    return result;
+  }
+  __name(formatLeaderboardAsMarkdown, "formatLeaderboardAsMarkdown");
+  function formatLeaderboardAsText(title, subtitle, data, showPercentage) {
+    let result = `${title}
+${subtitle}
+
+`;
+    data.forEach((item, index) => {
+      const percentageStr = showPercentage ? ` (${Math.round(item.percentage)}%)` : "";
+      result += `${index + 1}. ${item.name}：${item.count} 次${percentageStr}
+`;
+    });
+    return result.trim();
+  }
+  __name(formatLeaderboardAsText, "formatLeaderboardAsText");
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  inject,
+  name,
+  usage
+});