evolclaw 2.8.3 → 3.0.0

package/dist/core/agent-registry.js

@@ -1,450 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { EvolAgent } from './evolagent.js';
-import { validateEvolAgentConfig } from './evolagent-schema.js';
-import { extractFingerprint } from '../utils/channel-fingerprint.js';
-import { logger } from '../utils/logger.js';
-export class AgentRegistry {
-    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(`[AgentRegistry] ${file}: ${validation.errors.join('; ')}`);
-                    continue;
-                }
-                const agent = new EvolAgent(fullPath, raw);
-                this.agents.set(agent.name, agent);
-            }
-            catch (e) {
-                logger.warn(`[AgentRegistry] 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(`[AgentRegistry] ${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(`[AgentRegistry] setChannelOwner: channel "${channelName}" not found`);
-            return;
-        }
-        if (agent.isDefault) {
-            if (!this.globalWriter) {
-                logger.warn(`[AgentRegistry] 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(`[AgentRegistry] setShowActivities: channel "${channelName}" not found`);
-            return;
-        }
-        if (agent.isDefault) {
-            if (!this.globalWriter?.setShowActivities) {
-                logger.warn(`[AgentRegistry] 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(`[AgentRegistry] 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);
-}

package/dist/core/evolagent-schema.js

@@ -1,72 +0,0 @@
-import path from 'path';
-const VALID_BASEAGENTS = new Set(['claude', 'codex', 'gemini', 'hermes']);
-const VALID_CHANNEL_TYPES = new Set(['feishu', 'aun', 'wechat', 'wecom', 'dingtalk', 'qqbot']);
-const VALID_CHATMODES = new Set(['interactive', 'proactive']);
-export function validateEvolAgentConfig(raw) {
-    const errors = [];
-    if (!raw || typeof raw !== 'object') {
-        return { valid: false, errors: ['config must be an object'] };
-    }
-    if (typeof raw.name !== 'string' || raw.name.trim() === '') {
-        errors.push('name is required and must be a non-empty string');
-    }
-    if (raw.enabled !== undefined && typeof raw.enabled !== 'boolean') {
-        errors.push('enabled must be a boolean if present');
-    }
-    if (!raw.agents || typeof raw.agents !== 'object') {
-        errors.push('agents must be an object with exactly one baseagent block');
-    }
-    else {
-        const keys = Object.keys(raw.agents).filter(k => VALID_BASEAGENTS.has(k));
-        const unknownKeys = Object.keys(raw.agents).filter(k => !VALID_BASEAGENTS.has(k));
-        if (unknownKeys.length > 0) {
-            errors.push(`agents contains unknown baseagent keys: ${unknownKeys.join(', ')}`);
-        }
-        if (keys.length === 0) {
-            errors.push('agents must contain exactly one of: claude | codex | gemini | hermes');
-        }
-        else if (keys.length > 1) {
-            errors.push(`agents must contain exactly one baseagent (single baseagent only), got: ${keys.join(', ')}`);
-        }
-    }
-    if (!raw.channels || typeof raw.channels !== 'object') {
-        errors.push('channels is required');
-    }
-    else {
-        const channelKeys = Object.keys(raw.channels);
-        if (channelKeys.length === 0) {
-            errors.push('channels must contain at least one channel type');
-        }
-        for (const key of channelKeys) {
-            if (!VALID_CHANNEL_TYPES.has(key)) {
-                errors.push(`unknown channel type: ${key}`);
-            }
-        }
-    }
-    if (!raw.projects || typeof raw.projects !== 'object') {
-        errors.push('projects is required');
-    }
-    else {
-        const p = raw.projects.defaultPath;
-        if (typeof p !== 'string' || p === '') {
-            errors.push('projects.defaultPath is required');
-        }
-        else if (!path.isAbsolute(p)) {
-            errors.push(`projects.defaultPath must be absolute, got: ${p}`);
-        }
-    }
-    if (raw.chatmode !== undefined) {
-        if (typeof raw.chatmode !== 'object' || raw.chatmode === null) {
-            errors.push('chatmode must be an object if present');
-        }
-        else {
-            for (const key of ['private', 'group']) {
-                const val = raw.chatmode[key];
-                if (val !== undefined && !VALID_CHATMODES.has(val)) {
-                    errors.push(`chatmode.${key} must be 'interactive' or 'proactive'`);
-                }
-            }
-        }
-    }
-    return { valid: errors.length === 0, errors };
-}