koishi-plugin-cocoyyy-console 1.0.10 → 1.0.12

package/lib/index.d.ts

@@ -4,10 +4,10 @@ export declare const name = "cocoyyy-console";
 export declare let dev_mode: boolean;
 export interface Config {
     function_config?: my_config.FunctionConfig;
+    redis_config?: my_config.RedisConfig;
     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

@@ -1,6 +1,8 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -36,7 +46,8 @@ var FunctionConfigSchema = import_koishi.Schema.object({
   dev_mode: import_koishi.Schema.boolean().default(false).description("开发测试模式"),
   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("*人功能是否启用")
+  rbq_flag: import_koishi.Schema.boolean().default(true).description("*人功能是否启用"),
+  kuro_flag: import_koishi.Schema.boolean().default(true).description("鸣潮功能是否启用")
 });
 
 // src/utils/configs/mysql_config.ts
@@ -48,16 +59,6 @@ var MysqlConfigSchema = import_koishi2.Schema.object({
   password: import_koishi2.Schema.string().role("secret").default("").description("密码"),
   database: import_koishi2.Schema.string().default("test").description("数据库名")
 });
-function loadMysqlConfigFromEnv(env = process.env) {
-  return {
-    host: env.MYSQL_HOST || "127.0.0.1",
-    port: Number(env.MYSQL_PORT || 3306),
-    user: env.MYSQL_USER || "root",
-    password: env.MYSQL_PASSWORD || "",
-    database: env.MYSQL_DATABASE || "test"
-  };
-}
-__name(loadMysqlConfigFromEnv, "loadMysqlConfigFromEnv");
 
 // src/utils/configs/tag_config.ts
 var import_koishi3 = require("koishi");
@@ -79,22 +80,17 @@ var RepeatConfigSchema = import_koishi4.Schema.object({
   resetInterval: import_koishi4.Schema.number().default(300).description("过期秒数")
 });
 
-// src/utils/configs/rbq_config.ts
+// src/utils/configs/redis_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("触发配置")
+var RedisConfigSchema = import_koishi5.Schema.object({
+  redis_url: import_koishi5.Schema.string().default("127.0.0.1:6379").description("Redis连接字符串")
 });
 
 // src/infra/mysql_init.ts
 var import_sequelize = require("sequelize");
 var sequelize = null;
 function initSequelize(cfg) {
-  const conf = cfg ?? loadMysqlConfigFromEnv();
+  const conf = cfg;
   sequelize = new import_sequelize.Sequelize(conf.database, conf.user, conf.password, {
     host: conf.host,
     port: conf.port,
@@ -129,12 +125,6 @@ var TagsModel = class extends import_sequelize2.Model {
   static {
     __name(this, "TagsModel");
   }
-  id;
-  tags;
-  alias;
-  guild_id;
-  status;
-  createtime;
 };
 var inited = false;
 function getTagsModel() {
@@ -202,11 +192,6 @@ var ImgsModel = class extends import_sequelize3.Model {
   static {
     __name(this, "ImgsModel");
   }
-  id;
-  tag_id;
-  img_url;
-  status;
-  createtime;
 };
 var inited2 = false;
 function getImgsModel() {
@@ -304,6 +289,11 @@ var menuList = [
     name: "rbq",
     description: "*人功能，用于*人",
     command: "无"
+  },
+  {
+    name: "kuro",
+    description: "库洛相关功能，用于鸣潮相关功能",
+    command: "无"
   }
 ];
 function getMenuList(command = null, functionConfig) {
@@ -323,6 +313,10 @@ function getMenuList(command = null, functionConfig) {
       if (!functionConfig.rbq_flag)
         return "*人功能已关闭";
       return getRbqFuncMenu(command);
+    case "kuro":
+      if (!functionConfig.kuro_flag)
+        return "库洛相关功能已关闭";
+      return getKuroFuncMenu(command);
     default:
       return `[所有命令都需要@bot]
 当前可用功能列表:
@@ -409,6 +403,25 @@ function getRbqFuncMenu(command = null) {
 输入对应指令使用*人功能，如果遇到问题请联系开发人员。`;
 }
 __name(getRbqFuncMenu, "getRbqFuncMenu");
+var kuroFuncMenuList = [
+  {
+    name: "login",
+    description: "库街区登录",
+    command: "login [手机号] [验证码]"
+  },
+  {
+    name: "signin",
+    description: "库街区签到",
+    command: "signin"
+  }
+];
+function getKuroFuncMenu(command = null) {
+  return `[所有命令都需要@bot]
+库洛相关功能菜单:
+	${kuroFuncMenuList.map((item) => item.command + ": " + item.description).join("\n	")}
+输入对应指令使用库洛相关功能，如果遇到问题请联系开发人员。`;
+}
+__name(getKuroFuncMenu, "getKuroFuncMenu");
 function registerMenuCommands(ctx, connected, functionConfig) {
   ctx.command("help <参数>", "帮助菜单").action(async ({ session }, ...args) => {
     if (!dev_mode) {
@@ -901,10 +914,6 @@ var RbqPersonModel = class extends import_sequelize5.Model {
   static {
     __name(this, "RbqPersonModel");
   }
-  id;
-  guild_id;
-  uid_list;
-  createtime;
 };
 var inited3 = false;
 function getRbqPersonModel() {
@@ -964,11 +973,6 @@ var RbqContentModel = class extends import_sequelize6.Model {
   static {
     __name(this, "RbqContentModel");
   }
-  id;
-  guild_id;
-  content;
-  tag_uid;
-  createtime;
 };
 var inited4 = false;
 function getRbqContentModel() {
@@ -1189,23 +1193,19 @@ __name(create_content, "create_content");
 async function get_content_list(guild_id, tar_uid) {
   try {
     const RbqContent = getRbqContentModel();
+    const whereBase = { guild_id };
     const existed = await RbqContent.findAll({
-      where: {
-        guild_id,
-        tag_uid: null
-      }
+      where: { ...whereBase, tag_uid: null }
     });
-    let result_list = [];
+    let result_list = existed.map((item) => item.get("content")).filter(Boolean);
     result_list.push(...existed.map((item) => item.get("content")).filter(Boolean));
     if (tar_uid) {
       const tar_existed = await RbqContent.findAll({
-        where: {
-          guild_id,
-          tag_uid: tar_uid
-        }
+        where: { ...whereBase, tag_uid: tar_uid }
       });
       result_list.push(...tar_existed.map((item) => item.get("content")).filter(Boolean));
     }
+    result_list = Array.from(new Set(result_list.map((s) => s.trim()).filter((s) => s.length > 0)));
     return result_list;
   } catch (e) {
     logger.error("[get_content_list Error]: " + e?.message || String(e));
@@ -1222,9 +1222,14 @@ function registerRbqCommands(ctx, connected) {
       if (!connected) return;
       if (!is_at_bot(session)) return;
     }
-    const list = await get_person_list(session.guildId);
-    return `当前群聊rbq列表：
-${list.join(",")}`;
+    const guildId = session.guildId;
+    if (!guildId) return "无法获取群号";
+    const list = await get_person_list(guildId);
+    if (!list || list.length === 0) {
+      return "当前群聊还没有设置任何rbq";
+    }
+    return `当前群聊rbq列表:
+${list.map((item) => (0, import_koishi8.h)("at", { id: item })).join(",")}`;
   });
   ctx.command("rbqadd <参数>", "添加rbq").action(async ({ session }, ...args) => {
     if (!dev_mode) {
@@ -1241,8 +1246,8 @@ ${list.join(",")}`;
     }
     exec = await create_person(session.guildId, uid);
     if (!exec.result)
-      return `添加rbq失败：${exec.error}`;
-    return `已添加rbq：${uid}`;
+      return `添加rbq失败: ${exec.error}`;
+    return `已添加rbq: ${(0, import_koishi8.h)("at", { id: uid })}`;
   });
   ctx.command("rbqinstead <参数>", "替换rbq").action(async ({ session }, ...args) => {
     if (!dev_mode) {
@@ -1301,7 +1306,7 @@ ${list.join(",")}`;
       let content = "*死你";
       if (contents && contents.length > 0) {
         const random = new import_koishi8.Random(() => Math.random());
-        content = contents[random.int(0, contents.length - 1)];
+        content = contents[random.int(0, contents.length)];
       }
       return (0, import_koishi8.h)("at", { id: matchedUid }) + " " + content;
     } catch (error) {
@@ -1313,53 +1318,512 @@ ${list.join(",")}`;
 __name(registerRbqCommands, "registerRbqCommands");
 
 // src/services/test_command.ts
+var import_axios = __toESM(require("axios"));
+var import_qs = __toESM(require("qs"));
+var userMap = /* @__PURE__ */ new Map();
 function registerTestCommands(ctx) {
-  ctx.command("test <参数>", "获取指定群的成员列表").action(async ({ session }, guildId) => {
-    if (!guildId) return "请提供群号";
-    const bot = ctx.bots[session.uid] || Object.values(ctx.bots)[0];
-    if (!bot) return "未找到可用的机器人实例";
-    if (bot.platform !== "onebot") return "当前平台不支持该操作";
+  ctx.command("test <参数>", "test").action(async ({ session }, phoneNumber, code) => {
+    if (!phoneNumber || !code) return "请提供手机号和验证码";
     try {
-      const memberList = await bot.getGuildMemberList(guildId);
-      const members = memberList.data;
-      if (!members?.length) {
-        return `群 ${guildId} 未获取到成员，请检查权限或机器人是否在群中。`;
+      const token = await getToken(phoneNumber, code);
+      if (token.status) {
+        return `验证码登录成功，库街区用户: ${token.data.userName}`;
+      } else {
+        return `验证码登录失败: ${token.msg}`;
       }
-      const ids = members.map((m) => m.user?.id).filter(Boolean).join("\n");
-      console.log(`[群 ${guildId}] 成员数量: ${members.length}`);
-      return `群 ${guildId} 共 ${members.length} 位成员：
-${ids}`;
     } catch (err) {
       console.error(err);
-      return `获取群成员失败：${err.message}`;
+      return `test error: ${err.message}`;
+    }
+  });
+  ctx.command("getuser <参数>", "getuser").action(async ({ session }, mobile) => {
+    if (!mobile) return "请提供手机号";
+    const user = userMap.get(mobile);
+    if (user) {
+      return `库街区用户: ${JSON.stringify(user)}`;
+    } else {
+      return `库街区用户不存在`;
     }
   });
 }
 __name(registerTestCommands, "registerTestCommands");
+var CONSTANTS = {
+  REQUEST_HEADERS_BASE: {
+    "source": "ios"
+  }
+};
+async function getToken(mobile, code) {
+  const devCode = [...Array(40)].map(() => "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"[Math.random() * 36 | 0]).join("");
+  let data = import_qs.default.stringify({
+    mobile,
+    code
+  });
+  try {
+    const response = await import_axios.default.post("https://api.kurobbs.com/user/sdkLogin", data, { headers: { ...CONSTANTS.REQUEST_HEADERS_BASE, devCode } });
+    if (response.data.code === 200) {
+      userMap.set(mobile, response.data.data);
+      logger.info(`验证码登录成功，库街区用户: ${response.data.data.userName}`);
+      return { status: true, data: response.data.data };
+    } else {
+      logger.error(`验证码登录失败: ${response.data.msg}`);
+      return { status: false, msg: response.data.msg };
+    }
+  } catch (error) {
+    logger.error(`验证码登录失败，疑似网络问题: ${error}`);
+    return { status: false, msg: "登录失败，疑似网络问题，请检查控制台日志" };
+  }
+}
+__name(getToken, "getToken");
+
+// src/infra/redis_init.ts
+var import_ioredis = __toESM(require("ioredis"));
+var redis;
+function init_redis(config) {
+  try {
+    if (!redis) {
+      redis = new import_ioredis.default(config.redis_url);
+    }
+    redis.ping();
+    logger.info("redis连接成功");
+    return true;
+  } catch (error) {
+    logger.error("redis连接失败: " + error);
+    return false;
+  }
+}
+__name(init_redis, "init_redis");
+
+// src/services/kuro_func/kuro_service.ts
+var import_axios2 = __toESM(require("axios"));
+var import_qs2 = __toESM(require("qs"));
+
+// src/models/kuro_user.ts
+var import_sequelize8 = require("sequelize");
+var KuroUserModel = class extends import_sequelize8.Model {
+  static {
+    __name(this, "KuroUserModel");
+  }
+};
+var inited5 = false;
+function getKuroUserModel() {
+  const sequelize2 = getSequelize();
+  if (!inited5) {
+    KuroUserModel.init(
+      {
+        id: {
+          type: import_sequelize8.DataTypes.INTEGER.UNSIGNED,
+          allowNull: false,
+          autoIncrement: true,
+          primaryKey: true
+        },
+        qq_uid: {
+          type: import_sequelize8.DataTypes.STRING(128),
+          allowNull: false
+        },
+        user_id: {
+          type: import_sequelize8.DataTypes.STRING(128),
+          allowNull: false
+        },
+        user_name: {
+          type: import_sequelize8.DataTypes.STRING(128),
+          allowNull: false
+        },
+        role_id: {
+          type: import_sequelize8.DataTypes.STRING(128),
+          allowNull: true
+        },
+        server_id: {
+          type: import_sequelize8.DataTypes.STRING(512),
+          allowNull: true
+        },
+        token: {
+          type: import_sequelize8.DataTypes.STRING(512),
+          allowNull: true
+        },
+        updatetime: {
+          type: import_sequelize8.DataTypes.DATE,
+          allowNull: false,
+          defaultValue: import_sequelize8.DataTypes.NOW,
+          field: "updatetime",
+          set(value) {
+            if (typeof value === "number") {
+              const ts = value > 1e12 ? value : value * 1e3;
+              this.setDataValue("updatetime", new Date(ts));
+            } else {
+              this.setDataValue("updatetime", value);
+            }
+          }
+        }
+      },
+      {
+        sequelize: sequelize2,
+        tableName: "kuro_user",
+        modelName: "KuroUser",
+        timestamps: false,
+        underscored: false
+      }
+    );
+    inited5 = true;
+  }
+  return KuroUserModel;
+}
+__name(getKuroUserModel, "getKuroUserModel");
+
+// src/services/kuro_func/kuro_db_service.ts
+async function createUpdateUser(requestResult) {
+  const KuroUser = getKuroUserModel();
+  try {
+    const user = await KuroUser.findOne({ where: { qq_uid: requestResult.qq_uid } });
+    if (user) {
+      user.user_id = requestResult.user_id;
+      user.user_name = requestResult.user_name;
+      user.role_id = requestResult.role_id;
+      user.server_id = requestResult.server_id;
+      user.token = requestResult.token;
+      user.updatetime = new Date(Date.now() + 8 * 60 * 60 * 1e3);
+      await user.save();
+    } else {
+      await KuroUser.create({
+        qq_uid: requestResult.qq_uid,
+        user_id: requestResult.user_id,
+        user_name: requestResult.user_name,
+        role_id: requestResult.role_id,
+        server_id: requestResult.server_id,
+        token: requestResult.token,
+        updatetime: new Date(Date.now() + 8 * 60 * 60 * 1e3)
+      });
+    }
+    return { status: true, msg: null };
+  } catch (e) {
+    logger.error(`[createUpdateUser Error]: ${e?.message || String(e)}`);
+    return { status: false, msg: e?.message || String(e) };
+  }
+}
+__name(createUpdateUser, "createUpdateUser");
+
+// src/services/kuro_func/kuro_service.ts
+var userTokenMap = /* @__PURE__ */ new Map();
+var CONSTANTS2 = {
+  BASE_URL: "https://api.kurobbs.com",
+  LOGIN_URL: "/user/sdkLogin",
+  GAME_DATA_URL: "/gamer/role/list",
+  REFRESH_URL: "/aki/roleBox/akiBox/refreshData",
+  TOKEN_REFRESH_URL: "/aki/roleBox/requestToken",
+  // GAME_DATA_URL: '/gamer/widget/game3/refresh',
+  // BASE_DATA_URL: '/aki/roleBox/akiBox/baseData',
+  ROLE_DATA_URL: "/aki/roleBox/akiBox/roleData",
+  // CALABASH_DATA_URL: '/aki/roleBox/akiBox/calabashData',
+  // CHALLENGE_DATA_URL: '/aki/roleBox/akiBox/challengeDetails',
+  // EXPLORE_DATA_URL: '/aki/roleBox/akiBox/exploreIndex',
+  SIGNIN_URL: "/encourage/signIn/v2",
+  // QUERY_RECORD_URL: '/encourage/signIn/queryRecordV2',
+  // GACHA_URL: 'https://gmserver-api.aki-game2.com/gacha/record/query',
+  // INTL_GACHA_URL: 'https://gmserver-api.aki-game2.net/gacha/record/query',
+  // ROLE_DETAIL_URL: '/aki/roleBox/akiBox/getRoleDetail',
+  // EVENT_LIST_URL: '/forum/companyEvent/findEventList',
+  // SELF_TOWER_DATA_URL: '/aki/roleBox/akiBox/towerDataDetail',
+  // OTHER_TOWER_DATA_URL: '/aki/roleBox/akiBox/towerIndex',
+  REQUEST_HEADERS_BASE: {
+    "source": "ios"
+  }
+};
+var wavesApi = import_axios2.default.create();
+wavesApi.interceptors.request.use(
+  async (config) => {
+    if (config.url.startsWith("/")) {
+      config.url = CONSTANTS2.BASE_URL + config.url;
+    }
+    return config;
+  },
+  (error) => {
+    return Promise.reject(error);
+  }
+);
+async function init_userMap() {
+  const KuroUser = getKuroUserModel();
+  try {
+    const existed = await KuroUser.findAll();
+    if (!existed) return;
+    existed.forEach(async (item) => {
+      const qq_uid = item.get("qq_uid");
+      const user_id = item.get("user_id");
+      const user_name = item.get("user_name");
+      const role_id = item.get("role_id");
+      const server_id = item.get("server_id");
+      const token = item.get("token");
+      userTokenMap.set(qq_uid, { user_id, user_name, role_id, server_id, token, bat: null });
+    });
+    return true;
+  } catch (e) {
+    logger.error("[init_userMap Error]: " + e?.message || String(e));
+    return false;
+  }
+}
+__name(init_userMap, "init_userMap");
+async function checkUserToken(qq_uid) {
+  const userInfo = userTokenMap.get(qq_uid);
+  if (!userInfo) {
+    return null;
+  }
+  const available_response = await isAvailable(userInfo.server_id, userInfo.role_id, userInfo.token);
+  if (!available_response.status) {
+    return null;
+  }
+  userTokenMap.set(qq_uid, { ...userInfo, bat: available_response.data });
+  return userInfo;
+}
+__name(checkUserToken, "checkUserToken");
+async function getToken2(session, mobile, code) {
+  const existed = await checkUserToken(session.uid);
+  if (existed) {
+    return { status: true, data: existed };
+  }
+  const devCode = [...Array(40)].map(() => "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"[Math.random() * 36 | 0]).join("");
+  let data = import_qs2.default.stringify({
+    mobile,
+    code
+  });
+  try {
+    const user_response = await wavesApi.post(CONSTANTS2.LOGIN_URL, data, { headers: { ...CONSTANTS2.REQUEST_HEADERS_BASE, devCode } });
+    if (user_response.data.code != 200) {
+      logger.error(`验证码登录失败: ${user_response.data.msg}`);
+      return { status: false, msg: user_response.data.msg };
+    }
+    const game_response = await getGameData(user_response.data.data.token);
+    if (!game_response.status) {
+      return { status: false, msg: game_response.msg };
+    }
+    if (game_response.data === null) {
+      return { status: false, msg: "未检测到鸣潮信息" };
+    }
+    const available_response = await isAvailable(game_response.data.serverId, game_response.data.roleId, user_response.data.data.token);
+    if (!available_response.status) {
+      return { status: false, msg: available_response.msg };
+    }
+    const userInfo = {
+      qq_uid: session.uid,
+      user_id: user_response.data.data.userId,
+      user_name: user_response.data.data.userName,
+      role_id: game_response.data.roleId,
+      server_id: game_response.data.serverId,
+      token: user_response.data.data.token,
+      bat: available_response.data
+    };
+    createUpdateUser(userInfo);
+    userTokenMap.set(session.uid, userInfo);
+    logger.info(`[getToken Info]: 验证码登录成功，库街区用户: ${user_response.data.data.userName}`);
+    return { status: true, data: user_response.data.data };
+  } catch (error) {
+    logger.error(`[getToken Error]: ${error.message}`);
+    return { status: false, msg: "疑似网络问题，请检查控制台日志" };
+  }
+}
+__name(getToken2, "getToken");
+async function getGameData(token) {
+  try {
+    let data = import_qs2.default.stringify({
+      "gameId": 3
+    });
+    const response = await wavesApi.post(CONSTANTS2.GAME_DATA_URL, data, { headers: { ...CONSTANTS2.REQUEST_HEADERS_BASE, "token": token } });
+    if (response.data.code === 200) {
+      return { status: true, data: response.data.data[0] };
+    } else {
+      logger.error(`[getGameData Error]: ${response.data.msg}`);
+      return { status: false, msg: response.data.msg };
+    }
+  } catch (error) {
+    logger.error(`[getGameData Error]: ${error.message}`);
+    return { status: false, msg: "疑似网络问题，请检查控制台日志" };
+  }
+}
+__name(getGameData, "getGameData");
+async function isAvailable(serverId, roleId, token) {
+  let data = import_qs2.default.stringify({
+    "serverId": serverId,
+    "roleId": roleId
+  });
+  try {
+    const response = await wavesApi.post(CONSTANTS2.TOKEN_REFRESH_URL, data, { headers: { ...CONSTANTS2.REQUEST_HEADERS_BASE, "token": token } });
+    if (response.data.code === 220) {
+      logger.info(`${roleId} 获取可用性成功，账号已过期`);
+      return { status: false, msg: "账号已过期" };
+    } else {
+      logger.error(`${roleId} 获取可用性成功，账号可用`);
+      return { status: true, data: JSON.parse(response.data.data).accessToken };
+    }
+  } catch (error) {
+    logger.error(`[isAvailable Error]: ${error.message}`);
+    return { status: false, msg: "疑似网络问题，请检查控制台日志" };
+  }
+}
+__name(isAvailable, "isAvailable");
+async function refreshData(bat, serverId, roleId, token) {
+  let data = import_qs2.default.stringify({
+    "gameId": 3,
+    "serverId": serverId,
+    "roleId": roleId
+  });
+  try {
+    const response = await wavesApi.post(CONSTANTS2.REFRESH_URL, data, { headers: { ...CONSTANTS2.REQUEST_HEADERS_BASE, "token": token, "b-at": bat } });
+    if (response.data.code === 10902 || response.data.code === 200) {
+      return { status: true, data: response.data.data };
+    } else {
+      logger.error(`[refreshData Error]: ${response.data.msg}`);
+      return { status: false, msg: response.data.msg };
+    }
+  } catch (error) {
+    logger.error(`[refreshData Error]: ${error.message}`);
+    return { status: false, msg: "疑似网络问题，请检查控制台日志" };
+  }
+}
+__name(refreshData, "refreshData");
+async function signIn(qq_uid) {
+  const userInfo = await checkUserToken(qq_uid);
+  if (!userInfo) {
+    return { status: false, msg: "未检测到登录信息或信息已过期，请重新登录！" };
+  }
+  await refreshData(userInfo.bat, userInfo.server_id, userInfo.role_id, userInfo.token);
+  let data = import_qs2.default.stringify({
+    "gameId": 3,
+    "serverId": userInfo.server_id,
+    "roleId": userInfo.role_id,
+    "userId": userInfo.user_id,
+    "reqMonth": ((/* @__PURE__ */ new Date()).getMonth() + 1).toString().padStart(2, "0")
+  });
+  try {
+    const response = await wavesApi.post(CONSTANTS2.SIGNIN_URL, data, { headers: { ...CONSTANTS2.REQUEST_HEADERS_BASE, "token": userInfo.token, devcode: "", "b-at": userInfo.bat } });
+    if (response.data.code === 200) {
+      if (response.data.data === null) {
+        logger.info(`[signIn Info]: ${qq_uid} 签到失败，返回空数据`);
+        return { status: false, msg: "查询信息失败，请检查库街区数据终端中对应板块的对外展示开关是否打开" };
+      }
+      return { status: true, msg: "签到成功" };
+    } else {
+      logger.error(`[signIn Error]: ${qq_uid} 签到失败: ${response.data.msg}`);
+      return { status: false, msg: response.data.msg };
+    }
+  } catch (error) {
+    logger.error(`[signIn Error]: ${error.message}`);
+    return { status: false, msg: "疑似网络问题，请检查控制台日志" };
+  }
+}
+__name(signIn, "signIn");
+async function getRoleData(qq_uid) {
+  const userInfo = await checkUserToken(qq_uid);
+  if (!userInfo) {
+    return { status: false, msg: "未检测到登录信息或信息已过期，请重新登录！" };
+  }
+  await refreshData(userInfo.bat, userInfo.server_id, userInfo.role_id, userInfo.token);
+  let data = import_qs2.default.stringify({
+    "gameId": 3,
+    "serverId": userInfo.server_id,
+    "roleId": userInfo.role_id
+  });
+  try {
+    const response = await wavesApi.post(CONSTANTS2.ROLE_DATA_URL, data, { headers: { ...CONSTANTS2.REQUEST_HEADERS_BASE, "token": userInfo.token, "b-at": userInfo.bat } });
+    if (response.data.code === 10902 || response.data.code === 200) {
+      response.data.data = JSON.parse(response.data.data);
+      if (response.data.data === null || !response.data.data.showToGuest) {
+        logger.error(`[getRoleData Error]: ${qq_uid} 获取共鸣者失败，返回空数据`);
+        return { status: false, msg: "查询信息失败，请检查库街区数据终端中对应板块的对外展示开关是否打开" };
+      }
+      logger.info(`[getRoleData Info]: ${qq_uid} 获取共鸣者成功`);
+      return { status: true, data: response.data.data };
+    } else {
+      logger.error(`[getRoleData Error]: ${qq_uid} 获取共鸣者失败: ${response.data.msg}`);
+      return { status: false, msg: response.data.msg };
+    }
+  } catch (error) {
+    logger.error(`[getRoleData Error]: ${qq_uid} 获取共鸣者失败，疑似网络问题: ${error.message}`);
+    return { status: false, msg: "获取共鸣者失败，疑似网络问题，请检查控制台日志" };
+  }
+}
+__name(getRoleData, "getRoleData");
+
+// src/services/kuro_func/kuro_commands.ts
+function registerKuroCommands(ctx, connected) {
+  init_userMap();
+  ctx.command("login <参数>", "登录库街区账号").action(async ({ session }, phoneNumber, code) => {
+    if (!dev_mode) {
+      if (!connected) return;
+      if (!is_at_bot(session)) return;
+    }
+    if (!phoneNumber || !code) return "请提供手机号和验证码，如：@bot login [手机号] [验证码]";
+    try {
+      const result = await getToken2(session, phoneNumber, code);
+      if (result.status) {
+        return `登录成功，库街区用户: ${result.data.user_name}`;
+      } else {
+        return `登录失败: ${result.msg}`;
+      }
+    } catch (err) {
+      logger.error(`登录库街区账号失败: ${err.message}`);
+      return `登录库街区账号失败: ${err.message}`;
+    }
+  });
+  ctx.command("signin", "库街区签到").action(async ({ session }) => {
+    if (!dev_mode) {
+      if (!connected) return;
+      if (!is_at_bot(session)) return;
+    }
+    try {
+      const result = await signIn(session.uid);
+      if (result.status) {
+        return "库街区签到成功";
+      } else {
+        return `库街区签到失败: ${result.msg}`;
+      }
+    } catch (err) {
+      logger.error(`库街区签到失败: ${err.message}`);
+      return `库街区签到失败: ${err.message}`;
+    }
+  });
+  ctx.command("roledata <参数>", "共鸣者数据").action(async ({ session }, roleName) => {
+    if (!dev_mode) {
+      if (!connected) return;
+      if (!is_at_bot(session)) return;
+    }
+    if (!roleName) {
+      try {
+        const result = await getRoleData(session.uid);
+        if (result.status) {
+          return result.data;
+        } else {
+          return `共鸣者数据获取失败: ${result.msg}`;
+        }
+      } catch (err) {
+        logger.error(`共鸣者数据获取失败: ${err.message}`);
+        return `共鸣者数据获取失败: ${err.message}`;
+      }
+    }
+  });
+}
+__name(registerKuroCommands, "registerKuroCommands");
 
 // src/index.ts
 var name = "cocoyyy-console";
 var dev_mode;
 var Config = import_koishi9.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("复读配置")
-  // rbq_config:my_config.RbqConfigSchema.description('*人配置')
 });
 var logger = new import_koishi9.Logger(name);
 var savePath = null;
 async function apply(ctx, config) {
   ctx = ctx.guild();
   dev_mode = config.function_config.dev_mode;
-  const mysqlConf = config?.mysql_config ?? loadMysqlConfigFromEnv();
-  initSequelize(mysqlConf);
+  initSequelize(config?.mysql_config);
+  init_redis(config?.redis_config);
   const connected = await testConnect();
   if (connected) {
     await getTagsModel().sync();
     await getImgsModel().sync();
     await getRbqPersonModel().sync();
     await getRbqContentModel().sync();
+    await getKuroUserModel().sync();
   }
   savePath = resolveTagBaseDir(config?.tag_config);
   registerMenuCommands(ctx, connected, config.function_config);
@@ -1369,6 +1833,8 @@ async function apply(ctx, config) {
     registerRepeatMiddleware(ctx, config?.repeat_config);
   if (config.function_config.rbq_flag)
     registerRbqCommands(ctx, connected);
+  if (config.function_config)
+    registerKuroCommands(ctx, connected);
   if (dev_mode)
     registerTestCommands(ctx);
 }

package/lib/infra/redis_init.d.ts

@@ -0,0 +1,4 @@
+import Redis from 'ioredis';
+import { RedisConfig } from '../utils/config';
+export declare function getRedis(): Redis;
+export declare function init_redis(config?: RedisConfig): boolean;

package/lib/models/kuro_user.d.ts

@@ -0,0 +1,23 @@
+import { Model, Optional } from 'sequelize';
+export interface KuroUserAttributes {
+    id: number;
+    qq_uid: string;
+    user_id: string;
+    user_name: string;
+    role_id: string;
+    server_id: string;
+    token: string;
+    updatetime: Date;
+}
+export type KuroUserCreationAttributes = Optional<KuroUserAttributes, 'id' | 'updatetime'>;
+export declare class KuroUserModel extends Model<KuroUserAttributes, KuroUserCreationAttributes> implements KuroUserAttributes {
+    id: number;
+    qq_uid: string;
+    user_id: string;
+    user_name: string;
+    role_id: string;
+    server_id: string;
+    token: string;
+    updatetime: Date;
+}
+export declare function getKuroUserModel(): typeof KuroUserModel;

package/lib/services/kuro_func/kuro_commands.d.ts

@@ -0,0 +1,3 @@
+import { Context } from 'koishi';
+declare function registerKuroCommands(ctx: Context, connected: any): void;
+export { registerKuroCommands };

package/lib/services/kuro_func/kuro_db_service.d.ts

@@ -0,0 +1,5 @@
+declare function createUpdateUser(requestResult: any): Promise<{
+    status: boolean;
+    msg: any;
+}>;
+export { createUpdateUser, };

package/lib/services/kuro_func/kuro_service.d.ts

@@ -0,0 +1,25 @@
+import { Session } from "koishi";
+declare function init_userMap(): Promise<boolean>;
+declare function getToken(session: Session, mobile: any, code: any): Promise<{
+    status: boolean;
+    data: any;
+    msg?: undefined;
+} | {
+    status: boolean;
+    msg: any;
+    data?: undefined;
+}>;
+declare function signIn(qq_uid: string): Promise<{
+    status: boolean;
+    msg: any;
+}>;
+declare function getRoleData(qq_uid: any): Promise<{
+    status: boolean;
+    data: any;
+    msg?: undefined;
+} | {
+    status: boolean;
+    msg: any;
+    data?: undefined;
+}>;
+export { init_userMap, getToken, signIn, getRoleData };

package/lib/utils/config.d.ts

@@ -2,4 +2,4 @@ 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';
+export * from './configs/redis_config';

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

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

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

@@ -7,6 +7,5 @@ interface MysqlConfig {
     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, };
+export { MysqlConfig, MysqlConfigSchema, toMysqlUri, };

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

@@ -0,0 +1,6 @@
+import { Schema } from 'koishi';
+interface RedisConfig {
+    redis_url?: string;
+}
+declare const RedisConfigSchema: Schema<RedisConfig>;
+export { RedisConfig, RedisConfigSchema, };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-cocoyyy-console",
   "description": "自用koishi插件，功能包含复读，记录黑历史，*人等",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "contributors": [
@@ -21,7 +21,10 @@
     "koishi": "^4.18.7"
   },
   "dependencies": {
+    "axios": "^1.12.2",
     "mysql2": "^3.11.0",
-    "sequelize": "^6.37.3"
+    "qs": "^6.14.0",
+    "sequelize": "^6.37.3",
+    "ioredis": "^5.8.2"
   }
 }

package/lib/services/img_service.d.ts

@@ -1,8 +0,0 @@
-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(tag_name: string): Promise<string | null>;
-declare function getImgCountByTag(tag_id: number): Promise<number>;
-export { saveImg, randomImgByTag, getImgCountByTag };

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

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

package/lib/services/tag_service.d.ts

@@ -1,20 +0,0 @@
-import { TagsModel } from '../models/tags';
-declare function createorUpdateTag(tag_name: string, savePath?: string | null): Promise<{
-    result: boolean;
-    error: string | null;
-}>;
-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 };