koishi-plugin-cocoyyy-console 1.2.0-alpha.1 → 1.2.0

package/lib/config/config.d.ts

@@ -6,3 +6,4 @@ export * from './configs/redis_config';
 export * from './configs/ai_config';
 export * from './configs/wish_config';
 export * from './configs/sum_config';
+export * from './configs/jm_config';

package/lib/config/configs/function_config.d.ts

@@ -11,6 +11,7 @@ interface FunctionConfig {
     game_flag: boolean;
     kuro_flag: boolean;
     sum_flag: boolean;
+    jm_flag: boolean;
 }
 interface GroupFunctionLimitConfig {
     cofig_enable_flag: boolean;

package/lib/config/configs/jm_config.d.ts

@@ -0,0 +1,10 @@
+import { Schema } from 'koishi';
+interface JmConfig {
+    api_url?: string;
+    api_key?: string;
+    poll_interval_ms?: number;
+    poll_timeout_ms?: number;
+    max_concurrent_per_guild?: number;
+}
+declare const JmConfigSchema: Schema<JmConfig>;
+export { JmConfig, JmConfigSchema, };

package/lib/index.d.ts

@@ -16,6 +16,7 @@ export interface Config {
     repeat_config?: my_config.RepeatConfig;
     wish_config?: my_config.WishConfig;
     sum_config?: my_config.SumConfig;
+    jm_config?: my_config.JmConfig;
     test?: string;
 }
 export declare const Config: Schema<Config>;

package/lib/index.js

@@ -39,7 +39,7 @@ __export(src_exports, {
   savePath: () => savePath
 });
 module.exports = __toCommonJS(src_exports);
-var import_koishi16 = require("koishi");
+var import_koishi18 = require("koishi");
 
 // src/config/configs/function_config.ts
 var import_koishi = require("koishi");
@@ -54,7 +54,8 @@ var FunctionConfigSchema = import_koishi.Schema.object({
   wish_flag: import_koishi.Schema.boolean().default(true).description("许愿功能是否启用"),
   game_flag: import_koishi.Schema.boolean().default(true).description("游戏功能是否启用"),
   kuro_flag: import_koishi.Schema.boolean().default(true).description("鸣潮功能是否启用"),
-  sum_flag: import_koishi.Schema.boolean().default(true).description("总结功能是否启用")
+  sum_flag: import_koishi.Schema.boolean().default(true).description("总结功能是否启用"),
+  jm_flag: import_koishi.Schema.boolean().default(false).description("禁漫下载功能是否启用")
 });
 var GroupFunctionLimitConfigSchema = import_koishi.Schema.object({
   cofig_enable_flag: import_koishi.Schema.boolean().default(true).description("功能限制是否启用"),
@@ -117,6 +118,16 @@ var SumConfigSchema = import_koishi8.Schema.object({
   api_model: import_koishi8.Schema.string().default("").description("AI模型")
 });
 
+// src/config/configs/jm_config.ts
+var import_koishi9 = require("koishi");
+var JmConfigSchema = import_koishi9.Schema.object({
+  api_url: import_koishi9.Schema.string().default("http://127.0.0.1:6789").description("JM 下载服务地址"),
+  api_key: import_koishi9.Schema.string().default("").description("JM 下载服务 API Key（X-API-Key）"),
+  poll_interval_ms: import_koishi9.Schema.number().default(5e3).description("任务状态轮询间隔（毫秒）"),
+  poll_timeout_ms: import_koishi9.Schema.number().default(18e5).description("任务轮询超时（毫秒，默认 30 分钟）"),
+  max_concurrent_per_guild: import_koishi9.Schema.number().default(5).description("每个群聊同时进行的最大下载任务数")
+});
+
 // src/infra/mysql_init.ts
 var import_sequelize = require("sequelize");
 var sequelize = null;
@@ -370,6 +381,27 @@ function loadGroupFunctionLimitConfig(config) {
   }
 }
 __name(loadGroupFunctionLimitConfig, "loadGroupFunctionLimitConfig");
+function getCtxForFunction(ctx, menuNumber) {
+  if (!groupFunctionLimitConfig || groupFunctionLimitConfig.length === 0) {
+    return ctx;
+  }
+  const defaultEntry = groupFunctionLimitConfig.find((item) => String(item.group_id) === "#");
+  const defaultAllowed = defaultEntry ? defaultEntry.menu_list.includes(menuNumber) : false;
+  const explicitGroups = groupFunctionLimitConfig.filter((item) => String(item.group_id) !== "#");
+  if (defaultAllowed) {
+    const excludedIds = explicitGroups.filter((item) => !item.menu_list.includes(menuNumber)).map((item) => String(item.group_id));
+    if (excludedIds.length === 0) return ctx;
+    return ctx.exclude((session) => !!session.guildId && excludedIds.includes(session.guildId));
+  } else {
+    const includedIds = explicitGroups.filter((item) => item.menu_list.includes(menuNumber)).map((item) => String(item.group_id));
+    if (includedIds.length === 0) {
+      logger.info(`[getCtxForFunction Info]: 功能 ${menuNumber} 在所有群组中均未启用，跳过注册`);
+      return null;
+    }
+    return ctx.guild(...includedIds);
+  }
+}
+__name(getCtxForFunction, "getCtxForFunction");
 function getGroupFunctionLimitConfig() {
   return groupFunctionLimitConfig;
 }
@@ -477,6 +509,12 @@ function getMenuListByCommand(command = null, functionConfig, session) {
       if (!isCommandAllowedForGuild(9, guildId))
         return "当前群聊已限制总结功能";
       return buildFuncMenu("总结功能菜单", "总结功能", sumFuncMenuList);
+    case menuByNumber.get(10)?.name:
+      if (!functionConfig.jm_flag)
+        return "禁漫下载功能已关闭";
+      if (!isCommandAllowedForGuild(10, guildId))
+        return "当前群聊已限制禁漫下载功能";
+      return buildFuncMenu("禁漫下载功能菜单", "禁漫下载功能", jmFuncMenuList);
     default:
       const allowedMenuNumbers = getAllowedMenuNumbersForGuild(guildId);
       const finalMenuList = allowedMenuNumbers ? allMenus.filter((item) => allowedMenuNumbers.includes(item.number)) : allMenus;
@@ -618,6 +656,13 @@ var sumFuncMenuList = [
     command: "sum [时间范围(1-168小时)]"
   }
 ];
+var jmFuncMenuList = [
+  {
+    name: "jm",
+    description: "提交禁漫本子下载任务",
+    command: "jm [comic_id]"
+  }
+];
 function registerMenuCommands(ctx, connected, functionConfig) {
   ctx.command("help <参数>", "帮助菜单").action(async ({ session }, ...args) => {
     if (!dev_mode) {
@@ -631,7 +676,7 @@ function registerMenuCommands(ctx, connected, functionConfig) {
 __name(registerMenuCommands, "registerMenuCommands");
 
 // src/services/tag_func/tag_commands.ts
-var import_koishi10 = require("koishi");
+var import_koishi11 = require("koishi");
 
 // src/services/tag_func/tag_service.ts
 var import_sequelize4 = require("sequelize");
@@ -639,7 +684,7 @@ var import_fs3 = require("fs");
 var import_path3 = require("path");
 
 // src/services/tag_func/img_service.ts
-var import_koishi9 = require("koishi");
+var import_koishi10 = require("koishi");
 var import_path2 = require("path");
 var import_fs2 = require("fs");
 async function loadImageFromUrl(ctx, url) {
@@ -714,7 +759,7 @@ async function randomImgByTag(tag_name, guild_id) {
     if (ImgList.length <= 0) {
       throw new Error("Don't have image!");
     }
-    const random = new import_koishi9.Random(() => Math.random());
+    const random = new import_koishi10.Random(() => Math.random());
     let result = ImgList[random.int(0, ImgList.length)];
     const filePath = result.get("img_url");
     return filePath;
@@ -998,13 +1043,13 @@ function registerTagCommands(ctx, connected, savePath2) {
       if (!exec2)
         return `获取图片失败`;
       return `第${exec2.page}页，共${exec2.total}页
-${exec2.result?.map((item) => import_koishi10.h.image((0, import_url.pathToFileURL)(item).href)).join("\n\n")}`;
+${exec2.result?.map((item) => import_koishi11.h.image((0, import_url.pathToFileURL)(item).href)).join("\n\n")}`;
     }
     let exec = await randomImgByTag(tag, session.guildId);
     if (!exec)
       return `获取图片失败`;
     let path2 = (0, import_url.pathToFileURL)(exec).href;
-    return import_koishi10.h.image(path2);
+    return import_koishi11.h.image(path2);
   });
   ctx.command("bind <参数>", "标签绑定别名").action(async ({ session }, ...args) => {
     if (!dev_mode) {
@@ -1147,7 +1192,7 @@ function registerRepeatMiddleware(ctx, config) {
 __name(registerRepeatMiddleware, "registerRepeatMiddleware");
 
 // src/services/rbq_func/rbq_command.ts
-var import_koishi11 = require("koishi");
+var import_koishi12 = require("koishi");
 
 // src/models/rbq_persons.ts
 var import_sequelize5 = require("sequelize");
@@ -1474,7 +1519,7 @@ function registerRbqCommands(ctx, connected) {
     if (!list || list.length === 0) {
       return "当前群聊还没有设置任何rbq";
     }
-    return "当前群聊rbq列表:\n" + list.map((item) => (0, import_koishi11.h)("at", { id: item })).join(",");
+    return "当前群聊rbq列表:\n" + list.map((item) => (0, import_koishi12.h)("at", { id: item })).join(",");
   });
   ctx.command("rbqadd <参数>", "添加rbq").action(async ({ session }, ...args) => {
     if (!dev_mode) {
@@ -1492,7 +1537,7 @@ function registerRbqCommands(ctx, connected) {
     exec = await create_person(session.guildId, uid);
     if (!exec.result)
       return `添加rbq失败: ${exec.error}`;
-    return "已添加rbq:" + (0, import_koishi11.h)("at", { id: uid });
+    return "已添加rbq:" + (0, import_koishi12.h)("at", { id: uid });
   });
   ctx.command("rbqinstead <参数>", "替换rbq").action(async ({ session }, ...args) => {
     if (!dev_mode) {
@@ -1517,12 +1562,12 @@ function registerRbqCommands(ctx, connected) {
       exec = await instead_person(session.guildId, source_uid, new_target);
       if (!exec.result)
         return `替换rbq失败：${exec.error}`;
-      return "倒反天罡！进去吧你，已替换rbq：\n" + (0, import_koishi11.h)("at", { id: source_uid }) + " -> " + (0, import_koishi11.h)("at", { id: new_target });
+      return "倒反天罡！进去吧你，已替换rbq：\n" + (0, import_koishi12.h)("at", { id: source_uid }) + " -> " + (0, import_koishi12.h)("at", { id: new_target });
     }
     exec = await instead_person(session.guildId, source_uid, target_uid);
     if (!exec.result)
       return `替换rbq失败：${exec.error}`;
-    return (0, import_koishi11.h)("p", "已替换rbq：", (0, import_koishi11.h)("at", { id: source_uid }), " -> ", (0, import_koishi11.h)("at", { id: target_uid }));
+    return (0, import_koishi12.h)("p", "已替换rbq：", (0, import_koishi12.h)("at", { id: source_uid }), " -> ", (0, import_koishi12.h)("at", { id: target_uid }));
   });
   ctx.command("rbqadd_txt <参数>", "添加自定义文本").action(async ({ session }, ...args) => {
     if (!dev_mode) {
@@ -1549,10 +1594,10 @@ function registerRbqCommands(ctx, connected) {
         const contents = await get_content_list(session.guildId, target_uid);
         let content2 = "*死你";
         if (contents && contents.length > 0) {
-          const random = new import_koishi11.Random(() => Math.random());
+          const random = new import_koishi12.Random(() => Math.random());
           content2 = contents[random.int(0, contents.length)];
         }
-        return (0, import_koishi11.h)("at", { id: target_uid }) + "还想自己加文本？！\n" + content2;
+        return (0, import_koishi12.h)("at", { id: target_uid }) + "还想自己加文本？！\n" + content2;
       } catch (error) {
         logger.error("[rbq rbqadd_txt] Error:", error);
         return "不能给自己设置文本，请输入其他qq号";
@@ -1582,10 +1627,10 @@ function registerRbqCommands(ctx, connected) {
       const contents = await get_content_list(guildId, matchedUid);
       let content = "*死你";
       if (contents && contents.length > 0) {
-        const random = new import_koishi11.Random(() => Math.random());
+        const random = new import_koishi12.Random(() => Math.random());
         content = contents[random.int(0, contents.length)];
       }
-      return (0, import_koishi11.h)("at", { id: matchedUid }) + " " + content;
+      return (0, import_koishi12.h)("at", { id: matchedUid }) + " " + content;
     } catch (error) {
       logger.error("[rbq middleware] Error:", error);
       return next();
@@ -1810,7 +1855,7 @@ __name(is_at_bot_quote, "is_at_bot_quote");
 
 // src/services/himg_func/himg_service.ts
 var import_axios2 = __toESM(require("axios"));
-var import_koishi12 = require("koishi");
+var import_koishi13 = require("koishi");
 async function randomHImg(keywords, ...args) {
   try {
     const r18 = keywords?.[0];
@@ -1840,7 +1885,7 @@ async function randomHImg(keywords, ...args) {
         let author = item.author;
         let url = item.urls.regular;
         let tags2 = item.tags;
-        result_content += "作者: " + author + "\n标签: \n[" + tags2.join(",") + "]\n" + import_koishi12.h.image(url) + "\n";
+        result_content += "作者: " + author + "\n标签: \n[" + tags2.join(",") + "]\n" + import_koishi13.h.image(url) + "\n";
       }
       return {
         result: result_content,
@@ -1897,7 +1942,7 @@ function registerHImgCommands(ctx) {
 __name(registerHImgCommands, "registerHImgCommands");
 
 // src/services/wish_func/wish_command.ts
-var import_koishi13 = require("koishi");
+var import_koishi14 = require("koishi");
 
 // src/services/wish_func/wish_service.ts
 var chatHistory2 = [];
@@ -2272,9 +2317,9 @@ function registerWishCommands(ctx, yaml_config_path, ai_config, wish_config) {
       if (!exec_generation) return "愿望实现失败，请重新许愿";
       const imageResult = await renderWishImage(ctx, wish_content, exec_generation);
       if (typeof imageResult === "string") {
-        return (0, import_koishi13.h)("at", { id: session.userId }) + " " + imageResult + "\n" + exec_generation;
+        return (0, import_koishi14.h)("at", { id: session.userId }) + " " + imageResult + "\n" + exec_generation;
       }
-      return (0, import_koishi13.h)("at", { id: session.userId }) + " 祈祷成功，愿梦想成真！\n" + import_koishi13.h.image(imageResult, "image/png");
+      return (0, import_koishi14.h)("at", { id: session.userId }) + " 祈祷成功，愿梦想成真！\n" + import_koishi14.h.image(imageResult, "image/png");
     } finally {
       think_flag2 = false;
     }
@@ -2693,7 +2738,7 @@ function registerKuroCommands(ctx, connected) {
 __name(registerKuroCommands, "registerKuroCommands");
 
 // src/services/game_func/game_command.ts
-var import_koishi14 = require("koishi");
+var import_koishi15 = require("koishi");
 
 // src/services/game_func/game_service.ts
 var gameTimeout = null;
@@ -3059,7 +3104,7 @@ async function situationPuzzleMiddleware(session, ai_config) {
       return checkResp(resp2);
     }
     const resp = await questSituationPuzzle(text, ai_config);
-    return (0, import_koishi14.h)("at", { id: userId }) + " " + checkResp(resp);
+    return (0, import_koishi15.h)("at", { id: userId }) + " " + checkResp(resp);
   } finally {
     is_thinking = false;
   }
@@ -3074,7 +3119,7 @@ function checkResp(resp) {
 __name(checkResp, "checkResp");
 
 // src/services/sum_func/sum_command.ts
-var import_koishi15 = require("koishi");
+var import_koishi16 = require("koishi");
 
 // src/services/sum_func/sum_service.ts
 var import_sequelize10 = require("sequelize");
@@ -3595,7 +3640,7 @@ function registerSumCommands(ctx, yaml_config_path, ai_config, sum_config) {
       const imageResult = await renderChatSummaryImage(ctx, exec.result, exec.hours, exec.stats, false);
       if (typeof imageResult === "string")
         return imageResult + "\n" + exec.result;
-      return import_koishi15.h.image(imageResult, "image/png");
+      return import_koishi16.h.image(imageResult, "image/png");
     }
     return exec.result;
   });
@@ -3606,23 +3651,239 @@ function registerSumCommands(ctx, yaml_config_path, ai_config, sum_config) {
 }
 __name(registerSumCommands, "registerSumCommands");
 
+// src/services/jm_func/jm_service.ts
+var import_axios4 = __toESM(require("axios"));
+var import_fs4 = require("fs");
+var import_koishi17 = require("koishi");
+var guildActiveTasks = /* @__PURE__ */ new Map();
+function normalizeBaseUrl(apiUrl) {
+  return apiUrl.replace(/\/+$/, "");
+}
+__name(normalizeBaseUrl, "normalizeBaseUrl");
+function buildHeaders(config) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (config.api_key)
+    headers["X-API-Key"] = config.api_key;
+  return headers;
+}
+__name(buildHeaders, "buildHeaders");
+function getMaxConcurrent(config) {
+  const max = config.max_concurrent_per_guild ?? 5;
+  return max > 0 ? max : 5;
+}
+__name(getMaxConcurrent, "getMaxConcurrent");
+function registerTask(record, config) {
+  const guildId = record.guildId;
+  const list = guildActiveTasks.get(guildId) ?? [];
+  if (list.length >= getMaxConcurrent(config))
+    return false;
+  list.push(record);
+  guildActiveTasks.set(guildId, list);
+  return true;
+}
+__name(registerTask, "registerTask");
+function updateTaskId(guildId, oldTaskId, newTaskId) {
+  const list = guildActiveTasks.get(guildId);
+  if (!list) return;
+  const target = list.find((item) => item.taskId === oldTaskId);
+  if (target)
+    target.taskId = newTaskId;
+}
+__name(updateTaskId, "updateTaskId");
+function unregisterTask(guildId, taskId) {
+  const list = guildActiveTasks.get(guildId);
+  if (!list) return;
+  const next = list.filter((item) => item.taskId !== taskId);
+  if (next.length === 0)
+    guildActiveTasks.delete(guildId);
+  else
+    guildActiveTasks.set(guildId, next);
+}
+__name(unregisterTask, "unregisterTask");
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+__name(sleep, "sleep");
+async function submitDownload(albumId, config) {
+  const baseUrl = normalizeBaseUrl(config.api_url || "http://127.0.0.1:6789");
+  try {
+    const response = await import_axios4.default.post(
+      `${baseUrl}/api/download`,
+      { album_id: albumId },
+      { headers: buildHeaders(config), timeout: 3e4 }
+    );
+    return { ok: true, data: response.data };
+  } catch (error) {
+    const message = error?.response?.data?.detail ?? error?.response?.data?.message ?? error?.message ?? String(error);
+    logger.error("[jm submitDownload Error]: " + message);
+    return { ok: false, error: message };
+  }
+}
+__name(submitDownload, "submitDownload");
+async function getTask(taskId, config) {
+  const baseUrl = normalizeBaseUrl(config.api_url || "http://127.0.0.1:6789");
+  try {
+    const response = await import_axios4.default.get(
+      `${baseUrl}/api/task/${taskId}`,
+      { headers: buildHeaders(config), timeout: 3e4 }
+    );
+    return { ok: true, data: response.data };
+  } catch (error) {
+    const message = error?.response?.data?.detail ?? error?.response?.data?.message ?? error?.message ?? String(error);
+    logger.error("[jm getTask Error]: " + message);
+    return { ok: false, error: message };
+  }
+}
+__name(getTask, "getTask");
+async function deleteAlbum(albumId, config) {
+  const baseUrl = normalizeBaseUrl(config.api_url || "http://127.0.0.1:6789");
+  try {
+    await import_axios4.default.delete(
+      `${baseUrl}/api/album/${albumId}`,
+      { headers: buildHeaders(config), timeout: 3e4 }
+    );
+    logger.info(`[jm deleteAlbum Info]: album_id=${albumId} cleaned up`);
+  } catch (error) {
+    if (error?.response?.status === 404) {
+      logger.info(`[jm deleteAlbum Info]: album_id=${albumId} no local files to delete`);
+      return;
+    }
+    const message = error?.response?.data?.detail ?? error?.response?.data?.message ?? error?.message ?? String(error);
+    logger.warn("[jm deleteAlbum Error]: " + message);
+  }
+}
+__name(deleteAlbum, "deleteAlbum");
+async function readLocalPdf(pdfPath) {
+  return import_fs4.promises.readFile(pdfPath);
+}
+__name(readLocalPdf, "readLocalPdf");
+async function notifyUser(bot, record, message) {
+  await bot.sendMessage(record.channelId, message);
+}
+__name(notifyUser, "notifyUser");
+async function pollAndDeliver(bot, record, config) {
+  const pollInterval = config.poll_interval_ms ?? 5e3;
+  const pollTimeout = config.poll_timeout_ms ?? 18e5;
+  const startedAt = Date.now();
+  const deliver = /* @__PURE__ */ __name(async (message) => {
+    await deleteAlbum(record.albumId, config);
+    await notifyUser(bot, record, message);
+  }, "deliver");
+  try {
+    while (true) {
+      if (Date.now() - startedAt > pollTimeout) {
+        await deliver(`${(0, import_koishi17.h)("at", { id: record.userId })} 下载超时，请稍后重试。`);
+        return;
+      }
+      await sleep(pollInterval);
+      const result = await getTask(record.taskId, config);
+      if (!result.ok) {
+        await deliver(`${(0, import_koishi17.h)("at", { id: record.userId })} 查询任务失败：${result.error}`);
+        return;
+      }
+      const task = result.data;
+      if (task.status === "pending" || task.status === "running")
+        continue;
+      if (task.status === "failed") {
+        const errorMsg = task.error || task.message || "未知错误";
+        logger.error(
+          `[jm task Failed]: album_id=${record.albumId} task_id=${record.taskId} error=${errorMsg}`
+        );
+        await deliver(`${(0, import_koishi17.h)("at", { id: record.userId })} 下载失败：${errorMsg}`);
+        return;
+      }
+      if (task.status === "success") {
+        let message;
+        try {
+          const pdfPath = task.pdf_path;
+          if (!pdfPath)
+            throw new Error("任务成功但未返回文件路径");
+          const pdfBuffer = await readLocalPdf(pdfPath);
+          const filename = `${record.albumId}.pdf` || task.pdf_filename;
+          message = [
+            (0, import_koishi17.h)("at", { id: record.userId }),
+            ` 本子[${record.albumId}]下载完成：`,
+            import_koishi17.h.file(pdfBuffer, "application/pdf", { name: filename })
+          ];
+        } catch (error) {
+          const errorMsg = error?.message || String(error);
+          logger.error("[jm readLocalPdf Error]: " + errorMsg);
+          message = `${(0, import_koishi17.h)("at", { id: record.userId })} 文件读取失败：${errorMsg}`;
+        }
+        await deliver(message);
+        return;
+      }
+    }
+  } finally {
+    unregisterTask(record.guildId, record.taskId);
+  }
+}
+__name(pollAndDeliver, "pollAndDeliver");
+async function startJmDownload(bot, record, config) {
+  void pollAndDeliver(bot, record, config);
+}
+__name(startJmDownload, "startJmDownload");
+
+// src/services/jm_func/jm_command.ts
+function registerJmCommands(ctx, jm_config) {
+  ctx.command("jm <参数>", "提交禁漫本子下载任务").action(async ({ session }, ...args) => {
+    if (!dev_mode) {
+      if (!is_at_bot(session)) return;
+    }
+    const albumId = args?.[0]?.trim();
+    if (!albumId)
+      return "请提供正确格式，如：@bot jm [comic_id]";
+    if (!/^\d+$/.test(albumId))
+      return "comic_id 应为数字，如：@bot jm 123456";
+    const guildId = session.guildId;
+    const channelId = session.channelId;
+    const userId = session.userId;
+    if (!guildId || !channelId || !userId)
+      return "无法获取群聊或用户信息";
+    const maxConcurrent = jm_config.max_concurrent_per_guild ?? 5;
+    const pendingTaskId = `pending-${Date.now()}-${userId}`;
+    const record = {
+      taskId: pendingTaskId,
+      guildId,
+      channelId,
+      userId,
+      albumId
+    };
+    if (!registerTask(record, jm_config))
+      return `当前群聊已有${maxConcurrent}个下载任务进行中，请稍后再试`;
+    const submitResult = await submitDownload(albumId, jm_config);
+    if (!submitResult.ok) {
+      unregisterTask(guildId, pendingTaskId);
+      return `提交下载失败：${submitResult.error}`;
+    }
+    const taskId = submitResult.data.task_id;
+    updateTaskId(guildId, pendingTaskId, taskId);
+    startJmDownload(session.bot, record, jm_config);
+    return `已收到本子[${albumId}]的下载请求，完成后会在此群@你。`;
+  });
+}
+__name(registerJmCommands, "registerJmCommands");
+
 // src/index.ts
 var name = "cocoyyy-console";
 var inject = { optional: ["puppeteer"] };
 var dev_mode;
-var Config = import_koishi16.Schema.object({
+var Config = import_koishi18.Schema.object({
   function_config: FunctionConfigSchema.description("功能开关配置"),
   function_enable_config: GroupFunctionLimitConfigSchema.description("群聊功能限制配置"),
   ai_config: AiAPIConfigSchema.description("AI API配置"),
-  yaml_config_path: import_koishi16.Schema.string().default("").description("统一配置文件路径"),
+  yaml_config_path: import_koishi18.Schema.string().default("").description("统一配置文件路径"),
   mysql_config: MysqlConfigSchema.description("MySQL 数据库配置"),
   tag_config: SaveConfigSchema.description("tag图片保存配置"),
   repeat_config: RepeatConfigSchema.description("复读配置"),
   wish_config: WishConfigSchema.description("许愿配置"),
   sum_config: SumConfigSchema.description("总结配置"),
-  test: import_koishi16.Schema.string().description("测试")
+  jm_config: JmConfigSchema.description("禁漫下载配置"),
+  test: import_koishi18.Schema.string().description("测试")
 });
-var logger = new import_koishi16.Logger(name);
+var logger = new import_koishi18.Logger(name);
 var savePath = null;
 async function apply(ctx, config) {
   ctx = ctx.guild();
@@ -3640,26 +3901,38 @@ async function apply(ctx, config) {
   savePath = resolveTagBaseDir(config?.tag_config);
   loadGroupFunctionLimitConfig(config?.function_enable_config);
   registerMenuCommands(ctx, connected, config.function_config);
-  if (config.function_config.tag_flag)
-    registerTagCommands(ctx, connected, savePath);
-  if (config.function_config.repeat_flag)
-    registerRepeatMiddleware(ctx, config?.repeat_config);
-  if (config.function_config.son_flag)
-    registerShitOrNotCommands(ctx, config?.yaml_config_path, config?.ai_config);
-  if (config.function_config.setu_flag)
-    registerHImgCommands(ctx);
-  if (config.function_config.wish_flag)
-    registerWishCommands(ctx, config?.yaml_config_path, config?.ai_config, config?.wish_config);
-  if (config.function_config.game_flag) {
-    registerGameCommands(ctx, config?.yaml_config_path, config?.ai_config);
-    registerGameMiddleware(ctx, config?.ai_config);
-  }
-  if (config.function_config.rbq_flag)
-    registerRbqCommands(ctx, connected);
-  if (config.function_config)
-    registerKuroCommands(ctx, connected);
-  if (config.function_config.sum_flag)
-    registerSumCommands(ctx, config?.yaml_config_path, config?.ai_config, config?.sum_config);
+  const tagCtx = getCtxForFunction(ctx, 1);
+  if (config.function_config.tag_flag && tagCtx)
+    registerTagCommands(tagCtx, connected, savePath);
+  const repeatCtx = getCtxForFunction(ctx, 2);
+  if (config.function_config.repeat_flag && repeatCtx)
+    registerRepeatMiddleware(repeatCtx, config?.repeat_config);
+  const rbqCtx = getCtxForFunction(ctx, 3);
+  if (config.function_config.rbq_flag && rbqCtx)
+    registerRbqCommands(rbqCtx, connected);
+  const sonCtx = getCtxForFunction(ctx, 4);
+  if (config.function_config.son_flag && sonCtx)
+    registerShitOrNotCommands(sonCtx, config?.yaml_config_path, config?.ai_config);
+  const setuCtx = getCtxForFunction(ctx, 5);
+  if (config.function_config.setu_flag && setuCtx)
+    registerHImgCommands(setuCtx);
+  const wishCtx = getCtxForFunction(ctx, 6);
+  if (config.function_config.wish_flag && wishCtx)
+    registerWishCommands(wishCtx, config?.yaml_config_path, config?.ai_config, config?.wish_config);
+  const gameCtx = getCtxForFunction(ctx, 7);
+  if (config.function_config.game_flag && gameCtx) {
+    registerGameCommands(gameCtx, config?.yaml_config_path, config?.ai_config);
+    registerGameMiddleware(gameCtx, config?.ai_config);
+  }
+  const kuroCtx = getCtxForFunction(ctx, 8);
+  if (config.function_config.kuro_flag && kuroCtx)
+    registerKuroCommands(kuroCtx, connected);
+  const sumCtx = getCtxForFunction(ctx, 9);
+  if (config.function_config.sum_flag && sumCtx)
+    registerSumCommands(sumCtx, config?.yaml_config_path, config?.ai_config, config?.sum_config);
+  const jmCtx = getCtxForFunction(ctx, 10);
+  if (config.function_config.jm_flag && jmCtx)
+    registerJmCommands(jmCtx, config?.jm_config ?? {});
   if (dev_mode)
     registerTestCommands(ctx, config);
 }

package/lib/services/group_func_limit_service.d.ts

@@ -1,4 +1,5 @@
 import * as my_config from '../config/config';
+import { Context } from 'koishi';
 type GroupFunctionLimitItem = {
     group_id: string | number;
     menu_list: number[];
@@ -10,7 +11,17 @@ type MenuList = {
     description: string;
 };
 declare function loadGroupFunctionLimitConfig(config: my_config.GroupFunctionLimitConfig): boolean;
-export { groupFunctionLimitConfig, loadGroupFunctionLimitConfig };
+/**
+ * 根据 groupFuncLimit.json 的 groupList 配置，为指定功能编号返回对应的 Koishi Context：
+ *
+ * - "#" 条目作为默认规则（适用于未在 groupList 中显式列出的所有群组）
+ * - 若默认规则允许该功能：返回排除了显式禁用该功能的群组的 ctx
+ * - 若默认规则不允许该功能：返回仅限显式允许该功能的群组的 ctx
+ * - 若没有任何群组允许该功能：返回 null（调用方应跳过注册）
+ * - 若未加载功能限制配置：直接返回原始 ctx（不加限制）
+ */
+declare function getCtxForFunction(ctx: Context, menuNumber: number): Context | null;
+export { groupFunctionLimitConfig, loadGroupFunctionLimitConfig, getCtxForFunction, };
 declare function getGroupFunctionLimitConfig(): GroupFunctionLimitItem[];
 declare function getMenuList(): MenuList[];
 export { getGroupFunctionLimitConfig, getMenuList, };

package/lib/services/jm_func/jm_command.d.ts

@@ -0,0 +1,4 @@
+import { Context } from 'koishi';
+import { JmConfig } from '../../config/config';
+declare function registerJmCommands(ctx: Context, jm_config: JmConfig): void;
+export { registerJmCommands, };

package/lib/services/jm_func/jm_service.d.ts

@@ -0,0 +1,34 @@
+import { Bot } from 'koishi';
+import { JmConfig } from '../../config/config';
+type TaskStatus = 'pending' | 'running' | 'success' | 'failed';
+interface DownloadResponse {
+    task_id: string;
+    status: TaskStatus;
+    album_id: string;
+    pdf_path?: string | null;
+    pdf_filename?: string | null;
+    error?: string | null;
+    message?: string;
+}
+interface JmTaskRecord {
+    taskId: string;
+    guildId: string;
+    channelId: string;
+    userId: string;
+    albumId: string;
+}
+declare function getActiveTaskCount(guildId: string): number;
+declare function registerTask(record: JmTaskRecord, config: JmConfig): boolean;
+declare function updateTaskId(guildId: string, oldTaskId: string, newTaskId: string): void;
+declare function unregisterTask(guildId: string, taskId: string): void;
+declare function submitDownload(albumId: string, config: JmConfig): Promise<{
+    ok: true;
+    data: DownloadResponse;
+    error?: undefined;
+} | {
+    ok: false;
+    error: any;
+    data?: undefined;
+}>;
+declare function startJmDownload(bot: Bot, record: JmTaskRecord, config: JmConfig): Promise<void>;
+export { DownloadResponse, JmTaskRecord, getActiveTaskCount, registerTask, submitDownload, startJmDownload, unregisterTask, updateTaskId, };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-cocoyyy-console",
   "description": "自用koishi插件，功能包含复读，记录黑历史，*人等",
-  "version": "1.2.0-alpha.1",
+  "version": "1.2.0",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "contributors": [