evolclaw 2.8.1 → 2.8.2

package/dist/core/evolagent-registry.js

@@ -0,0 +1,503 @@
+import fs from 'fs';
+import path from 'path';
+import { EvolAgent, validateEvolAgentConfig } from './evolagent.js';
+import { logger } from '../utils/logger.js';
+// ── Channel Fingerprint ────────────────────────────────────────────────────
+// 为每个 channel 实例提取一个全局唯一标识，用于冲突检测和路由索引。
+// 格式：{type}:{primaryKey}
+const PRIMARY_KEY_MAP = {
+    feishu: 'appId',
+    aun: 'aid',
+    wechat: 'token',
+    wecom: 'botId',
+    dingtalk: 'clientId',
+    qqbot: 'appId',
+};
+export function extractFingerprint(channelType, instance) {
+    const keyField = PRIMARY_KEY_MAP[channelType];
+    if (!keyField)
+        return null;
+    const value = instance[keyField];
+    if (!value || typeof value !== 'string')
+        return null;
+    return `${channelType}:${value}`;
+}
+export function detectDuplicates(config) {
+    const seen = new Map();
+    const channels = config.channels || {};
+    for (const [type, raw] of Object.entries(channels)) {
+        if (type === 'defaultChannel')
+            continue;
+        const instances = Array.isArray(raw) ? raw : [raw];
+        for (const inst of instances) {
+            if (!inst || typeof inst !== 'object')
+                continue;
+            const fingerprint = extractFingerprint(type, inst);
+            if (!fingerprint)
+                continue;
+            const instName = inst.name ?? type;
+            const entry = seen.get(fingerprint);
+            if (entry) {
+                entry.instances.push(instName);
+            }
+            else {
+                seen.set(fingerprint, { channelType: type, instances: [instName] });
+            }
+        }
+    }
+    const duplicates = [];
+    for (const [fingerprint, entry] of seen) {
+        if (entry.instances.length > 1) {
+            duplicates.push({
+                fingerprint,
+                channelType: entry.channelType,
+                instances: entry.instances,
+            });
+        }
+    }
+    return duplicates;
+}
+export class EvolAgentRegistry {
+    agentsDir;
+    agents = new Map();
+    defaultAgent = null;
+    channelIndex = new Map();
+    globalWriter;
+    constructor(agentsDir, globalWriter) {
+        this.agentsDir = agentsDir;
+        this.globalWriter = globalWriter;
+    }
+    /** Late-binding setter for tests / index.ts wiring order. */
+    setGlobalWriter(writer) {
+        this.globalWriter = writer;
+    }
+    loadAll(globalConfig) {
+        this.agents.clear();
+        this.channelIndex.clear();
+        const files = fs.existsSync(this.agentsDir)
+            ? fs.readdirSync(this.agentsDir).filter(f => f.endsWith('.json'))
+            : [];
+        for (const file of files) {
+            const fullPath = path.join(this.agentsDir, file);
+            try {
+                const raw = JSON.parse(fs.readFileSync(fullPath, 'utf-8'));
+                const validation = validateEvolAgentConfig(raw);
+                if (!validation.valid) {
+                    const name = raw?.name || path.basename(file, '.json');
+                    const errorAgent = new EvolAgent(fullPath, { ...raw, name });
+                    errorAgent.status = 'error';
+                    errorAgent.error = validation.errors.join('; ');
+                    this.agents.set(name, errorAgent);
+                    logger.warn(`[EvolAgentRegistry] ${file}: ${validation.errors.join('; ')}`);
+                    continue;
+                }
+                const agent = new EvolAgent(fullPath, raw);
+                this.agents.set(agent.name, agent);
+            }
+            catch (e) {
+                logger.warn(`[EvolAgentRegistry] Failed to load ${file}: ${e}`);
+            }
+        }
+        this.defaultAgent = this.buildDefaultAgent(globalConfig);
+        this.detectAndFlagConflicts();
+        this.buildChannelIndex();
+    }
+    buildDefaultAgent(globalConfig) {
+        const agents = globalConfig.agents || {};
+        const defaultName = agents.defaultAgent || 'claude';
+        const cfg = {
+            name: '[default]',
+            enabled: true,
+            agents: { [defaultName]: agents[defaultName] || {} },
+            channels: globalConfig.channels || {},
+            projects: { defaultPath: globalConfig.projects?.defaultPath || process.cwd() },
+            chatmode: globalConfig.chatmode,
+        };
+        return new EvolAgent(null, cfg, { isDefault: true });
+    }
+    detectAndFlagConflicts() {
+        const seen = new Map();
+        const record = (agentName, channelsBlock) => {
+            for (const [type, raw] of Object.entries(channelsBlock || {})) {
+                if (type === 'defaultChannel')
+                    continue;
+                const instances = Array.isArray(raw) ? raw : [raw];
+                for (const inst of instances) {
+                    if (!inst || typeof inst !== 'object')
+                        continue;
+                    const fp = extractFingerprint(type, inst);
+                    if (!fp)
+                        continue;
+                    const instName = inst.name ?? type;
+                    const entry = seen.get(fp) || [];
+                    entry.push({ agent: agentName, instance: instName });
+                    seen.set(fp, entry);
+                }
+            }
+        };
+        for (const agent of this.agents.values()) {
+            if (agent.status === 'error')
+                continue;
+            record(agent.name, agent.config.channels);
+        }
+        if (this.defaultAgent) {
+            record(this.defaultAgent.name, this.defaultAgent.config.channels);
+        }
+        for (const [_fp, occurrences] of seen) {
+            if (occurrences.length <= 1)
+                continue;
+            const msg = `Channel conflict: fingerprint claimed by ${occurrences.map(o => `${o.agent}(${o.instance})`).join(', ')}`;
+            const involvedNames = [...new Set(occurrences.map(o => o.agent))];
+            for (const name of involvedNames) {
+                if (name === '[default]')
+                    continue;
+                const a = this.agents.get(name);
+                if (a && a.status !== 'error') {
+                    a.status = 'error';
+                    a.error = msg;
+                }
+            }
+            logger.error(`[EvolAgentRegistry] ${msg}`);
+        }
+    }
+    buildChannelIndex() {
+        for (const agent of this.agents.values()) {
+            if (agent.status === 'error' || agent.status === 'disabled')
+                continue;
+            for (const name of agent.channelInstanceNames()) {
+                this.channelIndex.set(name, agent.name);
+            }
+        }
+        if (this.defaultAgent) {
+            for (const name of this.defaultAgent.channelInstanceNames()) {
+                if (this.channelIndex.has(name))
+                    continue;
+                this.channelIndex.set(name, '[default]');
+            }
+        }
+    }
+    resolveByChannel(channelName) {
+        const agentName = this.channelIndex.get(channelName);
+        if (!agentName)
+            return null;
+        if (agentName === '[default]')
+            return this.defaultAgent;
+        return this.agents.get(agentName) || null;
+    }
+    /**
+     * Check ownership of a channel via the agent that owns it.
+     * - For named EvolAgent: reads agent.config (memory; reflects agent.json).
+     * - For DefaultAgent or unknown channel: invokes `globalFallback`, which
+     *   should consult the global config (evolclaw.json) via `config.ts:isOwner`.
+     */
+    isOwner(channelName, userId, globalFallback) {
+        const agent = this.resolveByChannel(channelName);
+        if (agent && !agent.isDefault)
+            return agent.isOwner(channelName, userId);
+        return globalFallback(channelName, userId);
+    }
+    /** Same routing logic as `isOwner`, applied to admin checks. */
+    isAdmin(channelName, userId, globalFallback) {
+        const agent = this.resolveByChannel(channelName);
+        if (agent && !agent.isDefault)
+            return agent.isAdmin(channelName, userId);
+        return globalFallback(channelName, userId);
+    }
+    /** Lookup current owner — agent first, then DefaultAgent (which mirrors evolclaw.json). */
+    getOwner(channelName) {
+        const agent = this.resolveByChannel(channelName);
+        if (!agent)
+            return undefined;
+        return agent.getOwner(channelName);
+    }
+    /**
+     * Persist owner. Routes to agent.json for named agents, or to evolclaw.json
+     * via the configured `globalWriter` for DefaultAgent. No-ops with a warning
+     * when the channel is unknown or no global writer is wired.
+     */
+    setChannelOwner(channelName, userId) {
+        const agent = this.resolveByChannel(channelName);
+        if (!agent) {
+            logger.warn(`[EvolAgentRegistry] setChannelOwner: channel "${channelName}" not found`);
+            return;
+        }
+        if (agent.isDefault) {
+            if (!this.globalWriter) {
+                logger.warn(`[EvolAgentRegistry] setChannelOwner: no globalWriter wired for default channel "${channelName}"`);
+                return;
+            }
+            this.globalWriter.setOwner(channelName, userId);
+        }
+        else {
+            agent.setOwner(channelName, userId);
+        }
+    }
+    /**
+     * Read showActivities mode. Falls back to `'all'` when the channel is
+     * unknown — matches the prior behavior of `config.ts:getChannelShowActivities`.
+     */
+    getShowActivities(channelName) {
+        const agent = this.resolveByChannel(channelName);
+        if (!agent)
+            return 'all';
+        return agent.getShowActivities(channelName);
+    }
+    /** Persist showActivities. Routes to agent.json or evolclaw.json. */
+    setShowActivities(channelName, mode) {
+        const agent = this.resolveByChannel(channelName);
+        if (!agent) {
+            logger.warn(`[EvolAgentRegistry] setShowActivities: channel "${channelName}" not found`);
+            return;
+        }
+        if (agent.isDefault) {
+            if (!this.globalWriter?.setShowActivities) {
+                logger.warn(`[EvolAgentRegistry] setShowActivities: no globalWriter wired for default channel "${channelName}"`);
+                return;
+            }
+            this.globalWriter.setShowActivities(channelName, mode);
+        }
+        else {
+            agent.setShowActivities(channelName, mode);
+        }
+    }
+    get(name) {
+        if (name === '[default]')
+            return this.defaultAgent;
+        return this.agents.get(name) || null;
+    }
+    list() {
+        const result = [];
+        for (const agent of this.agents.values()) {
+            result.push(this.toInfo(agent));
+        }
+        if (this.defaultAgent) {
+            result.push(this.toInfo(this.defaultAgent));
+        }
+        return result;
+    }
+    runnableAgents() {
+        return [...this.agents.values()].filter(a => a.status === 'stopped');
+    }
+    async reload(name, hooks) {
+        const oldAgent = this.agents.get(name);
+        if (!oldAgent)
+            throw new Error(`Agent "${name}" not found`);
+        if (!oldAgent.configPath)
+            throw new Error(`Cannot reload DefaultAgent`);
+        // 1. Re-read config from disk
+        const raw = JSON.parse(fs.readFileSync(oldAgent.configPath, 'utf-8'));
+        const validation = validateEvolAgentConfig(raw);
+        if (!validation.valid) {
+            throw new Error(`Invalid config after edit: ${validation.errors.join('; ')}`);
+        }
+        const newAgent = new EvolAgent(oldAgent.configPath, raw);
+        // Warn if projectPath changed — existing sessions retain old path (by design,
+        // to avoid breaking SDK conversation history at .claude/<encoded-path>/...)
+        if (oldAgent.projectPath !== newAgent.projectPath) {
+            logger.warn(`[EvolAgentRegistry] Agent "${name}" projectPath changed: ${oldAgent.projectPath} → ${newAgent.projectPath}. ` +
+                `Existing sessions retain the old path; only new sessions will use the new path. ` +
+                `To migrate, manually UPDATE sessions SET project_path=? WHERE id=? (warning: SDK conversation history may be lost).`);
+        }
+        // 2. Fingerprint conflict check (against all others except self)
+        const conflict = this.checkConflictForReload(newAgent, name);
+        if (conflict) {
+            throw new Error(`Channel conflict: ${conflict}`);
+        }
+        // 3. Compute channel diff
+        const oldChannels = new Set(oldAgent.channelInstanceNames());
+        const newChannels = new Set(newAgent.channelInstanceNames());
+        const toRemove = [...oldChannels].filter(c => !newChannels.has(c));
+        const toAdd = [...newChannels].filter(c => !oldChannels.has(c));
+        const kept = [...oldChannels].filter(c => newChannels.has(c));
+        // I6: detect kept-channel credential changes — treat as remove+add so
+        // the channel reconnects with new credentials (e.g. appSecret rotated).
+        const credentialsChanged = [];
+        const trulyKept = [];
+        for (const ch of kept) {
+            const oldCh = getChannelInstanceConfig(oldAgent, ch);
+            const newCh = getChannelInstanceConfig(newAgent, ch);
+            if (oldCh && newCh && channelConfigChanged(oldCh.config, newCh.config)) {
+                credentialsChanged.push(ch);
+            }
+            else {
+                trulyKept.push(ch);
+            }
+        }
+        toRemove.push(...credentialsChanged);
+        toAdd.push(...credentialsChanged);
+        // Track what was removed/added so we can roll back on failure
+        const removedSuccessfully = [];
+        const addedSuccessfully = [];
+        try {
+            // 4. Drain channels being removed
+            for (const ch of toRemove) {
+                await hooks.drainChannel(ch);
+            }
+            // 5. Disconnect removed channels
+            for (const ch of toRemove) {
+                await hooks.disconnectChannel(ch);
+                removedSuccessfully.push(ch);
+            }
+            // 6. Start new channels
+            for (const ch of toAdd) {
+                await hooks.startChannel(newAgent, ch);
+                addedSuccessfully.push(ch);
+            }
+            // 7. Transfer kept channel adapters from old to new (only truly unchanged ones)
+            for (const ch of trulyKept) {
+                const adapter = oldAgent.channels.get(ch);
+                if (adapter)
+                    newAgent.channels.set(ch, adapter);
+            }
+            // 8. Preserve runtime state
+            // I5: only set 'running' when oldAgent was running; preserve error/disabled
+            newAgent.activeSessions = oldAgent.activeSessions;
+            newAgent.lastActivity = oldAgent.lastActivity;
+            if (oldAgent.status === 'error' || oldAgent.status === 'disabled') {
+                newAgent.status = oldAgent.status;
+                newAgent.error = oldAgent.error;
+            }
+            else {
+                newAgent.status = 'running';
+            }
+            // 9. Swap in registry
+            this.agents.set(name, newAgent);
+            // 10. Rebuild channel index
+            this.channelIndex.clear();
+            this.buildChannelIndex();
+        }
+        catch (err) {
+            // C1: Rollback — restore original channels, keep oldAgent in registry
+            logger.error(`[Reload] Failed: ${err}. Attempting rollback for "${name}".`);
+            for (const ch of addedSuccessfully) {
+                try {
+                    await hooks.disconnectChannel(ch);
+                }
+                catch (_) { /* best effort */ }
+            }
+            for (const ch of removedSuccessfully) {
+                try {
+                    await hooks.startChannel(oldAgent, ch);
+                }
+                catch (_) { /* best effort */ }
+            }
+            // Don't swap registry — oldAgent stays in place
+            oldAgent.status = 'error';
+            oldAgent.error = `Reload failed (rollback attempted): ${err instanceof Error ? err.message : String(err)}`;
+            throw err;
+        }
+    }
+    checkConflictForReload(newAgent, excludeName) {
+        const newFingerprints = new Map(); // fp → instanceName
+        for (const [type, raw] of Object.entries(newAgent.config.channels || {})) {
+            if (type === 'defaultChannel')
+                continue;
+            const instances = Array.isArray(raw) ? raw : [raw];
+            for (const inst of instances) {
+                if (!inst || typeof inst !== 'object')
+                    continue;
+                const fp = extractFingerprint(type, inst);
+                if (!fp)
+                    continue;
+                const instName = inst.name ?? type;
+                newFingerprints.set(fp, instName);
+            }
+        }
+        // Check against all other agents (excluding self)
+        for (const [agentName, agent] of this.agents) {
+            if (agentName === excludeName)
+                continue;
+            if (agent.status === 'error' || agent.status === 'disabled')
+                continue;
+            for (const [type, raw] of Object.entries(agent.config.channels || {})) {
+                if (type === 'defaultChannel')
+                    continue;
+                const instances = Array.isArray(raw) ? raw : [raw];
+                for (const inst of instances) {
+                    if (!inst || typeof inst !== 'object')
+                        continue;
+                    const fp = extractFingerprint(type, inst);
+                    if (!fp)
+                        continue;
+                    if (newFingerprints.has(fp)) {
+                        return `${fp} conflicts with agent "${agentName}"`;
+                    }
+                }
+            }
+        }
+        // Check against DefaultAgent
+        if (this.defaultAgent) {
+            for (const [type, raw] of Object.entries(this.defaultAgent.config.channels || {})) {
+                if (type === 'defaultChannel')
+                    continue;
+                const instances = Array.isArray(raw) ? raw : [raw];
+                for (const inst of instances) {
+                    if (!inst || typeof inst !== 'object')
+                        continue;
+                    const fp = extractFingerprint(type, inst);
+                    if (!fp)
+                        continue;
+                    if (newFingerprints.has(fp)) {
+                        return `${fp} conflicts with DefaultAgent`;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    toInfo(agent) {
+        let baseagent = 'claude';
+        let model;
+        let effort;
+        try {
+            baseagent = agent.baseagent;
+            model = agent.model;
+            effort = agent.effort;
+        }
+        catch { /* invalid config */ }
+        return {
+            name: agent.name,
+            status: agent.status,
+            channels: agent.channelInstanceNames(),
+            projectPath: agent.config.projects?.defaultPath ?? '',
+            baseagent,
+            model,
+            effort,
+            lastActivity: agent.lastActivity,
+            activeSessions: agent.activeSessions,
+            error: agent.error,
+            isDefault: agent.isDefault,
+        };
+    }
+}
+/**
+ * Locate the raw config of a channel instance by name within an agent config.
+ * Returns `{ type, config }` or null if not found.
+ *
+ * Matches against the effective channel name (with agent prefix for EvolAgents),
+ * mirroring `EvolAgent.findChannelInstance`. Only used by `reload()` to detect
+ * kept-channel credential changes.
+ */
+function getChannelInstanceConfig(agent, channelName) {
+    for (const [type, raw] of Object.entries(agent.config?.channels || {})) {
+        if (type === 'defaultChannel')
+            continue;
+        const instances = Array.isArray(raw) ? raw : [raw];
+        for (const inst of instances) {
+            if (!inst || typeof inst !== 'object')
+                continue;
+            const effName = agent.effectiveChannelName(type, inst.name);
+            if (effName === channelName)
+                return { type, config: inst };
+        }
+    }
+    return null;
+}
+/**
+ * Compare two channel-instance configs by serialized JSON. Channel configs
+ * are plain JSON-shaped objects (no functions/Buffers), so this is a sound
+ * structural compare for "did anything in this channel block change".
+ */
+function channelConfigChanged(oldConfig, newConfig) {
+    return JSON.stringify(oldConfig) !== JSON.stringify(newConfig);
+}