koishi-plugin-adapter-onebot-multi 0.0.14 → 0.0.16

package/lib/heartbeat.d.ts

@@ -11,6 +11,8 @@ export declare class HeartbeatMonitor {
     private timer;
     private logger;
     private lastOnlineState;
+    private consecutiveFailures;
+    private readonly maxLoggedFailures;
     constructor(ctx: Context, bot: OneBotBot, interval: number);
     start(): void;
     stop(): void;

package/lib/index.d.ts

@@ -2,6 +2,7 @@ import { Context, Schema } from 'koishi';
 import { OneBotBot } from './bot';
 import { BaseBot } from './bot/base';
 import { PanelConfig } from './panel';
+import { LoadBalanceConfig } from './load-balancer';
 import * as OneBot from './utils';
 declare module '@koishijs/console' {
     interface Events {
@@ -19,6 +20,7 @@ export * from './heartbeat';
 export * from './status';
 export * from './panel';
 export * from './config-manager';
+export * from './load-balancer';
 export interface BotConfig {
     selfId: string;
     token?: string;
@@ -34,6 +36,7 @@ export interface Config {
     retryLazy?: number;
     advanced?: BaseBot.AdvancedConfig;
     panel?: PanelConfig;
+    loadBalance?: LoadBalanceConfig;
 }
 export declare const Config: Schema<Config>;
 export declare const name = "adapter-onebot-multi";

package/lib/index.js

@@ -35,6 +35,8 @@ __export(src_exports, {
   Config: () => Config,
   ConfigManager: () => ConfigManager,
   HeartbeatMonitor: () => HeartbeatMonitor,
+  LoadBalanceConfig: () => LoadBalanceConfig,
+  LoadBalancer: () => LoadBalancer,
   OneBot: () => utils_exports,
   OneBotBot: () => OneBotBot,
   OneBotMessageEncoder: () => OneBotMessageEncoder,
@@ -51,7 +53,7 @@ __export(src_exports, {
   name: () => name
 });
 module.exports = __toCommonJS(src_exports);
-var import_koishi11 = require("koishi");
+var import_koishi12 = require("koishi");
 var import_path = require("path");
 
 // src/bot/index.ts
@@ -976,6 +978,7 @@ function accept(socket, bot) {
   socket.addEventListener("close", () => {
     delete bot.internal._request;
     bot.offline();
+    bot.ctx.emit("onebot-multi/bot-offline", bot);
   });
   bot.internal._request = (action, params) => {
     const data = { action, params, echo: ++counter };
@@ -996,6 +999,7 @@ __name(accept, "accept");
 // src/heartbeat.ts
 var import_koishi6 = require("koishi");
 var HeartbeatMonitor = class {
+  // 连续失败超过此次数后降低日志级别
   constructor(ctx, bot, interval) {
     this.ctx = ctx;
     this.bot = bot;
@@ -1008,9 +1012,12 @@ var HeartbeatMonitor = class {
   timer = null;
   logger;
   lastOnlineState = null;
+  consecutiveFailures = 0;
+  maxLoggedFailures = 3;
   start() {
     if (this.timer) return;
     this.logger.debug(`Bot ${this.bot.selfId} 心跳检测已启动，间隔 ${this.interval}ms`);
+    this.consecutiveFailures = 0;
     this.check();
     this.timer = setInterval(() => this.check(), this.interval);
     this.ctx.on("dispose", () => this.stop());
@@ -1023,9 +1030,17 @@ var HeartbeatMonitor = class {
     }
   }
   async check() {
+    if (!this.bot.internal._request) {
+      if (this.consecutiveFailures === 0) {
+        this.logger.debug(`Bot ${this.bot.selfId} WebSocket 未连接，跳过心跳检测`);
+      }
+      this.consecutiveFailures++;
+      return;
+    }
     try {
       const status = await this.bot.internal.getStatus();
       const isOnline = status?.online ?? false;
+      this.consecutiveFailures = 0;
       if (this.lastOnlineState === isOnline) return;
       this.logger.info(`Bot ${this.bot.selfId} 状态变化: ${this.lastOnlineState} -> ${isOnline}`);
       this.lastOnlineState = isOnline;
@@ -1041,7 +1056,12 @@ var HeartbeatMonitor = class {
         }
       }
     } catch (error) {
-      this.logger.warn(`Bot ${this.bot.selfId} 心跳检测失败:`, error);
+      this.consecutiveFailures++;
+      if (this.consecutiveFailures <= this.maxLoggedFailures) {
+        this.logger.warn(`Bot ${this.bot.selfId} 心跳检测失败 (${this.consecutiveFailures}/${this.maxLoggedFailures}):`, error.message);
+      } else if (this.consecutiveFailures === this.maxLoggedFailures + 1) {
+        this.logger.warn(`Bot ${this.bot.selfId} 心跳检测持续失败，后续失败将不再记录`);
+      }
       if (this.lastOnlineState !== false) {
         this.lastOnlineState = false;
         if (this.bot.status === import_koishi6.Universal.Status.ONLINE) {
@@ -1530,7 +1550,8 @@ var StatusPanel = class {
           lastMessageTime: runtime?.lastMessageTime,
           startupTime: runtime?.startupTime,
           groupCount: runtime?.groupCount,
-          friendCount: runtime?.friendCount
+          friendCount: runtime?.friendCount,
+          lastHeartbeat: runtime?.lastHeartbeat
         };
       });
       ctx.body = { bots, updatedAt: Date.now() };
@@ -2926,26 +2947,438 @@ var ConfigManager = class {
   }
 };
 
+// src/load-balancer.ts
+var import_koishi11 = require("koishi");
+var LoadBalanceConfig = import_koishi11.Schema.object({
+  enabled: import_koishi11.Schema.boolean().default(false).description("是否启用负载均衡。"),
+  balanceInterval: import_koishi11.Schema.number().min(60).step(60).default(600).description("负载均衡间隔（秒）。"),
+  channelFilterMode: import_koishi11.Schema.union(["blacklist", "whitelist"]).default("blacklist").description("群过滤模式：blacklist=排除指定群，whitelist=仅管理指定群。"),
+  channelBlacklist: import_koishi11.Schema.array(String).default([]).description("黑名单：排除的群号列表（blacklist 模式生效）。").role("table"),
+  channelWhitelist: import_koishi11.Schema.array(String).default([]).description("白名单：仅管理的群号列表（whitelist 模式生效）。").role("table"),
+  priorityChannels: import_koishi11.Schema.array(String).default([]).description("关键群列表：这些群会被优先分配，确保可用性。").role("table"),
+  defaultMaxLoad: import_koishi11.Schema.number().min(0).default(0).description("默认 Bot 负载上限（0=不限制）。"),
+  botMaxLoad: import_koishi11.Schema.dict(import_koishi11.Schema.number().min(0)).default({}).description('各 Bot 负载上限（格式: "botId": 数量，0=不限制）。'),
+  unassignedValue: import_koishi11.Schema.string().default("").description('未分配群的 assignee 值（留空=不修改，设为"0"=无人负责）。'),
+  channelBotPriority: import_koishi11.Schema.dict(import_koishi11.Schema.array(String)).default({}).description('群Bot优先级配置 (格式: "群号": ["botId1", "botId2"])')
+}).description("负载均衡");
+var LoadBalancer = class {
+  constructor(ctx, config, statusManager) {
+    this.ctx = ctx;
+    this.config = config;
+    this.statusManager = statusManager;
+    if (!config.enabled) {
+      this.ctx.logger("load-balancer").info("负载均衡未启用");
+      return;
+    }
+    this.ctx.logger("load-balancer").info("负载均衡模块初始化中...");
+    this.setupEventListeners();
+    this.ctx.on("ready", () => this.initialize());
+    this.ctx.on("dispose", () => this.dispose());
+  }
+  static {
+    __name(this, "LoadBalancer");
+  }
+  // 核心数据结构
+  allChannels = /* @__PURE__ */ new Map();
+  // channelId -> Set<selfId>
+  botChannels = /* @__PURE__ */ new Map();
+  // selfId -> Set<channelId>
+  lastAssignees = /* @__PURE__ */ new Map();
+  // channelId -> 最近分配的 assignee
+  balanceTimer = null;
+  balancePending = null;
+  isBalancing = false;
+  get logger() {
+    return this.ctx.logger("load-balancer");
+  }
+  /**
+   * 检查 Bot 是否在线
+   */
+  isBotOnline(selfId) {
+    const bot = this.ctx.bots.find((b) => b.selfId === selfId && b.platform === "onebot");
+    return bot?.status === import_koishi11.Universal.Status.ONLINE;
+  }
+  /**
+   * 获取所有在线的 OneBot
+   */
+  getOnlineBots() {
+    return Array.from(this.ctx.bots).filter((b) => b.platform === "onebot" && b.status === import_koishi11.Universal.Status.ONLINE).map((b) => b.selfId);
+  }
+  /**
+   * 检查群是否应该被管理（根据白名单/黑名单模式）
+   */
+  shouldManageChannel(channelId) {
+    const mode = this.config.channelFilterMode || "blacklist";
+    if (mode === "whitelist") {
+      const whitelist = this.config.channelWhitelist || [];
+      return whitelist.length === 0 || whitelist.includes(channelId);
+    } else {
+      const blacklist = this.config.channelBlacklist || [];
+      return !blacklist.includes(channelId);
+    }
+  }
+  /**
+   * 获取 Bot 的负载上限（0=不限制）
+   */
+  getBotMaxLoad(botId) {
+    const specific = this.config.botMaxLoad?.[botId];
+    if (specific !== void 0 && specific > 0) {
+      return specific;
+    }
+    return this.config.defaultMaxLoad || 0;
+  }
+  /**
+   * 检查 Bot 是否已达到负载上限
+   */
+  isBotAtCapacity(botId, currentLoad) {
+    const maxLoad = this.getBotMaxLoad(botId);
+    if (maxLoad === 0) return false;
+    return currentLoad >= maxLoad;
+  }
+  /**
+   * 设置事件监听
+   */
+  setupEventListeners() {
+    this.ctx.on("onebot-multi/bot-online", async (bot) => {
+      this.logger.info(`Bot ${bot.selfId} 上线，开始获取群列表...`);
+      await this.fetchBotGuilds(bot);
+      this.scheduleLoadBalancing(5e3);
+    });
+    this.ctx.on("onebot-multi/bot-offline", (bot) => {
+      const channelIds = this.botChannels.get(bot.selfId) || /* @__PURE__ */ new Set();
+      for (const channelId of channelIds) {
+        const bots = this.allChannels.get(channelId);
+        if (bots) {
+          bots.delete(bot.selfId);
+          if (bots.size === 0) {
+            this.allChannels.delete(channelId);
+            this.lastAssignees.delete(channelId);
+          }
+        }
+      }
+      this.botChannels.delete(bot.selfId);
+      this.logger.info(`Bot ${bot.selfId} 下线，已清理 ${channelIds.size} 个群的映射`);
+      if (channelIds.size > 0) {
+        this.scheduleLoadBalancing(5e3);
+      }
+    });
+    this.ctx.on("guild-added", (session) => {
+      if (session.platform !== "onebot") return;
+      const botChannelSet = this.botChannels.get(session.selfId) || /* @__PURE__ */ new Set();
+      const isNewChannel = !botChannelSet.has(session.guildId);
+      botChannelSet.add(session.guildId);
+      this.botChannels.set(session.selfId, botChannelSet);
+      const channelBots = this.allChannels.get(session.guildId) || /* @__PURE__ */ new Set();
+      channelBots.add(session.selfId);
+      this.allChannels.set(session.guildId, channelBots);
+      this.logger.info(`Bot ${session.selfId} 加入群 ${session.guildId}`);
+      if (isNewChannel) {
+        this.scheduleLoadBalancing(1e4);
+      }
+    });
+    this.ctx.on("guild-removed", (session) => {
+      if (session.platform !== "onebot") return;
+      const botChannelSet = this.botChannels.get(session.selfId);
+      if (botChannelSet) {
+        botChannelSet.delete(session.guildId);
+      }
+      const channelBots = this.allChannels.get(session.guildId);
+      const hadOtherBots = channelBots && channelBots.size > 1;
+      if (channelBots) {
+        channelBots.delete(session.selfId);
+        if (channelBots.size === 0) {
+          this.allChannels.delete(session.guildId);
+          this.lastAssignees.delete(session.guildId);
+        }
+      }
+      this.logger.info(`Bot ${session.selfId} 退出群 ${session.guildId}`);
+      if (hadOtherBots) {
+        this.scheduleLoadBalancing(5e3);
+      }
+    });
+  }
+  /**
+   * 初始化
+   */
+  async initialize() {
+    this.logger.info("初始化负载均衡...");
+    await new Promise((resolve2) => setTimeout(resolve2, 2e3));
+    const allBots = Array.from(this.ctx.bots);
+    this.logger.info(`当前共 ${allBots.length} 个 Bot 实例`);
+    const onlineBots = allBots.filter(
+      (b) => b.platform === "onebot" && b.status === import_koishi11.Universal.Status.ONLINE
+    );
+    this.logger.info(`其中 ${onlineBots.length} 个 OneBot 在线: ${onlineBots.map((b) => b.selfId).join(", ") || "无"}`);
+    const maxConcurrency = 5;
+    for (let i = 0; i < onlineBots.length; i += maxConcurrency) {
+      const batch = onlineBots.slice(i, i + maxConcurrency);
+      await Promise.all(batch.map((bot) => this.fetchBotGuilds(bot)));
+    }
+    this.logger.info(`启动负载均衡定时器，间隔: ${this.config.balanceInterval}秒`);
+    this.balanceTimer = setInterval(
+      () => this.performLoadBalancing(),
+      (this.config.balanceInterval || 600) * 1e3
+    );
+    await this.performLoadBalancing();
+  }
+  /**
+   * 获取 Bot 的群列表
+   */
+  async fetchBotGuilds(bot, retries = 3) {
+    for (let i = 0; i < retries; i++) {
+      try {
+        if (i > 0) {
+          await new Promise((resolve2) => setTimeout(resolve2, 2e3 * i));
+          this.logger.info(`Bot ${bot.selfId} 重试获取群列表 (${i}/${retries})...`);
+        }
+        const guilds = await bot.getGuildList();
+        const channelIds = new Set(
+          Array.from(guilds.data || []).map((g) => g.id)
+        );
+        this.botChannels.set(bot.selfId, channelIds);
+        for (const channelId of channelIds) {
+          const bots = this.allChannels.get(channelId) || /* @__PURE__ */ new Set();
+          bots.add(bot.selfId);
+          this.allChannels.set(channelId, bots);
+        }
+        this.logger.info(`Bot ${bot.selfId} 在 ${channelIds.size} 个群中`);
+        return channelIds;
+      } catch (e) {
+        if (i === retries - 1) {
+          this.logger.error(`Bot ${bot.selfId} 获取群列表失败: ${e.message}`);
+          return null;
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * 延迟触发负载均衡（防抖）
+   */
+  scheduleLoadBalancing(delay = 5e3) {
+    if (this.balancePending) {
+      clearTimeout(this.balancePending);
+    }
+    this.balancePending = setTimeout(() => {
+      this.balancePending = null;
+      this.performLoadBalancing();
+    }, delay);
+  }
+  /**
+   * 执行负载均衡 - 动态容量约束的贪心算法
+   */
+  async performLoadBalancing() {
+    if (this.isBalancing) {
+      this.logger.debug("负载均衡正在执行中，跳过");
+      return;
+    }
+    this.isBalancing = true;
+    try {
+      this.logger.info("执行负载均衡...");
+      const onlineBots = this.getOnlineBots();
+      const onlineBotsSet = new Set(onlineBots);
+      if (onlineBots.length === 0) {
+        this.logger.warn("没有在线的 Bot");
+        return;
+      }
+      const channels = [];
+      const prioritySet = new Set(this.config.priorityChannels || []);
+      for (const [channelId, bots] of this.allChannels.entries()) {
+        channels.push({
+          channelId,
+          availableBots: [...bots],
+          isPriority: prioritySet.has(channelId)
+        });
+      }
+      channels.sort((a, b) => {
+        if (a.isPriority && !b.isPriority) return -1;
+        if (!a.isPriority && b.isPriority) return 1;
+        return 0;
+      });
+      const botLoad = /* @__PURE__ */ new Map();
+      const botRemainingCapacity = /* @__PURE__ */ new Map();
+      for (const botId of onlineBots) {
+        botLoad.set(botId, 0);
+        botRemainingCapacity.set(botId, 0);
+      }
+      for (const { availableBots } of channels) {
+        for (const botId of availableBots) {
+          if (onlineBotsSet.has(botId)) {
+            botRemainingCapacity.set(botId, (botRemainingCapacity.get(botId) || 0) + 1);
+          }
+        }
+      }
+      const assignments = [];
+      for (const channel of channels) {
+        if (!this.shouldManageChannel(channel.channelId)) continue;
+        const validBots = channel.availableBots.filter((botId) => onlineBotsSet.has(botId));
+        if (validBots.length === 0) {
+          this.logger.warn(`群 ${channel.channelId} 没有可用的 Bot`);
+          continue;
+        }
+        let selectedBot = null;
+        const priorityList = this.config.channelBotPriority?.[channel.channelId];
+        if (priorityList && priorityList.length > 0) {
+          for (const priorityBotId of priorityList) {
+            if (validBots.includes(priorityBotId)) {
+              const load = botLoad.get(priorityBotId) || 0;
+              if (!this.isBotAtCapacity(priorityBotId, load)) {
+                selectedBot = priorityBotId;
+                break;
+              }
+            }
+          }
+          if (!selectedBot) {
+            selectedBot = this.selectBotByGreedy(validBots, botRemainingCapacity, botLoad);
+          }
+        } else {
+          selectedBot = this.selectBotByGreedy(validBots, botRemainingCapacity, botLoad);
+        }
+        if (!selectedBot) {
+          const unassignedValue = this.config.unassignedValue;
+          if (unassignedValue !== void 0 && unassignedValue !== "") {
+            const lastAssignee2 = this.lastAssignees.get(channel.channelId);
+            if (lastAssignee2 !== unassignedValue) {
+              assignments.push({ channelId: channel.channelId, assignee: unassignedValue });
+              this.logger.info(`群 ${channel.channelId} 所有 Bot 达到上限，设为未分配`);
+            }
+          } else {
+            this.logger.warn(`群 ${channel.channelId} 所有可用 Bot 都已达到负载上限`);
+          }
+          continue;
+        }
+        const lastAssignee = this.lastAssignees.get(channel.channelId);
+        if (lastAssignee !== selectedBot) {
+          assignments.push({ channelId: channel.channelId, assignee: selectedBot });
+        }
+        botLoad.set(selectedBot, (botLoad.get(selectedBot) || 0) + 1);
+        for (const botId of validBots) {
+          botRemainingCapacity.set(botId, (botRemainingCapacity.get(botId) || 0) - 1);
+        }
+      }
+      if (assignments.length > 0) {
+        const batchSize = 100;
+        for (let i = 0; i < assignments.length; i += batchSize) {
+          const slice = assignments.slice(i, i + batchSize);
+          await Promise.all(
+            slice.map(
+              ({ channelId, assignee }) => this.ctx.database.setChannel("onebot", channelId, { assignee }).then(() => {
+                this.lastAssignees.set(channelId, assignee);
+              })
+            )
+          );
+        }
+      }
+      const botsWithData = onlineBots.filter((id) => {
+        const channels2 = this.botChannels.get(id);
+        return channels2 && channels2.size > 0;
+      });
+      const priorityCount = channels.filter((c) => c.isPriority && this.shouldManageChannel(c.channelId)).length;
+      if (botsWithData.length > 0) {
+        const loads = botsWithData.map((id) => botLoad.get(id) || 0);
+        const avg = loads.reduce((a, b) => a + b, 0) / loads.length;
+        const variance = loads.reduce((sum, load) => sum + Math.pow(load - avg, 2), 0) / loads.length;
+        const stdDev = Math.sqrt(variance);
+        const loadInfo = botsWithData.map((id) => `${id}:${botLoad.get(id) || 0}`).join(", ");
+        this.logger.info(`负载均衡完成，分配了 ${assignments.length} 个群（关键群: ${priorityCount} 个）`);
+        this.logger.info(`负载分布: [${loadInfo}]，平均: ${avg.toFixed(1)}，标准差: ${stdDev.toFixed(2)}`);
+      }
+    } catch (e) {
+      this.logger.error(`负载均衡失败: ${e.message}`);
+    } finally {
+      this.isBalancing = false;
+    }
+  }
+  /**
+   * 贪心选择 bot（考虑负载上限）
+   */
+  selectBotByGreedy(validBots, capacityMap, loadMap) {
+    const availableBots = validBots.filter((botId) => {
+      const load = loadMap.get(botId) || 0;
+      return !this.isBotAtCapacity(botId, load);
+    });
+    if (availableBots.length === 0) {
+      return null;
+    }
+    let selectedBot = availableBots[0];
+    let minCapacity = capacityMap.get(selectedBot) || 0;
+    let minLoad = loadMap.get(selectedBot) || 0;
+    for (const botId of availableBots) {
+      const capacity = capacityMap.get(botId) || 0;
+      const load = loadMap.get(botId) || 0;
+      if (capacity < minCapacity || capacity === minCapacity && load < minLoad) {
+        minCapacity = capacity;
+        minLoad = load;
+        selectedBot = botId;
+      }
+    }
+    return selectedBot;
+  }
+  /**
+   * 销毁
+   */
+  dispose() {
+    if (this.balanceTimer) {
+      clearInterval(this.balanceTimer);
+      this.balanceTimer = null;
+    }
+    if (this.balancePending) {
+      clearTimeout(this.balancePending);
+      this.balancePending = null;
+    }
+  }
+  /**
+   * 获取负载均衡状态（供 API 使用）
+   */
+  getStatus() {
+    const onlineBots = this.getOnlineBots();
+    const botStats = {};
+    for (const botId of onlineBots) {
+      const channels = this.botChannels.get(botId) || /* @__PURE__ */ new Set();
+      let assignedCount = 0;
+      for (const [channelId, assignee] of this.lastAssignees.entries()) {
+        if (assignee === botId) {
+          assignedCount++;
+        }
+      }
+      botStats[botId] = {
+        channelCount: channels.size,
+        assignedCount
+      };
+    }
+    return {
+      enabled: this.config.enabled,
+      totalChannels: this.allChannels.size,
+      onlineBots: onlineBots.length,
+      botStats
+    };
+  }
+};
+
 // src/index.ts
-var Config = import_koishi11.Schema.intersect([
+var Config = import_koishi12.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 禁用。")
+  import_koishi12.Schema.object({
+    responseTimeout: import_koishi12.Schema.natural().role("time").default(import_koishi12.Time.minute).description("等待响应的时间（毫秒）。"),
+    heartbeatInterval: import_koishi12.Schema.natural().role("ms").default(30 * import_koishi12.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)
+  import_koishi12.Schema.object({
+    retryTimes: import_koishi12.Schema.natural().description("初次连接时的最大重试次数。").default(6),
+    retryInterval: import_koishi12.Schema.natural().role("ms").description("初次连接时的重试时间间隔。").default(5 * import_koishi12.Time.second),
+    retryLazy: import_koishi12.Schema.natural().role("ms").description("连接关闭后的重试时间间隔。").default(import_koishi12.Time.minute)
   }).description("重连设置").collapse(),
   // 全局高级设置（折叠）
-  import_koishi11.Schema.object({
+  import_koishi12.Schema.object({
     advanced: BaseBot2.AdvancedConfig
   }).description("高级设置").collapse(),
   // 展示面板设置（折叠）
-  import_koishi11.Schema.object({
+  import_koishi12.Schema.object({
     panel: PanelConfig
+  }).collapse(),
+  // 负载均衡设置（折叠）
+  import_koishi12.Schema.object({
+    loadBalance: LoadBalanceConfig
   }).collapse()
 ]);
 var name = "adapter-onebot-multi";
@@ -2969,6 +3402,10 @@ function apply(ctx, config) {
   if (config.panel?.enabled) {
     new StatusPanel(ctx, config.panel, statusManager, configManager);
   }
+  if (config.loadBalance?.enabled) {
+    new LoadBalancer(ctx, config.loadBalance, statusManager);
+    logger.info("负载均衡已启用");
+  }
   ctx.inject(["console"], (ctx2) => {
     ctx2.console.addEntry({
       dev: (0, import_path.resolve)(__dirname, "../client/index.ts"),
@@ -3034,6 +3471,8 @@ __name(startBot, "startBot");
   Config,
   ConfigManager,
   HeartbeatMonitor,
+  LoadBalanceConfig,
+  LoadBalancer,
   OneBot,
   OneBotBot,
   OneBotMessageEncoder,

package/lib/load-balancer.d.ts

@@ -0,0 +1,88 @@
+import { Context, Schema } from 'koishi';
+import { StatusManager } from './status';
+export interface LoadBalanceConfig {
+    enabled?: boolean;
+    balanceInterval?: number;
+    channelFilterMode?: 'blacklist' | 'whitelist';
+    channelBlacklist?: string[];
+    channelWhitelist?: string[];
+    botMaxLoad?: Record<string, number>;
+    defaultMaxLoad?: number;
+    unassignedValue?: string;
+    priorityChannels?: string[];
+    channelBotPriority?: Record<string, string[]>;
+}
+export declare const LoadBalanceConfig: Schema<LoadBalanceConfig>;
+export declare class LoadBalancer {
+    private ctx;
+    private config;
+    private statusManager;
+    private allChannels;
+    private botChannels;
+    private lastAssignees;
+    private balanceTimer;
+    private balancePending;
+    private isBalancing;
+    constructor(ctx: Context, config: LoadBalanceConfig, statusManager: StatusManager);
+    private get logger();
+    /**
+     * 检查 Bot 是否在线
+     */
+    private isBotOnline;
+    /**
+     * 获取所有在线的 OneBot
+     */
+    private getOnlineBots;
+    /**
+     * 检查群是否应该被管理（根据白名单/黑名单模式）
+     */
+    private shouldManageChannel;
+    /**
+     * 获取 Bot 的负载上限（0=不限制）
+     */
+    private getBotMaxLoad;
+    /**
+     * 检查 Bot 是否已达到负载上限
+     */
+    private isBotAtCapacity;
+    /**
+     * 设置事件监听
+     */
+    private setupEventListeners;
+    /**
+     * 初始化
+     */
+    private initialize;
+    /**
+     * 获取 Bot 的群列表
+     */
+    private fetchBotGuilds;
+    /**
+     * 延迟触发负载均衡（防抖）
+     */
+    private scheduleLoadBalancing;
+    /**
+     * 执行负载均衡 - 动态容量约束的贪心算法
+     */
+    performLoadBalancing(): Promise<void>;
+    /**
+     * 贪心选择 bot（考虑负载上限）
+     */
+    private selectBotByGreedy;
+    /**
+     * 销毁
+     */
+    private dispose;
+    /**
+     * 获取负载均衡状态（供 API 使用）
+     */
+    getStatus(): {
+        enabled: boolean;
+        totalChannels: number;
+        onlineBots: number;
+        botStats: Record<string, {
+            channelCount: number;
+            assignedCount: number;
+        }>;
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-adapter-onebot-multi",
   "description": "奶龙bot定制版onebot适配器，支持自动负载均衡，适配器级黑名单/白名单，提供webui，可指定端口",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [