koishi-plugin-adapter-onebot-multi 1.0.1 → 1.0.2

package/lib/config-store.d.ts

@@ -20,17 +20,29 @@ export interface StoreConfig {
     bots: ManagedBotConfig[];
     loadBalance: Required<LoadBalanceConfig>;
 }
+type ExternalChangeListener = (next: StoreConfig, prev: StoreConfig) => void | Promise<void>;
 export declare class ConfigStore {
     private ctx;
     private configRoot;
     private configPath;
     private config;
     private saveTimer;
+    private reloadTimer;
+    private skipWatchUntil;
+    private watching;
+    private externalChangeListeners;
+    private logger;
+    private readonly onFileChanged;
     constructor(ctx: Context);
     private ensureDir;
     private normalize;
     private loadConfig;
+    private startWatching;
+    private stopWatching;
+    private scheduleReloadFromDisk;
+    private reloadFromDisk;
     private saveConfigSync;
+    onExternalChange(listener: ExternalChangeListener): () => void;
     private scheduleSave;
     getAll(): StoreConfig;
     getRuntime(): RuntimeConfig;
@@ -40,4 +52,6 @@ export declare class ConfigStore {
     setLoadBalance(loadBalance: Partial<LoadBalanceConfig>): void;
     setBots(bots: ManagedBotConfig[]): void;
     flush(): void;
+    dispose(): void;
 }
+export {};

package/lib/index.js

@@ -1695,11 +1695,11 @@ var LoadBalancer = class {
           selectedBot = this.selectBotByGreedy(validBots, botRemainingCapacity, botLoad);
         }
         if (!selectedBot) {
-          const unassignedValue = this.config.unassignedValue;
-          if (unassignedValue !== void 0 && unassignedValue !== "") {
+          const unassignedValue2 = this.config.unassignedValue;
+          if (unassignedValue2 !== void 0 && unassignedValue2 !== "") {
             const lastAssignee2 = this.lastAssignees.get(channel.channelId);
-            if (lastAssignee2 !== unassignedValue) {
-              assignments.push({ channelId: channel.channelId, assignee: unassignedValue });
+            if (lastAssignee2 !== unassignedValue2) {
+              assignments.push({ channelId: channel.channelId, assignee: unassignedValue2 });
               this.logger.info(`群 ${channel.channelId} 所有 Bot 达到上限，设为未分配`);
             }
           } else {
@@ -1725,14 +1725,28 @@ 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;
+      const managedChannels = channels.filter((c) => this.shouldManageChannel(c.channelId));
+      const priorityCount = managedChannels.filter((c) => c.isPriority).length;
+      const configuredPriorityCount = new Set(this.config.priorityChannels || []).size;
+      const unassignedValue = this.config.unassignedValue || "";
+      let assignedTotal = 0;
+      let unassignedTotal = 0;
+      for (const [, assignee] of this.lastAssignees.entries()) {
+        if (assignee && assignee !== unassignedValue) {
+          assignedTotal++;
+        } else {
+          unassignedTotal++;
+        }
+      }
       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(
+          `负载均衡完成，本轮变更 ${assignments.length} 个群；当前已分配 ${assignedTotal} 个，未分配 ${unassignedTotal} 个；关键群（参与调度）${priorityCount} / 配置总数 ${configuredPriorityCount}`
+        );
         this.logger.info(`负载分布: [${loadInfo}]，平均: ${avg.toFixed(1)}，标准差: ${stdDev.toFixed(2)}`);
       }
     } catch (e) {
@@ -1914,10 +1928,12 @@ var DEFAULT_CONFIG = {
 var ConfigStore = class {
   constructor(ctx) {
     this.ctx = ctx;
+    this.logger = this.ctx.logger("adapter-onebot-multi");
     this.configRoot = path.join(ctx.baseDir, "data", "adapter-onebot-multi");
     this.configPath = path.join(this.configRoot, "config.yaml");
     this.ensureDir(this.configRoot);
     this.loadConfig();
+    this.startWatching();
   }
   static {
     __name(this, "ConfigStore");
@@ -1926,6 +1942,17 @@ var ConfigStore = class {
   configPath;
   config = structuredClone(DEFAULT_CONFIG);
   saveTimer = null;
+  reloadTimer = null;
+  skipWatchUntil = 0;
+  watching = false;
+  externalChangeListeners = /* @__PURE__ */ new Set();
+  logger;
+  onFileChanged = /* @__PURE__ */ __name((curr, prev) => {
+    if (!this.watching) return;
+    if (curr.mtimeMs === prev.mtimeMs) return;
+    if (Date.now() < this.skipWatchUntil) return;
+    this.scheduleReloadFromDisk();
+  }, "onFileChanged");
   ensureDir(dir) {
     if (!fs.existsSync(dir)) {
       fs.mkdirSync(dir, { recursive: true });
@@ -1981,15 +2008,57 @@ var ConfigStore = class {
       const parsed = yaml.parse(content);
       this.config = this.normalize(parsed);
     } catch (error) {
-      this.ctx.logger("adapter-onebot-multi").warn("读取配置失败，使用默认配置: %s", error);
+      this.logger.warn("读取配置失败，使用默认配置: %s", error);
       this.config = structuredClone(DEFAULT_CONFIG);
       this.saveConfigSync();
     }
   }
+  startWatching() {
+    if (this.watching) return;
+    this.watching = true;
+    fs.watchFile(this.configPath, { interval: 1e3 }, this.onFileChanged);
+  }
+  stopWatching() {
+    if (!this.watching) return;
+    fs.unwatchFile(this.configPath, this.onFileChanged);
+    this.watching = false;
+  }
+  scheduleReloadFromDisk() {
+    if (this.reloadTimer) clearTimeout(this.reloadTimer);
+    this.reloadTimer = setTimeout(() => {
+      this.reloadTimer = null;
+      this.reloadFromDisk();
+    }, 200);
+  }
+  reloadFromDisk() {
+    try {
+      const content = fs.readFileSync(this.configPath, "utf8");
+      const parsed = yaml.parse(content);
+      const normalized = this.normalize(parsed);
+      const prev = structuredClone(this.config);
+      if (JSON.stringify(prev) === JSON.stringify(normalized)) return;
+      this.config = normalized;
+      this.logger.info("检测到配置文件变更，已重新加载。");
+      for (const listener of this.externalChangeListeners) {
+        Promise.resolve(listener(structuredClone(this.config), prev)).catch((error) => {
+          this.logger.warn("配置变更回调执行失败: %s", error);
+        });
+      }
+    } catch (error) {
+      this.logger.warn("重新加载配置失败，忽略本次变更: %s", error);
+    }
+  }
   saveConfigSync() {
+    this.skipWatchUntil = Date.now() + 300;
     const content = yaml.stringify(this.config, { indent: 2, lineWidth: 120 });
     fs.writeFileSync(this.configPath, content, "utf8");
   }
+  onExternalChange(listener) {
+    this.externalChangeListeners.add(listener);
+    return () => {
+      this.externalChangeListeners.delete(listener);
+    };
+  }
   scheduleSave() {
     if (this.saveTimer) clearTimeout(this.saveTimer);
     this.saveTimer = setTimeout(() => {
@@ -2037,6 +2106,14 @@ var ConfigStore = class {
     }
     this.saveConfigSync();
   }
+  dispose() {
+    if (this.reloadTimer) {
+      clearTimeout(this.reloadTimer);
+      this.reloadTimer = null;
+    }
+    this.stopWatching();
+    this.flush();
+  }
 };
 
 // src/index.ts
@@ -2066,6 +2143,28 @@ function apply(ctx, _config) {
   }, "getGlobalConfig");
   ctx._onebotMultiGlobalConfig = getGlobalConfig();
   const loadBalancer = new LoadBalancer(ctx, configStore.getLoadBalance(), statusManager);
+  const stopConfigWatcher = configStore.onExternalChange(async (next, prev) => {
+    const runtimeChanged = JSON.stringify(prev.runtime) !== JSON.stringify(next.runtime);
+    const loadBalanceChanged = JSON.stringify(prev.loadBalance) !== JSON.stringify(next.loadBalance);
+    const botsChanged = JSON.stringify(prev.bots) !== JSON.stringify(next.bots);
+    if (runtimeChanged) {
+      ;
+      ctx._onebotMultiGlobalConfig = getGlobalConfig();
+      const restartTargets = configStore.getBots().filter((bot) => bot.enabled !== false).map((bot) => bot.selfId);
+      for (const selfId of restartTargets) {
+        await restartBot(selfId);
+      }
+      logger.info("检测到 runtime 配置更新，已重启启用中的 Bot。");
+    }
+    if (loadBalanceChanged) {
+      loadBalancer.updateConfig(configStore.getLoadBalance());
+      logger.info("检测到 loadBalance 配置更新，已应用。");
+    }
+    if (botsChanged) {
+      await syncBots();
+      logger.info("检测到 bots 配置更新，已同步 Bot 状态。");
+    }
+  });
   const getBotListView = /* @__PURE__ */ __name(() => {
     const runtime = statusManager.getStatus();
     const runtimeMap = new Map(runtime.bots.map((b) => [String(b.selfId), b]));
@@ -2344,11 +2443,12 @@ function apply(ctx, _config) {
     logger.info(`Bot 配置 selfId 自动更新: ${configKey} -> ${runtimeSelfId}`);
   });
   ctx.on("dispose", async () => {
+    stopConfigWatcher();
     for (const selfId of Array.from(managedBotIds)) {
       await stopBot(selfId);
     }
     loadBalancer.dispose();
-    configStore.flush();
+    configStore.dispose();
   });
 }
 __name(apply, "apply");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-adapter-onebot-multi",
   "description": "奶龙bot定制版onebot适配器，支持自动负载均衡与黑白名单，控制台侧边栏管理",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [