koishi-plugin-aka-ai-generator 0.7.5 → 0.7.6

package/lib/index.js

@@ -1067,6 +1067,12 @@ var YunwuVideoProvider = class {
       await new Promise((resolve) => setTimeout(resolve, pollInterval * 1e3));
     }
   }
+  /**
+   * 等待指定任务完成并返回视频 URL（供外部在拿到 taskId 后自行控制扣费/提示）
+   */
+  async waitForVideo(taskId, maxWaitTime = 300) {
+    return await this.pollTaskCompletion(taskId, maxWaitTime);
+  }
   /**
    * 生成视频（主入口）
    */
@@ -1077,7 +1083,7 @@ var YunwuVideoProvider = class {
       const taskId = await this.createVideoTask(prompt, imageUrl, options);
       logger?.debug("任务已创建，等待 3 秒后开始查询", { taskId });
       await new Promise((resolve) => setTimeout(resolve, 3e3));
-      const videoUrl = await this.pollTaskCompletion(taskId, maxWaitTime);
+      const videoUrl = await this.waitForVideo(taskId, maxWaitTime);
       logger?.info("视频生成完成", { taskId, videoUrl });
       return videoUrl;
     } catch (error) {
@@ -1157,11 +1163,14 @@ var UserManager = class {
   dataFile;
   backupFile;
   rechargeHistoryFile;
+  pendingVideoTasksFile;
   logger;
   dataLock = new AsyncLock();
   historyLock = new AsyncLock();
+  pendingLock = new AsyncLock();
   // 内存缓存
   usersCache = null;
+  pendingVideoCache = null;
   activeTasks = /* @__PURE__ */ new Map();
   // userId -> requestId
   rateLimitMap = /* @__PURE__ */ new Map();
@@ -1176,6 +1185,7 @@ var UserManager = class {
     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");
+    this.pendingVideoTasksFile = (0, import_path.join)(this.dataDir, "pending_video_tasks.json");
     if (!(0, import_fs.existsSync)(this.dataDir)) {
       (0, import_fs.mkdirSync)(this.dataDir, { recursive: true });
     }
@@ -1237,6 +1247,83 @@ var UserManager = class {
       throw error;
     }
   }
+  // --- 待结算视频任务（防止超时套利） ---
+  async loadPendingVideoTasks() {
+    if (this.pendingVideoCache) return this.pendingVideoCache;
+    return await this.pendingLock.acquire(async () => {
+      if (this.pendingVideoCache) return this.pendingVideoCache;
+      try {
+        if ((0, import_fs.existsSync)(this.pendingVideoTasksFile)) {
+          const data = await import_fs.promises.readFile(this.pendingVideoTasksFile, "utf-8");
+          const parsed = JSON.parse(data);
+          this.pendingVideoCache = {
+            version: parsed?.version || "1.0.0",
+            lastUpdate: parsed?.lastUpdate || (/* @__PURE__ */ new Date()).toISOString(),
+            tasks: parsed?.tasks || {}
+          };
+          return this.pendingVideoCache;
+        }
+      } catch (error) {
+        this.logger.error("读取待结算视频任务失败", error);
+      }
+      this.pendingVideoCache = {
+        version: "1.0.0",
+        lastUpdate: (/* @__PURE__ */ new Date()).toISOString(),
+        tasks: {}
+      };
+      return this.pendingVideoCache;
+    });
+  }
+  async savePendingVideoTasksInternal() {
+    if (!this.pendingVideoCache) return;
+    try {
+      this.pendingVideoCache.lastUpdate = (/* @__PURE__ */ new Date()).toISOString();
+      await import_fs.promises.writeFile(this.pendingVideoTasksFile, JSON.stringify(this.pendingVideoCache, null, 2), "utf-8");
+    } catch (error) {
+      this.logger.error("保存待结算视频任务失败", error);
+      throw error;
+    }
+  }
+  /**
+   * 记录一个待结算的视频任务（任务创建成功后立即写入，避免“超时但最终成功”不扣费）
+   */
+  async addPendingVideoTask(task) {
+    await this.loadPendingVideoTasks();
+    await this.pendingLock.acquire(async () => {
+      if (!this.pendingVideoCache) {
+        this.pendingVideoCache = { version: "1.0.0", lastUpdate: (/* @__PURE__ */ new Date()).toISOString(), tasks: {} };
+      }
+      if (this.pendingVideoCache.tasks[task.taskId]) return;
+      this.pendingVideoCache.tasks[task.taskId] = task;
+      await this.savePendingVideoTasksInternal();
+    });
+  }
+  async getPendingVideoTask(taskId) {
+    const data = await this.loadPendingVideoTasks();
+    return data.tasks[taskId] || null;
+  }
+  async markPendingVideoTaskCharged(taskId) {
+    await this.loadPendingVideoTasks();
+    return await this.pendingLock.acquire(async () => {
+      if (!this.pendingVideoCache) return null;
+      const task = this.pendingVideoCache.tasks[taskId];
+      if (!task) return null;
+      if (task.charged) return task;
+      task.charged = true;
+      task.chargedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.savePendingVideoTasksInternal();
+      return task;
+    });
+  }
+  async deletePendingVideoTask(taskId) {
+    await this.loadPendingVideoTasks();
+    await this.pendingLock.acquire(async () => {
+      if (!this.pendingVideoCache) return;
+      if (!this.pendingVideoCache.tasks[taskId]) return;
+      delete this.pendingVideoCache.tasks[taskId];
+      await this.savePendingVideoTasksInternal();
+    });
+  }
   // 获取特定用户数据
   async getUserData(userId, userName) {
     await this.loadUsersData();
@@ -2230,6 +2317,7 @@ ${infoParts.join("\n")}`;
       if (!userManager.startTask(userId)) {
         return "您有一个任务正在进行中，请等待完成";
       }
+      let createdTaskId = null;
       try {
         const inputResult = await getInputData(session, img, "single");
         if ("error" in inputResult) {
@@ -2271,17 +2359,30 @@ ${infoParts.join("\n")}`;
 💡 提示：生成过程中可继续使用其他功能`
         );
         const startTime = Date.now();
-        const videoUrl = await videoProvider.generateVideo(
+        const taskId = await videoProvider.createVideoTask(
           prompt,
           imageUrls[0],
           {
             duration,
             aspectRatio: ratio
-          },
-          config.videoMaxWaitTime
+          }
         );
-        await recordUserUsage(session, "图生视频", videoCredits, false);
+        createdTaskId = taskId;
+        await userManager.addPendingVideoTask({
+          taskId,
+          userId,
+          userName,
+          commandName: "图生视频",
+          credits: videoCredits,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          charged: false
+        });
+        await new Promise((resolve) => setTimeout(resolve, 3e3));
+        const videoUrl = await videoProvider.waitForVideo(taskId, config.videoMaxWaitTime);
         await session.send(import_koishi2.h.video(videoUrl));
+        await recordUserUsage(session, "图生视频", videoCredits, false);
+        await userManager.markPendingVideoTaskCharged(taskId);
+        await userManager.deletePendingVideoTask(taskId);
         const totalTime = Math.floor((Date.now() - startTime) / 1e3);
         await session.send(`✅ 视频生成完成！（耗时 ${totalTime} 秒）`);
       } catch (error) {
@@ -2290,6 +2391,10 @@ ${infoParts.join("\n")}`;
         if (errorMsg.includes("任务ID:")) {
           return errorMsg;
         }
+        try {
+          if (createdTaskId) await userManager.deletePendingVideoTask(createdTaskId);
+        } catch {
+        }
         return `视频生成失败：${sanitizeString(errorMsg)}`;
       } finally {
         userManager.endTask(userId);
@@ -2306,7 +2411,17 @@ ${infoParts.join("\n")}`;
         await session.send("🔍 正在查询视频生成状态...");
         const status = await videoProvider.queryTaskStatus(taskId.trim());
         if (status.status === "completed" && status.videoUrl) {
+          const trimmedTaskId = taskId.trim();
+          const pending = await userManager.getPendingVideoTask(trimmedTaskId);
+          if (pending && pending.userId && pending.userId !== session.userId) {
+            return "该任务ID不属于当前用户，无法查询";
+          }
           await session.send(import_koishi2.h.video(status.videoUrl));
+          if (pending && !pending.charged) {
+            await recordUserUsage(session, pending.commandName, pending.credits, false);
+            await userManager.markPendingVideoTaskCharged(trimmedTaskId);
+            await userManager.deletePendingVideoTask(trimmedTaskId);
+          }
           return "✅ 视频已生成完成！";
         } else if (status.status === "processing" || status.status === "pending") {
           const progressText = status.progress ? `（进度：${status.progress}%）` : "";
@@ -2343,6 +2458,7 @@ ${infoParts.join("\n")}`;
         if (!userManager.startTask(userId)) {
           return "您有一个任务正在进行中，请等待完成";
         }
+        let createdTaskId = null;
         try {
           const inputResult = await getInputData(session, img, "single");
           if ("error" in inputResult) {
@@ -2361,17 +2477,30 @@ ${infoParts.join("\n")}`;
 📝 描述：${finalPrompt}
 ⏱️ 预计需要 1-3 分钟`
           );
-          const videoUrl = await videoProvider.generateVideo(
+          const taskId = await videoProvider.createVideoTask(
             finalPrompt,
             imageUrls[0],
             {
               duration: style.duration || 15,
               aspectRatio: style.aspectRatio || "16:9"
-            },
-            config.videoMaxWaitTime
+            }
           );
-          await recordUserUsage(session, style.commandName, videoCredits, false);
+          createdTaskId = taskId;
+          await userManager.addPendingVideoTask({
+            taskId,
+            userId,
+            userName,
+            commandName: style.commandName,
+            credits: videoCredits,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            charged: false
+          });
+          await new Promise((resolve) => setTimeout(resolve, 3e3));
+          const videoUrl = await videoProvider.waitForVideo(taskId, config.videoMaxWaitTime);
           await session.send(import_koishi2.h.video(videoUrl));
+          await recordUserUsage(session, style.commandName, videoCredits, false);
+          await userManager.markPendingVideoTaskCharged(taskId);
+          await userManager.deletePendingVideoTask(taskId);
           await session.send(`✅ 视频生成完成！`);
         } catch (error) {
           logger.error("视频风格转换失败", { userId, style: style.commandName, error: sanitizeError(error) });
@@ -2379,6 +2508,10 @@ ${infoParts.join("\n")}`;
           if (errorMsg.includes("任务ID:")) {
             return errorMsg;
           }
+          try {
+            if (createdTaskId) await userManager.deletePendingVideoTask(createdTaskId);
+          } catch {
+          }
           return `视频生成失败：${sanitizeString(errorMsg)}`;
         } finally {
           userManager.endTask(userId);

package/lib/providers/yunwu-video.d.ts

@@ -21,6 +21,10 @@ export declare class YunwuVideoProvider implements VideoProvider {
      * 轮询等待任务完成
      */
     private pollTaskCompletion;
+    /**
+     * 等待指定任务完成并返回视频 URL（供外部在拿到 taskId 后自行控制扣费/提示）
+     */
+    waitForVideo(taskId: string, maxWaitTime?: number): Promise<string>;
     /**
      * 生成视频（主入口）
      */

package/lib/services/UserManager.d.ts

@@ -39,15 +39,33 @@ export interface RechargeHistory {
     lastUpdate: string;
     records: RechargeRecord[];
 }
+export interface PendingVideoTask {
+    taskId: string;
+    userId: string;
+    userName: string;
+    commandName: string;
+    credits: number;
+    createdAt: string;
+    charged: boolean;
+    chargedAt?: string;
+}
+export interface PendingVideoTasksData {
+    version: string;
+    lastUpdate: string;
+    tasks: Record<string, PendingVideoTask>;
+}
 export declare class UserManager {
     private dataDir;
     private dataFile;
     private backupFile;
     private rechargeHistoryFile;
+    private pendingVideoTasksFile;
     private logger;
     private dataLock;
     private historyLock;
+    private pendingLock;
     private usersCache;
+    private pendingVideoCache;
     private activeTasks;
     private rateLimitMap;
     private securityBlockMap;
@@ -59,6 +77,15 @@ export declare class UserManager {
     isAdmin(userId: string, config: Config): boolean;
     private loadUsersData;
     private saveUsersDataInternal;
+    private loadPendingVideoTasks;
+    private savePendingVideoTasksInternal;
+    /**
+     * 记录一个待结算的视频任务（任务创建成功后立即写入，避免“超时但最终成功”不扣费）
+     */
+    addPendingVideoTask(task: PendingVideoTask): Promise<void>;
+    getPendingVideoTask(taskId: string): Promise<PendingVideoTask | null>;
+    markPendingVideoTaskCharged(taskId: string): Promise<PendingVideoTask | null>;
+    deletePendingVideoTask(taskId: string): Promise<void>;
     getUserData(userId: string, userName: string): Promise<UserData>;
     getAllUsers(): Promise<UsersData>;
     updateUsersBatch(updates: (data: UsersData) => void): Promise<void>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-aka-ai-generator",
   "description": "自用AI生成插件(GPTGod & Yunwu)",
-  "version": "0.7.5",
+  "version": "0.7.6",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [