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

package/lib/index.js

@@ -954,12 +954,12 @@ var YunwuVideoProvider = class {
         logger?.error("API 返回错误状态", { status: response.status, error: errorMsg, response: response.data });
         throw new Error(sanitizeString(errorMsg));
       }
-      const taskId = response.id || response.data?.id;
+      const taskId = response.id;
       if (!taskId) {
         logger?.error("未能获取任务ID", { response });
         throw new Error("未能获取任务ID，请检查 API 响应格式");
       }
-      logger?.info("视频任务已创建", { taskId });
+      logger?.info("视频任务已创建", { taskId, status: response.status });
       return taskId;
     } catch (error) {
       logger?.error("创建视频任务失败", { error: sanitizeError(error) });
@@ -979,12 +979,12 @@ var YunwuVideoProvider = class {
   }
   /**
    * 查询任务状态
-   * API: GET /v1/video/{taskId} (根据创建端点的模式推断)
+   * API: GET /v1/video/query?id={taskId}
    */
   async queryTaskStatus(taskId) {
     const { logger, ctx } = this.config;
     try {
-      const endpoint = `/v1/video/${taskId}`;
+      const endpoint = `/v1/video/query?id=${encodeURIComponent(taskId)}`;
       logger?.debug("查询任务状态", { taskId, endpoint });
       const response = await ctx.http.get(
         `${this.config.apiBase}${endpoint}`,
@@ -996,14 +996,14 @@ var YunwuVideoProvider = class {
           timeout: this.config.apiTimeout * 1e3
         }
       );
-      const status = response.status || response.data?.status || "pending";
-      const videoUrl = response.video_url || response.url || response.data?.video_url || response.data?.url;
+      const status = response.status || "pending";
+      const videoUrl = response.video_url || null;
       return {
         status,
-        taskId,
-        videoUrl,
-        error: response.error || response.data?.error,
-        progress: response.progress || response.data?.progress
+        taskId: response.id || taskId,
+        videoUrl: videoUrl || void 0,
+        error: response.error,
+        progress: response.progress
       };
     } catch (error) {
       logger?.error("查询任务状态失败", { taskId, error: sanitizeError(error) });
@@ -1020,6 +1020,8 @@ var YunwuVideoProvider = class {
   async pollTaskCompletion(taskId, maxWaitTime = 300, pollInterval = 3, onProgress) {
     const { logger } = this.config;
     const startTime = Date.now();
+    let consecutiveFailures = 0;
+    const maxConsecutiveFailures = 5;
     while (true) {
       const elapsed = (Date.now() - startTime) / 1e3;
       if (elapsed > maxWaitTime) {
@@ -1027,21 +1029,50 @@ var YunwuVideoProvider = class {
         throw new Error(`视频生成超时（已等待${Math.floor(elapsed)}秒），任务ID: ${taskId}
 请使用"查询视频 ${taskId}"命令稍后查询结果`);
       }
-      const status = await this.queryTaskStatus(taskId);
-      logger?.debug("任务状态", { taskId, status: status.status, elapsed: Math.floor(elapsed) });
-      if (onProgress) {
-        await onProgress(status);
-      }
-      if (status.status === "completed" && status.videoUrl) {
-        logger?.info("视频生成完成", { taskId, elapsed: Math.floor(elapsed) });
-        return status.videoUrl;
-      }
-      if (status.status === "failed") {
-        throw new Error(status.error || "视频生成失败");
+      try {
+        const status = await this.queryTaskStatus(taskId);
+        consecutiveFailures = 0;
+        logger?.debug("任务状态", { taskId, status: status.status, elapsed: Math.floor(elapsed) });
+        if (onProgress) {
+          await onProgress(status);
+        }
+        if (status.status === "completed" && status.videoUrl) {
+          logger?.info("视频生成完成", { taskId, elapsed: Math.floor(elapsed) });
+          return status.videoUrl;
+        }
+        if (status.status === "failed") {
+          throw new Error(status.error || "视频生成失败");
+        }
+      } catch (error) {
+        consecutiveFailures++;
+        logger?.warn("查询任务状态失败，继续重试", {
+          taskId,
+          consecutiveFailures,
+          maxConsecutiveFailures,
+          error: sanitizeError(error),
+          elapsed: Math.floor(elapsed)
+        });
+        if (consecutiveFailures >= maxConsecutiveFailures) {
+          logger?.error("连续查询失败次数过多，终止轮询", {
+            taskId,
+            consecutiveFailures,
+            elapsed: Math.floor(elapsed)
+          });
+          throw new Error(`查询任务状态连续失败 ${consecutiveFailures} 次，任务ID: ${taskId}
+请稍后使用"查询视频 ${taskId}"命令手动查询结果`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollInterval * 1e3 * 2));
+        continue;
       }
       await new Promise((resolve) => setTimeout(resolve, pollInterval * 1e3));
     }
   }
+  /**
+   * 等待指定任务完成并返回视频 URL（供外部在拿到 taskId 后自行控制扣费/提示）
+   */
+  async waitForVideo(taskId, maxWaitTime = 300) {
+    return await this.pollTaskCompletion(taskId, maxWaitTime);
+  }
   /**
    * 生成视频（主入口）
    */
@@ -1052,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) {
@@ -1132,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();
@@ -1151,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 });
     }
@@ -1212,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();
@@ -2205,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) {
@@ -2246,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) {
@@ -2265,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);
@@ -2281,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}%）` : "";
@@ -2318,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) {
@@ -2336,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) });
@@ -2354,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

@@ -14,13 +14,17 @@ export declare class YunwuVideoProvider implements VideoProvider {
     createVideoTask(prompt: string, imageUrl: string, options?: VideoGenerationOptions): Promise<string>;
     /**
      * 查询任务状态
-     * API: GET /v1/video/{taskId} (根据创建端点的模式推断)
+     * API: GET /v1/video/query?id={taskId}
      */
     queryTaskStatus(taskId: string): Promise<VideoTaskStatus>;
     /**
      * 轮询等待任务完成
      */
     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.4",
+  "version": "0.7.6",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [