koishi-plugin-aka-ai-generator 0.5.4 → 0.6.0

package/lib/index.js

@@ -25,11 +25,9 @@ __export(src_exports, {
   name: () => name
 });
 module.exports = __toCommonJS(src_exports);
-var import_koishi = require("koishi");
-var import_fs = require("fs");
-var import_path = require("path");
+var import_koishi2 = require("koishi");
 
-// src/providers/types.ts
+// src/providers/utils.ts
 function sanitizeError(error) {
   if (!error) return error;
   if (typeof error === "string") {
@@ -42,14 +40,10 @@ function sanitizeError(error) {
     const sanitized = {};
     for (const key in error) {
       const lowerKey = key.toLowerCase();
-      if (lowerKey.includes("apikey") || lowerKey.includes("api_key") || lowerKey === "key" || lowerKey === "authorization" || lowerKey === "token" || lowerKey === "secret" || lowerKey === "password" || lowerKey === "x-goog-api-key") {
+      if (lowerKey.includes("apikey") || lowerKey.includes("api_key") || lowerKey.includes("apikey") || lowerKey === "key" || lowerKey === "authorization" || lowerKey === "token" || lowerKey === "secret" || lowerKey === "password") {
         sanitized[key] = "[REDACTED]";
         continue;
       }
-      if (lowerKey === "url" && typeof error[key] === "string") {
-        sanitized[key] = sanitizeUrl(error[key]);
-        continue;
-      }
       sanitized[key] = sanitizeError(error[key]);
     }
     return sanitized;
@@ -59,196 +53,61 @@ function sanitizeError(error) {
 __name(sanitizeError, "sanitizeError");
 function sanitizeString(str) {
   if (typeof str !== "string") return str;
-  let sanitized = str.replace(/[?&]key=[^&\s"']+/gi, "?key=[REDACTED]").replace(/[?&]apikey=[^&\s"']+/gi, "&apikey=[REDACTED]").replace(/[?&]api_key=[^&\s"']+/gi, "&api_key=[REDACTED]");
-  sanitized = sanitized.replace(/key["\s:=]+([a-zA-Z0-9_-]{20,})/gi, 'key="[REDACTED]"').replace(/apikey["\s:=]+([a-zA-Z0-9_-]{20,})/gi, 'apikey="[REDACTED]"').replace(/api_key["\s:=]+([a-zA-Z0-9_-]{20,})/gi, 'api_key="[REDACTED]"').replace(/authorization["\s:=]+(Bearer\s+)?([a-zA-Z0-9_-]{20,})/gi, 'authorization="[REDACTED]"').replace(/Bearer\s+([a-zA-Z0-9_-]{20,})/gi, "Bearer [REDACTED]").replace(/x-goog-api-key["\s:]+([a-zA-Z0-9_-]{20,})/gi, "x-goog-api-key: [REDACTED]").replace(/X-Goog-Api-Key["\s:]+([a-zA-Z0-9_-]{20,})/gi, "X-Goog-Api-Key: [REDACTED]");
-  return sanitized;
+  return str.replace(/key["\s:=]+([a-zA-Z0-9_-]{20,})/gi, 'key="[REDACTED]"').replace(/apikey["\s:=]+([a-zA-Z0-9_-]{20,})/gi, 'apikey="[REDACTED]"').replace(/api_key["\s:=]+([a-zA-Z0-9_-]{20,})/gi, 'api_key="[REDACTED]"').replace(/authorization["\s:=]+(Bearer\s+)?([a-zA-Z0-9_-]{20,})/gi, 'authorization="[REDACTED]"').replace(/Bearer\s+([a-zA-Z0-9_-]{20,})/gi, "Bearer [REDACTED]");
 }
 __name(sanitizeString, "sanitizeString");
-function sanitizeUrl(url) {
-  if (typeof url !== "string") return url;
-  try {
-    const urlObj = new URL(url);
-    urlObj.searchParams.delete("key");
-    urlObj.searchParams.delete("apikey");
-    urlObj.searchParams.delete("api_key");
-    urlObj.searchParams.delete("token");
-    urlObj.searchParams.delete("secret");
-    return urlObj.toString();
-  } catch (e) {
-    return sanitizeString(url);
-  }
-}
-__name(sanitizeUrl, "sanitizeUrl");
-
-// src/providers/yunwu.ts
-async function downloadImageAsBase64(ctx, url, timeout, logger) {
+async function downloadImageAsBase64(ctx, url, timeout, logger, maxSize = 10 * 1024 * 1024) {
   try {
     const response = await ctx.http.get(url, {
       responseType: "arraybuffer",
-      timeout: timeout * 1e3
+      timeout: timeout * 1e3,
+      headers: {
+        "Accept": "image/*"
+      }
     });
     const buffer = Buffer.from(response);
+    if (buffer.length > maxSize) {
+      throw new Error(`图片大小超过限制 (${(maxSize / 1024 / 1024).toFixed(1)}MB)`);
+    }
     const base64 = buffer.toString("base64");
     let mimeType = "image/jpeg";
-    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 (buffer.length > 4) {
+      if (buffer[0] === 137 && buffer[1] === 80 && buffer[2] === 78 && buffer[3] === 71) {
+        mimeType = "image/png";
+      } else if (buffer[0] === 255 && buffer[1] === 216 && buffer[2] === 255) {
+        mimeType = "image/jpeg";
+      } else if (buffer[0] === 71 && buffer[1] === 73 && buffer[2] === 70) {
+        mimeType = "image/gif";
+      } else if (buffer[0] === 82 && buffer[1] === 73 && buffer[2] === 70 && buffer[3] === 70 && buffer[8] === 87 && buffer[9] === 69 && buffer[10] === 66 && buffer[11] === 80) {
+        mimeType = "image/webp";
+      }
+    }
+    if (mimeType === "image/jpeg") {
+      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 });
+    logger.error("下载图片失败", { url, error: sanitizeError(error) });
+    if (error?.message?.includes("图片大小超过限制")) {
+      throw 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) {
-        const safeMessage = typeof error?.message === "string" ? sanitizeString(error.message) : "未知错误";
-        logger.error("云雾图像编辑 API 调用失败", {
-          message: safeMessage,
-          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";
 var HTTP_URL_REGEX = /^https?:\/\//i;
 var DATA_URL_REGEX = /^data:image\//i;
-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 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 isHttpImage(url) {
   return HTTP_URL_REGEX.test(url);
 }
@@ -273,7 +132,7 @@ async function buildImageContentPart(ctx, url, timeout, logger) {
       image_url: { url }
     };
   }
-  const { data, mimeType } = await downloadImageAsBase642(ctx, url, timeout, logger);
+  const { data, mimeType } = await downloadImageAsBase64(ctx, url, timeout, logger);
   return {
     type: "image_url",
     image_url: {
@@ -423,7 +282,7 @@ function parseGptGodResponse(response, logger) {
     }
     return images;
   } catch (error) {
-    logger?.error("解析响应时出错", { error });
+    logger?.error("解析响应时出错", { error: sanitizeError(error) });
     return [];
   }
 }
@@ -448,13 +307,17 @@ var GptGodProvider = class {
     }
     const imageParts = [];
     for (const url of urls) {
-      const imagePart = await buildImageContentPart(
-        ctx,
-        url,
-        this.config.apiTimeout,
-        logger
-      );
-      imageParts.push(imagePart);
+      try {
+        const imagePart = await buildImageContentPart(
+          ctx,
+          url,
+          this.config.apiTimeout,
+          logger
+        );
+        imageParts.push(imagePart);
+      } catch (error) {
+        logger.error("构建图片部分失败，跳过该图片", { url, error: sanitizeError(error) });
+      }
     }
     const allImages = [];
     for (let i = 0; i < numImages; i++) {
@@ -568,7 +431,6 @@ var GptGodProvider = class {
             await new Promise((resolve) => setTimeout(resolve, delay));
             continue;
           }
-          const sanitizedError = sanitizeError(error);
           const safeMessage = typeof error?.message === "string" ? sanitizeString(error.message) : "未知错误";
           logger.error("GPTGod 图像编辑 API 调用失败", {
             message: safeMessage,
@@ -616,31 +478,6 @@ var GptGodProvider = class {
 };
 
 // src/providers/gemini.ts
-async function downloadImageAsBase643(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 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(downloadImageAsBase643, "downloadImageAsBase64");
 function parseGeminiResponse(response, logger) {
   try {
     const images = [];
@@ -773,9 +610,6 @@ var GeminiProvider = class {
     this.config = config;
   }
   async generateImages(prompt, imageUrls, numImages) {
-    if (!this.config.apiKey || !this.config.apiKey.trim()) {
-      throw new Error("Gemini API key 未配置或为空");
-    }
     let urls = [];
     if (Array.isArray(imageUrls)) {
       urls = imageUrls.filter((url) => url && typeof url === "string" && url.trim());
@@ -788,18 +622,22 @@ var GeminiProvider = class {
     const imageParts = [];
     for (const url of urls) {
       if (!url || !url.trim()) continue;
-      const { data, mimeType } = await downloadImageAsBase643(
-        ctx,
-        url,
-        this.config.apiTimeout,
-        logger
-      );
-      imageParts.push({
-        inlineData: {
-          mimeType,
-          data
-        }
-      });
+      try {
+        const { data, mimeType } = await downloadImageAsBase64(
+          ctx,
+          url,
+          this.config.apiTimeout,
+          logger
+        );
+        imageParts.push({
+          inline_data: {
+            mime_type: mimeType,
+            data
+          }
+        });
+      } catch (error) {
+        logger.error("处理输入图片失败，跳过该图片", { url, error: sanitizeError(error) });
+      }
     }
     const apiBase = this.config.apiBase?.replace(/\/$/, "") || "https://generativelanguage.googleapis.com";
     const endpoint = `${apiBase}/v1beta/models/${this.config.modelId}:generateContent`;
@@ -808,6 +646,7 @@ var GeminiProvider = class {
       const requestData = {
         contents: [
           {
+            role: "user",
             parts: [
               { text: prompt },
               ...imageParts
@@ -815,22 +654,10 @@ var GeminiProvider = class {
           }
         ],
         generationConfig: {
-          responseModalities: ["IMAGE"],
-          imageConfig: {
-            aspectRatio: "16:9"
-          }
+          responseModalities: ["IMAGE"]
         }
       };
-      logger.debug("调用 Gemini API", {
-        prompt: prompt.substring(0, 100),
-        imageCount: urls.length,
-        numImages,
-        current: i + 1,
-        endpoint,
-        hasApiKey: !!this.config.apiKey,
-        apiKeyLength: this.config.apiKey?.length || 0,
-        modelId: this.config.modelId
-      });
+      logger.debug("调用 Gemini API", { prompt, imageCount: urls.length, numImages, current: i + 1, endpoint });
       try {
         const response = await ctx.http.post(
           endpoint,
@@ -860,33 +687,14 @@ var GeminiProvider = class {
       } catch (error) {
         const sanitizedError = sanitizeError(error);
         const safeMessage = typeof error?.message === "string" ? sanitizeString(error.message) : "未知错误";
-        const errorDetails = {
+        logger.error("Gemini API 调用失败", {
           message: safeMessage,
           code: error?.code,
           status: error?.response?.status,
-          statusText: error?.response?.statusText,
+          responseData: error?.response?.data ? sanitizeString(JSON.stringify(error.response.data).substring(0, 500)) : void 0,
           current: i + 1,
-          total: numImages,
-          errorType: error?.name || error?.constructor?.name || "Unknown"
-        };
-        if (error?.response?.data) {
-          try {
-            const responseStr = JSON.stringify(error.response.data);
-            errorDetails.responseData = sanitizeString(responseStr.substring(0, 1e3));
-          } catch (e) {
-            errorDetails.responseData = "无法序列化响应数据";
-          }
-        }
-        if (error?.config) {
-          errorDetails.url = error.config.url ? sanitizeUrl(error.config.url) : void 0;
-          errorDetails.method = error.config.method;
-          errorDetails.hasData = !!error.config.data;
-        }
-        if (error?.code === "ECONNREFUSED" || error?.code === "ETIMEDOUT" || error?.code === "ENOTFOUND") {
-          errorDetails.networkError = true;
-          errorDetails.networkErrorCode = error.code;
-        }
-        logger.error("Gemini API 调用失败", errorDetails);
+          total: numImages
+        });
         if (allImages.length > 0) {
           logger.warn("部分图片生成失败，返回已生成的图片", { generated: allImages.length, requested: numImages });
           break;
@@ -906,9 +714,11 @@ var GeminiProvider = class {
 function createImageProvider(config) {
   switch (config.provider) {
     case "yunwu":
-      return new YunwuProvider({
+      return new GeminiProvider({
         apiKey: config.yunwuApiKey,
         modelId: config.yunwuModelId,
+        apiBase: "https://yunwu.ai",
+        // 指定云雾 API 地址
         apiTimeout: config.apiTimeout,
         logLevel: config.logLevel,
         logger: config.logger,
@@ -939,6 +749,412 @@ function createImageProvider(config) {
 }
 __name(createImageProvider, "createImageProvider");
 
+// src/services/UserManager.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var AsyncLock = class {
+  static {
+    __name(this, "AsyncLock");
+  }
+  promise = Promise.resolve();
+  async acquire(fn) {
+    const previousPromise = this.promise;
+    let release;
+    const nextPromise = new Promise((resolve) => {
+      release = resolve;
+    });
+    this.promise = nextPromise;
+    await previousPromise;
+    try {
+      return await fn();
+    } finally {
+      release();
+    }
+  }
+};
+var UserManager = class {
+  static {
+    __name(this, "UserManager");
+  }
+  dataDir;
+  dataFile;
+  backupFile;
+  rechargeHistoryFile;
+  logger;
+  dataLock = new AsyncLock();
+  historyLock = new AsyncLock();
+  // 内存缓存
+  usersCache = null;
+  activeTasks = /* @__PURE__ */ new Map();
+  // userId -> requestId
+  rateLimitMap = /* @__PURE__ */ new Map();
+  // userId -> timestamps
+  securityBlockMap = /* @__PURE__ */ new Map();
+  // userId -> 拦截时间戳数组
+  securityWarningMap = /* @__PURE__ */ new Map();
+  // userId -> 是否已收到警示
+  constructor(baseDir, logger) {
+    this.logger = logger;
+    this.dataDir = (0, import_path.join)(baseDir, "data/aka-ai-generator");
+    this.dataFile = (0, import_path.join)(this.dataDir, "users_data.json");
+    this.backupFile = (0, import_path.join)(this.dataDir, "users_data.json.backup");
+    this.rechargeHistoryFile = (0, import_path.join)(this.dataDir, "recharge_history.json");
+    if (!(0, import_fs.existsSync)(this.dataDir)) {
+      (0, import_fs.mkdirSync)(this.dataDir, { recursive: true });
+    }
+  }
+  // --- 任务管理 ---
+  startTask(userId) {
+    if (this.activeTasks.has(userId)) return false;
+    this.activeTasks.set(userId, "processing");
+    return true;
+  }
+  endTask(userId) {
+    this.activeTasks.delete(userId);
+  }
+  isTaskActive(userId) {
+    return this.activeTasks.has(userId);
+  }
+  // --- 权限管理 ---
+  isAdmin(userId, config) {
+    return config.adminUsers && config.adminUsers.includes(userId);
+  }
+  // --- 数据持久化 ---
+  async loadUsersData() {
+    if (this.usersCache) return this.usersCache;
+    return await this.dataLock.acquire(async () => {
+      if (this.usersCache) return this.usersCache;
+      try {
+        if ((0, import_fs.existsSync)(this.dataFile)) {
+          const data = await import_fs.promises.readFile(this.dataFile, "utf-8");
+          this.usersCache = JSON.parse(data);
+          return this.usersCache;
+        }
+      } catch (error) {
+        this.logger.error("读取用户数据失败", error);
+        if ((0, import_fs.existsSync)(this.backupFile)) {
+          try {
+            const backupData = await import_fs.promises.readFile(this.backupFile, "utf-8");
+            this.logger.warn("从备份文件恢复用户数据");
+            this.usersCache = JSON.parse(backupData);
+            return this.usersCache;
+          } catch (backupError) {
+            this.logger.error("备份文件也损坏，使用空数据", backupError);
+          }
+        }
+      }
+      this.usersCache = {};
+      return this.usersCache;
+    });
+  }
+  // 保存所有用户数据（内部使用）
+  async saveUsersDataInternal() {
+    if (!this.usersCache) return;
+    try {
+      if ((0, import_fs.existsSync)(this.dataFile)) {
+        await import_fs.promises.copyFile(this.dataFile, this.backupFile);
+      }
+      await import_fs.promises.writeFile(this.dataFile, JSON.stringify(this.usersCache, null, 2), "utf-8");
+    } catch (error) {
+      this.logger.error("保存用户数据失败", error);
+      throw error;
+    }
+  }
+  // 获取特定用户数据
+  async getUserData(userId, userName) {
+    await this.loadUsersData();
+    if (!this.usersCache[userId]) {
+      await this.dataLock.acquire(async () => {
+        if (this.usersCache[userId]) return;
+        this.usersCache[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 this.saveUsersDataInternal();
+        this.logger.info("创建新用户数据", { userId, userName });
+      });
+    }
+    return this.usersCache[userId];
+  }
+  // 获取所有用户数据 (用于充值等批量操作)
+  async getAllUsers() {
+    return await this.loadUsersData();
+  }
+  // 批量更新用户数据 (用于充值)
+  async updateUsersBatch(updates) {
+    await this.dataLock.acquire(async () => {
+      await this.loadUsersData();
+      updates(this.usersCache);
+      await this.saveUsersDataInternal();
+    });
+  }
+  // --- 充值历史 ---
+  async loadRechargeHistory() {
+    return await this.historyLock.acquire(async () => {
+      try {
+        if ((0, import_fs.existsSync)(this.rechargeHistoryFile)) {
+          const data = await import_fs.promises.readFile(this.rechargeHistoryFile, "utf-8");
+          return JSON.parse(data);
+        }
+      } catch (error) {
+        this.logger.error("读取充值历史失败", error);
+      }
+      return {
+        version: "1.0.0",
+        lastUpdate: (/* @__PURE__ */ new Date()).toISOString(),
+        records: []
+      };
+    });
+  }
+  async addRechargeRecord(record) {
+    await this.historyLock.acquire(async () => {
+      let history;
+      try {
+        if ((0, import_fs.existsSync)(this.rechargeHistoryFile)) {
+          history = JSON.parse(await import_fs.promises.readFile(this.rechargeHistoryFile, "utf-8"));
+        } else {
+          history = { version: "1.0.0", lastUpdate: "", records: [] };
+        }
+      } catch (e) {
+        history = { version: "1.0.0", lastUpdate: "", records: [] };
+      }
+      history.records.push(record);
+      history.lastUpdate = (/* @__PURE__ */ new Date()).toISOString();
+      await import_fs.promises.writeFile(this.rechargeHistoryFile, JSON.stringify(history, null, 2), "utf-8");
+    });
+  }
+  // --- 限流逻辑 ---
+  checkRateLimit(userId, config) {
+    const now = Date.now();
+    const userTimestamps = this.rateLimitMap.get(userId) || [];
+    const windowStart = now - config.rateLimitWindow * 1e3;
+    const validTimestamps = userTimestamps.filter((timestamp) => timestamp > windowStart);
+    this.rateLimitMap.set(userId, validTimestamps);
+    if (validTimestamps.length >= config.rateLimitMax) {
+      return {
+        allowed: false,
+        message: `操作过于频繁，请${Math.ceil((validTimestamps[0] + config.rateLimitWindow * 1e3 - now) / 1e3)}秒后再试`
+      };
+    }
+    return { allowed: true };
+  }
+  updateRateLimit(userId) {
+    const now = Date.now();
+    const userTimestamps = this.rateLimitMap.get(userId) || [];
+    userTimestamps.push(now);
+    this.rateLimitMap.set(userId, userTimestamps);
+  }
+  // --- 核心业务逻辑 ---
+  async checkDailyLimit(userId, config, numImages = 1) {
+    if (this.isAdmin(userId, config)) {
+      return { allowed: true, isAdmin: true };
+    }
+    const rateLimitCheck = this.checkRateLimit(userId, config);
+    if (!rateLimitCheck.allowed) {
+      return { ...rateLimitCheck, isAdmin: false };
+    }
+    this.updateRateLimit(userId);
+    const userData = await this.getUserData(userId, userId);
+    const today = (/* @__PURE__ */ new Date()).toDateString();
+    const lastReset = new Date(userData.lastDailyReset || userData.createdAt).toDateString();
+    let dailyCount = userData.dailyUsageCount;
+    if (today !== lastReset) {
+      dailyCount = 0;
+    }
+    if (numImages > config.dailyFreeLimit && userData.totalUsageCount === 0 && userData.purchasedCount === 0) {
+    }
+    const remainingToday = Math.max(0, config.dailyFreeLimit - dailyCount);
+    const totalAvailable = remainingToday + userData.remainingPurchasedCount;
+    if (totalAvailable < numImages) {
+      return {
+        allowed: false,
+        message: `生成 ${numImages} 张图片需要 ${numImages} 次可用次数，但您的可用次数不足（今日免费剩余：${remainingToday}次，充值剩余：${userData.remainingPurchasedCount}次，共${totalAvailable}次）`,
+        isAdmin: false
+      };
+    }
+    return { allowed: true, isAdmin: false };
+  }
+  // 扣减额度并记录使用
+  async consumeQuota(userId, userName, commandName, numImages, config) {
+    return await this.dataLock.acquire(async () => {
+      await this.loadUsersData();
+      let userData = this.usersCache[userId];
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const today = (/* @__PURE__ */ new Date()).toDateString();
+      if (!userData) {
+        userData = {
+          userId,
+          userName: userName || userId,
+          totalUsageCount: 0,
+          dailyUsageCount: 0,
+          lastDailyReset: now,
+          purchasedCount: 0,
+          remainingPurchasedCount: 0,
+          donationCount: 0,
+          donationAmount: 0,
+          lastUsed: now,
+          createdAt: now
+        };
+        this.usersCache[userId] = userData;
+      }
+      userData.totalUsageCount += numImages;
+      userData.lastUsed = now;
+      const lastReset = new Date(userData.lastDailyReset || userData.createdAt).toDateString();
+      if (today !== lastReset) {
+        userData.dailyUsageCount = 0;
+        userData.lastDailyReset = now;
+      }
+      let remainingToConsume = numImages;
+      let freeUsed = 0;
+      let purchasedUsed = 0;
+      const availableFree = Math.max(0, config.dailyFreeLimit - userData.dailyUsageCount);
+      if (availableFree > 0) {
+        const freeToUse = Math.min(availableFree, remainingToConsume);
+        userData.dailyUsageCount += freeToUse;
+        freeUsed = freeToUse;
+        remainingToConsume -= freeToUse;
+      }
+      if (remainingToConsume > 0) {
+        const purchasedToUse = Math.min(userData.remainingPurchasedCount, remainingToConsume);
+        userData.remainingPurchasedCount -= purchasedToUse;
+        purchasedUsed = purchasedToUse;
+        remainingToConsume -= purchasedToUse;
+      }
+      await this.saveUsersDataInternal();
+      let consumptionType;
+      if (freeUsed > 0 && purchasedUsed > 0) {
+        consumptionType = "mixed";
+      } else if (freeUsed > 0) {
+        consumptionType = "free";
+      } else {
+        consumptionType = "purchased";
+      }
+      return { userData, consumptionType, freeUsed, purchasedUsed };
+    });
+  }
+  // 记录安全拦截
+  async recordSecurityBlock(userId, config) {
+    if (!userId) return { shouldWarn: false, shouldDeduct: false, blockCount: 0 };
+    if (this.isAdmin(userId, config)) return { shouldWarn: false, shouldDeduct: false, blockCount: 0 };
+    const now = Date.now();
+    const windowMs = config.securityBlockWindow * 1e3;
+    const windowStart = now - windowMs;
+    let blockTimestamps = this.securityBlockMap.get(userId) || [];
+    blockTimestamps = blockTimestamps.filter((timestamp) => timestamp > windowStart);
+    blockTimestamps.push(now);
+    this.securityBlockMap.set(userId, blockTimestamps);
+    const blockCount = blockTimestamps.length;
+    const hasWarning = this.securityWarningMap.get(userId) || false;
+    let shouldWarn = false;
+    let shouldDeduct = false;
+    if (blockCount >= config.securityBlockWarningThreshold && !hasWarning) {
+      this.securityWarningMap.set(userId, true);
+      shouldWarn = true;
+    } else if (hasWarning) {
+      shouldDeduct = true;
+    }
+    return { shouldWarn, shouldDeduct, blockCount };
+  }
+};
+
+// src/utils/parser.ts
+var import_koishi = require("koishi");
+function normalizeSuffix(value) {
+  return value?.replace(/^\-+/, "").trim().toLowerCase();
+}
+__name(normalizeSuffix, "normalizeSuffix");
+function buildModelMappingIndex(mappings) {
+  const map = /* @__PURE__ */ new Map();
+  if (!Array.isArray(mappings)) return map;
+  for (const mapping of mappings) {
+    const key = normalizeSuffix(mapping?.suffix);
+    if (!key || !mapping?.modelId) continue;
+    map.set(key, mapping);
+  }
+  return map;
+}
+__name(buildModelMappingIndex, "buildModelMappingIndex");
+function parseStyleCommandModifiers(argv, imgParam, modelMappingIndex) {
+  const session = argv.session;
+  let rawText = "";
+  if (session?.content) {
+    const elements = import_koishi.h.parse(session.content);
+    rawText = import_koishi.h.select(elements, "text").map((e) => e.attrs.content).join(" ");
+  }
+  const argsList = rawText ? rawText.split(/\s+/).filter(Boolean) : [...argv.args || []].map((arg) => typeof arg === "string" ? arg.trim() : "").filter(Boolean);
+  if (!rawText) {
+    const restStr = typeof argv.rest === "string" ? argv.rest.trim() : "";
+    if (restStr) {
+      const restParts = restStr.split(/\s+/).filter(Boolean);
+      argsList.push(...restParts);
+    }
+    if (imgParam && typeof imgParam === "string" && !imgParam.startsWith("http") && !imgParam.startsWith("data:")) {
+      const imgParts = imgParam.split(/\s+/).filter(Boolean);
+      argsList.push(...imgParts);
+    }
+  }
+  if (!argsList.length) return {};
+  const modifiers = { customAdditions: [] };
+  const flagCandidates = [];
+  let index = 0;
+  while (index < argsList.length) {
+    const token = argsList[index];
+    if (!token) {
+      index++;
+      continue;
+    }
+    const lower = token.toLowerCase();
+    if (lower.startsWith("-prompt:")) {
+      const promptHead = token.substring(token.indexOf(":") + 1);
+      const restTokens = argsList.slice(index + 1);
+      modifiers.customPromptSuffix = [promptHead, ...restTokens].join(" ").trim();
+      break;
+    }
+    if (lower === "-add") {
+      index++;
+      const additionTokens = [];
+      while (index < argsList.length) {
+        const nextToken = argsList[index];
+        if (nextToken.startsWith("-")) {
+          const key = normalizeSuffix(nextToken);
+          if (key && modelMappingIndex.has(key)) break;
+          if (nextToken.toLowerCase().startsWith("-prompt:")) break;
+          if (nextToken.toLowerCase() === "-add") break;
+        }
+        additionTokens.push(nextToken);
+        index++;
+      }
+      if (additionTokens.length) {
+        modifiers.customAdditions.push(additionTokens.join(" "));
+      }
+      continue;
+    }
+    flagCandidates.push(token);
+    index++;
+  }
+  for (const arg of flagCandidates) {
+    if (!arg.startsWith("-")) continue;
+    const key = normalizeSuffix(arg);
+    if (!key) continue;
+    const mapping = modelMappingIndex.get(key);
+    if (mapping) {
+      modifiers.modelMapping = mapping;
+      break;
+    }
+  }
+  return modifiers;
+}
+__name(parseStyleCommandModifiers, "parseStyleCommandModifiers");
+
 // src/index.ts
 var name = "aka-ai-generator";
 var COMMANDS = {
@@ -955,56 +1171,56 @@ var COMMANDS = {
   FUNCTION_LIST: "图像功能",
   IMAGE_COMMANDS: "图像指令"
 };
-var StyleItemSchema = import_koishi.Schema.object({
-  commandName: import_koishi.Schema.string().required().description("命令名称").role("table-cell", { width: 100 }),
-  prompt: import_koishi.Schema.string().role("textarea", { rows: 4 }).required().description("生成 prompt")
+var StyleItemSchema = import_koishi2.Schema.object({
+  commandName: import_koishi2.Schema.string().required().description("命令名称").role("table-cell", { width: 100 }),
+  prompt: import_koishi2.Schema.string().role("textarea", { rows: 4 }).required().description("生成 prompt")
 });
-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 服务"),
-      import_koishi.Schema.const("gemini").description("Google Gemini 原生")
+var Config = import_koishi2.Schema.intersect([
+  import_koishi2.Schema.object({
+    provider: import_koishi2.Schema.union([
+      import_koishi2.Schema.const("yunwu").description("云雾 Gemini 服务"),
+      import_koishi2.Schema.const("gptgod").description("GPTGod 服务"),
+      import_koishi2.Schema.const("gemini").description("Google Gemini 原生")
     ]).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"),
-    geminiApiKey: import_koishi.Schema.string().description("Gemini API 密钥").role("secret").default(""),
-    geminiModelId: import_koishi.Schema.string().default("gemini-2.5-flash").description("Gemini 模型ID"),
-    geminiApiBase: import_koishi.Schema.string().default("https://generativelanguage.googleapis.com").description("Gemini API 基础地址"),
-    modelMappings: import_koishi.Schema.array(import_koishi.Schema.object({
-      suffix: import_koishi.Schema.string().required().description("指令后缀（例如 4K，对应输入 -4K）"),
-      provider: import_koishi.Schema.union([
-        import_koishi.Schema.const("yunwu").description("云雾 Gemini 服务"),
-        import_koishi.Schema.const("gptgod").description("GPTGod 服务"),
-        import_koishi.Schema.const("gemini").description("Google Gemini 原生")
+    yunwuApiKey: import_koishi2.Schema.string().description("云雾API密钥").role("secret").required(),
+    yunwuModelId: import_koishi2.Schema.string().default("gemini-2.5-flash-image").description("云雾图像生成模型ID"),
+    gptgodApiKey: import_koishi2.Schema.string().description("GPTGod API 密钥").role("secret").default(""),
+    gptgodModelId: import_koishi2.Schema.string().default("nano-banana").description("GPTGod 模型ID"),
+    geminiApiKey: import_koishi2.Schema.string().description("Gemini API 密钥").role("secret").default(""),
+    geminiModelId: import_koishi2.Schema.string().default("gemini-2.5-flash").description("Gemini 模型ID"),
+    geminiApiBase: import_koishi2.Schema.string().default("https://generativelanguage.googleapis.com").description("Gemini API 基础地址"),
+    modelMappings: import_koishi2.Schema.array(import_koishi2.Schema.object({
+      suffix: import_koishi2.Schema.string().required().description("指令后缀（例如 4K，对应输入 -4K）"),
+      provider: import_koishi2.Schema.union([
+        import_koishi2.Schema.const("yunwu").description("云雾 Gemini 服务"),
+        import_koishi2.Schema.const("gptgod").description("GPTGod 服务"),
+        import_koishi2.Schema.const("gemini").description("Google Gemini 原生")
       ]).description("可选：覆盖供应商"),
-      modelId: import_koishi.Schema.string().required().description("触发该后缀时使用的模型 ID")
+      modelId: import_koishi2.Schema.string().required().description("触发该后缀时使用的模型 ID")
     })).role("table").default([]).description("根据 -后缀切换模型/供应商"),
-    apiTimeout: import_koishi.Schema.number().default(120).description("API请求超时时间（秒）"),
-    commandTimeout: import_koishi.Schema.number().default(180).description("命令执行总超时时间（秒）"),
+    apiTimeout: import_koishi2.Schema.number().default(120).description("API请求超时时间（秒）"),
+    commandTimeout: import_koishi2.Schema.number().default(180).description("命令执行总超时时间（秒）"),
     // 默认设置
-    defaultNumImages: import_koishi.Schema.number().default(1).min(1).max(4).description("默认生成图片数量"),
+    defaultNumImages: import_koishi2.Schema.number().default(1).min(1).max(4).description("默认生成图片数量"),
     // 配额设置
-    dailyFreeLimit: import_koishi.Schema.number().default(5).min(1).max(100).description("每日免费调用次数"),
+    dailyFreeLimit: import_koishi2.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("限流窗口内最大调用次数"),
+    rateLimitWindow: import_koishi2.Schema.number().default(300).min(60).max(3600).description("限流时间窗口（秒）"),
+    rateLimitMax: import_koishi2.Schema.number().default(3).min(1).max(20).description("限流窗口内最大调用次数"),
     // 管理员设置
-    adminUsers: import_koishi.Schema.array(import_koishi.Schema.string()).default([]).description("管理员用户ID列表（不受每日使用限制）"),
+    adminUsers: import_koishi2.Schema.array(import_koishi2.Schema.string()).default([]).description("管理员用户ID列表（不受每日使用限制）"),
     // 日志级别设置
-    logLevel: import_koishi.Schema.union([
-      import_koishi.Schema.const("info").description("普通信息"),
-      import_koishi.Schema.const("debug").description("完整的debug信息")
+    logLevel: import_koishi2.Schema.union([
+      import_koishi2.Schema.const("info").description("普通信息"),
+      import_koishi2.Schema.const("debug").description("完整的debug信息")
     ]).default("info").description("日志输出详细程度"),
     // 安全策略拦截设置
-    securityBlockWindow: import_koishi.Schema.number().default(600).min(60).max(3600).description("安全策略拦截追踪时间窗口（秒），在此时间窗口内连续触发拦截会被记录"),
-    securityBlockWarningThreshold: import_koishi.Schema.number().default(3).min(1).max(10).description("安全策略拦截警示阈值，连续触发此次数拦截后将发送警示消息，再次触发将被扣除积分")
+    securityBlockWindow: import_koishi2.Schema.number().default(600).min(60).max(3600).description("安全策略拦截追踪时间窗口（秒），在此时间窗口内连续触发拦截会被记录"),
+    securityBlockWarningThreshold: import_koishi2.Schema.number().default(3).min(1).max(10).description("安全策略拦截警示阈值，连续触发此次数拦截后将发送警示消息，再次触发将被扣除积分")
   }),
   // 自定义风格命令配置
-  import_koishi.Schema.object({
-    styles: import_koishi.Schema.array(StyleItemSchema).role("table").default([
+  import_koishi2.Schema.object({
+    styles: import_koishi2.Schema.array(StyleItemSchema).role("table").default([
       {
         commandName: "变手办",
         prompt: "将这张照片变成手办模型。在它后面放置一个印有图像主体的盒子，桌子上有一台电脑显示Blender建模过程。在盒子前面添加一个圆形塑料底座，角色手办站在上面。如果可能的话，将场景设置在室内"
@@ -1015,128 +1231,33 @@ var Config = import_koishi.Schema.intersect([
       }
     ]).description("自定义风格命令配置")
   }),
-  import_koishi.Schema.object({
-    styleGroups: import_koishi.Schema.dict(import_koishi.Schema.object({
-      prompts: import_koishi.Schema.array(StyleItemSchema).role("table").default([]).description("属于该类型的 prompt 列表")
+  import_koishi2.Schema.object({
+    styleGroups: import_koishi2.Schema.dict(import_koishi2.Schema.object({
+      prompts: import_koishi2.Schema.array(StyleItemSchema).role("table").default([]).description("属于该类型的 prompt 列表")
     })).role("table").default({}).description("按类型管理的 prompt 组，键名即为分组名称")
   })
 ]);
 function apply(ctx, config) {
   const logger = ctx.logger("aka-ai-generator");
-  const activeTasks = /* @__PURE__ */ new Map();
-  const rateLimitMap = /* @__PURE__ */ new Map();
-  const securityBlockMap = /* @__PURE__ */ new Map();
-  const securityWarningMap = /* @__PURE__ */ new Map();
-  const providerCache = /* @__PURE__ */ new Map();
+  const userManager = new UserManager(ctx.baseDir, logger);
   function getProviderInstance(providerType, modelId) {
-    const cacheKey = `${providerType}:${modelId || "default"}`;
-    if (!providerCache.has(cacheKey)) {
-      providerCache.set(cacheKey, createImageProvider({
-        provider: providerType,
-        yunwuApiKey: config.yunwuApiKey,
-        yunwuModelId: providerType === "yunwu" ? modelId || config.yunwuModelId : config.yunwuModelId,
-        gptgodApiKey: config.gptgodApiKey,
-        gptgodModelId: providerType === "gptgod" ? modelId || config.gptgodModelId : config.gptgodModelId,
-        geminiApiKey: config.geminiApiKey,
-        geminiModelId: providerType === "gemini" ? modelId || config.geminiModelId : config.geminiModelId,
-        geminiApiBase: config.geminiApiBase,
-        apiTimeout: config.apiTimeout,
-        logLevel: config.logLevel,
-        logger,
-        ctx
-      }));
-    }
-    return providerCache.get(cacheKey);
+    return createImageProvider({
+      provider: providerType,
+      yunwuApiKey: config.yunwuApiKey,
+      yunwuModelId: providerType === "yunwu" ? modelId || config.yunwuModelId : config.yunwuModelId,
+      gptgodApiKey: config.gptgodApiKey,
+      gptgodModelId: providerType === "gptgod" ? modelId || config.gptgodModelId : config.gptgodModelId,
+      geminiApiKey: config.geminiApiKey,
+      geminiModelId: providerType === "gemini" ? modelId || config.geminiModelId : config.geminiModelId,
+      geminiApiBase: config.geminiApiBase,
+      apiTimeout: config.apiTimeout,
+      logLevel: config.logLevel,
+      logger,
+      ctx
+    });
   }
   __name(getProviderInstance, "getProviderInstance");
-  getProviderInstance(config.provider);
   const modelMappingIndex = buildModelMappingIndex(config.modelMappings);
-  function normalizeSuffix(value) {
-    return value?.replace(/^\-+/, "").trim().toLowerCase();
-  }
-  __name(normalizeSuffix, "normalizeSuffix");
-  function buildModelMappingIndex(mappings) {
-    const map = /* @__PURE__ */ new Map();
-    if (!Array.isArray(mappings)) return map;
-    for (const mapping of mappings) {
-      const key = normalizeSuffix(mapping?.suffix);
-      if (!key || !mapping?.modelId) continue;
-      map.set(key, mapping);
-    }
-    return map;
-  }
-  __name(buildModelMappingIndex, "buildModelMappingIndex");
-  function parseStyleCommandModifiers(argv, imgParam) {
-    const session = argv.session;
-    let rawText = "";
-    if (session?.content) {
-      const elements = import_koishi.h.parse(session.content);
-      rawText = import_koishi.h.select(elements, "text").map((e) => e.attrs.content).join(" ");
-    }
-    const argsList = rawText ? rawText.split(/\s+/).filter(Boolean) : [...argv.args || []].map((arg) => typeof arg === "string" ? arg.trim() : "").filter(Boolean);
-    if (!rawText) {
-      const restStr = typeof argv.rest === "string" ? argv.rest.trim() : "";
-      if (restStr) {
-        const restParts = restStr.split(/\s+/).filter(Boolean);
-        argsList.push(...restParts);
-      }
-      if (imgParam && typeof imgParam === "string" && !imgParam.startsWith("http") && !imgParam.startsWith("data:")) {
-        const imgParts = imgParam.split(/\s+/).filter(Boolean);
-        argsList.push(...imgParts);
-      }
-    }
-    if (!argsList.length) return {};
-    const modifiers = { customAdditions: [] };
-    const flagCandidates = [];
-    let index = 0;
-    while (index < argsList.length) {
-      const token = argsList[index];
-      if (!token) {
-        index++;
-        continue;
-      }
-      const lower = token.toLowerCase();
-      if (lower.startsWith("-prompt:")) {
-        const promptHead = token.substring(token.indexOf(":") + 1);
-        const restTokens = argsList.slice(index + 1);
-        modifiers.customPromptSuffix = [promptHead, ...restTokens].join(" ").trim();
-        break;
-      }
-      if (lower === "-add") {
-        index++;
-        const additionTokens = [];
-        while (index < argsList.length) {
-          const nextToken = argsList[index];
-          if (nextToken.startsWith("-")) {
-            const key = normalizeSuffix(nextToken);
-            if (key && modelMappingIndex.has(key)) break;
-            if (nextToken.toLowerCase().startsWith("-prompt:")) break;
-            if (nextToken.toLowerCase() === "-add") break;
-          }
-          additionTokens.push(nextToken);
-          index++;
-        }
-        if (additionTokens.length) {
-          modifiers.customAdditions.push(additionTokens.join(" "));
-        }
-        continue;
-      }
-      flagCandidates.push(token);
-      index++;
-    }
-    for (const arg of flagCandidates) {
-      if (!arg.startsWith("-")) continue;
-      const key = normalizeSuffix(arg);
-      if (!key) continue;
-      const mapping = modelMappingIndex.get(key);
-      if (mapping) {
-        modifiers.modelMapping = mapping;
-        break;
-      }
-    }
-    return modifiers;
-  }
-  __name(parseStyleCommandModifiers, "parseStyleCommandModifiers");
   const styleDefinitions = collectStyleDefinitions();
   function collectStyleDefinitions() {
     const unique = /* @__PURE__ */ new Map();
@@ -1191,230 +1312,18 @@ function apply(ctx, config) {
       { 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, numImages = 1, updateRateLimitImmediately = true) {
-    if (isAdmin(userId)) {
-      return { allowed: true, isAdmin: true };
-    }
-    const rateLimitCheck = checkRateLimit(userId);
-    if (!rateLimitCheck.allowed) {
-      return { ...rateLimitCheck, isAdmin: false };
-    }
-    if (updateRateLimitImmediately) {
-      updateRateLimit(userId);
-    }
-    const usersData = await loadUsersData();
-    const userData = usersData[userId];
-    if (!userData) {
-      if (numImages > config.dailyFreeLimit) {
-        return {
-          allowed: false,
-          message: `生成 ${numImages} 张图片需要 ${numImages} 次可用次数，但您的可用次数不足（今日免费：${config.dailyFreeLimit}次，充值：0次）`,
-          isAdmin: false
-        };
-      }
-      return { allowed: true, isAdmin: false };
-    }
-    const today = (/* @__PURE__ */ new Date()).toDateString();
-    const lastReset = new Date(userData.lastDailyReset || userData.createdAt).toDateString();
-    let dailyCount = userData.dailyUsageCount;
-    if (today !== lastReset) {
-      dailyCount = 0;
-      userData.dailyUsageCount = 0;
-      userData.lastDailyReset = (/* @__PURE__ */ new Date()).toISOString();
-    }
-    const remainingToday = Math.max(0, config.dailyFreeLimit - dailyCount);
-    const totalAvailable = remainingToday + userData.remainingPurchasedCount;
-    if (totalAvailable < numImages) {
-      return {
-        allowed: false,
-        message: `生成 ${numImages} 张图片需要 ${numImages} 次可用次数，但您的可用次数不足（今日免费剩余：${remainingToday}次，充值剩余：${userData.remainingPurchasedCount}次，共${totalAvailable}次）`,
-        isAdmin: false
-      };
-    }
-    return { allowed: true, 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, numImages = 1) {
-    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: numImages,
-        dailyUsageCount: numImages,
-        lastDailyReset: now,
-        purchasedCount: 0,
-        remainingPurchasedCount: 0,
-        donationCount: 0,
-        donationAmount: 0,
-        lastUsed: now,
-        createdAt: now
-      };
-      await saveUsersData(usersData);
-      return { userData: usersData[userId], consumptionType: "free", freeUsed: numImages, purchasedUsed: 0 };
-    }
-    usersData[userId].totalUsageCount += numImages;
-    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;
-    }
-    let remainingToConsume = numImages;
-    let freeUsed = 0;
-    let purchasedUsed = 0;
-    const availableFree = Math.max(0, config.dailyFreeLimit - usersData[userId].dailyUsageCount);
-    if (availableFree > 0) {
-      const freeToUse = Math.min(availableFree, remainingToConsume);
-      usersData[userId].dailyUsageCount += freeToUse;
-      freeUsed = freeToUse;
-      remainingToConsume -= freeToUse;
-    }
-    if (remainingToConsume > 0) {
-      const purchasedToUse = Math.min(usersData[userId].remainingPurchasedCount, remainingToConsume);
-      usersData[userId].remainingPurchasedCount -= purchasedToUse;
-      purchasedUsed = purchasedToUse;
-      remainingToConsume -= purchasedToUse;
-    }
-    await saveUsersData(usersData);
-    let consumptionType;
-    if (freeUsed > 0 && purchasedUsed > 0) {
-      consumptionType = "mixed";
-    } else if (freeUsed > 0) {
-      consumptionType = "free";
-    } else {
-      consumptionType = "purchased";
-    }
-    return { userData: usersData[userId], consumptionType, freeUsed, purchasedUsed };
-  }
-  __name(updateUserData, "updateUserData");
   async function recordUserUsage(session, commandName, numImages = 1) {
     const userId = session.userId;
     const userName = session.username || session.userId || "未知用户";
     if (!userId) return;
-    const { userData, consumptionType, freeUsed, purchasedUsed } = await updateUserData(userId, userName, commandName, numImages);
-    if (isAdmin(userId)) {
+    const { userData, consumptionType, freeUsed, purchasedUsed } = await userManager.consumeQuota(userId, userName, commandName, numImages, config);
+    if (userManager.isAdmin(userId, config)) {
       await session.send(`📊 使用统计 [管理员]
 用户：${userData.userName}
 总调用次数：${userData.totalUsageCount}次
@@ -1448,38 +1357,27 @@ function apply(ctx, config) {
       totalUsageCount: userData.totalUsageCount,
       dailyUsageCount: userData.dailyUsageCount,
       remainingPurchasedCount: userData.remainingPurchasedCount,
-      isAdmin: isAdmin(userId)
+      isAdmin: userManager.isAdmin(userId, config)
     });
   }
   __name(recordUserUsage, "recordUserUsage");
   async function recordSecurityBlock(session, numImages = 1) {
     const userId = session.userId;
     if (!userId) return;
-    if (isAdmin(userId)) {
-      return;
-    }
-    const now = Date.now();
-    const windowMs = config.securityBlockWindow * 1e3;
-    const windowStart = now - windowMs;
-    let blockTimestamps = securityBlockMap.get(userId) || [];
-    blockTimestamps = blockTimestamps.filter((timestamp) => timestamp > windowStart);
-    blockTimestamps.push(now);
-    securityBlockMap.set(userId, blockTimestamps);
-    const blockCount = blockTimestamps.length;
-    const hasWarning = securityWarningMap.get(userId) || false;
+    const { shouldWarn, shouldDeduct, blockCount } = await userManager.recordSecurityBlock(userId, config);
     logger.info("安全策略拦截记录", {
       userId,
       blockCount,
       threshold: config.securityBlockWarningThreshold,
-      hasWarning,
+      shouldWarn,
+      shouldDeduct,
       numImages
     });
-    if (blockCount >= config.securityBlockWarningThreshold && !hasWarning) {
-      securityWarningMap.set(userId, true);
+    if (shouldWarn) {
       await session.send(`⚠️ 安全策略警示
 您已连续${config.securityBlockWarningThreshold}次触发安全策略拦截，再次发送被拦截内容将被扣除积分`);
       logger.warn("用户收到安全策略警示", { userId, blockCount, threshold: config.securityBlockWarningThreshold });
-    } else if (hasWarning) {
+    } else if (shouldDeduct) {
       const commandName = "安全策略拦截";
       await recordUserUsage(session, commandName, numImages);
       logger.warn("用户因安全策略拦截被扣除积分", { userId, numImages });
@@ -1496,12 +1394,12 @@ function apply(ctx, config) {
       await session.send("请输入画面描述");
       const msg = await session.prompt(3e4);
       if (!msg) return { error: "等待超时" };
-      const elements = import_koishi.h.parse(msg);
-      const images = import_koishi.h.select(elements, "img");
+      const elements = import_koishi2.h.parse(msg);
+      const images = import_koishi2.h.select(elements, "img");
       if (images.length > 0) {
         return { error: "检测到图片，本功能仅支持文字输入" };
       }
-      const text = import_koishi.h.select(elements, "text").map((e) => e.attrs.content).join(" ").trim();
+      const text = import_koishi2.h.select(elements, "text").map((e) => e.attrs.content).join(" ").trim();
       if (!text) {
         return { error: "未检测到描述，操作已取消" };
       }
@@ -1517,7 +1415,7 @@ function apply(ctx, config) {
       }
     }
     if (session.quote?.elements) {
-      const quoteImages = import_koishi.h.select(session.quote.elements, "img");
+      const quoteImages = import_koishi2.h.select(session.quote.elements, "img");
       for (const img of quoteImages) {
         if (img.attrs.src) collectedImages.push(img.attrs.src);
       }
@@ -1536,9 +1434,9 @@ function apply(ctx, config) {
     while (true) {
       const msg = await session.prompt(mode === "multiple" ? 6e4 : 3e4);
       if (!msg) return { error: "等待超时" };
-      const elements = import_koishi.h.parse(msg);
-      const images = import_koishi.h.select(elements, "img");
-      const textElements = import_koishi.h.select(elements, "text");
+      const elements = import_koishi2.h.parse(msg);
+      const images = import_koishi2.h.select(elements, "img");
+      const textElements = import_koishi2.h.select(elements, "text");
       const text = textElements.map((el) => el.attrs.content).join(" ").trim();
       if (images.length > 0) {
         for (const img of images) {
@@ -1584,14 +1482,18 @@ function apply(ctx, config) {
   }
   __name(requestProviderImages, "requestProviderImages");
   async function processImageWithTimeout(session, img, prompt, styleName, requestContext, displayInfo, mode = "single") {
+    const userId = session.userId;
+    let isTimeout = false;
     return Promise.race([
-      processImage(session, img, prompt, styleName, requestContext, displayInfo, mode),
+      processImage(session, img, prompt, styleName, requestContext, displayInfo, mode, () => isTimeout),
       new Promise(
-        (_, reject) => setTimeout(() => reject(new Error("命令执行超时")), config.commandTimeout * 1e3)
+        (_, reject) => setTimeout(() => {
+          isTimeout = true;
+          reject(new Error("命令执行超时"));
+        }, config.commandTimeout * 1e3)
       )
     ]).catch(async (error) => {
-      const userId = session.userId;
-      if (userId) activeTasks.delete(userId);
+      if (userId) userManager.endTask(userId);
       const sanitizedError = sanitizeError(error);
       logger.error("图像处理超时或失败", { userId, error: sanitizedError });
       if (error?.message !== "命令执行超时") {
@@ -1607,99 +1509,88 @@ function apply(ctx, config) {
     });
   }
   __name(processImageWithTimeout, "processImageWithTimeout");
-  async function processImage(session, img, prompt, styleName, requestContext, displayInfo, mode = "single") {
+  async function processImage(session, img, prompt, styleName, requestContext, displayInfo, mode = "single", checkTimeout) {
     const userId = session.userId;
-    if (activeTasks.has(userId)) {
+    if (!userManager.startTask(userId)) {
       return "您有一个图像处理任务正在进行中，请等待完成";
     }
-    const imageCount = requestContext?.numImages || config.defaultNumImages;
-    if (imageCount < 1 || imageCount > 4) {
-      return "生成数量必须在 1-4 之间";
-    }
-    const inputResult = await getInputData(session, img, mode);
-    if ("error" in inputResult) {
-      return inputResult.error;
-    }
-    const { images: imageUrls, text: extraText } = inputResult;
-    let finalPrompt = prompt;
-    if (extraText) {
-      finalPrompt += " " + extraText;
-    }
-    finalPrompt = finalPrompt.trim();
-    if (!finalPrompt) {
-      await session.send("请发送画面描述");
-      const promptMsg = await session.prompt(3e4);
-      if (!promptMsg) {
-        return "未检测到描述，操作已取消";
+    try {
+      const imageCount = requestContext?.numImages || config.defaultNumImages;
+      if (imageCount < 1 || imageCount > 4) {
+        return "生成数量必须在 1-4 之间";
+      }
+      const inputResult = await getInputData(session, img, mode);
+      if ("error" in inputResult) {
+        return inputResult.error;
+      }
+      if (checkTimeout && checkTimeout()) throw new Error("命令执行超时");
+      const { images: imageUrls, text: extraText } = inputResult;
+      let finalPrompt = prompt;
+      if (extraText) {
+        finalPrompt += " " + extraText;
+      }
+      finalPrompt = finalPrompt.trim();
+      if (!finalPrompt) {
+        await session.send("请发送画面描述");
+        const promptMsg = await session.prompt(3e4);
+        if (!promptMsg) {
+          return "未检测到描述，操作已取消";
+        }
+        const elements = import_koishi2.h.parse(promptMsg);
+        const images2 = import_koishi2.h.select(elements, "img");
+        if (images2.length > 0) {
+          return "检测到图片，本功能仅支持文字输入";
+        }
+        const text = import_koishi2.h.select(elements, "text").map((e) => e.attrs.content).join(" ").trim();
+        if (text) {
+          finalPrompt = text;
+        } else {
+          return "未检测到有效文字描述，操作已取消";
+        }
       }
-      const elements = import_koishi.h.parse(promptMsg);
-      const images = import_koishi.h.select(elements, "img");
-      if (images.length > 0) {
-        return "检测到图片，本功能仅支持文字输入";
+      if (checkTimeout && checkTimeout()) throw new Error("命令执行超时");
+      const providerType = requestContext?.provider || config.provider;
+      const providerModelId = requestContext?.modelId || (providerType === "yunwu" ? config.yunwuModelId : config.gptgodModelId);
+      logger.info("开始图像处理", {
+        userId,
+        imageUrls,
+        styleName,
+        prompt: finalPrompt,
+        numImages: imageCount,
+        provider: providerType,
+        modelId: providerModelId
+      });
+      let statusMessage = `开始处理图片（${styleName}）`;
+      const infoParts = [];
+      if (displayInfo?.customAdditions && displayInfo.customAdditions.length > 0) {
+        infoParts.push(`自定义内容：${displayInfo.customAdditions.join("；")}`);
       }
-      const text = import_koishi.h.select(elements, "text").map((e) => e.attrs.content).join(" ").trim();
-      if (text) {
-        finalPrompt = text;
-      } else {
-        return "未检测到有效文字描述，操作已取消";
+      if (displayInfo?.modelId) {
+        const modelDesc = displayInfo.modelDescription || displayInfo.modelId;
+        infoParts.push(`使用模型：${modelDesc}`);
       }
-    }
-    const providerType = requestContext?.provider || config.provider;
-    const providerModelId = requestContext?.modelId || (providerType === "yunwu" ? config.yunwuModelId : config.gptgodModelId);
-    logger.info("开始图像处理", {
-      userId,
-      imageUrls,
-      styleName,
-      prompt: finalPrompt,
-      numImages: imageCount,
-      provider: providerType,
-      modelId: providerModelId
-    });
-    let statusMessage = `开始处理图片（${styleName}）`;
-    const infoParts = [];
-    if (displayInfo?.customAdditions && displayInfo.customAdditions.length > 0) {
-      infoParts.push(`自定义内容：${displayInfo.customAdditions.join("；")}`);
-    }
-    if (displayInfo?.modelId) {
-      const modelDesc = displayInfo.modelDescription || displayInfo.modelId;
-      infoParts.push(`使用模型：${modelDesc}`);
-    }
-    if (infoParts.length > 0) {
-      statusMessage += `
+      if (infoParts.length > 0) {
+        statusMessage += `
 ${infoParts.join("\n")}`;
-    }
-    statusMessage += "...";
-    await session.send(statusMessage);
-    try {
-      activeTasks.set(userId, "processing");
+      }
+      statusMessage += "...";
+      await session.send(statusMessage);
       const images = await requestProviderImages(finalPrompt, imageUrls, imageCount, requestContext);
+      if (checkTimeout && checkTimeout()) throw new Error("命令执行超时");
       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 (checkTimeout && checkTimeout()) break;
+        await session.send(import_koishi2.h.image(images[i]));
         if (images.length > 1 && i < images.length - 1) {
           await new Promise((resolve) => setTimeout(resolve, 1e3));
         }
       }
       await recordUserUsage(session, styleName, images.length);
-      activeTasks.delete(userId);
-    } catch (error) {
-      activeTasks.delete(userId);
-      const sanitizedError = sanitizeError(error);
-      logger.error("图像处理失败", { userId, error: sanitizedError });
-      const errorMessage = error?.message || "";
-      const isSecurityBlock = errorMessage.includes("内容被安全策略拦截") || errorMessage.includes("内容被安全策略阻止") || errorMessage.includes("内容被阻止") || errorMessage.includes("被阻止") || errorMessage.includes("SAFETY") || errorMessage.includes("RECITATION");
-      if (isSecurityBlock) {
-        await recordSecurityBlock(session, imageCount);
-      }
-      if (error?.message) {
-        const safeMessage = sanitizeString(error.message);
-        return `图像处理失败：${safeMessage}`;
-      }
-      return "图像处理失败，请稍后重试";
+    } finally {
+      userManager.endTask(userId);
     }
   }
   __name(processImage, "processImage");
@@ -1709,7 +1600,7 @@ ${infoParts.join("\n")}`;
         ctx.command(`${style.commandName} [img:text]`, "图像风格转换").option("num", "-n <num:number> 生成图片数量 (1-4)").option("multiple", "-m 允许多图输入").action(async (argv, img) => {
           const { session, options } = argv;
           if (!session?.userId) return "会话无效";
-          const modifiers = parseStyleCommandModifiers(argv, img);
+          const modifiers = parseStyleCommandModifiers(argv, img, modelMappingIndex);
           let userPromptParts = [];
           if (modifiers.customAdditions?.length) {
             userPromptParts.push(...modifiers.customAdditions);
@@ -1719,7 +1610,7 @@ ${infoParts.join("\n")}`;
           }
           const userPromptText = userPromptParts.join(" - ");
           const numImages = options?.num || config.defaultNumImages;
-          const limitCheck = await checkDailyLimit(session.userId, numImages);
+          const limitCheck = await userManager.checkDailyLimit(session.userId, config, numImages);
           if (!limitCheck.allowed) {
             return limitCheck.message;
           }
@@ -1755,7 +1646,7 @@ ${infoParts.join("\n")}`;
   ctx.command(`${COMMANDS.TXT_TO_IMG} [prompt:text]`, "根据文字描述生成图像").option("num", "-n <num:number> 生成图片数量 (1-4)").action(async ({ session, options }, prompt) => {
     if (!session?.userId) return "会话无效";
     const numImages = options?.num || config.defaultNumImages;
-    const limitCheck = await checkDailyLimit(session.userId, numImages);
+    const limitCheck = await userManager.checkDailyLimit(session.userId, config, numImages);
     if (!limitCheck.allowed) {
       return limitCheck.message;
     }
@@ -1768,7 +1659,7 @@ ${infoParts.join("\n")}`;
     if (!session?.userId) return "会话无效";
     const numImages = options?.num || config.defaultNumImages;
     const mode = options?.multiple ? "multiple" : "single";
-    const limitCheck = await checkDailyLimit(session.userId, numImages);
+    const limitCheck = await userManager.checkDailyLimit(session.userId, config, numImages);
     if (!limitCheck.allowed) {
       return limitCheck.message;
     }
@@ -1779,106 +1670,99 @@ ${infoParts.join("\n")}`;
   });
   ctx.command(COMMANDS.COMPOSE_IMAGE, "合成多张图片，使用自定义prompt控制合成效果").option("num", "-n <num:number> 生成图片数量 (1-4)").action(async ({ session, options }) => {
     if (!session?.userId) return "会话无效";
+    const userId = session.userId;
+    if (!userManager.startTask(userId)) {
+      return "您有一个图像处理任务正在进行中，请等待完成";
+    }
+    userManager.endTask(userId);
+    let isTimeout = false;
     return Promise.race([
       (async () => {
-        const userId = session.userId;
-        if (!userId) return "会话无效";
-        if (activeTasks.has(userId)) {
-          return "您有一个图像处理任务正在进行中，请等待完成";
-        }
-        await session.send("多张图片+描述");
-        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 (!userManager.startTask(userId)) return "您有一个图像处理任务正在进行中";
+        try {
+          await session.send("多张图片+描述");
+          const collectedImages = [];
+          let prompt = "";
+          while (true) {
+            const msg = await session.prompt(6e4);
+            if (!msg) {
+              return "等待超时，请重试";
+            }
+            if (isTimeout) throw new Error("命令执行超时");
+            const elements = import_koishi2.h.parse(msg);
+            const images = import_koishi2.h.select(elements, "img");
+            const textElements = import_koishi2.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} 张图片，继续发送或输入描述`);
+              continue;
             }
             if (text) {
+              if (collectedImages.length < 2) {
+                return `需要至少两张图片进行合成，当前只有 ${collectedImages.length} 张图片`;
+              }
               prompt = text;
               break;
             }
-            await session.send(`已收到 ${collectedImages.length} 张图片，继续发送或输入描述`);
-            continue;
+            return "未检测到有效内容，操作已取消";
           }
-          if (text) {
-            if (collectedImages.length < 2) {
-              return `需要至少两张图片进行合成，当前只有 ${collectedImages.length} 张图片`;
-            }
-            prompt = text;
-            break;
+          if (collectedImages.length < 2) {
+            return "需要至少两张图片进行合成，请重新发送";
           }
-          return "未检测到有效内容，操作已取消";
-        }
-        if (collectedImages.length < 2) {
-          return "需要至少两张图片进行合成，请重新发送";
-        }
-        if (!prompt) {
-          return "未检测到prompt描述，请重新发送";
-        }
-        const imageCount = options?.num || config.defaultNumImages;
-        if (imageCount < 1 || imageCount > 4) {
-          return "生成数量必须在 1-4 之间";
-        }
-        const limitCheck = await checkDailyLimit(userId, imageCount);
-        if (!limitCheck.allowed) {
-          return limitCheck.message;
-        }
-        logger.info("开始图片合成处理", {
-          userId,
-          imageUrls: collectedImages,
-          prompt,
-          numImages: imageCount,
-          imageCount: collectedImages.length
-        });
-        await session.send(`开始合成图（${collectedImages.length}张）...
+          if (!prompt) {
+            return "未检测到prompt描述，请重新发送";
+          }
+          const imageCount = options?.num || config.defaultNumImages;
+          if (imageCount < 1 || imageCount > 4) {
+            return "生成数量必须在 1-4 之间";
+          }
+          const limitCheck = await userManager.checkDailyLimit(userId, config, imageCount);
+          if (!limitCheck.allowed) {
+            return limitCheck.message;
+          }
+          if (isTimeout) throw new Error("命令执行超时");
+          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 (isTimeout) throw new Error("命令执行超时");
           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 (isTimeout) break;
+            await session.send(import_koishi2.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, resultImages.length);
-          activeTasks.delete(userId);
-        } catch (error) {
-          activeTasks.delete(userId);
-          const sanitizedError = sanitizeError(error);
-          logger.error("图片合成失败", { userId, error: sanitizedError });
-          const errorMessage = error?.message || "";
-          const isSecurityBlock = errorMessage.includes("内容被安全策略拦截") || errorMessage.includes("内容被安全策略阻止") || errorMessage.includes("内容被阻止") || errorMessage.includes("被阻止") || errorMessage.includes("SAFETY") || errorMessage.includes("RECITATION");
-          if (isSecurityBlock) {
-            await recordSecurityBlock(session, imageCount);
-          }
-          if (error?.message) {
-            const safeMessage = sanitizeString(error.message);
-            return `图片合成失败：${safeMessage}`;
-          }
-          return "图片合成失败，请稍后重试";
+        } finally {
+          userManager.endTask(userId);
         }
       })(),
       new Promise(
-        (_, reject) => setTimeout(() => reject(new Error("命令执行超时")), config.commandTimeout * 1e3)
+        (_, reject) => setTimeout(() => {
+          isTimeout = true;
+          reject(new Error("命令执行超时"));
+        }, config.commandTimeout * 1e3)
       )
     ]).catch(async (error) => {
-      const userId = session.userId;
-      if (userId) activeTasks.delete(userId);
+      if (userId) userManager.endTask(userId);
       const sanitizedError = sanitizeError(error);
       logger.error("图片合成超时或失败", { userId, error: sanitizedError });
       if (error?.message !== "命令执行超时") {
@@ -1895,14 +1779,14 @@ Prompt: ${prompt}`);
   });
   ctx.command(`${COMMANDS.RECHARGE} [content:text]`, "为用户充值次数（仅管理员）").action(async ({ session }, content) => {
     if (!session?.userId) return "会话无效";
-    if (!isAdmin(session.userId)) {
+    if (!userManager.isAdmin(session.userId, config)) {
       return "权限不足，仅管理员可操作";
     }
     const inputContent = content || await getPromptInput(session, "请输入充值信息，格式：\n@用户1 @用户2 充值次数 [备注]");
     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 elements = import_koishi2.h.parse(inputContent);
+    const atElements = import_koishi2.h.select(elements, "at");
+    const textElements = import_koishi2.h.select(elements, "text");
     const text = textElements.map((el) => el.attrs.content).join(" ").trim();
     if (atElements.length === 0) {
       return "未找到@用户，请使用@用户的方式";
@@ -1921,66 +1805,64 @@ Prompt: ${prompt}`);
       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] = {
+      let totalAmount = 0;
+      await userManager.updateUsersBatch((usersData) => {
+        for (const userId of userIds) {
+          if (!userId) continue;
+          let userName = userId;
+          if (usersData[userId]) {
+            userName = usersData[userId].userName || userId;
+          } else {
+            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: userId,
-            totalUsageCount: 0,
-            dailyUsageCount: 0,
-            lastDailyReset: now,
-            purchasedCount: 0,
-            remainingPurchasedCount: 0,
-            donationCount: 0,
-            donationAmount: 0,
-            lastUsed: now,
-            createdAt: now
-          };
+            userName,
+            amount,
+            beforeBalance,
+            afterBalance: usersData[userId].remainingPurchasedCount
+          });
         }
-        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 = {
+        totalAmount = amount * targets.length;
+      });
+      await userManager.addRechargeRecord({
         id: recordId,
         timestamp: now,
-        type: userIds.length > 1 ? "batch" : "single",
+        type: targets.length > 1 ? "batch" : "single",
         operator: {
           userId: session.userId,
           userName: session.username || session.userId
         },
         targets,
-        totalAmount: amount * userIds.length,
-        note: note || "管理员充值",
+        totalAmount,
+        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}`;
+总充值：${totalAmount}次
+操作员：${session.username}
+备注：${note}`;
     } catch (error) {
       logger.error("充值操作失败", error);
       return "充值失败，请稍后重试";
@@ -1988,13 +1870,13 @@ Prompt: ${prompt}`);
   });
   ctx.command(`${COMMANDS.RECHARGE_ALL} [content:text]`, "为所有用户充值次数（活动派发，仅管理员）").action(async ({ session }, content) => {
     if (!session?.userId) return "会话无效";
-    if (!isAdmin(session.userId)) {
+    if (!userManager.isAdmin(session.userId, config)) {
       return "权限不足，仅管理员可操作";
     }
     const inputContent = content || await getPromptInput(session, "请输入活动充值信息，格式：\n充值次数 [备注]\n例如：20 或 20 春节活动奖励");
     if (!inputContent) return "输入超时或无效";
-    const elements = import_koishi.h.parse(inputContent);
-    const textElements = import_koishi.h.select(elements, "text");
+    const elements = import_koishi2.h.parse(inputContent);
+    const textElements = import_koishi2.h.select(elements, "text");
     const text = textElements.map((el) => el.attrs.content).join(" ").trim();
     const parts = text.split(/\s+/).filter((p) => p);
     if (parts.length === 0) {
@@ -2006,32 +1888,34 @@ Prompt: ${prompt}`);
       return "充值次数必须大于0";
     }
     try {
-      const usersData = await loadUsersData();
-      const rechargeHistory = await loadRechargeHistory();
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const recordId = `recharge_all_${now.replace(/[-:T.]/g, "").slice(0, 14)}_${Math.random().toString(36).substr(2, 3)}`;
-      const allUserIds = Object.keys(usersData).filter((userId) => userId && usersData[userId]);
-      if (allUserIds.length === 0) {
-        return "当前没有使用过插件的用户，无法进行活动充值";
-      }
       const targets = [];
-      for (const userId of allUserIds) {
-        if (!userId) continue;
-        const userData = usersData[userId];
-        const userName = userData.userName || userId;
-        const beforeBalance = userData.remainingPurchasedCount;
-        userData.purchasedCount += amount;
-        userData.remainingPurchasedCount += amount;
-        targets.push({
-          userId,
-          userName,
-          amount,
-          beforeBalance,
-          afterBalance: userData.remainingPurchasedCount
-        });
+      let totalAmount = 0;
+      let successCount = 0;
+      await userManager.updateUsersBatch((usersData) => {
+        const allUserIds = Object.keys(usersData);
+        for (const userId of allUserIds) {
+          if (!userId || !usersData[userId]) continue;
+          const userData = usersData[userId];
+          const beforeBalance = userData.remainingPurchasedCount;
+          userData.purchasedCount += amount;
+          userData.remainingPurchasedCount += amount;
+          targets.push({
+            userId,
+            userName: userData.userName || userId,
+            amount,
+            beforeBalance,
+            afterBalance: userData.remainingPurchasedCount
+          });
+          successCount++;
+        }
+        totalAmount = amount * successCount;
+      });
+      if (successCount === 0) {
+        return "当前没有使用过插件的用户，无法进行活动充值";
       }
-      await saveUsersData(usersData);
-      const record = {
+      await userManager.addRechargeRecord({
         id: recordId,
         timestamp: now,
         type: "all",
@@ -2040,18 +1924,16 @@ Prompt: ${prompt}`);
           userName: session.username || session.userId
         },
         targets,
-        totalAmount: amount * allUserIds.length,
-        note: note || "活动充值",
+        totalAmount,
+        note,
         metadata: { all: true }
-      };
-      rechargeHistory.records.push(record);
-      await saveRechargeHistory(rechargeHistory);
+      });
       return `✅ 活动充值成功
-目标用户数：${allUserIds.length}人
+目标用户数：${successCount}人
 充值次数：${amount}次/人
-总充值：${record.totalAmount}次
-操作员：${record.operator.userName}
-备注：${record.note}`;
+总充值：${totalAmount}次
+操作员：${session.username}
+备注：${note}`;
     } catch (error) {
       logger.error("活动充值操作失败", error);
       return "活动充值失败，请稍后重试";
@@ -2059,7 +1941,7 @@ Prompt: ${prompt}`);
   });
   ctx.command(`${COMMANDS.QUERY_QUOTA} [target:text]`, "查询用户额度信息").action(async ({ session }, target) => {
     if (!session?.userId) return "会话无效";
-    const userIsAdmin = isAdmin(session.userId);
+    const userIsAdmin = userManager.isAdmin(session.userId, config);
     let targetUserId = session.userId;
     let targetUserName = session.username || session.userId;
     if (target && userIsAdmin) {
@@ -2072,15 +1954,7 @@ Prompt: ${prompt}`);
       return "权限不足，仅管理员可查询其他用户";
     }
     try {
-      const usersData = await loadUsersData();
-      const userData = usersData[targetUserId];
-      if (!userData) {
-        return `👤 用户信息
-用户：${targetUserName}
-状态：新用户
-今日剩余免费：${config.dailyFreeLimit}次
-充值剩余：0次`;
-      }
+      const userData = await userManager.getUserData(targetUserId, targetUserName);
       const remainingToday = Math.max(0, config.dailyFreeLimit - userData.dailyUsageCount);
       const totalAvailable = remainingToday + userData.remainingPurchasedCount;
       return `👤 用户额度信息
@@ -2097,11 +1971,11 @@ Prompt: ${prompt}`);
   });
   ctx.command(`${COMMANDS.RECHARGE_HISTORY} [page:number]`, "查看充值历史记录（仅管理员）").action(async ({ session }, page = 1) => {
     if (!session?.userId) return "会话无效";
-    if (!isAdmin(session.userId)) {
+    if (!userManager.isAdmin(session.userId, config)) {
       return "权限不足，仅管理员可查看充值记录";
     }
     try {
-      const history = await loadRechargeHistory();
+      const history = await userManager.loadRechargeHistory();
       const pageSize = 10;
       const totalPages = Math.ceil(history.records.length / pageSize);
       const startIndex = (page - 1) * pageSize;
@@ -2135,7 +2009,7 @@ Prompt: ${prompt}`);
   ctx.command(COMMANDS.FUNCTION_LIST, "查看所有可用的图像处理功能").action(async ({ session }) => {
     if (!session?.userId) return "会话无效";
     try {
-      const userIsAdmin = isAdmin(session.userId);
+      const userIsAdmin = userManager.isAdmin(session.userId, config);
       let result = "🎨 图像处理功能列表\n\n";
       result += "📝 用户指令：\n";
       commandRegistry.userCommands.forEach((cmd) => {