koishi-plugin-adapter-onebot-multi 0.0.1

package/lib/index.js

@@ -0,0 +1,3165 @@
+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) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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
+var src_exports = {};
+__export(src_exports, {
+  BaseBot: () => BaseBot2,
+  CQCode: () => CQCode,
+  Config: () => Config,
+  ConfigManager: () => ConfigManager,
+  HeartbeatMonitor: () => HeartbeatMonitor,
+  OneBot: () => utils_exports,
+  OneBotBot: () => OneBotBot,
+  OneBotMessageEncoder: () => OneBotMessageEncoder,
+  PRIVATE_PFX: () => PRIVATE_PFX,
+  PanelConfig: () => PanelConfig,
+  QQGuildBot: () => QQGuildBot,
+  StatusManager: () => StatusManager,
+  StatusPanel: () => StatusPanel,
+  WsClient: () => WsClient,
+  WsServer: () => WsServer,
+  accept: () => accept,
+  apply: () => apply,
+  inject: () => inject,
+  name: () => name
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi11 = require("koishi");
+
+// src/bot/index.ts
+var import_koishi8 = require("koishi");
+
+// src/bot/base.ts
+var import_koishi4 = require("koishi");
+
+// src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  Internal: () => Internal,
+  SafetyLevel: () => SafetyLevel,
+  TimeoutError: () => TimeoutError,
+  adaptChannel: () => adaptChannel,
+  adaptGuild: () => adaptGuild,
+  adaptMessage: () => adaptMessage,
+  adaptQQGuildMemberInfo: () => adaptQQGuildMemberInfo,
+  adaptQQGuildMemberProfile: () => adaptQQGuildMemberProfile,
+  adaptSession: () => adaptSession,
+  decodeGuildMember: () => decodeGuildMember,
+  decodeUser: () => decodeUser,
+  dispatchSession: () => dispatchSession
+});
+var import_koishi2 = require("koishi");
+var qface = __toESM(require("qface"));
+
+// src/types.ts
+var import_koishi = require("koishi");
+var SafetyLevel = /* @__PURE__ */ ((SafetyLevel2) => {
+  SafetyLevel2[SafetyLevel2["safe"] = 0] = "safe";
+  SafetyLevel2[SafetyLevel2["unknown"] = 1] = "unknown";
+  SafetyLevel2[SafetyLevel2["danger"] = 2] = "danger";
+  return SafetyLevel2;
+})(SafetyLevel || {});
+var TimeoutError = class extends Error {
+  static {
+    __name(this, "TimeoutError");
+  }
+  constructor(args, url) {
+    super(`Timeout with request ${url}, args: ${JSON.stringify(args)}`);
+    Object.defineProperties(this, {
+      args: { value: args },
+      url: { value: url }
+    });
+  }
+};
+var SenderError = class extends Error {
+  static {
+    __name(this, "SenderError");
+  }
+  constructor(args, url, retcode) {
+    super(`Error with request ${url}, args: ${JSON.stringify(args)}, retcode: ${retcode}`);
+    Object.defineProperties(this, {
+      code: { value: retcode },
+      args: { value: args },
+      url: { value: url }
+    });
+  }
+};
+var Internal = class _Internal {
+  constructor(bot) {
+    this.bot = bot;
+  }
+  static {
+    __name(this, "Internal");
+  }
+  async _get(action, params = {}) {
+    this.bot.logger.debug("[request] %s %o", action, params);
+    const response = await this._request(action, params);
+    this.bot.logger.debug("[response] %o", response);
+    const { data, retcode } = response;
+    if (retcode === 0) return data;
+    throw new SenderError(params, action, retcode);
+  }
+  async setGroupAnonymousBan(group_id, meta, duration) {
+    const args = { group_id, duration };
+    args[typeof meta === "string" ? "flag" : "anonymous"] = meta;
+    await this._get("set_group_anonymous_ban", args);
+  }
+  async setGroupAnonymousBanAsync(group_id, meta, duration) {
+    const args = { group_id, duration };
+    args[typeof meta === "string" ? "flag" : "anonymous"] = meta;
+    await this._get("set_group_anonymous_ban_async", args);
+  }
+  static asyncPrefixes = ["set", "send", "delete", "create", "upload", "move", "rename"];
+  static prepareMethod(name2) {
+    const prop = (0, import_koishi.camelize)(name2.replace(/^[_.]/, ""));
+    const isAsync = _Internal.asyncPrefixes.some((prefix) => prop.startsWith(prefix));
+    return [prop, isAsync];
+  }
+  static prepareArg(name2, params, args) {
+    const fixedArg = Object.fromEntries(params.map((name3, index) => [name3, args[index]]));
+    for (const key in fixedArg) {
+      if (!name2.includes("guild") && key.endsWith("_id")) {
+        const value = +fixedArg[key];
+        if (Math.abs(value) < 4294967296) {
+          fixedArg[key] = value;
+        }
+      }
+    }
+    return fixedArg;
+  }
+  static define(name2, ...params) {
+    const [prop, isAsync] = _Internal.prepareMethod(name2);
+    _Internal.prototype[prop] = async function(...args) {
+      const data = await this._get(name2, _Internal.prepareArg(name2, params, args));
+      if (!isAsync) return data;
+    };
+    isAsync && (_Internal.prototype[prop + "Async"] = async function(...args) {
+      await this._get(name2 + "_async", _Internal.prepareArg(name2, params, args));
+    });
+  }
+  static defineExtract(name2, key, ...params) {
+    const [prop, isAsync] = _Internal.prepareMethod(name2);
+    _Internal.prototype[prop] = async function(...args) {
+      const data = await this._get(name2, _Internal.prepareArg(name2, params, args));
+      return data[key];
+    };
+    isAsync && (_Internal.prototype[prop + "Async"] = async function(...args) {
+      await this._get(name2 + "_async", _Internal.prepareArg(name2, params, args));
+    });
+  }
+};
+Internal.defineExtract("send_private_msg", "message_id", "user_id", "message", "auto_escape");
+Internal.defineExtract("send_group_msg", "message_id", "group_id", "message", "auto_escape");
+Internal.defineExtract("send_group_forward_msg", "message_id", "group_id", "messages");
+Internal.defineExtract("send_private_forward_msg", "message_id", "user_id", "messages");
+Internal.define("delete_msg", "message_id");
+Internal.define("mark_msg_as_read", "message_id");
+Internal.define("set_essence_msg", "message_id");
+Internal.define("delete_essence_msg", "message_id");
+Internal.define("send_group_sign", "group_id");
+Internal.define("send_like", "user_id", "times");
+Internal.define("get_msg", "message_id");
+Internal.define("get_essence_msg_list", "group_id");
+Internal.define("ocr_image", "image");
+Internal.defineExtract("get_forward_msg", "messages", "message_id");
+Internal.defineExtract(".get_word_slices", "slices", "content");
+Internal.define("get_group_msg_history", "group_id", "message_seq");
+Internal.define("set_friend_add_request", "flag", "approve", "remark");
+Internal.define("set_group_add_request", "flag", "sub_type", "approve", "reason");
+Internal.defineExtract("_get_model_show", "variants", "model");
+Internal.define("_set_model_show", "model", "model_show");
+Internal.define("set_group_kick", "group_id", "user_id", "reject_add_request");
+Internal.define("set_group_ban", "group_id", "user_id", "duration");
+Internal.define("set_group_whole_ban", "group_id", "enable");
+Internal.define("set_group_admin", "group_id", "user_id", "enable");
+Internal.define("set_group_anonymous", "group_id", "enable");
+Internal.define("set_group_card", "group_id", "user_id", "card");
+Internal.define("set_group_leave", "group_id", "is_dismiss");
+Internal.define("set_group_special_title", "group_id", "user_id", "special_title", "duration");
+Internal.define("set_group_name", "group_id", "group_name");
+Internal.define("set_group_portrait", "group_id", "file", "cache");
+Internal.define("_send_group_notice", "group_id", "content", "image", "pinned", "confirm_required");
+Internal.define("_get_group_notice", "group_id");
+Internal.define("_del_group_notice", "group_id", "notice_id");
+Internal.define("get_group_at_all_remain", "group_id");
+Internal.define("get_login_info");
+Internal.define("qidian_get_login_info");
+Internal.define("set_qq_profile", "nickname", "company", "email", "college", "personal_note");
+Internal.define("set_qq_avatar", "file");
+Internal.define("set_online_status", "status", "ext_status", "battery_status");
+Internal.define("get_stranger_info", "user_id", "no_cache");
+Internal.define("_get_vip_info", "user_id");
+Internal.define("get_friend_list");
+Internal.define("get_unidirectional_friend_list");
+Internal.define("delete_friend", "user_id");
+Internal.define("delete_unidirectional_friend", "user_id");
+Internal.define("get_group_info", "group_id", "no_cache");
+Internal.define("get_group_list", "no_cache");
+Internal.define("get_group_member_info", "group_id", "user_id", "no_cache");
+Internal.define("get_group_member_list", "group_id");
+Internal.define("get_group_honor_info", "group_id", "type");
+Internal.define("get_group_system_msg");
+Internal.define("get_group_file_system_info", "group_id");
+Internal.define("get_group_root_files", "group_id");
+Internal.define("get_group_files_by_folder", "group_id", "folder_id");
+Internal.define("upload_private_file", "user_id", "file", "name");
+Internal.define("upload_group_file", "group_id", "file", "name", "folder");
+Internal.define("create_group_file_folder", "group_id", "folder_id", "name");
+Internal.define("delete_group_folder", "group_id", "folder_id");
+Internal.define("delete_group_file", "group_id", "folder_id", "file_id", "busid");
+Internal.defineExtract("get_group_file_url", "url", "group_id", "file_id", "busid");
+Internal.defineExtract("download_file", "file", "url", "headers", "thread_count");
+Internal.defineExtract("get_online_clients", "clients", "no_cache");
+Internal.defineExtract("check_url_safely", "level", "url");
+Internal.defineExtract("get_cookies", "cookies", "domain");
+Internal.defineExtract("get_csrf_token", "token");
+Internal.define("get_credentials", "domain");
+Internal.define("get_record", "file", "out_format", "full_path");
+Internal.define("get_image", "file");
+Internal.defineExtract("can_send_image", "yes");
+Internal.defineExtract("can_send_record", "yes");
+Internal.define("get_status");
+Internal.define("get_version_info");
+Internal.define("set_restart", "delay");
+Internal.define("reload_event_filter");
+Internal.define("clean_cache");
+Internal.define("get_guild_service_profile");
+Internal.define("get_guild_list");
+Internal.define("get_guild_meta_by_guest", "guild_id");
+Internal.define("get_guild_channel_list", "guild_id", "no_cache");
+Internal.define("get_guild_member_list", "guild_id", "next_token");
+Internal.define("get_guild_member_profile", "guild_id", "user_id");
+Internal.defineExtract("send_guild_channel_msg", "message_id", "guild_id", "channel_id", "message");
+Internal.define("upload_image", "file");
+Internal.defineExtract("get_private_file_url", "url", "user_id", "file_id", "file_hash");
+Internal.define("move_group_file", "group_id", "file_id", "parent_directory", "target_directory");
+Internal.define("delete_group_file_folder", "group_id", "folder_id");
+Internal.define("rename_group_file_folder", "group_id", "folder_id", "new_folder_name");
+
+// src/utils.ts
+var decodeUser = /* @__PURE__ */ __name((user) => ({
+  id: user.tiny_id || user.user_id.toString(),
+  name: user.nickname,
+  userId: user.tiny_id || user.user_id.toString(),
+  avatar: user.user_id ? `http://q.qlogo.cn/headimg_dl?dst_uin=${user.user_id}&spec=640` : void 0,
+  username: user.nickname
+}), "decodeUser");
+var decodeGuildMember = /* @__PURE__ */ __name((user) => ({
+  user: decodeUser(user),
+  nick: user.card,
+  roles: [user.role]
+}), "decodeGuildMember");
+var adaptQQGuildMemberInfo = /* @__PURE__ */ __name((user) => ({
+  user: {
+    id: user.tiny_id,
+    name: user.nickname,
+    isBot: user.role_name === "机器人"
+  },
+  name: user.nickname,
+  roles: user.role_name ? [user.role_name] : []
+}), "adaptQQGuildMemberInfo");
+var adaptQQGuildMemberProfile = /* @__PURE__ */ __name((user) => ({
+  user: {
+    id: user.tiny_id,
+    name: user.nickname,
+    isBot: user.roles?.some((r) => r.role_name === "机器人")
+  },
+  name: user.nickname,
+  roles: user.roles?.map((r) => r.role_name) || []
+}), "adaptQQGuildMemberProfile");
+async function adaptMessage(bot, data, message = {}, payload = message) {
+  message.id = message.messageId = data.message_id.toString();
+  const chain = CQCode.parse(data.message);
+  if (bot.config.advanced.splitMixedContent) {
+    chain.forEach((item, index) => {
+      if (item.type !== "image") return;
+      const left = chain[index - 1];
+      if (left && left.type === "text" && left.attrs.content.trimEnd() === left.attrs.content) {
+        left.attrs.content += " ";
+      }
+      const right = chain[index + 1];
+      if (right && right.type === "text" && right.attrs.content.trimStart() === right.attrs.content) {
+        right.attrs.content = " " + right.attrs.content;
+      }
+    });
+  }
+  message.elements = import_koishi2.h.transform(chain, {
+    at(attrs) {
+      if (attrs.qq !== "all") return import_koishi2.h.at(attrs.qq, { name: attrs.name });
+      return (0, import_koishi2.h)("at", { type: "all" });
+    },
+    face({ id }) {
+      const name2 = qface.get(id)?.QDes.slice(1);
+      return (0, import_koishi2.h)("face", { id, name: name2, platform: bot.platform }, [
+        import_koishi2.h.image(qface.getUrl(id))
+      ]);
+    },
+    image(attrs) {
+      return (0, import_koishi2.h)("img", {
+        src: attrs.url || attrs.file,
+        ...(0, import_koishi2.omit)(attrs, ["url"])
+      });
+    },
+    record(attrs) {
+      return (0, import_koishi2.h)("audio", {
+        src: attrs.url || attrs.file,
+        ...(0, import_koishi2.omit)(attrs, ["url"])
+      });
+    },
+    video(attrs) {
+      return (0, import_koishi2.h)("video", {
+        src: attrs.url || attrs.file,
+        ...(0, import_koishi2.omit)(attrs, ["url"])
+      });
+    },
+    file(attrs) {
+      return (0, import_koishi2.h)("file", {
+        src: attrs.url || attrs.file,
+        ...(0, import_koishi2.omit)(attrs, ["url"])
+      });
+    }
+  });
+  const [guildId, channelId] = decodeGuildChannelId(data);
+  if (message.elements[0]?.type === "reply") {
+    const reply = message.elements.shift();
+    message.quote = await bot.getMessage(channelId, reply.attrs.id).catch((error) => {
+      bot.logger.warn(error);
+      return void 0;
+    });
+  }
+  message.content = message.elements.join("");
+  if (!payload) return message;
+  payload.user = decodeUser(data.sender);
+  payload.member = decodeGuildMember(data.sender);
+  payload.timestamp = data.time * 1e3;
+  payload.guild = guildId && { id: guildId };
+  payload.channel = channelId && { id: channelId, type: guildId ? import_koishi2.Universal.Channel.Type.TEXT : import_koishi2.Universal.Channel.Type.DIRECT };
+  return message;
+}
+__name(adaptMessage, "adaptMessage");
+var decodeGuildChannelId = /* @__PURE__ */ __name((data) => {
+  if (data.guild_id) {
+    return [data.guild_id, data.channel_id];
+  } else if (data.group_id) {
+    return [data.group_id.toString(), data.group_id.toString()];
+  } else {
+    return [void 0, "private:" + data.sender.user_id];
+  }
+}, "decodeGuildChannelId");
+var adaptGuild = /* @__PURE__ */ __name((info) => {
+  if (info.guild_id) {
+    const guild = info;
+    return {
+      id: guild.guild_id,
+      name: guild.guild_name
+    };
+  } else {
+    const group = info;
+    return {
+      id: group.group_id.toString(),
+      name: group.group_name
+    };
+  }
+}, "adaptGuild");
+var adaptChannel = /* @__PURE__ */ __name((info) => {
+  if (info.channel_id) {
+    const channel = info;
+    return {
+      id: channel.channel_id,
+      name: channel.channel_name,
+      type: import_koishi2.Universal.Channel.Type.TEXT
+    };
+  } else {
+    const group = info;
+    return {
+      id: group.group_id.toString(),
+      name: group.group_name,
+      type: import_koishi2.Universal.Channel.Type.TEXT
+    };
+  }
+}, "adaptChannel");
+async function dispatchSession(bot, data) {
+  if (data.self_tiny_id) {
+    bot = bot["guildBot"];
+    if (!bot) return;
+  }
+  const session = await adaptSession(bot, data);
+  if (!session) return;
+  session.setInternal("onebot", data);
+  bot.dispatch(session);
+}
+__name(dispatchSession, "dispatchSession");
+async function adaptSession(bot, data) {
+  const session = bot.session();
+  session.selfId = data.self_tiny_id ? data.self_tiny_id : "" + data.self_id;
+  session.type = data.post_type;
+  if (data.post_type === "message" || data.post_type === "message_sent") {
+    await adaptMessage(bot, data, session.event.message = {}, session.event);
+    if (data.post_type === "message_sent" && !session.guildId) {
+      session.channelId = "private:" + data.target_id;
+    }
+    session.type = "message";
+    session.subtype = data.message_type === "guild" ? "group" : data.message_type;
+    session.isDirect = data.message_type === "private";
+    session.subsubtype = data.message_type;
+    return session;
+  }
+  session.subtype = data.sub_type;
+  if (data.user_id) session.userId = "" + data.user_id;
+  if (data.group_id) session.guildId = session.channelId = "" + data.group_id;
+  if (data.guild_id) session.guildId = "" + data.guild_id;
+  if (data.channel_id) session.channelId = "" + data.channel_id;
+  if (data.target_id) session["targetId"] = "" + data.target_id;
+  if (data.operator_id) session.operatorId = "" + data.operator_id;
+  if (data.message_id) session.messageId = "" + data.message_id;
+  if (data.post_type === "request") {
+    session.content = data.comment;
+    session.messageId = data.flag;
+    if (data.request_type === "friend") {
+      session.type = "friend-request";
+      session.channelId = `private:${session.userId}`;
+    } else if (data.sub_type === "add") {
+      session.type = "guild-member-request";
+    } else {
+      session.type = "guild-request";
+    }
+  } else if (data.post_type === "notice") {
+    switch (data.notice_type) {
+      case "group_recall":
+        session.type = "message-deleted";
+        session.subtype = "group";
+        break;
+      case "friend_recall":
+        session.type = "message-deleted";
+        session.subtype = "private";
+        session.channelId = `private:${session.userId}`;
+        break;
+      // from go-cqhttp source code, but not mentioned in official docs
+      case "guild_channel_recall":
+        session.type = "message-deleted";
+        session.subtype = "guild";
+        break;
+      case "friend_add":
+        session.type = "friend-added";
+        break;
+      case "group_admin":
+        session.type = "guild-member";
+        session.subtype = "role";
+        break;
+      case "group_ban":
+        session.type = "guild-member";
+        session.subtype = "ban";
+        break;
+      case "group_decrease":
+        session.type = session.userId === session.selfId ? "guild-deleted" : "guild-member-deleted";
+        session.subtype = session.userId === session.operatorId ? "active" : "passive";
+        break;
+      case "group_increase":
+        session.type = session.userId === session.selfId ? "guild-added" : "guild-member-added";
+        session.subtype = session.userId === session.operatorId ? "active" : "passive";
+        break;
+      case "group_card":
+        session.type = "guild-member";
+        session.subtype = "nickname";
+        break;
+      case "notify":
+        session.type = "notice";
+        session.subtype = (0, import_koishi2.hyphenate)(data.sub_type);
+        if (session.subtype === "poke") {
+          session.channelId ||= `private:${session.userId}`;
+        } else if (session.subtype === "honor") {
+          session.subsubtype = (0, import_koishi2.hyphenate)(data.honor_type);
+        }
+        break;
+      case "message_reactions_updated":
+        session.type = "onebot";
+        session.subtype = "message-reactions-updated";
+        break;
+      case "channel_created":
+        session.type = "onebot";
+        session.subtype = "channel-created";
+        break;
+      case "channel_updated":
+        session.type = "onebot";
+        session.subtype = "channel-updated";
+        break;
+      case "channel_destroyed":
+        session.type = "onebot";
+        session.subtype = "channel-destroyed";
+        break;
+      default:
+        return;
+    }
+  } else return;
+  return session;
+}
+__name(adaptSession, "adaptSession");
+
+// src/bot/message.ts
+var import_koishi3 = require("koishi");
+var import_node_url = require("node:url");
+var State = class {
+  constructor(type) {
+    this.type = type;
+  }
+  static {
+    __name(this, "State");
+  }
+  author = {};
+  children = [];
+};
+var PRIVATE_PFX = "private:";
+var OneBotMessageEncoder = class extends import_koishi3.MessageEncoder {
+  static {
+    __name(this, "OneBotMessageEncoder");
+  }
+  stack = [new State("message")];
+  children = [];
+  async prepare() {
+    super.prepare();
+    const { event: { channel } } = this.session;
+    if (!channel.type) {
+      channel.type = channel.id.startsWith(PRIVATE_PFX) ? import_koishi3.Universal.Channel.Type.DIRECT : import_koishi3.Universal.Channel.Type.TEXT;
+    }
+    if (!this.session.isDirect) {
+      this.session.guildId ??= this.channelId;
+    }
+  }
+  async forward() {
+    if (!this.stack[0].children.length) return;
+    const session = this.bot.session();
+    session.content = "";
+    session.messageId = this.session.event.channel.type === import_koishi3.Universal.Channel.Type.DIRECT ? "" + await this.bot.internal.sendPrivateForwardMsg(this.channelId.slice(PRIVATE_PFX.length), this.stack[0].children) : "" + await this.bot.internal.sendGroupForwardMsg(this.channelId, this.stack[0].children);
+    session.userId = this.bot.selfId;
+    session.channelId = this.session.channelId;
+    session.guildId = this.session.guildId;
+    session.isDirect = this.session.isDirect;
+    session.app.emit(session, "send", session);
+    this.results.push(session.event.message);
+  }
+  async flush() {
+    while (true) {
+      const first = this.children[0];
+      if (first?.type !== "text") break;
+      first.data.text = first.data.text.trimStart();
+      if (first.data.text) break;
+      this.children.shift();
+    }
+    while (true) {
+      const last = this.children[this.children.length - 1];
+      if (last?.type !== "text") break;
+      last.data.text = last.data.text.trimEnd();
+      if (last.data.text) break;
+      this.children.pop();
+    }
+    const { type, author } = this.stack[0];
+    if (!this.children.length && !author.messageId) return;
+    if (type === "forward") {
+      if (author.messageId) {
+        this.stack[1].children.push({
+          type: "node",
+          data: {
+            id: author.messageId
+          }
+        });
+      } else {
+        this.stack[1].children.push({
+          type: "node",
+          data: {
+            name: author.name || this.bot.user.name,
+            uin: author.id || this.bot.userId,
+            content: this.children,
+            time: `${Math.floor((+author.time || Date.now()) / 1e3)}`
+          }
+        });
+      }
+      this.children = [];
+      return;
+    }
+    const session = this.bot.session();
+    session.content = "";
+    session.messageId = this.bot.parent ? "" + await this.bot.internal.sendGuildChannelMsg(this.session.guildId, this.channelId, this.children) : this.session.event.channel.type === import_koishi3.Universal.Channel.Type.DIRECT ? "" + await this.bot.internal.sendPrivateMsg(this.channelId.slice(PRIVATE_PFX.length), this.children) : "" + await this.bot.internal.sendGroupMsg(this.channelId, this.children);
+    session.userId = this.bot.selfId;
+    session.channelId = this.session.channelId;
+    session.guildId = this.session.guildId;
+    session.isDirect = this.session.isDirect;
+    session.app.emit(session, "send", session);
+    this.results.push(session.event.message);
+    this.children = [];
+  }
+  async sendFile(attrs) {
+    const src = attrs.src || attrs.url;
+    const name2 = attrs.title || (await this.bot.ctx.http.file(src)).filename;
+    const file = src.startsWith("file:") ? (0, import_node_url.fileURLToPath)(src) : await this.bot.internal.downloadFile(src);
+    if (this.session.event.channel.type === import_koishi3.Universal.Channel.Type.DIRECT) {
+      await this.bot.internal.uploadPrivateFile(
+        this.channelId.slice(PRIVATE_PFX.length),
+        file,
+        name2
+      );
+    } else {
+      await this.bot.internal.uploadGroupFile(
+        this.channelId,
+        file,
+        name2
+      );
+    }
+    const session = this.bot.session();
+    session.messageId = "";
+    session.content = "";
+    session.userId = this.bot.selfId;
+    session.channelId = this.session.channelId;
+    session.guildId = this.session.guildId;
+    session.isDirect = this.session.isDirect;
+    session.app.emit(session, "send", session);
+    this.results.push(session.event.message);
+  }
+  text(text) {
+    this.children.push({ type: "text", data: { text } });
+  }
+  async visit(element) {
+    let { type, attrs, children } = element;
+    if (type === "text") {
+      this.text(attrs.content);
+    } else if (type === "br") {
+      this.text("\n");
+    } else if (type === "p") {
+      const prev = this.children[this.children.length - 1];
+      if (prev?.type === "text") {
+        if (!prev.data.text.endsWith("\n")) {
+          prev.data.text += "\n";
+        }
+      } else {
+        this.text("\n");
+      }
+      await this.render(children);
+      this.text("\n");
+    } else if (type === "at") {
+      if (attrs.type === "all") {
+        this.children.push({ type: "at", data: { qq: "all" } });
+      } else {
+        this.children.push({ type: "at", data: { qq: attrs.id, name: attrs.name } });
+      }
+    } else if (type === "sharp") {
+      if (attrs.id) this.text(attrs.id);
+    } else if (type === "face") {
+      if (attrs.platform && attrs.platform !== this.bot.platform) {
+        await this.render(children);
+      } else {
+        this.children.push({ type: "face", data: { id: attrs.id } });
+      }
+    } else if (type === "a") {
+      await this.render(children);
+      if (attrs.href) this.text(`（${attrs.href}）`);
+    } else if (["video", "audio", "image", "img"].includes(type)) {
+      if (type === "video" || type === "audio") await this.flush();
+      if (type === "audio") type = "record";
+      if (type === "img") type = "image";
+      attrs = { ...attrs };
+      attrs.file = attrs.src || attrs.url;
+      delete attrs.src;
+      delete attrs.url;
+      if (attrs.cache) {
+        attrs.cache = 1;
+      } else {
+        attrs.cache = 0;
+      }
+      const cap = /^data:([\w/.+-]+);base64,/.exec(attrs.file);
+      if (cap) attrs.file = "base64://" + attrs.file.slice(cap[0].length);
+      this.children.push({ type, data: attrs });
+    } else if (type === "file") {
+      await this.flush();
+      await this.sendFile(attrs);
+    } else if (type === "onebot:music") {
+      await this.flush();
+      this.children.push({ type: "music", data: attrs });
+    } else if (type === "onebot:tts") {
+      await this.flush();
+      this.children.push({ type: "tts", data: attrs });
+    } else if (type === "onebot:poke") {
+      await this.flush();
+      this.children.push({ type: "poke", data: attrs });
+    } else if (type === "onebot:gift") {
+      await this.flush();
+      this.children.push({ type: "gift", data: attrs });
+    } else if (type === "onebot:share") {
+      await this.flush();
+      this.children.push({ type: "share", data: attrs });
+    } else if (type === "onebot:json") {
+      await this.flush();
+      this.children.push({ type: "json", data: attrs });
+    } else if (type === "onebot:xml") {
+      await this.flush();
+      this.children.push({ type: "xml", data: attrs });
+    } else if (type === "onebot:cardimage") {
+      await this.flush();
+      this.children.push({ type: "cardimage", data: attrs });
+    } else if (type === "author") {
+      Object.assign(this.stack[0].author, attrs);
+    } else if (type === "figure" && !this.bot.parent) {
+      await this.flush();
+      this.stack.unshift(new State("forward"));
+      await this.render(children);
+      await this.flush();
+      this.stack.shift();
+      await this.forward();
+    } else if (type === "figure") {
+      await this.render(children);
+      await this.flush();
+    } else if (type === "quote") {
+      await this.flush();
+      this.children.push({ type: "reply", data: attrs });
+    } else if (type === "message") {
+      await this.flush();
+      if ("forward" in attrs && !this.bot.parent) {
+        this.stack.unshift(new State("forward"));
+        await this.render(children);
+        await this.flush();
+        this.stack.shift();
+        await this.forward();
+      } else if ("id" in attrs) {
+        this.stack[0].author.messageId = attrs.id.toString();
+      } else {
+        Object.assign(this.stack[0].author, (0, import_koishi3.pick)(attrs, ["userId", "username", "nickname", "time"]));
+        await this.render(children);
+        await this.flush();
+      }
+    } else {
+      await this.render(children);
+    }
+  }
+};
+
+// src/bot/base.ts
+var BaseBot2 = class extends import_koishi4.Bot {
+  static {
+    __name(this, "BaseBot");
+  }
+  static MessageEncoder = OneBotMessageEncoder;
+  static inject = ["http"];
+  parent;
+  internal;
+  async createDirectChannel(userId) {
+    return { id: `${PRIVATE_PFX}${userId}`, type: import_koishi4.Universal.Channel.Type.DIRECT };
+  }
+  async getMessage(channelId, messageId) {
+    const data = await this.internal.getMsg(messageId);
+    return await adaptMessage(this, data);
+  }
+  async deleteMessage(channelId, messageId) {
+    await this.internal.deleteMsg(messageId);
+  }
+  async getLogin() {
+    const data = await this.internal.getLoginInfo();
+    this.user = decodeUser(data);
+    return this.toJSON();
+  }
+  async getUser(userId) {
+    const data = await this.internal.getStrangerInfo(userId);
+    return decodeUser(data);
+  }
+  async getFriendList() {
+    const data = await this.internal.getFriendList();
+    return { data: data.map(decodeUser) };
+  }
+  async handleFriendRequest(messageId, approve, comment) {
+    await this.internal.setFriendAddRequest(messageId, approve, comment);
+  }
+  async handleGuildRequest(messageId, approve, comment) {
+    await this.internal.setGroupAddRequest(messageId, "invite", approve, comment);
+  }
+  async handleGuildMemberRequest(messageId, approve, comment) {
+    await this.internal.setGroupAddRequest(messageId, "add", approve, comment);
+  }
+  async deleteFriend(userId) {
+    await this.internal.deleteFriend(userId);
+  }
+  async getMessageList(channelId, before, direction = "before") {
+    if (direction !== "before") throw new Error("Unsupported direction.");
+    let list;
+    if (before) {
+      const msg = await this.internal.getMsg(before);
+      if (msg?.message_seq) {
+        list = (await this.internal.getGroupMsgHistory(Number(channelId), msg.message_seq)).messages;
+      }
+    } else {
+      list = (await this.internal.getGroupMsgHistory(Number(channelId))).messages;
+    }
+    return { data: await Promise.all(list.map((item) => adaptMessage(this, item))) };
+  }
+};
+((BaseBot3) => {
+  BaseBot3.AdvancedConfig = import_koishi4.Schema.object({
+    splitMixedContent: import_koishi4.Schema.boolean().description("是否自动在混合内容间插入空格。").default(true)
+  }).description("高级设置");
+})(BaseBot2 || (BaseBot2 = {}));
+
+// src/bot/qqguild.ts
+var QQGuildBot = class extends BaseBot2 {
+  static {
+    __name(this, "QQGuildBot");
+  }
+  hidden = true;
+  constructor(ctx, config) {
+    super(ctx, config, "qqguild");
+    this.platform = "qqguild";
+    this.selfId = config.profile.tiny_id;
+    this.parent = config.parent;
+    this.internal = config.parent.internal;
+    this.user.name = config.profile.nickname;
+    this.user.avatar = config.profile.avatar_url;
+    this.parent.guildBot = this;
+  }
+  get status() {
+    return this.parent.status;
+  }
+  set status(status) {
+    this.parent.status = status;
+  }
+  async start() {
+    await this.context.parallel("bot-connect", this);
+  }
+  async stop() {
+    if (!this.parent) return;
+    this.parent = void 0;
+    await this.context.parallel("bot-disconnect", this);
+  }
+  async getChannel(channelId, guildId) {
+    const { data } = await this.getChannelList(guildId);
+    return data.find((channel) => channel.id === channelId);
+  }
+  async getChannelList(guildId) {
+    const data = await this.internal.getGuildChannelList(guildId, false);
+    return { data: (data || []).map(adaptChannel) };
+  }
+  async getGuild(guildId) {
+    const data = await this.internal.getGuildMetaByGuest(guildId);
+    return adaptGuild(data);
+  }
+  async getGuildList() {
+    const data = await this.internal.getGuildList();
+    return { data: data.map(adaptGuild) };
+  }
+  async getGuildMember(guildId, userId) {
+    const profile = await this.internal.getGuildMemberProfile(guildId, userId);
+    return adaptQQGuildMemberProfile(profile);
+  }
+  async getGuildMemberList(guildId) {
+    let nextToken;
+    let list = [];
+    while (true) {
+      const data = await this.internal.getGuildMemberList(guildId, nextToken);
+      if (!data.members?.length) break;
+      list = list.concat(data.members.map(adaptQQGuildMemberInfo));
+      if (data.finished) break;
+      nextToken = data.next_token;
+    }
+    return { data: list };
+  }
+};
+
+// src/ws.ts
+var import_koishi5 = require("koishi");
+var WsClient = class extends import_koishi5.Adapter.WsClient {
+  static {
+    __name(this, "WsClient");
+  }
+  accept(socket) {
+    accept(socket, this.bot);
+  }
+  prepare() {
+    const { token, endpoint } = this.bot.config;
+    const http = this.ctx.http.extend(this.bot.config);
+    if (token) http.config.headers.Authorization = `Bearer ${token}`;
+    return http.ws(endpoint);
+  }
+};
+((WsClient2) => {
+  WsClient2.Options = import_koishi5.Schema.intersect([
+    import_koishi5.Schema.object({
+      protocol: import_koishi5.Schema.const("ws").required(process.env.KOISHI_ENV !== "browser"),
+      endpoint: import_koishi5.Schema.string().description("OneBot 实现的 WebSocket 服务器地址。").required(),
+      responseTimeout: import_koishi5.Schema.natural().role("time").default(import_koishi5.Time.minute).description("等待响应的时间 (单位为毫秒)。")
+    }).description("连接设置"),
+    import_koishi5.HTTP.createConfig(true),
+    import_koishi5.Adapter.WsClientConfig
+  ]);
+})(WsClient || (WsClient = {}));
+var kSocket = Symbol("socket");
+var WsServer = class extends import_koishi5.Adapter {
+  static {
+    __name(this, "WsServer");
+  }
+  static inject = ["server"];
+  logger;
+  wsServer;
+  constructor(ctx, bot) {
+    super(ctx);
+    this.logger = ctx.logger("onebot");
+    const { path = "/onebot" } = bot.config;
+    this.wsServer = ctx.server.ws(path, (socket, { headers }) => {
+      this.logger.debug("connected with", headers);
+      if (headers["x-client-role"] !== "Universal") {
+        return socket.close(1008, "invalid x-client-role");
+      }
+      const selfId = headers["x-self-id"]?.toString();
+      const bot2 = this.bots.find((bot3) => bot3.selfId === selfId);
+      if (!bot2) return socket.close(1008, "invalid x-self-id");
+      this.logger.info(`Bot ${selfId} 已连接 (ws-reverse)`);
+      bot2[kSocket] = socket;
+      accept(socket, bot2);
+    });
+    ctx.on("dispose", () => {
+      this.logger.debug("ws server closing");
+      this.wsServer.close();
+    });
+  }
+  async disconnect(bot) {
+    bot[kSocket]?.close();
+    bot[kSocket] = null;
+  }
+};
+((WsServer2) => {
+  WsServer2.Options = import_koishi5.Schema.object({
+    protocol: import_koishi5.Schema.const("ws-reverse").required(process.env.KOISHI_ENV === "browser"),
+    path: import_koishi5.Schema.string().description("服务器监听的路径。").default("/onebot"),
+    responseTimeout: import_koishi5.Schema.natural().role("time").default(import_koishi5.Time.minute).description("等待响应的时间 (单位为毫秒)。")
+  }).description("连接设置");
+})(WsServer || (WsServer = {}));
+var counter = 0;
+var listeners = {};
+function accept(socket, bot) {
+  socket.addEventListener("message", ({ data }) => {
+    let parsed;
+    const strData = data.toString();
+    try {
+      parsed = JSON.parse(strData);
+    } catch (error) {
+      return bot.logger.warn("cannot parse message", strData);
+    }
+    if ("post_type" in parsed) {
+      bot.logger.debug("[receive] %o", parsed);
+      dispatchSession(bot, parsed);
+    } else if (parsed.echo in listeners) {
+      listeners[parsed.echo](parsed);
+      delete listeners[parsed.echo];
+    }
+  });
+  socket.addEventListener("close", () => {
+    delete bot.internal._request;
+    bot.offline();
+  });
+  bot.internal._request = (action, params) => {
+    const data = { action, params, echo: ++counter };
+    data.echo = ++counter;
+    return new Promise((resolve, reject) => {
+      listeners[data.echo] = resolve;
+      setTimeout(() => {
+        delete listeners[data.echo];
+        reject(new TimeoutError(params, action));
+      }, bot.config.responseTimeout);
+      socket.send(JSON.stringify(data));
+    });
+  };
+  bot.initialize();
+}
+__name(accept, "accept");
+
+// src/heartbeat.ts
+var import_koishi6 = require("koishi");
+var HeartbeatMonitor = class {
+  constructor(ctx, bot, interval) {
+    this.ctx = ctx;
+    this.bot = bot;
+    this.interval = interval;
+    this.logger = ctx.logger("onebot-heartbeat");
+  }
+  static {
+    __name(this, "HeartbeatMonitor");
+  }
+  timer = null;
+  logger;
+  lastOnlineState = null;
+  start() {
+    if (this.timer) return;
+    this.logger.debug(`Bot ${this.bot.selfId} 心跳检测已启动，间隔 ${this.interval}ms`);
+    this.check();
+    this.timer = setInterval(() => this.check(), this.interval);
+    this.ctx.on("dispose", () => this.stop());
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+      this.logger.debug(`Bot ${this.bot.selfId} 心跳检测已停止`);
+    }
+  }
+  async check() {
+    try {
+      const status = await this.bot.internal.getStatus();
+      const isOnline = status?.online ?? false;
+      if (this.lastOnlineState === isOnline) return;
+      this.logger.info(`Bot ${this.bot.selfId} 状态变化: ${this.lastOnlineState} -> ${isOnline}`);
+      this.lastOnlineState = isOnline;
+      if (isOnline) {
+        if (this.bot.status !== import_koishi6.Universal.Status.ONLINE) {
+          this.bot.online();
+          this.ctx.emit("onebot-multi/bot-online", this.bot);
+        }
+      } else {
+        if (this.bot.status === import_koishi6.Universal.Status.ONLINE) {
+          this.bot.offline();
+          this.ctx.emit("onebot-multi/bot-offline", this.bot);
+        }
+      }
+    } catch (error) {
+      this.logger.warn(`Bot ${this.bot.selfId} 心跳检测失败:`, error);
+      if (this.lastOnlineState !== false) {
+        this.lastOnlineState = false;
+        if (this.bot.status === import_koishi6.Universal.Status.ONLINE) {
+          this.bot.offline(error);
+          this.ctx.emit("onebot-multi/bot-offline", this.bot);
+        }
+      }
+    }
+  }
+};
+
+// src/bot/cqcode.ts
+var import_koishi7 = require("koishi");
+function CQCode(type, attrs) {
+  if (type === "text") return attrs.content;
+  let output = "[CQ:" + type;
+  for (const key in attrs) {
+    if (attrs[key]) output += `,${key}=${import_koishi7.h.escape(attrs[key], true)}`;
+  }
+  return output + "]";
+}
+__name(CQCode, "CQCode");
+((CQCode2) => {
+  function escape(source, inline = false) {
+    const result = String(source).replace(/&/g, "&amp;").replace(/\[/g, "&#91;").replace(/\]/g, "&#93;");
+    return inline ? result.replace(/,/g, "&#44;").replace(/(\ud83c[\udf00-\udfff])|(\ud83d[\udc00-\ude4f\ude80-\udeff])|[\u2600-\u2B55]/g, " ") : result;
+  }
+  CQCode2.escape = escape;
+  __name(escape, "escape");
+  function unescape(source) {
+    return String(source).replace(/&#91;/g, "[").replace(/&#93;/g, "]").replace(/&#44;/g, ",").replace(/&amp;/g, "&");
+  }
+  CQCode2.unescape = unescape;
+  __name(unescape, "unescape");
+  const pattern = /\[CQ:(\w+)((,\w+=[^,\]]*)*)\]/;
+  function from(source) {
+    const capture = pattern.exec(source);
+    if (!capture) return null;
+    const [, type, attrs] = capture;
+    const data = {};
+    attrs && attrs.slice(1).split(",").forEach((str) => {
+      const index = str.indexOf("=");
+      data[str.slice(0, index)] = unescape(str.slice(index + 1));
+    });
+    return { type, data, capture };
+  }
+  CQCode2.from = from;
+  __name(from, "from");
+  function parse(source) {
+    if (typeof source !== "string") {
+      return source.map(({ type, data }) => {
+        if (type === "text") {
+          return (0, import_koishi7.h)("text", { content: data.text });
+        } else {
+          return (0, import_koishi7.h)(type, data);
+        }
+      });
+    }
+    const elements = [];
+    let result;
+    while (result = from(source)) {
+      const { type, data, capture } = result;
+      if (capture.index) {
+        elements.push((0, import_koishi7.h)("text", { content: unescape(source.slice(0, capture.index)) }));
+      }
+      elements.push((0, import_koishi7.h)(type, data));
+      source = source.slice(capture.index + capture[0].length);
+    }
+    if (source) elements.push((0, import_koishi7.h)("text", { content: unescape(source) }));
+    return elements;
+  }
+  CQCode2.parse = parse;
+  __name(parse, "parse");
+})(CQCode || (CQCode = {}));
+
+// src/bot/index.ts
+var OneBotBot = class extends BaseBot2 {
+  static {
+    __name(this, "OneBotBot");
+  }
+  guildBot;
+  heartbeat;
+  constructor(ctx, config) {
+    super(ctx, config, "onebot");
+    this.selfId = config.selfId;
+    this.internal = new Internal(this);
+    this.user.avatar = `http://q.qlogo.cn/headimg_dl?dst_uin=${config.selfId}&spec=640`;
+    if (config.protocol === "ws") {
+      ctx.plugin(WsClient, this);
+    } else {
+      ctx.plugin(WsServer, this);
+    }
+    if (config.heartbeatInterval > 0) {
+      this.heartbeat = new HeartbeatMonitor(ctx, this, config.heartbeatInterval);
+    }
+  }
+  async stop() {
+    if (this.guildBot) {
+      delete this.ctx.bots[this.guildBot.sid];
+    }
+    await super.stop();
+  }
+  async initialize() {
+    await Promise.all([
+      this.getLogin(),
+      this.setupGuildService().catch(import_koishi8.noop)
+    ]).then(() => {
+      this.online();
+      this.ctx.emit("onebot-multi/bot-online", this);
+      this.heartbeat?.start();
+    }, (error) => this.offline(error));
+  }
+  async setupGuildService() {
+    const profile = await this.internal.getGuildServiceProfile();
+    if (!profile?.tiny_id || profile.tiny_id === "0") return;
+    this.ctx.plugin(QQGuildBot, {
+      profile,
+      parent: this,
+      advanced: this.config.advanced
+    });
+  }
+  async getChannel(channelId) {
+    const data = await this.internal.getGroupInfo(channelId);
+    return adaptChannel(data);
+  }
+  async getGuild(guildId) {
+    const data = await this.internal.getGroupInfo(guildId);
+    return adaptGuild(data);
+  }
+  async getGuildList() {
+    const data = await this.internal.getGroupList();
+    return { data: data.map(adaptGuild) };
+  }
+  async getChannelList(guildId) {
+    return { data: [await this.getChannel(guildId)] };
+  }
+  async getGuildMember(guildId, userId) {
+    const data = await this.internal.getGroupMemberInfo(guildId, userId);
+    return decodeGuildMember(data);
+  }
+  async getGuildMemberList(guildId) {
+    const data = await this.internal.getGroupMemberList(guildId);
+    return { data: data.map(decodeGuildMember) };
+  }
+  async kickGuildMember(guildId, userId, permanent) {
+    return this.internal.setGroupKick(guildId, userId, permanent);
+  }
+  async muteGuildMember(guildId, userId, duration) {
+    return this.internal.setGroupBan(guildId, userId, Math.round(duration / 1e3));
+  }
+  async muteChannel(channelId, guildId, enable) {
+    return this.internal.setGroupWholeBan(channelId, enable);
+  }
+  async checkPermission(name2, session) {
+    if (name2 === "onebot.group.admin") {
+      return session.author?.roles?.[0] === "admin";
+    } else if (name2 === "onebot.group.owner") {
+      return session.author?.roles?.[0] === "owner";
+    }
+    return super.checkPermission(name2, session);
+  }
+};
+((OneBotBot2) => {
+  OneBotBot2.BaseConfig = import_koishi8.Schema.object({
+    selfId: import_koishi8.Schema.string().description("机器人的账号。").required(),
+    token: import_koishi8.Schema.string().role("secret").description("发送信息时用于验证的字段，应与 OneBot 配置文件中的 `access_token` 保持一致。"),
+    protocol: process.env.KOISHI_ENV === "browser" ? import_koishi8.Schema.const("ws").default("ws") : import_koishi8.Schema.union(["ws", "ws-reverse"]).description("选择要使用的协议。").default("ws-reverse"),
+    heartbeatInterval: import_koishi8.Schema.natural().role("ms").description("心跳检测间隔（毫秒），设为 0 禁用。").default(3e4)
+  });
+  OneBotBot2.Config = import_koishi8.Schema.intersect([
+    OneBotBot2.BaseConfig,
+    import_koishi8.Schema.union([
+      WsClient.Options,
+      WsServer.Options
+    ]),
+    import_koishi8.Schema.object({
+      advanced: BaseBot2.AdvancedConfig
+    })
+  ]);
+})(OneBotBot || (OneBotBot = {}));
+
+// src/status.ts
+var import_koishi9 = require("koishi");
+var StatusManager = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    ctx.on("onebot-multi/bot-online", async (bot) => {
+      await this.fetchBotInfo(bot);
+    });
+    ctx.on("onebot-multi/bot-offline", (bot) => {
+      const cached = this.cache.get(bot.selfId);
+      if (cached) {
+        cached.lastHeartbeat = Date.now();
+      }
+    });
+  }
+  static {
+    __name(this, "StatusManager");
+  }
+  // 缓存额外信息（统计数据等）
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * 获取 Bot 的额外信息（统计、群数等）
+   */
+  async fetchBotInfo(bot) {
+    const cached = this.cache.get(bot.selfId) || {};
+    try {
+      const status = await bot.internal.getStatus();
+      if (status?.stat) {
+        cached.messageReceived = status.stat.message_received;
+        cached.messageSent = status.stat.message_sent;
+        cached.lastMessageTime = status.stat.last_message_time;
+        cached.startupTime = status.stat.startup_time;
+      }
+      try {
+        const groups = await bot.internal.getGroupList();
+        cached.groupCount = groups?.length || 0;
+      } catch {
+      }
+      try {
+        const friends = await bot.internal.getFriendList();
+        cached.friendCount = friends?.length || 0;
+      } catch {
+      }
+      cached.lastHeartbeat = Date.now();
+      this.cache.set(bot.selfId, cached);
+    } catch (error) {
+      this.ctx.logger.warn(`获取 Bot ${bot.selfId} 信息失败:`, error);
+    }
+  }
+  /**
+   * 从 ctx.bots 获取实时状态
+   */
+  getStatus() {
+    const bots = [];
+    for (const bot of this.ctx.bots) {
+      if (bot.platform !== "onebot") continue;
+      const onebotBot = bot;
+      const config = onebotBot.config;
+      const cached = this.cache.get(bot.selfId) || {};
+      let status = "offline";
+      switch (bot.status) {
+        case import_koishi9.Universal.Status.ONLINE:
+          status = "online";
+          break;
+        case import_koishi9.Universal.Status.CONNECT:
+          status = "connecting";
+          break;
+        default:
+          status = "offline";
+      }
+      bots.push({
+        selfId: bot.selfId,
+        nickname: bot.user?.name,
+        protocol: config.protocol || "ws-reverse",
+        status,
+        endpoint: config.endpoint,
+        path: config.path,
+        messageReceived: cached.messageReceived,
+        messageSent: cached.messageSent,
+        lastMessageTime: cached.lastMessageTime,
+        startupTime: cached.startupTime,
+        groupCount: cached.groupCount,
+        friendCount: cached.friendCount,
+        lastHeartbeat: cached.lastHeartbeat
+      });
+    }
+    return {
+      bots,
+      updatedAt: Date.now()
+    };
+  }
+  /**
+   * 刷新所有 Bot 的信息
+   */
+  async refreshAll() {
+    for (const bot of this.ctx.bots) {
+      if (bot.platform !== "onebot") continue;
+      if (bot.status === import_koishi9.Universal.Status.ONLINE) {
+        await this.fetchBotInfo(bot);
+      }
+    }
+    return this.getStatus();
+  }
+  getBotStatus(selfId) {
+    const status = this.getStatus();
+    return status.bots.find((b) => b.selfId === selfId);
+  }
+};
+
+// src/panel.ts
+var import_koa = __toESM(require("koa"));
+var import_router = __toESM(require("@koa/router"));
+var import_koishi10 = require("koishi");
+var import_crypto = require("crypto");
+var SERVER_SECRET = (0, import_crypto.randomBytes)(32).toString("hex");
+var TOKEN_EXPIRY = 24 * 60 * 60 * 1e3;
+function generateSignedToken() {
+  const payload = {
+    iat: Date.now(),
+    exp: Date.now() + TOKEN_EXPIRY
+  };
+  const payloadStr = Buffer.from(JSON.stringify(payload)).toString("base64url");
+  const signature = (0, import_crypto.createHash)("sha256").update(payloadStr + SERVER_SECRET).digest("base64url");
+  return `${payloadStr}.${signature}`;
+}
+__name(generateSignedToken, "generateSignedToken");
+function verifySignedToken(token) {
+  try {
+    const [payloadStr, signature] = token.split(".");
+    if (!payloadStr || !signature) return false;
+    const expectedSig = (0, import_crypto.createHash)("sha256").update(payloadStr + SERVER_SECRET).digest("base64url");
+    if (signature !== expectedSig) return false;
+    const payload = JSON.parse(Buffer.from(payloadStr, "base64url").toString());
+    if (Date.now() > payload.exp) return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(verifySignedToken, "verifySignedToken");
+var PanelConfig = import_koishi10.Schema.object({
+  enabled: import_koishi10.Schema.boolean().default(false).description("是否启用状态展示面板。"),
+  port: import_koishi10.Schema.natural().default(8212).description("面板端口。"),
+  basePath: import_koishi10.Schema.string().default("/status").description("面板路径。")
+}).description("展示面板");
+var StatusPanel = class {
+  constructor(ctx, config, statusManager, configManager) {
+    this.ctx = ctx;
+    this.config = config;
+    this.statusManager = statusManager;
+    this.configManager = configManager;
+    if (!config.enabled) return;
+    this.app = new import_koa.default();
+    this.setupRoutes();
+    this.start();
+    ctx.on("dispose", () => this.stop());
+  }
+  static {
+    __name(this, "StatusPanel");
+  }
+  app;
+  server = null;
+  async parseJsonBody(ctx) {
+    return new Promise((resolve, reject) => {
+      let body = "";
+      ctx.req.on("data", (chunk) => {
+        body += chunk.toString();
+      });
+      ctx.req.on("end", () => {
+        try {
+          resolve(body ? JSON.parse(body) : {});
+        } catch (e) {
+          reject(new Error("Invalid JSON"));
+        }
+      });
+      ctx.req.on("error", reject);
+    });
+  }
+  setupRoutes() {
+    const router = new import_router.default();
+    const basePath = this.config.basePath || "/status";
+    router.get(`${basePath}/api/status`, (ctx) => {
+      const status = this.statusManager.getStatus();
+      ctx.body = {
+        bots: status.bots.map((bot) => ({
+          selfId: bot.selfId,
+          nickname: bot.nickname,
+          status: bot.status,
+          groupCount: bot.groupCount,
+          friendCount: bot.friendCount,
+          messageReceived: bot.messageReceived,
+          messageSent: bot.messageSent
+          // 不返回: protocol, endpoint, path, token 等敏感信息
+        })),
+        updatedAt: status.updatedAt
+      };
+    });
+    router.get(basePath, (ctx) => {
+      ctx.type = "html";
+      ctx.body = this.renderStatusPage();
+    });
+    const adminPath = `${basePath}/admin`;
+    const authMiddleware = /* @__PURE__ */ __name(async (ctx, next) => {
+      const cookies = ctx.headers.cookie || "";
+      const tokenMatch = cookies.match(/ob_admin_token=([^;]+)/);
+      const token = tokenMatch ? tokenMatch[1] : null;
+      if (!token || !verifySignedToken(token)) {
+        ctx.status = 401;
+        ctx.body = { error: "未授权访问" };
+        return;
+      }
+      await next();
+    }, "authMiddleware");
+    router.get(`${adminPath}/api/check-init`, async (ctx) => {
+      const hasPassword = await this.configManager.hasAdminPassword();
+      ctx.body = { needsInit: !hasPassword };
+    });
+    router.get(`${adminPath}/api/check-auth`, async (ctx) => {
+      const cookies = ctx.headers.cookie || "";
+      const tokenMatch = cookies.match(/ob_admin_token=([^;]+)/);
+      const token = tokenMatch ? tokenMatch[1] : null;
+      ctx.body = { authenticated: token && verifySignedToken(token) };
+    });
+    router.post(`${adminPath}/api/init-password`, async (ctx) => {
+      const hasPassword = await this.configManager.hasAdminPassword();
+      if (hasPassword) {
+        ctx.status = 400;
+        ctx.body = { error: "密码已设置" };
+        return;
+      }
+      const data = await this.parseJsonBody(ctx);
+      if (!data.password || data.password.length < 4) {
+        ctx.status = 400;
+        ctx.body = { error: "密码至少需要4位" };
+        return;
+      }
+      await this.configManager.setAdminPassword(data.password);
+      this.ctx.logger.info("管理密码已设置");
+      const token = generateSignedToken();
+      ctx.set("Set-Cookie", `ob_admin_token=${token}; Path=/; HttpOnly; SameSite=Lax; Max-Age=${TOKEN_EXPIRY / 1e3}`);
+      ctx.body = { success: true };
+    });
+    router.post(`${adminPath}/api/login`, async (ctx) => {
+      const data = await this.parseJsonBody(ctx);
+      const valid = await this.configManager.verifyAdminPassword(data.password || "");
+      this.ctx.logger.debug(`登录尝试: ${valid ? "成功" : "失败"}`);
+      if (valid) {
+        const token = generateSignedToken();
+        this.ctx.logger.debug(`生成签名 token`);
+        ctx.set("Set-Cookie", `ob_admin_token=${token}; Path=/; HttpOnly; SameSite=Lax; Max-Age=${TOKEN_EXPIRY / 1e3}`);
+        ctx.body = { success: true };
+      } else {
+        ctx.status = 401;
+        ctx.body = { error: "密码错误" };
+      }
+    });
+    router.post(`${adminPath}/api/logout`, async (ctx) => {
+      ctx.set("Set-Cookie", `ob_admin_token=; Path=/; HttpOnly; Max-Age=0`);
+      ctx.body = { success: true };
+    });
+    router.get(adminPath, async (ctx) => {
+      const hasPassword = await this.configManager.hasAdminPassword();
+      ctx.type = "html";
+      ctx.set("Cache-Control", "no-store, no-cache, must-revalidate");
+      ctx.set("Pragma", "no-cache");
+      if (!hasPassword) {
+        ctx.body = this.renderSetupPage();
+      } else {
+        const cookies = ctx.headers.cookie || "";
+        const tokenMatch = cookies.match(/ob_admin_token=([^;]+)/);
+        const token = tokenMatch ? tokenMatch[1] : null;
+        const isValid = token && verifySignedToken(token);
+        this.ctx.logger.debug(`访问管理面板: token=${token ? "存在" : "无"}, 有效=${isValid}`);
+        if (isValid) {
+          ctx.body = this.renderAdminPage();
+        } else {
+          ctx.body = this.renderLoginPage();
+        }
+      }
+    });
+    router.get(`${adminPath}/api/list`, authMiddleware, async (ctx) => {
+      const configs = await this.configManager.getAllConfigs();
+      const status = this.statusManager.getStatus();
+      const bots = configs.map((config) => {
+        const botStatus = status.bots.find((b) => b.selfId === config.selfId);
+        return {
+          selfId: config.selfId,
+          nickname: botStatus?.nickname,
+          protocol: config.protocol,
+          status: botStatus?.status || "offline",
+          endpoint: config.endpoint,
+          path: config.path,
+          enabled: config.enabled,
+          messageReceived: botStatus?.messageReceived,
+          messageSent: botStatus?.messageSent,
+          lastMessageTime: botStatus?.lastMessageTime,
+          startupTime: botStatus?.startupTime,
+          groupCount: botStatus?.groupCount,
+          friendCount: botStatus?.friendCount
+        };
+      });
+      ctx.body = { bots, updatedAt: Date.now() };
+    });
+    router.post(`${adminPath}/api/create`, authMiddleware, async (ctx) => {
+      const data = await this.parseJsonBody(ctx);
+      if (!data.selfId) {
+        ctx.status = 400;
+        ctx.body = { error: "selfId 不能为空" };
+        return;
+      }
+      const existing = await this.configManager.getConfig(data.selfId);
+      if (existing) {
+        ctx.status = 400;
+        ctx.body = { error: `Bot ${data.selfId} 已存在` };
+        return;
+      }
+      if (data.protocol === "ws" && !data.endpoint) {
+        ctx.status = 400;
+        ctx.body = { error: "WS 协议需要配置 endpoint" };
+        return;
+      }
+      const record = await this.configManager.createConfig({
+        selfId: data.selfId,
+        token: data.token,
+        protocol: data.protocol || "ws-reverse",
+        endpoint: data.endpoint,
+        path: data.path || "/onebot",
+        enabled: true
+      });
+      this.ctx.logger.info(`创建 Bot 配置: ${data.selfId}`);
+      await this.startBot(this.configManager.toBotConfig(record));
+      ctx.body = { success: true };
+    });
+    router.post(`${adminPath}/api/update`, authMiddleware, async (ctx) => {
+      const data = await this.parseJsonBody(ctx);
+      const existing = await this.configManager.getConfig(data.selfId);
+      if (!existing) {
+        ctx.status = 404;
+        ctx.body = { error: `Bot ${data.selfId} 不存在` };
+        return;
+      }
+      if (data.updates?.protocol === "ws" && !data.updates?.endpoint && !existing.endpoint) {
+        ctx.status = 400;
+        ctx.body = { error: "WS 协议需要配置 endpoint" };
+        return;
+      }
+      await this.configManager.updateConfig(data.selfId, data.updates);
+      this.ctx.logger.info(`更新 Bot 配置: ${data.selfId}`);
+      ctx.body = { success: true, needRestart: true };
+    });
+    router.post(`${adminPath}/api/delete`, authMiddleware, async (ctx) => {
+      const data = await this.parseJsonBody(ctx);
+      const selfId = data.selfId;
+      const existing = await this.configManager.getConfig(selfId);
+      if (!existing) {
+        ctx.status = 404;
+        ctx.body = { error: `Bot ${selfId} 不存在` };
+        return;
+      }
+      await this.stopBot(selfId);
+      await this.configManager.deleteConfig(selfId);
+      this.ctx.logger.info(`删除 Bot 配置: ${selfId}`);
+      ctx.body = { success: true };
+    });
+    router.post(`${adminPath}/api/toggle`, authMiddleware, async (ctx) => {
+      const data = await this.parseJsonBody(ctx);
+      const selfId = data.selfId;
+      const existing = await this.configManager.getConfig(selfId);
+      if (!existing) {
+        ctx.status = 404;
+        ctx.body = { error: `Bot ${selfId} 不存在` };
+        return;
+      }
+      const newEnabled = !existing.enabled;
+      await this.configManager.updateConfig(selfId, { enabled: newEnabled });
+      if (newEnabled) {
+        const config = await this.configManager.getConfig(selfId);
+        if (config) {
+          await this.startBot(this.configManager.toBotConfig(config));
+        }
+      } else {
+        await this.stopBot(selfId);
+      }
+      this.ctx.logger.info(`${newEnabled ? "启用" : "禁用"} Bot: ${selfId}`);
+      ctx.body = { success: true, enabled: newEnabled };
+    });
+    router.post(`${adminPath}/api/restart`, authMiddleware, async (ctx) => {
+      const data = await this.parseJsonBody(ctx);
+      const selfId = data.selfId;
+      const config = await this.configManager.getConfig(selfId);
+      if (!config) {
+        ctx.status = 404;
+        ctx.body = { error: `Bot ${selfId} 不存在` };
+        return;
+      }
+      if (!config.enabled) {
+        ctx.status = 400;
+        ctx.body = { error: `Bot ${selfId} 未启用` };
+        return;
+      }
+      await this.stopBot(selfId);
+      await this.startBot(this.configManager.toBotConfig(config));
+      this.ctx.logger.info(`重启 Bot: ${selfId}`);
+      ctx.body = { success: true };
+    });
+    this.app.use(router.routes());
+    this.app.use(router.allowedMethods());
+  }
+  async startBot(config) {
+    const existing = this.ctx.bots.find((b) => b.selfId === config.selfId && b.platform === "onebot");
+    if (existing) {
+      this.ctx.logger.warn(`Bot ${config.selfId} 已在运行`);
+      return;
+    }
+    const globalConfig = this.ctx._onebotMultiGlobalConfig || {};
+    const fullConfig = {
+      ...globalConfig,
+      ...config,
+      protocol: config.protocol || "ws-reverse"
+    };
+    this.ctx.plugin(OneBotBot, fullConfig);
+  }
+  async stopBot(selfId) {
+    const bot = this.ctx.bots.find((b) => b.selfId === selfId && b.platform === "onebot");
+    if (bot) {
+      await bot.stop();
+      delete this.ctx.bots[bot.sid];
+    }
+  }
+  start() {
+    const port = this.config.port || 8212;
+    this.server = this.app.listen(port, () => {
+      this.ctx.logger.info(`状态面板已启动: http://localhost:${port}${this.config.basePath}`);
+      this.ctx.logger.info(`管理面板已启动: http://localhost:${port}${this.config.basePath}/admin`);
+    });
+  }
+  stop() {
+    if (this.server) {
+      this.server.close();
+      this.ctx.logger.info("状态面板已关闭");
+    }
+  }
+  renderLoginPage() {
+    const basePath = this.config.basePath || "/status";
+    return `<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>OneBot Multi - 管理登录</title>
+  <link href="https://fonts.googleapis.com/css2?family=Fredoka+One&family=Noto+Sans+SC:wght@400;700;900&display=swap" rel="stylesheet">
+  <style>
+    :root {
+      --nl-primary: #fbbf24;
+      --nl-bg: #fffbeb;
+      --nl-surface: #ffffff;
+      --nl-text: #451a03;
+      --nl-border: 3px solid #451a03;
+      --nl-shadow: 4px 4px 0 #451a03;
+    }
+
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+
+    body {
+      font-family: 'Noto Sans SC', 'Segoe UI', sans-serif;
+      background-color: var(--nl-bg);
+      background-image:
+        radial-gradient(#fde68a 1px, transparent 1px),
+        radial-gradient(#fde68a 1px, transparent 1px);
+      background-size: 20px 20px;
+      background-position: 0 0, 10px 10px;
+      color: var(--nl-text);
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      padding: 2rem;
+    }
+
+    .login-box {
+      background: var(--nl-surface);
+      padding: 3rem;
+      border: var(--nl-border);
+      box-shadow: var(--nl-shadow);
+      border-radius: 16px;
+      max-width: 400px;
+      width: 100%;
+      text-align: center;
+    }
+
+    h1 {
+      font-family: 'Fredoka One', 'Noto Sans SC', cursive;
+      font-size: 1.8rem;
+      margin-bottom: 2rem;
+      text-shadow: 2px 2px 0 #fff;
+    }
+
+    .form-group {
+      margin-bottom: 1.5rem;
+    }
+
+    label {
+      display: block;
+      font-weight: 700;
+      margin-bottom: 0.5rem;
+      text-align: left;
+    }
+
+    input[type="password"] {
+      width: 100%;
+      padding: 1rem;
+      border: var(--nl-border);
+      border-radius: 8px;
+      font-size: 1rem;
+      font-family: inherit;
+    }
+
+    input[type="password"]:focus {
+      outline: none;
+      box-shadow: 0 0 0 3px #fbbf24;
+    }
+
+    .btn {
+      background: var(--nl-primary);
+      border: var(--nl-border);
+      color: var(--nl-text);
+      padding: 1rem 2rem;
+      border-radius: 12px;
+      cursor: pointer;
+      font-size: 1.1rem;
+      font-weight: 800;
+      box-shadow: var(--nl-shadow);
+      transition: all 0.1s;
+      width: 100%;
+    }
+
+    .btn:hover {
+      transform: translate(-1px, -1px);
+      box-shadow: 5px 5px 0 #451a03;
+    }
+
+    .btn:active {
+      transform: translate(1px, 1px);
+      box-shadow: 2px 2px 0 #451a03;
+    }
+
+    .error {
+      color: #b91c1c;
+      margin-top: 1rem;
+      display: none;
+    }
+  </style>
+</head>
+<body>
+  <div class="login-box">
+    <h1>🔐 管理登录</h1>
+    <form id="loginForm">
+      <div class="form-group">
+        <label for="adminKey">管理密钥</label>
+        <input type="password" id="adminKey" placeholder="请输入管理密钥" required>
+      </div>
+      <button type="submit" class="btn">登录</button>
+      <p class="error" id="error">密钥错误</p>
+    </form>
+  </div>
+
+  <script>
+    document.getElementById('loginForm').addEventListener('submit', async function(e) {
+      e.preventDefault()
+      const password = document.getElementById('adminKey').value
+      const errorEl = document.getElementById('error')
+      const btn = this.querySelector('button[type="submit"]')
+      btn.disabled = true
+      btn.textContent = '登录中...'
+
+      try {
+        const res = await fetch('${basePath}/admin/api/login', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ password }),
+          credentials: 'include'
+        })
+        const data = await res.json()
+        if (data.success) {
+          // 短暂延迟确保 Cookie 已设置
+          setTimeout(() => {
+            window.location.href = '${basePath}/admin'
+          }, 100)
+        } else {
+          errorEl.textContent = data.error || '登录失败'
+          errorEl.style.display = 'block'
+          btn.disabled = false
+          btn.textContent = '登录'
+        }
+      } catch (e) {
+        errorEl.textContent = '网络错误'
+        errorEl.style.display = 'block'
+        btn.disabled = false
+        btn.textContent = '登录'
+      }
+    })
+  </script>
+</body>
+</html>`;
+  }
+  renderSetupPage() {
+    const basePath = this.config.basePath || "/status";
+    return `<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>OneBot Multi - 初始设置</title>
+  <link href="https://fonts.googleapis.com/css2?family=Fredoka+One&family=Noto+Sans+SC:wght@400;700;900&display=swap" rel="stylesheet">
+  <style>
+    :root {
+      --nl-primary: #fbbf24;
+      --nl-bg: #fffbeb;
+      --nl-surface: #ffffff;
+      --nl-text: #451a03;
+      --nl-border: 3px solid #451a03;
+      --nl-shadow: 4px 4px 0 #451a03;
+    }
+
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+
+    body {
+      font-family: 'Noto Sans SC', 'Segoe UI', sans-serif;
+      background-color: var(--nl-bg);
+      background-image:
+        radial-gradient(#fde68a 1px, transparent 1px),
+        radial-gradient(#fde68a 1px, transparent 1px);
+      background-size: 20px 20px;
+      background-position: 0 0, 10px 10px;
+      color: var(--nl-text);
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      padding: 2rem;
+    }
+
+    .setup-box {
+      background: var(--nl-surface);
+      padding: 3rem;
+      border: var(--nl-border);
+      box-shadow: var(--nl-shadow);
+      border-radius: 16px;
+      max-width: 450px;
+      width: 100%;
+      text-align: center;
+    }
+
+    h1 {
+      font-family: 'Fredoka One', 'Noto Sans SC', cursive;
+      font-size: 1.8rem;
+      margin-bottom: 1rem;
+      text-shadow: 2px 2px 0 #fff;
+    }
+
+    .desc {
+      color: #92400e;
+      margin-bottom: 2rem;
+      font-weight: 600;
+    }
+
+    .form-group {
+      margin-bottom: 1.5rem;
+      text-align: left;
+    }
+
+    label {
+      display: block;
+      font-weight: 700;
+      margin-bottom: 0.5rem;
+    }
+
+    input[type="password"] {
+      width: 100%;
+      padding: 1rem;
+      border: var(--nl-border);
+      border-radius: 8px;
+      font-size: 1rem;
+      font-family: inherit;
+    }
+
+    input[type="password"]:focus {
+      outline: none;
+      box-shadow: 0 0 0 3px #fbbf24;
+    }
+
+    .btn {
+      background: var(--nl-primary);
+      border: var(--nl-border);
+      color: var(--nl-text);
+      padding: 1rem 2rem;
+      border-radius: 12px;
+      cursor: pointer;
+      font-size: 1.1rem;
+      font-weight: 800;
+      box-shadow: var(--nl-shadow);
+      transition: all 0.1s;
+      width: 100%;
+    }
+
+    .btn:hover {
+      transform: translate(-1px, -1px);
+      box-shadow: 5px 5px 0 #451a03;
+    }
+
+    .btn:active {
+      transform: translate(1px, 1px);
+      box-shadow: 2px 2px 0 #451a03;
+    }
+
+    .error {
+      color: #b91c1c;
+      margin-top: 1rem;
+      display: none;
+    }
+  </style>
+</head>
+<body>
+  <div class="setup-box">
+    <h1>🔧 初始设置</h1>
+    <p class="desc">首次使用，请设置管理密码</p>
+    <form id="setupForm">
+      <div class="form-group">
+        <label for="password">设置密码</label>
+        <input type="password" id="password" placeholder="至少4位" required minlength="4">
+      </div>
+      <div class="form-group">
+        <label for="confirmPassword">确认密码</label>
+        <input type="password" id="confirmPassword" placeholder="再次输入密码" required>
+      </div>
+      <button type="submit" class="btn">确认设置</button>
+      <p class="error" id="error"></p>
+    </form>
+  </div>
+
+  <script>
+    document.getElementById('setupForm').addEventListener('submit', async function(e) {
+      e.preventDefault()
+      const password = document.getElementById('password').value
+      const confirmPassword = document.getElementById('confirmPassword').value
+      const errorEl = document.getElementById('error')
+
+      if (password !== confirmPassword) {
+        errorEl.textContent = '两次密码不一致'
+        errorEl.style.display = 'block'
+        return
+      }
+
+      if (password.length < 4) {
+        errorEl.textContent = '密码至少需要4位'
+        errorEl.style.display = 'block'
+        return
+      }
+
+      try {
+        const res = await fetch('${basePath}/admin/api/init-password', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ password }),
+          credentials: 'include'
+        })
+        const data = await res.json()
+        if (data.success) {
+          window.location.href = '${basePath}/admin'
+        } else {
+          errorEl.textContent = data.error || '设置失败'
+          errorEl.style.display = 'block'
+        }
+      } catch (e) {
+        errorEl.textContent = '网络错误'
+        errorEl.style.display = 'block'
+      }
+    })
+  </script>
+</body>
+</html>`;
+  }
+  renderStatusPage() {
+    const basePath = this.config.basePath || "/status";
+    const status = this.statusManager.getStatus();
+    const onlineCount = status.bots.filter((b) => b.status === "online").length;
+    const offlineCount = status.bots.filter((b) => b.status === "offline").length;
+    const totalCount = status.bots.length;
+    const botCardsHtml = status.bots.map((bot) => {
+      const statusText = bot.status === "online" ? "在线" : bot.status === "offline" ? "离线" : "连接中";
+      const displayName = bot.nickname || bot.selfId;
+      const groupCount = bot.groupCount ?? "-";
+      const friendCount = bot.friendCount ?? "-";
+      const messageReceived = bot.messageReceived ?? "-";
+      const messageSent = bot.messageSent ?? "-";
+      const lastMessageTime = bot.lastMessageTime ? new Date(bot.lastMessageTime * 1e3).toLocaleTimeString() : "-";
+      const uptime = bot.startupTime ? this.formatUptime(bot.startupTime) : "-";
+      return `
+        <div class="bot-card">
+          <div class="bot-header">
+            <img class="bot-avatar" src="http://q.qlogo.cn/headimg_dl?dst_uin=${bot.selfId}&spec=640" alt="avatar">
+            <div class="bot-info">
+              <div class="bot-id">${displayName}</div>
+              <div class="bot-protocol">QQ: ${bot.selfId}</div>
+            </div>
+            <span class="status-badge status-${bot.status}">${statusText}</span>
+          </div>
+          <div class="bot-stats">
+            <div class="bot-stat">
+              <span class="bot-stat-label">群聊</span>
+              <span class="bot-stat-value">${groupCount}</span>
+            </div>
+            <div class="bot-stat">
+              <span class="bot-stat-label">好友</span>
+              <span class="bot-stat-value">${friendCount}</span>
+            </div>
+            <div class="bot-stat">
+              <span class="bot-stat-label">收到</span>
+              <span class="bot-stat-value">${messageReceived}</span>
+            </div>
+            <div class="bot-stat">
+              <span class="bot-stat-label">发送</span>
+              <span class="bot-stat-value">${messageSent}</span>
+            </div>
+            <div class="bot-stat">
+              <span class="bot-stat-label">最后消息</span>
+              <span class="bot-stat-value">${lastMessageTime}</span>
+            </div>
+            <div class="bot-stat">
+              <span class="bot-stat-label">运行时间</span>
+              <span class="bot-stat-value">${uptime}</span>
+            </div>
+          </div>
+        </div>`;
+    }).join("");
+    const updatedAtStr = new Date(status.updatedAt).toLocaleString();
+    return `<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>OneBot Multi - 状态面板</title>
+  <link href="https://fonts.googleapis.com/css2?family=Fredoka+One&family=Noto+Sans+SC:wght@400;700;900&display=swap" rel="stylesheet">
+  <style>
+    :root {
+      --nl-primary: #fbbf24;
+      --nl-bg: #fffbeb;
+      --nl-surface: #ffffff;
+      --nl-text: #451a03;
+      --nl-border: 3px solid #451a03;
+      --nl-shadow: 4px 4px 0 #451a03;
+
+      --status-online: #32CD32;
+      --status-offline: #FF4500;
+      --status-connecting: #FFA500;
+    }
+
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+
+    body {
+      font-family: 'Noto Sans SC', 'Segoe UI', sans-serif;
+      background-color: var(--nl-bg);
+      background-image:
+        radial-gradient(#fde68a 1px, transparent 1px),
+        radial-gradient(#fde68a 1px, transparent 1px);
+      background-size: 20px 20px;
+      background-position: 0 0, 10px 10px;
+      color: var(--nl-text);
+      min-height: 100vh;
+      padding: 2rem;
+    }
+
+    .container {
+      max-width: 1200px;
+      margin: 0 auto;
+      background: var(--nl-surface);
+      padding: 2rem;
+      border: var(--nl-border);
+      box-shadow: var(--nl-shadow);
+      border-radius: 16px;
+    }
+
+    h1 {
+      font-family: 'Fredoka One', 'Noto Sans SC', cursive;
+      font-size: 2.5rem;
+      margin-bottom: 2rem;
+      text-align: center;
+      text-shadow: 2px 2px 0 #fff;
+      color: var(--nl-text);
+    }
+
+    .stats {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+      gap: 1.5rem;
+      margin-bottom: 3rem;
+    }
+
+    .stat-card {
+      background: var(--nl-surface);
+      border: var(--nl-border);
+      padding: 1rem;
+      text-align: center;
+      box-shadow: 2px 2px 0 #451a03;
+      transition: transform 0.2s, box-shadow 0.2s;
+      border-radius: 16px;
+    }
+
+    .stat-card:hover {
+      transform: translate(-2px, -2px);
+      box-shadow: 4px 4px 0 #451a03;
+    }
+
+    .stat-value {
+      font-family: 'Fredoka One', sans-serif;
+      font-size: 2.5rem;
+      line-height: 1.2;
+    }
+
+    .stat-label {
+      font-weight: 800;
+      font-size: 14px;
+      color: #92400e;
+    }
+
+    .stat-online .stat-value { color: var(--status-online); }
+    .stat-offline .stat-value { color: var(--status-offline); }
+    .stat-total .stat-value { color: #00BFFF; }
+
+    .bots {
+      display: grid;
+      grid-template-columns: repeat(auto-fill, minmax(320px, 1fr));
+      gap: 2rem;
+    }
+
+    .bot-card {
+      background: var(--nl-surface);
+      border: var(--nl-border);
+      border-radius: 16px;
+      padding: 1.5rem;
+      position: relative;
+      box-shadow: var(--nl-shadow);
+      transition: all 0.2s ease;
+      overflow: hidden;
+    }
+
+    .bot-card:hover {
+      transform: translate(-2px, -2px);
+      box-shadow: 6px 6px 0 #451a03;
+    }
+
+    .bot-header {
+      display: flex;
+      align-items: center;
+      gap: 1rem;
+      margin-bottom: 1.5rem;
+    }
+
+    .bot-avatar {
+      width: 64px;
+      height: 64px;
+      border: var(--nl-border);
+      border-radius: 50%;
+      background: #fff;
+    }
+
+    .bot-info { flex: 1; }
+
+    .bot-id {
+      font-weight: 900;
+      font-size: 1.2rem;
+      color: var(--nl-text);
+    }
+
+    .bot-protocol {
+      color: #92400e;
+      font-size: 0.9rem;
+      font-weight: 700;
+      background: #fffbeb;
+      display: inline-block;
+      padding: 2px 6px;
+      border: 2px solid #451a03;
+      border-radius: 6px;
+      margin-top: 4px;
+    }
+
+    .status-badge {
+      padding: 0.4rem 0.8rem;
+      border: 2px solid #451a03;
+      border-radius: 20px;
+      font-size: 0.8rem;
+      font-weight: 900;
+    }
+
+    .status-online { background: #dcfce7; border-color: #10b981; color: #15803d; }
+    .status-offline { background: #fee2e2; border-color: #ef4444; color: #b91c1c; }
+    .status-connecting { background: #ffedd5; border-color: #f97316; color: #c2410c; }
+
+    .bot-stats {
+      display: grid;
+      grid-template-columns: 1fr 1fr;
+      gap: 10px;
+      background: #fff7ed;
+      padding: 1rem;
+      border: 2px solid #451a03;
+      border-radius: 12px;
+    }
+
+    .bot-stat {
+      display: flex;
+      flex-direction: column;
+      align-items: flex-start;
+    }
+
+    .bot-stat-label {
+      font-size: 0.75rem;
+      font-weight: 800;
+      color: #92400e;
+    }
+
+    .bot-stat-value {
+      font-weight: 700;
+      font-size: 1rem;
+      color: var(--nl-text);
+    }
+
+    .footer {
+      margin-top: 3rem;
+      text-align: center;
+      font-weight: 700;
+      color: #92400e;
+      padding: 0.5rem;
+      width: 100%;
+    }
+
+    .refresh-btn {
+      position: fixed;
+      bottom: 2rem;
+      right: 2rem;
+      background: var(--nl-primary);
+      border: var(--nl-border);
+      color: var(--nl-text);
+      padding: 1rem 2rem;
+      border-radius: 12px;
+      cursor: pointer;
+      font-size: 1.1rem;
+      font-weight: 800;
+      box-shadow: var(--nl-shadow);
+      transition: all 0.1s;
+      z-index: 100;
+    }
+
+    .refresh-btn:hover {
+      transform: translate(-1px, -1px);
+      box-shadow: 5px 5px 0 #451a03;
+    }
+
+    .refresh-btn:active {
+      transform: translate(1px, 1px);
+      box-shadow: 2px 2px 0 #451a03;
+    }
+
+    @media (max-width: 768px) {
+      body { padding: 1rem; }
+      .container { padding: 1rem; }
+      .stats { grid-template-columns: 1fr; }
+      .bot-card { margin-bottom: 1rem; }
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1 ondblclick="window.location='${basePath}/admin'" style="cursor: default;" title="双击进入管理">OneBot Multi 状态面板</h1>
+
+    <div class="stats">
+      <div class="stat-card stat-online">
+        <div class="stat-value">${onlineCount}</div>
+        <div class="stat-label">在线</div>
+      </div>
+      <div class="stat-card stat-offline">
+        <div class="stat-value">${offlineCount}</div>
+        <div class="stat-label">离线</div>
+      </div>
+      <div class="stat-card stat-total">
+        <div class="stat-value">${totalCount}</div>
+        <div class="stat-label">总计</div>
+      </div>
+    </div>
+
+    <div class="bots">
+      ${botCardsHtml}
+    </div>
+
+    <div class="footer">
+      更新时间: ${updatedAtStr}
+    </div>
+  </div>
+
+  <button class="refresh-btn" onclick="location.reload()">刷新 ⚡</button>
+
+  <script>
+    // 自动刷新
+    setTimeout(() => location.reload(), 30000)
+  </script>
+</body>
+</html>`;
+  }
+  renderAdminPage() {
+    const basePath = this.config.basePath || "/status";
+    return `<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>OneBot Multi - 管理面板</title>
+  <link href="https://fonts.googleapis.com/css2?family=Fredoka+One&family=Noto+Sans+SC:wght@400;700;900&display=swap" rel="stylesheet">
+  <style>
+    :root {
+      --nl-primary: #fbbf24;
+      --nl-bg: #fffbeb;
+      --nl-surface: #ffffff;
+      --nl-text: #451a03;
+      --nl-border: 3px solid #451a03;
+      --nl-shadow: 4px 4px 0 #451a03;
+
+      --status-online: #32CD32;
+      --status-offline: #FF4500;
+      --status-connecting: #FFA500;
+    }
+
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+
+    body {
+      font-family: 'Noto Sans SC', 'Segoe UI', sans-serif;
+      background-color: var(--nl-bg);
+      background-image:
+        radial-gradient(#fde68a 1px, transparent 1px),
+        radial-gradient(#fde68a 1px, transparent 1px);
+      background-size: 20px 20px;
+      background-position: 0 0, 10px 10px;
+      color: var(--nl-text);
+      min-height: 100vh;
+      padding: 2rem;
+    }
+
+    .container {
+      max-width: 1200px;
+      margin: 0 auto;
+      background: var(--nl-surface);
+      padding: 2rem;
+      border: var(--nl-border);
+      box-shadow: var(--nl-shadow);
+      border-radius: 16px;
+    }
+
+    h1 {
+      font-family: 'Fredoka One', 'Noto Sans SC', cursive;
+      font-size: 2.5rem;
+      margin-bottom: 2rem;
+      text-align: center;
+      text-shadow: 2px 2px 0 #fff;
+      color: var(--nl-text);
+    }
+
+    .toolbar {
+      display: flex;
+      gap: 1rem;
+      margin-bottom: 2rem;
+      flex-wrap: wrap;
+    }
+
+    .btn {
+      background: var(--nl-primary);
+      border: var(--nl-border);
+      color: var(--nl-text);
+      padding: 0.8rem 1.5rem;
+      border-radius: 12px;
+      cursor: pointer;
+      font-size: 1rem;
+      font-weight: 800;
+      box-shadow: 3px 3px 0 #451a03;
+      transition: all 0.1s;
+      text-decoration: none;
+    }
+
+    .btn:hover {
+      transform: translate(-1px, -1px);
+      box-shadow: 4px 4px 0 #451a03;
+    }
+
+    .btn:active {
+      transform: translate(1px, 1px);
+      box-shadow: 2px 2px 0 #451a03;
+    }
+
+    .btn-danger {
+      background: #fee2e2;
+    }
+
+    .btn-success {
+      background: #dcfce7;
+    }
+
+    .btn-secondary {
+      background: #f3f4f6;
+    }
+
+    .bots {
+      display: grid;
+      grid-template-columns: repeat(auto-fill, minmax(360px, 1fr));
+      gap: 2rem;
+    }
+
+    .bot-card {
+      background: var(--nl-surface);
+      border: var(--nl-border);
+      border-radius: 16px;
+      padding: 1.5rem;
+      position: relative;
+      box-shadow: var(--nl-shadow);
+      transition: all 0.2s ease;
+      overflow: hidden;
+    }
+
+    .bot-card.disabled {
+      opacity: 0.6;
+    }
+
+    .bot-card:hover {
+      transform: translate(-2px, -2px);
+      box-shadow: 6px 6px 0 #451a03;
+    }
+
+    .bot-header {
+      display: flex;
+      align-items: center;
+      gap: 1rem;
+      margin-bottom: 1rem;
+    }
+
+    .bot-avatar {
+      width: 64px;
+      height: 64px;
+      border: var(--nl-border);
+      border-radius: 50%;
+      background: #fff;
+    }
+
+    .bot-info { flex: 1; }
+
+    .bot-id {
+      font-weight: 900;
+      font-size: 1.2rem;
+      color: var(--nl-text);
+    }
+
+    .bot-protocol {
+      color: #92400e;
+      font-size: 0.9rem;
+      font-weight: 700;
+      background: #fffbeb;
+      display: inline-block;
+      padding: 2px 6px;
+      border: 2px solid #451a03;
+      border-radius: 6px;
+      margin-top: 4px;
+    }
+
+    .status-badge {
+      padding: 0.4rem 0.8rem;
+      border: 2px solid #451a03;
+      border-radius: 20px;
+      font-size: 0.8rem;
+      font-weight: 900;
+    }
+
+    .status-online { background: #dcfce7; border-color: #10b981; color: #15803d; }
+    .status-offline { background: #fee2e2; border-color: #ef4444; color: #b91c1c; }
+    .status-connecting { background: #ffedd5; border-color: #f97316; color: #c2410c; }
+
+    .bot-stats {
+      display: grid;
+      grid-template-columns: 1fr 1fr;
+      gap: 10px;
+      background: #fff7ed;
+      padding: 1rem;
+      border: 2px solid #451a03;
+      border-radius: 12px;
+      margin-bottom: 1rem;
+    }
+
+    .bot-stat {
+      display: flex;
+      flex-direction: column;
+      align-items: flex-start;
+    }
+
+    .bot-stat-label {
+      font-size: 0.75rem;
+      font-weight: 800;
+      color: #92400e;
+    }
+
+    .bot-stat-value {
+      font-weight: 700;
+      font-size: 1rem;
+      color: var(--nl-text);
+    }
+
+    .bot-actions {
+      display: flex;
+      gap: 0.5rem;
+      flex-wrap: wrap;
+    }
+
+    .bot-actions .btn {
+      padding: 0.5rem 1rem;
+      font-size: 0.85rem;
+    }
+
+    /* Modal */
+    .modal {
+      display: none;
+      position: fixed;
+      top: 0;
+      left: 0;
+      width: 100%;
+      height: 100%;
+      background: rgba(0,0,0,0.5);
+      z-index: 1000;
+      align-items: center;
+      justify-content: center;
+    }
+
+    .modal.active {
+      display: flex;
+    }
+
+    .modal-content {
+      background: var(--nl-surface);
+      border: var(--nl-border);
+      box-shadow: var(--nl-shadow);
+      border-radius: 16px;
+      padding: 2rem;
+      max-width: 500px;
+      width: 90%;
+    }
+
+    .modal h2 {
+      font-family: 'Fredoka One', cursive;
+      margin-bottom: 1.5rem;
+    }
+
+    .form-group {
+      margin-bottom: 1rem;
+    }
+
+    .form-group label {
+      display: block;
+      font-weight: 700;
+      margin-bottom: 0.5rem;
+    }
+
+    .form-group input, .form-group select {
+      width: 100%;
+      padding: 0.8rem;
+      border: var(--nl-border);
+      border-radius: 8px;
+      font-size: 1rem;
+      font-family: inherit;
+    }
+
+    .form-group input:focus, .form-group select:focus {
+      outline: none;
+      box-shadow: 0 0 0 3px #fbbf24;
+    }
+
+    .modal-actions {
+      display: flex;
+      gap: 1rem;
+      margin-top: 1.5rem;
+    }
+
+    .footer {
+      margin-top: 3rem;
+      text-align: center;
+      font-weight: 700;
+      color: #92400e;
+    }
+
+    .toast {
+      position: fixed;
+      bottom: 2rem;
+      left: 50%;
+      transform: translateX(-50%);
+      background: var(--nl-surface);
+      border: var(--nl-border);
+      box-shadow: var(--nl-shadow);
+      padding: 1rem 2rem;
+      border-radius: 12px;
+      font-weight: 700;
+      z-index: 2000;
+      display: none;
+    }
+
+    .toast.show {
+      display: block;
+    }
+
+    .toast.error {
+      background: #fee2e2;
+    }
+
+    .toast.success {
+      background: #dcfce7;
+    }
+
+    .empty-state {
+      text-align: center;
+      padding: 3rem;
+      color: #92400e;
+    }
+
+    .empty-state h3 {
+      font-size: 1.5rem;
+      margin-bottom: 1rem;
+    }
+
+    @media (max-width: 768px) {
+      body { padding: 1rem; }
+      .container { padding: 1rem; }
+      .bots { grid-template-columns: 1fr; }
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>🛠️ OneBot Multi 管理面板</h1>
+
+    <div class="toolbar">
+      <button class="btn" onclick="showAddModal()">➕ 添加 Bot</button>
+      <button class="btn btn-secondary" onclick="refreshList()">🔄 刷新</button>
+      <a href="${basePath}" class="btn btn-secondary">📊 状态面板</a>
+    </div>
+
+    <div class="bots" id="botList">
+      <div class="empty-state">
+        <h3>加载中...</h3>
+      </div>
+    </div>
+
+    <div class="footer">
+      OneBot Multi 管理面板
+    </div>
+  </div>
+
+  <!-- Add Modal -->
+  <div class="modal" id="addModal">
+    <div class="modal-content">
+      <h2>添加 Bot</h2>
+      <form id="addForm">
+        <div class="form-group">
+          <label for="selfId">QQ 号 *</label>
+          <input type="text" id="selfId" required placeholder="例如: 123456789">
+        </div>
+        <div class="form-group">
+          <label for="protocol">协议</label>
+          <select id="protocol" onchange="toggleEndpoint()">
+            <option value="ws-reverse">反向 WebSocket (ws-reverse)</option>
+            <option value="ws">正向 WebSocket (ws)</option>
+          </select>
+        </div>
+        <div class="form-group" id="endpointGroup" style="display: none;">
+          <label for="endpoint">Endpoint *</label>
+          <input type="text" id="endpoint" placeholder="例如: ws://127.0.0.1:6700">
+        </div>
+        <div class="form-group" id="pathGroup">
+          <label for="path">路径</label>
+          <input type="text" id="path" value="/onebot" placeholder="例如: /onebot">
+        </div>
+        <div class="form-group">
+          <label for="token">Token（可选）</label>
+          <input type="password" id="token" placeholder="访问令牌">
+        </div>
+        <div class="modal-actions">
+          <button type="submit" class="btn">确定</button>
+          <button type="button" class="btn btn-secondary" onclick="hideAddModal()">取消</button>
+        </div>
+      </form>
+    </div>
+  </div>
+
+  <!-- Toast -->
+  <div class="toast" id="toast"></div>
+
+  <script>
+    const BASE_PATH = '${basePath}/admin'
+
+    async function apiCall(endpoint, data = null) {
+      const options = {
+        method: data ? 'POST' : 'GET',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        credentials: 'include'
+      }
+      if (data) {
+        options.body = JSON.stringify(data)
+      }
+      const res = await fetch(BASE_PATH + endpoint, options)
+      if (res.status === 401) {
+        // 认证失败，重定向到登录页
+        window.location.href = '${basePath}/admin'
+        throw new Error('认证失败')
+      }
+      return res.json()
+    }
+
+    function showToast(message, type = 'success') {
+      const toast = document.getElementById('toast')
+      toast.textContent = message
+      toast.className = 'toast show ' + type
+      setTimeout(() => toast.className = 'toast', 3000)
+    }
+
+    function formatUptime(startTime) {
+      const diff = Math.floor(Date.now() / 1000 - startTime)
+      const hours = Math.floor(diff / 3600)
+      const minutes = Math.floor((diff % 3600) / 60)
+      if (hours > 0) return hours + 'h ' + minutes + 'm'
+      return minutes + 'm'
+    }
+
+    async function refreshList() {
+      try {
+        const data = await apiCall('/api/list')
+        if (data.error) {
+          showToast('加载失败: ' + data.error, 'error')
+          return
+        }
+        renderBots(data.bots || [])
+      } catch (e) {
+        console.error('refreshList error:', e)
+        showToast('加载失败: ' + e.message, 'error')
+      }
+    }
+
+    function renderBots(bots) {
+      const container = document.getElementById('botList')
+      if (bots.length === 0) {
+        container.innerHTML = '<div class="empty-state"><h3>暂无 Bot</h3><p>点击"添加 Bot"按钮创建</p></div>'
+        return
+      }
+
+      container.innerHTML = bots.map(bot => {
+        const statusText = bot.status === 'online' ? '在线' : bot.status === 'offline' ? '离线' : '连接中'
+        const displayName = bot.nickname || bot.selfId
+        const uptime = bot.startupTime ? formatUptime(bot.startupTime) : '-'
+        const disabledClass = !bot.enabled ? 'disabled' : ''
+
+        return '<div class="bot-card ' + disabledClass + '">' +
+          '<div class="bot-header">' +
+            '<img class="bot-avatar" src="http://q.qlogo.cn/headimg_dl?dst_uin=' + bot.selfId + '&spec=640" alt="avatar">' +
+            '<div class="bot-info">' +
+              '<div class="bot-id">' + displayName + '</div>' +
+              '<div class="bot-protocol">' + bot.protocol.toUpperCase() + ' | QQ: ' + bot.selfId + '</div>' +
+            '</div>' +
+            '<span class="status-badge status-' + bot.status + '">' + statusText + '</span>' +
+          '</div>' +
+          '<div class="bot-stats">' +
+            '<div class="bot-stat"><span class="bot-stat-label">群聊</span><span class="bot-stat-value">' + (bot.groupCount ?? '-') + '</span></div>' +
+            '<div class="bot-stat"><span class="bot-stat-label">好友</span><span class="bot-stat-value">' + (bot.friendCount ?? '-') + '</span></div>' +
+            '<div class="bot-stat"><span class="bot-stat-label">收到</span><span class="bot-stat-value">' + (bot.messageReceived ?? '-') + '</span></div>' +
+            '<div class="bot-stat"><span class="bot-stat-label">发送</span><span class="bot-stat-value">' + (bot.messageSent ?? '-') + '</span></div>' +
+            '<div class="bot-stat"><span class="bot-stat-label">连接</span><span class="bot-stat-value">' + (bot.endpoint || bot.path || '-') + '</span></div>' +
+            '<div class="bot-stat"><span class="bot-stat-label">运行时间</span><span class="bot-stat-value">' + uptime + '</span></div>' +
+          '</div>' +
+          '<div class="bot-actions">' +
+            '<button class="btn btn-secondary" onclick="toggleBot('' + bot.selfId + '')">' + (bot.enabled ? '禁用' : '启用') + '</button>' +
+            '<button class="btn btn-secondary" onclick="restartBot('' + bot.selfId + '')">重启</button>' +
+            '<button class="btn btn-danger" onclick="deleteBot('' + bot.selfId + '')">删除</button>' +
+          '</div>' +
+        '</div>'
+      }).join('')
+    }
+
+    function showAddModal() {
+      document.getElementById('addModal').classList.add('active')
+      document.getElementById('addForm').reset()
+      toggleEndpoint()
+    }
+
+    function hideAddModal() {
+      document.getElementById('addModal').classList.remove('active')
+    }
+
+    function toggleEndpoint() {
+      const protocol = document.getElementById('protocol').value
+      document.getElementById('endpointGroup').style.display = protocol === 'ws' ? 'block' : 'none'
+      document.getElementById('pathGroup').style.display = protocol === 'ws-reverse' ? 'block' : 'none'
+    }
+
+    document.getElementById('addForm').addEventListener('submit', async (e) => {
+      e.preventDefault()
+      const data = {
+        selfId: document.getElementById('selfId').value,
+        protocol: document.getElementById('protocol').value,
+        endpoint: document.getElementById('endpoint').value || undefined,
+        path: document.getElementById('path').value || undefined,
+        token: document.getElementById('token').value || undefined
+      }
+
+      try {
+        const result = await apiCall('/api/create', data)
+        if (result.error) throw new Error(result.error)
+        showToast('Bot 添加成功')
+        hideAddModal()
+        refreshList()
+      } catch (e) {
+        showToast('添加失败: ' + e.message, 'error')
+      }
+    })
+
+    async function toggleBot(selfId) {
+      try {
+        const result = await apiCall('/api/toggle', { selfId })
+        if (result.error) throw new Error(result.error)
+        showToast(result.enabled ? 'Bot 已启用' : 'Bot 已禁用')
+        refreshList()
+      } catch (e) {
+        showToast('操作失败: ' + e.message, 'error')
+      }
+    }
+
+    async function restartBot(selfId) {
+      try {
+        const result = await apiCall('/api/restart', { selfId })
+        if (result.error) throw new Error(result.error)
+        showToast('Bot 正在重启')
+        setTimeout(refreshList, 1000)
+      } catch (e) {
+        showToast('重启失败: ' + e.message, 'error')
+      }
+    }
+
+    async function deleteBot(selfId) {
+      if (!confirm('确定要删除 Bot ' + selfId + ' 吗？')) return
+      try {
+        const result = await apiCall('/api/delete', { selfId })
+        if (result.error) throw new Error(result.error)
+        showToast('Bot 已删除')
+        refreshList()
+      } catch (e) {
+        showToast('删除失败: ' + e.message, 'error')
+      }
+    }
+
+    // 初始加载
+    refreshList()
+    // 自动刷新
+    setInterval(refreshList, 30000)
+  </script>
+</body>
+</html>`;
+  }
+  formatUptime(startTime) {
+    const diff = Math.floor(Date.now() / 1e3 - startTime);
+    const hours = Math.floor(diff / 3600);
+    const minutes = Math.floor(diff % 3600 / 60);
+    if (hours > 0) return `${hours}h ${minutes}m`;
+    return `${minutes}m`;
+  }
+};
+
+// src/config-manager.ts
+var import_crypto2 = require("crypto");
+var SYSTEM_CONFIG_ID = "_system_";
+function generateSalt() {
+  return (0, import_crypto2.randomBytes)(16).toString("hex");
+}
+__name(generateSalt, "generateSalt");
+function hashPassword(password, salt) {
+  return (0, import_crypto2.createHash)("sha256").update(password + salt).digest("hex");
+}
+__name(hashPassword, "hashPassword");
+function createPasswordHash(password) {
+  const salt = generateSalt();
+  const hash = hashPassword(password, salt);
+  return `${salt}:${hash}`;
+}
+__name(createPasswordHash, "createPasswordHash");
+function verifyPasswordHash(password, storedHash) {
+  const [salt, hash] = storedHash.split(":");
+  if (!salt || !hash) return false;
+  return hashPassword(password, salt) === hash;
+}
+__name(verifyPasswordHash, "verifyPasswordHash");
+var ConfigManager = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    ctx.model.extend("onebot_multi_bots", {
+      id: "unsigned",
+      selfId: "string",
+      token: "string",
+      protocol: "string",
+      endpoint: "string",
+      path: "string",
+      enabled: "boolean",
+      createdAt: "timestamp",
+      updatedAt: "timestamp"
+    }, {
+      autoInc: true,
+      primary: "id",
+      unique: [["selfId"]]
+    });
+  }
+  static {
+    __name(this, "ConfigManager");
+  }
+  // ==================== 密码相关方法（使用哈希存储） ====================
+  /**
+   * 获取存储的密码哈希
+   */
+  async getStoredPasswordHash() {
+    const results = await this.ctx.database.get("onebot_multi_bots", { selfId: SYSTEM_CONFIG_ID });
+    return results[0]?.token || null;
+  }
+  /**
+   * 设置管理密码（哈希存储）
+   */
+  async setAdminPassword(password) {
+    const hashedPassword = createPasswordHash(password);
+    const existing = await this.ctx.database.get("onebot_multi_bots", { selfId: SYSTEM_CONFIG_ID });
+    if (existing.length > 0) {
+      await this.ctx.database.set("onebot_multi_bots", { selfId: SYSTEM_CONFIG_ID }, { token: hashedPassword, updatedAt: /* @__PURE__ */ new Date() });
+    } else {
+      await this.ctx.database.create("onebot_multi_bots", {
+        selfId: SYSTEM_CONFIG_ID,
+        token: hashedPassword,
+        protocol: "ws-reverse",
+        enabled: false,
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      });
+    }
+  }
+  /**
+   * 检查是否已设置密码
+   */
+  async hasAdminPassword() {
+    const hash = await this.getStoredPasswordHash();
+    return !!hash;
+  }
+  /**
+   * 验证管理密码
+   */
+  async verifyAdminPassword(password) {
+    const storedHash = await this.getStoredPasswordHash();
+    if (!storedHash) return false;
+    if (!storedHash.includes(":")) {
+      if (storedHash === password) {
+        await this.setAdminPassword(password);
+        return true;
+      }
+      return false;
+    }
+    return verifyPasswordHash(password, storedHash);
+  }
+  // ==================== Bot 配置相关方法 ====================
+  /**
+   * 获取所有 Bot 配置（排除系统配置）
+   */
+  async getAllConfigs() {
+    const all = await this.ctx.database.get("onebot_multi_bots", {});
+    return all.filter((r) => r.selfId !== SYSTEM_CONFIG_ID);
+  }
+  /**
+   * 获取启用的 Bot 配置（排除系统配置）
+   */
+  async getEnabledConfigs() {
+    const all = await this.ctx.database.get("onebot_multi_bots", { enabled: true });
+    return all.filter((r) => r.selfId !== SYSTEM_CONFIG_ID);
+  }
+  /**
+   * 获取单个 Bot 配置
+   */
+  async getConfig(selfId) {
+    const results = await this.ctx.database.get("onebot_multi_bots", { selfId });
+    return results[0];
+  }
+  /**
+   * 创建 Bot 配置
+   */
+  async createConfig(config) {
+    const now = /* @__PURE__ */ new Date();
+    const record = await this.ctx.database.create("onebot_multi_bots", {
+      ...config,
+      createdAt: now,
+      updatedAt: now
+    });
+    return record;
+  }
+  /**
+   * 更新 Bot 配置
+   */
+  async updateConfig(selfId, updates) {
+    const result = await this.ctx.database.set("onebot_multi_bots", { selfId }, {
+      ...updates,
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+    return result.modified > 0;
+  }
+  /**
+   * 删除 Bot 配置
+   */
+  async deleteConfig(selfId) {
+    const result = await this.ctx.database.remove("onebot_multi_bots", { selfId });
+    return result.removed > 0;
+  }
+  /**
+   * 切换 Bot 启用状态
+   */
+  async toggleEnabled(selfId) {
+    const config = await this.getConfig(selfId);
+    if (!config) return false;
+    return this.updateConfig(selfId, { enabled: !config.enabled });
+  }
+  /**
+   * 将数据库配置转换为 BotConfig 格式
+   */
+  toBotConfig(record) {
+    return {
+      selfId: record.selfId,
+      token: record.token,
+      protocol: record.protocol,
+      endpoint: record.endpoint,
+      path: record.path
+    };
+  }
+};
+
+// src/index.ts
+var Config = import_koishi11.Schema.intersect([
+  // 全局连接设置
+  import_koishi11.Schema.object({
+    responseTimeout: import_koishi11.Schema.natural().role("time").default(import_koishi11.Time.minute).description("等待响应的时间（毫秒）。"),
+    heartbeatInterval: import_koishi11.Schema.natural().role("ms").default(30 * import_koishi11.Time.second).description("心跳检测间隔（毫秒），设为 0 禁用。")
+  }).description("连接设置"),
+  // 全局重连设置（折叠）
+  import_koishi11.Schema.object({
+    retryTimes: import_koishi11.Schema.natural().description("初次连接时的最大重试次数。").default(6),
+    retryInterval: import_koishi11.Schema.natural().role("ms").description("初次连接时的重试时间间隔。").default(5 * import_koishi11.Time.second),
+    retryLazy: import_koishi11.Schema.natural().role("ms").description("连接关闭后的重试时间间隔。").default(import_koishi11.Time.minute)
+  }).description("重连设置").collapse(),
+  // 全局高级设置（折叠）
+  import_koishi11.Schema.object({
+    advanced: BaseBot2.AdvancedConfig
+  }).description("高级设置").collapse(),
+  // 展示面板设置（折叠）
+  import_koishi11.Schema.object({
+    panel: PanelConfig
+  }).collapse()
+]);
+var name = "adapter-onebot-multi";
+var inject = {
+  required: ["server", "database"]
+};
+function apply(ctx, config) {
+  const logger = ctx.logger("adapter-onebot-multi");
+  const statusManager = new StatusManager(ctx);
+  const configManager = new ConfigManager(ctx);
+  const globalConfig = {
+    responseTimeout: config.responseTimeout,
+    heartbeatInterval: config.heartbeatInterval,
+    retryTimes: config.retryTimes,
+    retryInterval: config.retryInterval,
+    retryLazy: config.retryLazy,
+    advanced: config.advanced
+  };
+  ctx._onebotMultiGlobalConfig = globalConfig;
+  if (config.panel?.enabled) {
+    new StatusPanel(ctx, config.panel, statusManager, configManager);
+  }
+  const startBots = /* @__PURE__ */ __name(async () => {
+    const dbConfigs = await configManager.getEnabledConfigs();
+    if (dbConfigs.length > 0) {
+      logger.info(`从数据库加载 ${dbConfigs.length} 个 Bot 配置`);
+      for (const record of dbConfigs) {
+        const botConfig = configManager.toBotConfig(record);
+        startBot(ctx, botConfig, globalConfig, logger);
+      }
+    } else {
+      logger.info("没有配置任何 Bot，请在管理面板中添加");
+    }
+  }, "startBots");
+  ctx.on("ready", () => {
+    startBots();
+  });
+}
+__name(apply, "apply");
+function startBot(ctx, botConfig, globalConfig, logger) {
+  const protocol = botConfig.protocol || "ws-reverse";
+  const fullConfig = {
+    ...globalConfig,
+    ...botConfig,
+    protocol
+  };
+  if (protocol === "ws") {
+    if (!botConfig.endpoint) {
+      logger.warn(`Bot ${botConfig.selfId} 使用 ws 协议但未配置 endpoint，跳过`);
+      return;
+    }
+    logger.info(`创建 Bot: ${botConfig.selfId} (ws → ${botConfig.endpoint})`);
+  } else {
+    logger.info(`创建 Bot: ${botConfig.selfId} (ws-reverse ← ${botConfig.path || "/onebot"})`);
+  }
+  ctx.plugin(OneBotBot, fullConfig);
+}
+__name(startBot, "startBot");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseBot,
+  CQCode,
+  Config,
+  ConfigManager,
+  HeartbeatMonitor,
+  OneBot,
+  OneBotBot,
+  OneBotMessageEncoder,
+  PRIVATE_PFX,
+  PanelConfig,
+  QQGuildBot,
+  StatusManager,
+  StatusPanel,
+  WsClient,
+  WsServer,
+  accept,
+  apply,
+  inject,
+  name
+});