koishi-plugin-cocoyyy-console 1.0.16-beta.1 → 1.0.16-beta.10

package/lib/index.d.ts

@@ -8,6 +8,8 @@ export interface Config {
     mysql_config?: my_config.MysqlConfig;
     tag_config?: my_config.SaveConfig;
     repeat_config?: my_config.RepeatConfig;
+    son_config?: my_config.ShitOrNotConfig;
+    test?: string;
 }
 export declare const Config: Schema<Config>;
 export declare let logger: Logger;

package/lib/index.js

@@ -38,7 +38,7 @@ __export(src_exports, {
   savePath: () => savePath
 });
 module.exports = __toCommonJS(src_exports);
-var import_koishi9 = require("koishi");
+var import_koishi10 = require("koishi");
 
 // src/utils/configs/function_config.ts
 var import_koishi = require("koishi");
@@ -47,6 +47,7 @@ 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("*人功能是否启用"),
+  son_flag: import_koishi.Schema.boolean().default(true).description("鉴别史消息功能是否启用"),
   kuro_flag: import_koishi.Schema.boolean().default(true).description("鸣潮功能是否启用")
 });
 
@@ -86,6 +87,15 @@ var RedisConfigSchema = import_koishi5.Schema.object({
   redis_url: import_koishi5.Schema.string().default("127.0.0.1:6379").description("Redis连接字符串")
 });
 
+// src/utils/configs/son_config.ts
+var import_koishi6 = require("koishi");
+var ShitOrNotConfigSchema = import_koishi6.Schema.object({
+  api_url: import_koishi6.Schema.string().default("").description("Api接口Url"),
+  api_model: import_koishi6.Schema.string().default("").description("AI模型"),
+  api_key: import_koishi6.Schema.string().default("").description("API Key"),
+  config_path: import_koishi6.Schema.string().default("").description("配置文件路径")
+});
+
 // src/infra/mysql_init.ts
 var import_sequelize = require("sequelize");
 var sequelize = null;
@@ -313,6 +323,10 @@ function getMenuList(command = null, functionConfig) {
       if (!functionConfig.rbq_flag)
         return "*人功能已关闭";
       return getRbqFuncMenu(command);
+    case "son":
+      if (!functionConfig.son_flag)
+        return "son功能已关闭";
+      return getSonFuncMenu(command);
     case "kuro":
       if (!functionConfig.kuro_flag)
         return "库洛相关功能已关闭";
@@ -321,7 +335,7 @@ function getMenuList(command = null, functionConfig) {
       return `[所有命令都需要@bot]
 当前可用功能列表:
 	${menuList.map((item) => item.name + ": " + item.description).join("\n	")}
-输入"help 功能名"查看特定功能的指令和使用示例。`;
+输入"help [功能名]"查看特定功能的指令和使用示例。`;
   }
 }
 __name(getMenuList, "getMenuList");
@@ -403,6 +417,25 @@ function getRbqFuncMenu(command = null) {
 输入对应指令使用*人功能，如果遇到问题请联系开发人员。`;
 }
 __name(getRbqFuncMenu, "getRbqFuncMenu");
+var sonFuncMenuList = [
+  {
+    name: "sonlist",
+    description: "查看son判断模式列表",
+    command: "sonlist"
+  },
+  {
+    name: "son",
+    description: "判断是否为史",
+    command: "son [判断模式]"
+  }
+];
+function getSonFuncMenu(command = null) {
+  return `[所有命令都需要@bot]
+son功能菜单:
+	${sonFuncMenuList.map((item) => item.command + ": " + item.description).join("\n	")}
+输入对应指令使用son功能，如果遇到问题请联系开发人员。`;
+}
+__name(getSonFuncMenu, "getSonFuncMenu");
 var kuroFuncMenuList = [
   {
     name: "login",
@@ -435,7 +468,7 @@ function registerMenuCommands(ctx, connected, functionConfig) {
 __name(registerMenuCommands, "registerMenuCommands");
 
 // src/services/tag_func/tag_commands.ts
-var import_koishi7 = require("koishi");
+var import_koishi8 = require("koishi");
 
 // src/services/tag_func/tag_service.ts
 var import_sequelize4 = require("sequelize");
@@ -443,7 +476,7 @@ var import_fs2 = require("fs");
 var import_path2 = require("path");
 
 // src/services/tag_func/img_service.ts
-var import_koishi6 = require("koishi");
+var import_koishi7 = require("koishi");
 var import_path = require("path");
 var import_fs = require("fs");
 async function loadImageFromUrl(ctx, url) {
@@ -518,7 +551,7 @@ async function randomImgByTag(tag_name, guild_id) {
     if (ImgList.length <= 0) {
       throw new Error("Don't have image!");
     }
-    const random = new import_koishi6.Random(() => Math.random());
+    const random = new import_koishi7.Random(() => Math.random());
     let result = ImgList[random.int(0, ImgList.length)];
     const filePath = result.get("img_url");
     return filePath;
@@ -762,8 +795,8 @@ function registerTagCommands(ctx, connected, savePath2) {
     let exec = await randomImgByTag(tag, session.guildId);
     if (!exec)
       return `获取图片失败`;
-    let path = (0, import_url.pathToFileURL)(exec).href;
-    return import_koishi7.h.image(path);
+    let path2 = (0, import_url.pathToFileURL)(exec).href;
+    return import_koishi8.h.image(path2);
   });
   ctx.command("bind <参数>", "标签绑定别名").action(async ({ session }, ...args) => {
     if (!dev_mode) {
@@ -906,7 +939,7 @@ function registerRepeatMiddleware(ctx, config) {
 __name(registerRepeatMiddleware, "registerRepeatMiddleware");
 
 // src/services/rbq_func/rbq_command.ts
-var import_koishi8 = require("koishi");
+var import_koishi9 = require("koishi");
 
 // src/models/rbq_persons.ts
 var import_sequelize5 = require("sequelize");
@@ -1231,7 +1264,7 @@ function registerRbqCommands(ctx, connected) {
     if (!list || list.length === 0) {
       return "当前群聊还没有设置任何rbq";
     }
-    return "当前群聊rbq列表:\n" + list.map((item) => (0, import_koishi8.h)("at", { id: item })).join(",");
+    return "当前群聊rbq列表:\n" + list.map((item) => (0, import_koishi9.h)("at", { id: item })).join(",");
   });
   ctx.command("rbqadd <参数>", "添加rbq").action(async ({ session }, ...args) => {
     if (!dev_mode) {
@@ -1249,7 +1282,7 @@ function registerRbqCommands(ctx, connected) {
     exec = await create_person(session.guildId, uid);
     if (!exec.result)
       return `添加rbq失败: ${exec.error}`;
-    return "已添加rbq:" + (0, import_koishi8.h)("at", { id: uid });
+    return "已添加rbq:" + (0, import_koishi9.h)("at", { id: uid });
   });
   ctx.command("rbqinstead <参数>", "替换rbq").action(async ({ session }, ...args) => {
     if (!dev_mode) {
@@ -1274,12 +1307,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_koishi8.h)("at", { id: source_uid }) + " -> " + (0, import_koishi8.h)("at", { id: new_target });
+      return "倒反天罡！进去吧你，已替换rbq：\n" + (0, import_koishi9.h)("at", { id: source_uid }) + " -> " + (0, import_koishi9.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_koishi8.h)("p", "已替换rbq：", (0, import_koishi8.h)("at", { id: source_uid }), " -> ", (0, import_koishi8.h)("at", { id: target_uid }));
+    return (0, import_koishi9.h)("p", "已替换rbq：", (0, import_koishi9.h)("at", { id: source_uid }), " -> ", (0, import_koishi9.h)("at", { id: target_uid }));
   });
   ctx.command("rbqadd_txt <参数>", "添加自定义文本").action(async ({ session }, ...args) => {
     if (!dev_mode) {
@@ -1306,10 +1339,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_koishi8.Random(() => Math.random());
+          const random = new import_koishi9.Random(() => Math.random());
           content2 = contents[random.int(0, contents.length)];
         }
-        return (0, import_koishi8.h)("at", { id: target_uid }) + "还想自己加文本？！\n" + content2;
+        return (0, import_koishi9.h)("at", { id: target_uid }) + "还想自己加文本？！\n" + content2;
       } catch (error) {
         logger.error("[rbq rbqadd_txt] Error:", error);
         return "不能给自己设置文本，请输入其他qq号";
@@ -1339,10 +1372,10 @@ function registerRbqCommands(ctx, connected) {
       const contents = await get_content_list(guildId, matchedUid);
       let content = "*死你";
       if (contents && contents.length > 0) {
-        const random = new import_koishi8.Random(() => Math.random());
+        const random = new import_koishi9.Random(() => Math.random());
         content = contents[random.int(0, contents.length)];
       }
-      return (0, import_koishi8.h)("at", { id: matchedUid }) + " " + content;
+      return (0, import_koishi9.h)("at", { id: matchedUid }) + " " + content;
     } catch (error) {
       logger.error("[rbq middleware] Error:", error);
       return next();
@@ -1352,19 +1385,232 @@ function registerRbqCommands(ctx, connected) {
 __name(registerRbqCommands, "registerRbqCommands");
 
 // src/services/test_command.ts
-function registerTestCommands(ctx) {
-  ctx.command("test <参数>", "test").action(async ({ session }, phoneNumber, code) => {
-    try {
-    } catch (err) {
-      console.error(err);
-      return `test error: ${err.message}`;
+var import_tesseract = require("tesseract.js");
+function registerTestCommands(ctx, config) {
+  ctx.command("test1 <prompt:text>", "调用 OpenRouter 模型进行测试").action(async ({ session }, prompt) => {
+    const apiKey = config?.test || process.env.OPENROUTER_API_KEY;
+    if (!apiKey) return "未配置 OpenRouter API Key（config.test 或环境变量 OPENROUTER_API_KEY）";
+    const content = prompt?.trim();
+    if (!content) return "请输入要测试的内容";
+  });
+  ctx.command("test <path>", "测试用").action(async ({ session }, path2) => {
+    const { content, uid, userId } = session;
+    if (session.quote) {
+      const quoteContent = session.quote.content;
+      const quoteUserId = session.quote.user.id;
+      logger.error(`command: quoteContent: ${quoteContent}, quoteUserId: ${quoteUserId},content: ${content} userId: ${userId}`);
+    } else {
+      logger.error(`command: content: ${content} userId: ${userId}`);
+    }
+  });
+  ctx.middleware((session, next) => {
+    const { content, uid, userId } = session;
+    const cid = session.cid;
+    if (session.guildId != "829263238") return next();
+    if (ctx.bots[uid]) return next();
+    if (session.quote) {
+      const quoteContent = session.quote.content;
+      const quoteUserId = session.quote.user.id;
+      logger.error(`quoteContent: ${quoteContent}, quoteUserId: ${quoteUserId},content: ${content} userId: ${userId}`);
+    } else {
+      logger.error(`content: ${content} userId: ${userId}`);
     }
   });
 }
 __name(registerTestCommands, "registerTestCommands");
 
-// src/services/kuro_func/kuro_service.ts
+// src/services/son_func/shit_or_not_command.ts
+var import_fs3 = require("fs");
+var yaml = __toESM(require("js-yaml"));
+var import_path3 = __toESM(require("path"));
+
+// src/services/son_func/shit_or_not_service.ts
+var import_tesseract2 = require("tesseract.js");
+
+// src/utils/ai_axios.ts
 var import_axios = __toESM(require("axios"));
+async function callOpenRouter(api_url, api_key, api_model = "gpt-4o-mini", messages) {
+  try {
+    const { data } = await import_axios.default.post(
+      api_url,
+      {
+        model: api_model,
+        messages
+      },
+      {
+        headers: {
+          Authorization: `Bearer ${api_key}`,
+          "Content-Type": "application/json"
+        }
+      }
+    );
+    const choices = data?.choices ?? [];
+    const reply = choices[0]?.message?.content;
+    let responseText;
+    let err = null;
+    if (typeof reply === "string") {
+      responseText = reply.trim();
+    } else if (Array.isArray(reply)) {
+      responseText = reply.map((part) => part?.text ?? "").join("").trim();
+      if (!responseText) {
+        err = "OpenRouter 返回空内容";
+      }
+    } else {
+      err = "OpenRouter 返回了未知格式，请检查日志";
+    }
+    return { err, resp: responseText };
+  } catch (error) {
+    const err = error;
+    const status = err.response?.status;
+    const detail = err.response?.data?.error || err.response?.data?.message || err.message;
+    logger.error("[callOpenRouter Error]: OpenRouter 请求失败", {
+      status,
+      detail,
+      url: err.config?.url,
+      payload: err.config?.data
+    });
+    const errorMessage = `test error${status ? `(${status})` : ""}: ${detail}`;
+    return { err: errorMessage, resp: null };
+  }
+}
+__name(callOpenRouter, "callOpenRouter");
+
+// src/services/son_func/shit_or_not_service.ts
+var chatHistory = [];
+function decodeHtmlEntities2(value) {
+  return value.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+}
+__name(decodeHtmlEntities2, "decodeHtmlEntities");
+function extractImageAndText(content) {
+  const imageUrls = [];
+  const imgTagRegex = /<img\b[^>]*>/gi;
+  const stripped = content.replace(imgTagRegex, (tag) => {
+    const srcMatch = tag.match(/src=["']([^"']+)["']/i);
+    if (srcMatch?.[1]) {
+      imageUrls.push(decodeHtmlEntities2(srcMatch[1]));
+    }
+    return " ";
+  });
+  const withoutTags = stripped.replace(/<[^>]+>/g, " ");
+  const text = withoutTags.replace(/\s+/g, " ").trim();
+  return { imageUrls, text };
+}
+__name(extractImageAndText, "extractImageAndText");
+async function checkShitOrNot(session, parttern_msg, config) {
+  chatHistory = [];
+  chatHistory.push({ role: "user", content: [{ type: "text", text: parttern_msg }] });
+  const { err, resp } = await callOpenRouter(config.api_url, config.api_key, config.api_model, chatHistory);
+  if (err != null) {
+    logger.error("[callOpenRouter Error 1]: " + err);
+    return null;
+  }
+  chatHistory.push({ role: "assistant", content: [{ type: "text", text: resp }] });
+  const quoteContent = session.quote.content;
+  const { imageUrls, text } = extractImageAndText(quoteContent);
+  if (!text && imageUrls.length === 0) {
+    logger.warn("[checkShitOrNot Warn]: 引用消息中未发现文本或图片");
+    return "引用消息中未发现文本或图片";
+  }
+  const targetContent = [
+    ...text ? [{ type: "text", text }] : [],
+    ...imageUrls.map((url) => ({ type: "image_url", image_url: { url } }))
+  ];
+  chatHistory.push({ role: "user", content: targetContent });
+  const { err: err2, resp: resp2 } = await callOpenRouter(config.api_url, config.api_key, config.api_model, chatHistory);
+  if (err2 != null) {
+    logger.error("[callOpenRouter Error 2]: " + err2);
+    return null;
+  }
+  return resp2;
+}
+__name(checkShitOrNot, "checkShitOrNot");
+
+// src/services/son_func/shit_or_not_command.ts
+var local_config = null;
+function loadYamlConfig(configPath) {
+  if (!configPath) {
+    logger.error("[loadYamlConfig Error]: SON 配置文件路径未配置");
+    return null;
+  }
+  try {
+    const trimmedPath = configPath.trim();
+    const fullPath = import_path3.default.isAbsolute(trimmedPath) ? trimmedPath : import_path3.default.resolve(process.cwd(), trimmedPath);
+    if (!(0, import_fs3.existsSync)(fullPath)) {
+      logger.error(`[loadYamlConfig Error]: SON 配置文件不存在: ${fullPath}`);
+      return null;
+    }
+    const fileContent = (0, import_fs3.readFileSync)(fullPath, "utf-8");
+    const config = yaml.load(fileContent);
+    return config;
+  } catch (error) {
+    logger.error(`[loadYamlConfig Error]: SON 读取配置文件失败: ${configPath}`, error);
+    return null;
+  }
+}
+__name(loadYamlConfig, "loadYamlConfig");
+function registerShitOrNotCommands(ctx, config) {
+  if (config?.config_path) {
+    local_config = loadYamlConfig(config.config_path);
+    if (local_config) {
+      logger.info("[loadYamlConfig Info]: SON 成功加载配置文件");
+    } else {
+      logger.error("[loadYamlConfig Error]: SON 配置文件加载失败，将使用默认配置");
+    }
+  } else {
+    logger.error("[loadYamlConfig Error]: 未配置 SON 配置文件路径");
+  }
+  ctx.command("sonlist <参数>", "查看son判断模式列表").action(async ({ session }) => {
+    if (!dev_mode) {
+      if (!is_at_bot(session)) return;
+    }
+    if (!local_config) return "未加载配置文件，请查看日志";
+    const mode_intro = local_config?.menu;
+    if (!mode_intro) return "未找到判断模式列表，请查看日志";
+    return `[所有命令都需要@bot]
+son判断模式列表:
+	${Object.keys(mode_intro).map((item) => item + ": " + mode_intro[item]).join("\n	")}`;
+  });
+  ctx.command("son <参数>", "判定是否为史").action(async ({ session }, ...args) => {
+    if (!dev_mode) {
+      if (!is_at_bot_quote(session)) return "请提供正确格式，如： [引用消息] @bot son [判断模式]";
+    } else {
+      if (!session.quote) return "请引用消息后使用功能";
+    }
+    const parttern = args?.[0];
+    if (!parttern) return "请提供正确判断模式，如： [引用消息] @bot son [判断模式]";
+    if (!local_config) return "未加载配置文件，请查看日志";
+    const parttern_msg = local_config.shit_or_not?.prompts[parttern];
+    if (!parttern_msg) return "未找到判断模式，请查看日志";
+    let exec = await checkShitOrNot(session, parttern_msg, config);
+    return exec;
+  });
+}
+__name(registerShitOrNotCommands, "registerShitOrNotCommands");
+function is_at_bot_quote(session) {
+  if (!session.quote)
+    return false;
+  const { content, userId } = session;
+  const quote = session.quote;
+  const quoteUserId = quote.user.id;
+  const quoteContent = quote.content;
+  const botId = session?.bot?.selfId ?? session?.selfId;
+  logger.info(`command: quoteContent: ${quoteContent}, quoteUserId: ${quoteUserId},content: ${content} userId: ${userId}`);
+  const elements = quote.elements || [];
+  logger.info("quote elements: ", { elements });
+  for (const elem of elements) {
+    if (elem.type === "at") {
+      const atId = elem.attrs.id;
+      if (String(atId) === String(botId)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+__name(is_at_bot_quote, "is_at_bot_quote");
+
+// src/services/kuro_func/kuro_service.ts
+var import_axios2 = __toESM(require("axios"));
 var import_qs = __toESM(require("qs"));
 
 // src/models/kuro_user.ts
@@ -1497,7 +1743,7 @@ var CONSTANTS = {
     "source": "ios"
   }
 };
-var wavesApi = import_axios.default.create();
+var wavesApi = import_axios2.default.create();
 wavesApi.interceptors.request.use(
   async (config) => {
     if (config.url.startsWith("/")) {
@@ -1774,14 +2020,16 @@ __name(registerKuroCommands, "registerKuroCommands");
 // src/index.ts
 var name = "cocoyyy-console";
 var dev_mode;
-var Config = import_koishi9.Schema.object({
+var Config = import_koishi10.Schema.object({
   function_config: FunctionConfigSchema.description("功能开关配置"),
   redis_config: RedisConfigSchema.description("Redis配置"),
   mysql_config: MysqlConfigSchema.description("MySQL 数据库配置"),
   tag_config: SaveConfigSchema.description("tag图片保存配置"),
-  repeat_config: RepeatConfigSchema.description("复读配置")
+  repeat_config: RepeatConfigSchema.description("复读配置"),
+  son_config: ShitOrNotConfigSchema.description("SON配置"),
+  test: import_koishi10.Schema.string().description("测试")
 });
-var logger = new import_koishi9.Logger(name);
+var logger = new import_koishi10.Logger(name);
 var savePath = null;
 async function apply(ctx, config) {
   ctx = ctx.guild();
@@ -1801,12 +2049,14 @@ async function apply(ctx, config) {
     registerTagCommands(ctx, connected, savePath);
   if (config.function_config.repeat_flag)
     registerRepeatMiddleware(ctx, config?.repeat_config);
+  if (config.function_config.son_flag)
+    registerShitOrNotCommands(ctx, config?.son_config);
   if (config.function_config.rbq_flag)
     registerRbqCommands(ctx, connected);
   if (config.function_config)
     registerKuroCommands(ctx, connected);
   if (dev_mode)
-    registerTestCommands(ctx);
+    registerTestCommands(ctx, config);
 }
 __name(apply, "apply");
 // Annotate the CommonJS export names for ESM import in node:

package/lib/services/son_func/shit_or_not_command.d.ts

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

package/lib/services/son_func/shit_or_not_service.d.ts

@@ -0,0 +1,5 @@
+import { Session } from 'koishi';
+import { ShitOrNotConfig } from '../../utils/config';
+declare function ocrImage(buffer: Buffer): Promise<string>;
+declare function checkShitOrNot(session: Session, parttern_msg: string, config: ShitOrNotConfig): Promise<string>;
+export { checkShitOrNot, ocrImage };

package/lib/services/test_command.d.ts

@@ -1,3 +1,5 @@
 import { Context } from 'koishi';
-declare function registerTestCommands(ctx: Context): void;
+import { Config } from '..';
+declare function registerTestCommands(ctx: Context, config: Config): void;
+export declare function ocrImage(buffer: Buffer): Promise<string>;
 export { registerTestCommands };

package/lib/utils/ai_axios.d.ts

@@ -0,0 +1,15 @@
+export interface OpenRouterMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: Array<{
+        type: 'text' | 'image_url';
+        text?: string;
+        image_url?: {
+            url: string;
+        };
+    }>;
+}
+export interface OpenRouterResult {
+    err: string | null;
+    resp: string | null;
+}
+export declare function callOpenRouter(api_url: string, api_key: string, api_model: string, messages: OpenRouterMessage[]): Promise<OpenRouterResult>;

package/lib/utils/config.d.ts

@@ -3,3 +3,4 @@ export * from './configs/mysql_config';
 export * from './configs/tag_config';
 export * from './configs/repeat_config';
 export * from './configs/redis_config';
+export * from './configs/son_config';

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

@@ -4,6 +4,7 @@ interface FunctionConfig {
     tag_flag: boolean;
     repeat_flag: boolean;
     rbq_flag: boolean;
+    son_flag: boolean;
     kuro_flag: boolean;
 }
 declare const FunctionConfigSchema: Schema<FunctionConfig>;

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

@@ -0,0 +1,9 @@
+import { Schema } from 'koishi';
+interface ShitOrNotConfig {
+    api_url?: string;
+    api_model?: string;
+    api_key?: string;
+    config_path?: string;
+}
+declare const ShitOrNotConfigSchema: Schema<ShitOrNotConfig>;
+export { ShitOrNotConfig, ShitOrNotConfigSchema, };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-cocoyyy-console",
   "description": "自用koishi插件，功能包含复读，记录黑历史，*人等",
-  "version": "1.0.16-beta.1",
+  "version": "1.0.16-beta.10",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "contributors": [
@@ -25,6 +25,8 @@
     "mysql2": "^3.11.0",
     "qs": "^6.14.0",
     "sequelize": "^6.37.3",
-    "ioredis": "^5.8.2"
+    "ioredis": "^5.8.2",
+    "tesseract.js": "^5.1.0",
+    "js-yaml": "^4.1.1"
   }
-}
+}