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

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));
@@ -1172,7 +1185,9 @@ var UserManager = class {
   usersCache = null;
   pendingVideoCache = null;
   activeTasks = /* @__PURE__ */ new Map();
-  // userId -> requestId
+  // userId -> requestId (图像任务锁)
+  activeVideoTasks = /* @__PURE__ */ new Map();
+  // userId -> requestId (视频任务锁，独立于图像任务)
   rateLimitMap = /* @__PURE__ */ new Map();
   // userId -> timestamps
   securityBlockMap = /* @__PURE__ */ new Map();
@@ -1191,6 +1206,7 @@ var UserManager = class {
     }
   }
   // --- 任务管理 ---
+  // 图像任务锁（原有逻辑保持不变）
   startTask(userId) {
     if (this.activeTasks.has(userId)) return false;
     this.activeTasks.set(userId, "processing");
@@ -1202,6 +1218,18 @@ var UserManager = class {
   isTaskActive(userId) {
     return this.activeTasks.has(userId);
   }
+  // 视频任务锁（独立于图像任务，不影响图像生成）
+  startVideoTask(userId) {
+    if (this.activeVideoTasks.has(userId)) return false;
+    this.activeVideoTasks.set(userId, "processing");
+    return true;
+  }
+  endVideoTask(userId) {
+    this.activeVideoTasks.delete(userId);
+  }
+  isVideoTaskActive(userId) {
+    return this.activeVideoTasks.has(userId);
+  }
   // --- 权限管理 ---
   isAdmin(userId, config) {
     return config.adminUsers && config.adminUsers.includes(userId);
@@ -1324,6 +1352,61 @@ var UserManager = class {
       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 countPendingVideoTasksForUser(userId) {
+    const data = await this.loadPendingVideoTasks();
+    return Object.values(data.tasks).filter((t) => t.userId === userId && !t.charged).length;
+  }
+  /**
+   * 列出某个用户所有未扣费的待结算视频任务
+   */
+  async listPendingVideoTasksForUser(userId) {
+    const data = await this.loadPendingVideoTasks();
+    return 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;
+    });
+  }
+  /**
+   * 添加待结算视频任务，并检查上限（默认max=1）
+   * @returns {Promise<{success: boolean, message?: string}>} 成功返回 {success: true}，失败返回 {success: false, message: '错误信息'}
+   */
+  async addPendingVideoTaskWithLimit(task, max = 1) {
+    await this.loadPendingVideoTasks();
+    return await this.pendingLock.acquire(async () => {
+      if (!this.pendingVideoCache) {
+        this.pendingVideoCache = { version: "1.0.0", lastUpdate: (/* @__PURE__ */ new Date()).toISOString(), tasks: {} };
+      }
+      const currentCount = Object.values(this.pendingVideoCache.tasks).filter((t) => t.userId === task.userId && !t.charged).length;
+      if (currentCount >= max) {
+        return {
+          success: false,
+          message: `您当前已有 ${currentCount} 个视频正在生成中（最多允许 ${max} 个），请先使用"查询视频"查看进度或等待完成`
+        };
+      }
+      if (this.pendingVideoCache.tasks[task.taskId]) {
+        return { success: true };
+      }
+      this.pendingVideoCache.tasks[task.taskId] = task;
+      await this.savePendingVideoTasksInternal();
+      return { success: true };
+    });
+  }
   // 获取特定用户数据
   async getUserData(userId, userName) {
     await this.loadUsersData();
@@ -2314,8 +2397,8 @@ ${infoParts.join("\n")}`;
       if (!limitCheck.allowed) {
         return limitCheck.message;
       }
-      if (!userManager.startTask(userId)) {
-        return "您有一个任务正在进行中，请等待完成";
+      if (!userManager.startVideoTask(userId)) {
+        return "您有一个视频任务正在进行中，请等待完成";
       }
       let createdTaskId = null;
       try {
@@ -2350,15 +2433,6 @@ ${infoParts.join("\n")}`;
         if (!validRatios.includes(ratio)) {
           return `宽高比必须是以下之一: ${validRatios.join(", ")}`;
         }
-        await session.send(
-          `🎬 开始生成视频...
-📝 描述：${prompt}
-⏱️ 时长：${duration}秒
-📐 宽高比：${ratio}
-⚠️ 预计需要 1-3 分钟，请耐心等待
-💡 提示：生成过程中可继续使用其他功能`
-        );
-        const startTime = Date.now();
         const taskId = await videoProvider.createVideoTask(
           prompt,
           imageUrls[0],
@@ -2368,7 +2442,7 @@ ${infoParts.join("\n")}`;
           }
         );
         createdTaskId = taskId;
-        await userManager.addPendingVideoTask({
+        const addResult = await userManager.addPendingVideoTaskWithLimit({
           taskId,
           userId,
           userName,
@@ -2376,64 +2450,119 @@ ${infoParts.join("\n")}`;
           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;
+        }, 1);
+        if (!addResult.success) {
+          try {
+            await userManager.deletePendingVideoTask(taskId);
+          } catch {
+          }
+          return addResult.message || "队列已满，请先查询已有任务";
         }
-        try {
-          if (createdTaskId) await userManager.deletePendingVideoTask(createdTaskId);
-        } catch {
+        await session.send("开始生成视频...");
+      } catch (error) {
+        logger.error("视频生成任务提交失败", { userId, error: sanitizeError(error) });
+        if (createdTaskId) {
+          try {
+            await userManager.deletePendingVideoTask(createdTaskId);
+          } catch {
+          }
         }
-        return `视频生成失败：${sanitizeString(errorMsg)}`;
+        const errorMsg = error.message || "";
+        return `视频生成任务提交失败：${sanitizeString(errorMsg)}`;
       } finally {
-        userManager.endTask(userId);
+        userManager.endVideoTask(userId);
       }
     });
   }
   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>";
-      }
-      try {
-        await session.send("🔍 正在查询视频生成状态...");
-        const status = await videoProvider.queryTaskStatus(taskId.trim());
-        if (status.status === "completed" && status.videoUrl) {
-          const trimmedTaskId = taskId.trim();
+      const trimmedTaskId = (taskId || "").trim();
+      if (trimmedTaskId) {
+        try {
+          await session.send("正在查询视频生成状态...");
+          const status = await videoProvider.queryTaskStatus(trimmedTaskId);
           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);
+          if (status.status === "completed" && status.videoUrl) {
+            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}%）` : "";
+            return `视频正在生成中${progressText}，请稍后再次查询`;
+          } else if (status.status === "failed") {
+            if (pending && !pending.charged) {
+              await userManager.deletePendingVideoTask(trimmedTaskId);
+            }
+            return `视频生成失败：${status.error || "未知错误"}`;
+          } else {
+            return `❓ 未知状态：${status.status}`;
+          }
+        } catch (error) {
+          logger.error("查询视频任务失败", { taskId: trimmedTaskId, error: sanitizeError(error) });
+          return `查询失败：${sanitizeString(error.message)}`;
+        }
+      }
+      try {
+        const pendingTasks = await userManager.listPendingVideoTasksForUser(session.userId);
+        if (pendingTasks.length === 0) {
+          return "你当前没有可查询的待生成视频任务";
+        }
+        await session.send(`正在查询 ${pendingTasks.length} 个视频任务状态...`);
+        let completedCount = 0;
+        let processingCount = 0;
+        let failedCount = 0;
+        const messages = [];
+        for (const task of pendingTasks) {
+          try {
+            const status = await videoProvider.queryTaskStatus(task.taskId);
+            if (status.status === "completed" && status.videoUrl) {
+              await session.send(import_koishi2.h.video(status.videoUrl));
+              if (!task.charged) {
+                await recordUserUsage(session, task.commandName, task.credits, false);
+                await userManager.markPendingVideoTaskCharged(task.taskId);
+                await userManager.deletePendingVideoTask(task.taskId);
+              }
+              completedCount++;
+              messages.push(`任务 ${task.taskId.substring(0, 20)}... 已完成`);
+            } else if (status.status === "processing" || status.status === "pending") {
+              processingCount++;
+              const progressText = status.progress ? `（进度：${status.progress}%）` : "";
+              messages.push(`任务 ${task.taskId.substring(0, 20)}... 生成中${progressText}`);
+            } else if (status.status === "failed") {
+              if (!task.charged) {
+                await userManager.deletePendingVideoTask(task.taskId);
+              }
+              failedCount++;
+              messages.push(`任务 ${task.taskId.substring(0, 20)}... 失败：${status.error || "未知错误"}`);
+            } else {
+              messages.push(`❓ 任务 ${task.taskId.substring(0, 20)}... 状态：${status.status}`);
+            }
+          } catch (error) {
+            logger.error("查询单个视频任务失败", { taskId: task.taskId, error: sanitizeError(error) });
+            messages.push(`⚠️ 任务 ${task.taskId.substring(0, 20)}... 查询失败：${sanitizeString(error.message)}`);
           }
-          return "✅ 视频已生成完成！";
-        } else if (status.status === "processing" || status.status === "pending") {
-          const progressText = status.progress ? `（进度：${status.progress}%）` : "";
-          return `⏳ 视频正在生成中${progressText}，请稍后再次查询
-任务ID：${taskId}`;
-        } else if (status.status === "failed") {
-          return `❌ 视频生成失败：${status.error || "未知错误"}`;
-        } else {
-          return `❓ 未知状态：${status.status}`;
         }
+        let summary = `查询结果汇总：
+`;
+        if (completedCount > 0) summary += `已完成：${completedCount} 个
+`;
+        if (processingCount > 0) summary += `生成中：${processingCount} 个
+`;
+        if (failedCount > 0) summary += `失败：${failedCount} 个
+`;
+        summary += `
+${messages.join("\n")}`;
+        return summary;
       } catch (error) {
-        logger.error("查询视频任务失败", { taskId, error: sanitizeError(error) });
+        logger.error("查询视频任务列表失败", { userId: session.userId, error: sanitizeError(error) });
         return `查询失败：${sanitizeString(error.message)}`;
       }
     });
@@ -2455,8 +2584,8 @@ ${infoParts.join("\n")}`;
         if (!limitCheck.allowed) {
           return limitCheck.message;
         }
-        if (!userManager.startTask(userId)) {
-          return "您有一个任务正在进行中，请等待完成";
+        if (!userManager.startVideoTask(userId)) {
+          return "您有一个视频任务正在进行中，请等待完成";
         }
         let createdTaskId = null;
         try {
@@ -2472,11 +2601,6 @@ ${infoParts.join("\n")}`;
           if (extraText) {
             finalPrompt += " - " + extraText;
           }
-          await session.send(
-            `🎬 开始生成视频（${style.commandName}）...
-📝 描述：${finalPrompt}
-⏱️ 预计需要 1-3 分钟`
-          );
           const taskId = await videoProvider.createVideoTask(
             finalPrompt,
             imageUrls[0],
@@ -2486,7 +2610,7 @@ ${infoParts.join("\n")}`;
             }
           );
           createdTaskId = taskId;
-          await userManager.addPendingVideoTask({
+          const addResult = await userManager.addPendingVideoTaskWithLimit({
             taskId,
             userId,
             userName,
@@ -2494,27 +2618,27 @@ ${infoParts.join("\n")}`;
             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;
+          }, 1);
+          if (!addResult.success) {
+            try {
+              await userManager.deletePendingVideoTask(taskId);
+            } catch {
+            }
+            return addResult.message || "队列已满，请先查询已有任务";
           }
-          try {
-            if (createdTaskId) await userManager.deletePendingVideoTask(createdTaskId);
-          } catch {
+          await session.send(`开始生成视频（${style.commandName}）...`);
+        } catch (error) {
+          logger.error("视频风格转换任务提交失败", { userId, style: style.commandName, error: sanitizeError(error) });
+          if (createdTaskId) {
+            try {
+              await userManager.deletePendingVideoTask(createdTaskId);
+            } catch {
+            }
           }
-          return `视频生成失败：${sanitizeString(errorMsg)}`;
+          const errorMsg = error.message || "";
+          return `视频生成任务提交失败：${sanitizeString(errorMsg)}`;
         } finally {
-          userManager.endTask(userId);
+          userManager.endVideoTask(userId);
         }
       });
       logger.info(`已注册视频风格命令: ${style.commandName}`);

package/lib/services/UserManager.d.ts

@@ -67,6 +67,7 @@ export declare class UserManager {
     private usersCache;
     private pendingVideoCache;
     private activeTasks;
+    private activeVideoTasks;
     private rateLimitMap;
     private securityBlockMap;
     private securityWarningMap;
@@ -74,6 +75,9 @@ export declare class UserManager {
     startTask(userId: string): boolean;
     endTask(userId: string): void;
     isTaskActive(userId: string): boolean;
+    startVideoTask(userId: string): boolean;
+    endVideoTask(userId: string): void;
+    isVideoTaskActive(userId: string): boolean;
     isAdmin(userId: string, config: Config): boolean;
     private loadUsersData;
     private saveUsersDataInternal;
@@ -86,6 +90,26 @@ export declare class UserManager {
     getPendingVideoTask(taskId: string): Promise<PendingVideoTask | null>;
     markPendingVideoTaskCharged(taskId: string): Promise<PendingVideoTask | null>;
     deletePendingVideoTask(taskId: string): Promise<void>;
+    /**
+     * 获取某个用户最近一次未扣费的待结算视频任务
+     */
+    getLatestPendingVideoTaskForUser(userId: string): Promise<PendingVideoTask | null>;
+    /**
+     * 统计某个用户未扣费的待结算视频任务数量
+     */
+    countPendingVideoTasksForUser(userId: string): Promise<number>;
+    /**
+     * 列出某个用户所有未扣费的待结算视频任务
+     */
+    listPendingVideoTasksForUser(userId: string): Promise<PendingVideoTask[]>;
+    /**
+     * 添加待结算视频任务，并检查上限（默认max=1）
+     * @returns {Promise<{success: boolean, message?: string}>} 成功返回 {success: true}，失败返回 {success: false, message: '错误信息'}
+     */
+    addPendingVideoTaskWithLimit(task: PendingVideoTask, max?: number): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
     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.6",
+  "version": "0.7.8",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [