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

package/lib/index.js

@@ -1185,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();
@@ -1204,6 +1206,7 @@ var UserManager = class {
     }
   }
   // --- 任务管理 ---
+  // 图像任务锁（原有逻辑保持不变）
   startTask(userId) {
     if (this.activeTasks.has(userId)) return false;
     this.activeTasks.set(userId, "processing");
@@ -1215,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);
@@ -1349,6 +1364,49 @@ var UserManager = class {
     });
     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();
@@ -2339,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 {
@@ -2375,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],
@@ -2393,7 +2442,7 @@ ${infoParts.join("\n")}`;
           }
         );
         createdTaskId = taskId;
-        await userManager.addPendingVideoTask({
+        const addResult = await userManager.addPendingVideoTaskWithLimit({
           taskId,
           userId,
           userName,
@@ -2401,64 +2450,158 @@ ${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 "⏳ 视频生成超时（任务仍在后台继续生成），请稍后发送“查询视频”获取结果";
+        }, 1);
+        if (!addResult.success) {
+          try {
+            await userManager.deletePendingVideoTask(taskId);
+          } catch {
+          }
+          return addResult.message || "队列已满，请先查询已有任务";
+        }
+        await session.send("开始生成视频...");
+        await new Promise((resolve) => setTimeout(resolve, 1e4));
+        try {
+          const firstStatus = await videoProvider.queryTaskStatus(taskId);
+          if (firstStatus.status === "failed") {
+            const errorMsg = firstStatus.error || "视频生成失败";
+            await userManager.deletePendingVideoTask(taskId);
+            return `视频生成失败：${sanitizeString(errorMsg)}`;
+          }
+          if (firstStatus.status === "completed" && firstStatus.videoUrl) {
+            await session.send(import_koishi2.h.video(firstStatus.videoUrl));
+            await recordUserUsage(session, "图生视频", videoCredits, false);
+            await userManager.markPendingVideoTaskCharged(taskId);
+            await userManager.deletePendingVideoTask(taskId);
+            return "视频生成完成！";
+          }
+          await session.send("视频正在生成中，请稍候...");
+        } catch (error) {
+          logger.error("第一次查询视频状态失败", { taskId, error: sanitizeError(error) });
         }
+        await new Promise((resolve) => setTimeout(resolve, config.videoMaxWaitTime * 1e3));
         try {
-          if (createdTaskId) await userManager.deletePendingVideoTask(createdTaskId);
-        } catch {
+          const secondStatus = await videoProvider.queryTaskStatus(taskId);
+          if (secondStatus.status === "completed" && secondStatus.videoUrl) {
+            await session.send(import_koishi2.h.video(secondStatus.videoUrl));
+            await recordUserUsage(session, "图生视频", videoCredits, false);
+            await userManager.markPendingVideoTaskCharged(taskId);
+            await userManager.deletePendingVideoTask(taskId);
+            return "视频生成完成！";
+          } else if (secondStatus.status === "failed") {
+            const errorMsg = secondStatus.error || "视频生成失败";
+            await userManager.deletePendingVideoTask(taskId);
+            return `视频生成失败：${sanitizeString(errorMsg)}`;
+          } else {
+            return '视频仍在生成中，请稍后使用"查询视频"指令获取结果';
+          }
+        } catch (error) {
+          logger.error("第二次查询视频状态失败", { taskId, error: sanitizeError(error) });
+          return '视频生成中，请稍后使用"查询视频"指令获取结果';
         }
-        return `视频生成失败：${sanitizeString(errorMsg)}`;
+      } catch (error) {
+        logger.error("视频生成任务提交失败", { userId, error: sanitizeError(error) });
+        if (createdTaskId) {
+          try {
+            await userManager.deletePendingVideoTask(createdTaskId);
+          } catch {
+          }
+        }
+        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 "会话无效";
       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(resolvedTaskId);
-        if (status.status === "completed" && status.videoUrl) {
-          const pending = await userManager.getPendingVideoTask(resolvedTaskId);
+      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(resolvedTaskId);
-            await userManager.deletePendingVideoTask(resolvedTaskId);
-          }
-          return "✅ 视频已生成完成！";
-        } else if (status.status === "processing" || status.status === "pending") {
-          const progressText = status.progress ? `（进度：${status.progress}%）` : "";
-          return `⏳ 视频正在生成中${progressText}，请稍后再次查询`;
-        } else if (status.status === "failed") {
-          return `❌ 视频生成失败：${status.error || "未知错误"}`;
-        } else {
-          return `❓ 未知状态：${status.status}`;
+          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)}`);
+          }
         }
+        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: resolvedTaskId, error: sanitizeError(error) });
+        logger.error("查询视频任务列表失败", { userId: session.userId, error: sanitizeError(error) });
         return `查询失败：${sanitizeString(error.message)}`;
       }
     });
@@ -2480,8 +2623,8 @@ ${infoParts.join("\n")}`;
         if (!limitCheck.allowed) {
           return limitCheck.message;
         }
-        if (!userManager.startTask(userId)) {
-          return "您有一个任务正在进行中，请等待完成";
+        if (!userManager.startVideoTask(userId)) {
+          return "您有一个视频任务正在进行中，请等待完成";
         }
         let createdTaskId = null;
         try {
@@ -2497,11 +2640,6 @@ ${infoParts.join("\n")}`;
           if (extraText) {
             finalPrompt += " - " + extraText;
           }
-          await session.send(
-            `🎬 开始生成视频（${style.commandName}）...
-📝 描述：${finalPrompt}
-⏱️ 预计需要 1-3 分钟`
-          );
           const taskId = await videoProvider.createVideoTask(
             finalPrompt,
             imageUrls[0],
@@ -2511,7 +2649,7 @@ ${infoParts.join("\n")}`;
             }
           );
           createdTaskId = taskId;
-          await userManager.addPendingVideoTask({
+          const addResult = await userManager.addPendingVideoTaskWithLimit({
             taskId,
             userId,
             userName,
@@ -2519,27 +2657,66 @@ ${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 "⏳ 视频生成超时（任务仍在后台继续生成），请稍后发送“查询视频”获取结果";
+          }, 1);
+          if (!addResult.success) {
+            try {
+              await userManager.deletePendingVideoTask(taskId);
+            } catch {
+            }
+            return addResult.message || "队列已满，请先查询已有任务";
           }
+          await session.send(`开始生成视频（${style.commandName}）...`);
+          await new Promise((resolve) => setTimeout(resolve, 1e4));
           try {
-            if (createdTaskId) await userManager.deletePendingVideoTask(createdTaskId);
-          } catch {
+            const firstStatus = await videoProvider.queryTaskStatus(taskId);
+            if (firstStatus.status === "failed") {
+              const errorMsg = firstStatus.error || "视频生成失败";
+              await userManager.deletePendingVideoTask(taskId);
+              return `视频生成失败：${sanitizeString(errorMsg)}`;
+            }
+            if (firstStatus.status === "completed" && firstStatus.videoUrl) {
+              await session.send(import_koishi2.h.video(firstStatus.videoUrl));
+              await recordUserUsage(session, style.commandName, videoCredits, false);
+              await userManager.markPendingVideoTaskCharged(taskId);
+              await userManager.deletePendingVideoTask(taskId);
+              return "视频生成完成！";
+            }
+            await session.send("视频正在生成中，请稍候...");
+          } catch (error) {
+            logger.error("第一次查询视频状态失败", { taskId, error: sanitizeError(error) });
+          }
+          await new Promise((resolve) => setTimeout(resolve, config.videoMaxWaitTime * 1e3));
+          try {
+            const secondStatus = await videoProvider.queryTaskStatus(taskId);
+            if (secondStatus.status === "completed" && secondStatus.videoUrl) {
+              await session.send(import_koishi2.h.video(secondStatus.videoUrl));
+              await recordUserUsage(session, style.commandName, videoCredits, false);
+              await userManager.markPendingVideoTaskCharged(taskId);
+              await userManager.deletePendingVideoTask(taskId);
+              return "视频生成完成！";
+            } else if (secondStatus.status === "failed") {
+              const errorMsg = secondStatus.error || "视频生成失败";
+              await userManager.deletePendingVideoTask(taskId);
+              return `视频生成失败：${sanitizeString(errorMsg)}`;
+            } else {
+              return '视频仍在生成中，请稍后使用"查询视频"指令获取结果';
+            }
+          } catch (error) {
+            logger.error("第二次查询视频状态失败", { taskId, error: sanitizeError(error) });
+            return '视频生成中，请稍后使用"查询视频"指令获取结果';
           }
-          return `视频生成失败：${sanitizeString(errorMsg)}`;
+        } catch (error) {
+          logger.error("视频风格转换任务提交失败", { userId, style: style.commandName, error: sanitizeError(error) });
+          if (createdTaskId) {
+            try {
+              await userManager.deletePendingVideoTask(createdTaskId);
+            } catch {
+            }
+          }
+          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;
@@ -90,6 +94,22 @@ export declare class UserManager {
      * 获取某个用户最近一次未扣费的待结算视频任务
      */
     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.7",
+  "version": "0.7.10",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [