evolclaw 2.8.3 → 3.0.0

package/dist/core/channel-loader.js

@@ -20,6 +20,50 @@ export class ChannelLoader {
         this.plugins.set(plugin.name, plugin);
         logger.debug(`Registered channel plugin: ${plugin.name}`);
     }
+    /**
+     * 新结构入口：从 EvolAgent 的 channels[] 列表创建 channel 实例。
+     *
+     * 内部把 ChannelInstance[] 翻成各 plugin 期望的 dict 形态（`{ type: [instances...] }`），
+     * 然后调用现有 plugin.createChannels / createChannel。
+     *
+     * 当所有 channel plugin 重写为直接吃 ChannelInstance[] 后，本方法可简化。
+     */
+    async createForAgent(agent) {
+        const rewrittenChannels = {};
+        // AUN channel 从 agent.aid 隐式创建——不需要在 channels[] 里显式声明
+        const aunEffName = agent.effectiveChannelName('aun', 'main');
+        rewrittenChannels['aun'] = [{
+                type: 'aun',
+                name: aunEffName,
+                aid: agent.aid,
+                enabled: true,
+                agentName: agent.aid,
+                // agent 顶层 owners[0] 透传给 AUN channel.owner（用于首次连接发欢迎消息）
+                owner: agent.config.owners?.[0],
+            }];
+        // 其它 channels（非 AUN）从 config.channels[] 取
+        for (const inst of agent.config.channels) {
+            if (inst.type === 'aun')
+                continue; // 跳过显式声明的 AUN（已隐式处理）
+            const effName = agent.effectiveChannelName(inst.type, inst.name);
+            const rewritten = { ...inst, name: effName, agentName: agent.aid };
+            (rewrittenChannels[inst.type] ??= []).push(rewritten);
+        }
+        // syntheticConfig 是老 Config schema（channel plugin 沿用旧接口），
+        // 新 schema 字段命名为 snake_case，这里转 camelCase 透传。
+        const syntheticConfig = {
+            agents: agent.config.baseagents,
+            channels: rewrittenChannels,
+            projects: agent.config.projects,
+            chatmode: agent.config.chatmode,
+            debug: agent.config.debug,
+            showActivities: agent.config.show_activities,
+            flushDelay: agent.config.flush_delay,
+            debounce: agent.config.debounce,
+            enableRichContent: agent.config.enable_rich_content,
+        };
+        return this.createAll(syntheticConfig);
+    }
     async createAll(config) {
         const instances = [];
         for (const [name, plugin] of this.plugins) {
@@ -45,17 +89,21 @@ export class ChannelLoader {
         }
         return instances;
     }
-    async connectAll(instances) {
-        const results = await Promise.allSettled(instances.map(async (inst) => {
-            await inst.connect();
-            return inst.adapter.channelName;
-        }));
-        const connected = results
-            .filter((r) => r.status === 'fulfilled')
-            .map((r) => r.value);
-        const failed = results
-            .filter((r) => r.status === 'rejected')
-            .map((r) => r.reason);
+    async connectAll(instances, delayMs = 150) {
+        const connected = [];
+        const failed = [];
+        for (const inst of instances) {
+            try {
+                await inst.connect();
+                connected.push(inst.adapter.channelName);
+            }
+            catch (e) {
+                failed.push(e);
+            }
+            if (delayMs > 0 && inst !== instances[instances.length - 1]) {
+                await new Promise(r => setTimeout(r, delayMs));
+            }
+        }
         if (failed.length > 0) {
             logger.warn(`Some channels failed to connect:`, failed);
         }
@@ -65,3 +113,106 @@ export class ChannelLoader {
         await Promise.allSettled(instances.map((inst) => inst.disconnect()));
     }
 }
+const SEP = '#';
+export function formatChannelKey(k) {
+    return `${k.aid}${SEP}${k.type}${SEP}${k.name}`;
+}
+export function parseChannelKey(key) {
+    const parts = key.split(SEP);
+    if (parts.length !== 3) {
+        throw new Error(`Invalid channel key (expected 3 segments separated by '#'): ${key}`);
+    }
+    const [aid, type, name] = parts;
+    if (!aid || !type || !name) {
+        throw new Error(`Invalid channel key (empty segment): ${key}`);
+    }
+    return { aid, type, name };
+}
+export function tryParseChannelKey(key) {
+    try {
+        return parseChannelKey(key);
+    }
+    catch {
+        return null;
+    }
+}
+export function isValidChannelName(name) {
+    return typeof name === 'string' && name.length > 0 && !name.includes(SEP);
+}
+export function buildReloadHooks(deps) {
+    const { channelLoader, channelInstances, registerChannelInstance, messageQueue } = deps;
+    const drainDelayMs = deps.drainDelayMs ?? 500;
+    const drainTimeoutMs = deps.drainTimeoutMs ?? 30000;
+    return {
+        async drainChannel(channelName) {
+            logger.info(`[Reload] Draining channel: ${channelName}`);
+            if (messageQueue) {
+                const pollMs = 100;
+                const start = Date.now();
+                while (messageQueue.isChannelProcessing(channelName)) {
+                    if (Date.now() - start > drainTimeoutMs) {
+                        logger.warn(`[Reload] Drain timeout (${drainTimeoutMs}ms) for channel: ${channelName}, proceeding anyway`);
+                        return;
+                    }
+                    await new Promise(r => setTimeout(r, pollMs));
+                }
+                logger.info(`[Reload] Drain complete: ${channelName}`);
+            }
+            else if (drainDelayMs > 0) {
+                await new Promise(r => setTimeout(r, drainDelayMs));
+            }
+        },
+        async disconnectChannel(channelName) {
+            const inst = channelInstances.find(i => i.adapter.channelName === channelName);
+            if (!inst) {
+                logger.warn(`[Reload] Channel ${channelName} not found, skipping disconnect`);
+                return;
+            }
+            try {
+                await inst.disconnect();
+                const idx = channelInstances.indexOf(inst);
+                if (idx >= 0)
+                    channelInstances.splice(idx, 1);
+                logger.info(`[Reload] Disconnected channel: ${channelName}`);
+            }
+            catch (e) {
+                logger.error(`[Reload] Failed to disconnect ${channelName}: ${e}`);
+                throw e;
+            }
+        },
+        async startChannel(agent, channelName) {
+            const channels = agent.config.channels;
+            let channelType = null;
+            for (const [type, raw] of Object.entries(channels)) {
+                const instances = Array.isArray(raw) ? raw : [raw];
+                for (const inst of instances) {
+                    const name = inst.name ?? type;
+                    if (name === channelName) {
+                        channelType = type;
+                        break;
+                    }
+                }
+                if (channelType)
+                    break;
+            }
+            if (!channelType) {
+                const msg = `[Reload] Channel ${channelName} not found in agent ${agent.name} config`;
+                logger.error(msg);
+                throw new Error(msg);
+            }
+            const partialConfig = {
+                agents: agent.config.agents,
+                channels: { [channelType]: channels[channelType] },
+                projects: agent.config.projects,
+            };
+            const newInstances = await channelLoader.createAll(partialConfig);
+            const newInst = newInstances.find(i => i.adapter.channelName === channelName);
+            if (!newInst)
+                throw new Error(`[Reload] Failed to create instance ${channelName}`);
+            registerChannelInstance(newInst);
+            await newInst.connect();
+            channelInstances.push(newInst);
+            logger.info(`[Reload] Started channel: ${channelName}`);
+        },
+    };
+}