evolcore 0.0.1 → 0.0.2

package/dist/core/evolagent.js

@@ -0,0 +1,331 @@
+import path from 'path';
+import { formatChannelKey } from './channel-loader.js';
+import { agentPersonalDir } from '../paths.js';
+import { fileCache } from './daemon-file-cache.js';
+import { ConfigTarget, read as cfgRead, write as cfgWrite, ensureFile as cfgEnsure, resolveEffective } from '../config/config-manager.js';
+import { withLifecycleForWrite } from '../config/lifecycle.js';
+/**
+ * EvolAgent —— 一个 self-agent 的运行时表示。
+ *
+ * 输入：EffectiveAgentConfig（defaults + per-agent 合并后的 effective 形态）。
+ * 持有该 agent 的 channels Map、活跃状态、生命周期。
+ *
+ * 写入永远落到 agents/<aid>/config.json（通过 ConfigManager 走原子写入），
+ * 不再有 "DefaultAgent" 概念，不再有 globalWriter / configPath null 的路径。
+ */
+export class EvolAgent {
+    aid;
+    /** 兼容字段：name = aid。channel routing / log / IPC 都用 aid 作 agent 标识。 */
+    name;
+    /** in-memory effective config（含 defaults 合并结果）；写盘时只回写 per-agent 部分。 */
+    merged;
+    /** per-agent 原始配置（写盘真相源） */
+    rawAgent;
+    channels = new Map();
+    activeSessions = 0;
+    lastActivity;
+    status;
+    error;
+    constructor(rawAgent, merged) {
+        if (rawAgent.aid !== merged.aid) {
+            throw new Error(`EvolAgent: rawAgent.aid (${rawAgent.aid}) != merged.aid (${merged.aid})`);
+        }
+        this.rawAgent = rawAgent;
+        this.merged = merged;
+        this.aid = rawAgent.aid;
+        this.name = rawAgent.aid;
+        this.status = rawAgent.enabled === false ? 'disabled' : 'stopped';
+    }
+    /** 当前 effective config（合并后的） */
+    get config() {
+        return this.merged;
+    }
+    get baseagent() {
+        if (!this.merged.active_baseagent) {
+            throw new Error(`[EvolAgent] active_baseagent is empty for agent ${this.name}`);
+        }
+        return this.merged.active_baseagent;
+    }
+    get model() {
+        const ba = this.baseagent;
+        // 动态读取配置（基于 fileCache + mtime），使配置变更立即体现在显示中
+        try {
+            const effective = resolveEffective({ self: this.aid }, { cache: true });
+            const block = effective.baseagents?.[ba];
+            return block?.model;
+        }
+        catch {
+            // 降级：读取快照
+            const block = this.merged.baseagents?.[ba];
+            return block?.model;
+        }
+    }
+    get effort() {
+        const ba = this.baseagent;
+        // 动态读取配置（基于 fileCache + mtime），使配置变更立即体现在显示中
+        try {
+            const effective = resolveEffective({ self: this.aid }, { cache: true });
+            const block = effective.baseagents?.[ba];
+            if (ba === 'codex')
+                return block?.effort ?? block?.reasoning;
+            return block?.effort;
+        }
+        catch {
+            // 降级：读取快照
+            const block = this.merged.baseagents?.[ba];
+            if (ba === 'codex')
+                return block?.effort ?? block?.reasoning;
+            return block?.effort;
+        }
+    }
+    get projectPath() {
+        return this.merged.projects?.defaultPath || process.cwd();
+    }
+    // ── Channels ──────────────────────────────────────────────────────────
+    /**
+     * effective channel key：`<type>#<selfAID>#<name>`。
+     * AUN channel 的 selfAID 是 agent.aid，name 固定为 'main'。
+     */
+    effectiveChannelName(type, rawName) {
+        return formatChannelKey({ type, selfAID: this.aid, name: rawName });
+    }
+    channelInstanceNames() {
+        // AUN channel 隐式存在（从 agent.aid 派生），不需要在 channels[] 里声明
+        const aunKey = this.effectiveChannelName('aun', 'main');
+        const others = this.merged.channels
+            .filter(c => c.type !== 'aun')
+            .map(c => this.effectiveChannelName(c.type, c.name));
+        return [aunKey, ...others];
+    }
+    /** 列出所有 channel 实例（含 effective key） */
+    listChannels() {
+        return this.merged.channels.map(inst => ({
+            key: this.effectiveChannelName(inst.type, inst.name),
+            instance: inst,
+        }));
+    }
+    /**
+     * 按 effective channel key 找到 instance（只读视图）。
+     * 找不到返回 null。
+     */
+    findChannelInstance(channelKey) {
+        return this.merged.channels.find(c => this.effectiveChannelName(c.type, c.name) === channelKey) ?? null;
+    }
+    // ── ShowActivities ────────────────────────────────────────────────────
+    getShowActivities(_channelKey) {
+        return this.merged.show_activities ?? 'all';
+    }
+    setShowActivities(_channelKey, mode) {
+        this.merged.show_activities = mode;
+        this.updateAgentConfig(b => { b.show_activities = mode; });
+    }
+    // ── Role-based Access Control ─────────────────────────────────────────
+    /**
+     * Check if a user has owner role for this agent (private scope).
+     */
+    isOwner(_channelKey, userId) {
+        if (this.merged.owners?.includes(userId))
+            return true;
+        return false;
+    }
+    /**
+     * Check if a user has admin role for this agent (private scope).
+     * Uses static owners/admins from agent config.
+     */
+    isAdmin(_channelKey, userId) {
+        if (this.isOwner(_channelKey, userId))
+            return true;
+        return this.merged.admins?.includes(userId) ?? false;
+    }
+    /**
+     * Get the first owner of this agent (private scope).
+     * Returns the peerId of the first owner assignment.
+     */
+    getOwner(_channelKey) {
+        return this.merged.owners?.[0];
+    }
+    /**
+     * Set a user as owner for this agent (private scope).
+     */
+    setOwner(_channelKey, userId) {
+        const owners = new Set(this.merged.owners ?? []);
+        owners.add(userId);
+        const nextOwners = [...owners];
+        this.merged.owners = nextOwners;
+        this.updateAgentConfig(b => { b.owners = nextOwners; });
+    }
+    // ── Baseagent 字段写入 ────────────────────────────
+    /** 切换当前活跃 baseagent（写入 config.json）。 */
+    setActiveBaseagent(value) {
+        this.merged.active_baseagent = value;
+        this.updateAgentConfig(b => {
+            if (value === undefined)
+                delete b.active_baseagent;
+            else
+                b.active_baseagent = value;
+        });
+    }
+    setBaseagentModel(value, baseagentName) {
+        const ba = baseagentName || this.baseagent;
+        if (!this.merged.baseagents)
+            this.merged.baseagents = {};
+        const mBlock = ((this.merged.baseagents)[ba] ??= {});
+        if (value === undefined)
+            delete mBlock.model;
+        else
+            mBlock.model = value;
+        this.updateAgentConfig(b => {
+            b.baseagents = b.baseagents || {};
+            const blk = (b.baseagents[ba] ??= {});
+            if (value === undefined)
+                delete blk.model;
+            else
+                blk.model = value;
+        });
+    }
+    setBaseagentEffort(value, baseagentName) {
+        const ba = baseagentName || this.baseagent;
+        if (!this.merged.baseagents)
+            this.merged.baseagents = {};
+        const mBlock = ((this.merged.baseagents)[ba] ??= {});
+        if (value === undefined) {
+            delete mBlock.effort;
+            delete mBlock.reasoning;
+        }
+        else {
+            mBlock.effort = value;
+            delete mBlock.reasoning;
+        }
+        this.updateAgentConfig(b => {
+            b.baseagents = b.baseagents || {};
+            const blk = (b.baseagents[ba] ??= {});
+            if (value === undefined) {
+                delete blk.effort;
+                delete blk.reasoning;
+            }
+            else {
+                blk.effort = value;
+                delete blk.reasoning;
+            }
+        });
+    }
+    /** 设置私聊 chatmode（群聊/非 human 强制 proactive，无可写入项）。 */
+    setChatmodePrivate(value) {
+        if (!this.merged.chatmode)
+            this.merged.chatmode = {};
+        this.merged.chatmode.private = value;
+        this.updateAgentConfig(b => {
+            b.chatmode = b.chatmode || {};
+            if (value === undefined)
+                delete b.chatmode.private;
+            else
+                b.chatmode.private = value;
+        });
+    }
+    /** 设置群聊 mentionMode（mention-only | disabled）。 */
+    setMentionMode(value) {
+        this.merged.mentionMode = value;
+        this.updateAgentConfig(b => {
+            if (value === undefined)
+                delete b.mentionMode;
+            else
+                b.mentionMode = value;
+        });
+    }
+    /** 读取观察者模式开关（默认 false）。 */
+    getObservable() {
+        return this.merged.observable === true;
+    }
+    /** 设置观察者模式开关：开启后入站/出站消息各转发一份给 owners[]。 */
+    setObservable(value) {
+        if (value)
+            this.rawAgent.observable = true;
+        else
+            delete this.rawAgent.observable;
+        this.merged.observable = value;
+        this.persist();
+    }
+    setLifecycle(value) {
+        this.rawAgent = withLifecycleForWrite(this.rawAgent, value);
+        this.rawAgent.$schema_version = Math.max(this.rawAgent.$schema_version || 0, this.merged.$schema_version || 0);
+        this.merged.lifecycle = value;
+        delete this.merged.initialized;
+        this.persist();
+    }
+    // ── Personal layer ────────────────────────────────────────────────────
+    /** 本 agent 身份层文件在 fileCache 的组名（带 aid，避免 reload 单个 agent 误失效他人）。 */
+    agentFilesGroup() {
+        return `agent-files:${this.aid}`;
+    }
+    /**
+     * 读取 personal/persona.md 内容。走 fileCache（mtime 门控）：persona 没有任何
+     * 写入命令、由 agent 自己带外改写，与 working memory 同样改了即应生效，故每次读
+     * stat 比对、变了自动重读。文件不存在返回 null。
+     */
+    getPersona() {
+        const personaPath = path.join(agentPersonalDir(this.aid), 'persona.md');
+        return fileCache.get(personaPath, (raw) => (raw === null ? null : (raw.trim() || null)), { policy: 'mtime', group: this.agentFilesGroup() });
+    }
+    /**
+     * 读取 personal/memory/working.md 内容。走 fileCache（mtime 门控）：
+     * agent 在对话中改写 working memory、不触发 reload，故每次读 stat 比对、
+     * 变了自动重读，既即时反映又避免无谓重读。
+     */
+    getWorkingMemory() {
+        const workingPath = path.join(agentPersonalDir(this.aid), 'memory', 'working.md');
+        return fileCache.get(workingPath, (raw) => (raw === null ? null : (raw.trim() || null)), { policy: 'mtime', group: this.agentFilesGroup() });
+    }
+    /** 清除本 agent 身份层缓存（reload 后重新读取）。只失效自己的文件组，不波及他人。 */
+    invalidatePersonaCache() {
+        fileCache.invalidateGroup(this.agentFilesGroup());
+    }
+    // ── Context（喂给 message-processor / command-handler） ──────────────
+    getContext(_channelKey, chatType, globalChatmode) {
+        const chatMode = this.resolveChatMode(chatType, globalChatmode);
+        return {
+            name: this.name,
+            isOwned: true,
+            baseagent: this.baseagent,
+            model: this.model,
+            effort: this.effort,
+            chatMode,
+            projectPath: this.projectPath,
+        };
+    }
+    resolveChatMode(chatType, globalChatmode) {
+        const key = chatType === 'group' ? 'group' : 'private';
+        return (this.merged.chatmode?.[key]
+            ?? globalChatmode?.[key]
+            ?? (key === 'group' ? 'proactive' : 'interactive'));
+    }
+    // ── Reload 支持：替换 in-memory config 并复用 channels Map ───────────
+    /** 用新的 raw + merged 替换 in-memory 状态。channels 由调用方决定如何 reconcile。 */
+    swapConfig(rawAgent, merged) {
+        if (rawAgent.aid !== this.aid) {
+            throw new Error(`EvolAgent.swapConfig: aid mismatch (${rawAgent.aid} vs ${this.aid})`);
+        }
+        this.rawAgent = rawAgent;
+        this.merged = merged;
+    }
+    // ── 内部辅助 ─────────────────────────────────────────────────────────
+    /**
+     * 找 rawAgent.channels 里的可变实例，用于写入。
+     *
+     * merged.channels 是 deep clone 时 raw 跟 merged 的 channels 引用同一份（resolveEffective
+     * 直接透传 agent.channels），所以 raw 里的实例就等于 merged 里的实例。
+     */
+    findRawChannelInstance(channelKey) {
+        return this.rawAgent.channels.find(c => this.effectiveChannelName(c.type, c.name) === channelKey) ?? null;
+    }
+    persist() {
+        cfgWrite(ConfigTarget.Agent, this.rawAgent, { self: this.aid });
+    }
+    /** 读改写 agent 级 config.json（v3 设计，走 ConfigManager 唯一写入口）。 */
+    updateAgentConfig(fn) {
+        const sel = { self: this.aid };
+        const cur = cfgRead(ConfigTarget.Agent, sel) || {};
+        fn(cur);
+        cfgEnsure(ConfigTarget.Agent, sel);
+        cfgWrite(ConfigTarget.Agent, cur, sel);
+    }
+}

package/dist/core/handoff/dispatcher.js

@@ -0,0 +1,229 @@
+import { logger } from '../../utils/logger.js';
+export class HandoffDispatcher {
+    store;
+    mutexes;
+    sender;
+    running = new Set();
+    pausedAgents = new Set();
+    maxAttempts;
+    retryDelaysMs;
+    queueTtlMs;
+    now;
+    expirationTimers = new Map();
+    constructor(store, mutexes, sender, options = {}) {
+        this.store = store;
+        this.mutexes = mutexes;
+        this.sender = sender;
+        this.maxAttempts = options.maxAttempts ?? 3;
+        this.retryDelaysMs = options.retryDelaysMs ?? [250, 1000];
+        this.queueTtlMs = typeof options.queueTtlMs === 'number'
+            && Number.isFinite(options.queueTtlMs)
+            && options.queueTtlMs > 0
+            ? options.queueTtlMs
+            : undefined;
+        this.now = options.now ?? Date.now;
+    }
+    notify(selfAid, targetSessionId) {
+        if (this.pausedAgents.has(selfAid))
+            return;
+        const key = this.key(selfAid, targetSessionId);
+        if (this.running.has(key))
+            return;
+        this.running.add(key);
+        void this.run(selfAid, targetSessionId).finally(() => this.running.delete(key));
+    }
+    pauseAgent(selfAid) {
+        this.pausedAgents.add(selfAid);
+        const prefix = `${selfAid}\u0000`;
+        for (const [key, timer] of this.expirationTimers) {
+            if (!key.startsWith(prefix))
+                continue;
+            clearTimeout(timer);
+            this.expirationTimers.delete(key);
+        }
+    }
+    async drainAgent(selfAid, timeoutMs = 30000) {
+        this.pauseAgent(selfAid);
+        const startedAt = Date.now();
+        while (this.isAgentRunning(selfAid)) {
+            if (Date.now() - startedAt >= timeoutMs) {
+                throw new Error(`Handoff drain timeout (${timeoutMs}ms) for agent: ${selfAid}`);
+            }
+            await new Promise(resolve => setTimeout(resolve, 10));
+        }
+    }
+    resumeAgent(selfAid) {
+        this.pausedAgents.delete(selfAid);
+        const targets = new Set(this.store.list(selfAid)
+            .filter(instance => instance.state === 'queued')
+            .map(instance => instance.target_session_id));
+        for (const targetSessionId of targets)
+            this.notify(selfAid, targetSessionId);
+    }
+    isAgentPaused(selfAid) {
+        return this.pausedAgents.has(selfAid);
+    }
+    async drain(selfAid, targetSessionId) {
+        const key = this.key(selfAid, targetSessionId);
+        if (this.running.has(key)) {
+            while (this.running.has(key))
+                await new Promise(resolve => setTimeout(resolve, 5));
+        }
+        this.running.add(key);
+        try {
+            await this.run(selfAid, targetSessionId);
+        }
+        finally {
+            this.running.delete(key);
+        }
+    }
+    expireQueued(selfAid, targetSessionId) {
+        if (this.queueTtlMs === undefined)
+            return [];
+        const now = this.now();
+        const expired = [];
+        const queued = targetSessionId
+            ? this.store.listByTarget(selfAid, targetSessionId, 'queued')
+            : this.store.list(selfAid).filter(instance => instance.state === 'queued');
+        for (const instance of queued) {
+            if (now - instance.created_at < this.queueTtlMs)
+                continue;
+            expired.push(this.store.recordSendExpired(selfAid, instance.handoff_id, this.queueTtlMs, now));
+            logger.warn(`[Handoff] queued delivery expired: ${instance.handoff_id}`);
+        }
+        return expired;
+    }
+    async expireTargetQueued(selfAid, targetSessionId) {
+        return this.mutexes.forKey(this.key(selfAid, targetSessionId)).runExclusive(async () => this.expireQueued(selfAid, targetSessionId));
+    }
+    async run(selfAid, targetSessionId) {
+        while (true) {
+            if (this.pausedAgents.has(selfAid))
+                return;
+            this.expireQueued(selfAid, targetSessionId);
+            const next = this.store.listByTarget(selfAid, targetSessionId, 'queued')[0];
+            if (!next)
+                return;
+            if (next.attention_required) {
+                this.scheduleExpiration(selfAid, next);
+                return;
+            }
+            let sent = false;
+            let blocked = false;
+            for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
+                if (this.pausedAgents.has(selfAid))
+                    return;
+                sent = await this.mutexes.forKey(this.key(selfAid, targetSessionId)).runExclusive(async () => {
+                    if (this.pausedAgents.has(selfAid))
+                        return false;
+                    const current = this.store.get(selfAid, next.handoff_id);
+                    if (!current || current.state !== 'queued' || current.attention_required)
+                        return current?.state === 'target_sent';
+                    this.store.recordSendStarted(selfAid, current.handoff_id);
+                    try {
+                        const send = await this.sendWithinQueueDeadline(current);
+                        if (send.timedOut) {
+                            blocked = true;
+                            this.store.markAttention(selfAid, current.handoff_id, 'TARGET_SEND_OUTCOME_UNKNOWN');
+                            return false;
+                        }
+                        const result = send.result;
+                        if (!result.ok) {
+                            this.store.recordSendFailed(selfAid, current.handoff_id, result.error || 'target send failed');
+                            return false;
+                        }
+                        if (!result.message_id) {
+                            blocked = true;
+                            this.store.markAttention(selfAid, current.handoff_id, 'TARGET_SEND_OUTCOME_UNKNOWN');
+                            return false;
+                        }
+                        try {
+                            this.store.recordSendSucceeded(selfAid, current.handoff_id, result.message_id);
+                        }
+                        catch (error) {
+                            blocked = true;
+                            try {
+                                this.store.markAttention(selfAid, current.handoff_id, 'STORE_CONFLICT');
+                            }
+                            catch { }
+                            logger.error(`[Handoff] failed to persist successful target send: ${current.handoff_id}`, error);
+                            return false;
+                        }
+                        return true;
+                    }
+                    catch (error) {
+                        this.store.recordSendFailed(selfAid, current.handoff_id, error instanceof Error ? error.message : String(error));
+                        return false;
+                    }
+                });
+                if (this.pausedAgents.has(selfAid))
+                    return;
+                if (sent)
+                    break;
+                if (blocked) {
+                    const current = this.store.get(selfAid, next.handoff_id);
+                    if (current?.state === 'queued' && current.attention_required) {
+                        this.scheduleExpiration(selfAid, current);
+                    }
+                    return;
+                }
+                if (attempt < this.maxAttempts) {
+                    await new Promise(resolve => setTimeout(resolve, this.retryDelaysMs[Math.min(attempt - 1, this.retryDelaysMs.length - 1)] ?? 0));
+                }
+            }
+            if (!sent) {
+                this.store.recordSendExhausted(selfAid, next.handoff_id);
+                logger.error(`[Handoff] target send retries exhausted: ${next.handoff_id}`);
+                continue;
+            }
+            await Promise.resolve();
+        }
+    }
+    key(selfAid, targetSessionId) {
+        return `${selfAid}\u0000${targetSessionId}`;
+    }
+    scheduleExpiration(selfAid, instance) {
+        if (this.queueTtlMs === undefined || this.pausedAgents.has(selfAid))
+            return;
+        const key = this.key(selfAid, instance.target_session_id);
+        if (this.expirationTimers.has(key))
+            return;
+        const remainingMs = Math.max(1, instance.created_at + this.queueTtlMs - this.now());
+        const timer = setTimeout(() => {
+            this.expirationTimers.delete(key);
+            this.notify(selfAid, instance.target_session_id);
+        }, Math.min(remainingMs, 2_147_483_647));
+        timer.unref?.();
+        this.expirationTimers.set(key, timer);
+    }
+    async sendWithinQueueDeadline(instance) {
+        if (this.queueTtlMs === undefined) {
+            return { timedOut: false, result: await this.sender(instance) };
+        }
+        const remainingMs = instance.created_at + this.queueTtlMs - this.now();
+        if (remainingMs <= 0)
+            return { timedOut: true };
+        let timer;
+        const sendOutcome = this.sender(instance).then(result => ({ kind: 'result', result }), error => ({ kind: 'error', error }));
+        const timeoutOutcome = new Promise(resolve => {
+            timer = setTimeout(() => resolve({ kind: 'timeout' }), Math.min(remainingMs, 2_147_483_647));
+            timer.unref?.();
+        });
+        const outcome = await Promise.race([sendOutcome, timeoutOutcome]);
+        if (timer)
+            clearTimeout(timer);
+        if (outcome.kind === 'timeout')
+            return { timedOut: true };
+        if (outcome.kind === 'error')
+            throw outcome.error;
+        return { timedOut: false, result: outcome.result };
+    }
+    isAgentRunning(selfAid) {
+        const prefix = `${selfAid}\u0000`;
+        for (const key of this.running) {
+            if (key.startsWith(prefix))
+                return true;
+        }
+        return false;
+    }
+}

package/dist/core/handoff/mutex.js

@@ -0,0 +1,46 @@
+export class FairMutex {
+    locked = false;
+    waiters = [];
+    acquire() {
+        return new Promise(resolve => {
+            const grant = () => {
+                this.locked = true;
+                let released = false;
+                resolve(() => {
+                    if (released)
+                        return;
+                    released = true;
+                    const next = this.waiters.shift();
+                    if (next)
+                        queueMicrotask(next);
+                    else
+                        this.locked = false;
+                });
+            };
+            if (!this.locked && this.waiters.length === 0)
+                grant();
+            else
+                this.waiters.push(grant);
+        });
+    }
+    async runExclusive(fn) {
+        const release = await this.acquire();
+        try {
+            return await fn();
+        }
+        finally {
+            release();
+        }
+    }
+}
+export class KeyedFairMutex {
+    locks = new Map();
+    forKey(key) {
+        let lock = this.locks.get(key);
+        if (!lock) {
+            lock = new FairMutex();
+            this.locks.set(key, lock);
+        }
+        return lock;
+    }
+}