koishi-plugin-aka-ai-generator 0.0.1 → 0.0.4

package/lib/index.js

@@ -0,0 +1,1356 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  name: () => name
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi = require("koishi");
+var import_fs = require("fs");
+var import_path = require("path");
+
+// src/providers/yunwu.ts
+async function downloadImageAsBase64(ctx, url, timeout, logger) {
+  try {
+    const response = await ctx.http.get(url, {
+      responseType: "arraybuffer",
+      timeout: timeout * 1e3
+    });
+    const buffer = Buffer.from(response);
+    const base64 = buffer.toString("base64");
+    let mimeType = "image/jpeg";
+    const contentType = response.headers?.["content-type"] || response.headers?.["Content-Type"];
+    if (contentType && contentType.startsWith("image/")) {
+      mimeType = contentType;
+    } else {
+      const urlLower = url.toLowerCase();
+      if (urlLower.endsWith(".png")) {
+        mimeType = "image/png";
+      } else if (urlLower.endsWith(".webp")) {
+        mimeType = "image/webp";
+      } else if (urlLower.endsWith(".gif")) {
+        mimeType = "image/gif";
+      }
+    }
+    logger.debug("图片下载并转换为Base64", { url, mimeType, size: base64.length });
+    return { data: base64, mimeType };
+  } catch (error) {
+    logger.error("下载图片失败", { url, error });
+    throw new Error("下载图片失败，请检查图片链接是否有效");
+  }
+}
+__name(downloadImageAsBase64, "downloadImageAsBase64");
+function parseYunwuResponse(response) {
+  try {
+    const images = [];
+    if (response.candidates && response.candidates.length > 0) {
+      for (const candidate of response.candidates) {
+        if (candidate.content && candidate.content.parts) {
+          for (const part of candidate.content.parts) {
+            if (part.inlineData && part.inlineData.data) {
+              const base64Data = part.inlineData.data;
+              const mimeType = part.inlineData.mimeType || "image/jpeg";
+              const dataUrl = `data:${mimeType};base64,${base64Data}`;
+              images.push(dataUrl);
+            } else if (part.inline_data && part.inline_data.data) {
+              const base64Data = part.inline_data.data;
+              const mimeType = part.inline_data.mime_type || "image/jpeg";
+              const dataUrl = `data:${mimeType};base64,${base64Data}`;
+              images.push(dataUrl);
+            } else if (part.fileData && part.fileData.fileUri) {
+              images.push(part.fileData.fileUri);
+            }
+          }
+        }
+      }
+    }
+    return images;
+  } catch (error) {
+    return [];
+  }
+}
+__name(parseYunwuResponse, "parseYunwuResponse");
+var YunwuProvider = class {
+  static {
+    __name(this, "YunwuProvider");
+  }
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async generateImages(prompt, imageUrls, numImages) {
+    const urls = Array.isArray(imageUrls) ? imageUrls : [imageUrls];
+    const logger = this.config.logger;
+    const ctx = this.config.ctx;
+    logger.debug("开始下载图片并转换为Base64", { urls });
+    const imageParts = [];
+    for (const url of urls) {
+      const { data, mimeType } = await downloadImageAsBase64(
+        ctx,
+        url,
+        this.config.apiTimeout,
+        logger
+      );
+      imageParts.push({
+        inline_data: {
+          mime_type: mimeType,
+          data
+        }
+      });
+    }
+    const allImages = [];
+    for (let i = 0; i < numImages; i++) {
+      const requestData = {
+        contents: [
+          {
+            role: "user",
+            parts: [
+              { text: prompt },
+              ...imageParts
+            ]
+          }
+        ],
+        generationConfig: {
+          responseModalities: ["IMAGE"]
+        }
+      };
+      logger.debug("调用云雾图像编辑 API", { prompt, imageCount: urls.length, numImages, current: i + 1 });
+      try {
+        const response = await ctx.http.post(
+          `https://yunwu.ai/v1beta/models/${this.config.modelId}:generateContent`,
+          requestData,
+          {
+            headers: {
+              "Content-Type": "application/json"
+            },
+            params: {
+              key: this.config.apiKey
+            },
+            timeout: this.config.apiTimeout * 1e3
+          }
+        );
+        const images = parseYunwuResponse(response);
+        allImages.push(...images);
+        logger.success("云雾图像编辑 API 调用成功", { current: i + 1, total: numImages });
+      } catch (error) {
+        logger.error("云雾图像编辑 API 调用失败", {
+          message: error?.message || "未知错误",
+          code: error?.code,
+          status: error?.response?.status,
+          current: i + 1,
+          total: numImages
+        });
+        if (allImages.length > 0) {
+          logger.warn("部分图片生成失败，返回已生成的图片", { generated: allImages.length, requested: numImages });
+          break;
+        }
+        throw new Error("图像处理API调用失败");
+      }
+    }
+    return allImages;
+  }
+};
+
+// src/providers/gptgod.ts
+var GPTGOD_DEFAULT_API_URL = "https://api.gptgod.online/v1/chat/completions";
+async function downloadImageAsBase642(ctx, url, timeout, logger) {
+  try {
+    const response = await ctx.http.get(url, {
+      responseType: "arraybuffer",
+      timeout: timeout * 1e3
+    });
+    const buffer = Buffer.from(response);
+    const base64 = buffer.toString("base64");
+    let mimeType = "image/jpeg";
+    const contentType = response.headers?.["content-type"] || response.headers?.["Content-Type"];
+    if (contentType && contentType.startsWith("image/")) {
+      mimeType = contentType;
+    } else {
+      const urlLower = url.toLowerCase();
+      if (urlLower.endsWith(".png")) {
+        mimeType = "image/png";
+      } else if (urlLower.endsWith(".webp")) {
+        mimeType = "image/webp";
+      } else if (urlLower.endsWith(".gif")) {
+        mimeType = "image/gif";
+      }
+    }
+    if (logger) {
+      logger.debug("图片下载并转换为Base64", { url, mimeType, size: base64.length });
+    }
+    return { data: base64, mimeType };
+  } catch (error) {
+    logger.error("下载图片失败", { url, error });
+    throw new Error("下载图片失败，请检查图片链接是否有效");
+  }
+}
+__name(downloadImageAsBase642, "downloadImageAsBase64");
+function parseGptGodResponse(response, logger) {
+  try {
+    const images = [];
+    if (Array.isArray(response.images)) {
+      if (logger) {
+        logger.debug("从 response.images 数组提取图片", { count: response.images.length });
+      }
+      return response.images;
+    }
+    if (response.image && typeof response.image === "string") {
+      if (response.image.startsWith("data:") || response.image.startsWith("http")) {
+        if (logger) {
+          logger.debug("从 response.image 提取图片");
+        }
+        images.push(response.image);
+        return images;
+      }
+    }
+    if (response?.choices?.length > 0) {
+      const firstChoice = response.choices[0];
+      const messageContent = firstChoice.message?.content;
+      let contentText = "";
+      if (typeof messageContent === "string") {
+        contentText = messageContent;
+      } else if (Array.isArray(messageContent)) {
+        for (const part of messageContent) {
+          if (part?.type === "image_url" && part?.image_url?.url) {
+            if (logger) {
+              logger.debug("从 content 数组的 image_url 提取图片");
+            }
+            images.push(part.image_url.url);
+          } else if (part?.type === "text" && part?.text) {
+            contentText += part.text + "\n";
+          } else if (part?.text) {
+            contentText += part.text + "\n";
+          }
+        }
+      } else if (messageContent?.text) {
+        contentText = messageContent.text;
+      }
+      if (images.length > 0) {
+        return images;
+      }
+      if (contentText) {
+        const mdImageRegex = /!\[.*?\]\((https?:\/\/[^\)]+)\)/g;
+        let match;
+        while ((match = mdImageRegex.exec(contentText)) !== null) {
+          images.push(match[1]);
+        }
+        if (images.length === 0) {
+          const urlRegex = /(https?:\/\/[^\s"')<>]+\.(?:png|jpg|jpeg|webp|gif|bmp))/gi;
+          let urlMatch;
+          while ((urlMatch = urlRegex.exec(contentText)) !== null) {
+            images.push(urlMatch[1]);
+          }
+        }
+        if (images.length === 0 && contentText.trim().startsWith("http")) {
+          const trimmedUrl = contentText.trim().split(/\s/)[0];
+          if (trimmedUrl.match(/^https?:\/\//)) {
+            images.push(trimmedUrl);
+          }
+        }
+        const dataUrlRegex = /(data:image\/[^;]+;base64,[^\s"')<>]+)/gi;
+        let dataUrlMatch;
+        while ((dataUrlMatch = dataUrlRegex.exec(contentText)) !== null) {
+          images.push(dataUrlMatch[1]);
+        }
+      }
+      if (images.length === 0 && firstChoice.message) {
+        if (firstChoice.message.image_url) {
+          if (logger) {
+            logger.debug("从 message.image_url 提取图片");
+          }
+          images.push(firstChoice.message.image_url);
+        }
+        if (Array.isArray(firstChoice.message.images)) {
+          if (logger) {
+            logger.debug("从 message.images 数组提取图片", { count: firstChoice.message.images.length });
+          }
+          return firstChoice.message.images;
+        }
+      }
+    }
+    if (images.length === 0) {
+      if (response.data) {
+        if (Array.isArray(response.data)) {
+          const dataImages = response.data.filter(
+            (item) => item?.url || item?.image_url || typeof item === "string" && (item.startsWith("http") || item.startsWith("data:"))
+          ).map((item) => item?.url || item?.image_url || item);
+          if (dataImages.length > 0) {
+            if (logger) {
+              logger.debug("从 response.data 数组提取图片", { count: dataImages.length });
+            }
+            return dataImages;
+          }
+        } else if (response.data.url || response.data.image_url) {
+          if (logger) {
+            logger.debug("从 response.data 提取图片");
+          }
+          images.push(response.data.url || response.data.image_url);
+        }
+      }
+      if (response.result) {
+        if (Array.isArray(response.result)) {
+          const resultImages = response.result.filter(
+            (item) => item?.url || item?.image_url || typeof item === "string" && (item.startsWith("http") || item.startsWith("data:"))
+          ).map((item) => item?.url || item?.image_url || item);
+          if (resultImages.length > 0) {
+            if (logger) {
+              logger.debug("从 response.result 数组提取图片", { count: resultImages.length });
+            }
+            return resultImages;
+          }
+        } else if (typeof response.result === "string" && (response.result.startsWith("http") || response.result.startsWith("data:"))) {
+          if (logger) {
+            logger.debug("从 response.result 提取图片");
+          }
+          images.push(response.result);
+        }
+      }
+    }
+    if (images.length > 0) {
+      if (logger) {
+        logger.debug("成功提取图片", { count: images.length });
+      }
+    } else {
+      if (logger) {
+        logger.warn("未能从响应中提取图片", {
+          responseStructure: {
+            hasChoices: !!response?.choices,
+            hasImages: !!response?.images,
+            hasImage: !!response?.image,
+            hasData: !!response?.data,
+            hasResult: !!response?.result,
+            keys: Object.keys(response || {})
+          }
+        });
+      }
+    }
+    return images;
+  } catch (error) {
+    logger?.error("解析响应时出错", { error });
+    return [];
+  }
+}
+__name(parseGptGodResponse, "parseGptGodResponse");
+var GptGodProvider = class {
+  static {
+    __name(this, "GptGodProvider");
+  }
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async generateImages(prompt, imageUrls, numImages) {
+    const urls = Array.isArray(imageUrls) ? imageUrls : [imageUrls];
+    const logger = this.config.logger;
+    const ctx = this.config.ctx;
+    if (!this.config.apiKey) {
+      throw new Error("GPTGod 配置不完整，请检查 API Key");
+    }
+    if (this.config.logLevel === "debug") {
+      logger.debug("调用 GPTGod 图像编辑 API", { prompt, imageCount: urls.length, numImages });
+    }
+    const contentParts = [
+      {
+        type: "text",
+        text: `${prompt}
+请生成 ${numImages} 张图片。`
+      }
+    ];
+    for (const url of urls) {
+      const { data, mimeType } = await downloadImageAsBase642(
+        ctx,
+        url,
+        this.config.apiTimeout,
+        logger
+      );
+      contentParts.push({
+        type: "image_url",
+        image_url: {
+          url: `data:${mimeType};base64,${data}`
+        }
+      });
+    }
+    const requestData = {
+      model: this.config.modelId,
+      stream: false,
+      n: numImages,
+      // 使用 n 参数指定生成数量
+      messages: [
+        {
+          role: "user",
+          content: contentParts
+        }
+      ]
+    };
+    try {
+      const response = await ctx.http.post(
+        GPTGOD_DEFAULT_API_URL,
+        requestData,
+        {
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${this.config.apiKey}`
+          },
+          timeout: this.config.apiTimeout * 1e3
+        }
+      );
+      logger.success("GPTGod 图像编辑 API 调用成功");
+      if (this.config.logLevel === "debug") {
+        logger.debug("GPTGod API 响应结构", {
+          hasChoices: !!response?.choices,
+          choicesLength: response?.choices?.length,
+          hasImages: !!response?.images,
+          hasImage: !!response?.image,
+          responseKeys: Object.keys(response || {}),
+          firstChoiceContent: response?.choices?.[0]?.message?.content ? typeof response.choices[0].message.content === "string" ? response.choices[0].message.content.substring(0, 200) : JSON.stringify(response.choices[0].message.content).substring(0, 200) : "none"
+        });
+      }
+      const images = parseGptGodResponse(response, this.config.logLevel === "debug" ? logger : null);
+      if (images.length < numImages) {
+        const warnData = {
+          requested: numImages,
+          received: images.length
+        };
+        if (this.config.logLevel === "debug") {
+          warnData.responsePreview = JSON.stringify(response).substring(0, 500);
+        }
+        logger.warn("生成的图片数量不足", warnData);
+      }
+      return images;
+    } catch (error) {
+      logger.error("GPTGod 图像编辑 API 调用失败", {
+        message: error?.message || "未知错误",
+        code: error?.code,
+        status: error?.response?.status,
+        data: error?.response?.data
+      });
+      throw new Error("图像处理API调用失败");
+    }
+  }
+};
+
+// src/providers/index.ts
+function createImageProvider(config) {
+  switch (config.provider) {
+    case "yunwu":
+      return new YunwuProvider({
+        apiKey: config.yunwuApiKey,
+        modelId: config.yunwuModelId,
+        apiTimeout: config.apiTimeout,
+        logLevel: config.logLevel,
+        logger: config.logger,
+        ctx: config.ctx
+      });
+    case "gptgod":
+      return new GptGodProvider({
+        apiKey: config.gptgodApiKey,
+        modelId: config.gptgodModelId,
+        apiTimeout: config.apiTimeout,
+        logLevel: config.logLevel,
+        logger: config.logger,
+        ctx: config.ctx
+      });
+    default:
+      throw new Error(`不支持的供应商类型: ${config.provider}`);
+  }
+}
+__name(createImageProvider, "createImageProvider");
+
+// src/index.ts
+var name = "aka-ai-generator";
+var COMMANDS = {
+  GENERATE_IMAGE: "生成图像",
+  COMPOSE_IMAGE: "合成图像",
+  QUERY_QUOTA: "图像额度",
+  RECHARGE: "图像充值",
+  RECHARGE_HISTORY: "图像充值记录",
+  FUNCTION_LIST: "图像功能"
+};
+var Config = import_koishi.Schema.intersect([
+  import_koishi.Schema.object({
+    provider: import_koishi.Schema.union([
+      import_koishi.Schema.const("yunwu").description("云雾 Gemini 服务"),
+      import_koishi.Schema.const("gptgod").description("GPTGod 服务")
+    ]).default("yunwu").description("图像生成供应商"),
+    yunwuApiKey: import_koishi.Schema.string().description("云雾API密钥").role("secret").required(),
+    yunwuModelId: import_koishi.Schema.string().default("gemini-2.5-flash-image").description("云雾图像生成模型ID"),
+    gptgodApiKey: import_koishi.Schema.string().description("GPTGod API 密钥").role("secret").default(""),
+    gptgodModelId: import_koishi.Schema.string().default("nano-banana").description("GPTGod 模型ID"),
+    apiTimeout: import_koishi.Schema.number().default(120).description("API请求超时时间（秒）"),
+    commandTimeout: import_koishi.Schema.number().default(180).description("命令执行总超时时间（秒）"),
+    // 默认设置
+    defaultNumImages: import_koishi.Schema.number().default(1).min(1).max(4).description("默认生成图片数量"),
+    // 配额设置
+    dailyFreeLimit: import_koishi.Schema.number().default(5).min(1).max(100).description("每日免费调用次数"),
+    // 限流设置
+    rateLimitWindow: import_koishi.Schema.number().default(300).min(60).max(3600).description("限流时间窗口（秒）"),
+    rateLimitMax: import_koishi.Schema.number().default(3).min(1).max(20).description("限流窗口内最大调用次数"),
+    // 管理员设置
+    adminUsers: import_koishi.Schema.array(import_koishi.Schema.string()).default([]).description("管理员用户ID列表（不受每日使用限制）"),
+    // 日志级别设置
+    logLevel: import_koishi.Schema.union([
+      import_koishi.Schema.const("info").description("普通信息"),
+      import_koishi.Schema.const("debug").description("完整的debug信息")
+    ]).default("info").description("日志输出详细程度")
+  }),
+  // 自定义风格命令配置
+  import_koishi.Schema.object({
+    styles: import_koishi.Schema.array(import_koishi.Schema.object({
+      commandName: import_koishi.Schema.string().required().description("命令名称（不含前缀斜杠）"),
+      commandDescription: import_koishi.Schema.string().required().description("命令描述"),
+      prompt: import_koishi.Schema.string().role("textarea", { rows: 4 }).required().description("生成 prompt"),
+      enabled: import_koishi.Schema.boolean().default(true).description("是否启用此命令")
+    })).role("table").default([
+      {
+        commandName: "变手办",
+        commandDescription: "转换为手办风格",
+        prompt: "将这张照片变成手办模型。在它后面放置一个印有图像主体的盒子，桌子上有一台电脑显示Blender建模过程。在盒子前面添加一个圆形塑料底座，角色手办站在上面。如果可能的话，将场景设置在室内",
+        enabled: true
+      },
+      {
+        commandName: "变写实",
+        commandDescription: "以真实摄影风格重建主体",
+        prompt: "请根据用户提供的图片，在保持主体身份、外观与姿态的前提下生成一张超写实的摄影作品。确保光影、皮肤质感、服饰纹理与背景环境都贴近真实世界，可以适度优化噪点与瑕疵，但不要改变主体特征或添加额外元素，整体效果需像专业摄影棚拍摄。",
+        enabled: true
+      },
+      {
+        commandName: "角色设定",
+        commandDescription: "生成人物角色设定",
+        prompt: "为我生成人物的角色设定（Character Design）, 比例设定（不同身高对比、头身比等）, 三视图（正面、侧面、背面）, 表情设定（Expression Sheet） , 动作设定（Pose Sheet） → 各种常见姿势, 服装设定（Costume Design）",
+        enabled: true
+      },
+      {
+        commandName: "道具设定",
+        commandDescription: "生成游戏道具设定（武器、载具等）",
+        prompt: "为我生成游戏道具的完整设定（Prop/Item Design），包含以下内容：功能结构图（Functional Components）、状态变化展示（State Variations）、细节特写（Detail Close-ups）",
+        enabled: true
+      }
+    ]).description("自定义风格命令配置")
+  })
+]);
+function apply(ctx, config) {
+  const logger = ctx.logger("aka-ai-generator");
+  const activeTasks = /* @__PURE__ */ new Map();
+  const rateLimitMap = /* @__PURE__ */ new Map();
+  const imageProvider = createImageProvider({
+    provider: config.provider,
+    yunwuApiKey: config.yunwuApiKey,
+    yunwuModelId: config.yunwuModelId,
+    gptgodApiKey: config.gptgodApiKey,
+    gptgodModelId: config.gptgodModelId,
+    apiTimeout: config.apiTimeout,
+    logLevel: config.logLevel,
+    logger,
+    ctx
+  });
+  function getStyleCommands() {
+    if (!config.styles || !Array.isArray(config.styles)) return [];
+    return config.styles.filter((style) => style.enabled && style.commandName && style.prompt).map((style) => ({
+      name: style.commandName,
+      description: style.commandDescription || "图像风格转换"
+    }));
+  }
+  __name(getStyleCommands, "getStyleCommands");
+  const commandRegistry = {
+    // 非管理员指令（包含动态风格指令）
+    userCommands: [
+      ...getStyleCommands(),
+      { name: COMMANDS.GENERATE_IMAGE, description: "使用自定义prompt进行图像处理" },
+      { name: COMMANDS.COMPOSE_IMAGE, description: "合成多张图片，使用自定义prompt控制合成效果" },
+      { name: COMMANDS.QUERY_QUOTA, description: "查询用户额度信息" }
+    ],
+    // 管理员指令
+    adminCommands: [
+      { name: COMMANDS.RECHARGE, description: "为用户充值次数（仅管理员）" },
+      { name: COMMANDS.RECHARGE_HISTORY, description: "查看充值历史记录（仅管理员）" }
+    ]
+  };
+  const dataDir = "./data/aka-ai-generator";
+  const dataFile = (0, import_path.join)(dataDir, "users_data.json");
+  const backupFile = (0, import_path.join)(dataDir, "users_data.json.backup");
+  const rechargeHistoryFile = (0, import_path.join)(dataDir, "recharge_history.json");
+  if (!(0, import_fs.existsSync)(dataDir)) {
+    (0, import_fs.mkdirSync)(dataDir, { recursive: true });
+  }
+  function isAdmin(userId) {
+    return config.adminUsers && config.adminUsers.includes(userId);
+  }
+  __name(isAdmin, "isAdmin");
+  function checkRateLimit(userId) {
+    const now = Date.now();
+    const userTimestamps = rateLimitMap.get(userId) || [];
+    const windowStart = now - config.rateLimitWindow * 1e3;
+    const validTimestamps = userTimestamps.filter((timestamp) => timestamp > windowStart);
+    if (validTimestamps.length >= config.rateLimitMax) {
+      return {
+        allowed: false,
+        message: `操作过于频繁，请${Math.ceil((validTimestamps[0] + config.rateLimitWindow * 1e3 - now) / 1e3)}秒后再试`
+      };
+    }
+    return { allowed: true };
+  }
+  __name(checkRateLimit, "checkRateLimit");
+  function updateRateLimit(userId) {
+    const now = Date.now();
+    const userTimestamps = rateLimitMap.get(userId) || [];
+    userTimestamps.push(now);
+    rateLimitMap.set(userId, userTimestamps);
+  }
+  __name(updateRateLimit, "updateRateLimit");
+  async function checkDailyLimit(userId) {
+    if (isAdmin(userId)) {
+      return { allowed: true, isAdmin: true };
+    }
+    const rateLimitCheck = checkRateLimit(userId);
+    if (!rateLimitCheck.allowed) {
+      return { ...rateLimitCheck, isAdmin: false };
+    }
+    const usersData = await loadUsersData();
+    const userData = usersData[userId];
+    if (!userData) {
+      return { allowed: true, isAdmin: false };
+    }
+    const today = (/* @__PURE__ */ new Date()).toDateString();
+    const lastReset = new Date(userData.lastDailyReset || userData.createdAt).toDateString();
+    if (today !== lastReset) {
+      userData.dailyUsageCount = 0;
+      userData.lastDailyReset = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    if (userData.dailyUsageCount < config.dailyFreeLimit) {
+      return { allowed: true, isAdmin: false };
+    }
+    if (userData.remainingPurchasedCount > 0) {
+      return { allowed: true, isAdmin: false };
+    }
+    return {
+      allowed: false,
+      message: `今日免费次数已用完（${config.dailyFreeLimit}次），充值次数也已用完。请联系管理员充值或明天再试`,
+      isAdmin: false
+    };
+  }
+  __name(checkDailyLimit, "checkDailyLimit");
+  async function getPromptInput(session, message) {
+    await session.send(message);
+    const input = await session.prompt(3e4);
+    return input || null;
+  }
+  __name(getPromptInput, "getPromptInput");
+  async function loadUsersData() {
+    try {
+      if ((0, import_fs.existsSync)(dataFile)) {
+        const data = await import_fs.promises.readFile(dataFile, "utf-8");
+        return JSON.parse(data);
+      }
+    } catch (error) {
+      logger.error("读取用户数据失败", error);
+      if ((0, import_fs.existsSync)(backupFile)) {
+        try {
+          const backupData = await import_fs.promises.readFile(backupFile, "utf-8");
+          logger.warn("从备份文件恢复用户数据");
+          return JSON.parse(backupData);
+        } catch (backupError) {
+          logger.error("备份文件也损坏，使用空数据", backupError);
+        }
+      }
+    }
+    return {};
+  }
+  __name(loadUsersData, "loadUsersData");
+  async function saveUsersData(data) {
+    try {
+      if ((0, import_fs.existsSync)(dataFile)) {
+        await import_fs.promises.copyFile(dataFile, backupFile);
+      }
+      await import_fs.promises.writeFile(dataFile, JSON.stringify(data, null, 2), "utf-8");
+    } catch (error) {
+      logger.error("保存用户数据失败", error);
+      throw error;
+    }
+  }
+  __name(saveUsersData, "saveUsersData");
+  async function loadRechargeHistory() {
+    try {
+      if ((0, import_fs.existsSync)(rechargeHistoryFile)) {
+        const data = await import_fs.promises.readFile(rechargeHistoryFile, "utf-8");
+        return JSON.parse(data);
+      }
+    } catch (error) {
+      logger.error("读取充值历史失败", error);
+    }
+    return {
+      version: "1.0.0",
+      lastUpdate: (/* @__PURE__ */ new Date()).toISOString(),
+      records: []
+    };
+  }
+  __name(loadRechargeHistory, "loadRechargeHistory");
+  async function saveRechargeHistory(history) {
+    try {
+      history.lastUpdate = (/* @__PURE__ */ new Date()).toISOString();
+      await import_fs.promises.writeFile(rechargeHistoryFile, JSON.stringify(history, null, 2), "utf-8");
+    } catch (error) {
+      logger.error("保存充值历史失败", error);
+      throw error;
+    }
+  }
+  __name(saveRechargeHistory, "saveRechargeHistory");
+  async function getUserData(userId, userName) {
+    const usersData = await loadUsersData();
+    if (!usersData[userId]) {
+      usersData[userId] = {
+        userId,
+        userName,
+        totalUsageCount: 0,
+        dailyUsageCount: 0,
+        lastDailyReset: (/* @__PURE__ */ new Date()).toISOString(),
+        purchasedCount: 0,
+        remainingPurchasedCount: 0,
+        donationCount: 0,
+        donationAmount: 0,
+        lastUsed: (/* @__PURE__ */ new Date()).toISOString(),
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await saveUsersData(usersData);
+      logger.info("创建新用户数据", { userId, userName });
+    }
+    return usersData[userId];
+  }
+  __name(getUserData, "getUserData");
+  async function updateUserData(userId, userName, commandName) {
+    const usersData = await loadUsersData();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const today = (/* @__PURE__ */ new Date()).toDateString();
+    if (!usersData[userId]) {
+      usersData[userId] = {
+        userId,
+        userName: userId,
+        totalUsageCount: 1,
+        dailyUsageCount: 1,
+        lastDailyReset: now,
+        purchasedCount: 0,
+        remainingPurchasedCount: 0,
+        donationCount: 0,
+        donationAmount: 0,
+        lastUsed: now,
+        createdAt: now
+      };
+      await saveUsersData(usersData);
+      return { userData: usersData[userId], consumptionType: "free" };
+    }
+    usersData[userId].totalUsageCount += 1;
+    usersData[userId].lastUsed = now;
+    const lastReset = new Date(usersData[userId].lastDailyReset || usersData[userId].createdAt).toDateString();
+    if (today !== lastReset) {
+      usersData[userId].dailyUsageCount = 0;
+      usersData[userId].lastDailyReset = now;
+    }
+    if (usersData[userId].dailyUsageCount < config.dailyFreeLimit) {
+      usersData[userId].dailyUsageCount += 1;
+      await saveUsersData(usersData);
+      return { userData: usersData[userId], consumptionType: "free" };
+    }
+    if (usersData[userId].remainingPurchasedCount > 0) {
+      usersData[userId].remainingPurchasedCount -= 1;
+      await saveUsersData(usersData);
+      return { userData: usersData[userId], consumptionType: "purchased" };
+    }
+    await saveUsersData(usersData);
+    return { userData: usersData[userId], consumptionType: "free" };
+  }
+  __name(updateUserData, "updateUserData");
+  async function recordUserUsage(session, commandName) {
+    const userId = session.userId;
+    const userName = session.username || session.userId || "未知用户";
+    if (!userId) return;
+    updateRateLimit(userId);
+    const { userData, consumptionType } = await updateUserData(userId, userName, commandName);
+    if (isAdmin(userId)) {
+      await session.send(`📊 使用统计 [管理员]
+用户：${userData.userName}
+总调用次数：${userData.totalUsageCount}次
+状态：无限制使用`);
+    } else {
+      const remainingToday = Math.max(0, config.dailyFreeLimit - userData.dailyUsageCount);
+      const consumptionText = consumptionType === "free" ? "每日免费次数" : "充值次数";
+      await session.send(`📊 使用统计
+用户：${userData.userName}
+本次消费：${consumptionText} -1
+总调用次数：${userData.totalUsageCount}次
+今日剩余免费：${remainingToday}次
+充值剩余：${userData.remainingPurchasedCount}次`);
+    }
+    logger.info("用户调用记录", {
+      userId,
+      userName: userData.userName,
+      commandName,
+      totalUsageCount: userData.totalUsageCount,
+      dailyUsageCount: userData.dailyUsageCount,
+      remainingPurchasedCount: userData.remainingPurchasedCount,
+      consumptionType,
+      isAdmin: isAdmin(userId)
+    });
+  }
+  __name(recordUserUsage, "recordUserUsage");
+  async function getImageUrl(img, session) {
+    let url = null;
+    if (img) {
+      url = img.attrs?.src || null;
+      if (url) {
+        if (config.logLevel === "debug") {
+          logger.debug("从命令参数获取图片", { url });
+        }
+        return url;
+      }
+    }
+    let elements = session.quote?.elements;
+    if (elements) {
+      const images2 = import_koishi.h.select(elements, "img");
+      if (images2.length > 0) {
+        if (images2.length > 1) {
+          await session.send('本功能仅支持处理一张图片，检测到多张图片。如需合成多张图片请使用"合成图像"命令');
+          return null;
+        }
+        url = images2[0].attrs.src;
+        if (config.logLevel === "debug") {
+          logger.debug("从引用消息获取图片", { url });
+        }
+        return url;
+      }
+    }
+    await session.send("请在30秒内发送一张图片");
+    const msg = await session.prompt(3e4);
+    if (!msg) {
+      await session.send("等待超时");
+      return null;
+    }
+    elements = import_koishi.h.parse(msg);
+    const images = import_koishi.h.select(elements, "img");
+    if (images.length === 0) {
+      await session.send("未检测到图片，请重试");
+      return null;
+    }
+    if (images.length > 1) {
+      await session.send('本功能仅支持处理一张图片，检测到多张图片。如需合成多张图片请使用"合成图像"命令');
+      return null;
+    }
+    url = images[0].attrs.src;
+    if (config.logLevel === "debug") {
+      logger.debug("从用户输入获取图片", { url });
+    }
+    return url;
+  }
+  __name(getImageUrl, "getImageUrl");
+  async function requestProviderImages(prompt, imageUrls, numImages) {
+    return await imageProvider.generateImages(prompt, imageUrls, numImages);
+  }
+  __name(requestProviderImages, "requestProviderImages");
+  async function processImageWithTimeout(session, img, prompt, styleName, numImages) {
+    return Promise.race([
+      processImage(session, img, prompt, styleName, numImages),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("命令执行超时")), config.commandTimeout * 1e3)
+      )
+    ]).catch((error) => {
+      const userId = session.userId;
+      if (userId) activeTasks.delete(userId);
+      logger.error("图像处理超时或失败", { userId, error });
+      return error.message === "命令执行超时" ? "图像处理超时，请重试" : "图像处理失败，请稍后重试";
+    });
+  }
+  __name(processImageWithTimeout, "processImageWithTimeout");
+  async function processImage(session, img, prompt, styleName, numImages) {
+    const userId = session.userId;
+    if (activeTasks.has(userId)) {
+      return "您有一个图像处理任务正在进行中，请等待完成";
+    }
+    const imageCount = numImages || config.defaultNumImages;
+    if (imageCount < 1 || imageCount > 4) {
+      return "生成数量必须在 1-4 之间";
+    }
+    const imageUrl = await getImageUrl(img, session);
+    if (!imageUrl) {
+      return;
+    }
+    logger.info("开始图像处理", {
+      userId,
+      imageUrl,
+      styleName,
+      prompt,
+      numImages: imageCount
+    });
+    await session.send(`开始处理图片（${styleName}）...`);
+    try {
+      activeTasks.set(userId, "processing");
+      const images = await requestProviderImages(prompt, imageUrl, imageCount);
+      if (images.length === 0) {
+        activeTasks.delete(userId);
+        return "图像处理失败：未能生成图片";
+      }
+      await session.send("图像处理完成！");
+      for (let i = 0; i < images.length; i++) {
+        await session.send(import_koishi.h.image(images[i]));
+        if (images.length > 1 && i < images.length - 1) {
+          await new Promise((resolve) => setTimeout(resolve, 1e3));
+        }
+      }
+      await recordUserUsage(session, styleName);
+      activeTasks.delete(userId);
+    } catch (error) {
+      activeTasks.delete(userId);
+      logger.error("图像处理失败", { userId, error });
+      return "图像处理失败，请稍后重试";
+    }
+  }
+  __name(processImage, "processImage");
+  if (config.styles && Array.isArray(config.styles)) {
+    for (const style of config.styles) {
+      if (style.enabled && style.commandName && style.prompt) {
+        ctx.command(`${style.commandName} [img:text]`, style.commandDescription || "图像风格转换").option("num", "-n <num:number> 生成图片数量 (1-4)").action(async ({ session, options }, img) => {
+          if (!session?.userId) return "会话无效";
+          const limitCheck = await checkDailyLimit(session.userId);
+          if (!limitCheck.allowed) {
+            return limitCheck.message;
+          }
+          return processImageWithTimeout(session, img, style.prompt, style.commandName, options?.num);
+        });
+        logger.info(`已注册命令: ${style.commandName}`);
+      }
+    }
+  }
+  ctx.command(COMMANDS.GENERATE_IMAGE, "使用自定义prompt进行图像处理").option("num", "-n <num:number> 生成图片数量 (1-4)").action(async ({ session, options }) => {
+    if (!session?.userId) return "会话无效";
+    const limitCheck = await checkDailyLimit(session.userId);
+    if (!limitCheck.allowed) {
+      return limitCheck.message;
+    }
+    return Promise.race([
+      (async () => {
+        const userId = session.userId;
+        if (!userId) return "会话无效";
+        if (activeTasks.has(userId)) {
+          return "您有一个图像处理任务正在进行中，请等待完成";
+        }
+        await session.send('请发送一张图片和prompt，支持两种方式：\n1. 同时发送：[图片] + prompt描述\n2. 分步发送：先发送一张图片，再发送prompt文字\n\n例如：[图片] 让这张图片变成油画风格\n\n注意：本功能仅支持处理一张图片，多张图片请使用"合成图像"命令');
+        const collectedImages = [];
+        let prompt = "";
+        while (true) {
+          const msg = await session.prompt(6e4);
+          if (!msg) {
+            return "等待超时，请重试";
+          }
+          const elements = import_koishi.h.parse(msg);
+          const images = import_koishi.h.select(elements, "img");
+          const textElements = import_koishi.h.select(elements, "text");
+          const text = textElements.map((el) => el.attrs.content).join(" ").trim();
+          if (images.length > 0) {
+            if (collectedImages.length > 0) {
+              return '本功能仅支持处理一张图片，如需合成多张图片请使用"合成图像"命令';
+            }
+            if (images.length > 1) {
+              return '本功能仅支持处理一张图片，检测到多张图片。如需合成多张图片请使用"合成图像"命令';
+            }
+            for (const img of images) {
+              collectedImages.push(img.attrs.src);
+            }
+            if (text) {
+              prompt = text;
+              break;
+            }
+            await session.send("已收到图片，请发送 prompt 描述文字");
+            continue;
+          }
+          if (text) {
+            if (collectedImages.length === 0) {
+              return "未检测到图片，请先发送图片";
+            }
+            prompt = text;
+            break;
+          }
+          return "未检测到有效内容，请重新发送";
+        }
+        if (collectedImages.length === 0) {
+          return "未检测到图片，请重新发送";
+        }
+        if (collectedImages.length > 1) {
+          return '本功能仅支持处理一张图片，检测到多张图片。如需合成多张图片请使用"合成图像"命令';
+        }
+        if (!prompt) {
+          return "未检测到prompt描述，请重新发送";
+        }
+        const imageUrl = collectedImages[0];
+        const imageCount = options?.num || config.defaultNumImages;
+        if (imageCount < 1 || imageCount > 4) {
+          return "生成数量必须在 1-4 之间";
+        }
+        logger.info("开始自定义图像处理", {
+          userId,
+          imageUrl,
+          prompt,
+          numImages: imageCount
+        });
+        await session.send(`开始处理图片（自定义prompt）...
+Prompt: ${prompt}`);
+        try {
+          activeTasks.set(userId, "processing");
+          const resultImages = await requestProviderImages(prompt, imageUrl, imageCount);
+          if (resultImages.length === 0) {
+            activeTasks.delete(userId);
+            return "图像处理失败：未能生成图片";
+          }
+          await session.send("图像处理完成！");
+          for (let i = 0; i < resultImages.length; i++) {
+            await session.send(import_koishi.h.image(resultImages[i]));
+            if (resultImages.length > 1 && i < resultImages.length - 1) {
+              await new Promise((resolve) => setTimeout(resolve, 1e3));
+            }
+          }
+          await recordUserUsage(session, COMMANDS.GENERATE_IMAGE);
+          activeTasks.delete(userId);
+        } catch (error) {
+          activeTasks.delete(userId);
+          logger.error("自定义图像处理失败", { userId, error });
+          return "图像处理失败，请稍后重试";
+        }
+      })(),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("命令执行超时")), config.commandTimeout * 1e3)
+      )
+    ]).catch((error) => {
+      const userId = session.userId;
+      if (userId) activeTasks.delete(userId);
+      logger.error("自定义图像处理超时或失败", { userId, error });
+      return error.message === "命令执行超时" ? "图像处理超时，请重试" : "图像处理失败，请稍后重试";
+    });
+  });
+  ctx.command(COMMANDS.COMPOSE_IMAGE, "合成多张图片，使用自定义prompt控制合成效果").option("num", "-n <num:number> 生成图片数量 (1-4)").action(async ({ session, options }) => {
+    if (!session?.userId) return "会话无效";
+    const limitCheck = await checkDailyLimit(session.userId);
+    if (!limitCheck.allowed) {
+      return limitCheck.message;
+    }
+    return Promise.race([
+      (async () => {
+        const userId = session.userId;
+        if (!userId) return "会话无效";
+        if (activeTasks.has(userId)) {
+          return "您有一个图像处理任务正在进行中，请等待完成";
+        }
+        await session.send("请发送多张图片和prompt，支持两种方式：\n1. 同时发送：[图片1] [图片2]... + prompt描述\n2. 分步发送：先发送多张图片，再发送prompt文字\n\n例如：[图片1] [图片2] 将这两张图片合成一张");
+        const collectedImages = [];
+        let prompt = "";
+        while (true) {
+          const msg = await session.prompt(6e4);
+          if (!msg) {
+            return "等待超时，请重试";
+          }
+          const elements = import_koishi.h.parse(msg);
+          const images = import_koishi.h.select(elements, "img");
+          const textElements = import_koishi.h.select(elements, "text");
+          const text = textElements.map((el) => el.attrs.content).join(" ").trim();
+          if (images.length > 0) {
+            for (const img of images) {
+              collectedImages.push(img.attrs.src);
+            }
+            if (text) {
+              prompt = text;
+              break;
+            }
+            await session.send(`已收到 ${collectedImages.length} 张图片，请继续发送图片或发送 prompt 文字`);
+            continue;
+          }
+          if (text) {
+            if (collectedImages.length < 2) {
+              return `需要至少两张图片进行合成，当前只有 ${collectedImages.length} 张图片`;
+            }
+            prompt = text;
+            break;
+          }
+          return "未检测到有效内容，请重新发送";
+        }
+        if (collectedImages.length < 2) {
+          return "需要至少两张图片进行合成，请重新发送";
+        }
+        if (!prompt) {
+          return "未检测到prompt描述，请重新发送";
+        }
+        const imageCount = options?.num || config.defaultNumImages;
+        if (imageCount < 1 || imageCount > 4) {
+          return "生成数量必须在 1-4 之间";
+        }
+        logger.info("开始图片合成处理", {
+          userId,
+          imageUrls: collectedImages,
+          prompt,
+          numImages: imageCount,
+          imageCount: collectedImages.length
+        });
+        await session.send(`开始合成图像（${collectedImages.length}张）...
+Prompt: ${prompt}`);
+        try {
+          activeTasks.set(userId, "processing");
+          const resultImages = await requestProviderImages(prompt, collectedImages, imageCount);
+          if (resultImages.length === 0) {
+            activeTasks.delete(userId);
+            return "图片合成失败：未能生成图片";
+          }
+          await session.send("图片合成完成！");
+          for (let i = 0; i < resultImages.length; i++) {
+            await session.send(import_koishi.h.image(resultImages[i]));
+            if (resultImages.length > 1 && i < resultImages.length - 1) {
+              await new Promise((resolve) => setTimeout(resolve, 1e3));
+            }
+          }
+          await recordUserUsage(session, COMMANDS.COMPOSE_IMAGE);
+          activeTasks.delete(userId);
+        } catch (error) {
+          activeTasks.delete(userId);
+          logger.error("图片合成失败", { userId, error });
+          return "图片合成失败，请稍后重试";
+        }
+      })(),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("命令执行超时")), config.commandTimeout * 1e3)
+      )
+    ]).catch((error) => {
+      const userId = session.userId;
+      if (userId) activeTasks.delete(userId);
+      logger.error("图片合成超时或失败", { userId, error });
+      return error.message === "命令执行超时" ? "图片合成超时，请重试" : "图片合成失败，请稍后重试";
+    });
+  });
+  ctx.command(`${COMMANDS.RECHARGE} [content:text]`, "为用户充值次数（仅管理员）").action(async ({ session }, content) => {
+    if (!session?.userId) return "会话无效";
+    if (!isAdmin(session.userId)) {
+      return "权限不足，仅管理员可操作";
+    }
+    const inputContent = content || await getPromptInput(session, "请输入充值信息，格式：\n@用户1 @用户2 充值次数 [备注]\n\n例如：\n@难捅一号 10 测试充值");
+    if (!inputContent) return "输入超时或无效";
+    const elements = import_koishi.h.parse(inputContent);
+    const atElements = import_koishi.h.select(elements, "at");
+    const textElements = import_koishi.h.select(elements, "text");
+    const text = textElements.map((el) => el.attrs.content).join(" ").trim();
+    if (atElements.length === 0) {
+      return "未找到@用户，请使用@用户的方式";
+    }
+    const parts = text.split(/\s+/).filter((p) => p);
+    if (parts.length === 0) {
+      return "请输入充值次数";
+    }
+    const amount = parseInt(parts[0]);
+    const note = parts.slice(1).join(" ") || "管理员充值";
+    if (!amount || amount <= 0) {
+      return "充值次数必须大于0";
+    }
+    const userIds = atElements.map((el) => el.attrs.id).filter(Boolean);
+    if (userIds.length === 0) {
+      return "未找到有效的用户，请使用@用户的方式";
+    }
+    try {
+      const usersData = await loadUsersData();
+      const rechargeHistory = await loadRechargeHistory();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const recordId = `recharge_${now.replace(/[-:T.]/g, "").slice(0, 14)}_${Math.random().toString(36).substr(2, 3)}`;
+      const targets = [];
+      for (const userId of userIds) {
+        if (!userId) continue;
+        let userName = userId;
+        if (usersData[userId]) {
+          userName = usersData[userId].userName || userId;
+        }
+        if (!usersData[userId]) {
+          usersData[userId] = {
+            userId,
+            userName: userId,
+            totalUsageCount: 0,
+            dailyUsageCount: 0,
+            lastDailyReset: now,
+            purchasedCount: 0,
+            remainingPurchasedCount: 0,
+            donationCount: 0,
+            donationAmount: 0,
+            lastUsed: now,
+            createdAt: now
+          };
+        }
+        const beforeBalance = usersData[userId].remainingPurchasedCount;
+        usersData[userId].purchasedCount += amount;
+        usersData[userId].remainingPurchasedCount += amount;
+        targets.push({
+          userId,
+          userName,
+          amount,
+          beforeBalance,
+          afterBalance: usersData[userId].remainingPurchasedCount
+        });
+      }
+      await saveUsersData(usersData);
+      const record = {
+        id: recordId,
+        timestamp: now,
+        type: userIds.length > 1 ? "batch" : "single",
+        operator: {
+          userId: session.userId,
+          userName: session.username || session.userId
+        },
+        targets,
+        totalAmount: amount * userIds.length,
+        note: note || "管理员充值",
+        metadata: {}
+      };
+      rechargeHistory.records.push(record);
+      await saveRechargeHistory(rechargeHistory);
+      const userList = targets.map((t) => `${t.userName}(${t.afterBalance}次)`).join(", ");
+      return `✅ 充值成功
+目标用户：${userList}
+充值次数：${amount}次/人
+总充值：${record.totalAmount}次
+操作员：${record.operator.userName}
+备注：${record.note}`;
+    } catch (error) {
+      logger.error("充值操作失败", error);
+      return "充值失败，请稍后重试";
+    }
+  });
+  ctx.command(`${COMMANDS.QUERY_QUOTA} [target:text]`, "查询用户额度信息").action(async ({ session }, target) => {
+    if (!session?.userId) return "会话无效";
+    const userIsAdmin = isAdmin(session.userId);
+    let targetUserId = session.userId;
+    let targetUserName = session.username || session.userId;
+    if (target && userIsAdmin) {
+      const userMatch = target.match(/<at id="([^"]+)"/);
+      if (userMatch) {
+        targetUserId = userMatch[1];
+        targetUserName = "目标用户";
+      }
+    } else if (target && !userIsAdmin) {
+      return "权限不足，仅管理员可查询其他用户";
+    }
+    try {
+      const usersData = await loadUsersData();
+      const userData = usersData[targetUserId];
+      if (!userData) {
+        return `👤 用户信息
+用户：${targetUserName}
+状态：新用户
+今日剩余免费：${config.dailyFreeLimit}次
+充值剩余：0次`;
+      }
+      const remainingToday = Math.max(0, config.dailyFreeLimit - userData.dailyUsageCount);
+      const totalAvailable = remainingToday + userData.remainingPurchasedCount;
+      return `👤 用户额度信息
+用户：${userData.userName}
+今日剩余免费：${remainingToday}次
+充值剩余：${userData.remainingPurchasedCount}次
+总可用次数：${totalAvailable}次
+历史总调用：${userData.totalUsageCount}次
+历史总充值：${userData.purchasedCount}次`;
+    } catch (error) {
+      logger.error("查询额度失败", error);
+      return "查询失败，请稍后重试";
+    }
+  });
+  ctx.command(`${COMMANDS.RECHARGE_HISTORY} [page:number]`, "查看充值历史记录（仅管理员）").action(async ({ session }, page = 1) => {
+    if (!session?.userId) return "会话无效";
+    if (!isAdmin(session.userId)) {
+      return "权限不足，仅管理员可查看充值记录";
+    }
+    try {
+      const history = await loadRechargeHistory();
+      const pageSize = 10;
+      const totalPages = Math.ceil(history.records.length / pageSize);
+      const startIndex = (page - 1) * pageSize;
+      const endIndex = startIndex + pageSize;
+      const records = history.records.slice(startIndex, endIndex).reverse();
+      if (records.length === 0) {
+        return `📋 充值记录
+当前页：${page}/${totalPages}
+暂无充值记录`;
+      }
+      let result = `📋 充值记录 (第${page}/${totalPages}页)
+
+`;
+      for (const record of records) {
+        const date = new Date(record.timestamp).toLocaleString("zh-CN");
+        const userList = record.targets.map((t) => `${t.userName}(${t.amount}次)`).join(", ");
+        result += `🕐 ${date}
+👤 操作员：${record.operator.userName}
+👥 目标：${userList}
+💰 总充值：${record.totalAmount}次
+📝 备注：${record.note}
+
+`;
+      }
+      return result;
+    } catch (error) {
+      logger.error("查询充值记录失败", error);
+      return "查询失败，请稍后重试";
+    }
+  });
+  ctx.command(COMMANDS.FUNCTION_LIST, "查看所有可用的图像处理功能").action(async ({ session }) => {
+    if (!session?.userId) return "会话无效";
+    try {
+      const userIsAdmin = isAdmin(session.userId);
+      let result = "🎨 图像处理功能列表\n\n";
+      result += "📝 用户指令：\n";
+      commandRegistry.userCommands.forEach((cmd) => {
+        result += `• ${cmd.name} - ${cmd.description}
+`;
+      });
+      if (userIsAdmin) {
+        result += "\n🔧 管理员指令：\n";
+        commandRegistry.adminCommands.forEach((cmd) => {
+          result += `• ${cmd.name} - ${cmd.description}
+`;
+        });
+      }
+      result += "\n💡 使用提示：\n";
+      result += "• 发送图片后使用相应指令进行图像处理\n";
+      result += "• 支持直接传参：.指令名 [图片] 参数\n";
+      result += "• 支持交互式输入：.指令名 然后按提示操作\n";
+      if (userIsAdmin) {
+        result += "\n🔑 管理员提示：\n";
+        result += "• 可使用所有功能，无使用限制\n";
+        result += "• 可以查看充值记录\n";
+        result += "• 可以为其他用户充值次数\n";
+      } else {
+        result += "\n👤 普通用户提示：\n";
+        result += "• 每日有免费使用次数限制\n";
+        result += "• 可使用充值次数进行额外调用\n";
+        result += "• 使用 .图像额度 查看剩余次数\n";
+      }
+      return result;
+    } catch (error) {
+      logger.error("获取功能列表失败", error);
+      return "获取功能列表失败，请稍后重试";
+    }
+  });
+  const providerLabel = config.provider === "gptgod" ? "GPTGod" : "云雾 Gemini 2.5 Flash Image";
+  logger.info(`aka-ai-generator 插件已启动 (${providerLabel})`);
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  name
+});