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

package/lib/index.js

@@ -914,7 +914,7 @@ var YunwuVideoProvider = class {
       } else {
         duration = 25;
       }
-      const requestBody = {
+      const buildRequestBody = /* @__PURE__ */ __name((watermark) => ({
         images: [`data:${mimeType};base64,${imageBase64}`],
         model: this.config.modelId,
         orientation,
@@ -922,29 +922,42 @@ var YunwuVideoProvider = class {
         size: "large",
         // 高清1080p
         duration,
-        watermark: true,
-        // 默认优先无水印，出错会兜底到有水印
+        watermark,
+        // 优先无水印；若接口不允许则降级有水印
         private: false
         // 默认视频会发布
-      };
+      }), "buildRequestBody");
       logger?.info("提交视频生成任务", {
         model: this.config.modelId,
         promptLength: prompt.length,
-        duration: requestBody.duration,
-        orientation: requestBody.orientation
+        duration,
+        orientation
       });
-      const response = await ctx.http.post(
-        `${this.config.apiBase}/v1/video/create`,
-        requestBody,
-        {
-          headers: {
-            "Authorization": `Bearer ${this.config.apiKey}`,
-            "Content-Type": "application/json",
-            "Accept": "application/json"
-          },
-          timeout: this.config.apiTimeout * 1e3
-        }
-      );
+      const doCreate = /* @__PURE__ */ __name(async (watermark) => {
+        return await ctx.http.post(
+          `${this.config.apiBase}/v1/video/create`,
+          buildRequestBody(watermark),
+          {
+            headers: {
+              "Authorization": `Bearer ${this.config.apiKey}`,
+              "Content-Type": "application/json",
+              "Accept": "application/json"
+            },
+            timeout: this.config.apiTimeout * 1e3
+          }
+        );
+      }, "doCreate");
+      let response;
+      try {
+        response = await doCreate(false);
+      } catch (e) {
+        logger?.warn("无水印创建任务失败，尝试有水印", { error: sanitizeError(e) });
+        response = await doCreate(true);
+      }
+      if (response?.error || response?.status && response.status >= 400) {
+        logger?.warn("无水印创建任务返回错误，尝试有水印", { status: response?.status, error: response?.error, response: response?.data });
+        response = await doCreate(true);
+      }
       if (response.error) {
         const errorMsg = response.error.message || response.error.type || "创建任务失败";
         throw new Error(sanitizeString(errorMsg));
@@ -1067,6 +1080,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 +1096,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 +1176,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 +1198,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 +1260,95 @@ 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 getLatestPendingVideoTaskForUser(userId) {
+    const data = await this.loadPendingVideoTasks();
+    const tasks = Object.values(data.tasks).filter((t) => t.userId === userId && !t.charged).sort((a, b) => {
+      const ta = Date.parse(a.createdAt || "") || 0;
+      const tb = Date.parse(b.createdAt || "") || 0;
+      return tb - ta;
+    });
+    return tasks[0] || null;
+  }
   // 获取特定用户数据
   async getUserData(userId, userName) {
     await this.loadUsersData();
@@ -2230,6 +2342,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,24 +2384,41 @@ ${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) {
         logger.error("视频生成失败", { userId, error: sanitizeError(error) });
         const errorMsg = error.message || "";
         if (errorMsg.includes("任务ID:")) {
-          return errorMsg;
+          return "⏳ 视频生成超时（任务仍在后台继续生成），请稍后发送“查询视频”获取结果";
+        }
+        try {
+          if (createdTaskId) await userManager.deletePendingVideoTask(createdTaskId);
+        } catch {
         }
         return `视频生成失败：${sanitizeString(errorMsg)}`;
       } finally {
@@ -2297,28 +2427,38 @@ ${infoParts.join("\n")}`;
     });
   }
   if (config.enableVideoGeneration && videoProvider) {
-    ctx.command("查询视频 <taskId:string>", "根据任务ID查询视频生成状态").action(async ({ session }, taskId) => {
+    ctx.command("查询视频 [taskId:string]", "查询视频生成状态（不传任务ID则查询自己最近一次任务）").action(async ({ session }, taskId) => {
       if (!session?.userId) return "会话无效";
-      if (!taskId || !taskId.trim()) {
-        return "请提供任务ID，格式：查询视频 <任务ID>";
+      const trimmedTaskId = (taskId || "").trim();
+      const resolvedTaskId = trimmedTaskId ? trimmedTaskId : (await userManager.getLatestPendingVideoTaskForUser(session.userId))?.taskId;
+      if (!resolvedTaskId) {
+        return "你当前没有可查询的待生成视频任务";
       }
       try {
         await session.send("🔍 正在查询视频生成状态...");
-        const status = await videoProvider.queryTaskStatus(taskId.trim());
+        const status = await videoProvider.queryTaskStatus(resolvedTaskId);
         if (status.status === "completed" && status.videoUrl) {
+          const pending = await userManager.getPendingVideoTask(resolvedTaskId);
+          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(resolvedTaskId);
+            await userManager.deletePendingVideoTask(resolvedTaskId);
+          }
           return "✅ 视频已生成完成！";
         } else if (status.status === "processing" || status.status === "pending") {
           const progressText = status.progress ? `（进度：${status.progress}%）` : "";
-          return `⏳ 视频正在生成中${progressText}，请稍后再次查询
-任务ID：${taskId}`;
+          return `⏳ 视频正在生成中${progressText}，请稍后再次查询`;
         } else if (status.status === "failed") {
           return `❌ 视频生成失败：${status.error || "未知错误"}`;
         } else {
           return `❓ 未知状态：${status.status}`;
         }
       } catch (error) {
-        logger.error("查询视频任务失败", { taskId, error: sanitizeError(error) });
+        logger.error("查询视频任务失败", { taskId: resolvedTaskId, error: sanitizeError(error) });
         return `查询失败：${sanitizeString(error.message)}`;
       }
     });
@@ -2343,6 +2483,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,23 +2502,40 @@ ${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) });
           const errorMsg = error.message || "";
           if (errorMsg.includes("任务ID:")) {
-            return errorMsg;
+            return "⏳ 视频生成超时（任务仍在后台继续生成），请稍后发送“查询视频”获取结果";
+          }
+          try {
+            if (createdTaskId) await userManager.deletePendingVideoTask(createdTaskId);
+          } catch {
           }
           return `视频生成失败：${sanitizeString(errorMsg)}`;
         } finally {

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,19 @@ 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>;
+    /**
+     * 获取某个用户最近一次未扣费的待结算视频任务
+     */
+    getLatestPendingVideoTaskForUser(userId: string): Promise<PendingVideoTask | null>;
     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.7",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [