evolcore 0.0.1 → 0.0.2

package/dist/core/evolagent-registry.js

@@ -0,0 +1,546 @@
+import fs from 'fs';
+import path from 'path';
+import { EvolAgent } from './evolagent.js';
+import { logger } from '../utils/logger.js';
+import { agentMdPath, agentPersonalDir } from '../paths.js';
+import { loadAllAgents, ensureAgentDirSkeleton, loadAgent, validateAgentConfig, } from '../config-store.js';
+import { resolveEffective } from '../config/config-manager.js';
+// ── Channel Fingerprint ───────────────────────────────────────────────────
+// 用于检测多 agent 之间复用同一外部凭证的冲突（appId、aid、token 等）。
+// 格式：{type}:{primaryKey}
+const PRIMARY_KEY_MAP = {
+    feishu: 'appId',
+    aun: '__aid__', // AUN 实例的“凭证”就是 agent 自身 aid
+    wechat: 'token',
+    wecom: 'botId',
+    dingtalk: 'clientId',
+    qqbot: 'appId',
+};
+export function extractFingerprint(channelType, instance, agentAid) {
+    const keyField = PRIMARY_KEY_MAP[channelType];
+    if (!keyField)
+        return null;
+    if (keyField === '__aid__')
+        return `${channelType}:${agentAid}`;
+    const value = instance[keyField];
+    if (!value || typeof value !== 'string')
+        return null;
+    return `${channelType}:${value}`;
+}
+/**
+ * 跨 agent 检查同一外部凭证是否被多次声明（飞书 appId、AUN aid 等）。
+ */
+export function detectDuplicates(agents) {
+    const seen = new Map();
+    for (const agent of agents) {
+        for (const inst of agent.config.channels) {
+            const fp = extractFingerprint(inst.type, inst, agent.aid);
+            if (!fp)
+                continue;
+            const arr = seen.get(fp) ?? [];
+            arr.push({ aid: agent.aid, channelName: agent.effectiveChannelName(inst.type, inst.name) });
+            seen.set(fp, arr);
+        }
+    }
+    const out = [];
+    for (const [fp, arr] of seen) {
+        if (arr.length > 1) {
+            const [type] = fp.split(':');
+            out.push({ fingerprint: fp, channelType: type, agents: arr });
+        }
+    }
+    return out;
+}
+// ── Registry ──────────────────────────────────────────────────────────────
+export class EvolAgentRegistry {
+    _agentsDir;
+    agents = new Map();
+    /** channel key (`<type>#<selfAID>#<name>`) → agent aid */
+    channelIndex = new Map();
+    /** 启动期被 ConfigStore 跳过的目录（命名非法 / 缺 config.json / 校验失败等） */
+    skipped = [];
+    /**
+     * agentsDir 参数保留作 ctor 兼容，但实际加载走 ConfigStore（基于 paths.ts）。
+     * globalWriter 已废弃——构造期接受但忽略，阶段 2c 删除。
+     */
+    constructor(_agentsDir, _globalWriter) {
+        this._agentsDir = _agentsDir;
+        void _globalWriter;
+    }
+    setGlobalWriter(_writer) {
+        void _writer; // no-op，废弃 API
+    }
+    /**
+     * 扫描 agents/ 目录加载所有 self-agent 配置（合并 defaults），构造 EvolAgent
+     * 实例并建立 channel 路由索引。
+     *
+     * `globalConfig` 参数保留作签名兼容，但被忽略——defaults 由 ConfigStore 自己加载。
+     */
+    loadAll(_globalConfig) {
+        void _globalConfig;
+        this.agents.clear();
+        this.channelIndex.clear();
+        this.skipped = [];
+        const { agents: rawAgents, skipped, invalidAgents = [] } = loadAllAgents({ includeInvalid: true });
+        this.skipped = skipped;
+        for (const raw of rawAgents) {
+            try {
+                const merged = resolveEffective({ self: raw.aid });
+                const agent = new EvolAgent(raw, merged);
+                ensureAgentDirSkeleton(raw.aid);
+                this.agents.set(agent.aid, agent);
+            }
+            catch (e) {
+                logger.warn(`[EvolAgentRegistry] failed to construct agent ${raw.aid}: ${e}`);
+            }
+        }
+        for (const { agent: raw, reason } of invalidAgents) {
+            this.registerErrorAgent(raw, reason);
+        }
+        this.detectAndFlagConflicts();
+        this.buildChannelIndex();
+    }
+    registerErrorAgent(raw, reason) {
+        try {
+            const merged = this.resolveMergedForErrorAgent(raw, reason);
+            const agent = new EvolAgent(raw, merged);
+            agent.status = 'error';
+            agent.error = reason;
+            ensureAgentDirSkeleton(raw.aid);
+            this.agents.set(agent.aid, agent);
+            logger.warn(`[EvolAgentRegistry] loaded invalid agent ${raw.aid} as error: ${reason}`);
+            return agent;
+        }
+        catch (e) {
+            logger.warn(`[EvolAgentRegistry] failed to register invalid agent ${raw.aid}: ${e}`);
+            return null;
+        }
+    }
+    resolveMergedForErrorAgent(raw, reason) {
+        try {
+            return resolveEffective({ self: raw.aid });
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            logger.warn(`[EvolAgentRegistry] fallback effective config for invalid agent ${raw.aid}: ${message}; original error: ${reason}`);
+            return {
+                ...raw,
+                $schema_version: raw.$schema_version ?? 1,
+                aid: raw.aid,
+                enabled: raw.enabled,
+                owners: raw.owners,
+                admins: raw.admins,
+                channels: Array.isArray(raw.channels) ? raw.channels : [],
+                active_baseagent: raw.active_baseagent,
+                baseagents: raw.baseagents,
+                projects: raw.projects,
+                chatmode: raw.chatmode,
+            };
+        }
+    }
+    detectAndFlagConflicts() {
+        const dups = detectDuplicates([...this.agents.values()].filter(a => a.status !== 'error' && a.status !== 'disabled'));
+        for (const d of dups) {
+            const owners = d.agents.map(o => `${o.aid}(${o.channelName})`).join(', ');
+            const msg = `Channel conflict: ${d.fingerprint} claimed by ${owners}`;
+            logger.error(`[EvolAgentRegistry] ${msg}`);
+            for (const o of d.agents) {
+                const a = this.agents.get(o.aid);
+                if (a && a.status !== 'error') {
+                    a.status = 'error';
+                    a.error = msg;
+                }
+            }
+        }
+    }
+    buildChannelIndex() {
+        for (const agent of this.agents.values()) {
+            if (agent.status === 'error' || agent.status === 'disabled')
+                continue;
+            for (const key of agent.channelInstanceNames()) {
+                const prev = this.channelIndex.get(key);
+                if (prev && prev !== agent.aid) {
+                    logger.warn(`[EvolAgentRegistry] channel key "${key}" claimed by both ${prev} and ${agent.aid}`);
+                }
+                this.channelIndex.set(key, agent.aid);
+            }
+        }
+    }
+    resolveByChannel(channelKey) {
+        const aid = this.channelIndex.get(channelKey);
+        if (!aid)
+            return null;
+        return this.agents.get(aid) ?? null;
+    }
+    isOwner(channelKey, userId, _globalFallback) {
+        void _globalFallback;
+        const agent = this.resolveByChannel(channelKey);
+        return agent?.isOwner(channelKey, userId) ?? false;
+    }
+    isAdmin(channelKey, userId, _globalFallback) {
+        void _globalFallback;
+        const agent = this.resolveByChannel(channelKey);
+        return agent?.isAdmin(channelKey, userId) ?? false;
+    }
+    getOwner(channelKey) {
+        return this.resolveByChannel(channelKey)?.getOwner(channelKey);
+    }
+    setChannelOwner(channelKey, userId) {
+        const agent = this.resolveByChannel(channelKey);
+        if (!agent) {
+            logger.warn(`[EvolAgentRegistry] setChannelOwner: channel "${channelKey}" not found`);
+            return;
+        }
+        agent.setOwner(channelKey, userId);
+    }
+    getShowActivities(channelKey) {
+        return this.resolveByChannel(channelKey)?.getShowActivities(channelKey) ?? 'all';
+    }
+    setShowActivities(channelKey, mode) {
+        const agent = this.resolveByChannel(channelKey);
+        if (!agent) {
+            logger.warn(`[EvolAgentRegistry] setShowActivities: channel "${channelKey}" not found`);
+            return;
+        }
+        agent.setShowActivities(channelKey, mode);
+    }
+    get(aidOrName) {
+        return this.agents.get(aidOrName) ?? null;
+    }
+    list() {
+        return [...this.agents.values()].map(a => this.toInfo(a));
+    }
+    invalidateAgentDisplayCache(aid) {
+        this.displayNameCache.delete(aid);
+        this.personalNameCache.delete(aid);
+        this.displayNamePending.delete(aid);
+    }
+    runnableAgents() {
+        return [...this.agents.values()].filter(a => a.status === 'stopped');
+    }
+    getSkipped() {
+        return [...this.skipped];
+    }
+    loadNewAgent(aid) {
+        if (this.agents.has(aid)) {
+            logger.info(`[EvolAgentRegistry] agent ${aid} already loaded, skipping`);
+            return this.agents.get(aid);
+        }
+        let raw = null;
+        try {
+            raw = loadAgent(aid);
+        }
+        catch (e) {
+            const reason = e instanceof Error ? e.message : String(e);
+            logger.warn(`[EvolAgentRegistry] loadNewAgent ${aid}: ${reason}`);
+            return this.registerErrorAgent({
+                $schema_version: 1,
+                aid,
+                enabled: true,
+                channels: [],
+            }, reason);
+        }
+        if (!raw) {
+            logger.warn(`[EvolAgentRegistry] loadNewAgent: ${aid}/config.json not found`);
+            return null;
+        }
+        const errs = validateAgentConfig(raw);
+        if (errs.length > 0) {
+            const reason = errs.join('; ');
+            logger.warn(`[EvolAgentRegistry] loadNewAgent ${aid}: ${reason}`);
+            return this.registerErrorAgent(raw, reason);
+        }
+        const conflict = this.checkConflictForReload(raw, aid);
+        if (conflict) {
+            logger.warn(`[EvolAgentRegistry] loadNewAgent ${aid}: ${conflict}`);
+            return this.registerErrorAgent(raw, `Channel conflict: ${conflict}`);
+        }
+        const merged = resolveEffective({ self: aid });
+        const agent = new EvolAgent(raw, merged);
+        ensureAgentDirSkeleton(aid);
+        this.agents.set(aid, agent);
+        for (const key of agent.channelInstanceNames()) {
+            this.channelIndex.set(key, aid);
+        }
+        logger.info(`[EvolAgentRegistry] Hot-loaded agent: ${aid}`);
+        return agent;
+    }
+    async reload(aidOrName, hooks) {
+        const oldAgent = this.agents.get(aidOrName);
+        if (!oldAgent)
+            throw new Error(`Agent "${aidOrName}" not found`);
+        const raw = loadAgent(oldAgent.aid);
+        if (!raw)
+            throw new Error(`Agent ${oldAgent.aid}/config.json missing on reload`);
+        const errs = validateAgentConfig(raw);
+        if (errs.length > 0)
+            throw new Error(`Invalid config after edit: ${errs.join('; ')}`);
+        const merged = resolveEffective({ self: raw.aid });
+        if (oldAgent.status === 'disabled' && raw.enabled !== false) {
+            oldAgent.swapConfig(raw, merged);
+            const hotLoad = globalThis.__evolcore_hotLoadAgent;
+            if (!hotLoad)
+                throw new Error(`Cannot enable agent "${aidOrName}": hot-load handler not initialized`);
+            this.agents.delete(oldAgent.aid);
+            this.channelIndex.clear();
+            this.buildChannelIndex();
+            await hotLoad(oldAgent.aid);
+            logger.info(`[Reload] Agent "${aidOrName}" transitioned from disabled to enabled`);
+            return;
+        }
+        if (oldAgent.status !== 'disabled' && raw.enabled === false) {
+            let prepared = false;
+            try {
+                await hooks.prepareHandoffReload?.(oldAgent.aid);
+                prepared = true;
+                for (const ch of oldAgent.channelInstanceNames()) {
+                    try {
+                        await hooks.drainChannel(ch);
+                    }
+                    catch { }
+                    try {
+                        await hooks.disconnectChannel(ch);
+                    }
+                    catch { }
+                }
+                oldAgent.swapConfig(raw, merged);
+                oldAgent.status = 'disabled';
+                this.channelIndex.clear();
+                this.buildChannelIndex();
+                logger.info(`[Reload] Agent "${aidOrName}" disabled`);
+                return;
+            }
+            catch (error) {
+                if (prepared) {
+                    try {
+                        await hooks.completeHandoffReload?.(oldAgent.aid);
+                    }
+                    catch { }
+                }
+                throw error;
+            }
+        }
+        const conflict = this.checkConflictForReload(raw, oldAgent.aid);
+        if (conflict)
+            throw new Error(`Channel conflict: ${conflict}`);
+        const removedSuccessfully = [];
+        const addedSuccessfully = [];
+        let prepared = false;
+        try {
+            await hooks.prepareHandoffReload?.(oldAgent.aid);
+            prepared = true;
+            const oldChannels = new Set(oldAgent.channelInstanceNames());
+            const aunKey = oldAgent.effectiveChannelName('aun', 'main');
+            const otherKeys = raw.channels.filter(c => c.type !== 'aun').map(c => oldAgent.effectiveChannelName(c.type, c.name));
+            const newChannels = new Set([aunKey, ...otherKeys]);
+            const toRemove = [...oldChannels].filter(c => !newChannels.has(c));
+            const toAdd = [...newChannels].filter(c => !oldChannels.has(c));
+            const kept = [...oldChannels].filter(c => newChannels.has(c));
+            const credentialsChanged = [];
+            for (const ch of kept) {
+                const oldInst = oldAgent.findChannelInstance(ch);
+                const newInst = findInstanceByKey(raw, oldAgent, ch);
+                if (oldInst && newInst && JSON.stringify(oldInst) !== JSON.stringify(newInst)) {
+                    credentialsChanged.push(ch);
+                }
+            }
+            toRemove.push(...credentialsChanged);
+            toAdd.push(...credentialsChanged);
+            for (const ch of toRemove)
+                await hooks.drainChannel(ch);
+            for (const ch of toRemove) {
+                await hooks.disconnectChannel(ch);
+                removedSuccessfully.push(ch);
+            }
+            oldAgent.swapConfig(raw, merged);
+            oldAgent.invalidatePersonaCache();
+            for (const ch of toAdd) {
+                await hooks.startChannel(oldAgent, ch);
+                addedSuccessfully.push(ch);
+            }
+            oldAgent.status = 'running';
+            this.channelIndex.clear();
+            this.buildChannelIndex();
+            await hooks.completeHandoffReload?.(oldAgent.aid);
+            prepared = false;
+        }
+        catch (err) {
+            logger.error(`[Reload] Failed: ${err}. Attempting rollback for "${aidOrName}".`);
+            for (const ch of addedSuccessfully) {
+                try {
+                    await hooks.disconnectChannel(ch);
+                }
+                catch { }
+            }
+            if (prepared) {
+                try {
+                    await hooks.completeHandoffReload?.(oldAgent.aid);
+                }
+                catch (resumeError) {
+                    logger.error(`[Reload] Failed to resume Handoff dispatcher for "${aidOrName}":`, resumeError);
+                }
+            }
+            void removedSuccessfully;
+            oldAgent.status = 'error';
+            oldAgent.error = `Reload failed (rollback partial): ${err instanceof Error ? err.message : String(err)}`;
+            throw err;
+        }
+    }
+    async stopAgent(aidOrName, hooks) {
+        const agent = this.agents.get(aidOrName);
+        if (!agent)
+            throw new Error(`Agent "${aidOrName}" not found`);
+        if (agent.status === 'disabled')
+            throw new Error('Agent is disabled; use enable/disable instead');
+        if (agent.status === 'stopped')
+            return;
+        for (const ch of agent.channelInstanceNames()) {
+            try {
+                await hooks.disconnectChannel(ch);
+            }
+            catch { }
+        }
+        agent.status = 'stopped';
+        this.channelIndex.clear();
+        this.buildChannelIndex();
+        logger.info(`[Registry] Stopped agent ${aidOrName}`);
+    }
+    async startAgent(aidOrName, hooks) {
+        const agent = this.agents.get(aidOrName);
+        if (!agent)
+            throw new Error(`Agent "${aidOrName}" not found`);
+        if (agent.status === 'disabled')
+            throw new Error('Agent is disabled; use enable instead');
+        if (agent.status === 'error')
+            throw new Error(`Agent is in error state: ${agent.error ?? 'unknown error'}`);
+        if (agent.status === 'running')
+            return;
+        for (const ch of agent.channelInstanceNames()) {
+            await hooks.startChannel(agent, ch);
+        }
+        agent.status = 'running';
+        this.channelIndex.clear();
+        this.buildChannelIndex();
+        logger.info(`[Registry] Started agent ${aidOrName}`);
+    }
+    checkConflictForReload(newRaw, excludeAid) {
+        const newFps = new Set();
+        for (const inst of newRaw.channels) {
+            const fp = extractFingerprint(inst.type, inst, newRaw.aid);
+            if (fp)
+                newFps.add(fp);
+        }
+        for (const [aid, agent] of this.agents) {
+            if (aid === excludeAid)
+                continue;
+            if (agent.status === 'error' || agent.status === 'disabled')
+                continue;
+            for (const inst of agent.config.channels) {
+                const fp = extractFingerprint(inst.type, inst, agent.aid);
+                if (fp && newFps.has(fp))
+                    return `${fp} conflicts with agent "${aid}"`;
+            }
+        }
+        return null;
+    }
+    displayNameCache = new Map();
+    displayNamePending = new Set();
+    resolveDisplayName(aid) {
+        const cached = this.displayNameCache.get(aid);
+        if (cached)
+            return cached;
+        try {
+            const mdPath = agentMdPath(aid);
+            if (fs.existsSync(mdPath)) {
+                const content = fs.readFileSync(mdPath, 'utf-8');
+                const fm = content.match(/^---\n([\s\S]*?)\n---/);
+                if (fm) {
+                    const nm = fm[1].match(/^name:\s*["']?(.+?)["']?\s*$/m);
+                    if (nm?.[1]) {
+                        this.displayNameCache.set(aid, nm[1]);
+                        return nm[1];
+                    }
+                }
+            }
+        }
+        catch { }
+        if (!this.displayNamePending.has(aid)) {
+            this.displayNamePending.add(aid);
+            import('../aun/aid/index.js').then(({ agentmdGet }) => {
+                agentmdGet(aid).then(content => {
+                    if (typeof content === 'string') {
+                        const fm = content.match(/^---\n([\s\S]*?)\n---/);
+                        if (fm) {
+                            const nm = fm[1].match(/^name:\s*["']?(.+?)["']?\s*$/m);
+                            if (nm?.[1])
+                                this.displayNameCache.set(aid, nm[1]);
+                        }
+                    }
+                }).catch(() => { }).finally(() => this.displayNamePending.delete(aid));
+            }).catch(() => { this.displayNamePending.delete(aid); });
+        }
+        return undefined;
+    }
+    personalNameCache = new Map();
+    resolvePersonalName(aid) {
+        const cached = this.personalNameCache.get(aid);
+        if (cached !== undefined)
+            return cached;
+        try {
+            const personaPath = path.join(agentPersonalDir(aid), 'persona.md');
+            if (fs.existsSync(personaPath)) {
+                const content = fs.readFileSync(personaPath, 'utf-8');
+                const bold = content.match(/我[叫是]\s*\*{1,2}(.+?)\*{1,2}/);
+                if (bold?.[1]) {
+                    this.personalNameCache.set(aid, bold[1]);
+                    return bold[1];
+                }
+                const plain = content.match(/(?:我是|我叫)\s*([^\s（(，,。.)]+)/);
+                if (plain?.[1]) {
+                    this.personalNameCache.set(aid, plain[1]);
+                    return plain[1];
+                }
+            }
+        }
+        catch { }
+        this.personalNameCache.set(aid, undefined);
+        return undefined;
+    }
+    toInfo(agent) {
+        const displayName = this.resolveDisplayName(agent.aid);
+        const personalName = this.resolvePersonalName(agent.aid);
+        const owners = Array.from(new Set(agent.config.owners ?? []));
+        const channels = safeInfoValue(() => agent.channelInstanceNames(), []);
+        const projectPath = safeInfoValue(() => agent.projectPath, '');
+        const baseagent = safeInfoValue(() => agent.baseagent, agent.config.active_baseagent ?? '');
+        const model = baseagent ? safeInfoValue(() => agent.model, undefined) : undefined;
+        const effort = baseagent ? safeInfoValue(() => agent.effort, undefined) : undefined;
+        return {
+            name: displayName || agent.name || agent.aid,
+            displayName,
+            personalName,
+            aid: agent.aid,
+            status: agent.status,
+            channels,
+            projectPath,
+            baseagent,
+            model,
+            effort,
+            owners,
+            lastActivity: agent.lastActivity,
+            activeSessions: agent.activeSessions,
+            error: agent.error,
+        };
+    }
+}
+function safeInfoValue(fn, fallback) {
+    try {
+        return fn();
+    }
+    catch {
+        return fallback;
+    }
+}
+function findInstanceByKey(raw, agent, channelKey) {
+    return raw.channels.find(c => agent.effectiveChannelName(c.type, c.name) === channelKey) ?? null;
+}