evolcore 0.0.1 → 0.0.2

package/dist/core/channel-loader.js

@@ -0,0 +1,277 @@
+/**
+ * Channel Plugin System
+ *
+ * Provides a lightweight plugin interface for channel integration.
+ * Plugins are responsible for creating channel instances only.
+ * The main service (index.ts) handles registration and message flow wiring.
+ */
+import { logger } from '../utils/logger.js';
+// ── Shared helpers for plugins ─────────────────────────────────────────────
+/** Resolve showActivities for a single instance (instance overrides default). */
+export function resolveShowActivities(inst) {
+    return inst.showActivities ?? 'all';
+}
+/**
+ * showMiddleResult / showIdleMonitor 策略。
+ * show_activities 只对 interactive 私聊中间输出有意义：
+ *   all → 文本 + activity；text → 仅文本；none → 全部静默。
+ */
+export function middleOutputModePolicy(mode, chatType, _identity) {
+    if (chatType !== 'private')
+        return 'none';
+    return mode;
+}
+export function showActivitiesPolicy(mode, chatType, _identity) {
+    return middleOutputModePolicy(mode, chatType, _identity) !== 'none';
+}
+// ── ChannelLoader ──────────────────────────────────────────────────────────
+export class ChannelLoader {
+    plugins = new Map();
+    register(plugin) {
+        if (this.plugins.has(plugin.name)) {
+            throw new Error(`Channel plugin '${plugin.name}' already registered`);
+        }
+        this.plugins.set(plugin.name, plugin);
+        logger.debug(`Registered channel plugin: ${plugin.name}`);
+    }
+    /** Look up a registered plugin by channel type (used by reload hooks). */
+    getPlugin(type) {
+        return this.plugins.get(type);
+    }
+    /**
+     * Create all runtime channels for an agent directly from its config.channels[].
+     * AUN is always created implicitly from agent.aid (no explicit entry required).
+     */
+    async createForAgent(agent) {
+        const ctx = {
+            agentName: agent.aid,
+            defaultProjectPath: agent.config.projects?.defaultPath ?? process.cwd(),
+            debug: agent.config.debug,
+        };
+        // Build the full list of config instances to create.
+        // AUN is synthesised from agent.aid; any explicit aun entry in channels[] is skipped.
+        const aunEffName = agent.effectiveChannelName('aun', 'main');
+        const aunInst = {
+            type: 'aun',
+            name: aunEffName,
+            aid: agent.aid,
+            owner: agent.getOwner(aunEffName),
+            enabled: true,
+        };
+        const configInsts = [aunInst];
+        for (const inst of agent.config.channels) {
+            if (inst.type === 'aun')
+                continue;
+            const effName = agent.effectiveChannelName(inst.type, inst.name);
+            configInsts.push({ ...inst, name: effName });
+        }
+        return this._buildInstances(configInsts, ctx);
+    }
+    /** Build runtime instances for a list of config instances + context. */
+    async _buildInstances(configInsts, ctx) {
+        const result = [];
+        for (const inst of configInsts) {
+            const plugin = this.plugins.get(inst.type);
+            if (!plugin) {
+                logger.debug(`No plugin for channel type '${inst.type}', skipping`);
+                continue;
+            }
+            try {
+                const runtime = await plugin.createInstance(inst, ctx);
+                if (runtime) {
+                    result.push(runtime);
+                    logger.info(`✓ Channel '${inst.name}' (${inst.type}) created`);
+                }
+                else {
+                    logger.info(`Channel '${inst.name}' (${inst.type}) disabled or invalid credentials, skipping`);
+                }
+            }
+            catch (err) {
+                logger.error(`✗ Failed to create channel '${inst.name}' (${inst.type}):`, err);
+            }
+        }
+        return result;
+    }
+    async connectAll(instances, { concurrency = 3, intervalMs = 50, onConnected, onFailed } = {}) {
+        const connected = [];
+        const failed = [];
+        const inflight = new Set();
+        for (const inst of instances) {
+            while (inflight.size >= concurrency) {
+                await Promise.race(inflight);
+            }
+            const task = (async () => {
+                try {
+                    await inst.connect();
+                    connected.push(inst.adapter.channelName);
+                    // Fire callback without blocking the connection pipeline
+                    if (onConnected) {
+                        Promise.resolve(onConnected(inst)).catch((callbackErr) => {
+                            logger.warn(`[connectAll] ${inst.adapter.channelName} onConnected callback failed: ${callbackErr}`);
+                        });
+                    }
+                }
+                catch (e) {
+                    failed.push({ name: inst.adapter.channelName, error: e });
+                    logger.warn(`[connectAll] ${inst.adapter.channelName} connect failed: ${e}`);
+                    // Fire callback without blocking the connection pipeline
+                    if (onFailed) {
+                        Promise.resolve(onFailed(inst, e)).catch((callbackErr) => {
+                            logger.warn(`[connectAll] ${inst.adapter.channelName} onFailed callback failed: ${callbackErr}`);
+                        });
+                    }
+                }
+            })();
+            const tracked = task.finally(() => { inflight.delete(tracked); });
+            inflight.add(tracked);
+            if (intervalMs > 0) {
+                await new Promise(r => setTimeout(r, intervalMs));
+            }
+        }
+        await Promise.allSettled(inflight);
+        if (failed.length > 0) {
+            logger.warn(`[connectAll] ${failed.length} channel(s) failed initial connect (will retry in background): ${failed.map(f => f.name).join(', ')}`);
+        }
+        return connected;
+    }
+    async disconnectAll(instances) {
+        await Promise.allSettled(instances.map(inst => inst.disconnect()));
+    }
+}
+const SEP = '#';
+export function formatChannelKey(k) {
+    if (k.selfAID.includes(SEP)) {
+        throw new Error(`Invalid selfAID (contains '#'): ${k.selfAID}`);
+    }
+    return `${k.type}${SEP}${k.selfAID}${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 [type, selfAID, name] = parts;
+    if (!type || !selfAID || !name) {
+        throw new Error(`Invalid channel key (empty segment): ${key}`);
+    }
+    return { type, selfAID, 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, unregisterChannelInstance, messageQueue, handoffRuntime, onChannelStarted, onChannelConnected } = deps;
+    const drainDelayMs = deps.drainDelayMs ?? 500;
+    const drainTimeoutMs = deps.drainTimeoutMs ?? 30000;
+    return {
+        async prepareHandoffReload(aid) {
+            if (!handoffRuntime)
+                return;
+            logger.info(`[Reload] Pausing Handoff dispatcher for agent: ${aid}`);
+            handoffRuntime.pauseAgent(aid);
+            await handoffRuntime.drainAgent(aid, drainTimeoutMs);
+        },
+        async completeHandoffReload(aid) {
+            if (!handoffRuntime)
+                return;
+            try {
+                await handoffRuntime.recover([aid]);
+            }
+            finally {
+                handoffRuntime.resumeAgent(aid);
+            }
+            logger.info(`[Reload] Resumed Handoff dispatcher for agent: ${aid}`);
+        },
+        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);
+                // 从 core 各 map 注销，避免死实例残留在 /status「未归属渠道」、菜单路由和 adapter 查找里
+                unregisterChannelInstance?.(channelName);
+                logger.info(`[Reload] Disconnected channel: ${channelName}`);
+            }
+            catch (e) {
+                logger.error(`[Reload] Failed to disconnect ${channelName}: ${e}`);
+                throw e;
+            }
+        },
+        async startChannel(agent, channelName) {
+            // The implicit AUN channel is synthesised from agent.aid (not in config.channels[]).
+            // Reconstruct it the same way createForAgent does before falling back to config scan.
+            const aid = agent.aid ?? agent.config?.aid;
+            const aunEffName = agent.effectiveChannelName?.('aun', 'main') ?? 'aun-main';
+            const isImplicitAun = channelName === aunEffName;
+            // Find config instance: implicit AUN gets a synthetic entry; others scan channels[].
+            const cfgInst = isImplicitAun
+                ? { type: 'aun', name: aunEffName, aid, enabled: true }
+                : (() => {
+                    const agentChannels = agent.config?.channels ?? [];
+                    return agentChannels.find((i) => {
+                        const effName = agent.effectiveChannelName?.(i.type, i.name) ?? i.name;
+                        return effName === channelName;
+                    }) ?? null;
+                })();
+            if (!cfgInst) {
+                const msg = `[Reload] Channel ${channelName} not found in agent config`;
+                logger.error(msg);
+                throw new Error(msg);
+            }
+            const ctx = {
+                agentName: agent.aid ?? agent.config?.aid,
+                defaultProjectPath: agent.config?.projects?.defaultPath ?? process.cwd(),
+                debug: agent.config?.debug,
+            };
+            const plugin = channelLoader.getPlugin(cfgInst.type);
+            if (!plugin)
+                throw new Error(`[Reload] No plugin for channel type '${cfgInst.type}'`);
+            const effInst = { ...cfgInst, name: channelName };
+            const newInst = await plugin.createInstance(effInst, ctx);
+            if (!newInst) {
+                // createInstance returns null for a disabled / invalid-credential channel.
+                // Not an error: skip it. Throwing here would propagate to reload(), which
+                // turns it into agent error state and takes down every healthy channel too.
+                logger.warn(`[Reload] Channel ${channelName} (${cfgInst.type}) disabled or invalid credentials, skipping`);
+                return;
+            }
+            registerChannelInstance(newInst);
+            onChannelStarted?.(newInst);
+            await newInst.connect();
+            channelInstances.push(newInst);
+            await onChannelConnected?.(newInst);
+            logger.info(`[Reload] Started channel: ${channelName}`);
+        },
+    };
+}