evolclaw 2.8.0 → 2.8.2

package/dist/config.js

@@ -155,7 +155,7 @@ export function loadConfig(configPath = resolvePaths().config) {
                     logger.warn(`Config file missing, creating from sample: ${samplePath}`);
                     const sample = JSON.parse(fs.readFileSync(samplePath, 'utf-8'));
                     // Set a usable defaultPath
-                    const defaultProjectDir = path.join(os.homedir(), 'evolclaw-project');
+                    const defaultProjectDir = path.join(os.homedir(), 'projects', 'default');
                     sample.projects.defaultPath = defaultProjectDir;
                     if (!fs.existsSync(defaultProjectDir)) {
                         fs.mkdirSync(defaultProjectDir, { recursive: true });
@@ -228,6 +228,45 @@ export function normalizeChannelInstances(cfg, defaultName) {
     }
     return [{ ...cfg, name: cfg.name ?? defaultName }];
 }
+/**
+ * Parse a defaultChannel reference. Supports:
+ *   "feishu"           → { type: "feishu" }
+ *   "feishu/feilun"    → { type: "feishu", instance: "feilun" }
+ */
+export function parseDefaultChannelRef(ref) {
+    const slash = ref.indexOf('/');
+    if (slash < 0)
+        return { type: ref };
+    return { type: ref.slice(0, slash), instance: ref.slice(slash + 1) };
+}
+/**
+ * Validate a defaultChannel reference against a channels config block.
+ * Returns an error message string if invalid, or null if OK.
+ *   - type must be in channelTypes
+ *   - type must have at least one instance configured
+ *   - if instance specified, must match an existing instance.name
+ *   - if instance omitted, type must have exactly 1 instance (else ambiguous)
+ */
+export function validateDefaultChannelRef(ref, channelsBlock) {
+    const { type, instance } = parseDefaultChannelRef(ref);
+    if (!channelTypes.includes(type)) {
+        return `channels.defaultChannel='${ref}' references unknown channel type '${type}'`;
+    }
+    const instances = normalizeChannelInstances(channelsBlock?.[type], type);
+    if (instances.length === 0) {
+        return `channels.defaultChannel='${ref}' but channels.${type} has no instances`;
+    }
+    if (instance) {
+        if (!instances.some(i => i.name === instance)) {
+            return `channels.defaultChannel='${ref}' but channels.${type} has no instance named '${instance}'`;
+        }
+    }
+    else if (instances.length > 1) {
+        const names = instances.map(i => i.name).join(', ');
+        return `channels.defaultChannel='${ref}' is ambiguous: channels.${type} has ${instances.length} instances (${names}); use 'type/instanceName' form`;
+    }
+    return null;
+}
 /**
  * Validate that all channel instance names are unique across all channel types.
  * Throws if duplicate names are found.
@@ -263,10 +302,14 @@ export function getOwner(config, channelOrType) {
     }
     return undefined;
 }
-export function setOwner(config, instanceName, userId, configPath = resolvePaths().config) {
-    if (!config.channels)
-        config.channels = {};
-    const channels = config.channels;
+/**
+ * Find a channel instance by name in a config-like object and set its owner.
+ * Returns true if the instance was found and updated.
+ */
+export function writeOwnerToChannelInstance(root, instanceName, userId) {
+    const channels = root?.channels;
+    if (!channels || typeof channels !== 'object')
+        return false;
     for (const type of channelTypes) {
         const raw = channels[type];
         if (raw === undefined)
@@ -275,26 +318,37 @@ export function setOwner(config, instanceName, userId, configPath = resolvePaths
             const inst = raw.find((item) => item.name === instanceName);
             if (inst) {
                 inst.owner = userId;
-                saveConfig(config, configPath);
-                return;
+                return true;
             }
         }
         else {
-            // Single-object form: match if name matches (or defaults to type name)
             const effectiveName = raw.name ?? type;
             if (effectiveName === instanceName) {
                 raw.owner = userId;
-                saveConfig(config, configPath);
-                return;
+                return true;
             }
         }
     }
-    // Fallback: if instanceName matches a channel type with no config, create it
+    return false;
+}
+export function setOwner(config, instanceName, userId, configPath = resolvePaths().config) {
+    if (!config.channels)
+        config.channels = {};
+    // 1. Try writing to evolclaw.json (default-agent channels)
+    if (writeOwnerToChannelInstance(config, instanceName, userId)) {
+        saveConfig(config, configPath);
+        return;
+    }
+    // 2. Last resort: if instanceName matches a channel type with no config, create it
     if (channelTypes.includes(instanceName)) {
-        channels[instanceName] = { owner: userId };
+        config.channels[instanceName] = { owner: userId };
         saveConfig(config, configPath);
         return;
     }
+    // 3. I4: No match — warn (don't silently lose owner). Callers managing
+    // agent-owned channels should route through EvolAgent.setOwner before
+    // falling back to this global setter.
+    logger.warn(`[setOwner] Channel instance "${instanceName}" not found in evolclaw.json. Owner ${userId} not persisted.`);
 }
 export function getChannelShowActivities(config, instanceName) {
     for (const type of channelTypes) {
@@ -353,10 +407,10 @@ export function getDefaultSessionMode(config, chatType) {
     return cm.private;
 }
 export function isOwner(config, channelOrType, userId) {
-    // 按实例名精确匹配
+    // 按实例名精确匹配（evolclaw.json）
     if (getOwner(config, channelOrType) === userId)
         return true;
-    // 按 channelType 匹配：检查该类型下所有实例
+    // 按 channelType 匹配：检查该类型下所有实例（evolclaw.json）
     for (const type of channelTypes) {
         if (type !== channelOrType)
             continue;
@@ -483,17 +537,35 @@ export function validateConfigIntegrity(config) {
             reasons.push(`agents.defaultAgent='${defaultAgent}' but agents.${defaultAgent} does not exist`);
         }
     }
-    // channels — 单通道时自动推断，无需显式 defaultChannel
-    const defaultChannel = config.channels?.defaultChannel;
-    if (!defaultChannel) {
-        const channelKeys = channelTypes.filter(t => config.channels?.[t]);
-        if (channelKeys.length === 0) {
-            reasons.push('Missing channels.defaultChannel (no channels configured)');
+    // channels — 单实例自动推断，多实例必填 defaultChannel
+    // 支持两种形式：
+    //   "feishu"           → type 级，要求该 type 下只有 1 个实例
+    //   "feishu/feilun"    → type/instanceName，精确指向实例
+    const totalInstances = channelTypes.reduce((acc, t) => {
+        return acc + normalizeChannelInstances(config.channels?.[t], t).length;
+    }, 0);
+    if (totalInstances === 0) {
+        reasons.push('Missing channels: no channel instances configured');
+    }
+    else if (totalInstances === 1) {
+        // 单实例：defaultChannel 可省略（自动推断）
+        const dc = config.channels?.defaultChannel;
+        if (dc) {
+            const err = validateDefaultChannelRef(dc, config.channels);
+            if (err)
+                reasons.push(err);
         }
     }
     else {
-        if (!config.channels?.[defaultChannel]) {
-            reasons.push(`channels.defaultChannel='${defaultChannel}' but channels.${defaultChannel} does not exist`);
+        // 多实例：defaultChannel 必填
+        const dc = config.channels?.defaultChannel;
+        if (!dc) {
+            reasons.push('Missing channels.defaultChannel (multiple channel instances configured; must specify "type" or "type/instanceName")');
+        }
+        else {
+            const err = validateDefaultChannelRef(dc, config.channels);
+            if (err)
+                reasons.push(err);
         }
     }
     // projects

package/dist/core/agent-registry.js

@@ -0,0 +1,450 @@
+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);
+}