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

package/lib/index.js

@@ -2952,7 +2952,13 @@ 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("负载均衡间隔（秒）。"),
-  excludeChannels: import_koishi11.Schema.array(String).default([]).description("排除的群号列表。").role("table"),
+  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 {
@@ -2999,10 +3005,35 @@ var LoadBalancer = class {
     return Array.from(this.ctx.bots).filter((b) => b.platform === "onebot" && b.status === import_koishi11.Universal.Status.ONLINE).map((b) => b.selfId);
   }
   /**
-   * 检查是否为排除的群
+   * 检查群是否应该被管理（根据白名单/黑名单模式）
    */
-  isExcludedChannel(channelId) {
-    return this.config.excludeChannels?.includes(channelId) || false;
+  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;
   }
   /**
    * 设置事件监听
@@ -3151,9 +3182,19 @@ var LoadBalancer = class {
         return;
       }
       const channels = [];
+      const prioritySet = new Set(this.config.priorityChannels || []);
       for (const [channelId, bots] of this.allChannels.entries()) {
-        channels.push({ channelId, availableBots: [...bots] });
+        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) {
@@ -3169,34 +3210,48 @@ var LoadBalancer = class {
       }
       const assignments = [];
       for (const channel of channels) {
-        if (this.isExcludedChannel(channel.channelId)) continue;
+        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;
+        let selectedBot = null;
         const priorityList = this.config.channelBotPriority?.[channel.channelId];
         if (priorityList && priorityList.length > 0) {
-          let found = false;
           for (const priorityBotId of priorityList) {
             if (validBots.includes(priorityBotId)) {
-              selectedBot = priorityBotId;
-              found = true;
-              break;
+              const load = botLoad.get(priorityBotId) || 0;
+              if (!this.isBotAtCapacity(priorityBotId, load)) {
+                selectedBot = priorityBotId;
+                break;
+              }
             }
           }
-          if (!found) {
+          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);
         }
+        botLoad.set(selectedBot, (botLoad.get(selectedBot) || 0) + 1);
         for (const botId of validBots) {
           botRemainingCapacity.set(botId, (botRemainingCapacity.get(botId) || 0) - 1);
         }
@@ -3218,13 +3273,14 @@ var LoadBalancer = class {
         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} 个群`);
+        this.logger.info(`负载均衡完成，分配了 ${assignments.length} 个群（关键群: ${priorityCount} 个）`);
         this.logger.info(`负载分布: [${loadInfo}]，平均: ${avg.toFixed(1)}，标准差: ${stdDev.toFixed(2)}`);
       }
     } catch (e) {
@@ -3234,13 +3290,20 @@ var LoadBalancer = class {
     }
   }
   /**
-   * 贪心选择 bot
+   * 贪心选择 bot（考虑负载上限）
    */
   selectBotByGreedy(validBots, capacityMap, loadMap) {
-    let selectedBot = validBots[0];
+    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 validBots) {
+    for (const botId of availableBots) {
       const capacity = capacityMap.get(botId) || 0;
       const load = loadMap.get(botId) || 0;
       if (capacity < minCapacity || capacity === minCapacity && load < minLoad) {

package/lib/load-balancer.d.ts

@@ -3,7 +3,13 @@ import { StatusManager } from './status';
 export interface LoadBalanceConfig {
     enabled?: boolean;
     balanceInterval?: number;
-    excludeChannels?: string[];
+    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>;
@@ -28,9 +34,17 @@ export declare class LoadBalancer {
      */
     private getOnlineBots;
     /**
-     * 检查是否为排除的群
+     * 检查群是否应该被管理（根据白名单/黑名单模式）
      */
-    private isExcludedChannel;
+    private shouldManageChannel;
+    /**
+     * 获取 Bot 的负载上限（0=不限制）
+     */
+    private getBotMaxLoad;
+    /**
+     * 检查 Bot 是否已达到负载上限
+     */
+    private isBotAtCapacity;
     /**
      * 设置事件监听
      */
@@ -52,7 +66,7 @@ export declare class LoadBalancer {
      */
     performLoadBalancing(): Promise<void>;
     /**
-     * 贪心选择 bot
+     * 贪心选择 bot（考虑负载上限）
      */
     private selectBotByGreedy;
     /**

package/package.json

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