evolclaw 2.8.1 → 2.8.3

package/dist/core/agent-registry.js

@@ -9,8 +9,14 @@ export class AgentRegistry {
     agents = new Map();
     defaultAgent = null;
     channelIndex = new Map();
-    constructor(agentsDir) {
+    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();
@@ -125,6 +131,82 @@ export class AgentRegistry {
             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;
@@ -143,10 +225,181 @@ export class AgentRegistry {
     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 {
@@ -155,6 +408,8 @@ export class AgentRegistry {
             channels: agent.channelInstanceNames(),
             projectPath: agent.config.projects?.defaultPath ?? '',
             baseagent,
+            model,
+            effort,
             lastActivity: agent.lastActivity,
             activeSessions: agent.activeSessions,
             error: agent.error,
@@ -162,3 +417,34 @@ export class AgentRegistry {
         };
     }
 }
+/**
+ * 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);
+}