koishi-plugin-cocoyyy-console 1.0.2 → 1.0.4

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,
@@ -225,20 +261,143 @@ function getImgsModel() {
 }
 __name(getImgsModel, "getImgsModel");
 
-// src/services/tag_service.ts
+// src/utils/common.ts
+function is_at_bot(session) {
+  const elements = Array.isArray(session?.elements) ? session.elements : [];
+  const atElement = elements.find((element) => element?.type === "at");
+  const atId = atElement?.attrs?.id;
+  const selfId = session?.bot?.selfId ?? session?.selfId;
+  if (atId == null || selfId == null) return false;
+  return String(atId) === String(selfId);
+}
+__name(is_at_bot, "is_at_bot");
+
+// 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_fs2 = require("fs");
 var import_path2 = require("path");
 
-// src/services/img_service.ts
-var import_koishi2 = require("koishi");
+// src/services/tag_func/img_service.ts
+var import_koishi6 = require("koishi");
 var import_path = require("path");
 var import_fs = require("fs");
-async function saveImg(tag_name, img, savePath2) {
+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();
-    logger.info("[saveImg Info]: " + img);
-    let tag = await getTag(tag_name);
+    let tag = await getTag(tag_name, guild_id);
     if (tag == null) {
       throw new Error(`not found tag '${tag_name}'!`);
     }
@@ -251,9 +410,19 @@ async function saveImg(tag_name, img, savePath2) {
     }
     let dir = (0, import_path.join)(savePath2, String(tag.get("id")));
     const now = new Date(Date.now() + 8 * 60 * 60 * 1e3);
-    const filetag_name = 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_path.join)(dir, filetag_name);
-    await import_fs.promises.writeFile(filePath, img);
+    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 };
@@ -263,10 +432,10 @@ async function saveImg(tag_name, img, savePath2) {
   }
 }
 __name(saveImg, "saveImg");
-async function randomImgByTag(tag_name) {
+async function randomImgByTag(tag_name, guild_id) {
   try {
     const Img = getImgsModel();
-    const existed = await getTag(tag_name);
+    const existed = await getTag(tag_name, guild_id);
     if (!existed) {
       throw new Error(`not found tag '${tag_name}'!`);
     }
@@ -282,11 +451,10 @@ async function randomImgByTag(tag_name) {
     if (ImgList.length <= 0) {
       throw new Error("Don't have image!");
     }
-    const random = new import_koishi2.Random(() => Math.random());
+    const random = new import_koishi6.Random(() => Math.random());
     let result = ImgList[random.int(0, ImgList.length)];
     const filePath = result.get("img_url");
-    const fileContent = await import_fs.promises.readFile(filePath, { encoding: "utf-8" });
-    return fileContent;
+    return filePath;
   } catch (e) {
     logger.error("[randomImgByTag Error]: " + e?.message || String(e));
     return null;
@@ -302,12 +470,13 @@ async function getImgCountByTag(tag_id) {
 }
 __name(getImgCountByTag, "getImgCountByTag");
 
-// src/services/tag_service.ts
-async function findTagByName(tag_name) {
+// 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: tag_name },
         { alias: { [import_sequelize4.Op.like]: `%${tag_name}%` } }
@@ -316,11 +485,12 @@ async function findTagByName(tag_name) {
   });
 }
 __name(findTagByName, "findTagByName");
-async function findDeletedTagByName(tag_name) {
+async function findDeletedTagByName(tag_name, guild_id) {
   const Tag = getTagsModel();
   return await Tag.findOne({
     where: {
       status: 1,
+      guild_id,
       [import_sequelize4.Op.or]: [
         { tags: tag_name },
         { alias: { [import_sequelize4.Op.like]: `%${tag_name}%` } }
@@ -329,14 +499,14 @@ async function findDeletedTagByName(tag_name) {
   });
 }
 __name(findDeletedTagByName, "findDeletedTagByName");
-async function createorUpdateTag(tag_name, savePath2) {
+async function createorUpdateTag(tag_name, guild_id, savePath2) {
   try {
     const Tag = getTagsModel();
-    let existed = await findTagByName(tag_name);
+    let existed = await findTagByName(tag_name, guild_id);
     if (existed) {
       throw new Error("already existed!");
     }
-    existed = await findDeletedTagByName(tag_name);
+    existed = await findDeletedTagByName(tag_name, guild_id);
     if (existed) {
       if (existed.get("status") != 0) {
         existed.set("status", 0);
@@ -349,7 +519,7 @@ async function createorUpdateTag(tag_name, savePath2) {
       throw new Error("saving path config wrong!");
     }
     const now = new Date(Date.now() + 8 * 60 * 60 * 1e3);
-    const tag = await Tag.create({ tags: tag_name, alias: null, createtime: now });
+    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 };
@@ -359,9 +529,9 @@ async function createorUpdateTag(tag_name, savePath2) {
   }
 }
 __name(createorUpdateTag, "createorUpdateTag");
-async function getTag(tag_name) {
+async function getTag(tag_name, guild_id) {
   try {
-    let tag = await findTagByName(tag_name);
+    let tag = await findTagByName(tag_name, guild_id);
     return tag;
   } catch (e) {
     logger.error("[getTag Error]: " + e?.message || String(e));
@@ -369,27 +539,27 @@ async function getTag(tag_name) {
   }
 }
 __name(getTag, "getTag");
-async function bindAlias(tag_name, alias) {
+async function bindAlias(tag_name, guild_id, alias) {
   try {
-    return await checkAlias(tag_name, alias, false);
+    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, alias) {
+async function unbindAlias(tag_name, guild_id, alias) {
   try {
-    return await checkAlias(tag_name, alias, true);
+    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, isDelete = false) {
+async function checkAlias(tag_name, alias, guild_id, isDelete = false) {
   try {
-    let existed = await findTagByName(tag_name);
+    let existed = await findTagByName(tag_name, guild_id);
     if (existed == null) {
       throw new Error(`not found tag '${tag_name}'`);
     }
@@ -422,22 +592,23 @@ async function checkAlias(tag_name, alias, isDelete = false) {
   }
 }
 __name(checkAlias, "checkAlias");
-async function getTagList() {
+async function getTagList(guild_id) {
   try {
     const Tag = getTagsModel();
     let resultList = await Tag.findAll({
-      where: { status: 0 }
+      where: { status: 0, guild_id }
     });
     let tagList = [];
-    resultList.forEach(async (element) => {
+    for (const element of resultList) {
       let count = await getImgCountByTag(element.get("id"));
       tagList.push({
         tag: element.get("tags"),
         alias: element.get("alias"),
         count
       });
-    });
-    return tagList;
+    }
+    ;
+    return tagList.sort((a, b) => b.count - a.count);
   } catch (e) {
     logger.error("[getTagList Error]: " + e?.message || String(e));
     return null;
@@ -445,111 +616,201 @@ async function getTagList() {
 }
 __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 [标签]"
-  },
-  {
-    name: "bind",
-    description: "标签绑定别名",
-    command: "bind [标签] [别名]"
-  },
-  {
-    name: "unbind",
-    description: "标签取消别名",
-    command: "unbind [标签] [别名]"
-  },
-  {
-    name: "taglist",
-    description: "获取标签列表",
-    command: "taglist"
-  }
-];
-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", "帮助菜单").action(async ({ session }) => {
-    return `帮助菜单[所有命令都需要@bot]:
-	${menuList.map((item) => item.command + ": " + item.description).join("\n	")}`;
-  });
-  ctx.command("maketag <参数>", "创建一个标签").action(async ({ session }, ...args) => {
+// 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, savePath);
+    let exec = await createorUpdateTag(tag, session.guildId, savePath2);
     if (!exec.result)
       return `创建标签失败：${exec.error}`;
     return `已创建标签：${tag}`;
   });
-  ctx.command("add <参数>", "给标签添加图片").action(async ({ session }, ...args) => {
+  ctx.command("add <参数>", "给标签添加图片").check(({ session }) => {
+    if (!connected) return;
+    if (!is_at_bot(session)) return;
+  }).action(async ({ session }, ...args) => {
     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 "保存图片成功";
   });
-  ctx.command("get <参数>", "获取标签对应图片").action(async ({ session }, ...args) => {
+  ctx.command("get <参数>", "获取标签对应图片").check(({ session }) => {
+    if (!connected) return;
+    if (!is_at_bot(session)) return;
+  }).action(async ({ session }, ...args) => {
     const tag = args?.[0];
     if (!tag) return "请提供正确格式，如：@bot get [标签]";
-    let exec = await randomImgByTag(tag);
+    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 <参数>", "标签绑定别名").action(async ({ session }, ...args) => {
+  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, alia);
+    let exec = await bindAlias(tag, session.guildId, alia);
     if (!exec.result)
       return `绑定别名失败：${exec.error}`;
     return `绑定别名成功`;
   });
-  ctx.command("unbind <参数>", "标签取消别名").action(async ({ session }, ...args) => {
+  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, alia);
+    let exec = await unbindAlias(tag, session.guildId, alia);
     if (!exec.result)
       return `取消绑定失败：${exec.error}`;
     return `取消绑定成功`;
   });
-  ctx.command("taglist", "获取标签列表").action(async ({ session }, ...args) => {
-    let exec = await getTagList();
+  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");
 
-      ${exec.map((item) => "标签:" + item.tag + "	黑历史数:" + item.count + "\n别名:" + item.alias).join("\n")}`;
+// 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,4 +1,5 @@
-declare function saveImg(tag_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;
 }>;

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/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.2",
+  "version": "1.0.4",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "contributors": [