koishi-plugin-cocoyyy-console 1.0.1 → 1.0.3

package/lib/index.d.ts

@@ -1,9 +1,12 @@
 import { Context, Logger, Schema } from 'koishi';
-import { MysqlConfig, SaveConfig } from './utils/config';
+import * as my_config from './utils/config';
 export declare const name = "cocoyyy-console";
 export interface Config {
-    mysql?: MysqlConfig;
-    save?: SaveConfig;
+    function_config?: my_config.FunctionConfig;
+    mysql_config?: my_config.MysqlConfig;
+    tag_config?: my_config.SaveConfig;
+    repeat_config?: my_config.RepeatConfig;
+    rbq_config?: my_config.RbqConfig;
 }
 export declare const Config: Schema<Config>;
 export declare let logger: Logger;

package/lib/index.js

@@ -27,16 +27,24 @@ __export(src_exports, {
   savePath: () => savePath
 });
 module.exports = __toCommonJS(src_exports);
-var import_koishi3 = require("koishi");
+var import_koishi9 = require("koishi");
 
-// src/utils/config.ts
+// src/utils/configs/function_config.ts
 var import_koishi = require("koishi");
-var MysqlConfigSchema = import_koishi.Schema.object({
-  host: import_koishi.Schema.string().default("127.0.0.1").description("MySQL 主机地址"),
-  port: import_koishi.Schema.number().default(3306).description("MySQL 端口"),
-  user: import_koishi.Schema.string().default("root").description("用户名"),
-  password: import_koishi.Schema.string().role("secret").default("").description("密码"),
-  database: import_koishi.Schema.string().default("test").description("数据库名")
+var FunctionConfigSchema = import_koishi.Schema.object({
+  tag_flag: import_koishi.Schema.boolean().default(true).description("标签功能是否启用"),
+  repeat_flag: import_koishi.Schema.boolean().default(true).description("复读功能是否启用"),
+  rbq_flag: import_koishi.Schema.boolean().default(true).description("*人功能是否启用")
+});
+
+// src/utils/configs/mysql_config.ts
+var import_koishi2 = require("koishi");
+var MysqlConfigSchema = import_koishi2.Schema.object({
+  host: import_koishi2.Schema.string().default("127.0.0.1").description("MySQL 主机地址"),
+  port: import_koishi2.Schema.number().default(3306).description("MySQL 端口"),
+  user: import_koishi2.Schema.string().default("root").description("用户名"),
+  password: import_koishi2.Schema.string().role("secret").default("").description("密码"),
+  database: import_koishi2.Schema.string().default("test").description("数据库名")
 });
 function loadMysqlConfigFromEnv(env = process.env) {
   return {
@@ -48,8 +56,11 @@ function loadMysqlConfigFromEnv(env = process.env) {
   };
 }
 __name(loadMysqlConfigFromEnv, "loadMysqlConfigFromEnv");
-var SaveConfigSchema = import_koishi.Schema.object({
-  save_path: import_koishi.Schema.string().default("").description("保存图片路径（绝对路径）")
+
+// src/utils/configs/tag_config.ts
+var import_koishi3 = require("koishi");
+var SaveConfigSchema = import_koishi3.Schema.object({
+  save_path: import_koishi3.Schema.string().default("").description("保存图片路径（绝对路径）")
 });
 function resolveTagBaseDir(config) {
   if (config?.save_path && config.save_path.trim().length > 0) return config.save_path;
@@ -57,6 +68,26 @@ function resolveTagBaseDir(config) {
 }
 __name(resolveTagBaseDir, "resolveTagBaseDir");
 
+// src/utils/configs/repeat_config.ts
+var import_koishi4 = require("koishi");
+var RepeatConfigSchema = import_koishi4.Schema.object({
+  minTimes: import_koishi4.Schema.number().default(1).description("最小重复次数"),
+  probability: import_koishi4.Schema.number().default(1).description("复读概率[0-1]"),
+  guild_ids: import_koishi4.Schema.string().default("").description("不需要复读的群ID，多个群ID用逗号分隔"),
+  resetInterval: import_koishi4.Schema.number().default(60).description("过期秒数")
+});
+
+// src/utils/configs/rbq_config.ts
+var import_koishi5 = require("koishi");
+var RbqConfigSchema = import_koishi5.Schema.object({
+  configList: import_koishi5.Schema.array(import_koishi5.Schema.object({
+    probability: import_koishi5.Schema.number().default(1).description("触发概率[0-1]"),
+    guild_id: import_koishi5.Schema.string().default("").description("触发群聊id"),
+    uid: import_koishi5.Schema.string().default("").description("触发用户id"),
+    content: import_koishi5.Schema.string().default("*死你").description("触发内容")
+  })).description("触发配置")
+});
+
 // src/infra/mysql_init.ts
 var import_sequelize = require("sequelize");
 var sequelize = null;
@@ -99,6 +130,7 @@ var TagsModel = class extends import_sequelize2.Model {
   id;
   tags;
   alias;
+  guild_id;
   status;
   createtime;
 };
@@ -123,6 +155,10 @@ function getTagsModel() {
           type: import_sequelize2.DataTypes.STRING(191),
           allowNull: true
         },
+        guild_id: {
+          type: import_sequelize2.DataTypes.STRING(191),
+          allowNull: false
+        },
         status: {
           type: import_sequelize2.DataTypes.TINYINT,
           allowNull: false,
@@ -236,57 +272,241 @@ function is_at_bot(session) {
 }
 __name(is_at_bot, "is_at_bot");
 
-// src/services/tag_service.ts
+// src/services/menu_service.ts
+var menuList = [
+  {
+    name: "tag",
+    description: "标签功能，用于记录黑历史",
+    command: "maketag [标签]"
+  },
+  {
+    name: "repeat",
+    description: "复读功能，用于复读",
+    command: "无"
+  },
+  {
+    name: "rbq",
+    description: "*人功能，用于*人",
+    command: "无"
+  }
+];
+function getMenuList(command = null, functionConfig) {
+  switch (command) {
+    case "tag":
+      if (!functionConfig.tag_flag)
+        return "标签功能已关闭";
+      return getTagFuncMenu(command);
+    case "repeat":
+      if (!functionConfig.repeat_flag)
+        return "复读功能已关闭";
+      return `[所有命令都需要@bot]
+复读功能菜单:
+群内重复一定次数的消息会进行复读
+如果遇到问题请联系开发人员。`;
+    case "rbq":
+      if (!functionConfig.rbq_flag)
+        return "*人功能已关闭";
+      return `[所有命令都需要@bot]
+*人功能菜单:
+联系管理人员配置群内指定用户，在群内@指定用户，会触发*人功能
+如果遇到问题请联系开发人员。`;
+    default:
+      return `[所有命令都需要@bot]
+当前可用功能列表:
+	${menuList.map((item) => item.name + ": " + item.description).join("\n	")}
+输入"help 功能名"查看特定功能的指令和使用示例。`;
+  }
+}
+__name(getMenuList, "getMenuList");
+var tagFuncMenuList = [
+  {
+    name: "maketag",
+    description: "创建一个标签",
+    command: "maketag [标签]"
+  },
+  {
+    name: "add",
+    description: "给标签添加图片",
+    command: "add [标签] [图片]"
+  },
+  {
+    name: "get",
+    description: "给标签添加图片",
+    command: "get [标签]"
+  },
+  {
+    name: "bind",
+    description: "标签绑定别名",
+    command: "bind [标签] [别名]"
+  },
+  {
+    name: "unbind",
+    description: "标签取消别名",
+    command: "unbind [标签] [别名]"
+  },
+  {
+    name: "taglist",
+    description: "获取标签列表",
+    command: "taglist"
+  }
+];
+function getTagFuncMenu(command = null) {
+  return `[所有命令都需要@bot]
+标签功能菜单:
+	${tagFuncMenuList.map((item) => item.command + ": " + item.description).join("\n	")}
+输入对应指令使用标签功能，如果遇到问题请联系开发人员。`;
+}
+__name(getTagFuncMenu, "getTagFuncMenu");
+function registerMenuCommands(ctx, connected, functionConfig) {
+  ctx.command("help <参数>", "帮助菜单").check(({ session }) => {
+    if (!connected) return;
+    if (!is_at_bot(session)) return;
+  }).action(async ({ session }, ...args) => {
+    const command = args?.[0];
+    return getMenuList(command, functionConfig);
+  });
+}
+__name(registerMenuCommands, "registerMenuCommands");
+
+// src/services/tag_func/tag_commands.ts
+var import_koishi7 = require("koishi");
+
+// src/services/tag_func/tag_service.ts
 var import_sequelize4 = require("sequelize");
-var import_fs = require("fs");
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+
+// src/services/tag_func/img_service.ts
+var import_koishi6 = require("koishi");
 var import_path = require("path");
-async function findTagByName(name2) {
+var import_fs = require("fs");
+async function loadImageFromUrl(ctx, url) {
+  try {
+    const responseArrayBuffer = await ctx.http.get(url, {
+      responseType: "arraybuffer",
+      timeout: 2e4
+      // 设置 20 秒超时
+    });
+    return Buffer.from(responseArrayBuffer);
+  } catch (error) {
+    logger.error(`[loadImageFromUrl] Failed to load image from URL: ${url}`, error);
+    throw new Error(`Failed to download image: ${error.message}`);
+  }
+}
+__name(loadImageFromUrl, "loadImageFromUrl");
+async function saveImg(ctx, tag_name, guild_id, imgurl, savePath2) {
+  try {
+    const Img = getImgsModel();
+    let tag = await getTag(tag_name, guild_id);
+    if (tag == null) {
+      throw new Error(`not found tag '${tag_name}'!`);
+    }
+    if (tag.get("status") !== 0) {
+      logger.info(`[saveImg Info]:tag '${tag_name}' is deleted`);
+      throw new Error(`tag '${tag_name}' is deleted!`);
+    }
+    if (savePath2 == null) {
+      throw new Error("saving path config wrong!");
+    }
+    let dir = (0, import_path.join)(savePath2, String(tag.get("id")));
+    const now = new Date(Date.now() + 8 * 60 * 60 * 1e3);
+    const srcMatch = imgurl.match(/src="([^"]+)"/);
+    if (!srcMatch) throw new Error("invalid img tag, no src found!");
+    const srcUrl = srcMatch[1];
+    const imageBuffer = await loadImageFromUrl(ctx, srcUrl);
+    if (!imageBuffer || imageBuffer.byteLength === 0) {
+      throw new Error("Downloaded image data is empty.");
+    }
+    logger.info("[saveImg Info]: Downloaded image data success!");
+    const fileNameMatch = imgurl.match(/file="([^"]+)"/);
+    if (!fileNameMatch) throw new Error("invalid img tag, no file name found!");
+    const fileName = fileNameMatch[1];
+    const filePath = (0, import_path.join)(dir, fileName);
+    await import_fs.promises.writeFile(filePath, imageBuffer);
+    const saveImg2 = await Img.create({ tag_id: tag.get("id"), img_url: filePath, createtime: now });
+    logger.info("[saveImg Info]: save image to '" + tag_name + "' success");
+    return { result: true, error: null };
+  } catch (e) {
+    logger.error("[saveImg Error]: " + e?.message || String(e));
+    return { result: false, error: e?.message || String(e) };
+  }
+}
+__name(saveImg, "saveImg");
+async function randomImgByTag(tag_name, guild_id) {
+  try {
+    const Img = getImgsModel();
+    const existed = await getTag(tag_name, guild_id);
+    if (!existed) {
+      throw new Error(`not found tag '${tag_name}'!`);
+    }
+    if (existed.status == 0) {
+      throw new Error(`not found tag '${tag_name}'!`);
+    }
+    let ImgList = await Img.findAll({
+      where: {
+        status: 0,
+        tag_id: existed.get("id")
+      }
+    });
+    if (ImgList.length <= 0) {
+      throw new Error("Don't have image!");
+    }
+    const random = new import_koishi6.Random(() => Math.random());
+    let result = ImgList[random.int(0, ImgList.length)];
+    const filePath = result.get("img_url");
+    return filePath;
+  } catch (e) {
+    logger.error("[randomImgByTag Error]: " + e?.message || String(e));
+    return null;
+  }
+}
+__name(randomImgByTag, "randomImgByTag");
+async function getImgCountByTag(tag_id) {
+  const Img = getImgsModel();
+  let count = await Img.count({
+    where: { status: 0, tag_id }
+  });
+  return count;
+}
+__name(getImgCountByTag, "getImgCountByTag");
+
+// src/services/tag_func/tag_service.ts
+async function findTagByName(tag_name, guild_id) {
   const Tag = getTagsModel();
   return await Tag.findOne({
     where: {
       status: 0,
+      guild_id,
       [import_sequelize4.Op.or]: [
-        { tags: name2 },
-        { alias: { [import_sequelize4.Op.like]: `%${name2}%` } }
+        { tags: tag_name },
+        { alias: { [import_sequelize4.Op.like]: `%${tag_name}%` } }
       ]
     }
   });
 }
 __name(findTagByName, "findTagByName");
-async function findDeletedTagByName(name2) {
+async function findDeletedTagByName(tag_name, guild_id) {
   const Tag = getTagsModel();
   return await Tag.findOne({
     where: {
       status: 1,
+      guild_id,
       [import_sequelize4.Op.or]: [
-        { tags: name2 },
-        { alias: { [import_sequelize4.Op.like]: `%${name2}%` } }
+        { tags: tag_name },
+        { alias: { [import_sequelize4.Op.like]: `%${tag_name}%` } }
       ]
     }
   });
 }
 __name(findDeletedTagByName, "findDeletedTagByName");
-async function createorUpdateTag(name2, alias, savePath2) {
+async function createorUpdateTag(tag_name, guild_id, savePath2) {
   try {
     const Tag = getTagsModel();
-    let existed = await findTagByName(name2);
+    let existed = await findTagByName(tag_name, guild_id);
     if (existed) {
-      if (alias == null) {
-        throw new Error("already existed!");
-      }
-      let now_alias = existed.get("alias");
-      if (now_alias != null) {
-        const list = now_alias.split(";");
-        if (!list.includes(alias)) list.push(alias);
-        now_alias = list.join(";");
-      } else {
-        now_alias = alias;
-      }
-      existed.alias = now_alias;
-      await existed.save();
-      return { result: true, error: null };
+      throw new Error("already existed!");
     }
-    existed = await findDeletedTagByName(name2);
+    existed = await findDeletedTagByName(tag_name, guild_id);
     if (existed) {
       if (existed.get("status") != 0) {
         existed.set("status", 0);
@@ -299,9 +519,9 @@ async function createorUpdateTag(name2, alias, savePath2) {
       throw new Error("saving path config wrong!");
     }
     const now = new Date(Date.now() + 8 * 60 * 60 * 1e3);
-    const tag = await Tag.create({ tags: name2, alias: alias ?? null, createtime: now });
-    const dir = (0, import_path.join)(savePath2, String(tag.id));
-    (0, import_fs.mkdirSync)(dir, { recursive: true });
+    const tag = await Tag.create({ tags: tag_name, alias: null, guild_id, createtime: now });
+    const dir = (0, import_path2.join)(savePath2, String(tag.id));
+    (0, import_fs2.mkdirSync)(dir, { recursive: true });
     return { result: true, error: null };
   } catch (e) {
     logger.error("[createorUpdateTag Error]: " + e?.message || String(e));
@@ -309,9 +529,9 @@ async function createorUpdateTag(name2, alias, savePath2) {
   }
 }
 __name(createorUpdateTag, "createorUpdateTag");
-async function getTag(name2) {
+async function getTag(tag_name, guild_id) {
   try {
-    let tag = await findTagByName(name2);
+    let tag = await findTagByName(tag_name, guild_id);
     return tag;
   } catch (e) {
     logger.error("[getTag Error]: " + e?.message || String(e));
@@ -319,119 +539,93 @@ async function getTag(name2) {
   }
 }
 __name(getTag, "getTag");
-
-// src/services/img_service.ts
-var import_koishi2 = require("koishi");
-var import_path2 = require("path");
-var import_fs2 = require("fs");
-async function saveImg(name2, img, savePath2) {
+async function bindAlias(tag_name, guild_id, alias) {
   try {
-    const Img = getImgsModel();
-    logger.info("[saveImg Info]: " + img);
-    let tag = await getTag(name2);
-    if (tag == null) {
-      throw new Error(`not found tag '${name2}'!`);
-    }
-    if (tag.get("status") !== 0) {
-      logger.info(`[saveImg Info]:tag '${name2}' is deleted`);
-      throw new Error(`tag '${name2}' is deleted!`);
+    return await checkAlias(tag_name, alias, guild_id, false);
+  } catch (e) {
+    logger.error("[bindAlias Error]: " + e?.message || String(e));
+    return { result: false, error: e?.message || String(e) };
+  }
+}
+__name(bindAlias, "bindAlias");
+async function unbindAlias(tag_name, guild_id, alias) {
+  try {
+    return await checkAlias(tag_name, alias, guild_id, true);
+  } catch (e) {
+    logger.error("[unbindAlias Error]: " + e?.message || String(e));
+    return { result: false, error: e?.message || String(e) };
+  }
+}
+__name(unbindAlias, "unbindAlias");
+async function checkAlias(tag_name, alias, guild_id, isDelete = false) {
+  try {
+    let existed = await findTagByName(tag_name, guild_id);
+    if (existed == null) {
+      throw new Error(`not found tag '${tag_name}'`);
     }
-    if (savePath2 == null) {
-      throw new Error("saving path config wrong!");
+    let now_alias = existed.get("alias");
+    let new_list;
+    if (!isDelete) {
+      if (now_alias != null) {
+        const list = now_alias.split(";");
+        if (!list.includes(alias)) list.push(alias);
+        now_alias = list.join(";");
+      } else {
+        now_alias = alias;
+      }
+    } else {
+      if (now_alias != null) {
+        const list = now_alias.split(";");
+        if (list.includes(alias))
+          new_list = list.filter((tar) => tar !== alias);
+        now_alias = new_list.join(";");
+      } else {
+        throw new Error(`not found alia '${alias}'`);
+      }
     }
-    let dir = (0, import_path2.join)(savePath2, String(tag.get("id")));
-    const now = new Date(Date.now() + 8 * 60 * 60 * 1e3);
-    const filename = now.getFullYear().toString() + String(now.getMonth() + 1).padStart(2, "0") + String(now.getDate()).padStart(2, "0") + String(now.getHours()).padStart(2, "0") + String(now.getMinutes()).padStart(2, "0") + String(now.getSeconds()).padStart(2, "0") + ".txt";
-    let filePath = (0, import_path2.join)(dir, filename);
-    await import_fs2.promises.writeFile(filePath, img);
-    const saveImg2 = await Img.create({ tag_id: tag.get("id"), img_url: filePath, createtime: now });
-    logger.info("[saveImg Info]: save image to '" + name2 + "' success");
+    existed.set("alias", now_alias);
+    await existed.save();
     return { result: true, error: null };
   } catch (e) {
-    logger.error("[saveImg Error]: " + e?.message || String(e));
+    logger.error("[checkAlias Error]: " + e?.message || String(e));
     return { result: false, error: e?.message || String(e) };
   }
 }
-__name(saveImg, "saveImg");
-async function randomImgByTag(name2, savePath2) {
+__name(checkAlias, "checkAlias");
+async function getTagList(guild_id) {
   try {
-    const Img = getImgsModel();
-    const existed = await getTag(name2);
-    if (!existed) {
-      throw new Error(`not found tag '${name2}'!`);
-    }
-    if (existed.status == 0) {
-      throw new Error(`not found tag '${name2}'!`);
-    }
-    let ImgList = await Img.findAll({
-      where: {
-        status: 0,
-        tag_id: existed.get("id")
-      }
+    const Tag = getTagsModel();
+    let resultList = await Tag.findAll({
+      where: { status: 0, guild_id }
     });
-    if (ImgList.length <= 0) {
-      throw new Error("Don't have image!");
+    let tagList = [];
+    for (const element of resultList) {
+      let count = await getImgCountByTag(element.get("id"));
+      tagList.push({
+        tag: element.get("tags"),
+        alias: element.get("alias"),
+        count
+      });
     }
-    const random = new import_koishi2.Random(() => Math.random());
-    let result = ImgList[random.int(0, ImgList.length)];
-    const filePath = result.get("img_url");
-    const fileContent = await import_fs2.promises.readFile(filePath, { encoding: "utf-8" });
-    return fileContent;
+    ;
+    return tagList.sort((a, b) => b.count - a.count);
   } catch (e) {
-    logger.error("[randomImgByTag Error]: " + e?.message || String(e));
+    logger.error("[getTagList Error]: " + e?.message || String(e));
     return null;
   }
 }
-__name(randomImgByTag, "randomImgByTag");
+__name(getTagList, "getTagList");
 
-// src/index.ts
-var name = "cocoyyy-console";
-var Config = import_koishi3.Schema.object({
-  mysql: MysqlConfigSchema.description("MySQL 数据库配置"),
-  save: SaveConfigSchema.description("图片保存配置")
-});
-var menuList = [
-  {
-    name: "maketag",
-    description: "创建一个标签",
-    command: "maketag [标签]"
-  },
-  {
-    name: "add",
-    description: "给标签添加图片",
-    command: "add [标签] [图片]"
-  },
-  {
-    name: "get",
-    description: "给标签添加图片",
-    command: "get [标签]"
-  }
-];
-var logger = new import_koishi3.Logger(name);
-var savePath = null;
-async function apply(ctx, config) {
-  const mysqlConf = config?.mysql ?? loadMysqlConfigFromEnv();
-  initSequelize(mysqlConf);
-  const connected = await testConnect();
-  if (connected) {
-    await getTagsModel().sync();
-    await getImgsModel().sync();
-  }
-  savePath = resolveTagBaseDir(config?.save);
-  ctx.command("fullhelp", "帮助菜单").check(({ session }) => {
-    if (!connected) return;
-    if (!is_at_bot(session)) return;
-  }).action(async ({ session }) => {
-    return `帮助菜单[所有命令都需要@bot]:
-	${menuList.map((item) => item.command + ": " + item.description).join("\n	")}`;
-  });
+// src/services/tag_func/tag_commands.ts
+var import_url = require("url");
+function registerTagCommands(ctx, connected, savePath2) {
   ctx.command("maketag <参数>", "创建一个标签").check(({ session }) => {
     if (!connected) return;
     if (!is_at_bot(session)) return;
   }).action(async ({ session }, ...args) => {
     const tag = args?.[0];
     if (!tag) return "请提供正确格式，如：@bot maketag [标签]";
-    let exec = await createorUpdateTag(tag, null, savePath);
+    let exec = await createorUpdateTag(tag, session.guildId, savePath2);
     if (!exec.result)
       return `创建标签失败：${exec.error}`;
     return `已创建标签：${tag}`;
@@ -443,7 +637,7 @@ async function apply(ctx, config) {
     const tag = args?.[0];
     const img = args?.[1];
     if (!tag || !img) return "请提供正确格式，如：@bot add [标签] [图片]";
-    let exec = await saveImg(tag, img, savePath);
+    let exec = await saveImg(ctx, tag, session.guildId, img, savePath2);
     if (!exec.result)
       return `保存图片失败：${exec.error}`;
     return "保存图片成功";
@@ -454,12 +648,169 @@ async function apply(ctx, config) {
   }).action(async ({ session }, ...args) => {
     const tag = args?.[0];
     if (!tag) return "请提供正确格式，如：@bot get [标签]";
-    let exec = await randomImgByTag(tag, savePath);
+    let exec = await randomImgByTag(tag, session.guildId);
     if (!exec)
       return `获取图片失败`;
-    return exec;
+    let path = (0, import_url.pathToFileURL)(exec).href;
+    return import_koishi7.h.image(path);
+  });
+  ctx.command("bind <参数>", "标签绑定别名").check(({ session }) => {
+    if (!connected) return;
+    if (!is_at_bot(session)) return;
+  }).action(async ({ session }, ...args) => {
+    const tag = args?.[0];
+    const alia = args?.[1];
+    if (!tag || !alia) return "请提供正确格式，如：@bot bind [标签] [别名]";
+    let exec = await bindAlias(tag, session.guildId, alia);
+    if (!exec.result)
+      return `绑定别名失败：${exec.error}`;
+    return `绑定别名成功`;
+  });
+  ctx.command("unbind <参数>", "标签取消别名").check(({ session }) => {
+    if (!connected) return;
+    if (!is_at_bot(session)) return;
+  }).action(async ({ session }, ...args) => {
+    const tag = args?.[0];
+    const alia = args?.[1];
+    if (!tag || !alia) return "请提供正确格式，如：@bot unbind [标签] [别名]";
+    let exec = await unbindAlias(tag, session.guildId, alia);
+    if (!exec.result)
+      return `取消绑定失败：${exec.error}`;
+    return `取消绑定成功`;
+  });
+  ctx.command("taglist", "获取标签列表").check(({ session }) => {
+    if (!connected) return;
+    if (!is_at_bot(session)) return;
+  }).action(async ({ session }, ...args) => {
+    let exec = await getTagList(session.guildId);
+    if (exec == null)
+      return `查询失败`;
+    return `查询成功!
+${exec.map((item) => "标签:" + item.tag + "	黑历史数:" + item.count + "\n别名:" + (item.alias ? item.alias : "无")).join("\n\n")}`;
+  });
+}
+__name(registerTagCommands, "registerTagCommands");
+
+// src/services/repeat_func/repeat_service.ts
+function registerRepeatMiddleware(ctx, config) {
+  const states = {};
+  const minTimes = config?.minTimes ?? 3;
+  const probability = config?.probability ?? 1;
+  const guild_ids = config?.guild_ids?.split(",") ?? [];
+  const resetInterval = config?.resetInterval ?? 300;
+  function getState(id) {
+    if (!states[id]) {
+      states[id] = {
+        content: "",
+        repeated: false,
+        times: 0,
+        users: {}
+      };
+    }
+    return states[id];
+  }
+  __name(getState, "getState");
+  function resetState(id) {
+    const state = getState(id);
+    state.content = "";
+    state.repeated = false;
+    state.times = 0;
+    state.users = {};
+  }
+  __name(resetState, "resetState");
+  ctx.before("send", ({ cid, content }) => {
+    const state = getState(cid);
+    state.repeated = true;
+    if (state.content === content) {
+      state.times += 1;
+    } else {
+      state.content = content;
+      state.times = 1;
+      state.users = {};
+    }
+  });
+  ctx.middleware((session, next) => {
+    const { content, uid, userId } = session;
+    const cid = session.cid;
+    if (guild_ids.includes(session.guildId)) return next();
+    if (ctx.bots[uid]) return next();
+    const state = getState(cid);
+    if (state.timer) clearTimeout(state.timer);
+    state.timer = setTimeout(() => resetState(cid), resetInterval * 1e3);
+    if (content === state.content) {
+      state.times += 1;
+      state.users[userId] = (state.users[userId] || 0) + 1;
+      const uniqueUsers = Object.keys(state.users).length;
+      if (!state.repeated && state.times >= minTimes && uniqueUsers >= 2 && Math.random() < probability) {
+        state.repeated = true;
+        return next(content);
+      }
+      return next();
+    }
+    state.content = content;
+    state.repeated = false;
+    state.times = 1;
+    state.users = { [userId]: 1 };
+    return next();
+  });
+}
+__name(registerRepeatMiddleware, "registerRepeatMiddleware");
+
+// src/services/rbq_func/rbq_service.ts
+var import_koishi8 = require("koishi");
+function registerRbqMiddleware(ctx, config) {
+  if (!config?.configList || config.configList.length === 0) return;
+  ctx.middleware((session, next) => {
+    const { guildId, elements } = session;
+    if (ctx.bots[session.uid]) return next();
+    if (!config.configList.some((item) => item.guild_id === guildId)) return next();
+    const atElements = elements?.filter((el) => el.type === "at") || [];
+    if (atElements.length === 0) return next();
+    const matched = config.configList.find((item) => {
+      const targetUid = item.uid?.trim();
+      if (!targetUid) return false;
+      const isAtTarget = atElements.some((el) => el.attrs?.id === targetUid);
+      if (!isAtTarget) return false;
+      const probability = item.probability ?? 1;
+      return Math.random() <= probability;
+    });
+    if (!matched) return next();
+    const content = matched.content || "*死你";
+    session.send((0, import_koishi8.h)("at", { id: matched.uid.trim() }) + " " + content);
+    return;
   });
 }
+__name(registerRbqMiddleware, "registerRbqMiddleware");
+
+// src/index.ts
+var name = "cocoyyy-console";
+var Config = import_koishi9.Schema.object({
+  function_config: FunctionConfigSchema.description("功能开关配置"),
+  mysql_config: MysqlConfigSchema.description("MySQL 数据库配置"),
+  tag_config: SaveConfigSchema.description("tag图片保存配置"),
+  repeat_config: RepeatConfigSchema.description("复读配置"),
+  rbq_config: RbqConfigSchema.description("*人配置")
+});
+var logger = new import_koishi9.Logger(name);
+var savePath = null;
+async function apply(ctx, config) {
+  ctx = ctx.guild();
+  const mysqlConf = config?.mysql_config ?? loadMysqlConfigFromEnv();
+  initSequelize(mysqlConf);
+  const connected = await testConnect();
+  if (connected) {
+    await getTagsModel().sync();
+    await getImgsModel().sync();
+  }
+  savePath = resolveTagBaseDir(config?.tag_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.rbq_flag)
+    registerRbqMiddleware(ctx, config?.rbq_config);
+}
 __name(apply, "apply");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/models/tags.d.ts

@@ -3,14 +3,16 @@ export interface TagAttributes {
     id: number;
     tags: string;
     alias: string | null;
+    guild_id: string | null;
     status: number | null;
     createtime: Date;
 }
-export type TagCreationAttributes = Optional<TagAttributes, 'id' | 'alias' | 'status' | 'createtime'>;
+export type TagCreationAttributes = Optional<TagAttributes, 'id' | 'alias' | 'guild_id' | 'status' | 'createtime'>;
 export declare class TagsModel extends Model<TagAttributes, TagCreationAttributes> implements TagAttributes {
     id: number;
     tags: string;
     alias: string | null;
+    guild_id: string | null;
     status: number | null;
     createtime: Date;
 }

package/lib/services/img_service.d.ts

@@ -1,6 +1,8 @@
-declare function saveImg(name: string, img: string, savePath: string): Promise<{
+import { Context } from "koishi";
+declare function saveImg(ctx: Context, tag_name: string, imgurl: string, savePath: string): Promise<{
     result: boolean;
     error: string | null;
 }>;
-declare function randomImgByTag(name: string, savePath: string): Promise<string | null>;
-export { saveImg, randomImgByTag };
+declare function randomImgByTag(tag_name: string): Promise<string | null>;
+declare function getImgCountByTag(tag_id: number): Promise<number>;
+export { saveImg, randomImgByTag, getImgCountByTag };

package/lib/services/menu_service.d.ts

@@ -0,0 +1,5 @@
+import { Context } from 'koishi';
+import * as my_config from '../utils/config';
+declare function getMenuList(command: string, functionConfig: my_config.FunctionConfig): string;
+declare function registerMenuCommands(ctx: Context, connected: boolean, functionConfig: my_config.FunctionConfig): void;
+export { getMenuList, registerMenuCommands };

package/lib/services/rbq_func/rbq_service.d.ts

@@ -0,0 +1,4 @@
+import { Context } from 'koishi';
+import { RbqConfig } from '../../utils/config';
+declare function registerRbqMiddleware(ctx: Context, config?: RbqConfig): void;
+export { registerRbqMiddleware, };

package/lib/services/repeat_func/repeat_service.d.ts

@@ -0,0 +1,12 @@
+import { Context, Dict, Session } from 'koishi';
+import { RepeatConfig } from '../../utils/config';
+interface RepeatState {
+    content: string;
+    repeated: boolean;
+    times: number;
+    users: Dict<number>;
+    timer?: NodeJS.Timeout;
+}
+type StateCallback = (state: RepeatState, session: Session) => void | string;
+declare function registerRepeatMiddleware(ctx: Context, config?: RepeatConfig): void;
+export { registerRepeatMiddleware, RepeatState, StateCallback };

package/lib/services/repeat_func/repeat_temp.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/services/tag_func/img_service.d.ts

@@ -0,0 +1,8 @@
+import { Context } from "koishi";
+declare function saveImg(ctx: Context, tag_name: string, guild_id: string, imgurl: string, savePath: string): Promise<{
+    result: boolean;
+    error: string | null;
+}>;
+declare function randomImgByTag(tag_name: string, guild_id: string): Promise<string | null>;
+declare function getImgCountByTag(tag_id: number): Promise<number>;
+export { saveImg, randomImgByTag, getImgCountByTag };

package/lib/services/tag_func/tag_commands.d.ts

@@ -0,0 +1,3 @@
+import { Context } from 'koishi';
+declare function registerTagCommands(ctx: Context, connected: boolean, savePath: string | null): void;
+export { registerTagCommands };

package/lib/services/tag_func/tag_service.d.ts

@@ -0,0 +1,20 @@
+import { TagsModel } from '../../models/tags';
+declare function createorUpdateTag(tag_name: string, guild_id: string, savePath?: string | null): Promise<{
+    result: boolean;
+    error: string | null;
+}>;
+declare function getTag(tag_name: string, guild_id: string): Promise<TagsModel | null>;
+declare function bindAlias(tag_name: string, guild_id: string, alias: string): Promise<{
+    result: boolean;
+    error: string | null;
+}>;
+declare function unbindAlias(tag_name: string, guild_id: string, alias: string): Promise<{
+    result: boolean;
+    error: string | null;
+}>;
+declare function getTagList(guild_id: string): Promise<{
+    tag: string;
+    alias: string;
+    count: number;
+}[]>;
+export { createorUpdateTag, getTag, bindAlias, unbindAlias, getTagList };

package/lib/services/tag_service.d.ts

@@ -1,7 +1,20 @@
 import { TagsModel } from '../models/tags';
-declare function createorUpdateTag(name: string, alias?: string | null, savePath?: string | null): Promise<{
+declare function createorUpdateTag(tag_name: string, savePath?: string | null): Promise<{
     result: boolean;
     error: string | null;
 }>;
-declare function getTag(name: string): Promise<TagsModel | null>;
-export { createorUpdateTag, getTag };
+declare function getTag(tag_name: string): Promise<TagsModel | null>;
+declare function bindAlias(tag_name: string, alias: string): Promise<{
+    result: boolean;
+    error: string | null;
+}>;
+declare function unbindAlias(tag_name: string, alias: string): Promise<{
+    result: boolean;
+    error: string | null;
+}>;
+declare function getTagList(): Promise<{
+    tag: string;
+    alias: string;
+    count: number;
+}[]>;
+export { createorUpdateTag, getTag, bindAlias, unbindAlias, getTagList };

package/lib/utils/config.d.ts

@@ -1,17 +1,5 @@
-import { Schema } from 'koishi';
-interface MysqlConfig {
-    host: string;
-    port: number;
-    user: string;
-    password: string;
-    database: string;
-}
-declare const MysqlConfigSchema: Schema<MysqlConfig>;
-declare function loadMysqlConfigFromEnv(env?: NodeJS.ProcessEnv): MysqlConfig;
-declare function toMysqlUri(cfg: MysqlConfig): string;
-interface SaveConfig {
-    save_path: string;
-}
-declare const SaveConfigSchema: Schema<SaveConfig>;
-declare function resolveTagBaseDir(config?: SaveConfig): string;
-export { MysqlConfigSchema, SaveConfigSchema, MysqlConfig, SaveConfig, loadMysqlConfigFromEnv, toMysqlUri, resolveTagBaseDir };
+export * from './configs/function_config';
+export * from './configs/mysql_config';
+export * from './configs/tag_config';
+export * from './configs/repeat_config';
+export * from './configs/rbq_config';

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

@@ -0,0 +1,8 @@
+import { Schema } from 'koishi';
+interface FunctionConfig {
+    tag_flag: boolean;
+    repeat_flag: boolean;
+    rbq_flag: boolean;
+}
+declare const FunctionConfigSchema: Schema<FunctionConfig>;
+export { FunctionConfig, FunctionConfigSchema, };

package/lib/utils/configs/mysql_config.d.ts

@@ -0,0 +1,12 @@
+import { Schema } from 'koishi';
+interface MysqlConfig {
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database: string;
+}
+declare const MysqlConfigSchema: Schema<MysqlConfig>;
+declare function loadMysqlConfigFromEnv(env?: NodeJS.ProcessEnv): MysqlConfig;
+declare function toMysqlUri(cfg: MysqlConfig): string;
+export { MysqlConfig, MysqlConfigSchema, loadMysqlConfigFromEnv, toMysqlUri, };

package/lib/utils/configs/rbq_config.d.ts

@@ -0,0 +1,12 @@
+import { Schema } from 'koishi';
+interface RbqConfigItem {
+    probability?: number;
+    guild_id?: string;
+    uid?: string;
+    content?: string;
+}
+interface RbqConfig {
+    configList?: RbqConfigItem[];
+}
+declare const RbqConfigSchema: Schema<RbqConfig>;
+export { RbqConfig, RbqConfigSchema, };

package/lib/utils/configs/repeat_config.d.ts

@@ -0,0 +1,9 @@
+import { Schema } from 'koishi';
+interface RepeatConfig {
+    minTimes?: number;
+    probability?: number;
+    guild_ids?: string;
+    resetInterval?: number;
+}
+declare const RepeatConfigSchema: Schema<RepeatConfig>;
+export { RepeatConfig, RepeatConfigSchema, };

package/lib/utils/configs/tag_config.d.ts

@@ -0,0 +1,7 @@
+import { Schema } from 'koishi';
+interface SaveConfig {
+    save_path: string;
+}
+declare const SaveConfigSchema: Schema<SaveConfig>;
+declare function resolveTagBaseDir(config?: SaveConfig): string;
+export { SaveConfig, SaveConfigSchema, resolveTagBaseDir, };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-cocoyyy-console",
   "description": "for self using, function console",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "contributors": [